@algosuite/vo-mcp 0.2.0-beta.30 → 0.2.0-beta.34

package/dist/runner-cli.js

@@ -2582,6 +2582,11 @@ var init_control_plane_auth_stub = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/control-plane-client.mjs
+var control_plane_client_exports = {};
+__export(control_plane_client_exports, {
+  ClaimAuthorityChangedError: () => ClaimAuthorityChangedError,
+  createControlPlaneClient: () => createControlPlaneClient
+});
 async function resolveBearer(env2) {
   const adminToken = env2.VO_CONTROL_PLANE_ADMIN_TOKEN;
   if (adminToken) return adminToken;
@@ -2614,11 +2619,11 @@ function createControlPlaneClient({
   const resolvedBaseUrl = baseUrl ?? env2.VO_CONTROL_PLANE_URL ?? "";
   if (!resolvedBaseUrl) throw new Error("VO_CONTROL_PLANE_URL is required for the code-runner daemon");
   const root = resolvedBaseUrl.replace(/\/+$/, "");
-  async function req(method, path20, body, { timeoutMs } = {}) {
+  async function req(method, path23, body, { timeoutMs } = {}) {
     const bearer = await resolveBearer(env2);
     const controller = timeoutMs ? new AbortController() : null;
     let timeoutId;
-    const request = Promise.resolve(fetchImpl(`${root}${path20}`, {
+    const request = Promise.resolve(fetchImpl(`${root}${path23}`, {
       method,
       headers: {
         "content-type": "application/json",
@@ -2631,7 +2636,7 @@ function createControlPlaneClient({
     const timeout = new Promise((_, reject) => {
       timeoutId = setTimeout(() => {
         controller.abort();
-        reject(new Error(`control-plane ${path20} timed out after ${timeoutMs}ms`));
+        reject(new Error(`control-plane ${path23} timed out after ${timeoutMs}ms`));
       }, timeoutMs);
     });
     try {
@@ -2640,7 +2645,7 @@ function createControlPlaneClient({
       clearTimeout(timeoutId);
     }
   }
-  const taskReq = (method, path20, body, options = {}) => req(method, path20, body, { timeoutMs: taskRequestTimeoutMs, ...options });
+  const taskReq = (method, path23, body, options = {}) => req(method, path23, body, { timeoutMs: taskRequestTimeoutMs, ...options });
   return {
     ...makeAutonomousDispatchAdmissionClient(
       req,
@@ -2763,8 +2768,8 @@ function createControlPlaneClient({
       return listAllPrOpenedTasks(taskReq);
     },
     async downloadTaskAttachment(taskId, attachmentId) {
-      const path20 = `/api/v1/code-task/${encodeURIComponent(taskId)}/attachment/${encodeURIComponent(attachmentId)}`;
-      const res = await taskReq("GET", path20);
+      const path23 = `/api/v1/code-task/${encodeURIComponent(taskId)}/attachment/${encodeURIComponent(attachmentId)}`;
+      const res = await taskReq("GET", path23);
       if (res.status === 401) cachedFirebaseToken = null;
       if (!res.ok) throw new Error(`attachment download failed: HTTP ${res.status}`);
       return Buffer.from(await res.arrayBuffer());
@@ -4870,6 +4875,188 @@ var init_cursor_runner = __esm({
   }
 });
 
+// ../../scripts/virtual-office/code-runner/ollama-agent-tools.mjs
+var MAX_READ_BYTES, MAX_WRITE_BYTES, TOOL_DEFS, TOOL_NAMES, READ_ONLY_TOOL_NAMES, READ_ONLY_TOOL_DEFS;
+var init_ollama_agent_tools = __esm({
+  "../../scripts/virtual-office/code-runner/ollama-agent-tools.mjs"() {
+    "use strict";
+    MAX_READ_BYTES = 64 * 1024;
+    MAX_WRITE_BYTES = 512 * 1024;
+    TOOL_DEFS = [
+      {
+        type: "function",
+        function: {
+          name: "read_file",
+          description: "Read a UTF-8 text file inside the working directory. Returns up to 64 KiB.",
+          parameters: {
+            type: "object",
+            properties: {
+              path: { type: "string", description: "File path relative to the working directory." }
+            },
+            required: ["path"]
+          }
+        }
+      },
+      {
+        type: "function",
+        function: {
+          name: "list_files",
+          description: "List entries in a directory inside the working directory (files and subdirs).",
+          parameters: {
+            type: "object",
+            properties: {
+              path: { type: "string", description: 'Directory path relative to the working directory. Default ".".' }
+            }
+          }
+        }
+      },
+      {
+        type: "function",
+        function: {
+          name: "write_file",
+          description: "Create or overwrite a UTF-8 text file inside the working directory. Parent dirs are created.",
+          parameters: {
+            type: "object",
+            properties: {
+              path: { type: "string", description: "File path relative to the working directory." },
+              content: { type: "string", description: "Full new file contents." }
+            },
+            required: ["path", "content"]
+          }
+        }
+      }
+    ];
+    TOOL_NAMES = TOOL_DEFS.map((t) => t.function.name);
+    READ_ONLY_TOOL_NAMES = Object.freeze(["read_file", "list_files"]);
+    READ_ONLY_TOOL_DEFS = Object.freeze(
+      TOOL_DEFS.filter((tool) => READ_ONLY_TOOL_NAMES.includes(tool.function.name))
+    );
+  }
+});
+
+// ../../scripts/virtual-office/code-runner/ollama-agent-core.mjs
+function parseOllamaAgentEvent(line) {
+  const trimmed = String(line || "").trim();
+  if (!trimmed) return null;
+  let evt;
+  try {
+    evt = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  if (!evt || typeof evt !== "object") return null;
+  if (evt.type === "progress") {
+    const text = String(evt.text || "").trim();
+    return text ? { kind: "progress", text } : null;
+  }
+  if (evt.type === "tool") {
+    const via = evt.recovered ? " (recovered from text)" : "";
+    const label = `${evt.ok === false ? "tool failed" : "tool"}: ${evt.name}${evt.path ? ` ${evt.path}` : ""}${via}`;
+    return { kind: "progress", text: label };
+  }
+  if (evt.type === "result") {
+    const usage = evt.usage || null;
+    const tokenUsage = usage ? { inputTokens: usage.inputTokens ?? null, outputTokens: usage.outputTokens ?? null, totalTokens: usage.totalTokens ?? null } : void 0;
+    return {
+      kind: "result",
+      isError: Boolean(evt.isError),
+      costUsd: 0,
+      // sovereign local inference is free — no meter.
+      summary: String(evt.summary || (evt.isError ? "local run failed" : "completed")),
+      numTurns: Number.isInteger(evt.numTurns) ? evt.numTurns : null,
+      ...tokenUsage ? { tokenUsage } : {},
+      // Pass the sovereign receipt through to the daemon. Omitted entirely when
+      // absent so the event shape is unchanged for every other transport.
+      ...evt.receipt ? { receipt: evt.receipt } : {}
+    };
+  }
+  return null;
+}
+var MAX_TURNS_DEFAULT, NUM_CTX_DEFAULT;
+var init_ollama_agent_core = __esm({
+  "../../scripts/virtual-office/code-runner/ollama-agent-core.mjs"() {
+    "use strict";
+    init_ollama_agent_tools();
+    init_ollama_agent_tools();
+    MAX_TURNS_DEFAULT = 20;
+    NUM_CTX_DEFAULT = 16384;
+  }
+});
+
+// ../../scripts/virtual-office/code-runner/ollama-native-transport.mjs
+import { fileURLToPath } from "node:url";
+import { dirname as dirname2, join as join2 } from "node:path";
+function resolveLocalNativeProfile(env2 = process.env) {
+  const profile = String(env2.VO_CODE_RUNNER_LOCAL_PROFILE || "").trim().toLowerCase() || DEFAULT_LOCAL_NATIVE_PROFILE;
+  if (!LOCAL_NATIVE_PROFILES.includes(profile)) {
+    throw new Error(`local-model runner (native): unknown profile "${profile}" (coding|verification).`);
+  }
+  return profile;
+}
+function resolveLocalTransport(env2 = process.env) {
+  return String(env2.VO_CODE_RUNNER_LOCAL_TRANSPORT || "").trim().toLowerCase() === "native" ? "native" : DEFAULT_LOCAL_TRANSPORT;
+}
+function ollamaAgentScriptPath() {
+  return join2(dirname2(fileURLToPath(import.meta.url)), "ollama-agent.mjs");
+}
+function posIntOr(raw, fallback) {
+  const n = Number(String(raw ?? "").trim());
+  return Number.isInteger(n) && n > 0 ? n : fallback;
+}
+function buildOllamaAgentArgs({ model, numCtx, maxTurns, profile = DEFAULT_LOCAL_NATIVE_PROFILE } = {}) {
+  return [
+    ollamaAgentScriptPath(),
+    "--model",
+    String(model),
+    "--profile",
+    String(profile),
+    "--num-ctx",
+    String(posIntOr(numCtx, NUM_CTX_DEFAULT)),
+    "--max-turns",
+    String(posIntOr(maxTurns, MAX_TURNS_DEFAULT))
+  ];
+}
+function buildLocalNativeArgs(opts = {}, env2 = process.env) {
+  const provider = resolveLocalProvider(env2);
+  if (provider !== "ollama") {
+    throw new Error(
+      `local-model runner (native): the native tool-loop executor speaks Ollama's /api/chat; provider "${provider}" is not supported on native transport. Set VO_CODE_RUNNER_LOCAL_PROVIDER=ollama, or use VO_CODE_RUNNER_LOCAL_TRANSPORT=codex for LM Studio.`
+    );
+  }
+  const model = resolveLocalModel(env2);
+  if (!model) {
+    throw new Error(
+      "local-model runner (native): set VO_CODE_RUNNER_LOCAL_MODEL to a coding model your Ollama server already has (e.g. qwen2.5-coder:7b). Refusing to run with no explicit model (fail-closed)."
+    );
+  }
+  if (!isValidLocalModel(model)) {
+    throw new Error(`local-model runner (native): "${model}" is not a valid local model id.`);
+  }
+  const baseUrl = resolveLocalBaseUrl(env2);
+  if (baseUrl && !isLoopbackBaseUrl(baseUrl)) {
+    throw new Error(
+      "local-model runner (native): VO_CODE_RUNNER_LOCAL_BASE_URL must be a loopback http(s) URL (localhost / 127.0.0.1 / [::1]). Remote endpoints are refused \u2014 use the Model Firewall lanes."
+    );
+  }
+  return buildOllamaAgentArgs({
+    model,
+    profile: resolveLocalNativeProfile(env2),
+    numCtx: env2.VO_CODE_RUNNER_LOCAL_NUM_CTX,
+    maxTurns: env2.VO_CODE_RUNNER_LOCAL_MAX_TURNS
+  });
+}
+var DEFAULT_LOCAL_TRANSPORT, LOCAL_NATIVE_PROFILES, DEFAULT_LOCAL_NATIVE_PROFILE;
+var init_ollama_native_transport = __esm({
+  "../../scripts/virtual-office/code-runner/ollama-native-transport.mjs"() {
+    "use strict";
+    init_ollama_agent_core();
+    init_local_model_runner();
+    DEFAULT_LOCAL_TRANSPORT = "codex";
+    LOCAL_NATIVE_PROFILES = Object.freeze(["coding", "verification"]);
+    DEFAULT_LOCAL_NATIVE_PROFILE = "coding";
+  }
+});
+
 // ../../scripts/virtual-office/code-runner/local-model-runner.mjs
 function resolveLocalProvider(env2 = process.env) {
   return String(env2.VO_CODE_RUNNER_LOCAL_PROVIDER || "").trim().toLowerCase() || DEFAULT_LOCAL_PROVIDER;
@@ -4943,20 +5130,37 @@ function buildLocalArgs(opts = {}, env2 = process.env) {
 }
 function applyLocalAuthEnv(baseEnv = process.env, configEnv = process.env) {
   const out = withAgentKey("local", baseEnv);
+  for (const key of Object.keys(out)) {
+    if (FORBIDDEN_LOCAL_CHILD_CREDENTIALS.has(key.toUpperCase())) delete out[key];
+  }
   const baseUrl = resolveLocalBaseUrl(configEnv);
   if (baseUrl && isLoopbackBaseUrl(baseUrl) && resolveLocalProvider(configEnv) === "ollama" && !String(out.OLLAMA_HOST || "").trim()) {
     out.OLLAMA_HOST = baseUrl.replace(/\/+$/, "");
   }
   return out;
 }
-var LOCAL_API_KEY_ENV, LOCAL_PROVIDERS, DEFAULT_LOCAL_PROVIDER, LOCAL_PROBE_URLS, remoteDesiredLocalModel, LOCAL_MODEL_RE, LocalModelRunner, localModelRunner;
+var LOCAL_API_KEY_ENV, FORBIDDEN_LOCAL_CHILD_CREDENTIALS, LOCAL_PROVIDERS, DEFAULT_LOCAL_PROVIDER, LOCAL_PROBE_URLS, remoteDesiredLocalModel, LOCAL_MODEL_RE, LocalModelRunner, localModelRunner;
 var init_local_model_runner = __esm({
   "../../scripts/virtual-office/code-runner/local-model-runner.mjs"() {
     "use strict";
     init_codex_runner();
     init_agent_key_store();
     init_agent_auth_tier();
+    init_ollama_agent_core();
+    init_ollama_native_transport();
     LOCAL_API_KEY_ENV = "VO_CODE_RUNNER_LOCAL_API_KEY";
+    FORBIDDEN_LOCAL_CHILD_CREDENTIALS = /* @__PURE__ */ new Set([
+      "ANTHROPIC_API_KEY",
+      "AWS_ACCESS_KEY_ID",
+      "AWS_SECRET_ACCESS_KEY",
+      "AWS_SESSION_TOKEN",
+      "FIREBASE_TOKEN",
+      "GH_TOKEN",
+      "GITHUB_TOKEN",
+      "GOOGLE_API_KEY",
+      "GOOGLE_APPLICATION_CREDENTIALS",
+      "OPENAI_API_KEY"
+    ]);
     LOCAL_PROVIDERS = ["ollama", "lmstudio"];
     DEFAULT_LOCAL_PROVIDER = "ollama";
     LOCAL_PROBE_URLS = {
@@ -4977,19 +5181,25 @@ var init_local_model_runner = __esm({
         this.env = env2;
         this.fetchImpl = fetchImpl;
       }
-      /** Codex is the transport binary; the model/endpoint are the user's. */
+      /**
+       * Transport binary. codex transport → the codex CLI. native transport →
+       * this daemon's own node (process.execPath), which runs ollama-agent.mjs; no
+       * external CLI is involved on the native path.
+       */
       get binary() {
-        return this.resolveBinary();
+        return resolveLocalTransport(this.env) === "native" ? process.execPath : this.resolveBinary();
       }
       buildArgs(opts = {}) {
-        return buildLocalArgs(opts, this.env);
+        return resolveLocalTransport(this.env) === "native" ? buildLocalNativeArgs(opts, this.env) : buildLocalArgs(opts, this.env);
       }
       /**
-       * Codex JSONL events map identically, except a sovereign local model has no
-       * vendor bill. Codex omits total_cost_usd for OSS runs; turn that known fact
-       * into a measured zero at the producer so readers never have to guess.
+       * native transport → parse the executor's own JSONL contract. codex transport
+       * → codex JSONL maps identically, except a sovereign local model has no vendor
+       * bill: codex omits total_cost_usd for OSS runs, so turn that known fact into a
+       * measured zero at the producer. (The native parser already stamps costUsd:0.)
        */
       parseEvent(line) {
+        if (resolveLocalTransport(this.env) === "native") return parseOllamaAgentEvent(line);
         const event = parseCodexEvent(line);
         return event?.kind === "result" ? { ...event, costUsd: 0 } : event;
       }
@@ -5488,9 +5698,9 @@ var init_rate_limit_resume_state = __esm({
 
 // ../../scripts/virtual-office/code-runner/rate-limit-resume.mjs
 import { homedir as homedir3 } from "node:os";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 function resumeQueuePath() {
-  return join2(homedir3(), ".claude", "resume-queue.jsonl");
+  return join3(homedir3(), ".claude", "resume-queue.jsonl");
 }
 function buildResumeEntry({ task = {}, resumeAfter = null, summary = "", at } = {}) {
   return {
@@ -5692,7 +5902,7 @@ var init_auto_merge = __esm({
 // ../../scripts/virtual-office/code-runner/pr-overlap-gate.mjs
 import { spawnSync as spawnSync8 } from "node:child_process";
 import { existsSync as existsSync6 } from "node:fs";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 function stripCredentials(env2 = process.env) {
   const safe = { ...env2 };
   for (const key of CREDENTIAL_ENV_KEYS) delete safe[key];
@@ -5718,7 +5928,7 @@ var init_pr_overlap_gate = __esm({
     TRUSTED_OVERLAP_CANDIDATES = [
       new URL("../../ci/check-local-pr-overlap.mjs", import.meta.url),
       new URL("./ci/check-local-pr-overlap.js", import.meta.url)
-    ].map((candidate) => fileURLToPath(candidate));
+    ].map((candidate) => fileURLToPath2(candidate));
     CREDENTIAL_ENV_KEYS = Object.freeze([
       "GH_TOKEN",
       "GITHUB_TOKEN",
@@ -5771,14 +5981,14 @@ function parsePorcelainZ(out) {
   for (let i = 0; i < tokens.length; i += 1) {
     const token2 = tokens[i];
     if (!token2) continue;
-    const path20 = token2.slice(3);
-    if (path20) files.push(path20);
+    const path23 = token2.slice(3);
+    if (path23) files.push(path23);
     if (token2[0] === "R" || token2[0] === "C") i += 1;
   }
   return files;
 }
-function isAgentScratch(path20) {
-  const normalized = String(path20 || "");
+function isAgentScratch(path23) {
+  const normalized = String(path23 || "");
   return SCRATCH_PATTERNS.some((pattern) => pattern.test(normalized));
 }
 var SCRATCH_PATTERNS;
@@ -5845,6 +6055,540 @@ var init_publish = __esm({
   }
 });
 
+// ../../scripts/virtual-office/test-gen/auto-tier.mjs
+function lower(s) {
+  return typeof s === "string" ? s.toLowerCase() : "";
+}
+function isAlgoProduct(product) {
+  return /^algo/i.test(String(product || ""));
+}
+function isAdminRoute(route) {
+  return /(^|\/)admin(\/|$)/i.test(String(route || ""));
+}
+function importsMatch(imports, re) {
+  return Array.isArray(imports) && imports.some((i) => re.test(String(i || "")));
+}
+function classifyTier(contract = {}) {
+  const product = lower(contract.product);
+  const callable = String(contract.callable || "");
+  const route = String(contract.route || "");
+  const imports = contract.imports;
+  const ov = contract.tier_override;
+  if (ov === 1 || ov === 2 || ov === 3 || ov === 4) {
+    return { tier: ov, rationale: `operator override \u2192 Tier ${ov}`, tier_override: true };
+  }
+  const algo = isAlgoProduct(product);
+  let tier;
+  let why;
+  const legalDomain = LEGAL_PRODUCTS.has(product);
+  const hasGovernedSource = Boolean(contract.authoritative_source_url) || importsMatch(imports, LEGAL_IMPORT_RE);
+  if (legalDomain && hasGovernedSource) {
+    tier = 4;
+    why = `legal-correctness domain (${product}) with a governed source \u2192 source-grounded Tier 4`;
+  } else if (isAdminRoute(route) || MONEY_OR_SAFETY_RE.test(callable)) {
+    tier = 3;
+    why = isAdminRoute(route) ? "admin/safety-critical route \u2192 real-time monitor Tier 3" : `money-moving or grading callable (${callable}) \u2192 real-time monitor Tier 3`;
+  } else if (importsMatch(imports, GENERATIVE_RE) || GENERATIVE_CALLABLE_RE.test(callable)) {
+    const long = Number(contract.workflow_seconds) > 30;
+    tier = long ? 3 : 2;
+    why = `generative/AI feature \u2192 E2E with verified results${long ? " + monitor (long workflow) Tier 3" : " Tier 2"}`;
+  } else if (callable || route) {
+    tier = 2;
+    why = "standard business logic \u2192 E2E with verified results (read-back) Tier 2";
+  } else {
+    tier = 1;
+    why = "pure navigation/surface, no backend effect \u2192 surface smoke Tier 1";
+  }
+  if (algo && tier < 2) {
+    return {
+      tier: 2,
+      rationale: `${why}; raised to Tier 2 (E2E floor: Algo* apps never auto-pick surface-smoke-only)`,
+      tier_override: false
+    };
+  }
+  return { tier, rationale: why, tier_override: false };
+}
+function tierLabel(tier) {
+  return {
+    1: "Tier 1 \u2014 surface & navigation smoke",
+    2: "Tier 2 \u2014 E2E with verified results",
+    3: "Tier 3 \u2014 real-time monitor / sentinel",
+    4: "Tier 4 \u2014 source-grounded governed-fact verification"
+  }[tier] || `Tier ${tier}`;
+}
+var LEGAL_PRODUCTS, LEGAL_IMPORT_RE, GENERATIVE_RE, GENERATIVE_CALLABLE_RE, MONEY_OR_SAFETY_RE;
+var init_auto_tier = __esm({
+  "../../scripts/virtual-office/test-gen/auto-tier.mjs"() {
+    "use strict";
+    LEGAL_PRODUCTS = /* @__PURE__ */ new Set(["algotax", "algolaw", "algoteach", "algolegal"]);
+    LEGAL_IMPORT_RE = /functions-core-(tax|law)|cornell|irs|\bstatute\b/i;
+    GENERATIVE_RE = /@google\/generative-ai|@anthropic|anthropic|openai|@google\/genai|consensus|\bllm\b/i;
+    GENERATIVE_CALLABLE_RE = /generate|summari[sz]e|\bai\b|consensus|draft|classify/i;
+    MONEY_OR_SAFETY_RE = /grade|payment|transfer|trade|charge|refund|payout|disburse|withdraw|remit/i;
+  }
+});
+
+// ../../scripts/virtual-office/test-gen/dispatch.mjs
+import { spawnSync as spawnSync10 } from "node:child_process";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import path14 from "node:path";
+function buildGenerationPrompt({ contract = {}, tier }) {
+  const label = tierLabel(tier);
+  const target = contract.callable ? `the \`${contract.callable}\` callable` : contract.route ? `the \`${contract.route}\` route` : contract.feature_name || "the feature";
+  return [
+    `Write a ${label} test for ${target} in product "${contract.product || "unknown"}".`,
+    contract.source_file ? `Source: ${contract.source_file}.` : "",
+    contract.expected_behavior ? `Expected behavior: ${contract.expected_behavior}.` : "",
+    "",
+    `TIER REQUIREMENT \u2014 ${TIER_GUIDANCE[tier] || TIER_GUIDANCE[2]}`,
+    "",
+    "Follow the AlgoSuite test-honesty standard: NO fake-green (no bare toBeTruthy, no broad",
+    "try/catch that swallows failures, no treating INVALID_ARGUMENT / empty / null / SKIP as a",
+    "pass). Use a real fixture (smoke@algosuite.ai) and real data shapes.",
+    "",
+    "After writing the test, it will be GATED server-side: deterministic ratchets, then",
+    "multi-model consensus that it proves the behavior with VERIFIED-CORRECT expected values.",
+    "A test that does not pass BOTH gates will NOT ship \u2014 so make the assertions real and the",
+    "expected values known-correct. Leave the test file UNCOMMITTED; the runner opens the PR."
+  ].filter((l) => l !== "").join("\n");
+}
+function planTestGenDispatch({ contract = {} }) {
+  const { tier, rationale } = classifyTier(contract);
+  return {
+    contract,
+    tier,
+    tier_label: tierLabel(tier),
+    tier_rationale: rationale,
+    generation_prompt: buildGenerationPrompt({ contract, tier })
+  };
+}
+function buildTestGenTaskPrompt(dispatch = {}) {
+  const contractJson = JSON.stringify(dispatch.contract ?? {});
+  return `${TEST_GEN_MARKER} ${contractJson}
+
+${dispatch.generation_prompt ?? ""}`;
+}
+function pickNextTarget({ gaps = [] }) {
+  if (!Array.isArray(gaps) || gaps.length === 0) return null;
+  const ranked = [...gaps].sort((a, b) => {
+    const al = LEGAL.has(String(a.product)) ? 0 : 1;
+    const bl = LEGAL.has(String(b.product)) ? 0 : 1;
+    return al - bl;
+  });
+  return ranked[0];
+}
+function resolveRepo(argv, env2) {
+  const repoArg = argv.indexOf("--repo");
+  if (repoArg >= 0 && argv[repoArg + 1]) return argv[repoArg + 1];
+  if (env2.VO_TEST_GEN_REPO) return env2.VO_TEST_GEN_REPO;
+  const remote = spawnSync10("git", ["remote", "get-url", "origin"], { encoding: "utf8" });
+  if (remote.status === 0) {
+    const m = String(remote.stdout).trim().match(/[:/]([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (m) return m[1];
+  }
+  return null;
+}
+async function main(argv = process.argv.slice(2)) {
+  const countArg = argv.indexOf("--count");
+  const count3 = countArg >= 0 ? Math.max(1, Number(argv[countArg + 1]) || 1) : 1;
+  const enqueue = argv.includes("--enqueue");
+  const here = path14.dirname(fileURLToPath3(import.meta.url));
+  const scan = spawnSync10("node", [path14.join(here, "coverage-scan.mjs"), "--limit", String(count3 * 8)], {
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024
+  });
+  if (scan.status !== 0) {
+    console.error(`[dispatch] coverage-scan failed: ${scan.stderr || scan.stdout}`);
+    process.exit(1);
+  }
+  let gaps = [];
+  try {
+    gaps = JSON.parse(scan.stdout).gaps || [];
+  } catch (err) {
+    console.error(`[dispatch] could not parse scan output: ${err.message}`);
+    process.exit(1);
+  }
+  const dispatches = [];
+  const seen = /* @__PURE__ */ new Set();
+  let pool = gaps;
+  while (dispatches.length < count3 && pool.length > 0) {
+    const target = pickNextTarget({ gaps: pool });
+    if (!target) break;
+    const key = `${target.product}:${target.callable}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      dispatches.push(planTestGenDispatch({ contract: target }));
+    }
+    pool = pool.filter((g) => `${g.product}:${g.callable}` !== key);
+  }
+  if (!enqueue) {
+    console.log(JSON.stringify({ requested: count3, emitted: dispatches.length, dispatches }, null, 2));
+    return;
+  }
+  const repo = resolveRepo(argv, process.env);
+  if (!repo) {
+    console.error("[dispatch] --enqueue needs a repo: pass --repo owner/name or set VO_TEST_GEN_REPO (could not derive from git origin)");
+    process.exit(1);
+  }
+  const { createControlPlaneClient: createControlPlaneClient2 } = await Promise.resolve().then(() => (init_control_plane_client(), control_plane_client_exports));
+  const client = createControlPlaneClient2({ env: process.env });
+  const enqueued = [];
+  for (const d of dispatches) {
+    const task = await client.enqueueCodeTask({
+      repo,
+      prompt: buildTestGenTaskPrompt(d),
+      max_turns: 40
+    });
+    const taskId = task && task.code_task_id ? task.code_task_id : "(unknown)";
+    enqueued.push({ task_id: taskId, product: d.contract.product, callable: d.contract.callable, tier: d.tier_label });
+    console.error(`[dispatch] enqueued ${d.tier_label} test-gen for ${d.contract.product}:${d.contract.callable} \u2192 task ${taskId}`);
+  }
+  console.log(JSON.stringify({ requested: count3, enqueued: enqueued.length, repo, tasks: enqueued }, null, 2));
+}
+var TEST_GEN_MARKER, TIER_GUIDANCE, LEGAL, invokedDirectly;
+var init_dispatch = __esm({
+  "../../scripts/virtual-office/test-gen/dispatch.mjs"() {
+    "use strict";
+    init_auto_tier();
+    TEST_GEN_MARKER = "[VO-TEST-GEN]";
+    TIER_GUIDANCE = {
+      1: "Surface/navigation smoke: assert the surface renders and the key controls are present. No backend effect needed.",
+      2: "E2E with VERIFIED RESULTS: drive the real user/callable workflow, then READ BACK the produced artifact and assert KNOWN-CORRECT expected values (not just a 200 / truthiness).",
+      3: "Real-time monitor / sentinel: drive the workflow AND verify the state transitions + safety rails (no money moved / graded / admin action without the guard). Assert the post-conditions, not just the response.",
+      4: "Source-grounded governed-fact: assert expected values that are GROUNDED in the cited authoritative source (the contract's authoritative_source_url). The fixture and the expected number/string must trace to that source."
+    };
+    LEGAL = /* @__PURE__ */ new Set(["algotax", "algolaw", "algoteach", "algolegal"]);
+    invokedDirectly = process.argv[1] && fileURLToPath3(import.meta.url) === path14.resolve(process.argv[1]);
+    if (invokedDirectly) {
+      main().catch((err) => {
+        console.error(`[dispatch] ${err.message}`);
+        process.exit(1);
+      });
+    }
+  }
+});
+
+// ../../scripts/virtual-office/test-gen/executor.mjs
+function consensusQuestion(tier) {
+  const tierAsk = tier >= 4 ? " For this governed-fact (Tier 4) test, the expected values MUST be grounded in the cited authoritative source." : tier >= 3 ? " For this safety-critical (Tier 3) test, it must verify state transitions and the safety rails, not just a 200." : "";
+  return "Does this test PROVE the stated behavior with VERIFIED-CORRECT expected values (not fake-green)? It must exercise the real product path (no stub/mock that bypasses the feature) and assert known-correct values, not placeholders." + tierAsk;
+}
+function buildContractSummary(contract, tier) {
+  const parts = [
+    `Feature: ${contract.feature_name || contract.callable || contract.route || "unnamed"}`,
+    `Product: ${contract.product || "unknown"}`,
+    contract.route ? `Route: ${contract.route}` : "",
+    contract.callable ? `Callable: ${contract.callable}` : "",
+    `Auto-selected tier: ${tierLabel(tier)}`,
+    contract.expected_behavior ? `Expected behavior: ${contract.expected_behavior}` : "",
+    contract.authoritative_source_url ? `Authoritative source: ${contract.authoritative_source_url}` : ""
+  ];
+  return parts.filter(Boolean).join("\n");
+}
+async function gateGeneratedTest({ contract = {}, testSource = "", verify, taskId = "autotest" }) {
+  if (typeof verify !== "function") throw new Error("gateGeneratedTest requires a `verify` transport");
+  const { tier, rationale } = classifyTier(contract);
+  const label = tierLabel(tier);
+  const filename = typeof contract.test_filename === "string" ? contract.test_filename : void 0;
+  const ratchets = await verify({
+    task_id: taskId,
+    gate_type: "ratchets",
+    excerpt: testSource,
+    ...filename ? { context: { filename } } : {}
+  });
+  if (!ratchets || ratchets.approved !== true) {
+    return {
+      ship: false,
+      tier,
+      tierLabel: label,
+      stage: "ratchets",
+      reason: ratchets?.reason || "ratchets gate did not approve",
+      ratchets: ratchets || null,
+      consensus: null
+    };
+  }
+  const consensus = await verify({
+    task_id: taskId,
+    gate_type: CONSENSUS_GATE_TYPE,
+    excerpt: `${buildContractSummary(contract, tier)}
+
+--- TEST ---
+${testSource}`,
+    question: consensusQuestion(tier)
+  });
+  const consensusBlocks = consensus?.available === true && consensus?.approved !== true;
+  if (consensusBlocks) {
+    return {
+      ship: false,
+      tier,
+      tierLabel: label,
+      stage: "consensus",
+      reason: consensus?.reason || "consensus did not confirm verified-correct expected values",
+      ratchets,
+      consensus
+    };
+  }
+  return {
+    ship: true,
+    tier,
+    tierLabel: label,
+    stage: "passed",
+    reason: consensus?.available === true ? `Passed ratchets + consensus (${label}). ${rationale}` : `Passed ratchets; consensus unavailable so not blocking (${label}). ${rationale}`,
+    ratchets,
+    consensus
+  };
+}
+function makeHttpVerify({ baseUrl, token: token2, fetchImpl = fetch }) {
+  if (!baseUrl) throw new Error("makeHttpVerify requires a baseUrl");
+  const url = `${baseUrl.replace(/\/$/, "")}/api/v1/verify`;
+  return async function httpVerify(req) {
+    let res;
+    try {
+      res = await fetchImpl(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...token2 ? { Authorization: `Bearer ${token2}` } : {} },
+        body: JSON.stringify(req)
+      });
+    } catch (err) {
+      return { ok: false, available: false, approved: false, reason: `transport error: ${err?.message || err}` };
+    }
+    let body = {};
+    try {
+      body = await res.json();
+    } catch {
+    }
+    if (!res.ok) {
+      return { ok: false, available: false, approved: false, reason: body?.error || `http ${res.status}` };
+    }
+    return body;
+  };
+}
+var CONSENSUS_GATE_TYPE;
+var init_executor = __esm({
+  "../../scripts/virtual-office/test-gen/executor.mjs"() {
+    "use strict";
+    init_auto_tier();
+    CONSENSUS_GATE_TYPE = "test_correctness_consensus";
+  }
+});
+
+// ../../scripts/virtual-office/code-runner/test-gen-gate.mjs
+import fs7 from "node:fs";
+import path15 from "node:path";
+async function postFailed(client, id, message, result) {
+  try {
+    await client.postProgress(id, {
+      status: "failed",
+      message: String(message).slice(0, 1500),
+      result
+    });
+  } catch {
+  }
+}
+async function gateTestGenTaskOrFail({ client, id, task, files, worktreeDir, env: env2 = process.env, log: log2 = () => {
+}, verify: verifyInjected } = {}) {
+  const prompt = String(task && task.prompt || "");
+  if (!prompt.startsWith(TEST_GEN_MARKER)) return false;
+  let contract;
+  try {
+    const after = prompt.slice(TEST_GEN_MARKER.length).trimStart();
+    contract = JSON.parse(after.split("\n\n")[0]);
+  } catch (err) {
+    log2(`task ${id}: test-gen contract parse failed: ${err.message}`);
+    await postFailed(client, id, `test-gen contract parse failed: ${err.message}`, "gate_contract_unparseable");
+    return true;
+  }
+  const testFile = (files || []).find((f) => TEST_FILE_RE.test(f));
+  if (!testFile) {
+    await postFailed(client, id, "test-gen task produced no *.test.* file", "gate_no_test_file");
+    return true;
+  }
+  const baseUrl = env2.VO_MOAT_PLANE_URL;
+  if (!verifyInjected && !baseUrl) {
+    log2(`task ${id}: VO_MOAT_PLANE_URL unset \u2014 skipping test-gen gate (fail-safe, ADR-002 opt-out)`);
+    return false;
+  }
+  let testSource = "";
+  try {
+    testSource = fs7.readFileSync(path15.join(worktreeDir, testFile), "utf8");
+  } catch (err) {
+    await postFailed(client, id, `could not read generated test ${testFile}: ${err.message}`, "gate_test_unreadable");
+    return true;
+  }
+  const verify = verifyInjected || makeHttpVerify({ baseUrl: String(baseUrl).replace(/\/$/, ""), token: env2.VO_MOAT_PLANE_TOKEN || "" });
+  let verdict;
+  try {
+    verdict = await gateGeneratedTest({
+      contract: { ...contract, test_filename: testFile },
+      testSource,
+      verify,
+      taskId: id
+    });
+  } catch (err) {
+    log2(`task ${id}: test-gen gate could not run: ${err.message}`);
+    await postFailed(client, id, `test-gen gate could not run (${err.message}) \u2014 not shipping un-gated`, "gate_transport_error");
+    return true;
+  }
+  if (!verdict.ship) {
+    log2(`task ${id}: test-gen gate REJECTED at ${verdict.stage}`);
+    await postFailed(
+      client,
+      id,
+      `test-gen gate rejected (${verdict.stage}): ${verdict.reason || "did not pass ratchets + consensus"}`,
+      "gate_rejected"
+    );
+    return true;
+  }
+  try {
+    await client.postProgress(id, {
+      message: `test-gen gate PASSED (${verdict.tierLabel || "tier"}): ${verdict.reason || "ratchets + consensus"}`
+    });
+  } catch {
+  }
+  return false;
+}
+var TEST_FILE_RE;
+var init_test_gen_gate = __esm({
+  "../../scripts/virtual-office/code-runner/test-gen-gate.mjs"() {
+    "use strict";
+    init_dispatch();
+    init_executor();
+    TEST_FILE_RE = /\.(test|spec)\.(ts|tsx|mjs|js)$/;
+  }
+});
+
+// ../../scripts/virtual-office/code-runner/completion-gate.mjs
+import { execFile } from "node:child_process";
+import fs8 from "node:fs";
+import path16 from "node:path";
+function resolveCompletionGate(task) {
+  const raw = task?.completion_gate;
+  if (raw === void 0 || raw === null) return null;
+  if (typeof raw !== "string" || raw.trim() === "") {
+    return { invalid: true, reason: "completion_gate must be a non-empty string" };
+  }
+  const trimmed = raw.trim();
+  if (trimmed.length > 500) {
+    return { invalid: true, reason: "completion_gate exceeds 500 characters" };
+  }
+  if (SHELL_METACHARACTERS.test(trimmed)) {
+    return { invalid: true, reason: "completion_gate contains shell metacharacters (no-shell contract: plain argv only, no pipes/redirects/quotes)" };
+  }
+  const [command, ...args] = trimmed.split(/\s+/);
+  const allowedCommand = ALLOWED_GATE_COMMANDS.get(command);
+  if (allowedCommand === void 0) {
+    const shown = command.length > 40 ? `${command.slice(0, 40)}...` : command;
+    return {
+      invalid: true,
+      reason: `completion_gate command ${shown} is not an allowed gate runner (${[...ALLOWED_GATE_COMMANDS.keys()].join(", ")})`
+    };
+  }
+  return { argv: [allowedCommand, ...args] };
+}
+function boundedTail(text) {
+  const s = String(text ?? "");
+  return s.length <= COMPLETION_GATE_OUTPUT_CAP ? s : s.slice(s.length - COMPLETION_GATE_OUTPUT_CAP);
+}
+function workspaceFingerprint(worktreeDir, execFileImpl = execFile) {
+  return new Promise((resolve2) => {
+    execFileImpl("git", ["rev-parse", "HEAD^{tree}"], { cwd: worktreeDir }, (err, stdout) => {
+      resolve2(err ? null : String(stdout).trim() || null);
+    });
+  });
+}
+function readState(worktreeDir) {
+  try {
+    return JSON.parse(fs8.readFileSync(path16.join(worktreeDir, COMPLETION_GATE_STATE_FILE), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeState(worktreeDir, state) {
+  try {
+    fs8.writeFileSync(path16.join(worktreeDir, COMPLETION_GATE_STATE_FILE), `${JSON.stringify(state)}
+`, "utf8");
+  } catch {
+  }
+}
+function runGateCommand({ argv, worktreeDir, timeoutMs = COMPLETION_GATE_TIMEOUT_MS, execFileImpl = execFile }) {
+  return new Promise((resolve2) => {
+    const command = ALLOWED_GATE_COMMANDS.get(argv?.[0]);
+    if (command === void 0) {
+      return resolve2({
+        exitCode: 1,
+        output: `completion_gate executable is not an allowed gate runner (${[...ALLOWED_GATE_COMMANDS.keys()].join(", ")})`,
+        timedOut: false
+      });
+    }
+    execFileImpl(
+      command,
+      argv.slice(1),
+      { cwd: worktreeDir, timeout: timeoutMs, maxBuffer: 16 * 1024 * 1024, windowsHide: true },
+      (err, stdout, stderr) => {
+        const output = boundedTail(`${stdout ?? ""}
+${stderr ?? ""}`.trim());
+        if (!err) return resolve2({ exitCode: 0, output, timedOut: false });
+        const timedOut = err.killed === true || err.signal === "SIGTERM";
+        const exitCode = typeof err.code === "number" ? err.code : 1;
+        resolve2({ exitCode, output: output || boundedTail(err.message), timedOut });
+      }
+    );
+  });
+}
+async function postFailed2(client, id, message, result) {
+  try {
+    await client.postProgress(id, { status: "failed", message: String(message).slice(0, 1500), result });
+  } catch {
+  }
+}
+function messageExcerpt(output) {
+  const s = String(output ?? "");
+  return s.length > 1200 ? `...${s.slice(-1200)}` : s;
+}
+async function enforceCompletionGateOrFail({ client, id, task, worktreeDir, log: log2 = () => {
+}, execFileImpl = execFile } = {}) {
+  const resolved = resolveCompletionGate(task);
+  if (resolved === null) return false;
+  if (resolved.invalid) {
+    log2(`task ${id}: completion_gate invalid \u2014 ${resolved.reason}`);
+    await postFailed2(client, id, `completion_gate invalid (${resolved.reason}) \u2014 failing closed, not publishing`, "completion_gate_invalid");
+    return true;
+  }
+  const fingerprint = await workspaceFingerprint(worktreeDir, execFileImpl);
+  const cached2 = readState(worktreeDir);
+  if (fingerprint && cached2 && cached2.fingerprint === fingerprint && cached2.exitCode !== 0) {
+    log2(`task ${id}: completion gate skip-on-unchanged (tree ${fingerprint.slice(0, 12)}) \u2014 reusing recorded failure exit ${cached2.exitCode}`);
+    await postFailed2(client, id, `completion gate '${task.completion_gate}' previously failed (exit ${cached2.exitCode}) and the workspace is unchanged:
+${messageExcerpt(cached2.output)}`, "completion_gate_failed");
+    return true;
+  }
+  log2(`task ${id}: running completion gate: ${resolved.argv.join(" ")}`);
+  const outcome = await runGateCommand({ argv: resolved.argv, worktreeDir, execFileImpl });
+  if (fingerprint) writeState(worktreeDir, { fingerprint, exitCode: outcome.exitCode, output: outcome.output, at: (/* @__PURE__ */ new Date()).toISOString() });
+  if (outcome.exitCode === 0) {
+    log2(`task ${id}: completion gate PASSED`);
+    return false;
+  }
+  const kind = outcome.timedOut ? `timed out after ${COMPLETION_GATE_TIMEOUT_MS}ms` : `exited ${outcome.exitCode}`;
+  log2(`task ${id}: completion gate FAILED (${kind}) \u2014 not publishing`);
+  await postFailed2(client, id, `completion gate '${task.completion_gate}' ${kind} \u2014 task may not claim completion:
+${messageExcerpt(outcome.output)}`, "completion_gate_failed");
+  return true;
+}
+var COMPLETION_GATE_TIMEOUT_MS, COMPLETION_GATE_OUTPUT_CAP, COMPLETION_GATE_STATE_FILE, SHELL_METACHARACTERS, ALLOWED_GATE_COMMANDS;
+var init_completion_gate = __esm({
+  "../../scripts/virtual-office/code-runner/completion-gate.mjs"() {
+    "use strict";
+    COMPLETION_GATE_TIMEOUT_MS = 5 * 6e4;
+    COMPLETION_GATE_OUTPUT_CAP = 8 * 1024;
+    COMPLETION_GATE_STATE_FILE = ".vo-completion-gate-state.json";
+    SHELL_METACHARACTERS = /[|&;<>$`(){}[\]*?~#\\'"]/;
+    ALLOWED_GATE_COMMANDS = new Map(
+      ["pnpm", "npm", "yarn", "node", "git", "make", "python", "python3", "cargo", "go"].map((name) => [name, name])
+    );
+  }
+});
+
 // ../../scripts/virtual-office/code-runner/process-runner.mjs
 import { spawn as spawn3 } from "node:child_process";
 function buildStepLabel(cmd, args = []) {
@@ -6338,8 +7082,8 @@ var init_publish_async = __esm({
 
 // ../../scripts/virtual-office/code-runner/skill-catalog.mjs
 import { readdirSync as readdirSync2, readFileSync as readFileSync3, statSync } from "node:fs";
-import { dirname as dirname2, join as join3 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { dirname as dirname3, join as join4 } from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 function parseFrontmatterNameDescription(raw) {
   const text = String(raw).replace(/\r\n/g, "\n");
   if (!text.startsWith("---\n")) return null;
@@ -6358,15 +7102,15 @@ function parseFrontmatterNameDescription(raw) {
   return name && description ? { name, description } : null;
 }
 function resolveDefaultRepoRoot() {
-  const starts = [dirname2(fileURLToPath2(import.meta.url)), process.cwd()];
+  const starts = [dirname3(fileURLToPath4(import.meta.url)), process.cwd()];
   for (const start of starts) {
     let dir = start;
     for (let i = 0; i < 8; i += 1) {
       try {
-        if (statSync(join3(dir, ".claude", "skills")).isDirectory()) return dir;
+        if (statSync(join4(dir, ".claude", "skills")).isDirectory()) return dir;
       } catch {
       }
-      const parent = dirname2(dir);
+      const parent = dirname3(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -6375,14 +7119,14 @@ function resolveDefaultRepoRoot() {
 }
 function loadSkillCatalog({ repoRoot: repoRoot2 = resolveDefaultRepoRoot() } = {}) {
   try {
-    const skillsDir = join3(repoRoot2, ".claude", "skills");
+    const skillsDir = join4(repoRoot2, ".claude", "skills");
     const catalog = [];
     for (const entry of readdirSync2(skillsDir)) {
-      const dir = join3(skillsDir, entry);
+      const dir = join4(skillsDir, entry);
       try {
         if (!statSync(dir).isDirectory()) continue;
         const parsed = parseFrontmatterNameDescription(
-          readFileSync3(join3(dir, "SKILL.md"), "utf8")
+          readFileSync3(join4(dir, "SKILL.md"), "utf8")
         );
         if (parsed) catalog.push(parsed);
       } catch {
@@ -6614,7 +7358,7 @@ var init_task_prompt = __esm({
 import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
 import { chmod, mkdir, mkdtemp, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import os2 from "node:os";
-import path14 from "node:path";
+import path17 from "node:path";
 function safeTaskToken(taskId) {
   return String(taskId || "task").replace(/[^0-9A-Za-z_-]/gu, "_").slice(0, 48) || "task";
 }
@@ -6624,25 +7368,25 @@ function sanitizeTaskAttachmentName(name, index = 0) {
   return `${String(index + 1).padStart(2, "0")}-${normalized}`;
 }
 function assertGeneratedDirectory(directory, tempRoot) {
-  const resolvedDirectory = path14.resolve(directory);
-  const resolvedRoot = path14.resolve(tempRoot);
-  if (path14.dirname(resolvedDirectory) !== resolvedRoot || !path14.basename(resolvedDirectory).startsWith(DIRECTORY_PREFIX)) {
+  const resolvedDirectory = path17.resolve(directory);
+  const resolvedRoot = path17.resolve(tempRoot);
+  if (path17.dirname(resolvedDirectory) !== resolvedRoot || !path17.basename(resolvedDirectory).startsWith(DIRECTORY_PREFIX)) {
     throw new Error("refusing to clean an unverified task-attachment directory");
   }
   return resolvedDirectory;
 }
 async function createAttachmentDirectory(taskId, tempRoot) {
-  const root = path14.resolve(tempRoot);
+  const root = path17.resolve(tempRoot);
   await mkdir(root, { recursive: true });
-  const directory = await mkdtemp(path14.join(root, `${DIRECTORY_PREFIX}${safeTaskToken(taskId)}-`));
-  const marker = JSON.stringify({ owner: MARKER_OWNER, token: randomUUID2(), directory: path14.basename(directory), created_at: (/* @__PURE__ */ new Date()).toISOString() });
-  await writeFile(path14.join(directory, MARKER_FILE), marker, { encoding: "utf8", mode: 384 });
+  const directory = await mkdtemp(path17.join(root, `${DIRECTORY_PREFIX}${safeTaskToken(taskId)}-`));
+  const marker = JSON.stringify({ owner: MARKER_OWNER, token: randomUUID2(), directory: path17.basename(directory), created_at: (/* @__PURE__ */ new Date()).toISOString() });
+  await writeFile(path17.join(directory, MARKER_FILE), marker, { encoding: "utf8", mode: 384 });
   return { directory, marker, tempRoot: root };
 }
 async function cleanupGeneratedDirectory(state) {
   if (!state || state.cleaned) return;
   const directory = assertGeneratedDirectory(state.directory, state.tempRoot);
-  const marker = await readFile(path14.join(directory, MARKER_FILE), "utf8").catch(() => "");
+  const marker = await readFile(path17.join(directory, MARKER_FILE), "utf8").catch(() => "");
   if (marker !== state.marker) throw new Error("refusing to clean a task-attachment directory without its exact marker");
   await rm(directory, { recursive: true, force: true });
   state.cleaned = true;
@@ -6661,7 +7405,7 @@ async function sweepStaleTaskAttachmentDirectories({
   now = Date.now(),
   maxAgeMs = DEFAULT_STALE_AGE_MS
 } = {}) {
-  const root = path14.resolve(tempRoot);
+  const root = path17.resolve(tempRoot);
   if (!Number.isFinite(maxAgeMs) || maxAgeMs <= 0) throw new Error("stale attachment age must be positive");
   const entries = await readdir(root, { withFileTypes: true }).catch((error) => {
     if (error?.code === "ENOENT") return [];
@@ -6670,8 +7414,8 @@ async function sweepStaleTaskAttachmentDirectories({
   let removed = 0;
   for (const entry of entries) {
     if (!entry.isDirectory() || !entry.name.startsWith(DIRECTORY_PREFIX)) continue;
-    const directory = assertGeneratedDirectory(path14.join(root, entry.name), root);
-    const markerRaw = await readFile(path14.join(directory, MARKER_FILE), "utf8").catch(() => "");
+    const directory = assertGeneratedDirectory(path17.join(root, entry.name), root);
+    const markerRaw = await readFile(path17.join(directory, MARKER_FILE), "utf8").catch(() => "");
     const marker = parseOwnedMarker(markerRaw, entry.name);
     if (!marker) continue;
     const directoryStat = await stat(directory);
@@ -6714,10 +7458,10 @@ async function materializeTaskAttachments(client, task, { tempRoot = os2.tmpdir(
       const sha256 = createHash3("sha256").update(content).digest("hex");
       if (sha256 !== ref.sha256) throw new Error(`attachment ${ref.attachment_id} sha256 mismatch`);
       const name = sanitizeTaskAttachmentName(ref.name, index);
-      const filePath = path14.join(state.directory, name);
+      const filePath = path17.join(state.directory, name);
       await writeFile(filePath, content, { flag: "wx", mode: 384 });
       await chmod(filePath, 384);
-      files.push({ attachmentId: ref.attachment_id, name, mime: ref.mime, sizeBytes: ref.size_bytes, sha256, path: path14.resolve(filePath) });
+      files.push({ attachmentId: ref.attachment_id, name, mime: ref.mime, sizeBytes: ref.size_bytes, sha256, path: path17.resolve(filePath) });
     }
     return { directory: state.directory, files, manifestMarkdown: buildManifest(files), cleanup: () => cleanupGeneratedDirectory(state) };
   } catch (error) {
@@ -6740,7 +7484,7 @@ var init_task_attachments = __esm({
 
 // ../../scripts/virtual-office/code-runner/session-spool-forwarder.mjs
 import { homedir as homedir4 } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 import { readdir as readdir2, readFile as readFile2, unlink, writeFile as writeFile2 } from "node:fs/promises";
 import { createHash as createHash4 } from "node:crypto";
 function deriveUuid(seed) {
@@ -6772,18 +7516,18 @@ async function readSpool(spoolDir = SPOOL_DIR) {
   for (const f of files) {
     if (!f.endsWith(".json")) continue;
     try {
-      const record = JSON.parse(await readFile2(join4(spoolDir, f), "utf8"));
+      const record = JSON.parse(await readFile2(join5(spoolDir, f), "utf8"));
       if (record && typeof record.session_key === "string") {
-        out.push({ full: join4(spoolDir, f), record });
+        out.push({ full: join5(spoolDir, f), record });
       }
     } catch {
     }
   }
   return out;
 }
-async function readCloudMap(path20) {
+async function readCloudMap(path23) {
   try {
-    return JSON.parse(await readFile2(path20, "utf8"));
+    return JSON.parse(await readFile2(path23, "utf8"));
   } catch {
     return {};
   }
@@ -6856,8 +7600,8 @@ var SPOOL_DIR, CLOUD_MAP_FILE, STALE_MS, ACTIVE_SILENCE_MS;
 var init_session_spool_forwarder = __esm({
   "../../scripts/virtual-office/code-runner/session-spool-forwarder.mjs"() {
     "use strict";
-    SPOOL_DIR = join4(homedir4(), ".vo", "session-spool");
-    CLOUD_MAP_FILE = join4(homedir4(), ".vo", "session-cloud-map.json");
+    SPOOL_DIR = join5(homedir4(), ".vo", "session-spool");
+    CLOUD_MAP_FILE = join5(homedir4(), ".vo", "session-cloud-map.json");
     STALE_MS = 60 * 60 * 1e3;
     ACTIVE_SILENCE_MS = 10 * 60 * 1e3;
   }
@@ -6928,7 +7672,7 @@ var init_rate_limit_resume_scheduler_core = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/rate-limit-resume-scheduler.mjs
-import { dirname as dirname3, join as join5, resolve } from "node:path";
+import { dirname as dirname4, join as join6, resolve } from "node:path";
 function defaultLog(message) {
   console.log(`[rate-limit-scheduler ${(/* @__PURE__ */ new Date()).toISOString()}] ${message}`);
 }
@@ -7010,7 +7754,7 @@ async function runLockedScheduler({
 async function runScheduler({
   env: env2 = process.env,
   queuePath = resumeQueuePath(),
-  attemptsPath = join5(dirname3(queuePath), "resume-attempts.json"),
+  attemptsPath = join6(dirname4(queuePath), "resume-attempts.json"),
   client,
   now,
   log: log2 = defaultLog
@@ -7073,6 +7817,10 @@ function makeLoopTicks({
     applyRemoteConfig: () => false,
     heartbeatFields: () => ({})
   },
+  // Host version awareness: reads `update_status` off the heartbeat ACK and logs
+  // ONE line per drift change (daemon-update-status.mjs). No-op default keeps
+  // old callers working; absent update_status reads as unknown, never current.
+  updateStatusTracker = { applyHeartbeatResponse: () => false },
   // Cached agent-availability provider (agent-availability.mjs); returns null
   // until the first probe completes — the heartbeat simply omits the field.
   getAgentAvailability = () => null,
@@ -7113,6 +7861,7 @@ function makeLoopTicks({
         request.then((response) => {
           capacityController.applyCapacity(response?.capacity, nextPayload.operatorId);
           localModelController.applyRemoteConfig(response?.local_model, nextPayload.operatorId);
+          updateStatusTracker.applyHeartbeatResponse(response);
         }).catch((e) => log2(`heartbeat failed: ${e.message}`)).finally(() => {
           for (const done of waiters) done();
           if (state.pending) {
@@ -7302,7 +8051,7 @@ var init_runner_capacity = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/agent-auth-probe-process.mjs
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
 async function probeAgentInChild(agent, timeoutMs) {
   const stdout = await runProcess2(process.execPath, [probeCli, agent], {
     timeout: timeoutMs,
@@ -7315,7 +8064,7 @@ var init_agent_auth_probe_process = __esm({
   "../../scripts/virtual-office/code-runner/agent-auth-probe-process.mjs"() {
     "use strict";
     init_process_runner2();
-    probeCli = fileURLToPath3(new URL("./agent-auth-probe-cli.mjs", import.meta.url));
+    probeCli = fileURLToPath5(new URL("./agent-auth-probe-cli.mjs", import.meta.url));
   }
 });
 
@@ -7540,7 +8289,7 @@ var init_local_model_remote_config = __esm({
 
 // ../../scripts/virtual-office/code-runner/account-usage/shared.mjs
 import crypto from "node:crypto";
-import fs7 from "node:fs";
+import fs9 from "node:fs";
 function accountKey(agent, rawId) {
   const id = typeof rawId === "string" ? rawId.trim() : "";
   if (!id) return null;
@@ -7604,7 +8353,7 @@ var init_shared = __esm({
     };
     readJson = (p) => {
       try {
-        return JSON.parse(fs7.readFileSync(p, "utf8"));
+        return JSON.parse(fs9.readFileSync(p, "utf8"));
       } catch {
         return null;
       }
@@ -7614,9 +8363,9 @@ var init_shared = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/account-usage/claude.mjs
-import fs8 from "node:fs";
+import fs10 from "node:fs";
 import os3 from "node:os";
-import path15 from "node:path";
+import path18 from "node:path";
 function fileCaptureTime(filePath, explicit, statFn) {
   if (typeof explicit === "string" && explicit) return explicit;
   try {
@@ -7630,7 +8379,7 @@ function usageBaseUrl(env2 = process.env) {
   return String(raw).replace(/\/+$/, "");
 }
 function readOAuthToken({ homeDir = os3.homedir(), read = readJson, now = Date.now() } = {}) {
-  const creds = read(path15.join(homeDir, ".claude", ".credentials.json"));
+  const creds = read(path18.join(homeDir, ".claude", ".credentials.json"));
   const oauth = creds && typeof creds === "object" ? creds.claudeAiOauth : null;
   if (!oauth || typeof oauth !== "object") return null;
   const token2 = typeof oauth.accessToken === "string" ? oauth.accessToken.trim() : "";
@@ -7640,7 +8389,7 @@ function readOAuthToken({ homeDir = os3.homedir(), read = readJson, now = Date.n
   return token2;
 }
 function readAccountId({ homeDir = os3.homedir(), read = readJson } = {}) {
-  const cfg = read(path15.join(homeDir, ".claude.json"));
+  const cfg = read(path18.join(homeDir, ".claude.json"));
   const account = cfg && typeof cfg === "object" ? cfg.oauthAccount : null;
   return account && typeof account.accountUuid === "string" ? account.accountUuid : null;
 }
@@ -7733,7 +8482,7 @@ async function readClaudeOAuthUsage({
 function readClaudeFileUsage({
   homeDir = os3.homedir(),
   read: rawRead = readJson,
-  statFn = fs8.statSync,
+  statFn = fs10.statSync,
   now = () => Date.now()
 } = {}) {
   const read = (p) => {
@@ -7750,7 +8499,7 @@ function readClaudeFileUsage({
     if (age === null || age > MAX_FILE_AGE_MS) return null;
     return row;
   };
-  const statusPath = path15.join(homeDir, ".claude", "claude-usage.json");
+  const statusPath = path18.join(homeDir, ".claude", "claude-usage.json");
   const status = read(statusPath);
   if (status && (status.seven_day || status.five_hour)) {
     const row = fresh(makeUsageRow({
@@ -7765,7 +8514,7 @@ function readClaudeFileUsage({
     }));
     if (row) return row;
   }
-  const weeklyPath = path15.join(homeDir, ".claude", "claude-weekly-usage.json");
+  const weeklyPath = path18.join(homeDir, ".claude", "claude-weekly-usage.json");
   const weekly = read(weeklyPath);
   if (weekly) {
     const row = fresh(makeUsageRow({
@@ -8206,7 +8955,7 @@ var init_watcher_coordination = __esm({
 // ../../scripts/virtual-office/code-runner/watcher-state.mjs
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { mkdir as mkdir2, open, readFile as readFile3, rename, unlink as unlink2 } from "node:fs/promises";
-import { dirname as dirname4 } from "node:path";
+import { dirname as dirname5 } from "node:path";
 async function readWatcherState(stateFile) {
   let raw;
   try {
@@ -8222,7 +8971,7 @@ async function readWatcherState(stateFile) {
   return parsed;
 }
 async function writeWatcherState(stateFile, state) {
-  const directory = dirname4(stateFile);
+  const directory = dirname5(stateFile);
   await mkdir2(directory, { recursive: true });
   const temp = `${stateFile}.${process.pid}.${randomUUID3()}.tmp`;
   let handle;
@@ -8468,7 +9217,7 @@ var init_enqueue_autonomous_code_task = __esm({
 
 // ../../scripts/virtual-office/code-runner/pr-watcher.mjs
 import { homedir as homedir5 } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 function parsePrCiStatus(view) {
   const state = (view && typeof view.state === "string" ? view.state : "UNKNOWN").toUpperCase();
   const rollup = view && Array.isArray(view.statusCheckRollup) ? view.statusCheckRollup : [];
@@ -8811,7 +9560,7 @@ var init_pr_watcher = __esm({
     init_watcher_state();
     init_superseded_pr_source();
     init_ci_fix_prompt();
-    DEFAULT_STATE_FILE = join6(homedir5(), ".vo", "dispatched-prs.json");
+    DEFAULT_STATE_FILE = join7(homedir5(), ".vo", "dispatched-prs.json");
     FAIL_CONCLUSIONS = /* @__PURE__ */ new Set([
       "FAILURE",
       "TIMED_OUT",
@@ -9041,9 +9790,9 @@ function buildControlHandler({ getStatus, requestStop, allowedOrigin }) {
       res.end();
       return;
     }
-    const path20 = String(req.url || "").split("?")[0];
+    const path23 = String(req.url || "").split("?")[0];
     res.setHeader("content-type", "application/json");
-    if (req.method === "GET" && path20 === "/status") {
+    if (req.method === "GET" && path23 === "/status") {
       let status;
       try {
         status = getStatus();
@@ -9054,7 +9803,7 @@ function buildControlHandler({ getStatus, requestStop, allowedOrigin }) {
       res.end(JSON.stringify({ ok: true, ...status }));
       return;
     }
-    if (req.method === "POST" && path20 === "/stop") {
+    if (req.method === "POST" && path23 === "/stop") {
       if (!isControlOriginAllowed(req.headers.origin, allowedOrigin) || !req.headers["x-vo-control"]) {
         res.statusCode = 403;
         res.end(JSON.stringify({ ok: false, error: "forbidden" }));
@@ -9115,7 +9864,7 @@ function startControlServer({ port, getStatus, requestStop, allowedOrigin, log:
   return server;
 }
 function startDaemonControl({ cfg, runnerInstanceId, requestStop, getActiveCount, isRunning, startedAt, log: log2 = () => {
-}, onDuplicate = null }) {
+}, onDuplicate = null, getUpdateStatus = () => null }) {
   if (!cfg.controlEnabled) return null;
   return startControlServer({
     port: cfg.controlPort,
@@ -9132,7 +9881,9 @@ function startDaemonControl({ cfg, runnerInstanceId, requestStop, getActiveCount
       watchEnabled: cfg.watchEnabled,
       activeTasks: getActiveCount(),
       startedAt: new Date(startedAt).toISOString(),
-      uptimeSec: Math.round((Date.now() - startedAt) / 1e3)
+      uptimeSec: Math.round((Date.now() - startedAt) / 1e3),
+      // Host version awareness — the app + `runner --status` read drift from here.
+      updateStatus: getUpdateStatus()
     }),
     log: log2
   });
@@ -9217,18 +9968,35 @@ var init_effort_mode_config = __esm({
 });
 
 // ../../scripts/virtual-office/model-registry.mjs
-import fs9 from "node:fs";
-import path16 from "node:path";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { randomUUID as randomUUID5 } from "node:crypto";
+import fs11 from "node:fs";
+import os4 from "node:os";
+import path19 from "node:path";
+import { fileURLToPath as fileURLToPath6 } from "node:url";
+function userCacheRoot() {
+  try {
+    const home = os4.homedir();
+    if (home) return path19.join(home, ".claude");
+  } catch {
+  }
+  return path19.join(os4.tmpdir(), `vo-model-registry-${randomUUID5()}`);
+}
+function resolveCacheBaseDir(env2 = process.env, moduleDir = __dirname) {
+  if (env2.VO_MODEL_REGISTRY_CACHE_DIR) return env2.VO_MODEL_REGISTRY_CACHE_DIR;
+  if (env2.VO_RUNNER_RUNTIME_ROOT) return env2.VO_RUNNER_RUNTIME_ROOT;
+  const segments = moduleDir.split(path19.sep);
+  const isRepoCheckout = segments.at(-1) === "virtual-office" && segments.at(-2) === "scripts";
+  return isRepoCheckout ? path19.resolve(moduleDir, "..", "..") : userCacheRoot();
+}
 function uniqueModels(models = []) {
   return [...new Set(models.map((model) => String(model || "").trim()).filter(Boolean))];
 }
 function normalizeProvider(value = "") {
-  const lower = String(value || "").trim().toLowerCase();
-  if (lower.includes("anthropic")) return "anthropic";
-  if (lower.includes("openai")) return "openai";
-  if (lower.includes("google") || lower.includes("gemini")) return "google";
-  return lower;
+  const lower2 = String(value || "").trim().toLowerCase();
+  if (lower2.includes("anthropic")) return "anthropic";
+  if (lower2.includes("openai")) return "openai";
+  if (lower2.includes("google") || lower2.includes("gemini")) return "google";
+  return lower2;
 }
 function stripProviderPrefix(id = "") {
   const raw = String(id || "").trim();
@@ -9270,15 +10038,15 @@ function normalizeCatalogModel(model = {}) {
   };
 }
 function parseVersionScore(id = "") {
-  const lower = String(id || "").toLowerCase();
-  const numbers = [...lower.matchAll(/\d+/g)].map((match) => Number(match[0])).filter(Number.isFinite);
+  const lower2 = String(id || "").toLowerCase();
+  const numbers = [...lower2.matchAll(/\d+/g)].map((match) => Number(match[0])).filter(Number.isFinite);
   let score = 0;
   for (let i = 0; i < numbers.length; i++) score += numbers[i] / Math.pow(1e3, i);
-  if (/opus|pro|flagship/.test(lower)) score += 10;
-  if (/sonnet/.test(lower)) score += 5;
-  if (/preview|latest/.test(lower)) score += 0.25;
-  if (/\[1m\]|\(1m\)/i.test(lower)) score += 1;
-  if (/mini|nano|haiku|lite/.test(lower)) score -= 20;
+  if (/opus|pro|flagship/.test(lower2)) score += 10;
+  if (/sonnet/.test(lower2)) score += 5;
+  if (/preview|latest/.test(lower2)) score += 0.25;
+  if (/\[1m\]|\(1m\)/i.test(lower2)) score += 1;
+  if (/mini|nano|haiku|lite/.test(lower2)) score -= 20;
   return score;
 }
 function familyMatches(model, family) {
@@ -9330,9 +10098,9 @@ async function fetchGoogleModels(fetchImpl, env2 = process.env) {
   return (data?.models || []).map((model) => normalizeCatalogModel({ ...model, provider: "google", source: "google" })).filter(Boolean);
 }
 function readCache(cacheFile = DEFAULT_CACHE_FILE, nowMs = Date.now(), ttlMs = DEFAULT_TTL_MS3) {
-  if (!fs9.existsSync(cacheFile)) return null;
+  if (!fs11.existsSync(cacheFile)) return null;
   try {
-    const parsed = JSON.parse(fs9.readFileSync(cacheFile, "utf-8"));
+    const parsed = JSON.parse(fs11.readFileSync(cacheFile, "utf-8"));
     if (nowMs - Number(parsed.checkedAtMs || 0) > ttlMs) return null;
     if (!Array.isArray(parsed.models)) return null;
     return parsed;
@@ -9341,8 +10109,8 @@ function readCache(cacheFile = DEFAULT_CACHE_FILE, nowMs = Date.now(), ttlMs = D
   }
 }
 function writeCache(cacheFile = DEFAULT_CACHE_FILE, payload) {
-  fs9.mkdirSync(path16.dirname(cacheFile), { recursive: true });
-  fs9.writeFileSync(cacheFile, JSON.stringify(payload, null, 2));
+  fs11.mkdirSync(path19.dirname(cacheFile), { recursive: true });
+  fs11.writeFileSync(cacheFile, JSON.stringify(payload, null, 2));
 }
 async function fetchRegistryCatalog({
   fetchImpl = fetch,
@@ -9395,14 +10163,17 @@ async function resolveModelFamily(family, options = {}) {
   const resolved = selectBestFamilyModel(catalog.models || [], family);
   return resolved || def.fallbacks[0];
 }
-var __dirname, ROOT, DEFAULT_CACHE_DIR, DEFAULT_CACHE_FILE, DEFAULT_TTL_MS3, ANTHROPIC_API_VERSION, FAMILY_DEFINITIONS, memoryCache;
+var __dirname, DEFAULT_CACHE_DIR, DEFAULT_CACHE_FILE, DEFAULT_TTL_MS3, ANTHROPIC_API_VERSION, FAMILY_DEFINITIONS, memoryCache;
 var init_model_registry = __esm({
   "../../scripts/virtual-office/model-registry.mjs"() {
     "use strict";
-    __dirname = path16.dirname(fileURLToPath4(import.meta.url));
-    ROOT = path16.resolve(__dirname, "..", "..");
-    DEFAULT_CACHE_DIR = path16.join(ROOT, ".virtual-office-cache", "model-registry");
-    DEFAULT_CACHE_FILE = path16.join(DEFAULT_CACHE_DIR, "catalog.json");
+    __dirname = path19.dirname(fileURLToPath6(import.meta.url));
+    DEFAULT_CACHE_DIR = path19.join(
+      resolveCacheBaseDir(),
+      ".virtual-office-cache",
+      "model-registry"
+    );
+    DEFAULT_CACHE_FILE = path19.join(DEFAULT_CACHE_DIR, "catalog.json");
     DEFAULT_TTL_MS3 = 60 * 60 * 1e3;
     ANTHROPIC_API_VERSION = "2023-06-01";
     FAMILY_DEFINITIONS = {
@@ -9507,17 +10278,17 @@ function modelCompatibleWithAgent(agent, model) {
   if (!model) return true;
   return AGENT_MODEL_COMPATIBILITY[agent]?.(model) ?? false;
 }
-function classifyTier(prompt) {
+function classifyTier2(prompt) {
   const text = String(prompt || "").trim();
   if (!text) return "mid";
-  const lower = text.toLowerCase();
+  const lower2 = text.toLowerCase();
   if (/lint|format|typo|missing import|update deps|chore|maintenance|runner|daemon/.test(
-    lower
+    lower2
   )) {
     return "cheap";
   }
   if (/generate roadmap|new feature|implement .* feature|major refactor|strategic/.test(
-    lower
+    lower2
   ) || text.length > 1500) {
     return "best";
   }
@@ -9538,7 +10309,7 @@ async function resolveModelForTier(tier, { agent = DEFAULT_AGENT2, resolveModelF
   return fallbacks[effectiveTier];
 }
 async function resolveTaskModel(task, { agent = DEFAULT_AGENT2 } = {}) {
-  const tier = task.tier && task.tier !== "auto" ? task.tier : classifyTier(task.prompt);
+  const tier = task.tier && task.tier !== "auto" ? task.tier : classifyTier2(task.prompt);
   const pinned = typeof task.model === "string" ? task.model.trim() : "";
   if (pinned && modelCompatibleWithAgent(normalizeAgent(agent), pinned)) {
     return { tier, model: pinned };
@@ -10011,7 +10782,7 @@ var init_classify_task = __esm({
 // ../../scripts/virtual-office/code-runner/auto-router/effort-policy.mjs
 import { readFileSync as readFileSync4 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 function difficultyToRung(difficulty, thresholds) {
   const b = thresholds.rungBounds;
   if (difficulty >= b.R5) return "R5";
@@ -10036,9 +10807,9 @@ function operatorTierToRung(tier, difficulty, thresholds) {
   if (tier === "best" && difficulty >= thresholds.rungBounds.R5) return "R5";
   return base;
 }
-function readCodexModelsCache({ path: path20 = DEFAULT_CODEX_MODELS_CACHE, read = readFileSync4 } = {}) {
+function readCodexModelsCache({ path: path23 = DEFAULT_CODEX_MODELS_CACHE, read = readFileSync4 } = {}) {
   try {
-    const parsed = JSON.parse(read(path20, "utf8"));
+    const parsed = JSON.parse(read(path23, "utf8"));
     return Array.isArray(parsed?.models) ? parsed : null;
   } catch {
     return null;
@@ -10088,7 +10859,7 @@ var init_effort_policy = __esm({
     init_meta_model_catalog();
     RUNG_ORDER = ["R1", "R2", "R3", "R4", "R5"];
     rungIndex = (rung) => RUNG_ORDER.indexOf(rung);
-    DEFAULT_CODEX_MODELS_CACHE = join7(homedir6(), ".codex", "models_cache.json");
+    DEFAULT_CODEX_MODELS_CACHE = join8(homedir6(), ".codex", "models_cache.json");
   }
 });
 
@@ -10220,16 +10991,16 @@ var init_role_cost_shadow = __esm({
 // ../../scripts/virtual-office/code-runner/auto-router/auto-router.mjs
 import { readFileSync as readFileSync5, appendFileSync, mkdirSync as mkdirSync4 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { join as join8, dirname as dirname5 } from "node:path";
-import { fileURLToPath as fileURLToPath5 } from "node:url";
+import { join as join9, dirname as dirname6 } from "node:path";
+import { fileURLToPath as fileURLToPath7 } from "node:url";
 function getAutoRouterMode(env2 = process.env) {
   const raw = String(env2.VO_CODE_RUNNER_AUTO_ROUTER || "").trim().toLowerCase();
   return MODES.has(raw) ? raw : "off";
 }
 function loadThresholds() {
   if (!cachedThresholds) {
-    const here = dirname5(fileURLToPath5(import.meta.url));
-    cachedThresholds = JSON.parse(readFileSync5(join8(here, "thresholds.json"), "utf8"));
+    const here = dirname6(fileURLToPath7(import.meta.url));
+    cachedThresholds = JSON.parse(readFileSync5(join9(here, "thresholds.json"), "utf8"));
   }
   return cachedThresholds;
 }
@@ -10295,15 +11066,15 @@ function formatDecisionReason(decision, maxLen = 480) {
   const s = `[${decision.routerVersion}] ${decision.taskClass} d=${decision.difficulty} c=${decision.confidence} \u2192 ${decision.rung}/${decision.tier}${decision.effort ? ` effort=${decision.effort}` : ""} turns=${decision.maxTurns} $${decision.maxBudgetUsd}${decision.flags.length ? ` [${decision.flags.join(",")}]` : ""} :: ${decision.reasons.join("; ")}`;
   return s.length > maxLen ? `${s.slice(0, maxLen - 1)}\u2026` : s;
 }
-function appendDecisionFallback(decision, { path: path20 = DECISION_FALLBACK_PATH, append = appendFileSync, mkdir: mkdir4 = mkdirSync4, task, thresholds, roleCostInputs } = {}) {
+function appendDecisionFallback(decision, { path: path23 = DECISION_FALLBACK_PATH, append = appendFileSync, mkdir: mkdir4 = mkdirSync4, task, thresholds, roleCostInputs } = {}) {
   try {
-    mkdir4(dirname5(path20), { recursive: true });
-    append(path20, `${JSON.stringify(decision)}
+    mkdir4(dirname6(path23), { recursive: true });
+    append(path23, `${JSON.stringify(decision)}
 `, "utf8");
     if (isRouterDecision(decision)) {
       try {
         const records = buildShadowRecords({ decision, task, thresholds: thresholds || loadThresholds(), roleCostInputs });
-        for (const record of records) append(path20, `${JSON.stringify(record)}
+        for (const record of records) append(path23, `${JSON.stringify(record)}
 `, "utf8");
       } catch {
       }
@@ -10321,7 +11092,7 @@ var init_auto_router = __esm({
     init_effort_policy();
     init_role_cost_shadow();
     ROUTER_VERSION = "0.1.0";
-    DECISION_FALLBACK_PATH = join8(homedir7(), ".claude", "vo-auto-router-decisions.jsonl");
+    DECISION_FALLBACK_PATH = join9(homedir7(), ".claude", "vo-auto-router-decisions.jsonl");
     MODES = /* @__PURE__ */ new Set(["off", "shadow", "on"]);
     cachedThresholds = null;
     isRouterDecision = (d) => Boolean(d && typeof d === "object" && typeof d.taskClass === "string" && typeof d.confidence === "number");
@@ -11294,9 +12065,9 @@ var init_inference_task_runner = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/isolation-audit.mjs
-import fs10 from "node:fs";
+import fs12 from "node:fs";
 import fsp11 from "node:fs/promises";
-import path17 from "node:path";
+import path20 from "node:path";
 async function defaultRun(command, args, cwd, options = {}) {
   return runProcess2(command, args, { cwd, timeout: 6e4, ...options });
 }
@@ -11309,7 +12080,7 @@ async function canonicalRootForWorktree(worktreeDir, run) {
     "--path-format=absolute",
     "--git-common-dir"
   ])).trim();
-  const root = path17.dirname(commonDir);
+  const root = path20.dirname(commonDir);
   return samePath2(root, worktreeDir) ? null : root;
 }
 async function snapshot(root, run) {
@@ -11351,21 +12122,21 @@ async function changedPaths(root, run) {
 }
 async function quarantineCanonicalWrites({ baseline, worktreeDir, taskId, run, now }) {
   const paths = await changedPaths(baseline.root, run);
-  const quarantineDir = path17.join(
-    path17.dirname(worktreeDir),
+  const quarantineDir = path20.join(
+    path20.dirname(worktreeDir),
     ".canonical-recovery",
     `${String(taskId || "unknown").replace(/[^a-z0-9-]/gi, "-")}-${now().toISOString().replace(/[:.]/g, "-")}`
   );
   await fsp11.mkdir(quarantineDir, { recursive: true });
   const patch = await git2(run, baseline.root, ["diff", "--binary", "HEAD"], { raw: true });
-  await fsp11.writeFile(path17.join(quarantineDir, "tracked.patch"), patch, "utf8");
+  await fsp11.writeFile(path20.join(quarantineDir, "tracked.patch"), patch, "utf8");
   for (const relative of paths.untracked) {
-    const source = path17.join(baseline.root, relative);
-    const target = path17.join(quarantineDir, "untracked", relative);
-    await fsp11.mkdir(path17.dirname(target), { recursive: true });
+    const source = path20.join(baseline.root, relative);
+    const target = path20.join(quarantineDir, "untracked", relative);
+    await fsp11.mkdir(path20.dirname(target), { recursive: true });
     await fsp11.copyFile(source, target);
   }
-  await fsp11.writeFile(path17.join(quarantineDir, "manifest.json"), `${JSON.stringify({
+  await fsp11.writeFile(path20.join(quarantineDir, "manifest.json"), `${JSON.stringify({
     taskId,
     canonicalRoot: baseline.root,
     canonicalHead: baseline.head,
@@ -11387,9 +12158,9 @@ async function restoreExactCanonicalPaths(baseline, evidence, run) {
     ]);
   }
   for (const relative of evidence.untracked) {
-    const target = path17.resolve(baseline.root, relative);
-    const prefix = `${path17.resolve(baseline.root)}${path17.sep}`;
-    if (!target.startsWith(prefix) || !fs10.existsSync(target)) continue;
+    const target = path20.resolve(baseline.root, relative);
+    const prefix = `${path20.resolve(baseline.root)}${path20.sep}`;
+    if (!target.startsWith(prefix) || !fs12.existsSync(target)) continue;
     await fsp11.rm(target, { force: true });
   }
 }
@@ -11425,7 +12196,7 @@ var init_isolation_audit = __esm({
     init_process_runner2();
     splitZ2 = (value) => String(value || "").split("\0").map((item) => item.trim()).filter(Boolean);
     samePath2 = (left, right) => {
-      const [a, b] = [left, right].map((value) => path17.resolve(value));
+      const [a, b] = [left, right].map((value) => path20.resolve(value));
       return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
     };
   }
@@ -11785,7 +12556,7 @@ var init_publication_outcome = __esm({
 
 // ../../scripts/virtual-office/code-runner/committed-scratch-cleanup.mjs
 import fsp12 from "node:fs/promises";
-import path18 from "node:path";
+import path21 from "node:path";
 function defaultRun2(command, args, cwd, options = {}) {
   return runProcess2(command, args, { cwd, ...options });
 }
@@ -11793,13 +12564,13 @@ async function resolveSafeScratchTarget(worktreeDir, file) {
   if (!isAgentScratch(file)) {
     throw new Error(`refusing to remove non-scratch publication path: ${file}`);
   }
-  const root = path18.resolve(worktreeDir);
-  const target = path18.resolve(root, file);
-  const relative = path18.relative(root, target);
-  if (!relative || relative.startsWith(`..${path18.sep}`) || path18.isAbsolute(relative)) {
+  const root = path21.resolve(worktreeDir);
+  const target = path21.resolve(root, file);
+  const relative = path21.relative(root, target);
+  if (!relative || relative.startsWith(`..${path21.sep}`) || path21.isAbsolute(relative)) {
     throw new Error(`refusing to remove publication scratch outside worktree: ${file}`);
   }
-  for (let cursor = target; cursor !== root; cursor = path18.dirname(cursor)) {
+  for (let cursor = target; cursor !== root; cursor = path21.dirname(cursor)) {
     try {
       if ((await fsp12.lstat(cursor)).isSymbolicLink()) {
         throw new Error(`refusing to follow symlink while removing publication scratch: ${file}`);
@@ -11919,9 +12690,9 @@ var init_publication_scope = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/recovery-ledger.mjs
-import fs11 from "node:fs";
+import fs13 from "node:fs";
 import fsp13 from "node:fs/promises";
-import path19 from "node:path";
+import path22 from "node:path";
 function recoveryTaskId(prompt) {
   const match = String(prompt || "").match(/VO_RECOVERY_FROM_CODE_TASK:\s*([0-9a-f-]{36})/i);
   return match ? match[1].toLowerCase() : null;
@@ -11935,10 +12706,10 @@ function cloneLeaf(repo) {
 function recoveryLedgerCandidates(repo, clonesRoot2) {
   const leaf = cloneLeaf(repo);
   if (!leaf || !clonesRoot2) return [];
-  const canonical = path19.join(clonesRoot2, leaf);
+  const canonical = path22.join(clonesRoot2, leaf);
   return [
-    path19.join(clonesRoot2, ".agent-worktrees", leaf, "recovery-ledger.jsonl"),
-    path19.join(canonical, ".agent-worktrees", "recovery-ledger.jsonl")
+    path22.join(clonesRoot2, ".agent-worktrees", leaf, "recovery-ledger.jsonl"),
+    path22.join(canonical, ".agent-worktrees", "recovery-ledger.jsonl")
   ];
 }
 async function readLedger(file, readFile5) {
@@ -11957,7 +12728,7 @@ async function readLedger(file, readFile5) {
 async function findPreservedRecovery(task, {
   clonesRoot: clonesRoot2 = process.env.VO_CODE_RUNNER_CLONES_ROOT || "",
   readFile: readFile5 = fsp13.readFile,
-  exists = fs11.existsSync
+  exists = fs13.existsSync
 } = {}) {
   const resumedFrom = /^[0-9a-f-]{36}$/iu.test(String(task.resumed_from || "")) ? String(task.resumed_from).toLowerCase() : null;
   const originalTaskId = recoveryTaskId(task.prompt) ?? resumedFrom;
@@ -12272,7 +13043,7 @@ var init_cancellation_probe = __esm({
 
 // ../../scripts/virtual-office/code-runner/detached-economics-spool.mjs
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname6, join as join9 } from "node:path";
+import { dirname as dirname7, join as join10 } from "node:path";
 import { mkdir as mkdir3, readFile as readFile4, rename as rename2, writeFile as writeFile3 } from "node:fs/promises";
 function withLock(operation) {
   const result = serialized.then(operation, operation);
@@ -12290,7 +13061,7 @@ async function readEntries(file) {
   }
 }
 async function writeEntries(file, entries) {
-  await mkdir3(dirname6(file), { recursive: true });
+  await mkdir3(dirname7(file), { recursive: true });
   const temp = `${file}.${process.pid}.tmp`;
   await writeFile3(temp, `${JSON.stringify(entries)}
 `, "utf8");
@@ -12336,13 +13107,13 @@ var DEFAULT_FILE, serialized;
 var init_detached_economics_spool = __esm({
   "../../scripts/virtual-office/code-runner/detached-economics-spool.mjs"() {
     "use strict";
-    DEFAULT_FILE = join9(homedir8(), ".vo", "detached-run-economics.json");
+    DEFAULT_FILE = join10(homedir8(), ".vo", "detached-run-economics.json");
     serialized = Promise.resolve();
   }
 });
 
 // ../../scripts/virtual-office/code-runner/killed-run-outcome.mjs
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 async function handleKilledRun({
   client,
   id,
@@ -12379,7 +13150,7 @@ async function handleKilledRun({
     };
   }
   if (reason === "claim_authority_changed") {
-    const occurrenceId = randomUUID5();
+    const occurrenceId = randomUUID6();
     const economics = {
       occurrence_id: occurrenceId,
       runner_id: runnerId,
@@ -12479,13 +13250,13 @@ var init_runner_runtime_limits = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/daemon-config.mjs
-import os4 from "node:os";
+import os5 from "node:os";
 function loadCodeRunnerConfig(env2 = process.env, { log: log2 = () => {
 } } = {}) {
   const servedOperators = parseList(env2.VO_CODE_RUNNER_OPERATOR_IDS);
   const allowAmbientGithub = env2.VO_CODE_RUNNER_ALLOW_AMBIENT_GH === "1";
   return {
-    runnerId: env2.VO_CODE_RUNNER_ID || `vo-code-runner-${os4.hostname()}`,
+    runnerId: env2.VO_CODE_RUNNER_ID || `vo-code-runner-${os5.hostname()}`,
     ...resolveRunner(env2, { warn: (message) => log2(`agent-select: ${message}`) }),
     permissionMode: env2.VO_CODE_RUNNER_PERMISSION_MODE || "acceptEdits",
     maxConcurrency: Math.max(1, Number(env2.VO_CODE_TASK_MAX_CONCURRENCY || 2) || 2),
@@ -12495,7 +13266,7 @@ function loadCodeRunnerConfig(env2 = process.env, { log: log2 = () => {
     requireGithubAppAuth: !allowAmbientGithub && servedOperators.length > 0,
     allowAmbientGithub,
     sessionForwardSec: Math.max(0, Number(env2.VO_SESSION_FORWARD_SEC ?? 30) || 0),
-    operatorSeed: env2.VO_LOCAL_OPERATOR_SEED || env2.VO_CODE_RUNNER_ID || `local-${os4.hostname()}`,
+    operatorSeed: env2.VO_LOCAL_OPERATOR_SEED || env2.VO_CODE_RUNNER_ID || `local-${os5.hostname()}`,
     cancelPollMs: Math.max(1e3, Number(env2.VO_CODE_RUNNER_CANCEL_POLL_MS || 2500) || 2500),
     maxWallClockMs: resolveMaxWallClockMs(env2.VO_CODE_RUNNER_MAX_WALL_CLOCK_MS),
     watchEnabled: env2.VO_CODE_RUNNER_WATCH !== "0",
@@ -12674,10 +13445,10 @@ var init_task_worktree_preparation = __esm({
 // ../../scripts/virtual-office/code-runner-daemon.mjs
 var code_runner_daemon_exports = {};
 __export(code_runner_daemon_exports, {
-  main: () => main
+  main: () => main2
 });
-import { randomUUID as randomUUID6 } from "node:crypto";
-import { fileURLToPath as fileURLToPath6 } from "node:url";
+import { randomUUID as randomUUID7 } from "node:crypto";
+import { fileURLToPath as fileURLToPath8 } from "node:url";
 function log(msg) {
   console.log(`[code-runner ${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}`);
 }
@@ -12819,16 +13590,12 @@ async function processOneTask(client, task, cfg, runnerInstanceId, swarmAdmissio
       return;
     }
     if (await taskWasCancelled({ client, id, run, safeProgress, log })) return;
+    if (await gateTestGenTaskOrFail({ client, id, task, files, worktreeDir: wt.worktreeDir, log })) return;
+    if (await enforceCompletionGateOrFail({ client, id, task, worktreeDir: wt.worktreeDir, log })) return;
     const publicationTarget = await resolvePublicationTarget({ task, continuationRestore, worktreeDir: wt.worktreeDir, githubToken, allowAmbientGithubFallback: cfg.allowAmbientGithub });
     const localBranch = await resolveOrCreateBranchAsync(wt.worktreeDir, "vo/code-task");
     const publicationBranch = publicationTarget.targetBranch || localBranch;
-    if (!await recordPublicationIntent({
-      client,
-      id,
-      branch: publicationBranch,
-      safeProgress,
-      log
-    })) {
+    if (!await recordPublicationIntent({ client, id, branch: publicationBranch, safeProgress, log })) {
       await reportCancelledRun({ client, id, run, safeProgress, log });
       return;
     }
@@ -12903,10 +13670,10 @@ Closes #${publicationTarget.supersedesPrNumber}` : "";
     }
   }
 }
-async function main({ env: env2 = process.env, once: once2 = false } = {}) {
+async function main2({ env: env2 = process.env, once: once2 = false } = {}) {
   const cfg = loadCodeRunnerConfig(env2, { log });
   await sweepStaleTaskAttachmentDirectories().catch((error) => log(`stale attachment cleanup failed: ${error.message}`));
-  const runnerInstanceId = randomUUID6();
+  const runnerInstanceId = randomUUID7();
   const client = createControlPlaneClient({
     env: env2,
     runnerId: cfg.runnerId,
@@ -13049,7 +13816,7 @@ async function main({ env: env2 = process.env, once: once2 = false } = {}) {
   if (controlServer) controlServer.close();
   log("stopped");
 }
-var RATE_LIMIT_RESUME_ENABLED, sleep2, safeProgress, invokedDirectly;
+var RATE_LIMIT_RESUME_ENABLED, sleep2, safeProgress, invokedDirectly2;
 var init_code_runner_daemon = __esm({
   "../../scripts/virtual-office/code-runner-daemon.mjs"() {
     "use strict";
@@ -13060,6 +13827,8 @@ var init_code_runner_daemon = __esm({
     init_resolve_runner();
     init_rate_limit_resume();
     init_publish();
+    init_test_gen_gate();
+    init_completion_gate();
     init_orphan_agent_reaper();
     init_publish_async();
     init_task_prompt();
@@ -13097,11 +13866,11 @@ var init_code_runner_daemon = __esm({
     RATE_LIMIT_RESUME_ENABLED = process.env.VO_RATE_LIMIT_RESUME !== "0";
     sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
     safeProgress = makeSafeProgress(log);
-    invokedDirectly = process.argv[1] && fileURLToPath6(import.meta.url) === process.argv[1] && // Bundle-safe: self-start only when THIS file is the real entry (not inlined into vo-mcp's runner-cli.js ⇒ double-claim).
+    invokedDirectly2 = process.argv[1] && fileURLToPath8(import.meta.url) === process.argv[1] && // Bundle-safe: self-start only when THIS file is the real entry (not inlined into vo-mcp's runner-cli.js ⇒ double-claim).
     import.meta.url.endsWith("code-runner-daemon.mjs");
-    if (invokedDirectly) {
+    if (invokedDirectly2) {
       const once2 = process.argv.includes("--once");
-      main({ once: once2 }).catch((err) => {
+      main2({ once: once2 }).catch((err) => {
         console.error("[code-runner] fatal:", err);
         process.exit(1);
       });
@@ -13468,8 +14237,8 @@ var env = {
   ...pairedOperatorId ? { VO_CODE_RUNNER_OPERATOR_IDS: pairedOperatorId } : {}
 };
 var once = process.argv.includes("--once");
-var { main: main2 } = await Promise.resolve().then(() => (init_code_runner_daemon(), code_runner_daemon_exports));
-main2({ env, once }).catch((err) => {
+var { main: main3 } = await Promise.resolve().then(() => (init_code_runner_daemon(), code_runner_daemon_exports));
+main3({ env, once }).catch((err) => {
   console.error("[vo-mcp runner] fatal:", err);
   process.exit(1);
 });