@jmanuelcorral/openteam 0.1.42 → 0.2.0

package/dist/index.js

@@ -340,6 +340,7 @@ var GraphModeSchema = z.enum(["off", "shadow", "active"]);
 var GraphConfigSchema = z.object({
   mode: GraphModeSchema.default("off"),
   killSwitch: z.boolean().default(false),
+  operatorApproval: z.boolean().default(false),
   worktrees: z.object({
     enabled: z.boolean().default(false)
   }).default({ enabled: false })
@@ -510,6 +511,59 @@ async function writeOpenTeamConfigFile(config, path = DEFAULT_CONFIG_PATH, stora
 // src/commands/setup.ts
 var OPENCODE_CONFIG_PATH = "opencode.json";
 
+// src/config/graphFeatureGate.ts
+function checkCertificate(status, name) {
+  if (status.status === "absent") {
+    return {
+      code: `${name}-certificate-absent`,
+      detail: `${name} certificate not found — run the ${name} certification suite to produce it`
+    };
+  }
+  if (status.status === "invalid") {
+    return {
+      code: `${name}-certificate-invalid`,
+      detail: `${name} certificate rejected by recomputing parser: ${status.code} — ${status.detail}`
+    };
+  }
+  return;
+}
+function evaluateGraphGate(input) {
+  const violations = [];
+  const shadowV = checkCertificate(input.shadow, "shadow");
+  if (shadowV !== undefined)
+    violations.push(shadowV);
+  const releaseV = checkCertificate(input.release, "release");
+  if (releaseV !== undefined)
+    violations.push(releaseV);
+  const soakV = checkCertificate(input.soak, "soak");
+  if (soakV !== undefined)
+    violations.push(soakV);
+  if (input.migration === "pending") {
+    violations.push({
+      code: "migration-pending",
+      detail: "legacy migration has pending work — run the migration tool to completion before enabling active mode"
+    });
+  } else if (input.migration === "unknown") {
+    violations.push({
+      code: "migration-unknown",
+      detail: "could not determine migration status — check ledger readability and storage access"
+    });
+  }
+  if (!input.operatorApproval) {
+    violations.push({
+      code: "operator-approval-missing",
+      detail: "set graph.operatorApproval to true in .opencode/openteam.json after reviewing all certificates and completing migration — this is a declaration of intent, not a proof"
+    });
+  }
+  return {
+    allowed: violations.length === 0,
+    violations
+  };
+}
+function isGateApplicable(mode) {
+  return mode === "active";
+}
+
 // src/config/migrations.ts
 var CURRENT_CONFIG_VERSION = 1;
 
@@ -546,6 +600,725 @@ function loadOpenTeamConfig(raw) {
   return OpenTeamConfigSchema.parse(migrateConfig(raw ?? {}));
 }
 
+// src/config/resolve.ts
+function resolveGraphConfig(config, source) {
+  const configuredMode = config.graph?.mode ?? "off";
+  const killSwitch = config.graph?.killSwitch ?? false;
+  const effectiveMode = killSwitch ? "off" : configuredMode;
+  return {
+    configuredMode,
+    effectiveMode,
+    executorEnabled: effectiveMode === "active",
+    killSwitch,
+    source
+  };
+}
+function applyGraphGate(resolved, gateResult) {
+  if (gateResult.allowed) {
+    return { ...resolved, gateDenied: false, gateViolations: [] };
+  }
+  return {
+    ...resolved,
+    effectiveMode: "off",
+    executorEnabled: false,
+    gateDenied: true,
+    gateViolations: gateResult.violations
+  };
+}
+
+// src/graph/certificate.ts
+import { z as z3 } from "zod";
+
+// src/context/redaction.ts
+import { createHash } from "node:crypto";
+
+class RedactionError extends Error {
+  code;
+  key;
+  constructor(key) {
+    super(`raw content field is not allowed: "${key}"`);
+    this.name = "RedactionError";
+    this.code = "raw-content";
+    this.key = key;
+  }
+}
+function sha256Hex(input) {
+  return createHash("sha256").update(input, "utf8").digest("hex");
+}
+var FORBIDDEN_RAW_KEYS = new Set([
+  "content",
+  "text",
+  "brief",
+  "prompt",
+  "raw",
+  "body",
+  "output",
+  "findings",
+  "message",
+  "source"
+]);
+function walkForbiddenKeys(value, onForbidden) {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkForbiddenKeys(item, onForbidden);
+    }
+    return;
+  }
+  if (value === null || typeof value !== "object") {
+    return;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    if (FORBIDDEN_RAW_KEYS.has(key)) {
+      const shouldStop = onForbidden(key);
+      if (shouldStop)
+        return;
+    }
+    walkForbiddenKeys(child, onForbidden);
+  }
+}
+function assertReferenceOnly(value) {
+  walkForbiddenKeys(value, (key) => {
+    throw new RedactionError(key);
+  });
+}
+function scanReferenceOnly(surfaces) {
+  let rawFindings = 0;
+  for (const surface of surfaces) {
+    walkForbiddenKeys(surface, () => {
+      rawFindings++;
+      return false;
+    });
+  }
+  return { surfacesScanned: surfaces.length, rawFindings };
+}
+
+// src/graph/soakLedger.ts
+import { z as z2 } from "zod";
+var Sha256Schema = z2.string().regex(/^[0-9a-f]{64}$/);
+var SoakPlatformSchema = z2.enum(["linux", "win32", "darwin"]);
+var PrivacyPairSchema = z2.object({
+  surfacesScanned: z2.number().int().nonnegative(),
+  rawFindings: z2.number().int().nonnegative()
+}).strict();
+var DuplicateEffectPairSchema = z2.object({
+  effectsExamined: z2.number().int().nonnegative(),
+  duplicatesFound: z2.number().int().nonnegative()
+}).strict();
+var ModelVerificationPairSchema = z2.object({
+  nodesChecked: z2.number().int().nonnegative(),
+  unverified: z2.number().int().nonnegative(),
+  mismatched: z2.number().int().nonnegative()
+}).strict();
+var SoakObservationSchema = z2.object({
+  version: z2.literal(1),
+  seq: z2.number().int().nonnegative(),
+  timestamp: z2.string().datetime(),
+  platform: SoakPlatformSchema,
+  opencodeVersion: z2.string().min(1),
+  provenance: z2.enum(["genuine-usage", "ci-synthetic"]),
+  traceDigest: Sha256Schema,
+  criticalDivergences: z2.number().int().nonnegative().nullable(),
+  privacy: PrivacyPairSchema.nullable(),
+  duplicateEffects: DuplicateEffectPairSchema.nullable(),
+  modelVerification: ModelVerificationPairSchema.nullable(),
+  chainDigest: Sha256Schema
+}).strict();
+function canonicalObservationPreimage(obs) {
+  return JSON.stringify({
+    version: obs.version,
+    seq: obs.seq,
+    timestamp: obs.timestamp,
+    platform: obs.platform,
+    opencodeVersion: obs.opencodeVersion,
+    provenance: obs.provenance,
+    traceDigest: obs.traceDigest,
+    criticalDivergences: obs.criticalDivergences,
+    privacy: obs.privacy,
+    duplicateEffects: obs.duplicateEffects,
+    modelVerification: obs.modelVerification
+  });
+}
+function validateChain(observations) {
+  if (observations.length === 0) {
+    return { valid: true, observations: [] };
+  }
+  let prevChainDigest = "0".repeat(64);
+  for (let i = 0;i < observations.length; i++) {
+    const obs = observations[i];
+    if (obs.seq !== i) {
+      return { valid: false, observations };
+    }
+    if (i > 0) {
+      const prev = observations[i - 1];
+      if (obs.timestamp <= prev.timestamp) {
+        return { valid: false, observations };
+      }
+    }
+    const preimage = canonicalObservationPreimage(obs);
+    const expectedDigest = sha256Hex(prevChainDigest + preimage);
+    if (obs.chainDigest !== expectedDigest) {
+      return { valid: false, observations };
+    }
+    prevChainDigest = obs.chainDigest;
+  }
+  return { valid: true, observations };
+}
+function canonicalLedger(chains) {
+  const validChains = [];
+  for (const chain of chains) {
+    const result = validateChain(chain);
+    if (result.valid && chain.length > 0) {
+      validChains.push(chain);
+    }
+  }
+  validChains.sort((a, b) => {
+    const aDigest = a[0].chainDigest;
+    const bDigest = b[0].chainDigest;
+    return aDigest < bDigest ? -1 : aDigest > bDigest ? 1 : 0;
+  });
+  const lines = [];
+  for (const chain of validChains) {
+    for (const obs of chain) {
+      lines.push(JSON.stringify(obs));
+    }
+  }
+  return sha256Hex(lines.join(`
+`));
+}
+
+// src/graph/certificate.ts
+var SHADOW_CERTIFICATE_MIN_RUNS = 1000;
+var DivergenceCodeSchema = z3.enum([
+  "status",
+  "order",
+  "roles",
+  "models",
+  "fixes",
+  "outcome"
+]);
+var ProvenanceSchema = z3.enum([
+  "recomputed",
+  "compiled",
+  "validated",
+  "carried"
+]);
+var EvidenceSchema = z3.object({
+  opencodeVersion: z3.string().min(1),
+  parity: z3.object({
+    runs: z3.number().int().nonnegative(),
+    match: z3.number().int().nonnegative(),
+    divergent: z3.number().int().nonnegative(),
+    inconclusive: z3.number().int().nonnegative(),
+    divergences: z3.array(DivergenceCodeSchema)
+  }).strict(),
+  legacy: z3.object({
+    observed: z3.number().int().nonnegative(),
+    duplicated: z3.number().int().nonnegative()
+  }).strict(),
+  privacy: z3.object({
+    surfacesScanned: z3.number().int().nonnegative(),
+    rawFindings: z3.number().int().nonnegative()
+  }).strict(),
+  overhead: z3.object({
+    p95Millis: z3.number().nonnegative(),
+    budgetMillis: z3.number().positive(),
+    samples: z3.number().int().nonnegative()
+  }).strict(),
+  provenance: z3.record(DivergenceCodeSchema, ProvenanceSchema)
+}).strict();
+var CertificateSchema = z3.object({
+  version: z3.literal(1),
+  certificate: z3.literal("graph-shadow"),
+  opencodeVersion: z3.string().min(1),
+  evidence: EvidenceSchema,
+  verdict: z3.enum(["pass", "fail"]),
+  failedGates: z3.array(z3.enum([
+    "sample",
+    "parity",
+    "one-legacy-execution",
+    "privacy",
+    "overhead"
+  ])),
+  digest: z3.string().regex(/^[0-9a-f]{64}$/)
+}).strict();
+
+class ShadowCertificateError extends Error {
+  code;
+  detail;
+  constructor(code, detail) {
+    super(`${code}: ${detail}`);
+    this.name = "ShadowCertificateError";
+    this.code = code;
+    this.detail = detail;
+  }
+}
+function evaluateGates(evidence) {
+  const failed = [];
+  if (evidence.parity.runs < SHADOW_CERTIFICATE_MIN_RUNS) {
+    failed.push("sample");
+  }
+  if (evidence.parity.divergent > 0 || evidence.parity.inconclusive > 0 || evidence.parity.divergences.length > 0 || evidence.parity.match !== evidence.parity.runs) {
+    failed.push("parity");
+  }
+  if (evidence.legacy.duplicated > 0 || evidence.legacy.observed < 1) {
+    failed.push("one-legacy-execution");
+  }
+  if (evidence.privacy.rawFindings > 0 || evidence.privacy.surfacesScanned < 1) {
+    failed.push("privacy");
+  }
+  if (evidence.overhead.samples < 1 || evidence.overhead.p95Millis > evidence.overhead.budgetMillis) {
+    failed.push("overhead");
+  }
+  return failed;
+}
+function canonicalCertificate(certificate) {
+  const evidence = certificate.evidence;
+  return JSON.stringify({
+    version: certificate.version,
+    certificate: certificate.certificate,
+    opencodeVersion: certificate.opencodeVersion,
+    verdict: certificate.verdict,
+    failedGates: [...certificate.failedGates],
+    evidence: {
+      opencodeVersion: evidence.opencodeVersion,
+      parity: {
+        runs: evidence.parity.runs,
+        match: evidence.parity.match,
+        divergent: evidence.parity.divergent,
+        inconclusive: evidence.parity.inconclusive,
+        divergences: [...evidence.parity.divergences].sort()
+      },
+      legacy: {
+        observed: evidence.legacy.observed,
+        duplicated: evidence.legacy.duplicated
+      },
+      privacy: {
+        surfacesScanned: evidence.privacy.surfacesScanned,
+        rawFindings: evidence.privacy.rawFindings
+      },
+      overhead: {
+        p95Millis: evidence.overhead.p95Millis,
+        budgetMillis: evidence.overhead.budgetMillis,
+        samples: evidence.overhead.samples
+      },
+      provenance: Object.fromEntries(Object.entries(evidence.provenance).sort(([a], [b]) => a < b ? -1 : 1))
+    }
+  });
+}
+function sameGates(a, b) {
+  return a.length === b.length && a.every((gate, index) => gate === b[index]);
+}
+function parseShadowCertificate(value, opencodeVersion) {
+  const parsed = CertificateSchema.safeParse(value);
+  if (!parsed.success) {
+    const detail = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.code}`).join("; ");
+    throw new ShadowCertificateError("invalid-certificate", detail);
+  }
+  const certificate = parsed.data;
+  const failedGates = evaluateGates(certificate.evidence);
+  const verdict = failedGates.length === 0 ? "pass" : "fail";
+  if (certificate.verdict !== verdict || !sameGates(certificate.failedGates, failedGates)) {
+    throw new ShadowCertificateError("verdict-mismatch", `evidence yields "${verdict}" (${failedGates.join(",") || "no failed gate"})`);
+  }
+  const { digest, ...unsigned } = certificate;
+  if (sha256Hex(canonicalCertificate(unsigned)) !== digest) {
+    throw new ShadowCertificateError("digest-mismatch", "certificate digest does not cover the presented evidence");
+  }
+  if (certificate.opencodeVersion !== opencodeVersion) {
+    throw new ShadowCertificateError("opencode-mismatch", `certified for "${certificate.opencodeVersion}", expected "${opencodeVersion}"`);
+  }
+  return certificate;
+}
+var ReleaseDeterminismSchema = z3.object({ runs: z3.number().int().nonnegative(), allMatch: z3.boolean() }).strict();
+var ReleaseCrashRecoverySchema = z3.object({
+  scenarios: z3.number().int().nonnegative(),
+  allConverge: z3.boolean()
+}).strict();
+var ReleaseReplayEquivalenceSchema = z3.object({
+  checks: z3.number().int().nonnegative(),
+  allEquivalent: z3.boolean()
+}).strict();
+var ReleasePrivacySchema = z3.object({
+  surfacesScanned: z3.number().int().nonnegative(),
+  rawFindings: z3.number().int().nonnegative()
+}).strict();
+var ReleaseContractSchema = z3.object({
+  roundTrips: z3.number().int().nonnegative(),
+  allSettled: z3.boolean()
+}).strict();
+var ReleaseMigrationSchema = z3.object({
+  cases: z3.number().int().nonnegative(),
+  allSucceeded: z3.boolean()
+}).strict();
+var ReleaseHealthSchema = z3.object({
+  samples: z3.number().int().nonnegative(),
+  bounded: z3.boolean(),
+  idempotent: z3.boolean()
+}).strict();
+var ReleasePerformanceSchema = z3.object({
+  p95Millis: z3.number().nonnegative(),
+  budgetMillis: z3.number().positive(),
+  samples: z3.number().int().nonnegative()
+}).strict();
+var ReleaseEvidenceSchema = z3.object({
+  opencodeVersion: z3.string().min(1),
+  platform: z3.enum(["linux", "win32"]),
+  shadowCertificateDigest: z3.string().regex(/^[0-9a-f]{64}$/),
+  determinism: ReleaseDeterminismSchema,
+  crashRecovery: ReleaseCrashRecoverySchema,
+  replayEquivalence: ReleaseReplayEquivalenceSchema,
+  privacy: ReleasePrivacySchema,
+  contract: ReleaseContractSchema,
+  migration: ReleaseMigrationSchema,
+  health: ReleaseHealthSchema,
+  performance: ReleasePerformanceSchema
+}).strict();
+var ReleaseCertificateSchema = z3.object({
+  version: z3.literal(1),
+  certificate: z3.literal("graph-release"),
+  platform: z3.enum(["linux", "win32"]),
+  opencodeVersion: z3.string().min(1),
+  shadowCertificateDigest: z3.string().regex(/^[0-9a-f]{64}$/),
+  evidence: ReleaseEvidenceSchema,
+  verdict: z3.enum(["pass", "fail"]),
+  failedGates: z3.array(z3.enum([
+    "shadow-valid",
+    "determinism",
+    "crash-recovery",
+    "replay-equivalence",
+    "privacy",
+    "contract",
+    "migration",
+    "health",
+    "performance"
+  ])),
+  digest: z3.string().regex(/^[0-9a-f]{64}$/)
+}).strict();
+
+class ReleaseCertificateError extends Error {
+  code;
+  detail;
+  constructor(code, detail) {
+    super(`${code}: ${detail}`);
+    this.name = "ReleaseCertificateError";
+    this.code = code;
+    this.detail = detail;
+  }
+}
+function evaluateReleaseGates(evidence, expectedShadowDigest) {
+  const failed = [];
+  if (evidence.shadowCertificateDigest !== expectedShadowDigest) {
+    failed.push("shadow-valid");
+  }
+  if (evidence.determinism.runs < 1 || !evidence.determinism.allMatch) {
+    failed.push("determinism");
+  }
+  if (evidence.crashRecovery.scenarios < 1 || !evidence.crashRecovery.allConverge) {
+    failed.push("crash-recovery");
+  }
+  if (evidence.replayEquivalence.checks < 1 || !evidence.replayEquivalence.allEquivalent) {
+    failed.push("replay-equivalence");
+  }
+  if (evidence.privacy.surfacesScanned < 1 || evidence.privacy.rawFindings > 0) {
+    failed.push("privacy");
+  }
+  if (evidence.contract.roundTrips < 1 || !evidence.contract.allSettled) {
+    failed.push("contract");
+  }
+  if (evidence.migration.cases < 1 || !evidence.migration.allSucceeded) {
+    failed.push("migration");
+  }
+  if (evidence.health.samples < 1 || !evidence.health.bounded || !evidence.health.idempotent) {
+    failed.push("health");
+  }
+  if (evidence.performance.samples < 1 || evidence.performance.p95Millis > evidence.performance.budgetMillis) {
+    failed.push("performance");
+  }
+  return failed;
+}
+function canonicalReleaseCertificate(certificate) {
+  const ev = certificate.evidence;
+  return JSON.stringify({
+    version: certificate.version,
+    certificate: certificate.certificate,
+    platform: certificate.platform,
+    opencodeVersion: certificate.opencodeVersion,
+    shadowCertificateDigest: certificate.shadowCertificateDigest,
+    verdict: certificate.verdict,
+    failedGates: [...certificate.failedGates],
+    evidence: {
+      opencodeVersion: ev.opencodeVersion,
+      platform: ev.platform,
+      shadowCertificateDigest: ev.shadowCertificateDigest,
+      determinism: {
+        runs: ev.determinism.runs,
+        allMatch: ev.determinism.allMatch
+      },
+      crashRecovery: {
+        scenarios: ev.crashRecovery.scenarios,
+        allConverge: ev.crashRecovery.allConverge
+      },
+      replayEquivalence: {
+        checks: ev.replayEquivalence.checks,
+        allEquivalent: ev.replayEquivalence.allEquivalent
+      },
+      privacy: {
+        surfacesScanned: ev.privacy.surfacesScanned,
+        rawFindings: ev.privacy.rawFindings
+      },
+      contract: {
+        roundTrips: ev.contract.roundTrips,
+        allSettled: ev.contract.allSettled
+      },
+      migration: {
+        cases: ev.migration.cases,
+        allSucceeded: ev.migration.allSucceeded
+      },
+      health: {
+        samples: ev.health.samples,
+        bounded: ev.health.bounded,
+        idempotent: ev.health.idempotent
+      },
+      performance: {
+        p95Millis: ev.performance.p95Millis,
+        budgetMillis: ev.performance.budgetMillis,
+        samples: ev.performance.samples
+      }
+    }
+  });
+}
+function sameReleaseGates(a, b) {
+  return a.length === b.length && a.every((gate, index) => gate === b[index]);
+}
+function parseReleaseCertificate(value, opencodeVersion, expectedShadowDigest) {
+  const parsed = ReleaseCertificateSchema.safeParse(value);
+  if (!parsed.success) {
+    const detail = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.code}`).join("; ");
+    throw new ReleaseCertificateError("invalid-certificate", detail);
+  }
+  const certificate = parsed.data;
+  const inconsistencies = [];
+  if (certificate.platform !== certificate.evidence.platform) {
+    inconsistencies.push("platform");
+  }
+  if (certificate.opencodeVersion !== certificate.evidence.opencodeVersion) {
+    inconsistencies.push("opencodeVersion");
+  }
+  if (certificate.shadowCertificateDigest !== certificate.evidence.shadowCertificateDigest) {
+    inconsistencies.push("shadowCertificateDigest");
+  }
+  if (inconsistencies.length > 0) {
+    throw new ReleaseCertificateError("field-inconsistency", `top-level/evidence divergence: ${inconsistencies.join(", ")}`);
+  }
+  const failedGates = evaluateReleaseGates(certificate.evidence, expectedShadowDigest);
+  const verdict = failedGates.length === 0 ? "pass" : "fail";
+  if (certificate.verdict !== verdict || !sameReleaseGates(certificate.failedGates, failedGates)) {
+    throw new ReleaseCertificateError("verdict-mismatch", `evidence yields "${verdict}" (${failedGates.join(",") || "no failed gate"})`);
+  }
+  const { digest, ...unsigned } = certificate;
+  if (sha256Hex(canonicalReleaseCertificate(unsigned)) !== digest) {
+    throw new ReleaseCertificateError("digest-mismatch", "certificate digest does not cover the presented evidence");
+  }
+  if (certificate.opencodeVersion !== opencodeVersion) {
+    throw new ReleaseCertificateError("opencode-mismatch", `certified for "${certificate.opencodeVersion}", expected "${opencodeVersion}"`);
+  }
+  return certificate;
+}
+var ShadowDivergenceCodeSchema = z3.enum([
+  "status",
+  "order",
+  "roles",
+  "models",
+  "fixes",
+  "outcome"
+]);
+var RECOMPUTED_DIVERGENCE_CODES = ["fixes"];
+var RecomputedDivergenceCodeSchema = z3.enum(RECOMPUTED_DIVERGENCE_CODES);
+var SoakPolicySchema = z3.object({
+  minimumGenuineObservations: z3.number().int().positive(),
+  minimumDistinctDays: z3.number().int().positive(),
+  requireGenuineUsageOnAllPlatforms: z3.boolean(),
+  supportedOpencodeVersion: z3.string().min(1),
+  criticalDivergenceCodes: z3.array(RecomputedDivergenceCodeSchema).min(1)
+}).strict();
+var DEFAULT_SOAK_POLICY = {
+  minimumGenuineObservations: 100,
+  minimumDistinctDays: 14,
+  requireGenuineUsageOnAllPlatforms: true,
+  supportedOpencodeVersion: "1.17.13",
+  criticalDivergenceCodes: ["fixes"]
+};
+var SoakPlatformEnumSchema = z3.enum(["linux", "win32", "darwin"]);
+var SoakPrivacyPairEvidenceSchema = z3.object({
+  surfacesScanned: z3.number().int().nonnegative(),
+  rawFindings: z3.number().int().nonnegative()
+}).strict();
+var SoakDuplicateEffectPairEvidenceSchema = z3.object({
+  effectsExamined: z3.number().int().nonnegative(),
+  duplicatesFound: z3.number().int().nonnegative()
+}).strict();
+var SoakModelVerificationPairEvidenceSchema = z3.object({
+  nodesChecked: z3.number().int().nonnegative(),
+  unverified: z3.number().int().nonnegative(),
+  mismatched: z3.number().int().nonnegative()
+}).strict();
+var SoakEvidenceSchema = z3.object({
+  totalObservations: z3.number().int().nonnegative(),
+  genuineUsageObservations: z3.number().int().nonnegative(),
+  ciSyntheticObservations: z3.number().int().nonnegative(),
+  recorderCount: z3.number().int().nonnegative(),
+  firstTimestamp: z3.string().datetime().nullable(),
+  lastTimestamp: z3.string().datetime().nullable(),
+  distinctDays: z3.number().int().nonnegative(),
+  criticalDivergences: z3.number().int().nonnegative().nullable(),
+  privacy: SoakPrivacyPairEvidenceSchema.nullable(),
+  duplicateEffects: SoakDuplicateEffectPairEvidenceSchema.nullable(),
+  modelVerification: SoakModelVerificationPairEvidenceSchema.nullable(),
+  platformsGenuine: z3.array(SoakPlatformEnumSchema),
+  platformsSynthetic: z3.array(SoakPlatformEnumSchema),
+  opencodeVersionsObserved: z3.array(z3.string().min(1)),
+  invalidChains: z3.number().int().nonnegative()
+}).strict();
+var SoakCertificateSchema = z3.object({
+  version: z3.literal(1),
+  certificate: z3.literal("graph-soak"),
+  trustBoundary: z3.literal("contributors"),
+  policy: SoakPolicySchema,
+  evidence: SoakEvidenceSchema,
+  verdict: z3.enum(["pass", "fail"]),
+  failedGates: z3.array(z3.enum([
+    "minimum-observations",
+    "minimum-duration",
+    "chain-integrity",
+    "zero-critical-divergence",
+    "zero-privacy-breach",
+    "zero-duplicate-effect",
+    "zero-model-mismatch",
+    "os-diversity",
+    "opencode-pin"
+  ])),
+  ledgerDigest: z3.string().regex(/^[0-9a-f]{64}$/),
+  digest: z3.string().regex(/^[0-9a-f]{64}$/)
+}).strict();
+
+class SoakCertificateError extends Error {
+  code;
+  detail;
+  constructor(code, detail) {
+    super(`${code}: ${detail}`);
+    this.name = "SoakCertificateError";
+    this.code = code;
+    this.detail = detail;
+  }
+}
+function evaluateSoakGates(evidence, policy) {
+  const failed = [];
+  if (evidence.genuineUsageObservations < policy.minimumGenuineObservations) {
+    failed.push("minimum-observations");
+  }
+  if (evidence.distinctDays < policy.minimumDistinctDays) {
+    failed.push("minimum-duration");
+  }
+  if (evidence.invalidChains > 0) {
+    failed.push("chain-integrity");
+  }
+  if (evidence.criticalDivergences === null || evidence.criticalDivergences > 0) {
+    failed.push("zero-critical-divergence");
+  }
+  if (evidence.privacy === null || evidence.privacy.surfacesScanned < 1 || evidence.privacy.rawFindings > 0) {
+    failed.push("zero-privacy-breach");
+  }
+  if (evidence.duplicateEffects === null || evidence.duplicateEffects.effectsExamined < 1 || evidence.duplicateEffects.duplicatesFound > 0) {
+    failed.push("zero-duplicate-effect");
+  }
+  if (evidence.modelVerification === null || evidence.modelVerification.nodesChecked < 1 || evidence.modelVerification.mismatched > 0) {
+    failed.push("zero-model-mismatch");
+  }
+  if (policy.requireGenuineUsageOnAllPlatforms) {
+    if (!evidence.platformsGenuine.includes("linux") || !evidence.platformsGenuine.includes("win32")) {
+      failed.push("os-diversity");
+    }
+  } else {
+    const allPlatforms = new Set([
+      ...evidence.platformsGenuine,
+      ...evidence.platformsSynthetic
+    ]);
+    if (!allPlatforms.has("linux") || !allPlatforms.has("win32") || evidence.platformsGenuine.length < 1) {
+      failed.push("os-diversity");
+    }
+  }
+  if (!evidence.opencodeVersionsObserved.includes(policy.supportedOpencodeVersion)) {
+    failed.push("opencode-pin");
+  }
+  return failed;
+}
+function canonicalSoakCertificate(certificate) {
+  const ev = certificate.evidence;
+  const pol = certificate.policy;
+  return JSON.stringify({
+    version: certificate.version,
+    certificate: certificate.certificate,
+    trustBoundary: certificate.trustBoundary,
+    policy: {
+      minimumGenuineObservations: pol.minimumGenuineObservations,
+      minimumDistinctDays: pol.minimumDistinctDays,
+      requireGenuineUsageOnAllPlatforms: pol.requireGenuineUsageOnAllPlatforms,
+      supportedOpencodeVersion: pol.supportedOpencodeVersion,
+      criticalDivergenceCodes: [...pol.criticalDivergenceCodes].sort()
+    },
+    verdict: certificate.verdict,
+    failedGates: [...certificate.failedGates],
+    ledgerDigest: certificate.ledgerDigest,
+    evidence: {
+      totalObservations: ev.totalObservations,
+      genuineUsageObservations: ev.genuineUsageObservations,
+      ciSyntheticObservations: ev.ciSyntheticObservations,
+      recorderCount: ev.recorderCount,
+      firstTimestamp: ev.firstTimestamp,
+      lastTimestamp: ev.lastTimestamp,
+      distinctDays: ev.distinctDays,
+      criticalDivergences: ev.criticalDivergences,
+      privacy: ev.privacy,
+      duplicateEffects: ev.duplicateEffects,
+      modelVerification: ev.modelVerification,
+      platformsGenuine: [...ev.platformsGenuine].sort(),
+      platformsSynthetic: [...ev.platformsSynthetic].sort(),
+      opencodeVersionsObserved: [...ev.opencodeVersionsObserved].sort(),
+      invalidChains: ev.invalidChains
+    }
+  });
+}
+function sameSoakGates(a, b) {
+  return a.length === b.length && a.every((gate, index) => gate === b[index]);
+}
+function sameSoakPolicy(a, b) {
+  return a.minimumGenuineObservations === b.minimumGenuineObservations && a.minimumDistinctDays === b.minimumDistinctDays && a.requireGenuineUsageOnAllPlatforms === b.requireGenuineUsageOnAllPlatforms && a.supportedOpencodeVersion === b.supportedOpencodeVersion && a.criticalDivergenceCodes.length === b.criticalDivergenceCodes.length && [...a.criticalDivergenceCodes].sort().every((code, i) => code === [...b.criticalDivergenceCodes].sort()[i]);
+}
+function parseSoakCertificate(value, expectedPolicy, expectedLedgerDigest) {
+  const parsed = SoakCertificateSchema.safeParse(value);
+  if (!parsed.success) {
+    const detail = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.code}`).join("; ");
+    throw new SoakCertificateError("invalid-certificate", detail);
+  }
+  const certificate = parsed.data;
+  if (!sameSoakPolicy(certificate.policy, expectedPolicy)) {
+    throw new SoakCertificateError("policy-mismatch", "embedded policy diverges from the expected policy");
+  }
+  const failedGates = evaluateSoakGates(certificate.evidence, certificate.policy);
+  const verdict = failedGates.length === 0 ? "pass" : "fail";
+  if (certificate.verdict !== verdict || !sameSoakGates(certificate.failedGates, failedGates)) {
+    throw new SoakCertificateError("verdict-mismatch", `evidence yields "${verdict}" (${failedGates.join(",") || "no failed gate"})`);
+  }
+  const { digest, ...unsigned } = certificate;
+  if (sha256Hex(canonicalSoakCertificate(unsigned)) !== digest) {
+    throw new SoakCertificateError("digest-mismatch", "certificate digest does not cover the presented evidence");
+  }
+  if (certificate.ledgerDigest !== expectedLedgerDigest) {
+    throw new SoakCertificateError("ledger-mismatch", "ledger digest does not match the evidence the caller holds");
+  }
+  return certificate;
+}
+
 // src/local/openai-compatible.ts
 function normalizeBaseURL(baseURL) {
   return baseURL.replace(/\/+$/, "");
@@ -562,8 +1335,8 @@ function errorMessage(error) {
   }
   return String(error);
 }
-async function listOpenAICompatibleModels(baseURL, fetch) {
-  const response = await fetch(modelsEndpoint(baseURL), {
+async function listOpenAICompatibleModels(baseURL, fetch2) {
+  const response = await fetch2(modelsEndpoint(baseURL), {
     method: "GET",
     headers: { accept: "application/json" }
   });
@@ -986,123 +1759,123 @@ function createAvailabilityCache(options) {
 }
 
 // src/telemetry/events.ts
-import { z as z3 } from "zod";
+import { z as z5 } from "zod";
 
 // src/capabilities/types.ts
-import { z as z2 } from "zod";
-var CapabilityTierSchema = z2.union([
-  z2.literal(0),
-  z2.literal(1),
-  z2.literal(2),
-  z2.literal(3),
-  z2.literal(4),
-  z2.literal(5)
+import { z as z4 } from "zod";
+var CapabilityTierSchema = z4.union([
+  z4.literal(0),
+  z4.literal(1),
+  z4.literal(2),
+  z4.literal(3),
+  z4.literal(4),
+  z4.literal(5)
 ]);
-var ComplexityTierSchema = z2.enum([
+var ComplexityTierSchema = z4.enum([
   "trivial",
   "simple",
   "moderate",
   "hard"
 ]);
-var ModelCapabilityProfileSchema = z2.object({
-  ref: z2.object({
-    providerID: z2.string().min(1),
-    modelID: z2.string().min(1)
+var ModelCapabilityProfileSchema = z4.object({
+  ref: z4.object({
+    providerID: z4.string().min(1),
+    modelID: z4.string().min(1)
   }),
-  kind: z2.enum(["local", "frontier", "router"]),
-  contextWindow: z2.number().int().positive(),
-  maxOutputTokens: z2.number().int().positive(),
-  supportsToolCalling: z2.boolean(),
-  supportsVision: z2.boolean(),
+  kind: z4.enum(["local", "frontier", "router"]),
+  contextWindow: z4.number().int().positive(),
+  maxOutputTokens: z4.number().int().positive(),
+  supportsToolCalling: z4.boolean(),
+  supportsVision: z4.boolean(),
   reasoningTier: CapabilityTierSchema,
   codeQualityTier: CapabilityTierSchema,
-  costPer1M: z2.object({
-    inputUSD: z2.number().min(0),
-    outputUSD: z2.number().min(0)
+  costPer1M: z4.object({
+    inputUSD: z4.number().min(0),
+    outputUSD: z4.number().min(0)
   }),
-  availability: z2.enum(["available", "degraded", "unavailable"])
+  availability: z4.enum(["available", "degraded", "unavailable"])
 });
 
 // src/telemetry/events.ts
 var EVENT_SCHEMA_VERSION = 1;
-var EventBaseSchema = z3.object({
-  v: z3.literal(EVENT_SCHEMA_VERSION),
-  ts: z3.number().finite(),
-  sessionID: z3.string().min(1)
+var EventBaseSchema = z5.object({
+  v: z5.literal(EVENT_SCHEMA_VERSION),
+  ts: z5.number().finite(),
+  sessionID: z5.string().min(1)
 });
 var RouteEventSchema = EventBaseSchema.extend({
-  type: z3.literal("route"),
-  promptHash: z3.string().min(1),
-  promptChars: z3.number().int().min(0),
+  type: z5.literal("route"),
+  promptHash: z5.string().min(1),
+  promptChars: z5.number().int().min(0),
   tier: ComplexityTierSchema,
-  routeKind: z3.enum(["local", "frontier"]),
+  routeKind: z5.enum(["local", "frontier"]),
   selected: ModelRefSchema,
-  rationale: z3.string(),
-  estimatedCostUSD: z3.number().finite().min(0),
-  baselineCostUSD: z3.number().finite().min(0),
-  estimatedSavingsUSD: z3.number().finite(),
-  budgetAction: z3.string().min(1),
-  tokensIn: z3.number().int().min(0).optional(),
-  tokensOut: z3.number().int().min(0).optional(),
-  decisionID: z3.string().min(1).optional(),
-  agent: z3.string().min(1).optional(),
-  success: z3.boolean().optional(),
-  batchID: z3.string().min(1).optional(),
-  taskID: z3.string().min(1).optional(),
-  failureReason: z3.string().min(1).optional(),
-  failureStage: z3.string().min(1).optional()
+  rationale: z5.string(),
+  estimatedCostUSD: z5.number().finite().min(0),
+  baselineCostUSD: z5.number().finite().min(0),
+  estimatedSavingsUSD: z5.number().finite(),
+  budgetAction: z5.string().min(1),
+  tokensIn: z5.number().int().min(0).optional(),
+  tokensOut: z5.number().int().min(0).optional(),
+  decisionID: z5.string().min(1).optional(),
+  agent: z5.string().min(1).optional(),
+  success: z5.boolean().optional(),
+  batchID: z5.string().min(1).optional(),
+  taskID: z5.string().min(1).optional(),
+  failureReason: z5.string().min(1).optional(),
+  failureStage: z5.string().min(1).optional()
 });
 var MessageEventSchema = EventBaseSchema.extend({
-  type: z3.literal("message"),
-  providerID: z3.string().min(1),
-  modelID: z3.string().min(1),
-  agent: z3.string().min(1).optional(),
-  mode: z3.string().min(1).optional(),
-  messageID: z3.string().min(1).optional(),
-  costUSD: z3.number().finite().min(0),
-  tokensIn: z3.number().int().min(0),
-  tokensOut: z3.number().int().min(0),
-  tokensReasoning: z3.number().int().min(0),
-  tokensCacheRead: z3.number().int().min(0),
-  tokensCacheWrite: z3.number().int().min(0),
-  durationMs: z3.number().int().min(0)
+  type: z5.literal("message"),
+  providerID: z5.string().min(1),
+  modelID: z5.string().min(1),
+  agent: z5.string().min(1).optional(),
+  mode: z5.string().min(1).optional(),
+  messageID: z5.string().min(1).optional(),
+  costUSD: z5.number().finite().min(0),
+  tokensIn: z5.number().int().min(0),
+  tokensOut: z5.number().int().min(0),
+  tokensReasoning: z5.number().int().min(0),
+  tokensCacheRead: z5.number().int().min(0),
+  tokensCacheWrite: z5.number().int().min(0),
+  durationMs: z5.number().int().min(0)
 });
 var ToolcallEventSchema = EventBaseSchema.extend({
-  type: z3.literal("toolcall"),
-  tool: z3.string().min(1),
-  callID: z3.string().min(1),
-  agent: z3.string().min(1).optional(),
-  durationMs: z3.number().int().min(0),
-  ok: z3.boolean(),
-  title: z3.string().optional()
+  type: z5.literal("toolcall"),
+  tool: z5.string().min(1),
+  callID: z5.string().min(1),
+  agent: z5.string().min(1).optional(),
+  durationMs: z5.number().int().min(0),
+  ok: z5.boolean(),
+  title: z5.string().optional()
 });
 var MeetingEventSchema = EventBaseSchema.extend({
-  type: z3.literal("meeting"),
-  batchID: z3.string().min(1),
-  purpose: z3.string().optional(),
-  roles: z3.array(z3.string().min(1)),
-  decisionIDs: z3.array(z3.string().min(1)).optional()
+  type: z5.literal("meeting"),
+  batchID: z5.string().min(1),
+  purpose: z5.string().optional(),
+  roles: z5.array(z5.string().min(1)),
+  decisionIDs: z5.array(z5.string().min(1)).optional()
 });
 var DecisionEventSchema = EventBaseSchema.extend({
-  type: z3.literal("decision"),
-  agent: z3.string().min(1).optional(),
-  summary: z3.string().min(1),
-  tags: z3.array(z3.string().min(1)).optional()
+  type: z5.literal("decision"),
+  agent: z5.string().min(1).optional(),
+  summary: z5.string().min(1),
+  tags: z5.array(z5.string().min(1)).optional()
 });
 var ActivityEventSchema = EventBaseSchema.extend({
-  type: z3.literal("activity"),
-  kind: z3.enum(["route", "agent", "decision", "commit"]),
-  agent: z3.string().min(1).optional(),
-  summary: z3.string().min(1)
+  type: z5.literal("activity"),
+  kind: z5.enum(["route", "agent", "decision", "commit"]),
+  agent: z5.string().min(1).optional(),
+  summary: z5.string().min(1)
 });
 var SessionEndpointEventSchema = EventBaseSchema.extend({
-  type: z3.literal("session-endpoint"),
-  url: z3.string().url(),
-  directory: z3.string().min(1).optional(),
-  worktree: z3.string().min(1).optional(),
-  title: z3.string().min(1).optional()
+  type: z5.literal("session-endpoint"),
+  url: z5.string().url(),
+  directory: z5.string().min(1).optional(),
+  worktree: z5.string().min(1).optional(),
+  title: z5.string().min(1).optional()
 });
-var OpenTeamEventSchema = z3.discriminatedUnion("type", [
+var OpenTeamEventSchema = z5.discriminatedUnion("type", [
   RouteEventSchema,
   MessageEventSchema,
   ToolcallEventSchema,
@@ -1479,6 +2252,15 @@ function renderDoctor(input) {
   if (reachable === 0) {
     lines.push("  ⚠ Ningún runtime local alcanzable: todo el tráfico irá a frontier.");
   }
+  if (input.graphHealth !== undefined) {
+    const h = input.graphHealth;
+    lines.push("  graph health:");
+    lines.push(`    recuperación requerida: ${h.recoveryRequired ? "sí" : "no"}`);
+    lines.push(`    efectos desconocidos:   ${h.unknownEffects}`);
+    lines.push(`    completaciones tardías: ${h.staleCompletions}`);
+    lines.push(`    conflictos:             ${h.conflicts}`);
+    lines.push(`    kill switch:            ${h.killSwitch ? "activo" : "inactivo"}`);
+  }
   return lines.join(`
 `);
 }
@@ -1927,42 +2709,254 @@ function createCommandTool(deps) {
   });
 }
 
-// src/capabilities/budget.ts
-var WARNING_UTILIZATION = 0.8;
-function projectedSpend(current, estimatedCostUSD) {
-  return Math.max(0, current) + Math.max(0, estimatedCostUSD);
+// src/plugin/graphTool.ts
+import { tool as tool2 } from "@opencode-ai/plugin";
+
+// src/graph/schema.ts
+import { z as z7 } from "zod";
+
+// src/context/schema.ts
+import { z as z6 } from "zod";
+var PrivacyClassSchema = z6.enum(["public", "internal", "sensitive"]);
+var Sha256Schema2 = z6.string().regex(/^[0-9a-f]{64}$/, "expected lowercase hex sha-256");
+var IdentifierSchema = z6.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/, "invalid identifier");
+var TaskAnchorSchema = z6.object({
+  taskID: IdentifierSchema,
+  specDigest: Sha256Schema2
+}).strict();
+var ContextRefSchema = z6.object({
+  uri: z6.string().min(1).max(1024),
+  sha256: Sha256Schema2,
+  bytes: z6.number().int().nonnegative(),
+  mediaType: z6.string().min(1).max(128).optional()
+}).strict();
+var ManifestEntrySchema = z6.object({
+  label: IdentifierSchema,
+  sha256: Sha256Schema2,
+  bytes: z6.number().int().nonnegative(),
+  ref: ContextRefSchema.optional()
+}).strict();
+var ArtifactManifestSchema = z6.object({
+  version: z6.literal(1),
+  taskID: IdentifierSchema,
+  privacyClass: PrivacyClassSchema,
+  entries: z6.array(ManifestEntrySchema)
+}).strict();
+var NodeContextContractSchema = z6.object({
+  version: z6.literal(1),
+  refs: z6.array(ContextRefSchema),
+  privacyClass: PrivacyClassSchema,
+  maxInputTokens: z6.number().int().positive().optional()
+}).strict();
+
+// src/graph/schema.ts
+var GRAPH_SPEC_VERSION = 1;
+var GRAPH_EVENT_VERSION = 1;
+var NodeIDSchema = z7.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "invalid node id");
+var NodeRoleSchema = z7.enum(["implementer", "reviewer"]);
+var OperationIDSchema = z7.string().regex(/^[0-9a-f]{8,64}$/, "invalid operation id");
+var AttemptIDSchema = z7.string().regex(/^[0-9a-f]{8,64}$/, "invalid attempt id");
+var ErrorClassSchema = z7.enum([
+  "transient",
+  "permanent",
+  "timeout",
+  "cancelled",
+  "unknown"
+]);
+var GraphNodeSchema = z7.object({
+  id: NodeIDSchema,
+  role: NodeRoleSchema,
+  dependsOn: z7.array(NodeIDSchema).default([]),
+  anchor: TaskAnchorSchema,
+  reviews: NodeIDSchema.optional()
+}).strict();
+var GraphSpecV1Schema = z7.object({
+  version: z7.literal(GRAPH_SPEC_VERSION),
+  runID: NodeIDSchema,
+  nodes: z7.array(GraphNodeSchema).min(1)
+}).strict();
+var eventEnvelope = {
+  v: z7.literal(GRAPH_EVENT_VERSION),
+  seq: z7.number().int().nonnegative(),
+  runID: NodeIDSchema
+};
+var RunStartedEventSchema = z7.object({
+  ...eventEnvelope,
+  type: z7.literal("run.started"),
+  specDigest: Sha256Schema2
+}).strict();
+var NodeDispatchedEventSchema = z7.object({
+  ...eventEnvelope,
+  type: z7.literal("node.dispatched"),
+  nodeID: NodeIDSchema,
+  operationID: OperationIDSchema,
+  attemptID: AttemptIDSchema
+}).strict();
+var NodeSucceededEventSchema = z7.object({
+  ...eventEnvelope,
+  type: z7.literal("node.succeeded"),
+  nodeID: NodeIDSchema,
+  operationID: OperationIDSchema,
+  attemptID: AttemptIDSchema,
+  artifact: ContextRefSchema
+}).strict();
+var NodeFailedEventSchema = z7.object({
+  ...eventEnvelope,
+  type: z7.literal("node.failed"),
+  nodeID: NodeIDSchema,
+  operationID: OperationIDSchema,
+  attemptID: AttemptIDSchema,
+  errorClass: ErrorClassSchema
+}).strict();
+var NodeCancelledEventSchema = z7.object({
+  ...eventEnvelope,
+  type: z7.literal("node.cancelled"),
+  nodeID: NodeIDSchema
+}).strict();
+var RunCompletedEventSchema = z7.object({ ...eventEnvelope, type: z7.literal("run.completed") }).strict();
+var RunFailedEventSchema = z7.object({ ...eventEnvelope, type: z7.literal("run.failed") }).strict();
+var RunCancelledEventSchema = z7.object({ ...eventEnvelope, type: z7.literal("run.cancelled") }).strict();
+var GraphEventV1Schema = z7.discriminatedUnion("type", [
+  RunStartedEventSchema,
+  NodeDispatchedEventSchema,
+  NodeSucceededEventSchema,
+  NodeFailedEventSchema,
+  NodeCancelledEventSchema,
+  RunCompletedEventSchema,
+  RunFailedEventSchema,
+  RunCancelledEventSchema
+]);
+
+// src/graph/ids.ts
+var NUL = "\x00";
+function operationID(runID, nodeID, revision = 0) {
+  return sha256Hex(`op${NUL}${runID}${NUL}${nodeID}${NUL}${revision}`).slice(0, 32);
+}
+function attemptID(operation, attempt) {
+  return sha256Hex(`att${NUL}${operation}${NUL}${attempt}`).slice(0, 32);
+}
+function canonicalSpec(spec) {
+  const nodes = spec.nodes.map((node) => ({
+    id: node.id,
+    role: node.role,
+    dependsOn: [...node.dependsOn],
+    anchor: { taskID: node.anchor.taskID, specDigest: node.anchor.specDigest },
+    ...node.reviews === undefined ? {} : { reviews: node.reviews }
+  }));
+  return JSON.stringify({
+    version: spec.version,
+    runID: spec.runID,
+    nodes
+  });
 }
-function budgetExceeded(projected, limit) {
-  return limit !== undefined && projected >= limit;
+function graphSpecDigest(spec) {
+  return sha256Hex(canonicalSpec(spec));
 }
-function budgetNearLimit(projected, limit) {
-  return limit !== undefined && projected >= limit * WARNING_UTILIZATION && projected < limit;
+
+// src/graph/validate.ts
+class GraphValidationError extends Error {
+  code;
+  detail;
+  constructor(code, detail) {
+    super(`${code}: ${detail}`);
+    this.name = "GraphValidationError";
+    this.code = code;
+    this.detail = detail;
+  }
 }
-function exhaustedDecision(budgets, reason) {
-  return {
-    action: budgets.hardStopOnBudgetExhaustion ? "blockFrontier" : "forceLocal",
-    reason
-  };
+function indexNodes(nodes) {
+  const byID = new Map;
+  for (const node of nodes) {
+    if (byID.has(node.id)) {
+      throw new GraphValidationError("duplicate-node", node.id);
+    }
+    byID.set(node.id, node);
+  }
+  return byID;
 }
-function evaluateBudget(state, estimatedCostUSD, budgets) {
-  const projectedSessionUSD = projectedSpend(state.sessionUSD, estimatedCostUSD);
-  const projectedMonthlyUSD = budgets.monthlyUSD === undefined ? undefined : projectedSpend(state.monthlyUSD ?? 0, estimatedCostUSD);
-  if (budgetExceeded(projectedSessionUSD, budgets.sessionUSD)) {
-    return exhaustedDecision(budgets, "session-budget-exhausted");
+function assertDependenciesExist(nodes, byID) {
+  for (const node of nodes) {
+    for (const dep of node.dependsOn) {
+      if (!byID.has(dep)) {
+        throw new GraphValidationError("missing-dependency", `${node.id} -> ${dep}`);
+      }
+    }
   }
-  if (budgetExceeded(projectedMonthlyUSD ?? 0, budgets.monthlyUSD)) {
-    return exhaustedDecision(budgets, "monthly-budget-exhausted");
+}
+function assertAcyclic(nodes, byID) {
+  const state = new Map;
+  const visit = (id) => {
+    const current = state.get(id);
+    if (current === "done") {
+      return;
+    }
+    if (current === "visiting") {
+      throw new GraphValidationError("cycle", id);
+    }
+    state.set(id, "visiting");
+    const node = byID.get(id);
+    for (const dep of node.dependsOn) {
+      visit(dep);
+    }
+    state.set(id, "done");
+  };
+  for (const node of nodes) {
+    visit(node.id);
   }
-  if (state.frontierTokens !== undefined && budgets.frontierTokensPerSession !== undefined && state.frontierTokens >= budgets.frontierTokensPerSession) {
-    return exhaustedDecision(budgets, "frontier-token-budget-exhausted");
+}
+function assertReviewRules(nodes, byID) {
+  for (const node of nodes) {
+    if (node.role === "implementer") {
+      if (node.reviews !== undefined) {
+        throw new GraphValidationError("implementer-has-review", node.id);
+      }
+      continue;
+    }
+    if (node.reviews === undefined) {
+      throw new GraphValidationError("reviewer-missing-review", node.id);
+    }
+    if (node.reviews === node.id) {
+      throw new GraphValidationError("self-review", node.id);
+    }
+    const target = byID.get(node.reviews);
+    if (target === undefined || target.role !== "implementer") {
+      throw new GraphValidationError("invalid-review-target", `${node.id} -> ${node.reviews}`);
+    }
   }
-  if (budgetNearLimit(projectedSessionUSD, budgets.sessionUSD)) {
-    return { action: "warn", reason: "session-budget-near-limit" };
+}
+function assertConnected(nodes) {
+  const adjacency = new Map;
+  for (const node of nodes) {
+    adjacency.set(node.id, adjacency.get(node.id) ?? new Set);
+    for (const dep of node.dependsOn) {
+      adjacency.get(node.id)?.add(dep);
+      const back = adjacency.get(dep) ?? new Set;
+      back.add(node.id);
+      adjacency.set(dep, back);
+    }
   }
-  if (budgetNearLimit(projectedMonthlyUSD ?? 0, budgets.monthlyUSD)) {
-    return { action: "warn", reason: "monthly-budget-near-limit" };
+  const root = nodes[0];
+  const seen = new Set([root.id]);
+  const queue = [root.id];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    for (const neighbor of adjacency.get(id) ?? new Set) {
+      if (!seen.has(neighbor)) {
+        seen.add(neighbor);
+        queue.push(neighbor);
+      }
+    }
+  }
+  if (seen.size !== nodes.length) {
+    throw new GraphValidationError("disconnected", `${seen.size}/${nodes.length} reachable`);
   }
-  return { action: "ok" };
+}
+function validateGraphSpec(spec) {
+  const byID = indexNodes(spec.nodes);
+  assertDependenciesExist(spec.nodes, byID);
+  assertAcyclic(spec.nodes, byID);
+  assertReviewRules(spec.nodes, byID);
+  assertConnected(spec.nodes);
 }
 
 // src/capabilities/classify.ts
@@ -2039,24 +3033,62 @@ function classifyHeuristic(task) {
   };
 }
 
-// src/router/modelSelection.ts
-function modelKey2(model) {
-  return `${model.providerID}/${model.modelID}`;
+// src/capabilities/budget.ts
+var WARNING_UTILIZATION = 0.8;
+function projectedSpend(current, estimatedCostUSD) {
+  return Math.max(0, current) + Math.max(0, estimatedCostUSD);
 }
-function sameModel(left, right) {
-  return left.providerID === right.providerID && left.modelID === right.modelID;
+function budgetExceeded(projected, limit) {
+  return limit !== undefined && projected >= limit;
 }
-function compareModels(left, right) {
-  return modelKey2(left).localeCompare(modelKey2(right));
+function budgetNearLimit(projected, limit) {
+  return limit !== undefined && projected >= limit * WARNING_UTILIZATION && projected < limit;
 }
-function uniqueModelSelections(models) {
-  const byKey = new Map;
-  for (const model of models) {
-    byKey.set(modelKey2(model), model);
-  }
-  return [...byKey.values()].sort(compareModels);
+function exhaustedDecision(budgets, reason) {
+  return {
+    action: budgets.hardStopOnBudgetExhaustion ? "blockFrontier" : "forceLocal",
+    reason
+  };
 }
-function localDefault(config) {
+function evaluateBudget(state, estimatedCostUSD, budgets) {
+  const projectedSessionUSD = projectedSpend(state.sessionUSD, estimatedCostUSD);
+  const projectedMonthlyUSD = budgets.monthlyUSD === undefined ? undefined : projectedSpend(state.monthlyUSD ?? 0, estimatedCostUSD);
+  if (budgetExceeded(projectedSessionUSD, budgets.sessionUSD)) {
+    return exhaustedDecision(budgets, "session-budget-exhausted");
+  }
+  if (budgetExceeded(projectedMonthlyUSD ?? 0, budgets.monthlyUSD)) {
+    return exhaustedDecision(budgets, "monthly-budget-exhausted");
+  }
+  if (state.frontierTokens !== undefined && budgets.frontierTokensPerSession !== undefined && state.frontierTokens >= budgets.frontierTokensPerSession) {
+    return exhaustedDecision(budgets, "frontier-token-budget-exhausted");
+  }
+  if (budgetNearLimit(projectedSessionUSD, budgets.sessionUSD)) {
+    return { action: "warn", reason: "session-budget-near-limit" };
+  }
+  if (budgetNearLimit(projectedMonthlyUSD ?? 0, budgets.monthlyUSD)) {
+    return { action: "warn", reason: "monthly-budget-near-limit" };
+  }
+  return { action: "ok" };
+}
+
+// src/router/modelSelection.ts
+function modelKey2(model) {
+  return `${model.providerID}/${model.modelID}`;
+}
+function sameModel(left, right) {
+  return left.providerID === right.providerID && left.modelID === right.modelID;
+}
+function compareModels(left, right) {
+  return modelKey2(left).localeCompare(modelKey2(right));
+}
+function uniqueModelSelections(models) {
+  const byKey = new Map;
+  for (const model of models) {
+    byKey.set(modelKey2(model), model);
+  }
+  return [...byKey.values()].sort(compareModels);
+}
+function localDefault(config) {
   return config.local.runtimes.find((runtime) => runtime.enabled)?.defaultModel ?? config.router.localDefault;
 }
 function resolveConfiguredFrontierBaseline(config) {
@@ -2359,22 +3391,22 @@ function toCostRecord(decision2, context) {
 }
 
 // src/telemetry/types.ts
-import { z as z4 } from "zod";
-var CostRecordSchema = z4.object({
-  ts: z4.number().finite(),
-  sessionID: z4.string().min(1).optional(),
-  promptHash: z4.string().min(1),
-  promptChars: z4.number().int().min(0),
+import { z as z8 } from "zod";
+var CostRecordSchema = z8.object({
+  ts: z8.number().finite(),
+  sessionID: z8.string().min(1).optional(),
+  promptHash: z8.string().min(1),
+  promptChars: z8.number().int().min(0),
   tier: ComplexityTierSchema,
-  routeKind: z4.enum(["local", "frontier"]),
+  routeKind: z8.enum(["local", "frontier"]),
   selected: ModelRefSchema,
-  rationale: z4.string(),
-  estimatedCostUSD: z4.number().finite().min(0),
-  baselineCostUSD: z4.number().finite().min(0),
-  estimatedSavingsUSD: z4.number().finite(),
-  budgetAction: z4.string().min(1),
-  tokensIn: z4.number().int().min(0).optional(),
-  tokensOut: z4.number().int().min(0).optional()
+  rationale: z8.string(),
+  estimatedCostUSD: z8.number().finite().min(0),
+  baselineCostUSD: z8.number().finite().min(0),
+  estimatedSavingsUSD: z8.number().finite(),
+  budgetAction: z8.string().min(1),
+  tokensIn: z8.number().int().min(0).optional(),
+  tokensOut: z8.number().int().min(0).optional()
 });
 
 // src/telemetry/read.ts
@@ -2534,6 +3566,973 @@ function hashPrompt(prompt) {
   return `fnv1a32:${(hash >>> 0).toString(16).padStart(8, "0")}`;
 }
 
+// src/orchestrator/graphIngress.ts
+var ACTIVE_INGRESS_BRAND = Symbol("openteam.activeIngress");
+function gateReason(policy) {
+  if (policy.capability === undefined) {
+    return "gate-closed";
+  }
+  if (policy.graph.killSwitch) {
+    return "kill-switch";
+  }
+  return policy.graph.configuredMode === "active" ? undefined : "graph-disabled";
+}
+function decideIngress(policy, taskID) {
+  const blocked = gateReason(policy);
+  if (blocked !== undefined) {
+    return { route: "legacy", reason: blocked };
+  }
+  if (!policy.allowList.includes(taskID)) {
+    return { route: "legacy", reason: "not-allow-listed" };
+  }
+  return { route: "graph", taskID };
+}
+
+// src/plugin/legacyRunProducer.ts
+function toObservedNode(node) {
+  return {
+    id: node.id,
+    role: node.role,
+    model: node.model,
+    ok: node.ok,
+    ...node.sessionRef !== undefined ? { sessionRef: node.sessionRef } : {},
+    ...node.errorClass !== undefined ? { errorClass: node.errorClass } : {}
+  };
+}
+function buildObservedRun(payload) {
+  return {
+    runID: payload.runID,
+    executed: true,
+    status: payload.status,
+    fixes: payload.fixes,
+    nodes: payload.nodes.map(toObservedNode),
+    ...payload.parentSessionRef !== undefined ? { parentSessionRef: payload.parentSessionRef } : {}
+  };
+}
+function crossVerify(payload, tracker) {
+  const unverifiedModels = [];
+  const modelMismatches = [];
+  const unknownSessions = [];
+  for (const node of payload.nodes) {
+    if (node.sessionRef !== undefined) {
+      const mv = tracker.verifyModel(node.sessionRef, node.model);
+      if (!mv.verified) {
+        unverifiedModels.push(node.id);
+      } else if (!mv.match) {
+        modelMismatches.push(node.id);
+      }
+      const sv = tracker.verifySessionRef(node.sessionRef);
+      if (sv.known === false) {
+        unknownSessions.push(node.id);
+      }
+    } else {
+      unverifiedModels.push(node.id);
+    }
+  }
+  return { unverifiedModels, modelMismatches, unknownSessions };
+}
+function formatWarnings(verification) {
+  const warnings = [];
+  if (verification.unverifiedModels.length > 0) {
+    warnings.push(`model not verifiable for nodes: ${verification.unverifiedModels.join(", ")}`);
+  }
+  if (verification.modelMismatches.length > 0) {
+    warnings.push(`model mismatch for nodes: ${verification.modelMismatches.join(", ")}`);
+  }
+  if (verification.unknownSessions.length > 0) {
+    warnings.push(`unknown sessionRef for nodes: ${verification.unknownSessions.join(", ")}`);
+  }
+  return warnings;
+}
+function formatResponse(response) {
+  const parts = [`report-run: ${response.result}`];
+  if (response.detail !== undefined) {
+    parts.push(response.detail);
+  }
+  if (response.warnings !== undefined && response.warnings.length > 0) {
+    parts.push(`warnings: ${response.warnings.join("; ")}`);
+  }
+  return parts.join(" — ");
+}
+
+// src/plugin/reportRunSchema.ts
+import { z as z10 } from "zod";
+
+// src/plugin/graphShadowIngress.ts
+import { z as z9 } from "zod";
+var LEGACY_EXECUTION_TRACE_VERSION = 1;
+var LegacyExecutionStatusSchema = z9.enum([
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var LegacyReviewOutcomeSchema = z9.enum([
+  "approved",
+  "rejected",
+  "inconclusive"
+]);
+var LegacyTraceNodeV1Schema = z9.object({
+  id: NodeIDSchema,
+  role: NodeRoleSchema,
+  model: z9.string().min(1),
+  sessionRef: z9.string().min(1).optional(),
+  errorClass: ErrorClassSchema.optional()
+}).strict();
+var LegacyExecutionTraceV1Schema = z9.object({
+  version: z9.literal(LEGACY_EXECUTION_TRACE_VERSION),
+  runID: NodeIDSchema,
+  status: LegacyExecutionStatusSchema,
+  outcome: LegacyReviewOutcomeSchema,
+  fixes: z9.number().int().nonnegative(),
+  nodes: z9.array(LegacyTraceNodeV1Schema).min(1),
+  parentSessionRef: z9.string().min(1).optional()
+}).strict();
+function gateReason2(gate) {
+  if (gate === undefined || gate.mode === "off") {
+    return "graph-disabled";
+  }
+  if (gate.killSwitch) {
+    return "kill-switch";
+  }
+  return;
+}
+function deriveOutcome(nodes) {
+  for (let index = nodes.length - 1;index >= 0; index -= 1) {
+    const node = nodes[index];
+    if (node !== undefined && node.role === "reviewer") {
+      return node.ok ? "approved" : "rejected";
+    }
+  }
+  return "inconclusive";
+}
+function toTraceNode(node) {
+  return {
+    id: node.id,
+    role: node.role,
+    model: node.model,
+    ...node.sessionRef !== undefined ? { sessionRef: node.sessionRef } : {},
+    ...node.errorClass !== undefined ? { errorClass: node.errorClass } : {}
+  };
+}
+function ingestLegacyExecution(observation, gate) {
+  const gated = gateReason2(gate);
+  if (gated !== undefined) {
+    return { eligible: false, reason: gated };
+  }
+  if (!observation.executed) {
+    return { eligible: false, reason: "not-executed" };
+  }
+  if (observation.nodes.length === 0) {
+    return { eligible: false, reason: "no-observation" };
+  }
+  const trace = {
+    version: LEGACY_EXECUTION_TRACE_VERSION,
+    runID: observation.runID,
+    status: observation.status,
+    outcome: deriveOutcome(observation.nodes),
+    fixes: Math.max(0, Math.trunc(observation.fixes)),
+    nodes: observation.nodes.map(toTraceNode),
+    ...observation.parentSessionRef !== undefined ? { parentSessionRef: observation.parentSessionRef } : {}
+  };
+  assertReferenceOnly(trace);
+  return { eligible: true, trace };
+}
+
+class LegacyTraceError extends Error {
+  code = "invalid-legacy-trace";
+  issues;
+  constructor(error) {
+    super(`invalid-legacy-trace: ${error.issues.map((issue) => issue.message).join("; ")}`);
+    this.name = "LegacyTraceError";
+    this.issues = error.issues.map((issue) => issue.message);
+  }
+}
+function parseLegacyExecutionTrace(input) {
+  const result = LegacyExecutionTraceV1Schema.safeParse(input);
+  if (!result.success) {
+    throw new LegacyTraceError(result.error);
+  }
+  return result.data;
+}
+
+// src/plugin/reportRunSchema.ts
+var ReportRunNodeSchema = z10.object({
+  id: NodeIDSchema,
+  role: NodeRoleSchema,
+  model: z10.string().min(1),
+  ok: z10.boolean(),
+  sessionRef: z10.string().min(1).optional(),
+  errorClass: ErrorClassSchema.optional()
+}).strict();
+var ReportRunPayloadSchema = z10.object({
+  runID: NodeIDSchema,
+  status: LegacyExecutionStatusSchema,
+  fixes: z10.number().int().nonnegative(),
+  nodes: z10.array(ReportRunNodeSchema).min(1),
+  parentSessionRef: z10.string().min(1).optional()
+}).strict();
+
+// src/graph/types.ts
+var TERMINAL_NODE_STATUSES = new Set([
+  "succeeded",
+  "cancelled"
+]);
+var TERMINAL_RUN_STATUSES = new Set([
+  "completed",
+  "failed",
+  "cancelled"
+]);
+
+// src/graph/reducer.ts
+class ReducerError extends Error {
+  code;
+  detail;
+  constructor(code, detail) {
+    super(`${code}: ${detail}`);
+    this.name = "ReducerError";
+    this.code = code;
+    this.detail = detail;
+  }
+}
+function initialState(spec) {
+  const nodes = {};
+  for (const node of spec.nodes) {
+    nodes[node.id] = { status: "pending", attempts: 0 };
+  }
+  return { runID: spec.runID, status: "running", seq: -1, nodes };
+}
+function withNode(state, nodeID, next) {
+  return {
+    ...state,
+    nodes: { ...state.nodes, [nodeID]: next },
+    seq: state.seq
+  };
+}
+function specNode(spec, nodeID) {
+  return spec.nodes.find((node) => node.id === nodeID);
+}
+function applyRunStarted(state, seq, specDigest) {
+  if (state.specDigest !== undefined) {
+    if (state.specDigest === specDigest) {
+      return state;
+    }
+    throw new ReducerError("run-started-conflict", specDigest);
+  }
+  return { ...state, specDigest, seq };
+}
+function applyDispatched(spec, state, event) {
+  const node = specNode(spec, event.nodeID);
+  const current = state.nodes[event.nodeID];
+  if (node === undefined || current === undefined) {
+    throw new ReducerError("unknown-node", event.nodeID);
+  }
+  for (const dep of node.dependsOn) {
+    if (state.nodes[dep]?.status !== "succeeded") {
+      throw new ReducerError("dependency-not-satisfied", `${event.nodeID} <- ${dep}`);
+    }
+  }
+  const running = {
+    status: "running",
+    attempts: current.attempts + 1,
+    operationID: event.operationID,
+    attemptID: event.attemptID
+  };
+  if (current.status === "pending") {
+    return withNode({ ...state, seq: event.seq }, event.nodeID, running);
+  }
+  if (current.status === "failed") {
+    if (current.operationID !== event.operationID) {
+      throw new ReducerError("dispatch-conflict", event.nodeID);
+    }
+    return withNode({ ...state, seq: event.seq }, event.nodeID, running);
+  }
+  if (current.status === "running") {
+    if (current.operationID === event.operationID && current.attemptID === event.attemptID) {
+      return state;
+    }
+    throw new ReducerError("dispatch-conflict", event.nodeID);
+  }
+  throw new ReducerError("illegal-transition", `dispatch ${current.status}`);
+}
+function applySucceeded(state, event) {
+  const current = state.nodes[event.nodeID];
+  if (current === undefined) {
+    throw new ReducerError("unknown-node", event.nodeID);
+  }
+  if (current.status === "succeeded") {
+    if (current.operationID === event.operationID && current.artifactSha256 === event.artifact.sha256) {
+      return state;
+    }
+    throw new ReducerError("receipt-conflict", event.nodeID);
+  }
+  if (current.status !== "running") {
+    throw new ReducerError("illegal-transition", `succeed ${current.status}`);
+  }
+  if (current.operationID !== event.operationID || current.attemptID !== event.attemptID) {
+    throw new ReducerError("receipt-conflict", event.nodeID);
+  }
+  return withNode({ ...state, seq: event.seq }, event.nodeID, {
+    status: "succeeded",
+    attempts: current.attempts,
+    operationID: event.operationID,
+    attemptID: event.attemptID,
+    artifactSha256: event.artifact.sha256
+  });
+}
+function applyFailed(state, event) {
+  const current = state.nodes[event.nodeID];
+  if (current === undefined) {
+    throw new ReducerError("unknown-node", event.nodeID);
+  }
+  if (current.status === "failed") {
+    if (current.operationID === event.operationID && current.attemptID === event.attemptID) {
+      return state;
+    }
+    throw new ReducerError("receipt-conflict", event.nodeID);
+  }
+  if (current.status !== "running") {
+    throw new ReducerError("illegal-transition", `fail ${current.status}`);
+  }
+  if (current.operationID !== event.operationID || current.attemptID !== event.attemptID) {
+    throw new ReducerError("receipt-conflict", event.nodeID);
+  }
+  return withNode({ ...state, seq: event.seq }, event.nodeID, {
+    status: "failed",
+    attempts: current.attempts,
+    operationID: event.operationID,
+    attemptID: event.attemptID
+  });
+}
+function applyCancelled(state, event) {
+  const current = state.nodes[event.nodeID];
+  if (current === undefined) {
+    throw new ReducerError("unknown-node", event.nodeID);
+  }
+  if (current.status === "cancelled") {
+    return state;
+  }
+  if (current.status === "succeeded") {
+    throw new ReducerError("illegal-transition", "cancel succeeded");
+  }
+  return withNode({ ...state, seq: event.seq }, event.nodeID, {
+    ...current,
+    status: "cancelled"
+  });
+}
+function applyRunCompleted(state, seq) {
+  for (const node of Object.values(state.nodes)) {
+    if (node.status !== "succeeded" && node.status !== "cancelled") {
+      throw new ReducerError("incomplete-run", node.status);
+    }
+  }
+  return { ...state, status: "completed", seq };
+}
+function applyEvent(spec, state, event) {
+  if (event.runID !== state.runID) {
+    throw new ReducerError("run-mismatch", event.runID);
+  }
+  if (TERMINAL_RUN_STATUSES.has(state.status)) {
+    if (event.type === "run.completed" && state.status === "completed" || event.type === "run.failed" && state.status === "failed" || event.type === "run.cancelled" && state.status === "cancelled") {
+      return state;
+    }
+    throw new ReducerError("post-terminal", event.type);
+  }
+  switch (event.type) {
+    case "run.started":
+      return applyRunStarted(state, event.seq, event.specDigest);
+    case "node.dispatched":
+      return applyDispatched(spec, state, event);
+    case "node.succeeded":
+      return applySucceeded(state, event);
+    case "node.failed":
+      return applyFailed(state, event);
+    case "node.cancelled":
+      return applyCancelled(state, event);
+    case "run.completed":
+      return applyRunCompleted(state, event.seq);
+    case "run.failed":
+      return { ...state, status: "failed", seq: event.seq };
+    case "run.cancelled":
+      return { ...state, status: "cancelled", seq: event.seq };
+  }
+}
+
+// src/orchestrator/graphShadow.ts
+class ShadowMirrorError extends Error {
+  code;
+  detail;
+  constructor(code, detail) {
+    super(`${code}: ${detail}`);
+    this.name = "ShadowMirrorError";
+    this.code = code;
+    this.detail = detail;
+  }
+}
+function traceAnchorDigest(trace) {
+  return sha256Hex(JSON.stringify({
+    version: trace.version,
+    runID: trace.runID,
+    nodes: trace.nodes.map((node) => [node.id, node.role])
+  }));
+}
+function compileShadowSpec(trace) {
+  const anchor = { taskID: trace.runID, specDigest: traceAnchorDigest(trace) };
+  const nodes = [];
+  let previousID;
+  let lastImplementerID;
+  for (const node of trace.nodes) {
+    const dependsOn = previousID === undefined ? [] : [previousID];
+    if (node.role === "implementer") {
+      nodes.push({ id: node.id, role: "implementer", dependsOn, anchor });
+      lastImplementerID = node.id;
+    } else {
+      nodes.push({
+        id: node.id,
+        role: "reviewer",
+        dependsOn,
+        anchor,
+        ...lastImplementerID === undefined ? {} : { reviews: lastImplementerID }
+      });
+    }
+    previousID = node.id;
+  }
+  let spec;
+  try {
+    spec = GraphSpecV1Schema.parse({ version: 1, runID: trace.runID, nodes });
+    validateGraphSpec(spec);
+  } catch (error) {
+    throw new ShadowMirrorError("invalid-spec", error instanceof Error ? error.message : String(error));
+  }
+  assertReferenceOnly(spec);
+  return spec;
+}
+var TERMINAL_EVENT = {
+  completed: "run.completed",
+  failed: "run.failed",
+  cancelled: "run.cancelled"
+};
+function shadowArtifact(runID, nodeID) {
+  return {
+    uri: `shadow://${runID}/${nodeID}`,
+    sha256: sha256Hex(`shadow-artifact\x00${runID}\x00${nodeID}`),
+    bytes: 0
+  };
+}
+function mirrorJournal(spec, trace) {
+  const runID = trace.runID;
+  const events = [
+    {
+      v: 1,
+      seq: 0,
+      runID,
+      type: "run.started",
+      specDigest: graphSpecDigest(spec)
+    }
+  ];
+  for (const node of trace.nodes) {
+    const operation = operationID(runID, node.id);
+    const attempt = attemptID(operation, 0);
+    events.push({
+      v: 1,
+      seq: events.length,
+      runID,
+      type: "node.dispatched",
+      nodeID: node.id,
+      operationID: operation,
+      attemptID: attempt
+    });
+    if (node.errorClass === undefined) {
+      events.push({
+        v: 1,
+        seq: events.length,
+        runID,
+        type: "node.succeeded",
+        nodeID: node.id,
+        operationID: operation,
+        attemptID: attempt,
+        artifact: shadowArtifact(runID, node.id)
+      });
+      continue;
+    }
+    if (node.errorClass === "cancelled") {
+      events.push({
+        v: 1,
+        seq: events.length,
+        runID,
+        type: "node.cancelled",
+        nodeID: node.id
+      });
+      continue;
+    }
+    events.push({
+      v: 1,
+      seq: events.length,
+      runID,
+      type: "node.failed",
+      nodeID: node.id,
+      operationID: operation,
+      attemptID: attempt,
+      errorClass: node.errorClass
+    });
+  }
+  events.push({
+    v: 1,
+    seq: events.length,
+    runID,
+    type: TERMINAL_EVENT[trace.status]
+  });
+  return events;
+}
+function reduceMirror(spec, journal) {
+  let state = initialState(spec);
+  try {
+    for (const event of journal) {
+      state = applyEvent(spec, state, event);
+    }
+  } catch (error) {
+    throw new ShadowMirrorError("illegal-sequence", error instanceof ReducerError ? `${error.code}: ${error.detail}` : String(error));
+  }
+  return state;
+}
+function projectLegacySummary(trace) {
+  return {
+    runID: trace.runID,
+    status: trace.status,
+    outcome: trace.outcome,
+    fixes: trace.fixes,
+    nodes: trace.nodes.map((node) => ({
+      id: node.id,
+      role: node.role,
+      model: node.model
+    }))
+  };
+}
+function projectShadowSummary(spec, trace) {
+  const implementers = spec.nodes.filter((node) => node.role === "implementer").length;
+  return {
+    runID: spec.runID,
+    status: trace.status,
+    outcome: trace.outcome,
+    fixes: implementers - 1,
+    nodes: spec.nodes.map((node, index) => ({
+      id: node.id,
+      role: node.role,
+      model: trace.nodes[index].model
+    }))
+  };
+}
+function mirrorLegacyExecution(trace) {
+  const spec = compileShadowSpec(trace);
+  const journal = mirrorJournal(spec, trace);
+  const state = reduceMirror(spec, journal);
+  const summary = projectShadowSummary(spec, trace);
+  assertReferenceOnly(summary);
+  return {
+    spec,
+    specDigest: graphSpecDigest(spec),
+    journal,
+    state,
+    summary
+  };
+}
+
+// src/orchestrator/graphFacade.ts
+function mirrorLegacyTrace(trace) {
+  try {
+    return {
+      ok: true,
+      mirror: mirrorLegacyExecution(parseLegacyExecutionTrace(trace))
+    };
+  } catch (error) {
+    if (error instanceof ShadowMirrorError) {
+      return { ok: false, code: error.code, detail: error.detail };
+    }
+    if (error instanceof LegacyTraceError) {
+      return {
+        ok: false,
+        code: "invalid-trace",
+        detail: error.issues.join("; ")
+      };
+    }
+    return {
+      ok: false,
+      code: "mirror-error",
+      detail: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// src/orchestrator/shadowComparator.ts
+function sequenceEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  return a.every((value, index) => value === b[index]);
+}
+function compareShadowRun(legacy, shadow) {
+  if (legacy === undefined || shadow === undefined) {
+    return { verdict: "inconclusive", divergences: [] };
+  }
+  const divergences = [];
+  if (legacy.status !== shadow.status) {
+    divergences.push("status");
+  }
+  if (!sequenceEqual(legacy.nodes.map((node) => node.id), shadow.nodes.map((node) => node.id))) {
+    divergences.push("order");
+  }
+  if (!sequenceEqual(legacy.nodes.map((node) => node.role), shadow.nodes.map((node) => node.role))) {
+    divergences.push("roles");
+  }
+  if (!sequenceEqual(legacy.nodes.map((node) => node.model), shadow.nodes.map((node) => node.model))) {
+    divergences.push("models");
+  }
+  if (legacy.fixes !== shadow.fixes) {
+    divergences.push("fixes");
+  }
+  if (legacy.outcome !== shadow.outcome) {
+    divergences.push("outcome");
+  }
+  return {
+    verdict: divergences.length === 0 ? "match" : "divergent",
+    divergences
+  };
+}
+
+// src/storage/graph/soakRecorder.ts
+async function ensureRecorderId(ports, basePath) {
+  const idPath = `${basePath}/soak-recorder-id`;
+  if (await ports.fs.exists(idPath)) {
+    const id = (await ports.fs.readFile(idPath)).trim();
+    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(id)) {
+      return id;
+    }
+  }
+  const newId = ports.id.randomUUID();
+  await ports.fs.writeFile(idPath, newId);
+  return newId;
+}
+async function readAllChains(ports, evidenceDir) {
+  if (!await ports.fs.exists(evidenceDir)) {
+    return [];
+  }
+  const files = await ports.fs.readDir(evidenceDir);
+  const chains = [];
+  for (const file of files) {
+    if (!file.endsWith(".jsonl")) {
+      continue;
+    }
+    const content = await ports.fs.readFile(`${evidenceDir}/${file}`);
+    const lines = content.split(`
+`).filter((l) => l.trim().length > 0);
+    const observations = [];
+    for (const line of lines) {
+      const parsed = SoakObservationSchema.safeParse(JSON.parse(line));
+      if (parsed.success) {
+        observations.push(parsed.data);
+      }
+    }
+    if (observations.length > 0) {
+      chains.push(observations);
+    }
+  }
+  return chains;
+}
+function canonicalObservationPreimage2(obs) {
+  return JSON.stringify({
+    version: obs.version,
+    seq: obs.seq,
+    timestamp: obs.timestamp,
+    platform: obs.platform,
+    opencodeVersion: obs.opencodeVersion,
+    provenance: obs.provenance,
+    traceDigest: obs.traceDigest,
+    criticalDivergences: obs.criticalDivergences,
+    privacy: obs.privacy,
+    duplicateEffects: obs.duplicateEffects,
+    modelVerification: obs.modelVerification
+  });
+}
+async function appendObservation(ports, evidenceDir, recorderId, input) {
+  await ports.fs.mkdir(evidenceDir);
+  const chainPath = `${evidenceDir}/${recorderId}.jsonl`;
+  let seq = 0;
+  let prevChainDigest = "0".repeat(64);
+  if (await ports.fs.exists(chainPath)) {
+    const content = await ports.fs.readFile(chainPath);
+    const lines = content.split(`
+`).filter((l) => l.trim().length > 0);
+    if (lines.length > 0) {
+      const lastLine = lines[lines.length - 1];
+      let rawParsed;
+      try {
+        rawParsed = JSON.parse(lastLine);
+      } catch {
+        throw new Error("corrupt chain tail: invalid JSON");
+      }
+      const parsed = SoakObservationSchema.safeParse(rawParsed);
+      if (!parsed.success) {
+        const detail = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.code}`).join("; ");
+        throw new Error(`corrupt chain tail: ${detail}`);
+      }
+      seq = parsed.data.seq + 1;
+      prevChainDigest = parsed.data.chainDigest;
+    }
+  }
+  const timestamp = ports.clock.now();
+  const base = {
+    version: 1,
+    seq,
+    timestamp,
+    platform: input.platform,
+    opencodeVersion: input.opencodeVersion,
+    provenance: input.provenance,
+    traceDigest: input.traceDigest,
+    criticalDivergences: input.criticalDivergences,
+    privacy: input.privacy,
+    duplicateEffects: input.duplicateEffects,
+    modelVerification: input.modelVerification
+  };
+  const preimage = canonicalObservationPreimage2(base);
+  const chainDigest = sha256Hex(prevChainDigest + preimage);
+  const observation = { ...base, chainDigest };
+  assertReferenceOnly(observation);
+  const line = JSON.stringify(observation);
+  if (await ports.fs.exists(chainPath)) {
+    const existing = await ports.fs.readFile(chainPath);
+    await ports.fs.writeFile(chainPath, `${existing}
+${line}`);
+  } else {
+    await ports.fs.writeFile(chainPath, line);
+  }
+  return observation;
+}
+
+// src/plugin/soakObserver.ts
+function resolvePlatform(platform) {
+  if (platform === "win32")
+    return "win32";
+  if (platform === "darwin")
+    return "darwin";
+  if (platform === "linux")
+    return "linux";
+  return null;
+}
+function countCriticalDivergences(parity, criticalCodes) {
+  if (parity === undefined)
+    return null;
+  if (criticalCodes.length === 0)
+    return null;
+  const criticalSet = new Set(criticalCodes);
+  return parity.divergences.filter((code) => criticalSet.has(code)).length;
+}
+function scanTracePrivacy(trace) {
+  const result = scanReferenceOnly([trace]);
+  return {
+    surfacesScanned: result.surfacesScanned,
+    rawFindings: result.rawFindings
+  };
+}
+function detectDuplicateEffects(trace) {
+  const nodes = trace.nodes;
+  if (nodes.length === 0)
+    return null;
+  const seen = new Set;
+  let duplicates = 0;
+  for (const node of nodes) {
+    if (seen.has(node.id)) {
+      duplicates++;
+    } else {
+      seen.add(node.id);
+    }
+  }
+  return { effectsExamined: nodes.length, duplicatesFound: duplicates };
+}
+function traceToObservationInput(trace, opencodeVersion, parity, criticalCodes, modelVerification, platformOverride) {
+  const platform = resolvePlatform(platformOverride ?? process.platform);
+  if (platform === null)
+    return null;
+  const traceDigest = sha256Hex(JSON.stringify(trace));
+  return {
+    platform,
+    opencodeVersion,
+    provenance: "genuine-usage",
+    traceDigest,
+    criticalDivergences: countCriticalDivergences(parity, criticalCodes),
+    privacy: scanTracePrivacy(trace),
+    duplicateEffects: detectDuplicateEffects(trace),
+    modelVerification
+  };
+}
+async function recordSoakObservation(ports, evidenceDir, recorderId, trace, opencodeVersion, parity, criticalCodes, modelVerification, platformOverride) {
+  const input = traceToObservationInput(trace, opencodeVersion, parity, criticalCodes, modelVerification, platformOverride);
+  if (input === null)
+    return false;
+  await appendObservation(ports, evidenceDir, recorderId, input);
+  return true;
+}
+
+// src/plugin/shadowPipeline.ts
+function createShadowPipeline(deps) {
+  return async (observation, modelVerification) => {
+    try {
+      const ingested = ingestLegacyExecution(observation, deps.gate);
+      if (!ingested.eligible) {
+        return { kind: "ineligible", reason: ingested.reason };
+      }
+      const mirror = mirrorLegacyTrace(ingested.trace);
+      let parity;
+      if (mirror.ok) {
+        const legacySummary = projectLegacySummary(ingested.trace);
+        const report = compareShadowRun(legacySummary, mirror.mirror.summary);
+        parity = { divergences: [...report.divergences] };
+      }
+      const recorded = await recordSoakObservation(deps.ports, deps.evidenceDir, deps.recorderId, ingested.trace, deps.opencodeVersion, parity, deps.criticalCodes, modelVerification ?? null, deps.platformOverride);
+      if (!recorded) {
+        return {
+          kind: "observation-rejected",
+          reason: "unrecognized-platform"
+        };
+      }
+      return { kind: "observed" };
+    } catch (error) {
+      return {
+        kind: "contained-failure",
+        detail: error instanceof Error ? error.message : String(error)
+      };
+    }
+  };
+}
+
+// src/plugin/graphTool.ts
+function describeDecision(decision2) {
+  if (decision2.route === "graph") {
+    return `graph: la tarea ${decision2.taskID} se enrutaría al runtime activo.`;
+  }
+  switch (decision2.reason) {
+    case "gate-closed":
+      return "legacy: gate-closed — el ingress activo no es alcanzable por configuración en esta versión.";
+    case "kill-switch":
+      return "legacy: kill-switch — apagado de emergencia activo.";
+    case "graph-disabled":
+      return "legacy: graph-disabled — graph.mode no es 'active'.";
+    case "not-allow-listed":
+      return "legacy: not-allow-listed — la tarea no está en la allow-list del ingress.";
+  }
+}
+function describeOutcome(outcome) {
+  switch (outcome.kind) {
+    case "legacy":
+      return describeDecision({ route: "legacy", reason: outcome.reason });
+    case "accepted":
+      return `accepted: run ${outcome.runID}, paso ${outcome.step.kind}.`;
+    case "revision":
+      return `revision: run ${outcome.runID}, plan ${outcome.plan.kind}.`;
+    case "reassigned":
+      return `reassigned: run ${outcome.runID}, reviewer ${outcome.reviewerID}.`;
+    case "cancelled":
+      return `cancelled: run ${outcome.runID}, ${outcome.cancelledNodeIDs.length} nodo(s) cancelado(s).`;
+    case "error":
+      return `error: ${outcome.code}.`;
+  }
+}
+function unavailableReason(deps, taskID) {
+  const decision2 = decideIngress(deps.policy, taskID);
+  return decision2.route === "legacy" ? describeDecision(decision2) : "unavailable: el ejecutor de efectos del runtime activo no está enchufado.";
+}
+function createGraphTool(deps) {
+  const observe = deps.shadow !== undefined ? createShadowPipeline(deps.shadow) : async () => ({
+    kind: "ineligible",
+    reason: "shadow-not-configured"
+  });
+  const definition = tool2({
+    description: "Ingress activo de SDD de openteam (GE-050). En esta versión la puerta interna está cerrada: informa del estado de enrutado y no ejecuta runs. La acción report-run registra una observación shadow de la ejecución legacy.",
+    args: {
+      action: tool2.schema.enum(["status", "start", "cancel", "report-run"]).describe("Acción a ejecutar"),
+      taskID: tool2.schema.string().optional().describe("Identificador de la tarea SDD"),
+      runID: tool2.schema.string().optional().describe("Identificador del run (para action=cancel o report-run)"),
+      status: tool2.schema.enum(["completed", "failed", "cancelled"]).optional().describe("Estado terminal del run (solo action=report-run)"),
+      fixes: tool2.schema.number().optional().describe("Número de iteraciones de fix (solo action=report-run)"),
+      nodes: tool2.schema.array(tool2.schema.object({
+        id: tool2.schema.string().describe("ID del nodo"),
+        role: tool2.schema.enum(["implementer", "reviewer"]).describe("Rol del nodo"),
+        model: tool2.schema.string().describe("Modelo utilizado por el nodo"),
+        ok: tool2.schema.boolean().describe("Éxito terminal del nodo"),
+        sessionRef: tool2.schema.string().optional().describe("ID de sesión de opencode del nodo"),
+        errorClass: tool2.schema.enum(["transient", "permanent", "exhausted"]).optional().describe("Clase de error si el nodo falló")
+      })).optional().describe("Nodos de la ejecución (solo action=report-run)"),
+      parentSessionRef: tool2.schema.string().optional().describe("Sesión padre del run (solo action=report-run)")
+    },
+    async execute(args) {
+      if (args.action === "report-run") {
+        return handleReportRun(args, observe, deps.tracker);
+      }
+      const taskID = args.taskID ?? "";
+      if (args.action === "status") {
+        return describeDecision(decideIngress(deps.policy, taskID));
+      }
+      const ingress = deps.ingress;
+      if (ingress === undefined) {
+        return unavailableReason(deps, taskID);
+      }
+      if (args.action === "cancel") {
+        return describeOutcome(await ingress.cancel(args.runID ?? ""));
+      }
+      return describeOutcome(await ingress.start({
+        id: taskID,
+        implementerRoleID: "linus",
+        title: taskID,
+        brief: taskID,
+        task: {
+          promptChars: 0,
+          hasCode: false,
+          estimatedInputTokens: 0,
+          estimatedOutputTokens: 0
+        }
+      }));
+    }
+  });
+  return { definition, observeLegacyExecution: observe };
+}
+async function handleReportRun(args, observe, tracker) {
+  const parsed = ReportRunPayloadSchema.safeParse({
+    runID: args.runID,
+    status: args.status,
+    fixes: args.fixes,
+    nodes: args.nodes,
+    ...args.parentSessionRef !== undefined ? { parentSessionRef: args.parentSessionRef } : {}
+  });
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((issue) => issue.message).join("; ");
+    return formatResponse({
+      result: "ineligible",
+      detail: `validation: ${issues}`
+    });
+  }
+  const verification = crossVerify(parsed.data, tracker);
+  const warnings = formatWarnings(verification);
+  const verificationPair = {
+    nodesChecked: parsed.data.nodes.length,
+    unverified: verification.unverifiedModels.length,
+    mismatched: verification.modelMismatches.length
+  };
+  const run = buildObservedRun(parsed.data);
+  try {
+    const result = await observe(run, verificationPair);
+    const base = { result: result.kind };
+    const detail = result.kind === "ineligible" ? result.reason : result.kind === "observation-rejected" ? result.reason : result.kind === "contained-failure" ? result.detail : null;
+    return formatResponse({
+      ...base,
+      ...detail !== null ? { detail } : {},
+      ...warnings.length > 0 ? { warnings } : {}
+    });
+  } catch (error) {
+    return formatResponse({
+      result: "contained-failure",
+      detail: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+
 // src/plugin/hooks.ts
 var codeSignals = [
   "```",
@@ -2621,6 +4620,12 @@ function createChatMessageHook(config, getAvailable, options = {}) {
       telemetryContext.tokensOut = signals.estimatedOutputTokens;
     }
     emitTelemetry(sink, costRecordToRouteEvent(toCostRecord(decision2, telemetryContext)));
+    if (options.onRoute !== undefined) {
+      const routedSessionID = input.sessionID ?? output.message.sessionID;
+      if (typeof routedSessionID === "string" && routedSessionID.length > 0) {
+        options.onRoute(routedSessionID, `${decision2.selected.providerID}/${decision2.selected.modelID}`);
+      }
+    }
     if (options.injectMemory !== undefined) {
       try {
         const block = await options.injectMemory(prompt);
@@ -2682,54 +4687,54 @@ ${lines.join(`
 }
 
 // src/memory/types.ts
-import { z as z5 } from "zod";
+import { z as z11 } from "zod";
 var SHARED_OWNER_KEY = "*";
-var OwnerKeySchema = z5.string().min(1);
-var MemoryKindSchema = z5.enum(["fact", "preference", "entity"]);
-var MemoryBaseSchema = z5.object({
-  id: z5.string().min(1),
+var OwnerKeySchema = z11.string().min(1);
+var MemoryKindSchema = z11.enum(["fact", "preference", "entity"]);
+var MemoryBaseSchema = z11.object({
+  id: z11.string().min(1),
   ownerKey: OwnerKeySchema,
-  confidence: z5.number().min(0).max(1),
-  validFrom: z5.number().finite(),
-  validUntil: z5.number().finite().nullable().default(null),
-  createdAt: z5.number().finite(),
-  invalidatedAt: z5.number().finite().nullable().default(null),
-  sourceHash: z5.string().min(1),
-  supersededBy: z5.string().min(1).nullable().default(null)
+  confidence: z11.number().min(0).max(1),
+  validFrom: z11.number().finite(),
+  validUntil: z11.number().finite().nullable().default(null),
+  createdAt: z11.number().finite(),
+  invalidatedAt: z11.number().finite().nullable().default(null),
+  sourceHash: z11.string().min(1),
+  supersededBy: z11.string().min(1).nullable().default(null)
 });
 var FactSchema = MemoryBaseSchema.extend({
-  kind: z5.literal("fact"),
-  subject: z5.string().min(1),
-  predicate: z5.string().min(1),
-  object: z5.string().min(1),
-  category: z5.string().min(1).nullable().default(null)
+  kind: z11.literal("fact"),
+  subject: z11.string().min(1),
+  predicate: z11.string().min(1),
+  object: z11.string().min(1),
+  category: z11.string().min(1).nullable().default(null)
 });
 var PreferenceSchema = MemoryBaseSchema.extend({
-  kind: z5.literal("preference"),
-  category: z5.string().min(1),
-  preference: z5.string().min(1),
-  context: z5.string().min(1).nullable().default(null),
-  lastAccessedAt: z5.number().finite().nullable().default(null),
-  accessCount: z5.number().int().min(0).default(0)
+  kind: z11.literal("preference"),
+  category: z11.string().min(1),
+  preference: z11.string().min(1),
+  context: z11.string().min(1).nullable().default(null),
+  lastAccessedAt: z11.number().finite().nullable().default(null),
+  accessCount: z11.number().int().min(0).default(0)
 });
 var EntitySchema = MemoryBaseSchema.extend({
-  kind: z5.literal("entity"),
-  canonicalName: z5.string().min(1),
-  type: z5.string().min(1),
-  aliases: z5.array(z5.string().min(1)).default([])
+  kind: z11.literal("entity"),
+  canonicalName: z11.string().min(1),
+  type: z11.string().min(1),
+  aliases: z11.array(z11.string().min(1)).default([])
 });
-var MemoryRecordSchema = z5.discriminatedUnion("kind", [
+var MemoryRecordSchema = z11.discriminatedUnion("kind", [
   FactSchema,
   PreferenceSchema,
   EntitySchema
 ]);
-var RecallQuerySchema = z5.object({
+var RecallQuerySchema = z11.object({
   ownerKey: OwnerKeySchema,
-  kinds: z5.array(MemoryKindSchema).default(["fact", "preference", "entity"]),
-  asOf: z5.number().finite().nullable().default(null),
-  limit: z5.number().int().positive().default(8),
-  minSimilarity: z5.number().min(0).max(1).default(0.2),
-  includeShared: z5.boolean().default(true)
+  kinds: z11.array(MemoryKindSchema).default(["fact", "preference", "entity"]),
+  asOf: z11.number().finite().nullable().default(null),
+  limit: z11.number().int().positive().default(8),
+  minSimilarity: z11.number().min(0).max(1).default(0.2),
+  includeShared: z11.boolean().default(true)
 });
 
 // src/memory/rank.ts
@@ -2878,6 +4883,33 @@ function buildMemoryInjector(deps, policy) {
   };
 }
 
+// src/plugin/sessionTracker.ts
+function createSessionTracker() {
+  const knownSessions = new Set;
+  const routedModels = new Map;
+  return {
+    trackSession(sessionID) {
+      knownSessions.add(sessionID);
+    },
+    trackRoutedModel(sessionID, model) {
+      routedModels.set(sessionID, model);
+    },
+    verifyModel(sessionRef, reportedModel) {
+      const routedModel = routedModels.get(sessionRef);
+      if (routedModel === undefined) {
+        return { verified: false };
+      }
+      return { verified: true, match: routedModel === reportedModel };
+    },
+    verifySessionRef(sessionRef) {
+      if (sessionRef === undefined) {
+        return { known: null };
+      }
+      return { known: knownSessions.has(sessionRef) };
+    }
+  };
+}
+
 // src/plugin/toolcalls.ts
 function key(sessionID, callID) {
   return `${sessionID}\x00${callID}`;
@@ -3337,6 +5369,82 @@ function logTelemetryError(error) {
   const message = error instanceof Error ? error.message : String(error);
   console.warn(`[openteam] telemetry write failed: ${message}`);
 }
+var SHADOW_CERT_PATH = "artifacts/graph-shadow-certificate.json";
+var RELEASE_CERT_PATH = "artifacts/graph-release-certificate.json";
+var SOAK_CERT_PATH = "artifacts/graph-soak-certificate.json";
+var SOAK_EVIDENCE_DIR = ".opencode/soak";
+async function readAndParseCertificate(storage, path, parse, digestExtractor) {
+  try {
+    const content = await storage.read(path);
+    if (content === undefined) {
+      return { status: "absent" };
+    }
+    const raw = JSON.parse(content);
+    const cert = parse(raw);
+    return { status: "valid", digest: digestExtractor(cert) };
+  } catch (error) {
+    if (isMissingFile(error)) {
+      return { status: "absent" };
+    }
+    if (error instanceof ShadowCertificateError || error instanceof ReleaseCertificateError || error instanceof SoakCertificateError) {
+      return { status: "invalid", code: error.code, detail: error.detail };
+    }
+    const msg = error instanceof Error ? error.message : String(error);
+    return { status: "invalid", code: "read-error", detail: msg };
+  }
+}
+async function readOpencodeVersion(serverUrl) {
+  try {
+    const url = new URL("/global/health", serverUrl);
+    const res = await fetch(url);
+    if (!res.ok) {
+      return "unknown";
+    }
+    const body = await res.json();
+    if (typeof body === "object" && body !== null && "version" in body && typeof body.version === "string" && body.version.length > 0) {
+      return body.version;
+    }
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+async function buildGateInput(config, storage, opencodeVersion) {
+  const shadow = await readAndParseCertificate(storage, SHADOW_CERT_PATH, (raw) => parseShadowCertificate(raw, opencodeVersion), (cert) => cert.digest);
+  const shadowDigest = shadow.status === "valid" ? shadow.digest : "0".repeat(64);
+  const release = await readAndParseCertificate(storage, RELEASE_CERT_PATH, (raw) => parseReleaseCertificate(raw, opencodeVersion, shadowDigest), (cert) => cert.digest);
+  let soakLedgerDigest = "0".repeat(64);
+  try {
+    const recorderPorts = recorderPortsFromStorage(storage);
+    const chains = await readAllChains(recorderPorts, SOAK_EVIDENCE_DIR);
+    if (chains.length > 0) {
+      soakLedgerDigest = canonicalLedger(chains);
+    }
+  } catch {}
+  const soak = await readAndParseCertificate(storage, SOAK_CERT_PATH, (raw) => parseSoakCertificate(raw, DEFAULT_SOAK_POLICY, soakLedgerDigest), (cert) => cert.digest);
+  const migration = "complete";
+  const operatorApproval = config.graph?.operatorApproval ?? false;
+  return { shadow, release, soak, migration, operatorApproval };
+}
+function recorderPortsFromStorage(storage) {
+  return {
+    fs: {
+      readFile: async (path) => {
+        const content = await storage.read(path);
+        if (content === undefined) {
+          throw Object.assign(new Error(`ENOENT: ${path}`), { code: "ENOENT" });
+        }
+        return content;
+      },
+      writeFile: (path, content) => storage.write(path, content),
+      exists: (path) => storage.exists(path),
+      readDir: (path) => storage.list(path),
+      mkdir: (path) => storage.mkdir(path)
+    },
+    clock: { now: () => new Date().toISOString() },
+    id: { randomUUID: () => crypto.randomUUID() }
+  };
+}
 async function buildMemoryInjectorFromConfig(config, storage) {
   const runtime = await buildMemoryRuntimeFromConfig(config, { storage }, { requireInjectionEnabled: true });
   if (runtime === undefined) {
@@ -3436,7 +5544,15 @@ var server = async (ctx, rawOptions) => {
   const storage = createFsStorageProvider(process.cwd());
   const sink = createEventSink(rawOptions, storage);
   const injectMemory = await buildMemoryInjectorFromConfig(config, storage);
-  const hooks = createHooks(config, cache.get, injectMemory === undefined ? { sink } : { sink, injectMemory });
+  const sessionTracker = createSessionTracker();
+  const hooks = createHooks(config, cache.get, injectMemory === undefined ? {
+    sink,
+    onRoute: (sid, model) => sessionTracker.trackRoutedModel(sid, model)
+  } : {
+    sink,
+    injectMemory,
+    onRoute: (sid, model) => sessionTracker.trackRoutedModel(sid, model)
+  });
   const cliDeps = createCliDeps(config, registry, telemetryPath, sessionsDir, storage);
   const toolcalls = createToolcallTracker({ sink });
   const now = () => Date.now();
@@ -3454,10 +5570,54 @@ var server = async (ctx, rawOptions) => {
       sink.emit(endpoint);
     }
   };
+  let graphConfig = resolveGraphConfig(config, "file");
+  const opencodeVersion = graphConfig.effectiveMode !== "off" ? await readOpencodeVersion(ctx.serverUrl) : undefined;
+  if (isGateApplicable(graphConfig.effectiveMode)) {
+    if (opencodeVersion === undefined) {
+      throw new Error("[openteam] BUG: gate applicable but opencodeVersion was not read");
+    }
+    const gateInput = await buildGateInput(config, storage, opencodeVersion);
+    const gateResult = evaluateGraphGate(gateInput);
+    graphConfig = applyGraphGate(graphConfig, gateResult);
+    if (graphConfig.gateDenied === true && graphConfig.gateViolations !== undefined) {
+      console.warn("[openteam] ⛔ cutover gate denied active mode — degrading to off");
+      for (const v of graphConfig.gateViolations) {
+        console.warn(`[openteam]   • ${v.code}: ${v.detail}`);
+      }
+    }
+  }
+  let shadowDeps;
+  if (graphConfig.effectiveMode !== "off") {
+    if (opencodeVersion === undefined) {
+      throw new Error("[openteam] BUG: shadow pipeline active but opencodeVersion was not read");
+    }
+    const recorderPorts = recorderPortsFromStorage(storage);
+    const recorderId = await ensureRecorderId(recorderPorts, ".opencode");
+    shadowDeps = {
+      gate: {
+        mode: graphConfig.configuredMode,
+        killSwitch: graphConfig.killSwitch
+      },
+      ports: recorderPorts,
+      evidenceDir: ".opencode/soak",
+      recorderId,
+      opencodeVersion,
+      criticalCodes: DEFAULT_SOAK_POLICY.criticalDivergenceCodes
+    };
+  }
+  const graphSurface = createGraphTool({
+    policy: {
+      graph: graphConfig,
+      allowList: []
+    },
+    shadow: shadowDeps,
+    tracker: sessionTracker
+  });
   return {
     ...hooks,
     tool: {
-      openteam: createCommandTool(cliDeps)
+      openteam: createCommandTool(cliDeps),
+      "openteam-graph": graphSurface.definition
     },
     "tool.execute.before": async (input) => {
       toolcalls.before(input);
@@ -3472,6 +5632,7 @@ var server = async (ctx, rawOptions) => {
       const activity = activityEventFrom(event, now);
       if (activity !== undefined) {
         announceEndpoint(activity.sessionID);
+        sessionTracker.trackSession(activity.sessionID);
         sink.emit(activity);
       }
       if (event.type === "message.updated") {
@@ -3479,6 +5640,7 @@ var server = async (ctx, rawOptions) => {
         const message = info === undefined ? undefined : messageEventFrom(info, now);
         if (message !== undefined) {
           announceEndpoint(message.sessionID);
+          sessionTracker.trackSession(message.sessionID);
           sink.emit(message);
         }
       }
@@ -3492,10 +5654,13 @@ var plugin = {
 var src_default = plugin;
 export {
   server,
+  recorderPortsFromStorage,
+  readOpencodeVersion,
   logTelemetryError,
   logAvailabilityRefreshError,
   isMissingFile,
   src_default as default,
   createEventSink,
-  createCliDeps
+  createCliDeps,
+  buildGateInput
 };