@algosuite/vo-mcp 0.2.0-beta.68 → 0.2.0-beta.69

package/dist/runner-cli.js

@@ -1699,14 +1699,18 @@ async function addWorktreeWithRetry({
   sleep: sleep3 = sleepMs,
   removeDir = async (target) => {
     await fsp2.rm(target, { recursive: true, force: true });
-  }
+  },
+  baseRef = "origin/main"
 }) {
+  if (baseRef !== "origin/main" && !/^[0-9a-f]{40}$/u.test(baseRef)) {
+    throw new Error("worktree base ref must be origin/main or an exact lowercase SHA");
+  }
   const maxAttempts = Math.max(1, Math.floor(attempts));
   let result = null;
   for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
     result = await runner(
       "git",
-      ["worktree", "add", "-b", branchName, worktreeDir, "origin/main"],
+      ["worktree", "add", "-b", branchName, worktreeDir, baseRef],
       { cwd: root, timeoutMs }
     );
     if (result.status === 0 && await pathExistsFn(worktreeDir)) {
@@ -2892,6 +2896,18 @@ async function alignCanonicalClone(root, options = {}) {
   }
   return { updated: true, headSha, originSha };
 }
+async function fetchExactTaskBase(root, baseSha, options = {}) {
+  if (!/^[0-9a-f]{40}$/u.test(baseSha)) {
+    throw new Error("comparative base SHA must be exact lowercase hex");
+  }
+  const fetched = await git(root, ["fetch", "origin", baseSha], options);
+  if (fetched.status !== 0) {
+    throw new Error(`exact comparative source is unavailable: ${summarizeProcessFailure(fetched)}`);
+  }
+  const resolved = await gitText(root, ["rev-parse", `${baseSha}^{commit}`], options);
+  if (resolved !== baseSha) throw new Error("exact comparative source did not resolve to the requested commit");
+  return resolved;
+}
 function shouldIgnoreManagedEntry(entryName) {
   return IGNORED_MANAGED_ENTRIES.has(entryName) || entryName.endsWith(".lock") || entryName.startsWith("runner-");
 }
@@ -2932,6 +2948,9 @@ async function prepareTaskRoot(root, options = {}) {
   try {
     await reportLegacyResiduals(root, options);
     const alignment = await alignCanonicalClone(root, options);
+    if (options.baseSha) {
+      await fetchExactTaskBase(root, options.baseSha, options);
+    }
     const hydration = await ensurePnpmHydration(root, {
       logger: options.logger,
       runner: options.runner || runProcess
@@ -3206,10 +3225,16 @@ async function createFixWorktree(kind, error = {}, options = {}) {
   const dependencyOwnership = createDependencyOwnershipTracker(worktreeDir);
   const prep = await prepare(root, {
     recoverDirtyCanonical: multiRepo,
-    managedPool: path11.dirname(worktreeDir)
+    managedPool: path11.dirname(worktreeDir),
+    baseSha: options.baseSha || null
   });
   await processRunner("git", ["config", "core.longpaths", "true"], { cwd: root, timeoutMs: 3e4 });
-  const add = await addWorktree({ root, branchName, worktreeDir });
+  const add = await addWorktree({
+    root,
+    branchName,
+    worktreeDir,
+    baseRef: options.baseSha || "origin/main"
+  });
   if (!add.ok) {
     const detail = describeGitFailure(add.result);
     if (multiRepo) {
@@ -4694,6 +4719,7 @@ function finalizeAgentTaskResult({
   result,
   bin,
   stderrTail,
+  classifyStderr = null,
   timedOut,
   killed,
   cancelReason,
@@ -4724,8 +4750,16 @@ function finalizeAgentTaskResult({
     if (code !== 0 || signal) summary = fallback || `${bin} exited ${signal || code}`;
     else summary = fallback || `${bin} exited without terminal result`;
   }
+  let failure = result.failure ?? null;
+  if (!failure && !sawTerminalResult && (code !== 0 || signal) && typeof classifyStderr === "function") {
+    try {
+      failure = classifyStderr(stderrTail);
+    } catch {
+    }
+  }
   return {
     ...result,
+    ...failure ? { failure } : {},
     ok: sawTerminalResult && result.ok && (code === 0 || forcedAfterResult),
     summary: augmentSummary(summary)
   };
@@ -5650,7 +5684,8 @@ function runAgentTask({
         // parser would work, the runner would report null, and the feature
         // would measure nothing while every test passed.
         tokenUsage: evt.tokenUsage ?? result.tokenUsage ?? null,
-        modelUsage: evt.modelUsage ?? result.modelUsage ?? null
+        modelUsage: evt.modelUsage ?? result.modelUsage ?? null,
+        failure: evt.failure ?? result.failure ?? null
       };
       terminalCleanupTimer ??= armTerminalCleanup({
         child,
@@ -5679,6 +5714,7 @@ function runAgentTask({
         result,
         bin,
         stderrTail,
+        classifyStderr: runner.classifyStderr,
         timedOut,
         killed,
         cancelReason,
@@ -5803,26 +5839,15 @@ var init_claude_runner = __esm({
         if (process.platform !== "win32") return { bin, args, spawnOptions: spawnOptions ?? this.getSpawnOptions() };
         return buildWindowsClaudeLaunch({ bin, args, env: env2 });
       }
-      /**
-       * Fill ANTHROPIC_API_KEY from the OS keychain when not already set (M4 BYO),
-       * so a friend who ran `vo-mcp set-key` authenticates without an env var.
-       * Explicit env wins; no key stored → unchanged (Claude Code login as before).
-       */
       applyAuthEnv(env2 = process.env) {
         return withAnthropicKey(env2);
       }
       costBasis(env2 = process.env) {
         return claudeCostBasis(env2);
       }
-      /** Describe which Anthropic auth source the spawn will use (for runner logs). */
       describeAuth(env2 = process.env) {
         return describeAnthropicAuthSource(env2);
       }
-      /**
-       * Best-effort auth check: is `claude` on PATH and can we verify login?
-       * Never throws. If we can't cheaply detect auth, we return installed:true
-       * and let the real spawn fail with a clearer error from the CLI itself.
-       */
       async checkAuth() {
         return checkClaudeAuth();
       }
@@ -5948,6 +5973,66 @@ var init_flat_token_usage = __esm({
   }
 });
 
+// ../../scripts/virtual-office/code-runner/error-message.mjs
+function boundedErrorMessage(error, maxLength = 240) {
+  try {
+    return String(error?.message ?? error ?? "unknown error").slice(0, maxLength);
+  } catch {
+    return "unknown error";
+  }
+}
+function codexFailure(code, fields = {}) {
+  const definition = FAILURE_DEFINITIONS[code];
+  return {
+    schema: FAILURE_SCHEMA,
+    agent: "codex",
+    source: definition.source,
+    code,
+    ...fields,
+    operator_next_action: definition.operator_next_action
+  };
+}
+function classifyCodexTerminalFailure(evt = {}) {
+  const error = evt && typeof evt.error === "object" && evt.error !== null ? evt.error : null;
+  if (!/^The ['"][^'"]+['"] model is not supported when using Codex with a ChatGPT account\.$/u.test(
+    typeof error?.message === "string" ? error.message : ""
+  )) return null;
+  const status = Number(evt.status ?? error.status);
+  return codexFailure("model_unsupported_for_account", Number.isInteger(status) ? { provider_status: status } : {});
+}
+function classifyCodexStderr(stderr = "") {
+  if (!/(?:^|\n)\s*windows sandbox(?: failed)?: runner error:.*\bCreateProcessAsUserW failed:\s*1312\b/imu.test(String(stderr))) return null;
+  return codexFailure("codex_runtime_launch_logon_session", { win32_error: 1312 });
+}
+function serializeRunnerFailure(record, maxLength = 2e3) {
+  const definition = record && FAILURE_DEFINITIONS[record.code];
+  if (!definition || record.schema !== FAILURE_SCHEMA || record.source !== definition.source) return null;
+  const value = codexFailure(record.code, {
+    ...record.code === "model_unsupported_for_account" && Number.isInteger(record.provider_status) ? { provider_status: record.provider_status } : {},
+    ...definition.win32_error ? { win32_error: definition.win32_error } : {}
+  });
+  const serialized2 = JSON.stringify(value);
+  return serialized2.length <= Math.max(0, maxLength) ? serialized2 : null;
+}
+var FAILURE_SCHEMA, FAILURE_DEFINITIONS;
+var init_error_message = __esm({
+  "../../scripts/virtual-office/code-runner/error-message.mjs"() {
+    "use strict";
+    FAILURE_SCHEMA = "vo.runner_failure.v1";
+    FAILURE_DEFINITIONS = {
+      model_unsupported_for_account: {
+        source: "terminal_event",
+        operator_next_action: "Create a new owner-reviewed task with an account-supported Codex model; keep the preserved draft PR for review rather than resuming this task."
+      },
+      codex_runtime_launch_logon_session: {
+        source: "stderr",
+        win32_error: 1312,
+        operator_next_action: "Repair the Codex Windows logon/session configuration on the serving host, then rerun the runner."
+      }
+    };
+  }
+});
+
 // ../../scripts/virtual-office/code-runner/codex-runner.mjs
 import { spawnSync as spawnSync6 } from "node:child_process";
 import { existsSync as existsSync10 } from "node:fs";
@@ -6048,7 +6133,8 @@ function parseCodexEvent(line) {
   }
   if (type === "turn.failed" || type === "error") {
     const msg = evt.error && (evt.error.message || evt.error) || evt.message || "codex run failed";
-    return { kind: "result", isError: true, costUsd: null, summary: String(msg), numTurns: null };
+    const failure = classifyCodexTerminalFailure(evt);
+    return { kind: "result", isError: true, costUsd: null, summary: String(msg), numTurns: null, ...failure ? { failure } : {} };
   }
   return null;
 }
@@ -6059,6 +6145,7 @@ var init_codex_runner = __esm({
     init_agent_key_store();
     init_agent_auth_tier();
     init_flat_token_usage();
+    init_error_message();
     CODEX_PREFER_LOGIN_ENV = "VO_RUNNER_CODEX_PREFER_LOGIN";
     LEGACY_PREFER_LOGIN_ENV = "VO_RUNNER_PREFER_LOGIN";
     CodexRunner = class {
@@ -6076,6 +6163,9 @@ var init_codex_runner = __esm({
       parseEvent(line) {
         return parseCodexEvent(line);
       }
+      classifyStderr(stderr) {
+        return classifyCodexStderr(stderr);
+      }
       /**
        * SECURITY: never `shell: true` — same RCE class as cursor-runner. The old
        * `shell: win32 && !/\.exe$/` fell back to shell mode whenever
@@ -6097,12 +6187,6 @@ var init_codex_runner = __esm({
           windowsVerbatimArguments: false
         };
       }
-      /**
-       * Fill the OpenAI credential env var(s) (OPENAI_API_KEY / CODEX_API_KEY) from
-       * the OS keychain when not already set, so a BYO friend who ran
-       * `vo-mcp set-key --provider codex` authenticates without an env var. Explicit
-       * env wins; no key stored → unchanged (a prior `codex login` still works).
-       */
       applyAuthEnv(env2 = process.env) {
         if (isTruthyFlag2(env2[CODEX_PREFER_LOGIN_ENV]) || isTruthyFlag2(env2[LEGACY_PREFER_LOGIN_ENV])) {
           const out = { ...env2 };
@@ -6115,20 +6199,9 @@ var init_codex_runner = __esm({
       costBasis(env2 = process.env) {
         return String(env2.OPENAI_API_KEY || env2.CODEX_API_KEY || "").trim() ? "vendor_billed" : "subscription_api_equivalent";
       }
-      /**
-       * Dispatch-time billing tier for the NEXT codex spawn, from the SAME facts
-       * checkAuth() already gathered — no extra subprocess. applyAuthEnv() is a
-       * keychain read in this process (@napi-rs/keyring), not a spawn.
-       *
-       * Codex is the agent where this signal was already computed and then thrown
-       * away: checkAuth() distinguished "API key available (no persisted ChatGPT
-       * login)" from a real login, but only inside a `message` string that the
-       * heartbeat schema strips before storage. This gives that fact a typed home.
-       */
       authTier(env2 = this.env) {
         return safeAuthTier(() => authTierFromCostBasis(this.costBasis(this.applyAuthEnv(env2))));
       }
-      /** Best-effort binary + persisted-login probe. Never throws or spends tokens. */
       async checkAuth() {
         try {
           const bin = this.binary;
@@ -7228,6 +7301,17 @@ async function classifyFailureForResume({
   record = recordRateLimited,
   deferRecord = false
 } = {}) {
+  const structuredFailure = serializeRunnerFailure(run.failure);
+  if (structuredFailure) {
+    return {
+      rateLimited: false,
+      progress: {
+        status: "failed",
+        message: `runner blocker: ${run.failure.code}; operator review required`,
+        result: structuredFailure
+      }
+    };
+  }
   if (enabled) {
     const rl = detect(run.summary, { now });
     if (rl.rateLimited) {
@@ -7302,6 +7386,7 @@ var init_rate_limit_resume = __esm({
     "use strict";
     init_rate_limit_detector_core();
     init_rate_limit_resume_state();
+    init_error_message();
   }
 });
 
@@ -8648,16 +8733,28 @@ var init_repair_publication_strategy = __esm({
 
 // ../../scripts/virtual-office/code-runner/partial-pr-continuation.mjs
 function partialPrContinuationResult(run = {}, maxLength = 2e3, reason = null) {
+  const limit = Math.max(0, Number(maxLength) || 0);
   const summary = String(run.summary || "agent stopped before completing the task").trim();
   const reasonMarker = reason === "rate_limited" ? `
 ${RATE_LIMITED_CONTINUATION_MARKER}` : "";
-  return `${PARTIAL_PR_CONTINUATION_MARKER}${reasonMarker}
-${summary}`.slice(0, Math.max(0, maxLength));
+  const blockedMarker = "ALGOSUITE_TASK_OUTCOME: BLOCKED";
+  const blockedPrefix = `${blockedMarker}${reasonMarker}
+`;
+  const serializedFailure = serializeRunnerFailure(run.failure, Math.max(0, limit - blockedPrefix.length - 1));
+  const outcomeMarker = serializedFailure ? blockedMarker : PARTIAL_PR_CONTINUATION_MARKER;
+  const prefix = `${outcomeMarker}${reasonMarker}
+`;
+  const failure = serializedFailure && outcomeMarker === blockedMarker ? serializedFailure : null;
+  const suffix = failure ? `
+${failure}` : "";
+  const summaryRoom = Math.max(0, limit - prefix.length - suffix.length);
+  return `${prefix}${summary.slice(0, summaryRoom)}${suffix}`.slice(0, limit);
 }
 var PARTIAL_PR_CONTINUATION_MARKER, RATE_LIMITED_CONTINUATION_MARKER;
 var init_partial_pr_continuation = __esm({
   "../../scripts/virtual-office/code-runner/partial-pr-continuation.mjs"() {
     "use strict";
+    init_error_message();
     PARTIAL_PR_CONTINUATION_MARKER = "ALGOSUITE_TASK_OUTCOME: NEEDS_CONTINUATION";
     RATE_LIMITED_CONTINUATION_MARKER = "ALGOSUITE_CONTINUATION_REASON: RATE_LIMITED";
   }
@@ -12015,20 +12112,6 @@ var init_pr_watcher_failure_confirmation = __esm({
   }
 });
 
-// ../../scripts/virtual-office/code-runner/error-message.mjs
-function boundedErrorMessage(error, maxLength = 240) {
-  try {
-    return String(error?.message ?? error ?? "unknown error").slice(0, maxLength);
-  } catch {
-    return "unknown error";
-  }
-}
-var init_error_message = __esm({
-  "../../scripts/virtual-office/code-runner/error-message.mjs"() {
-    "use strict";
-  }
-});
-
 // ../../scripts/virtual-office/code-runner/watcher-coordination.mjs
 import { createHash as createHash7 } from "node:crypto";
 function ciFixOccurrenceKey({ repo, prNumber, headSha, repairAttempt }) {
@@ -12524,7 +12607,49 @@ var init_superseded_pr_source = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/ci-fix-prompt.mjs
-function buildCiFixPrompt({ prNumber, repo, branch, headSha, failedChecks, prPatch, failedLogs }) {
+function fairSplit(aLen, bLen, budget) {
+  if (aLen + bLen <= budget) return { a: aLen, b: bLen };
+  const half = Math.floor(budget / 2);
+  if (aLen <= half) return { a: aLen, b: budget - aLen };
+  if (bLen <= half) return { a: budget - bLen, b: bLen };
+  return { a: half, b: budget - half };
+}
+function boundHead(content, allocated, label) {
+  if (content.length <= allocated) return content;
+  const marker = `
+[${label} truncated to the first ${allocated} characters available in this dispatch]`;
+  if (marker.length >= allocated) return marker.slice(0, Math.max(0, allocated));
+  return `${content.slice(0, allocated - marker.length)}${marker}`;
+}
+function boundTail(content, allocated, label) {
+  if (content.length <= allocated) return content;
+  const marker = `[${label} truncated to the final ${allocated} characters available in this dispatch]
+`;
+  if (marker.length >= allocated) return marker.slice(0, Math.max(0, allocated));
+  return `${marker}${content.slice(-(allocated - marker.length))}`;
+}
+function boundedEvidenceShares({
+  prPatch,
+  failedLogs,
+  fixedOverheadChars,
+  prNumber,
+  maxTotalChars = CI_FIX_PROMPT_MAX_CHARS
+}) {
+  const patchWanted = String(prPatch || "").trim() || NO_PATCH_EVIDENCE;
+  const logsWanted = String(failedLogs || "").trim() || NO_LOG_EVIDENCE;
+  const available = maxTotalChars - fixedOverheadChars;
+  if (available < NO_PATCH_EVIDENCE.length + NO_LOG_EVIDENCE.length) {
+    throw new Error(
+      `CI-fix prompt for PR #${prNumber ?? "?"} cannot fit its mandatory instructions and identity (${fixedOverheadChars} chars) plus even an empty-evidence notice inside the ${maxTotalChars}-character dispatch limit \u2014 refusing to send a malformed or instructions-truncated request`
+    );
+  }
+  const { a: patchShare, b: logsShare } = fairSplit(patchWanted.length, logsWanted.length, available);
+  return {
+    patchBody: boundHead(patchWanted, patchShare, "PR patch"),
+    logsBody: boundTail(logsWanted, logsShare, "failed-job evidence")
+  };
+}
+function renderHeader({ prNumber, repo, branch, headSha, failedChecks }) {
   return [
     `${CI_FIX_MARKER} An AlgoHQ-dispatched pull request has FAILING CI and needs a fix.`,
     "",
@@ -12543,24 +12668,45 @@ function buildCiFixPrompt({ prNumber, repo, branch, headSha, failedChecks, prPat
     "VO-ALLOW-PR-OVERLAP marker. Your work ships: finish the fix completely, leave UNCOMMITTED",
     "edits, and the runner publishes for you. A denied git/gh is EXPECTED; do NOT retry it.",
     "",
-    HEADLESS_EXECUTION_CONTRACT,
+    HEADLESS_EXECUTION_CONTRACT
+  ].join("\n");
+}
+function assemblePrompt(header, patchBody, logsBody) {
+  return [
+    header,
     "",
     "## Bounded source PR patch excerpt",
     "```diff",
-    prPatch || "[No excerpt available; the complete exact source is still materialized in the worktree.]",
+    patchBody,
     "```",
     "",
     "## Failed-job evidence",
     "```text",
-    failedLogs || "[No failed-job log was available; use the named checks and patch.]",
+    logsBody,
     "```"
   ].join("\n");
 }
+function buildCiFixPrompt({ prNumber, repo, branch, headSha, failedChecks, prPatch, failedLogs }) {
+  const header = renderHeader({ prNumber, repo, branch, headSha, failedChecks });
+  const fixedOverheadChars = assemblePrompt(header, "", "").length;
+  const { patchBody, logsBody } = boundedEvidenceShares({
+    prPatch,
+    failedLogs,
+    fixedOverheadChars,
+    prNumber,
+    maxTotalChars: CI_FIX_PROMPT_MAX_CHARS
+  });
+  return assemblePrompt(header, patchBody, logsBody);
+}
+var CI_FIX_PROMPT_MAX_CHARS, NO_PATCH_EVIDENCE, NO_LOG_EVIDENCE;
 var init_ci_fix_prompt = __esm({
   "../../scripts/virtual-office/code-runner/ci-fix-prompt.mjs"() {
     "use strict";
     init_superseded_pr_source();
     init_headless_execution_contract();
+    CI_FIX_PROMPT_MAX_CHARS = 9900;
+    NO_PATCH_EVIDENCE = "[No excerpt available; the complete exact source is still materialized in the worktree.]";
+    NO_LOG_EVIDENCE = "[No failed-job log was available; use the named checks and patch.]";
   }
 });
 
@@ -16067,7 +16213,11 @@ async function finalizePublishedPr({
   const overlapBlocked = pr.overlapDraft === true;
   const blockedRefs = Array.isArray(pr.overlapBlockedBy) && pr.overlapBlockedBy.length > 0 ? pr.overlapBlockedBy.map((n) => `#${n}`).join(", ") : "unresolved (see PR body for the gate report)";
   const overlapNote = overlapBlocked ? ` as DRAFT \u2014 overlap-blocked by ${blockedRefs} (finished work preserved; mark ready after the overlap is resolved)` : "";
-  const fixDispatchGuard = overlapBlocked ? { allowFixDispatch: false } : {};
+  const serializedRunnerFailure = serializeRunnerFailure(run?.failure);
+  const runnerFailure = Boolean(serializedRunnerFailure);
+  const runnerFailureRecord = serializedRunnerFailure ? JSON.parse(serializedRunnerFailure) : null;
+  const runnerFailureMessage = runnerFailureRecord ? `blocked by ${runnerFailureRecord.code}; operator review required: ${runnerFailureRecord.operator_next_action}` : "";
+  const fixDispatchGuard = overlapBlocked || runnerFailure ? { allowFixDispatch: false } : {};
   let resumeQueued = false;
   if (cfg.watchEnabled) {
     try {
@@ -16078,7 +16228,7 @@ async function finalizePublishedPr({
         taskId: id,
         operatorId: task.operator_id,
         tenantId: task.tenant_id,
-        needsContinuation: partial && !rateLimitResume && (task.continuation_attempt ?? 0) < (task.continuation_max_attempts ?? 3),
+        needsContinuation: partial && !rateLimitResume && !runnerFailure && (task.continuation_attempt ?? 0) < (task.continuation_max_attempts ?? 3),
         continuationExhausted: partial && (task.continuation_attempt ?? 0) >= (task.continuation_max_attempts ?? 3),
         repairChain: task.repair_chain ?? {
           root_pr_number: pr.prNumber,
@@ -16135,15 +16285,15 @@ async function finalizePublishedPr({
     safeProgress: safeProgress2,
     log: log2,
     patch: {
-      status: "pr_opened",
-      message: `opened ${pr.prUrl}${overlapNote}${pr.newCommit === false ? " (no new commits \u2014 the branch already held every change)" : ""}`,
+      status: runnerFailure ? "failed" : "pr_opened",
+      message: runnerFailure ? `${runnerFailureMessage}; preserved PR ${pr.prUrl} for owner review` : `opened ${pr.prUrl}${overlapNote}${pr.newCommit === false ? " (no new commits \u2014 the branch already held every change)" : ""}`,
       pr_url: pr.prUrl,
       pr_number: pr.prNumber,
       pr_branch: pr.branch,
       result: (() => {
         const prefix = overlapBlocked ? `[VO-PUBLISH-OVERLAP-BLOCKED: ${blockedRefs}] ` : "";
         const room = 2e3 - prefix.length;
-        return `${prefix}${partial ? partialPrContinuationResult(run, room, rateLimitResume ? "rate_limited" : null) : String(run.summary).slice(0, room)}`;
+        return `${prefix}${partial || runnerFailure ? partialPrContinuationResult(run, room, rateLimitResume ? "rate_limited" : null) : String(run.summary).slice(0, room)}`;
       })(),
       ...runOutcomePatch(run),
       ...terminalLedgerPatch(run)
@@ -16187,6 +16337,7 @@ var init_publication_outcome = __esm({
     init_outcome_commit();
     init_terminal_delivery();
     init_rate_limit_resume();
+    init_error_message();
     defaultRunCommand4 = (cmd, args, cwd, opts = {}) => runProcess2(cmd, args, { cwd, ...opts });
   }
 });
@@ -16524,7 +16675,16 @@ function isMaxTurnExhaustion(run = {}, maxTurns) {
   return Number.isInteger(maxTurns) && maxTurns > 0 && Number.isInteger(run.numTurns) && run.numTurns > maxTurns;
 }
 function decideNoChangesTerminalStatus({ partial, run = {}, maxTurns } = {}) {
+  const structuredFailure = serializeRunnerFailure(run.failure);
   if (!partial) {
+    if (structuredFailure) {
+      const failure = JSON.parse(structuredFailure);
+      return {
+        status: "failed",
+        message: `agent reported a runner blocker with no file changes \u2014 ${failure.code}; ${failure.operator_next_action}`,
+        result: partialPrContinuationResult(run, RESULT_LIMIT)
+      };
+    }
     if (reportsBlocker(run.summary)) {
       return {
         status: "failed",
@@ -16548,8 +16708,8 @@ function decideNoChangesTerminalStatus({ partial, run = {}, maxTurns } = {}) {
   const cause = String(run.summary || "").trim();
   return {
     status: "failed",
-    message: cause ? `agent made no file changes \u2014 ${cause.slice(0, 200)}` : "agent made no file changes",
-    result: (cause || "no_changes").slice(0, RESULT_LIMIT)
+    message: structuredFailure ? `agent made no file changes \u2014 ${JSON.parse(structuredFailure).code}; ${JSON.parse(structuredFailure).operator_next_action}` : cause ? `agent made no file changes \u2014 ${cause.slice(0, 200)}` : "agent made no file changes",
+    result: structuredFailure ? partialPrContinuationResult(run, RESULT_LIMIT) : (cause || "no_changes").slice(0, RESULT_LIMIT)
   };
 }
 async function closeSupersededSourceOnNoChanges({
@@ -16682,6 +16842,8 @@ var init_no_changes_terminal_status = __esm({
     init_terminal_ledger_patch();
     init_outcome_commit();
     init_terminal_delivery();
+    init_error_message();
+    init_partial_pr_continuation();
     RESULT_LIMIT = 2e3;
   }
 });
@@ -16999,6 +17161,50 @@ var init_daemon_config = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/task-worktree-preparation.mjs
+async function git3(worktreeDir, args, runCommand = runProcess2) {
+  const result = await runCommand("git", args, { cwd: worktreeDir, timeoutMs: 6e4 });
+  if (result.status !== 0) throw new Error(`source binding git ${args[0]} failed before model execution`);
+  return String(result.stdout || "").trim();
+}
+function hasAffirmativePreSpawnNoSpendEvidence(parentTask) {
+  return Boolean(parentTask && parentTask.status === "failed" && parentTask.completed_at && parentTask.execution_started_at === null && parentTask.usage_reported_at && parentTask.cost_usd === 0 && parentTask.cost_basis === "no_agent_spawned" && typeof parentTask.claimed_by === "string" && parentTask.claimed_by.length > 0 && RUNNER_INSTANCE_ID.test(parentTask.runner_instance_id ?? "") && parentTask.usage_runner_instance_id === parentTask.runner_instance_id && !parentTask.token_usage && !parentTask.model_usage && !parentTask.detached_run_economics?.length && !parentTask.resumed_from && !parentTask.pr_branch && !parentTask.pr_url && !parentTask.pr_number);
+}
+async function bindTaskExecutionSource({
+  client,
+  task,
+  parentTask,
+  worktreeDir,
+  continuationRestore,
+  runCommand = runProcess2
+}) {
+  const baseSha = task.comparative_base_sha;
+  if (!baseSha) return null;
+  if (!EXACT_SHA.test(baseSha)) throw new Error("comparative base SHA is invalid");
+  const actualSha = await git3(worktreeDir, ["rev-parse", "HEAD"], runCommand);
+  if (!EXACT_SHA.test(actualSha)) throw new Error("worktree HEAD is not an exact commit SHA");
+  if (!task.resumed_from) {
+    if (actualSha !== baseSha) throw new Error("initial comparative worktree HEAD does not match requested base");
+  } else if (continuationRestore) {
+    if (task.pr_head_sha_at_enqueue && actualSha !== task.pr_head_sha_at_enqueue) {
+      throw new Error("continuation worktree HEAD does not match its expected continuation head");
+    }
+    await git3(worktreeDir, ["merge-base", "--is-ancestor", baseSha, actualSha], runCommand);
+  } else {
+    if (!hasAffirmativePreSpawnNoSpendEvidence(parentTask)) {
+      throw new Error("continuation branch is missing and prior execution state is unknown; recovery review required");
+    }
+    if (actualSha !== baseSha) throw new Error("safe pre-spawn continuation did not rematerialize the original base");
+  }
+  const acknowledgement = await client.postProgress(task.code_task_id, {
+    execution_start_sha: actualSha,
+    stage: "preparing_worktree",
+    message: `Exact execution source ${actualSha} verified before model start`
+  });
+  if (acknowledgement?.terminal || acknowledgement?.task?.execution_start_sha !== actualSha) {
+    throw new Error("control plane did not durably acknowledge execution_start_sha");
+  }
+  return { baseSha, executionStartSha: actualSha };
+}
 async function prepareTaskWorktree({ client, task, cfg, safeProgress: safeProgress2, log: log2 }) {
   const id = task.code_task_id;
   await safeProgress2(client, id, runnerStagePatch(
@@ -17015,7 +17221,7 @@ async function prepareTaskWorktree({ client, task, cfg, safeProgress: safeProgre
   const wt = await createFixWorktree(
     "code-task",
     { source: id.slice(0, 8), repo: task.repo },
-    { githubToken }
+    { githubToken, baseSha: task.comparative_base_sha ?? null }
   );
   if (!wt.worktreeName || !wt.worktreeDir) {
     throw new Error("worktree isolation failure \u2014 refusing to run in the main tree");
@@ -17045,8 +17251,16 @@ async function prepareTaskWorktree({ client, task, cfg, safeProgress: safeProgre
     });
     log2(repairPlan.strategy === "in-place" ? `task ${id}: repairing ${task.repo}#${task.repair_pr_number}@${repairPlan.headSha} IN PLACE on ${repairPlan.remoteBranch}` : `task ${id}: materialized full repair source ${task.repo}#${task.repair_pr_number}@${repairPlan.headSha} for supersede (${repairPlan.reason})${repairPlan.conflicted ? " with conflicts for the agent to resolve" : ""}`);
   }
-  return { wt, githubToken, agentGithubReadToken, continuationRestore, repairPlan };
+  const sourceBinding = await bindTaskExecutionSource({
+    client,
+    task,
+    parentTask,
+    worktreeDir: wt.worktreeDir,
+    continuationRestore
+  });
+  return { wt, githubToken, agentGithubReadToken, continuationRestore, repairPlan, sourceBinding };
 }
+var EXACT_SHA, RUNNER_INSTANCE_ID;
 var init_task_worktree_preparation = __esm({
   "../../scripts/virtual-office/code-runner/task-worktree-preparation.mjs"() {
     "use strict";
@@ -17054,6 +17268,9 @@ var init_task_worktree_preparation = __esm({
     init_resume_branch();
     init_repair_publication_strategy();
     init_task_helpers();
+    init_process_runner2();
+    EXACT_SHA = /^[0-9a-f]{40}$/u;
+    RUNNER_INSTANCE_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
   }
 });