@jmanuelcorral/openteam 0.16.0 → 0.16.2

package/dist/cli.js

@@ -3,9 +3,10 @@ import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/cli.ts
-import { execFile as execFile2 } from "node:child_process";
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname5, resolve as resolve6 } from "node:path";
+import { exec, execFile as execFile2 } from "node:child_process";
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
+import { createRequire as createRequire2 } from "node:module";
+import { dirname as dirname6, resolve as resolve6 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 import {
   confirm as clackConfirm,
@@ -8551,7 +8552,15 @@ function recoverJournal(spec, text) {
 }
 
 // src/cli/graphOperator.ts
-var ALLOWED_GATE = { allowed: true, violations: [] };
+var ALLOWED_GATE = {
+  allowed: true,
+  violations: [],
+  advisories: []
+};
+var ALLOWED_EVALUATION = {
+  kind: "evaluated",
+  gate: ALLOWED_GATE
+};
 function journalRoot(config) {
   return config.graph?.journalRoot ?? DEFAULT_GRAPH_JOURNAL_ROOT;
 }
@@ -8641,7 +8650,7 @@ async function listWorktreeObservations(config, options) {
   })));
 }
 function createGraphOperator(options) {
-  const evaluateCutoverGate = options.evaluateCutoverGate ?? (async () => ALLOWED_GATE);
+  const evaluateCutoverGate = options.evaluateCutoverGate ?? (async () => ALLOWED_EVALUATION);
   const worktreeOptions = options.exec === undefined ? undefined : {
     exec: options.exec,
     repoRoot: options.repoRoot ?? process.cwd(),
@@ -8920,6 +8929,35 @@ function createMigrateAdapter(root) {
   };
 }
 
+// src/cli/opencodeVersion.ts
+var SEMVER_PATTERN = /(\d+\.\d+\.\d+)/;
+function normalizeVersion(raw) {
+  if (raw === undefined) {
+    return;
+  }
+  const trimmed = raw.trim();
+  if (trimmed === "" || trimmed.toLowerCase() === "unknown") {
+    return;
+  }
+  const match = SEMVER_PATTERN.exec(trimmed);
+  return match?.[1] ?? undefined;
+}
+async function resolveOpencodeVersionBestEffort(deps) {
+  try {
+    const fromPackage = normalizeVersion(deps.readPackageVersion("opencode-ai"));
+    if (fromPackage !== undefined) {
+      return fromPackage;
+    }
+  } catch {}
+  try {
+    const fromCommand = normalizeVersion(await deps.runVersionCommand());
+    if (fromCommand !== undefined) {
+      return fromCommand;
+    }
+  } catch {}
+  return;
+}
+
 // src/cli/purgeAdapter.ts
 import { execFile } from "node:child_process";
 import * as fs2 from "node:fs";
@@ -10239,6 +10277,56 @@ function createProbeRuntime(exec) {
 }
 
 // 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 advisories = [];
+  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)
+    advisories.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,
+    advisories
+  };
+}
 function isGateApplicable(mode) {
   return mode === "active";
 }
@@ -11057,7 +11145,7 @@ function legacyRosterFindings(audit) {
   }
   return findings;
 }
-function rosterHealthSection(audit, loadError, rosterRoleCount) {
+function rosterHealthSection(audit, loadError, rosterRoleCount, rosterMissing) {
   const auditFindings = audit?.findings ?? legacyRosterFindings(audit ?? {});
   const unparseable = auditFindings.find((finding) => finding.kind === "unparseable-roster");
   const unparseableMessage = loadError ?? unparseable?.message;
@@ -11070,6 +11158,14 @@ function rosterHealthSection(audit, loadError, rosterRoleCount) {
     ];
   }
   if (audit === undefined) {
+    if (rosterMissing === true) {
+      return [
+        "  roster health:",
+        `    ✗ ${OPENTEAM_ROSTER_PATH} does not exist — no team roster has been cast.`,
+        "      consequence: without a roster openteam cannot distribute work across roles, so every request is handled by a single agent and no work splitting happens.",
+        `      remedy: run \`openteam setup\` to cast a team and write the roster (${OPENTEAM_ROSTER_PATH}), then re-run \`openteam doctor\`.`
+      ];
+    }
     return [];
   }
   const missing = auditFindings.filter((finding) => finding.kind === "missing-guaranteed-role").map((finding) => finding.roleID);
@@ -11105,6 +11201,14 @@ function rosterHealthSection(audit, loadError, rosterRoleCount) {
   }
   return lines;
 }
+function orchestratorAgentSection() {
+  return [
+    "  orchestrator agent:",
+    `    ✗ ${ORCHESTRATOR_AGENT_PATH} does not exist — opencode has no openteam coordinator agent.`,
+    "      consequence: this is the primary agent that reads the roster and calls `openteam-orchestrate` to fan work out across roles; without it opencode has no openteam coordinator, so every request is handled by a single agent and no work splitting happens.",
+    `      remedy: run \`openteam setup\` to generate ${ORCHESTRATOR_AGENT_PATH}, then re-run \`openteam doctor\`.`
+  ];
+}
 function gitignoreSection(gitignore) {
   if (gitignore.missingRules.length === 0) {
     return [
@@ -11168,7 +11272,10 @@ function renderDoctor(input) {
   if (input.diagnostics !== undefined) {
     lines.push(...diagnosticsSection(input.diagnostics));
   }
-  lines.push(...rosterHealthSection(input.rosterAudit, input.rosterLoadError, input.rosterRoleCount));
+  lines.push(...rosterHealthSection(input.rosterAudit, input.rosterLoadError, input.rosterRoleCount, input.rosterMissing));
+  if (input.orchestratorAgentMissing === true) {
+    lines.push(...orchestratorAgentSection());
+  }
   if (input.gitignore !== undefined) {
     lines.push(...gitignoreSection(input.gitignore));
   }
@@ -11237,14 +11344,38 @@ function leaseLine(lease) {
   const state = lease.released ? "released" : "active";
   return `  lease:      ${lease.holder} → ${lease.runID} (${state})`;
 }
-function renderGraphStatus(snapshot) {
+function appendAdvisoryLines(lines, advisories) {
+  for (const advisory of advisories ?? []) {
+    lines.push(`    ⚠ advisory (non-blocking) ${advisory.code}: ${advisory.detail}`);
+  }
+}
+function appendEffectiveLines(lines, gate) {
+  switch (gate.kind) {
+    case "not-applicable":
+      return;
+    case "passed":
+      lines.push("  effective:  active");
+      appendAdvisoryLines(lines, gate.advisories);
+      return;
+    case "unevaluable":
+      lines.push("  effective:  unknown — could not evaluate the cutover gate");
+      lines.push(`    ${gate.reason}`);
+      return;
+    case "denied":
+      lines.push("  effective:  off — cutover gate denied");
+      for (const violation of gate.violations) {
+        lines.push(`    • ${violation.code}: ${violation.detail}`);
+      }
+      appendAdvisoryLines(lines, gate.advisories);
+  }
+}
+function renderGraphStatus(snapshot, gate = { kind: "not-applicable" }) {
   const lines = [
     "openteam graph status:",
-    `  config:     ${snapshot.effectiveMode} (source: ${snapshot.source})`,
-    leaseLine(snapshot.lease),
-    `  journal:    ${snapshot.journal}`,
-    `  effects:    ${snapshot.pendingEffects} pending, ${snapshot.unknownEffects} unknown`
+    `  config:     ${snapshot.effectiveMode} (source: ${snapshot.source})`
   ];
+  appendEffectiveLines(lines, gate);
+  lines.push(leaseLine(snapshot.lease), `  journal:    ${snapshot.journal}`, `  effects:    ${snapshot.pendingEffects} pending, ${snapshot.unknownEffects} unknown`);
   const needsReconciliation = isRecoveryRequired(snapshot.journal, snapshot.unknownEffects);
   if (needsReconciliation) {
     lines.push("  ⚠ Reconciliation required: journal or effects in an uncertain state.");
@@ -11495,11 +11626,152 @@ function mergeOpencodeConfigs(base, override) {
   return result;
 }
 
+// src/graph/soakLedger.ts
+import { z as z19 } from "zod";
+var Sha256Schema2 = z19.string().regex(/^[0-9a-f]{64}$/);
+var SoakPlatformSchema = z19.enum(["linux", "win32", "darwin"]);
+var PrivacyPairSchema = z19.object({
+  surfacesScanned: z19.number().int().nonnegative(),
+  rawFindings: z19.number().int().nonnegative()
+}).strict();
+var DuplicateEffectPairSchema = z19.object({
+  effectsExamined: z19.number().int().nonnegative(),
+  duplicatesFound: z19.number().int().nonnegative()
+}).strict();
+var ModelVerificationPairSchema = z19.object({
+  nodesChecked: z19.number().int().nonnegative(),
+  unverified: z19.number().int().nonnegative(),
+  mismatched: z19.number().int().nonnegative()
+}).strict();
+var SoakObservationSchema = z19.object({
+  version: z19.literal(1),
+  seq: z19.number().int().nonnegative(),
+  timestamp: z19.string().datetime(),
+  platform: SoakPlatformSchema,
+  opencodeVersion: z19.string().min(1),
+  provenance: z19.enum(["genuine-usage", "ci-synthetic"]),
+  traceDigest: Sha256Schema2,
+  criticalDivergences: z19.number().int().nonnegative().nullable(),
+  privacy: PrivacyPairSchema.nullable(),
+  duplicateEffects: DuplicateEffectPairSchema.nullable(),
+  modelVerification: ModelVerificationPairSchema.nullable(),
+  chainDigest: Sha256Schema2
+}).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/storage/graph/soakRecorder.ts
 var SOAK_EVIDENCE_DIR = ".opencode/soak";
 var SOAK_RECORDER_BASE_DIR = ".opencode";
 var SOAK_RECORDER_ID_FILENAME = "soak-recorder-id";
 var SOAK_RECORDER_ID_PATH = `${SOAK_RECORDER_BASE_DIR}/${SOAK_RECORDER_ID_FILENAME}`;
+async function readAllChains(ports, evidenceDir) {
+  if (!await ports.fs.exists(evidenceDir)) {
+    return { chains: [], rejectedLines: 0, rejections: [] };
+  }
+  const files = await ports.fs.readDir(evidenceDir);
+  const chains = [];
+  const rejections = [];
+  for (const file of files) {
+    if (!file.endsWith(".jsonl")) {
+      continue;
+    }
+    const content = await ports.fs.readFile(`${evidenceDir}/${file}`);
+    const lines = content.split(`
+`);
+    const observations = [];
+    for (const [index, line] of lines.entries()) {
+      if (line.trim().length === 0) {
+        continue;
+      }
+      const lineNumber = index + 1;
+      let rawParsed;
+      try {
+        rawParsed = JSON.parse(line);
+      } catch {
+        rejections.push({ file, lineNumber, detail: "invalid JSON" });
+        continue;
+      }
+      const parsed = SoakObservationSchema.safeParse(rawParsed);
+      if (parsed.success) {
+        observations.push(parsed.data);
+      } else {
+        rejections.push({
+          file,
+          lineNumber,
+          detail: formatSoakObservationIssues(parsed.error.issues)
+        });
+      }
+    }
+    if (observations.length > 0) {
+      chains.push(observations);
+    }
+  }
+  return { chains, rejectedLines: rejections.length, rejections };
+}
+function formatSoakObservationIssues(issues) {
+  return issues.map((i) => `${i.path.join(".")}: ${i.code}`).join("; ");
+}
 
 // src/commands/frontierCatalog.ts
 function weightedCost(inputUSD, outputUSD) {
@@ -13272,8 +13544,7 @@ async function runAgents(deps, configPath, opencodeConfigPaths, configResolution
 async function runGraph(positionals, deps, configPath, configResolution) {
   const sub = positionals[1];
   if (sub === "status") {
-    const snapshot = await deps.readGraphSnapshot(configPath, configResolution);
-    return { exitCode: 0, stdout: renderGraphStatus(snapshot) };
+    return runGraphStatus(deps, configPath, configResolution);
   }
   if (sub === "cancel") {
     return runGraphCancel(positionals, deps, configPath, configResolution);
@@ -13328,7 +13599,9 @@ function renderGraphOutcome(outcome) {
 async function resolveOperatorGraphPolicy(config, operator) {
   let graph = resolveGraphConfig(config, "file");
   if (isGateApplicable(graph.effectiveMode)) {
-    graph = applyGraphGate(graph, await operator.evaluateCutoverGate());
+    const evaluation = await operator.evaluateCutoverGate(config);
+    const gate = evaluation.kind === "evaluated" ? evaluation.gate : { allowed: false, violations: [], advisories: [] };
+    graph = applyGraphGate(graph, gate);
   }
   return {
     graph,
@@ -13346,6 +13619,36 @@ function checkOperatorGate(policy) {
     stdout: renderLegacyGraphReason(decision2)
   };
 }
+async function runGraphStatus(deps, configPath, configResolution) {
+  const snapshot = await deps.readGraphSnapshot(configPath, configResolution);
+  if (!isGateApplicable(snapshot.effectiveMode)) {
+    return { exitCode: 0, stdout: renderGraphStatus(snapshot) };
+  }
+  const operator = deps.graphOperator;
+  if (operator === undefined) {
+    const gate2 = {
+      kind: "unevaluable",
+      reason: "graph operator ports are not configured"
+    };
+    return { exitCode: 0, stdout: renderGraphStatus(snapshot, gate2) };
+  }
+  const config = await deps.loadConfig(configPath, configResolution);
+  const evaluation = await operator.evaluateCutoverGate(config);
+  if (evaluation.kind === "unevaluable") {
+    const gate2 = {
+      kind: "unevaluable",
+      reason: evaluation.reason
+    };
+    return { exitCode: 0, stdout: renderGraphStatus(snapshot, gate2) };
+  }
+  const resolved = applyGraphGate(resolveGraphConfig(config, "file"), evaluation.gate);
+  const gate = resolved.gateDenied === true ? {
+    kind: "denied",
+    violations: resolved.gateViolations ?? [],
+    advisories: evaluation.gate.advisories
+  } : { kind: "passed", advisories: evaluation.gate.advisories };
+  return { exitCode: 0, stdout: renderGraphStatus(snapshot, gate) };
+}
 async function runGraphCancel(positionals, deps, configPath, configResolution) {
   const runID = positionals[2];
   if (runID === undefined || runID.trim() === "") {
@@ -13792,6 +14095,9 @@ async function runCli(argv, deps) {
         const summary = summarizeQueueWaits(queueEvents);
         queueWait = summary !== undefined ? { summary } : {};
       }
+      const rosterMissing = deps.loadRosterForDoctor !== undefined && roster === undefined && rosterLoadError === undefined;
+      const orchestratorAgentName = ORCHESTRATOR_AGENT_PATH.slice(ORCHESTRATOR_AGENT_PATH.lastIndexOf("/") + 1).replace(/\.md$/, "");
+      const orchestratorAgentMissing = !agentFiles.some((file) => file.name === orchestratorAgentName);
       return {
         exitCode: 0,
         stdout: renderDoctor({
@@ -13805,6 +14111,8 @@ async function runCli(argv, deps) {
           ...rosterAudit !== undefined ? { rosterAudit } : {},
           ...rosterRoleCount !== undefined ? { rosterRoleCount } : {},
           ...rosterLoadError !== undefined ? { rosterLoadError } : {},
+          ...rosterMissing ? { rosterMissing } : {},
+          ...orchestratorAgentMissing ? { orchestratorAgentMissing } : {},
           ...diagnostics !== undefined && diagnostics.length > 0 ? { diagnostics } : {},
           ...opencodeConfigError !== undefined ? { opencodeConfigError } : {},
           ...cacheEntries !== undefined ? { cacheEntries, cliVersion: deps.version } : {},
@@ -14258,461 +14566,1031 @@ function planStartupHygieneMigration(exists) {
   return planLegacyMigration(exists).filter((move) => move.portable === false && move.relocation === "move" && move.from.startsWith(".opencode/openteam/"));
 }
 
-// src/local/cacheAdapter.ts
-import * as fs3 from "node:fs";
-import * as os from "node:os";
-import * as path3 from "node:path";
-var SCOPE_PREFIX2 = "@jmanuelcorral/openteam";
-var SCOPE_SEGMENTS = SCOPE_PREFIX2.split("/");
-function resolveCacheRoot(override) {
-  if (override !== undefined && override.trim() !== "") {
-    return override;
+// src/index.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname5 } from "node:path";
+import {
+  tool as tool2
+} from "@opencode-ai/plugin";
+
+// src/graph/certificate.ts
+import { z as z20 } from "zod";
+
+// src/contract/opencode.ts
+var SUPPORTED_OPENCODE_VERSIONS = [
+  "1.17.13",
+  "1.18.18",
+  "1.18.19"
+];
+var SEMVER_RE = /^(\d+)\.(\d+)\.(\d+)/;
+function parseSemver(version) {
+  const normalized = version.trim().replace(/^[=^~v]+/, "");
+  const match = SEMVER_RE.exec(normalized);
+  if (match === null) {
+    throw new Error(`invalid semver: "${version}"`);
   }
-  const base = process.env.XDG_CACHE_HOME ?? path3.join(os.homedir(), ".cache");
-  return path3.join(base, "opencode", "packages");
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3])
+  };
 }
-function readJsonSafe(filePath) {
-  try {
-    const text2 = fs3.readFileSync(filePath, "utf8");
-    const parsed = JSON.parse(text2);
-    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
-      return parsed;
-    }
-    return;
-  } catch {
-    return;
+function isCertificateVersionCompatible(certifiedVersion, liveVersion) {
+  if (certifiedVersion === liveVersion) {
+    return true;
   }
-}
-function extractVersion(pkg) {
-  if (pkg === undefined)
-    return "";
-  const v = pkg.version;
-  return typeof v === "string" ? v : "";
-}
-function readDirectoryEntries(dir) {
+  let certified;
+  let live;
   try {
-    return fs3.readdirSync(dir, { withFileTypes: true });
+    certified = parseSemver(certifiedVersion);
+    live = parseSemver(liveVersion);
   } catch {
-    return [];
+    return false;
+  }
+  if (certified.major !== live.major || certified.minor !== live.minor) {
+    return false;
   }
+  return live.patch >= certified.patch;
 }
-function lstatPlainDirectory(dir) {
-  try {
-    const stat2 = fs3.lstatSync(dir);
-    if (!stat2.isDirectory() || stat2.isSymbolicLink()) {
-      return;
-    }
-    return stat2;
-  } catch {
-    return;
+
+// src/graph/certificate.ts
+var SHADOW_CERTIFICATE_MIN_RUNS = 1000;
+var DivergenceCodeSchema = z20.enum([
+  "status",
+  "order",
+  "roles",
+  "models",
+  "fixes",
+  "outcome"
+]);
+var ProvenanceSchema = z20.enum([
+  "recomputed",
+  "compiled",
+  "validated",
+  "carried"
+]);
+var EvidenceSchema = z20.object({
+  opencodeVersion: z20.string().min(1),
+  parity: z20.object({
+    runs: z20.number().int().nonnegative(),
+    match: z20.number().int().nonnegative(),
+    divergent: z20.number().int().nonnegative(),
+    inconclusive: z20.number().int().nonnegative(),
+    divergences: z20.array(DivergenceCodeSchema)
+  }).strict(),
+  legacy: z20.object({
+    observed: z20.number().int().nonnegative(),
+    duplicated: z20.number().int().nonnegative()
+  }).strict(),
+  privacy: z20.object({
+    surfacesScanned: z20.number().int().nonnegative(),
+    rawFindings: z20.number().int().nonnegative()
+  }).strict(),
+  overhead: z20.object({
+    p95Millis: z20.number().nonnegative(),
+    budgetMillis: z20.number().positive(),
+    samples: z20.number().int().nonnegative()
+  }).strict(),
+  provenance: z20.record(DivergenceCodeSchema, ProvenanceSchema)
+}).strict();
+var CertificateSchema = z20.object({
+  version: z20.literal(1),
+  certificate: z20.literal("graph-shadow"),
+  opencodeVersion: z20.string().min(1),
+  evidence: EvidenceSchema,
+  verdict: z20.enum(["pass", "fail"]),
+  failedGates: z20.array(z20.enum([
+    "sample",
+    "parity",
+    "one-legacy-execution",
+    "privacy",
+    "overhead"
+  ])),
+  digest: z20.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 findEntryDirs(cacheRoot) {
-  const candidates = [];
-  for (const topEntry of readDirectoryEntries(cacheRoot)) {
-    const topPath = path3.join(cacheRoot, topEntry.name);
-    const topStat = lstatPlainDirectory(topPath);
-    if (topStat === undefined) {
-      continue;
-    }
-    if (!topEntry.name.startsWith("@")) {
-      candidates.push({
-        specDir: topEntry.name,
-        absolutePath: topPath,
-        stat: topStat
-      });
-      continue;
-    }
-    for (const packageEntry of readDirectoryEntries(topPath)) {
-      const packagePath = path3.join(topPath, packageEntry.name);
-      const packageStat = lstatPlainDirectory(packagePath);
-      if (packageStat === undefined) {
-        continue;
-      }
-      candidates.push({
-        specDir: `${topEntry.name}/${packageEntry.name}`,
-        absolutePath: packagePath,
-        stat: packageStat
-      });
-    }
+function evaluateGates(evidence) {
+  const failed = [];
+  if (evidence.parity.runs < SHADOW_CERTIFICATE_MIN_RUNS) {
+    failed.push("sample");
   }
-  return candidates.sort((a, b) => a.specDir.localeCompare(b.specDir));
+  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;
 }
-async function listEntries(cacheRoot) {
-  const entries = [];
-  for (const candidate of findEntryDirs(cacheRoot)) {
-    const { specDir, absolutePath, stat: stat2 } = candidate;
-    if (!specDir.startsWith(SCOPE_PREFIX2))
-      continue;
-    const mtimeIso = stat2.mtime.toISOString();
-    const entryPkg = readJsonSafe(path3.join(absolutePath, "package.json"));
-    const deps = entryPkg?.dependencies;
-    let pinnedVersion = "";
-    if (deps !== null && typeof deps === "object" && !Array.isArray(deps)) {
-      const depsObj = deps;
-      const pinned = depsObj[SCOPE_PREFIX2];
-      pinnedVersion = typeof pinned === "string" ? pinned : "";
+function shadowCertificateBindingDigest(evidence) {
+  return sha256Hex(JSON.stringify({
+    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: {
+      budgetMillis: evidence.overhead.budgetMillis,
+      samples: evidence.overhead.samples
+    },
+    provenance: Object.fromEntries(Object.entries(evidence.provenance).sort(([a], [b]) => a < b ? -1 : 1))
+  }));
+}
+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))
     }
-    const installedPkg = readJsonSafe(path3.join(absolutePath, "node_modules", ...SCOPE_SEGMENTS, "package.json"));
-    const installedVersion = extractVersion(installedPkg);
-    entries.push({
-      specDir,
-      absolutePath,
-      pinnedVersion,
-      installedVersion,
-      mtimeIso
-    });
-  }
-  return entries;
+  });
 }
-async function deleteEntry(entryPath) {
-  fs3.rmSync(entryPath, { recursive: true, force: true });
+function sameGates(a, b) {
+  return a.length === b.length && a.every((gate, index) => gate === b[index]);
 }
-async function isReparsePath(entryPath) {
-  try {
-    const stat2 = await fs3.promises.lstat(entryPath);
-    return stat2.isSymbolicLink();
-  } catch {
-    return true;
+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 (!isCertificateVersionCompatible(certificate.opencodeVersion, opencodeVersion)) {
+    throw new ShadowCertificateError("opencode-mismatch", `certified for "${certificate.opencodeVersion}", running "${opencodeVersion}" — evidence is accepted only on ${certificate.opencodeVersion} or a newer patch of the same minor line`);
+  }
+  return certificate;
 }
-var realCacheAdapter = {
-  resolveCacheRoot,
-  listEntries,
-  deleteEntry,
-  isReparsePath
-};
+var ReleaseDeterminismSchema = z20.object({ runs: z20.number().int().nonnegative(), allMatch: z20.boolean() }).strict();
+var ReleaseCrashRecoverySchema = z20.object({
+  scenarios: z20.number().int().nonnegative(),
+  allConverge: z20.boolean()
+}).strict();
+var ReleaseReplayEquivalenceSchema = z20.object({
+  checks: z20.number().int().nonnegative(),
+  allEquivalent: z20.boolean()
+}).strict();
+var ReleasePrivacySchema = z20.object({
+  surfacesScanned: z20.number().int().nonnegative(),
+  rawFindings: z20.number().int().nonnegative()
+}).strict();
+var ReleaseContractSchema = z20.object({
+  roundTrips: z20.number().int().nonnegative(),
+  allSettled: z20.boolean()
+}).strict();
+var ReleaseHealthSchema = z20.object({
+  samples: z20.number().int().nonnegative(),
+  bounded: z20.boolean(),
+  idempotent: z20.boolean()
+}).strict();
+var ReleasePerformanceSchema = z20.object({
+  p95Millis: z20.number().nonnegative(),
+  budgetMillis: z20.number().positive(),
+  samples: z20.number().int().nonnegative()
+}).strict();
+var ReleaseEvidenceSchema = z20.object({
+  opencodeVersion: z20.string().min(1),
+  platform: z20.enum(["linux", "win32"]),
+  shadowCertificateDigest: z20.string().regex(/^[0-9a-f]{64}$/),
+  determinism: ReleaseDeterminismSchema,
+  crashRecovery: ReleaseCrashRecoverySchema,
+  replayEquivalence: ReleaseReplayEquivalenceSchema,
+  privacy: ReleasePrivacySchema,
+  contract: ReleaseContractSchema,
+  health: ReleaseHealthSchema,
+  performance: ReleasePerformanceSchema
+}).strict();
+var ReleaseCertificateSchema = z20.object({
+  version: z20.literal(2),
+  certificate: z20.literal("graph-release"),
+  platform: z20.enum(["linux", "win32"]),
+  opencodeVersion: z20.string().min(1),
+  shadowCertificateDigest: z20.string().regex(/^[0-9a-f]{64}$/),
+  evidence: ReleaseEvidenceSchema,
+  verdict: z20.enum(["pass", "fail"]),
+  failedGates: z20.array(z20.enum([
+    "shadow-valid",
+    "determinism",
+    "crash-recovery",
+    "replay-equivalence",
+    "privacy",
+    "contract",
+    "health",
+    "performance"
+  ])),
+  digest: z20.string().regex(/^[0-9a-f]{64}$/)
+}).strict();
 
-// src/memory/rank.ts
-var DAY_MS = 86400000;
-var DEFAULT_RANK_SIGNALS = {
-  similarityWeight: 1,
-  recencyWeight: 0.2,
-  accessWeight: 0.1,
-  recencyHalfLifeMs: 14 * DAY_MS
-};
-function recencyTimestamp(record) {
-  if (record.kind === "preference" && record.lastAccessedAt !== null) {
-    return record.lastAccessedAt;
+class ReleaseCertificateError extends Error {
+  code;
+  detail;
+  constructor(code, detail) {
+    super(`${code}: ${detail}`);
+    this.name = "ReleaseCertificateError";
+    this.code = code;
+    this.detail = detail;
   }
-  return record.createdAt;
-}
-function recencyScore(record, signals) {
-  const ageMs = Math.max(0, signals.now - recencyTimestamp(record));
-  return 0.5 ** (ageMs / signals.recencyHalfLifeMs);
 }
-function accessScore(record) {
-  if (record.kind !== "preference") {
-    return 0;
+function evaluateReleaseGates(evidence, expectedShadowDigest) {
+  const failed = [];
+  if (evidence.shadowCertificateDigest !== expectedShadowDigest) {
+    failed.push("shadow-valid");
   }
-  return 1 - 1 / (1 + record.accessCount);
-}
-function scoreCandidate(candidate, signals) {
-  return signals.similarityWeight * candidate.similarity + signals.recencyWeight * recencyScore(candidate.record, signals) + signals.accessWeight * accessScore(candidate.record);
+  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.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 rankRecall(candidates, signals) {
-  return candidates.map((candidate) => ({
-    ...candidate,
-    score: scoreCandidate(candidate, signals)
-  })).sort((a, b) => {
-    if (b.score !== a.score) {
-      return b.score - a.score;
+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
+      },
+      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
+      }
     }
-    return a.record.id < b.record.id ? -1 : a.record.id > b.record.id ? 1 : 0;
   });
 }
+function sameReleaseGates(a, b) {
+  return a.length === b.length && a.every((gate, index) => gate === b[index]);
+}
+function parseReleaseCertificate(value, opencodeVersion, expectedShadowDigest) {
+  if (typeof value === "object" && value !== null && "version" in value && value.version === 1) {
+    throw new ReleaseCertificateError("invalid-certificate", "certificate is schema version 1 (carried a removed 'migration' gate); " + "rebuild the release certificate against the current schema");
+  }
+  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 (!isCertificateVersionCompatible(certificate.opencodeVersion, opencodeVersion)) {
+    throw new ReleaseCertificateError("opencode-mismatch", `certified for "${certificate.opencodeVersion}", running "${opencodeVersion}" — evidence is accepted only on ${certificate.opencodeVersion} or a newer patch of the same minor line`);
+  }
+  return certificate;
+}
+var ShadowDivergenceCodeSchema = z20.enum([
+  "status",
+  "order",
+  "roles",
+  "models",
+  "fixes",
+  "outcome"
+]);
+var RECOMPUTED_DIVERGENCE_CODES = ["fixes"];
+var RecomputedDivergenceCodeSchema = z20.enum(RECOMPUTED_DIVERGENCE_CODES);
+var SoakPolicySchema = z20.object({
+  minimumGenuineObservations: z20.number().int().positive(),
+  minimumDistinctDays: z20.number().int().positive(),
+  requireGenuineUsageOnAllPlatforms: z20.boolean(),
+  supportedOpencodeVersions: z20.array(z20.string().min(1)).min(1),
+  criticalDivergenceCodes: z20.array(RecomputedDivergenceCodeSchema).min(1)
+}).strict();
+var DEFAULT_SOAK_POLICY = {
+  minimumGenuineObservations: 100,
+  minimumDistinctDays: 14,
+  requireGenuineUsageOnAllPlatforms: true,
+  supportedOpencodeVersions: [...SUPPORTED_OPENCODE_VERSIONS],
+  criticalDivergenceCodes: ["fixes"]
+};
+var SoakPlatformEnumSchema = z20.enum(["linux", "win32", "darwin"]);
+var SoakPrivacyPairEvidenceSchema = z20.object({
+  surfacesScanned: z20.number().int().nonnegative(),
+  rawFindings: z20.number().int().nonnegative()
+}).strict();
+var SoakDuplicateEffectPairEvidenceSchema = z20.object({
+  effectsExamined: z20.number().int().nonnegative(),
+  duplicatesFound: z20.number().int().nonnegative()
+}).strict();
+var SoakModelVerificationPairEvidenceSchema = z20.object({
+  nodesChecked: z20.number().int().nonnegative(),
+  unverified: z20.number().int().nonnegative(),
+  mismatched: z20.number().int().nonnegative()
+}).strict();
+var SoakEvidenceSchema = z20.object({
+  totalObservations: z20.number().int().nonnegative(),
+  genuineUsageObservations: z20.number().int().nonnegative(),
+  ciSyntheticObservations: z20.number().int().nonnegative(),
+  recorderCount: z20.number().int().nonnegative(),
+  ineligibleObservations: z20.number().int().nonnegative(),
+  firstTimestamp: z20.string().datetime().nullable(),
+  lastTimestamp: z20.string().datetime().nullable(),
+  distinctDays: z20.number().int().nonnegative(),
+  criticalDivergences: z20.number().int().nonnegative().nullable(),
+  privacy: SoakPrivacyPairEvidenceSchema.nullable(),
+  duplicateEffects: SoakDuplicateEffectPairEvidenceSchema.nullable(),
+  modelVerification: SoakModelVerificationPairEvidenceSchema.nullable(),
+  platformsGenuine: z20.array(SoakPlatformEnumSchema),
+  platformsSynthetic: z20.array(SoakPlatformEnumSchema),
+  opencodeVersionsObserved: z20.array(z20.string().min(1)),
+  invalidChains: z20.number().int().nonnegative()
+}).strict();
+var SoakCertificateSchema = z20.object({
+  version: z20.literal(1),
+  certificate: z20.literal("graph-soak"),
+  trustBoundary: z20.literal("contributors"),
+  policy: SoakPolicySchema,
+  evidence: SoakEvidenceSchema,
+  verdict: z20.enum(["pass", "fail"]),
+  failedGates: z20.array(z20.enum([
+    "minimum-observations",
+    "minimum-duration",
+    "chain-integrity",
+    "zero-critical-divergence",
+    "zero-privacy-breach",
+    "zero-duplicate-effect",
+    "zero-model-mismatch",
+    "os-diversity",
+    "opencode-pin"
+  ])),
+  ledgerDigest: z20.string().regex(/^[0-9a-f]{64}$/),
+  digest: z20.string().regex(/^[0-9a-f]{64}$/)
+}).strict();
 
-// src/memory/temporal.ts
-function isTransactionActiveAt(record, asOf) {
-  return record.invalidatedAt === null || record.invalidatedAt > asOf;
+class SoakCertificateError extends Error {
+  code;
+  detail;
+  constructor(code, detail) {
+    super(`${code}: ${detail}`);
+    this.name = "SoakCertificateError";
+    this.code = code;
+    this.detail = detail;
+  }
 }
-function isValidAt(record, asOf) {
-  if (record.validFrom > asOf) {
-    return false;
+function evaluateSoakGates(evidence, policy) {
+  const failed = [];
+  if (evidence.genuineUsageObservations < policy.minimumGenuineObservations) {
+    failed.push("minimum-observations");
   }
-  return record.validUntil === null || record.validUntil > asOf;
+  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");
+    }
+  }
+  const supported = new Set(policy.supportedOpencodeVersions);
+  if (evidence.opencodeVersionsObserved.length === 0 || !evidence.opencodeVersionsObserved.every((v) => supported.has(v))) {
+    failed.push("opencode-pin");
+  }
+  return failed;
 }
-function isActiveAt(record, asOf) {
-  return isTransactionActiveAt(record, asOf) && isValidAt(record, asOf);
+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,
+      supportedOpencodeVersions: [...pol.supportedOpencodeVersions].sort(),
+      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,
+      ineligibleObservations: ev.ineligibleObservations,
+      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 filterActive(records, asOf) {
-  return records.filter((record) => isActiveAt(record, asOf));
+function sameSoakGates(a, b) {
+  return a.length === b.length && a.every((gate, index) => gate === b[index]);
 }
-function coalesceWindow(a, b) {
-  const validFrom = Math.min(a.validFrom, b.validFrom);
-  const validUntil = a.validUntil === null || b.validUntil === null ? null : Math.max(a.validUntil, b.validUntil);
-  return { validFrom, validUntil };
+function sameSoakPolicy(a, b) {
+  const aVersions = [...a.supportedOpencodeVersions].sort();
+  const bVersions = [...b.supportedOpencodeVersions].sort();
+  return a.minimumGenuineObservations === b.minimumGenuineObservations && a.minimumDistinctDays === b.minimumDistinctDays && a.requireGenuineUsageOnAllPlatforms === b.requireGenuineUsageOnAllPlatforms && aVersions.length === bVersions.length && aVersions.every((v, i) => v === bVersions[i]) && a.criticalDivergenceCodes.length === b.criticalDivergenceCodes.length && [...a.criticalDivergenceCodes].sort().every((code, i) => code === [...b.criticalDivergenceCodes].sort()[i]);
 }
-
-// src/memory/types.ts
-import { z as z19 } from "zod";
-var SHARED_OWNER_KEY = "*";
-var OwnerKeySchema = z19.string().min(1);
-var MemoryKindSchema = z19.enum(["fact", "preference", "entity"]);
-var MemoryBaseSchema = z19.object({
-  id: z19.string().min(1),
-  ownerKey: OwnerKeySchema,
-  confidence: z19.number().min(0).max(1),
-  validFrom: z19.number().finite(),
-  validUntil: z19.number().finite().nullable().default(null),
-  createdAt: z19.number().finite(),
-  invalidatedAt: z19.number().finite().nullable().default(null),
-  sourceHash: z19.string().min(1),
-  supersededBy: z19.string().min(1).nullable().default(null)
-}).strict();
-var FactSchema = MemoryBaseSchema.extend({
-  kind: z19.literal("fact"),
-  subject: z19.string().min(1),
-  predicate: z19.string().min(1),
-  object: z19.string().min(1),
-  category: z19.string().min(1).nullable().default(null)
-});
-var PreferenceSchema = MemoryBaseSchema.extend({
-  kind: z19.literal("preference"),
-  category: z19.string().min(1),
-  preference: z19.string().min(1),
-  context: z19.string().min(1).nullable().default(null),
-  lastAccessedAt: z19.number().finite().nullable().default(null),
-  accessCount: z19.number().int().min(0).default(0)
-});
-var EntitySchema = MemoryBaseSchema.extend({
-  kind: z19.literal("entity"),
-  canonicalName: z19.string().min(1),
-  type: z19.string().min(1),
-  aliases: z19.array(z19.string().min(1)).default([])
-});
-var RelationSchema = MemoryBaseSchema.extend({
-  kind: z19.literal("relation"),
-  from: z19.string().min(1),
-  to: z19.string().min(1),
-  predicate: z19.string().min(1),
-  annotation: z19.string().min(1).nullable().default(null)
-});
-var MemoryRecordSchema = z19.discriminatedUnion("kind", [
-  FactSchema,
-  PreferenceSchema,
-  EntitySchema,
-  RelationSchema
-]);
-var RecallQuerySchema = z19.object({
-  ownerKey: OwnerKeySchema,
-  kinds: z19.array(MemoryKindSchema).default(["fact", "preference", "entity"]),
-  asOf: z19.number().finite().nullable().default(null),
-  limit: z19.number().int().positive().default(8),
-  minSimilarity: z19.number().min(0).max(1).default(0.2),
-  includeShared: z19.boolean().default(true)
-}).strict();
-
-// src/memory/vector.ts
-function dot(a, b) {
-  if (a.length !== b.length) {
-    throw new Error(`dimension mismatch: ${a.length} vs ${b.length}`);
+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);
   }
-  let sum = 0;
-  for (let i = 0;i < a.length; i += 1) {
-    sum += a[i] * b[i];
+  const certificate = parsed.data;
+  if (!sameSoakPolicy(certificate.policy, expectedPolicy)) {
+    throw new SoakCertificateError("policy-mismatch", "embedded policy diverges from the expected policy");
   }
-  return sum;
+  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;
 }
-function norm(a) {
-  let sum = 0;
-  for (let i = 0;i < a.length; i += 1) {
-    const value = a[i];
-    sum += value * value;
+
+// src/local/cacheAdapter.ts
+import * as fs3 from "node:fs";
+import * as os from "node:os";
+import * as path3 from "node:path";
+var SCOPE_PREFIX2 = "@jmanuelcorral/openteam";
+var SCOPE_SEGMENTS = SCOPE_PREFIX2.split("/");
+function resolveCacheRoot(override) {
+  if (override !== undefined && override.trim() !== "") {
+    return override;
   }
-  return Math.sqrt(sum);
+  const base = process.env.XDG_CACHE_HOME ?? path3.join(os.homedir(), ".cache");
+  return path3.join(base, "opencode", "packages");
 }
-function cosineSimilarity(a, b) {
-  const denom = norm(a) * norm(b);
-  if (denom === 0) {
-    return 0;
+function readJsonSafe(filePath) {
+  try {
+    const text2 = fs3.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(text2);
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return;
+  } catch {
+    return;
   }
-  return dot(a, b) / denom;
 }
-
-// src/memory/recall.ts
-function matchesScope(record, query) {
-  if (record.ownerKey === query.ownerKey) {
-    return true;
+function extractVersion(pkg) {
+  if (pkg === undefined)
+    return "";
+  const v = pkg.version;
+  return typeof v === "string" ? v : "";
+}
+function readDirectoryEntries(dir) {
+  try {
+    return fs3.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
   }
-  return query.includeShared && record.ownerKey === SHARED_OWNER_KEY;
 }
-function recall(records, queryEmbedding, query, deps) {
-  const asOf = query.asOf ?? deps.now;
-  const kinds = new Set(query.kinds);
+function lstatPlainDirectory(dir) {
+  try {
+    const stat2 = fs3.lstatSync(dir);
+    if (!stat2.isDirectory() || stat2.isSymbolicLink()) {
+      return;
+    }
+    return stat2;
+  } catch {
+    return;
+  }
+}
+function findEntryDirs(cacheRoot) {
   const candidates = [];
-  for (const record of filterActive(records, asOf)) {
-    if (!kinds.has(record.kind) || !matchesScope(record, query)) {
+  for (const topEntry of readDirectoryEntries(cacheRoot)) {
+    const topPath = path3.join(cacheRoot, topEntry.name);
+    const topStat = lstatPlainDirectory(topPath);
+    if (topStat === undefined) {
       continue;
     }
-    const embedding = deps.embeddings.get(record.id);
-    if (embedding === undefined) {
+    if (!topEntry.name.startsWith("@")) {
+      candidates.push({
+        specDir: topEntry.name,
+        absolutePath: topPath,
+        stat: topStat
+      });
       continue;
     }
-    const similarity = cosineSimilarity(queryEmbedding, embedding);
-    if (similarity < query.minSimilarity) {
-      continue;
+    for (const packageEntry of readDirectoryEntries(topPath)) {
+      const packagePath = path3.join(topPath, packageEntry.name);
+      const packageStat = lstatPlainDirectory(packagePath);
+      if (packageStat === undefined) {
+        continue;
+      }
+      candidates.push({
+        specDir: `${topEntry.name}/${packageEntry.name}`,
+        absolutePath: packagePath,
+        stat: packageStat
+      });
     }
-    candidates.push({ record, similarity });
   }
-  const signals = {
-    now: deps.now,
-    ...deps.signals ?? DEFAULT_RANK_SIGNALS
-  };
-  return rankRecall(candidates, signals).slice(0, query.limit);
+  return candidates.sort((a, b) => a.specDir.localeCompare(b.specDir));
 }
-
-// src/memory/traverse.ts
-function inOwnerScope(record, ownerKey, includeShared) {
-  if (record.ownerKey === ownerKey) {
-    return true;
-  }
-  return includeShared && record.ownerKey === SHARED_OWNER_KEY;
-}
-function traverseRelations(records, query) {
-  const includeShared = query.includeShared ?? true;
-  const adjacency = new Map;
-  for (const record of records) {
-    if (record.kind !== "relation") {
-      continue;
-    }
-    if (!isActiveAt(record, query.asOf)) {
-      continue;
-    }
-    if (!inOwnerScope(record, query.ownerKey, includeShared)) {
+async function listEntries(cacheRoot) {
+  const entries = [];
+  for (const candidate of findEntryDirs(cacheRoot)) {
+    const { specDir, absolutePath, stat: stat2 } = candidate;
+    if (!specDir.startsWith(SCOPE_PREFIX2))
       continue;
+    const mtimeIso = stat2.mtime.toISOString();
+    const entryPkg = readJsonSafe(path3.join(absolutePath, "package.json"));
+    const deps = entryPkg?.dependencies;
+    let pinnedVersion = "";
+    if (deps !== null && typeof deps === "object" && !Array.isArray(deps)) {
+      const depsObj = deps;
+      const pinned = depsObj[SCOPE_PREFIX2];
+      pinnedVersion = typeof pinned === "string" ? pinned : "";
     }
-    const list = adjacency.get(record.from);
-    if (list === undefined) {
-      adjacency.set(record.from, [record]);
-    } else {
-      list.push(record);
-    }
-  }
-  const visited = new Set([query.seed]);
-  const nodes = [{ id: query.seed, depth: 0 }];
-  const edges = [];
-  let frontier = [query.seed];
-  for (let depth = 0;depth < query.maxDepth; depth += 1) {
-    const nextFrontier = [];
-    for (const nodeId of frontier) {
-      const outgoing = adjacency.get(nodeId) ?? [];
-      for (const edge of outgoing) {
-        if (visited.has(edge.to)) {
-          continue;
-        }
-        visited.add(edge.to);
-        const childDepth = depth + 1;
-        nodes.push({ id: edge.to, depth: childDepth });
-        edges.push({
-          from: edge.from,
-          to: edge.to,
-          predicate: edge.predicate,
-          depth: childDepth
-        });
-        nextFrontier.push(edge.to);
-      }
-    }
-    frontier = nextFrontier;
+    const installedPkg = readJsonSafe(path3.join(absolutePath, "node_modules", ...SCOPE_SEGMENTS, "package.json"));
+    const installedVersion = extractVersion(installedPkg);
+    entries.push({
+      specDir,
+      absolutePath,
+      pinnedVersion,
+      installedVersion,
+      mtimeIso
+    });
   }
-  return { seed: query.seed, nodes, edges };
+  return entries;
 }
-function seedNodeId(record) {
-  return record.kind === "entity" ? record.canonicalName : undefined;
+async function deleteEntry(entryPath) {
+  fs3.rmSync(entryPath, { recursive: true, force: true });
 }
-function recallGraph(records, queryEmbedding, query, options, deps) {
-  const seeds = recall(records, queryEmbedding, query, deps);
-  const asOf = query.asOf ?? deps.now;
-  const includeShared = options.includeShared ?? query.includeShared;
-  const traversals = [];
-  for (const result of seeds) {
-    const seed = seedNodeId(result.record);
-    if (seed === undefined) {
-      continue;
-    }
-    traversals.push({
-      seedRecordId: result.record.id,
-      traversal: traverseRelations(records, {
-        seed,
-        ownerKey: query.ownerKey,
-        asOf,
-        maxDepth: options.maxDepth,
-        includeShared
-      })
-    });
+async function isReparsePath(entryPath) {
+  try {
+    const stat2 = await fs3.promises.lstat(entryPath);
+    return stat2.isSymbolicLink();
+  } catch {
+    return true;
   }
-  return { recall: seeds, traversals };
 }
+var realCacheAdapter = {
+  resolveCacheRoot,
+  listEntries,
+  deleteEntry,
+  isReparsePath
+};
 
-// src/memory/merge.ts
-var SEP = "\x00";
-function factSlotKey(fact) {
-  return [fact.subject, fact.predicate, fact.ownerKey].join(SEP);
-}
-function factValueKey(fact) {
-  return [factSlotKey(fact), fact.object].join(SEP);
-}
-function preferenceSlotKey(preference) {
-  return [preference.category, preference.ownerKey].join(SEP);
-}
-function preferenceValueKey(preference) {
-  return [preferenceSlotKey(preference), preference.preference].join(SEP);
+// src/orchestrator/rosterPersistence.ts
+function rosterFence(roster) {
+  const data = { universe: roster.universe, entries: roster.entries };
+  return `\`\`\`json
+${JSON.stringify(data, null, 2)}
+\`\`\``;
 }
-function entitySlotKey(entity) {
-  return [entity.canonicalName, entity.type, entity.ownerKey].join(SEP);
+function serializeRoster(roster) {
+  return `# openteam roster
+
+Universe: ${roster.universe}
+
+${rosterFence(roster)}
+`;
 }
-function relationSlotKey(relation) {
-  return [relation.from, relation.predicate, relation.ownerKey].join(SEP);
+async function persistRoster(storage, roster, path4 = OPENTEAM_ROSTER_PATH) {
+  await storage.write(path4, serializeRoster(roster));
+  return path4;
 }
-function relationValueKey(relation) {
-  return [relationSlotKey(relation), relation.to].join(SEP);
+async function loadRosterFile(storage, path4 = OPENTEAM_ROSTER_PATH) {
+  const content = await storage.read(path4);
+  if (content === undefined) {
+    return { status: "absent", path: path4 };
+  }
+  const parsed = parseRosterResult(content);
+  if (!parsed.ok) {
+    return { status: "invalid", path: path4, error: parsed.error };
+  }
+  return {
+    status: "loaded",
+    path: path4,
+    roster: enforceGuaranteedRoles(parsed.roster)
+  };
 }
-function coalesceFact(existing, incoming) {
-  const window = coalesceWindow(existing, incoming);
+async function loadOrGenerateRoster(storage, generate, path4 = OPENTEAM_ROSTER_PATH) {
+  const existing = await loadRosterFile(storage, path4);
+  if (existing.status === "loaded") {
+    return { roster: existing.roster, regenerated: false };
+  }
+  const roster = enforceGuaranteedRoles(await generate());
+  if (existing.status === "absent") {
+    await persistRoster(storage, roster, path4);
+    return { roster, regenerated: true };
+  }
   return {
-    ...existing,
-    validFrom: window.validFrom,
-    validUntil: window.validUntil,
-    confidence: Math.max(existing.confidence, incoming.confidence)
+    roster,
+    regenerated: true,
+    recoveredFromInvalidPersisted: true,
+    invalidPersistedRosterError: existing.error.message
   };
 }
-function applyFact(state, incoming, now) {
-  const incomingSlot = factSlotKey(incoming);
-  const incomingValue = factValueKey(incoming);
-  const superseded = [];
-  const records = [];
-  let reaffirmed = false;
-  for (const fact of state) {
-    if (!isActiveAt(fact, now)) {
-      records.push(fact);
-      continue;
-    }
-    if (factValueKey(fact) === incomingValue) {
-      records.push(coalesceFact(fact, incoming));
-      reaffirmed = true;
-      continue;
-    }
-    if (factSlotKey(fact) === incomingSlot) {
-      const dead = {
-        ...fact,
-        invalidatedAt: now,
-        supersededBy: incoming.id
-      };
-      superseded.push(dead);
-      records.push(dead);
-      continue;
-    }
-    records.push(fact);
+
+// src/memory/types.ts
+import { z as z21 } from "zod";
+var SHARED_OWNER_KEY = "*";
+var OwnerKeySchema = z21.string().min(1);
+var MemoryKindSchema = z21.enum(["fact", "preference", "entity"]);
+var MemoryBaseSchema = z21.object({
+  id: z21.string().min(1),
+  ownerKey: OwnerKeySchema,
+  confidence: z21.number().min(0).max(1),
+  validFrom: z21.number().finite(),
+  validUntil: z21.number().finite().nullable().default(null),
+  createdAt: z21.number().finite(),
+  invalidatedAt: z21.number().finite().nullable().default(null),
+  sourceHash: z21.string().min(1),
+  supersededBy: z21.string().min(1).nullable().default(null)
+}).strict();
+var FactSchema = MemoryBaseSchema.extend({
+  kind: z21.literal("fact"),
+  subject: z21.string().min(1),
+  predicate: z21.string().min(1),
+  object: z21.string().min(1),
+  category: z21.string().min(1).nullable().default(null)
+});
+var PreferenceSchema = MemoryBaseSchema.extend({
+  kind: z21.literal("preference"),
+  category: z21.string().min(1),
+  preference: z21.string().min(1),
+  context: z21.string().min(1).nullable().default(null),
+  lastAccessedAt: z21.number().finite().nullable().default(null),
+  accessCount: z21.number().int().min(0).default(0)
+});
+var EntitySchema = MemoryBaseSchema.extend({
+  kind: z21.literal("entity"),
+  canonicalName: z21.string().min(1),
+  type: z21.string().min(1),
+  aliases: z21.array(z21.string().min(1)).default([])
+});
+var RelationSchema = MemoryBaseSchema.extend({
+  kind: z21.literal("relation"),
+  from: z21.string().min(1),
+  to: z21.string().min(1),
+  predicate: z21.string().min(1),
+  annotation: z21.string().min(1).nullable().default(null)
+});
+var MemoryRecordSchema = z21.discriminatedUnion("kind", [
+  FactSchema,
+  PreferenceSchema,
+  EntitySchema,
+  RelationSchema
+]);
+var RecallQuerySchema = z21.object({
+  ownerKey: OwnerKeySchema,
+  kinds: z21.array(MemoryKindSchema).default(["fact", "preference", "entity"]),
+  asOf: z21.number().finite().nullable().default(null),
+  limit: z21.number().int().positive().default(8),
+  minSimilarity: z21.number().min(0).max(1).default(0.2),
+  includeShared: z21.boolean().default(true)
+}).strict();
+
+// src/memory/rank.ts
+var DAY_MS = 86400000;
+var DEFAULT_RANK_SIGNALS = {
+  similarityWeight: 1,
+  recencyWeight: 0.2,
+  accessWeight: 0.1,
+  recencyHalfLifeMs: 14 * DAY_MS
+};
+function recencyTimestamp(record) {
+  if (record.kind === "preference" && record.lastAccessedAt !== null) {
+    return record.lastAccessedAt;
   }
-  if (!reaffirmed) {
-    records.push(incoming);
+  return record.createdAt;
+}
+function recencyScore(record, signals) {
+  const ageMs = Math.max(0, signals.now - recencyTimestamp(record));
+  return 0.5 ** (ageMs / signals.recencyHalfLifeMs);
+}
+function accessScore(record) {
+  if (record.kind !== "preference") {
+    return 0;
   }
-  return { records, superseded };
+  return 1 - 1 / (1 + record.accessCount);
 }
-function applyPreference(state, incoming, now) {
-  const incomingSlot = preferenceSlotKey(incoming);
-  const incomingValue = preferenceValueKey(incoming);
-  const superseded = [];
+function scoreCandidate(candidate, signals) {
+  return signals.similarityWeight * candidate.similarity + signals.recencyWeight * recencyScore(candidate.record, signals) + signals.accessWeight * accessScore(candidate.record);
+}
+function rankRecall(candidates, signals) {
+  return candidates.map((candidate) => ({
+    ...candidate,
+    score: scoreCandidate(candidate, signals)
+  })).sort((a, b) => {
+    if (b.score !== a.score) {
+      return b.score - a.score;
+    }
+    return a.record.id < b.record.id ? -1 : a.record.id > b.record.id ? 1 : 0;
+  });
+}
+
+// src/memory/temporal.ts
+function isTransactionActiveAt(record, asOf) {
+  return record.invalidatedAt === null || record.invalidatedAt > asOf;
+}
+function isValidAt(record, asOf) {
+  if (record.validFrom > asOf) {
+    return false;
+  }
+  return record.validUntil === null || record.validUntil > asOf;
+}
+function isActiveAt(record, asOf) {
+  return isTransactionActiveAt(record, asOf) && isValidAt(record, asOf);
+}
+function filterActive(records, asOf) {
+  return records.filter((record) => isActiveAt(record, asOf));
+}
+function coalesceWindow(a, b) {
+  const validFrom = Math.min(a.validFrom, b.validFrom);
+  const validUntil = a.validUntil === null || b.validUntil === null ? null : Math.max(a.validUntil, b.validUntil);
+  return { validFrom, validUntil };
+}
+
+// src/memory/vector.ts
+function dot(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`dimension mismatch: ${a.length} vs ${b.length}`);
+  }
+  let sum = 0;
+  for (let i = 0;i < a.length; i += 1) {
+    sum += a[i] * b[i];
+  }
+  return sum;
+}
+function norm(a) {
+  let sum = 0;
+  for (let i = 0;i < a.length; i += 1) {
+    const value = a[i];
+    sum += value * value;
+  }
+  return Math.sqrt(sum);
+}
+function cosineSimilarity(a, b) {
+  const denom = norm(a) * norm(b);
+  if (denom === 0) {
+    return 0;
+  }
+  return dot(a, b) / denom;
+}
+
+// src/memory/recall.ts
+function matchesScope(record, query) {
+  if (record.ownerKey === query.ownerKey) {
+    return true;
+  }
+  return query.includeShared && record.ownerKey === SHARED_OWNER_KEY;
+}
+function recall(records, queryEmbedding, query, deps) {
+  const asOf = query.asOf ?? deps.now;
+  const kinds = new Set(query.kinds);
+  const candidates = [];
+  for (const record of filterActive(records, asOf)) {
+    if (!kinds.has(record.kind) || !matchesScope(record, query)) {
+      continue;
+    }
+    const embedding = deps.embeddings.get(record.id);
+    if (embedding === undefined) {
+      continue;
+    }
+    const similarity = cosineSimilarity(queryEmbedding, embedding);
+    if (similarity < query.minSimilarity) {
+      continue;
+    }
+    candidates.push({ record, similarity });
+  }
+  const signals = {
+    now: deps.now,
+    ...deps.signals ?? DEFAULT_RANK_SIGNALS
+  };
+  return rankRecall(candidates, signals).slice(0, query.limit);
+}
+
+// src/memory/merge.ts
+var SEP = "\x00";
+function factSlotKey(fact) {
+  return [fact.subject, fact.predicate, fact.ownerKey].join(SEP);
+}
+function factValueKey(fact) {
+  return [factSlotKey(fact), fact.object].join(SEP);
+}
+function preferenceSlotKey(preference) {
+  return [preference.category, preference.ownerKey].join(SEP);
+}
+function preferenceValueKey(preference) {
+  return [preferenceSlotKey(preference), preference.preference].join(SEP);
+}
+function entitySlotKey(entity) {
+  return [entity.canonicalName, entity.type, entity.ownerKey].join(SEP);
+}
+function relationSlotKey(relation) {
+  return [relation.from, relation.predicate, relation.ownerKey].join(SEP);
+}
+function relationValueKey(relation) {
+  return [relationSlotKey(relation), relation.to].join(SEP);
+}
+function coalesceFact(existing, incoming) {
+  const window = coalesceWindow(existing, incoming);
+  return {
+    ...existing,
+    validFrom: window.validFrom,
+    validUntil: window.validUntil,
+    confidence: Math.max(existing.confidence, incoming.confidence)
+  };
+}
+function applyFact(state, incoming, now) {
+  const incomingSlot = factSlotKey(incoming);
+  const incomingValue = factValueKey(incoming);
+  const superseded = [];
+  const records = [];
+  let reaffirmed = false;
+  for (const fact of state) {
+    if (!isActiveAt(fact, now)) {
+      records.push(fact);
+      continue;
+    }
+    if (factValueKey(fact) === incomingValue) {
+      records.push(coalesceFact(fact, incoming));
+      reaffirmed = true;
+      continue;
+    }
+    if (factSlotKey(fact) === incomingSlot) {
+      const dead = {
+        ...fact,
+        invalidatedAt: now,
+        supersededBy: incoming.id
+      };
+      superseded.push(dead);
+      records.push(dead);
+      continue;
+    }
+    records.push(fact);
+  }
+  if (!reaffirmed) {
+    records.push(incoming);
+  }
+  return { records, superseded };
+}
+function applyPreference(state, incoming, now) {
+  const incomingSlot = preferenceSlotKey(incoming);
+  const incomingValue = preferenceValueKey(incoming);
+  const superseded = [];
   const records = [];
   let reaffirmed = false;
   for (const preference of state) {
@@ -15076,71 +15954,550 @@ async function recallMemory(deps, queryText, query) {
   return recall(recordRead.records, queryEmbedding, query, recallDeps);
 }
 
-// src/mcp/semanticRecall.ts
-function buildSemanticRecall(deps, policy) {
-  return async ({ queryText, kinds, limit }) => {
-    const query = RecallQuerySchema.parse({
-      ownerKey: policy.ownerKey,
-      kinds,
-      asOf: policy.asOf ?? null,
-      limit,
-      minSimilarity: policy.minSimilarity,
-      includeShared: policy.includeShared
-    });
-    const recallDeps = deps.signals === undefined ? { index: deps.index, embedder: deps.embedder, now: deps.now() } : {
-      index: deps.index,
-      embedder: deps.embedder,
-      now: deps.now(),
-      signals: deps.signals
-    };
-    return recallMemory(recallDeps, queryText, query);
-  };
-}
-var DEFAULT_TRAVERSAL_DEPTH = 3;
-function buildRelationTraversal(deps, policy) {
-  return async ({ seed, maxDepth }) => {
-    const asOf = policy.asOf ?? deps.now();
-    return traverseRelations(deps.index.allRecords(), {
-      seed,
-      ownerKey: policy.ownerKey,
-      asOf,
-      maxDepth: maxDepth ?? DEFAULT_TRAVERSAL_DEPTH,
-      includeShared: policy.includeShared
-    });
-  };
-}
-function buildGraphRecall(deps, policy) {
-  return async ({ queryText, limit, maxDepth }) => {
-    const query = RecallQuerySchema.parse({
-      ownerKey: policy.ownerKey,
-      kinds: ["fact", "preference", "entity"],
-      asOf: policy.asOf ?? null,
-      limit,
-      minSimilarity: policy.minSimilarity,
-      includeShared: policy.includeShared
-    });
-    const [queryEmbedding] = await deps.embedder([queryText]);
-    if (queryEmbedding === undefined) {
-      return { recall: [], traversals: [] };
+// src/plugin/orchestrateTool.ts
+import { tool } from "@opencode-ai/plugin";
+import { z as z22 } from "zod";
+var _pluginWarnedRoles = new Set;
+var RoleAssignmentSchema = z22.object({
+  roleID: z22.string().min(1).describe("Role identifier from the roster"),
+  prompt: z22.string().min(1).describe("Work prompt for this role"),
+  title: z22.string().min(1).optional().describe("Human-readable title"),
+  dependsOn: z22.array(z22.string().min(1)).optional().describe("Role IDs this assignment depends on (DAG edges)")
+}).strict();
+var OrchestratePayloadSchema = z22.object({
+  assignments: z22.array(RoleAssignmentSchema).min(1).describe("Role assignments to distribute"),
+  parentSessionID: z22.string().min(1).optional().describe("Parent session for subsessions"),
+  directory: z22.string().min(1).optional().describe("Working directory override")
+}).strict();
+function adaptSdkClient(sdk) {
+  return {
+    session: {
+      create: async (args) => {
+        const result = await sdk.session.create(args);
+        const out = {};
+        if (result.data !== undefined) {
+          out.data = result.data;
+        }
+        if (result.error !== undefined) {
+          out.error = result.error;
+        }
+        return out;
+      },
+      prompt: async (args) => {
+        const result = await sdk.session.prompt(args);
+        const out = {};
+        if (result.data !== undefined) {
+          out.data = result.data;
+        }
+        if (result.error !== undefined) {
+          out.error = result.error;
+        }
+        return out;
+      }
     }
-    const recallDeps = deps.signals === undefined ? { embeddings: deps.index.embeddingMap(), now: deps.now() } : {
-      embeddings: deps.index.embeddingMap(),
-      now: deps.now(),
-      signals: deps.signals
-    };
-    return recallGraph(deps.index.allRecords(), queryEmbedding, query, {
-      maxDepth: maxDepth ?? DEFAULT_TRAVERSAL_DEPTH,
-      includeShared: policy.includeShared
-    }, recallDeps);
   };
 }
 
-// src/mcp/teamMemory.ts
-function buildTeamMemory(events) {
-  const aggregate = aggregateEvents(events);
-  return {
-    sessions: aggregate.sessions,
-    totals: aggregate.totals,
+// src/local/embeddings.ts
+function parseEmbeddingsResponse(payload) {
+  if (typeof payload !== "object" || payload === null || !Array.isArray(payload.data)) {
+    throw new Error("Malformed /embeddings response: missing 'data'");
+  }
+  const data = payload.data;
+  return data.map((entry, index) => {
+    const embedding = typeof entry === "object" && entry !== null ? entry.embedding : undefined;
+    if (!Array.isArray(embedding) || !embedding.every((n) => typeof n === "number" && Number.isFinite(n))) {
+      throw new Error(`Malformed /embeddings response: invalid vector at index ${index}`);
+    }
+    return embedding;
+  });
+}
+async function embedTexts(request, deps) {
+  if (request.texts.length === 0) {
+    return [];
+  }
+  let response;
+  try {
+    response = await deps.fetch(embeddingsEndpoint(request.baseURL), {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        accept: "application/json"
+      },
+      body: JSON.stringify({
+        model: request.modelID,
+        input: [...request.texts]
+      })
+    });
+  } catch (error) {
+    throw new Error(`Local embeddings failed: ${errorMessage(error)}`);
+  }
+  if (!response.ok) {
+    throw new Error(`Local embeddings failed: HTTP ${response.status} on /embeddings`);
+  }
+  let payload;
+  try {
+    payload = await response.json();
+  } catch (error) {
+    throw new Error(`Local embeddings failed: ${errorMessage(error)}`);
+  }
+  const vectors = parseEmbeddingsResponse(payload);
+  if (vectors.length !== request.texts.length) {
+    throw new Error(`Local embeddings returned ${vectors.length} vectors for ${request.texts.length} texts`);
+  }
+  return vectors;
+}
+function createLocalEmbedder(request, deps) {
+  return (texts) => embedTexts({ ...request, texts }, deps);
+}
+
+// src/memory/embedText.ts
+function normalize(parts) {
+  return parts.map((part) => part.trim()).filter((part) => part.length > 0).join(" ");
+}
+function recordEmbeddingText(record) {
+  if (record.kind === "fact") {
+    return normalize([
+      record.subject,
+      record.predicate,
+      record.object,
+      record.category ?? ""
+    ]);
+  }
+  if (record.kind === "preference") {
+    return normalize([
+      record.category,
+      record.preference,
+      record.context ?? ""
+    ]);
+  }
+  if (record.kind === "relation") {
+    return normalize([
+      record.from,
+      record.predicate,
+      record.to,
+      record.annotation ?? ""
+    ]);
+  }
+  return normalize([record.canonicalName, record.type, ...record.aliases]);
+}
+
+// src/storage/index/memoryEmbeddings.ts
+async function ensureMemoryEmbeddings(deps) {
+  const { index, embedder, model } = deps;
+  const warn = deps.warn ?? console.warn;
+  const storedModel = index.embeddingModel();
+  const modelChanged = storedModel !== null && storedModel !== model;
+  if (modelChanged) {
+    index.clearEmbeddings();
+  }
+  index.setEmbeddingModel(model);
+  const records = index.allRecords();
+  index.pruneEmbeddings();
+  const have = modelChanged ? new Set : new Set(index.embeddingMap().keys());
+  const todo = records.filter((record) => !have.has(record.id));
+  if (todo.length === 0) {
+    return { embedded: 0, failed: 0, modelChanged };
+  }
+  let vectors;
+  try {
+    vectors = await embedder(todo.map(recordEmbeddingText));
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    warn(`[openteam] could not compute embeddings for ${todo.length} memory record(s): ${reason}. ` + "Recall over them is unavailable until the local runtime is reachable.");
+    return { embedded: 0, failed: todo.length, modelChanged };
+  }
+  if (vectors.length !== todo.length) {
+    warn(`[openteam] could not compute embeddings for ${todo.length} memory record(s): ` + `the embedder returned ${vectors.length} vector(s). Recall over them is unavailable.`);
+    return { embedded: 0, failed: todo.length, modelChanged };
+  }
+  const entries = todo.map((record, position) => ({
+    recordId: record.id,
+    vector: vectors[position]
+  }));
+  index.putEmbeddings(entries);
+  return { embedded: entries.length, failed: 0, modelChanged };
+}
+
+// src/storage/index/memoryRuntime.ts
+async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
+  const semantic = resolveMemorySemantic(config);
+  if (!semantic.enabled || semantic.embeddings.provider === "none") {
+    return;
+  }
+  if (options.requireInjectionEnabled === true && !semantic.injection.enabled) {
+    return;
+  }
+  const runtime = config.local.runtimes.find((rt) => rt.enabled && rt.baseURL !== undefined);
+  if (runtime?.baseURL === undefined) {
+    return;
+  }
+  const modelID = semantic.embeddings.model?.modelID ?? runtime.defaultModel.modelID;
+  const openDatabase = deps.openDatabase ?? createBunSqliteDatabase;
+  const makeEmbedder = deps.createEmbedder ?? createLocalEmbedder;
+  const fetchImpl = deps.fetch ?? globalThis.fetch;
+  const now = deps.now ?? (() => Date.now());
+  const warn = deps.warn ?? console.warn;
+  try {
+    const db = await openDatabase(semantic.indexPath);
+    const index = createMemoryIndex(db, warn);
+    const rebuildResult = await rebuildMemoryIndexFromStorage(index, semantic.logPath, { storage: deps.storage });
+    if (rebuildResult.rejectedLines > 0) {
+      warn(`[openteam] memory log rejected ${rebuildResult.rejectedLines} line(s); semantic memory may be incomplete.`);
+    }
+    const embedder = makeEmbedder({ baseURL: runtime.baseURL, modelID }, { fetch: fetchImpl });
+    await ensureMemoryEmbeddings({ index, embedder, model: modelID, warn });
+    return {
+      index,
+      embedder,
+      now,
+      ownerKey: semantic.scope === "user" ? "user" : "project",
+      semantic
+    };
+  } catch {
+    return;
+  }
+}
+// package.json
+var package_default = {
+  name: "@jmanuelcorral/openteam",
+  version: "0.16.2",
+  packageManager: "bun@1.3.14",
+  description: "Cost-aware, local-first routing plugin for opencode with cheapest-capable frontier fallback and multi-agent orchestration.",
+  license: "MIT",
+  author: "Jose Manuel Corral",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/jmanuelcorral/openteam.git"
+  },
+  homepage: "https://github.com/jmanuelcorral/openteam#readme",
+  bugs: {
+    url: "https://github.com/jmanuelcorral/openteam/issues"
+  },
+  keywords: [
+    "opencode",
+    "opencode-plugin",
+    "llm",
+    "routing",
+    "local-llm",
+    "ollama",
+    "lm-studio",
+    "foundry-local",
+    "cost-optimization",
+    "multi-agent"
+  ],
+  engines: {
+    bun: ">=1.3",
+    node: "^22.22.2 || ^24.15.0 || >=26.0.0"
+  },
+  type: "module",
+  main: "./dist/index.js",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  bin: {
+    openteam: "./dist/cli.js"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  files: [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "AGENTS.md",
+    ".opencode/openteam.example.json",
+    ".opencode/command/openteam.md"
+  ],
+  publishConfig: {
+    access: "public",
+    registry: "https://registry.npmjs.org/"
+  },
+  trustedDependencies: [],
+  sideEffects: false,
+  scripts: {
+    prebuild: "bun run clean",
+    build: "bun run build:js && bun run build:cli && bun run build:types && bun run build:certificates",
+    "build:js": "bun build ./src/index.ts --target=node --format=esm --outfile=dist/index.js --external @opencode-ai/plugin --external @opencode-ai/sdk --external zod --external @opentelemetry/api --external @opentelemetry/sdk-trace-base --external @opentelemetry/exporter-trace-otlp-http --external @opentelemetry/resources --external @langchain/langgraph",
+    "build:cli": 'bun build ./src/cli.ts --target=node --format=esm --outfile=dist/cli.js --banner "#!/usr/bin/env node" --external @opencode-ai/plugin --external @opencode-ai/sdk --external zod --external @clack/prompts --external @opentelemetry/api --external @opentelemetry/sdk-trace-base --external @opentelemetry/exporter-trace-otlp-http --external @opentelemetry/resources --external @langchain/langgraph',
+    "build:types": "tsc -p tsconfig.build.json",
+    clean: `node -e "require('node:fs').rmSync('dist', { recursive: true, force: true })"`,
+    test: "bun test",
+    "test:cov": "bun test --coverage",
+    "certify:shadow": "bun run scripts/certify-artifact.ts shadow",
+    "certify:release": "bun run scripts/certify-artifact.ts release",
+    "build:certificates": "bun run certify:shadow && bun run certify:release && bun run scripts/bundle-certificates.ts",
+    "coverage:check": "node scripts/check-coverage.mjs",
+    typecheck: "tsc --noEmit",
+    lint: "biome check .",
+    "format:check": "biome format .",
+    "docs:install": "cd docs && bun install --frozen-lockfile --ignore-scripts",
+    "docs:dev": "cd docs && bun run docs:dev",
+    "docs:build": "cd docs && bun run docs:build",
+    "docs:preview": "cd docs && bun run docs:preview",
+    prepublishOnly: "bun run build",
+    "link:local": "bun run build && npm link",
+    "hooks:install": "git config core.hooksPath .githooks"
+  },
+  dependencies: {
+    "@clack/prompts": "1.7.0",
+    "@langchain/core": "1.2.9",
+    "@langchain/langgraph": "1.4.12",
+    "@opencode-ai/plugin": "1.18.19",
+    "@opencode-ai/sdk": "1.18.19",
+    "@opentelemetry/api": "1.9.1",
+    "@opentelemetry/exporter-trace-otlp-http": "0.221.0",
+    "@opentelemetry/resources": "2.10.0",
+    "@opentelemetry/sdk-trace-base": "2.10.0",
+    zod: "4.4.3"
+  },
+  devDependencies: {
+    "@biomejs/biome": "2.5.9",
+    "@types/bun": "1.3.14",
+    typescript: "7.0.2"
+  }
+};
+
+// src/version.ts
+var PACKAGE_VERSION = package_default.version;
+
+// src/index.ts
+function warnSoakEvidenceRejections(result, warn) {
+  if (result.rejectedLines === 0) {
+    return;
+  }
+  (warn ?? console.warn)(`[openteam] soak evidence reader rejected ${result.rejectedLines} observation line(s); cutover gate evidence may be incomplete.`);
+  for (const rejection of result.rejections) {
+    (warn ?? console.warn)(`[openteam]   • ${rejection.file}:${rejection.lineNumber}: ${rejection.detail}`);
+  }
+}
+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";
+async function readPackagedCertificate(path4) {
+  try {
+    return await readFile2(new URL(`./certificates/${basename2(path4)}`, import.meta.url), "utf8");
+  } catch {
+    return;
+  }
+}
+async function readAndParseCertificate(storage, path4, parse2, digestExtractor, fallbackRead) {
+  try {
+    const content = await storage.read(path4) ?? (fallbackRead === undefined ? undefined : await fallbackRead(path4));
+    if (content === undefined) {
+      return { status: "absent" };
+    }
+    const raw = JSON.parse(content);
+    const cert = parse2(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 buildGateInput(config, storage, opencodeVersion, warn, packagedRead = readPackagedCertificate) {
+  const shadow = await readAndParseCertificate(storage, SHADOW_CERT_PATH, (raw) => parseShadowCertificate(raw, opencodeVersion), (cert) => shadowCertificateBindingDigest(cert.evidence), packagedRead);
+  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, packagedRead);
+  let soakLedgerDigest = "0".repeat(64);
+  try {
+    const recorderPorts = recorderPortsFromStorage(storage);
+    const chainRead = await readAllChains(recorderPorts, SOAK_EVIDENCE_DIR);
+    warnSoakEvidenceRejections(chainRead, warn);
+    soakLedgerDigest = canonicalLedger(chainRead.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 };
+}
+var OPENCODE_VERSION_UNRESOLVED_REASON = "the opencode version is not determinable outside a running opencode session, " + "so the cutover gate cannot be verified here — the running plugin logs the " + "authoritative gate result and warns loudly on a real denial";
+async function evaluateCutoverGateForBoundary(config, storage, version) {
+  if (version === undefined) {
+    return { kind: "unevaluable", reason: OPENCODE_VERSION_UNRESOLVED_REASON };
+  }
+  const gateInput = await buildGateInput(config, storage, version, () => {});
+  return { kind: "evaluated", gate: evaluateGraphGate(gateInput) };
+}
+function recorderPortsFromStorage(storage) {
+  return {
+    fs: {
+      readFile: async (path4) => {
+        const content = await storage.read(path4);
+        if (content === undefined) {
+          throw Object.assign(new Error(`ENOENT: ${path4}`), { code: "ENOENT" });
+        }
+        return content;
+      },
+      writeFile: (path4, content) => storage.write(path4, content),
+      exists: (path4) => storage.exists(path4),
+      readDir: (path4) => storage.list(path4),
+      mkdir: (path4) => storage.mkdir(path4)
+    },
+    clock: { now: () => new Date().toISOString() },
+    id: { randomUUID: () => crypto.randomUUID() }
+  };
+}
+function isMissingFile(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/memory/traverse.ts
+function inOwnerScope(record, ownerKey, includeShared) {
+  if (record.ownerKey === ownerKey) {
+    return true;
+  }
+  return includeShared && record.ownerKey === SHARED_OWNER_KEY;
+}
+function traverseRelations(records, query) {
+  const includeShared = query.includeShared ?? true;
+  const adjacency = new Map;
+  for (const record of records) {
+    if (record.kind !== "relation") {
+      continue;
+    }
+    if (!isActiveAt(record, query.asOf)) {
+      continue;
+    }
+    if (!inOwnerScope(record, query.ownerKey, includeShared)) {
+      continue;
+    }
+    const list = adjacency.get(record.from);
+    if (list === undefined) {
+      adjacency.set(record.from, [record]);
+    } else {
+      list.push(record);
+    }
+  }
+  const visited = new Set([query.seed]);
+  const nodes = [{ id: query.seed, depth: 0 }];
+  const edges = [];
+  let frontier = [query.seed];
+  for (let depth = 0;depth < query.maxDepth; depth += 1) {
+    const nextFrontier = [];
+    for (const nodeId of frontier) {
+      const outgoing = adjacency.get(nodeId) ?? [];
+      for (const edge of outgoing) {
+        if (visited.has(edge.to)) {
+          continue;
+        }
+        visited.add(edge.to);
+        const childDepth = depth + 1;
+        nodes.push({ id: edge.to, depth: childDepth });
+        edges.push({
+          from: edge.from,
+          to: edge.to,
+          predicate: edge.predicate,
+          depth: childDepth
+        });
+        nextFrontier.push(edge.to);
+      }
+    }
+    frontier = nextFrontier;
+  }
+  return { seed: query.seed, nodes, edges };
+}
+function seedNodeId(record) {
+  return record.kind === "entity" ? record.canonicalName : undefined;
+}
+function recallGraph(records, queryEmbedding, query, options, deps) {
+  const seeds = recall(records, queryEmbedding, query, deps);
+  const asOf = query.asOf ?? deps.now;
+  const includeShared = options.includeShared ?? query.includeShared;
+  const traversals = [];
+  for (const result of seeds) {
+    const seed = seedNodeId(result.record);
+    if (seed === undefined) {
+      continue;
+    }
+    traversals.push({
+      seedRecordId: result.record.id,
+      traversal: traverseRelations(records, {
+        seed,
+        ownerKey: query.ownerKey,
+        asOf,
+        maxDepth: options.maxDepth,
+        includeShared
+      })
+    });
+  }
+  return { recall: seeds, traversals };
+}
+
+// src/mcp/semanticRecall.ts
+function buildSemanticRecall(deps, policy) {
+  return async ({ queryText, kinds, limit }) => {
+    const query = RecallQuerySchema.parse({
+      ownerKey: policy.ownerKey,
+      kinds,
+      asOf: policy.asOf ?? null,
+      limit,
+      minSimilarity: policy.minSimilarity,
+      includeShared: policy.includeShared
+    });
+    const recallDeps = deps.signals === undefined ? { index: deps.index, embedder: deps.embedder, now: deps.now() } : {
+      index: deps.index,
+      embedder: deps.embedder,
+      now: deps.now(),
+      signals: deps.signals
+    };
+    return recallMemory(recallDeps, queryText, query);
+  };
+}
+var DEFAULT_TRAVERSAL_DEPTH = 3;
+function buildRelationTraversal(deps, policy) {
+  return async ({ seed, maxDepth }) => {
+    const asOf = policy.asOf ?? deps.now();
+    return traverseRelations(deps.index.allRecords(), {
+      seed,
+      ownerKey: policy.ownerKey,
+      asOf,
+      maxDepth: maxDepth ?? DEFAULT_TRAVERSAL_DEPTH,
+      includeShared: policy.includeShared
+    });
+  };
+}
+function buildGraphRecall(deps, policy) {
+  return async ({ queryText, limit, maxDepth }) => {
+    const query = RecallQuerySchema.parse({
+      ownerKey: policy.ownerKey,
+      kinds: ["fact", "preference", "entity"],
+      asOf: policy.asOf ?? null,
+      limit,
+      minSimilarity: policy.minSimilarity,
+      includeShared: policy.includeShared
+    });
+    const [queryEmbedding] = await deps.embedder([queryText]);
+    if (queryEmbedding === undefined) {
+      return { recall: [], traversals: [] };
+    }
+    const recallDeps = deps.signals === undefined ? { embeddings: deps.index.embeddingMap(), now: deps.now() } : {
+      embeddings: deps.index.embeddingMap(),
+      now: deps.now(),
+      signals: deps.signals
+    };
+    return recallGraph(deps.index.allRecords(), queryEmbedding, query, {
+      maxDepth: maxDepth ?? DEFAULT_TRAVERSAL_DEPTH,
+      includeShared: policy.includeShared
+    }, recallDeps);
+  };
+}
+
+// src/mcp/teamMemory.ts
+function buildTeamMemory(events) {
+  const aggregate = aggregateEvents(events);
+  return {
+    sessions: aggregate.sessions,
+    totals: aggregate.totals,
     decisions: aggregate.decisions,
     meetings: aggregate.meetings
   };
@@ -15367,585 +16724,224 @@ function projectRecall(results) {
     if (record.kind === "preference") {
       return {
         ...base,
-        category: record.category,
-        preference: record.preference
-      };
-    }
-    const entity = record;
-    return { ...base, canonicalName: entity.canonicalName, type: entity.type };
-  });
-}
-function projectGraphRecall(graph) {
-  return {
-    recall: projectRecall(graph.recall),
-    traversals: graph.traversals.map((entry) => ({
-      seedRecordId: entry.seedRecordId,
-      traversal: projectRelationGraph(entry.traversal)
-    }))
-  };
-}
-async function callSemanticRecall(recall2, kinds, args) {
-  const query = optionalString(args.query);
-  if (query === undefined) {
-    return textContent({ error: "requiere 'query'" });
-  }
-  const limit = optionalLimit(args.limit) ?? DEFAULT_RECALL_LIMIT;
-  const results = await recall2({ queryText: query, kinds, limit });
-  return textContent(projectRecall(results));
-}
-async function callRelationTraversal(traverse, args) {
-  const entity = optionalString(args.entity);
-  if (entity === undefined) {
-    return textContent({ error: "requiere 'entity'" });
-  }
-  const depth = optionalLimit(args.depth) ?? DEFAULT_TRAVERSAL_DEPTH2;
-  const graph = await traverse({ seed: entity, maxDepth: depth });
-  return textContent(projectRelationGraph(graph));
-}
-async function callGraphRecall(recall2, args) {
-  const query = optionalString(args.query);
-  if (query === undefined) {
-    return textContent({ error: "requiere 'query'" });
-  }
-  const limit = optionalLimit(args.limit) ?? DEFAULT_RECALL_LIMIT;
-  const depth = optionalLimit(args.depth) ?? DEFAULT_TRAVERSAL_DEPTH2;
-  const graph = await recall2({ queryText: query, limit, maxDepth: depth });
-  return textContent(projectGraphRecall(graph));
-}
-async function callTool(name, args, deps) {
-  if (deps.recallSemantic !== undefined) {
-    switch (name) {
-      case "recall_facts":
-        return callSemanticRecall(deps.recallSemantic, ["fact"], args);
-      case "recall_preferences":
-        return callSemanticRecall(deps.recallSemantic, ["preference"], args);
-      case "similar_tasks":
-        return callSemanticRecall(deps.recallSemantic, ["fact", "preference", "entity"], args);
-      default:
-        break;
-    }
-  }
-  if (deps.recallRelations !== undefined && name === "recall_relations") {
-    return callRelationTraversal(deps.recallRelations, args);
-  }
-  if (deps.recallGraph !== undefined && name === "recall_graph") {
-    return callGraphRecall(deps.recallGraph, args);
-  }
-  const memory = await deps.readMemory();
-  switch (name) {
-    case "list_decisions": {
-      const query = {};
-      const agent = optionalString(args.agent);
-      const tag = optionalString(args.tag);
-      const limit = optionalLimit(args.limit);
-      if (agent !== undefined) {
-        query.agent = agent;
-      }
-      if (tag !== undefined) {
-        query.tag = tag;
-      }
-      if (limit !== undefined) {
-        query.limit = limit;
-      }
-      return textContent(queryDecisions(memory, query));
-    }
-    case "list_meetings":
-      return textContent(queryMeetings(memory, { limit: optionalLimit(args.limit) ?? 0 }));
-    case "list_sessions":
-      return textContent(querySessions(memory, { limit: optionalLimit(args.limit) ?? 0 }));
-    case "cost_summary":
-      return textContent(costSummary(memory));
-    default:
-      return;
-  }
-}
-async function handleMcpMessage(message, deps) {
-  const isNotification = message.id === undefined;
-  const id = message.id ?? null;
-  const serverInfo = deps.serverInfo ?? DEFAULT_SERVER_INFO;
-  switch (message.method) {
-    case "initialize":
-      return response(id, {
-        protocolVersion: MCP_PROTOCOL_VERSION,
-        capabilities: { tools: {} },
-        serverInfo
-      });
-    case "tools/list":
-      return response(id, { tools: availableTools(deps) });
-    case "tools/call": {
-      const params = message.params ?? {};
-      const name = optionalString(params.name);
-      if (name === undefined) {
-        return errorResponse(id, -32602, "tools/call requiere 'name'");
-      }
-      const args = typeof params.arguments === "object" && params.arguments !== null ? params.arguments : {};
-      const result = await callTool(name, args, deps);
-      if (result === undefined) {
-        return errorResponse(id, -32602, `unknown tool: ${name}`);
-      }
-      return response(id, result);
-    }
-    default:
-      if (isNotification) {
-        return null;
-      }
-      return errorResponse(id, -32601, `unsupported method: ${message.method}`);
-  }
-}
-
-// src/mcp/stdio.ts
-function parseErrorResponse() {
-  return JSON.stringify({
-    jsonrpc: "2.0",
-    id: null,
-    error: { code: -32700, message: "Invalid JSON" }
-  });
-}
-async function runMcpStdio(deps, io) {
-  for await (const rawLine of io.lines) {
-    const line = rawLine.trim();
-    if (line.length === 0) {
-      continue;
-    }
-    let message;
-    try {
-      message = JSON.parse(line);
-    } catch {
-      io.write(`${parseErrorResponse()}
-`);
-      continue;
-    }
-    const reply = await handleMcpMessage(message, deps);
-    if (reply !== null) {
-      io.write(`${JSON.stringify(reply)}
-`);
-    }
-  }
-}
-async function* linesFromReadable(readable) {
-  let buffer = "";
-  for await (const chunk of readable) {
-    buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
-    let newlineIndex = buffer.indexOf(`
-`);
-    while (newlineIndex >= 0) {
-      yield buffer.slice(0, newlineIndex);
-      buffer = buffer.slice(newlineIndex + 1);
-      newlineIndex = buffer.indexOf(`
-`);
-    }
-  }
-  if (buffer.length > 0) {
-    yield buffer;
-  }
-}
-
-// src/orchestrator/rosterPersistence.ts
-function rosterFence(roster) {
-  const data = { universe: roster.universe, entries: roster.entries };
-  return `\`\`\`json
-${JSON.stringify(data, null, 2)}
-\`\`\``;
-}
-function serializeRoster(roster) {
-  return `# openteam roster
-
-Universe: ${roster.universe}
-
-${rosterFence(roster)}
-`;
-}
-async function persistRoster(storage, roster, path4 = OPENTEAM_ROSTER_PATH) {
-  await storage.write(path4, serializeRoster(roster));
-  return path4;
-}
-async function loadRosterFile(storage, path4 = OPENTEAM_ROSTER_PATH) {
-  const content = await storage.read(path4);
-  if (content === undefined) {
-    return { status: "absent", path: path4 };
-  }
-  const parsed = parseRosterResult(content);
-  if (!parsed.ok) {
-    return { status: "invalid", path: path4, error: parsed.error };
-  }
-  return {
-    status: "loaded",
-    path: path4,
-    roster: enforceGuaranteedRoles(parsed.roster)
-  };
-}
-async function loadOrGenerateRoster(storage, generate, path4 = OPENTEAM_ROSTER_PATH) {
-  const existing = await loadRosterFile(storage, path4);
-  if (existing.status === "loaded") {
-    return { roster: existing.roster, regenerated: false };
-  }
-  const roster = enforceGuaranteedRoles(await generate());
-  if (existing.status === "absent") {
-    await persistRoster(storage, roster, path4);
-    return { roster, regenerated: true };
-  }
-  return {
-    roster,
-    regenerated: true,
-    recoveredFromInvalidPersisted: true,
-    invalidPersistedRosterError: existing.error.message
-  };
+        category: record.category,
+        preference: record.preference
+      };
+    }
+    const entity = record;
+    return { ...base, canonicalName: entity.canonicalName, type: entity.type };
+  });
 }
-
-// src/plugin/orchestrateTool.ts
-import { tool } from "@opencode-ai/plugin";
-import { z as z20 } from "zod";
-var _pluginWarnedRoles = new Set;
-var RoleAssignmentSchema = z20.object({
-  roleID: z20.string().min(1).describe("Role identifier from the roster"),
-  prompt: z20.string().min(1).describe("Work prompt for this role"),
-  title: z20.string().min(1).optional().describe("Human-readable title"),
-  dependsOn: z20.array(z20.string().min(1)).optional().describe("Role IDs this assignment depends on (DAG edges)")
-}).strict();
-var OrchestratePayloadSchema = z20.object({
-  assignments: z20.array(RoleAssignmentSchema).min(1).describe("Role assignments to distribute"),
-  parentSessionID: z20.string().min(1).optional().describe("Parent session for subsessions"),
-  directory: z20.string().min(1).optional().describe("Working directory override")
-}).strict();
-function adaptSdkClient(sdk) {
+function projectGraphRecall(graph) {
   return {
-    session: {
-      create: async (args) => {
-        const result = await sdk.session.create(args);
-        const out = {};
-        if (result.data !== undefined) {
-          out.data = result.data;
-        }
-        if (result.error !== undefined) {
-          out.error = result.error;
-        }
-        return out;
-      },
-      prompt: async (args) => {
-        const result = await sdk.session.prompt(args);
-        const out = {};
-        if (result.data !== undefined) {
-          out.data = result.data;
-        }
-        if (result.error !== undefined) {
-          out.error = result.error;
-        }
-        return out;
-      }
-    }
+    recall: projectRecall(graph.recall),
+    traversals: graph.traversals.map((entry) => ({
+      seedRecordId: entry.seedRecordId,
+      traversal: projectRelationGraph(entry.traversal)
+    }))
   };
 }
-
-// src/memory/consolidate.ts
-var DAY_MS2 = 86400000;
-var DEFAULT_DECAY_PARAMS = {
-  halfLifeMs: 90 * DAY_MS2,
-  forgetThreshold: 0.05
-};
-function lastReinforcedAt(record) {
-  if (record.kind === "preference" && record.lastAccessedAt !== null) {
-    return record.lastAccessedAt;
+async function callSemanticRecall(recall2, kinds, args) {
+  const query = optionalString(args.query);
+  if (query === undefined) {
+    return textContent({ error: "requiere 'query'" });
   }
-  return record.createdAt;
-}
-function decayedConfidence(record, now, params = DEFAULT_DECAY_PARAMS) {
-  const ageMs = Math.max(0, now - lastReinforcedAt(record));
-  return record.confidence * 0.5 ** (ageMs / params.halfLifeMs);
+  const limit = optionalLimit(args.limit) ?? DEFAULT_RECALL_LIMIT;
+  const results = await recall2({ queryText: query, kinds, limit });
+  return textContent(projectRecall(results));
 }
-function consolidate(records, now, params = DEFAULT_DECAY_PARAMS) {
-  const tombstones = [];
-  for (const record of records) {
-    if (!isTransactionActiveAt(record, now)) {
-      continue;
-    }
-    if (decayedConfidence(record, now, params) < params.forgetThreshold) {
-      tombstones.push({ ...record, invalidatedAt: now, supersededBy: null });
-    }
+async function callRelationTraversal(traverse, args) {
+  const entity = optionalString(args.entity);
+  if (entity === undefined) {
+    return textContent({ error: "requiere 'entity'" });
   }
-  return tombstones;
+  const depth = optionalLimit(args.depth) ?? DEFAULT_TRAVERSAL_DEPTH2;
+  const graph = await traverse({ seed: entity, maxDepth: depth });
+  return textContent(projectRelationGraph(graph));
 }
-
-// src/storage/index/memoryConsolidate.ts
-async function runConsolidation(logPath, deps) {
-  const params = deps.params ?? DEFAULT_DECAY_PARAMS;
-  const text2 = await deps.storage.read(logPath) ?? "";
-  const { records, rejectedLines } = parseMemoryLog(text2);
-  const state = foldAssertions(records);
-  const tombstones = consolidate(allRecords(state), deps.now, params);
-  if (tombstones.length === 0) {
-    return { forgotten: 0, rejectedLines };
+async function callGraphRecall(recall2, args) {
+  const query = optionalString(args.query);
+  if (query === undefined) {
+    return textContent({ error: "requiere 'query'" });
   }
-  const appended = `${tombstones.map(serializeAssertion).join(`
-`)}
-`;
-  await deps.storage.append(logPath, appended);
-  return { forgotten: tombstones.length, rejectedLines };
+  const limit = optionalLimit(args.limit) ?? DEFAULT_RECALL_LIMIT;
+  const depth = optionalLimit(args.depth) ?? DEFAULT_TRAVERSAL_DEPTH2;
+  const graph = await recall2({ queryText: query, limit, maxDepth: depth });
+  return textContent(projectGraphRecall(graph));
 }
-
-// src/local/embeddings.ts
-function parseEmbeddingsResponse(payload) {
-  if (typeof payload !== "object" || payload === null || !Array.isArray(payload.data)) {
-    throw new Error("Malformed /embeddings response: missing 'data'");
-  }
-  const data = payload.data;
-  return data.map((entry, index) => {
-    const embedding = typeof entry === "object" && entry !== null ? entry.embedding : undefined;
-    if (!Array.isArray(embedding) || !embedding.every((n) => typeof n === "number" && Number.isFinite(n))) {
-      throw new Error(`Malformed /embeddings response: invalid vector at index ${index}`);
+async function callTool(name, args, deps) {
+  if (deps.recallSemantic !== undefined) {
+    switch (name) {
+      case "recall_facts":
+        return callSemanticRecall(deps.recallSemantic, ["fact"], args);
+      case "recall_preferences":
+        return callSemanticRecall(deps.recallSemantic, ["preference"], args);
+      case "similar_tasks":
+        return callSemanticRecall(deps.recallSemantic, ["fact", "preference", "entity"], args);
+      default:
+        break;
     }
-    return embedding;
-  });
-}
-async function embedTexts(request, deps) {
-  if (request.texts.length === 0) {
-    return [];
-  }
-  let response2;
-  try {
-    response2 = await deps.fetch(embeddingsEndpoint(request.baseURL), {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        accept: "application/json"
-      },
-      body: JSON.stringify({
-        model: request.modelID,
-        input: [...request.texts]
-      })
-    });
-  } catch (error) {
-    throw new Error(`Local embeddings failed: ${errorMessage(error)}`);
-  }
-  if (!response2.ok) {
-    throw new Error(`Local embeddings failed: HTTP ${response2.status} on /embeddings`);
-  }
-  let payload;
-  try {
-    payload = await response2.json();
-  } catch (error) {
-    throw new Error(`Local embeddings failed: ${errorMessage(error)}`);
-  }
-  const vectors = parseEmbeddingsResponse(payload);
-  if (vectors.length !== request.texts.length) {
-    throw new Error(`Local embeddings returned ${vectors.length} vectors for ${request.texts.length} texts`);
   }
-  return vectors;
-}
-function createLocalEmbedder(request, deps) {
-  return (texts) => embedTexts({ ...request, texts }, deps);
-}
-
-// src/memory/embedText.ts
-function normalize(parts) {
-  return parts.map((part) => part.trim()).filter((part) => part.length > 0).join(" ");
-}
-function recordEmbeddingText(record) {
-  if (record.kind === "fact") {
-    return normalize([
-      record.subject,
-      record.predicate,
-      record.object,
-      record.category ?? ""
-    ]);
+  if (deps.recallRelations !== undefined && name === "recall_relations") {
+    return callRelationTraversal(deps.recallRelations, args);
   }
-  if (record.kind === "preference") {
-    return normalize([
-      record.category,
-      record.preference,
-      record.context ?? ""
-    ]);
+  if (deps.recallGraph !== undefined && name === "recall_graph") {
+    return callGraphRecall(deps.recallGraph, args);
   }
-  if (record.kind === "relation") {
-    return normalize([
-      record.from,
-      record.predicate,
-      record.to,
-      record.annotation ?? ""
-    ]);
+  const memory = await deps.readMemory();
+  switch (name) {
+    case "list_decisions": {
+      const query = {};
+      const agent = optionalString(args.agent);
+      const tag = optionalString(args.tag);
+      const limit = optionalLimit(args.limit);
+      if (agent !== undefined) {
+        query.agent = agent;
+      }
+      if (tag !== undefined) {
+        query.tag = tag;
+      }
+      if (limit !== undefined) {
+        query.limit = limit;
+      }
+      return textContent(queryDecisions(memory, query));
+    }
+    case "list_meetings":
+      return textContent(queryMeetings(memory, { limit: optionalLimit(args.limit) ?? 0 }));
+    case "list_sessions":
+      return textContent(querySessions(memory, { limit: optionalLimit(args.limit) ?? 0 }));
+    case "cost_summary":
+      return textContent(costSummary(memory));
+    default:
+      return;
   }
-  return normalize([record.canonicalName, record.type, ...record.aliases]);
 }
-
-// src/storage/index/memoryEmbeddings.ts
-async function ensureMemoryEmbeddings(deps) {
-  const { index, embedder, model } = deps;
-  const warn = deps.warn ?? console.warn;
-  const storedModel = index.embeddingModel();
-  const modelChanged = storedModel !== null && storedModel !== model;
-  if (modelChanged) {
-    index.clearEmbeddings();
+async function handleMcpMessage(message, deps) {
+  const isNotification = message.id === undefined;
+  const id = message.id ?? null;
+  const serverInfo = deps.serverInfo ?? DEFAULT_SERVER_INFO;
+  switch (message.method) {
+    case "initialize":
+      return response(id, {
+        protocolVersion: MCP_PROTOCOL_VERSION,
+        capabilities: { tools: {} },
+        serverInfo
+      });
+    case "tools/list":
+      return response(id, { tools: availableTools(deps) });
+    case "tools/call": {
+      const params = message.params ?? {};
+      const name = optionalString(params.name);
+      if (name === undefined) {
+        return errorResponse(id, -32602, "tools/call requiere 'name'");
+      }
+      const args = typeof params.arguments === "object" && params.arguments !== null ? params.arguments : {};
+      const result = await callTool(name, args, deps);
+      if (result === undefined) {
+        return errorResponse(id, -32602, `unknown tool: ${name}`);
+      }
+      return response(id, result);
+    }
+    default:
+      if (isNotification) {
+        return null;
+      }
+      return errorResponse(id, -32601, `unsupported method: ${message.method}`);
   }
-  index.setEmbeddingModel(model);
-  const records = index.allRecords();
-  index.pruneEmbeddings();
-  const have = modelChanged ? new Set : new Set(index.embeddingMap().keys());
-  const todo = records.filter((record) => !have.has(record.id));
-  if (todo.length === 0) {
-    return { embedded: 0, failed: 0, modelChanged };
+}
+
+// src/mcp/stdio.ts
+function parseErrorResponse() {
+  return JSON.stringify({
+    jsonrpc: "2.0",
+    id: null,
+    error: { code: -32700, message: "Invalid JSON" }
+  });
+}
+async function runMcpStdio(deps, io) {
+  for await (const rawLine of io.lines) {
+    const line = rawLine.trim();
+    if (line.length === 0) {
+      continue;
+    }
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      io.write(`${parseErrorResponse()}
+`);
+      continue;
+    }
+    const reply = await handleMcpMessage(message, deps);
+    if (reply !== null) {
+      io.write(`${JSON.stringify(reply)}
+`);
+    }
   }
-  let vectors;
-  try {
-    vectors = await embedder(todo.map(recordEmbeddingText));
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    warn(`[openteam] could not compute embeddings for ${todo.length} memory record(s): ${reason}. ` + "Recall over them is unavailable until the local runtime is reachable.");
-    return { embedded: 0, failed: todo.length, modelChanged };
+}
+async function* linesFromReadable(readable) {
+  let buffer = "";
+  for await (const chunk of readable) {
+    buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    let newlineIndex = buffer.indexOf(`
+`);
+    while (newlineIndex >= 0) {
+      yield buffer.slice(0, newlineIndex);
+      buffer = buffer.slice(newlineIndex + 1);
+      newlineIndex = buffer.indexOf(`
+`);
+    }
   }
-  if (vectors.length !== todo.length) {
-    warn(`[openteam] could not compute embeddings for ${todo.length} memory record(s): ` + `the embedder returned ${vectors.length} vector(s). Recall over them is unavailable.`);
-    return { embedded: 0, failed: todo.length, modelChanged };
+  if (buffer.length > 0) {
+    yield buffer;
   }
-  const entries = todo.map((record, position) => ({
-    recordId: record.id,
-    vector: vectors[position]
-  }));
-  index.putEmbeddings(entries);
-  return { embedded: entries.length, failed: 0, modelChanged };
 }
 
-// src/storage/index/memoryRuntime.ts
-async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
-  const semantic = resolveMemorySemantic(config);
-  if (!semantic.enabled || semantic.embeddings.provider === "none") {
-    return;
-  }
-  if (options.requireInjectionEnabled === true && !semantic.injection.enabled) {
-    return;
-  }
-  const runtime = config.local.runtimes.find((rt) => rt.enabled && rt.baseURL !== undefined);
-  if (runtime?.baseURL === undefined) {
-    return;
+// src/memory/consolidate.ts
+var DAY_MS2 = 86400000;
+var DEFAULT_DECAY_PARAMS = {
+  halfLifeMs: 90 * DAY_MS2,
+  forgetThreshold: 0.05
+};
+function lastReinforcedAt(record) {
+  if (record.kind === "preference" && record.lastAccessedAt !== null) {
+    return record.lastAccessedAt;
   }
-  const modelID = semantic.embeddings.model?.modelID ?? runtime.defaultModel.modelID;
-  const openDatabase = deps.openDatabase ?? createBunSqliteDatabase;
-  const makeEmbedder = deps.createEmbedder ?? createLocalEmbedder;
-  const fetchImpl = deps.fetch ?? globalThis.fetch;
-  const now = deps.now ?? (() => Date.now());
-  const warn = deps.warn ?? console.warn;
-  try {
-    const db = await openDatabase(semantic.indexPath);
-    const index = createMemoryIndex(db, warn);
-    const rebuildResult = await rebuildMemoryIndexFromStorage(index, semantic.logPath, { storage: deps.storage });
-    if (rebuildResult.rejectedLines > 0) {
-      warn(`[openteam] memory log rejected ${rebuildResult.rejectedLines} line(s); semantic memory may be incomplete.`);
+  return record.createdAt;
+}
+function decayedConfidence(record, now, params = DEFAULT_DECAY_PARAMS) {
+  const ageMs = Math.max(0, now - lastReinforcedAt(record));
+  return record.confidence * 0.5 ** (ageMs / params.halfLifeMs);
+}
+function consolidate(records, now, params = DEFAULT_DECAY_PARAMS) {
+  const tombstones = [];
+  for (const record of records) {
+    if (!isTransactionActiveAt(record, now)) {
+      continue;
+    }
+    if (decayedConfidence(record, now, params) < params.forgetThreshold) {
+      tombstones.push({ ...record, invalidatedAt: now, supersededBy: null });
     }
-    const embedder = makeEmbedder({ baseURL: runtime.baseURL, modelID }, { fetch: fetchImpl });
-    await ensureMemoryEmbeddings({ index, embedder, model: modelID, warn });
-    return {
-      index,
-      embedder,
-      now,
-      ownerKey: semantic.scope === "user" ? "user" : "project",
-      semantic
-    };
-  } catch {
-    return;
   }
+  return tombstones;
 }
-// package.json
-var package_default = {
-  name: "@jmanuelcorral/openteam",
-  version: "0.16.0",
-  packageManager: "bun@1.3.14",
-  description: "Cost-aware, local-first routing plugin for opencode with cheapest-capable frontier fallback and multi-agent orchestration.",
-  license: "MIT",
-  author: "Jose Manuel Corral",
-  repository: {
-    type: "git",
-    url: "git+https://github.com/jmanuelcorral/openteam.git"
-  },
-  homepage: "https://github.com/jmanuelcorral/openteam#readme",
-  bugs: {
-    url: "https://github.com/jmanuelcorral/openteam/issues"
-  },
-  keywords: [
-    "opencode",
-    "opencode-plugin",
-    "llm",
-    "routing",
-    "local-llm",
-    "ollama",
-    "lm-studio",
-    "foundry-local",
-    "cost-optimization",
-    "multi-agent"
-  ],
-  engines: {
-    bun: ">=1.3",
-    node: "^22.22.2 || ^24.15.0 || >=26.0.0"
-  },
-  type: "module",
-  main: "./dist/index.js",
-  module: "./dist/index.js",
-  types: "./dist/index.d.ts",
-  bin: {
-    openteam: "./dist/cli.js"
-  },
-  exports: {
-    ".": {
-      types: "./dist/index.d.ts",
-      import: "./dist/index.js"
-    },
-    "./package.json": "./package.json"
-  },
-  files: [
-    "dist",
-    "README.md",
-    "LICENSE",
-    "AGENTS.md",
-    ".opencode/openteam.example.json",
-    ".opencode/command/openteam.md"
-  ],
-  publishConfig: {
-    access: "public",
-    registry: "https://registry.npmjs.org/"
-  },
-  trustedDependencies: [],
-  sideEffects: false,
-  scripts: {
-    prebuild: "bun run clean",
-    build: "bun run build:js && bun run build:cli && bun run build:types",
-    "build:js": "bun build ./src/index.ts --target=node --format=esm --outfile=dist/index.js --external @opencode-ai/plugin --external @opencode-ai/sdk --external zod --external @opentelemetry/api --external @opentelemetry/sdk-trace-base --external @opentelemetry/exporter-trace-otlp-http --external @opentelemetry/resources --external @langchain/langgraph",
-    "build:cli": 'bun build ./src/cli.ts --target=node --format=esm --outfile=dist/cli.js --banner "#!/usr/bin/env node" --external @opencode-ai/plugin --external @opencode-ai/sdk --external zod --external @clack/prompts --external @opentelemetry/api --external @opentelemetry/sdk-trace-base --external @opentelemetry/exporter-trace-otlp-http --external @opentelemetry/resources --external @langchain/langgraph',
-    "build:types": "tsc -p tsconfig.build.json",
-    clean: `node -e "require('node:fs').rmSync('dist', { recursive: true, force: true })"`,
-    test: "bun test",
-    "test:cov": "bun test --coverage",
-    "certify:shadow": "bun run scripts/certify-artifact.ts shadow",
-    "certify:release": "bun run scripts/certify-artifact.ts release",
-    "coverage:check": "node scripts/check-coverage.mjs",
-    typecheck: "tsc --noEmit",
-    lint: "biome check .",
-    "format:check": "biome format .",
-    "docs:install": "cd docs && bun install --frozen-lockfile --ignore-scripts",
-    "docs:dev": "cd docs && bun run docs:dev",
-    "docs:build": "cd docs && bun run docs:build",
-    "docs:preview": "cd docs && bun run docs:preview",
-    prepublishOnly: "bun run build",
-    "link:local": "bun run build && npm link",
-    "hooks:install": "git config core.hooksPath .githooks"
-  },
-  dependencies: {
-    "@clack/prompts": "1.7.0",
-    "@langchain/core": "1.2.9",
-    "@langchain/langgraph": "1.4.12",
-    "@opencode-ai/plugin": "1.18.19",
-    "@opencode-ai/sdk": "1.18.19",
-    "@opentelemetry/api": "1.9.1",
-    "@opentelemetry/exporter-trace-otlp-http": "0.221.0",
-    "@opentelemetry/resources": "2.10.0",
-    "@opentelemetry/sdk-trace-base": "2.10.0",
-    zod: "4.4.3"
-  },
-  devDependencies: {
-    "@biomejs/biome": "2.5.9",
-    "@types/bun": "1.3.14",
-    typescript: "7.0.2"
-  }
-};
 
-// src/version.ts
-var PACKAGE_VERSION = package_default.version;
+// src/storage/index/memoryConsolidate.ts
+async function runConsolidation(logPath, deps) {
+  const params = deps.params ?? DEFAULT_DECAY_PARAMS;
+  const text2 = await deps.storage.read(logPath) ?? "";
+  const { records, rejectedLines } = parseMemoryLog(text2);
+  const state = foldAssertions(records);
+  const tombstones = consolidate(allRecords(state), deps.now, params);
+  if (tombstones.length === 0) {
+    return { forgotten: 0, rejectedLines };
+  }
+  const appended = `${tombstones.map(serializeAssertion).join(`
+`)}
+`;
+  await deps.storage.append(logPath, appended);
+  return { forgotten: tombstones.length, rejectedLines };
+}
 
 // src/web/git.ts
 function createGitLastCommit(exec) {
@@ -15968,7 +16964,8 @@ function createGitLastCommit(exec) {
 
 // src/cli.ts
 var execFileAsync2 = promisify2(execFile2);
-var AGENT_DIR2 = dirname5(ORCHESTRATOR_AGENT_PATH);
+var execAsync = promisify2(exec);
+var AGENT_DIR2 = dirname6(ORCHESTRATOR_AGENT_PATH);
 var storage = createFsStorageProvider(process.cwd());
 async function readStoredRosterForDoctor() {
   const content = await storage.read(OPENTEAM_ROSTER_PATH);
@@ -15996,6 +16993,22 @@ var nodeExec2 = async (command, args) => {
     };
   }
 };
+var requireFromCli = createRequire2(import.meta.url);
+function readPackageVersion(packageName) {
+  try {
+    const pkg = requireFromCli(`${packageName}/package.json`);
+    return typeof pkg.version === "string" ? pkg.version : undefined;
+  } catch {
+    return;
+  }
+}
+async function runOpencodeVersionCommand() {
+  const { stdout } = await execAsync("opencode --version", {
+    timeout: 4000,
+    windowsHide: true
+  });
+  return stdout;
+}
 function describeFileReadError(error) {
   const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
   if (code === "ENOENT") {
@@ -16011,7 +17024,7 @@ async function readConfigFile(path4, resolution) {
     return storage.read(path4);
   }
   try {
-    return await readFile2(resolve6(path4), "utf8");
+    return await readFile3(resolve6(path4), "utf8");
   } catch (error) {
     throw new Error(`[openteam] config file named by --config could not be read: ${path4} (${describeFileReadError(error)})`);
   }
@@ -16030,7 +17043,7 @@ async function saveConfig(config, path4, resolution = { explicit: false }) {
     return;
   }
   const diskPath = resolve6(path4);
-  await mkdir2(dirname5(diskPath), { recursive: true });
+  await mkdir2(dirname6(diskPath), { recursive: true });
   await writeFile2(diskPath, `${JSON.stringify(config, null, 2)}
 `, "utf8");
 }
@@ -16153,7 +17166,11 @@ var deps = {
     storage,
     holder: "openteam-cli",
     exec: nodeExec2,
-    repoRoot: process.cwd()
+    repoRoot: process.cwd(),
+    evaluateCutoverGate: async (gateConfig) => evaluateCutoverGateForBoundary(gateConfig, storage, await resolveOpencodeVersionBestEffort({
+      readPackageVersion,
+      runVersionCommand: runOpencodeVersionCommand
+    }))
   }),
   configPath: DEFAULT_CONFIG_PATH,
   telemetryPath: DEFAULT_TELEMETRY_PATH,