karajan-code 2.17.1 → 2.18.1

package/src/hu/auto-generator.js

@@ -66,64 +66,191 @@ export function needsSetupHu({ isNewProject = false, stackHints = [], subtasks =
   return subtasks.some(s => setupKeywords.test(s));
 }
 
+// Stack-hint keyword sets. Used by filterConflictingHints (drop hints
+// from other ecosystems once one is detected) and by
+// resolveLanguageFromHints (pick the canonical language for setup +
+// acceptance_tests templates).
+const HINT_NODE = new Set(["express", "vite", "vitest", "jest", "next", "astro", "react", "vue", "svelte", "nestjs", "monorepo", "workspaces"]);
+const HINT_PYTHON = new Set(["pytest", "flask", "fastapi", "django", "numpy", "pandas"]);
+const HINT_GO = new Set(["gin", "fiber", "go"]);
+const HINT_RUST = new Set(["cargo", "rust"]);
+
 /**
- * Filter conflicting stack hints. When Node.js ecosystem keywords are present,
- * remove Go/Rust/Python keywords that were detected from gitignore patterns
- * but aren't actually part of the task.
+ * Drop hints from OTHER ecosystems when one is clearly the project's.
+ * Symmetric: previously only node-vs-go was filtered, so a Python
+ * project that also had "vitest" in a stale gitignore would still
+ * receive vitest in its setup HU.
  */
 function filterConflictingHints(hints) {
   if (!hints || hints.length === 0) return hints;
-  const nodeEcosystem = new Set(["express", "vite", "vitest", "jest", "next", "astro", "react", "vue", "svelte", "nestjs", "monorepo", "workspaces"]);
-  const goKeywords = new Set(["gin", "fiber", "go"]);
-  const hasNode = hints.some(h => nodeEcosystem.has(h));
-  if (!hasNode) return hints;
-  return hints.filter(h => !goKeywords.has(h));
+  const setForEachLang = [
+    ["python", HINT_PYTHON],
+    ["go", HINT_GO],
+    ["rust", HINT_RUST],
+    ["node", HINT_NODE],
+  ];
+  const present = setForEachLang.filter(([, set]) => hints.some((h) => set.has(h)));
+  if (present.length <= 1) return hints;
+  // First ecosystem found in the original hints order wins. We keep
+  // ambiguous keywords (those not in any set) and the winner's own
+  // keywords; we drop the explicit losers from competing ecosystems.
+  const winnerSet = present[0][1];
+  const losers = present.slice(1).flatMap(([, s]) => [...s]);
+  return hints.filter((h) => winnerSet.has(h) || !losers.includes(h));
+}
+
+/**
+ * Pick the canonical language for setup + acceptance_test templates
+ * based on the (already filtered) stack hints. Falls back to
+ * javascript so existing Node-centric runs keep their previous shape.
+ * @param {string[]} hints
+ * @returns {"python"|"go"|"rust"|"javascript"}
+ */
+export function resolveLanguageFromHints(hints) {
+  if (!hints || hints.length === 0) return "javascript";
+  if (hints.some((h) => HINT_PYTHON.has(h))) return "python";
+  if (hints.some((h) => HINT_GO.has(h))) return "go";
+  if (hints.some((h) => HINT_RUST.has(h))) return "rust";
+  return "javascript";
+}
+
+// HU templates per language. The JS template is the legacy default;
+// the others were missing — every autogenerated HU got vitest /
+// npm-install hardcoded acceptance_tests regardless of stack.
+const HU_TEMPLATES = {
+  javascript: {
+    pkgManager: "npm",
+    setupBullets: [
+      "- Create package.json (with workspaces if monorepo detected from stack hints)",
+      "- Install all runtime + dev dependencies listed in stack hints",
+      "- Install test framework WITH coverage reporter (e.g. vitest + @vitest/coverage-v8)",
+      "- Configure vitest.config.js with coverage.enabled = true",
+      "- Create .env.example with placeholder variables",
+    ],
+    setupCriteria: [
+      "npm install succeeds without errors",
+      "npm test runs without error",
+      "npm run test:coverage runs without error",
+      ".env.example exists",
+    ],
+    setupTests: [
+      "npm install --ignore-scripts 2>&1 && echo PASS || echo FAIL",
+      "npx vitest run 2>&1; test $? -eq 0 && echo PASS || echo FAIL",
+      "npx vitest run --coverage 2>&1 | grep -q 'All files\\|% Stmts' && echo PASS || echo FAIL",
+      "test -f .env.example && echo PASS || echo FAIL",
+    ],
+    taskTests: [
+      "npx vitest run 2>&1; test $? -eq 0 && echo PASS || echo FAIL",
+      "npx vitest run --coverage 2>&1 | grep -q 'All files\\|% Stmts' && echo PASS || echo FAIL",
+    ],
+  },
+  python: {
+    pkgManager: "pip",
+    setupBullets: [
+      "- Create pyproject.toml (preferred) or requirements.txt",
+      "- Create a virtual env: python -m venv .venv",
+      "- Install runtime + dev dependencies (pip install -e . or pip install -r requirements.txt)",
+      "- Install pytest with coverage (pip install pytest pytest-cov)",
+      "- Create .env.example with placeholder variables",
+    ],
+    setupCriteria: [
+      "Project metadata file exists (pyproject.toml or requirements.txt)",
+      "pytest runs without error",
+      "pytest --cov reports a total",
+      ".env.example exists",
+    ],
+    setupTests: [
+      "(test -f pyproject.toml || test -f requirements.txt) && echo PASS || echo FAIL",
+      "python -m pytest 2>&1; test $? -eq 0 && echo PASS || echo FAIL",
+      "python -m pytest --cov 2>&1 | grep -q 'TOTAL\\|coverage' && echo PASS || echo FAIL",
+      "test -f .env.example && echo PASS || echo FAIL",
+    ],
+    taskTests: [
+      "python -m pytest 2>&1; test $? -eq 0 && echo PASS || echo FAIL",
+      "python -m pytest --cov 2>&1 | grep -q 'TOTAL\\|coverage' && echo PASS || echo FAIL",
+    ],
+  },
+  go: {
+    pkgManager: "go",
+    setupBullets: [
+      "- Create go.mod with `go mod init <module>`",
+      "- Install dependencies with `go get` per import",
+      "- Create .env.example with placeholder variables",
+    ],
+    setupCriteria: [
+      "go.mod exists",
+      "go test ./... runs without error",
+      "go test -cover reports coverage",
+      ".env.example exists",
+    ],
+    setupTests: [
+      "test -f go.mod && echo PASS || echo FAIL",
+      "go test ./... 2>&1; test $? -eq 0 && echo PASS || echo FAIL",
+      "go test -cover ./... 2>&1 | grep -q 'coverage:' && echo PASS || echo FAIL",
+      "test -f .env.example && echo PASS || echo FAIL",
+    ],
+    taskTests: [
+      "go test ./... 2>&1; test $? -eq 0 && echo PASS || echo FAIL",
+    ],
+  },
+  rust: {
+    pkgManager: "cargo",
+    setupBullets: [
+      "- Initialise the crate with `cargo init`",
+      "- Add dependencies with `cargo add`",
+      "- Create .env.example with placeholder variables",
+    ],
+    setupCriteria: [
+      "Cargo.toml exists",
+      "cargo test runs without error",
+      ".env.example exists",
+    ],
+    setupTests: [
+      "test -f Cargo.toml && echo PASS || echo FAIL",
+      "cargo test 2>&1; test $? -eq 0 && echo PASS || echo FAIL",
+      "test -f .env.example && echo PASS || echo FAIL",
+    ],
+    taskTests: [
+      "cargo test 2>&1; test $? -eq 0 && echo PASS || echo FAIL",
+    ],
+  },
+};
+
+function templateFor(language) {
+  return HU_TEMPLATES[language] || HU_TEMPLATES.javascript;
 }
 
 /**
  * Build a MINIMAL setup HU — project structure + deps only.
  * NEVER includes the full original task. The coder must only do setup.
  */
-function buildSetupHu({ stackHints }) {
+function buildSetupHu({ stackHints, language = "javascript" }) {
+  const tpl = templateFor(language);
   const deps = stackHints.length > 0
     ? stackHints.map(h => `- ${h}`).join("\n")
     : "- (auto-detect from subsequent HUs)";
   const certifiedText = [
-    "**Setup: initialize project structure and install dependencies.**",
+    `**Setup: initialise the ${language} project + install dependencies (package manager: ${tpl.pkgManager}).**`,
     "",
     "SCOPE (do ONLY this, nothing else):",
-    "- Create package.json (with workspaces if monorepo detected from stack hints)",
-    "- Install all runtime + dev dependencies listed in stack hints",
-    "- Install test framework WITH coverage reporter (e.g. vitest + @vitest/coverage-v8)",
-    "- Configure vitest.config.js with coverage.enabled = true",
-    "- Create .env.example with placeholder variables",
+    ...tpl.setupBullets,
     "- Verify by running each acceptance_test command below",
     "",
     "DO NOT implement any business logic, API routes, components, or features.",
     "This HU is ONLY project scaffolding.",
     "",
     "Stack hints:",
-    deps
+    deps,
   ].join("\n");
   return {
     id: "HU-01",
-    title: "Setup: project structure + dependencies",
+    title: `Setup: ${language} project structure + dependencies`,
     task_type: "infra",
     status: "certified",
     blocked_by: [],
     certified: { text: certifiedText },
-    acceptance_criteria: [
-      "npm install succeeds without errors",
-      "npm test runs without error",
-      "npm run test:coverage runs without error",
-      ".env.example exists"
-    ],
-    acceptance_tests: [
-      "npm install --ignore-scripts 2>&1 && echo PASS || echo FAIL",
-      "npx vitest run 2>&1; test $? -eq 0 && echo PASS || echo FAIL",
-      "npx vitest run --coverage 2>&1 | grep -q 'All files\\|% Stmts' && echo PASS || echo FAIL",
-      "test -f .env.example && echo PASS || echo FAIL"
-    ]
+    acceptance_criteria: tpl.setupCriteria,
+    acceptance_tests: tpl.setupTests,
   };
 }
 
@@ -131,8 +258,9 @@ function buildSetupHu({ stackHints }) {
  * Build a MINIMAL task HU — one specific, focused piece of work.
  * Includes a short goal reference (max 80 chars) NOT the full task.
  */
-function buildTaskHu({ id, subtask, projectName, blockedBy }) {
+function buildTaskHu({ id, subtask, projectName, blockedBy, language = "javascript" }) {
   const taskType = classifyTaskType(subtask);
+  const tpl = templateFor(language);
   const certifiedText = [
     `**${subtask}**`,
     "",
@@ -143,7 +271,7 @@ function buildTaskHu({ id, subtask, projectName, blockedBy }) {
     "- Add unit tests for the new code",
     "- Run ALL acceptance_tests listed below and ensure they pass",
     "- Do NOT touch code outside this subtask's scope",
-    "- Target: <200 lines changed (like an atomic PR)"
+    "- Target: <200 lines changed (like an atomic PR)",
   ].join("\n");
   return {
     id,
@@ -155,12 +283,9 @@ function buildTaskHu({ id, subtask, projectName, blockedBy }) {
     acceptance_criteria: [
       `${subtask} is implemented and working`,
       "Unit tests cover the new code",
-      "All acceptance_tests pass"
+      "All acceptance_tests pass",
     ],
-    acceptance_tests: [
-      "npx vitest run 2>&1; test $? -eq 0 && echo PASS || echo FAIL",
-      "npx vitest run --coverage 2>&1 | grep -q 'All files\\|% Stmts' && echo PASS || echo FAIL"
-    ]
+    acceptance_tests: tpl.taskTests,
   };
 }
 
@@ -182,7 +307,8 @@ export function generateHuBatch({
   stackHints = [],
   isNewProject = false,
   researcherContext = null,
-  architectContext = null
+  architectContext = null,
+  language = null,
 }) {
   if (!originalTask || typeof originalTask !== "string") {
     throw new Error("generateHuBatch: originalTask is required");
@@ -194,12 +320,17 @@ export function generateHuBatch({
   const stories = [];
   const filteredHints = filterConflictingHints(stackHints);
   const needsSetup = needsSetupHu({ isNewProject, stackHints: filteredHints, subtasks });
+  // Caller may pass a language explicitly (when it has a real
+  // detectProjectStack result from the filesystem); otherwise fall
+  // back to inferring from the hint keywords. Default 'javascript'
+  // matches the previous behaviour for Node-centric runs.
+  const resolvedLanguage = language || resolveLanguageFromHints(filteredHints);
   let nextId = 1;
 
   const projectName = deriveProjectName(originalTask);
 
   if (needsSetup) {
-    stories.push(buildSetupHu({ stackHints: filteredHints }));
+    stories.push(buildSetupHu({ stackHints: filteredHints, language: resolvedLanguage }));
     nextId = 2;
   }
 
@@ -211,7 +342,7 @@ export function generateHuBatch({
     const blockedBy = [];
     if (setupId) blockedBy.push(setupId);
     if (previousId && previousId !== setupId) blockedBy.push(previousId);
-    stories.push(buildTaskHu({ id, subtask, projectName, blockedBy }));
+    stories.push(buildTaskHu({ id, subtask, projectName, blockedBy, language: resolvedLanguage }));
     previousId = id;
     nextId += 1;
   }

package/src/orchestrator/drivers/iteration-phases/coder-and-refactorer.js

@@ -18,6 +18,25 @@ import { stageRegistry } from "../../stages/stage-classes.js";
 import { runStage } from "../../stages/stage-executor.js";
 import { handleStandbyResult } from "../error-recovery.js";
 
+/**
+ * A coder/refactorer stage hit a provider quota cap and Brain Recovery
+ * hibernated the run. Turn it into a clean loop return carrying
+ * `hibernated:true` — the iteration loop and flow-runner read that to
+ * seal the session as `hibernated` (NOT `failed`) so it stays resumable.
+ */
+function hibernateReturn(stageResult, session) {
+  return {
+    action: "return",
+    result: {
+      hibernated: true,
+      sessionId: session?.id || null,
+      reason: "quota_exhausted",
+      standbyFile: stageResult.standbyFile || null,
+      recovery: stageResult.recovery || null,
+    },
+  };
+}
+
 export async function runCoderAndRefactorerStages({ coderRoleInstance, coderRole, refactorerRole, pipelineFlags, config, logger, emitter, eventBase, session, plannedTask, trackBudget, i, brainCtx }) {
   // Coder via StageRegistry (TSK-0336). canRun = coderRequired !== false; in
   // analysis-only task types coderRequired is set to false by policy, so the
@@ -25,6 +44,7 @@ export async function runCoderAndRefactorerStages({ coderRoleInstance, coderRole
   // runFlow.
   const coderCtx = { coderRoleInstance, coderRole, config, logger, emitter, eventBase, session, plannedTask, trackBudget, iteration: i, brainCtx, pipelineFlags };
   const coderResult = await runStage(stageRegistry.get("coder"), coderCtx);
+  if (coderResult?.action === "hibernate") return hibernateReturn(coderResult, session);
   if (coderResult?.action === "pause") return { action: "return", result: coderResult.result };
   const coderStandby = await handleStandbyResult({ stageResult: coderResult, session, emitter, eventBase, i, stage: "coder", logger, config });
   if (coderStandby.handled) {
@@ -35,6 +55,7 @@ export async function runCoderAndRefactorerStages({ coderRoleInstance, coderRole
 
   if (pipelineFlags.refactorerEnabled) {
     const refResult = await runRefactorerStage({ refactorerRole, config, logger, emitter, eventBase, session, plannedTask, trackBudget, iteration: i });
+    if (refResult?.action === "hibernate") return hibernateReturn(refResult, session);
     if (refResult?.action === "pause") return { action: "return", result: refResult.result };
     const refStandby = await handleStandbyResult({ stageResult: refResult, session, emitter, eventBase, i, stage: "refactorer", logger, config });
     if (refStandby.handled) {

package/src/orchestrator/drivers/pre-loop-phases/auto-hu-batch.js

@@ -16,6 +16,7 @@
  */
 
 import { emitProgress, makeEvent } from "#utils/events.js";
+import { detectProjectStack } from "#utils/stack-detect.js";
 
 export async function maybeGenerateAutoHuBatch({
   flags, stageResults, task, logger, emitter, eventBase, projectDir, session,
@@ -40,19 +41,38 @@ export async function maybeGenerateAutoHuBatch({
     isNewProject = relevant.length === 0;
   } catch { /* ignore */ }
 
-  // Extract stack hints from planner + architect output
+  // Stack hints from planner + architect text. Now multi-ecosystem
+  // (was 13/16 JS keywords — Python/Go/Rust barely existed). Combined
+  // with `detectProjectStack(projectDir)` below to override the text
+  // heuristic with the actual filesystem reality when available.
   const stackHints = [];
   const combined = `${stageResults.planner?.plan || ""} ${stageResults.architect?.architecture ? JSON.stringify(stageResults.architect.architecture) : ""} ${task}`.toLowerCase();
-  const stackKeywords = ["express", "vite", "vitest", "jest", "next", "astro", "react", "vue", "svelte", "fastapi", "django", "spring", "gin", "nestjs", "monorepo", "workspaces"];
+  const stackKeywords = [
+    "express", "vite", "vitest", "jest", "next", "astro", "react", "vue", "svelte", "nestjs", "monorepo", "workspaces",
+    "pytest", "flask", "fastapi", "django", "numpy", "pandas",
+    "gin", "fiber", "go",
+    "cargo", "rust",
+    "spring",
+  ];
   for (const kw of stackKeywords) {
     if (combined.includes(kw)) stackHints.push(kw);
   }
 
+  // Filesystem trumps text. detectProjectStack inspects package.json /
+  // pyproject.toml / go.mod / Cargo.toml, so a pure-python repo gets
+  // `language: "python"` regardless of what the task text says.
+  let detectedLanguage = null;
+  try {
+    const fsStack = await detectProjectStack(projectDir);
+    if (fsStack?.language) detectedLanguage = fsStack.language;
+  } catch { /* best-effort */ }
+
   const batch = generateHuBatch({
     originalTask: task,
     subtasks,
     stackHints,
     isNewProject,
+    language: detectedLanguage,
     researcherContext: stageResults.researcher?.summary || null,
     architectContext: stageResults.architect?.architecture ? JSON.stringify(stageResults.architect.architecture) : null
   });

package/src/orchestrator/drivers/pre-loop-phases/inject-loaded-plan.js

@@ -32,6 +32,7 @@ import {
   setLiveOutcomeUpdater, setPreLoopContext,
 } from "#session/mutators.js";
 import { emitProgress, makeEvent } from "#utils/events.js";
+import { listActiveRuns } from "../../../utils/run-registry.js";
 
 /**
  * @param {object} args
@@ -64,6 +65,19 @@ export async function injectLoadedPlan({ flags, updatedConfig, session, stageRes
       message: `Plan loaded: ${flags.plan}`,
       detail: { planId: flags.plan, task: loadedPlan.task, version: loadedPlan.version, huCount: loadedPlan.hus?.length || 0 }
     }));
+
+    // Zombie reconciliation: a previous run may have died mid-flight,
+    // leaving HUs stuck in coding/reviewing/running. The board-side
+    // reaper only runs inside the board; without this, a headless
+    // `kj run --plan` would refuse to pick those HUs up.
+    const reaped = await reconcilePlanHuZombies({ loadedPlan, planId: flags.plan, logger });
+    if (reaped > 0) {
+      await savePlanToDisk(projectDir, loadedPlan);
+      emitProgress(emitter, makeEvent("plan:zombies-reaped", { ...eventBase, stage: "plan" }, {
+        message: `Reset ${reaped} stale HU(s) from a previous run that did not finish`,
+        detail: { planId: flags.plan, count: reaped }
+      }));
+    }
     stageResults.researcher = { ok: true, summary: "Loaded from persisted plan", fromPlan: flags.plan };
     stageResults.architect = { ok: true, summary: "Loaded from persisted plan", fromPlan: flags.plan };
     stageResults.planner = { ok: true, summary: "Loaded from persisted plan", fromPlan: flags.plan };
@@ -122,6 +136,48 @@ export async function injectLoadedPlan({ flags, updatedConfig, session, stageRes
   }
 }
 
+/**
+ * Reset HUs that look mid-execution but have no live run behind them.
+ *
+ * Resilience audit, Phase 3 (Hallazgo A1 / status-zombi). A previous
+ * `kj run --plan` flipped HUs to `coding`/`reviewing`/`running` in the
+ * plan JSON, then died (SIGKILL, terminal closed, OOM, crash). The
+ * board-side `hu-zombie-reaper` only queries SQLite and only runs
+ * inside the board process, so the plan JSON on disk kept stale
+ * in-flight statuses forever. The next `kj run --plan` then refused to
+ * pick those HUs up.
+ *
+ * Cross-check via `run-registry`: if there is a live run with our
+ * planId, do NOT touch — that run owns the in-flight HUs. Otherwise
+ * any in-flight status with no live owner is a zombie → reset to
+ * `pending` so it can run again.
+ *
+ * Mutates `loadedPlan.hus` in place. Returns the number of HUs reset
+ * so the caller can persist + emit a progress event.
+ *
+ * @param {object} args
+ * @param {object} args.loadedPlan
+ * @param {string} args.planId
+ * @param {object} [args.logger]
+ * @returns {number}
+ */
+export function reconcilePlanHuZombies({ loadedPlan, planId, logger }) {
+  if (!Array.isArray(loadedPlan?.hus) || loadedPlan.hus.length === 0) return 0;
+  const activeRuns = listActiveRuns({ planId });
+  if (activeRuns.length > 0) return 0;
+  const ZOMBIE_STATES = new Set(["coding", "reviewing", "running"]);
+  let reaped = 0;
+  for (const hu of loadedPlan.hus) {
+    if (ZOMBIE_STATES.has(hu.status)) {
+      const previous = hu.status;
+      hu.status = "pending";
+      reaped += 1;
+      logger?.warn?.(`[plan] HU ${hu.id || hu.hu_id || "?"} was '${previous}' but no live run owns the plan — reset to 'pending'.`);
+    }
+  }
+  return reaped;
+}
+
 /**
  * Throws when any HU lacks an acceptance_tests array with at least
  * one entry. Logs + emits the same `plan:tests-missing` progress

package/src/orchestrator/flow-runner.js

@@ -74,6 +74,7 @@ import { runSecurityStage, runFinalAuditStage } from "./post-loop-stages.js";
  *   approved → "approved"
  *   paused   → "paused"
  *   cancelled → "cancelled"
+ *   hibernated → "hibernated"
  *   anything else → "failed"
  *
  * Idempotent: only writes when the current status is still "running"
@@ -95,6 +96,10 @@ export async function sealSessionStatusIfStillRunning(session, result) {
     if (result?.approved === true) target = "approved";
     else if (result?.paused === true) target = "paused";
     else if (result?.cancelled === true) target = "cancelled";
+    // A run hibernated on a provider quota cap is NOT a failure — it is
+    // suspended and resumable via `kj standby resume`. Sealing it as
+    // `failed` would let the HU-zombie reaper treat it as dead work.
+    else if (result?.hibernated === true) target = "hibernated";
     await markSessionStatus(session, target);
   } catch { /* non-blocking */ }
 }

package/src/orchestrator/stages/coder-stage.js

@@ -18,6 +18,7 @@ import { runCoderWithFallback } from "../agent-fallback.js";
 import { invokeSolomon } from "../solomon-escalation.js";
 import { detectRateLimit } from "../../utils/rate-limit-detector.js";
 import { createStallDetector } from "../../utils/stall-detector.js";
+import { buildStandbyState } from "../../brain/standby-store.js";
 import { snapshotHomeTopLevel, detectNewHomeEntries, formatLeakMessage, verifyLeaksAgainstTranscript, detectTranscriptCdLeaks } from "../fs-leak-detector.js";
 
 export async function runCoderStage({ coderRoleInstance, coderRole, config, logger, emitter, eventBase, session, plannedTask, trackBudget, iteration, brainCtx, acceptanceTests = null, adrs = null, specSection = null, reviewerFindings = null, huId = null }) {
@@ -66,7 +67,10 @@ export async function runCoderStage({ coderRoleInstance, coderRole, config, logg
       // the plan, the rest are scoped to this HU. All four pass through
       // untouched when the caller omits them (legacy single-task runs).
       adrs, specSection, reviewerFindings, huId,
-      onOutput: coderStall.onOutput
+      onOutput: coderStall.onOutput,
+      // Lets Brain Recovery persist a standby snapshot if the coder's
+      // provider hits a quota cap mid-run (KJC hibernation wiring).
+      sessionState: buildStandbyState({ session, config, huId }),
     });
   } finally {
     coderStall.stop();
@@ -75,6 +79,21 @@ export async function runCoderStage({ coderRoleInstance, coderRole, config, logg
 
   if (!coderExecResult.ok) {
     const details = coderExecResult.result?.error || coderExecResult.summary || "unknown error";
+    // Quota cap → Brain Recovery already hibernated the run and persisted
+    // the standby snapshot. Stop the stage cleanly: no fallback, no
+    // Solomon. The caller turns this into a clean run halt; the HU is NOT
+    // marked failed — it resumes via `kj standby resume`.
+    if (coderExecResult.result?.action === "hibernate") {
+      emitProgress(emitter, makeEvent("coder:hibernate", { ...eventBase, stage: "coder" }, {
+        message: "Coder hibernated — provider quota exhausted, run can be resumed",
+        detail: { standbyFile: coderExecResult.result?.standbyFile || null }
+      }));
+      return {
+        action: "hibernate",
+        standbyFile: coderExecResult.result?.standbyFile || null,
+        recovery: coderExecResult.result?.recovery || null,
+      };
+    }
     const rateLimitCheck = detectRateLimit({
       stderr: coderExecResult.result?.error || "",
       stdout: coderExecResult.result?.output || ""
@@ -190,8 +209,17 @@ export async function runCoderStage({ coderRoleInstance, coderRole, config, logg
       baseRef: session.session_start_sha,
       projectDir: config.projectDir || process.cwd()
     });
-    filesChanged = verif.filesChanged || 0;
-  } catch { /* ignore verification errors */ }
+    if (verif.gitError) {
+      // Git failed (bad baseRef, corrupt repo, git missing). Don't
+      // feed filesChanged=0 into stale detection — it would blame the
+      // coder for an infrastructure problem.
+      logger?.warn?.(`[verification-gate] Git failed, change count is unreliable: ${verif.gitError}`);
+    } else {
+      filesChanged = verif.filesChanged || 0;
+    }
+  } catch (err) {
+    logger?.warn?.(`[verification-gate] Skipped: ${err?.message || err}`);
+  }
 
   await addCheckpoint(session, { stage: "coder", iteration, note: "Coder applied changes", provider: coderRole.provider, model: coderRole.model || null, filesChanged });
   emitProgress(
@@ -245,13 +273,28 @@ export async function runRefactorerStage({ refactorerRole, config, logger, emitt
   const refactorerStart = Date.now();
   let refResult;
   try {
-    refResult = await refRole.execute({ task: plannedTask, onOutput: refactorerStall.onOutput });
+    refResult = await refRole.execute({
+      task: plannedTask, onOutput: refactorerStall.onOutput,
+      sessionState: buildStandbyState({ session, config }),
+    });
   } finally {
     refactorerStall.stop();
   }
   trackBudget({ role: "refactorer", provider: refactorerRole.provider, model: refactorerRole.model, result: refResult.result, duration_ms: Date.now() - refactorerStart });
   if (!refResult.ok) {
     const details = refResult.result?.error || refResult.summary || "unknown error";
+    // Quota cap → hibernate cleanly, same as the coder stage above.
+    if (refResult.result?.action === "hibernate") {
+      emitProgress(emitter, makeEvent("refactorer:hibernate", { ...eventBase, stage: "refactorer" }, {
+        message: "Refactorer hibernated — provider quota exhausted, run can be resumed",
+        detail: { standbyFile: refResult.result?.standbyFile || null }
+      }));
+      return {
+        action: "hibernate",
+        standbyFile: refResult.result?.standbyFile || null,
+        recovery: refResult.result?.recovery || null,
+      };
+    }
     const rateLimitCheck = detectRateLimit({
       stderr: refResult.result?.error || "",
       stdout: refResult.result?.output || ""

package/src/orchestrator/verification-gate.js

@@ -47,8 +47,16 @@ export function countChangesSince(baseRef, projectDir = null) {
     }
 
     return { files, filesChanged: files.length, linesAdded, linesDeleted };
-  } catch {
-    return { files: [], filesChanged: 0, linesAdded: 0, linesDeleted: 0 };
+  } catch (err) {
+    // Git itself failed (baseRef invalid, repo corrupt, git binary
+    // missing). Previously we returned `filesChanged: 0` silently —
+    // indistinguishable from "the coder did nothing". Surface the
+    // error so verifyCoderOutput stops blaming the agent for an
+    // infrastructure failure.
+    return {
+      files: [], filesChanged: 0, linesAdded: 0, linesDeleted: 0,
+      gitError: err?.stderr?.toString?.() || err?.message || String(err),
+    };
   }
 }
 
@@ -65,10 +73,13 @@ export function countUntrackedFiles(projectDir = null) {
       encoding: "utf8", stdio: ["pipe", "pipe", "pipe"],
     }).trim();
 
-    if (!output) return [];
-    return output.split("\n").filter(Boolean);
-  } catch {
-    return [];
+    if (!output) return { files: [] };
+    return { files: output.split("\n").filter(Boolean) };
+  } catch (err) {
+    return {
+      files: [],
+      gitError: err?.stderr?.toString?.() || err?.message || String(err),
+    };
   }
 }
 
@@ -87,11 +98,29 @@ export function verifyCoderOutput({ baseRef, projectDir = null, minFiles = 1, mi
   const tracked = countChangesSince(baseRef, projectDir);
   const untracked = countUntrackedFiles(projectDir);
 
-  const totalFiles = tracked.filesChanged + untracked.length;
+  // Git infra failure (bad baseRef, corrupt repo, git missing) — not
+  // the coder's fault. Bail out with `gitError` so the caller can log
+  // it and skip the "retry with explicit file paths" feedback that
+  // would otherwise blame the agent.
+  const gitError = tracked.gitError || untracked.gitError;
+  if (gitError) {
+    return {
+      passed: false,
+      filesChanged: 0,
+      linesChanged: 0,
+      files: [],
+      reason: `Git verification failed: ${gitError}`,
+      retryStrategy: null,
+      gitError,
+    };
+  }
+
+  const untrackedFiles = untracked.files || [];
+  const totalFiles = tracked.filesChanged + untrackedFiles.length;
   const totalLines = tracked.linesAdded + tracked.linesDeleted;
-  const allFiles = [...tracked.files, ...untracked];
+  const allFiles = [...tracked.files, ...untrackedFiles];
 
-  const passed = totalFiles >= minFiles && (untracked.length > 0 || totalLines >= minLines);
+  const passed = totalFiles >= minFiles && (untrackedFiles.length > 0 || totalLines >= minLines);
 
   if (passed) {
     return {