Add P2P wiring, trace logger, integration tests, gate experiments, and constitutional geometry

- trace_logger.py: Structured agent trace collection for training data
- constitutional_geometry.py: Geometric alignment evaluation in embedding space
- test_integration.py: End-to-end pipeline integration tests
- gate1_probe.py: Gate 1 probe experiment (>85% tool call prediction)
- gate2_degradation.py: Gate 2 degradation curves (<50% quality drop at T=5)
- P2P wiring: blob_store, distributed_jepa, sharding, p2p, governance extensions
- Config updates for trace logging and P2P inference

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: EightRice

atn/config.py

@@ -111,6 +111,27 @@ class AutonetConfig:
     wallet_address: str = ""            # Connected wallet address (empty = not connected)
 
 
+@dataclass
+class TraceLoggingConfig:
+    """Configuration for structured agent trace logging.
+
+    Traces are written to ``trace_dir`` (default: ``{data_dir}/traces/``) as
+    content-addressed JSON files and serve as training data for VL-JEPA.
+
+    Example config.yaml snippet::
+
+        trace_logging:
+          enabled: true
+          trace_dir: ~/.atn/traces   # optional override
+          include_user_data: false   # set true to include orchestrator sessions
+          min_turns: 1               # quality filter: skip near-empty sessions
+    """
+    enabled: bool = False
+    trace_dir: str = ""             # empty → {data_dir}/traces/
+    include_user_data: bool = False  # consent gate (Epic 3 Story 3.1)
+    min_turns: int = 1              # minimum assistant turns for quality filter
+
+
 @dataclass
 class ATNConfig:
     """Top-level ATN configuration."""
@@ -119,6 +140,7 @@ class ATNConfig:
     orchestrator: OrchestratorConfig = field(default_factory=OrchestratorConfig)
     voice: VoiceConfig = field(default_factory=VoiceConfig)
     autonet: AutonetConfig = field(default_factory=AutonetConfig)
+    trace_logging: TraceLoggingConfig = field(default_factory=TraceLoggingConfig)
     providers: dict[str, ProviderConfig] = field(default_factory=dict)
     connectors: dict[str, ConnectorConfig] = field(default_factory=dict)
     raw: dict[str, Any] = field(default_factory=dict)
@@ -272,6 +294,16 @@ def load_config(path: Path | None = None) -> ATNConfig:
             wallet_address=resolved.get("wallet_address", ""),
         )
 
+    # Trace logging
+    trace_raw = raw.get("trace_logging", {})
+    if isinstance(trace_raw, dict):
+        config.trace_logging = TraceLoggingConfig(
+            enabled=trace_raw.get("enabled", False),
+            trace_dir=trace_raw.get("trace_dir", ""),
+            include_user_data=trace_raw.get("include_user_data", False),
+            min_turns=trace_raw.get("min_turns", 1),
+        )
+
     # Connectors
     for name, craw in raw.get("connectors", {}).items():
         if not isinstance(craw, dict):

atn/conversation.py

@@ -168,6 +168,29 @@ def turn_count(self) -> int:
         """Number of turns in the active conversation."""
         return len(self._turns)
 
+    def export_trace_turns(self) -> list[dict[str, Any]]:
+        """Export the active conversation as structured trace turns.
+
+        Converts the stored conversation history to the trace format used by
+        TraceLogger and VL-JEPA training:
+
+            [
+                {"role": "user",      "content": "...", "tool_calls": [], "timestamp": "..."},
+                {"role": "assistant", "content": "...", "tool_calls": [], "timestamp": "..."},
+            ]
+
+        Returns an empty list if there are no turns.
+        """
+        return [
+            {
+                "role": turn.role,
+                "content": turn.content,
+                "tool_calls": [],
+                "timestamp": turn.timestamp.isoformat(),
+            }
+            for turn in self._turns
+        ]
+
     # ------------------------------------------------------------------
     # Write
     # ------------------------------------------------------------------

atn/runtime/__init__.py

@@ -202,6 +202,26 @@ def __init__(self, event_bus: EventBus, data_dir: Path | None = None, config: AT
             data_dir=str(self._config.data_dir),
         )
 
+        # Trace logger (Phase B Step 1 — Agent Trace Collection)
+        from ..trace_logger import TraceLogger, TraceLoggingConfig as _TLConfig
+        _tl_cfg = self._config.trace_logging
+        _trace_dir = (
+            Path(_tl_cfg.trace_dir).expanduser()
+            if _tl_cfg.trace_dir
+            else self._config.data_dir / "traces"
+        )
+        self.trace_logger = TraceLogger(
+            config=_TLConfig(
+                enabled=_tl_cfg.enabled,
+                trace_dir=str(_trace_dir),
+                include_user_data=_tl_cfg.include_user_data,
+                min_turns=_tl_cfg.min_turns,
+            ),
+            trace_dir=_trace_dir,
+        )
+        # Wire trace_logger into the execution engine
+        self.engine.trace_logger = self.trace_logger
+
         # Tool registry
         from ..tool_registry import ToolRegistry
         self.tool_registry = ToolRegistry(self)
@@ -260,6 +280,9 @@ async def start(self) -> None:
         if self._config.autonet.enabled:
             await self.autonet.start()
 
+        # Attach trace logger to event bus (subscribes to AGENT_TOOL_USE_* events)
+        self.trace_logger.attach(self.events)
+
         await self.events.emit(Event(
             type=EventType.RUNTIME_STARTED,
             source="runtime",

atn/runtime/execution_engine.py

@@ -234,6 +234,9 @@ def __init__(
         # Events for signalling delegate completion
         self._delegate_done: dict[str, asyncio.Event] = {}
 
+        # Trace logger (set by Runtime after construction; may be None)
+        self.trace_logger: Any = None
+
     # ------------------------------------------------------------------
     # Trigger
     # ------------------------------------------------------------------
@@ -668,6 +671,17 @@ async def _on_chunk(text: str) -> None:
                     },
                 ))
 
+            # --- Trace logging: record execution start ---
+            if self.trace_logger is not None:
+                self.trace_logger.begin_execution(
+                    agent_id=defn.id,
+                    execution_id=record.execution_id,
+                    agent_type=defn.agent_type or ("orchestrator" if is_orchestrator else "cognitive"),
+                    system_prompt=system_prompt,
+                    # Store the raw user message before history prepending for cleaner traces
+                    user_message="\n\n".join(prompt_parts) if prompt_parts else (defn.description or defn.name),
+                )
+
             # --- Run the agent ---
             send_kwargs: dict[str, Any] = {
                 "message": user_message,
@@ -741,6 +755,22 @@ async def _on_chunk(text: str) -> None:
                     execution_id=record.execution_id,
                 ))
 
+            # --- Trace logging: finalise trace ---
+            if self.trace_logger is not None:
+                _trace_result = ""
+                if isinstance(record.output, dict):
+                    _trace_result = record.output.get("result", "")
+                elif record.output:
+                    _trace_result = str(record.output)
+                self.trace_logger.end_execution(
+                    agent_id=defn.id,
+                    execution_id=record.execution_id,
+                    result_text=_trace_result,
+                    status=record.status.value,
+                    error=record.error,
+                    completed_at=record.completed_at,
+                )
+
             # Record assistant turn (children)
             if not is_orchestrator:
                 _convo_text = ""