@algosuite/vo-mcp 0.2.0-beta.55 → 0.2.0-beta.57

package/dist/runner-cli.js

@@ -675,12 +675,15 @@ function installWindowsAutostart(runnerCommand, log2, env2) {
       log2(`\u26A0 Could not remove legacy launcher ${legacyCmdPath} (${error instanceof Error ? error.message : String(error)}); remove it manually to avoid a double start`);
     }
   }
-  const hiddenCommand = `cmd /c ${runnerCommand} >> "%USERPROFILE%\\.claude\\vo-runner.log" 2>&1`.replace(/"/g, '""');
+  const runnerConsoleCommand = `cmd /c ${runnerCommand} >> "%USERPROFILE%\\.claude\\vo-runner.log" 2>&1`.replace(/"/g, '""');
   const launcherContent = `' Auto-start launcher for vo-mcp runner
 ' Created by vo-mcp autostart installer
 ' Keepalive supervisor: restarts the runner if it exits (parity with launchd
 ' KeepAlive on macOS and systemd Restart=on-failure on Linux).
-' To stop: create %USERPROFILE%\\.claude\\vo-runner.stop, or end wscript.exe.
+' Runs the runner in a MINIMIZED (style 7), never a hidden (style 0) window:
+' hidden script-host exec trips Defender's PowhidSubExec.B heuristic and gets
+' blocked at logon. To stop: create %USERPROFILE%\\.claude\\vo-runner.stop, or
+' end wscript.exe.
 Dim sh, fso, stopFile, backoff, startedAt, ranMs
 Set sh = CreateObject("WScript.Shell")
 Set fso = CreateObject("Scripting.FileSystemObject")
@@ -694,7 +697,7 @@ Do
     WScript.Quit 0
   End If
   startedAt = Timer
-  sh.Run "${hiddenCommand}", 0, True
+  sh.Run "${runnerConsoleCommand}", 7, True
   ranMs = (Timer - startedAt) * 1000
   If ranMs < 0 Then ranMs = ${WINDOWS_HEALTHY_RUN_MS}
   If ranMs >= ${WINDOWS_HEALTHY_RUN_MS} Then
@@ -1178,8 +1181,8 @@ async function walkManagedRoots(ownership, options, onLink) {
   const normalized = normalizeOwnership(ownership);
   let scannedEntries = 0;
   for (const rootPath of normalized.managedRoots) {
-    const present = await assertManagedRoot(rootPath, normalized.worktreeRoot, fsApi);
-    if (!present) continue;
+    const present2 = await assertManagedRoot(rootPath, normalized.worktreeRoot, fsApi);
+    if (!present2) continue;
     const stack = [rootPath];
     while (stack.length > 0) {
       const current = stack.pop();
@@ -1999,12 +2002,12 @@ var init_pnpm_materialize = __esm({
 });
 
 // src/runner/pnpm-hydration.mjs
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import fs3 from "node:fs";
 import fsp5 from "node:fs/promises";
 import path5 from "node:path";
 function hashText(text) {
-  return createHash("sha256").update(String(text)).digest("hex");
+  return createHash2("sha256").update(String(text)).digest("hex");
 }
 function statePath(root) {
   return path5.join(root, ".agent-worktrees", "runner-pnpm-hydration.json");
@@ -2314,7 +2317,7 @@ var init_pnpm_hydration = __esm({
 });
 
 // src/runner/worktree-paths.mjs
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import path6 from "node:path";
 function samePath2(left, right) {
   const a = path6.resolve(left);
@@ -2332,7 +2335,7 @@ function worktreePoolForRoot(root, { clonesRootDir = process.env.VO_CODE_RUNNER_
   return path6.join(canonicalRoot, ".agent-worktrees");
 }
 function worktreeDirForName(root, worktreeName, options = {}) {
-  const leaf = createHash2("sha256").update(String(worktreeName)).digest("hex").slice(0, 16);
+  const leaf = createHash3("sha256").update(String(worktreeName)).digest("hex").slice(0, 16);
   return path6.join(worktreePoolForRoot(root, options), leaf);
 }
 function recoveryLedgerPathForRoot(root, options = {}) {
@@ -3497,8 +3500,9 @@ async function mergeVerifiedPrRequest(req, prNumber, automationContext, onUnauth
       actionReceiptId: typeof json.action_receipt_id === "string" ? json.action_receipt_id : null
     };
   }
-  if (res.status === 503 && json?.error === "verify_unavailable") {
-    return { status: "retry", reason: json.reason || "verification unavailable" };
+  const captureStoreRetry = json?.action_status === "not_attempted" && (json?.error === "capture_preflight_unavailable" || json?.error === "decision_outcome_intent_failed");
+  if (res.status === 503 && (json?.error === "verify_unavailable" || json?.error === "merge_unavailable" || captureStoreRetry)) {
+    return { status: "retry", reason: json.reason || json.message || json.error || "verification unavailable" };
   }
   return {
     status: "blocked",
@@ -3604,6 +3608,64 @@ var init_claim_gate_notice = __esm({
   }
 });
 
+// ../../scripts/virtual-office/code-runner/control-plane-knowledge-context.mjs
+function isRetryableStatus(status) {
+  return status >= 500 && status <= 599;
+}
+function defaultSleep(ms) {
+  return new Promise((resolve3) => {
+    setTimeout(resolve3, ms);
+  });
+}
+async function getTaskKnowledgeContextRequest(req, taskId, { query } = {}, {
+  taskRequestTimeoutMs,
+  invalidateToken = () => {
+  },
+  sleep: sleep3 = defaultSleep,
+  log: log2 = () => {
+  }
+} = {}) {
+  const body = {};
+  if (typeof query === "string" && query.trim()) body.query = query;
+  const path22 = `/api/v1/code-task/${encodeURIComponent(taskId)}/knowledge-context`;
+  const timeoutMs = Math.max(Number(taskRequestTimeoutMs) || 0, MIN_KNOWLEDGE_CONTEXT_TIMEOUT_MS);
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt += 1) {
+    let res;
+    let cause;
+    try {
+      res = await req("POST", path22, body, { timeoutMs });
+    } catch (err) {
+      cause = err;
+    }
+    if (!cause) {
+      if (res.status === 401) {
+        invalidateToken();
+        throw new Error("knowledge-context unauthorized (401)");
+      }
+      if (res.status === 404) return null;
+      if (res.ok) return res.json();
+      if (!isRetryableStatus(res.status)) {
+        throw new Error(`knowledge-context failed: HTTP ${res.status}`);
+      }
+      cause = new Error(`knowledge-context failed: HTTP ${res.status}`);
+    }
+    if (attempt === MAX_ATTEMPTS) throw cause;
+    const delayMs = RETRY_DELAYS_MS[attempt - 1];
+    log2(`knowledge-context attempt ${attempt}/${MAX_ATTEMPTS} failed (${cause.message}); retrying in ${delayMs}ms`);
+    await sleep3(delayMs);
+  }
+  throw new Error("knowledge-context retry loop exited unexpectedly");
+}
+var MIN_KNOWLEDGE_CONTEXT_TIMEOUT_MS, RETRY_DELAYS_MS, MAX_ATTEMPTS;
+var init_control_plane_knowledge_context = __esm({
+  "../../scripts/virtual-office/code-runner/control-plane-knowledge-context.mjs"() {
+    "use strict";
+    MIN_KNOWLEDGE_CONTEXT_TIMEOUT_MS = 15e3;
+    RETRY_DELAYS_MS = [2e3, 6e3];
+    MAX_ATTEMPTS = RETRY_DELAYS_MS.length + 1;
+  }
+});
+
 // src/runner/control-plane-auth-stub.mjs
 var control_plane_auth_stub_exports = {};
 __export(control_plane_auth_stub_exports, {
@@ -3647,7 +3709,8 @@ function createControlPlaneClient({
     6e4
   ),
   runnerId,
-  runnerInstanceId
+  runnerInstanceId,
+  sleep: sleep3
 } = {}) {
   const resolvedBaseUrl = baseUrl ?? env2.VO_CONTROL_PLANE_URL ?? "";
   if (!resolvedBaseUrl) throw new Error("VO_CONTROL_PLANE_URL is required for the code-runner daemon");
@@ -3828,17 +3891,16 @@ function createControlPlaneClient({
       if (!res.ok) throw new Error(`attachment download failed: HTTP ${res.status}`);
       return Buffer.from(await res.arrayBuffer());
     },
+    // Raised per-attempt timeout (>=15s) + bounded retry — see control-plane-knowledge-context.mjs.
     async getTaskKnowledgeContext(taskId, { query } = {}) {
-      const body = {};
-      if (typeof query === "string" && query.trim()) body.query = query;
-      const res = await taskReq("POST", `/api/v1/code-task/${encodeURIComponent(taskId)}/knowledge-context`, body);
-      if (res.status === 401) {
-        cachedFirebaseToken = null;
-        throw new Error("knowledge-context unauthorized (401)");
-      }
-      if (res.status === 404) return null;
-      if (!res.ok) throw new Error(`knowledge-context failed: HTTP ${res.status}`);
-      return res.json();
+      return getTaskKnowledgeContextRequest(req, taskId, { query }, {
+        taskRequestTimeoutMs,
+        invalidateToken: () => {
+          cachedFirebaseToken = null;
+        },
+        sleep: sleep3,
+        log: (m) => console.warn(`[code-runner ${(/* @__PURE__ */ new Date()).toISOString()}] ${m}`)
+      });
     },
     /** Weekly Claude token usage report — see control-plane-weekly-tokens.mjs. */
     async postWeeklyTokens(report) {
@@ -3992,6 +4054,7 @@ var init_control_plane_client = __esm({
     init_control_plane_weekly_tokens();
     init_control_plane_telemetry_relay();
     init_claim_gate_notice();
+    init_control_plane_knowledge_context();
     cachedFirebaseToken = null;
     ClaimAuthorityChangedError = class extends Error {
       constructor() {
@@ -8606,7 +8669,7 @@ var init_task_prompt = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/task-attachments.mjs
-import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID3 } from "node:crypto";
 import { chmod, mkdir, mkdtemp, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import os2 from "node:os";
 import path16 from "node:path";
@@ -8630,7 +8693,7 @@ async function createAttachmentDirectory(taskId, tempRoot) {
   const root = path16.resolve(tempRoot);
   await mkdir(root, { recursive: true });
   const directory = await mkdtemp(path16.join(root, `${DIRECTORY_PREFIX}${safeTaskToken(taskId)}-`));
-  const marker = JSON.stringify({ owner: MARKER_OWNER, token: randomUUID2(), directory: path16.basename(directory), created_at: (/* @__PURE__ */ new Date()).toISOString() });
+  const marker = JSON.stringify({ owner: MARKER_OWNER, token: randomUUID3(), directory: path16.basename(directory), created_at: (/* @__PURE__ */ new Date()).toISOString() });
   await writeFile(path16.join(directory, MARKER_FILE), marker, { encoding: "utf8", mode: 384 });
   return { directory, marker, tempRoot: root };
 }
@@ -8706,7 +8769,7 @@ 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 = createHash3("sha256").update(content).digest("hex");
+      const sha256 = createHash4("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 = path16.join(state.directory, name);
@@ -8737,9 +8800,9 @@ var init_task_attachments = __esm({
 import { homedir as homedir7 } from "node:os";
 import { join as join11 } 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";
+import { createHash as createHash5 } from "node:crypto";
 function deriveUuid(seed) {
-  const h = createHash4("sha256").update(seed).digest("hex");
+  const h = createHash5("sha256").update(seed).digest("hex");
   return `${h.slice(0, 8)}-${h.slice(8, 12)}-5${h.slice(13, 16)}-${(parseInt(h.slice(16, 18), 16) & 63 | 128).toString(16)}${h.slice(18, 20)}-${h.slice(20, 32)}`;
 }
 function spoolToCloud(record, ids) {
@@ -8876,7 +8939,7 @@ function selectDueEntries({ entries = [], now, alreadyDispatched = /* @__PURE__
     if (!code_task_id) continue;
     if (seen.has(code_task_id)) continue;
     const stableAttempts = Number(attemptsByKey[stableTaskKey(e)] || 0);
-    if (Math.max(typeof attempts === "number" ? attempts : 0, stableAttempts) >= MAX_ATTEMPTS) {
+    if (Math.max(typeof attempts === "number" ? attempts : 0, stableAttempts) >= MAX_ATTEMPTS2) {
       exhausted.push(e);
       continue;
     }
@@ -8912,11 +8975,11 @@ function reconcileQueue({ entries = [], dispatchedIds = /* @__PURE__ */ new Set(
     return true;
   });
 }
-var MAX_ATTEMPTS, MAX_DISPATCH_PER_RUN, NULL_RESUME_AFTER_BACKOFF_MS;
+var MAX_ATTEMPTS2, MAX_DISPATCH_PER_RUN, NULL_RESUME_AFTER_BACKOFF_MS;
 var init_rate_limit_resume_scheduler_core = __esm({
   "../../scripts/virtual-office/code-runner/rate-limit-resume-scheduler-core.mjs"() {
     "use strict";
-    MAX_ATTEMPTS = 3;
+    MAX_ATTEMPTS2 = 3;
     MAX_DISPATCH_PER_RUN = 10;
     NULL_RESUME_AFTER_BACKOFF_MS = 15 * 60 * 1e3;
   }
@@ -8943,7 +9006,7 @@ function bumpAttempts(store, key, sourceTaskId, nowIso) {
   store[key] = {
     count: (typeof prior.count === "number" ? prior.count : 0) + 1,
     lastSeen: nowIso,
-    resumedTaskIds: [...resumedTaskIds, sourceTaskId].slice(-MAX_ATTEMPTS)
+    resumedTaskIds: [...resumedTaskIds, sourceTaskId].slice(-MAX_ATTEMPTS2)
   };
 }
 function pruneAttemptsStore(store, nowIso) {
@@ -8995,7 +9058,7 @@ async function runLockedScheduler({
   await writeResumeAttempts(attemptsPath, pruneAttemptsStore(attemptsStore, nowIso));
   await writeResumeQueue(queuePath, kept);
   if (exhausted.length > 0) {
-    log2(`WARN: ${exhausted.length} task(s) reached the ${MAX_ATTEMPTS}-continuation spend ceiling and remain queued for operator review: ${exhausted.map((entry) => entry.code_task_id).join(", ")}`);
+    log2(`WARN: ${exhausted.length} task(s) reached the ${MAX_ATTEMPTS2}-continuation spend ceiling and remain queued for operator review: ${exhausted.map((entry) => entry.code_task_id).join(", ")}`);
   }
   if (due.length >= MAX_DISPATCH_PER_RUN) {
     log2(`WARN: hit the per-run dispatch cap (${MAX_DISPATCH_PER_RUN}); more tasks remain queued`);
@@ -10446,39 +10509,6 @@ var init_pr_watcher_failure_confirmation = __esm({
   }
 });
 
-// ../../scripts/virtual-office/code-runner/superseded-pr-source.mjs
-function supersededSourcePrNumber(prompt) {
-  const text = String(prompt || "");
-  if (text.includes(CI_FIX_MARKER)) {
-    const match = text.match(/\bPR:\s*#(\d+)\b/u);
-    return match ? Number(match[1]) : null;
-  }
-  const repairMatch = text.match(/^REPAIR MISSION:\s*PR\s+#(\d+)\b/iu);
-  if (repairMatch) return Number(repairMatch[1]);
-  const recoverySupersedeMatch = text.match(
-    /^VO_RECOVERY_FROM_CODE_TASK:\s*[0-9a-f-]{36}\n\nSupersede draft PR #(\d+) from a fresh current origin\/main branch\b/iu
-  );
-  if (recoverySupersedeMatch) return Number(recoverySupersedeMatch[1]);
-  const restoredContextMatch = text.match(
-    /^(?:The previous run reached its max-turn cap after opening a partial draft PR\.|The previous run left a draft PR\.)\nThe HQ runner will restore the existing draft PR context before you start \(draft PR https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/(\d+), PR #(\d+)\)\. Continue that work and finish it\./u
-  );
-  if (restoredContextMatch) {
-    return restoredContextMatch[1] === restoredContextMatch[2] ? Number(restoredContextMatch[1]) : null;
-  }
-  const continuationMatch = text.match(
-    /^(?:The previous run reached its max-turn cap after opening a partial draft PR\.|The previous run left a draft PR\.)\nContinue the work already started on the branch for PR #(\d+) \(draft PR https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/(\d+)\); check it out and finish it\./u
-  );
-  if (!continuationMatch || continuationMatch[1] !== continuationMatch[2]) return null;
-  return Number(continuationMatch[1]);
-}
-var CI_FIX_MARKER;
-var init_superseded_pr_source = __esm({
-  "../../scripts/virtual-office/code-runner/superseded-pr-source.mjs"() {
-    "use strict";
-    CI_FIX_MARKER = "[VO-CI-FIX]";
-  }
-});
-
 // ../../scripts/virtual-office/code-runner/error-message.mjs
 function boundedErrorMessage(error, maxLength = 240) {
   try {
@@ -10494,7 +10524,7 @@ var init_error_message = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/watcher-coordination.mjs
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 function ciFixOccurrenceKey({ repo, prNumber, headSha, repairAttempt }) {
   const occurrence = JSON.stringify([
     String(repo).toLowerCase(),
@@ -10502,7 +10532,7 @@ function ciFixOccurrenceKey({ repo, prNumber, headSha, repairAttempt }) {
     String(headSha).toLowerCase(),
     Number(repairAttempt)
   ]);
-  return `ci-fix:v1:${createHash5("sha256").update(occurrence).digest("hex")}`;
+  return `ci-fix:v1:${createHash6("sha256").update(occurrence).digest("hex")}`;
 }
 function coordinationRetryDue(entry, nowMs) {
   return !entry.nextRetryAt || nowMs >= entry.nextRetryAt;
@@ -10513,9 +10543,52 @@ function mergeEnqueueActive(entry, nowMs = Date.now()) {
   if (!at) return true;
   return nowMs - at < MERGE_ENQUEUE_TTL_MS;
 }
+function migrateLegacyMergeState(entry, nowMs = Date.now()) {
+  if (!entry) return false;
+  if (entry.mergeEnqueued === true && !(Number(entry.mergeEnqueuedAt) > 0)) {
+    entry.mergeEnqueuedAt = nowMs;
+    return true;
+  }
+  const exhausted = entry.mergeRetryExhausted === true || (Number(entry.mergeAttempts) || 0) >= 3 || (Number(entry.mergeErrors) || 0) >= 3;
+  if (entry.mergeTerminal === true || mergeEnqueueActive(entry, nowMs) || !exhausted) return false;
+  entry.mergeRetryExhausted = true;
+  entry.mergeTerminal = true;
+  entry.mergeBlockReason ||= "Legacy watcher state exhausted 3 automatic merge attempts without a terminal result.";
+  return true;
+}
 function isTerminalResumeRefusal(error) {
   return typeof error?.code === "string" && TERMINAL_RESUME_REFUSALS.includes(error.code);
 }
+async function reportPendingMergeExhaustion({
+  entry,
+  now,
+  reportBlocker,
+  taskId,
+  prNumber,
+  log: log2 = () => {
+  }
+}) {
+  if (!entry.mergeRetryExhausted || entry.mergeEscalatedAt || typeof reportBlocker !== "function") return false;
+  const lastError = boundedErrorMessage(entry.mergeRetryReason || entry.mergeBlockReason);
+  try {
+    await reportBlocker({
+      taskId,
+      message: `PR #${prNumber} automatic merge verification exhausted its bounded retry budget; operator review is required. Last error: ${lastError}`
+    });
+    entry.mergeEscalatedAt = now();
+    return true;
+  } catch (reportError) {
+    log2(`watch: pr #${prNumber} merge escalation failed; terminal state retained: ${boundedErrorMessage(reportError)}`);
+    return false;
+  }
+}
+async function scheduleMergeRetry(input) {
+  await scheduleCoordinationRetry({ ...input, kind: "merge" });
+  return {
+    terminal: input.entry.mergeTerminal === true,
+    escalated: await reportPendingMergeExhaustion(input)
+  };
+}
 async function scheduleCoordinationRetry({
   entry,
   kind,
@@ -10534,10 +10607,21 @@ async function scheduleCoordinationRetry({
     log2(`watch: pr #${prNumber} automatic continuation refused by the plane (${error.code}); no retry \u2014 operator may resume explicitly with a larger cap`);
     return;
   }
-  const errorsKey = kind === "resume" ? "resumeErrors" : "enqueueErrors";
-  const attemptsKey = kind === "resume" ? "resumeAttempts" : "fixAttempts";
+  const errorsKey = kind === "resume" ? "resumeErrors" : kind === "merge" ? "mergeErrors" : "enqueueErrors";
+  const attemptsKey = kind === "resume" ? "resumeAttempts" : kind === "merge" ? "mergeAttempts" : "fixAttempts";
   entry[errorsKey] = (entry[errorsKey] || 0) + 1;
-  entry[attemptsKey] = Math.max(0, (entry[attemptsKey] || 1) - 1);
+  if (kind === "merge") {
+    entry.mergeRetryReason = boundedErrorMessage(error);
+    if (entry[errorsKey] >= 3) {
+      entry.mergeTerminal = true;
+      entry.mergeRetryExhausted = true;
+      entry.mergeBlockReason = `Automatic merge verification remained unavailable after 3 attempts: ${entry.mergeRetryReason}`;
+      delete entry.nextRetryAt;
+      log2(`watch: pr #${prNumber} merge retry cap reached \u2014 terminal and operator review required`);
+      return;
+    }
+  }
+  if (kind !== "merge") entry[attemptsKey] = Math.max(0, (entry[attemptsKey] || 1) - 1);
   const delay2 = Math.min(MAX_BACKOFF_MS2, 3e4 * 2 ** Math.min(7, entry[errorsKey] - 1));
   entry.nextRetryAt = now() + delay2;
   if (entry[errorsKey] >= 3 && !entry.coordinationEscalatedAt && typeof reportBlocker === "function") {
@@ -10578,7 +10662,7 @@ var init_watcher_coordination = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/watcher-state.mjs
-import { randomUUID as randomUUID3 } from "node:crypto";
+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";
 async function readWatcherState(stateFile) {
@@ -10598,7 +10682,7 @@ async function readWatcherState(stateFile) {
 async function writeWatcherState(stateFile, state) {
   const directory = dirname10(stateFile);
   await mkdir3(directory, { recursive: true });
-  const temp = `${stateFile}.${process.pid}.${randomUUID3()}.tmp`;
+  const temp = `${stateFile}.${process.pid}.${randomUUID4()}.tmp`;
   let handle;
   try {
     handle = await open2(temp, "wx");
@@ -10646,16 +10730,87 @@ var init_watcher_state = __esm({
 function normalizedRepo(repo) {
   return String(repo || "").trim().toLowerCase();
 }
+function present(value) {
+  return value !== null && value !== void 0 && value !== "";
+}
 function watcherKey(state, repo, prNumber) {
+  const targetRepo = normalizedRepo(repo);
+  for (const [key, entry] of Object.entries(state)) {
+    if (watcherPrNumber(key, entry) !== Number(prNumber)) continue;
+    if (normalizedRepo(entry?.repo) === targetRepo) return key;
+  }
   const legacy = String(prNumber);
   const existing = state[legacy];
-  if (!existing || normalizedRepo(existing.repo) === normalizedRepo(repo)) return legacy;
-  return `${normalizedRepo(repo)}#${prNumber}`;
+  if (!existing) return legacy;
+  return `${targetRepo}#${prNumber}`;
 }
 function watcherPrNumber(stateKey, entry) {
   const value = Number(entry?.prNumber ?? String(stateKey).split("#").at(-1));
   return Number.isInteger(value) && value > 0 ? value : null;
 }
+function collapseDuplicateWatcherEntries(state) {
+  const keeperBySubject = /* @__PURE__ */ new Map();
+  let collapsed = 0;
+  for (const [key, entry] of Object.entries(state)) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+    const repo = normalizedRepo(entry.repo);
+    const prNumber = watcherPrNumber(key, entry);
+    if (!repo || !prNumber) continue;
+    const subject = `${repo}#${prNumber}`;
+    const keeperKey = keeperBySubject.get(subject);
+    if (!keeperKey) {
+      keeperBySubject.set(subject, key);
+      continue;
+    }
+    const keeper = state[keeperKey];
+    let identityConflict = false;
+    for (const field of ["taskId", "operatorId", "tenantId"]) {
+      const current = keeper[field];
+      const duplicate = entry[field];
+      if (!present(current) && present(duplicate)) keeper[field] = duplicate;
+      else if (present(current) && present(duplicate) && current !== duplicate) identityConflict = true;
+    }
+    if (keeper.operatorId === "admin" && present(keeper.tenantId)) identityConflict = true;
+    for (const field of ["fixAttempts", "mergeAttempts", "mergeErrors", "resumeAttempts"]) {
+      const current = Number(keeper[field]);
+      const duplicate = Number(entry[field]);
+      const total = (Number.isSafeInteger(current) && current > 0 ? current : 0) + (Number.isSafeInteger(duplicate) && duplicate > 0 ? duplicate : 0);
+      keeper[field] = Math.min(Number.MAX_SAFE_INTEGER, total);
+    }
+    for (const [field, value] of Object.entries(entry)) {
+      if (["taskId", "operatorId", "tenantId"].includes(field)) continue;
+      if (!present(keeper[field]) && present(value)) keeper[field] = value;
+    }
+    if (entry.allowFixDispatch === false) keeper.allowFixDispatch = false;
+    const continuationExhausted = keeper.continuationExhausted === true || entry.continuationExhausted === true;
+    keeper.continuationExhausted = continuationExhausted;
+    keeper.needsContinuation = !continuationExhausted && (keeper.needsContinuation === true || entry.needsContinuation === true);
+    if (entry.mergeEnqueued === true) {
+      keeper.mergeEnqueued = true;
+      if ((Number(entry.mergeEnqueuedAt) || 0) > (Number(keeper.mergeEnqueuedAt) || 0)) {
+        keeper.mergeEnqueuedAt = entry.mergeEnqueuedAt;
+        keeper.mergeActionReceiptId = entry.mergeActionReceiptId ?? null;
+      }
+    }
+    if (entry.mergeTerminal === true && keeper.mergeTerminal !== true) {
+      keeper.mergeTerminal = true;
+      keeper.mergeBlockReason = entry.mergeBlockReason || "verification refused";
+    }
+    if ((Number(keeper.mergeErrors) || 0) >= 3) {
+      keeper.mergeRetryExhausted = true;
+      keeper.mergeTerminal = true;
+      keeper.mergeBlockReason ||= `Duplicate watcher history exhausted ${keeper.mergeErrors} automatic merge retries.`;
+    }
+    if (identityConflict) {
+      keeper.automationContextConflict = true;
+      keeper.mergeTerminal = true;
+      keeper.mergeBlockReason = "Duplicate watcher entries disagree on automation attribution.";
+    }
+    delete state[key];
+    collapsed += 1;
+  }
+  return collapsed;
+}
 function deleteWatcherEntry(state, repo, prNumber) {
   const targetRepo = normalizedRepo(repo);
   for (const [key, entry] of Object.entries(state)) {
@@ -10670,6 +10825,46 @@ var init_watcher_key = __esm({
   }
 });
 
+// ../../scripts/virtual-office/code-runner/watcher-merge-authority.mjs
+function nonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function resolveWatcherMergeAuthority(entry = {}) {
+  if (entry.automationContextConflict === true) {
+    return {
+      kind: "blocked",
+      reason: "Watcher automation attribution conflicts with the durable code task."
+    };
+  }
+  if (String(entry.repo || "").trim().toLowerCase() !== CANONICAL_WATCHER_MERGE_REPO) {
+    return {
+      kind: "blocked",
+      reason: "Watcher merge target is not the canonical Nexus repository."
+    };
+  }
+  const taskId = entry.taskId;
+  const operatorId = entry.operatorId;
+  const tenantId = entry.tenantId;
+  if (nonEmptyString(taskId) && operatorId === "admin" && (tenantId === null || tenantId === void 0)) {
+    return { kind: "legacy-admin", context: void 0 };
+  }
+  if (nonEmptyString(taskId) && nonEmptyString(operatorId) && nonEmptyString(tenantId)) {
+    return { kind: "scoped", context: { taskId, operatorId, tenantId } };
+  }
+  return {
+    kind: "blocked",
+    reason: INCOMPLETE_WATCHER_AUTHORITY_REASON
+  };
+}
+var INCOMPLETE_WATCHER_AUTHORITY_REASON, CANONICAL_WATCHER_MERGE_REPO;
+var init_watcher_merge_authority = __esm({
+  "../../scripts/virtual-office/code-runner/watcher-merge-authority.mjs"() {
+    "use strict";
+    INCOMPLETE_WATCHER_AUTHORITY_REASON = "Watcher automation attribution is incomplete; merge was not attempted.";
+    CANONICAL_WATCHER_MERGE_REPO = "algosuite-ai/nexus";
+  }
+});
+
 // ../../scripts/virtual-office/code-runner/watcher-adoption.mjs
 async function adoptPrOpenedTasks(tasks, {
   stateFile,
@@ -10690,7 +10885,38 @@ async function adoptPrOpenedTasks(tasks, {
       if (repos.size > 0 && !repos.has(task.repo.toLowerCase())) continue;
       if (operators.size > 0 && !operators.has(task.operator_id)) continue;
       const key = watcherKey(state, task.repo, task.pr_number);
-      if (state[key]) continue;
+      const existing = state[key];
+      if (existing) {
+        let changed = false;
+        let conflict = false;
+        for (const [field, durable] of [
+          ["taskId", task.code_task_id],
+          ["operatorId", task.operator_id],
+          ["tenantId", task.tenant_id]
+        ]) {
+          const comparable = durable === null || typeof durable === "string" && durable.length > 0;
+          if (!comparable) continue;
+          const current = existing[field];
+          if ((current === null || current === void 0 || current === "") && durable !== null) {
+            existing[field] = durable;
+            changed = true;
+          } else if (current !== null && current !== void 0 && current !== "" && current !== durable) {
+            conflict = true;
+          }
+        }
+        if (conflict && existing.automationContextConflict !== true) {
+          existing.automationContextConflict = true;
+          changed = true;
+        }
+        if (!conflict && existing.mergeTerminal === true && existing.mergeBlockReason === INCOMPLETE_WATCHER_AUTHORITY_REASON && resolveWatcherMergeAuthority(existing).kind !== "blocked") {
+          delete existing.mergeTerminal;
+          delete existing.mergeBlockReason;
+          existing.mergeAttempts = 0;
+          changed = true;
+        }
+        if (changed) adopted += 1;
+        continue;
+      }
       const partial = String(task.result || "").includes(PARTIAL_PR_CONTINUATION_MARKER);
       const repairChain = task.repair_chain ?? {
         root_pr_number: task.repair_pr_number ?? task.pr_number,
@@ -10726,6 +10952,7 @@ var init_watcher_adoption = __esm({
     init_watcher_state();
     init_partial_pr_continuation();
     init_watcher_key();
+    init_watcher_merge_authority();
   }
 });
 
@@ -10757,6 +10984,39 @@ var init_watcher_github_token = __esm({
   }
 });
 
+// ../../scripts/virtual-office/code-runner/superseded-pr-source.mjs
+function supersededSourcePrNumber(prompt) {
+  const text = String(prompt || "");
+  if (text.includes(CI_FIX_MARKER)) {
+    const match = text.match(/\bPR:\s*#(\d+)\b/u);
+    return match ? Number(match[1]) : null;
+  }
+  const repairMatch = text.match(/^REPAIR MISSION:\s*PR\s+#(\d+)\b/iu);
+  if (repairMatch) return Number(repairMatch[1]);
+  const recoverySupersedeMatch = text.match(
+    /^VO_RECOVERY_FROM_CODE_TASK:\s*[0-9a-f-]{36}\n\nSupersede draft PR #(\d+) from a fresh current origin\/main branch\b/iu
+  );
+  if (recoverySupersedeMatch) return Number(recoverySupersedeMatch[1]);
+  const restoredContextMatch = text.match(
+    /^(?:The previous run reached its max-turn cap after opening a partial draft PR\.|The previous run left a draft PR\.)\nThe HQ runner will restore the existing draft PR context before you start \(draft PR https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/(\d+), PR #(\d+)\)\. Continue that work and finish it\./u
+  );
+  if (restoredContextMatch) {
+    return restoredContextMatch[1] === restoredContextMatch[2] ? Number(restoredContextMatch[1]) : null;
+  }
+  const continuationMatch = text.match(
+    /^(?:The previous run reached its max-turn cap after opening a partial draft PR\.|The previous run left a draft PR\.)\nContinue the work already started on the branch for PR #(\d+) \(draft PR https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/(\d+)\); check it out and finish it\./u
+  );
+  if (!continuationMatch || continuationMatch[1] !== continuationMatch[2]) return null;
+  return Number(continuationMatch[1]);
+}
+var CI_FIX_MARKER;
+var init_superseded_pr_source = __esm({
+  "../../scripts/virtual-office/code-runner/superseded-pr-source.mjs"() {
+    "use strict";
+    CI_FIX_MARKER = "[VO-CI-FIX]";
+  }
+});
+
 // ../../scripts/virtual-office/code-runner/ci-fix-prompt.mjs
 function buildCiFixPrompt({ prNumber, repo, branch, headSha, failedChecks, prPatch, failedLogs }) {
   return [
@@ -10900,7 +11160,7 @@ var init_pr_watcher_github = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/enqueue-autonomous-code-task.mjs
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 function isDefiniteRefusal(err) {
   const status = Number(err?.status);
   if (Number.isFinite(status) && status >= 400 && status < 500) return true;
@@ -10919,7 +11179,7 @@ async function enqueueAutonomousCodeTask(client, task, log2 = () => {
   if (typeof client?.reserveAutonomousDispatchBudget !== "function" || typeof client?.releaseAutonomousDispatchBudget !== "function") {
     throw new Error("autonomous dispatch admission client unavailable");
   }
-  const reservationId = randomUUID4();
+  const reservationId = randomUUID5();
   const admission = await client.reserveAutonomousDispatchBudget({
     requestedBudgetUsd,
     reservationId,
@@ -11038,6 +11298,7 @@ async function runWatchCycleUnlocked({
   stateFile = DEFAULT_STATE_FILE
 }) {
   const state = await readWatcherState(stateFile);
+  collapseDuplicateWatcherEntries(state);
   const prNumbers = Object.keys(state);
   let checked = 0;
   let fixed = 0;
@@ -11063,6 +11324,7 @@ async function runWatchCycleUnlocked({
     }
     checked += 1;
     const pr = parsePrCiStatus(view);
+    migrateLegacyMergeState(entry, now());
     entry.lastCi = pr.ci;
     const confirmation = observeRepairFailure(entry, pr, now());
     const proposedAction = decideWatchAction(
@@ -11133,10 +11395,30 @@ async function runWatchCycleUnlocked({
           mergeBlocked += 1;
           log2(`watch: pr #${prNumber} verification blocked merge: ${entry.mergeBlockReason}`);
         } else {
-          log2(`watch: pr #${prNumber} verification unavailable; retry ${entry.mergeAttempts}/3`);
+          const retry = await scheduleMergeRetry({
+            entry,
+            now,
+            reportBlocker,
+            taskId: entry.taskId,
+            prNumber,
+            error: new Error(outcome.reason || "verification unavailable"),
+            log: log2
+          });
+          if (retry.terminal) mergeBlocked += 1;
+          if (retry.escalated) escalated += 1;
         }
       } catch (err) {
-        log2(`watch: pr #${prNumber} gated merge failed (${entry.mergeAttempts}/3): ${err.message}`);
+        const retry = await scheduleMergeRetry({
+          entry,
+          now,
+          reportBlocker,
+          taskId: entry.taskId,
+          prNumber,
+          error: err,
+          log: log2
+        });
+        if (retry.terminal) mergeBlocked += 1;
+        if (retry.escalated) escalated += 1;
       }
     } else if (action === "fix") {
       entry.fixAttempts = (entry.fixAttempts || 0) + 1;
@@ -11169,6 +11451,7 @@ async function runWatchCycleUnlocked({
       }
     } else {
       entry.lastCheckedAt = now();
+      if (await reportPendingMergeExhaustion({ entry, now, reportBlocker, taskId: entry.taskId, prNumber, log: log2 })) escalated += 1;
       const repairCapped = pr.ci === "failing" && ((entry.fixAttempts || 0) >= maxFixAttempts || entry.allowFixDispatch === false);
       if ((repairCapped || entry.continuationExhausted) && !entry.escalatedAt) {
         try {
@@ -11226,7 +11509,7 @@ function makeWatchRunner({
       repairChainMax,
       repairBudgetUsd
     });
-    if (adopted > 0) log2(`watch: adopted ${adopted} open task PR(s) from the control plane`);
+    if (adopted > 0) log2(`watch: adopted or reconciled ${adopted} open task PR(s) from the control plane`);
     return runWatchCycle({
       viewPr: watchView,
       enqueueFix: async ({ prNumber, repo, branch, headSha, failedChecks, failedCheckLinks, repairChain, operatorId }) => {
@@ -11268,13 +11551,10 @@ function makeWatchRunner({
         return result;
       },
       mergePr: (prNumber, entry) => {
-        const context = {
-          taskId: entry.taskId,
-          operatorId: entry.operatorId,
-          tenantId: entry.tenantId
-        };
-        const complete = Object.values(context).every((value) => typeof value === "string" && value.length > 0);
-        return client.mergeVerifiedPr(prNumber, complete ? context : void 0);
+        const authority = resolveWatcherMergeAuthority(entry);
+        if (authority.kind === "blocked")
+          return Promise.resolve({ status: "blocked", reason: authority.reason });
+        return client.mergeVerifiedPr(prNumber, authority.context);
       },
       log: log2,
       maxFixAttempts,
@@ -11291,7 +11571,6 @@ var init_pr_watcher = __esm({
     init_check_run_latest();
     init_ci_repair_evidence();
     init_pr_watcher_failure_confirmation();
-    init_superseded_pr_source();
     init_watcher_coordination();
     init_watcher_adoption();
     init_watcher_key();
@@ -11300,6 +11579,7 @@ var init_pr_watcher = __esm({
     init_pr_watcher_github();
     init_enqueue_autonomous_code_task();
     init_watcher_state();
+    init_watcher_merge_authority();
     init_superseded_pr_source();
     init_ci_fix_prompt();
     DEFAULT_STATE_FILE = join14(homedir9(), ".vo", "dispatched-prs.json");
@@ -11733,7 +12013,7 @@ var init_effort_mode_config = __esm({
 });
 
 // ../../scripts/virtual-office/model-registry.mjs
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import fs11 from "node:fs";
 import os4 from "node:os";
 import path18 from "node:path";
@@ -11744,7 +12024,7 @@ function userCacheRoot() {
     if (home) return path18.join(home, ".claude");
   } catch {
   }
-  return path18.join(os4.tmpdir(), `vo-model-registry-${randomUUID5()}`);
+  return path18.join(os4.tmpdir(), `vo-model-registry-${randomUUID6()}`);
 }
 function resolveCacheBaseDir(env2 = process.env, moduleDir = __dirname) {
   if (env2.VO_MODEL_REGISTRY_CACHE_DIR) return env2.VO_MODEL_REGISTRY_CACHE_DIR;
@@ -13110,9 +13390,16 @@ function makeSafeProgress(log2) {
 function runnerStagePatch(stage, message, extra = {}) {
   return { stage, message, ...extra };
 }
+function preservedReceiptLines(run, slicedBodyText) {
+  const full = `${String(run?.summary || "")}
+${String(run?.lastAgentMessage || "")}`;
+  const found = [...new Set((full.match(RECEIPT_LINE_RE) || []).map((line) => line.trim()))];
+  const missing = found.filter((line) => !String(slicedBodyText || "").includes(line));
+  return missing.length ? ["", "### Consensus evidence (preserved past truncation)", "", ...missing.map((line) => redactSecrets(line))] : [];
+}
 function buildPrBody(task, run, files, { armAutoMerge = false } = {}) {
   const governedStakes = matchGovernedStakes({ prompt: String(task.prompt || "") });
-  return [
+  const slicedSections = [
     "## AlgoHQ Command Center \u2014 Code-from-Anywhere task",
     "",
     `- **Task:** \`${task.code_task_id}\``,
@@ -13135,7 +13422,12 @@ function buildPrBody(task, run, files, { armAutoMerge = false } = {}) {
     "",
     // A budget/turn-capped run ends with no assistant text (summary = the bare
     // subtype); its LAST message is the honest report the operator needs.
-    ...run.lastAgentMessage ? ["### Last agent message before the cap", "", redactSecrets(String(run.lastAgentMessage)).slice(0, 2e3), ""] : [],
+    ...run.lastAgentMessage ? ["### Last agent message before the cap", "", redactSecrets(String(run.lastAgentMessage)).slice(0, 2e3), ""] : []
+  ];
+  return [
+    ...slicedSections,
+    // Receipt lines the slices dropped — the gate reads only this body.
+    ...preservedReceiptLines(run, slicedSections.join("\n")),
     "---",
     armAutoMerge ? "_Opened by the AlgoHQ code-runner daemon. After CI passes, the watcher must obtain a durable consensus receipt and merge the exact verified SHA._" : "_Opened by the AlgoHQ code-runner daemon. This PR awaits the verify-before-act gate / operator review \u2014 it is NOT auto-merged._"
   ].filter((l) => l !== "").join("\n");
@@ -13153,11 +13445,13 @@ async function mintRunnerGithubTokens({ client, taskId, log: log2, repo = null,
   if (!agentReadToken) log2(`task ${taskId}: no GitHub read access for the agent (${reason}); it cannot read a private repo`);
   return { publishToken, agentReadToken };
 }
+var RECEIPT_LINE_RE;
 var init_task_helpers = __esm({
   "../../scripts/virtual-office/code-runner/task-helpers.mjs"() {
     "use strict";
     init_redact_tokens();
     init_methodology_composer();
+    RECEIPT_LINE_RE = /receipt id:\s*[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/giu;
   }
 });
 
@@ -15022,7 +15316,7 @@ var init_detached_economics_spool = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/killed-run-outcome.mjs
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 async function handleKilledRun({
   client,
   id,
@@ -15059,7 +15353,7 @@ async function handleKilledRun({
     };
   }
   if (reason === "claim_authority_changed") {
-    const occurrenceId = randomUUID6();
+    const occurrenceId = randomUUID7();
     const economics = {
       occurrence_id: occurrenceId,
       runner_id: runnerId,
@@ -15359,7 +15653,7 @@ var code_runner_daemon_exports = {};
 __export(code_runner_daemon_exports, {
   main: () => main
 });
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 function log(msg) {
   console.log(`[code-runner ${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}`);
@@ -15592,7 +15886,7 @@ Closes #${publicationTarget.supersedesPrNumber}` : "";
 async function main({ 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 = randomUUID7();
+  const runnerInstanceId = randomUUID8();
   const client = createControlPlaneClient({
     env: env2,
     runnerId: cfg.runnerId,
@@ -15804,8 +16098,163 @@ var init_code_runner_daemon = __esm({
 import { createRequire as createRequire4 } from "node:module";
 
 // src/runner-readiness.mjs
-function failed({ paired = false, operatorId = null, tenantId = null, githubReady = null, error, message }) {
-  return { ok: false, paired, operatorId, tenantId, githubReady, error, message };
+import { createHash, randomUUID } from "node:crypto";
+var RUNNER_GITHUB_READINESS_TIMEOUT_MS = 5e4;
+var RUNNER_IDENTITY_READINESS_TIMEOUT_MS = 1e4;
+var RUNNER_READINESS_MAX_REPOSITORIES = 4;
+var RUNNER_READINESS_MAX_TIMER_DELAY_MS = 2147e6;
+var RUNNER_READINESS_TRANSIENT_MAX_RETRY_AFTER_MS = 3e5;
+var RUNNER_READINESS_IPC_ACK_TIMEOUT_MS = 5e3;
+var RUNNER_READINESS_DEFERRAL_MESSAGE_TYPE = "vo-runner-readiness-deferred-v1";
+var RUNNER_READINESS_DEFERRAL_ACK_TYPE = "vo-runner-readiness-deferred-ack-v1";
+var RUNNER_REPOSITORY = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/u;
+function runnerRepositoryScopeFromEnv(env2 = {}) {
+  return String(env2.VO_CODE_RUNNER_REPOS || "").split(/[\s,]+/u).map((repo) => repo.trim()).filter(Boolean);
+}
+function normalizeRunnerRepositoryScope(repositories) {
+  if (!Array.isArray(repositories) || repositories.length < 1) {
+    throw new Error("VO_CODE_RUNNER_REPOS must name at least one owner/name repository");
+  }
+  if (repositories.length > RUNNER_READINESS_MAX_REPOSITORIES) {
+    throw new Error(`VO_CODE_RUNNER_REPOS supports at most ${RUNNER_READINESS_MAX_REPOSITORIES} repositories`);
+  }
+  const normalized = repositories.map((repo) => {
+    const [owner, name] = typeof repo === "string" ? repo.split("/") : [];
+    if (typeof repo !== "string" || repo.length > 140 || !RUNNER_REPOSITORY.test(repo) || owner === "." || owner === ".." || name === "." || name === "..") {
+      throw new Error("VO_CODE_RUNNER_REPOS entries must be canonical owner/name repositories");
+    }
+    return repo.toLowerCase();
+  });
+  if (new Set(normalized).size !== normalized.length) {
+    throw new Error("VO_CODE_RUNNER_REPOS entries must be unique");
+  }
+  const owners = new Set(normalized.map((repo) => repo.split("/")[0]));
+  if (owners.size !== 1) {
+    throw new Error("VO_CODE_RUNNER_REPOS entries must share one owner");
+  }
+  return Object.freeze(normalized.sort());
+}
+function runnerRepositoryScopeDigest(repositories) {
+  const scope = normalizeRunnerRepositoryScope(repositories);
+  return createHash("sha256").update(JSON.stringify({
+    version: 1,
+    repositories: scope
+  }), "utf8").digest("hex");
+}
+function runnerReadinessRetryDelayMs(readiness) {
+  if (readiness?.paired !== true || readiness?.githubReady !== false) return null;
+  if (Number.isFinite(readiness.retryAfterMs) && readiness.retryAfterMs > 0) {
+    return Math.ceil(readiness.retryAfterMs);
+  }
+  return null;
+}
+function runnerReadinessFailureDisposition(readiness, delivery = null) {
+  const retryAfterMs = runnerReadinessRetryDelayMs(readiness);
+  if (retryAfterMs === null) {
+    return Object.freeze({ action: "exit", exitCode: 1, retryAfterMs: null });
+  }
+  if (delivery?.attempted === true) {
+    return Object.freeze({
+      action: "exit",
+      exitCode: delivery.delivered === true ? 75 : 1,
+      retryAfterMs
+    });
+  }
+  return Object.freeze({ action: "wait", exitCode: null, retryAfterMs });
+}
+async function notifySupervisorReadinessDeferral({
+  processLike,
+  retryAfterMs,
+  error = null,
+  ackTimeoutMs = RUNNER_READINESS_IPC_ACK_TIMEOUT_MS
+}) {
+  if (processLike?.connected !== true || typeof processLike.send !== "function") {
+    return Object.freeze({ attempted: false, delivered: false });
+  }
+  if (typeof processLike.on !== "function" || typeof processLike.off !== "function") {
+    return Object.freeze({ attempted: true, delivered: false });
+  }
+  const nonce = randomUUID();
+  const delivered = await new Promise((resolve3) => {
+    let settled = false;
+    const onMessage = (message) => {
+      if (message?.type === RUNNER_READINESS_DEFERRAL_ACK_TYPE && message.nonce === nonce) {
+        finish(true);
+      }
+    };
+    const onDisconnect = () => finish(false);
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      processLike.off("message", onMessage);
+      processLike.off("disconnect", onDisconnect);
+      resolve3(value);
+    };
+    const timer = setTimeout(() => finish(false), ackTimeoutMs);
+    processLike.on("message", onMessage);
+    processLike.on("disconnect", onDisconnect);
+    try {
+      processLike.send({
+        type: RUNNER_READINESS_DEFERRAL_MESSAGE_TYPE,
+        nonce,
+        retryAfterMs,
+        error
+      }, (sendError) => {
+        if (sendError) finish(false);
+      });
+    } catch {
+      finish(false);
+    }
+  });
+  return Object.freeze({ attempted: true, delivered });
+}
+async function waitForRunnerReadinessRetry(delayMs, {
+  nowMs = () => Date.now(),
+  wait: wait3 = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms))
+} = {}) {
+  if (!Number.isFinite(delayMs) || delayMs <= 0) {
+    throw new TypeError("runner readiness retry delay is invalid");
+  }
+  const deadline = nowMs() + Math.ceil(delayMs);
+  while (nowMs() < deadline) {
+    await wait3(Math.min(RUNNER_READINESS_MAX_TIMER_DELAY_MS, deadline - nowMs()));
+  }
+}
+function failed({
+  paired = false,
+  operatorId = null,
+  tenantId = null,
+  githubReady = null,
+  retryAfterMs = null,
+  error,
+  message
+}) {
+  return {
+    ok: false,
+    paired,
+    operatorId,
+    tenantId,
+    githubReady,
+    ...Number.isFinite(retryAfterMs) && retryAfterMs > 0 ? { retryAfterMs } : {},
+    error,
+    message
+  };
+}
+function responseRetryAfterMs(response, body) {
+  const transientReadinessFailure = response.status === 503 && body?.error === "github_installation_readiness_retryable";
+  if (response.status !== 429 && !transientReadinessFailure) return null;
+  const bound = (retryAfterMs) => transientReadinessFailure ? Math.min(RUNNER_READINESS_TRANSIENT_MAX_RETRY_AFTER_MS, retryAfterMs) : retryAfterMs;
+  const value = response.headers?.get?.("retry-after")?.trim() ?? "";
+  const seconds = Number(value);
+  if (value && Number.isFinite(seconds) && seconds >= 0) {
+    return bound(Math.max(1e3, Math.ceil(seconds * 1e3)));
+  }
+  const at = value ? Date.parse(value) : Number.NaN;
+  if (Number.isFinite(at)) {
+    return bound(Math.max(1e3, Math.ceil(at - Date.now())));
+  }
+  return bound(6e4);
 }
 async function responseBody(response) {
   try {
@@ -15818,11 +16267,21 @@ async function responseBody(response) {
 function serverMessage(body, fallback) {
   return typeof body.message === "string" && body.message.trim() ? body.message.trim() : fallback;
 }
-async function fetchWithTimeout(fetchImpl, url, init, timeoutMs) {
+async function fetchJsonWithTimeout(fetchImpl, url, init, timeoutMs) {
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      reject(new Error(`request aborted after ${timeoutMs}ms`));
+    }, timeoutMs);
+  });
   try {
-    return await fetchImpl(url, { ...init, signal: controller.signal });
+    const requestAndBody = (async () => {
+      const response = await fetchImpl(url, { ...init, signal: controller.signal });
+      return { response, body: await responseBody(response) };
+    })();
+    return await Promise.race([requestAndBody, timeout]);
   } finally {
     clearTimeout(timer);
   }
@@ -15832,18 +16291,24 @@ async function probeRunnerReadiness({
   token: token2,
   fetchImpl = fetch,
   requireGithub = false,
-  timeoutMs = 1e4
+  repositories = [],
+  timeoutMs = RUNNER_IDENTITY_READINESS_TIMEOUT_MS,
+  // The server performs at most five sequential App-JWT GETs (installation plus
+  // every one of at most four configured repositories), each bounded at 8s.
+  // Keep a transport margin while preventing a stuck proof from hanging startup.
+  githubTimeoutMs = RUNNER_GITHUB_READINESS_TIMEOUT_MS
 }) {
   const base = controlPlaneUrl2.replace(/\/+$/u, "");
   const headers = { authorization: `Bearer ${token2}` };
   let identityResponse;
+  let identity;
   try {
-    identityResponse = await fetchWithTimeout(
+    ({ response: identityResponse, body: identity } = await fetchJsonWithTimeout(
       fetchImpl,
       `${base}/api/v1/auth/me`,
       { headers },
       timeoutMs
-    );
+    ));
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
     return failed({
@@ -15851,7 +16316,6 @@ async function probeRunnerReadiness({
       message: `AlgoHQ could not be reached: ${detail}`
     });
   }
-  const identity = await responseBody(identityResponse);
   if (!identityResponse.ok) {
     return failed({
       error: "credential_rejected",
@@ -15877,18 +16341,33 @@ async function probeRunnerReadiness({
       message: "Paired to AlgoHQ."
     };
   }
+  let repositoryScope = null;
+  try {
+    if (!Array.isArray(repositories)) {
+      throw new Error("VO_CODE_RUNNER_REPOS must be a repository array");
+    }
+    if (repositories.length > 0) repositoryScope = normalizeRunnerRepositoryScope(repositories);
+  } catch (error) {
+    return failed({
+      paired: true,
+      operatorId,
+      tenantId,
+      githubReady: false,
+      error: "github_repository_scope_invalid",
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
   let githubResponse;
+  let github;
   try {
-    githubResponse = await fetchWithTimeout(
+    const readinessUrl = new URL(`${base}/api/v1/github/installation-readiness`);
+    for (const repo of repositoryScope ?? []) readinessUrl.searchParams.append("repo", repo);
+    ({ response: githubResponse, body: github } = await fetchJsonWithTimeout(
       fetchImpl,
-      `${base}/api/v1/github/installation-token`,
-      {
-        method: "POST",
-        headers: { ...headers, "content-type": "application/json" },
-        body: "{}"
-      },
-      timeoutMs
-    );
+      readinessUrl.toString(),
+      { headers },
+      githubTimeoutMs
+    ));
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
     return failed({
@@ -15900,14 +16379,25 @@ async function probeRunnerReadiness({
       message: `GitHub publication readiness could not be checked: ${detail}`
     });
   }
-  const github = await responseBody(githubResponse);
-  if (!githubResponse.ok || typeof github.token !== "string" || !github.token) {
+  const repositorySelection = github.repository_selection;
+  const repositoriesVerified = github.repositories_verified;
+  const returnedScope = github.repository_scope;
+  let normalizedReturnedScope = null;
+  try {
+    normalizedReturnedScope = normalizeRunnerRepositoryScope(returnedScope);
+  } catch {
+  }
+  const effectiveScope = repositoryScope ?? normalizedReturnedScope;
+  const sourceVerified = repositoryScope === null ? github.repository_scope_source === "persisted_installation_singleton" && normalizedReturnedScope?.length === 1 : github.repository_scope_source === "runner_config";
+  const repositoryScopeVerified = effectiveScope !== null && normalizedReturnedScope !== null && Array.isArray(returnedScope) && returnedScope.length === normalizedReturnedScope.length && returnedScope.every((repo, index) => repo === normalizedReturnedScope[index]) && normalizedReturnedScope.length === effectiveScope.length && normalizedReturnedScope.every((repo, index) => repo === effectiveScope[index]) && github.repository_scope_sha256 === runnerRepositoryScopeDigest(effectiveScope) && repositoriesVerified === effectiveScope.length && sourceVerified && (repositorySelection === "all" || repositorySelection === "selected");
+  if (!githubResponse.ok || github.configured !== true || github.verified !== true || github.publication_ready !== true || !repositoryScopeVerified) {
     const error = typeof github.error === "string" && github.error ? github.error : "github_not_ready";
     return failed({
       paired: true,
       operatorId,
       tenantId,
       githubReady: false,
+      retryAfterMs: responseRetryAfterMs(githubResponse, github),
       error,
       message: serverMessage(github, `GitHub publication preflight failed (HTTP ${githubResponse.status}).`)
     });
@@ -15918,8 +16408,10 @@ async function probeRunnerReadiness({
     operatorId,
     tenantId,
     githubReady: true,
+    repositoryScope: effectiveScope,
+    repositoryScopeSource: github.repository_scope_source,
     error: null,
-    message: "Paired and ready to publish through the Algosuite GitHub App."
+    message: `Paired with a verified Algosuite GitHub App installation (${repositoriesVerified} repos).`
   };
 }
 function pairedOperatorScope(readiness) {
@@ -15930,7 +16422,7 @@ function pairedOperatorScope(readiness) {
 import { closeSync, existsSync, mkdirSync, openSync, unlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import { posix, win32 } from "node:path";
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 var APP_IDENTIFIER = "ai.algosuite.vo-runner";
 var CLONES_DIR = "clones";
 function pathsFor(platform4) {
@@ -16000,7 +16492,7 @@ function runnerWorkingDirectory({ repoRoot: repoRoot2, clonesRoot: clonesRoot2 }
 }
 function assertWritableRunnerDirectory(root) {
   mkdirSync(root, { recursive: true });
-  const probe = pathsFor(process.platform).join(root, `.vo-runner-write-probe-${process.pid}-${randomUUID()}`);
+  const probe = pathsFor(process.platform).join(root, `.vo-runner-write-probe-${process.pid}-${randomUUID2()}`);
   let handle;
   try {
     handle = openSync(probe, "wx", 384);
@@ -16120,21 +16612,51 @@ if (!token) {
 }
 var controlPlaneUrl = process.env.VO_CONTROL_PLANE_URL || DEFAULT_CONTROL_PLANE_URL3;
 var pairedOperatorId = null;
-if (!explicitAdminToken) {
-  const readiness = await probeRunnerReadiness({
-    controlPlaneUrl,
-    token,
-    requireGithub: true
+async function deferRunnerReadinessRetry(readiness) {
+  const initial = runnerReadinessFailureDisposition(readiness);
+  if (initial.action === "exit") return initial;
+  const { retryAfterMs } = initial;
+  console.error(
+    `[vo-mcp runner] GitHub readiness is temporarily unavailable; retrying after ${retryAfterMs}ms: ${readiness.message}`
+  );
+  const delivery = await notifySupervisorReadinessDeferral({
+    processLike: process,
+    retryAfterMs,
+    error: readiness.error
   });
-  if (!readiness.ok) {
-    console.error(`[vo-mcp runner] Readiness check failed: ${readiness.message}`);
-    process.exit(1);
+  if (delivery.attempted) {
+    const disposition = runnerReadinessFailureDisposition(readiness, delivery);
+    if (disposition.exitCode === 1) {
+      console.error("[vo-mcp runner] Supervisor readiness deferral could not be delivered; failing closed.");
+    }
+    return disposition;
+  }
+  await waitForRunnerReadinessRetry(retryAfterMs);
+  return Object.freeze({ action: "retry", exitCode: null, retryAfterMs });
+}
+if (!explicitAdminToken) {
+  let readiness;
+  while (true) {
+    readiness = await probeRunnerReadiness({
+      controlPlaneUrl,
+      token,
+      requireGithub: true,
+      repositories: runnerRepositoryScopeFromEnv(process.env)
+    });
+    if (readiness.ok) break;
+    const disposition = await deferRunnerReadinessRetry(readiness);
+    if (disposition.action === "retry") continue;
+    if (disposition.retryAfterMs === null) {
+      console.error(`[vo-mcp runner] Readiness check failed: ${readiness.message}`);
+    }
+    process.exit(disposition.exitCode);
   }
   pairedOperatorId = pairedOperatorScope(readiness);
   if (!pairedOperatorId) {
     console.error("[vo-mcp runner] Readiness check failed: paired operator scope is missing. Pair this computer again.");
     process.exit(1);
   }
+  process.env.VO_CODE_RUNNER_REPOS = readiness.repositoryScope.join(",");
 }
 var rootConfig;
 try {