@algosuite/vo-mcp 0.2.0-beta.4 → 0.2.0-beta.40

package/dist/cli.js

@@ -1079,6 +1079,42 @@ 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 toEventSynthesizedVerdict(src) {
   return {
     verdict: src.verdict,
@@ -1261,6 +1297,7 @@ __export(credential_store_exports, {
   KEYCHAIN_LOCATION: () => KEYCHAIN_LOCATION,
   credentialPath: () => credentialPath,
   readStoredCredential: () => readStoredCredential,
+  readStoredCredentialKeychainOnly: () => readStoredCredentialKeychainOnly,
   writeStoredCredential: () => writeStoredCredential
 });
 import { homedir as homedir3 } from "node:os";
@@ -1319,6 +1356,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 });
@@ -1368,43 +1410,505 @@ var init_credential_store = __esm({
   }
 });
 
-// src/tools/memory/sync-config.ts
-var sync_config_exports = {};
-__export(sync_config_exports, {
-  TOOL_NAME: () => TOOL_NAME22,
-  deriveProjectSlug: () => deriveProjectSlug,
-  description: () => description22,
-  getMemoryDir: () => getMemoryDir,
-  handleSyncConfig: () => handleSyncConfig,
-  inputSchema: () => inputSchema22,
-  isNoopSyncReason: () => isNoopSyncReason,
-  runMemorySync: () => runMemorySync
+// 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;
+  }
 });
-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";
-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;
+
+// src/tools/memory/sync-lock-liveness.ts
+import { statSync as statSync4, readFileSync as readFileSync8 } from "node:fs";
+function defaultIsProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
 }
-function deriveProjectSlug(cwd) {
-  return cwd.replace(/\\/g, "/").replace(/\/+$/g, "").replace(/^([a-zA-Z]):/, (_m, drive) => `${drive.toUpperCase()}:`).replace(/[^a-zA-Z0-9]/g, "-");
+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 getMemoryDir(cwd) {
-  const slug = deriveProjectSlug(cwd);
-  return join7(homedir5(), ".claude", "projects", slug, "memory");
+function readLockRecord(path3) {
+  let raw;
+  try {
+    raw = readFileSync8(path3, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    return { raw, payload: toPayload(JSON.parse(raw)) };
+  } catch {
+    return { raw, payload: null };
+  }
+}
+function lockAgeMs(record, path3, 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 = statSync4(path3).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;
+}
+var init_sync_lock_liveness = __esm({
+  "src/tools/memory/sync-lock-liveness.ts"() {
+    "use strict";
+  }
+});
+
+// src/tools/memory/sync-lock.ts
+import { closeSync as closeSync2, 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";
+function positiveOr(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function createExclusive2(path3, contents) {
+  let fd;
+  try {
+    fd = openSync3(path3, "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) {
+    closeSync2(fd);
+    try {
+      unlinkSync2(path3);
+    } catch {
+    }
+    return { ok: false, exists: false, message: err instanceof Error ? err.message : String(err) };
+  }
+  closeSync2(fd);
+  return { ok: true };
+}
+function removeAbandoned(path3, expectedRaw) {
+  let current;
+  try {
+    current = readFileSync9(path3, "utf8");
+  } catch {
+    return;
+  }
+  if (current !== expectedRaw) return;
+  try {
+    unlinkSync2(path3);
+  } catch {
+  }
+}
+function makeRelease(path3, token) {
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    let raw;
+    try {
+      raw = readFileSync9(path3, "utf8");
+    } catch {
+      return;
+    }
+    let stillOurs;
+    try {
+      stillOurs = toPayload(JSON.parse(raw))?.token === token;
+    } catch {
+      stillOurs = false;
+    }
+    if (!stillOurs) return;
+    try {
+      unlinkSync2(path3);
+    } 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 path3 = 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(path3, `${JSON.stringify(payload, null, 2)}
+`);
+    if (created.ok) {
+      return { path: path3, payload, tookOverFrom, release: makeRelease(path3, payload.token) };
+    }
+    if (!created.exists) {
+      throw new Error(
+        `memory sync lock ${path3} could not be created (${created.message}) \u2014 refusing to sync without exclusion`
+      );
+    }
+    const record = readLockRecord(path3);
+    let reclaimed = false;
+    if (record) {
+      holderDescription = describeHolder(record);
+      const age = lockAgeMs(record, path3, now());
+      if (isLockAbandoned(record, age, ttlMs, isProcessAlive, thisHost)) {
+        tookOverFrom = record.payload;
+        removeAbandoned(path3, record.raw);
+        reclaimed = true;
+      }
+    }
+    if (now() >= deadline) {
+      throw new Error(
+        `memory sync lock ${path3} 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();
+  }
+}
+var MEMORY_SYNC_LOCK_FILE, DEFAULT_LOCK_TTL_MS, DEFAULT_LOCK_WAIT_MS, INITIAL_BACKOFF_MS, MAX_BACKOFF_MS, BACKOFF_FACTOR;
+var init_sync_lock = __esm({
+  "src/tools/memory/sync-lock.ts"() {
+    "use strict";
+    init_sync_lock_liveness();
+    init_sync_lock_liveness();
+    MEMORY_SYNC_LOCK_FILE = ".memory-sync.lock";
+    DEFAULT_LOCK_TTL_MS = 15 * 6e4;
+    DEFAULT_LOCK_WAIT_MS = 1e4;
+    INITIAL_BACKOFF_MS = 25;
+    MAX_BACKOFF_MS = 500;
+    BACKOFF_FACTOR = 1.6;
+  }
+});
+
+// src/tools/memory/memory-index-merge.ts
+function isMemoryIndexFile(fileName) {
+  return fileName.toUpperCase() === MEMORY_INDEX_FILE.toUpperCase();
+}
+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 };
+}
+var MEMORY_INDEX_FILE, INDEX_ROW_RE;
+var init_memory_index_merge = __esm({
+  "src/tools/memory/memory-index-merge.ts"() {
+    "use strict";
+    MEMORY_INDEX_FILE = "MEMORY.md";
+    INDEX_ROW_RE = /^\s*[-*]\s+\[[^\]]*\]\(([^)]+)\)/;
+  }
+});
+
+// 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-sync-http.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync6, readdirSync as readdirSync4 } from "node:fs";
 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)}`);
@@ -1413,117 +1917,392 @@ async function pullMemory(controlPlaneUrl, token, memoryDir, fetchFn) {
   if (!data.ok || !Array.isArray(data.entries)) {
     throw new Error("GET /api/v1/agent-config/memory/me response missing ok=true or entries array");
   }
-  mkdirSync4(memoryDir, { recursive: true });
+  const writes = data.entries.map((entry) => ({
+    entry,
+    filePath: resolveMemoryFilePath(memoryDir, entry.file_name)
+  }));
+  mkdirSync6(memoryDir, { recursive: true });
   const files = [];
-  for (const entry of data.entries) {
-    const filePath = join7(memoryDir, entry.file_name);
-    writeFileSync3(filePath, entry.content, "utf8");
+  for (const { entry, filePath } of writes) {
+    writeFileSync6(filePath, entry.content, "utf8");
     files.push(entry.file_name);
   }
   return { pulled: data.entries.length, files };
 }
-async function pushMemory(controlPlaneUrl, token, memoryDir, sessionId, fetchFn) {
+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 (!existsSync5(memoryDir)) {
-    return { pushed: 0, created: 0, updated: 0 };
+    return empty;
   }
-  const localFiles = readdirSync4(memoryDir).filter((f) => f.endsWith(".md")).map((f) => ({
+  const localFiles = listPushableFiles(memoryDir).map((f) => ({
     file_name: f,
-    content: readFileSync7(join7(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 };
+}
+var init_memory_sync_http = __esm({
+  "src/tools/memory/memory-sync-http.ts"() {
+    "use strict";
+    init_safe_memory_file();
+    init_sync_lock();
+    init_memory_index_merge();
+    init_bounded_sync();
+    init_memory_push_cache();
+  }
+});
+
+// src/tools/memory/sync-kill-switch.ts
+import { existsSync as existsSync6, readFileSync as readFileSync12 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { join as join10 } from "node:path";
+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 ?? existsSync6;
+  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 };
-}
-function isNoopSyncReason(reason) {
-  if (!reason) return false;
-  return /not set|No auth configured|Failed to obtain auth token/.test(reason);
+  if (fired.length === 0) return { disabled: false, reason: null };
+  return { disabled: true, reason: `memory sync DISABLED by ${fired.join(" + ")}` };
 }
-async function runMemorySync(action, cwd, sessionId, fetchFn = globalThis.fetch) {
-  const controlPlaneUrl = process.env["VO_CONTROL_PLANE_URL"];
-  if (!controlPlaneUrl) {
-    return { synced: false, reason: "VO_CONTROL_PLANE_URL not set \u2014 cloud mode disabled" };
-  }
-  const { createAuthTokenSourceFromEnv: createAuthTokenSourceFromEnv2 } = await Promise.resolve().then(() => (init_auth_token_source(), auth_token_source_exports));
-  const { readStoredCredential: readStoredCredential2 } = await Promise.resolve().then(() => (init_credential_store(), credential_store_exports));
-  const tokenSource = createAuthTokenSourceFromEnv2(process.env, fetchFn, () => readStoredCredential2(process.env));
-  if (!tokenSource) {
-    return { synced: false, reason: "No auth configured. Run `vo-mcp login` to authenticate as an operator." };
+var MEMORY_SYNC_DISABLE_ENV, MEMORY_SYNC_DISABLE_SENTINEL, NEGATIONS, MAX_LOGGED_VALUE;
+var init_sync_kill_switch = __esm({
+  "src/tools/memory/sync-kill-switch.ts"() {
+    "use strict";
+    MEMORY_SYNC_DISABLE_ENV = "VO_MCP_DISABLE_MEMORY_SYNC";
+    MEMORY_SYNC_DISABLE_SENTINEL = "vo-memory-sync-disabled";
+    NEGATIONS = /* @__PURE__ */ new Set(["0", "false", "no"]);
+    MAX_LOGGED_VALUE = 32;
+  }
+});
+
+// src/tools/memory/memory-knowledge-bridge.ts
+var memory_knowledge_bridge_exports = {};
+__export(memory_knowledge_bridge_exports, {
+  extractMemoryTitle: () => extractMemoryTitle,
+  upsertMemoryFilesAsKnowledge: () => upsertMemoryFilesAsKnowledge
+});
+import { existsSync as existsSync7, 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 description23 = frontmatter[1].match(/^description:\s*(.+)$/m);
+    if (description23 && description23[1].trim()) return description23[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 (!existsSync7(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/tools/memory/sync-config.ts
+var sync_config_exports = {};
+__export(sync_config_exports, {
+  TOOL_NAME: () => TOOL_NAME22,
+  deriveProjectSlug: () => deriveProjectSlug,
+  description: () => description22,
+  getMemoryDir: () => getMemoryDir,
+  handleSyncConfig: () => handleSyncConfig,
+  inputSchema: () => inputSchema22,
+  isNoopSyncReason: () => isNoopSyncReason,
+  runMemorySync: () => runMemorySync
+});
+import { existsSync as existsSync8 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { join as join11 } from "node:path";
+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, "-");
+}
+function getMemoryDir(cwd) {
+  const slug = deriveProjectSlug(cwd);
+  return join11(homedir7(), ".claude", "projects", slug, "memory");
+}
+function isNoopSyncReason(reason) {
+  if (!reason) return false;
+  return /not set|No auth configured|Failed to obtain auth token|DISABLED by/.test(reason);
+}
+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" };
+  }
+  const { createAuthTokenSourceFromEnv: createAuthTokenSourceFromEnv2 } = await Promise.resolve().then(() => (init_auth_token_source(), auth_token_source_exports));
+  const { readStoredCredential: readStoredCredential2 } = await Promise.resolve().then(() => (init_credential_store(), credential_store_exports));
+  const tokenSource = createAuthTokenSourceFromEnv2(process.env, fetchFn, () => readStoredCredential2(process.env));
+  if (!tokenSource) {
+    return { synced: false, reason: "No auth configured. Run `vo-mcp login` to authenticate as an operator." };
   }
   const token = await tokenSource.getToken();
   if (!token) {
@@ -1531,20 +2310,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" && !existsSync8(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}` };
@@ -1566,6 +2404,11 @@ var init_sync_config = __esm({
   "src/tools/memory/sync-config.ts"() {
     "use strict";
     init_common();
+    init_memory_sync_http();
+    init_bounded_sync();
+    init_memory_push_cache();
+    init_sync_lock();
+    init_sync_kill_switch();
     TOOL_NAME22 = "vo_sync_config";
     inputSchema22 = {
       type: "object",
@@ -1583,19 +2426,19 @@ var init_sync_config = __esm({
       required: ["action"],
       additionalProperties: false
     };
-    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.";
+    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. Serialized across concurrent sessions by an exclusive lock in the memory dir.";
   }
 });
 
 // src/cli.ts
-import { homedir as homedir6, hostname } from "node:os";
-import { randomUUID as randomUUID5 } from "node:crypto";
-import { join as join8 } from "node:path";
+import { homedir as homedir8, hostname as hostname2 } from "node:os";
+import { randomUUID as randomUUID6 } from "node:crypto";
+import { join as join14 } from "node:path";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/server.ts
 init_common();
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import {
   CallToolRequestSchema,
@@ -1971,7 +2814,8 @@ 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)
   };
   const payload = {
     verdict: engineResult.synthesized_verdict.verdict,
@@ -2154,7 +2998,8 @@ 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)
   };
   const payload = {
     verdict: engineResult.synthesized_verdict.verdict,
@@ -2163,6 +3008,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 } : {}
@@ -2419,7 +3267,8 @@ 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)
   };
   const payload = {
     verdict: engineResult.synthesized_verdict.verdict,
@@ -2428,6 +3277,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
@@ -2446,7 +3300,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,
@@ -2624,7 +3482,8 @@ 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)
   };
   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 ?? "";
@@ -4111,7 +4970,8 @@ 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)
   };
   deps.events.append(enrichedEvent);
   return jsonContent(envelope);
@@ -4324,7 +5184,7 @@ async function buildCloudOrStubResponse(args) {
 
 // src/tools/heal/common-heal.ts
 init_common();
-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
@@ -4345,7 +5205,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;
@@ -4403,7 +5263,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;
@@ -4491,7 +5351,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;
@@ -4539,7 +5399,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;
@@ -4585,7 +5445,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;
@@ -4612,7 +5472,7 @@ init_common();
 
 // src/tools/pr/common-pr.ts
 init_common();
-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
@@ -4624,7 +5484,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;
 }
@@ -4661,7 +5521,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;
@@ -4706,7 +5566,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;
@@ -4745,7 +5605,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;
 }
@@ -4780,7 +5640,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;
@@ -4857,7 +5717,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"}`,
@@ -4925,7 +5785,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";
@@ -4985,7 +5845,8 @@ 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)
   });
 }
 
@@ -5023,6 +5884,8 @@ 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 VALID_AGENT_TYPES = ["claude-code", "codex", "cursor", "continue"];
 var MAX_GOAL_CHARS = 500;
@@ -5073,7 +5936,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 + VO_CONTROL_PLANE_ADMIN_TOKEN + VO_TENANT_ID are set; 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 description19 = "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;
@@ -5098,14 +5961,39 @@ function isToolInput19(v) {
   }
   return true;
 }
-function getCloudConfig() {
-  const url = process.env["VO_CONTROL_PLANE_URL"];
-  const token = process.env["VO_CONTROL_PLANE_ADMIN_TOKEN"];
-  const tenant_id = process.env["VO_TENANT_ID"];
-  if (!url || !token || !tenant_id) return null;
-  return { url, token, tenant_id };
+async function fetchCloudIdentity(url, token, fetchFn) {
+  try {
+    const response = await fetchFn(`${url}/api/v1/auth/me`, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${token}`
+      }
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    if (!data.ok || !data.provisioned || !data.operator_id || !data.tenant_id) return null;
+    return { operator_id: data.operator_id, tenant_id: data.tenant_id };
+  } catch {
+    return null;
+  }
+}
+async function getCloudConfig(fetchFn = fetch) {
+  const url = process.env["VO_CONTROL_PLANE_URL"]?.trim();
+  if (!url) return null;
+  const tokenSource = createAuthTokenSourceFromEnv(
+    process.env,
+    fetchFn,
+    () => readStoredCredential(process.env)
+  );
+  const token = await tokenSource?.getToken();
+  if (!token) return null;
+  const tenant_id = process.env["VO_TENANT_ID"]?.trim();
+  if (tenant_id) return { url, token, tenant_id };
+  const identity = await fetchCloudIdentity(url, token, fetchFn);
+  if (!identity) return null;
+  return { url, token, tenant_id: identity.tenant_id, operator_id: identity.operator_id };
 }
-async function tryCloudReportState(cloud, input) {
+async function tryCloudReportState(cloud, input, fetchFn = fetch) {
   try {
     const reportBody = {
       context_used_pct: input.context_used_pct
@@ -5118,7 +6006,7 @@ async function tryCloudReportState(cloud, input) {
       reportBody["recent_tool_uses"] = input.recent_tool_uses;
     }
     const reportUrl = `${cloud.url}/api/v1/session/${input.session_id}/report-state`;
-    let response = await fetch(reportUrl, {
+    let response = await fetchFn(reportUrl, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -5128,7 +6016,7 @@ async function tryCloudReportState(cloud, input) {
     });
     if (response.status === 404) {
       const allocateBody = {
-        operator_id: input.operator_id,
+        operator_id: cloud.operator_id ?? input.operator_id,
         tenant_id: cloud.tenant_id,
         agent_type: input.agent_type,
         current_goal: input.current_goal ?? "Interactive session"
@@ -5137,7 +6025,7 @@ async function tryCloudReportState(cloud, input) {
         allocateBody["initial_context_used_pct"] = input.context_used_pct;
       }
       const allocateUrl = `${cloud.url}/api/v1/session`;
-      const allocateResponse = await fetch(allocateUrl, {
+      const allocateResponse = await fetchFn(allocateUrl, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -5148,7 +6036,10 @@ async function tryCloudReportState(cloud, input) {
       if (!allocateResponse.ok) {
         return null;
       }
-      response = await fetch(reportUrl, {
+      const allocateData = await allocateResponse.json();
+      const retrySessionId = typeof allocateData.session?.session_id === "string" && allocateData.session.session_id.length > 0 ? allocateData.session.session_id : input.session_id;
+      const retryReportUrl = `${cloud.url}/api/v1/session/${retrySessionId}/report-state`;
+      response = await fetchFn(retryReportUrl, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -5187,7 +6078,7 @@ async function handleReportSessionState(deps, rawInput, _signal) {
       `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}).`
     );
   }
-  const cloud = getCloudConfig();
+  const cloud = await getCloudConfig();
   if (cloud !== null) {
     const cloudPayload = await tryCloudReportState(cloud, rawInput);
     if (cloudPayload !== null) {
@@ -5214,9 +6105,324 @@ async function handleReportSessionState(deps, rawInput, _signal) {
 // src/tools/session/spawn-successor.ts
 init_common();
 import { spawn } from "node:child_process";
+import { homedir as homedir5 } from "node:os";
+import { join as join7 } from "node:path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, openSync as openSync2, readFileSync as readFileSync7, readdirSync as readdirSync3, statSync as statSync3 } 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 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 {
+    parsed = JSON.parse(raw);
+  } catch {
+    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
+  };
+}
+function inheritSwarmTierBinding(env, nowIso) {
+  return parseSwarmTierBinding(env[SWARM_TIER_BINDING_ENV], nowIso);
+}
+function bindingEnvFragment(binding) {
+  return { [SWARM_TIER_BINDING_ENV]: serializeSwarmTierBinding(binding) };
+}
+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}` };
+  }
+  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";
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, openSync, readFileSync as readFileSync6, readdirSync as readdirSync3, statSync as statSync3 } from "node:fs";
+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(path3, contents) {
+  let fd;
+  try {
+    fd = openSync(path3, "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 path3 = join6(swarmDir, CEILING_FILE);
+  const head = JSON.stringify({
+    ceiling: proposedCeiling,
+    cap_cents: proposedCapCents,
+    recorded_at: nowIso
+  });
+  if (createExclusive(path3, head)) {
+    return { ceiling: proposedCeiling, capCents: proposedCapCents };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync6(path3, "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/tools/session/spawn-successor.ts
 var TOOL_NAME20 = "vo_spawn_successor";
 var MAX_HANDOFF_BYTES = 64e3;
 var inputSchema20 = {
@@ -5237,11 +6443,16 @@ var inputSchema20 = {
     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 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;
@@ -5250,12 +6461,18 @@ function isToolInput20(v) {
   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 newestHandoff(dir = join6(homedir4(), ".vo", "handoffs")) {
+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: statSync3(join6(dir, f)).mtimeMs })).sort((a, b) => b.m - a.m);
-    return entries.length > 0 && entries[0] ? join6(dir, entries[0].f) : null;
+    const entries = readdirSync3(dir).filter((f) => f.endsWith(".md")).map((f) => ({ f, m: statSync3(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;
   }
@@ -5271,7 +6488,7 @@ var MANDATORY_READS = [
 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",
+    "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.",
@@ -5282,7 +6499,7 @@ function buildSuccessorPrompt(handoffMarkdown, goal) {
     "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",
+    "branch; finish line is MERGED + DEPLOYED + LIVE-VERIFIED, and AlgoHQ changes update",
     "the roadmap in the same PR.",
     "",
     "--- HANDOFF ---",
@@ -5292,147 +6509,759 @@ function buildSuccessorPrompt(handoffMarkdown, goal) {
   if (goal && goal.trim().length > 0) lines.push("", `OPERATOR GOAL OVERRIDE: ${goal.trim()}`);
   return lines.join("\n");
 }
-function buildSuccessorArgs(maxTurns) {
-  const args = ["-p", "--permission-mode", "acceptEdits"];
-  if (Number.isInteger(maxTurns) && maxTurns > 0) {
-    args.push("--max-turns", String(maxTurns));
+function buildSuccessorArgs(maxTurns) {
+  const args = ["-p", "--permission-mode", "acceptEdits"];
+  if (Number.isInteger(maxTurns) && maxTurns > 0) {
+    args.push("--max-turns", String(maxTurns));
+  }
+  return args;
+}
+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();
+    if (explicit) {
+      const resolved2 = resolveSuccessorLaunch({ agent: explicit, 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
+      };
+    }
+    return {
+      ok: true,
+      bin: "claude",
+      args: buildSuccessorArgs(input.max_turns),
+      agent: "claude",
+      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
+  };
+}
+async function handleSpawnSuccessor(_deps, rawInput, _signal, spawnImpl = spawn) {
+  const retired = retiredCounterRefusal(rawInput);
+  if (retired !== null) throw invalidParams(TOOL_NAME20, retired);
+  if (!isToolInput20(rawInput)) {
+    throw invalidParams(TOOL_NAME20, "invalid input. Optional: { handoff_path, goal, cwd, max_turns, agent }.");
+  }
+  const handoffPath = rawInput.handoff_path?.trim() || newestHandoff();
+  if (!handoffPath || !existsSync4(handoffPath)) {
+    return jsonContent({
+      tool: TOOL_NAME20,
+      schema_version: 1,
+      payload: {
+        spawned: false,
+        reason: rawInput.handoff_path ? `handoff not found: ${rawInput.handoff_path}` : "no handoff docs in ~/.vo/handoffs \u2014 write one first (the 85% directive does this)"
+      }
+    });
+  }
+  const handoff = readFileSync7(handoffPath, "utf8").slice(0, MAX_HANDOFF_BYTES);
+  const prompt = buildSuccessorPrompt(handoff, rawInput.goal);
+  const plan = resolveSpawnPlan(process.env, rawInput, (/* @__PURE__ */ new Date()).toISOString());
+  if (!plan.ok) {
+    return jsonContent({
+      tool: TOOL_NAME20,
+      schema_version: 1,
+      payload: {
+        spawned: false,
+        reason: `swarm tier binding refused this spawn: ${plan.reason}`,
+        tier: plan.tier,
+        handoff_path: handoffPath
+      }
+    });
+  }
+  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(plan.bin, [...plan.args], {
+    cwd: rawInput.cwd?.trim() || process.cwd(),
+    detached: true,
+    stdio: ["pipe", logFd, logFd],
+    // Windows: the agent CLIs are .cmd shims — they need a shell to resolve.
+    // The prompt goes via STDIN below, never argv, so the shell never sees it.
+    shell: process.platform === "win32",
+    windowsHide: true,
+    // 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 } } : {}
+  });
+  let spawnError = null;
+  child.on("error", (e) => {
+    spawnError = e.message;
+  });
+  try {
+    child.stdin.write(prompt);
+    child.stdin.end();
+  } catch {
+  }
+  child.unref();
+  await new Promise((r) => setTimeout(r, 150));
+  return jsonContent({
+    tool: TOOL_NAME20,
+    schema_version: 1,
+    payload: spawnError ? { spawned: false, reason: `spawn failed: ${spawnError}`, agent: plan.agent, tier: plan.tier, handoff_path: handoffPath } : {
+      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
+    }
+  });
+}
+
+// src/tools/concierge/dispatch.ts
+init_common();
+
+// src/tools/concierge/common-concierge.ts
+var CONCIERGE_STUB_REASON = "cloud mode not active in this MCP runtime \u2014 set VO_CONTROL_PLANE_URL + VO_CONTROL_PLANE_ADMIN_TOKEN to enable. The server-side /api/v1/admin/concierge/dispatch endpoint IS built + deployed (vo-control-plane #5724/#5734); in cloud mode this tool returns the routed pack README + file index.";
+var CONCIERGE_GATE_TYPE = "concierge-dispatch";
+var KNOWN_CONCIERGE_PACKS = [
+  "gcp",
+  "firebase",
+  "aws",
+  "cloudflare",
+  "vercel",
+  "netlify",
+  "tax",
+  "hybrid"
+];
+function isKnownConciergePack(value) {
+  return typeof value === "string" && KNOWN_CONCIERGE_PACKS.includes(value);
+}
+
+// src/tools/concierge/dispatch.ts
+var TOOL_NAME21 = "vo_concierge_dispatch";
+var CALLABLE_NAME10 = "voConciergeDispatch";
+var ADMIN_PATH10 = "/api/v1/admin/concierge/dispatch";
+var inputSchema21 = {
+  type: "object",
+  properties: {
+    pack: {
+      type: "string",
+      description: `Explicit knowledge pack name. One of: ${KNOWN_CONCIERGE_PACKS.join(", ")}. When provided, overrides tenant-based routing. Omit to let server route by tenant_id.`,
+      enum: [...KNOWN_CONCIERGE_PACKS]
+    },
+    tenant_id: {
+      type: "string",
+      description: "Tenant identifier. When provided (and pack is omitted), the server looks up Tenant.cloud_provider and dispatches to the matching pack. Ignored when pack is also provided."
+    }
+  },
+  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'`.";
+function isToolInput21(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const obj = v;
+  if (obj.pack !== void 0 && typeof obj.pack !== "string") return false;
+  if (obj.tenant_id !== void 0 && typeof obj.tenant_id !== "string") return false;
+  return true;
+}
+async function handleConciergeDispatch(deps, rawInput, _signal) {
+  if (!isToolInput21(rawInput)) {
+    throw invalidParams(
+      TOOL_NAME21,
+      "invalid input. Expected { pack?: string, tenant_id?: string }."
+    );
+  }
+  if (rawInput.pack !== void 0 && rawInput.pack !== "" && !isKnownConciergePack(rawInput.pack)) {
+    throw invalidParams(
+      TOOL_NAME21,
+      `unknown pack: ${JSON.stringify(rawInput.pack)}. Known packs: ${KNOWN_CONCIERGE_PACKS.join(", ")}.`
+    );
+  }
+  const normalizedInput = {};
+  if (rawInput.pack) normalizedInput.pack = rawInput.pack;
+  if (rawInput.tenant_id) normalizedInput.tenant_id = rawInput.tenant_id;
+  const cloudBody = {};
+  if (rawInput.pack) cloudBody.pack = rawInput.pack;
+  if (rawInput.tenant_id) cloudBody.tenantId = rawInput.tenant_id;
+  return buildCloudOrStubResponse({
+    toolName: TOOL_NAME21,
+    callableName: CALLABLE_NAME10,
+    adminPath: ADMIN_PATH10,
+    normalizedInput,
+    cloudBody,
+    // Concierge dispatch returns `{ok, mode, routed_from, pack|packs}`,
+    // NOT the callable-proxy `{ok, callable, result}` shape — take the
+    // raw envelope as response_data instead of mandating `.result`.
+    rawEnvelope: true,
+    gateType: CONCIERGE_GATE_TYPE,
+    stubReason: CONCIERGE_STUB_REASON,
+    // Read-only pack fetch — stays live under VO_ADMIN_CALLABLES_READONLY.
+    readOnly: true,
+    deps
+  });
+}
+
+// src/server.ts
+init_sync_config();
+
+// src/tools/memory/private-knowledge.ts
+init_common();
+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 = {
+  type: "object",
+  properties: {
+    knowledge_class: { type: "string", enum: KNOWLEDGE_CLASSES },
+    source_path: { type: "string", description: "Stable private source identifier; not exposed to other users." },
+    title: { type: "string", description: 'Descriptive, retrieval-friendly title (e.g. "AlgoTax OCR redaction architecture", not "notes") \u2014 retrieval matches on it.' },
+    content: { type: "string", description: "Private knowledge text to store server-side. Keep each entry tight and focused (~1-3 pages, under ~12k chars); split larger corpora into separate entries." }
+  },
+  required: ["knowledge_class", "source_path", "title", "content"],
+  additionalProperties: false
+};
+var contextInputSchema = {
+  type: "object",
+  properties: {
+    query: { type: "string" },
+    limit: { type: "number", minimum: 1, maximum: 50 },
+    knowledge_class: { type: "string", enum: KNOWLEDGE_CLASSES }
+  },
+  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);
+}
+function isUpsertInput(value) {
+  if (typeof value !== "object" || value === null) return false;
+  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;
+  if (typeof input["query"] !== "string") return false;
+  if (input["limit"] !== void 0 && typeof input["limit"] !== "number") return false;
+  if (input["knowledge_class"] !== void 0 && !isKnowledgeClass(input["knowledge_class"])) return false;
+  return true;
+}
+async function getCloudAuth(fetchFn) {
+  const controlPlaneUrl = process.env["VO_CONTROL_PLANE_URL"]?.replace(/\/+$/, "");
+  if (!controlPlaneUrl) {
+    return { ok: false, reason: "VO_CONTROL_PLANE_URL not set \u2014 cloud mode disabled" };
+  }
+  const { createAuthTokenSourceFromEnv: createAuthTokenSourceFromEnv2 } = await Promise.resolve().then(() => (init_auth_token_source(), auth_token_source_exports));
+  const { readStoredCredential: readStoredCredential2 } = await Promise.resolve().then(() => (init_credential_store(), credential_store_exports));
+  const tokenSource = createAuthTokenSourceFromEnv2(process.env, fetchFn, () => readStoredCredential2(process.env));
+  if (!tokenSource) return { ok: false, reason: "No auth configured. Run `vo-mcp login`." };
+  const token = await tokenSource.getToken();
+  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) {
+  const auth = await getCloudAuth(fetchFn);
+  if (!auth.ok) return { ok: false, reason: auth.reason };
+  const response = await fetchFn(`${auth.controlPlaneUrl}${path3}`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${auth.token}`,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  const text = await response.text();
+  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 };
+  }
+  return parsed;
+}
+async function handlePrivateKnowledgeUpsert(_deps, rawInput, _signal, fetchFn = globalThis.fetch) {
+  if (!isUpsertInput(rawInput)) {
+    throw invalidParams(UPSERT_TOOL_NAME, "expected { knowledge_class, source_path, title, content }.");
+  }
+  const payload = await callPrivateKnowledge("/api/v1/knowledge/private", rawInput, fetchFn);
+  const envelope = {
+    tool: UPSERT_TOOL_NAME,
+    schema_version: 1,
+    payload
+  };
+  if (rawInput.content.length > PRECISION_CHAR_BUDGET) {
+    envelope.precision_note = `content is ${rawInput.content.length} chars (> ${PRECISION_CHAR_BUDGET}). Tight 1-3 page entries retrieve better \u2014 consider splitting into focused entries, then re-test retrieval via ${CONTEXT_TOOL_NAME}.`;
+  }
+  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 }.");
+  }
+  const payload = await callPrivateKnowledge("/api/v1/knowledge/private/context", rawInput, fetchFn);
+  return jsonContent({ tool: CONTEXT_TOOL_NAME, schema_version: 1, payload });
+}
+
+// src/tools/hq/whiteboard.ts
+init_auth_token_source();
+init_credential_store();
+init_common();
+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;
   }
-  return args;
 }
-async function handleSpawnSuccessor(_deps, rawInput, _signal, spawnImpl = spawn) {
-  if (!isToolInput20(rawInput)) {
-    throw invalidParams(TOOL_NAME20, "invalid input. Optional: { handoff_path, goal, cwd, max_turns }.");
+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 handoffPath = rawInput.handoff_path?.trim() || newestHandoff();
-  if (!handoffPath || !existsSync4(handoffPath)) {
-    return jsonContent({
-      tool: TOOL_NAME20,
-      schema_version: 1,
-      payload: {
-        spawned: false,
-        reason: rawInput.handoff_path ? `handoff not found: ${rawInput.handoff_path}` : "no handoff docs in ~/.vo/handoffs \u2014 write one first (the 85% directive does this)"
-      }
-    });
+  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);
   }
-  const handoff = readFileSync6(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), {
-    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
-  });
-  let spawnError = null;
-  child.on("error", (e) => {
-    spawnError = e.message;
-  });
   try {
-    child.stdin.write(prompt);
-    child.stdin.end();
-  } catch {
+    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)
+    };
   }
-  child.unref();
-  await new Promise((r) => setTimeout(r, 150));
-  return jsonContent({
-    tool: TOOL_NAME20,
-    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 }
-  });
+}
+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/concierge/dispatch.ts
-init_common();
+// src/tools/skills/skill-corpus.ts
+import { existsSync as existsSync9, statSync as statSync6 } from "node:fs";
+import { dirname as dirname5, isAbsolute, join as join13, resolve as resolve2 } from "node:path";
 
-// src/tools/concierge/common-concierge.ts
-var CONCIERGE_STUB_REASON = "cloud mode not active in this MCP runtime \u2014 set VO_CONTROL_PLANE_URL + VO_CONTROL_PLANE_ADMIN_TOKEN to enable. The server-side /api/v1/admin/concierge/dispatch endpoint IS built + deployed (vo-control-plane #5724/#5734); in cloud mode this tool returns the routed pack README + file index.";
-var CONCIERGE_GATE_TYPE = "concierge-dispatch";
-var KNOWN_CONCIERGE_PACKS = [
-  "gcp",
-  "firebase",
-  "aws",
-  "cloudflare",
-  "vercel",
-  "netlify",
-  "tax",
-  "hybrid"
-];
-function isKnownConciergePack(value) {
-  return typeof value === "string" && KNOWN_CONCIERGE_PACKS.includes(value);
+// ../skill-registry/src/loader.ts
+import { readdirSync as readdirSync6, readFileSync as readFileSync14, statSync as statSync5 } 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 description23 = "";
+  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") description23 = value;
+  }
+  if (name.length === 0) {
+    throw new InvalidSkillFrontmatterError(sourcePath, 'missing required field "name"');
+  }
+  if (description23.length === 0) {
+    throw new InvalidSkillFrontmatterError(sourcePath, 'missing required field "description"');
+  }
+  return { name, description: description23, body };
+}
+function loadSkillsFromDir(skillsDir) {
+  const entries = readdirSync6(skillsDir);
+  const skills = [];
+  for (const entry of entries) {
+    const entryPath = join12(skillsDir, entry);
+    let stat;
+    try {
+      stat = statSync5(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: description23, body } = parseFrontmatter(raw, skillFile);
+    skills.push({ name, description: description23, body, sourcePath: skillFile });
+  }
+  return [...skills].sort((a, b) => a.name.localeCompare(b.name));
 }
 
-// src/tools/concierge/dispatch.ts
-var TOOL_NAME21 = "vo_concierge_dispatch";
-var CALLABLE_NAME10 = "voConciergeDispatch";
-var ADMIN_PATH10 = "/api/v1/admin/concierge/dispatch";
-var inputSchema21 = {
+// src/tools/skills/skill-corpus.ts
+init_common();
+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: {
-    pack: {
-      type: "string",
-      description: `Explicit knowledge pack name. One of: ${KNOWN_CONCIERGE_PACKS.join(", ")}. When provided, overrides tenant-based routing. Omit to let server route by tenant_id.`,
-      enum: [...KNOWN_CONCIERGE_PACKS]
-    },
-    tenant_id: {
+    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: "Tenant identifier. When provided (and pack is omitted), the server looks up Tenant.cloud_provider and dispatches to the matching pack. Ignored when pack is also provided."
+      description: "Skill name exactly as returned by vo_skill_list."
     }
   },
-  additionalProperties: false
+  required: ["name"]
 };
-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'`.";
-function isToolInput21(v) {
-  if (typeof v !== "object" || v === null) return false;
-  const obj = v;
-  if (obj.pack !== void 0 && typeof obj.pack !== "string") return false;
-  if (obj.tenant_id !== void 0 && typeof obj.tenant_id !== "string") return false;
-  return true;
+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 existsSync9(abs) && statSync6(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 (existsSync9(candidate) && statSync6(candidate).isDirectory()) return candidate;
+    const parent = dirname5(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
 }
-async function handleConciergeDispatch(deps, rawInput, _signal) {
-  if (!isToolInput21(rawInput)) {
-    throw invalidParams(
-      TOOL_NAME21,
-      "invalid input. Expected { pack?: string, tenant_id?: string }."
-    );
+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."
+    };
   }
-  if (rawInput.pack !== void 0 && rawInput.pack !== "" && !isKnownConciergePack(rawInput.pack)) {
+  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(
-      TOOL_NAME21,
-      `unknown pack: ${JSON.stringify(rawInput.pack)}. Known packs: ${KNOWN_CONCIERGE_PACKS.join(", ")}.`
+      GET_TOOL_NAME,
+      `unknown skill "${requested}". Known skills: ${corpus.skills.map((s) => s.name).join(", ")}`
     );
   }
-  const normalizedInput = {};
-  if (rawInput.pack) normalizedInput.pack = rawInput.pack;
-  if (rawInput.tenant_id) normalizedInput.tenant_id = rawInput.tenant_id;
-  const cloudBody = {};
-  if (rawInput.pack) cloudBody.pack = rawInput.pack;
-  if (rawInput.tenant_id) cloudBody.tenantId = rawInput.tenant_id;
-  return buildCloudOrStubResponse({
-    toolName: TOOL_NAME21,
-    callableName: CALLABLE_NAME10,
-    adminPath: ADMIN_PATH10,
-    normalizedInput,
-    cloudBody,
-    // Concierge dispatch returns `{ok, mode, routed_from, pack|packs}`,
-    // NOT the callable-proxy `{ok, callable, result}` shape — take the
-    // raw envelope as response_data instead of mandating `.result`.
-    rawEnvelope: true,
-    gateType: CONCIERGE_GATE_TYPE,
-    stubReason: CONCIERGE_STUB_REASON,
-    // Read-only pack fetch — stays live under VO_ADMIN_CALLABLES_READONLY.
-    readOnly: true,
-    deps
+  return jsonContent({
+    corpus_available: true,
+    skill: {
+      name: skill.name,
+      description: skill.description,
+      instructions: skill.body,
+      source_path: skill.sourcePath
+    }
   });
 }
 
 // src/server.ts
-init_sync_config();
 function buildToolRegistry() {
   return {
     [TOOL_NAME]: {
@@ -5610,11 +7439,75 @@ function buildToolRegistry() {
         inputSchema: inputSchema22
       },
       handler: handleSyncConfig
+    },
+    [UPSERT_TOOL_NAME]: {
+      definition: {
+        name: UPSERT_TOOL_NAME,
+        description: upsertDescription,
+        inputSchema: upsertInputSchema
+      },
+      handler: handlePrivateKnowledgeUpsert
+    },
+    [CONTEXT_TOOL_NAME]: {
+      definition: {
+        name: CONTEXT_TOOL_NAME,
+        description: contextDescription,
+        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(
@@ -5663,9 +7556,9 @@ function createServer(options) {
 }
 
 // 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
@@ -5710,7 +7603,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);
@@ -5741,7 +7634,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("|");
@@ -5836,7 +7729,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
@@ -5868,7 +7761,7 @@ function createStubRatchetClient() {
     }
   };
 }
-function clip(s, n) {
+function clip2(s, n) {
   return s.length <= n ? s : s.slice(0, n) + "\u2026";
 }
 function buildSummary2(args) {
@@ -5879,7 +7772,7 @@ function buildSummary2(args) {
 // src/consensus/engine-client.ts
 init_events_writer();
 init_common();
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 
 // src/consensus/null-client.ts
 var NULL_CLIENT_DEFAULT_REASON = "consensus-engine-package-pending";
@@ -5901,6 +7794,60 @@ function createNullConsensusEngineClient(reason = NULL_CLIENT_DEFAULT_REASON) {
   };
 }
 
+// src/consensus/meta-model-caller.ts
+var META_CONSENSUS_MODEL = "muse-spark-1.1";
+function createMetaModelCaller(options = {}) {
+  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) {
@@ -5954,6 +7901,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 {
@@ -6103,9 +8058,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),
@@ -6158,8 +8115,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.
@@ -6169,6 +8131,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 } : {},
@@ -6184,25 +8150,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"
-};
+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");
   return out;
 }
 async function loadFactoryAndCallers(injectedEngine, injectedShared) {
@@ -6247,14 +8200,12 @@ async function tryCreateEngineConsensusClientFromEnvAsync(options = {}) {
   const callerByProvider = {
     anthropic: loaded.shared.callAnthropicWithMetrics,
     openai: loaded.shared.callOpenAIWithMetrics,
-    google: loaded.shared.callGeminiWithMetrics,
-    deepseek: loaded.shared.callDeepSeekWithMetrics
+    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
+    google: options.models?.google ?? DEFAULT_MODELS.google
   };
   const panel = [];
   for (const p of providers) {
@@ -6296,7 +8247,7 @@ function tryCreateEngineConsensusClientFromEnv(options = {}) {
 }
 
 // src/consensus/moat-client.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 
 // src/consensus/client.ts
 var CANCELLED_REASON = "cancelled";
@@ -6348,7 +8299,7 @@ function createMoatConsensusClient(opts) {
       request.signal?.addEventListener("abort", onAbort, { once: true });
       const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
       const body = JSON.stringify({
-        task_id: randomUUID4(),
+        task_id: randomUUID5(),
         gate_type: request.gate_type,
         excerpt: request.prompt,
         ...request.system_prompt ? { question: request.system_prompt } : {},
@@ -6377,8 +8328,10 @@ function createMoatConsensusClient(opts) {
         }
         const agreeing = normalizeAgreeing(parsed.models_agreeing);
         const reasoning = agreeing !== void 0 ? `${parsed.reason} (${agreeing} models agreeing)` : parsed.reason;
+        const receiptId = typeof parsed.decision_id === "string" && parsed.decision_id.trim().length > 0 ? parsed.decision_id.trim().slice(0, 120) : null;
         return {
           ok: true,
+          ...receiptId ? { receipt_id: receiptId } : {},
           synthesized_verdict: {
             verdict: parsed.approved ? "pass" : "fail",
             confidence: normalizeConfidence(parsed.confidence),
@@ -6419,6 +8372,68 @@ function tryCreateMoatConsensusClientFromEnv(env = process.env, fetchFn) {
   });
 }
 
+// src/consensus/fallback-client.ts
+var MIN_VALID_LOCAL_VERDICTS = 2;
+var INSUFFICIENT_LOCAL_VERDICTS_REASON = "local-panel-insufficient-valid-verdicts";
+function createConsensusFallbackClient(primary, fallback, options = {}) {
+  return {
+    async run(request) {
+      const primaryResult = await primary.run(request);
+      if (request.signal?.aborted || !primaryResult.ok && primaryResult.reason === CANCELLED_REASON) {
+        return primaryResult;
+      }
+      if (primaryResult.ok) {
+        const validVerdicts = primaryResult.per_model_verdicts.filter(
+          (verdict) => verdict.verdict !== "error"
+        );
+        if (validVerdicts.length >= MIN_VALID_LOCAL_VERDICTS) return primaryResult;
+        options.onFallback?.(INSUFFICIENT_LOCAL_VERDICTS_REASON);
+        return fallback.run(request);
+      }
+      options.onFallback?.(primaryResult.reason);
+      return fallback.run(request);
+    }
+  };
+}
+
+// src/consensus/local-credential-env.ts
+import { createRequire as createRequire2 } from "node:module";
+var require2 = createRequire2(import.meta.url);
+var KEY_SERVICE = "algosuite-vo";
+var KEYCHAIN_TARGETS = [
+  { account: "anthropic-api-key", envVar: "ANTHROPIC_API_KEY" },
+  { account: "openai-api-key", envVar: "OPENAI_API_KEY" },
+  { account: "meta-api-key", envVar: "MODEL_API_KEY" }
+];
+function loadEntryCtor() {
+  try {
+    return require2("@napi-rs/keyring").Entry ?? null;
+  } catch {
+    return null;
+  }
+}
+function readKey(EntryCtor, account) {
+  try {
+    return new EntryCtor(KEY_SERVICE, account).getPassword()?.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function withLocalConsensusCredentials(baseEnv = process.env, options = {}) {
+  const env = { ...baseEnv };
+  if (!env.OPENAI_API_KEY?.trim() && env.CODEX_API_KEY?.trim()) {
+    env.OPENAI_API_KEY = env.CODEX_API_KEY;
+  }
+  const EntryCtor = options.EntryCtor === void 0 ? loadEntryCtor() : options.EntryCtor;
+  if (!EntryCtor) return env;
+  for (const target of KEYCHAIN_TARGETS) {
+    if (env[target.envVar]?.trim()) continue;
+    const key = readKey(EntryCtor, target.account);
+    if (key) env[target.envVar] = key;
+  }
+  return env;
+}
+
 // src/cloud/login.ts
 init_credential_store();
 import { createServer as createServer2 } from "node:http";
@@ -6453,7 +8468,7 @@ function processCapture(rawBody, expectedState, store) {
   };
 }
 function captureHtml() {
-  return `<!doctype html><html><head><meta charset="utf-8"><title>VO login</title></head>
+  return `<!doctype html><html><head><meta charset="utf-8"><title>AlgoHQ login</title></head>
 <body style="font-family:system-ui;max-width:32rem;margin:4rem auto;text-align:center">
 <h2 id="m">Completing sign-in\u2026</h2>
 <script>
@@ -6469,7 +8484,7 @@ function captureHtml() {
 function defaultOpenBrowser(url) {
   const platform = process.platform;
   if (platform === "win32") {
-    spawn2("cmd", ["/c", "start", "", url], { detached: true, stdio: "ignore" }).unref();
+    spawn2("rundll32", ["url.dll,FileProtocolHandler", url], { detached: true, stdio: "ignore" }).unref();
   } else if (platform === "darwin") {
     spawn2("open", [url], { detached: true, stdio: "ignore" }).unref();
   } else {
@@ -6484,7 +8499,7 @@ async function runLogin(opts = {}) {
   const nowIso = opts.nowIso ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   const openBrowser = opts.openBrowser ?? defaultOpenBrowser;
   const state = randomBytes(32).toString("base64url");
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     let settled = false;
     const finish = (err, result) => {
       if (settled) return;
@@ -6492,7 +8507,7 @@ async function runLogin(opts = {}) {
       clearTimeout(timer);
       server.close();
       if (err) reject(err);
-      else resolve(result);
+      else resolve3(result);
     };
     const server = createServer2((req, res) => {
       const url = new URL(req.url ?? "/", "http://127.0.0.1");
@@ -6540,7 +8555,7 @@ async function runLogin(opts = {}) {
               result = { ...capt.email ? { email: capt.email } : {}, credentialPath: path3 };
             }
             res.writeHead(outcome.httpStatus, { "content-type": "text/html; charset=utf-8" });
-            res.end(outcome.ok ? "<h2>VO login complete \u2014 you can close this tab.</h2>" : `<h2>Login failed: ${outcome.error}</h2>`);
+            res.end(outcome.ok ? "<h2>AlgoHQ login complete \u2014 you can close this tab.</h2>" : `<h2>Login failed: ${outcome.error}</h2>`);
             finish(outcome.ok ? null : new Error(outcome.error ?? "login failed"), result);
           })();
         });
@@ -6607,7 +8622,7 @@ init_common();
 function defaultCacheDbPath() {
   const env = process.env["VO_MCP_DB_PATH"];
   if (env && env.length > 0) return env;
-  return join8(homedir6(), ".claude", "vo-mcp-cache.db");
+  return join14(homedir8(), ".claude", "vo-mcp-cache.db");
 }
 async function probeEngineVersion() {
   try {
@@ -6682,11 +8697,23 @@ async function main() {
   const ratchets = createStubRatchetClient();
   const testModule = process.env["VO_MCP_TEST_ENGINE_MODULE"];
   const testClient = testModule !== void 0 && testModule.length > 0 ? await loadTestEngineClient(testModule) : null;
+  const localEnv = withLocalConsensusCredentials();
+  const localProviders = probeProviders(localEnv);
+  for (const key of ["ANTHROPIC_API_KEY", "OPENAI_API_KEY", "GOOGLE_API_KEY", "DEEPSEEK_API_KEY", "MODEL_API_KEY"]) {
+    if (!process.env[key] && localEnv[key]) process.env[key] = localEnv[key];
+  }
+  const localConsensus = tryCreateEngineConsensusClientFromEnv({ envSource: localEnv });
   const cloudConsensus = testClient ? null : tryCreateMoatConsensusClientFromEnv();
-  if (cloudConsensus) {
-    console.error("[vo-mcp] cloud consensus active \u2014 verdicts via vo-moat-plane (no local model keys)");
+  let consensus = testClient ?? localConsensus;
+  if (!testClient && cloudConsensus && localProviders.length >= 2) {
+    console.error(`[vo-mcp] local-first consensus active (${localProviders.join(", ")}); cloud moat is fallback-only`);
+    consensus = createConsensusFallbackClient(localConsensus, cloudConsensus, {
+      onFallback: (reason) => console.error(`[vo-mcp] local consensus unavailable (${reason}); using cloud moat fallback`)
+    });
+  } else if (!testClient && cloudConsensus) {
+    console.error("[vo-mcp] fewer than 2 linked local providers; cloud moat consensus active");
+    consensus = cloudConsensus;
   }
-  const consensus = testClient ?? cloudConsensus ?? tryCreateEngineConsensusClientFromEnv();
   let adminCallables = null;
   try {
     adminCallables = buildAdminCallableClientFromEnv();
@@ -6722,7 +8749,7 @@ async function main() {
 }
 if (process.argv[2] === "login") {
   const controlPlaneUrl = process.env["VO_CONTROL_PLANE_URL"]?.trim();
-  const credentialLabel = `vo-mcp-cli@${hostname()}`.slice(0, 200);
+  const credentialLabel = `vo-mcp-cli@${hostname2()}`.slice(0, 200);
   runLogin(
     controlPlaneUrl ? {
       exchange: (refreshToken, apiKey) => exchangeForVoCredential({ refreshToken, apiKey, controlPlaneUrl, label: credentialLabel })
@@ -6731,35 +8758,53 @@ if (process.argv[2] === "login") {
     console.error(`[vo-mcp] login successful${r.email ? ` as ${r.email}` : ""}. Credential stored at ${r.credentialPath}.`);
     console.error("[vo-mcp] You can now remove VO_CONTROL_PLANE_ADMIN_TOKEN (the god-token) from your MCP config.");
     console.error("[vo-mcp] NOTE: per-user auth requires VO_OPERATOR_ALLOWED_EMAILS (with your email) on the deployed control-plane.");
-    process.exit(0);
   }).catch((err) => {
     console.error("[vo-mcp] login failed:", err instanceof Error ? err.message : String(err));
-    process.exit(1);
+    process.exitCode = 1;
   });
 } else if (process.argv[2] === "sync") {
   const action = process.argv[3];
   if (action !== "push" && action !== "pull") {
-    console.error("[vo-mcp] usage: vo-mcp sync <push|pull> [--cwd <path>]");
+    console.error("[vo-mcp] usage: vo-mcp sync <push|pull> [--cwd <path>] [--lock-wait-ms <n>]");
     process.exit(2);
   }
   const cwdFlag = process.argv.indexOf("--cwd");
   const cwd = cwdFlag >= 0 && typeof process.argv[cwdFlag + 1] === "string" ? process.argv[cwdFlag + 1] : process.cwd();
-  const sessionId = randomUUID5();
+  const waitFlag = process.argv.indexOf("--lock-wait-ms");
+  const parsedWait = waitFlag >= 0 ? Number(process.argv[waitFlag + 1]) : Number.NaN;
+  const lockOptions = Number.isFinite(parsedWait) && parsedWait >= 0 ? { waitMs: parsedWait } : {};
+  const sessionId = randomUUID6();
+  const appendSyncLog = async (line) => {
+    try {
+      const { appendFileSync: appendFileSync2, mkdirSync: mkdirSync8 } = await import("node:fs");
+      const { join: join15 } = await import("node:path");
+      const { homedir: homedir9 } = await import("node:os");
+      const dir = join15(homedir9(), ".claude");
+      mkdirSync8(dir, { recursive: true });
+      appendFileSync2(join15(dir, "vo-mcp-sync.log"), `${line}
+`, "utf8");
+    } catch {
+    }
+  };
   Promise.resolve().then(() => (init_sync_config(), sync_config_exports)).then(async ({ runMemorySync: runMemorySync2, isNoopSyncReason: isNoopSyncReason2 }) => {
-    const r = await runMemorySync2(action, cwd, sessionId);
+    const r = await runMemorySync2(action, cwd, sessionId, void 0, lockOptions);
+    const stamp = `${sessionId} ${action}`;
     if (r.synced) {
       console.error(`[vo-mcp] sync ${action} ok: ${JSON.stringify(r)}`);
-      process.exit(0);
-    }
-    if (isNoopSyncReason2(r.reason)) {
+      await appendSyncLog(`ok ${stamp} ${JSON.stringify(r)}`);
+    } else if (isNoopSyncReason2(r.reason)) {
       console.error(`[vo-mcp] sync ${action} skipped: ${r.reason}`);
-      process.exit(0);
+      await appendSyncLog(`skip ${stamp} ${r.reason ?? ""}`);
+    } else {
+      console.error(`[vo-mcp] sync ${action} failed: ${r.reason}`);
+      await appendSyncLog(`FAIL ${stamp} ${r.reason ?? ""}`);
+      process.exitCode = 1;
     }
-    console.error(`[vo-mcp] sync ${action} failed: ${r.reason}`);
-    process.exit(1);
-  }).catch((err) => {
-    console.error("[vo-mcp] sync fatal:", err instanceof Error ? err.message : String(err));
-    process.exit(1);
+  }).catch(async (err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error("[vo-mcp] sync fatal:", message);
+    await appendSyncLog(`FATAL ${sessionId} ${action} ${message}`);
+    process.exitCode = 1;
   });
 } else {
   main().catch((err) => {