@gethmy/harness 1.2.1 → 1.3.0

package/dist/index.js

@@ -118,6 +118,9 @@ var init_branchRef = __esm(() => {
 
 // ../harmony-shared/dist/cardLinks.js
 var init_cardLinks = () => {};
+
+// ../harmony-shared/dist/cardModelStat.js
+var init_cardModelStat = () => {};
 // ../harmony-shared/dist/classification.js
 function tierFromScore(score) {
   const s = Math.max(0, Math.min(10, Math.round(score)));
@@ -476,7 +479,8 @@ var init_gateEvaluate = __esm(() => {
     "artifact",
     "label",
     "custom",
-    "oracle_passed"
+    "oracle_passed",
+    "oracle_red"
   ];
   GATE_OPERATORS = [
     "eq",
@@ -579,6 +583,7 @@ var init_dist = __esm(() => {
   init_agentStaleness();
   init_branchRef();
   init_cardLinks();
+  init_cardModelStat();
   init_classification();
   init_columnCardSplit();
   init_columnSort();
@@ -602,11 +607,14 @@ var exports_git_pr = {};
 __export(exports_git_pr, {
   validateGitProviderCli: () => validateGitProviderCli,
   upsertReviewedSha: () => upsertReviewedSha,
+  upsertCiReviewRequestedSha: () => upsertCiReviewRequestedSha,
   updateExistingPr: () => updateExistingPr,
   resolvePrUrl: () => resolvePrUrl,
   resolvePrHeadBranch: () => resolvePrHeadBranch,
+  requestIndependentReview: () => requestIndependentReview,
   renameRemoteBranch: () => renameRemoteBranch,
   remoteBranchExists: () => remoteBranchExists,
+  readPrChecks: () => readPrChecks,
   pushBranch: () => pushBranch,
   mergePullRequest: () => mergePullRequest,
   getPrStatus: () => getPrStatus,
@@ -615,25 +623,28 @@ __export(exports_git_pr, {
   findExistingPr: () => findExistingPr,
   extractReviewedSha: () => extractReviewedSha,
   extractPrUrl: () => extractPrUrl,
+  extractCiReviewRequestedSha: () => extractCiReviewRequestedSha,
   extractAzurePrId: () => extractAzurePrId,
   detectGitProvider: () => detectGitProvider,
+  deriveReviewVerdictState: () => deriveReviewVerdictState,
+  deriveIndependentReviewState: () => deriveIndependentReviewState,
   deriveCiStatus: () => deriveCiStatus,
   decidePrBranch: () => decidePrBranch,
   createPullRequest: () => createPullRequest,
   checkPrMergeStatus: () => checkPrMergeStatus,
   buildPrBody: () => buildPrBody
 });
-import { execFile, execFileSync as execFileSync6 } from "node:child_process";
-import { promisify } from "node:util";
-function createExecFileAsync() {
-  return promisify(execFile);
+import { execFile as execFile2, execFileSync as execFileSync7 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+function createExecFileAsync2() {
+  return promisify2(execFile2);
 }
-function execFileAsync() {
-  return cachedExecFileAsync ??= createExecFileAsync();
+function execFileAsync2() {
+  return cachedExecFileAsync2 ??= createExecFileAsync2();
 }
 function detectGitProvider(cwd) {
   try {
-    const url = execFileSync6("git", ["remote", "get-url", "origin"], {
+    const url = execFileSync7("git", ["remote", "get-url", "origin"], {
       cwd,
       encoding: "utf-8"
     }).trim();
@@ -654,7 +665,7 @@ function validateGitProviderCli(provider, cwd) {
   switch (provider) {
     case "github": {
       try {
-        execFileSync6("gh", ["auth", "status"], { cwd, stdio: "pipe" });
+        execFileSync7("gh", ["auth", "status"], { cwd, stdio: "pipe" });
       } catch {
         throw new Error("GitHub CLI (gh) is not authenticated. Run: gh auth login");
       }
@@ -662,12 +673,12 @@ function validateGitProviderCli(provider, cwd) {
     }
     case "azure": {
       try {
-        execFileSync6("az", ["--version"], { cwd, stdio: "pipe" });
+        execFileSync7("az", ["--version"], { cwd, stdio: "pipe" });
       } catch {
         throw new Error("Azure CLI (az) not found. Install it: https://learn.microsoft.com/en-us/cli/azure/install-azure-cli");
       }
       try {
-        execFileSync6("az", ["account", "show"], { cwd, stdio: "pipe" });
+        execFileSync7("az", ["account", "show"], { cwd, stdio: "pipe" });
       } catch {
         throw new Error("Azure CLI is not authenticated. Run: az login");
       }
@@ -675,7 +686,7 @@ function validateGitProviderCli(provider, cwd) {
     }
     case "gitlab": {
       try {
-        execFileSync6("glab", ["auth", "status"], { cwd, stdio: "pipe" });
+        execFileSync7("glab", ["auth", "status"], { cwd, stdio: "pipe" });
       } catch {
         throw new Error("GitLab CLI (glab) is not installed or not authenticated. Install: https://gitlab.com/gitlab-org/cli — then run: glab auth login");
       }
@@ -683,7 +694,7 @@ function validateGitProviderCli(provider, cwd) {
     }
     case "bitbucket":
     case "unknown":
-      log.warn(TAG11, `Git provider "${provider}" — PR creation will be skipped (no CLI support)`);
+      log.warn(TAG13, `Git provider "${provider}" — PR creation will be skipped (no CLI support)`);
       break;
   }
 }
@@ -701,18 +712,51 @@ function upsertReviewedSha(description, sha) {
   if (REVIEWED_SHA_RE.test(description)) {
     return description.replace(REVIEWED_SHA_RE, line);
   }
-  const sep2 = description ? `
+  const sep3 = description ? `
+` : "";
+  return `${description}${sep3}${line}`;
+}
+function extractCiReviewRequestedSha(description) {
+  if (!description)
+    return null;
+  const m = description.match(CI_REVIEW_REQUESTED_SHA_RE);
+  return m ? m[1] : null;
+}
+function upsertCiReviewRequestedSha(description, sha) {
+  const line = `CI-Review-Requested-SHA: ${sha}`;
+  if (CI_REVIEW_REQUESTED_SHA_RE.test(description)) {
+    return description.replace(CI_REVIEW_REQUESTED_SHA_RE, line);
+  }
+  const sep3 = description ? `
 ` : "";
-  return `${description}${sep2}${line}`;
+  return `${description}${sep3}${line}`;
+}
+function checkMatchesName(c, wanted) {
+  if (!wanted)
+    return false;
+  const name = typeof c.name === "string" ? c.name.toLowerCase() : "";
+  const workflow = typeof c.workflowName === "string" ? c.workflowName.toLowerCase() : "";
+  return name === wanted || workflow === wanted;
+}
+function isNamedCheck(c, skip) {
+  if (!skip)
+    return false;
+  const wanted = skip.trim().toLowerCase();
+  if (!wanted)
+    return false;
+  return typeof c.name === "string" && c.name.toLowerCase() === wanted;
 }
-function deriveCiStatus(rollup) {
+function deriveCiStatus(rollup, excludeChecks = []) {
   if (!Array.isArray(rollup) || rollup.length === 0)
     return "unknown";
+  const excluded = excludeChecks.map((n) => n.trim().toLowerCase()).filter(Boolean);
   let anyPending = false;
   for (const check of rollup) {
     if (typeof check !== "object" || check === null)
       continue;
     const c = check;
+    if (excluded.some((name) => checkMatchesName(c, name)))
+      continue;
     if (typeof c.status === "string") {
       if (c.status.toUpperCase() !== "COMPLETED") {
         anyPending = true;
@@ -736,18 +780,152 @@ function deriveCiStatus(rollup) {
   }
   return anyPending ? "pending" : "success";
 }
-async function getPrStatus(prUrl, cwd, provider) {
-  if (provider !== "github" || !isValidPrUrl(prUrl)) {
-    return { ciStatus: "unknown", headSha: null };
+function deriveIndependentReviewState(rollup, checkName, skipCheckName) {
+  if (!Array.isArray(rollup))
+    return "absent";
+  const wanted = checkName.trim().toLowerCase();
+  if (!wanted)
+    return "absent";
+  let sawPending = false;
+  let sawFailed = false;
+  let sawSkipped = false;
+  for (const check of rollup) {
+    if (typeof check !== "object" || check === null)
+      continue;
+    const c = check;
+    if (isNamedCheck(c, skipCheckName))
+      continue;
+    if (!checkMatchesName(c, wanted))
+      continue;
+    if (typeof c.status === "string") {
+      if (c.status.toUpperCase() !== "COMPLETED") {
+        sawPending = true;
+        continue;
+      }
+      const conclusion = typeof c.conclusion === "string" ? c.conclusion.toUpperCase() : "";
+      if (conclusion === "SKIPPED") {
+        sawSkipped = true;
+        continue;
+      }
+      if (conclusion === "SUCCESS" || conclusion === "NEUTRAL")
+        return "passed";
+      sawFailed = true;
+      continue;
+    }
+    if (typeof c.state === "string") {
+      const state = c.state.toUpperCase();
+      if (state === "SUCCESS")
+        return "passed";
+      if (state === "PENDING") {
+        sawPending = true;
+        continue;
+      }
+      sawFailed = true;
+    }
+  }
+  if (sawPending)
+    return "pending";
+  if (sawFailed)
+    return "failed";
+  if (sawSkipped)
+    return "skipped";
+  return "absent";
+}
+function deriveReviewVerdictState(rollup, checkName, skipCheckName) {
+  if (!Array.isArray(rollup))
+    return "absent";
+  const wanted = checkName.trim().toLowerCase();
+  if (!wanted)
+    return "absent";
+  let sawPending = false;
+  let sawUnknown = false;
+  let sawClean = false;
+  for (const check of rollup) {
+    if (typeof check !== "object" || check === null)
+      continue;
+    const c = check;
+    if (isNamedCheck(c, skipCheckName))
+      continue;
+    if (!checkMatchesName(c, wanted))
+      continue;
+    if (typeof c.status === "string") {
+      if (c.status.toUpperCase() !== "COMPLETED") {
+        sawPending = true;
+        continue;
+      }
+      const conclusion = typeof c.conclusion === "string" ? c.conclusion.toUpperCase() : "";
+      if (conclusion === "SUCCESS") {
+        sawClean = true;
+        continue;
+      }
+      if (conclusion === "NEUTRAL" || conclusion === "SKIPPED") {
+        sawUnknown = true;
+        continue;
+      }
+      return "blocking";
+    }
+    if (typeof c.state === "string") {
+      const state = c.state.toUpperCase();
+      if (state === "SUCCESS") {
+        sawClean = true;
+        continue;
+      }
+      if (state === "PENDING") {
+        sawPending = true;
+        continue;
+      }
+      return "blocking";
+    }
   }
+  if (sawPending)
+    return "pending";
+  if (sawUnknown)
+    return "unknown";
+  if (sawClean)
+    return "clean";
+  return "absent";
+}
+function readPrChecks(rollup, checks = {}) {
+  const { independentReviewCheck, reviewVerdictCheck } = checks;
+  return {
+    ciStatus: deriveCiStatus(rollup, [independentReviewCheck, reviewVerdictCheck].filter((n) => typeof n === "string")),
+    independentReview: independentReviewCheck ? deriveIndependentReviewState(rollup, independentReviewCheck, reviewVerdictCheck) : "absent",
+    reviewVerdict: reviewVerdictCheck ? deriveReviewVerdictState(rollup, reviewVerdictCheck, independentReviewCheck) : "absent"
+  };
+}
+async function getPrStatus(prUrl, cwd, provider, independentReviewCheck, reviewVerdictCheck) {
+  const unreadable = {
+    ciStatus: "unknown",
+    headSha: null,
+    independentReview: "absent",
+    reviewVerdict: "absent"
+  };
+  if (provider !== "github" || !isValidPrUrl(prUrl))
+    return { ...unreadable };
   try {
-    const { stdout } = await execFileAsync()("gh", ["pr", "view", prUrl, "--json", "statusCheckRollup,headRefOid"], { cwd, encoding: "utf-8", timeout: 1e4 });
+    const { stdout } = await execFileAsync2()("gh", ["pr", "view", prUrl, "--json", "statusCheckRollup,headRefOid"], { cwd, encoding: "utf-8", timeout: 1e4 });
     const parsed = JSON.parse(stdout.trim());
     const headSha = typeof parsed.headRefOid === "string" ? parsed.headRefOid : null;
-    return { ciStatus: deriveCiStatus(parsed.statusCheckRollup), headSha };
+    return {
+      ...readPrChecks(parsed.statusCheckRollup, {
+        independentReviewCheck,
+        reviewVerdictCheck
+      }),
+      headSha
+    };
   } catch {
-    return { ciStatus: "unknown", headSha: null };
+    return { ...unreadable };
+  }
+}
+async function requestIndependentReview(prUrl, cwd, provider, label) {
+  if (provider !== "github") {
+    throw new Error(`independent review request unsupported for "${provider}"`);
   }
+  const opts = { cwd, encoding: "utf-8", timeout: 30000 };
+  try {
+    await execFileAsync2()("gh", ["pr", "edit", prUrl, "--remove-label", label], opts);
+  } catch {}
+  await execFileAsync2()("gh", ["pr", "edit", prUrl, "--add-label", label], opts);
 }
 async function mergePullRequest(prUrl, cwd, provider, strategy, deleteBranch) {
   if (provider !== "github") {
@@ -756,7 +934,7 @@ async function mergePullRequest(prUrl, cwd, provider, strategy, deleteBranch) {
   const args = ["pr", "merge", prUrl, `--${strategy}`];
   if (deleteBranch)
     args.push("--delete-branch");
-  await execFileAsync()("gh", args, {
+  await execFileAsync2()("gh", args, {
     cwd,
     encoding: "utf-8",
     timeout: 30000
@@ -764,7 +942,7 @@ async function mergePullRequest(prUrl, cwd, provider, strategy, deleteBranch) {
 }
 function getHeadSha(cwd) {
   try {
-    return execFileSync6("git", ["rev-parse", "HEAD"], {
+    return execFileSync7("git", ["rev-parse", "HEAD"], {
       cwd,
       encoding: "utf-8"
     }).trim();
@@ -778,7 +956,7 @@ async function checkPrMergeStatus(prUrl, cwd, provider) {
   try {
     switch (provider) {
       case "github": {
-        const { stdout } = await execFileAsync()("gh", ["pr", "view", prUrl, "--json", "state", "--jq", ".state"], { cwd, encoding: "utf-8", timeout: 1e4 });
+        const { stdout } = await execFileAsync2()("gh", ["pr", "view", prUrl, "--json", "state", "--jq", ".state"], { cwd, encoding: "utf-8", timeout: 1e4 });
         switch (stdout.trim()) {
           case "MERGED":
             return "merged";
@@ -794,12 +972,12 @@ async function checkPrMergeStatus(prUrl, cwd, provider) {
         const mrMatch = prUrl.match(/merge_requests\/(\d+)/);
         if (!mrMatch)
           return "unknown";
-        const { stdout } = await execFileAsync()("glab", ["mr", "view", mrMatch[1], "--output", "json"], { cwd, encoding: "utf-8", timeout: 1e4 });
+        const { stdout } = await execFileAsync2()("glab", ["mr", "view", mrMatch[1], "--output", "json"], { cwd, encoding: "utf-8", timeout: 1e4 });
         let parsed;
         try {
           parsed = JSON.parse(stdout.trim());
         } catch {
-          log.warn(TAG11, `Failed to parse glab JSON output for MR ${mrMatch[1]}`);
+          log.warn(TAG13, `Failed to parse glab JSON output for MR ${mrMatch[1]}`);
           return "unknown";
         }
         if (typeof parsed !== "object" || parsed === null)
@@ -894,10 +1072,10 @@ function extractAzurePrId(prUrl) {
 async function resolvePrHeadBranch(prUrl, cwd, provider) {
   if (provider === "github") {
     try {
-      const { stdout } = await execFileAsync()("gh", ["pr", "view", prUrl, "--json", "headRefName,isCrossRepository"], { cwd, encoding: "utf-8", timeout: 1e4 });
+      const { stdout } = await execFileAsync2()("gh", ["pr", "view", prUrl, "--json", "headRefName,isCrossRepository"], { cwd, encoding: "utf-8", timeout: 1e4 });
       return decidePrBranch("github", stdout);
     } catch (err) {
-      log.warn(TAG11, `gh pr view failed for ${prUrl}: ${err instanceof Error ? err.message : String(err)}`);
+      log.warn(TAG13, `gh pr view failed for ${prUrl}: ${err instanceof Error ? err.message : String(err)}`);
       return decidePrBranch("github", null);
     }
   }
@@ -910,10 +1088,10 @@ async function resolvePrHeadBranch(prUrl, cwd, provider) {
       };
     }
     try {
-      const { stdout } = await execFileAsync()("az", ["repos", "pr", "show", "--id", prId, "--output", "json"], { cwd, encoding: "utf-8", timeout: 1e4 });
+      const { stdout } = await execFileAsync2()("az", ["repos", "pr", "show", "--id", prId, "--output", "json"], { cwd, encoding: "utf-8", timeout: 1e4 });
       return decidePrBranch("azure", stdout);
     } catch (err) {
-      log.warn(TAG11, `az repos pr show failed for ${prUrl}: ${err instanceof Error ? err.message : String(err)}`);
+      log.warn(TAG13, `az repos pr show failed for ${prUrl}: ${err instanceof Error ? err.message : String(err)}`);
       return decidePrBranch("azure", null);
     }
   }
@@ -941,7 +1119,7 @@ function resolvePrUrl(description, branchName, cwd, provider) {
 }
 function remoteBranchExists(branchName, cwd) {
   try {
-    execFileSync6("git", ["ls-remote", "--exit-code", "origin", `refs/heads/${branchName}`], { cwd, stdio: "pipe" });
+    execFileSync7("git", ["ls-remote", "--exit-code", "origin", `refs/heads/${branchName}`], { cwd, stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -949,24 +1127,24 @@ function remoteBranchExists(branchName, cwd) {
 }
 function pushBranch(branchName, cwd) {
   if (remoteBranchExists(branchName, cwd)) {
-    log.info(TAG11, `Remote branch ${branchName} exists (rework), force-pushing`);
+    log.info(TAG13, `Remote branch ${branchName} exists (rework), force-pushing`);
     let expectedSha = null;
     try {
-      execFileSync6("git", ["fetch", "origin", branchName], {
+      execFileSync7("git", ["fetch", "origin", branchName], {
         cwd,
         stdio: "pipe"
       });
-      expectedSha = execFileSync6("git", ["rev-parse", `refs/remotes/origin/${branchName}`], { cwd, encoding: "utf-8" }).trim();
+      expectedSha = execFileSync7("git", ["rev-parse", `refs/remotes/origin/${branchName}`], { cwd, encoding: "utf-8" }).trim();
     } catch (err) {
-      log.warn(TAG11, `could not resolve remote tip for ${branchName}, falling back to weak lease: ${err instanceof Error ? err.message : err}`);
+      log.warn(TAG13, `could not resolve remote tip for ${branchName}, falling back to weak lease: ${err instanceof Error ? err.message : err}`);
     }
     const lease = expectedSha ? `--force-with-lease=refs/heads/${branchName}:${expectedSha}` : "--force-with-lease";
-    execFileSync6("git", ["push", lease, "-u", "origin", branchName], {
+    execFileSync7("git", ["push", lease, "-u", "origin", branchName], {
       cwd,
       stdio: "pipe"
     });
   } else {
-    execFileSync6("git", ["push", "-u", "origin", branchName], {
+    execFileSync7("git", ["push", "-u", "origin", branchName], {
       cwd,
       stdio: "pipe"
     });
@@ -977,25 +1155,25 @@ function renameRemoteBranch(oldRef, newRef, cwd) {
     return;
   let sha;
   try {
-    sha = execFileSync6("git", ["rev-parse", "HEAD"], {
+    sha = execFileSync7("git", ["rev-parse", "HEAD"], {
       cwd,
       encoding: "utf-8"
     }).trim();
   } catch (err) {
     throw new Error(`renameRemoteBranch: could not resolve HEAD: ${err instanceof Error ? err.message : err}`);
   }
-  log.info(TAG11, `Renaming remote ${oldRef} → ${newRef}`);
-  execFileSync6("git", ["push", "origin", `${sha}:refs/heads/${newRef}`, "--force-with-lease"], { cwd, stdio: "pipe" });
+  log.info(TAG13, `Renaming remote ${oldRef} → ${newRef}`);
+  execFileSync7("git", ["push", "origin", `${sha}:refs/heads/${newRef}`, "--force-with-lease"], { cwd, stdio: "pipe" });
   try {
-    execFileSync6("git", ["push", "origin", `:refs/heads/${oldRef}`], {
+    execFileSync7("git", ["push", "origin", `:refs/heads/${oldRef}`], {
       cwd,
       stdio: "pipe"
     });
   } catch (err) {
-    log.warn(TAG11, `renameRemoteBranch: could not delete old ref ${oldRef}: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG13, `renameRemoteBranch: could not delete old ref ${oldRef}: ${err instanceof Error ? err.message : err}`);
   }
   try {
-    execFileSync6("git", ["branch", "-m", oldRef, newRef], {
+    execFileSync7("git", ["branch", "-m", oldRef, newRef], {
       cwd,
       stdio: "pipe"
     });
@@ -1003,7 +1181,7 @@ function renameRemoteBranch(oldRef, newRef, cwd) {
 }
 function getBranchWebUrl(branchName, cwd) {
   try {
-    const remoteUrl = execFileSync6("git", ["remote", "get-url", "origin"], {
+    const remoteUrl = execFileSync7("git", ["remote", "get-url", "origin"], {
       cwd,
       encoding: "utf-8"
     }).trim();
@@ -1051,12 +1229,12 @@ function buildPrBody(card, commitLog) {
 }
 function createPullRequest(card, branchName, worktreePath, config, provider, existingPrUrl) {
   if (existingPrUrl) {
-    log.info(TAG11, `Reusing existing PR from card description: ${existingPrUrl}`);
+    log.info(TAG13, `Reusing existing PR from card description: ${existingPrUrl}`);
     return existingPrUrl;
   }
   let commitLog = "";
   try {
-    commitLog = execFileSync6("git", ["log", "--oneline", `origin/${config.worktree.baseBranch}..HEAD`], { cwd: worktreePath, encoding: "utf-8" }).trim();
+    commitLog = execFileSync7("git", ["log", "--oneline", `origin/${config.worktree.baseBranch}..HEAD`], { cwd: worktreePath, encoding: "utf-8" }).trim();
   } catch {
     commitLog = "(unable to retrieve commit log)";
   }
@@ -1065,7 +1243,7 @@ function createPullRequest(card, branchName, worktreePath, config, provider, exi
   const base = config.worktree.baseBranch;
   const existingUrl = findExistingPr(branchName, worktreePath, provider);
   if (existingUrl) {
-    log.info(TAG11, `PR already exists for ${branchName}, updating body...`);
+    log.info(TAG13, `PR already exists for ${branchName}, updating body...`);
     updateExistingPr(branchName, body, worktreePath, provider);
     return existingUrl;
   }
@@ -1073,10 +1251,10 @@ function createPullRequest(card, branchName, worktreePath, config, provider, exi
     let result;
     switch (provider) {
       case "github":
-        result = execFileSync6("gh", ["pr", "create", "--title", title, "--body", body, "--base", base], { cwd: worktreePath, encoding: "utf-8" }).trim();
+        result = execFileSync7("gh", ["pr", "create", "--title", title, "--body", body, "--base", base], { cwd: worktreePath, encoding: "utf-8" }).trim();
         break;
       case "azure": {
-        const azOutput = execFileSync6("az", [
+        const azOutput = execFileSync7("az", [
           "repos",
           "pr",
           "create",
@@ -1100,7 +1278,7 @@ function createPullRequest(card, branchName, worktreePath, config, provider, exi
         break;
       }
       case "gitlab":
-        result = execFileSync6("glab", [
+        result = execFileSync7("glab", [
           "mr",
           "create",
           "--title",
@@ -1115,13 +1293,13 @@ function createPullRequest(card, branchName, worktreePath, config, provider, exi
         ], { cwd: worktreePath, encoding: "utf-8" }).trim();
         break;
       default:
-        log.warn(TAG11, `No PR CLI for provider "${provider}" — branch pushed but no PR created`);
+        log.warn(TAG13, `No PR CLI for provider "${provider}" — branch pushed but no PR created`);
         return null;
     }
-    log.info(TAG11, `PR created: ${result}`);
+    log.info(TAG13, `PR created: ${result}`);
     return result;
   } catch (err) {
-    log.error(TAG11, `Failed to create PR: ${err instanceof Error ? err.message : err}`);
+    log.error(TAG13, `Failed to create PR: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
@@ -1129,9 +1307,9 @@ function findExistingPr(branchName, worktreePath, provider) {
   try {
     switch (provider) {
       case "github":
-        return execFileSync6("gh", ["pr", "view", branchName, "--json", "url", "--jq", ".url"], { cwd: worktreePath, encoding: "utf-8" }).trim();
+        return execFileSync7("gh", ["pr", "view", branchName, "--json", "url", "--jq", ".url"], { cwd: worktreePath, encoding: "utf-8" }).trim();
       case "gitlab": {
-        const json = execFileSync6("glab", ["mr", "view", branchName, "--output", "json"], { cwd: worktreePath, encoding: "utf-8" }).trim();
+        const json = execFileSync7("glab", ["mr", "view", branchName, "--output", "json"], { cwd: worktreePath, encoding: "utf-8" }).trim();
         const parsed = JSON.parse(json);
         return parsed.web_url || null;
       }
@@ -1146,27 +1324,28 @@ function updateExistingPr(branchName, body, worktreePath, provider) {
   try {
     switch (provider) {
       case "github":
-        execFileSync6("gh", ["pr", "edit", branchName, "--body", body], {
+        execFileSync7("gh", ["pr", "edit", branchName, "--body", body], {
           cwd: worktreePath,
           stdio: "pipe"
         });
         break;
       case "gitlab":
-        execFileSync6("glab", ["mr", "update", branchName, "--description", body], { cwd: worktreePath, stdio: "pipe" });
+        execFileSync7("glab", ["mr", "update", branchName, "--description", body], { cwd: worktreePath, stdio: "pipe" });
         break;
     }
-    log.info(TAG11, `Updated existing PR body for ${branchName}`);
+    log.info(TAG13, `Updated existing PR body for ${branchName}`);
   } catch (err) {
-    log.warn(TAG11, `Failed to update PR body: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG13, `Failed to update PR body: ${err instanceof Error ? err.message : err}`);
   }
 }
-var cachedExecFileAsync, TAG11 = "git-pr", VALID_PR_URL_RE, PR_URL_RE, REVIEWED_SHA_RE;
+var cachedExecFileAsync2, TAG13 = "git-pr", VALID_PR_URL_RE, PR_URL_RE, REVIEWED_SHA_RE, CI_REVIEW_REQUESTED_SHA_RE;
 var init_git_pr = __esm(() => {
   init_dist();
   init_log();
   VALID_PR_URL_RE = /^https:\/\/(github\.com|gitlab\.com|dev\.azure\.com|bitbucket\.org)\//;
   PR_URL_RE = /PR:\s*(https?:\/\/[^\s)]+)/;
   REVIEWED_SHA_RE = /^Reviewed-SHA:\s*([0-9a-f]{7,40})\s*$/im;
+  CI_REVIEW_REQUESTED_SHA_RE = /^CI-Review-Requested-SHA:\s*([0-9a-f]{7,40})\s*$/im;
 });
 
 // src/artifact-judge.ts
@@ -1217,6 +1396,8 @@ var AUTH = /\b401\b|invalid x-api-key|authentication_error|unauthorized|oauth to
 var OUT_OF_CREDITS = /\b402\b|credit balance is too low|insufficient (?:funds|credit|balance)|billing|payment required|purchase more credits/i;
 var USAGE_LIMIT = /usage limit|daily limit|monthly limit|quota (?:exceeded|reached)|reached your .{0,20}limit|usage_limit_reached|limit will reset/i;
 var RATE_LIMIT = /\b429\b|\b529\b|rate[ _-]?limit|too many requests|overloaded_error|"type"\s*:\s*"overloaded"/i;
+var SPEND_LIMIT = /spend(?:ing)? (?:limit|cap)|monthly spend/i;
+var SPEND_LIMIT_REMEDY = /admin-settings\/usage/i;
 function parseRetryAfterMs(message) {
   const match = message.match(/retry[- ]?after["':\s]+(\d+)/i);
   if (!match)
@@ -1232,12 +1413,16 @@ function classifyRunError(message) {
   const retryAfterMs = parseRetryAfterMs(message);
   if (AUTH.test(message))
     return { kind: "auth", retryAfterMs };
+  if (SPEND_LIMIT.test(message))
+    return { kind: "spend_limit", retryAfterMs };
   if (OUT_OF_CREDITS.test(message))
     return { kind: "out_of_credits", retryAfterMs };
   if (USAGE_LIMIT.test(message))
     return { kind: "usage_limit", retryAfterMs };
   if (RATE_LIMIT.test(message))
     return { kind: "rate_limit", retryAfterMs };
+  if (SPEND_LIMIT_REMEDY.test(message))
+    return { kind: "spend_limit", retryAfterMs };
   return { kind: null };
 }
 function describeApiError(kind) {
@@ -1250,6 +1435,8 @@ function describeApiError(kind) {
       return "Anthropic usage limit reached — retrying after reset";
     case "rate_limit":
       return "Anthropic rate limit hit — retrying shortly";
+    case "spend_limit":
+      return "Account spend limit reached — raise it at claude.ai/admin-settings/usage, then run `harmony-agent resume`";
   }
 }
 function cooldownMsFor(kind) {
@@ -1262,6 +1449,8 @@ function cooldownMsFor(kind) {
       return 30 * 60000;
     case "auth":
       return 30 * 60000;
+    case "spend_limit":
+      return 30 * 60000;
   }
 }
 
@@ -1615,7 +1804,7 @@ ${this.capturedStderr}`);
             kind: "error",
             source: "system",
             payload: {
-              message: `result ${r.subtype}: ${joined || "(no detail)"}`,
+              message: resultErrorMessage(r.subtype, joined),
               errorKind: cls.kind,
               retryable: cls.kind !== "auth" && cls.kind !== null
             }
@@ -1626,6 +1815,13 @@ ${this.capturedStderr}`);
     }
   }
 }
+function resultErrorMessage(subtype, detail) {
+  return `result ${subtype}: ${detail || "(no detail)"}`;
+}
+function resultErrorSubtype(message) {
+  const match = message.match(/^result ([A-Za-z0-9_]+):/);
+  return match ? match[1] : null;
+}
 function normalize(raw) {
   if (raw == null)
     return;
@@ -1845,6 +2041,168 @@ class ArtifactCollector {
     };
   }
 }
+// src/ci-failure.ts
+init_log();
+import { execFile, execFileSync } from "node:child_process";
+import { promisify } from "node:util";
+function createExecFileAsync() {
+  return promisify(execFile);
+}
+var cachedExecFileAsync;
+function execFileAsync() {
+  return cachedExecFileAsync ??= createExecFileAsync();
+}
+var TAG3 = "ci-failure";
+var LOG_TAIL_BYTES = 16000;
+var MAX_CHECK_NAME = 200;
+function sanitizeCiText(text, maxLength) {
+  return text.replace(/`/g, "'").replace(/[\u0000-\u0008\u000B-\u001F\u007F]/g, " ").slice(0, maxLength);
+}
+function githubSlug(remoteOrPrUrl) {
+  const m = remoteOrPrUrl.match(/github\.com[:/]([^/\s]+)\/([^/\s]+?)(?:\.git)?(?:\/|$)/i);
+  return m ? `${m[1].toLowerCase()}/${m[2].toLowerCase()}` : null;
+}
+var STRICT_PR_URL_RE = /^https:\/\/github\.com\/[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+\/pull\/\d+$/;
+function isPrOnOrigin(prUrl, cwd) {
+  if (!STRICT_PR_URL_RE.test(prUrl))
+    return false;
+  const prSlug = githubSlug(prUrl);
+  if (!prSlug)
+    return false;
+  try {
+    const remote = execFileSync("git", ["remote", "get-url", "origin"], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+    return githubSlug(remote) === prSlug;
+  } catch {
+    return false;
+  }
+}
+var RUN_ID_RE = /\/actions\/runs\/(\d+)/;
+function extractWorkflowRunId(detailsUrl) {
+  if (!detailsUrl)
+    return null;
+  return detailsUrl.match(RUN_ID_RE)?.[1] ?? null;
+}
+function parseFailedChecks(rollup) {
+  if (!Array.isArray(rollup))
+    return [];
+  const failed = [];
+  for (const check of rollup) {
+    if (typeof check !== "object" || check === null)
+      continue;
+    const c = check;
+    const name = sanitizeCiText(typeof c.name === "string" && c.name || typeof c.context === "string" && c.context || "unnamed check", MAX_CHECK_NAME);
+    const detailsUrl = typeof c.detailsUrl === "string" && c.detailsUrl || typeof c.targetUrl === "string" && c.targetUrl || null;
+    if (typeof c.status === "string") {
+      if (c.status.toUpperCase() !== "COMPLETED")
+        continue;
+      const conclusion = typeof c.conclusion === "string" ? c.conclusion.toUpperCase() : "";
+      if (["SUCCESS", "NEUTRAL", "SKIPPED"].includes(conclusion))
+        continue;
+      failed.push({
+        name,
+        conclusion: conclusion || "FAILURE",
+        detailsUrl,
+        workflowRunId: extractWorkflowRunId(detailsUrl)
+      });
+      continue;
+    }
+    if (typeof c.state === "string") {
+      const state = c.state.toUpperCase();
+      if (state === "SUCCESS" || state === "PENDING")
+        continue;
+      failed.push({
+        name,
+        conclusion: state,
+        detailsUrl,
+        workflowRunId: extractWorkflowRunId(detailsUrl)
+      });
+    }
+  }
+  return failed;
+}
+var INFRA_SIGNATURES = [
+  { signal: "esm.sh 5xx", pattern: /esm\.sh[^\n]{0,200}?\b5\d\d\b/i },
+  {
+    signal: "setup-bun unavailable",
+    pattern: /setup-bun[^\n]{0,200}?\b(?:503|502|504)\b/i
+  },
+  {
+    signal: "runner setup failed",
+    pattern: /(?:##\[error\])?Set up job[^\n]{0,120}?(?:fail|error)/i
+  },
+  {
+    signal: "runner network",
+    pattern: /(?:getaddrinfo\s+(?:EAI_AGAIN|ENOTFOUND)|connect\s+(?:ETIMEDOUT|ECONNREFUSED)\s+[\d.:]|(?:read|write)\s+ECONNRESET\b[^\n]{0,80}(?:https?:|\.com|\.org|\.io|\.sh|\.dev)|TLS handshake timeout)/i
+  },
+  {
+    signal: "actions infrastructure",
+    pattern: /(?:The (?:self-hosted )?runner[^\n]{0,80}lost communication|The operation was canceled[^\n]{0,80}runner|We are experiencing (?:a )?(?:degraded|high) )/i
+  },
+  {
+    signal: "registry 5xx",
+    pattern: /(?:npm|bun|yarn|pnpm)[^\n]{0,200}?\b(?:502 Bad Gateway|503 Service Unavailable|504 Gateway Time-?out)\b/i
+  }
+];
+function classifyCiFailure(input) {
+  const haystack = `${input.checkName}
+${input.log}`;
+  for (const { signal, pattern } of INFRA_SIGNATURES) {
+    if (pattern.test(haystack))
+      return { kind: "infra", signal };
+  }
+  return { kind: "code", signal: null };
+}
+function describeCiFailure(failure) {
+  return failure.kind === "infra" ? `infrastructure failure (${failure.signal}) — re-dispatching, no code change` : "a real build or test failure — repairing the branch";
+}
+function classifyCiFailures(failures) {
+  if (failures.length === 0)
+    return { kind: "code", signal: null };
+  const infra = failures.filter((f) => f.kind === "infra");
+  if (infra.length !== failures.length)
+    return { kind: "code", signal: null };
+  const signals = [...new Set(infra.map((f) => f.signal).filter(Boolean))];
+  return { kind: "infra", signal: signals.join(", ") || null };
+}
+async function getPrFailedChecks(prUrl, cwd, provider) {
+  if (provider !== "github")
+    return [];
+  try {
+    const { stdout } = await execFileAsync()("gh", ["pr", "view", prUrl, "--json", "statusCheckRollup"], { cwd, encoding: "utf-8", timeout: 15000 });
+    const parsed = JSON.parse(stdout.trim());
+    return parseFailedChecks(parsed.statusCheckRollup);
+  } catch (err) {
+    log.warn(TAG3, `could not read failing checks for ${prUrl}: ${err instanceof Error ? err.message : err}`);
+    return [];
+  }
+}
+async function getFailedRunLog(runId, cwd) {
+  try {
+    const { stdout } = await execFileAsync()("gh", ["run", "view", runId, "--log-failed"], { cwd, encoding: "utf-8", timeout: 60000, maxBuffer: 32 * 1024 * 1024 });
+    return sanitizeCiText(stdout.slice(-LOG_TAIL_BYTES), LOG_TAIL_BYTES);
+  } catch (err) {
+    log.debug(TAG3, `could not read failed-step log for run ${runId}: ${err instanceof Error ? err.message : err}`);
+    return "";
+  }
+}
+async function rerunFailedJobs(runId, cwd) {
+  try {
+    await execFileAsync()("gh", ["run", "rerun", runId, "--failed"], {
+      cwd,
+      encoding: "utf-8",
+      timeout: 30000
+    });
+    log.info(TAG3, `re-dispatched failed jobs of run ${runId}`);
+    return true;
+  } catch (err) {
+    log.warn(TAG3, `could not re-dispatch run ${runId}: ${err instanceof Error ? err.message : err}`);
+    return false;
+  }
+}
 // src/command-metric.ts
 init_dist();
 
@@ -1856,7 +2214,7 @@ init_dist();
 
 // src/command-metric.ts
 init_log();
-var TAG3 = "command-metric";
+var TAG4 = "command-metric";
 var MAX_RAW_CHARS = 2000;
 var MAX_OUTPUT_BUFFER = 10 * 1024 * 1024;
 var MAX_STDERR_CHARS = 64 * 1024;
@@ -2036,7 +2394,7 @@ class CommandMetricCollector {
     const requested = typeof def.timeoutMs === "number" && def.timeoutMs > 0 ? Math.floor(def.timeoutMs) : DEFAULT_METRIC_TIMEOUT_MS;
     const timeoutMs = Math.min(requested, MAX_METRIC_TIMEOUT_MS);
     if (timeoutMs < requested) {
-      log.warn(TAG3, `Metric "${name}" declares timeoutMs=${requested}, clamped to the ${MAX_METRIC_TIMEOUT_MS}ms ceiling`);
+      log.warn(TAG4, `Metric "${name}" declares timeoutMs=${requested}, clamped to the ${MAX_METRIC_TIMEOUT_MS}ms ceiling`);
     }
     const run = this.deps.runCommand ?? runMetricCommand;
     let stdout;
@@ -2049,15 +2407,15 @@ class CommandMetricCollector {
       });
     } catch (err) {
       const reason = describeRunFailure(err, timeoutMs);
-      log.warn(TAG3, `Metric "${name}" did not produce a measurement: ${reason}`);
+      log.warn(TAG4, `Metric "${name}" did not produce a measurement: ${reason}`);
       return blocked(name, reason);
     }
     const parsed = parseMetricValue(mode, stdout);
     if (!parsed.ok) {
-      log.warn(TAG3, `Metric "${name}" output unusable: ${parsed.reason}`);
+      log.warn(TAG4, `Metric "${name}" output unusable: ${parsed.reason}`);
       return blocked(name, `Metric "${name}": ${parsed.reason}.`, stdout);
     }
-    log.info(TAG3, `Metric "${name}" measured: ${JSON.stringify(parsed.value)}`);
+    log.info(TAG4, `Metric "${name}" measured: ${JSON.stringify(parsed.value)}`);
     return {
       result: "passed",
       structured: {
@@ -2105,147 +2463,587 @@ function truncate(value, max) {
   return value.length <= max ? value : `${value.slice(0, max)}…[truncated]`;
 }
 // src/confine-to-repo.ts
-import { isAbsolute, resolve, sep } from "node:path";
-var PATH_ARG_BY_TOOL = {
+import { realpathSync } from "node:fs";
+import { dirname, isAbsolute, parse, resolve, sep } from "node:path";
+var READ_PATH_ARGS = {
   Read: ["file_path", "path", "notebook_path"],
   Grep: ["path"],
   Glob: ["path"]
 };
+var WRITE_PATH_ARGS = {
+  Write: ["file_path"],
+  Edit: ["file_path"],
+  MultiEdit: ["file_path"],
+  NotebookEdit: ["notebook_path"]
+};
+var CONFINED_READ_TOOLS = Object.freeze(Object.keys(READ_PATH_ARGS));
+var CONFINED_WRITE_TOOLS = Object.freeze([
+  ...Object.keys(READ_PATH_ARGS),
+  ...Object.keys(WRITE_PATH_ARGS).filter((t) => t !== "MultiEdit")
+]);
+var PATTERN_ARG_BY_TOOL = {
+  Glob: ["pattern"],
+  Grep: ["glob"]
+};
+function isGitMetadata(repoRoot, candidate) {
+  const rel = candidate.startsWith(repoRoot) ? candidate.slice(repoRoot.length) : candidate;
+  return rel.split(/[\\/]/).some((segment) => segment.toLowerCase() === ".git");
+}
+function patternEscapes(pattern) {
+  if (isAbsolute(pattern))
+    return true;
+  if (/[{}[\]~()!+@]/.test(pattern))
+    return true;
+  return pattern.split(/[\\/]/).some((segment) => segment === "..");
+}
+function pathArgsFor(mode) {
+  return mode === "write" ? { ...READ_PATH_ARGS, ...WRITE_PATH_ARGS } : READ_PATH_ARGS;
+}
+function realPathOrNearest(p) {
+  const abs = isAbsolute(p) ? p : resolve(p);
+  const { root } = parse(abs);
+  let real = root;
+  for (const part of abs.slice(root.length).split(sep)) {
+    if (part === "" || part === ".")
+      continue;
+    if (part === "..") {
+      real = dirname(real);
+      continue;
+    }
+    const next = real.endsWith(sep) ? real + part : real + sep + part;
+    try {
+      real = realpathSync(next);
+    } catch {
+      real = next;
+    }
+  }
+  return real;
+}
 function isInsideTree(root, target) {
-  const normalizedRoot = resolve(root);
-  const normalizedTarget = resolve(target);
+  const normalizedRoot = realPathOrNearest(root);
+  const normalizedTarget = realPathOrNearest(target);
   if (normalizedTarget === normalizedRoot)
     return true;
   return normalizedTarget.startsWith(normalizedRoot + sep);
 }
-function decideConfinedTool(repoRoot, toolName, input) {
-  const pathArgs = PATH_ARG_BY_TOOL[toolName];
+function decideConfinedTool(repoRoot, toolName, input, mode = "read") {
+  const pathArgs = pathArgsFor(mode)[toolName];
   if (!pathArgs) {
     return {
       behavior: "deny",
       message: `${toolName} is not available to this run.`
     };
   }
+  const verb = toolName in WRITE_PATH_ARGS ? "write" : "read";
+  for (const key of PATTERN_ARG_BY_TOOL[toolName] ?? []) {
+    const value = input[key];
+    if (typeof value !== "string" || value.length === 0)
+      continue;
+    if (patternEscapes(value)) {
+      return {
+        behavior: "deny",
+        message: `${toolName} patterns must stay inside the repository — no absolute path and no "..". Refused: ${value}`
+      };
+    }
+  }
   for (const key of pathArgs) {
     const value = input[key];
     if (typeof value !== "string" || value.length === 0)
       continue;
-    const candidate = isAbsolute(value) ? value : resolve(repoRoot, value);
+    const candidate = isAbsolute(value) ? value : `${repoRoot}${sep}${value}`;
+    if (isGitMetadata(repoRoot, candidate)) {
+      return {
+        behavior: "deny",
+        message: `${toolName} may not touch the repository's git metadata. Refused: ${value}`
+      };
+    }
     if (!isInsideTree(repoRoot, candidate)) {
       return {
         behavior: "deny",
-        message: `${toolName} may only read inside the repository. Refused: ${value}`
+        message: `${toolName} may only ${verb} inside the repository. Refused: ${value}`
       };
     }
   }
   return { behavior: "allow" };
 }
-function confineToRepo(repoRoot) {
-  return async (toolName, input) => decideConfinedTool(repoRoot, toolName, input);
+function confineToRepo(repoRoot, mode = "read") {
+  return async (toolName, input) => decideConfinedTool(repoRoot, toolName, input, mode);
 }
 // src/gate-collectors.ts
 init_dist();
 init_log();
 
 // src/oracle-collector.ts
-init_log();
 import { createHash } from "node:crypto";
-var TAG4 = "oracle-collector";
+init_log();
 
-class OracleCollector {
-  deps;
-  kind = "oracle_passed";
-  constructor(deps) {
-    this.deps = deps;
+// src/oracle.ts
+import { lstatSync, readFileSync, statSync } from "node:fs";
+import {
+  chmod,
+  lstat,
+  mkdir,
+  mkdtemp,
+  realpath,
+  rm,
+  writeFile
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join, resolve as resolve2, sep as sep2 } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+init_log();
+var TAG5 = "oracle";
+async function resolveContained(repoPath, relativePath) {
+  if (isAbsolute2(relativePath)) {
+    throw new Error(`refusing to place an oracle at an absolute path: ${relativePath}`);
   }
-  async collect(context) {
-    const oracle = await this.deps.fetchOracle(context.cardId, context.stageId, this.deps.sessionId);
-    if (!oracle) {
-      log.info(TAG4, `No oracle held for stage ${context.stageId} — blocked`);
-      return {
-        result: "blocked",
-        structured: {
-          reason: `No oracle is held for stage ${context.stageId}.`
-        }
-      };
-    }
-    return await this.runHeld(oracle);
+  if (relativePath === "" || relativePath === ".") {
+    throw new Error(`refusing to place an oracle at the empty/self path: "${relativePath}"`);
   }
-  async runHeld(oracle) {
-    const identity = {
-      oracleId: oracle.id ?? null,
-      contentHash: createHash("sha256").update(oracle.content).digest("hex")
-    };
-    await this.deps.place(this.deps.repoPath, oracle);
-    try {
-      const { exitCode, output } = await this.deps.run(this.deps.repoPath, oracle);
-      const logLine = `Oracle run for ${oracle.path} exited ${exitCode}:
-${output}`;
-      if (exitCode === 0) {
-        log.info(TAG4, logLine);
-      } else {
-        log.warn(TAG4, logLine);
-      }
-      return {
-        result: exitCode === 0 ? "passed" : "failed",
-        structured: {
-          oracle: {
-            exitCode,
-            path: oracle.path,
-            ...identity,
-            output: "withheld — oracle_passed is a secrecy gate; see the motor's local log"
-          }
-        }
-      };
-    } catch (err) {
-      const message = errText(err);
-      log.warn(TAG4, `Oracle run threw: ${message} — blocked`);
-      return {
-        result: "blocked",
-        structured: {
-          oracle: { path: oracle.path, ...identity },
-          error: message
-        }
-      };
-    } finally {
-      await this.removeBestEffort(oracle);
-    }
+  const root = await realpath(repoPath);
+  const target = resolve2(root, relativePath);
+  if (target !== root && !target.startsWith(root + sep2)) {
+    throw new Error(`refusing to place an oracle outside the worktree: ${relativePath}`);
   }
-  async removeBestEffort(oracle) {
-    try {
-      await this.deps.remove(this.deps.repoPath, oracle);
-      return;
-    } catch (err) {
-      log.warn(TAG4, `Removing the held test at ${oracle.path} failed (${errText(err)}) — retrying once`);
-    }
-    try {
-      await this.deps.remove(this.deps.repoPath, oracle);
-      log.info(TAG4, `Held test at ${oracle.path} removed on the second attempt`);
-    } catch (err) {
-      log.error(TAG4, `HELD TEST NOT REMOVED: ${oracle.path} is still in ${this.deps.repoPath} after two attempts (${errText(err)}). ` + "It will be auto-committed by the completion path if it is left there — delete it by hand and check whether it reached a commit.");
+  let cursor = root;
+  for (const segment of relativePath.split("/")) {
+    cursor = resolve2(cursor, segment);
+    const stat = await lstat(cursor).catch(() => null);
+    if (stat?.isSymbolicLink()) {
+      throw new Error(`refusing an oracle path through a symlink component: ${relativePath}`);
     }
   }
+  return target;
 }
-function errText(err) {
-  return err instanceof Error ? err.message : String(err);
+async function place(repoPath, oracle) {
+  const target = await resolveContained(repoPath, oracle.path);
+  await mkdir(dirname2(target), { recursive: true });
+  await writeFile(target, oracle.content, "utf8");
 }
-
-// src/verification.ts
+async function remove(repoPath, oracle) {
+  const target = await resolveContained(repoPath, oracle.path);
+  await rm(target, { force: true });
+}
+var ORACLE_RUNNERS = {
+  vitest: {
+    argv: (path) => ({
+      command: "npx",
+      args: ["--no-install", "vitest", "run", path]
+    }),
+    verdictStream: "stdout",
+    report: {
+      file: "report.json",
+      flags: (reportPath) => [
+        "--reporter=default",
+        "--reporter=json",
+        `--outputFile=${reportPath}`
+      ],
+      parse: (content) => {
+        const parsed = JSON.parse(content);
+        if (typeof parsed !== "object" || parsed === null)
+          return null;
+        const { numTotalTests, numFailedTests } = parsed;
+        if (typeof numTotalTests !== "number" || typeof numFailedTests !== "number" || !Number.isFinite(numTotalTests) || !Number.isFinite(numFailedTests)) {
+          return null;
+        }
+        return { total: numTotalTests, failed: numFailedTests };
+      }
+    }
+  },
+  bun: {
+    argv: (path) => ({ command: "bun", args: ["test", path] }),
+    verdictStream: "stderr",
+    report: {
+      file: "report.xml",
+      flags: (reportPath) => [
+        "--reporter=junit",
+        `--reporter-outfile=${reportPath}`
+      ],
+      parse: (content) => {
+        const root = /<testsuites\b[^>]*>/.exec(content);
+        if (!root)
+          return null;
+        const total = /\btests="(\d+)"/.exec(root[0]);
+        const failed = /\bfailures="(\d+)"/.exec(root[0]);
+        if (!total || !failed)
+          return null;
+        return { total: Number(total[1]), failed: Number(failed[1]) };
+      }
+    }
+  }
+};
+var ORACLE_RUNNER_HINTS = Object.keys(ORACLE_RUNNERS).sort();
+var ORACLE_OUTPUT_LIMIT = 64 * 1024;
+var ORACLE_SIGINT_GRACE_MS = 2000;
+var ORACLE_SIGTERM_GRACE_MS = 3000;
+var ORACLE_DRAIN_GRACE_MS = 500;
+function resolveOracleRunner(oracle) {
+  return resolveOracleRunnerSpec(oracle).argv(argvPath(oracle.path));
+}
+function resolveOracleRunnerSpec(oracle) {
+  const hint = oracle.runnerHint?.trim().toLowerCase() ?? "";
+  const spec = Object.hasOwn(ORACLE_RUNNERS, hint) ? ORACLE_RUNNERS[hint] : undefined;
+  if (!spec) {
+    throw new Error(`refusing to run the held test: runner_hint ${JSON.stringify(oracle.runnerHint)} is not in the motor's allow-list (${ORACLE_RUNNER_HINTS.join(", ")})`);
+  }
+  return spec;
+}
+function summarizeOracleReport(oracle, content) {
+  const spec = resolveOracleRunnerSpec(oracle);
+  try {
+    return spec.report.parse(content) ?? null;
+  } catch {
+    return null;
+  }
+}
+function gradeOracleRed(summary, exitCode) {
+  if (!summary) {
+    return {
+      outcome: "no_verdict",
+      reason: `the runner exited ${exitCode} but the motor has no report it could read — absent, unreadable, or refused, ` + "so it cannot be shown to have run the held test (an absent runner and a failing test share this exit code). " + "The report is a file the runner writes outside the worktree; the motor's local log says which of the three it was"
+    };
+  }
+  if (summary.total === 0) {
+    return {
+      outcome: "no_verdict",
+      reason: `the runner started but executed no tests (exit ${exitCode}), so the held test produced no verdict`
+    };
+  }
+  if (summary.failed > 0) {
+    return { outcome: "reproduced", summary };
+  }
+  if (exitCode === 0) {
+    return { outcome: "not_reproduced", summary };
+  }
+  return {
+    outcome: "no_verdict",
+    reason: `all ${summary.total} test(s) passed but the runner exited ${exitCode}, so the failure is not the held test's`
+  };
+}
+function argvPath(path) {
+  return path.startsWith("./") ? path : `./${path}`;
+}
+async function runHeldOracle(repoPath, oracle, timeoutMs = DEFAULT_METRIC_TIMEOUT_MS) {
+  const spec = resolveOracleRunnerSpec(oracle);
+  const reportDir = await mkdtemp(join(tmpdir(), reportDirPrefix()));
+  const reportPath = join(reportDir, spec.report.file);
+  try {
+    return await spawnHeldOracle(spec, repoPath, oracle, reportPath, timeoutMs);
+  } finally {
+    await removeReportDir(reportDir);
+  }
+}
+function reportDirPrefix() {
+  return "harmony-oracle-report-";
+}
+function assertUntampered(reportPath) {
+  const dir = statSync(dirname2(reportPath));
+  if ((dir.mode & 511) !== 448) {
+    throw new Error(`the oracle report directory's mode changed to ${(dir.mode & 511).toString(8)} — refusing the report`);
+  }
+  const file = lstatSync(reportPath);
+  if (!file.isFile()) {
+    throw new Error("the oracle report is not a regular file — refusing it");
+  }
+  if ((file.mode & 128) === 0) {
+    throw new Error(`the oracle report is not owner-writable (mode ${(file.mode & 511).toString(8)}), so the runner could not have written it last — refusing it`);
+  }
+}
+async function removeReportDir(reportDir) {
+  try {
+    await chmod(reportDir, 448).catch(() => {});
+    await rm(reportDir, { recursive: true, force: true });
+  } catch (err) {
+    log.warn(TAG5, `Could not remove the oracle report directory ${reportDir} (${err instanceof Error ? err.message : String(err)}) — it may still hold the runner's report, which carries assertion text for vitest. Remove it by hand.`);
+  }
+}
+async function spawnHeldOracle(spec, repoPath, oracle, reportPath, timeoutMs) {
+  const { command, args: baseArgs } = spec.argv(argvPath(oracle.path));
+  const args = [...baseArgs, ...spec.report.flags(reportPath)];
+  return await new Promise((settleOk, settleErr) => {
+    let child;
+    try {
+      child = spawnInGroup(command, args, {
+        cwd: repoPath,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (err) {
+      settleErr(err);
+      return;
+    }
+    const pgid = child.pid;
+    let output = "";
+    let truncated = false;
+    const outDecoder = new StringDecoder("utf8");
+    const errDecoder = new StringDecoder("utf8");
+    let verdict = "";
+    let flushed = false;
+    const flush = () => {
+      if (flushed)
+        return;
+      flushed = true;
+      const outTail = outDecoder.end();
+      const errTail = errDecoder.end();
+      output += outTail + errTail;
+      verdict += spec.verdictStream === "stdout" ? outTail : errTail;
+    };
+    const finalOutput = () => {
+      flush();
+      return truncated ? `… earlier output dropped; kept the last ${ORACLE_OUTPUT_LIMIT} characters
+${output}` : output;
+    };
+    const finalVerdict = () => {
+      flush();
+      return verdict;
+    };
+    let report = null;
+    const captureReport = () => {
+      try {
+        assertUntampered(reportPath);
+        report = spec.report.parse(readFileSync(reportPath, "utf8"));
+      } catch (err) {
+        report = null;
+        const message = err instanceof Error ? err.message : String(err);
+        const absent = err instanceof Error && err.code === "ENOENT";
+        if (absent) {
+          log.info(TAG5, `No oracle report at ${reportPath} — no verdict.`);
+        } else {
+          log.warn(TAG5, `Refusing the oracle report at ${reportPath}: ${message} — the gate will report no verdict.`);
+        }
+      }
+    };
+    let settled = false;
+    let killing = false;
+    let timer;
+    let drainTimer;
+    const settle = (failure, result) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer)
+        clearTimeout(timer);
+      if (drainTimer)
+        clearTimeout(drainTimer);
+      reapGroup(pgid);
+      if (failure)
+        settleErr(failure);
+      else
+        settleOk(result);
+    };
+    const append = (stream, chunk) => {
+      const text = (stream === "stdout" ? outDecoder : errDecoder).write(chunk);
+      output += text;
+      if (output.length > ORACLE_OUTPUT_LIMIT) {
+        output = output.slice(-ORACLE_OUTPUT_LIMIT);
+        truncated = true;
+      }
+      if (stream === spec.verdictStream) {
+        verdict += text;
+        if (verdict.length > ORACLE_OUTPUT_LIMIT) {
+          verdict = verdict.slice(-ORACLE_OUTPUT_LIMIT);
+        }
+      }
+    };
+    child.stdout?.on("data", (chunk) => append("stdout", chunk));
+    child.stderr?.on("data", (chunk) => append("stderr", chunk));
+    child.once("error", (err) => settle(err));
+    const settleFromExit = (code, signal) => {
+      if (drainTimer)
+        clearTimeout(drainTimer);
+      if (code === null) {
+        settle(new Error(`the held test was terminated by signal ${signal}`));
+        return;
+      }
+      settle(null, {
+        exitCode: code,
+        output: finalOutput(),
+        verdict: finalVerdict(),
+        report
+      });
+    };
+    child.once("exit", (code, signal) => {
+      if (killing)
+        return;
+      captureReport();
+      if (timer)
+        clearTimeout(timer);
+      reapGroup(pgid);
+      drainTimer = setTimeout(() => settleFromExit(code, signal), ORACLE_DRAIN_GRACE_MS);
+      child.once("close", () => settleFromExit(code, signal));
+    });
+    timer = setTimeout(() => {
+      if (settled)
+        return;
+      killing = true;
+      terminateGroup(child, {
+        sigintTimeoutMs: ORACLE_SIGINT_GRACE_MS,
+        sigtermTimeoutMs: ORACLE_SIGTERM_GRACE_MS
+      }).catch(() => {}).then(() => {
+        settle(new Error(`the held test did not finish within ${timeoutMs}ms`));
+      });
+    }, timeoutMs);
+  });
+}
+
+// src/oracle-collector.ts
+var TAG6 = "oracle-collector";
+
+class HeldOracleCollector {
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async collect(context) {
+    const stageId = this.oracleStageId(context);
+    if (!stageId) {
+      const reason = `No stage downstream of ${context.stageId} declares an \`oracle_passed\` gate, ` + "so there is no held test for this gate to grade. A red gate needs a later stage that runs the same test green.";
+      log.warn(TAG6, `${reason} — blocked (config)`);
+      return {
+        result: "blocked",
+        structured: { reason, ...GATE_CONFIG_ERROR_MARK }
+      };
+    }
+    const oracle = await this.deps.fetchOracle(context.cardId, stageId, this.deps.sessionId);
+    if (!oracle) {
+      log.info(TAG6, `No oracle held for stage ${stageId} — blocked`);
+      return {
+        result: "blocked",
+        structured: {
+          reason: `No oracle is held for stage ${stageId}.`
+        }
+      };
+    }
+    return await this.runHeld(oracle);
+  }
+  async runHeld(oracle) {
+    const identity = {
+      oracleId: oracle.id ?? null,
+      contentHash: createHash("sha256").update(oracle.content).digest("hex")
+    };
+    await this.deps.place(this.deps.repoPath, oracle);
+    try {
+      const { exitCode, output, report } = await this.deps.run(this.deps.repoPath, oracle);
+      const logLine = `Oracle run for ${oracle.path} exited ${exitCode}:
+${output}`;
+      if (exitCode === 0) {
+        log.info(TAG6, logLine);
+      } else {
+        log.warn(TAG6, logLine);
+      }
+      return this.verdict({
+        oracle,
+        identity,
+        exitCode,
+        output,
+        report: report ?? null
+      });
+    } catch (err) {
+      const message = errText(err);
+      log.warn(TAG6, `Oracle run threw: ${message} — blocked`);
+      return {
+        result: "blocked",
+        structured: {
+          oracle: { path: oracle.path, ...identity },
+          error: message
+        }
+      };
+    } finally {
+      await this.removeBestEffort(oracle);
+    }
+  }
+  async removeBestEffort(oracle) {
+    try {
+      await this.deps.remove(this.deps.repoPath, oracle);
+      return;
+    } catch (err) {
+      log.warn(TAG6, `Removing the held test at ${oracle.path} failed (${errText(err)}) — retrying once`);
+    }
+    try {
+      await this.deps.remove(this.deps.repoPath, oracle);
+      log.info(TAG6, `Held test at ${oracle.path} removed on the second attempt`);
+    } catch (err) {
+      log.error(TAG6, `HELD TEST NOT REMOVED: ${oracle.path} is still in ${this.deps.repoPath} after two attempts (${errText(err)}). ` + "It will be auto-committed by the completion path if it is left there — delete it by hand and check whether it reached a commit.");
+    }
+  }
+}
+
+class OracleCollector extends HeldOracleCollector {
+  kind = "oracle_passed";
+  oracleStageId(context) {
+    return context.stageId;
+  }
+  verdict({
+    oracle,
+    identity,
+    exitCode
+  }) {
+    return {
+      result: exitCode === 0 ? "passed" : "failed",
+      structured: {
+        oracle: {
+          exitCode,
+          path: oracle.path,
+          ...identity,
+          output: "withheld — oracle_passed is a secrecy gate; see the motor's local log"
+        }
+      }
+    };
+  }
+}
+
+class OracleRedCollector extends HeldOracleCollector {
+  kind = "oracle_red";
+  oracleStageId() {
+    return this.deps.targetStageId ?? null;
+  }
+  verdict({
+    oracle,
+    identity,
+    exitCode,
+    report
+  }) {
+    const graded = gradeOracleRed(report, exitCode);
+    const base = { exitCode, path: oracle.path, ...identity };
+    if (graded.outcome === "no_verdict") {
+      log.warn(TAG6, `Red gate for ${oracle.path}: ${graded.reason} — blocked`);
+      return {
+        result: "blocked",
+        structured: { oracle: base, reason: graded.reason }
+      };
+    }
+    return {
+      result: graded.outcome === "reproduced" ? "passed" : "failed",
+      structured: {
+        oracle: {
+          ...base,
+          testsRun: graded.summary.total,
+          testsFailed: graded.summary.failed,
+          output: "withheld — oracle_red is a secrecy gate; see the motor's local log"
+        }
+      }
+    };
+  }
+}
+function errText(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/verification.ts
 init_log();
-import { execFileSync as execFileSync4, spawn as spawn2 } from "node:child_process";
+import { execFileSync as execFileSync5, spawn as spawn2 } from "node:child_process";
 
 // src/pm.ts
 init_log();
-import { execFileSync } from "node:child_process";
+import { execFileSync as execFileSync2 } from "node:child_process";
 import { existsSync } from "node:fs";
-var TAG5 = "pm";
+var TAG7 = "pm";
 var cached = null;
 function detectPackageManager() {
   if (cached)
     return cached;
   let repoRoot;
   try {
-    repoRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+    repoRoot = execFileSync2("git", ["rev-parse", "--show-toplevel"], {
       encoding: "utf-8"
     }).trim();
   } catch {
@@ -2260,20 +3058,21 @@ function detectPackageManager() {
   } else {
     cached = "npm";
   }
-  log.info(TAG5, `Detected package manager: ${cached}`);
+  log.info(TAG7, `Detected package manager: ${cached}`);
   return cached;
 }
-function installCommand() {
+function installCommand(ignoreScripts = false) {
   const pm = detectPackageManager();
+  const skip = ignoreScripts ? " --ignore-scripts" : "";
   switch (pm) {
     case "bun":
-      return "bun install --frozen-lockfile";
+      return `bun install --frozen-lockfile${skip}`;
     case "pnpm":
-      return "pnpm install --frozen-lockfile";
+      return `pnpm install --frozen-lockfile${skip}`;
     case "yarn":
-      return "yarn install --frozen-lockfile";
+      return `yarn install --frozen-lockfile${skip}`;
     case "npm":
-      return "npm ci";
+      return `npm ci${skip}`;
   }
 }
 function spawnRunArgs(script, ...extra) {
@@ -2286,9 +3085,9 @@ function spawnRunArgs(script, ...extra) {
 
 // src/project-type.ts
 init_log();
-import { execFileSync as execFileSync2 } from "node:child_process";
-import { existsSync as existsSync2, readdirSync, readFileSync } from "node:fs";
-var TAG6 = "project-type";
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "node:fs";
+var TAG8 = "project-type";
 var _cache = new Map;
 function _resetCache() {
   _cache.clear();
@@ -2299,7 +3098,7 @@ function detect(dir) {
     return cached2;
   const result = detectUncached(dir);
   _cache.set(dir, result);
-  log.info(TAG6, `Detected project type in ${dir}: ${result.kind}`);
+  log.info(TAG8, `Detected project type in ${dir}: ${result.kind}`);
   return result;
 }
 function detectUncached(dir) {
@@ -2390,16 +3189,16 @@ var NPM_PLACEHOLDER_TEST = /no test specified/i;
 function hasNodeTestScript(dir) {
   let script;
   try {
-    const pkg = JSON.parse(readFileSync(`${dir}/package.json`, "utf-8"));
+    const pkg = JSON.parse(readFileSync2(`${dir}/package.json`, "utf-8"));
     script = pkg.scripts?.test;
   } catch (err) {
-    log.warn(TAG6, `Could not read package.json in ${dir}: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG8, `Could not read package.json in ${dir}: ${err instanceof Error ? err.message : err}`);
     return false;
   }
   if (typeof script !== "string" || script.trim().length === 0)
     return false;
   if (NPM_PLACEHOLDER_TEST.test(script)) {
-    log.info(TAG6, `package.json 'test' is the npm placeholder — skipping tests`);
+    log.info(TAG8, `package.json 'test' is the npm placeholder — skipping tests`);
     return false;
   }
   return true;
@@ -2407,10 +3206,10 @@ function hasNodeTestScript(dir) {
 function firstNodeScript(dir, candidates) {
   let scripts;
   try {
-    const pkg = JSON.parse(readFileSync(`${dir}/package.json`, "utf-8"));
+    const pkg = JSON.parse(readFileSync2(`${dir}/package.json`, "utf-8"));
     scripts = pkg.scripts ?? {};
   } catch (err) {
-    log.warn(TAG6, `Could not read package.json in ${dir}: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG8, `Could not read package.json in ${dir}: ${err instanceof Error ? err.message : err}`);
     return null;
   }
   for (const name of candidates) {
@@ -2429,7 +3228,7 @@ function xcodeBuildCommand(pt) {
     return null;
   const scheme = resolveXcodeScheme(pt);
   if (!scheme) {
-    log.warn(TAG6, "Could not resolve an Xcode scheme — skipping build (best-effort)");
+    log.warn(TAG8, "Could not resolve an Xcode scheme — skipping build (best-effort)");
     return null;
   }
   const containerFlag = pt.xcodeIsWorkspace ? "-workspace" : "-project";
@@ -2452,20 +3251,20 @@ function resolveXcodeScheme(pt) {
     return null;
   const flag = pt.xcodeIsWorkspace ? "-workspace" : "-project";
   try {
-    const out = execFileSync2("xcodebuild", ["-list", "-json", flag, pt.xcodeContainer], { encoding: "utf-8", timeout: 30000, stdio: "pipe" });
+    const out = execFileSync3("xcodebuild", ["-list", "-json", flag, pt.xcodeContainer], { encoding: "utf-8", timeout: 30000, stdio: "pipe" });
     const parsed = JSON.parse(out);
     const schemes = pt.xcodeIsWorkspace ? parsed.workspace?.schemes ?? [] : parsed.project?.schemes ?? [];
     return schemes[0] ?? null;
   } catch (err) {
-    log.warn(TAG6, `xcodebuild -list failed: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG8, `xcodebuild -list failed: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
 
 // src/revert-guard.ts
 init_log();
-import { execFileSync as execFileSync3 } from "node:child_process";
-var TAG7 = "revert-guard";
+import { execFileSync as execFileSync4 } from "node:child_process";
+var TAG9 = "revert-guard";
 var TEST_FILE = /(?:^|\/)__tests__\/|\.(?:test|spec)\.[cm]?[jt]sx?$/;
 function isTestFile(path) {
   return TEST_FILE.test(path);
@@ -2475,21 +3274,21 @@ function filterTestFiles(paths) {
 }
 function refetchBase(worktreePath, baseBranch) {
   try {
-    execFileSync3("git", ["fetch", "origin", baseBranch], {
+    execFileSync4("git", ["fetch", "origin", baseBranch], {
       cwd: worktreePath,
       stdio: "pipe"
     });
   } catch {
-    log.warn(TAG7, "Failed to re-fetch base for revert guard — using last fetch");
+    log.warn(TAG9, "Failed to re-fetch base for revert guard — using last fetch");
   }
 }
 function listDeletedFilesAgainstBase(worktreePath, baseBranch) {
   try {
-    const out = execFileSync3("git", ["diff", "--diff-filter=D", "--name-only", `origin/${baseBranch}...HEAD`], { cwd: worktreePath, encoding: "utf-8" });
+    const out = execFileSync4("git", ["diff", "--diff-filter=D", "--name-only", `origin/${baseBranch}...HEAD`], { cwd: worktreePath, encoding: "utf-8" });
     return out.split(`
 `).map((l) => l.trim()).filter((l) => l.length > 0);
   } catch (err) {
-    log.warn(TAG7, `Failed to list deleted files: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG9, `Failed to list deleted files: ${err instanceof Error ? err.message : err}`);
     return [];
   }
 }
@@ -2499,7 +3298,7 @@ function findDeletedTestFiles(worktreePath, baseBranch) {
 }
 
 // src/verification.ts
-var TAG8 = "verification";
+var TAG10 = "verification";
 var MAX_OUTPUT_BUFFER2 = 64 * 1024 * 1024;
 async function runVerification(worktreePath, config, workerId) {
   const result = {
@@ -2511,52 +3310,52 @@ async function runVerification(worktreePath, config, workerId) {
     revertWarnings: []
   };
   if (config.verification.revertGuard) {
-    log.info(TAG8, `[worker:${workerId}] Checking for reverted merged work...`);
+    log.info(TAG10, `[worker:${workerId}] Checking for reverted merged work...`);
     const deletedTests = findDeletedTestFiles(worktreePath, config.worktree.baseBranch);
     if (deletedTests.length > 0) {
       result.revertWarnings = deletedTests.map((f) => `Branch deletes test file '${f}' relative to current ${config.worktree.baseBranch} — ` + "likely an accidental revert of already-merged work. Restore the test or rebase on current main.");
-      log.warn(TAG8, `[worker:${workerId}] Revert guard tripped: ${deletedTests.length} deleted test file(s)`);
+      log.warn(TAG10, `[worker:${workerId}] Revert guard tripped: ${deletedTests.length} deleted test file(s)`);
       result.passed = false;
     } else {
-      log.info(TAG8, `[worker:${workerId}] Revert guard passed`);
+      log.info(TAG10, `[worker:${workerId}] Revert guard passed`);
     }
   }
   if (config.verification.build) {
-    log.info(TAG8, `[worker:${workerId}] Running build...`);
+    log.info(TAG10, `[worker:${workerId}] Running build...`);
     result.buildErrors = runBuild(worktreePath, config.verification.timeout);
     if (result.buildErrors.length > 0) {
-      log.warn(TAG8, `[worker:${workerId}] Build failed with ${result.buildErrors.length} error(s)`);
+      log.warn(TAG10, `[worker:${workerId}] Build failed with ${result.buildErrors.length} error(s)`);
       result.passed = false;
     } else {
-      log.info(TAG8, `[worker:${workerId}] Build passed`);
+      log.info(TAG10, `[worker:${workerId}] Build passed`);
     }
   }
   if (config.verification.test && result.buildErrors.length === 0) {
-    log.info(TAG8, `[worker:${workerId}] Running tests...`);
+    log.info(TAG10, `[worker:${workerId}] Running tests...`);
     result.testFailures = runTests(worktreePath, config.verification.testTimeout);
     if (result.testFailures.length > 0) {
-      log.warn(TAG8, `[worker:${workerId}] Tests failed with ${result.testFailures.length} failure(s)`);
+      log.warn(TAG10, `[worker:${workerId}] Tests failed with ${result.testFailures.length} failure(s)`);
       result.passed = false;
     } else {
-      log.info(TAG8, `[worker:${workerId}] Tests passed`);
+      log.info(TAG10, `[worker:${workerId}] Tests passed`);
     }
   }
   if (config.verification.lint) {
-    log.info(TAG8, `[worker:${workerId}] Running lint...`);
+    log.info(TAG10, `[worker:${workerId}] Running lint...`);
     result.lintWarnings = runLint(worktreePath, config.verification.timeout);
     if (result.lintWarnings.length > 0) {
-      log.warn(TAG8, `[worker:${workerId}] Lint found ${result.lintWarnings.length} issue(s)`);
+      log.warn(TAG10, `[worker:${workerId}] Lint found ${result.lintWarnings.length} issue(s)`);
     } else {
-      log.info(TAG8, `[worker:${workerId}] Lint passed`);
+      log.info(TAG10, `[worker:${workerId}] Lint passed`);
     }
   }
   if (config.verification.deepReview) {
-    log.info(TAG8, `[worker:${workerId}] Running deep review...`);
+    log.info(TAG10, `[worker:${workerId}] Running deep review...`);
     result.reviewFindings = await runDeepReview(worktreePath, config, workerId);
     if (result.reviewFindings.length > 0) {
-      log.warn(TAG8, `[worker:${workerId}] Deep review found ${result.reviewFindings.length} finding(s)`);
+      log.warn(TAG10, `[worker:${workerId}] Deep review found ${result.reviewFindings.length} finding(s)`);
     } else {
-      log.info(TAG8, `[worker:${workerId}] Deep review passed`);
+      log.info(TAG10, `[worker:${workerId}] Deep review passed`);
     }
   }
   return result;
@@ -2564,11 +3363,11 @@ async function runVerification(worktreePath, config, workerId) {
 function runBuild(worktreePath, timeout) {
   const command = buildCommand(worktreePath);
   if (!command) {
-    log.warn(TAG8, `No known build toolchain for ${worktreePath} — skipping build`);
+    log.warn(TAG10, `No known build toolchain for ${worktreePath} — skipping build`);
     return [];
   }
   try {
-    execFileSync4(command.cmd, command.args, {
+    execFileSync5(command.cmd, command.args, {
       cwd: worktreePath,
       timeout,
       stdio: "pipe",
@@ -2582,11 +3381,11 @@ function runBuild(worktreePath, timeout) {
 function runTests(worktreePath, timeout) {
   const command = testCommand(worktreePath);
   if (!command) {
-    log.warn(TAG8, `No test command for detected toolchain in ${worktreePath} — skipping tests`);
+    log.warn(TAG10, `No test command for detected toolchain in ${worktreePath} — skipping tests`);
     return [];
   }
   try {
-    execFileSync4(command.cmd, command.args, {
+    execFileSync5(command.cmd, command.args, {
       cwd: worktreePath,
       timeout,
       stdio: "pipe",
@@ -2595,7 +3394,7 @@ function runTests(worktreePath, timeout) {
     return [];
   } catch (err) {
     const output = combineOutput(err);
-    log.warn(TAG8, `Test run failed:
+    log.warn(TAG10, `Test run failed:
 ${output.slice(-4000) || "(no output captured)"}`);
     return parseTestFailures(err, timeout);
   }
@@ -2605,25 +3404,25 @@ function runFormatFix(worktreePath, timeout, workerId) {
   if (!command)
     return;
   try {
-    execFileSync4(command.cmd, command.args, {
+    execFileSync5(command.cmd, command.args, {
       cwd: worktreePath,
       timeout,
       stdio: "pipe",
       maxBuffer: MAX_OUTPUT_BUFFER2
     });
-    log.info(TAG8, `[worker:${workerId}] Auto-formatted worktree before commit/push`);
+    log.info(TAG10, `[worker:${workerId}] Auto-formatted worktree before commit/push`);
   } catch (err) {
-    log.warn(TAG8, `[worker:${workerId}] Auto-format step exited non-zero (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+    log.warn(TAG10, `[worker:${workerId}] Auto-format step exited non-zero (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
   }
 }
 function runLint(worktreePath, timeout) {
   const command = lintCommand(worktreePath);
   if (!command) {
-    log.info(TAG8, `No lint step for detected toolchain in ${worktreePath} — skipping lint`);
+    log.info(TAG10, `No lint step for detected toolchain in ${worktreePath} — skipping lint`);
     return [];
   }
   try {
-    execFileSync4(command.cmd, command.args, {
+    execFileSync5(command.cmd, command.args, {
       cwd: worktreePath,
       timeout,
       stdio: "pipe",
@@ -2636,7 +3435,7 @@ function runLint(worktreePath, timeout) {
 }
 async function runDeepReview(worktreePath, config, workerId) {
   if (!supportsDevServer(worktreePath)) {
-    log.info(TAG8, `[worker:${workerId}] Detected non-web toolchain — skipping deep review`);
+    log.info(TAG10, `[worker:${workerId}] Detected non-web toolchain — skipping deep review`);
     return [];
   }
   const port = config.verification.devServerBasePort + workerId;
@@ -2651,12 +3450,12 @@ async function runDeepReview(worktreePath, config, workerId) {
       await waitForDevServer(devServer, 30000);
       await probeDevServer(port);
     } catch (err) {
-      log.error(TAG8, `Dev server did not become ready: ${err instanceof Error ? err.message : err}`);
+      log.error(TAG10, `Dev server did not become ready: ${err instanceof Error ? err.message : err}`);
       return [];
     }
     let diff = "";
     try {
-      diff = execFileSync4("git", ["diff", `origin/${config.worktree.baseBranch}..HEAD`], {
+      diff = execFileSync5("git", ["diff", `origin/${config.worktree.baseBranch}..HEAD`], {
         cwd: worktreePath,
         encoding: "utf-8",
         timeout: 30000,
@@ -2678,7 +3477,7 @@ async function runDeepReview(worktreePath, config, workerId) {
     ].join(`
 `);
     const leanSources = config.claude.leanSettingSources;
-    const output = execFileSync4("claude", [
+    const output = execFileSync5("claude", [
       "--print",
       "--model",
       "sonnet",
@@ -2696,7 +3495,7 @@ async function runDeepReview(worktreePath, config, workerId) {
     });
     return parseReviewFindings(output);
   } catch (err) {
-    log.error(TAG8, `Deep review failed: ${err instanceof Error ? err.message : err}`);
+    log.error(TAG10, `Deep review failed: ${err instanceof Error ? err.message : err}`);
     return [];
   } finally {
     if (devServer && !devServer.killed) {
@@ -2735,8 +3534,8 @@ function attemptAutoFix(worktreePath, config, errors) {
     "--",
     fixPrompt
   ];
-  log.info(TAG8, "Spawning Claude for auto-fix...");
-  execFileSync4("claude", args, {
+  log.info(TAG10, "Spawning Claude for auto-fix...");
+  execFileSync5("claude", args, {
     cwd: worktreePath,
     timeout: config.verification.timeout,
     stdio: "pipe",
@@ -2773,7 +3572,7 @@ async function reportFindings(client, cardId, result, recovery) {
     try {
       await client.createSubtask(cardId, title);
     } catch (err) {
-      log.error(TAG8, `Failed to create subtask: ${err instanceof Error ? err.message : err}`);
+      log.error(TAG10, `Failed to create subtask: ${err instanceof Error ? err.message : err}`);
     }
   }));
   if (overflow > 0) {
@@ -2781,7 +3580,7 @@ async function reportFindings(client, cardId, result, recovery) {
       await client.createSubtask(cardId, `...and ${overflow} more issues`);
     } catch {}
   }
-  log.info(TAG8, `Reported ${Math.min(items.length, maxSubtasks)} finding(s) as subtasks on card ${cardId}`);
+  log.info(TAG10, `Reported ${Math.min(items.length, maxSubtasks)} finding(s) as subtasks on card ${cardId}`);
 }
 function combineOutput(err) {
   const stderr = err?.stderr?.toString() ?? "";
@@ -2841,7 +3640,7 @@ class DevServerReadinessError extends Error {
   }
 }
 function waitForDevServer(proc, timeout) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     let settled = false;
     const cleanup = () => {
       proc.stdout?.off("data", onData);
@@ -2855,7 +3654,7 @@ function waitForDevServer(proc, timeout) {
         return;
       settled = true;
       cleanup();
-      resolve2();
+      resolve3();
     };
     const settleReject = (err) => {
       if (settled)
@@ -2905,7 +3704,7 @@ async function probeDevServer(port, timeoutMs = 5000) {
 }
 
 // src/gate-collectors.ts
-var TAG9 = "gate-collectors";
+var TAG11 = "gate-collectors";
 async function resolveStageGate(client, card) {
   const currentStage = card.current_stage;
   const playbookId = card.playbook_id;
@@ -2923,7 +3722,7 @@ async function resolveStageGate(client, card) {
       return null;
     return { stage: resolution.stage, gate };
   } catch (err) {
-    log.warn(TAG9, `resolveStageGate failed for stage "${currentStage}": ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG11, `resolveStageGate failed for stage "${currentStage}": ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
@@ -3048,13 +3847,14 @@ function buildGateCollectorRegistry(deps) {
   }
   if (deps.oracle) {
     registry.oracle_passed = new OracleCollector(deps.oracle);
+    registry.oracle_red = new OracleRedCollector(deps.oracle);
   }
   return registry;
 }
 async function collectGateEvidence(registry, context) {
   const collector = registry[context.gate.kind];
   if (!collector) {
-    log.info(TAG9, `No collector for gate kind "${context.gate.kind}" — reporting blocked`);
+    log.info(TAG11, `No collector for gate kind "${context.gate.kind}" — reporting blocked`);
     return {
       result: "blocked",
       structured: {
@@ -3066,14 +3866,14 @@ async function collectGateEvidence(registry, context) {
     return await collector.collect(context);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    log.warn(TAG9, `Collector for "${context.gate.kind}" threw: ${msg} — reporting blocked`);
+    log.warn(TAG11, `Collector for "${context.gate.kind}" threw: ${msg} — reporting blocked`);
     return { result: "blocked", structured: { error: msg } };
   }
 }
 // src/git-diff-stat.ts
 init_log();
-import { execFileSync as execFileSync5 } from "node:child_process";
-var TAG10 = "git-diff-stat";
+import { execFileSync as execFileSync6 } from "node:child_process";
+var TAG12 = "git-diff-stat";
 var MAX_CHANGED_FILES = 30;
 function parseNumstat(raw, maxFiles = MAX_CHANGED_FILES) {
   const files = [];
@@ -3152,10 +3952,10 @@ function formatDiffSummary(diff, maxFiles = 100) {
 }
 function captureDiffStat(worktreePath, baseBranch, maxFiles = MAX_CHANGED_FILES) {
   try {
-    const raw = execFileSync5("git", ["diff", "--numstat", `${baseBranch}...HEAD`], { cwd: worktreePath, encoding: "utf-8", timeout: 30000 });
+    const raw = execFileSync6("git", ["diff", "--numstat", `${baseBranch}...HEAD`], { cwd: worktreePath, encoding: "utf-8", timeout: 30000 });
     return parseNumstat(raw, maxFiles);
   } catch (err) {
-    log.warn(TAG10, "git diff --numstat failed", {
+    log.warn(TAG12, "git diff --numstat failed", {
       event: "diff_stat_failed",
       error: err instanceof Error ? err.message : String(err)
     });
@@ -3168,7 +3968,7 @@ init_git_pr();
 
 // src/harmony-client.ts
 init_log();
-var TAG12 = "harmony-client";
+var TAG14 = "harmony-client";
 function readClientConfig(env) {
   const apiUrl = env.HARMONY_API_URL?.trim();
   const apiKey = env.HARMONY_API_KEY?.trim();
@@ -3220,7 +4020,7 @@ class HarmonyClient {
       purpose: "gate_evaluation"
     });
     if (!response.ok) {
-      log.warn(TAG12, `Oracle fetch for stage ${stageId} returned ${response.status} — no oracle read, the gate will report blocked`);
+      log.warn(TAG14, `Oracle fetch for stage ${stageId} returned ${response.status} — no oracle read, the gate will report blocked`);
       return null;
     }
     const body = await response.json();
@@ -3300,138 +4100,101 @@ function relayAgentEvent(draft) {
   }
   return { type: "agent_event", event: draft };
 }
-// src/oracle.ts
-import { lstat, mkdir, realpath, rm, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute as isAbsolute2, resolve as resolve2, sep as sep2 } from "node:path";
-async function resolveContained(repoPath, relativePath) {
-  if (isAbsolute2(relativePath)) {
-    throw new Error(`refusing to place an oracle at an absolute path: ${relativePath}`);
-  }
-  if (relativePath === "" || relativePath === ".") {
-    throw new Error(`refusing to place an oracle at the empty/self path: "${relativePath}"`);
-  }
-  const root = await realpath(repoPath);
-  const target = resolve2(root, relativePath);
-  if (target !== root && !target.startsWith(root + sep2)) {
-    throw new Error(`refusing to place an oracle outside the worktree: ${relativePath}`);
-  }
-  let cursor = root;
-  for (const segment of relativePath.split("/")) {
-    cursor = resolve2(cursor, segment);
-    const stat = await lstat(cursor).catch(() => null);
-    if (stat?.isSymbolicLink()) {
-      throw new Error(`refusing an oracle path through a symlink component: ${relativePath}`);
-    }
-  }
-  return target;
+// src/repair-sandbox.ts
+init_log();
+import { randomUUID } from "node:crypto";
+import { promisify as promisify3 } from "node:util";
+var TAG15 = "repair-sandbox";
+async function dockerExec(argv, opts) {
+  const { execFile: execFile3 } = await import("node:child_process");
+  return promisify3(execFile3)("docker", argv, {
+    encoding: "utf-8",
+    ...opts
+  });
 }
-async function place(repoPath, oracle) {
-  const target = await resolveContained(repoPath, oracle.path);
-  await mkdir(dirname(target), { recursive: true });
-  await writeFile(target, oracle.content, "utf8");
+var MAX_OUTPUT_BUFFER3 = 20971520;
+var PROBE_TIMEOUT_MS = 1e4;
+var SANDBOX_MOUNT = "/repo";
+var SANDBOX_MEMORY = "4g";
+var SANDBOX_PIDS = "512";
+var dockerProbe = null;
+async function sandboxAvailable() {
+  if (dockerProbe === true)
+    return true;
+  try {
+    await dockerExec(["version", "--format", "{{.Server.Version}}"], {
+      timeout: PROBE_TIMEOUT_MS
+    });
+    dockerProbe = true;
+  } catch {
+    dockerProbe = false;
+  }
+  return dockerProbe;
 }
-async function remove(repoPath, oracle) {
-  const target = await resolveContained(repoPath, oracle.path);
-  await rm(target, { force: true });
+function __resetSandboxProbe() {
+  dockerProbe = null;
 }
-var ORACLE_RUNNERS = {
-  vitest: (path) => ({
-    command: "npx",
-    args: ["--no-install", "vitest", "run", path]
-  }),
-  bun: (path) => ({ command: "bun", args: ["test", path] })
-};
-var ORACLE_RUNNER_HINTS = Object.keys(ORACLE_RUNNERS).sort();
-var ORACLE_OUTPUT_LIMIT = 64 * 1024;
-var ORACLE_SIGINT_GRACE_MS = 2000;
-var ORACLE_SIGTERM_GRACE_MS = 3000;
-var ORACLE_DRAIN_GRACE_MS = 500;
-function resolveOracleRunner(oracle) {
-  const hint = oracle.runnerHint?.trim().toLowerCase() ?? "";
-  const build = Object.hasOwn(ORACLE_RUNNERS, hint) ? ORACLE_RUNNERS[hint] : undefined;
-  if (!build) {
-    throw new Error(`refusing to run the held test: runner_hint ${JSON.stringify(oracle.runnerHint)} is not in the motor's allow-list (${ORACLE_RUNNER_HINTS.join(", ")})`);
-  }
-  return build(argvPath(oracle.path));
+async function removeContainer(name) {
+  try {
+    await dockerExec(["rm", "--force", name], { timeout: PROBE_TIMEOUT_MS });
+    log.warn(TAG15, `removed the timed-out sandbox container ${name}`);
+  } catch {}
 }
-function argvPath(path) {
-  return path.startsWith("./") ? path : `./${path}`;
+function sandboxRunArgs(image, worktree, command, name) {
+  return [
+    "run",
+    "--rm",
+    ...name ? ["--name", name] : [],
+    "--network=none",
+    "--cap-drop=ALL",
+    "--security-opt=no-new-privileges",
+    `--memory=${SANDBOX_MEMORY}`,
+    `--pids-limit=${SANDBOX_PIDS}`,
+    ...typeof process.getuid === "function" && typeof process.getgid === "function" ? ["--user", `${process.getuid()}:${process.getgid()}`] : [],
+    "--env",
+    "HOME=/tmp",
+    "--volume",
+    `${worktree}:${SANDBOX_MOUNT}`,
+    "--workdir",
+    SANDBOX_MOUNT,
+    "--entrypoint",
+    command.cmd,
+    image,
+    ...command.args
+  ];
 }
-async function runHeldOracle(repoPath, oracle, timeoutMs = DEFAULT_METRIC_TIMEOUT_MS) {
-  const { command, args } = resolveOracleRunner(oracle);
-  return await new Promise((settleOk, settleErr) => {
-    let child;
-    try {
-      child = spawnInGroup(command, args, {
-        cwd: repoPath,
-        stdio: ["ignore", "pipe", "pipe"]
-      });
-    } catch (err) {
-      settleErr(err);
-      return;
-    }
-    const pgid = child.pid;
-    let output = "";
-    let settled = false;
-    let killing = false;
-    let timer;
-    let drainTimer;
-    const settle = (failure, result) => {
-      if (settled)
-        return;
-      settled = true;
-      if (timer)
-        clearTimeout(timer);
-      if (drainTimer)
-        clearTimeout(drainTimer);
-      reapGroup(pgid);
-      if (failure)
-        settleErr(failure);
-      else
-        settleOk(result);
-    };
-    const append = (chunk) => {
-      if (output.length >= ORACLE_OUTPUT_LIMIT)
-        return;
-      output += chunk.toString("utf8");
-      if (output.length > ORACLE_OUTPUT_LIMIT) {
-        output = `${output.slice(0, ORACLE_OUTPUT_LIMIT)}
-… output truncated at ${ORACLE_OUTPUT_LIMIT} characters`;
-      }
-    };
-    child.stdout?.on("data", append);
-    child.stderr?.on("data", append);
-    child.once("error", (err) => settle(err));
-    const settleFromExit = (code, signal) => {
-      if (drainTimer)
-        clearTimeout(drainTimer);
-      if (code === null) {
-        settle(new Error(`the held test was terminated by signal ${signal}`));
-        return;
-      }
-      settle(null, { exitCode: code, output });
-    };
-    child.once("exit", (code, signal) => {
-      if (killing)
-        return;
-      if (timer)
-        clearTimeout(timer);
-      reapGroup(pgid);
-      drainTimer = setTimeout(() => settleFromExit(code, signal), ORACLE_DRAIN_GRACE_MS);
-      child.once("close", () => settleFromExit(code, signal));
+async function runInSandbox(args) {
+  const name = `harmony-repair-${randomUUID()}`;
+  const argv = sandboxRunArgs(args.image, args.worktree, args.command, name);
+  log.info(TAG15, `sandbox: ${args.command.cmd} ${args.command.args.join(" ")} (image ${args.image})`);
+  try {
+    const { stdout } = await dockerExec(argv, {
+      timeout: args.timeoutMs,
+      maxBuffer: MAX_OUTPUT_BUFFER3
     });
-    timer = setTimeout(() => {
-      if (settled)
-        return;
-      killing = true;
-      terminateGroup(child, {
-        sigintTimeoutMs: ORACLE_SIGINT_GRACE_MS,
-        sigtermTimeoutMs: ORACLE_SIGTERM_GRACE_MS
-      }).catch(() => {}).then(() => {
-        settle(new Error(`the held test did not finish within ${timeoutMs}ms`));
-      });
-    }, timeoutMs);
-  });
+    return { passed: true, output: stdout ?? "" };
+  } catch (err) {
+    const e = err;
+    const output = `${e.stdout ?? ""}${e.stderr ?? ""}`;
+    if (typeof e.code !== "number") {
+      const timedOut = e.killed === true || e.signal != null;
+      if (timedOut)
+        await removeContainer(name);
+      return {
+        passed: false,
+        output,
+        sandboxError: timedOut ? `the sandbox timed out after ${args.timeoutMs}ms` : `the sandbox did not run: ${e.message ?? "unknown error"}`
+      };
+    }
+    if (e.code === 125) {
+      return {
+        passed: false,
+        output,
+        sandboxError: `the sandbox could not start (image "${args.image}" missing or unusable)`
+      };
+    }
+    return { passed: false, output };
+  }
 }
 // src/run-sizing.ts
 init_dist();
@@ -3531,14 +4294,37 @@ var defaultRunSize = async ({
     cwd,
     model
   };
+  return collectSizingOutput(runner.start(input));
+};
+async function collectSizingOutput(events) {
   const parts = [];
-  for await (const ev of runner.start(input)) {
+  let named;
+  let sawError = false;
+  for await (const ev of events) {
     if (ev.kind === "assistant_text")
       parts.push(ev.payload.text);
+    if (ev.kind === "error") {
+      sawError = true;
+      named ??= sizingFailureFromError(ev.payload.message) ?? undefined;
+    }
   }
-  return parts.join(`
-`);
-};
+  const failure = named ?? (sawError ? "spawn" : undefined);
+  return { text: parts.join(`
+`), ...failure ? { failure } : {} };
+}
+function sizingFailureFromError(message) {
+  const subtype = resultErrorSubtype(message);
+  if (!subtype)
+    return null;
+  switch (subtype) {
+    case "error_max_turns":
+      return "turns";
+    case "error_max_budget_usd":
+      return "budget";
+    default:
+      return "spawn";
+  }
+}
 function buildSizingPrompt(title, description) {
   const card = JSON.stringify({
     title: title.slice(0, PROMPT_TITLE_MAX),
@@ -3589,7 +4375,7 @@ function sizingEventSource(source) {
 async function sizeRun(deps) {
   const requested = deps.model ?? SIZING_MODEL;
   if (!requested)
-    return null;
+    return { status: "disabled" };
   const model = clampWithdrawn(requested);
   const timeoutMs = deps.timeoutMs ?? SIZING_TIMEOUT_MS;
   const run = deps.runSize ?? defaultRunSize;
@@ -3597,7 +4383,7 @@ async function sizeRun(deps) {
   let timer;
   let runner = null;
   try {
-    const text = await Promise.race([
+    const result = await Promise.race([
       run({
         prompt,
         cwd: deps.cwd,
@@ -3616,11 +4402,16 @@ async function sizeRun(deps) {
         }, timeoutMs);
       })
     ]);
-    if (text === null)
-      return null;
-    return parseVerdict(text);
+    if (result === null)
+      return { status: "failed", reason: "timeout" };
+    const sizing = parseVerdict(result.text);
+    if (sizing)
+      return { status: "sized", sizing };
+    if (result.failure)
+      return { status: "failed", reason: result.failure };
+    return { status: "failed", reason: "malformed" };
   } catch {
-    return null;
+    return { status: "failed", reason: "spawn" };
   } finally {
     if (timer)
       clearTimeout(timer);
@@ -3652,10 +4443,10 @@ async function runStage(request, deps) {
 }
 // src/worktree.ts
 init_log();
-import { execFileSync as execFileSync7, execSync } from "node:child_process";
+import { execFileSync as execFileSync8, execSync } from "node:child_process";
 import { existsSync as existsSync3, readdirSync as readdirSync2, rmSync } from "node:fs";
 import { resolve as resolve3 } from "node:path";
-var TAG13 = "worktree";
+var TAG16 = "worktree";
 
 class WorktreeBaseError extends Error {
   constructor(message) {
@@ -3663,7 +4454,7 @@ class WorktreeBaseError extends Error {
     this.name = "WorktreeBaseError";
   }
 }
-function fetchBaseBranch(repoRoot, baseBranch, attempts = 3, fetchImpl = (root, branch) => execFileSync7("git", ["fetch", "origin", branch], {
+function fetchBaseBranch(repoRoot, baseBranch, attempts = 3, fetchImpl = (root, branch) => execFileSync8("git", ["fetch", "origin", branch], {
   cwd: root,
   stdio: "pipe"
 })) {
@@ -3674,7 +4465,7 @@ function fetchBaseBranch(repoRoot, baseBranch, attempts = 3, fetchImpl = (root,
       return;
     } catch (err) {
       lastErr = err;
-      log.warn(TAG13, `fetch origin ${baseBranch} failed (attempt ${attempt}/${attempts})`);
+      log.warn(TAG16, `fetch origin ${baseBranch} failed (attempt ${attempt}/${attempts})`);
     }
   }
   throw new WorktreeBaseError(`Could not fetch origin/${baseBranch} after ${attempts} attempts — ` + `refusing to build on a stale base. ${gitErrorDetail(lastErr)}`);
@@ -3689,7 +4480,7 @@ function resolveWorktreeStartRef(baseBranch, branchName, continueExisting, branc
   }
   return `origin/${baseBranch}`;
 }
-function fetchExistingBranch(repoRoot, branchName, attempts = 3, lsRemoteImpl = (root, branch) => execFileSync7("git", ["ls-remote", "--exit-code", "origin", `refs/heads/${branch}`], { cwd: root, stdio: "pipe" }), fetchImpl = (root, branch) => execFileSync7("git", [
+function fetchExistingBranch(repoRoot, branchName, attempts = 3, lsRemoteImpl = (root, branch) => execFileSync8("git", ["ls-remote", "--exit-code", "origin", `refs/heads/${branch}`], { cwd: root, stdio: "pipe" }), fetchImpl = (root, branch) => execFileSync8("git", [
   "fetch",
   "origin",
   `+refs/heads/${branch}:refs/remotes/origin/${branch}`
@@ -3704,7 +4495,7 @@ function fetchExistingBranch(repoRoot, branchName, attempts = 3, lsRemoteImpl =
       if (err.status === 2)
         return false;
       lastErr = err;
-      log.warn(TAG13, `ls-remote ${branchName} failed (attempt ${attempt}/${attempts})`);
+      log.warn(TAG16, `ls-remote ${branchName} failed (attempt ${attempt}/${attempts})`);
     }
   }
   if (!probed) {
@@ -3716,14 +4507,14 @@ function fetchExistingBranch(repoRoot, branchName, attempts = 3, lsRemoteImpl =
       return true;
     } catch (err) {
       lastErr = err;
-      log.warn(TAG13, `fetch ${branchName} failed (attempt ${attempt}/${attempts})`);
+      log.warn(TAG16, `fetch ${branchName} failed (attempt ${attempt}/${attempts})`);
     }
   }
   throw new WorktreeBaseError(`${branchName} exists on origin but could not be fetched after ${attempts} attempts: ${gitErrorDetail(lastErr)}. Refusing to rebuild the branch.`);
 }
 function readWorktreeHead(worktreePath) {
   try {
-    return execFileSync7("git", ["rev-parse", "HEAD"], {
+    return execFileSync8("git", ["rev-parse", "HEAD"], {
       cwd: worktreePath,
       encoding: "utf-8"
     }).trim();
@@ -3732,50 +4523,50 @@ function readWorktreeHead(worktreePath) {
   }
 }
 function createWorktree(basePath, baseBranch, branchName, opts = {}) {
-  const repoRoot = execFileSync7("git", ["rev-parse", "--show-toplevel"], {
+  const repoRoot = execFileSync8("git", ["rev-parse", "--show-toplevel"], {
     encoding: "utf-8"
   }).trim();
   const worktreeDir = resolve3(repoRoot, basePath, branchName);
   if (existsSync3(worktreeDir)) {
-    log.warn(TAG13, `Worktree already exists at ${worktreeDir}, cleaning up`);
+    log.warn(TAG16, `Worktree already exists at ${worktreeDir}, cleaning up`);
     cleanupWorktree(worktreeDir, branchName);
   }
   try {
-    execFileSync7("git", ["worktree", "prune", "--expire=now"], {
+    execFileSync8("git", ["worktree", "prune", "--expire=now"], {
       cwd: repoRoot,
       stdio: "pipe"
     });
   } catch {}
   fetchBaseBranch(repoRoot, baseBranch);
   const startRef = resolveWorktreeStartRef(baseBranch, branchName, opts.continueExisting ?? false, () => fetchExistingBranch(repoRoot, branchName));
-  log.info(TAG13, `Creating worktree: ${worktreeDir} (branch: ${branchName}, base: ${startRef})`);
+  log.info(TAG16, `Creating worktree: ${worktreeDir} (branch: ${branchName}, base: ${startRef})`);
   try {
-    execFileSync7("git", ["worktree", "add", "-B", branchName, worktreeDir, startRef], { cwd: repoRoot, stdio: "pipe" });
+    execFileSync8("git", ["worktree", "add", "-B", branchName, worktreeDir, startRef], { cwd: repoRoot, stdio: "pipe" });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    log.warn(TAG13, `worktree add failed, attempting forced recovery: ${msg}`);
+    log.warn(TAG16, `worktree add failed, attempting forced recovery: ${msg}`);
     removeWorktreeHoldingBranch(repoRoot, branchName, worktreeDir);
     try {
-      execFileSync7("git", ["worktree", "remove", worktreeDir, "--force"], {
+      execFileSync8("git", ["worktree", "remove", worktreeDir, "--force"], {
         cwd: repoRoot,
         stdio: "pipe"
       });
     } catch {}
     try {
-      execFileSync7("git", ["worktree", "prune", "--expire=now"], {
+      execFileSync8("git", ["worktree", "prune", "--expire=now"], {
         cwd: repoRoot,
         stdio: "pipe"
       });
     } catch {}
     try {
-      execFileSync7("git", ["branch", "-D", branchName], {
+      execFileSync8("git", ["branch", "-D", branchName], {
         cwd: repoRoot,
         stdio: "pipe"
       });
     } catch {}
-    execFileSync7("git", ["worktree", "add", "-B", branchName, worktreeDir, startRef], { cwd: repoRoot, stdio: "pipe" });
+    execFileSync8("git", ["worktree", "add", "-B", branchName, worktreeDir, startRef], { cwd: repoRoot, stdio: "pipe" });
   }
-  log.info(TAG13, "Installing dependencies in worktree...");
+  log.info(TAG16, "Installing dependencies in worktree...");
   try {
     execSync(installCommand(), {
       cwd: worktreeDir,
@@ -3783,7 +4574,7 @@ function createWorktree(basePath, baseBranch, branchName, opts = {}) {
       timeout: 60000
     });
   } catch {
-    log.warn(TAG13, "Install failed (may be fine if deps are hoisted)");
+    log.warn(TAG16, "Install failed (may be fine if deps are hoisted)");
   }
   return worktreeDir;
 }
@@ -3799,7 +4590,7 @@ function containsForeignWorktrees(dir) {
   return children.some((child) => existsSync3(resolve3(dir, child, ".git")));
 }
 function cleanupWorktree(worktreePath, branchName) {
-  const repoRoot = execFileSync7("git", ["rev-parse", "--show-toplevel"], {
+  const repoRoot = execFileSync8("git", ["rev-parse", "--show-toplevel"], {
     encoding: "utf-8"
   }).trim();
   if (existsSync3(worktreePath)) {
@@ -3807,18 +4598,18 @@ function cleanupWorktree(worktreePath, branchName) {
       throw new Error(`Refusing to remove ${worktreePath}: it is not a git worktree itself, ` + `but git worktrees live directly beneath it. Removing it would ` + `destroy them — pass the individual worktree paths instead (#928).`);
     }
     try {
-      execFileSync7("git", ["worktree", "remove", worktreePath, "--force"], {
+      execFileSync8("git", ["worktree", "remove", worktreePath, "--force"], {
         cwd: repoRoot,
         stdio: "pipe"
       });
-      log.info(TAG13, `Removed worktree: ${worktreePath}`);
+      log.info(TAG16, `Removed worktree: ${worktreePath}`);
     } catch (err) {
-      log.warn(TAG13, `Failed to remove worktree cleanly: ${err instanceof Error ? err.message : err}`);
+      log.warn(TAG16, `Failed to remove worktree cleanly: ${err instanceof Error ? err.message : err}`);
       if (existsSync3(worktreePath)) {
         rmSync(worktreePath, { recursive: true, force: true });
       }
       try {
-        execFileSync7("git", ["worktree", "prune", "--expire=now"], {
+        execFileSync8("git", ["worktree", "prune", "--expire=now"], {
           cwd: repoRoot,
           stdio: "pipe"
         });
@@ -3826,7 +4617,7 @@ function cleanupWorktree(worktreePath, branchName) {
     }
   } else {
     try {
-      execFileSync7("git", ["worktree", "prune", "--expire=now"], {
+      execFileSync8("git", ["worktree", "prune", "--expire=now"], {
         cwd: repoRoot,
         stdio: "pipe"
       });
@@ -3834,7 +4625,7 @@ function cleanupWorktree(worktreePath, branchName) {
   }
   if (branchName) {
     try {
-      execFileSync7("git", ["branch", "-D", branchName], {
+      execFileSync8("git", ["branch", "-D", branchName], {
         cwd: repoRoot,
         stdio: "pipe"
       });
@@ -3844,7 +4635,7 @@ function cleanupWorktree(worktreePath, branchName) {
 function removeWorktreeHoldingBranch(repoRoot, branchName, exceptDir) {
   let listing;
   try {
-    listing = execFileSync7("git", ["worktree", "list", "--porcelain"], {
+    listing = execFileSync8("git", ["worktree", "list", "--porcelain"], {
       cwd: repoRoot,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -3872,17 +4663,17 @@ function removeWorktreeHoldingBranch(repoRoot, branchName, exceptDir) {
   if (exceptDir && resolve3(holderPath) === resolve3(exceptDir))
     return null;
   try {
-    execFileSync7("git", ["worktree", "remove", holderPath, "--force"], {
+    execFileSync8("git", ["worktree", "remove", holderPath, "--force"], {
       cwd: repoRoot,
       stdio: "pipe"
     });
-    log.warn(TAG13, `Evicted worktree ${holderPath} holding branch ${branchName} so it can be reused (#732)`);
+    log.warn(TAG16, `Evicted worktree ${holderPath} holding branch ${branchName} so it can be reused (#732)`);
   } catch (err) {
-    log.warn(TAG13, `Failed to evict worktree ${holderPath} holding ${branchName}: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG16, `Failed to evict worktree ${holderPath} holding ${branchName}: ${err instanceof Error ? err.message : err}`);
     return null;
   }
   try {
-    execFileSync7("git", ["worktree", "prune", "--expire=now"], {
+    execFileSync8("git", ["worktree", "prune", "--expire=now"], {
       cwd: repoRoot,
       stdio: "pipe"
     });
@@ -3890,13 +4681,13 @@ function removeWorktreeHoldingBranch(repoRoot, branchName, exceptDir) {
   return holderPath;
 }
 function resolveRepoRoot() {
-  return execFileSync7("git", ["rev-parse", "--show-toplevel"], {
+  return execFileSync8("git", ["rev-parse", "--show-toplevel"], {
     encoding: "utf-8"
   }).trim();
 }
 function localBranchExists(branchName, repoRoot) {
   try {
-    execFileSync7("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], { cwd: repoRoot, stdio: "ignore" });
+    execFileSync8("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], { cwd: repoRoot, stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -3906,7 +4697,7 @@ function branchAheadOfItsRemote(branchName, repoRoot = resolveRepoRoot()) {
   if (!localBranchExists(branchName, repoRoot))
     return false;
   try {
-    const out = execFileSync7("git", ["rev-list", branchName, "--not", "--remotes=origin"], { cwd: repoRoot, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+    const out = execFileSync8("git", ["rev-list", branchName, "--not", "--remotes=origin"], { cwd: repoRoot, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).trim();
     return out.length > 0;
   } catch {
     return false;
@@ -3917,17 +4708,17 @@ async function rescueUnpushedBranch(client, cardId, branchName, repoRoot = resol
   try {
     pushBranch2(branchName, repoRoot);
   } catch (err) {
-    log.error(TAG13, `push-rescue failed for ${branchName} — leaving local branch ref intact (recoverable via git reflog / the local branch): ${err instanceof Error ? err.message : err}`);
+    log.error(TAG16, `push-rescue failed for ${branchName} — leaving local branch ref intact (recoverable via git reflog / the local branch): ${err instanceof Error ? err.message : err}`);
     return false;
   }
-  log.warn(TAG13, `push-rescued unpushed branch ${branchName} to origin before teardown`);
+  log.warn(TAG16, `push-rescued unpushed branch ${branchName} to origin before teardown`);
   try {
     const url = getBranchWebUrl2(branchName, repoRoot);
     const recover = url ? `View it at ${url} or recover locally: \`git fetch && git checkout ${branchName}\`` : `Recover it locally: \`git fetch && git checkout ${branchName}\``;
     const body = `⚠ Run ended before completion. Committed work was push-rescued to ` + `\`origin/${branchName}\` so it isn't lost. ${recover}`;
     await client.addComment(cardId, body, { commentType: "message" });
   } catch (err) {
-    log.warn(TAG13, `push-rescue comment failed for ${branchName} (work is still safe on origin): ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG16, `push-rescue comment failed for ${branchName} (work is still safe on origin): ${err instanceof Error ? err.message : err}`);
   }
   return true;
 }
@@ -3945,7 +4736,7 @@ async function teardownWorktree(client, cardId, worktreePath, branchName) {
       const ok = await rescueUnpushedBranch(client, cardId, branchName, repoRoot);
       if (!ok) {
         skipBranchDelete = true;
-        log.error(TAG13, `Keeping local branch ${branchName} (push-rescue failed) to avoid orphaning its commit`);
+        log.error(TAG16, `Keeping local branch ${branchName} (push-rescue failed) to avoid orphaning its commit`);
       }
     }
   }
@@ -3962,32 +4753,43 @@ export {
   waitForDevServer,
   validateGitProviderCli,
   upsertReviewedSha,
+  upsertCiReviewRequestedSha,
   updateExistingPr,
   testCommand,
   terminateGroup,
   teardownWorktree,
   supportsDevServer,
   summarizeUnifiedDiff,
+  summarizeOracleReport,
   spawnRunArgs,
   spawnInGroup,
+  sizingFailureFromError,
   sizingEventSource,
   sizeRun,
   signalGroup,
+  sanitizeCiText,
+  sandboxRunArgs,
+  sandboxAvailable,
   runVerification,
   runTests,
   runStage,
   runMetricCommand,
   runLint,
+  runInSandbox,
   runHeldOracle,
   runFormatFix,
   runDeepReview,
   runBuild,
+  resultErrorSubtype,
+  resultErrorMessage,
   resolveWorktreeStartRef,
   resolveStageGate,
   resolvePrUrl,
   resolvePrHeadBranch,
   resolveOracleRunner,
   rescueUnpushedBranch,
+  rerunFailedJobs,
+  requestIndependentReview,
   reportFindings,
   renameRemoteBranch,
   removeWorktreeHoldingBranch,
@@ -3996,6 +4798,7 @@ export {
   relayAgentEvent,
   reapGroup,
   readWorktreeHead,
+  readPrChecks,
   readClientConfig,
   pushBranch,
   probeDevServer,
@@ -4004,6 +4807,7 @@ export {
   parseNumstat,
   parseMetricValue,
   parseJudgeVerdict,
+  parseFailedChecks,
   normalizeGateSpec,
   mergePullRequest,
   mapSdkErrorKind,
@@ -4013,10 +4817,14 @@ export {
   lintCommand,
   isTestFile,
   isPretty,
+  isPrOnOrigin,
   isInsideTree,
   installCommand,
+  gradeOracleRed,
   getPrStatus,
+  getPrFailedChecks,
   getHeadSha,
+  getFailedRunLog,
   getBranchWebUrl,
   gateConfigErrorReason,
   formatFixCommand,
@@ -4026,14 +4834,19 @@ export {
   filterTestFiles,
   fetchExistingBranch,
   fetchBaseBranch,
+  extractWorkflowRunId,
   extractReviewedSha,
   extractPrUrl,
+  extractCiReviewRequestedSha,
   extractAzurePrId,
   envKeysDroppedByLaunch,
   detectPackageManager,
   detectGitProvider,
   detect,
+  describeCiFailure,
   describeApiError,
+  deriveReviewVerdictState,
+  deriveIndependentReviewState,
   deriveCiStatus,
   decidePrBranch,
   decideConfinedTool,
@@ -4042,9 +4855,12 @@ export {
   createPullRequest,
   cooldownMsFor,
   confineToRepo,
+  collectSizingOutput,
   collectGateEvidence,
   cleanupWorktree,
   classifyRunError,
+  classifyCiFailures,
+  classifyCiFailure,
   clampWithdrawn,
   chooseImplementModel,
   checkPrMergeStatus,
@@ -4057,11 +4873,14 @@ export {
   branchAheadOfItsRemote,
   attemptAutoFix,
   _resetCache,
+  __resetSandboxProbe,
   WorktreeBaseError,
   SdkAgentRunner,
   SIZING_MODEL,
   SDK_ALLOWED_TOOLS,
+  SANDBOX_MOUNT,
   ReviewPassedCollector,
+  OracleRedCollector,
   OracleCollector,
   ORACLE_RUNNER_HINTS,
   MOTOR_TOOL_INPUT_VALUE_MAX,
@@ -4078,6 +4897,8 @@ export {
   DEFAULT_METRIC_TIMEOUT_MS,
   CommandMetricCollector,
   ChecklistDodCollector,
+  CONFINED_WRITE_TOOLS,
+  CONFINED_READ_TOOLS,
   BuildGreenCollector,
   ArtifactCollector
 };