diff --git a/config/agent_contracts/agent_output_contracts.json b/config/agent_contracts/agent_output_contracts.json
index e3d9f90c..1bd3d3ec 100644
--- a/config/agent_contracts/agent_output_contracts.json
+++ b/config/agent_contracts/agent_output_contracts.json
@@ -1,7 +1,7 @@
 {
   "registry_id": "contextlattice_agent_output_contracts",
-  "registry_version": 2,
-  "updated_at": "2026-05-27T00:00:00Z",
+  "registry_version": 3,
+  "updated_at": "2026-05-28T00:00:00Z",
   "default_validator": "contextlattice.boundary.v1",
   "purpose": "Agent-facing ContextLattice payloads must carry explicit contract identifiers and pass boundary validation before being returned or handed to another agent.",
   "shared_fragments": {
@@ -61,6 +61,9 @@
       "payload_kind": "agent_policy_context_package",
       "required_output_mode": "json_object",
       "safe_failure_behavior": "return_json_contract_violation_envelope_without_raw_payload",
+      "max_total_json_bytes": 60000,
+      "max_string_bytes": 6000,
+      "max_list_items": 32,
       "required_fields": [
         "version",
         "agent",
@@ -160,6 +163,13 @@
         "anti_scheming_protocol.red_flags": 4,
         "anti_scheming_protocol.delivery": 3
       },
+      "max_bytes_by_path": {
+        "mission": 2000,
+        "objective": 2000,
+        "goal": 2000,
+        "handoff.handoff_prompt": 4000,
+        "evidence.mission_pack_error": 1000
+      },
       "forbidden_fields": [
         "hookSpecificOutput",
         "messages",
@@ -175,6 +185,9 @@
       "contract_version": 1,
       "payload_kind": "agent_preflight_response",
       "required_output_mode": "json_object",
+      "max_total_json_bytes": 180000,
+      "max_string_bytes": 8000,
+      "max_list_items": 64,
       "required_fields": [
         "ok",
         "service",
@@ -225,6 +238,9 @@
       "contract_version": 1,
       "payload_kind": "context_pack_response",
       "required_output_mode": "json_object",
+      "max_total_json_bytes": 120000,
+      "max_string_bytes": 6000,
+      "max_list_items": 64,
       "required_fields": [
         "context_pack",
         "source_coverage",
@@ -274,6 +290,10 @@
         "secrets"
       ],
       "forbidden_scope": "root",
+      "max_bytes_by_path": {
+        "query": 2000,
+        "task_summary": 1000
+      },
       "required_string_contains": {
         "format_contract.schema_id": "context_pack_response.v1"
       }
@@ -321,6 +341,9 @@
       "contract_version": 1,
       "payload_kind": "codex_compact_hook_stdout",
       "required_output_mode": "json_object",
+      "max_total_json_bytes": 4096,
+      "max_string_bytes": 4000,
+      "max_list_items": 4,
       "allowed_fields": [
         "continue",
         "suppressOutput",
@@ -597,6 +620,9 @@
       "payload_kind": "context_overflow_recovery",
       "contract_version": 1,
       "required_output_mode": "json_object",
+      "max_total_json_bytes": 120000,
+      "max_string_bytes": 8000,
+      "max_list_items": 16000,
       "required_fields": [
         "ok",
         "status",
diff --git a/contextlattice-dashboard/app/api/telemetry/memory/graph/route.ts b/contextlattice-dashboard/app/api/telemetry/memory/graph/route.ts
new file mode 100644
index 00000000..0031a097
--- /dev/null
+++ b/contextlattice-dashboard/app/api/telemetry/memory/graph/route.ts
@@ -0,0 +1,16 @@
+import { NextResponse } from "next/server";
+import { callOrchestrator } from "@/lib/orchestrator";
+
+export async function GET(request: Request) {
+  const url = new URL(request.url);
+  const params = new URLSearchParams();
+  for (const key of ["project", "limit", "include_ephemeral"]) {
+    const value = url.searchParams.get(key);
+    if (value) {
+      params.set(key, value);
+    }
+  }
+  const suffix = params.toString() ? `?${params.toString()}` : "";
+  const data = await callOrchestrator(`/telemetry/memory/graph${suffix}`);
+  return NextResponse.json(data);
+}
diff --git a/contextlattice-dashboard/app/status/page.tsx b/contextlattice-dashboard/app/status/page.tsx
index fa357d4d..f438f83f 100644
--- a/contextlattice-dashboard/app/status/page.tsx
+++ b/contextlattice-dashboard/app/status/page.tsx
@@ -2,6 +2,7 @@
 
 import { useEffect, useState } from "react";
 import { RetrievalPanel } from "@/components/RetrievalPanel";
+import { MemoryGraphPanel, type MemoryGraphPayload } from "@/components/MemoryGraphPanel";
 
 type Service = {
   name: string;
@@ -61,17 +62,19 @@ export default function StatusPage() {
   const [preferences, setPreferences] = useState<PreferencesPayload | null>(null);
   const [topics, setTopics] = useState<TopicsPayload | null>(null);
   const [memoryTelemetry, setMemoryTelemetry] = useState<MemoryTelemetry | null>(null);
+  const [memoryGraph, setMemoryGraph] = useState<MemoryGraphPayload | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [updatedAt, setUpdatedAt] = useState<string | null>(null);
 
   async function loadStatus() {
     try {
       setError(null);
-      const [statusRes, prefRes, topicRes, memRes] = await Promise.all([
+      const [statusRes, prefRes, topicRes, memRes, graphRes] = await Promise.all([
         fetch("/api/memory/status", { cache: "no-store" }),
         fetch("/api/memory/preferences", { cache: "no-store" }),
         fetch("/api/memory/topics", { cache: "no-store" }),
         fetch("/api/telemetry/memory", { cache: "no-store" }),
+        fetch("/api/telemetry/memory/graph", { cache: "no-store" }),
       ]);
       const statusData = await statusRes.json();
       if (!statusRes.ok) {
@@ -87,6 +90,9 @@ export default function StatusPage() {
       if (memRes.ok) {
         setMemoryTelemetry(await memRes.json());
       }
+      if (graphRes.ok) {
+        setMemoryGraph(await graphRes.json());
+      }
       setUpdatedAt(new Date().toLocaleTimeString());
     } catch (err: any) {
       setError(err?.message || "Status unavailable");
@@ -206,6 +212,8 @@ export default function StatusPage() {
         </div>
       </section>
 
+      <MemoryGraphPanel graph={memoryGraph} />
+
       <RetrievalPanel />
     </div>
   );
diff --git a/contextlattice-dashboard/components/MemoryGraphPanel.tsx b/contextlattice-dashboard/components/MemoryGraphPanel.tsx
new file mode 100644
index 00000000..6119330a
--- /dev/null
+++ b/contextlattice-dashboard/components/MemoryGraphPanel.tsx
@@ -0,0 +1,211 @@
+"use client";
+
+type CountRow = {
+  name?: string;
+  count?: number;
+};
+
+type ProjectRow = {
+  project?: string;
+  docs?: number;
+  connected_docs?: number;
+  isolated_docs?: number;
+  edges?: number;
+  inferred_edges?: number;
+  explicit_edges?: number;
+  density_edges_per_doc?: number;
+  top_relations?: CountRow[];
+};
+
+type NodeRow = {
+  memory_id?: string;
+  degree?: number;
+  inbound?: number;
+  outbound?: number;
+};
+
+export type MemoryGraphPayload = {
+  ok?: boolean;
+  status?: string;
+  generated_at?: string;
+  doc_count?: number;
+  edge_count?: number;
+  connected_doc_count?: number;
+  isolated_doc_count?: number;
+  inferred_edge_count?: number;
+  explicit_edge_count?: number;
+  density_edges_per_doc?: number;
+  projects?: ProjectRow[];
+  relations?: CountRow[];
+  top_nodes?: NodeRow[];
+  recommendations?: string[];
+  edge_store?: {
+    bytes?: number;
+    path?: string;
+  };
+};
+
+function numberValue(value: unknown): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+function MiniBar({ value, max }: { value: number; max: number }) {
+  const pct = max > 0 ? Math.max(0, Math.min(100, (value / max) * 100)) : 0;
+  return (
+    <div className="h-2 w-full rounded bg-slate-800 overflow-hidden" aria-hidden="true">
+      <div className="h-full bg-cyan-300" style={{ width: `${pct}%` }} />
+    </div>
+  );
+}
+
+function Metric({
+  label,
+  value,
+  tone,
+}: {
+  label: string;
+  value: number | string;
+  tone?: "warn" | "good";
+}) {
+  const toneClass =
+    tone === "warn" ? "text-amber-200 border-amber-500/70" : tone === "good" ? "text-emerald-200 border-emerald-500/70" : "text-slate-200 border-slate-600";
+  return (
+    <div className={`rounded border px-3 py-2 ${toneClass}`}>
+      <div className="text-xs uppercase tracking-wide text-slate-400">{label}</div>
+      <div className="text-lg font-semibold">{typeof value === "number" ? value.toLocaleString() : value}</div>
+    </div>
+  );
+}
+
+export function MemoryGraphPanel({ graph }: { graph: MemoryGraphPayload | null }) {
+  if (!graph) {
+    return (
+      <section className="card">
+        <h3 className="text-lg font-semibold">Memory graph</h3>
+        <p className="text-sm text-slate-400 mt-2">Graph telemetry unavailable.</p>
+      </section>
+    );
+  }
+
+  const projects = Array.isArray(graph.projects) ? graph.projects.slice(0, 6) : [];
+  const relations = Array.isArray(graph.relations) ? graph.relations.slice(0, 8) : [];
+  const topNodes = Array.isArray(graph.top_nodes) ? graph.top_nodes.slice(0, 6) : [];
+  const maxProjectEdges = Math.max(1, ...projects.map((item) => numberValue(item.edges)));
+  const maxRelationCount = Math.max(1, ...relations.map((item) => numberValue(item.count)));
+  const status = String(graph.status || "unknown");
+  const sparse = status === "sparse" || status === "no_edges";
+
+  return (
+    <section className="card space-y-5">
+      <div className="flex flex-wrap items-start justify-between gap-3">
+        <div>
+          <h3 className="text-lg font-semibold">Memory graph</h3>
+          <p className="text-xs text-slate-500 mt-1">
+            {graph.generated_at ? `Updated ${new Date(graph.generated_at).toLocaleTimeString()}` : "Updated -"}
+          </p>
+        </div>
+        <span
+          className={`text-xs px-2 py-1 rounded ${
+            sparse ? "bg-amber-500 text-amber-950" : "bg-emerald-500 text-emerald-950"
+          }`}
+        >
+          {status}
+        </span>
+      </div>
+
+      <div className="grid md:grid-cols-5 gap-3 text-sm">
+        <Metric label="Docs" value={numberValue(graph.doc_count)} />
+        <Metric label="Edges" value={numberValue(graph.edge_count)} tone={numberValue(graph.edge_count) > 0 ? "good" : "warn"} />
+        <Metric label="Inferred" value={numberValue(graph.inferred_edge_count)} />
+        <Metric label="Isolated" value={numberValue(graph.isolated_doc_count)} tone={numberValue(graph.isolated_doc_count) > 0 ? "warn" : "good"} />
+        <Metric label="Density" value={numberValue(graph.density_edges_per_doc).toFixed(2)} />
+      </div>
+
+      <div className="grid lg:grid-cols-2 gap-5">
+        <div className="space-y-2">
+          <h4 className="text-sm font-semibold text-slate-200">Projects</h4>
+          {projects.length ? (
+            <div className="space-y-2">
+              {projects.map((item) => {
+                const edges = numberValue(item.edges);
+                return (
+                  <div key={item.project || "project"} className="grid grid-cols-[minmax(0,1fr)_4rem] items-center gap-3 text-xs">
+                    <div className="min-w-0">
+                      <div className="flex items-center justify-between gap-2">
+                        <span className="truncate text-slate-300">{item.project || "unknown"}</span>
+                        <span className="text-slate-500">{numberValue(item.docs)} docs</span>
+                      </div>
+                      <MiniBar value={edges} max={maxProjectEdges} />
+                    </div>
+                    <div className="text-right text-slate-300">{edges.toLocaleString()}</div>
+                  </div>
+                );
+              })}
+            </div>
+          ) : (
+            <p className="text-xs text-slate-500">No project graph rows.</p>
+          )}
+        </div>
+
+        <div className="space-y-2">
+          <h4 className="text-sm font-semibold text-slate-200">Relations</h4>
+          {relations.length ? (
+            <div className="space-y-2">
+              {relations.map((item) => {
+                const count = numberValue(item.count);
+                return (
+                  <div key={item.name || "relation"} className="grid grid-cols-[minmax(0,1fr)_4rem] items-center gap-3 text-xs">
+                    <div className="min-w-0">
+                      <span className="truncate block text-slate-300">{item.name || "unknown"}</span>
+                      <MiniBar value={count} max={maxRelationCount} />
+                    </div>
+                    <div className="text-right text-slate-300">{count.toLocaleString()}</div>
+                  </div>
+                );
+              })}
+            </div>
+          ) : (
+            <p className="text-xs text-slate-500">No relation rows.</p>
+          )}
+        </div>
+      </div>
+
+      {topNodes.length ? (
+        <div className="overflow-x-auto text-xs">
+          <h4 className="text-sm font-semibold text-slate-200 mb-2">Top connected memories</h4>
+          <table className="w-full border border-slate-700/60 rounded">
+            <thead className="bg-slate-900/40 text-slate-300">
+              <tr>
+                <th className="px-3 py-2 text-left">Memory</th>
+                <th className="px-3 py-2 text-right">Degree</th>
+                <th className="px-3 py-2 text-right">In</th>
+                <th className="px-3 py-2 text-right">Out</th>
+              </tr>
+            </thead>
+            <tbody>
+              {topNodes.map((node) => (
+                <tr key={node.memory_id || "node"} className="border-t border-slate-800">
+                  <td className="px-3 py-2 max-w-[32rem] truncate">{node.memory_id || "unknown"}</td>
+                  <td className="px-3 py-2 text-right">{numberValue(node.degree)}</td>
+                  <td className="px-3 py-2 text-right">{numberValue(node.inbound)}</td>
+                  <td className="px-3 py-2 text-right">{numberValue(node.outbound)}</td>
+                </tr>
+              ))}
+            </tbody>
+          </table>
+        </div>
+      ) : null}
+
+      {Array.isArray(graph.recommendations) && graph.recommendations.length ? (
+        <div className="rounded border border-slate-700/70 p-3 text-xs text-slate-300">
+          <div className="font-semibold text-slate-100 mb-1">Recommended next action</div>
+          <ul className="space-y-1">
+            {graph.recommendations.slice(0, 3).map((item) => (
+              <li key={item}>{item}</li>
+            ))}
+          </ul>
+        </div>
+      ) : null}
+    </section>
+  );
+}
diff --git a/crates/context_codec/src/agent_contracts_generated.rs b/crates/context_codec/src/agent_contracts_generated.rs
index 7ffdc553..455c4cd8 100644
--- a/crates/context_codec/src/agent_contracts_generated.rs
+++ b/crates/context_codec/src/agent_contracts_generated.rs
@@ -9,7 +9,7 @@ pub struct AgentContractRef {
 }
 
 pub const AGENT_CONTRACT_REGISTRY_ID: &str = "contextlattice_agent_output_contracts";
-pub const AGENT_CONTRACT_REGISTRY_VERSION: u32 = 2;
+pub const AGENT_CONTRACT_REGISTRY_VERSION: u32 = 3;
 
 pub const A2A_READINESS_PROFILE_V1: &str = "a2a_readiness_profile.v1";
 pub const AGENT_FLIGHT_RECORDER_EVENT_V1: &str = "agent_flight_recorder_event.v1";
diff --git a/docs/agent-hooks.md b/docs/agent-hooks.md
index 7af340c3..8268cbd7 100644
--- a/docs/agent-hooks.md
+++ b/docs/agent-hooks.md
@@ -197,6 +197,7 @@ Context-pack shape is guarded by:
 
 ```bash
 scripts/agent/audit-agent-output-contracts
+scripts/agent/audit-agent-boundary-live
 scripts/agent/audit-context-pack-schema
 scripts/agent/audit-context-overflow-recovery
 scripts/agent/eval-skill-policy
@@ -221,6 +222,36 @@ uses provider-style error fixtures and oversized Responses-style input arrays so
 raw errors such as `array_above_max_length` or context-length failures do not
 become the user-facing contract.
 
+Before a release, run the live boundary canary against the local gateway:
+
+```bash
+scripts/agent/audit-agent-boundary-live --pretty
+```
+
+The canary hits `/memory/context-pack`, `/tools/context_pack`,
+`/v1/agents/preflight`, `/v1/codex/preflight`, and compact hook stdout wrappers
+with adversarial oversized inputs. By default it exercises Codex, Claude Code,
+Hermes, and Pi agent profiles through the generic preflight route. It validates
+the shared contracts and fails if raw provider-overflow-shaped text leaves the
+product boundary.
+
+Memory graph observability is available from the gateway at
+`GET /telemetry/memory/graph` and from the terminal:
+
+```bash
+scripts/agent/memory-graph-observe
+```
+
+Project bootstrap for a new repo should stay bounded and curated. Use:
+
+```bash
+scripts/agent/project-bootstrap-memory --repo /path/to/repo --project project-name --write --apply-edges
+```
+
+This writes compact overview/code-map/next-work notes from high-signal files
+only, then runs memory edge backfill for that project. It is not whole-repo raw
+ingestion.
+
 Agent ContextLattice wrappers retry and fail non-zero by default when reads or
 writes cannot complete. A compact JSON failure replaces Python tracebacks, but
 it is still a failure. Use context-pack `--soft` only for non-critical startup
diff --git a/scripts/agent/audit-agent-boundary-live b/scripts/agent/audit-agent-boundary-live
new file mode 100755
index 00000000..7954650d
--- /dev/null
+++ b/scripts/agent/audit-agent-boundary-live
@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+"""Live release gate for agent-facing ContextLattice boundary payloads."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+from _common import REPO_ROOT, contextlattice_base_url, emit, request_json
+
+sys.path.insert(0, str(REPO_ROOT / "scripts"))
+from agent_contracts import load_agent_contracts_registry, validate_agent_contract_payload  # noqa: E402
+
+
+FORBIDDEN_PROVIDER_PHRASES = (
+    "array_above_max_length",
+    "context length exceeded",
+    "maximum context length",
+    "max context length",
+    "input array is too long",
+    "oversized input",
+)
+
+
+def json_bytes(payload: Any) -> int:
+    return len(json.dumps(payload, sort_keys=True, separators=(",", ":")).encode("utf-8"))
+
+
+def raw_provider_phrase_findings(payload: Any, case: str) -> list[dict[str, Any]]:
+    encoded = json.dumps(payload, sort_keys=True).lower()
+    return [
+        {"severity": "error", "case": case, "reason": "raw_provider_overflow_phrase_leaked", "phrase": phrase}
+        for phrase in FORBIDDEN_PROVIDER_PHRASES
+        if phrase in encoded
+    ]
+
+
+def validate_contract(case: str, contract_id: str, payload: dict[str, Any], registry: dict[str, Any]) -> list[dict[str, Any]]:
+    findings = [{"severity": "error", "case": case, **item} for item in validate_agent_contract_payload(contract_id, payload, registry)]
+    findings.extend(raw_provider_phrase_findings(payload, case))
+    return findings
+
+
+def format_validation(payload: dict[str, Any]) -> str:
+    format_contract = payload.get("format_contract")
+    if isinstance(format_contract, dict):
+        validation = format_contract.get("validation")
+        if isinstance(validation, dict):
+            return str(validation.get("status") or "")
+    format_contracts = payload.get("format_contracts")
+    if isinstance(format_contracts, dict):
+        validation = format_contracts.get("validation")
+        if isinstance(validation, dict):
+            return str(validation.get("status") or "")
+    return ""
+
+
+def adversarial_text() -> str:
+    seed = "array_above_max_length context length exceeded maximum context length oversized input "
+    return (seed * 360).strip()
+
+
+def endpoint_cases(timeout: float, agents: list[str]) -> list[dict[str, Any]]:
+    query = adversarial_text()
+    context_payload = {
+        "project": "contextlattice",
+        "topic_path": "runbooks/boundary-canary",
+        "query": query,
+        "retrieval_mode": "balanced",
+        "limit": 100,
+        "max_facts": 100,
+        "include_retrieval_debug": True,
+        "agent_id": "codex_gpt5_boundary_canary",
+        "objective_context": {
+            "mission": "boundary canary mission",
+            "objective": "prove ContextLattice clips agent-facing payloads",
+            "goal": "no raw provider overflow shape leaves the product boundary",
+        },
+    }
+    preflight_payload = {
+        "project": "contextlattice",
+        "topic_path": "runbooks/boundary-canary",
+        "query": query,
+        "retrieval_mode": "balanced",
+        "agent_id": "codex_gpt5_boundary_canary",
+        "mission": "boundary canary mission",
+        "objective": "prove ContextLattice clips agent-facing payloads",
+        "goal": "no raw provider overflow shape leaves the product boundary",
+    }
+    cases = [
+        {
+            "name": "memory_context_pack",
+            "path": "/memory/context-pack",
+            "contract": "context_pack_response.v1",
+            "payload": request_json("POST", "/memory/context-pack", context_payload, timeout),
+        },
+        {
+            "name": "tools_context_pack",
+            "path": "/tools/context_pack",
+            "contract": "context_pack_response.v1",
+            "payload": request_json("POST", "/tools/context_pack", context_payload, timeout),
+        },
+        {
+            "name": "codex_preflight",
+            "path": "/v1/codex/preflight",
+            "contract": "agent_preflight_response.v1",
+            "payload": request_json("POST", "/v1/codex/preflight", {**preflight_payload, "agent": "codex"}, timeout),
+        },
+    ]
+    for agent in agents:
+        cases.append(
+            {
+                "name": f"agents_preflight_{agent.replace('-', '_')}",
+                "path": "/v1/agents/preflight",
+                "contract": "agent_preflight_response.v1",
+                "payload": request_json("POST", "/v1/agents/preflight", {**preflight_payload, "agent": agent}, timeout),
+            }
+        )
+    return cases
+
+
+def run_command(case: str, argv: list[str], stdin: str = "", env: dict[str, str] | None = None, timeout: float = 30) -> tuple[int, Any, str]:
+    proc = subprocess.run(
+        argv,
+        input=stdin,
+        text=True,
+        capture_output=True,
+        check=False,
+        cwd=str(REPO_ROOT),
+        env={**os.environ, **(env or {})},
+        timeout=timeout,
+    )
+    try:
+        parsed: Any = json.loads(proc.stdout or "{}")
+    except Exception:
+        parsed = {"ok": False, "stdout": proc.stdout[:1000], "parse_error": True}
+    return proc.returncode, parsed, proc.stderr[:1000]
+
+
+def compact_cases(timeout: float) -> list[dict[str, Any]]:
+    huge_payload = json.dumps(
+        {
+            "summary": adversarial_text(),
+            "objective": adversarial_text(),
+            "commands": [adversarial_text() for _ in range(12)],
+        }
+    )
+    helper = REPO_ROOT / "scripts" / "agent" / "compaction-handoff-payload"
+    pre_hook = REPO_ROOT / "scripts" / "agent_hooks" / "contextlattice_pre_compaction_write.sh"
+    post_hook = REPO_ROOT / "scripts" / "agent_hooks" / "contextlattice_post_compaction_read.sh"
+    cases: list[dict[str, Any]] = []
+    rc, payload, stderr = run_command(
+        "compaction_handoff_payload",
+        [str(helper), "--fallback-summary", adversarial_text(), "--summary"],
+        stdin=huge_payload,
+        timeout=timeout,
+    )
+    cases.append(
+        {
+            "name": "compaction_handoff_payload",
+            "contract": "handoff_json_budget",
+            "returncode": rc,
+            "payload": payload,
+            "stderr": stderr,
+        }
+    )
+    for name, hook, env_key in (
+        ("precompact_stdout", pre_hook, "CONTEXTLATTICE_PRECOMPACT_SCHEMA_SMOKE"),
+        ("postcompact_stdout", post_hook, "CONTEXTLATTICE_POSTCOMPACT_SCHEMA_SMOKE"),
+    ):
+        rc, payload, stderr = run_command(name, [str(hook)], env={env_key: "1"}, timeout=timeout)
+        cases.append(
+            {
+                "name": name,
+                "contract": "codex_compact_hook_stdout.v1",
+                "returncode": rc,
+                "payload": payload,
+                "stderr": stderr,
+            }
+        )
+    return cases
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--timeout", type=float, default=60.0)
+    parser.add_argument("--skip-live", action="store_true", help="Only validate compact handoff/stdout wrappers.")
+    parser.add_argument(
+        "--agents",
+        default="codex,claude-code,hermes-agent,pi",
+        help="Comma-separated agent profiles to exercise through /v1/agents/preflight.",
+    )
+    parser.add_argument("--pretty", action="store_true")
+    args = parser.parse_args()
+
+    registry = load_agent_contracts_registry()
+    findings: list[dict[str, Any]] = []
+    cases: list[dict[str, Any]] = []
+    agents = [item.strip() for item in str(args.agents or "").split(",") if item.strip()]
+
+    if not args.skip_live:
+        for case in endpoint_cases(args.timeout, agents):
+            payload = case["payload"]
+            case_summary = {
+                "name": case["name"],
+                "path": case["path"],
+                "contract": case["contract"],
+                "json_bytes": json_bytes(payload),
+                "format_validation": format_validation(payload),
+            }
+            cases.append(case_summary)
+            findings.extend(validate_contract(case["name"], case["contract"], payload, registry))
+            if format_validation(payload) not in {"", "passed"}:
+                findings.append(
+                    {
+                        "severity": "error",
+                        "case": case["name"],
+                        "reason": "format_validation_not_passed",
+                        "status": format_validation(payload),
+                    }
+                )
+
+    for case in compact_cases(args.timeout):
+        payload = case["payload"]
+        cases.append(
+            {
+                "name": case["name"],
+                "contract": case["contract"],
+                "returncode": case["returncode"],
+                "json_bytes": json_bytes(payload),
+            }
+        )
+        if case["returncode"] != 0:
+            findings.append({"severity": "error", "case": case["name"], "reason": "command_failed", "stderr": case["stderr"]})
+        if case["contract"] == "codex_compact_hook_stdout.v1":
+            findings.extend(validate_contract(case["name"], case["contract"], payload, registry))
+        else:
+            findings.extend(raw_provider_phrase_findings(payload, case["name"]))
+            if json_bytes(payload) > 12_000:
+                findings.append(
+                    {
+                        "severity": "error",
+                        "case": case["name"],
+                        "reason": "handoff_payload_exceeds_summary_budget",
+                        "bytes": json_bytes(payload),
+                    }
+                )
+
+    errors = [item for item in findings if item.get("severity") == "error"]
+    emit(
+        {
+            "ok": not errors,
+            "base_url": contextlattice_base_url(),
+            "case_count": len(cases),
+            "cases": cases,
+            "findings": findings,
+        },
+        args.pretty,
+    )
+    return 1 if errors else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/agent/compaction-handoff-payload b/scripts/agent/compaction-handoff-payload
index 6c411e23..6a25704d 100755
--- a/scripts/agent/compaction-handoff-payload
+++ b/scripts/agent/compaction-handoff-payload
@@ -11,7 +11,7 @@ import sys
 from pathlib import Path
 from typing import Any
 
-from _common import emit, now_iso
+from _common import REPO_ROOT, emit, now_iso
 
 
 TEXT_KEYS = (
@@ -24,20 +24,108 @@ TEXT_KEYS = (
     "reason",
 )
 SESSION_KEYS = ("session_id", "sessionId", "conversation_id", "conversationId", "id")
+DEFAULT_MAX_STDIN_BYTES = 512 * 1024
+DEFAULT_MAX_SUMMARY_JSON_BYTES = 12_000
+MAX_DEPTH = 8
+MAX_DICT_ITEMS = 80
+MAX_LIST_ITEMS = 64
+MODEL_COMPATIBILITY_CONTRACT_PATH = REPO_ROOT / "config" / "model_compat" / "compaction_prompt_contract.json"
+_MODEL_COMPATIBILITY_CONTRACT: dict[str, Any] | None = None
+PROVIDER_OVERFLOW_PATTERNS = (
+    "array_above_max_length",
+    "context length exceeded",
+    "maximum context length",
+    "max context length",
+    "input array is too long",
+    "oversized input",
+)
+
+
+def env_int(name: str, default: int, min_value: int = 1, max_value: int = 10_000_000) -> int:
+    raw = os.getenv(name, "").strip()
+    if not raw:
+        return default
+    try:
+        value = int(raw)
+    except ValueError:
+        return default
+    return max(min_value, min(max_value, value))
+
+
+def model_compatibility_contract() -> dict[str, Any]:
+    global _MODEL_COMPATIBILITY_CONTRACT
+    if _MODEL_COMPATIBILITY_CONTRACT is None:
+        if not MODEL_COMPATIBILITY_CONTRACT_PATH.exists():
+            _MODEL_COMPATIBILITY_CONTRACT = {}
+            return {}
+        with MODEL_COMPATIBILITY_CONTRACT_PATH.open(encoding="utf-8") as fh:
+            parsed = json.load(fh)
+        if not isinstance(parsed, dict):
+            raise ValueError(f"{MODEL_COMPATIBILITY_CONTRACT_PATH} must contain a JSON object")
+        _MODEL_COMPATIBILITY_CONTRACT = parsed
+    return dict(_MODEL_COMPATIBILITY_CONTRACT)
+
+
+def prompt_safe_text(value: str) -> str:
+    text = str(value or "")
+    lowered = text.lower()
+    if any(pattern in lowered for pattern in PROVIDER_OVERFLOW_PATTERNS):
+        text = "ContextLattice boundary reduced an oversized provider input before recording this compaction handoff."
+    replacements = model_compatibility_contract().get("prompt_escape_replacements") or []
+    for replacement in replacements:
+        if not isinstance(replacement, dict):
+            continue
+        needle = str(replacement.get("find") or "")
+        replacement_text = str(replacement.get("replace") or "")
+        if not needle:
+            continue
+        text = text.replace(needle, replacement_text)
+    return " ".join(text.split())
 
 
 def compact_text(value: str, limit: int = 1200) -> str:
-    return " ".join(str(value or "").split())[:limit]
+    return prompt_safe_text(value)[:limit]
+
+
+def bounded_value(value: Any, depth: int = 0) -> Any:
+    if depth >= MAX_DEPTH:
+        return {"_truncated": "max_depth"}
+    if isinstance(value, dict):
+        out: dict[str, Any] = {}
+        for index, (key, item) in enumerate(value.items()):
+            if index >= MAX_DICT_ITEMS:
+                out["_truncated_keys"] = max(0, len(value) - MAX_DICT_ITEMS)
+                break
+            out[str(key)[:160]] = bounded_value(item, depth + 1)
+        return out
+    if isinstance(value, list):
+        out = [bounded_value(item, depth + 1) for item in value[:MAX_LIST_ITEMS]]
+        if len(value) > MAX_LIST_ITEMS:
+            out.append({"_truncated_items": len(value) - MAX_LIST_ITEMS})
+        return out
+    if isinstance(value, str):
+        return compact_text(value, 1600)
+    return value
 
 
 def load_payload() -> Any:
-    raw = sys.stdin.read() if not sys.stdin.isatty() else ""
+    if sys.stdin.isatty():
+        return {}
+    max_bytes = env_int("CONTEXTLATTICE_COMPACTION_STDIN_MAX_BYTES", DEFAULT_MAX_STDIN_BYTES)
+    raw_bytes = sys.stdin.buffer.read(max_bytes + 1)
+    truncated = len(raw_bytes) > max_bytes
+    if truncated:
+        raw_bytes = raw_bytes[:max_bytes]
+    raw = raw_bytes.decode("utf-8", errors="replace")
     if not raw.strip():
         return {}
     try:
-        return json.loads(raw)
+        payload = bounded_value(json.loads(raw))
+        if isinstance(payload, dict) and truncated:
+            payload["_contextlattice_input_truncated"] = True
+        return payload
     except Exception:
-        return {"raw": raw[:1600]}
+        return {"raw": raw[:1600], "input_truncated": truncated}
 
 
 def first_string(value: Any, keys: tuple[str, ...], accept_bare: bool = False) -> str:
diff --git a/scripts/agent/memory-graph-observe b/scripts/agent/memory-graph-observe
new file mode 100755
index 00000000..86f0490f
--- /dev/null
+++ b/scripts/agent/memory-graph-observe
@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+"""Render ContextLattice memory graph observability in the terminal."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import urllib.parse
+from typing import Any
+
+from _common import emit, request_json
+
+
+def bar(value: int, maximum: int, width: int = 32) -> str:
+    if maximum <= 0:
+        filled = 0
+    else:
+        filled = round((max(0, value) / maximum) * width)
+    filled = max(0, min(width, filled))
+    return "#" * filled + "." * (width - filled)
+
+
+def count_name(row: dict[str, Any]) -> str:
+    return str(row.get("name") or row.get("project") or row.get("memory_id") or "unknown")
+
+
+def count_value(row: dict[str, Any], key: str = "count") -> int:
+    try:
+        return int(row.get(key) or 0)
+    except Exception:
+        return 0
+
+
+def print_counts(title: str, rows: list[dict[str, Any]], value_key: str = "count", limit: int = 8) -> None:
+    print()
+    print(title)
+    if not rows:
+        print("  (none)")
+        return
+    maximum = max(count_value(row, value_key) for row in rows[:limit]) or 1
+    for row in rows[:limit]:
+        name = count_name(row)
+        value = count_value(row, value_key)
+        print(f"  {name[:34]:34} {value:6d}  {bar(value, maximum)}")
+
+
+def render(payload: dict[str, Any]) -> None:
+    status = str(payload.get("status") or "unknown")
+    edge_count = count_value(payload, "edge_count")
+    doc_count = count_value(payload, "doc_count")
+    inferred = count_value(payload, "inferred_edge_count")
+    isolated = count_value(payload, "isolated_doc_count")
+    density = float(payload.get("density_edges_per_doc") or 0)
+    print("ContextLattice Memory Graph")
+    print(f"  status: {status}")
+    print(f"  docs: {doc_count}   edges: {edge_count}   inferred: {inferred}   isolated: {isolated}   density: {density:.3f}")
+    print(f"  doc collection: {payload.get('doc_collection_status') or 'unknown'}")
+    edge_store = payload.get("edge_store") if isinstance(payload.get("edge_store"), dict) else {}
+    if edge_store:
+        print(f"  edge log: {edge_store.get('path') or ''}")
+        print(f"  edge log bytes: {edge_store.get('bytes') or 0}")
+    projects = [row for row in payload.get("projects") or [] if isinstance(row, dict)]
+    relations = [row for row in payload.get("relations") or [] if isinstance(row, dict)]
+    nodes = [row for row in payload.get("top_nodes") or [] if isinstance(row, dict)]
+    print_counts("Projects by edge count", projects, "edges")
+    print_counts("Relations", relations, "count")
+    if nodes:
+        print()
+        print("Top connected memories")
+        maximum = max(count_value(row, "degree") for row in nodes) or 1
+        for row in nodes[:8]:
+            memory_id = str(row.get("memory_id") or "")
+            degree = count_value(row, "degree")
+            in_out = f"in:{count_value(row, 'inbound')} out:{count_value(row, 'outbound')}"
+            print(f"  {memory_id[:48]:48} {degree:5d}  {bar(degree, maximum, 22)}  {in_out}")
+    recommendations = [str(item) for item in payload.get("recommendations") or [] if str(item).strip()]
+    if recommendations:
+        print()
+        print("Recommended next action")
+        for item in recommendations[:4]:
+            print(f"  - {item}")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--project", default="")
+    parser.add_argument("--limit", type=int, default=10)
+    parser.add_argument("--include-ephemeral", action="store_true")
+    parser.add_argument("--json", action="store_true", help="Emit raw JSON instead of terminal graphics.")
+    parser.add_argument("--pretty", action="store_true")
+    parser.add_argument("--timeout", type=float, default=20)
+    args = parser.parse_args()
+
+    query = {"limit": str(max(1, min(args.limit, 50)))}
+    if args.project:
+        query["project"] = args.project
+    if args.include_ephemeral:
+        query["include_ephemeral"] = "true"
+    path = "/telemetry/memory/graph?" + urllib.parse.urlencode(query)
+    payload = request_json("GET", path, None, args.timeout)
+    if args.json:
+        emit(payload, args.pretty)
+    else:
+        render(payload)
+    return 0 if payload.get("ok", False) else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/agent/project-bootstrap-memory b/scripts/agent/project-bootstrap-memory
new file mode 100755
index 00000000..8c26a0c5
--- /dev/null
+++ b/scripts/agent/project-bootstrap-memory
@@ -0,0 +1,335 @@
+#!/usr/bin/env python3
+"""Create bounded ContextLattice project memory from high-signal repo files."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from _common import emit, request_json
+
+
+EXCLUDED_DIRS = {
+    ".git",
+    ".next",
+    ".pytest_cache",
+    ".venv",
+    "node_modules",
+    "target",
+    "dist",
+    "build",
+    "__pycache__",
+}
+PRIORITY_FILES = (
+    "AGENTS.md",
+    "README.md",
+    "Outline.txt",
+    "EVALUATION.md",
+    "pyproject.toml",
+    "package.json",
+    "go.mod",
+    "Cargo.toml",
+    "docker-compose.yml",
+    "docker-compose.lite.yml",
+    "Dockerfile",
+)
+PRIORITY_NAMES = {
+    "app.py",
+    "main.py",
+    "models.py",
+    "orchestrator.py",
+    "worker.py",
+    "store.py",
+    "pipeline.py",
+    "main.go",
+    "server.go",
+    "index.ts",
+    "index.tsx",
+}
+TEXT_SUFFIXES = {".md", ".txt", ".py", ".go", ".rs", ".ts", ".tsx", ".js", ".json", ".toml", ".yml", ".yaml"}
+
+
+def utc_date() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%d")
+
+
+def safe_project_from_repo(repo: Path) -> str:
+    name = repo.resolve().name.strip().lower().replace(" ", "-")
+    return "".join(ch for ch in name if ch.isalnum() or ch in "._-") or "project"
+
+
+def should_skip(path: Path, repo: Path) -> bool:
+    try:
+        rel = path.relative_to(repo)
+    except ValueError:
+        return True
+    return any(part in EXCLUDED_DIRS or part.startswith(".venv") for part in rel.parts)
+
+
+def candidate_files(repo: Path, max_files: int) -> list[Path]:
+    seen: set[Path] = set()
+    out: list[Path] = []
+
+    def add(path: Path) -> None:
+        if len(out) >= max_files:
+            return
+        if path in seen or not path.is_file() or should_skip(path, repo):
+            return
+        if path.suffix.lower() not in TEXT_SUFFIXES and path.name not in PRIORITY_FILES and path.name not in PRIORITY_NAMES:
+            return
+        seen.add(path)
+        out.append(path)
+
+    for name in PRIORITY_FILES:
+        add(repo / name)
+    for path in sorted(repo.glob("docs/**/*.md")):
+        add(path)
+    for path in sorted(repo.rglob("*")):
+        if path.name in PRIORITY_NAMES:
+            add(path)
+        if len(out) >= max_files:
+            break
+    return out[:max_files]
+
+
+def compact_text(text: str, limit: int) -> str:
+    text = text.replace("\x00", "")
+    lines = [" ".join(line.strip().split()) for line in text.splitlines()]
+    lines = [line for line in lines if line]
+    compact = "\n".join(lines)
+    if len(compact.encode("utf-8")) <= limit:
+        return compact
+    raw = compact.encode("utf-8")[:limit]
+    return raw.decode("utf-8", errors="ignore") + "\n[truncated]"
+
+
+def read_snippet(path: Path, max_bytes: int) -> str:
+    raw = path.read_bytes()[: max_bytes + 1]
+    truncated = len(raw) > max_bytes
+    if truncated:
+        raw = raw[:max_bytes]
+    text = raw.decode("utf-8", errors="replace")
+    snippet = compact_text(text, max_bytes)
+    return snippet + ("\n[file snippet truncated]" if truncated else "")
+
+
+def file_role(path: Path) -> str:
+    name = path.name.lower()
+    if name.startswith("readme") or name == "agents.md":
+        return "operator_context"
+    if name in {"pyproject.toml", "package.json", "go.mod", "cargo.toml"}:
+        return "runtime_manifest"
+    if "test" in path.parts or name.startswith("test_") or name.endswith("_test.go"):
+        return "test_surface"
+    if path.suffix.lower() in {".py", ".go", ".rs", ".ts", ".tsx", ".js"}:
+        return "code_surface"
+    if "docs" in path.parts:
+        return "documentation"
+    return "project_context"
+
+
+def collect_file_summaries(repo: Path, max_files: int, max_file_bytes: int) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    for path in candidate_files(repo, max_files):
+        rel = str(path.relative_to(repo))
+        snippet = read_snippet(path, max_file_bytes)
+        rows.append(
+            {
+                "path": rel,
+                "role": file_role(path),
+                "bytes_sampled": min(path.stat().st_size, max_file_bytes),
+                "raw_bytes": path.stat().st_size,
+                "snippet": snippet,
+            }
+        )
+    return rows
+
+
+def render_overview(project: str, repo: Path, rows: list[dict[str, Any]]) -> str:
+    docs = [row for row in rows if row["role"] in {"operator_context", "documentation", "runtime_manifest"}]
+    lines = [
+        "# Project Bootstrap Overview",
+        f"project: {project}",
+        f"repo: {repo}",
+        "scope: bounded high-signal project memory, not raw repository ingestion",
+        "",
+        "## High-signal files",
+    ]
+    for row in docs[:12]:
+        lines.append(f"- {row['path']} ({row['role']}, sampled {row['bytes_sampled']} bytes)")
+    lines.append("")
+    lines.append("## Extracts")
+    for row in docs[:6]:
+        lines.extend([f"### {row['path']}", str(row["snippet"])[:1800], ""])
+    return "\n".join(lines).strip() + "\n"
+
+
+def render_code_map(project: str, rows: list[dict[str, Any]]) -> str:
+    code = [row for row in rows if row["role"] in {"code_surface", "test_surface"}]
+    lines = [
+        "# Project Code Map",
+        f"project: {project}",
+        "scope: compact source-surface map for agent planning",
+        "",
+        "## Files",
+    ]
+    for row in code[:24]:
+        lines.append(f"- {row['path']} ({row['role']}, sampled {row['bytes_sampled']} bytes)")
+    lines.append("")
+    lines.append("## Extracts")
+    for row in code[:8]:
+        lines.extend([f"### {row['path']}", str(row["snippet"])[:1400], ""])
+    return "\n".join(lines).strip() + "\n"
+
+
+def render_next_work(project: str, rows: list[dict[str, Any]]) -> str:
+    markers: list[str] = []
+    for row in rows:
+        for line in str(row["snippet"]).splitlines():
+            lowered = line.lower()
+            if any(token in lowered for token in ("todo", "fixme", "next", "risk", "missing", "follow-up", "follow up")):
+                markers.append(f"{row['path']}: {line[:220]}")
+            if len(markers) >= 32:
+                break
+        if len(markers) >= 32:
+            break
+    lines = [
+        "# Project Bootstrap Next Work",
+        f"project: {project}",
+        "scope: deterministic next-work hints from bounded repo metadata",
+        "",
+        "## Detected markers",
+    ]
+    if markers:
+        lines.extend(f"- {marker}" for marker in markers)
+    else:
+        lines.append("- No TODO/risk/next-work markers found in sampled files.")
+    lines.extend(
+        [
+            "",
+            "## Recommended bootstrap checks",
+            "- Run the repo's lightweight compile/test command before acting on inferred architecture.",
+            "- Use ContextLattice context-pack with this project filter before cross-file planning.",
+            "- Run memory edge backfill after bootstrap writes so graph neighbors can surface related notes.",
+        ]
+    )
+    return "\n".join(lines).strip() + "\n"
+
+
+def bootstrap_documents(project: str, repo: Path, topic_path: str, rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    stamp = utc_date()
+    return [
+        {
+            "project": project,
+            "file_name": f"notes/codex/{project}-bootstrap-overview-{stamp}.md",
+            "topic_path": topic_path,
+            "content": render_overview(project, repo, rows),
+        },
+        {
+            "project": project,
+            "file_name": f"notes/codex/{project}-bootstrap-code-map-{stamp}.md",
+            "topic_path": topic_path,
+            "content": render_code_map(project, rows),
+        },
+        {
+            "project": project,
+            "file_name": f"notes/codex/{project}-bootstrap-next-work-{stamp}.md",
+            "topic_path": topic_path,
+            "content": render_next_work(project, rows),
+        },
+    ]
+
+
+def write_doc(doc: dict[str, Any], timeout: float) -> dict[str, Any]:
+    payload = {
+        "projectName": doc["project"],
+        "fileName": doc["file_name"],
+        "topicPath": doc["topic_path"],
+        "content": doc["content"],
+        "tags": ["type:project_bootstrap", "source:bounded_repo_scan"],
+    }
+    return request_json("POST", "/memory/write", payload, timeout)
+
+
+def backfill_edges(project: str, apply_edges: bool, profile: str, timeout: float) -> dict[str, Any]:
+    profiles = {
+        "strict": {"min_confidence": 0.90, "inferred_min_score": 0.90, "inferred_peer_limit": 1, "inferred_max_token_postings": 64},
+        "balanced": {"min_confidence": 0.85, "inferred_min_score": 0.85, "inferred_peer_limit": 3, "inferred_max_token_postings": 128},
+        "exploratory": {"min_confidence": 0.80, "inferred_min_score": 0.80, "inferred_peer_limit": 5, "inferred_max_token_postings": 256},
+    }
+    selected = profiles.get(profile, profiles["exploratory"])
+    payload: dict[str, Any] = {
+        "dry_run": not apply_edges,
+        "project": project,
+        "corpus": "disk",
+        "relations": ["same_topic", "references", "same_session", "same_agent", "inferred_related"],
+        "include_inferred": True,
+        "include_low_confidence_audit": True,
+        "inferred_min_shared_terms": 3,
+        "sample_limit": 20,
+        **selected,
+    }
+    return request_json("POST", "/v1/memory/edges/backfill", payload, timeout)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--repo", default=".", help="Repository path to summarize.")
+    parser.add_argument("--project", default="", help="ContextLattice project name. Defaults to repo directory name.")
+    parser.add_argument("--topic-path", default="", help="Topic path for bootstrap notes.")
+    parser.add_argument("--max-files", type=int, default=24)
+    parser.add_argument("--max-file-bytes", type=int, default=7000)
+    parser.add_argument("--write", action="store_true", help="Write bootstrap docs to ContextLattice.")
+    parser.add_argument("--apply-edges", action="store_true", help="Apply edge backfill after writes. Defaults to dry-run.")
+    parser.add_argument("--edge-profile", choices=("strict", "balanced", "exploratory"), default="exploratory")
+    parser.add_argument("--timeout", type=float, default=120)
+    parser.add_argument("--pretty", action="store_true")
+    args = parser.parse_args()
+
+    repo = Path(args.repo).expanduser().resolve()
+    if not repo.exists() or not repo.is_dir():
+        emit({"ok": False, "error": "repo_not_found", "repo": str(repo)}, args.pretty)
+        return 1
+    project = args.project.strip() or safe_project_from_repo(repo)
+    topic_path = args.topic_path.strip() or f"runbooks/{project}"
+    rows = collect_file_summaries(repo, max(3, min(args.max_files, 80)), max(512, min(args.max_file_bytes, 24_000)))
+    docs = bootstrap_documents(project, repo, topic_path, rows)
+    writes: list[dict[str, Any]] = []
+    if args.write:
+        for doc in docs:
+            writes.append(write_doc(doc, args.timeout))
+    edge_backfill = None
+    if args.write:
+        edge_backfill = backfill_edges(project, args.apply_edges, args.edge_profile, args.timeout)
+
+    emit(
+        {
+            "ok": True,
+            "repo": str(repo),
+            "project": project,
+            "topic_path": topic_path,
+            "dry_run": not args.write,
+            "sampled_files": [{"path": row["path"], "role": row["role"], "bytes_sampled": row["bytes_sampled"]} for row in rows],
+            "documents": [
+                {
+                    "file_name": doc["file_name"],
+                    "topic_path": doc["topic_path"],
+                    "bytes": len(doc["content"].encode("utf-8")),
+                    "preview": doc["content"][:600],
+                }
+                for doc in docs
+            ],
+            "writes": writes,
+            "edge_backfill": edge_backfill,
+        },
+        args.pretty,
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/agent_contracts.py b/scripts/agent_contracts.py
index 8566351f..08e78213 100755
--- a/scripts/agent_contracts.py
+++ b/scripts/agent_contracts.py
@@ -12,6 +12,14 @@
 REPO_ROOT = Path(__file__).resolve().parents[1]
 DEFAULT_REGISTRY_PATH = REPO_ROOT / "config" / "agent_contracts" / "agent_output_contracts.json"
 REGISTRY_ENV = "CONTEXTLATTICE_AGENT_CONTRACTS_PATH"
+PROVIDER_OVERFLOW_PATTERNS = (
+    "array_above_max_length",
+    "context length exceeded",
+    "maximum context length",
+    "max context length",
+    "input array is too long",
+    "oversized input",
+)
 
 
 def registry_path() -> Path:
@@ -95,6 +103,194 @@ def _walk_forbidden_keys(value: Any, forbidden: set[str], path: str = "") -> lis
     return findings
 
 
+def _json_bytes(value: Any) -> int:
+    return len(json.dumps(value, sort_keys=True, separators=(",", ":")).encode("utf-8"))
+
+
+def _sanitize_provider_overflow_text(value: str) -> str:
+    lowered = value.lower()
+    if any(pattern in lowered for pattern in PROVIDER_OVERFLOW_PATTERNS):
+        return "ContextLattice boundary reduced an oversized provider input before returning this payload."
+    return value
+
+
+def _clip_utf8(value: str, max_bytes: int) -> str:
+    raw = value.encode("utf-8")
+    if max_bytes <= 0 or len(raw) <= max_bytes:
+        return value
+    suffix = b"... [truncated]"
+    if max_bytes <= len(suffix):
+        return raw[:max_bytes].decode("utf-8", errors="ignore")
+    prefix = raw[: max_bytes - len(suffix)].decode("utf-8", errors="ignore")
+    return prefix + suffix.decode("ascii")
+
+
+def _walk_string_bytes(value: Any, max_bytes: int, contract_id: str, path: str = "") -> list[dict[str, Any]]:
+    findings: list[dict[str, Any]] = []
+    if max_bytes <= 0:
+        return findings
+    if isinstance(value, dict):
+        for key in sorted(value):
+            next_path = f"{path}.{key}" if path else str(key)
+            findings.extend(_walk_string_bytes(value[key], max_bytes, contract_id, next_path))
+    elif isinstance(value, list):
+        for item in value[:512]:
+            findings.extend(_walk_string_bytes(item, max_bytes, contract_id, f"{path}[]"))
+    elif isinstance(value, str):
+        actual = len(value.encode("utf-8"))
+        if actual > max_bytes:
+            findings.append(
+                {
+                    "reason": "string_bytes_exceed_contract",
+                    "path": path,
+                    "bytes": actual,
+                    "max_bytes": max_bytes,
+                    "contract_id": contract_id,
+                }
+            )
+    return findings
+
+
+def _walk_list_items(value: Any, max_items: int, contract_id: str, path: str = "") -> list[dict[str, Any]]:
+    findings: list[dict[str, Any]] = []
+    if max_items <= 0:
+        return findings
+    if isinstance(value, dict):
+        for key in sorted(value):
+            next_path = f"{path}.{key}" if path else str(key)
+            findings.extend(_walk_list_items(value[key], max_items, contract_id, next_path))
+    elif isinstance(value, list):
+        if len(value) > max_items:
+            findings.append(
+                {
+                    "reason": "list_items_exceed_contract",
+                    "path": path,
+                    "items": len(value),
+                    "max_items": max_items,
+                    "contract_id": contract_id,
+                }
+            )
+        for item in value[:512]:
+            findings.extend(_walk_list_items(item, max_items, contract_id, f"{path}[]"))
+    return findings
+
+
+def _enforce_value_limits(value: Any, max_string_bytes: int, max_list_items: int, sanitize_overflow: bool) -> Any:
+    if isinstance(value, dict):
+        return {
+            str(key): _enforce_value_limits(item, max_string_bytes, max_list_items, sanitize_overflow)
+            for key, item in value.items()
+        }
+    if isinstance(value, list):
+        items = value
+        if max_list_items >= 0 and len(items) > max_list_items:
+            items = items[:max_list_items]
+        return [_enforce_value_limits(item, max_string_bytes, max_list_items, sanitize_overflow) for item in items]
+    if isinstance(value, str):
+        text = _sanitize_provider_overflow_text(value) if sanitize_overflow else value
+        if max_string_bytes > 0:
+            text = _clip_utf8(text, max_string_bytes)
+        return text
+    return value
+
+
+def _compact_context_pack_payload(payload: dict[str, Any], keep: int) -> None:
+    pack = payload.get("context_pack")
+    if isinstance(pack, dict):
+        for key in (
+            "facts",
+            "numericFacts",
+            "numeric_facts",
+            "citations",
+            "results",
+            "relevantDecisions",
+            "relevant_decisions",
+            "filesToRead",
+            "files_to_read",
+            "filesToAvoid",
+            "files_to_avoid",
+            "capabilitiesToUse",
+            "capabilities_to_use",
+            "runbooks",
+            "knownFailureModes",
+            "known_failure_modes",
+            "commands",
+            "acceptanceCriteria",
+            "acceptance_criteria",
+        ):
+            if isinstance(pack.get(key), list):
+                pack[key] = pack[key][:keep]
+    if "retrieval" in payload:
+        payload["retrieval"] = {"omitted_by_boundary": True}
+    if isinstance(payload.get("warnings"), list):
+        payload["warnings"] = payload["warnings"][: min(keep, 8)]
+
+
+def _compact_policy_payload(payload: dict[str, Any], keep: int) -> None:
+    for key in ("mission", "objective", "goal", "query"):
+        if isinstance(payload.get(key), str):
+            payload[key] = _clip_utf8(_sanitize_provider_overflow_text(payload[key]), 2000)
+    evidence = payload.get("evidence")
+    if isinstance(evidence, dict):
+        for key in ("primary_facts", "mission_facts"):
+            if isinstance(evidence.get(key), list):
+                evidence[key] = evidence[key][: max(5, keep)]
+        if isinstance(evidence.get("mission_pack_error"), str):
+            evidence["mission_pack_error"] = _clip_utf8(_sanitize_provider_overflow_text(evidence["mission_pack_error"]), 1000)
+    handoff = payload.get("handoff")
+    if isinstance(handoff, dict) and isinstance(handoff.get("handoff_prompt"), str):
+        handoff["handoff_prompt"] = _clip_utf8(_sanitize_provider_overflow_text(handoff["handoff_prompt"]), 4000)
+
+
+def _compact_preflight_payload(payload: dict[str, Any], keep: int) -> None:
+    for key in ("context_pack", "mission_context_pack", "mission_pack"):
+        value = payload.get(key)
+        if isinstance(value, dict):
+            _compact_context_pack_payload(value, keep)
+            nested = value.get("payload")
+            if isinstance(nested, dict):
+                _compact_context_pack_payload(nested, keep)
+    for key in ("scoped_search", "broadened_search", "status", "health"):
+        if isinstance(payload.get(key), dict):
+            payload[key] = {"omitted_by_boundary": True}
+    policy = payload.get("policy_context_package")
+    if isinstance(policy, dict):
+        _compact_policy_payload(policy, keep)
+
+
+def enforce_contract_limits(
+    contract_id: str,
+    payload: dict[str, Any],
+    registry: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    registry = registry or load_agent_contracts_registry()
+    contract = _contract(registry, contract_id)
+    max_total = int(contract.get("max_total_json_bytes") or 0)
+    max_string = int(contract.get("max_string_bytes") or 0)
+    max_list = int(contract.get("max_list_items") or 0)
+    sanitize_overflow = contract_id != "context_overflow_recovery.v1"
+    out = _enforce_value_limits(deepcopy(payload), max_string, max_list if max_list > 0 else -1, sanitize_overflow)
+    if not isinstance(out, dict) or max_total <= 0 or _json_bytes(out) <= max_total:
+        return out if isinstance(out, dict) else dict(payload)
+
+    for keep, string_cap, list_cap in ((16, 2048, 16), (8, 1024, 8), (5, 512, 8)):
+        if contract_id == "context_pack_response.v1":
+            _compact_context_pack_payload(out, keep)
+        elif contract_id == "agent_preflight_response.v1":
+            _compact_preflight_payload(out, keep)
+        elif contract_id == "policy_context_package.v1":
+            _compact_policy_payload(out, keep)
+        out = _enforce_value_limits(
+            out,
+            min(max_string, string_cap) if max_string else string_cap,
+            min(max_list, list_cap) if max_list else list_cap,
+            sanitize_overflow,
+        )
+        if _json_bytes(out) <= max_total:
+            return out
+    return out
+
+
 def validate_agent_contract_payload(
     contract_id: str,
     payload: Any,
@@ -190,6 +386,26 @@ def validate_agent_contract_payload(
                     }
                 )
 
+    max_total = int(contract.get("max_total_json_bytes") or 0)
+    if max_total > 0:
+        actual = _json_bytes(payload)
+        if actual > max_total:
+            findings.append(
+                {
+                    "reason": "json_bytes_exceed_contract",
+                    "bytes": actual,
+                    "max_bytes": max_total,
+                    "contract_id": contract_id,
+                    "payload_kind": contract.get("payload_kind"),
+                }
+            )
+
+    max_string = int(contract.get("max_string_bytes") or 0)
+    findings.extend(_walk_string_bytes(payload, max_string, contract_id))
+
+    max_list = int(contract.get("max_list_items") or 0)
+    findings.extend(_walk_list_items(payload, max_list, contract_id))
+
     max_bytes = contract.get("max_bytes_by_path")
     if isinstance(max_bytes, dict):
         for dotted_path, raw_max in max_bytes.items():
@@ -225,7 +441,7 @@ def validate_agent_contract_payload(
 def contract_metadata(contract_id: str, registry: dict[str, Any] | None = None) -> dict[str, Any]:
     registry = registry or load_agent_contracts_registry()
     contract = _contract(registry, contract_id)
-    return {
+    metadata = {
         "registry_id": str(registry.get("registry_id") or "contextlattice_agent_output_contracts"),
         "registry_version": int(registry.get("registry_version") or 0),
         "schema_id": contract_id,
@@ -235,6 +451,13 @@ def contract_metadata(contract_id: str, registry: dict[str, Any] | None = None)
         "forbidden_fields": [str(item) for item in contract.get("forbidden_fields") or []],
         "validation": {"status": "pending", "errors": []},
     }
+    for key in ("max_total_json_bytes", "max_string_bytes", "max_list_items"):
+        value = int(contract.get(key) or 0)
+        if value > 0:
+            metadata[key] = value
+    if isinstance(contract.get("max_bytes_by_path"), dict):
+        metadata["max_bytes_by_path"] = deepcopy(contract["max_bytes_by_path"])
+    return metadata
 
 
 def stamp_validation(metadata: dict[str, Any], findings: list[dict[str, Any]]) -> dict[str, Any]:
@@ -261,6 +484,10 @@ def attach_format_contract(
     stamped = dict(payload)
     metadata = contract_metadata(contract_id, registry)
     stamped["format_contract"] = metadata
+    stamped = enforce_contract_limits(contract_id, stamped, registry)
+    findings = validate_agent_contract_payload(contract_id, stamped, registry)
+    stamped["format_contract"] = stamp_validation(metadata, findings)
+    stamped = enforce_contract_limits(contract_id, stamped, registry)
     findings = validate_agent_contract_payload(contract_id, stamped, registry)
     stamped["format_contract"] = stamp_validation(metadata, findings)
     return stamped
@@ -269,10 +496,14 @@ def attach_format_contract(
 def preflight_contracts_summary(findings: list[dict[str, Any]] | None = None) -> dict[str, Any]:
     registry = load_agent_contracts_registry()
     errors = findings or []
+    preflight_contract = _contract(registry, "agent_preflight_response.v1")
     return {
         "registry_id": str(registry.get("registry_id") or "contextlattice_agent_output_contracts"),
         "registry_version": int(registry.get("registry_version") or 0),
         "contracts": agent_contract_ids(registry),
+        "max_total_json_bytes": int(preflight_contract.get("max_total_json_bytes") or 0),
+        "max_string_bytes": int(preflight_contract.get("max_string_bytes") or 0),
+        "max_list_items": int(preflight_contract.get("max_list_items") or 0),
         "validation": {
             "status": "failed" if errors else "passed",
             "errors": errors[:12],
diff --git a/scripts/agent_hooks/contextlattice_post_compaction_read.sh b/scripts/agent_hooks/contextlattice_post_compaction_read.sh
index 19e42a36..574c4b4b 100755
--- a/scripts/agent_hooks/contextlattice_post_compaction_read.sh
+++ b/scripts/agent_hooks/contextlattice_post_compaction_read.sh
@@ -4,20 +4,86 @@ set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 # shellcheck source=common.sh
 source "${SCRIPT_DIR}/common.sh"
+REPO_ROOT="$(repo_root)"
+
+emit_codex_postcompact_output() {
+  local status="${1:-0}"
+  python3 -c '
+import json
+import os
+import sys
+
+try:
+    status = int(sys.argv[1])
+except Exception:
+    status = 1
+raw = sys.stdin.read()
+payload = {}
+parse_error = None
+if raw.strip():
+    try:
+        parsed = json.loads(raw)
+        if isinstance(parsed, dict):
+            payload = parsed
+        else:
+            parse_error = "non_object_output"
+    except Exception as exc:
+        parse_error = str(exc)
+
+ok = status == 0 and parse_error is None and bool(payload.get("ok", True))
+out = {
+    "continue": True,
+    "suppressOutput": ok,
+}
+if not ok:
+    detail = parse_error or payload.get("error") or payload.get("reason") or f"exit_status_{status}"
+    detail = " ".join(str(detail).split())[:240]
+    out["systemMessage"] = f"ContextLattice PostCompact checkpoint read did not complete cleanly: {detail}"
+repo_root = sys.argv[2] if len(sys.argv) > 2 else ""
+if repo_root:
+    sys.path.insert(0, os.path.join(repo_root, "scripts"))
+try:
+    from agent_contracts import enforce_contract_limits
+    out = enforce_contract_limits("codex_compact_hook_stdout.v1", out)
+except Exception:
+    pass
+try:
+    max_bytes = int(os.getenv("CONTEXTLATTICE_POSTCOMPACT_OUTPUT_MAX_BYTES", "4096") or "4096")
+except Exception:
+    max_bytes = 4096
+max_bytes = max(256, min(max_bytes, 65536))
+encoded = json.dumps(out, separators=(",", ":"))
+if len(encoded.encode("utf-8")) > max_bytes:
+    out = {
+        "continue": True,
+        "suppressOutput": False,
+        "systemMessage": "ContextLattice PostCompact checkpoint output exceeded local hook budget and was truncated.",
+    }
+    encoded = json.dumps(out, separators=(",", ":"))
+print(encoded)
+' "$status" "$REPO_ROOT" || printf '%s\n' '{"continue":true,"suppressOutput":false,"systemMessage":"ContextLattice PostCompact checkpoint output emitter failed."}'
+}
+
+if [[ "${CONTEXTLATTICE_POSTCOMPACT_SCHEMA_SMOKE:-}" == "1" ]]; then
+  printf '%s' '{"ok":true}' | emit_codex_postcompact_output 0
+  exit 0
+fi
 
 contextlattice_env
 project="${CONTEXTLATTICE_PROJECT:-contextlattice}"
 topic="${CONTEXTLATTICE_COMPACTION_TOPIC_PATH:-runbooks/context-compaction-handoff}"
 query="${CONTEXTLATTICE_COMPACTION_QUERY:-}"
-stdin_payload=""
-if [[ ! -t 0 ]]; then
-  stdin_payload="$(cat || true)"
-fi
-if [[ -z "${query}" && -n "${stdin_payload}" ]]; then
-  query="$(printf '%s' "${stdin_payload}" | python3 "${SCRIPT_DIR}/../agent/compaction-handoff-payload" --query)"
+if [[ -z "${query}" && ! -t 0 ]]; then
+  set +e
+  query="$(python3 "${SCRIPT_DIR}/../agent/compaction-handoff-payload" --query)"
+  query_status=$?
+  set -e
+  if [[ "$query_status" -ne 0 ]]; then
+    query=""
+  fi
 fi
 query="${query:-context compaction handoff mission objective goal blockers next actions}"
-timeout="${CONTEXTLATTICE_HOOK_TIMEOUT_SECS:-30}"
+timeout="${CONTEXTLATTICE_HOOK_TIMEOUT_SECS:-200}"
 base="${CONTEXTLATTICE_ORCHESTRATOR_URL%/}"
 
 payload="$(python3 - "$project" "$topic" "$query" <<'PY'
@@ -37,16 +103,30 @@ print(json.dumps({
 PY
 )"
 
+set +e
 out="$(curl_json POST "${base}/memory/search" "$payload" "$timeout")"
-python3 - "$out" <<'PY'
+curl_status=$?
+set -e
+if [[ "$curl_status" -ne 0 ]]; then
+  printf '{"ok":false,"reason":"memory_search_failed"}' | emit_codex_postcompact_output "$curl_status"
+  exit 0
+fi
+
+set +e
+post_out="$(python3 - "$out" <<'PY'
 import json, sys
 p = json.loads(sys.argv[1])
 results = p.get("results") or []
-print(json.dumps({
+out = {
   "ok": bool(results) and not bool(p.get("degraded")),
   "hook": "post_compaction_read",
   "result_count": len(results),
   "first_file": results[0].get("file") if results and isinstance(results[0], dict) else None,
   "degraded": bool(p.get("degraded")),
-}, separators=(",",":")))
+}
+print(json.dumps(out, separators=(",",":")))
 PY
+)"
+post_status=$?
+set -e
+printf '%s' "$post_out" | emit_codex_postcompact_output "$post_status"
diff --git a/scripts/agent_hooks/contextlattice_pre_compaction_write.sh b/scripts/agent_hooks/contextlattice_pre_compaction_write.sh
index e266ebe5..36284f4d 100755
--- a/scripts/agent_hooks/contextlattice_pre_compaction_write.sh
+++ b/scripts/agent_hooks/contextlattice_pre_compaction_write.sh
@@ -4,10 +4,63 @@ set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_ROOT="$(cd "${SCRIPT_DIR}/../.." && pwd)"
 
-stdin_payload=""
-if [[ ! -t 0 ]]; then
-  stdin_payload="$(cat || true)"
-fi
+emit_codex_precompact_output() {
+  local status="${1:-0}"
+  python3 -c '
+import json
+import os
+import sys
+
+try:
+    status = int(sys.argv[1])
+except Exception:
+    status = 1
+raw = sys.stdin.read()
+payload = {}
+parse_error = None
+if raw.strip():
+    try:
+        parsed = json.loads(raw)
+        if isinstance(parsed, dict):
+            payload = parsed
+        else:
+            parse_error = "non_object_output"
+    except Exception as exc:
+        parse_error = str(exc)
+
+ok = status == 0 and parse_error is None and bool(payload.get("ok", True))
+out = {
+    "continue": True,
+    "suppressOutput": ok,
+}
+if not ok:
+    detail = parse_error or payload.get("error") or payload.get("reason") or f"exit_status_{status}"
+    detail = " ".join(str(detail).split())[:240]
+    out["systemMessage"] = f"ContextLattice PreCompact checkpoint did not complete cleanly: {detail}"
+repo_root = sys.argv[2] if len(sys.argv) > 2 else ""
+if repo_root:
+    sys.path.insert(0, os.path.join(repo_root, "scripts"))
+try:
+    from agent_contracts import enforce_contract_limits
+    out = enforce_contract_limits("codex_compact_hook_stdout.v1", out)
+except Exception:
+    pass
+try:
+    max_bytes = int(os.getenv("CONTEXTLATTICE_PRECOMPACT_OUTPUT_MAX_BYTES", "4096") or "4096")
+except Exception:
+    max_bytes = 4096
+max_bytes = max(256, min(max_bytes, 65536))
+encoded = json.dumps(out, separators=(",", ":"))
+if len(encoded.encode("utf-8")) > max_bytes:
+    out = {
+        "continue": True,
+        "suppressOutput": False,
+        "systemMessage": "ContextLattice PreCompact checkpoint output exceeded local hook budget and was truncated.",
+    }
+    encoded = json.dumps(out, separators=(",", ":"))
+print(encoded)
+' "$status" "$REPO_ROOT" || printf '%s\n' '{"continue":true,"suppressOutput":false,"systemMessage":"ContextLattice PreCompact checkpoint output emitter failed."}'
+}
 
 summary="${1:-${CONTEXTLATTICE_COMPACTION_SUMMARY:-}}"
 summary="${summary:-continue objective-aligned execution after context compaction}"
@@ -15,13 +68,30 @@ project="${CONTEXTLATTICE_PROJECT:-contextlattice}"
 topic="${CONTEXTLATTICE_COMPACTION_TOPIC_PATH:-runbooks/context-compaction-handoff}"
 mode="${CONTEXTLATTICE_COMPACTION_RETRIEVAL_MODE:-balanced}"
 query="${CONTEXTLATTICE_COMPACTION_QUERY:-context compaction handoff mission objective goal blockers next actions}"
-handoff_payload="$(printf '%s' "${stdin_payload}" | python3 "${REPO_ROOT}/scripts/agent/compaction-handoff-payload" --fallback-summary "${summary}" --summary)"
+export CONTEXTLATTICE_CLIENT_TIMEOUT_SECS="${CONTEXTLATTICE_CLIENT_TIMEOUT_SECS:-${CONTEXTLATTICE_HOOK_TIMEOUT_SECS:-200}}"
+
+if [[ "${CONTEXTLATTICE_PRECOMPACT_SCHEMA_SMOKE:-}" == "1" ]]; then
+  printf '%s' '{"ok":true}' | emit_codex_precompact_output 0
+  exit 0
+fi
+
+set +e
+handoff_payload="$(python3 "${REPO_ROOT}/scripts/agent/compaction-handoff-payload" --fallback-summary "${summary}" --summary)"
+payload_status=$?
+set -e
+if [[ "$payload_status" -ne 0 ]]; then
+  printf '{"ok":false,"reason":"handoff_payload_failed"}' | emit_codex_precompact_output "$payload_status"
+  exit 0
+fi
 
-python3 "${REPO_ROOT}/scripts/agent_orchestration.py" \
+set +e
+orchestration_out="$(python3 "${REPO_ROOT}/scripts/agent_orchestration.py" \
   compaction-handoff \
   "$project" \
   "$handoff_payload" \
   "$topic" \
   "$mode" \
-  "$query" \
-  | python3 -c 'import json,sys; p=json.load(sys.stdin); print(json.dumps({"ok": bool(p.get("ok", True)), "hook": "pre_compaction_write", "file": p.get("file"), "topic_path": p.get("topic_path"), "session_id": (p.get("handoff_metadata") or {}).get("session_id")}, separators=(",",":")))'
+  "$query")"
+orchestration_status=$?
+set -e
+printf '%s' "$orchestration_out" | emit_codex_precompact_output "$orchestration_status"
diff --git a/services/gateway-go/agent_boundary_limits.go b/services/gateway-go/agent_boundary_limits.go
new file mode 100644
index 00000000..f6d91415
--- /dev/null
+++ b/services/gateway-go/agent_boundary_limits.go
@@ -0,0 +1,554 @@
+package main
+
+import (
+	"encoding/json"
+	"sort"
+	"strings"
+	"unicode/utf8"
+)
+
+type agentBoundaryLimits struct {
+	MaxTotalJSONBytes int
+	MaxStringBytes    int
+	MaxListItems      int
+}
+
+type agentBoundaryStats struct {
+	StringsClipped          int
+	ListsClipped            int
+	OptionalFieldsCompacted int
+	TotalPasses             int
+}
+
+func agentBoundaryLimitsFromContract(contract map[string]any) agentBoundaryLimits {
+	if contract == nil {
+		return agentBoundaryLimits{}
+	}
+	return agentBoundaryLimits{
+		MaxTotalJSONBytes: anyToInt(contract["max_total_json_bytes"], 0),
+		MaxStringBytes:    anyToInt(contract["max_string_bytes"], 0),
+		MaxListItems:      anyToInt(contract["max_list_items"], 0),
+	}
+}
+
+func agentBoundaryLimitsForContract(contractID string) agentBoundaryLimits {
+	registry, err := loadAgentContractsRegistry()
+	if err != nil {
+		return agentBoundaryLimits{}
+	}
+	return agentBoundaryLimitsFromContract(agentContract(registry, contractID))
+}
+
+func enforceAgentBoundaryContract(contractID string, payload map[string]any) agentBoundaryStats {
+	limits := agentBoundaryLimitsForContract(contractID)
+	stats := agentBoundaryStats{}
+	if limits.MaxTotalJSONBytes <= 0 && limits.MaxStringBytes <= 0 && limits.MaxListItems <= 0 {
+		return stats
+	}
+	sanitizeOverflow := contractID != GeneratedAgentContractContextOverflowRecoveryV1
+	applyAgentBoundaryLimits(payload, limits.MaxStringBytes, positiveListLimit(limits.MaxListItems), sanitizeOverflow, &stats)
+	if limits.MaxTotalJSONBytes > 0 {
+		stats.TotalPasses += shrinkAgentBoundaryPayload(contractID, payload, limits, sanitizeOverflow, &stats)
+	}
+	return stats
+}
+
+func positiveListLimit(value int) int {
+	if value <= 0 {
+		return -1
+	}
+	return value
+}
+
+func applyAgentBoundaryLimits(value any, maxStringBytes int, maxListItems int, sanitizeOverflow bool, stats *agentBoundaryStats) any {
+	switch typed := value.(type) {
+	case map[string]any:
+		for key, item := range typed {
+			typed[key] = applyAgentBoundaryLimits(item, maxStringBytes, maxListItems, sanitizeOverflow, stats)
+		}
+		return typed
+	case []any:
+		items := typed
+		if maxListItems >= 0 && len(items) > maxListItems {
+			items = items[:maxListItems]
+			if stats != nil {
+				stats.ListsClipped++
+			}
+		}
+		for idx, item := range items {
+			items[idx] = applyAgentBoundaryLimits(item, maxStringBytes, maxListItems, sanitizeOverflow, stats)
+		}
+		return items
+	case []string:
+		items := make([]any, 0, len(typed))
+		for _, item := range typed {
+			items = append(items, item)
+		}
+		return applyAgentBoundaryLimits(items, maxStringBytes, maxListItems, sanitizeOverflow, stats)
+	case string:
+		text := typed
+		if sanitizeOverflow {
+			text = sanitizeProviderOverflowText(text)
+		}
+		if maxStringBytes > 0 && len([]byte(text)) > maxStringBytes {
+			text = clipUTF8Bytes(text, maxStringBytes)
+			if stats != nil {
+				stats.StringsClipped++
+			}
+		}
+		return text
+	default:
+		return value
+	}
+}
+
+func sanitizeProviderOverflowText(value string) string {
+	lower := strings.ToLower(value)
+	for _, pattern := range []string{
+		"array_above_max_length",
+		"context length exceeded",
+		"maximum context length",
+		"max context length",
+		"input array is too long",
+		"oversized input",
+	} {
+		if strings.Contains(lower, pattern) {
+			return "ContextLattice boundary reduced an oversized provider input before returning this payload."
+		}
+	}
+	return value
+}
+
+func clipUTF8Bytes(value string, maxBytes int) string {
+	if maxBytes <= 0 || len([]byte(value)) <= maxBytes {
+		return value
+	}
+	const suffix = "... [truncated]"
+	if maxBytes <= len(suffix) {
+		raw := []byte(value)
+		limit := maxBytes
+		for limit > 0 && !utf8.Valid(raw[:limit]) {
+			limit--
+		}
+		return string(raw[:limit])
+	}
+	limit := maxBytes - len(suffix)
+	raw := []byte(value)
+	if limit > len(raw) {
+		limit = len(raw)
+	}
+	for limit > 0 && !utf8.Valid(raw[:limit]) {
+		limit--
+	}
+	return string(raw[:limit]) + suffix
+}
+
+func jsonByteLen(value any) int {
+	encoded, err := json.Marshal(value)
+	if err != nil {
+		return 0
+	}
+	return len(encoded)
+}
+
+func validateAgentBoundaryStringBytes(value any, maxBytes int, path string, contractID string) []map[string]any {
+	if maxBytes <= 0 {
+		return nil
+	}
+	findings := []map[string]any{}
+	switch typed := value.(type) {
+	case map[string]any:
+		keys := make([]string, 0, len(typed))
+		for key := range typed {
+			keys = append(keys, key)
+		}
+		sort.Strings(keys)
+		for _, key := range keys {
+			nextPath := key
+			if path != "" {
+				nextPath = path + "." + key
+			}
+			findings = append(findings, validateAgentBoundaryStringBytes(typed[key], maxBytes, nextPath, contractID)...)
+		}
+	case []any:
+		for idx, item := range typed {
+			if idx >= 512 {
+				break
+			}
+			nextPath := path + "[]"
+			findings = append(findings, validateAgentBoundaryStringBytes(item, maxBytes, nextPath, contractID)...)
+		}
+	case string:
+		actual := len([]byte(typed))
+		if actual > maxBytes {
+			findings = append(findings, map[string]any{
+				"reason":      "string_bytes_exceed_contract",
+				"path":        path,
+				"bytes":       actual,
+				"max_bytes":   maxBytes,
+				"contract_id": contractID,
+			})
+		}
+	}
+	return findings
+}
+
+func validateAgentBoundaryListItems(value any, maxItems int, path string, contractID string) []map[string]any {
+	if maxItems <= 0 {
+		return nil
+	}
+	findings := []map[string]any{}
+	switch typed := value.(type) {
+	case map[string]any:
+		keys := make([]string, 0, len(typed))
+		for key := range typed {
+			keys = append(keys, key)
+		}
+		sort.Strings(keys)
+		for _, key := range keys {
+			nextPath := key
+			if path != "" {
+				nextPath = path + "." + key
+			}
+			findings = append(findings, validateAgentBoundaryListItems(typed[key], maxItems, nextPath, contractID)...)
+		}
+	case []any:
+		if len(typed) > maxItems {
+			findings = append(findings, map[string]any{
+				"reason":      "list_items_exceed_contract",
+				"path":        path,
+				"items":       len(typed),
+				"max_items":   maxItems,
+				"contract_id": contractID,
+			})
+		}
+		for idx, item := range typed {
+			if idx >= 512 {
+				break
+			}
+			nextPath := path + "[]"
+			findings = append(findings, validateAgentBoundaryListItems(item, maxItems, nextPath, contractID)...)
+		}
+	}
+	return findings
+}
+
+func shrinkAgentBoundaryPayload(
+	contractID string,
+	payload map[string]any,
+	limits agentBoundaryLimits,
+	sanitizeOverflow bool,
+	stats *agentBoundaryStats,
+) int {
+	if jsonByteLen(payload) <= limits.MaxTotalJSONBytes {
+		return 0
+	}
+	passes := 0
+	shrink := func(maxStringBytes int, maxListItems int) bool {
+		passes++
+		applyAgentBoundaryLimits(payload, maxStringBytes, maxListItems, sanitizeOverflow, stats)
+		return jsonByteLen(payload) <= limits.MaxTotalJSONBytes
+	}
+
+	switch contractID {
+	case contextPackResponseContractID:
+		compactContextPackResponseBoundary(payload, 16, stats)
+	case agentPreflightResponseContractID:
+		compactPreflightResponseBoundary(payload, 16, stats)
+	case policyContextPackageContractID:
+		compactPolicyContextPackageBoundary(payload, 8, stats)
+	}
+	if shrink(minPositive(limits.MaxStringBytes, 2048), minPositive(limits.MaxListItems, 16)) {
+		return passes
+	}
+
+	switch contractID {
+	case contextPackResponseContractID:
+		dropContextPackDebugBoundary(payload, stats)
+		compactContextPackResponseBoundary(payload, 8, stats)
+	case agentPreflightResponseContractID:
+		compactPreflightResponseBoundary(payload, 8, stats)
+		dropPreflightOptionalBoundary(payload, stats)
+	case policyContextPackageContractID:
+		compactPolicyContextPackageBoundary(payload, 6, stats)
+	}
+	if shrink(minPositive(limits.MaxStringBytes, 1024), minPositive(limits.MaxListItems, 8)) {
+		return passes
+	}
+
+	switch contractID {
+	case contextPackResponseContractID:
+		compactContextPackResponseBoundary(payload, 3, stats)
+	case agentPreflightResponseContractID:
+		compactPreflightResponseBoundary(payload, 4, stats)
+	case policyContextPackageContractID:
+		compactPolicyContextPackageBoundary(payload, 5, stats)
+	}
+	if shrink(minPositive(limits.MaxStringBytes, 512), minPositive(limits.MaxListItems, 8)) {
+		return passes
+	}
+
+	switch contractID {
+	case contextPackResponseContractID:
+		forceMinimalContextPackResponseBoundary(payload, stats)
+	case agentPreflightResponseContractID:
+		forceMinimalPreflightResponseBoundary(payload, stats)
+	case policyContextPackageContractID:
+		compactPolicyContextPackageBoundary(payload, 5, stats)
+	}
+	shrink(minPositive(limits.MaxStringBytes, 384), minPositive(limits.MaxListItems, 8))
+	return passes
+}
+
+func minPositive(value int, capValue int) int {
+	if value <= 0 {
+		return capValue
+	}
+	if capValue <= 0 {
+		return value
+	}
+	return minInt(value, capValue)
+}
+
+func trimBoundaryList(value any, keep int, stats *agentBoundaryStats) any {
+	items, ok := value.([]any)
+	if !ok {
+		return value
+	}
+	if keep < 0 {
+		keep = 0
+	}
+	if len(items) <= keep {
+		return items
+	}
+	if stats != nil {
+		stats.ListsClipped++
+	}
+	return items[:keep]
+}
+
+func compactContextPackLists(pack map[string]any, keep int, stats *agentBoundaryStats) {
+	if pack == nil {
+		return
+	}
+	for _, key := range []string{
+		"facts",
+		"numericFacts",
+		"numeric_facts",
+		"citations",
+		"results",
+		"relevantDecisions",
+		"relevant_decisions",
+		"filesToRead",
+		"files_to_read",
+		"filesToAvoid",
+		"files_to_avoid",
+		"capabilitiesToUse",
+		"capabilities_to_use",
+		"runbooks",
+		"knownFailureModes",
+		"known_failure_modes",
+		"commands",
+		"acceptanceCriteria",
+		"acceptance_criteria",
+	} {
+		if _, ok := pack[key]; ok {
+			pack[key] = trimBoundaryList(pack[key], keep, stats)
+		}
+	}
+	for _, key := range []string{"query", "retrievalMode", "retrieval_mode", "retrievalIntent", "retrieval_intent"} {
+		if text := strings.TrimSpace(anyToString(pack[key])); text != "" {
+			pack[key] = clipUTF8Bytes(sanitizeProviderOverflowText(text), 1000)
+		}
+	}
+	for _, key := range []string{"sourceCoverage", "source_coverage"} {
+		if coverage, ok := pack[key].(map[string]any); ok {
+			compactSourceCoverageBoundary(coverage, keep, stats)
+		}
+	}
+}
+
+func compactSourceCoverageBoundary(coverage map[string]any, keep int, stats *agentBoundaryStats) {
+	if coverage == nil {
+		return
+	}
+	for _, key := range []string{
+		"configured",
+		"queried",
+		"returned",
+		"pending",
+		"warming",
+		"timed_out",
+		"failed",
+		"budget_exceeded",
+		"skipped",
+		"continuation_unavailable",
+		"sync_fallback_slow_sources",
+		"async_warm_slow_sources",
+		"fail_open_continuation_sources",
+	} {
+		if _, ok := coverage[key]; ok {
+			coverage[key] = trimBoundaryList(coverage[key], keep, stats)
+		}
+	}
+}
+
+func compactContextPackResponseBoundary(payload map[string]any, keep int, stats *agentBoundaryStats) {
+	compactContextPackLists(anyMap(payload["context_pack"]), keep, stats)
+	compactSourceCoverageBoundary(anyMap(payload["source_coverage"]), keep, stats)
+	if warnings, ok := payload["warnings"]; ok {
+		payload["warnings"] = trimBoundaryList(warnings, minInt(keep, 8), stats)
+	}
+}
+
+func dropContextPackDebugBoundary(payload map[string]any, stats *agentBoundaryStats) {
+	if _, ok := payload["retrieval"]; ok {
+		payload["retrieval"] = map[string]any{"omitted_by_boundary": true}
+		if stats != nil {
+			stats.OptionalFieldsCompacted++
+		}
+	}
+}
+
+func compactContextPackValueBoundary(value any, keep int, stats *agentBoundaryStats) any {
+	object, ok := value.(map[string]any)
+	if !ok {
+		return value
+	}
+	compactContextPackResponseBoundary(object, keep, stats)
+	if nested, ok := object["payload"].(map[string]any); ok {
+		compactContextPackResponseBoundary(nested, keep, stats)
+	}
+	dropContextPackDebugBoundary(object, stats)
+	return object
+}
+
+func compactSearchBoundary(value any, stats *agentBoundaryStats) any {
+	object, ok := value.(map[string]any)
+	if !ok {
+		return value
+	}
+	out := map[string]any{
+		"omitted_by_boundary": true,
+		"result_count":        resultCount(object),
+	}
+	for _, key := range []string{"ok", "degraded", "result_state", "retrieval_mode", "retrieval_intent", "traffic_class", "status", "error"} {
+		if value, ok := object[key]; ok {
+			out[key] = value
+		}
+	}
+	if stats != nil {
+		stats.OptionalFieldsCompacted++
+	}
+	return out
+}
+
+func compactPreflightResponseBoundary(payload map[string]any, keep int, stats *agentBoundaryStats) {
+	for _, key := range []string{"context_pack", "mission_context_pack", "mission_pack"} {
+		if value, ok := payload[key]; ok {
+			payload[key] = compactContextPackValueBoundary(value, keep, stats)
+		}
+	}
+	if policy, ok := payload["policy_context_package"].(map[string]any); ok {
+		compactPolicyContextPackageBoundary(policy, maxInt(keep, 5), stats)
+	}
+	for _, key := range []string{"scoped_search", "broadened_search"} {
+		if value, ok := payload[key]; ok {
+			payload[key] = compactSearchBoundary(value, stats)
+		}
+	}
+}
+
+func dropPreflightOptionalBoundary(payload map[string]any, stats *agentBoundaryStats) {
+	for _, key := range []string{"status", "health", "agent_profile"} {
+		if _, ok := payload[key]; ok {
+			payload[key] = map[string]any{"omitted_by_boundary": true}
+			if stats != nil {
+				stats.OptionalFieldsCompacted++
+			}
+		}
+	}
+}
+
+func compactPolicyContextPackageBoundary(policy map[string]any, keep int, stats *agentBoundaryStats) {
+	if policy == nil {
+		return
+	}
+	for _, key := range []string{"query", "mission", "objective", "goal"} {
+		if text := strings.TrimSpace(anyToString(policy[key])); text != "" {
+			policy[key] = clipUTF8Bytes(sanitizeProviderOverflowText(text), 2000)
+		}
+	}
+	if evidence, ok := policy["evidence"].(map[string]any); ok {
+		for _, key := range []string{"primary_facts", "mission_facts"} {
+			if _, ok := evidence[key]; ok {
+				evidence[key] = trimBoundaryList(evidence[key], keep, stats)
+			}
+		}
+		if text := strings.TrimSpace(anyToString(evidence["mission_pack_error"])); text != "" {
+			evidence["mission_pack_error"] = clipUTF8Bytes(sanitizeProviderOverflowText(text), 1000)
+		}
+	}
+	if handoff, ok := policy["handoff"].(map[string]any); ok {
+		if text := strings.TrimSpace(anyToString(handoff["handoff_prompt"])); text != "" {
+			handoff["handoff_prompt"] = clipUTF8Bytes(sanitizeProviderOverflowText(text), 4000)
+		}
+	}
+}
+
+func forceMinimalContextPackResponseBoundary(payload map[string]any, stats *agentBoundaryStats) {
+	sourceCoverage := anyMap(payload["source_coverage"])
+	payload["context_pack"] = minimalContextPackBoundary(anyMap(payload["context_pack"]))
+	payload["source_coverage"] = minimalSourceCoverageBoundary(sourceCoverage)
+	payload["warnings"] = []any{"ContextLattice context pack was clipped to the output boundary budget."}
+	delete(payload, "retrieval")
+	if stats != nil {
+		stats.OptionalFieldsCompacted++
+	}
+}
+
+func minimalContextPackBoundary(existing map[string]any) map[string]any {
+	query := strings.TrimSpace(anyToString(existing["query"]))
+	return map[string]any{
+		"query":               clipUTF8Bytes(sanitizeProviderOverflowText(query), 1000),
+		"facts":               []any{},
+		"numericFacts":        []any{},
+		"numeric_facts":       []any{},
+		"citations":           []any{},
+		"results":             []any{},
+		"relevantDecisions":   []any{},
+		"relevant_decisions":  []any{},
+		"filesToRead":         []any{},
+		"files_to_read":       []any{},
+		"filesToAvoid":        []any{},
+		"files_to_avoid":      []any{},
+		"capabilitiesToUse":   []any{},
+		"capabilities_to_use": []any{},
+		"runbooks":            []any{},
+		"knownFailureModes":   []any{},
+		"known_failure_modes": []any{},
+		"commands":            []any{},
+		"acceptanceCriteria":  []any{},
+		"acceptance_criteria": []any{},
+	}
+}
+
+func minimalSourceCoverageBoundary(existing map[string]any) map[string]any {
+	return map[string]any{
+		"configured": anyToStringList(existing["configured"], 8),
+		"returned":   anyToStringList(existing["returned"], 8),
+		"complete":   anyToBool(existing["complete"]),
+	}
+}
+
+func forceMinimalPreflightResponseBoundary(payload map[string]any, stats *agentBoundaryStats) {
+	dropPreflightOptionalBoundary(payload, stats)
+	payload["scoped_search"] = compactSearchBoundary(payload["scoped_search"], stats)
+	payload["broadened_search"] = compactSearchBoundary(payload["broadened_search"], stats)
+	payload["context_pack"] = compactContextPackValueBoundary(payload["context_pack"], 1, stats)
+	payload["mission_context_pack"] = map[string]any{"omitted_by_boundary": true}
+	payload["mission_pack"] = map[string]any{"omitted_by_boundary": true}
+	if policy, ok := payload["policy_context_package"].(map[string]any); ok {
+		compactPolicyContextPackageBoundary(policy, 5, stats)
+	}
+}
diff --git a/services/gateway-go/agent_contracts.go b/services/gateway-go/agent_contracts.go
index 40904805..1b739097 100644
--- a/services/gateway-go/agent_contracts.go
+++ b/services/gateway-go/agent_contracts.go
@@ -186,7 +186,7 @@ func contractMetadata(contractID string) map[string]any {
 	if mode == "" {
 		mode = "json_object"
 	}
-	return map[string]any{
+	metadata := map[string]any{
 		"registry_id":          registry.RegistryID,
 		"registry_version":     registry.RegistryVersion,
 		"schema_id":            contractID,
@@ -199,6 +199,20 @@ func contractMetadata(contractID string) map[string]any {
 			"errors": []any{},
 		},
 	}
+	limits := agentBoundaryLimitsFromContract(contract)
+	if limits.MaxTotalJSONBytes > 0 {
+		metadata["max_total_json_bytes"] = limits.MaxTotalJSONBytes
+	}
+	if limits.MaxStringBytes > 0 {
+		metadata["max_string_bytes"] = limits.MaxStringBytes
+	}
+	if limits.MaxListItems > 0 {
+		metadata["max_list_items"] = limits.MaxListItems
+	}
+	if maxBytesByPath, ok := contract["max_bytes_by_path"].(map[string]any); ok && len(maxBytesByPath) > 0 {
+		metadata["max_bytes_by_path"] = cloneContractMap(maxBytesByPath)
+	}
+	return metadata
 }
 
 func stampContractValidation(metadata map[string]any, findings []map[string]any) map[string]any {
@@ -269,6 +283,18 @@ func preflightContractsSummary(findings []map[string]any) map[string]any {
 		"registry_id":      registryID,
 		"registry_version": registryVersion,
 		"contracts":        contractIDs,
+		"max_total_json_bytes": func() int {
+			limits := agentBoundaryLimitsForContract(agentPreflightResponseContractID)
+			return limits.MaxTotalJSONBytes
+		}(),
+		"max_string_bytes": func() int {
+			limits := agentBoundaryLimitsForContract(agentPreflightResponseContractID)
+			return limits.MaxStringBytes
+		}(),
+		"max_list_items": func() int {
+			limits := agentBoundaryLimitsForContract(agentPreflightResponseContractID)
+			return limits.MaxListItems
+		}(),
 		"validation": map[string]any{
 			"status": status,
 			"errors": errors,
@@ -277,9 +303,14 @@ func preflightContractsSummary(findings []map[string]any) map[string]any {
 }
 
 func attachPayloadFormatContract(contractID string, payload map[string]any, agentID string, lane string, endpoint string) map[string]any {
-	payload["format_contract"] = contractMetadata(contractID)
+	metadata := contractMetadata(contractID)
+	payload["format_contract"] = metadata
+	enforceAgentBoundaryContract(contractID, payload)
 	findings := validateAgentContractPayload(contractID, payload)
-	payload["format_contract"] = stampContractValidation(contractMetadata(contractID), findings)
+	payload["format_contract"] = stampContractValidation(metadata, findings)
+	enforceAgentBoundaryContract(contractID, payload)
+	findings = validateAgentContractPayload(contractID, payload)
+	payload["format_contract"] = stampContractValidation(metadata, findings)
 	recordAgentContractBoundary(agentID, contractID, lane, endpoint, findings)
 	return payload
 }
@@ -306,8 +337,12 @@ func attachWritebackFormatContract(payload map[string]any, item normalizedWrite,
 
 func attachAgentPreflightFormatContracts(payload map[string]any) map[string]any {
 	payload["format_contracts"] = preflightContractsSummary(nil)
+	enforceAgentBoundaryContract(agentPreflightResponseContractID, payload)
 	findings := validateAgentContractPayload(agentPreflightResponseContractID, payload)
 	payload["format_contracts"] = preflightContractsSummary(findings)
+	enforceAgentBoundaryContract(agentPreflightResponseContractID, payload)
+	findings = validateAgentContractPayload(agentPreflightResponseContractID, payload)
+	payload["format_contracts"] = preflightContractsSummary(findings)
 	recordAgentContractBoundary(anyToString(payload["agent_id"]), agentPreflightResponseContractID, "preflight", "/v1/agents/preflight", findings)
 	return payload
 }
@@ -493,6 +528,25 @@ func validateAgentContractPayload(contractID string, payload any) []map[string]a
 			}
 		}
 	}
+	limits := agentBoundaryLimitsFromContract(contract)
+	if limits.MaxTotalJSONBytes > 0 {
+		actual := jsonByteLen(object)
+		if actual > limits.MaxTotalJSONBytes {
+			findings = append(findings, map[string]any{
+				"reason":       "json_bytes_exceed_contract",
+				"bytes":        actual,
+				"max_bytes":    limits.MaxTotalJSONBytes,
+				"contract_id":  contractID,
+				"payload_kind": contract["payload_kind"],
+			})
+		}
+	}
+	if limits.MaxStringBytes > 0 {
+		findings = append(findings, validateAgentBoundaryStringBytes(object, limits.MaxStringBytes, "", contractID)...)
+	}
+	if limits.MaxListItems > 0 {
+		findings = append(findings, validateAgentBoundaryListItems(object, limits.MaxListItems, "", contractID)...)
+	}
 	if maxBytes, ok := contract["max_bytes_by_path"].(map[string]any); ok {
 		keys := sortedMapKeys(maxBytes)
 		for _, path := range keys {
diff --git a/services/gateway-go/agent_contracts_generated.go b/services/gateway-go/agent_contracts_generated.go
index e4f1d371..9abcd759 100644
--- a/services/gateway-go/agent_contracts_generated.go
+++ b/services/gateway-go/agent_contracts_generated.go
@@ -10,7 +10,7 @@ type GeneratedAgentContractRef struct {
 }
 
 const GeneratedAgentContractRegistryID = "contextlattice_agent_output_contracts"
-const GeneratedAgentContractRegistryVersion = 2
+const GeneratedAgentContractRegistryVersion = 3
 
 const GeneratedAgentContractA2aReadinessProfileV1 = "a2a_readiness_profile.v1"
 const GeneratedAgentContractAgentFlightRecorderEventV1 = "agent_flight_recorder_event.v1"
diff --git a/services/gateway-go/agent_contracts_test.go b/services/gateway-go/agent_contracts_test.go
index 2127da95..fe376edc 100644
--- a/services/gateway-go/agent_contracts_test.go
+++ b/services/gateway-go/agent_contracts_test.go
@@ -1,6 +1,7 @@
 package main
 
 import (
+	"encoding/json"
 	"reflect"
 	"sort"
 	"strings"
@@ -67,6 +68,7 @@ func TestPolicyContextPackageContractValidationPassesAndFails(t *testing.T) {
 		pack,
 		pack,
 		nil,
+		objectiveContext{},
 	)
 	format, ok := policy["format_contract"].(map[string]any)
 	if !ok {
@@ -101,7 +103,7 @@ func TestPolicyContextPackageContractValidationPassesAndFails(t *testing.T) {
 
 func TestAgentPreflightFormatContractValidationPassesAndFails(t *testing.T) {
 	pack := map[string]any{"context_pack": map[string]any{"facts": []any{}, "results": []any{}}}
-	policy := buildPolicyContextPackage("codex", "codex_gpt5_test", "contextlattice", "runbooks/codex-integration", "preflight", "fast", pack, pack, nil)
+	policy := buildPolicyContextPackage("codex", "codex_gpt5_test", "contextlattice", "runbooks/codex-integration", "preflight", "fast", pack, pack, nil, objectiveContext{})
 	response := attachAgentPreflightFormatContracts(map[string]any{
 		"ok":                     true,
 		"service":                "gateway-go",
@@ -172,6 +174,118 @@ func TestContextPackAndWritebackFormatContractsValidate(t *testing.T) {
 	}
 }
 
+func TestAgentBoundaryContractClipsOversizedContextPackPayload(t *testing.T) {
+	oversized := strings.Repeat("array_above_max_length context length exceeded ", 400)
+	items := make([]any, 0, 140)
+	for idx := 0; idx < 140; idx++ {
+		items = append(items, map[string]any{
+			"text":       oversized,
+			"summary":    oversized,
+			"file":       "notes/oversized.md",
+			"source":     "fixture",
+			"topic_path": "runbooks/boundary",
+		})
+	}
+	pack := map[string]any{
+		"facts":               items,
+		"numeric_facts":       items,
+		"citations":           items,
+		"results":             items,
+		"relevant_decisions":  items,
+		"files_to_read":       items,
+		"files_to_avoid":      items,
+		"capabilities_to_use": items,
+		"runbooks":            items,
+		"known_failure_modes": items,
+		"commands":            items,
+		"acceptance_criteria": items,
+	}
+	payload := attachContextPackFormatContract(map[string]any{
+		"ok":                 true,
+		"agent_id":           "codex_gpt5_test",
+		"context_pack":       pack,
+		"source_coverage":    map[string]any{"configured": items, "returned": items, "complete": true},
+		"retrieval":          map[string]any{"debug": oversized},
+		"writeback_required": true,
+	})
+	assertBoundaryContractPassed(t, contextPackResponseContractID, payload)
+	assertBoundaryJSONUnderLimit(t, contextPackResponseContractID, payload)
+	assertNoRawProviderOverflowShape(t, payload)
+	clippedPack, _ := payload["context_pack"].(map[string]any)
+	if results, _ := clippedPack["results"].([]any); len(results) > agentBoundaryLimitsForContract(contextPackResponseContractID).MaxListItems {
+		t.Fatalf("expected context_pack.results clipped, got %d", len(results))
+	}
+}
+
+func TestAgentBoundaryContractClipsOversizedPreflightPayload(t *testing.T) {
+	oversized := strings.Repeat("context length exceeded array_above_max_length ", 600)
+	item := map[string]any{"text": oversized, "summary": oversized, "source": "fixture", "file": "oversized.md"}
+	items := []any{}
+	for idx := 0; idx < 120; idx++ {
+		items = append(items, cloneContractMap(item))
+	}
+	pack := attachContextPackFormatContract(map[string]any{
+		"ok":                 true,
+		"agent_id":           "codex_gpt5_test",
+		"context_pack":       map[string]any{"facts": items, "results": items, "citations": items, "relevant_decisions": items, "files_to_read": items, "files_to_avoid": []any{}, "capabilities_to_use": []any{}, "runbooks": []any{}, "known_failure_modes": []any{}, "commands": []any{}, "acceptance_criteria": []any{}},
+		"source_coverage":    map[string]any{"configured": []any{"fixture"}, "returned": []any{"fixture"}, "complete": true},
+		"writeback_required": true,
+	})
+	policy := buildPolicyContextPackage("codex", "codex_gpt5_test", "contextlattice", "runbooks/codex-integration", oversized, "balanced", pack, pack, nil, objectiveContext{})
+	response := attachAgentPreflightFormatContracts(map[string]any{
+		"ok":                     true,
+		"service":                "gateway-go",
+		"agent":                  "codex",
+		"agent_id":               "codex_gpt5_test",
+		"project":                "contextlattice",
+		"query":                  oversized,
+		"topic_path":             "runbooks/codex-integration",
+		"retrieval_mode":         "balanced",
+		"status":                 map[string]any{"raw": oversized, "items": items},
+		"scoped_search":          map[string]any{"results": items, "degraded": false},
+		"broadened_search":       map[string]any{"results": items, "degraded": false},
+		"context_pack":           pack,
+		"mission_context_pack":   pack,
+		"policy_context_package": policy,
+	})
+	assertBoundaryContractPassed(t, agentPreflightResponseContractID, response)
+	assertBoundaryJSONUnderLimit(t, agentPreflightResponseContractID, response)
+	assertNoRawProviderOverflowShape(t, response)
+}
+
+func assertBoundaryContractPassed(t *testing.T, contractID string, payload map[string]any) {
+	t.Helper()
+	findings := validateAgentContractPayload(contractID, payload)
+	if len(findings) != 0 {
+		t.Fatalf("expected %s validation passed, got %#v", contractID, findings)
+	}
+}
+
+func assertBoundaryJSONUnderLimit(t *testing.T, contractID string, payload map[string]any) {
+	t.Helper()
+	limits := agentBoundaryLimitsForContract(contractID)
+	if limits.MaxTotalJSONBytes <= 0 {
+		t.Fatalf("expected %s to define max_total_json_bytes", contractID)
+	}
+	if size := jsonByteLen(payload); size > limits.MaxTotalJSONBytes {
+		t.Fatalf("expected %s JSON bytes <= %d, got %d", contractID, limits.MaxTotalJSONBytes, size)
+	}
+}
+
+func assertNoRawProviderOverflowShape(t *testing.T, payload any) {
+	t.Helper()
+	encoded, err := json.Marshal(payload)
+	if err != nil {
+		t.Fatalf("marshal payload: %v", err)
+	}
+	lower := strings.ToLower(string(encoded))
+	for _, forbidden := range []string{"array_above_max_length", "context length exceeded", "maximum context length"} {
+		if strings.Contains(lower, forbidden) {
+			t.Fatalf("payload still contains raw provider overflow phrase %q", forbidden)
+		}
+	}
+}
+
 func TestAgentContractTelemetryRecordsValidationReasons(t *testing.T) {
 	before := anyToInt(agentContractTelemetrySnapshot()["total"], 0)
 	recordAgentContractBoundary("codex_gpt5_test", writebackResultContractID, "writeback", "/memory/write", []map[string]any{{"reason": "missing_required_field"}})
diff --git a/services/gateway-go/main.go b/services/gateway-go/main.go
index 2c6b0ae4..6b682910 100644
--- a/services/gateway-go/main.go
+++ b/services/gateway-go/main.go
@@ -1886,6 +1886,9 @@ type agentPreflightRequest struct {
 	RetrievalMode string `json:"retrieval_mode"`
 	AgentID       string `json:"agent_id"`
 	Agent         string `json:"agent"`
+	Mission       string `json:"mission"`
+	Objective     string `json:"objective"`
+	Goal          string `json:"goal"`
 }
 
 type agentPreflightProfile struct {
@@ -2096,6 +2099,7 @@ func (s *server) agentPreflight(w http.ResponseWriter, r *http.Request, forcedAg
 	if strings.TrimSpace(reqBody.AgentID) == "" {
 		reqBody.AgentID = "codex_gpt5"
 	}
+	objectiveCtx := objectiveContextFromPreflightRequest(reqBody)
 
 	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
 	defer cancel()
@@ -2111,6 +2115,7 @@ func (s *server) agentPreflight(w http.ResponseWriter, r *http.Request, forcedAg
 		"include_grounding":       true,
 		"include_retrieval_debug": true,
 		"agent_id":                reqBody.AgentID,
+		"objective_context":       objectiveCtx.toMap(),
 	}
 	scopedPayload, scopedStatus, scopedErr := s.backendJSONRequest(
 		ctx,
@@ -2141,6 +2146,7 @@ func (s *server) agentPreflight(w http.ResponseWriter, r *http.Request, forcedAg
 			"include_grounding":       true,
 			"include_retrieval_debug": true,
 			"agent_id":                reqBody.AgentID,
+			"objective_context":       objectiveCtx.toMap(),
 		}
 		broadenedPayload, broadenedStatus, broadenedErr = s.backendJSONRequest(
 			ctx,
@@ -2158,6 +2164,7 @@ func (s *server) agentPreflight(w http.ResponseWriter, r *http.Request, forcedAg
 		"retrieval_mode":          reqBody.RetrievalMode,
 		"include_retrieval_debug": true,
 		"agent_id":                reqBody.AgentID,
+		"objective_context":       objectiveCtx.toMap(),
 	}
 	contextPackPayload, contextPackStatus, contextPackErr := s.backendJSONRequest(
 		ctx,
@@ -2178,6 +2185,7 @@ func (s *server) agentPreflight(w http.ResponseWriter, r *http.Request, forcedAg
 		"retrieval_mode":          reqBody.RetrievalMode,
 		"include_retrieval_debug": true,
 		"agent_id":                reqBody.AgentID,
+		"objective_context":       objectiveCtx.toMap(),
 	}
 	missionPackPayload, missionPackStatus, missionPackErr := s.backendJSONRequest(
 		ctx,
@@ -2206,6 +2214,7 @@ func (s *server) agentPreflight(w http.ResponseWriter, r *http.Request, forcedAg
 		contextPackPayload,
 		missionPackPayload,
 		missionPackErr,
+		objectiveCtx,
 	)
 
 	response := map[string]any{
@@ -2219,6 +2228,7 @@ func (s *server) agentPreflight(w http.ResponseWriter, r *http.Request, forcedAg
 		"topic_path":             reqBody.TopicPath,
 		"retrieval_mode":         reqBody.RetrievalMode,
 		"backend_url":            s.backendURL,
+		"objective_context":      objectiveCtx.toMap(),
 		"health":                 healthPayload,
 		"health_status":          healthStatus,
 		"health_error":           errString(healthErr),
@@ -6524,6 +6534,7 @@ func buildMux(s *server) *http.ServeMux {
 	mux.HandleFunc("/telemetry/retrieval", s.telemetryRetrievalRoute)
 	mux.HandleFunc("/telemetry/retrieval/source-quality", s.telemetryRetrievalSourceQualityRoute)
 	mux.HandleFunc("/telemetry/fanout", s.telemetryFanoutRoute)
+	mux.HandleFunc("/telemetry/memory/graph", s.telemetryMemoryGraphRoute)
 	mux.HandleFunc("/telemetry/agent-contracts", s.agentContractTelemetryRoute)
 	mux.HandleFunc("/telemetry/recall", s.telemetryRecallRoute)
 	mux.HandleFunc("/telemetry/recall/monitor", s.telemetryRecallMonitorRoute)
diff --git a/services/gateway-go/main_test.go b/services/gateway-go/main_test.go
index 4e7a735d..1e19b56d 100644
--- a/services/gateway-go/main_test.go
+++ b/services/gateway-go/main_test.go
@@ -842,6 +842,7 @@ func TestHotPathRoutesRemainGoOwned(t *testing.T) {
 		`mux.HandleFunc("/telemetry/retrieval", s.telemetryRetrievalRoute)`,
 		`mux.HandleFunc("/telemetry/retrieval/source-quality", s.telemetryRetrievalSourceQualityRoute)`,
 		`mux.HandleFunc("/telemetry/fanout", s.telemetryFanoutRoute)`,
+		`mux.HandleFunc("/telemetry/memory/graph", s.telemetryMemoryGraphRoute)`,
 		`mux.HandleFunc("/telemetry/agent-contracts", s.agentContractTelemetryRoute)`,
 		`mux.HandleFunc("/telemetry/recall", s.telemetryRecallRoute)`,
 		`mux.HandleFunc("/telemetry/recall/monitor", s.telemetryRecallMonitorRoute)`,
@@ -891,6 +892,7 @@ func TestHotPathRoutesRemainGoOwned(t *testing.T) {
 		`mux.HandleFunc("/telemetry/retrieval", s.proxy)`,
 		`mux.HandleFunc("/telemetry/retrieval/source-quality", s.proxy)`,
 		`mux.HandleFunc("/telemetry/fanout", s.proxy)`,
+		`mux.HandleFunc("/telemetry/memory/graph", s.proxy)`,
 		`mux.HandleFunc("/telemetry/recall", s.proxy)`,
 		`mux.HandleFunc("/telemetry/recall/monitor", s.proxy)`,
 		`mux.HandleFunc("/telemetry/tools/invocations", s.proxy)`,
@@ -2733,7 +2735,7 @@ func TestCodexPreflightBroadensScopeAndRequestsContextPack(t *testing.T) {
 	gateway := httptest.NewServer(buildMux(s))
 	defer gateway.Close()
 
-	reqBody := `{"project":"contextlattice","topic_path":"runbooks/codex-integration","query":"codex preflight","agent_id":"codex_gpt5_test"}`
+	reqBody := `{"project":"contextlattice","topic_path":"runbooks/codex-integration","query":"codex preflight","agent_id":"codex_gpt5_test","mission":"compound release evidence","objective":"ship boundary graph gate","goal":"protect every agent handoff"}`
 	resp, err := http.Post(gateway.URL+"/v1/codex/preflight", "application/json", strings.NewReader(reqBody))
 	if err != nil {
 		t.Fatalf("preflight request failed: %v", err)
@@ -2775,6 +2777,16 @@ func TestCodexPreflightBroadensScopeAndRequestsContextPack(t *testing.T) {
 		t.Fatalf("expected policy_context_package payload, got nil")
 	}
 	assertPolicyContextIncludesAntiScheming(t, payload["policy_context_package"])
+	objectiveContext, ok := payload["objective_context"].(map[string]any)
+	if !ok || strings.TrimSpace(anyToString(objectiveContext["objective"])) != "ship boundary graph gate" {
+		t.Fatalf("expected preflight objective_context override, got %#v", payload["objective_context"])
+	}
+	policyContext, _ := payload["policy_context_package"].(map[string]any)
+	if strings.TrimSpace(anyToString(policyContext["mission"])) != "compound release evidence" ||
+		strings.TrimSpace(anyToString(policyContext["objective"])) != "ship boundary graph gate" ||
+		strings.TrimSpace(anyToString(policyContext["goal"])) != "protect every agent handoff" {
+		t.Fatalf("expected policy package to mirror requested mission/objective/goal, got %#v", policyContext)
+	}
 	contracts, ok := payload["format_contracts"].(map[string]any)
 	if !ok {
 		t.Fatalf("expected format_contracts object, got %#v", payload["format_contracts"])
diff --git a/services/gateway-go/memory_context_pack.go b/services/gateway-go/memory_context_pack.go
index 0413193a..0f768651 100644
--- a/services/gateway-go/memory_context_pack.go
+++ b/services/gateway-go/memory_context_pack.go
@@ -64,6 +64,10 @@ func (s *server) buildContextPackResponse(
 		"traffic_class":           strings.TrimSpace(anyToString(requestPayload["traffic_class"])),
 		"include_grounding":       true,
 	}
+	objectiveCtx := extractObjectiveContext(requestPayload)
+	if !objectiveCtx.empty() {
+		searchRequest["objective_context"] = objectiveCtx.toMap()
+	}
 	if value := requestPayload["sources"]; value != nil {
 		searchRequest["sources"] = value
 	}
@@ -126,6 +130,9 @@ func (s *server) buildContextPackResponse(
 			response["retrieval"] = retrievalDebug
 		}
 	}
+	if !objectiveCtx.empty() {
+		response["objective_context"] = objectiveCtx.toMap()
+	}
 	return attachContextPackFormatContract(response), status, nil
 }
 
diff --git a/services/gateway-go/memory_edges_test.go b/services/gateway-go/memory_edges_test.go
index 98d3b809..287af65d 100644
--- a/services/gateway-go/memory_edges_test.go
+++ b/services/gateway-go/memory_edges_test.go
@@ -148,6 +148,82 @@ func TestMemoryV1NeighborsReturnsExplicitEdgesWhenRetrievalDisabled(t *testing.T
 	}
 }
 
+func TestMemoryGraphTelemetrySummarizesEdgesDocsAndRecommendations(t *testing.T) {
+	s, gateway := newMemoryGraphTestServer(t, true)
+	defer gateway.Close()
+
+	for _, item := range []normalizedWrite{
+		{
+			project:   "alpha",
+			fileName:  "notes/a.md",
+			content:   "alpha graph qdrant pgvector relationship anchor",
+			topicPath: "runbooks/graph",
+			agentID:   "agent-a",
+		},
+		{
+			project:   "alpha",
+			fileName:  "notes/b.md",
+			content:   "alpha graph qdrant pgvector relationship neighbor",
+			topicPath: "runbooks/graph",
+			agentID:   "agent-a",
+		},
+		{
+			project:   "alpha",
+			fileName:  "notes/c.md",
+			content:   "alpha isolated memory note",
+			topicPath: "runbooks/isolated",
+			agentID:   "agent-a",
+		},
+	} {
+		if _, _, err := s.memoryStore.put(item); err != nil {
+			t.Fatalf("seed memory doc: %v", err)
+		}
+	}
+	resp, err := http.Post(
+		gateway.URL+"/v1/memory/edges",
+		"application/json",
+		strings.NewReader(`{"source_id":"alpha::notes/a.md","target_id":"alpha::notes/b.md","relation":"inferred_related","confidence":0.91,"topic_path":"runbooks/graph","metadata":{"inferred":true},"provenance":{"kind":"inferred_memory_edge_scoring"}}`),
+	)
+	if err != nil {
+		t.Fatalf("edge write failed: %v", err)
+	}
+	resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("expected edge write 200, got %d", resp.StatusCode)
+	}
+
+	telemetry, err := http.Get(gateway.URL + "/telemetry/memory/graph?project=alpha&limit=5")
+	if err != nil {
+		t.Fatalf("graph telemetry request failed: %v", err)
+	}
+	defer telemetry.Body.Close()
+	if telemetry.StatusCode != http.StatusOK {
+		raw, _ := io.ReadAll(telemetry.Body)
+		t.Fatalf("expected 200 graph telemetry, got %d body=%s", telemetry.StatusCode, string(raw))
+	}
+	var payload map[string]any
+	if err := json.NewDecoder(telemetry.Body).Decode(&payload); err != nil {
+		t.Fatalf("decode graph telemetry: %v", err)
+	}
+	if anyToInt(payload["doc_count"], 0) != 3 {
+		t.Fatalf("expected doc_count=3, got %#v", payload)
+	}
+	if anyToInt(payload["edge_count"], 0) != 1 || anyToInt(payload["inferred_edge_count"], 0) != 1 {
+		t.Fatalf("expected one inferred edge, got %#v", payload)
+	}
+	if anyToInt(payload["isolated_doc_count"], 0) != 1 {
+		t.Fatalf("expected one isolated doc, got %#v", payload)
+	}
+	relations, _ := payload["relations"].([]any)
+	if len(relations) == 0 || anyToString(relations[0].(map[string]any)["name"]) != "inferred_related" {
+		t.Fatalf("expected inferred_related top relation, got %#v", relations)
+	}
+	topNodes, _ := payload["top_nodes"].([]any)
+	if len(topNodes) == 0 {
+		t.Fatalf("expected top_nodes in graph telemetry, got %#v", payload)
+	}
+}
+
 func TestMergeNeighborRowsPrefersExplicitEdgesAndDedupesRetrieval(t *testing.T) {
 	edgeRows := []map[string]any{
 		{"memory_id": "alpha::notes/b.md", "project": "alpha", "file": "notes/b.md", "source": memoryEdgeSource, "score": 0.9},
diff --git a/services/gateway-go/memory_graph_telemetry.go b/services/gateway-go/memory_graph_telemetry.go
new file mode 100644
index 00000000..14b56120
--- /dev/null
+++ b/services/gateway-go/memory_graph_telemetry.go
@@ -0,0 +1,415 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"os"
+	"sort"
+	"strings"
+	"time"
+)
+
+type graphTelemetryCount struct {
+	Name  string `json:"name"`
+	Count int    `json:"count"`
+}
+
+type graphTelemetryProject struct {
+	Project            string                `json:"project"`
+	Docs               int                   `json:"docs"`
+	ConnectedDocs      int                   `json:"connected_docs"`
+	IsolatedDocs       int                   `json:"isolated_docs"`
+	Edges              int                   `json:"edges"`
+	InferredEdges      int                   `json:"inferred_edges"`
+	ExplicitEdges      int                   `json:"explicit_edges"`
+	InboundEdges       int                   `json:"inbound_edges"`
+	OutboundEdges      int                   `json:"outbound_edges"`
+	DensityEdgesPerDoc float64               `json:"density_edges_per_doc"`
+	TopRelations       []graphTelemetryCount `json:"top_relations"`
+}
+
+type graphTelemetryNode struct {
+	MemoryID string `json:"memory_id"`
+	Project  string `json:"project"`
+	File     string `json:"file"`
+	Degree   int    `json:"degree"`
+	Inbound  int    `json:"inbound"`
+	Outbound int    `json:"outbound"`
+}
+
+type graphTelemetrySnapshot struct {
+	OK                  bool                    `json:"ok"`
+	Source              string                  `json:"source"`
+	GeneratedAt         string                  `json:"generated_at"`
+	ProjectFilter       string                  `json:"project_filter,omitempty"`
+	Corpus              string                  `json:"corpus"`
+	Status              string                  `json:"status"`
+	DocCount            int                     `json:"doc_count"`
+	EdgeCount           int                     `json:"edge_count"`
+	ConnectedDocCount   int                     `json:"connected_doc_count"`
+	IsolatedDocCount    int                     `json:"isolated_doc_count"`
+	InferredEdgeCount   int                     `json:"inferred_edge_count"`
+	ExplicitEdgeCount   int                     `json:"explicit_edge_count"`
+	DensityEdgesPerDoc  float64                 `json:"density_edges_per_doc"`
+	Projects            []graphTelemetryProject `json:"projects"`
+	Relations           []graphTelemetryCount   `json:"relations"`
+	Lifecycles          []graphTelemetryCount   `json:"lifecycles"`
+	TopNodes            []graphTelemetryNode    `json:"top_nodes"`
+	Recommendations     []string                `json:"recommendations"`
+	EdgeStore           map[string]any          `json:"edge_store"`
+	DocCollectionStatus string                  `json:"doc_collection_status"`
+}
+
+type graphTelemetryProjectStats struct {
+	docs          int
+	docIDs        map[string]struct{}
+	connected     map[string]struct{}
+	isolated      int
+	edges         int
+	inferred      int
+	explicit      int
+	inbound       int
+	outbound      int
+	relationCount map[string]int
+}
+
+type graphTelemetryNodeStats struct {
+	memoryID string
+	project  string
+	file     string
+	inbound  int
+	outbound int
+}
+
+func (m *memoryStore) memoryGraphTelemetrySnapshot(ctx context.Context, projectFilter string, includeEphemeral bool, topLimit int) (graphTelemetrySnapshot, error) {
+	if m == nil || !m.policy.enabled {
+		return graphTelemetrySnapshot{}, errors.New("go memory store is disabled")
+	}
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	topLimit = clampInt(topLimit, 1, 50)
+	projectFilter = strings.TrimSpace(projectFilter)
+	if projectFilter != "" {
+		clean, err := sanitizeMemoryProject(projectFilter)
+		if err != nil {
+			return graphTelemetrySnapshot{}, err
+		}
+		projectFilter = clean
+	}
+
+	docStatus := "history_index"
+	docs, ok := m.collectDocsFromHistoryIndex(ctx, projectFilter)
+	if !ok {
+		var err error
+		docs, err = m.collectDocsFromDisk(ctx, projectFilter, true, includeEphemeral)
+		if err != nil {
+			return graphTelemetrySnapshot{}, err
+		}
+		docStatus = "disk_fallback"
+	}
+
+	docIDs := map[string]struct{}{}
+	projectStats := map[string]*graphTelemetryProjectStats{}
+	for _, doc := range docs {
+		memoryID := doc.Project + "::" + doc.FileName
+		docIDs[strings.ToLower(memoryID)] = struct{}{}
+		stats := projectStats[strings.ToLower(doc.Project)]
+		if stats == nil {
+			stats = &graphTelemetryProjectStats{docIDs: map[string]struct{}{}, connected: map[string]struct{}{}, relationCount: map[string]int{}}
+			projectStats[strings.ToLower(doc.Project)] = stats
+		}
+		stats.docs += 1
+		stats.docIDs[strings.ToLower(memoryID)] = struct{}{}
+	}
+
+	m.mu.RLock()
+	edges := make([]memoryEdgeEntry, 0, len(m.edgeOrder))
+	for _, edgeID := range m.edgeOrder {
+		edge, exists := m.edges[edgeID]
+		if !exists {
+			continue
+		}
+		if projectFilter != "" && !strings.EqualFold(edge.Project, projectFilter) {
+			continue
+		}
+		if !includeEphemeral && !shouldSurfaceMemoryLifecycle(edge.Lifecycle, false) {
+			continue
+		}
+		edges = append(edges, edge)
+	}
+	m.mu.RUnlock()
+
+	relationCounts := map[string]int{}
+	lifecycleCounts := map[string]int{}
+	nodeStats := map[string]*graphTelemetryNodeStats{}
+	inferredCount := 0
+	explicitCount := 0
+	for _, edge := range edges {
+		projectKey := strings.ToLower(edge.Project)
+		stats := projectStats[projectKey]
+		if stats == nil {
+			stats = &graphTelemetryProjectStats{docIDs: map[string]struct{}{}, connected: map[string]struct{}{}, relationCount: map[string]int{}}
+			projectStats[projectKey] = stats
+		}
+		stats.edges += 1
+		stats.relationCount[edge.Relation] += 1
+		relationCounts[edge.Relation] += 1
+		lifecycle := normalizeMemoryLifecycle(edge.Lifecycle)
+		lifecycleCounts[lifecycle] += 1
+		inferred := memoryEdgeTelemetryInferred(edge)
+		if inferred {
+			inferredCount += 1
+			stats.inferred += 1
+		} else {
+			explicitCount += 1
+			stats.explicit += 1
+		}
+		recordNode := func(memoryID string, outbound bool) {
+			project, fileName, canonical, _, err := canonicalMemoryID(memoryID)
+			if err != nil {
+				return
+			}
+			key := strings.ToLower(canonical)
+			node := nodeStats[key]
+			if node == nil {
+				node = &graphTelemetryNodeStats{memoryID: canonical, project: project, file: fileName}
+				nodeStats[key] = node
+			}
+			if outbound {
+				node.outbound += 1
+				stats.outbound += 1
+			} else {
+				node.inbound += 1
+				stats.inbound += 1
+			}
+			stats.connected[key] = struct{}{}
+		}
+		recordNode(edge.SourceID, true)
+		recordNode(edge.TargetID, false)
+	}
+
+	connectedDocCount := 0
+	for id := range docIDs {
+		if _, exists := nodeStats[id]; exists {
+			connectedDocCount += 1
+		}
+	}
+	isolatedDocCount := len(docIDs) - connectedDocCount
+	if isolatedDocCount < 0 {
+		isolatedDocCount = 0
+	}
+	for key, stats := range projectStats {
+		connectedDocs := stats.connectedDocCount()
+		stats.isolated = stats.docs - connectedDocs
+		if stats.isolated < 0 {
+			stats.isolated = 0
+		}
+		if stats.docs == 0 && stats.edges == 0 {
+			delete(projectStats, key)
+		}
+	}
+
+	status := "healthy"
+	if len(docs) == 0 && len(edges) == 0 {
+		status = "empty"
+	} else if len(docs) > 0 && len(edges) == 0 {
+		status = "no_edges"
+	} else if len(docs) > 0 && float64(len(edges))/float64(len(docs)) < 0.15 {
+		status = "sparse"
+	}
+
+	return graphTelemetrySnapshot{
+		OK:                  true,
+		Source:              "go_memory_store",
+		GeneratedAt:         time.Now().UTC().Format(time.RFC3339Nano),
+		ProjectFilter:       projectFilter,
+		Corpus:              "memory_store",
+		Status:              status,
+		DocCount:            len(docs),
+		EdgeCount:           len(edges),
+		ConnectedDocCount:   connectedDocCount,
+		IsolatedDocCount:    isolatedDocCount,
+		InferredEdgeCount:   inferredCount,
+		ExplicitEdgeCount:   explicitCount,
+		DensityEdgesPerDoc:  ratioFloat(len(edges), len(docs)),
+		Projects:            graphTelemetryProjects(projectStats, topLimit),
+		Relations:           topGraphTelemetryCounts(relationCounts, topLimit),
+		Lifecycles:          topGraphTelemetryCounts(lifecycleCounts, topLimit),
+		TopNodes:            graphTelemetryTopNodes(nodeStats, topLimit),
+		Recommendations:     graphTelemetryRecommendations(status, len(docs), len(edges), inferredCount, isolatedDocCount),
+		EdgeStore:           m.memoryGraphEdgeStoreInfo(),
+		DocCollectionStatus: docStatus,
+	}, nil
+}
+
+func (s *graphTelemetryProjectStats) connectedDocCount() int {
+	if s == nil {
+		return 0
+	}
+	if len(s.docIDs) == 0 {
+		return len(s.connected)
+	}
+	count := 0
+	for id := range s.docIDs {
+		if _, exists := s.connected[id]; exists {
+			count += 1
+		}
+	}
+	return count
+}
+
+func memoryEdgeTelemetryInferred(edge memoryEdgeEntry) bool {
+	if anyToBool(edge.Metadata["inferred"]) {
+		return true
+	}
+	kind := strings.ToLower(strings.TrimSpace(anyToString(edge.Provenance["kind"])))
+	return strings.Contains(kind, "inferred")
+}
+
+func ratioFloat(numerator int, denominator int) float64 {
+	if denominator <= 0 {
+		return 0
+	}
+	return float64(numerator) / float64(denominator)
+}
+
+func graphTelemetryProjects(stats map[string]*graphTelemetryProjectStats, limit int) []graphTelemetryProject {
+	rows := make([]graphTelemetryProject, 0, len(stats))
+	for key, item := range stats {
+		if item == nil {
+			continue
+		}
+		rows = append(rows, graphTelemetryProject{
+			Project:            key,
+			Docs:               item.docs,
+			ConnectedDocs:      item.connectedDocCount(),
+			IsolatedDocs:       item.isolated,
+			Edges:              item.edges,
+			InferredEdges:      item.inferred,
+			ExplicitEdges:      item.explicit,
+			InboundEdges:       item.inbound,
+			OutboundEdges:      item.outbound,
+			DensityEdgesPerDoc: ratioFloat(item.edges, item.docs),
+			TopRelations:       topGraphTelemetryCounts(item.relationCount, 5),
+		})
+	}
+	sort.Slice(rows, func(i, j int) bool {
+		if rows[i].Edges != rows[j].Edges {
+			return rows[i].Edges > rows[j].Edges
+		}
+		if rows[i].Docs != rows[j].Docs {
+			return rows[i].Docs > rows[j].Docs
+		}
+		return rows[i].Project < rows[j].Project
+	})
+	if len(rows) > limit {
+		rows = rows[:limit]
+	}
+	return rows
+}
+
+func topGraphTelemetryCounts(counts map[string]int, limit int) []graphTelemetryCount {
+	rows := make([]graphTelemetryCount, 0, len(counts))
+	for name, count := range counts {
+		rows = append(rows, graphTelemetryCount{Name: name, Count: count})
+	}
+	sort.Slice(rows, func(i, j int) bool {
+		if rows[i].Count != rows[j].Count {
+			return rows[i].Count > rows[j].Count
+		}
+		return rows[i].Name < rows[j].Name
+	})
+	if limit > 0 && len(rows) > limit {
+		rows = rows[:limit]
+	}
+	return rows
+}
+
+func graphTelemetryTopNodes(stats map[string]*graphTelemetryNodeStats, limit int) []graphTelemetryNode {
+	rows := make([]graphTelemetryNode, 0, len(stats))
+	for _, item := range stats {
+		if item == nil {
+			continue
+		}
+		rows = append(rows, graphTelemetryNode{
+			MemoryID: item.memoryID,
+			Project:  item.project,
+			File:     item.file,
+			Degree:   item.inbound + item.outbound,
+			Inbound:  item.inbound,
+			Outbound: item.outbound,
+		})
+	}
+	sort.Slice(rows, func(i, j int) bool {
+		if rows[i].Degree != rows[j].Degree {
+			return rows[i].Degree > rows[j].Degree
+		}
+		return strings.ToLower(rows[i].MemoryID) < strings.ToLower(rows[j].MemoryID)
+	})
+	if len(rows) > limit {
+		rows = rows[:limit]
+	}
+	return rows
+}
+
+func graphTelemetryRecommendations(status string, docs int, edges int, inferred int, isolated int) []string {
+	recommendations := []string{}
+	if docs > 0 && edges == 0 {
+		recommendations = append(recommendations, "Run scripts/agent/memory-edge-backfill --include-inferred --inferred-min-score 0.80 --inferred-peer-limit 5 before graph-neighbor debugging.")
+	}
+	if isolated > 0 && docs > 0 && float64(isolated)/float64(docs) > 0.35 {
+		recommendations = append(recommendations, "High isolated-doc ratio: run disk corpus edge backfill for older projects or bootstrap missing project summaries.")
+	}
+	if edges > 0 && inferred == 0 {
+		recommendations = append(recommendations, "No inferred edges visible: enable inferred_related backfill when semantic relationship recall is expected.")
+	}
+	if status == "healthy" && len(recommendations) == 0 {
+		recommendations = append(recommendations, "Graph density is sufficient for relationship recall; inspect top nodes for over-connected memory anchors.")
+	}
+	return recommendations
+}
+
+func (m *memoryStore) memoryGraphEdgeStoreInfo() map[string]any {
+	info := map[string]any{
+		"path":                   m.policy.edgePath,
+		"max_edges":              m.policy.maxEdges,
+		"startup_max_lines":      m.policy.edgeStartupMaxLines,
+		"max_edge_neighbors":     m.policy.maxEdgeNeighbors,
+		"history_startup_lines":  m.policy.historyStartupMaxLines,
+		"history_tail_max_bytes": m.policy.historyStartupTailMaxBytes,
+	}
+	if stat, err := os.Stat(m.policy.edgePath); err == nil {
+		info["bytes"] = stat.Size()
+		info["updated_at"] = stat.ModTime().UTC().Format(time.RFC3339Nano)
+	} else if errors.Is(err, os.ErrNotExist) {
+		info["bytes"] = 0
+	}
+	return info
+}
+
+func (s *server) telemetryMemoryGraphRoute(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		writeJSON(w, http.StatusMethodNotAllowed, map[string]any{"error": "method not allowed"})
+		return
+	}
+	if _, ok := s.prepareAuthorizedHeaders(w, r); !ok {
+		return
+	}
+	if s.memoryStore == nil || !s.memoryStore.policy.enabled {
+		writeJSON(w, http.StatusServiceUnavailable, map[string]any{"ok": false, "error": "go memory store is disabled"})
+		return
+	}
+	project := strings.TrimSpace(r.URL.Query().Get("project"))
+	includeEphemeral := anyToBool(r.URL.Query().Get("include_ephemeral"))
+	limit := clampInt(anyToInt(r.URL.Query().Get("limit"), 10), 1, 50)
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+	snapshot, err := s.memoryStore.memoryGraphTelemetrySnapshot(ctx, project, includeEphemeral, limit)
+	if err != nil {
+		writeJSON(w, http.StatusUnprocessableEntity, map[string]any{"ok": false, "error": err.Error()})
+		return
+	}
+	writeJSON(w, http.StatusOK, snapshot)
+}
diff --git a/services/gateway-go/objective_context.go b/services/gateway-go/objective_context.go
index 6f96b8f9..3ea39548 100644
--- a/services/gateway-go/objective_context.go
+++ b/services/gateway-go/objective_context.go
@@ -13,6 +13,14 @@ type objectiveContext struct {
 	Goal      string
 }
 
+func defaultObjectiveContext() objectiveContext {
+	return objectiveContext{
+		Mission:   defaultContextLatticeMission(),
+		Objective: defaultContextLatticeObjective(),
+		Goal:      defaultContextLatticeGoal(),
+	}
+}
+
 func defaultContextLatticeMission() string {
 	value := strings.TrimSpace(os.Getenv("CONTEXTLATTICE_MISSION"))
 	if value == "" {
@@ -43,6 +51,25 @@ func (c objectiveContext) empty() bool {
 		strings.TrimSpace(c.Goal) == ""
 }
 
+func (c objectiveContext) withDefaults() objectiveContext {
+	defaults := defaultObjectiveContext()
+	out := objectiveContext{
+		Mission:   strings.TrimSpace(c.Mission),
+		Objective: strings.TrimSpace(c.Objective),
+		Goal:      strings.TrimSpace(c.Goal),
+	}
+	if out.Mission == "" {
+		out.Mission = defaults.Mission
+	}
+	if out.Objective == "" {
+		out.Objective = defaults.Objective
+	}
+	if out.Goal == "" {
+		out.Goal = defaults.Goal
+	}
+	return out
+}
+
 func (c objectiveContext) toMap() map[string]any {
 	payload := map[string]any{}
 	if value := strings.TrimSpace(c.Mission); value != "" {
@@ -86,6 +113,14 @@ func extractObjectiveContext(payload map[string]any) objectiveContext {
 	return out
 }
 
+func objectiveContextFromPreflightRequest(req agentPreflightRequest) objectiveContext {
+	return objectiveContext{
+		Mission:   req.Mission,
+		Objective: req.Objective,
+		Goal:      req.Goal,
+	}.withDefaults()
+}
+
 func objectiveContextCaptureEnabled() bool {
 	return envBool("GO_OBJECTIVE_CONTEXT_CAPTURE_ENABLED", true)
 }
@@ -294,10 +329,12 @@ func buildPolicyContextPackage(
 	primaryPack map[string]any,
 	missionPack map[string]any,
 	missionPackError error,
+	requestedContext objectiveContext,
 ) map[string]any {
-	mission := defaultContextLatticeMission()
-	objective := defaultContextLatticeObjective()
-	goal := defaultContextLatticeGoal()
+	policyContext := requestedContext.withDefaults()
+	mission := policyContext.Mission
+	objective := policyContext.Objective
+	goal := policyContext.Goal
 	formatContract := contractMetadata(policyContextPackageContractID)
 	policy := map[string]any{
 		"version":        "2026-05-10",