@algosuite/vo-mcp 0.2.0-beta.56 → 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
@@ -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 = {}) {
@@ -8666,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";
@@ -8690,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 };
 }
@@ -8766,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);
@@ -8797,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) {
@@ -10521,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(),
@@ -10529,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;
@@ -10659,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) {
@@ -10679,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");
@@ -11157,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;
@@ -11176,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,
@@ -12010,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";
@@ -12021,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;
@@ -15313,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,
@@ -15350,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,
@@ -15650,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}`);
@@ -15883,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,
@@ -16095,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 {
@@ -16109,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);
   }
@@ -16123,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({
@@ -16142,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",
@@ -16168,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({
@@ -16191,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}).`)
     });
@@ -16209,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) {
@@ -16221,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) {
@@ -16291,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);
@@ -16411,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 {