@algosuite/vo-mcp 0.2.0-beta.7 → 0.2.0-beta.70

package/dist/index.js

@@ -180,6 +180,7 @@ __export(credential_store_exports, {
   KEYCHAIN_LOCATION: () => KEYCHAIN_LOCATION,
   credentialPath: () => credentialPath,
   readStoredCredential: () => readStoredCredential,
+  readStoredCredentialKeychainOnly: () => readStoredCredentialKeychainOnly,
   writeStoredCredential: () => writeStoredCredential
 });
 import { homedir as homedir3 } from "node:os";
@@ -238,6 +239,11 @@ function readStoredCredential(env = process.env, keychain = realKeychain) {
   }
   return readFromFile(env);
 }
+function readStoredCredentialKeychainOnly(env = process.env, keychain = realKeychain) {
+  if (!keychainEnabled(env, keychain)) return null;
+  const raw = keychain.get();
+  return raw ? deserialize(raw) : null;
+}
 function deleteFile(env) {
   try {
     rmSync(credentialPath(env), { force: true });
@@ -287,8 +293,332 @@ var init_credential_store = __esm({
   }
 });
 
+// src/tools/memory/safe-memory-file.ts
+import { resolve, sep } from "node:path";
+function isSafeMemoryFileName(fileName) {
+  return fileName.length <= 200 && fileName.trim() === fileName && !fileName.includes("/") && !fileName.includes("\\") && !fileName.includes(":") && SAFE_MEMORY_FILE_RE.test(fileName);
+}
+function resolveMemoryFilePath(memoryDir, fileName) {
+  if (!isSafeMemoryFileName(fileName)) {
+    throw new Error(`unsafe memory file_name: ${fileName.slice(0, 80)}`);
+  }
+  const root = resolve(memoryDir);
+  const filePath = resolve(root, fileName);
+  const rootPrefix = root.endsWith(sep) ? root : `${root}${sep}`;
+  if (filePath !== root && !filePath.startsWith(rootPrefix)) {
+    throw new Error(`memory file path escapes memory directory: ${fileName.slice(0, 80)}`);
+  }
+  return filePath;
+}
+var SAFE_MEMORY_FILE_RE;
+var init_safe_memory_file = __esm({
+  "src/tools/memory/safe-memory-file.ts"() {
+    "use strict";
+    SAFE_MEMORY_FILE_RE = /^[A-Za-z0-9][A-Za-z0-9._ -]*\.md$/i;
+  }
+});
+
+// src/tools/memory/bounded-sync.ts
+function createSyncDeadline(budgetMs = SYNC_DEADLINE_MS, now = Date.now) {
+  const startedAt = now();
+  return {
+    check() {
+      const elapsed = now() - startedAt;
+      if (elapsed > budgetMs) throw new SyncDeadlineExceededError(elapsed, budgetMs);
+    },
+    remainingMs() {
+      return Math.max(0, budgetMs - (now() - startedAt));
+    }
+  };
+}
+async function withRequestTimeout(url, run, budgetMs = REQUEST_TIMEOUT_MS) {
+  let timer;
+  try {
+    return await Promise.race([
+      run(),
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new RequestTimeoutError(url, budgetMs)), budgetMs);
+        timer.unref?.();
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function mapWithConcurrency(items, limit, fn) {
+  const results = new Array(items.length);
+  const width = Math.max(1, Math.min(limit, items.length));
+  let next = 0;
+  async function worker() {
+    for (; ; ) {
+      const index = next++;
+      if (index >= items.length) return;
+      try {
+        results[index] = { ok: true, value: await fn(items[index], index) };
+      } catch (error) {
+        results[index] = { ok: false, error };
+      }
+    }
+  }
+  await Promise.all(Array.from({ length: width }, () => worker()));
+  return results;
+}
+var REQUEST_TIMEOUT_MS, SYNC_DEADLINE_MS, PUSH_CONCURRENCY, SyncDeadlineExceededError, RequestTimeoutError;
+var init_bounded_sync = __esm({
+  "src/tools/memory/bounded-sync.ts"() {
+    "use strict";
+    REQUEST_TIMEOUT_MS = 15e3;
+    SYNC_DEADLINE_MS = 12e4;
+    PUSH_CONCURRENCY = 6;
+    SyncDeadlineExceededError = class extends Error {
+      constructor(elapsedMs, budgetMs) {
+        super(
+          `memory sync exceeded its ${budgetMs}ms deadline after ${elapsedMs}ms \u2014 aborting so the lock is released instead of held indefinitely`
+        );
+        this.name = "SyncDeadlineExceededError";
+      }
+    };
+    RequestTimeoutError = class extends Error {
+      constructor(url, budgetMs) {
+        super(`memory sync request to ${url} exceeded ${budgetMs}ms`);
+        this.name = "RequestTimeoutError";
+      }
+    };
+  }
+});
+
+// src/tools/memory/memory-push-cache.ts
+import { createHash as createHash3 } from "node:crypto";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join9 } from "node:path";
+function sha256(content) {
+  return createHash3("sha256").update(content, "utf8").digest("hex");
+}
+function statePath(memoryDir) {
+  return join9(memoryDir, MEMORY_SYNC_STATE_FILE);
+}
+function readPushCache(memoryDir, controlPlaneUrl) {
+  const empty = { controlPlaneUrl, entries: /* @__PURE__ */ new Map(), knowledgeSweptAtMs: null };
+  let raw;
+  try {
+    raw = readFileSync10(statePath(memoryDir), "utf8");
+  } catch {
+    return empty;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return empty;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return empty;
+  const obj = parsed;
+  if (obj["version"] !== STATE_VERSION) return empty;
+  if (obj["controlPlaneUrl"] !== controlPlaneUrl) return empty;
+  const files = obj["entries"];
+  if (typeof files !== "object" || files === null || Array.isArray(files)) return empty;
+  const entries = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(files)) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) continue;
+    const row = value;
+    const memoryHash = typeof row["memoryHash"] === "string" ? row["memoryHash"] : void 0;
+    const knowledgeHash = typeof row["knowledgeHash"] === "string" ? row["knowledgeHash"] : void 0;
+    if (memoryHash === void 0 && knowledgeHash === void 0) continue;
+    entries.set(name, {
+      ...memoryHash !== void 0 ? { memoryHash } : {},
+      ...knowledgeHash !== void 0 ? { knowledgeHash } : {}
+    });
+  }
+  const sweptAt = obj["knowledgeSweptAtMs"];
+  return {
+    controlPlaneUrl,
+    entries,
+    // An unreadable/absent sweep stamp reads as NEVER SWEPT, which forces a full
+    // sweep — the fail-closed direction (more upserts, never fewer).
+    knowledgeSweptAtMs: typeof sweptAt === "number" && Number.isFinite(sweptAt) ? sweptAt : null
+  };
+}
+function writePushCache(memoryDir, cache) {
+  const entries = {};
+  for (const [name, value] of cache.entries) entries[name] = value;
+  try {
+    writeFileSync5(
+      statePath(memoryDir),
+      `${JSON.stringify(
+        {
+          version: STATE_VERSION,
+          controlPlaneUrl: cache.controlPlaneUrl,
+          knowledgeSweptAtMs: cache.knowledgeSweptAtMs,
+          entries
+        },
+        null,
+        2
+      )}
+`,
+      "utf8"
+    );
+  } catch {
+  }
+}
+function recordMemoryPush(cache, fileName, payloadHash) {
+  cache.entries.set(fileName, { ...cache.entries.get(fileName), memoryHash: payloadHash });
+}
+function recordKnowledgePush(cache, fileName, contentHash) {
+  cache.entries.set(fileName, { ...cache.entries.get(fileName), knowledgeHash: contentHash });
+}
+function pruneMissing(cache, presentFileNames) {
+  const present = new Set(presentFileNames);
+  for (const name of [...cache.entries.keys()]) {
+    if (!present.has(name)) cache.entries.delete(name);
+  }
+}
+function needsMemoryPush(cache, fileName, payloadHash, serverHasEntry) {
+  if (!serverHasEntry) return true;
+  return cache.entries.get(fileName)?.memoryHash !== payloadHash;
+}
+function knowledgeSweepDue(cache, nowMs = Date.now()) {
+  const swept = cache.knowledgeSweptAtMs;
+  if (swept === null || !Number.isFinite(swept)) return true;
+  const age = nowMs - swept;
+  return !(age >= 0 && age < KNOWLEDGE_FULL_SWEEP_MS);
+}
+function needsKnowledgePush(cache, fileName, contentHash, sweepDue = false) {
+  if (sweepDue) return true;
+  return cache.entries.get(fileName)?.knowledgeHash !== contentHash;
+}
+var MEMORY_SYNC_STATE_FILE, STATE_VERSION, KNOWLEDGE_FULL_SWEEP_MS;
+var init_memory_push_cache = __esm({
+  "src/tools/memory/memory-push-cache.ts"() {
+    "use strict";
+    MEMORY_SYNC_STATE_FILE = ".memory-sync-state.json";
+    STATE_VERSION = 1;
+    KNOWLEDGE_FULL_SWEEP_MS = 24 * 60 * 6e4;
+  }
+});
+
+// src/tools/memory/memory-knowledge-bridge.ts
+var memory_knowledge_bridge_exports = {};
+__export(memory_knowledge_bridge_exports, {
+  extractMemoryTitle: () => extractMemoryTitle,
+  upsertMemoryFilesAsKnowledge: () => upsertMemoryFilesAsKnowledge
+});
+import { existsSync as existsSync8, readdirSync as readdirSync5, readFileSync as readFileSync13 } from "node:fs";
+function extractMemoryTitle(fileName, content) {
+  const frontmatter = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (frontmatter) {
+    const description24 = frontmatter[1].match(/^description:\s*(.+)$/m);
+    if (description24 && description24[1].trim()) return description24[1].trim().slice(0, 200);
+  }
+  const heading = content.match(/^#\s+(.+)$/m);
+  if (heading && heading[1].trim()) return heading[1].trim().slice(0, 200);
+  return fileName;
+}
+async function upsertMemoryFilesAsKnowledge(options) {
+  const { controlPlaneUrl, token, memoryDir, fetchFn, cache, deadline } = options;
+  let files;
+  try {
+    if (!existsSync8(memoryDir)) {
+      return { attempted: 0, upserted: 0, failed: 0, skipped: 0, failures: [] };
+    }
+    files = readdirSync5(memoryDir).filter(
+      (f) => f.endsWith(".md") && f.toUpperCase() !== "MEMORY.MD"
+    );
+  } catch (err) {
+    return {
+      attempted: 0,
+      upserted: 0,
+      failed: 1,
+      skipped: 0,
+      failures: [`memory dir scan: ${err instanceof Error ? err.message : String(err)}`]
+    };
+  }
+  const sweepDue = cache ? knowledgeSweepDue(cache) : true;
+  const candidates = [];
+  const failures = [];
+  let skipped = 0;
+  for (const fileName of files) {
+    try {
+      const content = readFileSync13(resolveMemoryFilePath(memoryDir, fileName), "utf8");
+      if (content.length > CONTENT_HARD_LIMIT) {
+        failures.push(`${fileName}: ${content.length} chars exceeds the ${CONTENT_HARD_LIMIT} server limit \u2014 split the memory file`);
+        continue;
+      }
+      const hash = sha256(content);
+      if (cache && !needsKnowledgePush(cache, fileName, hash, sweepDue)) {
+        skipped += 1;
+        continue;
+      }
+      candidates.push({ fileName, content, hash });
+    } catch (err) {
+      failures.push(`${fileName}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  const url = `${controlPlaneUrl}/api/v1/knowledge/private`;
+  const outcomes = await mapWithConcurrency(candidates, options.concurrency ?? PUSH_CONCURRENCY, async (candidate) => {
+    deadline?.check();
+    const base = {
+      knowledge_class: "memory",
+      source_path: `memory/${candidate.fileName}`,
+      title: extractMemoryTitle(candidate.fileName, candidate.content),
+      content: candidate.content
+    };
+    const post = (body) => withRequestTimeout(url, () => fetchFn(url, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${token}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(body)
+    }));
+    let response = await post({
+      ...base,
+      provenance: { written_by: "memory-bridge", source_kind: "operator_memory" }
+    });
+    if (response.status === 400) {
+      response = await post(base);
+    }
+    if (response.status >= 200 && response.status < 300) return true;
+    const text = await response.text();
+    throw new Error(`HTTP ${response.status} ${text.slice(0, 80)}`);
+  });
+  let upserted = 0;
+  for (let i = 0; i < outcomes.length; i++) {
+    const outcome = outcomes[i];
+    const candidate = candidates[i];
+    if (outcome.ok) {
+      upserted += 1;
+      if (cache) recordKnowledgePush(cache, candidate.fileName, candidate.hash);
+    } else {
+      const error = outcome.error;
+      failures.push(`${candidate.fileName}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (cache && sweepDue && failures.length === 0) {
+    cache.knowledgeSweptAtMs = Date.now();
+  }
+  return {
+    // Every memory file this run considered. `attempted === upserted + skipped
+    // + failed` holds, so a caller can tell "nothing to do" from "nothing ran".
+    attempted: files.length,
+    upserted,
+    failed: failures.length,
+    skipped,
+    failures: failures.slice(0, 5)
+  };
+}
+var CONTENT_HARD_LIMIT;
+var init_memory_knowledge_bridge = __esm({
+  "src/tools/memory/memory-knowledge-bridge.ts"() {
+    "use strict";
+    init_safe_memory_file();
+    init_bounded_sync();
+    init_memory_push_cache();
+    CONTENT_HARD_LIMIT = 5e5;
+  }
+});
+
 // src/server.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import {
   CallToolRequestSchema,
@@ -477,24 +807,24 @@ function defaultOverridePath() {
   return join2(homedir(), ".claude", "vo-arch-defaults.local.json");
 }
 function loadTenantOverride(opts = {}) {
-  const path3 = opts.path ?? defaultOverridePath();
-  if (!existsSync2(path3)) {
+  const path4 = opts.path ?? defaultOverridePath();
+  if (!existsSync2(path4)) {
     return { override: null, source_path: null };
   }
-  const raw = readFileSync2(path3, "utf8");
+  const raw = readFileSync2(path4, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
     const m = err instanceof Error ? err.message : String(err);
-    throw new Error(`vo-arch-defaults: invalid JSON in override ${path3}: ${m}`, { cause: err });
+    throw new Error(`vo-arch-defaults: invalid JSON in override ${path4}: ${m}`, { cause: err });
   }
   try {
     const override = parseOverride(parsed);
-    return { override, source_path: path3 };
+    return { override, source_path: path4 };
   } catch (err) {
     const m = err instanceof Error ? err.message : String(err);
-    throw new Error(`vo-arch-defaults: override schema validation failed for ${path3}: ${m}`, { cause: err });
+    throw new Error(`vo-arch-defaults: override schema validation failed for ${path4}: ${m}`, { cause: err });
   }
 }
 
@@ -624,9 +954,9 @@ function globToRegExp(glob) {
   }
   return new RegExp("^" + out + "$");
 }
-function matchesAnyGlob(path3, globs) {
+function matchesAnyGlob(path4, globs) {
   for (const g of globs) {
-    if (globToRegExp(g).test(path3)) return true;
+    if (globToRegExp(g).test(path4)) return true;
   }
   return false;
 }
@@ -1160,7 +1490,17 @@ function assertWithinByteCap(toolName, fieldName, value, maxBytes) {
     );
   }
 }
+var REPO_RE = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/u;
+function subjectFromEnv(env = process.env) {
+  const code_task_id = (env["VO_CODE_TASK_ID"] ?? "").trim().slice(0, 120);
+  const repo = (env["VO_CODE_TASK_REPO"] ?? "").trim();
+  const subject = {};
+  if (code_task_id) subject.code_task_id = code_task_id;
+  if (repo && REPO_RE.test(repo) && repo.length <= 200) subject.repo = repo;
+  return subject.code_task_id || subject.repo ? subject : null;
+}
 function buildBaseEvent(args) {
+  const subject = args.subject === void 0 ? subjectFromEnv() : args.subject;
   return {
     schema_version: 1,
     event_id: args.eventId ?? randomUUID(),
@@ -1186,7 +1526,12 @@ function buildBaseEvent(args) {
     downstream_outcome: null,
     vo_mcp_version: VO_MCP_VERSION,
     consensus_engine_version: null,
-    cache_hit: false
+    cache_hit: false,
+    // OMIT the key when there is no subject (rather than `subject: null`): the
+    // ingest schema is `.strict()`, so an event with no subject stays valid on a
+    // sink that has not learned the field yet — only subject-carrying events
+    // depend on the sink being current (deploy ordering: sink before producer).
+    ...subject ? { subject } : {}
   };
 }
 function jsonContent(value) {
@@ -1216,6 +1561,52 @@ function toEventPerModelVerdicts(src) {
     };
   });
 }
+function aggregateEventTokenUsage(src, engineUsage) {
+  if (engineUsage !== void 0) {
+    const hasIn = Object.keys(engineUsage.per_model_tokens_in).length > 0;
+    const hasOut = Object.keys(engineUsage.per_model_tokens_out).length > 0;
+    return {
+      per_model_tokens_in: hasIn ? engineUsage.per_model_tokens_in : null,
+      per_model_tokens_out: hasOut ? engineUsage.per_model_tokens_out : null,
+      total_cost_usd: engineUsage.cost_micro_usd === null ? null : engineUsage.cost_micro_usd / 1e6
+    };
+  }
+  const tokensIn = {};
+  const tokensOut = {};
+  let anyTokensIn = false;
+  let anyTokensOut = false;
+  let costMicroUsd = 0;
+  let anyCost = false;
+  for (const v of src) {
+    if (typeof v.input_tokens === "number") {
+      tokensIn[v.model] = (tokensIn[v.model] ?? 0) + v.input_tokens;
+      anyTokensIn = true;
+    }
+    if (typeof v.output_tokens === "number") {
+      tokensOut[v.model] = (tokensOut[v.model] ?? 0) + v.output_tokens;
+      anyTokensOut = true;
+    }
+    if (typeof v.cost_micro_usd === "number") {
+      costMicroUsd += v.cost_micro_usd;
+      anyCost = true;
+    }
+  }
+  return {
+    per_model_tokens_in: anyTokensIn ? tokensIn : null,
+    per_model_tokens_out: anyTokensOut ? tokensOut : null,
+    total_cost_usd: anyCost ? costMicroUsd / 1e6 : null
+  };
+}
+function trajectoryFromEngine(result, known = {}) {
+  const rounds = typeof result.token_usage?.rounds_counted === "number" && Number.isInteger(result.token_usage.rounds_counted) && result.token_usage.rounds_counted >= 0 ? result.token_usage.rounds_counted : null;
+  const called = result.fan_out_diagnostics?.models_called;
+  const turns = typeof called === "number" && Number.isInteger(called) && called >= 0 ? called : rounds !== null && rounds > 0 ? result.per_model_verdicts.length * rounds : null;
+  const sourceGrounded = result.citation_grade !== void 0 || result.low_confidence_sources !== void 0;
+  const tool_calls = typeof known.tool_calls === "number" && Number.isInteger(known.tool_calls) && known.tool_calls >= 0 ? known.tool_calls : sourceGrounded ? null : 0;
+  if (rounds === null && turns === null && tool_calls === null) return {};
+  const trajectory = { rounds, turns, tool_calls };
+  return { trajectory };
+}
 function toEventSynthesizedVerdict(src) {
   return {
     verdict: src.verdict,
@@ -1587,7 +1978,9 @@ async function handleCheckHollowTest(deps, rawInput, signal) {
     synthesized_verdict: synthForEvent,
     consensus_confidence: engineResult.synthesized_verdict.confidence,
     duration_ms: engineResult.duration_ms,
-    consensus_engine_version: engineResult.engine_version
+    consensus_engine_version: engineResult.engine_version,
+    ...aggregateEventTokenUsage(engineResult.per_model_verdicts, engineResult.token_usage),
+    ...trajectoryFromEngine(engineResult)
   };
   const payload = {
     verdict: engineResult.synthesized_verdict.verdict,
@@ -1769,7 +2162,9 @@ async function handleVerifyAnswer(deps, rawInput, signal) {
     synthesized_verdict: synthForEvent,
     consensus_confidence: engineResult.synthesized_verdict.confidence,
     duration_ms: engineResult.duration_ms,
-    consensus_engine_version: engineResult.engine_version
+    consensus_engine_version: engineResult.engine_version,
+    ...aggregateEventTokenUsage(engineResult.per_model_verdicts, engineResult.token_usage),
+    ...trajectoryFromEngine(engineResult)
   };
   const payload = {
     verdict: engineResult.synthesized_verdict.verdict,
@@ -1778,6 +2173,9 @@ async function handleVerifyAnswer(deps, rawInput, signal) {
     synthesized_verdict: synthForEvent,
     engine_version: engineResult.engine_version,
     degraded: engineResult.degraded,
+    ...engineResult.quorum_failed === true ? { quorum_failed: true } : {},
+    // The verification receipt (moat decision_id) — the thing an agent pastes as `receipt id: <uuid>`.
+    ...engineResult.receipt_id ? { receipt_id: engineResult.receipt_id } : {},
     gate_type: gateType,
     ...kbResult.error !== null ? { kb_unavailable: true } : {},
     ...kbTruncated > 0 ? { kb_rules_truncated: kbTruncated } : {}
@@ -2031,7 +2429,9 @@ async function handleConsensusJudgment(deps, rawInput, signal) {
     duration_ms: engineResult.duration_ms,
     consensus_engine_version: engineResult.engine_version,
     per_model_verdicts: perModelForEvent,
-    synthesized_verdict: synthForEvent
+    synthesized_verdict: synthForEvent,
+    ...aggregateEventTokenUsage(engineResult.per_model_verdicts, engineResult.token_usage),
+    ...trajectoryFromEngine(engineResult)
   };
   const payload = {
     verdict: engineResult.synthesized_verdict.verdict,
@@ -2040,6 +2440,11 @@ async function handleConsensusJudgment(deps, rawInput, signal) {
     synthesized_verdict: synthForEvent,
     engine_version: engineResult.engine_version,
     degraded: engineResult.degraded,
+    ...engineResult.quorum_failed === true ? { quorum_failed: true } : {},
+    // The verification receipt (moat decision_id) — the thing an agent pastes as `receipt id: <uuid>`.
+    // NOTE: a content-hash cache hit replays the ORIGINAL call's receipt_id (same claim, same verdict, no new spend) —
+    // a receipt asserts the stage ran for this claim, not one-receipt-per-call.
+    ...engineResult.receipt_id ? { receipt_id: engineResult.receipt_id } : {},
     gate_type: gateType,
     // ─── Consensus-engine feature outputs (additive; 2026-06-13) ─────────────
     // Feature 2 (calibrated-confidence) — ON by default; the engine attaches
@@ -2058,7 +2463,11 @@ async function handleConsensusJudgment(deps, rawInput, signal) {
     ...engineResult.low_confidence_sources !== void 0 ? { low_confidence_sources: engineResult.low_confidence_sources } : {},
     // Escalation (from citation grade or human-tiebreak synthesizer).
     ...engineResult.escalation_required !== void 0 ? { escalation_required: engineResult.escalation_required } : {},
-    ...engineResult.escalation_reason !== void 0 ? { escalation_reason: engineResult.escalation_reason } : {}
+    ...engineResult.escalation_reason !== void 0 ? { escalation_reason: engineResult.escalation_reason } : {},
+    // Critique-uptake (2026-07-20 red-team fix) — the engine computes this
+    // on every call; this spread closes the gap where the visibility report
+    // was itself silently dropped at the payload boundary.
+    ...engineResult.critique_uptake !== void 0 ? { critique_uptake: engineResult.critique_uptake } : {}
   };
   const envelope = {
     tool: TOOL_NAME4,
@@ -2234,7 +2643,9 @@ async function handleArchitectureReview(deps, rawInput, signal) {
     synthesized_verdict: synthForEvent,
     consensus_confidence: engineResult.synthesized_verdict.confidence,
     duration_ms: engineResult.duration_ms,
-    consensus_engine_version: engineResult.engine_version
+    consensus_engine_version: engineResult.engine_version,
+    ...aggregateEventTokenUsage(engineResult.per_model_verdicts, engineResult.token_usage),
+    ...trajectoryFromEngine(engineResult)
   };
   const escalationRequired = engineResult.escalation_required === true || engineResult.escalation_required === void 0 && engineResult.synthesized_verdict.dissent_summary !== null;
   const escalationReason = engineResult.escalation_reason ?? engineResult.synthesized_verdict.dissent_summary ?? "";
@@ -3719,7 +4130,9 @@ Produce the JSON dispatch plan now.`;
     duration_ms: engineResult.duration_ms,
     consensus_engine_version: engineResult.engine_version,
     per_model_verdicts: toEventPerModelVerdicts(engineResult.per_model_verdicts),
-    synthesized_verdict: toEventSynthesizedVerdict(engineResult.synthesized_verdict)
+    synthesized_verdict: toEventSynthesizedVerdict(engineResult.synthesized_verdict),
+    ...aggregateEventTokenUsage(engineResult.per_model_verdicts, engineResult.token_usage),
+    ...trajectoryFromEngine(engineResult)
   };
   deps.events.append(enrichedEvent);
   return jsonContent(envelope);
@@ -3729,14 +4142,16 @@ Produce the JSON dispatch plan now.`;
 init_auth_token_source();
 init_credential_store();
 var AdminCallableError = class extends Error {
-  constructor(status, path3, message) {
+  constructor(status, path4, message, body) {
     super(message);
     this.status = status;
-    this.path = path3;
+    this.path = path4;
+    this.body = body;
     this.name = "AdminCallableError";
   }
   status;
   path;
+  body;
 };
 
 // src/tools/cloud-call.ts
@@ -3771,11 +4186,12 @@ async function buildCloudOrStubResponse(args) {
     args.deps.events.append(event);
     return jsonContent(envelope);
   }
+  const invokeOptions = args.rawEnvelope || args.invokeOptions ? { ...args.rawEnvelope ? { rawEnvelope: true } : {}, ...args.invokeOptions } : void 0;
   try {
     const result = await args.deps.adminCallables.invoke(
       args.adminPath,
       args.cloudBody ?? args.normalizedInput,
-      args.rawEnvelope ? { rawEnvelope: true } : void 0
+      invokeOptions
     );
     const payload = {
       verdict: "pass",
@@ -3795,11 +4211,13 @@ async function buildCloudOrStubResponse(args) {
   } catch (err) {
     const status = err instanceof AdminCallableError ? err.status : void 0;
     const message = err instanceof Error ? err.message : String(err);
+    const errorBody = err instanceof AdminCallableError && err.body !== void 0 ? err.body : void 0;
     const payload = {
       verdict: "fail",
       reason: status !== void 0 ? `vo-control-plane returned HTTP ${status}: ${message.slice(0, 300)}` : `cloud invocation failed: ${message.slice(0, 300)}`,
       callable: args.callableName,
-      normalized_input: args.normalizedInput
+      normalized_input: args.normalizedInput,
+      ...errorBody ? { response_data: errorBody } : {}
     };
     const envelope = {
       tool: args.toolName,
@@ -3813,7 +4231,7 @@ async function buildCloudOrStubResponse(args) {
 }
 
 // src/tools/heal/common-heal.ts
-var HEAL_STUB_REASON = 'cloud-mode not yet wired; tool surface is live, admin-callable wiring pending vo-cloud-tenant-model dispatch (see packages/vo-mcp/src/modes/cloud.ts + EXTRACTION_AUDIT.md "Stub remaining")';
+var HEAL_STUB_REASON = "cloud mode is not configured on this session, so the admin callable was not reached. The wiring exists (see buildCloudOrStubResponse); sign in with `vo-mcp login` to route this tool to the control plane. Note that /api/v1/admin/* additionally requires a founding-operator credential.";
 var HEAL_GATE_TYPE = "admin-action";
 
 // src/tools/heal/trigger-heal.ts
@@ -3834,7 +4252,7 @@ var inputSchema8 = {
   },
   additionalProperties: false
 };
-var description8 = "Triggers a self-heal pass against open PRs. Optionally scope to a `focus_page` (priority queue for one tester) or omit to fire the auto-process queue. Wraps the `voTriggerHeal` admin Cloud Function. V1 stub: returns `verdict: 'unimplemented'` with structured normalized_input \u2014 cloud-mode wiring is pending. The contract is locked; consumers can call this tool today and get the correct surface without working execution.";
+var description8 = "Triggers a self-heal pass against open PRs. Optionally scope to a `focus_page` (priority queue for one tester) or omit to fire the auto-process queue. Wraps the `voTriggerHeal` admin Cloud Function. Requires a founding-operator credential: the control plane's scoped-operator gate refuses `/api/v1/admin/*` for tenant-scoped accounts, which receive HTTP 403 `scoped_operator_forbidden`. Falls back to a clearly-marked `unimplemented` envelope with structured normalized_input when cloud mode is not configured.";
 function isToolInput8(v) {
   if (typeof v !== "object" || v === null) return false;
   const o = v;
@@ -3891,7 +4309,7 @@ var inputSchema9 = {
   },
   additionalProperties: false
 };
-var description9 = "Retries one or more failed fix attempts by id. Pass `attempt_id` for the single case or `attempt_ids` (up to 50) for the batch case. Wraps `voRetryFixAttempt` / `voRetryFixAttempts` admin Cloud Functions. V1 stub: returns `verdict: 'unimplemented'` \u2014 cloud-mode wiring pending.";
+var description9 = "Retries one or more failed fix attempts by id. Pass `attempt_id` for the single case or `attempt_ids` (up to 50) for the batch case. Wraps `voRetryFixAttempt` / `voRetryFixAttempts` admin Cloud Functions. Requires a founding-operator credential: the control plane's scoped-operator gate refuses `/api/v1/admin/*` for tenant-scoped accounts, which receive HTTP 403 `scoped_operator_forbidden`. Falls back to a clearly-marked `unimplemented` envelope when cloud mode is not configured.";
 function isToolInput9(v) {
   if (typeof v !== "object" || v === null) return false;
   const o = v;
@@ -3978,7 +4396,7 @@ var inputSchema10 = {
   required: ["attempt_id"],
   additionalProperties: false
 };
-var description10 = "Clears (cancels) a single fix attempt by id. Wraps `voClearFixAttempt` admin Cloud Function. V1 stub: returns `verdict: 'unimplemented'` \u2014 cloud-mode wiring pending.";
+var description10 = "Clears (cancels) a single fix attempt by id. Wraps `voClearFixAttempt` admin Cloud Function. Requires a founding-operator credential: the control plane's scoped-operator gate refuses `/api/v1/admin/*` for tenant-scoped accounts, which receive HTTP 403 `scoped_operator_forbidden`. Falls back to a clearly-marked `unimplemented` envelope when cloud mode is not configured.";
 function isToolInput10(v) {
   if (typeof v !== "object" || v === null) return false;
   const o = v;
@@ -4025,7 +4443,7 @@ var inputSchema11 = {
   required: ["run_id"],
   additionalProperties: false
 };
-var description11 = "Cancels a running GitHub Actions workflow by run id. Wraps `voStopWorkflow` admin Cloud Function. V1 stub: returns `verdict: 'unimplemented'` \u2014 cloud-mode wiring pending.";
+var description11 = "Cancels a running GitHub Actions workflow by run id. Wraps `voStopWorkflow` admin Cloud Function. Requires a founding-operator credential: the control plane's scoped-operator gate refuses `/api/v1/admin/*` for tenant-scoped accounts, which receive HTTP 403 `scoped_operator_forbidden`. Falls back to a clearly-marked `unimplemented` envelope when cloud mode is not configured.";
 function isToolInput11(v) {
   if (typeof v !== "object" || v === null) return false;
   const o = v;
@@ -4070,7 +4488,7 @@ var inputSchema12 = {
   properties: {},
   additionalProperties: false
 };
-var description12 = "Returns the current Command Center workflow-runs snapshot (Heal, Manager, Auto-Merge, Deploy on Merge, etc.). Wraps `voGetWorkflowRuns` admin Cloud Function. Read-only diagnostic. V1 stub: returns `verdict: 'unimplemented'` \u2014 cloud-mode wiring pending.";
+var description12 = "Returns the current Command Center workflow-runs snapshot (Heal, Manager, Auto-Merge, Deploy on Merge, etc.). Wraps `voGetWorkflowRuns` admin Cloud Function. Read-only diagnostic. Requires a founding-operator credential: the control plane's scoped-operator gate refuses `/api/v1/admin/*` for tenant-scoped accounts, which receive HTTP 403 `scoped_operator_forbidden`. Falls back to a clearly-marked `unimplemented` envelope when cloud mode is not configured.";
 function isToolInput12(v) {
   if (typeof v !== "object" || v === null) return false;
   return true;
@@ -4093,7 +4511,7 @@ async function handleGetWorkflowRuns(deps, rawInput, _signal) {
 }
 
 // src/tools/pr/common-pr.ts
-var PR_STUB_REASON = 'cloud-mode not yet wired; tool surface is live, admin-callable wiring pending vo-cloud-tenant-model dispatch (see packages/vo-mcp/src/modes/cloud.ts + EXTRACTION_AUDIT.md "Stub remaining")';
+var PR_STUB_REASON = "cloud mode is not configured on this session, so the admin callable was not reached. The wiring exists (see buildCloudOrStubResponse); sign in with `vo-mcp login` to route this tool to the control plane. Note that /api/v1/admin/* additionally requires a founding-operator credential.";
 var PR_GATE_TYPE = "admin-action";
 
 // src/tools/pr/list-pending-prs.ts
@@ -4105,7 +4523,7 @@ var inputSchema13 = {
   properties: {},
   additionalProperties: false
 };
-var description13 = "Lists open VO-source pull requests with blocker / source / tester / specialist-context metadata. Read-only diagnostic for Command Center reads. Wraps `voListPendingPRs` admin Cloud Function. V1 stub: returns `verdict: 'unimplemented'` \u2014 cloud-mode wiring pending.";
+var description13 = "Lists open AlgoHQ-source pull requests with blocker / source / tester / specialist-context metadata. Read-only diagnostic for Command Center reads. Wraps `voListPendingPRs` admin Cloud Function. Requires a founding-operator credential: the control plane's scoped-operator gate refuses `/api/v1/admin/*` for tenant-scoped accounts, which receive HTTP 403 `scoped_operator_forbidden`. Falls back to a clearly-marked `unimplemented` envelope when cloud mode is not configured.";
 function isToolInput13(v) {
   return typeof v === "object" && v !== null;
 }
@@ -4141,7 +4559,7 @@ var inputSchema14 = {
   required: ["pr_number"],
   additionalProperties: false
 };
-var description14 = "Approves + merges a single VO-source pull request by number. Wraps `voMergePR` admin Cloud Function (server-side refuses non-VO PRs with permission-denied). V1 stub: returns `verdict: 'unimplemented'` \u2014 cloud-mode wiring pending.";
+var description14 = "Approves + merges a single AlgoHQ-source pull request by number. Wraps `voMergePR` admin Cloud Function (server-side refuses non-AlgoHQ PRs with permission-denied). Requires a founding-operator credential: the control plane's scoped-operator gate refuses `/api/v1/admin/*` for tenant-scoped accounts, which receive HTTP 403 `scoped_operator_forbidden`. Falls back to a clearly-marked `unimplemented` envelope when cloud mode is not configured.";
 function isToolInput14(v) {
   if (typeof v !== "object" || v === null) return false;
   const o = v;
@@ -4185,7 +4603,7 @@ var inputSchema15 = {
   required: ["pr_number"],
   additionalProperties: false
 };
-var description15 = "Closes a pull request without merging. No retry dispatched \u2014 use `vo_reject_and_retry` for close+retry. Wraps `voRejectPR` admin Cloud Function. V1 stub: returns `verdict: 'unimplemented'` \u2014 cloud-mode wiring pending.";
+var description15 = "Closes a pull request without merging. No retry dispatched \u2014 use `vo_reject_and_retry` for close+retry. Wraps `voRejectPR` admin Cloud Function. Requires a founding-operator credential: the control plane's scoped-operator gate refuses `/api/v1/admin/*` for tenant-scoped accounts, which receive HTTP 403 `scoped_operator_forbidden`. Falls back to a clearly-marked `unimplemented` envelope when cloud mode is not configured.";
 function isToolInput15(v) {
   if (typeof v !== "object" || v === null) return false;
   const o = v;
@@ -4223,7 +4641,7 @@ var inputSchema16 = {
   properties: {},
   additionalProperties: false
 };
-var description16 = "Iterates all open VO-source pull requests and merges (or arms auto-merge) on each. Returns counts of merged / accepted / total plus per-PR results. Wraps `voApproveAllFixes` admin Cloud Function. V1 stub: returns `verdict: 'unimplemented'` \u2014 cloud-mode wiring pending.";
+var description16 = "Iterates all open AlgoHQ-source pull requests and merges (or arms auto-merge) on each. Returns counts of merged / accepted / total plus per-PR results. Wraps `voApproveAllFixes` admin Cloud Function. Requires a founding-operator credential: the control plane's scoped-operator gate refuses `/api/v1/admin/*` for tenant-scoped accounts, which receive HTTP 403 `scoped_operator_forbidden`. Falls back to a clearly-marked `unimplemented` envelope when cloud mode is not configured.";
 function isToolInput16(v) {
   return typeof v === "object" && v !== null;
 }
@@ -4257,7 +4675,7 @@ var inputSchema17 = {
   required: ["pr_number"],
   additionalProperties: false
 };
-var description17 = "Closes a VO pull request and dispatches a self-heal pass to retry the same focus page. Cloud callable refuses non-VO PRs and respects the self-heal kill switch + per-PR retry block. Wraps `voRejectAndRetry` admin Cloud Function. V1 stub: returns `verdict: 'unimplemented'` \u2014 cloud-mode wiring pending.";
+var description17 = "Closes an AlgoHQ pull request and dispatches a self-heal pass to retry the same focus page. Cloud callable refuses non-AlgoHQ PRs and respects the self-heal kill switch + per-PR retry block. Wraps `voRejectAndRetry` admin Cloud Function. Requires a founding-operator credential: the control plane's scoped-operator gate refuses `/api/v1/admin/*` for tenant-scoped accounts, which receive HTTP 403 `scoped_operator_forbidden`. Falls back to a clearly-marked `unimplemented` envelope when cloud mode is not configured.";
 function isToolInput17(v) {
   if (typeof v !== "object" || v === null) return false;
   const o = v;
@@ -4289,6 +4707,7 @@ async function handleRejectAndRetry(deps, rawInput, _signal) {
 // src/tools/pr/review-merge.ts
 var TOOL_NAME18 = "vo_review_merge";
 var LIST_PATH = "/api/v1/admin/pr/list";
+var DEFAULT_REVIEW_REPO = "Algosuite-ai/Nexus";
 var ENGINE_GATE = "final-deep-verify";
 var EVENT_GATE = "merge-review";
 var UNAVAILABLE_REASON = "vo_review_merge needs cloud mode to fetch PR context \u2014 set VO_CONTROL_PLANE_URL + VO_CONTROL_PLANE_ADMIN_TOKEN in the MCP env. (It is read-only; it never merges.)";
@@ -4333,7 +4752,7 @@ function buildPrompt4(pr, notes) {
   const lines = [
     "You are a release gatekeeper deciding whether a pull request is safe to MERGE.",
     "Recommend exactly one of: merge / hold / reject. Be conservative \u2014 this is a high-stakes irreversible action.",
-    "Rules: HOLD if CI is failing/blocked, there is a merge conflict, or the change is a draft. REJECT if the PR is not a legitimate VO-source change or has no clear purpose. MERGE only if it looks complete, scoped, and unblocked.",
+    "Rules: HOLD if CI is failing/blocked, there is a merge conflict, or the change is a draft. REJECT if the PR is not a legitimate AlgoHQ-source change or has no clear purpose. MERGE only if it looks complete, scoped, and unblocked.",
     "",
     `PR #${pr.number}: ${pr.title}`,
     `Source: ${pr.source ?? "unknown"}`,
@@ -4353,6 +4772,11 @@ async function handleReviewMerge(deps, rawInput, signal) {
   if (rawInput.notes !== void 0) normalizedInput.notes = rawInput.notes;
   const inputJson = JSON.stringify(normalizedInput);
   const key = deps.cache.keyFor(TOOL_NAME18, normalizedInput);
+  const subject = {
+    ...subjectFromEnv() ?? {},
+    repo: subjectFromEnv()?.repo ?? DEFAULT_REVIEW_REPO,
+    pr_number: prNumber
+  };
   const baseEvent = buildBaseEvent({
     tool: TOOL_NAME18,
     gateType: EVENT_GATE,
@@ -4360,7 +4784,8 @@ async function handleReviewMerge(deps, rawInput, signal) {
     inputExcerpt: inputJson.slice(0, 300),
     inputSizeBytes: bytesOf(inputJson),
     session: deps.session,
-    now: deps.now()
+    now: deps.now(),
+    subject
   });
   const emit = (payload2, eventExtra) => {
     deps.events.append(eventExtra ? { ...baseEvent, ...eventExtra } : baseEvent);
@@ -4401,7 +4826,7 @@ async function handleReviewMerge(deps, rawInput, signal) {
   }
   if (pr === null) {
     return emit(
-      emptyPayload("hold", `PR #${prNumber} is not among open VO PRs (already merged/closed, or not a VO-source PR).`, null)
+      emptyPayload("hold", `PR #${prNumber} is not among open AlgoHQ PRs (already merged/closed, or not an AlgoHQ-source PR).`, null)
     );
   }
   const hasBlocker = pr.blocker !== null && pr.blocker !== "none";
@@ -4461,7 +4886,138 @@ async function handleReviewMerge(deps, rawInput, signal) {
     duration_ms: result.duration_ms,
     consensus_engine_version: result.engine_version,
     per_model_verdicts: perModel,
-    synthesized_verdict: synth
+    synthesized_verdict: synth,
+    ...aggregateEventTokenUsage(result.per_model_verdicts, result.token_usage),
+    ...trajectoryFromEngine(result)
+  });
+}
+
+// src/tools/runner/prepared-job-mode.ts
+var TOOL_NAME19 = "vo_prepared_job_mode";
+var CALLABLE_NAME10 = "GET|POST /api/v1/runner/prepared-job-mode";
+var PLANE_PATH = "/api/v1/runner/prepared-job-mode";
+var PREPARED_JOB_MODE_GATE_TYPE = "admin-action";
+var PREPARED_JOB_MODE_STUB_REASON = "cloud mode is not configured on this session, so vo-control-plane was not reached. Sign in with `vo-mcp login` to route this tool to the plane. This route is NOT under /api/v1/admin/*, so a tenant-scoped operator credential is the CORRECT principal for it \u2014 the target operator is derived from that principal, never from this input.";
+var PREPARED_JOB_MODES = ["off", "shadow", "prepared"];
+var MIN_REASON_CHARS = 10;
+var MAX_REASON_CHARS = 500;
+var MAX_RUNNER_ID_CHARS = 100;
+var inputSchema19 = {
+  type: "object",
+  properties: {
+    action: {
+      type: "string",
+      enum: ["get", "set"],
+      description: "Required. 'get' reads the delivered mode (read-only; stays live under VO_ADMIN_CALLABLES_READONLY). 'set' writes it (a write; gated to the stub in read-only mode)."
+    },
+    runner_id: {
+      type: "string",
+      minLength: 1,
+      maxLength: MAX_RUNNER_ID_CHARS,
+      description: "Required. Runner to read/configure, e.g. 'vo-code-runner-JacksPC'. Must belong to the authenticated operator \u2014 the plane scopes by principal, so another operator's runner simply reads as unset."
+    },
+    prepared_job_mode: {
+      type: "string",
+      enum: [...PREPARED_JOB_MODES],
+      description: "Required for action='set'. 'off' = the runner's machine-local env rules; 'shadow' = compare the plane's prepared job without consuming it. 'prepared' is recognized but REFUSED by the plane with 409 prepared_mode_not_flippable (ADR-004 11.1c owns the flip)."
+    },
+    expected_revision: {
+      type: "integer",
+      minimum: 0,
+      description: "Required for action='set'. Optimistic-concurrency revision read from a prior 'get' (use 0 when no config exists). A stale value returns 409 stale_prepared_job_revision carrying the authoritative current_revision."
+    },
+    reason: {
+      type: "string",
+      minLength: MIN_REASON_CHARS,
+      maxLength: MAX_REASON_CHARS,
+      description: `Required for action='set'. Audit reason stored on the config-change record; at least ${MIN_REASON_CHARS} characters after trimming.`
+    }
+  },
+  required: ["action", "runner_id"],
+  additionalProperties: false
+};
+var description19 = "Gets or sets a paired runner's plane-delivered prepared-job mode (ADR-004 \xA7 11.1) via vo-control-plane GET/POST /api/v1/runner/prepared-job-mode. action='get' returns the stored config ({prepared_job_mode, revision, reason, updated_at, updated_by}, or null when unset); action='set' writes it with optimistic concurrency and returns the new config plus an audit_id. THE TARGET OPERATOR IS DERIVED FROM THE AUTHENTICATED PRINCIPAL, never from this input \u2014 an admin token therefore writes under operator 'admin' and does NOT reach a scoped operator's runner, so use the operator credential from `vo-mcp login`. 'prepared' is refused by the plane with 409 prepared_mode_not_flippable; 'get' is read-only while 'set' is a write and is gated to a stub under VO_ADMIN_CALLABLES_READONLY. Falls back to a clearly-marked `unimplemented` envelope when cloud mode is not configured.";
+var SHAPE_HINT = `invalid input. Shape: { action: 'get' | 'set', runner_id: non-empty string \u2264${MAX_RUNNER_ID_CHARS} chars }. For action='set' also required: prepared_job_mode ('${PREPARED_JOB_MODES.join("' | '")}'), expected_revision (integer \u2265 0), reason (string \u2265${MIN_REASON_CHARS} chars after trim). Those three fields are NOT accepted with action='get'.`;
+function parseInput(v) {
+  if (typeof v !== "object" || v === null || Array.isArray(v)) return null;
+  const o = v;
+  const action = o["action"];
+  if (action !== "get" && action !== "set") return null;
+  const rawRunnerId = o["runner_id"];
+  if (typeof rawRunnerId !== "string") return null;
+  const runner_id = rawRunnerId.trim();
+  if (runner_id.length === 0 || runner_id.length > MAX_RUNNER_ID_CHARS) return null;
+  const setOnly = ["prepared_job_mode", "expected_revision", "reason"];
+  if (action === "get") {
+    if (setOnly.some((key) => o[key] !== void 0)) return null;
+    return { action, runner_id };
+  }
+  const mode = o["prepared_job_mode"];
+  if (typeof mode !== "string") return null;
+  if (!PREPARED_JOB_MODES.includes(mode)) return null;
+  const revision = o["expected_revision"];
+  if (typeof revision !== "number") return null;
+  if (!Number.isInteger(revision) || revision < 0) return null;
+  const rawReason = o["reason"];
+  if (typeof rawReason !== "string") return null;
+  const reason = rawReason.trim();
+  if (reason.length < MIN_REASON_CHARS || reason.length > MAX_REASON_CHARS) return null;
+  return {
+    action,
+    runner_id,
+    prepared_job_mode: mode,
+    expected_revision: revision,
+    reason
+  };
+}
+async function handlePreparedJobMode(deps, rawInput, _signal) {
+  const input = parseInput(rawInput);
+  if (!input) {
+    throw invalidParams(TOOL_NAME19, SHAPE_HINT);
+  }
+  if (input.action === "get") {
+    return buildCloudOrStubResponse({
+      toolName: TOOL_NAME19,
+      callableName: CALLABLE_NAME10,
+      adminPath: PLANE_PATH,
+      normalizedInput: { action: "get", runner_id: input.runner_id },
+      // A GET carries no body; the runner id rides the query string.
+      cloudBody: {},
+      invokeOptions: { method: "GET", query: { runner_id: input.runner_id } },
+      // The plane answers `{ok, config}` — not the `{ok, callable, result}`
+      // admin-proxy envelope — so take the whole object with `ok` stripped.
+      rawEnvelope: true,
+      gateType: PREPARED_JOB_MODE_GATE_TYPE,
+      stubReason: PREPARED_JOB_MODE_STUB_REASON,
+      readOnly: true,
+      deps
+    });
+  }
+  return buildCloudOrStubResponse({
+    toolName: TOOL_NAME19,
+    callableName: CALLABLE_NAME10,
+    adminPath: PLANE_PATH,
+    normalizedInput: {
+      action: "set",
+      runner_id: input.runner_id,
+      prepared_job_mode: input.prepared_job_mode,
+      expected_revision: input.expected_revision,
+      reason: input.reason
+    },
+    // Exactly the four fields of `updateRunnerPreparedJobConfigInputSchema`
+    // (.strict()) — no `operator_id`, which the route would ignore anyway.
+    cloudBody: {
+      runner_id: input.runner_id,
+      prepared_job_mode: input.prepared_job_mode,
+      expected_revision: input.expected_revision,
+      reason: input.reason
+    },
+    rawEnvelope: true,
+    gateType: PREPARED_JOB_MODE_GATE_TYPE,
+    stubReason: PREPARED_JOB_MODE_STUB_REASON,
+    // A write: stays gated behind VO_ADMIN_CALLABLES_READONLY.
+    readOnly: false,
+    deps
   });
 }
 
@@ -4498,12 +5054,12 @@ function suggestedHandoffPath(session_id, isoTimestamp) {
 // src/tools/session/report-session-state.ts
 init_auth_token_source();
 init_credential_store();
-var TOOL_NAME19 = "vo_report_session_state";
+var TOOL_NAME20 = "vo_report_session_state";
 var VALID_AGENT_TYPES = ["claude-code", "codex", "cursor", "continue"];
 var MAX_GOAL_CHARS = 500;
 var MAX_RECENT_FILES = 20;
 var MAX_RECENT_TOOLS = 50;
-var inputSchema19 = {
+var inputSchema20 = {
   type: "object",
   properties: {
     operator_id: {
@@ -4548,7 +5104,7 @@ var inputSchema19 = {
   required: ["operator_id", "session_id", "agent_type", "context_used_pct"],
   additionalProperties: false
 };
-var description19 = "Reports per-session context-window utilization to VO and returns a directive: 'continue' (under 70%), 'prepare_handoff' (70-84%), or 'execute_handoff_now' (\u226585%). Implements V1 launch gate #9 (fleet context lifecycle management) per the official VO roadmap. Cloud-control-plane mode when VO_CONTROL_PLANE_URL plus a user/scoped VO credential (or legacy admin token) is available; auto-allocates the session on first report so interactive agents (Claude Code, Cursor, Codex, Continue) appear on the live fleet whiteboard. Stub-local fallback when cloud config is absent or fails. The response shape stays stable across modes (`backend_mode` field in the payload tells the caller which mode produced the verdict).";
+var description20 = "Reports per-session context-window utilization to AlgoHQ and returns a directive: 'continue' (under 70%), 'prepare_handoff' (70-84%), or 'execute_handoff_now' (\u226585%). Implements V1 launch gate #9 (fleet context lifecycle management) per the official AlgoHQ roadmap. Cloud-control-plane mode when VO_CONTROL_PLANE_URL plus a user/scoped HQ credential (or legacy admin token) is available; auto-allocates the session on first report so interactive agents (Claude Code, Cursor, Codex, Continue) appear on the live fleet whiteboard. Stub-local fallback when cloud config is absent or fails. The response shape stays stable across modes (`backend_mode` field in the payload tells the caller which mode produced the verdict).";
 function isStringArray2(v, maxItems) {
   if (!Array.isArray(v)) return false;
   if (v.length > maxItems) return false;
@@ -4686,7 +5242,7 @@ async function tryCloudReportState(cloud, input, fetchFn = fetch) {
 async function handleReportSessionState(deps, rawInput, _signal) {
   if (!isToolInput19(rawInput)) {
     throw invalidParams(
-      TOOL_NAME19,
+      TOOL_NAME20,
       `invalid input. Required fields: operator_id (non-empty string), session_id (non-empty string), agent_type (one of: ${VALID_AGENT_TYPES.join(" | ")}), context_used_pct (number 0-100). Optional: current_goal (string \u2264${MAX_GOAL_CHARS} chars), recent_files_touched (string[] \u2264${MAX_RECENT_FILES}), recent_tool_uses (string[] \u2264${MAX_RECENT_TOOLS}).`
     );
   }
@@ -4716,99 +5272,702 @@ async function handleReportSessionState(deps, rawInput, _signal) {
 
 // src/tools/session/spawn-successor.ts
 import { spawn } from "node:child_process";
-import { homedir as homedir4 } from "node:os";
-import { join as join6 } from "node:path";
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, openSync, readFileSync as readFileSync6, readdirSync as readdirSync3, statSync as statSync3 } from "node:fs";
-var TOOL_NAME20 = "vo_spawn_successor";
-var MAX_HANDOFF_BYTES = 64e3;
-var inputSchema20 = {
-  type: "object",
-  properties: {
-    handoff_path: {
-      type: "string",
-      description: "Path to the handoff doc to pre-inject. Default: the newest .md in ~/.vo/handoffs/."
-    },
-    goal: {
-      type: "string",
-      description: "Optional one-line goal override appended after the handoff."
-    },
-    cwd: {
-      type: "string",
-      description: "Working directory for the successor (default: the repo the handoff names, else process cwd)."
-    },
-    max_turns: {
-      type: "number",
-      description: "Optional --max-turns bound for the successor."
-    }
-  },
-  required: [],
-  additionalProperties: false
-};
-var description20 = "Mode B auto-handoff (roadmap \xA73.4): spawn a DETACHED headless `claude -p` successor with a handoff doc pre-injected into its prompt. Defaults to the newest handoff in ~/.vo/handoffs/. Returns {spawned, pid, log_path, handoff_path}. The successor works under the same gates as any session (ADR-001: verify-before-act, human merge approval) \u2014 this tool never fires autonomously.";
-function isToolInput20(v) {
-  if (typeof v !== "object" || v === null) return false;
-  const o = v;
-  if (o["handoff_path"] !== void 0 && typeof o["handoff_path"] !== "string") return false;
-  if (o["goal"] !== void 0 && typeof o["goal"] !== "string") return false;
-  if (o["cwd"] !== void 0 && typeof o["cwd"] !== "string") return false;
-  if (o["max_turns"] !== void 0 && typeof o["max_turns"] !== "number") return false;
-  return true;
+import { homedir as homedir5 } from "node:os";
+import { join as join7 } from "node:path";
+import { closeSync as closeSync2, existsSync as existsSync5, mkdirSync as mkdirSync4, openSync as openSync2, readFileSync as readFileSync7, readdirSync as readdirSync3, statSync as statSync4 } from "node:fs";
+
+// src/swarm/tier-binding.ts
+var SWARM_TIERS = Object.freeze([
+  "tier1_subscription",
+  "tier1_local",
+  "tier2_user_key",
+  "tier3_platform_key",
+  "refused",
+  "unresolved"
+]);
+var TIER_ADMITS_SPAWN = /* @__PURE__ */ new Set([
+  "tier1_subscription",
+  "tier1_local",
+  "tier2_user_key",
+  "tier3_platform_key"
+]);
+var SWARM_TIER_BINDING_ENV = "VO_SWARM_TIER_BINDING";
+var MAX_BOUND_SUBAGENTS = 20;
+function isPositiveCap(cap) {
+  return typeof cap === "number" && Number.isFinite(cap) && cap > 0;
+}
+function unresolvedBinding(swarmId, nowIso, reason) {
+  return {
+    schema_version: 1,
+    swarm_id: swarmId,
+    tier: "unresolved",
+    agent: null,
+    reason,
+    exhausted_agents: [],
+    subagent_budget: 0,
+    spend_cap_usd: null,
+    resolved_at: nowIso
+  };
 }
-function newestHandoff(dir = join6(homedir4(), ".vo", "handoffs")) {
+function serializeSwarmTierBinding(binding) {
+  return JSON.stringify(binding);
+}
+function parseSwarmTierBinding(raw, nowIso) {
+  if (typeof raw !== "string" || raw.trim().length === 0) {
+    return unresolvedBinding("", nowIso, "no swarm tier binding present in the environment");
+  }
+  let parsed;
   try {
-    const entries = readdirSync3(dir).filter((f) => f.endsWith(".md")).map((f) => ({ f, m: statSync3(join6(dir, f)).mtimeMs })).sort((a, b) => b.m - a.m);
-    return entries.length > 0 && entries[0] ? join6(dir, entries[0].f) : null;
+    parsed = JSON.parse(raw);
   } catch {
-    return null;
+    return unresolvedBinding("", nowIso, "swarm tier binding is not valid JSON");
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return unresolvedBinding("", nowIso, "swarm tier binding is not an object");
+  }
+  const o = parsed;
+  const swarmId = typeof o["swarm_id"] === "string" ? o["swarm_id"] : "";
+  if (o["schema_version"] !== 1) {
+    return unresolvedBinding(swarmId, nowIso, "swarm tier binding has an unsupported schema_version");
+  }
+  const tier = o["tier"];
+  if (typeof tier !== "string" || !SWARM_TIERS.includes(tier)) {
+    return unresolvedBinding(swarmId, nowIso, "swarm tier binding names an unknown tier");
+  }
+  const budget = o["subagent_budget"];
+  const cap = o["spend_cap_usd"];
+  const capNum = isPositiveCap(cap) ? cap : null;
+  if (tier === "tier3_platform_key" && capNum === null) {
+    return unresolvedBinding(
+      swarmId,
+      nowIso,
+      "inherited tier3_platform_key binding carries no positive numeric spend cap \u2014 refusing an uncapped platform-billed fan-out"
+    );
   }
+  return {
+    schema_version: 1,
+    swarm_id: swarmId,
+    tier,
+    agent: typeof o["agent"] === "string" ? o["agent"] : null,
+    reason: typeof o["reason"] === "string" ? o["reason"] : "inherited binding carried no reason",
+    exhausted_agents: Array.isArray(o["exhausted_agents"]) ? o["exhausted_agents"].filter((v) => typeof v === "string") : [],
+    subagent_budget: typeof budget === "number" && Number.isFinite(budget) && budget > 0 ? Math.min(Math.floor(budget), MAX_BOUND_SUBAGENTS) : 0,
+    spend_cap_usd: capNum,
+    resolved_at: typeof o["resolved_at"] === "string" ? o["resolved_at"] : nowIso
+  };
 }
-var MANDATORY_READS = [
-  "CLAUDE.md + AGENTS.md + README.md (repo root)",
-  "docs/current/virtual-office-agent-charter.md, -operating-model.md, -test-architect.md",
-  "docs/current/evidence-grounded-consensus-testing.md",
-  "docs/vo/ADR-001-* (verify + sign, human approves merge; no autonomous bot-merge / headless triggers) + docs/vo/vo-adr-002-two-plane-moat.md",
-  "docs/vo/vo-roadmap-2026-05-26.md (read the Change log tail for current state)",
-  "the operator memory index ~/.claude/projects/C--Users-greyl/memory/MEMORY.md"
-];
-function buildSuccessorPrompt(handoffMarkdown, goal) {
-  const reads = MANDATORY_READS.map((r, i) => `  ${i + 1}. ${r}`).join("\n");
-  const lines = [
-    "You are the SUCCESSOR agent for a Virtual Office lane. The previous session",
-    "exhausted its context and wrote the handoff below. Read it fully, verify its",
-    '"verification needed" items against live state (a handoff is a claim, not',
-    "evidence \u2014 verify via `git show origin/main:<path>`), then continue the lane.",
-    "",
-    "MANDATORY READS before writing any code (NOT all auto-loaded \u2014 open them):",
-    reads,
-    "",
-    "NON-NEGOTIABLES: multi-model consensus verification is the core; test honesty",
-    "(verified-answer-only, no fake green); verify-before-act + human merge approval;",
-    "never a full functions-shared deploy; Gen2 only; work in a worktree on your own",
-    "branch; finish line is MERGED + DEPLOYED + LIVE-VERIFIED, and VO changes update",
-    "the roadmap in the same PR.",
-    "",
-    "--- HANDOFF ---",
-    handoffMarkdown,
-    "--- END HANDOFF ---"
-  ];
-  if (goal && goal.trim().length > 0) lines.push("", `OPERATOR GOAL OVERRIDE: ${goal.trim()}`);
-  return lines.join("\n");
+function inheritSwarmTierBinding(env, nowIso) {
+  return parseSwarmTierBinding(env[SWARM_TIER_BINDING_ENV], nowIso);
 }
-function buildSuccessorArgs(maxTurns) {
-  const args = ["-p", "--permission-mode", "acceptEdits"];
-  if (Number.isInteger(maxTurns) && maxTurns > 0) {
-    args.push("--max-turns", String(maxTurns));
-  }
-  return args;
+function bindingEnvFragment(binding) {
+  return { [SWARM_TIER_BINDING_ENV]: serializeSwarmTierBinding(binding) };
 }
-async function handleSpawnSuccessor(_deps, rawInput, _signal, spawnImpl = spawn) {
-  if (!isToolInput20(rawInput)) {
-    throw invalidParams(TOOL_NAME20, "invalid input. Optional: { handoff_path, goal, cwd, max_turns }.");
+function childBindingEnvFragment(binding, allocatedCapUsd = null) {
+  return bindingEnvFragment(childBinding(binding, allocatedCapUsd));
+}
+function admitSubagentSpawn(binding, spawnsSoFar = 0) {
+  if (!TIER_ADMITS_SPAWN.has(binding.tier)) {
+    return { allowed: false, reason: `tier '${binding.tier}' admits no spawn: ${binding.reason}` };
   }
-  const handoffPath = rawInput.handoff_path?.trim() || newestHandoff();
-  if (!handoffPath || !existsSync4(handoffPath)) {
+  if (binding.tier === "tier3_platform_key" && !isPositiveCap(binding.spend_cap_usd)) {
+    return {
+      allowed: false,
+      reason: `swarm ${binding.swarm_id} is tier3_platform_key with no positive spend cap \u2014 refusing to spend the platform owner's money uncapped`
+    };
+  }
+  if (!Number.isFinite(spawnsSoFar) || spawnsSoFar < 0) {
+    return { allowed: false, reason: "spawn counter is not a finite non-negative number" };
+  }
+  if (spawnsSoFar >= binding.subagent_budget) {
+    return {
+      allowed: false,
+      reason: `swarm ${binding.swarm_id} exhausted its bound subagent budget (${binding.subagent_budget})`
+    };
+  }
+  return { allowed: true, reason: `admitted under tier '${binding.tier}'` };
+}
+function childBinding(binding, allocatedCapUsd = null) {
+  const allocated = isPositiveCap(allocatedCapUsd) ? allocatedCapUsd : null;
+  const parentCap = isPositiveCap(binding.spend_cap_usd) ? binding.spend_cap_usd : null;
+  return {
+    ...binding,
+    subagent_budget: Math.max(0, binding.subagent_budget - 1),
+    // A child never carries more than its parent, whatever the ledger says: a
+    // forged or hand-edited pool cannot inflate a descendant above the binding
+    // it descends from.
+    spend_cap_usd: allocated === null || parentCap === null ? null : Math.min(allocated, parentCap)
+  };
+}
+function agentBindingRefusal(binding, requestedAgent) {
+  const requested = typeof requestedAgent === "string" ? requestedAgent.trim() : "";
+  if (requested.length === 0) return null;
+  if (binding.agent !== null && requested === binding.agent) return null;
+  return `swarm '${binding.swarm_id}' is bound to agent '${binding.agent ?? "none"}' under tier '${binding.tier}'; a caller-supplied agent '${requested}' would move this fan-out onto a different payer \u2014 refusing (the tier is decided once, at admission, and an inherited binding cannot be renegotiated)`;
+}
+
+// src/swarm/successor-launch.ts
+var AGENT_LAUNCH_SHAPES = Object.freeze({
+  claude: {
+    bin: "claude",
+    baseArgs: ["-p", "--permission-mode", "acceptEdits"],
+    enforcesMaxTurns: true,
+    maxTurnsFlag: "--max-turns",
+    windowsShellSafe: true
+  },
+  codex: {
+    bin: "codex",
+    baseArgs: ["exec", "--json", "-c", 'approval_policy="never"', "--sandbox", "workspace-write", "--skip-git-repo-check"],
+    enforcesMaxTurns: false,
+    // `-` makes codex read the prompt from stdin (injection-safe), matching how
+    // codex-runner.mjs already spawns it.
+    trailingArgs: ["-"],
+    // `approval_policy="never"` carries embedded quotes; cmd.exe re-parsing is
+    // unverified, so win32 refuses rather than risking a mangled sandbox flag.
+    windowsShellSafe: false
+  }
+});
+function resolveSuccessorLaunch(input) {
+  const agent = typeof input.agent === "string" ? input.agent.trim() : "";
+  if (!agent) {
+    return { ok: false, reason: "no agent bound for this spawn \u2014 refusing rather than defaulting to claude" };
+  }
+  const shape = AGENT_LAUNCH_SHAPES[agent];
+  if (!shape) {
+    const known = Object.keys(AGENT_LAUNCH_SHAPES).join(", ");
+    return {
+      ok: false,
+      reason: `no known headless launch shape for agent '${agent}' (known: ${known}) \u2014 refusing rather than guessing its argv`
+    };
+  }
+  const wantsMaxTurns = Number.isInteger(input.maxTurns) && input.maxTurns > 0;
+  if (wantsMaxTurns && !shape.enforcesMaxTurns) {
+    return {
+      ok: false,
+      reason: `agent '${agent}' cannot enforce a max_turns cap \u2014 refusing rather than spawning it unbounded`
+    };
+  }
+  const platform = input.platform ?? process.platform;
+  if (platform === "win32" && !shape.windowsShellSafe) {
+    return {
+      ok: false,
+      reason: `agent '${agent}' has an argv whose behaviour under Windows cmd.exe re-parsing is unverified \u2014 refusing rather than emitting a command line that may mean something else`
+    };
+  }
+  const args = [...shape.baseArgs];
+  if (wantsMaxTurns && shape.maxTurnsFlag) {
+    args.push(shape.maxTurnsFlag, String(input.maxTurns));
+  }
+  if (shape.trailingArgs) args.push(...shape.trailingArgs);
+  return { ok: true, agent, bin: shape.bin, args };
+}
+
+// src/swarm/spawn-ledger.ts
+import { mkdirSync as mkdirSync3, openSync, closeSync, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join6 } from "node:path";
+var SWARM_LEDGER_DIR_ENV = "VO_SWARM_LEDGER_DIR";
+function resolveLedgerDir(env) {
+  const override = env[SWARM_LEDGER_DIR_ENV];
+  if (typeof override === "string" && override.trim().length > 0) return override.trim();
+  return join6(homedir4(), ".vo", "swarm-ledger");
+}
+function sanitizeSwarmId(raw) {
+  if (typeof raw !== "string") return null;
+  const id = raw.trim();
+  if (id.length === 0 || id.length > 128) return null;
+  if (!/^[A-Za-z0-9._-]+$/u.test(id)) return null;
+  if (id === "." || id === "..") return null;
+  return id;
+}
+var CEILING_FILE = "ceiling.json";
+function createExclusive(path4, contents) {
+  let fd;
+  try {
+    fd = openSync(path4, "wx");
+  } catch {
+    return false;
+  }
+  try {
+    writeFileSync3(fd, contents, "utf8");
+  } finally {
+    closeSync(fd);
+  }
+  return true;
+}
+function capToCents(cap) {
+  return isPositiveCap(cap) ? Math.round(cap * 100) : 0;
+}
+function readOrRecordLedgerHead(swarmDir, proposedCeiling, proposedCapCents, nowIso) {
+  const path4 = join6(swarmDir, CEILING_FILE);
+  const head = JSON.stringify({
+    ceiling: proposedCeiling,
+    cap_cents: proposedCapCents,
+    recorded_at: nowIso
+  });
+  if (createExclusive(path4, head)) {
+    return { ceiling: proposedCeiling, capCents: proposedCapCents };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync6(path4, "utf8"));
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+  const record = parsed;
+  const recorded = record["ceiling"];
+  if (typeof recorded !== "number" || !Number.isFinite(recorded) || recorded < 1) return null;
+  const recordedCap = record["cap_cents"];
+  const capCents = typeof recordedCap === "number" && Number.isFinite(recordedCap) && recordedCap > 0 ? Math.floor(recordedCap) : 0;
+  return { ceiling: Math.min(Math.floor(recorded), MAX_BOUND_SUBAGENTS), capCents };
+}
+var claimSpawnSlot = ({ swarmId, proposedCeiling, proposedCapUsd, dir, nowIso }) => {
+  const id = sanitizeSwarmId(swarmId);
+  if (id === null) {
+    return {
+      ok: false,
+      reason: `swarm id ${JSON.stringify(swarmId)} is absent or unusable as a ledger key \u2014 refusing a spawn that cannot be counted against a fan-out ceiling`
+    };
+  }
+  const proposed = Number.isFinite(proposedCeiling) ? Math.floor(proposedCeiling) : 0;
+  if (proposed < 1) {
+    return { ok: false, reason: `swarm '${id}' proposes a ceiling of ${proposed} \u2014 no allowance to claim` };
+  }
+  const swarmDir = join6(dir, id);
+  try {
+    mkdirSync3(swarmDir, { recursive: true });
+  } catch (err) {
+    return {
+      ok: false,
+      reason: `swarm '${id}' ledger directory is unwritable (${err instanceof Error ? err.message : String(err)}) \u2014 refusing rather than spawning uncounted`
+    };
+  }
+  const wantedCents = capToCents(proposedCapUsd);
+  const head = readOrRecordLedgerHead(swarmDir, Math.min(proposed, MAX_BOUND_SUBAGENTS), wantedCents, nowIso);
+  if (head === null) {
+    return { ok: false, reason: `swarm '${id}' ledger carries no readable ceiling \u2014 refusing rather than spawning uncounted` };
+  }
+  const { ceiling, capCents } = head;
+  const shareCents = capCents > 0 ? Math.floor(capCents / ceiling) : 0;
+  if (wantedCents > 0 && shareCents < 1) {
+    return {
+      ok: false,
+      reason: `swarm '${id}' has no spend allowance left to debit (recorded pool $${(capCents / 100).toFixed(2)} across a ceiling of ${ceiling} leaves under one cent per spawn) \u2014 refusing a platform-billed spawn it cannot fund`
+    };
+  }
+  for (let slot = 0; slot < ceiling; slot++) {
+    const debitedCents = shareCents;
+    const remainingCents = capCents > 0 ? capCents - (slot + 1) * shareCents : 0;
+    const claimed = createExclusive(
+      join6(swarmDir, `slot-${slot}.json`),
+      JSON.stringify({
+        slot,
+        ceiling,
+        pid: process.pid,
+        claimed_at: nowIso,
+        // The debit record. Durable and atomic with the claim: this file is
+        // created with O_EXCL, so exactly one claimant ever writes this line.
+        cap_cents_pool: capCents,
+        cap_cents_debited: debitedCents,
+        cap_cents_remaining: remainingCents
+      })
+    );
+    if (claimed) {
+      return {
+        ok: true,
+        slot,
+        ceiling,
+        remaining: ceiling - slot - 1,
+        capUsd: debitedCents > 0 ? debitedCents / 100 : null,
+        capRemainingUsd: capCents > 0 ? remainingCents / 100 : null
+      };
+    }
+  }
+  return {
+    ok: false,
+    reason: `swarm '${id}' has spent its whole fan-out ceiling (${ceiling} spawns across every generation) \u2014 refusing`
+  };
+};
+
+// src/swarm/spawn-plan.ts
+function resolveSpawnPlan(env, input, nowIso, platform = process.platform, claim = claimSpawnSlot) {
+  const rawBinding = env[SWARM_TIER_BINDING_ENV];
+  const hasBinding = typeof rawBinding === "string" && rawBinding.trim().length > 0;
+  if (!hasBinding) {
+    const explicit = input.agent?.trim();
+    const resolved2 = resolveSuccessorLaunch({ agent: explicit || "claude", maxTurns: input.max_turns, platform });
+    if (!resolved2.ok) return { ok: false, reason: resolved2.reason, tier: "unbound" };
+    return {
+      ok: true,
+      bin: resolved2.bin,
+      args: resolved2.args,
+      agent: resolved2.agent,
+      tier: "unbound",
+      bound: false,
+      env: {},
+      slot: null,
+      capUsd: null,
+      capRemainingUsd: null
+    };
+  }
+  const binding = inheritSwarmTierBinding(env, nowIso);
+  const admission = admitSubagentSpawn(binding);
+  if (!admission.allowed) {
+    return { ok: false, reason: admission.reason, tier: binding.tier };
+  }
+  const agentRefusal = agentBindingRefusal(binding, input.agent);
+  if (agentRefusal !== null) return { ok: false, reason: agentRefusal, tier: binding.tier };
+  const resolved = resolveSuccessorLaunch({
+    agent: binding.agent,
+    maxTurns: input.max_turns,
+    platform
+  });
+  if (!resolved.ok) return { ok: false, reason: resolved.reason, tier: binding.tier };
+  const slot = claim({
+    swarmId: binding.swarm_id,
+    proposedCeiling: binding.subagent_budget,
+    // The spend-cap POOL, recorded once per swarm exactly like the ceiling. The
+    // child's cap is DEBITED from it below, not recomputed from this binding.
+    proposedCapUsd: binding.spend_cap_usd,
+    dir: resolveLedgerDir(env),
+    nowIso
+  });
+  if (!slot.ok) return { ok: false, reason: slot.reason, tier: binding.tier };
+  return {
+    ok: true,
+    bin: resolved.bin,
+    args: resolved.args,
+    agent: resolved.agent,
+    tier: binding.tier,
+    bound: true,
+    // Re-export the same TIER with a DECREMENTED budget and the spend cap the
+    // ledger just DEBITED. Exporting the binding verbatim (what this did before
+    // #9312) meant the child re-read the full budget and every generation
+    // restarted at zero. Recomputing the cap from THIS binding (what #9312 did)
+    // bounded a chain but not a tree: three siblings each re-halved the parent's
+    // untouched $50 and walked away with $75 between them.
+    env: childBindingEnvFragment(binding, slot.capUsd),
+    slot: slot.slot,
+    capUsd: slot.capUsd,
+    capRemainingUsd: slot.capRemainingUsd
+  };
+}
+
+// ../../scripts/virtual-office/code-runner/windows-claude-launch.mjs
+import { existsSync as existsSync4, realpathSync } from "node:fs";
+import { win32 as path3 } from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+var NATIVE_CLAUDE_PARTS = [
+  "node_modules",
+  "@anthropic-ai",
+  "claude-code",
+  "bin",
+  "claude.exe"
+];
+function pathValue(env) {
+  for (const key of ["Path", "PATH", "path"]) {
+    if (typeof env?.[key] === "string") return env[key];
+  }
+  return "";
+}
+function cleanPathSegment(value) {
+  const trimmed = String(value || "").trim();
+  return trimmed.startsWith('"') && trimmed.endsWith('"') ? trimmed.slice(1, -1) : trimmed;
+}
+function envValue(env, name) {
+  const exact = env?.[name];
+  if (typeof exact === "string") return exact.trim();
+  const key = Object.keys(env || {}).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+  return typeof env?.[key] === "string" ? env[key].trim() : "";
+}
+function userClaudeCandidates(bin, env) {
+  if (!/^claude(?:\.(?:exe|cmd|ps1))?$/iu.test(bin)) return [];
+  const userProfile = envValue(env, "USERPROFILE");
+  const appData = envValue(env, "APPDATA") || (userProfile ? path3.join(userProfile, "AppData", "Roaming") : "");
+  const localAppData = envValue(env, "LOCALAPPDATA") || (userProfile ? path3.join(userProfile, "AppData", "Local") : "");
+  const candidates = [];
+  if (appData) {
+    const npmBin = path3.join(appData, "npm");
+    candidates.push(
+      path3.join(npmBin, "claude.exe"),
+      path3.join(npmBin, "claude.cmd"),
+      path3.join(npmBin, "claude.ps1"),
+      path3.join(npmBin, "claude"),
+      path3.join(npmBin, ...NATIVE_CLAUDE_PARTS)
+    );
+  }
+  if (userProfile) candidates.push(path3.join(userProfile, ".local", "bin", "claude.exe"));
+  if (localAppData) {
+    candidates.push(
+      path3.join(localAppData, "Microsoft", "WinGet", "Links", "claude.exe"),
+      path3.join(localAppData, "Microsoft", "WindowsApps", "claude.exe")
+    );
+  }
+  return candidates;
+}
+function pathCandidates(bin, env) {
+  if (path3.isAbsolute(bin) || /[\\/]/u.test(bin)) {
+    return [path3.resolve(bin)];
+  }
+  const extension = path3.extname(bin);
+  const fromPath = pathValue(env).split(";").map(cleanPathSegment).filter(Boolean).flatMap((directory) => extension ? [path3.join(directory, bin)] : [
+    path3.join(directory, `${bin}.exe`),
+    path3.join(directory, `${bin}.cmd`),
+    path3.join(directory, `${bin}.ps1`),
+    path3.join(directory, bin)
+  ]);
+  const seen = /* @__PURE__ */ new Set();
+  return [...fromPath, ...userClaudeCandidates(bin, env)].filter((candidate) => {
+    const key = candidate.toLowerCase();
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function canonicalExistingPath(candidate, exists, canonicalize2) {
+  if (!exists(candidate)) return null;
+  try {
+    return canonicalize2(candidate);
+  } catch {
+    return null;
+  }
+}
+function resolveWindowsClaudeExecutable({
+  bin = "claude",
+  env = process.env,
+  exists = existsSync4,
+  canonicalize: canonicalize2 = realpathSync
+} = {}) {
+  const requested = String(bin || "").trim();
+  if (!requested || requested.includes("\0")) {
+    throw new TypeError("Claude executable must be a non-empty path without NUL bytes");
+  }
+  for (const candidate of pathCandidates(requested, env)) {
+    const found = canonicalExistingPath(candidate, exists, canonicalize2);
+    if (!found) continue;
+    if (path3.extname(found).toLowerCase() === ".exe") return found;
+    const native = path3.join(path3.dirname(found), ...NATIVE_CLAUDE_PARTS);
+    const resolvedNative = canonicalExistingPath(native, exists, canonicalize2);
+    if (resolvedNative) return resolvedNative;
+  }
+  const error = new Error(
+    `Could not resolve a native claude.exe for "${requested}". Install or update Claude Code with the native Windows installer (recommended) or npm install -g @anthropic-ai/claude-code; the HQ runner will not execute a shell-only .cmd/.ps1 shim.`
+  );
+  error.code = "ENOENT";
+  throw error;
+}
+
+// src/swarm/successor-windows-exe.ts
+var resolveWindowsClaudeExe = (bin, env) => resolveWindowsClaudeExecutable({ bin, env });
+function resolveNativeWindowsExecutable(bin, env = process.env, resolve3 = resolveWindowsClaudeExe) {
+  try {
+    return { ok: true, bin: resolve3(bin, env) };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      ok: false,
+      reason: `could not resolve a native Windows executable for '${bin}': ${message}`
+    };
+  }
+}
+
+// src/swarm/successor-liveness.ts
+import { statSync as statSync3 } from "node:fs";
+var DEFAULT_EARLY_EXIT_SEC = 10;
+var DEFAULT_NO_OUTPUT_SEC = 0;
+var DEFAULT_POLL_MS = 200;
+var KILL_ESCALATION_MS = 2e3;
+function positiveSeconds(raw, fallback) {
+  if (raw === void 0) return fallback;
+  const n = Number(raw.trim());
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+function resolveLivenessConfigFromEnv(env = process.env, explicitOverride = {}) {
+  const earlyExitMs = explicitOverride.earlyExitMs ?? positiveSeconds(env["VO_MCP_SUCCESSOR_EXIT_CHECK_SEC"], DEFAULT_EARLY_EXIT_SEC) * 1e3;
+  const noOutputMs = explicitOverride.noOutputMs ?? positiveSeconds(env["VO_MCP_SUCCESSOR_OUTPUT_CHECK_SEC"], DEFAULT_NO_OUTPUT_SEC) * 1e3;
+  return { earlyExitMs, noOutputMs };
+}
+function defaultStatLogBytes(path4) {
+  try {
+    return statSync3(path4).size;
+  } catch {
+    return 0;
+  }
+}
+function defaultKillChild(child) {
+  try {
+    child.kill("SIGTERM");
+  } catch {
+  }
+  const escalation = setTimeout(() => {
+    try {
+      child.kill("SIGKILL");
+    } catch {
+    }
+  }, KILL_ESCALATION_MS);
+  escalation.unref();
+}
+function checkSuccessorLiveness(child, logPath, config, deps = {}) {
+  const statLogBytes = deps.statLogBytes ?? defaultStatLogBytes;
+  const now = deps.now ?? Date.now;
+  const pollIntervalMs = deps.pollIntervalMs ?? DEFAULT_POLL_MS;
+  const killChild = deps.killChild ?? defaultKillChild;
+  const outputGateEnabled = Number.isFinite(config.noOutputMs) && config.noOutputMs > 0;
+  const startedAt = now();
+  return new Promise((resolve3) => {
+    let settled = false;
+    let pollTimer = null;
+    const onExit = (code, signal) => {
+      const elapsedMs = now() - startedAt;
+      finish({
+        ok: false,
+        reason: `child_exited_early: exit code ${code ?? "null"} signal ${signal ?? "none"} after ${elapsedMs}ms`,
+        detail: { exitCode: code, signal, elapsedMs }
+      });
+    };
+    const cleanup = () => {
+      if (pollTimer !== null) clearInterval(pollTimer);
+      child.off?.("exit", onExit);
+    };
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (!result.ok) {
+        try {
+          killChild(child);
+        } catch {
+        }
+      }
+      resolve3(result);
+    };
+    if (typeof child.exitCode === "number" || typeof child.signalCode === "string" && child.signalCode.length > 0) {
+      finish({
+        ok: false,
+        reason: `child_exited_early: exit code ${child.exitCode ?? "null"} signal ${child.signalCode ?? "none"} before the liveness watch attached`,
+        detail: { exitCode: child.exitCode ?? null, signal: child.signalCode ?? null, elapsedMs: 0 }
+      });
+      return;
+    }
+    child.on("exit", onExit);
+    const tick = () => {
+      if (settled) return;
+      const elapsedMs = now() - startedAt;
+      const outputSeen = outputGateEnabled ? statLogBytes(logPath) > 0 : true;
+      if (outputSeen && elapsedMs >= config.earlyExitMs) {
+        finish({ ok: true });
+        return;
+      }
+      if (outputGateEnabled && !outputSeen && elapsedMs >= config.noOutputMs) {
+        finish({
+          ok: false,
+          reason: `no_output: log stayed empty for ${elapsedMs}ms (limit ${config.noOutputMs}ms)`,
+          detail: { elapsedMs, logPath }
+        });
+      }
+    };
+    pollTimer = setInterval(tick, pollIntervalMs);
+    tick();
+  });
+}
+
+// src/tools/session/spawn-successor.ts
+var TOOL_NAME21 = "vo_spawn_successor";
+var MAX_HANDOFF_BYTES = 64e3;
+var inputSchema21 = {
+  type: "object",
+  properties: {
+    handoff_path: {
+      type: "string",
+      description: "Path to the handoff doc to pre-inject. Default: the newest .md in ~/.vo/handoffs/."
+    },
+    goal: {
+      type: "string",
+      description: "Optional one-line goal override appended after the handoff."
+    },
+    cwd: {
+      type: "string",
+      description: "Working directory for the successor (default: the repo the handoff names, else process cwd)."
+    },
+    max_turns: {
+      type: "number",
+      description: "Optional --max-turns bound for the successor."
+    },
+    agent: {
+      type: "string",
+      description: `Which agent to spawn ('claude' | 'codex'). Normally omitted: the agent comes from the swarm tier binding inherited via ${SWARM_TIER_BINDING_ENV}. When a binding IS inherited this may only RESTATE the bound agent \u2014 an agent that contradicts the binding is REFUSED, because a different agent is a different payer and the payer was decided once, at admission.`
+    }
+  },
+  required: [],
+  additionalProperties: false
+};
+var RETIRED_COUNTER_INPUT = "spawns_so_far";
+var description21 = "Mode B auto-handoff (roadmap \xA73.4): spawn a DETACHED headless `claude -p` successor with a handoff doc pre-injected into its prompt. Defaults to the newest handoff in ~/.vo/handoffs/. Verifies the child is actually alive (survives an early-exit window; an optional log-output window is off by default) before reporting success. Returns {spawned, pid, log_path, handoff_path}. The successor works under the same gates as any session (ADR-001: verify-before-act, human merge approval) \u2014 this tool never fires autonomously.";
+function isToolInput20(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const o = v;
+  if (o["handoff_path"] !== void 0 && typeof o["handoff_path"] !== "string") return false;
+  if (o["goal"] !== void 0 && typeof o["goal"] !== "string") return false;
+  if (o["cwd"] !== void 0 && typeof o["cwd"] !== "string") return false;
+  if (o["max_turns"] !== void 0 && typeof o["max_turns"] !== "number") return false;
+  if (o["agent"] !== void 0 && typeof o["agent"] !== "string") return false;
+  return true;
+}
+function retiredCounterRefusal(v) {
+  if (typeof v !== "object" || v === null) return null;
+  if (!(RETIRED_COUNTER_INPUT in v)) return null;
+  return `\`${RETIRED_COUNTER_INPUT}\` is no longer accepted: a spawn counter supplied by the process being bounded bounds nothing, and an absent one read as zero. The fan-out ceiling is now enforced by the durable per-swarm spawn ledger; remove the field.`;
+}
+function newestHandoff(dir = join7(homedir5(), ".vo", "handoffs")) {
+  try {
+    const entries = readdirSync3(dir).filter((f) => f.endsWith(".md")).map((f) => ({ f, m: statSync4(join7(dir, f)).mtimeMs })).sort((a, b) => b.m - a.m);
+    return entries.length > 0 && entries[0] ? join7(dir, entries[0].f) : null;
+  } catch {
+    return null;
+  }
+}
+var MANDATORY_READS = [
+  "CLAUDE.md + AGENTS.md + README.md (repo root)",
+  "docs/current/virtual-office-agent-charter.md, -operating-model.md, -test-architect.md",
+  "docs/current/evidence-grounded-consensus-testing.md",
+  "docs/vo/ADR-001-* (verify + sign, human approves merge; no autonomous bot-merge / headless triggers) + docs/vo/vo-adr-002-two-plane-moat.md",
+  "docs/vo/vo-roadmap-2026-05-26.md (read the Change log tail for current state)",
+  "the operator memory index ~/.claude/projects/C--Users-greyl/memory/MEMORY.md"
+];
+function buildSuccessorPrompt(handoffMarkdown, goal) {
+  const reads = MANDATORY_READS.map((r, i) => `  ${i + 1}. ${r}`).join("\n");
+  const lines = [
+    "You are the SUCCESSOR agent for an AlgoHQ lane. The previous session",
+    "exhausted its context and wrote the handoff below. Read it fully, verify its",
+    '"verification needed" items against live state (a handoff is a claim, not',
+    "evidence \u2014 verify via `git show origin/main:<path>`), then continue the lane.",
+    "",
+    "MANDATORY READS before writing any code (NOT all auto-loaded \u2014 open them):",
+    reads,
+    "",
+    "NON-NEGOTIABLES: multi-model consensus verification is the core; test honesty",
+    "(verified-answer-only, no fake green); verify-before-act + human merge approval;",
+    "never a full functions-shared deploy; Gen2 only; work in a worktree on your own",
+    "branch; finish line is MERGED + DEPLOYED + LIVE-VERIFIED, and AlgoHQ changes update",
+    "the roadmap in the same PR.",
+    "",
+    "--- HANDOFF ---",
+    handoffMarkdown,
+    "--- END HANDOFF ---"
+  ];
+  if (goal && goal.trim().length > 0) lines.push("", `OPERATOR GOAL OVERRIDE: ${goal.trim()}`);
+  return lines.join("\n");
+}
+async function handleSpawnSuccessor(_deps, rawInput, _signal, spawnImpl = spawn, overrides = {}) {
+  const retired = retiredCounterRefusal(rawInput);
+  if (retired !== null) throw invalidParams(TOOL_NAME21, retired);
+  if (!isToolInput20(rawInput)) {
+    throw invalidParams(TOOL_NAME21, "invalid input. Optional: { handoff_path, goal, cwd, max_turns, agent }.");
+  }
+  const handoffPath = rawInput.handoff_path?.trim() || newestHandoff();
+  if (!handoffPath || !existsSync5(handoffPath)) {
     return jsonContent({
-      tool: TOOL_NAME20,
+      tool: TOOL_NAME21,
       schema_version: 1,
       payload: {
         spawned: false,
@@ -4816,25 +5975,67 @@ async function handleSpawnSuccessor(_deps, rawInput, _signal, spawnImpl = spawn)
       }
     });
   }
-  const handoff = readFileSync6(handoffPath, "utf8").slice(0, MAX_HANDOFF_BYTES);
+  const handoff = readFileSync7(handoffPath, "utf8").slice(0, MAX_HANDOFF_BYTES);
   const prompt = buildSuccessorPrompt(handoff, rawInput.goal);
-  const logDir = process.env["VO_MCP_SUCCESSOR_LOG_DIR"]?.trim() || join6(homedir4(), ".vo", "successors");
-  mkdirSync3(logDir, { recursive: true });
-  const logPath = join6(logDir, `successor-${Date.now()}.log`);
-  const logFd = openSync(logPath, "a");
-  const child = spawnImpl("claude", buildSuccessorArgs(rawInput.max_turns), {
+  const plan = resolveSpawnPlan(process.env, rawInput, (/* @__PURE__ */ new Date()).toISOString());
+  if (!plan.ok) {
+    return jsonContent({
+      tool: TOOL_NAME21,
+      schema_version: 1,
+      payload: {
+        spawned: false,
+        reason: `swarm tier binding refused this spawn: ${plan.reason}`,
+        tier: plan.tier,
+        handoff_path: handoffPath
+      }
+    });
+  }
+  const platform = overrides.platform ?? process.platform;
+  let resolvedBin = plan.bin;
+  if (platform === "win32") {
+    const resolution = resolveNativeWindowsExecutable(plan.bin, process.env, overrides.resolveWindowsExecutable);
+    if (!resolution.ok) {
+      return jsonContent({
+        tool: TOOL_NAME21,
+        schema_version: 1,
+        payload: {
+          spawned: false,
+          reason: resolution.reason,
+          agent: plan.agent,
+          tier: plan.tier,
+          handoff_path: handoffPath
+        }
+      });
+    }
+    resolvedBin = resolution.bin;
+  }
+  const logDir = process.env["VO_MCP_SUCCESSOR_LOG_DIR"]?.trim() || join7(homedir5(), ".vo", "successors");
+  mkdirSync4(logDir, { recursive: true });
+  const logPath = join7(logDir, `successor-${Date.now()}.log`);
+  const logFd = openSync2(logPath, "a");
+  const child = spawnImpl(resolvedBin, [...plan.args], {
     cwd: rawInput.cwd?.trim() || process.cwd(),
     detached: true,
     stdio: ["pipe", logFd, logFd],
-    // Windows: `claude` is a .cmd shim — needs a shell to resolve. The prompt
-    // goes via STDIN below, never argv, so the shell never sees it.
-    shell: process.platform === "win32",
-    windowsHide: true
+    // Never a shell: `resolvedBin` is either the bare platform-neutral name
+    // (POSIX, resolved by the OS via PATH + shebang) or the native win32 exe
+    // resolved above — routing either through cmd.exe/sh is the extra layer
+    // a detached, unref'd child can lose silently (2026-08-16 incident).
+    shell: false,
+    windowsHide: true,
+    windowsVerbatimArguments: false,
+    // Carry the SAME binding to the child. Without this the successor inherits
+    // no tier and re-resolves its own — which is the split-payer defect one
+    // generation down.
+    ...plan.bound ? { env: { ...process.env, ...plan.env } } : {}
   });
+  closeSync2(logFd);
   let spawnError = null;
   child.on("error", (e) => {
     spawnError = e.message;
   });
+  child.stdin.on?.("error", () => {
+  });
   try {
     child.stdin.write(prompt);
     child.stdin.end();
@@ -4842,10 +6043,56 @@ async function handleSpawnSuccessor(_deps, rawInput, _signal, spawnImpl = spawn)
   }
   child.unref();
   await new Promise((r) => setTimeout(r, 150));
+  if (spawnError) {
+    return jsonContent({
+      tool: TOOL_NAME21,
+      schema_version: 1,
+      payload: {
+        spawned: false,
+        reason: `spawn failed: ${spawnError}`,
+        agent: plan.agent,
+        tier: plan.tier,
+        handoff_path: handoffPath
+      }
+    });
+  }
+  const checkLiveness = overrides.checkLiveness ?? ((c, p) => checkSuccessorLiveness(c, p, resolveLivenessConfigFromEnv(process.env, overrides.livenessConfig), overrides.livenessDeps));
+  const liveness = await checkLiveness(child, logPath);
+  if (!liveness.ok) {
+    return jsonContent({
+      tool: TOOL_NAME21,
+      schema_version: 1,
+      payload: {
+        spawned: false,
+        reason: liveness.reason,
+        pid: child.pid ?? null,
+        log_path: logPath,
+        agent: plan.agent,
+        tier: plan.tier,
+        handoff_path: handoffPath
+      }
+    });
+  }
   return jsonContent({
-    tool: TOOL_NAME20,
+    tool: TOOL_NAME21,
     schema_version: 1,
-    payload: spawnError ? { spawned: false, reason: `spawn failed: ${spawnError}`, handoff_path: handoffPath } : { spawned: true, pid: child.pid ?? null, log_path: logPath, handoff_path: handoffPath }
+    payload: {
+      spawned: true,
+      pid: child.pid ?? null,
+      log_path: logPath,
+      handoff_path: handoffPath,
+      agent: plan.agent,
+      tier: plan.tier,
+      tier_bound: plan.bound,
+      ledger_slot: plan.slot,
+      // The debit, surfaced so an operator can reconcile a fan-out's spend
+      // against the pool without reading the ledger directory by hand.
+      ledger_cap_usd: plan.capUsd,
+      ledger_cap_remaining_usd: plan.capRemainingUsd,
+      // Additive (2026-08-17): true only once the child survived the
+      // early-exit window (and the output window, when that gate is enabled).
+      verified_alive: true
+    }
   });
 }
 
@@ -4867,10 +6114,10 @@ function isKnownConciergePack(value) {
 }
 
 // src/tools/concierge/dispatch.ts
-var TOOL_NAME21 = "vo_concierge_dispatch";
-var CALLABLE_NAME10 = "voConciergeDispatch";
+var TOOL_NAME22 = "vo_concierge_dispatch";
+var CALLABLE_NAME11 = "voConciergeDispatch";
 var ADMIN_PATH10 = "/api/v1/admin/concierge/dispatch";
-var inputSchema21 = {
+var inputSchema22 = {
   type: "object",
   properties: {
     pack: {
@@ -4885,7 +6132,7 @@ var inputSchema21 = {
   },
   additionalProperties: false
 };
-var description21 = "Dispatches a provider-scoped knowledge pack (gcp | firebase | aws | cloudflare | vercel | netlify | tax | hybrid). Cross-vendor MCP equivalent of the /vo-concierge Claude-Code slash command. Route explicitly via `pack`, or via tenant.cloud_provider by passing `tenant_id`. Returns the pack's README (`readme_markdown`) + file index. In cloud mode, dispatches via vo-control-plane and returns `verdict: 'pass'` with the pack/directory data; without cloud config, returns `verdict: 'unimplemented'`.";
+var description22 = "Dispatches a provider-scoped knowledge pack (gcp | firebase | aws | cloudflare | vercel | netlify | tax | hybrid). Cross-vendor MCP equivalent of the /vo-concierge Claude-Code slash command. Route explicitly via `pack`, or via tenant.cloud_provider by passing `tenant_id`. Returns the pack's README (`readme_markdown`) + file index. In cloud mode, dispatches via vo-control-plane and returns `verdict: 'pass'` with the pack/directory data; without cloud config, returns `verdict: 'unimplemented'`.";
 function isToolInput21(v) {
   if (typeof v !== "object" || v === null) return false;
   const obj = v;
@@ -4896,13 +6143,13 @@ function isToolInput21(v) {
 async function handleConciergeDispatch(deps, rawInput, _signal) {
   if (!isToolInput21(rawInput)) {
     throw invalidParams(
-      TOOL_NAME21,
+      TOOL_NAME22,
       "invalid input. Expected { pack?: string, tenant_id?: string }."
     );
   }
   if (rawInput.pack !== void 0 && rawInput.pack !== "" && !isKnownConciergePack(rawInput.pack)) {
     throw invalidParams(
-      TOOL_NAME21,
+      TOOL_NAME22,
       `unknown pack: ${JSON.stringify(rawInput.pack)}. Known packs: ${KNOWN_CONCIERGE_PACKS.join(", ")}.`
     );
   }
@@ -4913,8 +6160,8 @@ async function handleConciergeDispatch(deps, rawInput, _signal) {
   if (rawInput.pack) cloudBody.pack = rawInput.pack;
   if (rawInput.tenant_id) cloudBody.tenantId = rawInput.tenant_id;
   return buildCloudOrStubResponse({
-    toolName: TOOL_NAME21,
-    callableName: CALLABLE_NAME10,
+    toolName: TOOL_NAME22,
+    callableName: CALLABLE_NAME11,
     adminPath: ADMIN_PATH10,
     normalizedInput,
     cloudBody,
@@ -4931,70 +6178,294 @@ async function handleConciergeDispatch(deps, rawInput, _signal) {
 }
 
 // src/tools/memory/sync-config.ts
-import { homedir as homedir5 } from "node:os";
-import { join as join7 } from "node:path";
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync3, readdirSync as readdirSync4 } from "node:fs";
+import { existsSync as existsSync9 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { join as join11 } from "node:path";
 
-// src/tools/memory/safe-memory-file.ts
-import { resolve, sep } from "node:path";
-var SAFE_MEMORY_FILE_RE = /^[A-Za-z0-9][A-Za-z0-9._ -]*\.md$/i;
-function isSafeMemoryFileName(fileName) {
-  return fileName.length <= 200 && fileName.trim() === fileName && !fileName.includes("/") && !fileName.includes("\\") && !fileName.includes(":") && SAFE_MEMORY_FILE_RE.test(fileName);
+// src/tools/memory/memory-sync-http.ts
+init_safe_memory_file();
+import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync6, readdirSync as readdirSync4 } from "node:fs";
+
+// src/tools/memory/sync-lock.ts
+import { closeSync as closeSync3, mkdirSync as mkdirSync5, openSync as openSync3, readFileSync as readFileSync9, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { hostname } from "node:os";
+import { join as join8 } from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// src/tools/memory/sync-lock-liveness.ts
+import { statSync as statSync5, readFileSync as readFileSync8 } from "node:fs";
+function defaultIsProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
 }
-function resolveMemoryFilePath(memoryDir, fileName) {
-  if (!isSafeMemoryFileName(fileName)) {
-    throw new Error(`unsafe memory file_name: ${fileName.slice(0, 80)}`);
+function toPayload(parsed) {
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+  const record = parsed;
+  const token = record["token"];
+  const host = record["hostname"];
+  if (typeof token !== "string" || token.length === 0) return null;
+  const pid = record["pid"];
+  const acquiredAtMs = record["acquiredAtMs"];
+  return {
+    pid: typeof pid === "number" && Number.isInteger(pid) && pid > 0 ? pid : 0,
+    hostname: typeof host === "string" ? host : "",
+    sessionId: typeof record["sessionId"] === "string" ? record["sessionId"] : null,
+    token,
+    acquiredAt: typeof record["acquiredAt"] === "string" ? record["acquiredAt"] : "",
+    acquiredAtMs: typeof acquiredAtMs === "number" && Number.isFinite(acquiredAtMs) ? acquiredAtMs : Number.NaN
+  };
+}
+function readLockRecord(path4) {
+  let raw;
+  try {
+    raw = readFileSync8(path4, "utf8");
+  } catch {
+    return null;
   }
-  const root = resolve(memoryDir);
-  const filePath = resolve(root, fileName);
-  const rootPrefix = root.endsWith(sep) ? root : `${root}${sep}`;
-  if (filePath !== root && !filePath.startsWith(rootPrefix)) {
-    throw new Error(`memory file path escapes memory directory: ${fileName.slice(0, 80)}`);
+  try {
+    return { raw, payload: toPayload(JSON.parse(raw)) };
+  } catch {
+    return { raw, payload: null };
   }
-  return filePath;
+}
+function lockAgeMs(record, path4, nowMs) {
+  let startedMs = Number.NaN;
+  if (record.payload) {
+    if (Number.isFinite(record.payload.acquiredAtMs)) {
+      startedMs = record.payload.acquiredAtMs;
+    } else if (record.payload.acquiredAt) {
+      startedMs = Date.parse(record.payload.acquiredAt);
+    }
+  }
+  if (!Number.isFinite(startedMs)) {
+    try {
+      startedMs = statSync5(path4).mtimeMs;
+    } catch {
+      return null;
+    }
+  }
+  const age = nowMs - startedMs;
+  return Number.isFinite(age) && age >= 0 ? age : null;
+}
+function classifyHolderLiveness(record, isProcessAlive, thisHost) {
+  const payload = record.payload;
+  if (payload === null) return "unknown";
+  if (payload.pid <= 0) return "unknown";
+  if (thisHost.length === 0) return "unknown";
+  if (payload.hostname !== thisHost) return "unknown";
+  return isProcessAlive(payload.pid) ? "alive" : "dead";
+}
+function isLockAbandoned(record, ageMs, ttlMs, isProcessAlive, thisHost) {
+  const liveness = classifyHolderLiveness(record, isProcessAlive, thisHost);
+  if (liveness === "alive") return false;
+  if (liveness === "dead") return true;
+  return ageMs !== null && ageMs > ttlMs;
 }
 
-// src/tools/memory/sync-config.ts
-var TOOL_NAME22 = "vo_sync_config";
-var inputSchema22 = {
-  type: "object",
-  properties: {
-    action: {
-      type: "string",
-      enum: ["pull", "push"],
-      description: "pull: download cloud memory to local files. push: upload local files to cloud."
-    },
-    cwd: {
-      type: "string",
-      description: "Working directory to derive project slug from (default: process.cwd())."
+// src/tools/memory/sync-lock.ts
+var MEMORY_SYNC_LOCK_FILE = ".memory-sync.lock";
+var DEFAULT_LOCK_TTL_MS = 15 * 6e4;
+var DEFAULT_LOCK_WAIT_MS = 1e4;
+var INITIAL_BACKOFF_MS = 25;
+var MAX_BACKOFF_MS = 500;
+var BACKOFF_FACTOR = 1.6;
+function positiveOr(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function createExclusive2(path4, contents) {
+  let fd;
+  try {
+    fd = openSync3(path4, "wx");
+  } catch (err) {
+    const code = err.code;
+    return { ok: false, exists: code === "EEXIST", message: err instanceof Error ? err.message : String(err) };
+  }
+  try {
+    writeFileSync4(fd, contents, "utf8");
+  } catch (err) {
+    closeSync3(fd);
+    try {
+      unlinkSync2(path4);
+    } catch {
     }
-  },
-  required: ["action"],
-  additionalProperties: false
-};
-var description22 = "Syncs memory entries between local ~/.claude/projects/<slug>/memory/ and cloud control-plane /api/v1/agent-config/memory/me. Requires operator auth (vo-mcp login). Actions: pull (cloud\u2192local), push (local\u2192cloud). Idempotent; push creates/updates as needed.";
-function isToolInput22(v) {
-  if (typeof v !== "object" || v === null) return false;
-  const o = v;
-  if (o["action"] !== "pull" && o["action"] !== "push") return false;
-  if (o["cwd"] !== void 0 && typeof o["cwd"] !== "string") return false;
-  return true;
+    return { ok: false, exists: false, message: err instanceof Error ? err.message : String(err) };
+  }
+  closeSync3(fd);
+  return { ok: true };
 }
-function deriveProjectSlug(cwd) {
-  return cwd.replace(/\\/g, "/").replace(/\/+$/g, "").replace(/^([a-zA-Z]):/, (_m, drive) => `${drive.toUpperCase()}:`).replace(/[^a-zA-Z0-9]/g, "-");
+function removeAbandoned(path4, expectedRaw) {
+  let current;
+  try {
+    current = readFileSync9(path4, "utf8");
+  } catch {
+    return;
+  }
+  if (current !== expectedRaw) return;
+  try {
+    unlinkSync2(path4);
+  } catch {
+  }
 }
-function getMemoryDir(cwd) {
-  const slug = deriveProjectSlug(cwd);
-  return join7(homedir5(), ".claude", "projects", slug, "memory");
+function makeRelease(path4, token) {
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    let raw;
+    try {
+      raw = readFileSync9(path4, "utf8");
+    } catch {
+      return;
+    }
+    let stillOurs;
+    try {
+      stillOurs = toPayload(JSON.parse(raw))?.token === token;
+    } catch {
+      stillOurs = false;
+    }
+    if (!stillOurs) return;
+    try {
+      unlinkSync2(path4);
+    } catch {
+    }
+  };
+}
+function describeHolder(record) {
+  const payload = record?.payload;
+  if (!payload) return "an unreadable lock file";
+  return `pid ${payload.pid} on ${payload.hostname || "(unknown host)"} (session ${payload.sessionId ?? "unknown"}, held since ${payload.acquiredAt || "unknown"})`;
+}
+async function acquireMemorySyncLock(options) {
+  const waitMs = positiveOr(options.waitMs, DEFAULT_LOCK_WAIT_MS);
+  const ttlMs = positiveOr(options.ttlMs, DEFAULT_LOCK_TTL_MS);
+  const now = options.now ?? Date.now;
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve3) => {
+    setTimeout(resolve3, ms);
+  }));
+  const isProcessAlive = options.isProcessAlive ?? defaultIsProcessAlive;
+  const thisHost = hostname();
+  const path4 = join8(options.memoryDir, MEMORY_SYNC_LOCK_FILE);
+  if (options.createDir === true) mkdirSync5(options.memoryDir, { recursive: true });
+  const deadline = now() + waitMs;
+  let backoffMs = INITIAL_BACKOFF_MS;
+  let tookOverFrom = null;
+  let holderDescription = "another session";
+  for (; ; ) {
+    const acquiredAtMs = now();
+    const payload = {
+      pid: process.pid,
+      hostname: thisHost,
+      sessionId: options.sessionId ?? null,
+      token: randomUUID2(),
+      acquiredAt: new Date(acquiredAtMs).toISOString(),
+      acquiredAtMs
+    };
+    const created = createExclusive2(path4, `${JSON.stringify(payload, null, 2)}
+`);
+    if (created.ok) {
+      return { path: path4, payload, tookOverFrom, release: makeRelease(path4, payload.token) };
+    }
+    if (!created.exists) {
+      throw new Error(
+        `memory sync lock ${path4} could not be created (${created.message}) \u2014 refusing to sync without exclusion`
+      );
+    }
+    const record = readLockRecord(path4);
+    let reclaimed = false;
+    if (record) {
+      holderDescription = describeHolder(record);
+      const age = lockAgeMs(record, path4, now());
+      if (isLockAbandoned(record, age, ttlMs, isProcessAlive, thisHost)) {
+        tookOverFrom = record.payload;
+        removeAbandoned(path4, record.raw);
+        reclaimed = true;
+      }
+    }
+    if (now() >= deadline) {
+      throw new Error(
+        `memory sync lock ${path4} is held by ${holderDescription}; waited ${waitMs}ms \u2014 refusing to sync unlocked (concurrent memory writes corrupt the shared index). If that holder is provably gone, delete the lock file.`
+      );
+    }
+    if (reclaimed) backoffMs = INITIAL_BACKOFF_MS;
+    await sleep(Math.max(1, Math.min(backoffMs, deadline - now())));
+    if (!reclaimed) backoffMs = Math.min(MAX_BACKOFF_MS, Math.ceil(backoffMs * BACKOFF_FACTOR));
+  }
+}
+async function withMemorySyncLock(options, fn) {
+  const handle = await acquireMemorySyncLock(options);
+  try {
+    return await fn(handle);
+  } finally {
+    handle.release();
+  }
 }
+
+// src/tools/memory/memory-index-merge.ts
+var MEMORY_INDEX_FILE = "MEMORY.md";
+function isMemoryIndexFile(fileName) {
+  return fileName.toUpperCase() === MEMORY_INDEX_FILE.toUpperCase();
+}
+var INDEX_ROW_RE = /^\s*[-*]\s+\[[^\]]*\]\(([^)]+)\)/;
+function indexRowKey(line) {
+  const match = INDEX_ROW_RE.exec(line);
+  if (!match) return null;
+  let target = match[1].trim();
+  if (target.startsWith("<") && target.endsWith(">")) target = target.slice(1, -1).trim();
+  target = target.replace(/\s+(["'])[\s\S]*\1$/, "").trim();
+  if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(target)) {
+    target = target.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
+    target = target.replace(/^(?:\.\/)+/, "");
+  }
+  return target.length > 0 ? target.toLowerCase() : null;
+}
+function mergeMemoryIndex(localContent, cloudContent) {
+  if (typeof cloudContent !== "string" || cloudContent.trim().length === 0) {
+    return { content: localContent, addedFromCloud: [] };
+  }
+  const eol = localContent.includes("\r\n") ? "\r\n" : "\n";
+  const localLines = localContent.split(/\r?\n/);
+  const localKeys = /* @__PURE__ */ new Set();
+  let lastLocalRowIndex = -1;
+  for (let i = 0; i < localLines.length; i++) {
+    const key = indexRowKey(localLines[i]);
+    if (key === null) continue;
+    localKeys.add(key);
+    lastLocalRowIndex = i;
+  }
+  const addedFromCloud = [];
+  const seenCloudKeys = /* @__PURE__ */ new Set();
+  for (const rawLine of cloudContent.split(/\r?\n/)) {
+    const key = indexRowKey(rawLine);
+    if (key === null) continue;
+    if (localKeys.has(key) || seenCloudKeys.has(key)) continue;
+    seenCloudKeys.add(key);
+    addedFromCloud.push(rawLine.replace(/\r$/, ""));
+  }
+  if (addedFromCloud.length === 0) {
+    return { content: localContent, addedFromCloud: [] };
+  }
+  const merged = lastLocalRowIndex >= 0 ? [...localLines.slice(0, lastLocalRowIndex + 1), ...addedFromCloud, ...localLines.slice(lastLocalRowIndex + 1)] : [...localLines, ...addedFromCloud];
+  return { content: merged.join(eol), addedFromCloud };
+}
+
+// src/tools/memory/memory-sync-http.ts
+init_bounded_sync();
+init_memory_push_cache();
 async function pullMemory(controlPlaneUrl, token, memoryDir, fetchFn) {
   const url = `${controlPlaneUrl}/api/v1/agent-config/memory/me`;
-  const response = await fetchFn(url, {
-    method: "GET",
-    headers: {
-      authorization: `Bearer ${token}`
-    }
-  });
+  const response = await withRequestTimeout(
+    url,
+    () => fetchFn(url, {
+      method: "GET",
+      headers: {
+        authorization: `Bearer ${token}`
+      }
+    })
+  );
   if (response.status !== 200) {
     const text = await response.text();
     throw new Error(`GET /api/v1/agent-config/memory/me returned HTTP ${response.status}: ${text.slice(0, 200)}`);
@@ -5007,103 +6478,246 @@ async function pullMemory(controlPlaneUrl, token, memoryDir, fetchFn) {
     entry,
     filePath: resolveMemoryFilePath(memoryDir, entry.file_name)
   }));
-  mkdirSync4(memoryDir, { recursive: true });
+  mkdirSync6(memoryDir, { recursive: true });
   const files = [];
   for (const { entry, filePath } of writes) {
-    writeFileSync3(filePath, entry.content, "utf8");
+    writeFileSync6(filePath, entry.content, "utf8");
     files.push(entry.file_name);
   }
   return { pulled: data.entries.length, files };
 }
-async function pushMemory(controlPlaneUrl, token, memoryDir, sessionId, fetchFn) {
-  if (!existsSync5(memoryDir)) {
-    return { pushed: 0, created: 0, updated: 0 };
+function listPushableFiles(memoryDir) {
+  return readdirSync4(memoryDir).filter((f) => f.endsWith(".md") && f !== MEMORY_SYNC_LOCK_FILE);
+}
+async function uploadOne(item, controlPlaneUrl, token, sessionId, fetchFn, deadline) {
+  deadline.check();
+  if (item.memoryId !== null) {
+    const updateUrl = `${controlPlaneUrl}/api/v1/agent-config/memory/${item.memoryId}`;
+    const updateBody = { content: item.content, session_id: sessionId };
+    const updateResponse = await withRequestTimeout(
+      updateUrl,
+      () => fetchFn(updateUrl, {
+        method: "PUT",
+        headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+        body: JSON.stringify(updateBody)
+      })
+    );
+    if (updateResponse.status !== 200) {
+      const text = await updateResponse.text();
+      throw new Error(
+        `PUT /api/v1/agent-config/memory/${item.memoryId} returned HTTP ${updateResponse.status}: ${text.slice(0, 200)}`
+      );
+    }
+    const updateData = JSON.parse(await updateResponse.text());
+    if (!updateData.ok) throw new Error(`PUT /api/v1/agent-config/memory/${item.memoryId} returned ok=false`);
+    return "updated";
+  }
+  const createUrl = `${controlPlaneUrl}/api/v1/agent-config/memory/me`;
+  const createBody = {
+    entry_type: item.entryType,
+    file_name: item.fileName,
+    content: item.content,
+    session_id: sessionId
+  };
+  const createResponse = await withRequestTimeout(
+    createUrl,
+    () => fetchFn(createUrl, {
+      method: "POST",
+      headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+      body: JSON.stringify(createBody)
+    })
+  );
+  if (createResponse.status !== 200 && createResponse.status !== 201) {
+    const text = await createResponse.text();
+    throw new Error(
+      `POST /api/v1/agent-config/memory/me returned HTTP ${createResponse.status}: ${text.slice(0, 200)}`
+    );
+  }
+  const createData = JSON.parse(await createResponse.text());
+  if (!createData.ok) throw new Error("POST /api/v1/agent-config/memory/me returned ok=false");
+  return "created";
+}
+async function pushMemory(controlPlaneUrl, token, memoryDir, sessionId, fetchFn, options = {}) {
+  const empty = { pushed: 0, created: 0, updated: 0, skipped: 0, indexRowsPreserved: 0 };
+  if (!existsSync6(memoryDir)) {
+    return empty;
   }
-  const localFiles = readdirSync4(memoryDir).filter((f) => f.endsWith(".md")).map((f) => ({
+  const localFiles = listPushableFiles(memoryDir).map((f) => ({
     file_name: f,
-    content: readFileSync7(resolveMemoryFilePath(memoryDir, f), "utf8"),
-    entry_type: f === "MEMORY.md" ? "index" : "topic"
+    content: readFileSync11(resolveMemoryFilePath(memoryDir, f), "utf8"),
+    entry_type: isMemoryIndexFile(f) ? "index" : "topic"
   }));
   if (localFiles.length === 0) {
-    return { pushed: 0, created: 0, updated: 0 };
+    return empty;
   }
+  const deadline = options.deadline ?? createSyncDeadline();
+  const cache = options.cache ?? readPushCache(memoryDir, controlPlaneUrl);
+  deadline.check();
   const getUrl = `${controlPlaneUrl}/api/v1/agent-config/memory/me`;
-  const getResponse = await fetchFn(getUrl, {
-    method: "GET",
-    headers: {
-      authorization: `Bearer ${token}`
-    }
-  });
+  const getResponse = await withRequestTimeout(
+    getUrl,
+    () => fetchFn(getUrl, { method: "GET", headers: { authorization: `Bearer ${token}` } })
+  );
   const existingMap = /* @__PURE__ */ new Map();
   if (getResponse.status === 200) {
     const getData = JSON.parse(await getResponse.text());
     if (getData.ok && Array.isArray(getData.entries)) {
       for (const entry of getData.entries) {
-        existingMap.set(entry.file_name, entry.memory_id);
+        existingMap.set(entry.file_name, {
+          memoryId: entry.memory_id,
+          content: typeof entry.content === "string" ? entry.content : ""
+        });
       }
     }
   }
+  const toUpload = [];
+  let skipped = 0;
+  for (const localFile of localFiles) {
+    const existing = existingMap.get(localFile.file_name);
+    let content = localFile.content;
+    let rowsPreserved = 0;
+    if (localFile.entry_type === "index") {
+      const merged = mergeMemoryIndex(localFile.content, existing?.content);
+      content = merged.content;
+      rowsPreserved = merged.addedFromCloud.length;
+    }
+    const payloadHash = sha256(content);
+    if (!needsMemoryPush(cache, localFile.file_name, payloadHash, existing !== void 0)) {
+      skipped++;
+      continue;
+    }
+    toUpload.push({
+      fileName: localFile.file_name,
+      entryType: localFile.entry_type,
+      content,
+      payloadHash,
+      memoryId: existing?.memoryId ?? null,
+      rowsPreserved
+    });
+  }
+  const outcomes = await mapWithConcurrency(
+    toUpload,
+    options.concurrency ?? PUSH_CONCURRENCY,
+    (item) => uploadOne(item, controlPlaneUrl, token, sessionId, fetchFn, deadline)
+  );
   let created = 0;
   let updated = 0;
-  for (const localFile of localFiles) {
-    const memoryId = existingMap.get(localFile.file_name);
-    if (memoryId) {
-      const updateUrl = `${controlPlaneUrl}/api/v1/agent-config/memory/${memoryId}`;
-      const updateBody = {
-        content: localFile.content,
-        session_id: sessionId
-      };
-      const updateResponse = await fetchFn(updateUrl, {
-        method: "PUT",
-        headers: {
-          authorization: `Bearer ${token}`,
-          "content-type": "application/json"
-        },
-        body: JSON.stringify(updateBody)
-      });
-      if (updateResponse.status !== 200) {
-        const text = await updateResponse.text();
-        throw new Error(
-          `PUT /api/v1/agent-config/memory/${memoryId} returned HTTP ${updateResponse.status}: ${text.slice(0, 200)}`
-        );
-      }
-      const updateData = JSON.parse(await updateResponse.text());
-      if (!updateData.ok) {
-        throw new Error(`PUT /api/v1/agent-config/memory/${memoryId} returned ok=false`);
-      }
-      updated++;
-    } else {
-      const createUrl = `${controlPlaneUrl}/api/v1/agent-config/memory/me`;
-      const createBody = {
-        entry_type: localFile.entry_type,
-        file_name: localFile.file_name,
-        content: localFile.content,
-        session_id: sessionId
-      };
-      const createResponse = await fetchFn(createUrl, {
-        method: "POST",
-        headers: {
-          authorization: `Bearer ${token}`,
-          "content-type": "application/json"
-        },
-        body: JSON.stringify(createBody)
-      });
-      if (createResponse.status !== 200 && createResponse.status !== 201) {
-        const text = await createResponse.text();
-        throw new Error(
-          `POST /api/v1/agent-config/memory/me returned HTTP ${createResponse.status}: ${text.slice(0, 200)}`
-        );
-      }
-      const createData = JSON.parse(await createResponse.text());
-      if (!createData.ok) {
-        throw new Error("POST /api/v1/agent-config/memory/me returned ok=false");
-      }
-      created++;
+  let indexRowsPreserved = 0;
+  let firstError;
+  for (let i = 0; i < outcomes.length; i++) {
+    const outcome = outcomes[i];
+    const item = toUpload[i];
+    if (outcome.ok) {
+      if (outcome.value === "created") created++;
+      else updated++;
+      indexRowsPreserved += item.rowsPreserved;
+      recordMemoryPush(cache, item.fileName, item.payloadHash);
+    } else if (firstError === void 0) {
+      firstError = outcome.error;
+    }
+  }
+  pruneMissing(cache, localFiles.map((f) => f.file_name));
+  if (options.persistCache ?? options.cache === void 0) writePushCache(memoryDir, cache);
+  if (firstError !== void 0) throw firstError;
+  return { pushed: created + updated, created, updated, skipped, indexRowsPreserved };
+}
+
+// src/tools/memory/sync-config.ts
+init_bounded_sync();
+init_memory_push_cache();
+
+// src/tools/memory/sync-kill-switch.ts
+import { existsSync as existsSync7, readFileSync as readFileSync12 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { join as join10 } from "node:path";
+var MEMORY_SYNC_DISABLE_ENV = "VO_MCP_DISABLE_MEMORY_SYNC";
+var MEMORY_SYNC_DISABLE_SENTINEL = "vo-memory-sync-disabled";
+var NEGATIONS = /* @__PURE__ */ new Set(["0", "false", "no"]);
+var MAX_LOGGED_VALUE = 32;
+function memorySyncSentinelPath(home) {
+  return join10(home, ".claude", MEMORY_SYNC_DISABLE_SENTINEL);
+}
+function isKillSwitchValueOn(raw) {
+  if (raw === void 0 || raw === null) return false;
+  const v = raw.trim().toLowerCase();
+  if (v === "") return false;
+  return !NEGATIONS.has(v);
+}
+function clip(raw) {
+  const v = raw.trim();
+  return v.length > MAX_LOGGED_VALUE ? `${v.slice(0, MAX_LOGGED_VALUE)}\u2026` : v;
+}
+function evaluateMemorySyncKillSwitch(deps = {}) {
+  const env = deps.env ?? process.env;
+  const home = deps.home ?? homedir6();
+  const fileExists = deps.fileExists ?? existsSync7;
+  const readFile3 = deps.readFile ?? ((p) => readFileSync12(p, "utf8"));
+  const fired = [];
+  const rawEnv = env[MEMORY_SYNC_DISABLE_ENV];
+  if (isKillSwitchValueOn(rawEnv)) {
+    fired.push(`env ${MEMORY_SYNC_DISABLE_ENV}=${clip(rawEnv)}`);
+  }
+  const sentinel = memorySyncSentinelPath(home);
+  let sentinelPresent;
+  try {
+    sentinelPresent = fileExists(sentinel);
+  } catch {
+    sentinelPresent = false;
+  }
+  if (sentinelPresent) {
+    let contents = "";
+    let readable = true;
+    try {
+      contents = readFile3(sentinel);
+    } catch {
+      readable = false;
+    }
+    if (!readable || isKillSwitchValueOn(contents) || contents.trim() === "") {
+      fired.push(`sentinel file ${sentinel}`);
     }
   }
-  return { pushed: localFiles.length, created, updated };
+  if (fired.length === 0) return { disabled: false, reason: null };
+  return { disabled: true, reason: `memory sync DISABLED by ${fired.join(" + ")}` };
+}
+
+// src/tools/memory/sync-config.ts
+var TOOL_NAME23 = "vo_sync_config";
+var inputSchema23 = {
+  type: "object",
+  properties: {
+    action: {
+      type: "string",
+      enum: ["pull", "push"],
+      description: "pull: download cloud memory to local files. push: upload local files to cloud."
+    },
+    cwd: {
+      type: "string",
+      description: "Working directory to derive project slug from (default: process.cwd())."
+    }
+  },
+  required: ["action"],
+  additionalProperties: false
+};
+var description23 = "Syncs memory entries between local ~/.claude/projects/<slug>/memory/ and cloud control-plane /api/v1/agent-config/memory/me. Requires operator auth (vo-mcp login). Actions: pull (cloud\u2192local), push (local\u2192cloud). Idempotent; push creates/updates as needed. Serialized across concurrent sessions by an exclusive lock in the memory dir.";
+function isToolInput22(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const o = v;
+  if (o["action"] !== "pull" && o["action"] !== "push") return false;
+  if (o["cwd"] !== void 0 && typeof o["cwd"] !== "string") return false;
+  return true;
+}
+function deriveProjectSlug(cwd) {
+  return cwd.replace(/([^:\\/])[\\/]+$/, "$1").replace(/\\/g, "/").replace(/^([a-zA-Z]):/, (_m, drive) => `${drive.toUpperCase()}:`).replace(/[^a-zA-Z0-9]/g, "-");
 }
-async function runMemorySync(action, cwd, sessionId, fetchFn = globalThis.fetch) {
+function getMemoryDir(cwd) {
+  const slug = deriveProjectSlug(cwd);
+  return join11(homedir7(), ".claude", "projects", slug, "memory");
+}
+async function runMemorySync(action, cwd, sessionId, fetchFn = globalThis.fetch, lockOptions = {}) {
+  const killSwitch = evaluateMemorySyncKillSwitch();
+  if (killSwitch.disabled) {
+    return { synced: false, reason: killSwitch.reason };
+  }
   const controlPlaneUrl = process.env["VO_CONTROL_PLANE_URL"];
   if (!controlPlaneUrl) {
     return { synced: false, reason: "VO_CONTROL_PLANE_URL not set \u2014 cloud mode disabled" };
@@ -5120,20 +6734,79 @@ async function runMemorySync(action, cwd, sessionId, fetchFn = globalThis.fetch)
   }
   const memoryDir = getMemoryDir(cwd);
   const baseUrl = controlPlaneUrl.replace(/\/+$/, "");
-  try {
-    if (action === "pull") {
-      const result2 = await pullMemory(baseUrl, token, memoryDir, fetchFn);
-      return { synced: true, action: "pull", pulled: result2.pulled, files: result2.files, memory_dir: memoryDir };
-    }
-    const result = await pushMemory(baseUrl, token, memoryDir, sessionId, fetchFn);
+  if (action === "push" && !existsSync9(memoryDir)) {
     return {
       synced: true,
       action: "push",
-      pushed: result.pushed,
-      created: result.created,
-      updated: result.updated,
+      pushed: 0,
+      created: 0,
+      updated: 0,
+      skipped: 0,
+      index_rows_preserved: 0,
+      knowledge_upserted: 0,
+      knowledge_failed: 0,
       memory_dir: memoryDir
     };
+  }
+  try {
+    return await withMemorySyncLock({ ...lockOptions, memoryDir, sessionId, createDir: action === "pull" }, async (lock) => {
+      const takeover = lock.tookOverFrom ? { lock_taken_over_from_pid: lock.tookOverFrom.pid } : {};
+      if (action === "pull") {
+        const result2 = await pullMemory(baseUrl, token, memoryDir, fetchFn);
+        return {
+          synced: true,
+          action: "pull",
+          pulled: result2.pulled,
+          files: result2.files,
+          memory_dir: memoryDir,
+          ...takeover
+        };
+      }
+      const deadline = createSyncDeadline();
+      const cache = readPushCache(memoryDir, baseUrl);
+      let result;
+      try {
+        result = await pushMemory(baseUrl, token, memoryDir, sessionId, fetchFn, { cache, deadline });
+      } catch (err) {
+        writePushCache(memoryDir, cache);
+        throw err;
+      }
+      let bridge;
+      try {
+        const { upsertMemoryFilesAsKnowledge: upsertMemoryFilesAsKnowledge2 } = await Promise.resolve().then(() => (init_memory_knowledge_bridge(), memory_knowledge_bridge_exports));
+        bridge = await upsertMemoryFilesAsKnowledge2({
+          controlPlaneUrl: baseUrl,
+          token,
+          memoryDir,
+          fetchFn,
+          cache,
+          deadline
+        });
+      } catch (err) {
+        bridge = {
+          upserted: 0,
+          failed: 1,
+          skipped: 0,
+          failures: [`bridge unavailable: ${err instanceof Error ? err.message : String(err)}`]
+        };
+      }
+      writePushCache(memoryDir, cache);
+      return {
+        synced: true,
+        action: "push",
+        pushed: result.pushed,
+        created: result.created,
+        updated: result.updated,
+        skipped: result.skipped,
+        index_rows_preserved: result.indexRowsPreserved,
+        memory_dir: memoryDir,
+        knowledge_upserted: bridge.upserted,
+        knowledge_failed: bridge.failed,
+        knowledge_skipped: bridge.skipped,
+        ...bridge.failed > 0 ? { knowledge_failures: bridge.failures } : {},
+        ...takeover
+      };
+    });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     return { synced: false, reason: `Sync failed: ${message}` };
@@ -5142,18 +6815,20 @@ async function runMemorySync(action, cwd, sessionId, fetchFn = globalThis.fetch)
 async function handleSyncConfig(deps, rawInput, _signal, fetchFn = globalThis.fetch) {
   if (!isToolInput22(rawInput)) {
     throw invalidParams(
-      TOOL_NAME22,
+      TOOL_NAME23,
       'invalid input. Required: { action: "pull" | "push" }. Optional: { cwd: "<path>" }.'
     );
   }
   const cwd = rawInput.cwd?.trim() || process.cwd();
   const result = await runMemorySync(rawInput.action, cwd, deps.session.sessionId, fetchFn);
-  return jsonContent({ tool: TOOL_NAME22, schema_version: 1, payload: result });
+  return jsonContent({ tool: TOOL_NAME23, schema_version: 1, payload: result });
 }
 
 // src/tools/memory/private-knowledge.ts
 var UPSERT_TOOL_NAME = "vo_private_knowledge_upsert";
 var CONTEXT_TOOL_NAME = "vo_private_knowledge_context";
+var INVALIDATE_TOOL_NAME = "vo_private_knowledge_invalidate";
+var STALE_TOOL_NAME = "vo_private_knowledge_stale";
 var KNOWLEDGE_CLASSES = ["memory", "skill", "doctrine", "hook", "command"];
 var PRECISION_CHAR_BUDGET = 12e3;
 var upsertInputSchema = {
@@ -5177,8 +6852,35 @@ var contextInputSchema = {
   required: ["query"],
   additionalProperties: false
 };
+var invalidateInputSchema = {
+  type: "object",
+  properties: {
+    knowledge_class: { type: "string", enum: KNOWLEDGE_CLASSES },
+    source_path: { type: "string", minLength: 1, maxLength: 400, description: "Stable private source identifier of the entry to invalidate \u2014 must match the source_path used at upsert." }
+  },
+  required: ["knowledge_class", "source_path"],
+  additionalProperties: false
+};
+var staleInputSchema = {
+  type: "object",
+  properties: {
+    days: { type: "number", minimum: 1, maximum: 3650, description: "Window in days (default 90): entries at least this old that were never recalled into an agent context, or not within the window." },
+    limit: { type: "number", minimum: 1, maximum: 500 }
+  },
+  additionalProperties: false
+};
+var staleDescription = `The FORGETTING REPORT: lists the authenticated operator\u2019s live private-knowledge entries that are at least N days old and have never been recalled into an agent context (or not within N days). Metadata only. SURFACES ONLY \u2014 never auto-invalidates or auto-merges: two memories that disagree may both have been right in different contexts, so you decide. Act on a candidate deliberately with ${INVALIDATE_TOOL_NAME}; recall counts come from ${CONTEXT_TOOL_NAME} reads that actually placed the entry into returned context.`;
 var upsertDescription = "Uploads or refreshes the authenticated operator\u2019s private cloud knowledge. Works for Claude, Codex, Cursor, and cowork clients via the same vo-mcp login credential. Returns metadata only, not raw stored content. PRECISION DISCIPLINE: keep each entry tight and focused (~1-3 pages) with a descriptive retrieval-friendly title \u2014 retrieval surfaces whole entries, so small dense entries beat bulk dumps. Split large corpora into focused entries, then run a retrieval self-test via vo_private_knowledge_context before relying on the knowledge.";
 var contextDescription = "Retrieves prompt-ready private knowledge context for the authenticated operator. Returns snippets/context only; no raw corpus download. Also the retrieval self-test surface: after upserting critical knowledge, query for it here and confirm the entry surfaces before trusting it in downstream work.";
+var invalidateDescription = `Soft-deletes one private-knowledge entry for the authenticated operator: closes the live entry\u2019s validity window (bi-temporal) so it stops surfacing in retrieval. Never destroys data \u2014 invalidated versions remain queryable server-side via include_invalidated. Identify the entry by the same { knowledge_class, source_path } used at upsert; a not_found response means no live entry matches. After invalidating, self-test via ${CONTEXT_TOOL_NAME} to confirm the entry no longer surfaces.`;
+function isStaleInput(value) {
+  if (value === void 0 || value === null) return true;
+  if (typeof value !== "object") return false;
+  const input = value;
+  if (input["days"] !== void 0 && typeof input["days"] !== "number") return false;
+  if (input["limit"] !== void 0 && typeof input["limit"] !== "number") return false;
+  return true;
+}
 function isKnowledgeClass(value) {
   return typeof value === "string" && KNOWLEDGE_CLASSES.includes(value);
 }
@@ -5187,6 +6889,11 @@ function isUpsertInput(value) {
   const input = value;
   return isKnowledgeClass(input["knowledge_class"]) && typeof input["source_path"] === "string" && typeof input["title"] === "string" && typeof input["content"] === "string";
 }
+function isInvalidateInput(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const input = value;
+  return isKnowledgeClass(input["knowledge_class"]) && typeof input["source_path"] === "string";
+}
 function isContextInput(value) {
   if (typeof value !== "object" || value === null) return false;
   const input = value;
@@ -5208,10 +6915,10 @@ async function getCloudAuth(fetchFn) {
   if (!token) return { ok: false, reason: "Failed to obtain auth token. Run `vo-mcp login` again." };
   return { ok: true, controlPlaneUrl, token };
 }
-async function callPrivateKnowledge(path3, body, fetchFn) {
+async function callPrivateKnowledge(path4, body, fetchFn) {
   const auth = await getCloudAuth(fetchFn);
   if (!auth.ok) return { ok: false, reason: auth.reason };
-  const response = await fetchFn(`${auth.controlPlaneUrl}${path3}`, {
+  const response = await fetchFn(`${auth.controlPlaneUrl}${path4}`, {
     method: "POST",
     headers: {
       authorization: `Bearer ${auth.token}`,
@@ -5220,7 +6927,12 @@ async function callPrivateKnowledge(path3, body, fetchFn) {
     body: JSON.stringify(body)
   });
   const text = await response.text();
-  const parsed = text ? JSON.parse(text) : null;
+  let parsed;
+  try {
+    parsed = text ? JSON.parse(text) : null;
+  } catch {
+    parsed = null;
+  }
   if (response.status < 200 || response.status >= 300) {
     return { ok: false, status: response.status, response: parsed ?? text };
   }
@@ -5241,6 +6953,37 @@ async function handlePrivateKnowledgeUpsert(_deps, rawInput, _signal, fetchFn =
   }
   return jsonContent(envelope);
 }
+async function handlePrivateKnowledgeInvalidate(_deps, rawInput, _signal, fetchFn = globalThis.fetch) {
+  if (!isInvalidateInput(rawInput)) {
+    throw invalidParams(INVALIDATE_TOOL_NAME, "expected { knowledge_class, source_path }.");
+  }
+  const payload = await callPrivateKnowledge("/api/v1/knowledge/private/invalidate", rawInput, fetchFn);
+  return jsonContent({ tool: INVALIDATE_TOOL_NAME, schema_version: 1, payload });
+}
+async function handlePrivateKnowledgeStale(_deps, rawInput, _signal, fetchFn = globalThis.fetch) {
+  if (!isStaleInput(rawInput)) {
+    throw invalidParams(STALE_TOOL_NAME, "expected { optional days, optional limit }.");
+  }
+  const auth = await getCloudAuth(fetchFn);
+  if (!auth.ok) return jsonContent({ tool: STALE_TOOL_NAME, schema_version: 1, payload: { ok: false, reason: auth.reason } });
+  const params = new URLSearchParams();
+  if (rawInput?.days !== void 0) params.set("days", String(Math.trunc(rawInput.days)));
+  if (rawInput?.limit !== void 0) params.set("limit", String(Math.trunc(rawInput.limit)));
+  const qs = params.toString();
+  const response = await fetchFn(`${auth.controlPlaneUrl}/api/v1/knowledge/private/stale${qs ? `?${qs}` : ""}`, {
+    method: "GET",
+    headers: { authorization: `Bearer ${auth.token}` }
+  });
+  const text = await response.text();
+  let parsed;
+  try {
+    parsed = text ? JSON.parse(text) : null;
+  } catch {
+    parsed = null;
+  }
+  const payload = response.status < 200 || response.status >= 300 ? { ok: false, status: response.status, response: parsed ?? text } : parsed;
+  return jsonContent({ tool: STALE_TOOL_NAME, schema_version: 1, payload });
+}
 async function handlePrivateKnowledgeContext(_deps, rawInput, _signal, fetchFn = globalThis.fetch) {
   if (!isContextInput(rawInput)) {
     throw invalidParams(CONTEXT_TOOL_NAME, "expected { query, optional limit, optional knowledge_class }.");
@@ -5249,6 +6992,337 @@ async function handlePrivateKnowledgeContext(_deps, rawInput, _signal, fetchFn =
   return jsonContent({ tool: CONTEXT_TOOL_NAME, schema_version: 1, payload });
 }
 
+// src/tools/hq/whiteboard.ts
+init_auth_token_source();
+init_credential_store();
+var POST_TOOL_NAME = "hq_whiteboard_post";
+var READ_TOOL_NAME = "hq_whiteboard_read";
+var postDescription = "Post an append-only coordination note to the live AlgoHQ whiteboard. Uses the scoped credential from vo-mcp login; operator and tenant ownership are derived by the server.";
+var readDescription = "Read recent coordination notes from the caller's live AlgoHQ whiteboard. Uses the scoped credential from vo-mcp login and cannot widen tenant scope.";
+var postInputSchema = {
+  type: "object",
+  properties: {
+    from: { type: "string", minLength: 1, maxLength: 100, description: "Agent/session display name." },
+    type: { type: "string", minLength: 1, maxLength: 64, description: "Message kind, such as intent, worklog, blocker, or completion." },
+    content: { type: "string", minLength: 1, maxLength: 500, description: "Short coordination note." },
+    targetAgent: { type: "string", maxLength: 100 },
+    tester: { type: "string", maxLength: 100 },
+    tier: { type: "string", maxLength: 32 }
+  },
+  required: ["from", "type", "content"],
+  additionalProperties: false
+};
+var readInputSchema = {
+  type: "object",
+  properties: {
+    limit: { type: "integer", minimum: 1, maximum: 100, default: 25 },
+    since: { type: "string", description: "Optional ISO-8601 lower bound." },
+    type: { type: "string", minLength: 1, maxLength: 64 }
+  },
+  additionalProperties: false
+};
+function resolveTimeoutMs() {
+  const parsed = Number(process.env["HQ_WHITEBOARD_TIMEOUT_MS"]);
+  return Number.isFinite(parsed) && parsed >= 10 && parsed <= 12e4 ? parsed : 1e4;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function onlyKeys(value, allowed) {
+  return Object.keys(value).every((key) => allowed.includes(key));
+}
+function isBoundedString(value, min, max) {
+  return typeof value === "string" && value.trim().length >= min && value.trim().length <= max;
+}
+function parsePostInput(value) {
+  if (!isRecord(value) || !onlyKeys(value, ["from", "type", "content", "targetAgent", "tester", "tier"])) return null;
+  if (!isBoundedString(value["from"], 1, 100)) return null;
+  if (!isBoundedString(value["type"], 1, 64) || !/^[a-zA-Z0-9_-]+$/.test(value["type"].trim())) return null;
+  if (!isBoundedString(value["content"], 1, 500)) return null;
+  for (const [key, max] of [["targetAgent", 100], ["tester", 100], ["tier", 32]]) {
+    if (value[key] !== void 0 && !isBoundedString(value[key], 0, max)) return null;
+  }
+  return {
+    from: value["from"].trim(),
+    type: value["type"].trim(),
+    content: value["content"].trim(),
+    ...typeof value["targetAgent"] === "string" ? { targetAgent: value["targetAgent"].trim() } : {},
+    ...typeof value["tester"] === "string" ? { tester: value["tester"].trim() } : {},
+    ...typeof value["tier"] === "string" ? { tier: value["tier"].trim() } : {}
+  };
+}
+function parseReadInput(value) {
+  if (!isRecord(value) || !onlyKeys(value, ["limit", "since", "type"])) return null;
+  if (value["limit"] !== void 0 && (!Number.isInteger(value["limit"]) || Number(value["limit"]) < 1 || Number(value["limit"]) > 100)) return null;
+  if (value["since"] !== void 0 && (typeof value["since"] !== "string" || Number.isNaN(Date.parse(value["since"])))) return null;
+  if (value["type"] !== void 0 && !isBoundedString(value["type"], 1, 64)) return null;
+  return {
+    ...typeof value["limit"] === "number" ? { limit: value["limit"] } : {},
+    ...typeof value["since"] === "string" ? { since: value["since"] } : {},
+    ...typeof value["type"] === "string" ? { type: value["type"].trim() } : {}
+  };
+}
+async function resolveCloud(fetchFn) {
+  const url = process.env["VO_CONTROL_PLANE_URL"]?.trim().replace(/\/$/, "");
+  if (!url) return null;
+  try {
+    const source = createAuthTokenSourceFromEnv(process.env, fetchFn, () => readStoredCredential(process.env));
+    const token = await source?.getToken();
+    return token ? { url, token } : null;
+  } catch {
+    return null;
+  }
+}
+async function callWhiteboard(method, bodyOrQuery, signal, fetchFn = fetch) {
+  const cloud = await resolveCloud(fetchFn);
+  if (!cloud) {
+    return {
+      ok: false,
+      error: "hq_whiteboard_not_configured",
+      message: "Set VO_CONTROL_PLANE_URL and run vo-mcp login to install a scoped HQ credential."
+    };
+  }
+  const timeoutSignal = AbortSignal.timeout(resolveTimeoutMs());
+  const requestSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+  const query = new URLSearchParams();
+  if (method === "GET") {
+    const input = bodyOrQuery;
+    query.set("limit", String(input.limit ?? 25));
+    if (input.since) query.set("since", input.since);
+    if (input.type) query.set("type", input.type);
+  }
+  try {
+    const response = await fetchFn(
+      `${cloud.url}/api/v1/hq/whiteboard/messages${query.size ? `?${query}` : ""}`,
+      {
+        method,
+        headers: {
+          Authorization: `Bearer ${cloud.token}`,
+          ...method === "POST" ? { "Content-Type": "application/json" } : {}
+        },
+        ...method === "POST" ? { body: JSON.stringify(bodyOrQuery) } : {},
+        signal: requestSignal
+      }
+    );
+    const text = await response.text();
+    let payload;
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      payload = { ok: false, error: "invalid_response", message: text.slice(0, 200) };
+    }
+    if (!response.ok) {
+      return { ok: false, error: "hq_whiteboard_http_error", status: response.status, response: payload };
+    }
+    return payload;
+  } catch (error) {
+    return {
+      ok: false,
+      error: signal?.aborted ? "cancelled" : timeoutSignal.aborted ? "hq_whiteboard_timeout" : "hq_whiteboard_unreachable",
+      message: error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200)
+    };
+  }
+}
+async function handleHqWhiteboardPost(_deps, rawInput, signal) {
+  const input = parsePostInput(rawInput);
+  if (!input) throw invalidParams(POST_TOOL_NAME, "requires from, type, and 1-500 character content; unknown fields are rejected");
+  return jsonContent(await callWhiteboard("POST", input, signal));
+}
+async function handleHqWhiteboardRead(_deps, rawInput, signal) {
+  const input = parseReadInput(rawInput);
+  if (!input) throw invalidParams(READ_TOOL_NAME, "limit must be 1-100, since must be ISO-8601, and unknown fields are rejected");
+  return jsonContent(await callWhiteboard("GET", input, signal));
+}
+
+// src/tools/skills/skill-corpus.ts
+import { existsSync as existsSync10, statSync as statSync7 } from "node:fs";
+import { dirname as dirname5, isAbsolute, join as join13, resolve as resolve2 } from "node:path";
+
+// ../skill-registry/src/loader.ts
+import { readdirSync as readdirSync6, readFileSync as readFileSync14, statSync as statSync6 } from "node:fs";
+import { join as join12 } from "node:path";
+var InvalidSkillFrontmatterError = class extends Error {
+  constructor(skillFile, reason) {
+    super(`Invalid frontmatter in ${skillFile}: ${reason}`);
+    this.skillFile = skillFile;
+    this.reason = reason;
+  }
+  skillFile;
+  reason;
+  name = "InvalidSkillFrontmatterError";
+};
+var FRONTMATTER_DELIMITER = "---";
+function parseFrontmatter(rawInput, sourcePath) {
+  const raw = rawInput.replace(/\r\n/g, "\n");
+  if (!raw.startsWith(`${FRONTMATTER_DELIMITER}
+`)) {
+    throw new InvalidSkillFrontmatterError(sourcePath, 'file does not start with frontmatter delimiter "---"');
+  }
+  const afterFirst = raw.slice(FRONTMATTER_DELIMITER.length + 1);
+  const closingIdx = afterFirst.indexOf(`
+${FRONTMATTER_DELIMITER}
+`);
+  if (closingIdx === -1) {
+    throw new InvalidSkillFrontmatterError(sourcePath, 'missing closing frontmatter delimiter "---"');
+  }
+  const frontmatterText = afterFirst.slice(0, closingIdx);
+  const body = afterFirst.slice(closingIdx + `
+${FRONTMATTER_DELIMITER}
+`.length);
+  let name = "";
+  let description24 = "";
+  for (const line of frontmatterText.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = trimmed.slice(0, colonIdx).trim();
+    const value = trimmed.slice(colonIdx + 1).trim();
+    if (key === "name") name = value;
+    else if (key === "description") description24 = value;
+  }
+  if (name.length === 0) {
+    throw new InvalidSkillFrontmatterError(sourcePath, 'missing required field "name"');
+  }
+  if (description24.length === 0) {
+    throw new InvalidSkillFrontmatterError(sourcePath, 'missing required field "description"');
+  }
+  return { name, description: description24, body };
+}
+function loadSkillsFromDir(skillsDir) {
+  const entries = readdirSync6(skillsDir);
+  const skills = [];
+  for (const entry of entries) {
+    const entryPath = join12(skillsDir, entry);
+    let stat;
+    try {
+      stat = statSync6(entryPath);
+    } catch {
+      continue;
+    }
+    if (!stat.isDirectory()) continue;
+    const skillFile = join12(entryPath, "SKILL.md");
+    let raw;
+    try {
+      raw = readFileSync14(skillFile, "utf8");
+    } catch {
+      continue;
+    }
+    const { name, description: description24, body } = parseFrontmatter(raw, skillFile);
+    skills.push({ name, description: description24, body, sourcePath: skillFile });
+  }
+  return [...skills].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// src/tools/skills/skill-corpus.ts
+var LIST_TOOL_NAME = "vo_skill_list";
+var GET_TOOL_NAME = "vo_skill_get";
+var listDescription = "List the Algosuite skill corpus (name + trigger description for every skill). Call once near session start to learn which skills exist; then fetch the full instructions for a relevant skill with vo_skill_get. This is the same corpus Claude Code loads natively from .claude/skills \u2014 served over MCP so every vendor works from identical playbooks. Pass refresh:true to re-scan from disk.";
+var getDescription = "Fetch the full markdown instructions of one Algosuite skill by name. Follow the returned instructions for the current task the same way a native skill invocation would. Use vo_skill_list to discover skill names.";
+var listInputSchema = {
+  type: "object",
+  properties: {
+    refresh: {
+      type: "boolean",
+      description: "Re-scan the skills directory instead of using the cached corpus."
+    }
+  },
+  required: []
+};
+var getInputSchema = {
+  type: "object",
+  properties: {
+    name: {
+      type: "string",
+      description: "Skill name exactly as returned by vo_skill_list."
+    }
+  },
+  required: ["name"]
+};
+var MAX_WALK_UP_LEVELS = 8;
+var cachedCorpus = null;
+function resolveSkillsDir(env = process.env, startDir = process.cwd()) {
+  const override = env.VO_SKILLS_DIR;
+  if (typeof override === "string" && override.length > 0) {
+    const abs = isAbsolute(override) ? override : resolve2(startDir, override);
+    return existsSync10(abs) && statSync7(abs).isDirectory() ? abs : null;
+  }
+  let dir = resolve2(startDir);
+  for (let i = 0; i < MAX_WALK_UP_LEVELS; i += 1) {
+    const candidate = join13(dir, ".claude", "skills");
+    if (existsSync10(candidate) && statSync7(candidate).isDirectory()) return candidate;
+    const parent = dirname5(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function loadCorpus() {
+  const skillsDir = resolveSkillsDir();
+  if (skillsDir === null) {
+    return {
+      skills: [],
+      skillsDir: null,
+      unavailableReason: "No skills directory found. Set VO_SKILLS_DIR or run inside a repo with .claude/skills."
+    };
+  }
+  try {
+    return { skills: loadSkillsFromDir(skillsDir), skillsDir, unavailableReason: null };
+  } catch (err) {
+    const message = err instanceof Error ? `${err.name}: ${err.message}` : String(err);
+    return { skills: [], skillsDir, unavailableReason: message };
+  }
+}
+function getCorpus(refresh) {
+  if (refresh || cachedCorpus === null) {
+    cachedCorpus = loadCorpus();
+  }
+  return cachedCorpus;
+}
+async function handleSkillList(_deps, rawInput) {
+  const input = rawInput ?? {};
+  const refresh = input.refresh === true;
+  const corpus = getCorpus(refresh);
+  return jsonContent({
+    corpus_available: corpus.unavailableReason === null,
+    skills_dir: corpus.skillsDir,
+    unavailable_reason: corpus.unavailableReason,
+    skill_count: corpus.skills.length,
+    skills: corpus.skills.map((s) => ({ name: s.name, description: s.description }))
+  });
+}
+async function handleSkillGet(_deps, rawInput) {
+  const input = rawInput ?? {};
+  if (typeof input.name !== "string" || input.name.trim().length === 0) {
+    throw invalidParams(GET_TOOL_NAME, 'input field "name" (non-empty string) is required');
+  }
+  const requested = input.name.trim();
+  const corpus = getCorpus(false);
+  if (corpus.unavailableReason !== null) {
+    return jsonContent({
+      corpus_available: false,
+      unavailable_reason: corpus.unavailableReason,
+      skill: null
+    });
+  }
+  const skill = corpus.skills.find((s) => s.name === requested);
+  if (skill === void 0) {
+    throw invalidParams(
+      GET_TOOL_NAME,
+      `unknown skill "${requested}". Known skills: ${corpus.skills.map((s) => s.name).join(", ")}`
+    );
+  }
+  return jsonContent({
+    corpus_available: true,
+    skill: {
+      name: skill.name,
+      description: skill.description,
+      instructions: skill.body,
+      source_path: skill.sourcePath
+    }
+  });
+}
+
 // src/server.ts
 function buildToolRegistry() {
   return {
@@ -5402,7 +7476,7 @@ function buildToolRegistry() {
         description: description19,
         inputSchema: inputSchema19
       },
-      handler: handleReportSessionState
+      handler: handlePreparedJobMode
     },
     [TOOL_NAME20]: {
       definition: {
@@ -5410,7 +7484,7 @@ function buildToolRegistry() {
         description: description20,
         inputSchema: inputSchema20
       },
-      handler: handleSpawnSuccessor
+      handler: handleReportSessionState
     },
     [TOOL_NAME21]: {
       definition: {
@@ -5418,7 +7492,7 @@ function buildToolRegistry() {
         description: description21,
         inputSchema: inputSchema21
       },
-      handler: handleConciergeDispatch
+      handler: handleSpawnSuccessor
     },
     [TOOL_NAME22]: {
       definition: {
@@ -5426,6 +7500,14 @@ function buildToolRegistry() {
         description: description22,
         inputSchema: inputSchema22
       },
+      handler: handleConciergeDispatch
+    },
+    [TOOL_NAME23]: {
+      definition: {
+        name: TOOL_NAME23,
+        description: description23,
+        inputSchema: inputSchema23
+      },
       handler: handleSyncConfig
     },
     [UPSERT_TOOL_NAME]: {
@@ -5443,11 +7525,59 @@ function buildToolRegistry() {
         inputSchema: contextInputSchema
       },
       handler: handlePrivateKnowledgeContext
+    },
+    [INVALIDATE_TOOL_NAME]: {
+      definition: {
+        name: INVALIDATE_TOOL_NAME,
+        description: invalidateDescription,
+        inputSchema: invalidateInputSchema
+      },
+      handler: handlePrivateKnowledgeInvalidate
+    },
+    [STALE_TOOL_NAME]: {
+      definition: {
+        name: STALE_TOOL_NAME,
+        description: staleDescription,
+        inputSchema: staleInputSchema
+      },
+      handler: handlePrivateKnowledgeStale
+    },
+    [POST_TOOL_NAME]: {
+      definition: {
+        name: POST_TOOL_NAME,
+        description: postDescription,
+        inputSchema: postInputSchema
+      },
+      handler: handleHqWhiteboardPost
+    },
+    [READ_TOOL_NAME]: {
+      definition: {
+        name: READ_TOOL_NAME,
+        description: readDescription,
+        inputSchema: readInputSchema
+      },
+      handler: handleHqWhiteboardRead
+    },
+    [LIST_TOOL_NAME]: {
+      definition: {
+        name: LIST_TOOL_NAME,
+        description: listDescription,
+        inputSchema: listInputSchema
+      },
+      handler: handleSkillList
+    },
+    [GET_TOOL_NAME]: {
+      definition: {
+        name: GET_TOOL_NAME,
+        description: getDescription,
+        inputSchema: getInputSchema
+      },
+      handler: handleSkillGet
     }
   };
 }
 function createServer(options) {
-  const sessionId = options.sessionId ?? randomUUID2();
+  const sessionId = options.sessionId ?? randomUUID3();
   const mode = createLocalMode();
   const now = options.now ?? (() => /* @__PURE__ */ new Date());
   const server = new Server(
@@ -5499,9 +7629,9 @@ function listToolNames() {
 }
 
 // src/cache/sqlite-cache.ts
-import { createHash as createHash3 } from "node:crypto";
-import { chmodSync as chmodSync3, mkdirSync as mkdirSync5 } from "node:fs";
-import { dirname as dirname5 } from "node:path";
+import { createHash as createHash4 } from "node:crypto";
+import { chmodSync as chmodSync3, mkdirSync as mkdirSync7 } from "node:fs";
+import { dirname as dirname6 } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 
 // src/cache/canonicalize.ts
@@ -5546,7 +7676,7 @@ function normalizeString(s) {
 function createSqliteCache(options) {
   const fileBacked = options.dbPath !== ":memory:";
   if (fileBacked) {
-    mkdirSync5(dirname5(options.dbPath), { recursive: true, mode: 448 });
+    mkdirSync7(dirname6(options.dbPath), { recursive: true, mode: 448 });
   }
   const versionNamespace = options.cacheVersionNamespace ?? "";
   const db = new DatabaseSync(options.dbPath);
@@ -5577,7 +7707,7 @@ function createSqliteCache(options) {
   return {
     keyFor(toolName, input, opts) {
       const canonical = canonicalize(input, opts);
-      const hash = createHash3("sha256");
+      const hash = createHash4("sha256");
       if (versionNamespace.length > 0) {
         hash.update(versionNamespace);
         hash.update("|");
@@ -5669,7 +7799,7 @@ function createStubRatchetClient() {
         let m;
         while ((m = pat.regex.exec(req.source)) !== null) {
           findings.push({
-            line_excerpt: clip(m[0], 80),
+            line_excerpt: clip2(m[0], 80),
             severity: pat.severity,
             code: pat.code,
             message: pat.message
@@ -5701,7 +7831,7 @@ function createStubRatchetClient() {
     }
   };
 }
-function clip(s, n) {
+function clip2(s, n) {
   return s.length <= n ? s : s.slice(0, n) + "\u2026";
 }
 function buildSummary2(args) {
@@ -5730,66 +7860,62 @@ function createNullConsensusEngineClient(reason = NULL_CLIENT_DEFAULT_REASON) {
 }
 
 // src/consensus/engine-client.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 
 // src/consensus/meta-model-caller.ts
-var META_MODEL_API_BASE_URL = "https://api.meta.ai/v1";
 var META_CONSENSUS_MODEL = "muse-spark-1.1";
-var META_MODEL_API_KEY_ENV = "MODEL_API_KEY";
-var META_MODEL_API_KEY_ALIAS = "META_API";
-function resolveMetaKey(env) {
-  return String(env[META_MODEL_API_KEY_ENV] || env[META_MODEL_API_KEY_ALIAS] || "").trim();
-}
-function positiveMaxTokens(value) {
-  const parsed = Math.floor(Number(value));
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : 2048;
-}
 function createMetaModelCaller(options = {}) {
-  const fetchImpl = options.fetchImpl ?? fetch;
-  const envSource = options.envSource ?? process.env;
-  const reasoningEffort = options.reasoningEffort ?? "high";
-  return async function callMetaWithMetrics2(prompt, systemPrompt, model, maxTokens, _privacyOptions, signal) {
-    const key = resolveMetaKey(envSource);
-    if (!key) throw new Error(`Missing ${META_MODEL_API_KEY_ENV} for Meta Model API`);
-    const messages = [
-      ...systemPrompt ? [{ role: "system", content: systemPrompt }] : [],
-      { role: "user", content: prompt }
-    ];
-    const response = await fetchImpl(`${META_MODEL_API_BASE_URL}/chat/completions`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${key}`,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        model: model || META_CONSENSUS_MODEL,
-        messages,
-        max_tokens: positiveMaxTokens(maxTokens),
-        reasoning_effort: reasoningEffort
-      }),
-      signal
-    });
-    const payload = await response.json();
-    if (!response.ok) {
-      const message = String(payload.error?.message || response.statusText || "request failed").slice(0, 500);
-      throw Object.assign(new Error(`Meta Model API ${response.status}: ${message}`), { status: response.status });
-    }
-    const content = payload.choices?.[0]?.message?.content;
-    if (typeof content !== "string" || !content.trim()) {
-      throw new Error(`Meta Model API returned no text (finish=${payload.choices?.[0]?.finish_reason || "unknown"})`);
-    }
-    const inputTokens = Number(payload.usage?.prompt_tokens || 0);
-    const outputTokens = Number(payload.usage?.completion_tokens || 0);
-    return {
-      content,
-      inputTokens,
-      outputTokens,
-      totalTokens: Number(payload.usage?.total_tokens || inputTokens + outputTokens)
-    };
+  void options;
+  return async function callMetaWithMetrics2() {
+    throw new Error(
+      "Muse Spark direct consensus is disabled. Use an explicit sanitized task capsule through the AlgoSuite Model Firewall."
+    );
   };
 }
 var callMetaWithMetrics = createMetaModelCaller();
 
+// src/consensus/consensus-panel.ts
+var VO_MCP_CONSENSUS_PANEL = {
+  // claude-opus-5 (2026-07-24). Opus 4.7 was STRICTLY DOMINATED, not merely old:
+  // Opus 5 is $5/$25 per MTok vs Opus 4.7's $15/$75 — a 3x cost cut on this slot,
+  // corroborated by our own catalog (constants/pricing/sciencePricing.ts prices
+  // claude-opus-5 at 0.010 vs claude-opus-4-7 at 0.030) — AND the same 2026-07-24
+  // release note REMOVED fast mode from Opus 4.7 outright: `speed: "fast"` now
+  // returns an error there rather than degrading, unlike the Opus 4.6 removal.
+  // Verified served: GET /v1/models/claude-opus-5 -> HTTP 200 (2026-07-30).
+  //
+  // Claude-5 API safety checked before this swap: Opus 5 rejects `temperature` /
+  // `top_p` / `top_k` and manual `thinking.budget_tokens` with HTTP 400. Neither
+  // the consensus-engine Anthropic adapter nor functions-shared `callAnthropic`
+  // sends any of them, and buildAdaptiveThinking emits `thinking: {type:'adaptive'}`
+  // (the supported form) — so this swap cannot 400.
+  anthropic: "claude-opus-5",
+  // gpt-5.6-terra (GA 2026-07-09; −20% price cut 2026-07-30). NOTE the real IDs
+  // are tiered — `gpt-5.6-sol` / `-terra` / `-luna`; there is NO bare `gpt-5.6`
+  // alias (verified against the served model list, 2026-07-30). Terra is the
+  // cost/capability balance point and the right default for a judgment panel;
+  // Sol is available if verdict quality ever needs it.
+  openai: "gpt-5.6-terra",
+  // gemini-2.5-FLASH (not -pro): flash accepts the default thinkingBudget=0 from
+  // callGeminiWithMetrics; 2.5-pro REJECTS budget 0 ("only works in thinking mode").
+  // Flash is also ~10x cheaper. 2026-06-02.
+  google: "gemini-2.5-flash",
+  deepseek: "deepseek-chat",
+  // Muse Spark identity is owned by meta-model-caller.ts (single source of
+  // truth for the meta slot); re-exported here so the panel stays complete.
+  meta: META_CONSENSUS_MODEL
+};
+function getVoMcpConsensusPanel(panel = VO_MCP_CONSENSUS_PANEL) {
+  for (const [provider, modelId] of Object.entries(panel)) {
+    if (typeof modelId !== "string" || modelId.trim().length === 0) {
+      throw new Error(
+        `getVoMcpConsensusPanel: panel slot "${provider}" has a missing or blank model ID`
+      );
+    }
+  }
+  return panel;
+}
+
 // src/consensus/engine-options.ts
 var AGREEMENT_GATE_ENV_VAR = "VO_CONSENSUS_AGREEMENT_GATE";
 function isTruthyFlag(raw) {
@@ -5843,6 +7969,14 @@ function shadowEnabled(env) {
   const norm = raw.trim().toLowerCase();
   return !(norm === "0" || norm === "false" || norm === "no" || norm === "off" || norm === "");
 }
+var MIN_RESPONDERS_ENV_VAR = "VO_CONSENSUS_MIN_RESPONDERS";
+function resolveMinResponders(env) {
+  const raw = (env ?? {})[MIN_RESPONDERS_ENV_VAR];
+  if (raw === void 0 || raw.trim() === "") return 2;
+  const parsed = Number.parseInt(raw.trim(), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return void 0;
+  return parsed;
+}
 function mapShadowSynthesis(s) {
   if (s === void 0) return void 0;
   return {
@@ -5992,9 +8126,11 @@ function createEngineConsensusClient(options) {
           ...options.agreement_gate_enabled !== void 0 ? { configEnabled: options.agreement_gate_enabled } : {},
           ...options.env !== void 0 ? { env: options.env } : {}
         });
+        const minResponders = resolveMinResponders(options.env);
         const engineOptions = {
           panel,
           ...options.per_model_timeout_ms !== void 0 ? { per_model_timeout_ms: options.per_model_timeout_ms } : {},
+          ...minResponders !== void 0 ? { min_responders: minResponders } : {},
           ...agreementGate !== void 0 ? { agreement_gate: agreementGate } : {},
           // Stage A7-shadow: run the adaptive verdict alongside the live one for grading.
           // Cheap (pure log-odds over already-fetched verdicts; no extra model calls),
@@ -6003,7 +8139,7 @@ function createEngineConsensusClient(options) {
           shadow_synthesis: { enabled: shadowEnabled(options.env) }
         };
         const sources = request.source_urls;
-        const useSourceGrounded = sources !== void 0 && sources.length > 0 && typeof engine.runSourceGroundedConsensus === "function";
+        const useSourceGrounded = sources !== void 0 && sources.length > 0;
         let response;
         let sourceExtras;
         if (useSourceGrounded) {
@@ -6047,8 +8183,13 @@ function createEngineConsensusClient(options) {
           synthesized_verdict: response.synthesized_verdict,
           per_model_verdicts: response.per_model_verdicts,
           degraded: response.degraded,
+          ...response.quorum_failed === true ? { quorum_failed: true } : {},
           duration_ms: response.duration_ms,
           engine_version: response.engine_version,
+          // Cumulative cross-round inference usage (B44-3). Absent when no panel
+          // member reported usage; forwarded verbatim — the aggregator prefers it
+          // over summing final-round verdicts (which under-reports deliberation).
+          ...response.token_usage !== void 0 ? { token_usage: response.token_usage } : {},
           // Phase 2 Lane D-1 — forward escalation signal when present. The
           // source-grounded layer's own escalation (from the citation grade)
           // takes precedence when set, else the synthesizer's.
@@ -6058,6 +8199,10 @@ function createEngineConsensusClient(options) {
           ...mapFanOutDiagnostics(response.fan_out_diagnostics) !== void 0 ? { fan_out_diagnostics: mapFanOutDiagnostics(response.fan_out_diagnostics) } : {},
           // Stage A7-shadow — adaptive-vs-incumbent comparison (PII-free; present iff shadow on).
           ...mapShadowSynthesis(response.shadow_synthesis) !== void 0 ? { shadow_synthesis: mapShadowSynthesis(response.shadow_synthesis) } : {},
+          // Critique-uptake (2026-07-20 red-team fix) — verifier-critique
+          // visibility report; previously computed by the engine on every
+          // call but dropped at this boundary.
+          ...response.critique_uptake !== void 0 ? { critique_uptake: response.critique_uptake } : {},
           // Source-grounded additive outputs (Tier-4 features).
           ...useSourceGrounded ? { source_grounded: true } : {},
           ...sourceExtras?.citation_grade !== void 0 ? { citation_grade: sourceExtras.citation_grade } : {},
@@ -6073,27 +8218,12 @@ function createEngineConsensusClient(options) {
     }
   };
 }
-var DEFAULT_MODELS = {
-  // These ids match the strategic-roadmap §4 `newsStandard` / `newsDeep` panel
-  // intent — current production model ids. Per handoff §C-3 these MUST come
-  // from `CONSENSUS_PANELS` in `functions-shared/shared-model-resolvers.ts`
-  // for V1; placeholder defaults here keep Phase 2 Lane A non-blocking.
-  anthropic: "claude-opus-4-7",
-  openai: "gpt-5",
-  // gemini-2.5-FLASH (not -pro): flash accepts the default thinkingBudget=0 from
-  // callGeminiWithMetrics; 2.5-pro REJECTS budget 0 ("only works in thinking mode").
-  // Flash is also ~10x cheaper. 2026-06-02.
-  google: "gemini-2.5-flash",
-  deepseek: "deepseek-chat",
-  meta: META_CONSENSUS_MODEL
-};
+var DEFAULT_MODELS = getVoMcpConsensusPanel();
 function probeProviders(env = process.env) {
   const out = [];
   if ((env["ANTHROPIC_API_KEY"] ?? "").trim().length > 0) out.push("anthropic");
   if ((env["OPENAI_API_KEY"] ?? "").trim().length > 0) out.push("openai");
   if ((env["GOOGLE_API_KEY"] ?? "").trim().length > 0) out.push("google");
-  if ((env["DEEPSEEK_API_KEY"] ?? "").trim().length > 0) out.push("deepseek");
-  if ((env[META_MODEL_API_KEY_ENV] ?? "").trim().length > 0 || (env[META_MODEL_API_KEY_ALIAS] ?? "").trim().length > 0) out.push("meta");
   return out;
 }
 async function loadFactoryAndCallers(injectedEngine, injectedShared) {
@@ -6138,25 +8268,20 @@ async function tryCreateEngineConsensusClientFromEnvAsync(options = {}) {
   const callerByProvider = {
     anthropic: loaded.shared.callAnthropicWithMetrics,
     openai: loaded.shared.callOpenAIWithMetrics,
-    google: loaded.shared.callGeminiWithMetrics,
-    deepseek: loaded.shared.callDeepSeekWithMetrics,
-    meta: options.metaCaller ?? callMetaWithMetrics
+    google: loaded.shared.callGeminiWithMetrics
   };
   const modelByProvider = {
     anthropic: options.models?.anthropic ?? DEFAULT_MODELS.anthropic,
     openai: options.models?.openai ?? DEFAULT_MODELS.openai,
-    google: options.models?.google ?? DEFAULT_MODELS.google,
-    deepseek: options.models?.deepseek ?? DEFAULT_MODELS.deepseek,
-    meta: options.models?.meta ?? DEFAULT_MODELS.meta
+    google: options.models?.google ?? DEFAULT_MODELS.google
   };
-  const adapterEnv = !(env[META_MODEL_API_KEY_ENV] ?? "").trim() && (env[META_MODEL_API_KEY_ALIAS] ?? "").trim() ? { ...env, [META_MODEL_API_KEY_ENV]: env[META_MODEL_API_KEY_ALIAS] } : env;
   const panel = [];
   for (const p of providers) {
     try {
       const adapter = loaded.engine.createAdapter(p, {
         model: modelByProvider[p],
         caller: callerByProvider[p],
-        envSource: adapterEnv
+        envSource: env
       });
       panel.push(adapter);
     } catch {