@algosuite/vo-mcp 0.2.0-beta.58 → 0.2.0-beta.59

package/dist/runner-cli.js

@@ -3666,6 +3666,93 @@ var init_control_plane_knowledge_context = __esm({
   }
 });
 
+// ../../scripts/virtual-office/code-runner/control-plane-prepared-job.mjs
+function preparedJobQuery({ agent = "claude", env: env2 = {} } = {}) {
+  const params = new URLSearchParams();
+  params.set("agent", String(agent));
+  const sent = [];
+  const dropped = [];
+  for (const key of PREPARED_JOB_ENV_QUERY_KEYS) {
+    const raw = env2?.[key];
+    if (typeof raw !== "string" || raw.length === 0) continue;
+    if (raw.length > PREPARED_JOB_ENV_VALUE_MAX) {
+      dropped.push(key);
+      continue;
+    }
+    params.set(key, raw);
+    sent.push(key);
+  }
+  return { query: params.toString(), sent, dropped };
+}
+async function refusalCode(res) {
+  try {
+    const body = await res.json();
+    return typeof body?.error === "string" && body.error ? body.error : null;
+  } catch {
+    return null;
+  }
+}
+async function getPreparedJobRequest(req, taskId, options = {}, invalidateToken = () => {
+}) {
+  const { agent = "claude", env: env2 = {}, timeoutMs = 15e3 } = options;
+  const { query, sent, dropped } = preparedJobQuery({ agent, env: env2 });
+  const envMeta = { envSent: sent, envDropped: dropped };
+  if (typeof taskId !== "string" || taskId.length === 0) {
+    return { ok: false, reason: "missing_task_id", status: 0, ...envMeta };
+  }
+  const path22 = `/api/v1/code-task/${encodeURIComponent(taskId)}/prepared-job?${query}`;
+  let res;
+  try {
+    res = await req("GET", path22, void 0, { timeoutMs });
+  } catch (err) {
+    return { ok: false, reason: `transport: ${err?.message || String(err)}`, status: 0, ...envMeta };
+  }
+  if (res?.status === 401) {
+    try {
+      invalidateToken();
+    } catch {
+    }
+    return { ok: false, reason: "unauthorized", status: 401, ...envMeta };
+  }
+  if (!res?.ok) {
+    const code = await refusalCode(res);
+    return { ok: false, reason: code || `http_${res?.status ?? "unknown"}`, status: res?.status ?? 0, ...envMeta };
+  }
+  let body;
+  try {
+    body = await res.json();
+  } catch (err) {
+    return { ok: false, reason: `unreadable_body: ${err?.message || String(err)}`, status: res.status, ...envMeta };
+  }
+  const job = body?.prepared_job;
+  if (!job || typeof job !== "object") {
+    return { ok: false, reason: "no_prepared_job_in_body", status: res.status, ...envMeta };
+  }
+  return {
+    ok: true,
+    job,
+    composition: body?.composition && typeof body.composition === "object" ? body.composition : {},
+    ...envMeta
+  };
+}
+var PREPARED_JOB_ENV_QUERY_KEYS, PREPARED_JOB_ENV_VALUE_MAX;
+var init_control_plane_prepared_job = __esm({
+  "../../scripts/virtual-office/code-runner/control-plane-prepared-job.mjs"() {
+    "use strict";
+    PREPARED_JOB_ENV_QUERY_KEYS = [
+      "VO_CODE_RUNNER_NO_WEB",
+      "VO_CODE_RUNNER_NO_WORKFLOW",
+      "VO_CODE_RUNNER_NO_CONSENSUS",
+      "VO_CODE_RUNNER_PERMISSION_MODE",
+      "VO_CODE_RUNNER_DEFAULT_BUDGET_USD",
+      "VO_CODE_RUNNER_META_REASONING_EFFORT",
+      "VO_CODE_RUNNER_ALLOW_MISSING_KNOWLEDGE_CONTEXT",
+      "VO_ENABLE_CONTEXT7"
+    ];
+    PREPARED_JOB_ENV_VALUE_MAX = 64;
+  }
+});
+
 // src/runner/control-plane-auth-stub.mjs
 var control_plane_auth_stub_exports = {};
 __export(control_plane_auth_stub_exports, {
@@ -3902,6 +3989,10 @@ function createControlPlaneClient({
         log: (m) => console.warn(`[code-runner ${(/* @__PURE__ */ new Date()).toISOString()}] ${m}`)
       });
     },
+    /** ADR-004 § 11.1b: the plane's prepared job, for SHADOW comparison. Never throws. */
+    getPreparedJob: (taskId, options) => getPreparedJobRequest(req, taskId, options, () => {
+      cachedFirebaseToken = null;
+    }),
     /** Weekly Claude token usage report — see control-plane-weekly-tokens.mjs. */
     async postWeeklyTokens(report) {
       return postWeeklyTokensRequest(taskReq, report, () => {
@@ -3923,8 +4014,8 @@ function createControlPlaneClient({
      * authenticated operator so the web shows a TRUE "runner online" signal.
      * Best-effort caller; throws on 401/non-ok so the daemon can log + retry.
      */
-    async postHeartbeat({ runnerId: runnerId2, runnerInstanceId: runnerInstanceId2, operatorId, uptimeSec, activeTasks, maxConcurrency, effectiveConcurrency, measuredTaskSlots, measuredCpuSlots, measuredMemorySlots, version, daemonVersion, defaultAgent, supervisorInstanceId, supervisorVersion, supervisorCapabilities, servedRepos, servedOperators, availableAgents, accountUsage, availableLocalModels }) {
-      const body = { runner_id: runnerId2 };
+    async postHeartbeat({ runnerId: runnerId2, runnerInstanceId: runnerInstanceId2, operatorId, uptimeSec, activeTasks, maxConcurrency, effectiveConcurrency, measuredTaskSlots, measuredCpuSlots, measuredMemorySlots, version, daemonVersion, defaultAgent, supervisorInstanceId, supervisorVersion, supervisorCapabilities, servedRepos, servedOperators, availableAgents, accountUsage, availableLocalModels, prepared_job_shadow: preparedJobShadow }) {
+      const body = { runner_id: runnerId2, ...preparedJobShadow ? { prepared_job_shadow: preparedJobShadow } : {} };
       if (runnerInstanceId2) body.runner_instance_id = runnerInstanceId2;
       if (operatorId) body.operator_id = operatorId;
       if (typeof uptimeSec === "number") body.uptime_sec = uptimeSec;
@@ -4055,6 +4146,7 @@ var init_control_plane_client = __esm({
     init_control_plane_telemetry_relay();
     init_claim_gate_notice();
     init_control_plane_knowledge_context();
+    init_control_plane_prepared_job();
     cachedFirebaseToken = null;
     ClaimAuthorityChangedError = class extends Error {
       constructor() {
@@ -8784,13 +8876,13 @@ async function materializeTaskAttachments(client, task, { tempRoot = os2.tmpdir(
       const content = await client.downloadTaskAttachment(task.code_task_id, ref.attachment_id);
       if (!Buffer.isBuffer(content)) throw new Error(`attachment ${ref.attachment_id} did not return binary content`);
       if (content.byteLength !== ref.size_bytes) throw new Error(`attachment ${ref.attachment_id} size mismatch`);
-      const sha256 = createHash4("sha256").update(content).digest("hex");
-      if (sha256 !== ref.sha256) throw new Error(`attachment ${ref.attachment_id} sha256 mismatch`);
+      const sha2562 = createHash4("sha256").update(content).digest("hex");
+      if (sha2562 !== ref.sha256) throw new Error(`attachment ${ref.attachment_id} sha256 mismatch`);
       const name = sanitizeTaskAttachmentName(ref.name, index);
       const filePath = path16.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: path16.resolve(filePath) });
+      files.push({ attachmentId: ref.attachment_id, name, mime: ref.mime, sizeBytes: ref.size_bytes, sha256: sha2562, path: path16.resolve(filePath) });
     }
     return { directory: state.directory, files, manifestMarkdown: buildManifest(files), cleanup: () => cleanupGeneratedDirectory(state) };
   } catch (error) {
@@ -9443,6 +9535,13 @@ function makeLoopTicks({
     applyRemoteConfig: () => false,
     heartbeatFields: () => ({})
   },
+  // ADR-004 § 11.1b-2: plane-delivered prepared-job consumption mode + the
+  // counts-only shadow tally (prepared-job-remote-config.mjs). Same no-op
+  // default contract as above, so an absent controller changes nothing.
+  preparedJobController = {
+    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.
@@ -9491,6 +9590,7 @@ function makeLoopTicks({
         request.then((response) => {
           capacityController.applyCapacity(response?.capacity, nextPayload.operatorId);
           localModelController.applyRemoteConfig(response?.local_model, nextPayload.operatorId);
+          preparedJobController.applyRemoteConfig(response?.prepared_job, nextPayload.operatorId);
           updateStatusTracker.applyHeartbeatResponse(response);
         }).catch((e) => log2(`heartbeat failed: ${e.message}`)).finally(() => {
           for (const done of waiters) done();
@@ -9535,6 +9635,7 @@ function makeLoopTicks({
       const supervisorCapabilities = String(env2.VO_RUNNER_SUPERVISOR_CAPABILITIES || "").split(",").map((value) => value.trim()).filter(Boolean).slice(0, 8);
       const capacityFields = capacityController.heartbeatFields();
       const localModelFields = localModelController.heartbeatFields();
+      const preparedJobFields = preparedJobController.heartbeatFields();
       const baseHeartbeat = {
         runnerId: cfg.runnerId,
         ...runnerInstanceId ? { runnerInstanceId } : {},
@@ -9552,7 +9653,8 @@ function makeLoopTicks({
         activeTasks: getActive(),
         maxConcurrency: cfg.maxConcurrency,
         ...capacityFields,
-        ...localModelFields
+        ...localModelFields,
+        ...preparedJobFields
       };
       const operatorIds = servedOperators.length > 0 ? servedOperators : [void 0];
       for (const operatorId of operatorIds) {
@@ -9919,6 +10021,434 @@ var init_local_model_remote_config = __esm({
   }
 });
 
+// ../../scripts/virtual-office/code-runner/prepared-job-shadow.mjs
+import { appendFileSync, mkdirSync as mkdirSync8 } from "node:fs";
+import { createHash as createHash6 } from "node:crypto";
+import { homedir as homedir9 } from "node:os";
+import { dirname as dirname10, join as join14 } from "node:path";
+function setRemotePreparedJobMode(mode) {
+  const value = typeof mode === "string" ? mode.trim().toLowerCase() : "";
+  remotePreparedJobMode = value && PREPARED_JOB_MODES.includes(value) ? value : "";
+}
+function preparedJobConsumptionMode(env2 = process.env) {
+  const raw = String(env2?.[PREPARED_JOB_MODE_ENV] ?? "").trim().toLowerCase();
+  if (raw && PREPARED_JOB_MODES.includes(raw)) return raw;
+  return remotePreparedJobMode || "off";
+}
+function shadowTimeoutMs(env2 = process.env) {
+  const n = Number(env2?.[PREPARED_JOB_SHADOW_TIMEOUT_ENV]);
+  return Number.isFinite(n) && n > 0 ? Math.min(n, 6e4) : DEFAULT_SHADOW_TIMEOUT_MS;
+}
+function firstDivergenceIndex(a, b) {
+  const A = String(a ?? "");
+  const B = String(b ?? "");
+  const limit = Math.min(A.length, B.length);
+  for (let i = 0; i < limit; i += 1) if (A[i] !== B[i]) return i;
+  return A.length === B.length ? -1 : limit;
+}
+function localCompositionAsPreparedJob(local = {}, { agent = "claude", env: env2 = process.env } = {}) {
+  const isClaude = String(agent || "").trim().toLowerCase() === "claude";
+  return {
+    prompt: local.prompt ?? "",
+    argv: buildClaudeArgs({
+      permissionMode: local.permissionMode,
+      maxTurns: isClaude ? local.maxTurns : void 0,
+      model: local.model,
+      effort: local.effort,
+      maxBudgetUsd: isClaude ? local.maxBudgetUsd : void 0,
+      researchHarness: local.methodology?.shape === "research",
+      env: env2
+    }),
+    permission_mode: local.permissionMode ?? null,
+    dispatch_mode: local.dispatchMode ?? null,
+    tier: local.tier ?? null,
+    model: local.model ?? null,
+    effort: local.effort ?? null,
+    max_turns: local.maxTurns ?? null,
+    max_budget_usd: local.maxBudgetUsd ?? null,
+    methodology_shape: local.methodology?.shape ?? null,
+    methodology_stakes: local.methodology?.stakes ?? null
+  };
+}
+function planeJobAsComparable(job = {}) {
+  return {
+    prompt: job.prompt ?? "",
+    argv: job.argv ?? null,
+    permission_mode: job.permission_mode ?? null,
+    dispatch_mode: job.dispatch_mode ?? null,
+    tier: job.tier ?? null,
+    model: job.model ?? null,
+    effort: job.effort ?? null,
+    max_turns: job.max_turns ?? null,
+    max_budget_usd: job.max_budget_usd ?? null,
+    methodology_shape: job.methodology?.shape ?? null,
+    methodology_stakes: job.methodology?.stakes ?? null
+  };
+}
+function classifyDivergence(field, ctx = {}) {
+  const known = (reason) => ({ class: "known_remainder", reason });
+  if (Array.isArray(ctx.envDropped) && ctx.envDropped.length > 0) {
+    return known(`env_value_too_long:${ctx.envDropped.join("+")}`);
+  }
+  if ((field === "model" || field === "tier") && ctx.planeModelRegistryUnavailable) {
+    return known("no_plane_model_registry");
+  }
+  if (field === "dispatch_mode" && ctx.taskDispatchModeAbsent) return known("plane_dispatch_mode_default");
+  if (ctx.dispatchModeDiverged && DISPATCH_MODE_DEPENDENT.has(field)) {
+    return known("downstream_of_dispatch_mode");
+  }
+  if (field === "prompt" && ctx.attachmentManifestPresent) return known("attachment_manifest_not_sent");
+  if (field === "prompt" && ctx.planeSkillCatalogUnavailable) return known("skill_catalog_unavailable");
+  return { class: "unexplained", reason: null };
+}
+function comparePreparedJob({ local, plane, context = {} }) {
+  const L = local || {};
+  const P = plane || {};
+  const raw = COMPARED_FIELDS.filter((f) => !sameValue(L[f], P[f]));
+  const ctx = { ...context, dispatchModeDiverged: raw.includes("dispatch_mode") };
+  const divergences = raw.map((field) => {
+    const { class: cls, reason } = classifyDivergence(field, ctx);
+    const entry = { field, class: cls, reason };
+    if (field !== "prompt") {
+      entry.runner = L[field] ?? null;
+      entry.plane = P[field] ?? null;
+    }
+    return entry;
+  });
+  const unexplainedFields = divergences.filter((d) => d.class === "unexplained").map((d) => d.field);
+  return {
+    verdict: divergences.length === 0 ? "parity_ok" : unexplainedFields.length > 0 ? "parity_diverged" : "parity_known_remainder",
+    divergences,
+    divergentFields: raw,
+    unexplainedFields,
+    prompt: {
+      runner_len: String(L.prompt ?? "").length,
+      plane_len: String(P.prompt ?? "").length,
+      runner_sha256: sha256(L.prompt),
+      plane_sha256: sha256(P.prompt),
+      first_diff_index: firstDivergenceIndex(L.prompt, P.prompt)
+    }
+  };
+}
+function selectDispatchComposition({ mode, local, plane, comparison }) {
+  if (mode === "prepared" && plane && comparison?.verdict !== "unavailable") {
+    return { source: "plane", composition: plane };
+  }
+  return { source: "local", composition: local };
+}
+function buildShadowRecord({
+  taskId,
+  repo,
+  agent,
+  mode,
+  comparison,
+  fetched,
+  ts
+}) {
+  const base = {
+    schema_version: 1,
+    kind: "prepared_job_shadow",
+    adr: "ADR-004 \xA7 11.1b",
+    ts,
+    code_task_id: taskId ?? null,
+    repo: repo ?? null,
+    agent: agent ?? null,
+    mode,
+    env_sent: fetched?.envSent ?? [],
+    env_dropped: fetched?.envDropped ?? []
+  };
+  if (!comparison) {
+    return {
+      ...base,
+      verdict: "unavailable",
+      reason: fetched?.reason ?? "unknown",
+      status: fetched?.status ?? 0,
+      divergent_fields: [],
+      unexplained_fields: [],
+      divergences: []
+    };
+  }
+  return {
+    ...base,
+    verdict: comparison.verdict,
+    reason: null,
+    divergent_fields: comparison.divergentFields,
+    unexplained_fields: comparison.unexplainedFields,
+    divergences: comparison.divergences,
+    prompt: comparison.prompt,
+    plane_composition: {
+      model_registry: fetched?.composition?.model_registry ?? null,
+      skill_catalog_available: fetched?.composition?.skill_catalog_available ?? null
+    }
+  };
+}
+function formatShadowLogLine(record) {
+  const parts = [
+    `task=${record.code_task_id}`,
+    `mode=${record.mode}`,
+    `verdict=${record.verdict}`
+  ];
+  if (record.verdict === "unavailable") parts.push(`reason=${record.reason}`, `status=${record.status}`);
+  if (record.unexplained_fields?.length) parts.push(`UNEXPLAINED=${record.unexplained_fields.join(",")}`);
+  const known = (record.divergences || []).filter((d) => d.class === "known_remainder");
+  if (known.length) parts.push(`known=${known.map((d) => `${d.field}(${d.reason})`).join(",")}`);
+  if (record.verdict === "parity_diverged" && typeof record.prompt?.first_diff_index === "number" && record.prompt.first_diff_index >= 0 && record.unexplained_fields?.includes("prompt")) {
+    parts.push(`prompt_first_diff_index=${record.prompt.first_diff_index}`);
+  }
+  const loud = record.unexplained_fields?.length ? "!! " : "";
+  return `${loud}[prepared-job-shadow] ${parts.join(" ")}`;
+}
+function appendShadowRecord(record, { path: path22 = PREPARED_JOB_SHADOW_SINK, append = appendFileSync, mkdir: mkdir5 = mkdirSync8 } = {}) {
+  try {
+    mkdir5(dirname10(path22), { recursive: true });
+    append(path22, `${JSON.stringify(record)}
+`, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function preparedJobShadowPass({
+  client,
+  task,
+  agent = "claude",
+  env: env2 = process.env,
+  local,
+  log: log2 = () => {
+  },
+  now = () => (/* @__PURE__ */ new Date()).toISOString(),
+  sinkOptions
+} = {}) {
+  const mode = preparedJobConsumptionMode(env2);
+  if (mode === "off") return { mode: "off" };
+  try {
+    if (mode === "prepared") {
+      log2("[prepared-job-shadow] prepared_mode_not_wired \u2014 comparing only; ADR-004 \xA7 11.1c owns the flip");
+    }
+    if (typeof client?.getPreparedJob !== "function") {
+      return { mode, verdict: "unavailable", reason: "client_lacks_get_prepared_job" };
+    }
+    const fetched = await client.getPreparedJob(task?.code_task_id, {
+      agent,
+      env: env2,
+      timeoutMs: shadowTimeoutMs(env2)
+    });
+    const localJob = localCompositionAsPreparedJob(local, { agent, env: env2 });
+    const comparison = fetched?.ok ? comparePreparedJob({
+      local: localJob,
+      plane: planeJobAsComparable(fetched.job),
+      context: {
+        planeModelRegistryUnavailable: fetched.composition?.model_registry !== "injected",
+        planeSkillCatalogUnavailable: fetched.composition?.skill_catalog_available === false,
+        taskDispatchModeAbsent: !task?.dispatch_mode,
+        attachmentManifestPresent: Boolean(local?.attachmentManifestMarkdown),
+        envDropped: fetched.envDropped
+      }
+    }) : null;
+    const record = buildShadowRecord({
+      taskId: task?.code_task_id,
+      repo: task?.repo,
+      agent,
+      mode,
+      comparison,
+      fetched,
+      ts: now()
+    });
+    appendShadowRecord(record, sinkOptions);
+    log2(formatShadowLogLine(record));
+    return {
+      mode,
+      verdict: record.verdict,
+      record,
+      selection: selectDispatchComposition({
+        mode,
+        local: localJob,
+        plane: fetched?.ok ? planeJobAsComparable(fetched.job) : null,
+        comparison
+      })
+    };
+  } catch (err) {
+    try {
+      log2(`[prepared-job-shadow] shadow pass failed (dispatch unaffected): ${err?.message || err}`);
+    } catch {
+    }
+    return { mode, verdict: "unavailable", reason: `shadow_error: ${err?.message || String(err)}` };
+  }
+}
+function setPreparedJobShadowObserver(fn) {
+  verdictObserver = typeof fn === "function" ? fn : null;
+}
+async function runPreparedJobShadow(options = {}) {
+  const result = await preparedJobShadowPass(options);
+  try {
+    verdictObserver?.(result);
+  } catch {
+  }
+  return result;
+}
+var PREPARED_JOB_MODES, PREPARED_JOB_MODE_ENV, PREPARED_JOB_SHADOW_TIMEOUT_ENV, DEFAULT_SHADOW_TIMEOUT_MS, PREPARED_JOB_SHADOW_SINK, remotePreparedJobMode, COMPARED_FIELDS, DISPATCH_MODE_DEPENDENT, sha256, sameValue, verdictObserver;
+var init_prepared_job_shadow = __esm({
+  "../../scripts/virtual-office/code-runner/prepared-job-shadow.mjs"() {
+    "use strict";
+    init_claude_args();
+    PREPARED_JOB_MODES = ["off", "shadow", "prepared"];
+    PREPARED_JOB_MODE_ENV = "VO_CODE_RUNNER_PREPARED_JOB";
+    PREPARED_JOB_SHADOW_TIMEOUT_ENV = "VO_PREPARED_JOB_SHADOW_TIMEOUT_MS";
+    DEFAULT_SHADOW_TIMEOUT_MS = 15e3;
+    PREPARED_JOB_SHADOW_SINK = join14(homedir9(), ".claude", "vo-prepared-job-shadow.jsonl");
+    remotePreparedJobMode = "";
+    COMPARED_FIELDS = [
+      "prompt",
+      "argv",
+      "permission_mode",
+      "dispatch_mode",
+      "tier",
+      "model",
+      "effort",
+      "max_turns",
+      "max_budget_usd",
+      "methodology_shape",
+      "methodology_stakes"
+    ];
+    DISPATCH_MODE_DEPENDENT = /* @__PURE__ */ new Set([
+      "prompt",
+      "argv",
+      "permission_mode",
+      "tier",
+      "model",
+      "effort",
+      "max_turns"
+    ]);
+    sha256 = (s) => createHash6("sha256").update(String(s ?? ""), "utf8").digest("hex");
+    sameValue = (a, b) => Array.isArray(a) || Array.isArray(b) ? JSON.stringify(a) === JSON.stringify(b) : (a ?? null) === (b ?? null);
+    verdictObserver = null;
+  }
+});
+
+// ../../scripts/virtual-office/code-runner/prepared-job-remote-config.mjs
+function emptyPreparedJobTally() {
+  return {
+    compared: 0,
+    parity_ok: 0,
+    parity_diverged: 0,
+    unavailable: 0,
+    unexplained: 0,
+    diverged_fields: {},
+    last_verdict_at: null
+  };
+}
+function foldPreparedJobVerdict(tally, result, nowIso) {
+  const verdict = result?.verdict;
+  if (!verdict) return tally;
+  tally.last_verdict_at = nowIso;
+  if (verdict === "unavailable") {
+    tally.unavailable += 1;
+    return tally;
+  }
+  tally.compared += 1;
+  if (verdict === "parity_ok") tally.parity_ok += 1;
+  else if (verdict === "parity_diverged") tally.parity_diverged += 1;
+  const record = result.record || {};
+  tally.unexplained += (record.unexplained_fields || []).length;
+  for (const field of record.divergent_fields || []) {
+    const known = Object.prototype.hasOwnProperty.call(tally.diverged_fields, field);
+    if (!known && Object.keys(tally.diverged_fields).length >= MAX_DIVERGED_FIELD_KEYS) continue;
+    tally.diverged_fields[field] = (tally.diverged_fields[field] || 0) + 1;
+  }
+  return tally;
+}
+function createPreparedJobRemoteController({
+  log: log2 = () => {
+  },
+  now = () => (/* @__PURE__ */ new Date()).toISOString(),
+  apply = setRemotePreparedJobMode,
+  observe = setPreparedJobShadowObserver
+} = {}) {
+  const byOperator = /* @__PURE__ */ new Map();
+  const tally = emptyPreparedJobTally();
+  let planeSpeaksPreparedJob = false;
+  let warnedNotWired = false;
+  let warnedConflict = "";
+  function desiredMode() {
+    const modes = [...new Set(
+      [...byOperator.values()].map((s) => s.mode).filter((m) => m && m !== "off")
+    )];
+    if (modes.length > 1) {
+      const key = modes.slice().sort().join(",");
+      if (warnedConflict !== key) {
+        warnedConflict = key;
+        log2(`prepared-job remote config: conflicting modes across served operators (${key}) \u2014 applying off`);
+      }
+      return "off";
+    }
+    return modes[0] ?? "off";
+  }
+  function syncEffective() {
+    const mode = desiredMode();
+    apply(mode);
+    return mode;
+  }
+  observe((result) => foldPreparedJobVerdict(tally, result, now()));
+  return {
+    /**
+     * Heartbeat payload extras. Silent until the plane has proven it speaks this
+     * contract AND a pass has actually been counted — see safety property 3.
+     */
+    heartbeatFields() {
+      if (!planeSpeaksPreparedJob || tally.last_verdict_at === null) return {};
+      return {
+        prepared_job_shadow: {
+          schema_version: PREPARED_JOB_CONFIG_SCHEMA_VERSION,
+          mode: desiredMode(),
+          ...tally,
+          diverged_fields: { ...tally.diverged_fields }
+        }
+      };
+    },
+    /**
+     * Apply one operator's heartbeat-response echo
+     * `{ schema_version, prepared_job_mode, revision }`. Returns whether the
+     * echo was accepted.
+     */
+    applyRemoteConfig(echo, operatorId = "") {
+      const scope = String(operatorId || "");
+      const previous = byOperator.get(scope);
+      if (!echo || echo.schema_version !== PREPARED_JOB_CONFIG_SCHEMA_VERSION || !Number.isInteger(echo.revision) || previous && echo.revision < previous.revision) {
+        return false;
+      }
+      const raw = typeof echo.prepared_job_mode === "string" ? echo.prepared_job_mode.trim().toLowerCase() : "";
+      if (!PREPARED_JOB_MODES.includes(raw)) return false;
+      planeSpeaksPreparedJob = true;
+      let mode = raw;
+      if (mode === "prepared") {
+        mode = "shadow";
+        if (!warnedNotWired) {
+          warnedNotWired = true;
+          log2("prepared-job remote config: prepared_mode_not_wired \u2014 applying shadow; ADR-004 \xA7 11.1c owns the flip");
+        }
+      }
+      byOperator.set(scope, { revision: echo.revision, mode });
+      syncEffective();
+      return true;
+    },
+    snapshot: () => ({
+      mode: desiredMode(),
+      planeSpeaksPreparedJob,
+      tally: { ...tally, diverged_fields: { ...tally.diverged_fields } },
+      operators: Object.fromEntries(byOperator)
+    })
+  };
+}
+var PREPARED_JOB_CONFIG_SCHEMA_VERSION, MAX_DIVERGED_FIELD_KEYS;
+var init_prepared_job_remote_config = __esm({
+  "../../scripts/virtual-office/code-runner/prepared-job-remote-config.mjs"() {
+    "use strict";
+    init_prepared_job_shadow();
+    PREPARED_JOB_CONFIG_SCHEMA_VERSION = 1;
+    MAX_DIVERGED_FIELD_KEYS = 24;
+  }
+});
+
 // ../../scripts/virtual-office/code-runner/account-usage/shared.mjs
 import crypto from "node:crypto";
 import fs9 from "node:fs";
@@ -10539,7 +11069,7 @@ var init_error_message = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/watcher-coordination.mjs
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 function ciFixOccurrenceKey({ repo, prNumber, headSha, repairAttempt }) {
   const occurrence = JSON.stringify([
     String(repo).toLowerCase(),
@@ -10547,7 +11077,7 @@ function ciFixOccurrenceKey({ repo, prNumber, headSha, repairAttempt }) {
     String(headSha).toLowerCase(),
     Number(repairAttempt)
   ]);
-  return `ci-fix:v1:${createHash6("sha256").update(occurrence).digest("hex")}`;
+  return `ci-fix:v1:${createHash7("sha256").update(occurrence).digest("hex")}`;
 }
 function coordinationRetryDue(entry, nowMs) {
   return !entry.nextRetryAt || nowMs >= entry.nextRetryAt;
@@ -10679,7 +11209,7 @@ var init_watcher_coordination = __esm({
 // ../../scripts/virtual-office/code-runner/watcher-state.mjs
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { mkdir as mkdir3, open as open2, readFile as readFile4, rename, unlink as unlink2 } from "node:fs/promises";
-import { dirname as dirname10 } from "node:path";
+import { dirname as dirname11 } from "node:path";
 async function readWatcherState(stateFile) {
   let raw;
   try {
@@ -10695,7 +11225,7 @@ async function readWatcherState(stateFile) {
   return parsed;
 }
 async function writeWatcherState(stateFile, state) {
-  const directory = dirname10(stateFile);
+  const directory = dirname11(stateFile);
   await mkdir3(directory, { recursive: true });
   const temp = `${stateFile}.${process.pid}.${randomUUID4()}.tmp`;
   let handle;
@@ -11224,8 +11754,8 @@ var init_enqueue_autonomous_code_task = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/pr-watcher.mjs
-import { homedir as homedir9 } from "node:os";
-import { join as join14 } from "node:path";
+import { homedir as homedir10 } from "node:os";
+import { join as join15 } from "node:path";
 function parsePrCiStatus(view) {
   const state = (view && typeof view.state === "string" ? view.state : "UNKNOWN").toUpperCase();
   const rollup = latestCheckRunsByName(view && Array.isArray(view.statusCheckRollup) ? view.statusCheckRollup : []);
@@ -11597,7 +12127,7 @@ var init_pr_watcher = __esm({
     init_watcher_merge_authority();
     init_superseded_pr_source();
     init_ci_fix_prompt();
-    DEFAULT_STATE_FILE = join14(homedir9(), ".vo", "dispatched-prs.json");
+    DEFAULT_STATE_FILE = join15(homedir10(), ".vo", "dispatched-prs.json");
     FAIL_CONCLUSIONS = /* @__PURE__ */ new Set([
       "FAILURE",
       "TIMED_OUT",
@@ -12371,13 +12901,13 @@ async function resolveModelForTier(tier, { agent = DEFAULT_AGENT2, resolveModelF
   if (resolved && modelCompatibleWithAgent(normalizedAgent, resolved)) return resolved;
   return fallbacks[effectiveTier];
 }
-async function resolveTaskModel(task, { agent = DEFAULT_AGENT2 } = {}) {
+async function resolveTaskModel(task, { agent = DEFAULT_AGENT2, resolveModelFamily: resolver = resolveModelFamily } = {}) {
   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 };
   }
-  const model = await resolveModelForTier(tier, { agent });
+  const model = await resolveModelForTier(tier, { agent, resolveModelFamily: resolver });
   return { tier, model };
 }
 var TASK_MODEL_AGENTS, DEFAULT_AGENT2, AGENT_TIER_FAMILIES, AGENT_TIER_FALLBACKS, AGENT_MODEL_COMPATIBILITY;
@@ -12844,8 +13374,8 @@ var init_classify_task = __esm({
 
 // ../../scripts/virtual-office/code-runner/auto-router/effort-policy.mjs
 import { readFileSync as readFileSync9 } from "node:fs";
-import { homedir as homedir10 } from "node:os";
-import { join as join15 } from "node:path";
+import { homedir as homedir11 } from "node:os";
+import { join as join16 } from "node:path";
 function difficultyToRung(difficulty, thresholds) {
   const b = thresholds.rungBounds;
   if (difficulty >= b.R5) return "R5";
@@ -12922,7 +13452,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 = join15(homedir10(), ".codex", "models_cache.json");
+    DEFAULT_CODEX_MODELS_CACHE = join16(homedir11(), ".codex", "models_cache.json");
   }
 });
 
@@ -13052,9 +13582,9 @@ var init_role_cost_shadow = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/auto-router/auto-router.mjs
-import { readFileSync as readFileSync10, appendFileSync, mkdirSync as mkdirSync8 } from "node:fs";
-import { homedir as homedir11 } from "node:os";
-import { join as join16, dirname as dirname11 } from "node:path";
+import { readFileSync as readFileSync10, appendFileSync as appendFileSync2, mkdirSync as mkdirSync9 } from "node:fs";
+import { homedir as homedir12 } from "node:os";
+import { join as join17, dirname as dirname12 } 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();
@@ -13062,8 +13592,8 @@ function getAutoRouterMode(env2 = process.env) {
 }
 function loadThresholds() {
   if (!cachedThresholds) {
-    const here = dirname11(fileURLToPath7(import.meta.url));
-    cachedThresholds = JSON.parse(readFileSync10(join16(here, "thresholds.json"), "utf8"));
+    const here = dirname12(fileURLToPath7(import.meta.url));
+    cachedThresholds = JSON.parse(readFileSync10(join17(here, "thresholds.json"), "utf8"));
   }
   return cachedThresholds;
 }
@@ -13129,9 +13659,9 @@ 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: path22 = DECISION_FALLBACK_PATH, append = appendFileSync, mkdir: mkdir5 = mkdirSync8, task, thresholds, roleCostInputs } = {}) {
+function appendDecisionFallback(decision, { path: path22 = DECISION_FALLBACK_PATH, append = appendFileSync2, mkdir: mkdir5 = mkdirSync9, task, thresholds, roleCostInputs } = {}) {
   try {
-    mkdir5(dirname11(path22), { recursive: true });
+    mkdir5(dirname12(path22), { recursive: true });
     append(path22, `${JSON.stringify(decision)}
 `, "utf8");
     if (isRouterDecision(decision)) {
@@ -13155,7 +13685,7 @@ var init_auto_router = __esm({
     init_effort_policy();
     init_role_cost_shadow();
     ROUTER_VERSION = "0.1.0";
-    DECISION_FALLBACK_PATH = join16(homedir11(), ".claude", "vo-auto-router-decisions.jsonl");
+    DECISION_FALLBACK_PATH = join17(homedir12(), ".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");
@@ -15291,8 +15821,8 @@ var init_cancellation_probe = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/detached-economics-spool.mjs
-import { homedir as homedir12 } from "node:os";
-import { dirname as dirname12, join as join17 } from "node:path";
+import { homedir as homedir13 } from "node:os";
+import { dirname as dirname13, join as join18 } from "node:path";
 import { mkdir as mkdir4, readFile as readFile5, rename as rename2, writeFile as writeFile4 } from "node:fs/promises";
 function withLock(operation) {
   const result = serialized.then(operation, operation);
@@ -15310,7 +15840,7 @@ async function readEntries(file) {
   }
 }
 async function writeEntries(file, entries) {
-  await mkdir4(dirname12(file), { recursive: true });
+  await mkdir4(dirname13(file), { recursive: true });
   const temp = `${file}.${process.pid}.tmp`;
   await writeFile4(temp, `${JSON.stringify(entries)}
 `, "utf8");
@@ -15356,7 +15886,7 @@ var DEFAULT_FILE, serialized;
 var init_detached_economics_spool = __esm({
   "../../scripts/virtual-office/code-runner/detached-economics-spool.mjs"() {
     "use strict";
-    DEFAULT_FILE = join17(homedir12(), ".vo", "detached-run-economics.json");
+    DEFAULT_FILE = join18(homedir13(), ".vo", "detached-run-economics.json");
     serialized = Promise.resolve();
   }
 });
@@ -15734,6 +16264,19 @@ async function processOneTask(client, task, cfg, runnerInstanceId, swarmAdmissio
       allowMissingKnowledgeContext: process.env.VO_CODE_RUNNER_ALLOW_MISSING_KNOWLEDGE_CONTEXT === "1",
       attachmentManifestMarkdown: attachmentBundle.manifestMarkdown
     }) });
+    await runPreparedJobShadow({ client, task, agent: sel.agent, env: process.env, log, local: {
+      // ADR-004 § 11.1b SHADOW: default OFF; return value deliberately unread — slice C owns consumption
+      prompt: effortPrompt,
+      dispatchMode,
+      tier,
+      model,
+      permissionMode: effectivePermissionMode,
+      maxTurns: effectiveMaxTurns,
+      effort: effectiveEffort,
+      maxBudgetUsd: effectiveMaxBudgetUsd,
+      methodology,
+      attachmentManifestMarkdown: attachmentBundle.manifestMarkdown
+    } });
     assertRunnerGovernors({
       agent: sel.agent,
       // Only persisted operator caps are hard contracts. Router/global values
@@ -15998,7 +16541,7 @@ async function main({ env: env2 = process.env, once: once2 = false } = {}) {
   const agentAvailability = makeAgentAvailabilityProvider({ onError: (e) => log(`agent probe failed: ${e.message}`) });
   await agentAvailability.ready();
   const accountUsage = makeAccountUsageProvider();
-  const loopTick = makeLoopTicks({ client, cfg, env: env2, log, getActive: () => active, runnerInstanceId, capacityController, localModelController: createLocalModelRemoteController({ env: env2, log }), getAgentAvailability: () => agentAvailability.get(), getAccountUsage: () => accountUsage.get() });
+  const loopTick = makeLoopTicks({ client, cfg, env: env2, log, getActive: () => active, runnerInstanceId, capacityController, localModelController: createLocalModelRemoteController({ env: env2, log }), preparedJobController: createPreparedJobRemoteController({ log }), getAgentAvailability: () => agentAvailability.get(), getAccountUsage: () => accountUsage.get() });
   const backoff = makeReconnectBackoff({ baseMs: cfg.pollSec * 1e3, log });
   let detachedFlushRunning = false;
   while (!stopping) {
@@ -16102,6 +16645,7 @@ var init_code_runner_daemon = __esm({
     init_runner_capacity();
     init_agent_availability();
     init_local_model_remote_config();
+    init_prepared_job_remote_config();
     init_account_usage2();
     init_pr_watcher();
     init_existing_pr_target();
@@ -16111,6 +16655,7 @@ var init_code_runner_daemon = __esm({
     init_claim_scoping_log();
     init_reconnect_backoff();
     init_task_helpers();
+    init_prepared_job_shadow();
     init_agent_process_env();
     init_sandbox_config();
     init_inference_task_runner();