@algosuite/vo-mcp 0.2.0-beta.49 → 0.2.0-beta.51

package/dist/cli.js

@@ -203,24 +203,24 @@ function defaultOverridePath() {
   return join2(homedir(), ".claude", "vo-arch-defaults.local.json");
 }
 function loadTenantOverride(opts = {}) {
-  const path3 = opts.path ?? defaultOverridePath();
-  if (!existsSync2(path3)) {
+  const path4 = opts.path ?? defaultOverridePath();
+  if (!existsSync2(path4)) {
     return { override: null, source_path: null };
   }
-  const raw = readFileSync2(path3, "utf8");
+  const raw = readFileSync2(path4, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
     const m = err instanceof Error ? err.message : String(err);
-    throw new Error(`vo-arch-defaults: invalid JSON in override ${path3}: ${m}`, { cause: err });
+    throw new Error(`vo-arch-defaults: invalid JSON in override ${path4}: ${m}`, { cause: err });
   }
   try {
     const override = parseOverride(parsed);
-    return { override, source_path: path3 };
+    return { override, source_path: path4 };
   } catch (err) {
     const m = err instanceof Error ? err.message : String(err);
-    throw new Error(`vo-arch-defaults: override schema validation failed for ${path3}: ${m}`, { cause: err });
+    throw new Error(`vo-arch-defaults: override schema validation failed for ${path4}: ${m}`, { cause: err });
   }
 }
 var init_load_override = __esm({
@@ -371,9 +371,9 @@ function globToRegExp(glob) {
   }
   return new RegExp("^" + out + "$");
 }
-function matchesAnyGlob(path3, globs) {
+function matchesAnyGlob(path4, globs) {
   for (const g of globs) {
-    if (globToRegExp(g).test(path3)) return true;
+    if (globToRegExp(g).test(path4)) return true;
   }
   return false;
 }
@@ -1023,7 +1023,16 @@ function assertWithinByteCap(toolName, fieldName, value, maxBytes) {
     );
   }
 }
+function subjectFromEnv(env = process.env) {
+  const code_task_id = (env["VO_CODE_TASK_ID"] ?? "").trim().slice(0, 120);
+  const repo = (env["VO_CODE_TASK_REPO"] ?? "").trim();
+  const subject = {};
+  if (code_task_id) subject.code_task_id = code_task_id;
+  if (repo && REPO_RE.test(repo) && repo.length <= 200) subject.repo = repo;
+  return subject.code_task_id || subject.repo ? subject : null;
+}
 function buildBaseEvent(args) {
+  const subject = args.subject === void 0 ? subjectFromEnv() : args.subject;
   return {
     schema_version: 1,
     event_id: args.eventId ?? randomUUID(),
@@ -1049,7 +1058,12 @@ function buildBaseEvent(args) {
     downstream_outcome: null,
     vo_mcp_version: VO_MCP_VERSION,
     consensus_engine_version: null,
-    cache_hit: false
+    cache_hit: false,
+    // OMIT the key when there is no subject (rather than `subject: null`): the
+    // ingest schema is `.strict()`, so an event with no subject stays valid on a
+    // sink that has not learned the field yet — only subject-carrying events
+    // depend on the sink being current (deploy ordering: sink before producer).
+    ...subject ? { subject } : {}
   };
 }
 function jsonContent(value) {
@@ -1115,6 +1129,16 @@ function aggregateEventTokenUsage(src, engineUsage) {
     total_cost_usd: anyCost ? costMicroUsd / 1e6 : null
   };
 }
+function trajectoryFromEngine(result, known = {}) {
+  const rounds = typeof result.token_usage?.rounds_counted === "number" && Number.isInteger(result.token_usage.rounds_counted) && result.token_usage.rounds_counted >= 0 ? result.token_usage.rounds_counted : null;
+  const called = result.fan_out_diagnostics?.models_called;
+  const turns = typeof called === "number" && Number.isInteger(called) && called >= 0 ? called : rounds !== null && rounds > 0 ? result.per_model_verdicts.length * rounds : null;
+  const sourceGrounded = result.citation_grade !== void 0 || result.low_confidence_sources !== void 0;
+  const tool_calls = typeof known.tool_calls === "number" && Number.isInteger(known.tool_calls) && known.tool_calls >= 0 ? known.tool_calls : sourceGrounded ? null : 0;
+  if (rounds === null && turns === null && tool_calls === null) return {};
+  const trajectory = { rounds, turns, tool_calls };
+  return { trajectory };
+}
 function toEventSynthesizedVerdict(src) {
   return {
     verdict: src.verdict,
@@ -1122,12 +1146,13 @@ function toEventSynthesizedVerdict(src) {
     reasoning_excerpt: sanitizeExcerpt(src.reasoning_excerpt)
   };
 }
-var VO_MCP_VERSION;
+var VO_MCP_VERSION, REPO_RE;
 var init_common = __esm({
   "src/tools/common.ts"() {
     "use strict";
     init_events_writer();
     VO_MCP_VERSION = readVoMcpVersion();
+    REPO_RE = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/u;
   }
 });
 
@@ -1436,7 +1461,7 @@ var init_safe_memory_file = __esm({
 });
 
 // src/tools/memory/sync-lock-liveness.ts
-import { statSync as statSync4, readFileSync as readFileSync8 } from "node:fs";
+import { statSync as statSync5, readFileSync as readFileSync8 } from "node:fs";
 function defaultIsProcessAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -1462,10 +1487,10 @@ function toPayload(parsed) {
     acquiredAtMs: typeof acquiredAtMs === "number" && Number.isFinite(acquiredAtMs) ? acquiredAtMs : Number.NaN
   };
 }
-function readLockRecord(path3) {
+function readLockRecord(path4) {
   let raw;
   try {
-    raw = readFileSync8(path3, "utf8");
+    raw = readFileSync8(path4, "utf8");
   } catch {
     return null;
   }
@@ -1475,7 +1500,7 @@ function readLockRecord(path3) {
     return { raw, payload: null };
   }
 }
-function lockAgeMs(record, path3, nowMs) {
+function lockAgeMs(record, path4, nowMs) {
   let startedMs = Number.NaN;
   if (record.payload) {
     if (Number.isFinite(record.payload.acquiredAtMs)) {
@@ -1486,7 +1511,7 @@ function lockAgeMs(record, path3, nowMs) {
   }
   if (!Number.isFinite(startedMs)) {
     try {
-      startedMs = statSync4(path3).mtimeMs;
+      startedMs = statSync5(path4).mtimeMs;
     } catch {
       return null;
     }
@@ -1515,17 +1540,17 @@ var init_sync_lock_liveness = __esm({
 });
 
 // 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 { closeSync as closeSync3, mkdirSync as mkdirSync5, openSync as openSync3, readFileSync as readFileSync9, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "node:fs";
 import { hostname } from "node:os";
 import { join as join8 } from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
 function positiveOr(value, fallback) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
 }
-function createExclusive2(path3, contents) {
+function createExclusive2(path4, contents) {
   let fd;
   try {
-    fd = openSync3(path3, "wx");
+    fd = openSync3(path4, "wx");
   } catch (err) {
     const code = err.code;
     return { ok: false, exists: code === "EEXIST", message: err instanceof Error ? err.message : String(err) };
@@ -1533,37 +1558,37 @@ function createExclusive2(path3, contents) {
   try {
     writeFileSync4(fd, contents, "utf8");
   } catch (err) {
-    closeSync2(fd);
+    closeSync3(fd);
     try {
-      unlinkSync2(path3);
+      unlinkSync2(path4);
     } catch {
     }
     return { ok: false, exists: false, message: err instanceof Error ? err.message : String(err) };
   }
-  closeSync2(fd);
+  closeSync3(fd);
   return { ok: true };
 }
-function removeAbandoned(path3, expectedRaw) {
+function removeAbandoned(path4, expectedRaw) {
   let current;
   try {
-    current = readFileSync9(path3, "utf8");
+    current = readFileSync9(path4, "utf8");
   } catch {
     return;
   }
   if (current !== expectedRaw) return;
   try {
-    unlinkSync2(path3);
+    unlinkSync2(path4);
   } catch {
   }
 }
-function makeRelease(path3, token) {
+function makeRelease(path4, token) {
   let released = false;
   return () => {
     if (released) return;
     released = true;
     let raw;
     try {
-      raw = readFileSync9(path3, "utf8");
+      raw = readFileSync9(path4, "utf8");
     } catch {
       return;
     }
@@ -1575,7 +1600,7 @@ function makeRelease(path3, token) {
     }
     if (!stillOurs) return;
     try {
-      unlinkSync2(path3);
+      unlinkSync2(path4);
     } catch {
     }
   };
@@ -1594,7 +1619,7 @@ async function acquireMemorySyncLock(options) {
   }));
   const isProcessAlive = options.isProcessAlive ?? defaultIsProcessAlive;
   const thisHost = hostname();
-  const path3 = join8(options.memoryDir, MEMORY_SYNC_LOCK_FILE);
+  const path4 = join8(options.memoryDir, MEMORY_SYNC_LOCK_FILE);
   if (options.createDir === true) mkdirSync5(options.memoryDir, { recursive: true });
   const deadline = now() + waitMs;
   let backoffMs = INITIAL_BACKOFF_MS;
@@ -1610,30 +1635,30 @@ async function acquireMemorySyncLock(options) {
       acquiredAt: new Date(acquiredAtMs).toISOString(),
       acquiredAtMs
     };
-    const created = createExclusive2(path3, `${JSON.stringify(payload, null, 2)}
+    const created = createExclusive2(path4, `${JSON.stringify(payload, null, 2)}
 `);
     if (created.ok) {
-      return { path: path3, payload, tookOverFrom, release: makeRelease(path3, payload.token) };
+      return { path: path4, payload, tookOverFrom, release: makeRelease(path4, payload.token) };
     }
     if (!created.exists) {
       throw new Error(
-        `memory sync lock ${path3} could not be created (${created.message}) \u2014 refusing to sync without exclusion`
+        `memory sync lock ${path4} could not be created (${created.message}) \u2014 refusing to sync without exclusion`
       );
     }
-    const record = readLockRecord(path3);
+    const record = readLockRecord(path4);
     let reclaimed = false;
     if (record) {
       holderDescription = describeHolder(record);
-      const age = lockAgeMs(record, path3, now());
+      const age = lockAgeMs(record, path4, now());
       if (isLockAbandoned(record, age, ttlMs, isProcessAlive, thisHost)) {
         tookOverFrom = record.payload;
-        removeAbandoned(path3, record.raw);
+        removeAbandoned(path4, 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.`
+        `memory sync lock ${path4} is held by ${holderDescription}; waited ${waitMs}ms \u2014 refusing to sync unlocked (concurrent memory writes corrupt the shared index). If that holder is provably gone, delete the lock file.`
       );
     }
     if (reclaimed) backoffMs = INITIAL_BACKOFF_MS;
@@ -1897,7 +1922,7 @@ var init_memory_push_cache = __esm({
 });
 
 // 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";
+import { existsSync as existsSync6, 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 withRequestTimeout(
@@ -1982,7 +2007,7 @@ async function uploadOne(item, controlPlaneUrl, token, sessionId, fetchFn, deadl
 }
 async function pushMemory(controlPlaneUrl, token, memoryDir, sessionId, fetchFn, options = {}) {
   const empty = { pushed: 0, created: 0, updated: 0, skipped: 0, indexRowsPreserved: 0 };
-  if (!existsSync5(memoryDir)) {
+  if (!existsSync6(memoryDir)) {
     return empty;
   }
   const localFiles = listPushableFiles(memoryDir).map((f) => ({
@@ -2076,7 +2101,7 @@ var init_memory_sync_http = __esm({
 });
 
 // src/tools/memory/sync-kill-switch.ts
-import { existsSync as existsSync6, readFileSync as readFileSync12 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync12 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
 import { join as join10 } from "node:path";
 function memorySyncSentinelPath(home) {
@@ -2095,7 +2120,7 @@ function clip(raw) {
 function evaluateMemorySyncKillSwitch(deps = {}) {
   const env = deps.env ?? process.env;
   const home = deps.home ?? homedir6();
-  const fileExists = deps.fileExists ?? existsSync6;
+  const fileExists = deps.fileExists ?? existsSync7;
   const readFile3 = deps.readFile ?? ((p) => readFileSync12(p, "utf8"));
   const fired = [];
   const rawEnv = env[MEMORY_SYNC_DISABLE_ENV];
@@ -2141,7 +2166,7 @@ __export(memory_knowledge_bridge_exports, {
   extractMemoryTitle: () => extractMemoryTitle,
   upsertMemoryFilesAsKnowledge: () => upsertMemoryFilesAsKnowledge
 });
-import { existsSync as existsSync7, readdirSync as readdirSync5, readFileSync as readFileSync13 } from "node:fs";
+import { existsSync as existsSync8, readdirSync as readdirSync5, readFileSync as readFileSync13 } from "node:fs";
 function extractMemoryTitle(fileName, content) {
   const frontmatter = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (frontmatter) {
@@ -2156,7 +2181,7 @@ async function upsertMemoryFilesAsKnowledge(options) {
   const { controlPlaneUrl, token, memoryDir, fetchFn, cache, deadline } = options;
   let files;
   try {
-    if (!existsSync7(memoryDir)) {
+    if (!existsSync8(memoryDir)) {
       return { attempted: 0, upserted: 0, failed: 0, skipped: 0, failures: [] };
     }
     files = readdirSync5(memoryDir).filter(
@@ -2268,7 +2293,7 @@ __export(sync_config_exports, {
   isNoopSyncReason: () => isNoopSyncReason,
   runMemorySync: () => runMemorySync
 });
-import { existsSync as existsSync8 } from "node:fs";
+import { existsSync as existsSync9 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
 import { join as join11 } from "node:path";
 function isToolInput22(v) {
@@ -2310,7 +2335,7 @@ async function runMemorySync(action, cwd, sessionId, fetchFn = globalThis.fetch,
   }
   const memoryDir = getMemoryDir(cwd);
   const baseUrl = controlPlaneUrl.replace(/\/+$/, "");
-  if (action === "push" && !existsSync8(memoryDir)) {
+  if (action === "push" && !existsSync9(memoryDir)) {
     return {
       synced: true,
       action: "push",
@@ -2431,9 +2456,9 @@ var init_sync_config = __esm({
 });
 
 // src/cli.ts
-import { homedir as homedir8, hostname as hostname2 } from "node:os";
+import { homedir as homedir9, hostname as hostname2 } from "node:os";
 import { randomUUID as randomUUID6 } from "node:crypto";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/server.ts
@@ -2815,7 +2840,8 @@ async function handleCheckHollowTest(deps, rawInput, signal) {
     consensus_confidence: engineResult.synthesized_verdict.confidence,
     duration_ms: engineResult.duration_ms,
     consensus_engine_version: engineResult.engine_version,
-    ...aggregateEventTokenUsage(engineResult.per_model_verdicts, engineResult.token_usage)
+    ...aggregateEventTokenUsage(engineResult.per_model_verdicts, engineResult.token_usage),
+    ...trajectoryFromEngine(engineResult)
   };
   const payload = {
     verdict: engineResult.synthesized_verdict.verdict,
@@ -2999,7 +3025,8 @@ async function handleVerifyAnswer(deps, rawInput, signal) {
     consensus_confidence: engineResult.synthesized_verdict.confidence,
     duration_ms: engineResult.duration_ms,
     consensus_engine_version: engineResult.engine_version,
-    ...aggregateEventTokenUsage(engineResult.per_model_verdicts, engineResult.token_usage)
+    ...aggregateEventTokenUsage(engineResult.per_model_verdicts, engineResult.token_usage),
+    ...trajectoryFromEngine(engineResult)
   };
   const payload = {
     verdict: engineResult.synthesized_verdict.verdict,
@@ -3268,7 +3295,8 @@ async function handleConsensusJudgment(deps, rawInput, signal) {
     consensus_engine_version: engineResult.engine_version,
     per_model_verdicts: perModelForEvent,
     synthesized_verdict: synthForEvent,
-    ...aggregateEventTokenUsage(engineResult.per_model_verdicts, engineResult.token_usage)
+    ...aggregateEventTokenUsage(engineResult.per_model_verdicts, engineResult.token_usage),
+    ...trajectoryFromEngine(engineResult)
   };
   const payload = {
     verdict: engineResult.synthesized_verdict.verdict,
@@ -3483,7 +3511,8 @@ async function handleArchitectureReview(deps, rawInput, signal) {
     consensus_confidence: engineResult.synthesized_verdict.confidence,
     duration_ms: engineResult.duration_ms,
     consensus_engine_version: engineResult.engine_version,
-    ...aggregateEventTokenUsage(engineResult.per_model_verdicts, engineResult.token_usage)
+    ...aggregateEventTokenUsage(engineResult.per_model_verdicts, engineResult.token_usage),
+    ...trajectoryFromEngine(engineResult)
   };
   const escalationRequired = engineResult.escalation_required === true || engineResult.escalation_required === void 0 && engineResult.synthesized_verdict.dissent_summary !== null;
   const escalationReason = engineResult.escalation_reason ?? engineResult.synthesized_verdict.dissent_summary ?? "";
@@ -4971,7 +5000,8 @@ Produce the JSON dispatch plan now.`;
     consensus_engine_version: engineResult.engine_version,
     per_model_verdicts: toEventPerModelVerdicts(engineResult.per_model_verdicts),
     synthesized_verdict: toEventSynthesizedVerdict(engineResult.synthesized_verdict),
-    ...aggregateEventTokenUsage(engineResult.per_model_verdicts, engineResult.token_usage)
+    ...aggregateEventTokenUsage(engineResult.per_model_verdicts, engineResult.token_usage),
+    ...trajectoryFromEngine(engineResult)
   };
   deps.events.append(enrichedEvent);
   return jsonContent(envelope);
@@ -4984,10 +5014,10 @@ init_common();
 init_auth_token_source();
 init_credential_store();
 var AdminCallableError = class extends Error {
-  constructor(status, path3, message) {
+  constructor(status, path4, message) {
     super(message);
     this.status = status;
-    this.path = path3;
+    this.path = path4;
     this.name = "AdminCallableError";
   }
   status;
@@ -5014,21 +5044,21 @@ var HttpAdminCallableClient = class {
     this.fetchFn = config.fetchFn ?? globalThis.fetch;
     this.readOnly = config.readOnly ?? false;
   }
-  async invoke(path3, body, opts) {
-    if (!path3.startsWith("/")) {
+  async invoke(path4, body, opts) {
+    if (!path4.startsWith("/")) {
       throw new Error(
-        `HttpAdminCallableClient.invoke: path must start with '/', got '${path3}'`
+        `HttpAdminCallableClient.invoke: path must start with '/', got '${path4}'`
       );
     }
     const token = await this.tokenSource.getToken();
     if (!token) {
       throw new AdminCallableError(
         401,
-        path3,
-        `admin proxy ${path3}: no auth token available (check VO_USER_REFRESH_TOKEN / VO_USER_ID_TOKEN / VO_CONTROL_PLANE_ADMIN_TOKEN)`
+        path4,
+        `admin proxy ${path4}: no auth token available (check VO_USER_REFRESH_TOKEN / VO_USER_ID_TOKEN / VO_CONTROL_PLANE_ADMIN_TOKEN)`
       );
     }
-    const url = `${this.baseUrl}${path3}`;
+    const url = `${this.baseUrl}${path4}`;
     const response = await this.fetchFn(url, {
       method: "POST",
       headers: {
@@ -5041,8 +5071,8 @@ var HttpAdminCallableClient = class {
     if (response.status < 200 || response.status >= 300) {
       throw new AdminCallableError(
         response.status,
-        path3,
-        `admin proxy ${path3} returned HTTP ${response.status}: ${text.slice(0, 200)}`
+        path4,
+        `admin proxy ${path4} returned HTTP ${response.status}: ${text.slice(0, 200)}`
       );
     }
     let parsed;
@@ -5051,23 +5081,23 @@ var HttpAdminCallableClient = class {
     } catch {
       throw new AdminCallableError(
         response.status,
-        path3,
-        `admin proxy ${path3} returned non-JSON body`
+        path4,
+        `admin proxy ${path4} returned non-JSON body`
       );
     }
     if (typeof parsed !== "object" || parsed === null) {
       throw new AdminCallableError(
         response.status,
-        path3,
-        `admin proxy ${path3} response not an object`
+        path4,
+        `admin proxy ${path4} response not an object`
       );
     }
     const obj = parsed;
     if (obj["ok"] !== true) {
       throw new AdminCallableError(
         response.status,
-        path3,
-        `admin proxy ${path3} returned ok=false: ${JSON.stringify(obj).slice(0, 200)}`
+        path4,
+        `admin proxy ${path4} returned ok=false: ${JSON.stringify(obj).slice(0, 200)}`
       );
     }
     if (opts?.rawEnvelope) {
@@ -5080,8 +5110,8 @@ var HttpAdminCallableClient = class {
     if (!("result" in obj)) {
       throw new AdminCallableError(
         response.status,
-        path3,
-        `admin proxy ${path3} response missing .result field`
+        path4,
+        `admin proxy ${path4} response missing .result field`
       );
     }
     return obj["result"];
@@ -5673,6 +5703,7 @@ async function handleRejectAndRetry(deps, rawInput, _signal) {
 init_common();
 var TOOL_NAME18 = "vo_review_merge";
 var LIST_PATH = "/api/v1/admin/pr/list";
+var DEFAULT_REVIEW_REPO = "Algosuite-ai/Nexus";
 var ENGINE_GATE = "final-deep-verify";
 var EVENT_GATE = "merge-review";
 var UNAVAILABLE_REASON = "vo_review_merge needs cloud mode to fetch PR context \u2014 set VO_CONTROL_PLANE_URL + VO_CONTROL_PLANE_ADMIN_TOKEN in the MCP env. (It is read-only; it never merges.)";
@@ -5737,6 +5768,11 @@ async function handleReviewMerge(deps, rawInput, signal) {
   if (rawInput.notes !== void 0) normalizedInput.notes = rawInput.notes;
   const inputJson = JSON.stringify(normalizedInput);
   const key = deps.cache.keyFor(TOOL_NAME18, normalizedInput);
+  const subject = {
+    ...subjectFromEnv() ?? {},
+    repo: subjectFromEnv()?.repo ?? DEFAULT_REVIEW_REPO,
+    pr_number: prNumber
+  };
   const baseEvent = buildBaseEvent({
     tool: TOOL_NAME18,
     gateType: EVENT_GATE,
@@ -5744,7 +5780,8 @@ async function handleReviewMerge(deps, rawInput, signal) {
     inputExcerpt: inputJson.slice(0, 300),
     inputSizeBytes: bytesOf(inputJson),
     session: deps.session,
-    now: deps.now()
+    now: deps.now(),
+    subject
   });
   const emit = (payload2, eventExtra) => {
     deps.events.append(eventExtra ? { ...baseEvent, ...eventExtra } : baseEvent);
@@ -5846,7 +5883,8 @@ async function handleReviewMerge(deps, rawInput, signal) {
     consensus_engine_version: result.engine_version,
     per_model_verdicts: perModel,
     synthesized_verdict: synth,
-    ...aggregateEventTokenUsage(result.per_model_verdicts, result.token_usage)
+    ...aggregateEventTokenUsage(result.per_model_verdicts, result.token_usage),
+    ...trajectoryFromEngine(result)
   });
 }
 
@@ -6107,7 +6145,7 @@ 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";
+import { closeSync as closeSync2, existsSync as existsSync5, mkdirSync as mkdirSync4, openSync as openSync2, readFileSync as readFileSync7, readdirSync as readdirSync3, statSync as statSync4 } from "node:fs";
 
 // src/swarm/tier-binding.ts
 var SWARM_TIERS = Object.freeze([
@@ -6313,10 +6351,10 @@ function sanitizeSwarmId(raw) {
   return id;
 }
 var CEILING_FILE = "ceiling.json";
-function createExclusive(path3, contents) {
+function createExclusive(path4, contents) {
   let fd;
   try {
-    fd = openSync(path3, "wx");
+    fd = openSync(path4, "wx");
   } catch {
     return false;
   }
@@ -6331,18 +6369,18 @@ function capToCents(cap) {
   return isPositiveCap(cap) ? Math.round(cap * 100) : 0;
 }
 function readOrRecordLedgerHead(swarmDir, proposedCeiling, proposedCapCents, nowIso) {
-  const path3 = join6(swarmDir, CEILING_FILE);
+  const path4 = join6(swarmDir, CEILING_FILE);
   const head = JSON.stringify({
     ceiling: proposedCeiling,
     cap_cents: proposedCapCents,
     recorded_at: nowIso
   });
-  if (createExclusive(path3, head)) {
+  if (createExclusive(path4, head)) {
     return { ceiling: proposedCeiling, capCents: proposedCapCents };
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync6(path3, "utf8"));
+    parsed = JSON.parse(readFileSync6(path4, "utf8"));
   } catch {
     return null;
   }
@@ -6422,6 +6460,288 @@ var claimSpawnSlot = ({ swarmId, proposedCeiling, proposedCapUsd, dir, nowIso })
   };
 };
 
+// src/swarm/spawn-plan.ts
+function resolveSpawnPlan(env, input, nowIso, platform = process.platform, claim = claimSpawnSlot) {
+  const rawBinding = env[SWARM_TIER_BINDING_ENV];
+  const hasBinding = typeof rawBinding === "string" && rawBinding.trim().length > 0;
+  if (!hasBinding) {
+    const explicit = input.agent?.trim();
+    const resolved2 = resolveSuccessorLaunch({ agent: explicit || "claude", maxTurns: input.max_turns, platform });
+    if (!resolved2.ok) return { ok: false, reason: resolved2.reason, tier: "unbound" };
+    return {
+      ok: true,
+      bin: resolved2.bin,
+      args: resolved2.args,
+      agent: resolved2.agent,
+      tier: "unbound",
+      bound: false,
+      env: {},
+      slot: null,
+      capUsd: null,
+      capRemainingUsd: null
+    };
+  }
+  const binding = inheritSwarmTierBinding(env, nowIso);
+  const admission = admitSubagentSpawn(binding);
+  if (!admission.allowed) {
+    return { ok: false, reason: admission.reason, tier: binding.tier };
+  }
+  const agentRefusal = agentBindingRefusal(binding, input.agent);
+  if (agentRefusal !== null) return { ok: false, reason: agentRefusal, tier: binding.tier };
+  const resolved = resolveSuccessorLaunch({
+    agent: binding.agent,
+    maxTurns: input.max_turns,
+    platform
+  });
+  if (!resolved.ok) return { ok: false, reason: resolved.reason, tier: binding.tier };
+  const slot = claim({
+    swarmId: binding.swarm_id,
+    proposedCeiling: binding.subagent_budget,
+    // The spend-cap POOL, recorded once per swarm exactly like the ceiling. The
+    // child's cap is DEBITED from it below, not recomputed from this binding.
+    proposedCapUsd: binding.spend_cap_usd,
+    dir: resolveLedgerDir(env),
+    nowIso
+  });
+  if (!slot.ok) return { ok: false, reason: slot.reason, tier: binding.tier };
+  return {
+    ok: true,
+    bin: resolved.bin,
+    args: resolved.args,
+    agent: resolved.agent,
+    tier: binding.tier,
+    bound: true,
+    // Re-export the same TIER with a DECREMENTED budget and the spend cap the
+    // ledger just DEBITED. Exporting the binding verbatim (what this did before
+    // #9312) meant the child re-read the full budget and every generation
+    // restarted at zero. Recomputing the cap from THIS binding (what #9312 did)
+    // bounded a chain but not a tree: three siblings each re-halved the parent's
+    // untouched $50 and walked away with $75 between them.
+    env: childBindingEnvFragment(binding, slot.capUsd),
+    slot: slot.slot,
+    capUsd: slot.capUsd,
+    capRemainingUsd: slot.capRemainingUsd
+  };
+}
+
+// ../../scripts/virtual-office/code-runner/windows-claude-launch.mjs
+import { existsSync as existsSync4, realpathSync } from "node:fs";
+import { win32 as path3 } from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+var NATIVE_CLAUDE_PARTS = [
+  "node_modules",
+  "@anthropic-ai",
+  "claude-code",
+  "bin",
+  "claude.exe"
+];
+function pathValue(env) {
+  for (const key of ["Path", "PATH", "path"]) {
+    if (typeof env?.[key] === "string") return env[key];
+  }
+  return "";
+}
+function cleanPathSegment(value) {
+  const trimmed = String(value || "").trim();
+  return trimmed.startsWith('"') && trimmed.endsWith('"') ? trimmed.slice(1, -1) : trimmed;
+}
+function envValue(env, name) {
+  const exact = env?.[name];
+  if (typeof exact === "string") return exact.trim();
+  const key = Object.keys(env || {}).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+  return typeof env?.[key] === "string" ? env[key].trim() : "";
+}
+function userClaudeCandidates(bin, env) {
+  if (!/^claude(?:\.(?:exe|cmd|ps1))?$/iu.test(bin)) return [];
+  const userProfile = envValue(env, "USERPROFILE");
+  const appData = envValue(env, "APPDATA") || (userProfile ? path3.join(userProfile, "AppData", "Roaming") : "");
+  const localAppData = envValue(env, "LOCALAPPDATA") || (userProfile ? path3.join(userProfile, "AppData", "Local") : "");
+  const candidates = [];
+  if (appData) {
+    const npmBin = path3.join(appData, "npm");
+    candidates.push(
+      path3.join(npmBin, "claude.exe"),
+      path3.join(npmBin, "claude.cmd"),
+      path3.join(npmBin, "claude.ps1"),
+      path3.join(npmBin, "claude"),
+      path3.join(npmBin, ...NATIVE_CLAUDE_PARTS)
+    );
+  }
+  if (userProfile) candidates.push(path3.join(userProfile, ".local", "bin", "claude.exe"));
+  if (localAppData) {
+    candidates.push(
+      path3.join(localAppData, "Microsoft", "WinGet", "Links", "claude.exe"),
+      path3.join(localAppData, "Microsoft", "WindowsApps", "claude.exe")
+    );
+  }
+  return candidates;
+}
+function pathCandidates(bin, env) {
+  if (path3.isAbsolute(bin) || /[\\/]/u.test(bin)) {
+    return [path3.resolve(bin)];
+  }
+  const extension = path3.extname(bin);
+  const fromPath = pathValue(env).split(";").map(cleanPathSegment).filter(Boolean).flatMap((directory) => extension ? [path3.join(directory, bin)] : [
+    path3.join(directory, `${bin}.exe`),
+    path3.join(directory, `${bin}.cmd`),
+    path3.join(directory, `${bin}.ps1`),
+    path3.join(directory, bin)
+  ]);
+  const seen = /* @__PURE__ */ new Set();
+  return [...fromPath, ...userClaudeCandidates(bin, env)].filter((candidate) => {
+    const key = candidate.toLowerCase();
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function canonicalExistingPath(candidate, exists, canonicalize2) {
+  if (!exists(candidate)) return null;
+  try {
+    return canonicalize2(candidate);
+  } catch {
+    return null;
+  }
+}
+function resolveWindowsClaudeExecutable({
+  bin = "claude",
+  env = process.env,
+  exists = existsSync4,
+  canonicalize: canonicalize2 = realpathSync
+} = {}) {
+  const requested = String(bin || "").trim();
+  if (!requested || requested.includes("\0")) {
+    throw new TypeError("Claude executable must be a non-empty path without NUL bytes");
+  }
+  for (const candidate of pathCandidates(requested, env)) {
+    const found = canonicalExistingPath(candidate, exists, canonicalize2);
+    if (!found) continue;
+    if (path3.extname(found).toLowerCase() === ".exe") return found;
+    const native = path3.join(path3.dirname(found), ...NATIVE_CLAUDE_PARTS);
+    const resolvedNative = canonicalExistingPath(native, exists, canonicalize2);
+    if (resolvedNative) return resolvedNative;
+  }
+  const error = new Error(
+    `Could not resolve a native claude.exe for "${requested}". Install or update Claude Code with the native Windows installer (recommended) or npm install -g @anthropic-ai/claude-code; the HQ runner will not execute a shell-only .cmd/.ps1 shim.`
+  );
+  error.code = "ENOENT";
+  throw error;
+}
+
+// src/swarm/successor-windows-exe.ts
+var resolveWindowsClaudeExe = (bin, env) => resolveWindowsClaudeExecutable({ bin, env });
+function resolveNativeWindowsExecutable(bin, env = process.env, resolve3 = resolveWindowsClaudeExe) {
+  try {
+    return { ok: true, bin: resolve3(bin, env) };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      ok: false,
+      reason: `could not resolve a native Windows executable for '${bin}': ${message}`
+    };
+  }
+}
+
+// src/swarm/successor-liveness.ts
+import { statSync as statSync3 } from "node:fs";
+var DEFAULT_EARLY_EXIT_SEC = 10;
+var DEFAULT_NO_OUTPUT_SEC = 0;
+var DEFAULT_POLL_MS = 200;
+var KILL_ESCALATION_MS = 2e3;
+function positiveSeconds(raw, fallback) {
+  if (raw === void 0) return fallback;
+  const n = Number(raw.trim());
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+function resolveLivenessConfigFromEnv(env = process.env, explicitOverride = {}) {
+  const earlyExitMs = explicitOverride.earlyExitMs ?? positiveSeconds(env["VO_MCP_SUCCESSOR_EXIT_CHECK_SEC"], DEFAULT_EARLY_EXIT_SEC) * 1e3;
+  const noOutputMs = explicitOverride.noOutputMs ?? positiveSeconds(env["VO_MCP_SUCCESSOR_OUTPUT_CHECK_SEC"], DEFAULT_NO_OUTPUT_SEC) * 1e3;
+  return { earlyExitMs, noOutputMs };
+}
+function defaultStatLogBytes(path4) {
+  try {
+    return statSync3(path4).size;
+  } catch {
+    return 0;
+  }
+}
+function defaultKillChild(child) {
+  try {
+    child.kill("SIGTERM");
+  } catch {
+  }
+  const escalation = setTimeout(() => {
+    try {
+      child.kill("SIGKILL");
+    } catch {
+    }
+  }, KILL_ESCALATION_MS);
+  escalation.unref();
+}
+function checkSuccessorLiveness(child, logPath, config, deps = {}) {
+  const statLogBytes = deps.statLogBytes ?? defaultStatLogBytes;
+  const now = deps.now ?? Date.now;
+  const pollIntervalMs = deps.pollIntervalMs ?? DEFAULT_POLL_MS;
+  const killChild = deps.killChild ?? defaultKillChild;
+  const outputGateEnabled = Number.isFinite(config.noOutputMs) && config.noOutputMs > 0;
+  const startedAt = now();
+  return new Promise((resolve3) => {
+    let settled = false;
+    let pollTimer = null;
+    const onExit = (code, signal) => {
+      const elapsedMs = now() - startedAt;
+      finish({
+        ok: false,
+        reason: `child_exited_early: exit code ${code ?? "null"} signal ${signal ?? "none"} after ${elapsedMs}ms`,
+        detail: { exitCode: code, signal, elapsedMs }
+      });
+    };
+    const cleanup = () => {
+      if (pollTimer !== null) clearInterval(pollTimer);
+      child.off?.("exit", onExit);
+    };
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (!result.ok) {
+        try {
+          killChild(child);
+        } catch {
+        }
+      }
+      resolve3(result);
+    };
+    if (typeof child.exitCode === "number" || typeof child.signalCode === "string" && child.signalCode.length > 0) {
+      finish({
+        ok: false,
+        reason: `child_exited_early: exit code ${child.exitCode ?? "null"} signal ${child.signalCode ?? "none"} before the liveness watch attached`,
+        detail: { exitCode: child.exitCode ?? null, signal: child.signalCode ?? null, elapsedMs: 0 }
+      });
+      return;
+    }
+    child.on("exit", onExit);
+    const tick = () => {
+      if (settled) return;
+      const elapsedMs = now() - startedAt;
+      const outputSeen = outputGateEnabled ? statLogBytes(logPath) > 0 : true;
+      if (outputSeen && elapsedMs >= config.earlyExitMs) {
+        finish({ ok: true });
+        return;
+      }
+      if (outputGateEnabled && !outputSeen && elapsedMs >= config.noOutputMs) {
+        finish({
+          ok: false,
+          reason: `no_output: log stayed empty for ${elapsedMs}ms (limit ${config.noOutputMs}ms)`,
+          detail: { elapsedMs, logPath }
+        });
+      }
+    };
+    pollTimer = setInterval(tick, pollIntervalMs);
+    tick();
+  });
+}
+
 // src/tools/session/spawn-successor.ts
 var TOOL_NAME20 = "vo_spawn_successor";
 var MAX_HANDOFF_BYTES = 64e3;
@@ -6453,7 +6773,7 @@ var inputSchema20 = {
   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.";
+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/. Verifies the child is actually alive (survives an early-exit window; an optional log-output window is off by default) before reporting success. Returns {spawned, pid, log_path, handoff_path}. The successor works under the same gates as any session (ADR-001: verify-before-act, human merge approval) \u2014 this tool never fires autonomously.";
 function isToolInput20(v) {
   if (typeof v !== "object" || v === null) return false;
   const o = v;
@@ -6471,7 +6791,7 @@ function retiredCounterRefusal(v) {
 }
 function newestHandoff(dir = join7(homedir5(), ".vo", "handoffs")) {
   try {
-    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);
+    const entries = readdirSync3(dir).filter((f) => f.endsWith(".md")).map((f) => ({ f, m: statSync4(join7(dir, f)).mtimeMs })).sort((a, b) => b.m - a.m);
     return entries.length > 0 && entries[0] ? join7(dir, entries[0].f) : null;
   } catch {
     return null;
@@ -6509,97 +6829,14 @@ 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));
-  }
-  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) {
+async function handleSpawnSuccessor(_deps, rawInput, _signal, spawnImpl = spawn, overrides = {}) {
   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)) {
+  if (!handoffPath || !existsSync5(handoffPath)) {
     return jsonContent({
       tool: TOOL_NAME20,
       schema_version: 1,
@@ -6624,27 +6861,52 @@ async function handleSpawnSuccessor(_deps, rawInput, _signal, spawnImpl = spawn)
       }
     });
   }
+  const platform = overrides.platform ?? process.platform;
+  let resolvedBin = plan.bin;
+  if (platform === "win32") {
+    const resolution = resolveNativeWindowsExecutable(plan.bin, process.env, overrides.resolveWindowsExecutable);
+    if (!resolution.ok) {
+      return jsonContent({
+        tool: TOOL_NAME20,
+        schema_version: 1,
+        payload: {
+          spawned: false,
+          reason: resolution.reason,
+          agent: plan.agent,
+          tier: plan.tier,
+          handoff_path: handoffPath
+        }
+      });
+    }
+    resolvedBin = resolution.bin;
+  }
   const logDir = process.env["VO_MCP_SUCCESSOR_LOG_DIR"]?.trim() || join7(homedir5(), ".vo", "successors");
   mkdirSync4(logDir, { recursive: true });
   const logPath = join7(logDir, `successor-${Date.now()}.log`);
   const logFd = openSync2(logPath, "a");
-  const child = spawnImpl(plan.bin, [...plan.args], {
+  const child = spawnImpl(resolvedBin, [...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",
+    // Never a shell: `resolvedBin` is either the bare platform-neutral name
+    // (POSIX, resolved by the OS via PATH + shebang) or the native win32 exe
+    // resolved above — routing either through cmd.exe/sh is the extra layer
+    // a detached, unref'd child can lose silently (2026-08-16 incident).
+    shell: false,
     windowsHide: true,
+    windowsVerbatimArguments: false,
     // Carry the SAME binding to the child. Without this the successor inherits
     // no tier and re-resolves its own — which is the split-payer defect one
     // generation down.
     ...plan.bound ? { env: { ...process.env, ...plan.env } } : {}
   });
+  closeSync2(logFd);
   let spawnError = null;
   child.on("error", (e) => {
     spawnError = e.message;
   });
+  child.stdin.on?.("error", () => {
+  });
   try {
     child.stdin.write(prompt);
     child.stdin.end();
@@ -6652,10 +6914,40 @@ async function handleSpawnSuccessor(_deps, rawInput, _signal, spawnImpl = spawn)
   }
   child.unref();
   await new Promise((r) => setTimeout(r, 150));
+  if (spawnError) {
+    return jsonContent({
+      tool: TOOL_NAME20,
+      schema_version: 1,
+      payload: {
+        spawned: false,
+        reason: `spawn failed: ${spawnError}`,
+        agent: plan.agent,
+        tier: plan.tier,
+        handoff_path: handoffPath
+      }
+    });
+  }
+  const checkLiveness = overrides.checkLiveness ?? ((c, p) => checkSuccessorLiveness(c, p, resolveLivenessConfigFromEnv(process.env, overrides.livenessConfig), overrides.livenessDeps));
+  const liveness = await checkLiveness(child, logPath);
+  if (!liveness.ok) {
+    return jsonContent({
+      tool: TOOL_NAME20,
+      schema_version: 1,
+      payload: {
+        spawned: false,
+        reason: liveness.reason,
+        pid: child.pid ?? null,
+        log_path: logPath,
+        agent: plan.agent,
+        tier: plan.tier,
+        handoff_path: handoffPath
+      }
+    });
+  }
   return jsonContent({
     tool: TOOL_NAME20,
     schema_version: 1,
-    payload: spawnError ? { spawned: false, reason: `spawn failed: ${spawnError}`, agent: plan.agent, tier: plan.tier, handoff_path: handoffPath } : {
+    payload: {
       spawned: true,
       pid: child.pid ?? null,
       log_path: logPath,
@@ -6667,7 +6959,10 @@ async function handleSpawnSuccessor(_deps, rawInput, _signal, spawnImpl = spawn)
       // 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
+      ledger_cap_remaining_usd: plan.capRemainingUsd,
+      // Additive (2026-08-17): true only once the child survived the
+      // early-exit window (and the output window, when that gate is enabled).
+      verified_alive: true
     }
   });
 }
@@ -6851,10 +7146,10 @@ async function getCloudAuth(fetchFn) {
   if (!token) return { ok: false, reason: "Failed to obtain auth token. Run `vo-mcp login` again." };
   return { ok: true, controlPlaneUrl, token };
 }
-async function callPrivateKnowledge(path3, body, fetchFn) {
+async function callPrivateKnowledge(path4, body, fetchFn) {
   const auth = await getCloudAuth(fetchFn);
   if (!auth.ok) return { ok: false, reason: auth.reason };
-  const response = await fetchFn(`${auth.controlPlaneUrl}${path3}`, {
+  const response = await fetchFn(`${auth.controlPlaneUrl}${path4}`, {
     method: "POST",
     headers: {
       authorization: `Bearer ${auth.token}`,
@@ -7072,11 +7367,11 @@ async function handleHqWhiteboardRead(_deps, rawInput, signal) {
 }
 
 // src/tools/skills/skill-corpus.ts
-import { existsSync as existsSync9, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync10, statSync as statSync7 } from "node:fs";
 import { dirname as dirname5, isAbsolute, join as join13, resolve as resolve2 } from "node:path";
 
 // ../skill-registry/src/loader.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync14, statSync as statSync5 } from "node:fs";
+import { readdirSync as readdirSync6, readFileSync as readFileSync14, statSync as statSync6 } from "node:fs";
 import { join as join12 } from "node:path";
 var InvalidSkillFrontmatterError = class extends Error {
   constructor(skillFile, reason) {
@@ -7133,7 +7428,7 @@ function loadSkillsFromDir(skillsDir) {
     const entryPath = join12(skillsDir, entry);
     let stat;
     try {
-      stat = statSync5(entryPath);
+      stat = statSync6(entryPath);
     } catch {
       continue;
     }
@@ -7183,12 +7478,12 @@ 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;
+    return existsSync10(abs) && statSync7(abs).isDirectory() ? abs : null;
   }
   let dir = resolve2(startDir);
   for (let i = 0; i < MAX_WALK_UP_LEVELS; i += 1) {
     const candidate = join13(dir, ".claude", "skills");
-    if (existsSync9(candidate) && statSync6(candidate).isDirectory()) return candidate;
+    if (existsSync10(candidate) && statSync7(candidate).isDirectory()) return candidate;
     const parent = dirname5(dir);
     if (parent === dir) break;
     dir = parent;
@@ -8396,6 +8691,109 @@ function createConsensusFallbackClient(primary, fallback, options = {}) {
   };
 }
 
+// src/consensus/shadow-client.ts
+import { appendFileSync as appendFileSync2, chmodSync as chmodSync4, mkdirSync as mkdirSync8, renameSync, statSync as statSync8 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { dirname as dirname7, join as join14 } from "node:path";
+var DEFAULT_SHADOW_TIMEOUT_MS = 2e4;
+var SHADOW_RECEIPT_MAX_BYTES = 20 * 1024 * 1024;
+function defaultShadowReceiptPath(env = process.env) {
+  const p = (env["VO_MCP_MOAT_SHADOW_PATH"] ?? "").trim();
+  return p || join14(homedir8(), ".claude", "vo-mcp-moat-shadow.jsonl");
+}
+function appendShadowReceipt(receipt, path4 = defaultShadowReceiptPath()) {
+  try {
+    mkdirSync8(dirname7(path4), { recursive: true, mode: 448 });
+    try {
+      if (statSync8(path4).size > SHADOW_RECEIPT_MAX_BYTES) renameSync(path4, `${path4}.1`);
+    } catch {
+    }
+    appendFileSync2(path4, `${JSON.stringify(receipt)}
+`, "utf8");
+    try {
+      chmodSync4(path4, 384);
+    } catch {
+    }
+  } catch {
+  }
+}
+function summarize(result) {
+  if (result.ok) {
+    return {
+      ok: true,
+      verdict: result.synthesized_verdict.verdict,
+      confidence: result.synthesized_verdict.confidence,
+      ...result.receipt_id ? { receipt_id: result.receipt_id } : {}
+    };
+  }
+  return { ok: false, reason: result.reason };
+}
+async function runMoat(shadow, request, timeoutMs, linkCallerSignal) {
+  const callerSignal = linkCallerSignal ? request.signal : void 0;
+  if (callerSignal?.aborted) return { ok: false, reason: CANCELLED_REASON };
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const onCallerAbort = () => controller.abort();
+  callerSignal?.addEventListener("abort", onCallerAbort, { once: true });
+  try {
+    const { signal: _ignored, ...rest } = request;
+    void _ignored;
+    return await shadow.run({ ...rest, signal: controller.signal });
+  } catch (err) {
+    return { ok: false, reason: `moat-shadow-threw: ${err instanceof Error ? err.message : String(err)}`.slice(0, 200) };
+  } finally {
+    clearTimeout(timer);
+    callerSignal?.removeEventListener("abort", onCallerAbort);
+  }
+}
+function createConsensusShadowClient(primary, shadow, options = {}) {
+  const authoritative = options.authoritative === true;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_SHADOW_TIMEOUT_MS;
+  const now = options.now ?? (() => Date.now());
+  const random = options.random ?? Math.random;
+  const samplePct = Math.min(100, Math.max(0, options.samplePct ?? 100));
+  const onReceipt = options.onReceipt ?? ((r) => appendShadowReceipt(r));
+  function receiptFor(request, local, moat, startedAt) {
+    const l = summarize(local);
+    const m = summarize(moat);
+    return {
+      ts: new Date(now()).toISOString(),
+      gate_type: request.gate_type,
+      mode: authoritative ? "authoritative" : "shadow",
+      local: l,
+      moat: m,
+      agree: l.ok && m.ok ? l.verdict === m.verdict : null,
+      duration_ms: Math.max(0, now() - startedAt)
+    };
+  }
+  return {
+    async run(request) {
+      const startedAt = now();
+      const primaryResult = await primary.run(request);
+      if (request.signal?.aborted || !primaryResult.ok && primaryResult.reason === CANCELLED_REASON) {
+        return primaryResult;
+      }
+      if (!primaryResult.ok || primaryResult.receipt_id) return primaryResult;
+      if (authoritative) {
+        const moatResult = await runMoat(shadow, request, timeoutMs, true);
+        try {
+          onReceipt(receiptFor(request, primaryResult, moatResult, startedAt));
+        } catch {
+        }
+        return moatResult.ok ? moatResult : primaryResult;
+      }
+      if (samplePct < 100 && random() * 100 >= samplePct) return primaryResult;
+      void runMoat(shadow, request, timeoutMs, false).then((moatResult) => {
+        try {
+          onReceipt(receiptFor(request, primaryResult, moatResult, startedAt));
+        } catch {
+        }
+      });
+      return primaryResult;
+    }
+  };
+}
+
 // src/consensus/local-credential-env.ts
 import { createRequire as createRequire2 } from "node:module";
 var require2 = createRequire2(import.meta.url);
@@ -8466,11 +8864,11 @@ function processCapture(rawBody, expectedState, store) {
     return { ok: false, httpStatus: 400, error: "login response missing refresh_token / api_key" };
   }
   const email = typeof data.email === "string" && data.email.trim() ? data.email.trim() : void 0;
-  const path3 = store({ refresh_token: refresh, api_key: apiKey, ...email ? { email } : {} });
+  const path4 = store({ refresh_token: refresh, api_key: apiKey, ...email ? { email } : {} });
   return {
     ok: true,
     httpStatus: 200,
-    result: { ...email ? { email } : {}, credentialPath: path3 },
+    result: { ...email ? { email } : {}, credentialPath: path4 },
     captured: { refresh_token: refresh, api_key: apiKey, ...email ? { email } : {} }
   };
 }
@@ -8558,8 +8956,8 @@ async function runLogin(opts = {}) {
                 }
               } catch {
               }
-              const path3 = writeNow(cred);
-              result = { ...capt.email ? { email: capt.email } : {}, credentialPath: path3 };
+              const path4 = writeNow(cred);
+              result = { ...capt.email ? { email: capt.email } : {}, credentialPath: path4 };
             }
             res.writeHead(outcome.httpStatus, { "content-type": "text/html; charset=utf-8" });
             res.end(outcome.ok ? "<h2>AlgoHQ login complete \u2014 you can close this tab.</h2>" : `<h2>Login failed: ${outcome.error}</h2>`);
@@ -8629,7 +9027,7 @@ init_common();
 function defaultCacheDbPath() {
   const env = process.env["VO_MCP_DB_PATH"];
   if (env && env.length > 0) return env;
-  return join14(homedir8(), ".claude", "vo-mcp-cache.db");
+  return join15(homedir9(), ".claude", "vo-mcp-cache.db");
 }
 async function probeEngineVersion() {
   try {
@@ -8717,6 +9115,16 @@ async function main() {
     consensus = createConsensusFallbackClient(localConsensus, cloudConsensus, {
       onFallback: (reason) => console.error(`[vo-mcp] local consensus unavailable (${reason}); using cloud moat fallback`)
     });
+    const moatAuthoritative = process.env["VO_CONSENSUS_MOAT_AUTHORITATIVE"] === "1";
+    if (moatAuthoritative || process.env["VO_CONSENSUS_MOAT_SHADOW"] === "1") {
+      const pctRaw = Number(process.env["VO_CONSENSUS_MOAT_SHADOW_PCT"] ?? "100");
+      const samplePct = Number.isFinite(pctRaw) ? Math.min(100, Math.max(0, pctRaw)) : 100;
+      const shadowedLocal = createConsensusShadowClient(localConsensus, cloudConsensus, { authoritative: moatAuthoritative, samplePct });
+      consensus = createConsensusFallbackClient(shadowedLocal, cloudConsensus, {
+        onFallback: (reason) => console.error(`[vo-mcp] local consensus unavailable (${reason}); using cloud moat fallback`)
+      });
+      console.error(`[vo-mcp] moat ${moatAuthoritative ? "AUTHORITATIVE" : `SHADOW (${samplePct}%)`} active \u2014 local verdicts also reach the moat verify path (receipts: ${defaultShadowReceiptPath()})`);
+    }
   } else if (!testClient && cloudConsensus) {
     console.error("[vo-mcp] fewer than 2 linked local providers; cloud moat consensus active");
     consensus = cloudConsensus;
@@ -8785,12 +9193,12 @@ if (process.argv[2] === "login") {
   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}
+      const { appendFileSync: appendFileSync3, mkdirSync: mkdirSync9 } = await import("node:fs");
+      const { join: join16 } = await import("node:path");
+      const { homedir: homedir10 } = await import("node:os");
+      const dir = join16(homedir10(), ".claude");
+      mkdirSync9(dir, { recursive: true });
+      appendFileSync3(join16(dir, "vo-mcp-sync.log"), `${line}
 `, "utf8");
     } catch {
     }