@gethmy/agent 1.27.0 → 1.28.0

package/dist/cli.js

@@ -17,6 +17,104 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// src/base-branch.ts
+import { execFileSync } from "node:child_process";
+function resolveBaseBranch(baseBranch, remote, probe) {
+  const ref = `${remote}/${baseBranch}`;
+  if (probe.hasRef(ref))
+    return { ok: true, fetched: false };
+  const remotes = probe.remotes();
+  if (!remotes.includes(remote)) {
+    return {
+      ok: false,
+      message: remotes.length ? `This checkout has no "${remote}" remote — it has ${remotes.map((r) => `"${r}"`).join(", ")}. Every worktree branches from "${ref}", so the daemon needs that remote. Add it, or run the daemon from a clone that has it.` : `This checkout has no git remote, so "${ref}" can never resolve. Every worktree branches from the remote base branch. Add a remote, or run the daemon from a clone of the repository.`
+    };
+  }
+  const fetchError = probe.fetch(remote, baseBranch);
+  if (fetchError === null && probe.hasRef(ref)) {
+    return { ok: true, fetched: true };
+  }
+  const upstream = probe.remoteHasBranch(remote, baseBranch);
+  if (upstream === false) {
+    const actual = probe.remoteDefaultBranch(remote);
+    const suggestion = actual && actual !== baseBranch ? ` "${remote}" reports "${actual}" as its default branch.` : "";
+    return {
+      ok: false,
+      message: `Branch "${baseBranch}" does not exist on "${remote}".${suggestion} ${BASE_BRANCH_CONFIG_HINT}`
+    };
+  }
+  const detail = fetchError ? `: ${fetchError}` : " for an unknown reason";
+  if (upstream === null) {
+    return {
+      ok: false,
+      message: `Could not reach "${remote}" to resolve "${ref}"${detail}. Fix the git access from this checkout, then start the daemon again.`
+    };
+  }
+  return {
+    ok: false,
+    message: `"${baseBranch}" exists on "${remote}", but fetching it into "${ref}" failed${detail}. Fix the git access from this checkout, then start the daemon again.`
+  };
+}
+function createGitProbe(cwd) {
+  const git = (args) => execFileSync("git", args, {
+    cwd,
+    encoding: "utf-8",
+    stdio: "pipe"
+  }).trim();
+  return {
+    remotes() {
+      try {
+        return git(["remote"]).split(`
+`).filter(Boolean);
+      } catch {
+        return [];
+      }
+    },
+    hasRef(ref) {
+      try {
+        git(["rev-parse", "--verify", ref]);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    fetch(remote, branch) {
+      try {
+        git([
+          "fetch",
+          remote,
+          `+refs/heads/${branch}:refs/remotes/${remote}/${branch}`
+        ]);
+        return null;
+      } catch (err) {
+        const e = err;
+        const text = String(e?.stderr ?? e?.message ?? "").trim();
+        return text.split(`
+`).filter(Boolean).slice(-1)[0] ?? "git fetch failed";
+      }
+    },
+    remoteHasBranch(remote, branch) {
+      try {
+        return git(["ls-remote", "--heads", remote, branch]).length > 0;
+      } catch {
+        return null;
+      }
+    },
+    remoteDefaultBranch(remote) {
+      try {
+        const line = git(["ls-remote", "--symref", remote, "HEAD"]).split(`
+`).find((l) => l.startsWith("ref:"));
+        const match = line?.match(/refs\/heads\/(\S+)/);
+        return match?.[1] ?? null;
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+var BASE_BRANCH_CONFIG_HINT = "Set `agent.worktree.baseBranch` in ~/.harmony-mcp/config.json to the branch worktrees should branch from.";
+var init_base_branch = () => {};
+
 // src/board-helpers.ts
 var exports_board_helpers = {};
 __export(exports_board_helpers, {
@@ -547,6 +645,16 @@ function hasUnsafeDaemonBranchLine(description) {
   }
   return false;
 }
+function recordsPushedWorkOn(description, branchName) {
+  if (!description || !branchName)
+    return false;
+  for (const match of description.matchAll(DAEMON_BRANCH_LINE_PATTERN)) {
+    const ref = match[1];
+    if (ref && SAFE_GIT_REF_PATTERN.test(ref) && ref === branchName)
+      return true;
+  }
+  return false;
+}
 var BRANCH_REF_PATTERN, DAEMON_BRANCH_LINE_PATTERN, SAFE_GIT_REF_PATTERN, PR_LINK_PATTERN;
 var init_branchRef = __esm(() => {
   BRANCH_REF_PATTERN = /Branch:\s*`([^`]+)`/g;
@@ -676,6 +784,12 @@ var init_constants = __esm(() => {
     QUERY_GC_TIME: 1000 * 60 * 60 * 24
   };
 });
+// ../harmony-shared/dist/gateConfigError.js
+var GATE_CONFIG_ERROR_KEY = "configError", GATE_CONFIG_ERROR_MARK;
+var init_gateConfigError = __esm(() => {
+  GATE_CONFIG_ERROR_MARK = Object.freeze({ [GATE_CONFIG_ERROR_KEY]: true });
+});
+
 // ../harmony-shared/dist/gateEvaluate.js
 function isGateKind(value) {
   return typeof value === "string" && GATE_KINDS.includes(value);
@@ -1140,6 +1254,42 @@ function entryActionAllowlist(entryAction) {
 function stageDisallowedTools() {
   return STAGE_DAEMON_OWNED_TOOLS.length > 0 ? STAGE_DAEMON_OWNED_TOOLS.join(",") : null;
 }
+function customGateMetric(gate) {
+  if (gate === null || typeof gate !== "object" || Array.isArray(gate)) {
+    return null;
+  }
+  const record = gate;
+  if (record.kind !== "custom")
+    return null;
+  if (record.pendingEngine === true)
+    return null;
+  const metric = typeof record.metric === "string" ? record.metric.trim() : "";
+  return metric ? metric : null;
+}
+function referencedGateMetrics(def) {
+  const out = [];
+  for (const stage of readStageDefs(def)) {
+    if (!stage || typeof stage !== "object")
+      continue;
+    const stageId = typeof stage.id === "string" ? stage.id : "";
+    const stageName = typeof stage.name === "string" ? stage.name : stageId;
+    const gateMetric = customGateMetric(stage.gate);
+    if (gateMetric) {
+      out.push({ stageId, stageName, metric: gateMetric, source: "gate" });
+    }
+    const loop = normalizeLoopDef(stage.loop);
+    const loopMetric = loop?.exit_gate ? customGateMetric(loop.exit_gate) : null;
+    if (loopMetric) {
+      out.push({
+        stageId,
+        stageName,
+        metric: loopMetric,
+        source: "loop_exit_gate"
+      });
+    }
+  }
+  return out;
+}
 var DEFAULT_LOOP_MAX_ITERATIONS = 5, PLAYBOOK_STAGE_ROLES, SKILL_TOOL_ALLOWLIST, HARMONY_TOOL_RE, STAGE_DAEMON_OWNED_TOOLS;
 var init_playbookStage = __esm(() => {
   PLAYBOOK_STAGE_ROLES = [
@@ -1430,6 +1580,7 @@ var init_dist = __esm(() => {
   init_columnSort();
   init_commentSerializer();
   init_constants();
+  init_gateConfigError();
   init_gateEvaluate();
   init_logger();
   init_playbookAutoBind();
@@ -1775,6 +1926,7 @@ var init_types2 = __esm(() => {
         advanced: "claude-opus-5",
         research: "claude-fable-5"
       },
+      sizingModel: "",
       reviewModel: "sonnet",
       maxTurns: 80,
       reviewMaxTurns: 60,
@@ -1828,7 +1980,8 @@ var init_types2 = __esm(() => {
     },
     budget: {
       maxAttemptsPerCard: 3,
-      dailyBudgetCents: 5000
+      dailyBudgetCents: 5000,
+      pause: { enabled: true, waitHours: 24, extraTurns: null }
     },
     http: {
       enabled: true,
@@ -2105,6 +2258,15 @@ var init_config_validation = __esm(() => {
   };
 });
 
+// src/declared-metrics.ts
+var exports_declared_metrics = {};
+__export(exports_declared_metrics, {
+  declaredMetricNames: () => declaredMetricNames
+});
+function declaredMetricNames(metrics) {
+  return Object.keys(metrics ?? {}).map((name) => name.trim()).filter((name) => name.length > 0).sort();
+}
+
 // src/http-server.ts
 import {
   createServer
@@ -2231,7 +2393,7 @@ function isAddrInUse(err) {
   return typeof err === "object" && err !== null && err.code === "EADDRINUSE";
 }
 function parseCommand(path) {
-  const match = path.match(/^\/(pause|resume|stop)\/([^/]+)$/);
+  const match = path.match(/^\/(pause|resume|stop|continue)\/([^/]+)$/);
   if (!match)
     return null;
   return { command: match[1], cardId: decodeURIComponent(match[2]) };
@@ -2273,8 +2435,11 @@ function decideAutoMergeAction(input) {
     if (ciStatus !== "success")
       return "wait";
   }
-  if (config.reReviewOnBranchChange && reviewedSha && headSha && reviewedSha !== headSha) {
-    return "rereview";
+  if (config.reReviewOnBranchChange) {
+    if (!reviewedSha)
+      return "wait";
+    if (headSha && reviewedSha !== headSha)
+      return "rereview";
   }
   return "merge";
 }
@@ -2310,7 +2475,11 @@ async function attemptAutoMerge(deps) {
   });
   switch (action) {
     case "wait":
-      log4.debug(TAG4, `#${card.short_id} waiting (ci=${ciStatus})`);
+      if (autoMerge.reReviewOnBranchChange && !reviewedSha) {
+        log4.info(TAG4, `#${card.short_id} holding — no Reviewed-SHA on the card, so nothing has reviewed this head. Merge it yourself, or let the review pipeline run.`);
+      } else {
+        log4.debug(TAG4, `#${card.short_id} waiting (ci=${ciStatus})`);
+      }
       return;
     case "stamp-failure":
       log4.info(TAG4, `#${card.short_id} CI failed — flagging for human`);
@@ -2330,7 +2499,7 @@ var TAG4 = "auto-merge";
 var init_auto_merge = () => {};
 
 // src/review-worktree.ts
-import { execFileSync, execSync as execSync2 } from "node:child_process";
+import { execFileSync as execFileSync2, execSync as execSync2 } from "node:child_process";
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 import {
@@ -2353,7 +2522,7 @@ function gitErrorDetail(err) {
   return err instanceof Error ? err.message : String(err);
 }
 function checkoutExistingBranch(basePath, branchName) {
-  const repoRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+  const repoRoot = execFileSync2("git", ["rev-parse", "--show-toplevel"], {
     encoding: "utf-8"
   }).trim();
   const worktreeDir = resolve(repoRoot, basePath, `review-${branchName}`);
@@ -2362,13 +2531,13 @@ function checkoutExistingBranch(basePath, branchName) {
     cleanupWorktree(worktreeDir);
   }
   try {
-    execFileSync("git", ["worktree", "prune", "--expire=now"], {
+    execFileSync2("git", ["worktree", "prune", "--expire=now"], {
       cwd: repoRoot,
       stdio: "pipe"
     });
   } catch {}
   try {
-    execFileSync("git", ["fetch", "origin", branchName], {
+    execFileSync2("git", ["fetch", "origin", branchName], {
       cwd: repoRoot,
       stdio: "pipe"
     });
@@ -2377,14 +2546,14 @@ function checkoutExistingBranch(basePath, branchName) {
   }
   removeWorktreeHoldingBranch(repoRoot, branchName, worktreeDir);
   try {
-    execFileSync("git", ["branch", "-D", branchName], {
+    execFileSync2("git", ["branch", "-D", branchName], {
       cwd: repoRoot,
       stdio: "pipe"
     });
   } catch {}
   log5.info(TAG5, `Creating review worktree: ${worktreeDir} (branch: ${branchName})`);
   try {
-    execFileSync("git", [
+    execFileSync2("git", [
       "worktree",
       "add",
       "--track",
@@ -2621,6 +2790,57 @@ var init_merge_monitor = __esm(() => {
   execFileAsync = promisify(execFile);
 });
 
+// src/metric-validation.ts
+function formatUndeclaredMetricWarning(finding) {
+  const card = finding.cardShortId != null ? `#${finding.cardShortId} "${finding.cardTitle}"` : `"${finding.cardTitle}"`;
+  return `Card ${card} is bound to a playbook whose stage "${finding.stageName}" ` + `gates on metric "${finding.metric}", which this daemon does not declare — ` + `its stage run would hold as misconfigured. Add \`agent.playbooks.metrics.${finding.metric}\` to permit it.`;
+}
+async function findUndeclaredGateMetrics(client, projectId, config) {
+  if (!config.playbooks.enabled)
+    return [];
+  const declared = new Set(Object.keys(config.playbooks.metrics ?? {}));
+  const board = await client.getFullBoard(projectId);
+  const bound = board.cards.filter((card) => card && typeof card === "object" && card.playbook_id && card.playbook_version != null && card.current_stage);
+  if (bound.length === 0)
+    return [];
+  const request = client.request?.bind(client);
+  if (typeof request !== "function")
+    return [];
+  const versionCache = new Map;
+  const findings = [];
+  for (const card of bound) {
+    const cacheKey = `${card.playbook_id}@${card.playbook_version}`;
+    let def = versionCache.get(cacheKey);
+    if (def === undefined) {
+      try {
+        const res = await request("GET", `/playbooks/${encodeURIComponent(String(card.playbook_id))}/versions/${card.playbook_version}`);
+        def = res?.version ?? null;
+      } catch {
+        def = null;
+      }
+      versionCache.set(cacheKey, def);
+    }
+    if (!def)
+      continue;
+    const warned = new Set;
+    for (const ref of referencedGateMetrics(def)) {
+      if (declared.has(ref.metric) || warned.has(ref.metric))
+        continue;
+      warned.add(ref.metric);
+      findings.push({
+        cardShortId: typeof card.short_id === "number" ? card.short_id : null,
+        cardTitle: card.title ?? "",
+        stageName: ref.stageName || ref.stageId,
+        metric: ref.metric
+      });
+    }
+  }
+  return findings;
+}
+var init_metric_validation = __esm(() => {
+  init_dist();
+});
+
 // src/pickup-router.ts
 function isStageCard(card, columnName, playbooks) {
   if (!playbooks.enabled)
@@ -2668,10 +2888,11 @@ class BudgetGuard {
     return { allow: true };
   }
 }
-function buildGaveUpComment(maxAttempts, failures) {
+function buildGaveUpComment(maxAttempts, failures, pauseEnabled) {
+  const wayBackIn = pauseEnabled ? "Continue to grant a fresh attempt, or reassign the card." : "Reassign the card to grant a fresh attempt.";
   const lines = [
-    "**Agent gave up — needs a human.**",
-    `Stopped after ${maxAttempts} failed attempt${maxAttempts === 1 ? "" : "s"}. Reassign the card to try again.`
+    "**Out of attempts — over to you.**",
+    `Stopped after ${maxAttempts} failed attempt${maxAttempts === 1 ? "" : "s"}. ${wayBackIn}`
   ];
   if (failures.length > 0) {
     lines.push("", "Recent failures:");
@@ -2689,6 +2910,89 @@ function buildGaveUpComment(maxAttempts, failures) {
 `);
 }
 
+// src/budget-pause.ts
+function classifyRunExit(x) {
+  if (x.exitCode === 0)
+    return null;
+  if (x.timedOut)
+    return "timeout";
+  if (x.maxTurns <= 0)
+    return null;
+  if (x.stopReason === "error_max_turns")
+    return "max_turns";
+  if (x.numTurns >= x.maxTurns)
+    return "max_turns";
+  return null;
+}
+function computeDecisionDeadline(waitHours, now = Date.now()) {
+  return now + waitHours * 60 * 60 * 1000;
+}
+function humanDuration(ms) {
+  const total = Math.round(ms / 1000);
+  const m = Math.floor(total / 60);
+  const s = total % 60;
+  return m > 0 ? `${m}m ${s}s` : `${s}s`;
+}
+function formatBudgetComment(i) {
+  const lines = [HEADLINE[i.trigger](i)];
+  if (i.trigger !== "max_attempts") {
+    lines.push(`${i.toolCalls} tool calls · ${humanDuration(i.durationMs)} · $${i.costUsd.toFixed(2)}.`);
+    if (i.lastAction)
+      lines.push(`Last action: ${i.lastAction}.`);
+  }
+  lines.push(i.branchName ? `The work is parked, not lost: branch \`${i.branchName}\`, worktree kept.` : "The work is parked, not lost.");
+  lines.push(i.trigger === "max_attempts" ? `Continue to start a fresh attempt, or stop and I'll hand the card back.` : `Continue to pick up from where I stopped with a fresh turn budget, or stop and I'll hand the card back.`);
+  lines.push(`This decision expires in ${i.waitHours}h.`);
+  return lines.join(`
+`);
+}
+function formatExpiredAttemptCapComment() {
+  return [
+    "The decision window closed with no answer.",
+    "Nothing was running, so there is nothing to resume — reassign the card when you want me to try again."
+  ].join(`
+`);
+}
+function formatExpiredParkComment(i) {
+  const lines = ["The decision window closed with no answer."];
+  lines.push(i.branchName ? `The work is not lost: branch \`${i.branchName}\` is on origin.` : "The work is not lost, though no branch was recorded for this run.");
+  if (i.cliSessionId) {
+    lines.push(`CLI session \`${i.cliSessionId}\` is still available for a manual \`claude --resume\`.`);
+  }
+  return lines.join(`
+`);
+}
+function formatResumeConflictComment(i) {
+  const lines = [
+    "I could not pick this back up: another driver holds the agent session on this card.",
+    `The server said: ${i.holderMessage}`,
+    "Nothing was thrown away — the run is still parked exactly where it stopped."
+  ];
+  lines.push(i.branchName ? `Branch \`${i.branchName}\` and its worktree are kept.` : "The worktree is kept, though no branch was recorded for this run.");
+  if (i.cliSessionId) {
+    lines.push(`CLI session \`${i.cliSessionId}\` is still resumable, here or by hand.`);
+  }
+  lines.push(`End the other session and press Continue again. I'll hold for ${i.waitHours}h, then hand the card back.`);
+  return lines.join(`
+`);
+}
+var BudgetPauseError, MAX_GRANTED_TURNS = 1000, HEADLINE;
+var init_budget_pause = __esm(() => {
+  BudgetPauseError = class BudgetPauseError extends Error {
+    trigger;
+    constructor(trigger) {
+      super(`budget limit reached: ${trigger}`);
+      this.trigger = trigger;
+      this.name = "BudgetPauseError";
+    }
+  };
+  HEADLINE = {
+    max_turns: (i) => `Turn budget exhausted — ${i.maxTurns} of ${i.maxTurns} turns.`,
+    timeout: (i) => `Wall-clock budget exhausted after ${humanDuration(i.durationMs)}.`,
+    max_attempts: () => "Attempt budget exhausted — I have used every attempt on this card."
+  };
+});
+
 // src/queue.ts
 import { log as log7 } from "@gethmy/harness";
 
@@ -3078,7 +3382,7 @@ var init_episode_writer = __esm(() => {
 });
 
 // src/completion.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
+import { execFileSync as execFileSync3 } from "node:child_process";
 import {
   attemptAutoFix,
   captureDiffStat,
@@ -3106,6 +3410,9 @@ function describeNoCommitFailure(numTurns, maxTurns) {
     failureSummary: maxTurnsExhausted ? `Agent exhausted its ${maxTurns}-turn budget without committing any changes` : "Agent finished without making any changes to commit"
   };
 }
+function noCommitOutcome(maxTurnsExhausted, pauseEnabled) {
+  return maxTurnsExhausted && pauseEnabled ? "park" : "fail";
+}
 function buildTokenPayload(stats) {
   if (!stats?.cost)
     return {};
@@ -3119,7 +3426,7 @@ function buildTokenPayload(stats) {
     numTurns: stats.cost.numTurns
   };
 }
-async function runCompletion(client, card, branchName, worktreePath, config, workerId, sessionStats, workspaceId, agentSessionId, stateStore, onMovedToCompletion, onBeforeWorktreeCleanup) {
+async function runCompletion(client, card, branchName, worktreePath, config, workerId, sessionStats, workspaceId, agentSessionId, stateStore, onMovedToCompletion, onBeforeWorktreeCleanup, runBaselineSha, effectiveMaxTurns) {
   let verificationResult = {
     passed: true,
     buildErrors: [],
@@ -3132,9 +3439,13 @@ async function runCompletion(client, card, branchName, worktreePath, config, wor
     runFormatFix(worktreePath, config.verification.timeout, workerId);
   }
   commitUncommittedChanges(worktreePath, card);
-  const hasCommits = checkHasCommits(worktreePath, config.worktree.baseBranch);
+  const hasCommits = checkHasCommits(worktreePath, config.worktree.baseBranch, runBaselineSha);
   if (!hasCommits) {
-    const { maxTurnsExhausted, failureSummary } = describeNoCommitFailure(sessionStats?.cost?.numTurns ?? 0, config.claude.maxTurns);
+    const { maxTurnsExhausted, failureSummary } = describeNoCommitFailure(sessionStats?.cost?.numTurns ?? 0, effectiveMaxTurns ?? config.claude.maxTurns);
+    if (noCommitOutcome(maxTurnsExhausted, config.budget.pause.enabled) === "park") {
+      log9.warn(TAG9, `No commits on branch ${branchName} — ${failureSummary}; parking for a decision`);
+      return "park";
+    }
     log9.warn(TAG9, `No commits on branch ${branchName} — ${failureSummary}; counting as a failed attempt`);
     await moveCardToColumn(client, card, config.pickupColumns[0] ?? "To Do");
     await client.endAgentSession(card.id, {
@@ -3320,7 +3631,7 @@ function buildVerificationFailureSummary(result, autoFixAttempts) {
 }
 function readHeadSha(worktreePath) {
   try {
-    return execFileSync2("git", ["rev-parse", "HEAD"], {
+    return execFileSync3("git", ["rev-parse", "HEAD"], {
       cwd: worktreePath,
       encoding: "utf-8"
     }).trim();
@@ -3331,7 +3642,7 @@ function readHeadSha(worktreePath) {
 function commitUncommittedChanges(worktreePath, card) {
   let status = "";
   try {
-    status = execFileSync2("git", ["status", "--porcelain"], {
+    status = execFileSync3("git", ["status", "--porcelain"], {
       cwd: worktreePath,
       encoding: "utf-8"
     }).trim();
@@ -3344,11 +3655,11 @@ function commitUncommittedChanges(worktreePath, card) {
   const title = card.title?.trim() || "agent changes";
   const message = `#${card.short_id} ${title}`;
   try {
-    execFileSync2("git", ["add", "-A"], {
+    execFileSync3("git", ["add", "-A"], {
       cwd: worktreePath,
       encoding: "utf-8"
     });
-    execFileSync2("git", ["commit", "-m", message], {
+    execFileSync3("git", ["commit", "-m", message], {
       cwd: worktreePath,
       encoding: "utf-8"
     });
@@ -3359,9 +3670,17 @@ function commitUncommittedChanges(worktreePath, card) {
     return false;
   }
 }
-function checkHasCommits(worktreePath, baseBranch) {
+function checkHasCommits(worktreePath, baseBranch, baselineSha, gitImpl = (args, cwd) => execFileSync3("git", args, { cwd, encoding: "utf-8" })) {
+  if (baselineSha) {
+    try {
+      gitImpl(["merge-base", "--is-ancestor", baselineSha, "HEAD"], worktreePath);
+    } catch {
+      return false;
+    }
+  }
+  const range = baselineSha ? `${baselineSha}..HEAD` : `origin/${baseBranch}..HEAD`;
   try {
-    const count = execFileSync2("git", ["rev-list", "--count", `origin/${baseBranch}..HEAD`], { cwd: worktreePath, encoding: "utf-8" }).trim();
+    const count = gitImpl(["rev-list", "--count", range], worktreePath).trim();
     return parseInt(count, 10) > 0;
   } catch {
     return false;
@@ -3370,7 +3689,7 @@ function checkHasCommits(worktreePath, baseBranch) {
 async function postSummary(client, card, branchName, worktreePath, prUrl, baseBranch, sessionStats) {
   let commitLog = "";
   try {
-    commitLog = execFileSync2("git", ["log", "--oneline", `origin/${baseBranch}..HEAD`], { cwd: worktreePath, encoding: "utf-8" }).trim();
+    commitLog = execFileSync3("git", ["log", "--oneline", `origin/${baseBranch}..HEAD`], { cwd: worktreePath, encoding: "utf-8" }).trim();
   } catch {}
   const SUMMARY_MARKER = `---
 **Agent completed**`;
@@ -3531,6 +3850,9 @@ class ProgressTracker {
       this.heartbeatTimer = null;
     }
   }
+  get isStopped() {
+    return this.stopped;
+  }
   get stats() {
     return {
       filesEdited: this.filesEdited.size,
@@ -3641,6 +3963,9 @@ class ProgressTracker {
       this.scheduleUpdate(this.currentTaskLabel());
     }
   }
+  get lastActionSummary() {
+    return this.lastAction || null;
+  }
   currentTaskLabel() {
     if (this.lastAction)
       return this.lastAction;
@@ -3798,89 +4123,280 @@ var init_progress_tracker = __esm(() => {
   };
 });
 
-// src/review-completion.ts
-import { readFileSync as readFileSync2, statSync } from "node:fs";
-import {
-  cleanupWorktree as cleanupWorktree2,
-  createPullRequest as createPullRequest2,
-  detectGitProvider as detectGitProvider4,
-  extractPrUrl as extractPrUrl2,
-  getBranchWebUrl as getBranchWebUrl2,
-  getHeadSha,
-  log as log11,
-  pushBranch as pushBranch2,
-  renameRemoteBranch,
-  upsertReviewedSha
-} from "@gethmy/harness";
-function clampSubtaskTitle(title) {
-  return title.length > MAX_SUBTASK_TITLE ? `${title.slice(0, MAX_SUBTASK_TITLE - 3)}...` : title;
+// src/prompt.ts
+import { log as log11 } from "@gethmy/harness";
+function buildSteeringPrompt(messages) {
+  if (messages.length === 1)
+    return messages[0];
+  return messages.map((m, i) => `${i + 1}. ${m}`).join(`
+`);
 }
-function renderFindingBlock(f) {
-  const locationLine = f.location ? `
-Location: ${f.location}` : "";
-  return `**[${f.severity}] ${f.title}**
-${f.description}${locationLine}`;
+function renderPreviousAttemptsSection(failures) {
+  if (failures.length === 0)
+    return "";
+  const lines = failures.map((f) => {
+    const tag = f.reason ? `[${f.reason}] ` : "";
+    return `- ${tag}${f.summary}`;
+  });
+  return [
+    "## Previous attempt feedback",
+    "This is a re-attempt on the branch your last run already pushed — build on that existing work and FIX the issues below. Do NOT reimplement from scratch or revert the prior commits.",
+    ...lines
+  ].join(`
+`);
 }
-function buildFindingComments(findings) {
-  const header = `**Review findings — ${findings.length} blocking issue(s) to resolve.**`;
-  const sep = `
-
-`;
-  const bodies = [];
-  let current = header;
-  for (const f of findings) {
-    let block = renderFindingBlock(f);
-    const maxBlock = COMMENT_BODY_BUDGET - header.length - sep.length;
-    if (block.length > maxBlock) {
-      const suffix = `
-…[truncated]`;
-      block = `${block.slice(0, Math.max(0, maxBlock - suffix.length))}${suffix}`;
-    }
-    if (current.length + sep.length + block.length > COMMENT_BODY_BUDGET) {
-      bodies.push(current);
-      current = `${header}${sep}${block}`;
-    } else {
-      current = `${current}${sep}${block}`;
-    }
+async function buildPrompt(enriched, branchName, worktreePath, client, workspaceId, projectId) {
+  const { card } = enriched;
+  const [pastEpisodesSection, referenceSection] = await Promise.all([
+    renderPastEpisodesSection(client, card.title, card.description ?? "", workspaceId, projectId),
+    renderReferenceSection(client, card.title, card.description ?? "", workspaceId, projectId)
+  ]);
+  try {
+    const result = await client.generateCardPrompt({
+      cardId: card.id,
+      workspaceId,
+      projectId,
+      variant: "execute",
+      customConstraints: `You are working in a git worktree at \`${worktreePath}\` on branch \`${branchName}\`.
+Do NOT push to main. All your work stays on \`${branchName}\`.
+The daemon owns the run lifecycle: once your work is committed it ends the agent session, pushes the branch, and moves the card to Review for you. Do NOT call harmony_end_agent_session, do NOT start a new session, and do NOT move the card or change its column yourself. If the skill driving this work tells you to move the card or end the session as a final step, SKIP it — it is handled for you (those tools are disabled for this run). Finish the implementation, commit, and stop.`
+    });
+    log11.info(TAG11, `Generated prompt for #${card.short_id} — ${result.contextSummary.memoryCount} memories, ${result.tokenEstimate} tokens`);
+    return result.prompt + pastEpisodesSection + referenceSection;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log11.warn(TAG11, `Failed to generate prompt via API, using fallback: ${msg}`);
+    const commentsSection = await renderCommentsSection(client, card.id);
+    return buildFallbackPrompt(enriched, branchName, worktreePath) + commentsSection + pastEpisodesSection + referenceSection;
   }
-  if (current.length > header.length)
-    bodies.push(current);
-  return bodies;
 }
-function acceptanceSummaryLine(checks) {
-  if (!checks || checks.length === 0)
+async function renderCommentsSection(client, cardId) {
+  try {
+    const { comments } = await client.request("GET", `/cards/${encodeURIComponent(cardId)}/comments?limit=200&order=desc`);
+    if (!Array.isArray(comments) || comments.length === 0)
+      return "";
+    const section = serializeCommentThread(comments, {
+      heading: "Comments",
+      maxComments: 40
+    });
+    return section ? `
+
+${section}` : "";
+  } catch (err) {
+    log11.warn(TAG11, "comment-thread fetch failed", {
+      event: "comment_fetch_failed",
+      error: err instanceof Error ? err.message : String(err)
+    });
     return "";
-  const counts = { pass: 0, partial: 0, fail: 0, unverifiable: 0 };
-  for (const c of checks)
-    counts[c.status]++;
-  const flagged = [];
-  if (counts.fail)
-    flagged.push(`${counts.fail} fail`);
-  if (counts.partial)
-    flagged.push(`${counts.partial} partial`);
-  if (counts.unverifiable)
-    flagged.push(`${counts.unverifiable} unverifiable`);
-  const detail = flagged.length ? ` (${flagged.join(", ")})` : "";
-  return `Acceptance: ${counts.pass}/${checks.length} pass${detail}`;
-}
-async function persistReviewedSha(client, card, worktreePath) {
-  const headSha = getHeadSha(worktreePath);
-  if (!headSha)
-    return;
-  const { card: latest } = await client.getCard(card.id);
-  const desc = latest.description || "";
-  const next = upsertReviewedSha(desc, headSha);
-  if (next !== desc) {
-    await client.updateCard(card.id, { description: next });
   }
 }
-function tailRunLog(path, bytes = RUN_LOG_TAIL_BYTES) {
+async function renderPastEpisodesSection(client, title, description, workspaceId, projectId) {
+  if (!projectId)
+    return "";
   try {
-    const size = statSync(path).size;
-    if (size === 0)
-      return null;
-    const start = Math.max(0, size - bytes);
-    const buf = readFileSync2(path);
+    const query = `${title}
+${description}`.trim();
+    const { entities } = await client.harmonyRecall({
+      workspaceId,
+      projectId,
+      query,
+      type: ["solution", "error"],
+      memory_tier: "episode",
+      scope: "project",
+      topK: 3,
+      includeEpisodes: true,
+      consumer: "agent-prompt"
+    });
+    if (entities.length === 0)
+      return "";
+    const bullets = entities.map((entity) => {
+      const e = entity;
+      const meta = e.metadata ?? {};
+      const outcomeTag = meta.outcome ? `[${meta.outcome}]` : "[?]";
+      const approach = meta.approach_summary ?? "";
+      const lines = [
+        `- ${outcomeTag} ${e.title ?? "(untitled episode)"}`,
+        `  Approach: ${approach}`
+      ];
+      if (meta.key_insight)
+        lines.push(`  Key insight: ${meta.key_insight}`);
+      if (meta.changed_files && meta.changed_files.length > 0) {
+        const shown = meta.changed_files.slice(0, 8);
+        const extra = meta.changed_files.length - shown.length;
+        const suffix = extra > 0 ? ` (+${extra} more)` : "";
+        lines.push(`  Changed files: ${shown.join(", ")}${suffix}`);
+      }
+      return lines.join(`
+`);
+    }).join(`
+`);
+    return `
+
+## Similar past tasks
+${bullets}`;
+  } catch (err) {
+    log11.warn(TAG11, "past-episodes recall failed", {
+      event: "episode_recall_failed",
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return "";
+  }
+}
+async function renderReferenceSection(client, title, description, workspaceId, projectId) {
+  try {
+    const query = `${title}
+${description}`.trim();
+    const { entities } = await client.harmonyRecall({
+      workspaceId,
+      projectId,
+      query,
+      memory_tier: "reference",
+      topK: 5,
+      consumer: "agent-prompt"
+    });
+    if (entities.length === 0)
+      return "";
+    const bullets = entities.map((entity) => {
+      const e = entity;
+      const content = (e.content ?? "").slice(0, 300);
+      return `- ${e.title ?? "(untitled)"}
+  ${content}`;
+    }).join(`
+`);
+    return `
+
+## How we work here
+${bullets}`;
+  } catch (err) {
+    log11.warn(TAG11, "reference recall failed", {
+      event: "reference_recall_failed",
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return "";
+  }
+}
+function buildFallbackPrompt(enriched, branchName, worktreePath) {
+  const { card, column, labels, subtasks } = enriched;
+  const labelStr = labels.length > 0 ? labels.map((l) => l.name).join(", ") : "none";
+  const subtaskStr = subtasks.length > 0 ? subtasks.map((s) => `- [${s.completed ? "x" : " "}] ${s.title}`).join(`
+`) : "No subtasks defined.";
+  const description = card.description?.trim() || "No description provided.";
+  return `You are an AI agent working on a task from the Harmony project board.
+
+## Card: #${card.short_id} - ${card.title}
+**Labels**: ${labelStr}
+**Column**: ${column.name}
+**Priority**: ${card.priority}
+
+## Description
+${description}
+
+## Subtasks
+${subtaskStr}
+
+## Instructions
+1. Read the codebase and understand the context needed for this task
+2. Report progress via harmony_update_agent_progress at key milestones:
+   - After reading codebase and forming a plan (~20%)
+   - After each major implementation step (~30-60%)
+   - After completing each subtask (also toggle via harmony_toggle_subtask)
+   - Before committing (~65%)
+   Include a brief currentTask description.
+3. Implement the changes on branch \`${branchName}\`
+4. Commit your work with clear, descriptive commit messages
+5. When the work is committed, STOP. The daemon owns the run lifecycle: it ends the agent session, pushes the branch, and moves the card to Review for you. Do NOT call harmony_end_agent_session, do NOT start a new session, and do NOT move the card or change its column yourself — those tools are disabled for this run.
+
+You are working in a git worktree at \`${worktreePath}\` on branch \`${branchName}\`.
+Do NOT push to main. All your work stays on \`${branchName}\`.`;
+}
+var TAG11 = "prompt";
+var init_prompt = __esm(() => {
+  init_dist();
+});
+
+// src/review-completion.ts
+import { readFileSync as readFileSync2, statSync } from "node:fs";
+import {
+  cleanupWorktree as cleanupWorktree2,
+  createPullRequest as createPullRequest2,
+  detectGitProvider as detectGitProvider4,
+  extractPrUrl as extractPrUrl2,
+  getBranchWebUrl as getBranchWebUrl2,
+  getHeadSha,
+  log as log12,
+  pushBranch as pushBranch2,
+  renameRemoteBranch,
+  upsertReviewedSha
+} from "@gethmy/harness";
+function clampSubtaskTitle(title) {
+  return title.length > MAX_SUBTASK_TITLE ? `${title.slice(0, MAX_SUBTASK_TITLE - 3)}...` : title;
+}
+function renderFindingBlock(f) {
+  const locationLine = f.location ? `
+Location: ${f.location}` : "";
+  return `**[${f.severity}] ${f.title}**
+${f.description}${locationLine}`;
+}
+function buildFindingComments(findings) {
+  const header = `**Review findings — ${findings.length} blocking issue(s) to resolve.**`;
+  const sep = `
+
+`;
+  const bodies = [];
+  let current = header;
+  for (const f of findings) {
+    let block = renderFindingBlock(f);
+    const maxBlock = COMMENT_BODY_BUDGET - header.length - sep.length;
+    if (block.length > maxBlock) {
+      const suffix = `
+…[truncated]`;
+      block = `${block.slice(0, Math.max(0, maxBlock - suffix.length))}${suffix}`;
+    }
+    if (current.length + sep.length + block.length > COMMENT_BODY_BUDGET) {
+      bodies.push(current);
+      current = `${header}${sep}${block}`;
+    } else {
+      current = `${current}${sep}${block}`;
+    }
+  }
+  if (current.length > header.length)
+    bodies.push(current);
+  return bodies;
+}
+function acceptanceSummaryLine(checks) {
+  if (!checks || checks.length === 0)
+    return "";
+  const counts = { pass: 0, partial: 0, fail: 0, unverifiable: 0 };
+  for (const c of checks)
+    counts[c.status]++;
+  const flagged = [];
+  if (counts.fail)
+    flagged.push(`${counts.fail} fail`);
+  if (counts.partial)
+    flagged.push(`${counts.partial} partial`);
+  if (counts.unverifiable)
+    flagged.push(`${counts.unverifiable} unverifiable`);
+  const detail = flagged.length ? ` (${flagged.join(", ")})` : "";
+  return `Acceptance: ${counts.pass}/${checks.length} pass${detail}`;
+}
+async function persistReviewedSha(client, card, worktreePath) {
+  const headSha = getHeadSha(worktreePath);
+  if (!headSha)
+    return;
+  const { card: latest } = await client.getCard(card.id);
+  const desc = latest.description || "";
+  const next = upsertReviewedSha(desc, headSha);
+  if (next !== desc) {
+    await client.updateCard(card.id, { description: next });
+  }
+}
+function tailRunLog(path, bytes = RUN_LOG_TAIL_BYTES) {
+  try {
+    const size = statSync(path).size;
+    if (size === 0)
+      return null;
+    const start = Math.max(0, size - bytes);
+    const buf = readFileSync2(path);
     return buf.subarray(start).toString("utf-8");
   } catch {
     return null;
@@ -3932,7 +4448,7 @@ function parseReviewOutput(stdout) {
     try {
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object" && "verdict" in parsed) {
-        log11.debug(TAG11, "Parsed review output from fenced JSON block");
+        log12.debug(TAG12, "Parsed review output from fenced JSON block");
         return extractResult(parsed);
       }
     } catch {}
@@ -3958,21 +4474,21 @@ function parseReviewOutput(stdout) {
     try {
       const parsed = JSON.parse(candidates[i]);
       if (parsed && typeof parsed === "object" && "verdict" in parsed) {
-        log11.debug(TAG11, "Parsed review output from raw JSON object");
+        log12.debug(TAG12, "Parsed review output from raw JSON object");
         return extractResult(parsed);
       }
     } catch {}
   }
   const verdictMatch = stdout.match(/"verdict"\s*:\s*"(approved|rejected)"/i);
   if (verdictMatch) {
-    log11.warn(TAG11, `Parsed verdict via regex fallback — findings lost (${verdictMatch[1]})`);
+    log12.warn(TAG12, `Parsed verdict via regex fallback — findings lost (${verdictMatch[1]})`);
     return {
       verdict: verdictMatch[1].toLowerCase(),
       summary: "Parsed via regex fallback — original JSON was malformed. Check run log.",
       findings: []
     };
   }
-  log11.warn(TAG11, "Failed to parse review JSON output — returning error verdict (card stays in Review)");
+  log12.warn(TAG12, "Failed to parse review JSON output — returning error verdict (card stays in Review)");
   return {
     verdict: "error",
     summary: stdout.slice(0, 500),
@@ -4005,7 +4521,7 @@ async function postReviewComment(client, card, commentType, body) {
   try {
     await client.addComment(card.id, body, { commentType });
   } catch (err) {
-    log11.error(TAG11, `Failed to post review comment to #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+    log12.error(TAG12, `Failed to post review comment to #${card.short_id}: ${err instanceof Error ? err.message : err}`);
   }
 }
 async function runReviewCompletion(client, card, result, config, worktreePath, branchName, sessionStats, runLogPath, workspaceId, agentSessionId, stateStore, resolvedFromPrUrl) {
@@ -4019,11 +4535,11 @@ async function runReviewCompletion(client, card, result, config, worktreePath, b
   const currentCycle = getReviewCycle(freshDesc) + 1;
   const maxCycles = config.review.maxReviewCycles;
   if (result.verdict === "error") {
-    log11.warn(TAG11, `#${card.short_id} review output unparseable — labelling "${NEED_REVIEW_LABEL}" for manual inspection`);
+    log12.warn(TAG12, `#${card.short_id} review output unparseable — labelling "${NEED_REVIEW_LABEL}" for manual inspection`);
     try {
       await addLabelByName(client, card, NEED_REVIEW_LABEL, NEED_REVIEW_LABEL_COLOR);
     } catch (err) {
-      log11.warn(TAG11, `Failed to add "${NEED_REVIEW_LABEL}" label: ${err instanceof Error ? err.message : err}`);
+      log12.warn(TAG12, `Failed to add "${NEED_REVIEW_LABEL}" label: ${err instanceof Error ? err.message : err}`);
     }
     if (config.review.postFindings) {
       const rawTail = runLogPath ? tailRunLog(runLogPath) : null;
@@ -4066,7 +4582,7 @@ ${runLogTail}
           renameRemoteBranch(branchName, newRef, worktreePath);
           approvedBranch = newRef;
         } catch (err) {
-          log11.warn(TAG11, `Branch rename failed (continuing on ${branchName}): ${err instanceof Error ? err.message : err}`);
+          log12.warn(TAG12, `Branch rename failed (continuing on ${branchName}): ${err instanceof Error ? err.message : err}`);
         }
       }
       if (config.review.createPR && approvedBranch) {
@@ -4087,14 +4603,14 @@ ${runLogTail}
           });
         }
       } catch (err) {
-        log11.warn(TAG11, `Failed to persist PR URL to #${card.short_id} description: ${err instanceof Error ? err.message : err}`);
+        log12.warn(TAG12, `Failed to persist PR URL to #${card.short_id} description: ${err instanceof Error ? err.message : err}`);
       }
     }
     if (branchName) {
       try {
         await persistReviewedSha(client, card, worktreePath);
       } catch (err) {
-        log11.warn(TAG11, `Failed to persist Reviewed-SHA to #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+        log12.warn(TAG12, `Failed to persist Reviewed-SHA to #${card.short_id}: ${err instanceof Error ? err.message : err}`);
       }
     }
     if (config.review.postFindings) {
@@ -4116,7 +4632,7 @@ ${runLogTail}
       progressPercent: 100,
       ...buildTokenPayload(sessionStats)
     });
-    log11.info(TAG11, `#${card.short_id} approved${prUrl ? ` — PR: ${prUrl}` : ""} — labeled "${config.review.approvedLabel}"`);
+    log12.info(TAG12, `#${card.short_id} approved${prUrl ? ` — PR: ${prUrl}` : ""} — labeled "${config.review.approvedLabel}"`);
   } else {
     const reworkFindings = result.findings.filter((f) => f.relatedToDiff !== false);
     const criticalFindings = reworkFindings.filter((f) => f.severity === "critical").slice(0, MAX_FINDINGS);
@@ -4124,7 +4640,7 @@ ${runLogTail}
     const linkedFindings = [...criticalFindings, ...majorFindings];
     const minorFindings = reworkFindings.filter((f) => f.severity === "minor").slice(0, MAX_FINDINGS);
     if (currentCycle >= maxCycles) {
-      log11.warn(TAG11, `#${card.short_id} reached max review cycles (${maxCycles}), moving to Done with note`);
+      log12.warn(TAG12, `#${card.short_id} reached max review cycles (${maxCycles}), moving to Done with note`);
       await moveCardToColumn(client, card, config.review.moveToColumn);
       const body = [
         "**Review — needs human review.**",
@@ -4164,7 +4680,7 @@ ${runLogTail}
         try {
           await client.createSubtask(card.id, clampSubtaskTitle(`[${finding.severity}] ${finding.title}`));
         } catch (err) {
-          log11.error(TAG11, `Failed to create finding subtask: ${err instanceof Error ? err.message : err}`);
+          log12.error(TAG12, `Failed to create finding subtask: ${err instanceof Error ? err.message : err}`);
         }
       }));
       if (linkedFindings.length > 0) {
@@ -4176,7 +4692,7 @@ ${runLogTail}
         try {
           await client.createSubtask(card.id, clampSubtaskTitle(finding.title));
         } catch (err) {
-          log11.error(TAG11, `Failed to create subtask: ${err instanceof Error ? err.message : err}`);
+          log12.error(TAG12, `Failed to create subtask: ${err instanceof Error ? err.message : err}`);
         }
       }));
       const baseDesc = stripReviewSummary(freshDesc);
@@ -4184,7 +4700,7 @@ ${runLogTail}
       try {
         await client.updateCard(card.id, { description: updatedDesc });
       } catch (err) {
-        log11.error(TAG11, `Failed to update review cycle marker: ${err instanceof Error ? err.message : err}`);
+        log12.error(TAG12, `Failed to update review cycle marker: ${err instanceof Error ? err.message : err}`);
       }
       const scopeLine = result.scopeCheck ? `Scope: ${result.scopeCheck.status}${result.scopeCheck.notes ? ` — ${result.scopeCheck.notes}` : ""}` : "";
       const body = [
@@ -4201,9 +4717,9 @@ ${runLogTail}
     if (config.planning.enabled && card.plan_id) {
       try {
         await client.updateCard(card.id, { needsPlanRefresh: true });
-        log11.info(TAG11, `#${card.short_id} flagged needs_plan_refresh after rejected review`);
+        log12.info(TAG12, `#${card.short_id} flagged needs_plan_refresh after rejected review`);
       } catch (err) {
-        log11.warn(TAG11, `Failed to flag needs_plan_refresh for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+        log12.warn(TAG12, `Failed to flag needs_plan_refresh for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
       }
     }
     await moveCardToColumn(client, card, config.review.failColumn);
@@ -4217,10 +4733,10 @@ ${runLogTail}
         recoveryBranch
       });
     } catch (err) {
-      log11.debug(TAG11, `recordFailureSummary failed: ${err instanceof Error ? err.message : err}`);
+      log12.debug(TAG12, `recordFailureSummary failed: ${err instanceof Error ? err.message : err}`);
     }
     if (recoveryBranch) {
-      log11.info(TAG11, `#${card.short_id} recovery branch ${recoveryBranch}${recoveryUrl ? ` (${recoveryUrl})` : ""}`);
+      log12.info(TAG12, `#${card.short_id} recovery branch ${recoveryBranch}${recoveryUrl ? ` (${recoveryUrl})` : ""}`);
     }
     await client.endAgentSession(card.id, {
       status: "failed",
@@ -4229,7 +4745,7 @@ ${runLogTail}
       recoveryBranch,
       ...buildTokenPayload(sessionStats)
     });
-    log11.info(TAG11, `#${card.short_id} rejected (cycle ${currentCycle}/${maxCycles}) — moved to "${config.review.failColumn}"`);
+    log12.info(TAG12, `#${card.short_id} rejected (cycle ${currentCycle}/${maxCycles}) — moved to "${config.review.failColumn}"`);
   }
   if (workspaceId && (result.verdict === "approved" || result.verdict === "rejected")) {
     const originalEpisodeId = await findLatestImplementEpisode(client, workspaceId, card.project_id, card.short_id);
@@ -4251,7 +4767,7 @@ ${runLogTail}
     cleanupWorktree2(worktreePath, branchName);
   }
 }
-var TAG11 = "review-completion", MAX_FINDINGS = 10, MAX_SUBTASK_TITLE = 120, COMMENT_BODY_BUDGET = 9500, REVIEW_MARKER = `---
+var TAG12 = "review-completion", MAX_FINDINGS = 10, MAX_SUBTASK_TITLE = 120, COMMENT_BODY_BUDGET = 9500, REVIEW_MARKER = `---
 **Review:`, RUN_LOG_TAIL_BYTES = 2048;
 var init_review_completion = __esm(() => {
   init_board_helpers();
@@ -4398,7 +4914,7 @@ var init_review_prompt = __esm(() => {
 import { createWriteStream, mkdirSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { join as join2 } from "node:path";
-import { log as log12 } from "@gethmy/harness";
+import { log as log13 } from "@gethmy/harness";
 function openRunLog(tag, runId, shortId) {
   if (!runId)
     return null;
@@ -4409,7 +4925,7 @@ function openRunLog(tag, runId, shortId) {
     const stream = createWriteStream(path, { flags: "a" });
     return { path, stream };
   } catch (err) {
-    log12.warn(tag, `Failed to open run log: ${err instanceof Error ? err.message : err}`);
+    log13.warn(tag, `Failed to open run log: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
@@ -4430,6 +4946,8 @@ function isSessionConflict(err) {
 var exports_state_store = {};
 __export(exports_state_store, {
   newRunId: () => newRunId,
+  isParkedRun: () => isParkedRun,
+  isBudgetHeldRun: () => isBudgetHeldRun,
   defaultStatePath: () => defaultStatePath,
   StateStore: () => StateStore
 });
@@ -4442,7 +4960,7 @@ import {
 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { dirname, join as join3 } from "node:path";
-import { log as log13 } from "@gethmy/harness";
+import { log as log14 } from "@gethmy/harness";
 function emptyState() {
   return {
     version: SCHEMA_VERSION,
@@ -4457,6 +4975,16 @@ function emptyState() {
 function todayUtc() {
   return new Date().toISOString().slice(0, 10);
 }
+function isParkedRun(run) {
+  return run.status === "parked" && run.endedAt === null;
+}
+function isBudgetHeldRun(run) {
+  if (run.endedAt !== null)
+    return false;
+  if (run.status === "parked")
+    return true;
+  return run.grantedTurns != null;
+}
 function newRunId() {
   const ts = Date.now().toString(36);
   const rand = Math.random().toString(36).slice(2, 10);
@@ -4488,7 +5016,7 @@ class StateStore {
       const raw = readFileSync3(this.path, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed?.version !== SCHEMA_VERSION) {
-        log13.warn(TAG12, `state file has version ${parsed?.version}, expected ${SCHEMA_VERSION} — migrating (preserving card budget/attempts, dropping in-flight runs)`);
+        log14.warn(TAG13, `state file has version ${parsed?.version}, expected ${SCHEMA_VERSION} — migrating (preserving card budget/attempts, dropping in-flight runs)`);
         return {
           version: SCHEMA_VERSION,
           daemonId: null,
@@ -4509,7 +5037,7 @@ class StateStore {
         daily: parsed.daily ?? []
       };
     } catch (err) {
-      log13.error(TAG12, `failed to read state file: ${err instanceof Error ? err.message : err}`);
+      log14.error(TAG13, `failed to read state file: ${err instanceof Error ? err.message : err}`);
       return emptyState();
     }
   }
@@ -4568,12 +5096,40 @@ class StateStore {
     }
     return this.updateRun(runId, patch);
   }
+  parkRun(runId, opts) {
+    const patch = {
+      status: "parked",
+      pauseTrigger: opts.pauseTrigger,
+      blockerCommentId: opts.blockerCommentId,
+      awaitingDecisionUntil: opts.awaitingDecisionUntil,
+      parkedAt: Date.now()
+    };
+    if (opts.costCents !== undefined && opts.costCents > 0) {
+      patch.costCents = opts.costCents;
+    }
+    if (opts.numTurns !== undefined && opts.numTurns > 0) {
+      patch.numTurns = opts.numTurns;
+    }
+    return this.updateRun(runId, patch);
+  }
   getRun(runId) {
     return this.state.runs.find((r) => r.runId === runId) ?? null;
   }
   getActiveRuns() {
     return this.state.runs.filter((r) => r.endedAt === null);
   }
+  getParkedRuns() {
+    return this.state.runs.filter(isParkedRun);
+  }
+  getParkedRunForCard(cardId) {
+    return this.state.runs.find((r) => r.cardId === cardId && isParkedRun(r)) ?? null;
+  }
+  getResumableRunForCard(cardId) {
+    return this.state.runs.find((r) => r.cardId === cardId && r.status === "active" && r.endedAt === null && r.grantedTurns != null) ?? null;
+  }
+  getResumableRuns() {
+    return this.state.runs.filter((r) => r.status === "active" && r.endedAt === null && r.grantedTurns != null);
+  }
   getRunsForCard(cardId) {
     return this.state.runs.filter((r) => r.cardId === cardId);
   }
@@ -4652,6 +5208,22 @@ class StateStore {
     rec.loopIterations = 0;
     await this.persist();
   }
+  async markAwaitingDecision(cardId, opts) {
+    const rec = this.ensureCard(cardId);
+    rec.awaitingDecisionUntil = opts.until;
+    rec.blockerCommentId = opts.blockerCommentId;
+    rec.awaitingDecisionAgentIdentifier = opts.agentIdentifier ?? null;
+    await this.persist();
+  }
+  async clearAwaitingDecision(cardId) {
+    const rec = this.getCard(cardId);
+    if (!rec || rec.awaitingDecisionUntil == null)
+      return;
+    rec.awaitingDecisionUntil = null;
+    rec.blockerCommentId = null;
+    rec.awaitingDecisionAgentIdentifier = null;
+    await this.persist();
+  }
   async resetAttempts(cardId) {
     const rec = this.getCard(cardId);
     if (!rec || rec.attempts === 0)
@@ -4698,12 +5270,12 @@ class StateStore {
     return this.state.daily.find((d) => d.date === key)?.costCents ?? 0;
   }
 }
-var TAG12 = "state-store", SCHEMA_VERSION = 1;
+var TAG13 = "state-store", SCHEMA_VERSION = 1;
 var init_state_store = () => {};
 
 // src/stream-parser.ts
 import { EventEmitter } from "node:events";
-import { log as log14 } from "@gethmy/harness";
+import { log as log15 } from "@gethmy/harness";
 function normalizeToolResultContent(raw) {
   if (raw == null)
     return;
@@ -4724,7 +5296,7 @@ function normalizeToolResultContent(raw) {
     return String(raw);
   }
 }
-var TAG13 = "stream-parser", StreamParser;
+var TAG14 = "stream-parser", StreamParser;
 var init_stream_parser = __esm(() => {
   StreamParser = class StreamParser extends EventEmitter {
     buffer = "";
@@ -4771,14 +5343,14 @@ var init_stream_parser = __esm(() => {
       try {
         msg = JSON.parse(line);
       } catch {
-        log14.debug(TAG13, `Non-JSON line: ${line.slice(0, 100)}`);
+        log15.debug(TAG14, `Non-JSON line: ${line.slice(0, 100)}`);
         return;
       }
       try {
         this.handleMessage(msg);
       } catch (err) {
         const errMsg = err instanceof Error ? err.message : String(err);
-        log14.warn(TAG13, `Error handling stream event: ${errMsg}`);
+        log15.warn(TAG14, `Error handling stream event: ${errMsg}`);
         this.emit("parse_error", errMsg);
       }
     }
@@ -4854,7 +5426,7 @@ var init_stream_parser = __esm(() => {
 });
 
 // src/transitions.ts
-import { log as log15 } from "@gethmy/harness";
+import { log as log16 } from "@gethmy/harness";
 async function withRetry(step, cardShortId, op, attempts, backoffMs) {
   let lastErr;
   for (let i = 0;i < attempts; i++) {
@@ -4865,7 +5437,7 @@ async function withRetry(step, cardShortId, op, attempts, backoffMs) {
       const msg2 = err instanceof Error ? err.message : String(err);
       if (i < attempts - 1) {
         const wait = backoffMs * 2 ** i;
-        log15.warn(TAG14, `${step} failed for #${cardShortId} (attempt ${i + 1}/${attempts}): ${msg2} — retrying in ${wait}ms`);
+        log16.warn(TAG15, `${step} failed for #${cardShortId} (attempt ${i + 1}/${attempts}): ${msg2} — retrying in ${wait}ms`);
         await new Promise((r) => setTimeout(r, wait));
       }
     }
@@ -4889,10 +5461,10 @@ async function runTransition(client, card, plan, opts = {}) {
       if (opts.strictColumn) {
         throw new TransitionError("move", 1, msg);
       }
-      log15.warn(TAG14, `#${shortId}: ${msg} — skipping move`);
+      log16.warn(TAG15, `#${shortId}: ${msg} — skipping move`);
     } else if (card.column_id !== target.id) {
       await withRetry("move", shortId, () => client.moveCard(card.id, target.id), attempts, backoffMs);
-      log15.info(TAG14, `#${shortId} → "${target.name}"`);
+      log16.info(TAG15, `#${shortId} → "${target.name}"`);
       card.column_id = target.id;
       moveLanded = true;
     } else {
@@ -4911,7 +5483,7 @@ async function runTransition(client, card, plan, opts = {}) {
         continue;
       await withRetry("addLabel", shortId, () => client.addLabelToCard(card.id, labelId), attempts, backoffMs);
       existing.add(labelId);
-      log15.info(TAG14, `#${shortId} +label "${name}"`);
+      log16.info(TAG15, `#${shortId} +label "${name}"`);
     }
     card.labelIds = Array.from(existing);
   }
@@ -4923,23 +5495,23 @@ async function runTransition(client, card, plan, opts = {}) {
         continue;
       await withRetry("removeLabel", shortId, () => client.removeLabelFromCard(card.id, match.id), attempts, backoffMs);
       existing.delete(match.id);
-      log15.info(TAG14, `#${shortId} -label "${name}"`);
+      log16.info(TAG15, `#${shortId} -label "${name}"`);
     }
     card.labelIds = Array.from(existing);
   }
   if (plan.updateCard) {
     await withRetry("updateCard", shortId, () => client.updateCard(card.id, plan.updateCard), attempts, backoffMs);
-    log15.info(TAG14, `#${shortId} updated`);
+    log16.info(TAG15, `#${shortId} updated`);
   }
   if (plan.endSession) {
     const endResult = await withRetry("endSession", shortId, () => client.endAgentSession(card.id, plan.endSession), attempts, backoffMs);
     result.endSession = endResult;
-    log15.info(TAG14, `#${shortId} session ended (${plan.endSession.status})`);
+    log16.info(TAG15, `#${shortId} session ended (${plan.endSession.status})`);
   }
   if (plan.assignAgent !== undefined) {
     const assignedAgentId = plan.assignAgent;
     await withRetry("assignAgent", shortId, () => client.updateCard(card.id, { assignedAgentId }), attempts, backoffMs);
-    log15.info(TAG14, assignedAgentId ? `#${shortId} assigned → agent ${assignedAgentId}` : `#${shortId} unassigned`);
+    log16.info(TAG15, assignedAgentId ? `#${shortId} assigned → agent ${assignedAgentId}` : `#${shortId} unassigned`);
   }
   if (opts.store && opts.runId) {
     try {
@@ -4953,11 +5525,11 @@ async function ensureLabel(client, projectId, name, color, attempts, backoffMs)
     const result = await withRetry("addLabel", 0, () => client.createLabel(projectId, { name, color: color ?? "#8b5cf6" }), attempts, backoffMs);
     return result?.label?.id ?? null;
   } catch (err) {
-    log15.warn(TAG14, `ensureLabel "${name}" failed: ${err instanceof Error ? err.message : err}`);
+    log16.warn(TAG15, `ensureLabel "${name}" failed: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
-var TAG14 = "transition", TransitionError;
+var TAG15 = "transition", TransitionError;
 var init_transitions = __esm(() => {
   TransitionError = class TransitionError extends Error {
     step;
@@ -4974,14 +5546,14 @@ var init_transitions = __esm(() => {
 });
 
 // src/review-worker.ts
-import { execFileSync as execFileSync3 } from "node:child_process";
+import { execFileSync as execFileSync4 } from "node:child_process";
 import {
   buildGateCollectorRegistry,
   cleanupWorktree as cleanupWorktree3,
   collectGateEvidence,
   DevServerReadinessError,
   formatDiffSummary,
-  log as log16,
+  log as log17,
   probeDevServer,
   resolveStageGate,
   signalGroup,
@@ -5012,10 +5584,17 @@ class ReviewWorker {
   lastSessionStats = null;
   aborted = false;
   timedOut = false;
+  lastStopReason = null;
   sessionConflict = false;
   runId = null;
   lastRunLogPath = null;
   sessionId = null;
+  cliSessionId = null;
+  grantedTurns = null;
+  resumeMessage = null;
+  get effectiveMaxTurns() {
+    return this.grantedTurns ?? this.config.claude.reviewMaxTurns;
+  }
   constructor(id, config, client, identity, onDone, stateStore, workspaceId, _projectId) {
     this.config = config;
     this.client = client;
@@ -5041,6 +5620,14 @@ class ReviewWorker {
       this.heartbeatTimer = null;
     }
   }
+  captureCliSessionId(sessionId) {
+    if (!sessionId || sessionId === this.cliSessionId)
+      return;
+    this.cliSessionId = sessionId;
+    if (this.runId) {
+      this.stateStore.updateRun(this.runId, { cliSessionId: sessionId }).catch(() => {});
+    }
+  }
   async recordPhase(phase) {
     if (!this.runId)
       return;
@@ -5049,14 +5636,16 @@ class ReviewWorker {
         phase,
         lastHeartbeatAt: Date.now(),
         worktreePath: this.worktreePath,
-        branchName: this.branchName
+        branchName: this.branchName,
+        sessionId: this.sessionId,
+        cliSessionId: this.cliSessionId
       });
     } catch (err) {
-      log16.warn(this.tag, `state store updateRun failed: ${err instanceof Error ? err.message : err}`);
+      log17.warn(this.tag, `state store updateRun failed: ${err instanceof Error ? err.message : err}`);
     }
   }
   get tag() {
-    return `${TAG15}:${this.id}`;
+    return `${TAG16}:${this.id}`;
   }
   get isIdle() {
     return this.state === "idle";
@@ -5083,70 +5672,95 @@ class ReviewWorker {
   async run(card, column, labels, subtasks) {
     this.aborted = false;
     this.timedOut = false;
+    this.lastStopReason = null;
     this.sessionConflict = false;
+    this.cliSessionId = null;
+    this.grantedTurns = null;
+    this.resumeMessage = null;
     this.cardId = card.id;
     this.startedAt = Date.now();
     this.runId = newRunId();
+    const resuming = this.stateStore.getResumableRunForCard(card.id);
+    if (resuming) {
+      this.runId = resuming.runId;
+      this.worktreePath = resuming.worktreePath;
+      this.branchName = resuming.branchName;
+      this.cliSessionId = resuming.cliSessionId ?? null;
+      this.sessionId = resuming.sessionId;
+      this.grantedTurns = resuming.grantedTurns ?? null;
+      this.resumeMessage = resuming.resumeMessage ?? null;
+      try {
+        await this.stateStore.updateRun(resuming.runId, {
+          grantedTurns: null,
+          resumeMessage: null
+        });
+      } catch (err) {
+        log17.warn(this.tag, `Failed to clear the consumed grant: ${err}`);
+      }
+    }
     try {
       this.state = "preparing";
-      log16.info(this.tag, `Preparing review for #${card.short_id} "${card.title}"`);
+      log17.info(this.tag, resuming ? `Resuming review of #${card.short_id} "${card.title}" with ${this.grantedTurns ?? "the default"} more turns` : `Preparing review for #${card.short_id} "${card.title}"`);
       this.startHeartbeat();
-      await this.stateStore.insertRun({
-        runId: this.runId,
-        cardId: card.id,
-        cardShortId: card.short_id,
-        pipeline: "review",
-        workerId: this.id,
-        sessionId: null,
-        worktreePath: null,
-        branchName: null,
-        daemonPid: process.pid,
-        phase: "preparing",
-        startedAt: this.startedAt,
-        lastHeartbeatAt: this.startedAt,
-        endedAt: null,
-        status: "active",
-        costCents: 0,
-        numTurns: 0
-      });
-      const repoRoot = execFileSync3("git", ["rev-parse", "--show-toplevel"], {
-        encoding: "utf-8",
-        timeout: 5000
-      }).trim();
-      const resolution = await resolveReviewBranch(card.description, repoRoot);
-      if (resolution.kind !== "branch") {
-        const why = resolution.kind === "skip" ? resolution.reason : "no branch or PR reference";
-        log16.info(this.tag, `#${card.short_id} not auto-reviewable (${why}) — marking for human review (staying in Review)`);
-        await addLabelByName(this.client, card, NEED_REVIEW_LABEL, NEED_REVIEW_LABEL_COLOR);
-        return;
-      }
-      this.branchName = resolution.branch;
-      log16.info(this.tag, `Review branch: ${this.branchName}`);
-      let reviewSession;
-      try {
-        const started = await this.client.startAgentSession(card.id, {
-          agentIdentifier: agentIdentifier(this.id),
-          agentName: `${AGENT_NAME} (Review)`,
-          agentId: this.identity.agentId,
-          status: "working",
-          currentTask: "Setting up review worktree",
-          progressPercent: 5,
-          modelName: this.config.claude.reviewModel,
-          driver: "daemon"
+      if (!resuming) {
+        await this.stateStore.insertRun({
+          runId: this.runId,
+          cardId: card.id,
+          cardShortId: card.short_id,
+          pipeline: "review",
+          workerId: this.id,
+          sessionId: null,
+          worktreePath: null,
+          branchName: null,
+          daemonPid: process.pid,
+          phase: "preparing",
+          startedAt: this.startedAt,
+          lastHeartbeatAt: this.startedAt,
+          endedAt: null,
+          status: "active",
+          costCents: 0,
+          numTurns: 0
         });
-        reviewSession = started.session;
-      } catch (err) {
-        if (isSessionConflict(err)) {
-          this.sessionConflict = true;
-          log16.info(this.tag, `Skipping review of #${card.short_id}: ${err instanceof Error ? err.message : String(err)}`);
+        const repoRoot = execFileSync4("git", ["rev-parse", "--show-toplevel"], {
+          encoding: "utf-8",
+          timeout: 5000
+        }).trim();
+        const resolution = await resolveReviewBranch(card.description, repoRoot);
+        if (resolution.kind !== "branch") {
+          const why = resolution.kind === "skip" ? resolution.reason : "no branch or PR reference";
+          log17.info(this.tag, `#${card.short_id} not auto-reviewable (${why}) — marking for human review (staying in Review)`);
+          await addLabelByName(this.client, card, NEED_REVIEW_LABEL, NEED_REVIEW_LABEL_COLOR);
           return;
         }
-        throw err;
+        this.branchName = resolution.branch;
+        log17.info(this.tag, `Review branch: ${this.branchName}`);
+        let reviewSession;
+        try {
+          const started = await this.client.startAgentSession(card.id, {
+            agentIdentifier: agentIdentifier(this.id),
+            agentName: `${AGENT_NAME} (Review)`,
+            agentId: this.identity.agentId,
+            status: "working",
+            currentTask: "Setting up review worktree",
+            progressPercent: 5,
+            modelName: this.config.claude.reviewModel,
+            driver: "daemon",
+            awaitingDecisionUntil: null
+          });
+          reviewSession = started.session;
+        } catch (err) {
+          if (isSessionConflict(err)) {
+            this.sessionConflict = true;
+            log17.info(this.tag, `Skipping review of #${card.short_id}: ${err instanceof Error ? err.message : String(err)}`);
+            return;
+          }
+          throw err;
+        }
+        this.sessionId = reviewSession && typeof reviewSession === "object" && "id" in reviewSession ? reviewSession.id ?? null : null;
+        const labelPromise = addLabelByName(this.client, card, "agent", "#8b5cf6");
+        this.worktreePath = checkoutExistingBranch(this.config.worktree.basePath, this.branchName);
+        await labelPromise;
       }
-      this.sessionId = reviewSession && typeof reviewSession === "object" && "id" in reviewSession ? reviewSession.id ?? null : null;
-      const labelPromise = addLabelByName(this.client, card, "agent", "#8b5cf6");
-      this.worktreePath = checkoutExistingBranch(this.config.worktree.basePath, this.branchName);
-      await labelPromise;
       if (this.aborted)
         return;
       this.state = "running";
@@ -5156,7 +5770,7 @@ class ReviewWorker {
       }
       const port = this.reviewPort;
       const cwd = this.worktreePath;
-      log16.info(this.tag, `Starting dev server on port ${port}...`);
+      log17.info(this.tag, `Starting dev server on port ${port}...`);
       const [devCmd, devArgs] = spawnRunArgs("dev", "--port", String(port));
       this.devServerProcess = spawnInGroup(devCmd, devArgs, {
         cwd,
@@ -5178,7 +5792,7 @@ class ReviewWorker {
       }
       await waitForDevServer(this.devServerProcess, 30000);
       await probeDevServer(port);
-      log16.info(this.tag, `Dev server ready on port ${port}`);
+      log17.info(this.tag, `Dev server ready on port ${port}`);
       await this.client.updateAgentProgress(card.id, {
         agentIdentifier: agentIdentifier(this.id),
         agentName: `${AGENT_NAME} (Review)`,
@@ -5190,7 +5804,7 @@ class ReviewWorker {
         return;
       let diff = "";
       try {
-        diff = execFileSync3("git", ["diff", `origin/${this.config.worktree.baseBranch}..HEAD`], { cwd, encoding: "utf-8", timeout: 30000 });
+        diff = execFileSync4("git", ["diff", `origin/${this.config.worktree.baseBranch}..HEAD`], { cwd, encoding: "utf-8", timeout: 30000 });
       } catch {
         diff = "(unable to retrieve diff)";
       }
@@ -5211,14 +5825,19 @@ class ReviewWorker {
             pinnedContract = extractPinnedContract(comments, this.identity);
           }
         } catch (err) {
-          log16.warn(this.tag, `pinned-contract fetch failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+          log17.warn(this.tag, `pinned-contract fetch failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
         }
         if (pinnedContract) {
-          log16.info(this.tag, `Grading pinned contract for #${card.short_id} (${pinnedContract.assertions.length} criteria)`);
+          log17.info(this.tag, `Grading pinned contract for #${card.short_id} (${pinnedContract.assertions.length} criteria)`);
         }
       }
       const systemPrompt = buildReviewSystemPrompt();
-      const userPrompt = buildReviewUserPrompt(enriched, this.branchName, cwd, previewUrl, diffSummary, this.config.worktree.baseBranch, undefined, pinnedContract);
+      let userPrompt = buildReviewUserPrompt(enriched, this.branchName, cwd, previewUrl, diffSummary, this.config.worktree.baseBranch, undefined, pinnedContract);
+      if (resuming && this.resumeMessage) {
+        userPrompt = `${buildSteeringPrompt([this.resumeMessage])}
+
+${userPrompt}`;
+      }
       try {
         await this.client.recordPromptHistory({
           cardId: card.id,
@@ -5227,7 +5846,7 @@ class ReviewWorker {
           contextIncluded: { source: "review-knowledge", mode: "review" }
         });
       } catch (err) {
-        log16.warn(this.tag, `prompt_history persistence skipped: ${err instanceof Error ? err.message : String(err)}`);
+        log17.warn(this.tag, `prompt_history persistence skipped: ${err instanceof Error ? err.message : String(err)}`);
       }
       await this.client.updateAgentProgress(card.id, {
         agentIdentifier: agentIdentifier(this.id),
@@ -5237,13 +5856,16 @@ class ReviewWorker {
         progressPercent: 20
       });
       this.timeoutTimer = setTimeout(() => {
-        log16.warn(this.tag, `Review timeout reached (${this.config.review.maxTimeout}ms), cancelling`);
+        log17.warn(this.tag, `Review timeout reached (${this.config.review.maxTimeout}ms), cancelling`);
         this.timedOut = true;
         this.cancel("timeout");
       }, this.config.review.maxTimeout);
       this.progressTracker = new ProgressTracker(this.client, card.id, this.id, subtasks);
       this.progressTracker.setRequestedModel(this.config.claude.reviewModel);
-      const stdout = await this.spawnClaude(userPrompt, systemPrompt, this.progressTracker, card.short_id);
+      const stdout = await this.spawnClaude(userPrompt, systemPrompt, this.progressTracker, card.short_id, {
+        maxTurns: this.grantedTurns ?? undefined,
+        resumeSessionId: this.cliSessionId ?? undefined
+      });
       this.lastSessionStats = this.progressTracker?.stats ?? null;
       this.progressTracker?.stop();
       this.progressTracker = null;
@@ -5256,10 +5878,10 @@ class ReviewWorker {
       }
       this.state = "completing";
       await this.recordPhase("completing");
-      log16.info(this.tag, `Claude review finished for #${card.short_id}`);
+      log17.info(this.tag, `Claude review finished for #${card.short_id}`);
       this.killDevServer();
       const result = parseReviewOutput(stdout);
-      log16.info(this.tag, `Review verdict: ${result.verdict} (${result.findings.length} finding(s))`);
+      log17.info(this.tag, `Review verdict: ${result.verdict} (${result.findings.length} finding(s))`);
       await this.client.updateAgentProgress(card.id, {
         agentIdentifier: agentIdentifier(this.id),
         agentName: `${AGENT_NAME} (Review)`,
@@ -5270,9 +5892,17 @@ class ReviewWorker {
       await runReviewCompletion(this.client, card, result, this.config, cwd, this.branchName, sessionStats, this.lastRunLogPath, this.workspaceId, this.sessionId, this.stateStore, reviewedFromPrUrl(card.description));
       await this.collectReviewGate(card, result);
     } catch (err) {
+      if (err instanceof BudgetPauseError) {
+        await this.parkForDecision(card, err.trigger);
+        return;
+      }
+      if (resuming && isSessionConflict(err)) {
+        await this.holdParkOnSessionConflict(card, err);
+        return;
+      }
       this.state = "error";
       const msg = err instanceof Error ? err.message : String(err);
-      log16.error(this.tag, `Error reviewing #${card.short_id}: ${msg}`);
+      log17.error(this.tag, `Error reviewing #${card.short_id}: ${msg}`);
       try {
         const stats = this.lastSessionStats ?? this.progressTracker?.stats;
         await runTransition(this.client, card, {
@@ -5282,21 +5912,21 @@ class ReviewWorker {
           }
         });
       } catch (tErr) {
-        log16.error(this.tag, `endAgentSession unrecoverable on #${card.short_id}: ${tErr instanceof TransitionError ? tErr.detail : tErr}`);
+        log17.error(this.tag, `endAgentSession unrecoverable on #${card.short_id}: ${tErr instanceof TransitionError ? tErr.detail : tErr}`);
       }
       if (err instanceof DevServerReadinessError) {
         try {
           await addLabelByName(this.client, card, NEED_REVIEW_LABEL, NEED_REVIEW_LABEL_COLOR);
-          log16.info(this.tag, `#${card.short_id} kept in Review — dev server unavailable, human review needed`);
+          log17.info(this.tag, `#${card.short_id} kept in Review — dev server unavailable, human review needed`);
         } catch {
-          log16.warn(this.tag, "Failed to add Need Review label after dev-server failure");
+          log17.warn(this.tag, "Failed to add Need Review label after dev-server failure");
         }
       } else {
         try {
           await moveCardToColumn(this.client, card, this.config.review.failColumn);
-          log16.info(this.tag, `Moved #${card.short_id} to "${this.config.review.failColumn}" after error`);
+          log17.info(this.tag, `Moved #${card.short_id} to "${this.config.review.failColumn}" after error`);
         } catch {
-          log16.warn(this.tag, "Failed to move card to fail column after error");
+          log17.warn(this.tag, "Failed to move card to fail column after error");
         }
       }
       if (this.runId) {
@@ -5308,21 +5938,119 @@ class ReviewWorker {
       if (this.runId) {
         try {
           const run = this.stateStore.getRun(this.runId);
-          if (run && run.endedAt === null) {
+          if (run && run.endedAt === null && run.status !== "parked") {
             const status = this.timedOut ? "failed" : this.state === "error" || this.aborted || this.sessionConflict ? "paused" : "completed";
             await this.stateStore.endRun(this.runId, status, this.sessionConflict ? { errorMessage: "session_conflict", ...this.endLedger() } : this.endLedger());
           }
         } catch {}
       }
+      if (this.cardId && this.timedOut && this.config.budget.pause.enabled && this.state !== "parked" && this.state !== "error") {
+        try {
+          await this.client.endAgentSession(this.cardId, {
+            status: "failed",
+            failureReason: "timeout",
+            failureSummary: `Review exceeded the ${Math.round(this.config.review.maxTimeout / 60000)} min timeout`,
+            ...buildTokenPayload(this.lastSessionStats)
+          });
+        } catch {}
+      }
       this.cleanup();
       this.state = "idle";
       this.onDone(this);
     }
   }
+  async holdParkOnSessionConflict(card, err) {
+    this.state = "parked";
+    this.progressTracker?.stop();
+    this.progressTracker = null;
+    const holderMessage = err instanceof Error ? err.message : String(err);
+    const waitHours = this.config.budget.pause.waitHours;
+    const until = computeDecisionDeadline(waitHours);
+    log17.warn(this.tag, `#${card.short_id} stays parked — the resume could not reclaim its session: ${holderMessage}`);
+    try {
+      await this.client.addComment(card.id, formatResumeConflictComment({
+        holderMessage,
+        branchName: this.branchName,
+        cliSessionId: this.cliSessionId,
+        waitHours
+      }), {
+        commentType: "blocker",
+        agentSessionId: this.sessionId ?? undefined
+      });
+    } catch (commentErr) {
+      log17.warn(this.tag, `Failed to post the resume-conflict note for #${card.short_id}: ${commentErr}`);
+    }
+    if (this.runId) {
+      const run = this.stateStore.getRun(this.runId);
+      try {
+        await this.stateStore.parkRun(this.runId, {
+          pauseTrigger: run?.pauseTrigger ?? "timeout",
+          blockerCommentId: run?.blockerCommentId ?? null,
+          awaitingDecisionUntil: until
+        });
+      } catch (storeErr) {
+        log17.error(this.tag, `#${card.short_id} could not be re-parked after a resume conflict — the daemon has no hold on it: ${storeErr}`);
+      }
+    }
+  }
+  async parkForDecision(card, trigger) {
+    this.state = "parked";
+    const stats = this.lastSessionStats ?? this.progressTracker?.stats;
+    const lastAction = this.progressTracker?.lastActionSummary ?? null;
+    this.progressTracker?.stop();
+    this.progressTracker = null;
+    const waitHours = this.config.budget.pause.waitHours;
+    const until = computeDecisionDeadline(waitHours);
+    log17.warn(this.tag, `#${card.short_id} parked (${trigger}) — awaiting a human decision for ${waitHours}h`);
+    const body = formatBudgetComment({
+      trigger,
+      numTurns: stats?.cost?.numTurns ?? 0,
+      maxTurns: this.effectiveMaxTurns,
+      toolCalls: stats?.toolCalls ?? 0,
+      durationMs: stats?.cost?.durationMs ?? 0,
+      costUsd: stats?.cost?.totalCostUsd ?? 0,
+      lastAction,
+      branchName: this.branchName,
+      waitHours
+    });
+    let commentId = null;
+    try {
+      const res = await this.client.addComment(card.id, body, {
+        commentType: "blocker"
+      });
+      commentId = res?.comment?.id ?? null;
+    } catch (err) {
+      log17.warn(this.tag, `Failed to post the budget-pause comment: ${err}`);
+    }
+    try {
+      await this.client.updateAgentProgress(card.id, {
+        agentIdentifier: agentIdentifier(this.id),
+        agentName: `${AGENT_NAME} (Review)`,
+        status: "blocked",
+        currentTask: "Waiting for your decision on the turn budget",
+        awaitingDecisionUntil: new Date(until).toISOString()
+      });
+    } catch (err) {
+      log17.warn(this.tag, `Failed to mark the session blocked: ${err}`);
+    }
+    if (this.runId) {
+      try {
+        await this.stateStore.parkRun(this.runId, {
+          pauseTrigger: trigger,
+          blockerCommentId: commentId,
+          awaitingDecisionUntil: until,
+          costCents: Math.round((stats?.cost?.totalCostUsd ?? 0) * 100),
+          numTurns: stats?.cost?.numTurns ?? 0
+        });
+      } catch (err) {
+        log17.error(this.tag, `#${card.short_id} parkRun failed after the blocker comment + blocked session were already written — the daemon has no local record of this park: ${err}`);
+      }
+    }
+  }
   async pause() {
     if (!this.isActive || !this.process || this.process.killed)
       return;
-    log16.info(this.tag, `Pausing review on ${this.cardId}`);
+    log17.info(this.tag, `Pausing review on ${this.cardId}`);
     signalGroup(this.process, "SIGSTOP");
     if (this.timeoutTimer) {
       clearTimeout(this.timeoutTimer);
@@ -5336,17 +6064,17 @@ class ReviewWorker {
           status: "paused"
         });
       } catch {
-        log16.warn(this.tag, "Failed to update agent session to paused");
+        log17.warn(this.tag, "Failed to update agent session to paused");
       }
     }
   }
   async resume() {
     if (!this.isActive || !this.process || this.process.killed)
       return;
-    log16.info(this.tag, `Resuming review on ${this.cardId}`);
+    log17.info(this.tag, `Resuming review on ${this.cardId}`);
     signalGroup(this.process, "SIGCONT");
     this.timeoutTimer = setTimeout(() => {
-      log16.warn(this.tag, `Timeout reached (${this.config.review.maxTimeout}ms), cancelling`);
+      log17.warn(this.tag, `Timeout reached (${this.config.review.maxTimeout}ms), cancelling`);
       this.timedOut = true;
       this.cancel("timeout");
     }, this.config.review.maxTimeout);
@@ -5358,7 +6086,7 @@ class ReviewWorker {
           status: "working"
         });
       } catch {
-        log16.warn(this.tag, "Failed to update agent session to working");
+        log17.warn(this.tag, "Failed to update agent session to working");
       }
     }
   }
@@ -5367,7 +6095,7 @@ class ReviewWorker {
       return;
     this.aborted = true;
     this.state = "cancelling";
-    log16.info(this.tag, `Cancelling review on ${this.cardId}`);
+    log17.info(this.tag, `Cancelling review on ${this.cardId}`);
     const snapshotStats = this.lastSessionStats ?? this.progressTracker?.stats;
     if (this.progressTracker) {
       this.progressTracker?.stop();
@@ -5380,7 +6108,8 @@ class ReviewWorker {
         sigtermTimeoutMs: CANCEL_SIGTERM_TIMEOUT
       });
     }
-    if (this.cardId) {
+    const parkingOnTimeout = this.timedOut && this.config.budget.pause.enabled;
+    if (this.cardId && !parkingOnTimeout) {
       try {
         await this.client.endAgentSession(this.cardId, {
           status: this.timedOut ? "failed" : endStatusForCancel(reason),
@@ -5393,7 +6122,8 @@ class ReviewWorker {
       } catch {}
     }
   }
-  spawnClaude(prompt, systemPrompt, tracker, shortId) {
+  spawnClaude(prompt, systemPrompt, tracker, shortId, opts = {}) {
+    const effectiveMaxTurns = opts.maxTurns ?? this.config.claude.reviewMaxTurns;
     return new Promise((resolve2, reject) => {
       const leanSources = this.config.claude.leanSettingSources;
       const reviewDenylist = reviewDisallowedTools();
@@ -5404,21 +6134,22 @@ class ReviewWorker {
         "--model",
         this.config.claude.reviewModel,
         "--max-turns",
-        String(this.config.claude.reviewMaxTurns),
+        String(effectiveMaxTurns),
         "--allowedTools",
         "Bash(readonly),Read,Glob,Grep,Agent,mcp__harmony__*",
         ...reviewDenylist ? ["--disallowedTools", reviewDenylist] : [],
+        ...opts.resumeSessionId ? ["--resume", opts.resumeSessionId] : [],
         ...leanSources ? ["--setting-sources", leanSources] : [],
         ...systemPrompt ? ["--append-system-prompt", systemPrompt] : [],
         ...this.config.claude.additionalArgs,
         "--",
         prompt
       ];
-      log16.info(this.tag, `Spawning review: claude ${args.slice(0, 5).join(" ")} ...`);
+      log17.info(this.tag, `Spawning review: claude ${args.slice(0, 5).join(" ")} ...`);
       const runLog = openRunLog(this.tag, this.runId, shortId);
       this.lastRunLogPath = runLog?.path ?? null;
       if (runLog) {
-        log16.info(this.tag, `Run log: ${runLog.path}`);
+        log17.info(this.tag, `Run log: ${runLog.path}`);
         runLog.stream.write(`# run=${this.runId} card=#${shortId} pipeline=review started=${new Date().toISOString()}
 ` + `# args: ${args.slice(0, -2).join(" ")} -- <prompt:${prompt.length} chars>
 
@@ -5433,13 +6164,17 @@ class ReviewWorker {
       const textChunks = [];
       parser.on("text", (content) => {
         textChunks.push(content);
+        this.captureCliSessionId(parser.sessionId);
       });
       parser.on("parse_error", (msg) => {
-        log16.debug(this.tag, `Stream parse error (non-fatal): ${msg}`);
+        log17.debug(this.tag, `Stream parse error (non-fatal): ${msg}`);
         runLog?.stream.write(`
 [parse_error] ${msg}
 `);
       });
+      parser.on("result", (stop) => {
+        this.lastStopReason = stop;
+      });
       if (this.process?.stdout) {
         parser.attach(this.process.stdout);
         if (runLog) {
@@ -5458,6 +6193,7 @@ class ReviewWorker {
       });
       this.process?.on("close", (code) => {
         this.process = null;
+        this.captureCliSessionId(parser.sessionId);
         const stdout = textChunks.join("");
         const stats = tracker.stats;
         if (runLog) {
@@ -5466,10 +6202,21 @@ class ReviewWorker {
 `);
           runLog.stream.end();
         }
-        if (this.aborted) {
+        const trigger = this.config.budget.pause.enabled ? classifyRunExit({
+          exitCode: code ?? 1,
+          stopReason: this.lastStopReason,
+          numTurns: stats?.cost?.numTurns ?? 0,
+          maxTurns: effectiveMaxTurns,
+          timedOut: this.timedOut
+        }) : null;
+        if (this.timedOut && trigger) {
+          reject(new BudgetPauseError(trigger));
+        } else if (this.aborted) {
           resolve2(stdout);
         } else if (code === 0) {
           resolve2(stdout);
+        } else if (trigger) {
+          reject(new BudgetPauseError(trigger));
         } else {
           reject(new Error(`claude exited with code ${code}${stderr ? `: ${stderr.slice(0, 500)}` : ""}`));
         }
@@ -5499,16 +6246,16 @@ class ReviewWorker {
       const evidence = await collectGateEvidence(registry, context);
       const evaluation = gateEvaluate(resolved.gate, evidence);
       await this.client.request("POST", `/cards/${encodeURIComponent(card.id)}/stage-gate-evidence`, toStageGateEvidenceInsert(context, evidence));
-      log16.info(this.tag, `Recorded review_passed gate evidence for #${card.short_id} stage "${resolved.stage.name}": result=${evidence.result} passed=${evaluation.passed}`);
+      log17.info(this.tag, `Recorded review_passed gate evidence for #${card.short_id} stage "${resolved.stage.name}": result=${evidence.result} passed=${evaluation.passed}`);
     } catch (err) {
-      log16.warn(this.tag, `review gate evidence collection failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+      log17.warn(this.tag, `review gate evidence collection failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
     }
   }
   killDevServer() {
     if (this.devServerProcess && !this.devServerProcess.killed) {
       signalGroup(this.devServerProcess, "SIGTERM");
       this.devServerProcess = null;
-      log16.debug(this.tag, "Killed dev server group");
+      log17.debug(this.tag, "Killed dev server group");
     }
   }
   cleanup() {
@@ -5516,13 +6263,17 @@ class ReviewWorker {
       clearTimeout(this.timeoutTimer);
       this.timeoutTimer = null;
     }
+    if (this.progressTracker) {
+      this.progressTracker.stop();
+      this.progressTracker = null;
+    }
     this.stopHeartbeat();
     this.killDevServer();
-    if (this.worktreePath && this.state === "error" && this.branchName) {
+    if (this.worktreePath && this.state === "error") {
       try {
-        cleanupWorktree3(this.worktreePath, this.branchName);
+        cleanupWorktree3(this.worktreePath);
       } catch {
-        log16.warn(this.tag, "Failed to cleanup review worktree");
+        log17.warn(this.tag, "Failed to cleanup review worktree");
       }
     }
     this.process = null;
@@ -5534,13 +6285,15 @@ class ReviewWorker {
     this.lastSessionStats = null;
   }
 }
-var TAG15 = "review-worker", CANCEL_SIGINT_TIMEOUT = 30000, CANCEL_SIGTERM_TIMEOUT = 1e4;
+var TAG16 = "review-worker", CANCEL_SIGINT_TIMEOUT = 30000, CANCEL_SIGTERM_TIMEOUT = 1e4;
 var init_review_worker = __esm(() => {
   init_dist();
   init_board_helpers();
+  init_budget_pause();
   init_completion();
   init_contract_phase();
   init_progress_tracker();
+  init_prompt();
   init_review_completion();
   init_review_prompt();
   init_review_worktree();
@@ -5553,7 +6306,7 @@ var init_review_worker = __esm(() => {
 
 // src/sleep-guard.ts
 import { spawn } from "node:child_process";
-import { log as log17 } from "@gethmy/harness";
+import { log as log18 } from "@gethmy/harness";
 
 class SleepGuard {
   platform;
@@ -5581,7 +6334,7 @@ class SleepGuard {
       if (!this.child.killed)
         this.child.kill("SIGTERM");
       this.child = null;
-      log17.info(TAG16, "sleep assertion released");
+      log18.info(TAG17, "sleep assertion released");
     }
   }
   start() {
@@ -5596,7 +6349,7 @@ class SleepGuard {
         spawned = true;
       });
       child.on("error", (err) => {
-        log17.warn(TAG16, `caffeinate unavailable: ${err.message}`);
+        log18.warn(TAG17, `caffeinate unavailable: ${err.message}`);
         if (this.child === child)
           this.child = null;
       });
@@ -5609,23 +6362,23 @@ class SleepGuard {
       });
       child.unref();
       this.child = child;
-      log17.info(TAG16, "sleep assertion acquired (caffeinate -i)");
+      log18.info(TAG17, "sleep assertion acquired (caffeinate -i)");
     } catch (err) {
-      log17.warn(TAG16, `failed to spawn caffeinate: ${err instanceof Error ? err.message : err}`);
+      log18.warn(TAG17, `failed to spawn caffeinate: ${err instanceof Error ? err.message : err}`);
     }
   }
 }
-var TAG16 = "sleep-guard";
+var TAG17 = "sleep-guard";
 var init_sleep_guard = () => {};
 
 // src/unblock.ts
-import { log as log18 } from "@gethmy/harness";
+import { log as log19 } from "@gethmy/harness";
 async function fetchBlocksLinks(client, cardId) {
   try {
     const { links } = await client.getCardLinks(cardId);
     return links.filter((l) => l.link_type === "blocks");
   } catch (err) {
-    log18.warn(TAG17, `link fetch failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
+    log19.warn(TAG18, `link fetch failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
@@ -5657,31 +6410,31 @@ async function promoteUnblockedSuccessors(completedCard, deps) {
   const successors = links.filter((l) => l.direction === "outgoing" && !l.target_card.done);
   if (successors.length === 0)
     return;
-  log18.info(TAG17, `#${completedCard.short_id} completed — checking ${successors.length} chained successor(s)`);
+  log19.info(TAG18, `#${completedCard.short_id} completed — checking ${successors.length} chained successor(s)`);
   for (const link of successors) {
     const successorId = link.target_card.id;
     try {
       const { card } = await deps.client.getCard(successorId);
       if (card.assigned_agent_id === deps.agentId) {} else if (card.assigned_agent_id === null && !card.assignee_id) {
-        log18.info(TAG17, `successor #${card.short_id} unassigned — auto-assigning to continue chain`);
+        log19.info(TAG18, `successor #${card.short_id} unassigned — auto-assigning to continue chain`);
         await deps.client.updateCard(successorId, {
           assignedAgentId: deps.agentId
         });
       } else {
-        log18.debug(TAG17, `successor #${card.short_id} assigned to different entity — skipping`);
+        log19.debug(TAG18, `successor #${card.short_id} assigned to different entity — skipping`);
         continue;
       }
       await deps.enqueue(successorId);
     } catch (err) {
-      log18.warn(TAG17, `promotion failed for successor ${successorId}: ${err instanceof Error ? err.message : err}`);
+      log19.warn(TAG18, `promotion failed for successor ${successorId}: ${err instanceof Error ? err.message : err}`);
     }
   }
 }
-var TAG17 = "unblock";
+var TAG18 = "unblock";
 var init_unblock = () => {};
 
 // src/cli-agent-runner.ts
-import { log as log19 } from "@gethmy/harness";
+import { log as log20 } from "@gethmy/harness";
 function truncateOutput(value) {
   return value === undefined ? undefined : value.slice(0, MAX_OUTPUT_LEN);
 }
@@ -5831,7 +6584,7 @@ class CliAgentRunner {
         events: batch
       });
     } catch (err) {
-      log19.warn(TAG18, `Failed to flush run events: ${err}`);
+      log20.warn(TAG19, `Failed to flush run events: ${err}`);
       this.buffer.unshift(...batch);
       if (this.buffer.length > MAX_BUFFER) {
         this.buffer.length = MAX_BUFFER;
@@ -5868,15 +6621,19 @@ function mapCost(cost) {
     durationMs: cost.durationMs
   };
 }
-var TAG18 = "cli-agent-runner", FLUSH_INTERVAL_MS = 2000, MAX_BUFFER = 1000, MAX_TEXT_LEN = 8000, MAX_OUTPUT_LEN = 4000;
+var TAG19 = "cli-agent-runner", FLUSH_INTERVAL_MS = 2000, MAX_BUFFER = 1000, MAX_TEXT_LEN = 8000, MAX_OUTPUT_LEN = 4000;
 var init_cli_agent_runner = () => {};
 
 // src/motor-driver.ts
-import { spawn as spawn2 } from "node:child_process";
 import { mkdtempSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { tmpdir } from "node:os";
 import { dirname as dirname2, join as join4 } from "node:path";
+import {
+  reapGroup,
+  spawnInGroup as spawnInGroup2,
+  terminateGroup as terminateGroup2
+} from "@gethmy/harness";
 function motorApiBase(apiUrl) {
   return apiUrl.replace(/\/+$/, "").replace(/\/v1$/, "");
 }
@@ -5900,7 +6657,7 @@ function evaluationFromVerdict(v, structured) {
 }
 function runMotorStage(args, deps) {
   const bin = deps.binPath ?? resolveMotorBin();
-  const spawnFn = deps.spawnFn ?? spawn2;
+  const spawnFn = deps.spawnFn ?? spawnInGroup2;
   const argv = [
     bin,
     "stage",
@@ -5926,6 +6683,14 @@ function runMotorStage(args, deps) {
       },
       stdio: ["ignore", "pipe", "pipe"]
     });
+    const pgid = child.pid;
+    let swept = false;
+    const sweepGroupOnce = () => {
+      if (swept)
+        return;
+      swept = true;
+      reapGroup(pgid);
+    };
     const lines = [];
     let verdict = null;
     let structured = null;
@@ -5941,15 +6706,15 @@ function runMotorStage(args, deps) {
       resolve2(result);
     };
     function onAbort() {
-      try {
-        child.kill("SIGTERM");
-        const escalate = setTimeout(() => {
-          try {
-            child.kill("SIGKILL");
-          } catch {}
-        }, ABORT_SIGKILL_GRACE_MS);
-        escalate.unref?.();
-      } catch {}
+      (async () => {
+        try {
+          await terminateGroup2(child, {
+            sigintTimeoutMs: ABORT_SIGINT_GRACE_MS,
+            sigtermTimeoutMs: ABORT_SIGTERM_GRACE_MS
+          });
+        } catch {}
+        sweepGroupOnce();
+      })();
       settleOnce({
         exitCode: 1,
         lines,
@@ -5975,7 +6740,8 @@ function runMotorStage(args, deps) {
           let line = null;
           try {
             line = JSON.parse(raw);
-            lines.push(line);
+            if (line.type !== "agent_event")
+              lines.push(line);
             if (line.type === "gate_verdict") {
               verdict = { passed: line.passed, findings: line.findings };
             }
@@ -6024,6 +6790,7 @@ function runMotorStage(args, deps) {
       });
     });
     child.on("close", (code) => {
+      sweepGroupOnce();
       settleOnce({
         exitCode: code ?? 1,
         lines,
@@ -6034,156 +6801,9 @@ function runMotorStage(args, deps) {
     });
   });
 }
-var ABORT_SIGKILL_GRACE_MS = 1e4;
+var ABORT_SIGINT_GRACE_MS = 12000, ABORT_SIGTERM_GRACE_MS = 6000;
 var init_motor_driver = () => {};
 
-// src/prompt.ts
-import { log as log20 } from "@gethmy/harness";
-function renderPreviousAttemptsSection(failures) {
-  if (failures.length === 0)
-    return "";
-  const lines = failures.map((f) => {
-    const tag = f.reason ? `[${f.reason}] ` : "";
-    return `- ${tag}${f.summary}`;
-  });
-  return [
-    "## Previous attempt feedback",
-    "This is a re-attempt on the branch your last run already pushed — build on that existing work and FIX the issues below. Do NOT reimplement from scratch or revert the prior commits.",
-    ...lines
-  ].join(`
-`);
-}
-async function buildPrompt(enriched, branchName, worktreePath, client, workspaceId, projectId) {
-  const { card } = enriched;
-  const pastEpisodesSection = await renderPastEpisodesSection(client, card.title, card.description ?? "", workspaceId, projectId);
-  try {
-    const result = await client.generateCardPrompt({
-      cardId: card.id,
-      workspaceId,
-      projectId,
-      variant: "execute",
-      customConstraints: `You are working in a git worktree at \`${worktreePath}\` on branch \`${branchName}\`.
-Do NOT push to main. All your work stays on \`${branchName}\`.
-The daemon owns the run lifecycle: once your work is committed it ends the agent session, pushes the branch, and moves the card to Review for you. Do NOT call harmony_end_agent_session, do NOT start a new session, and do NOT move the card or change its column yourself. If the skill driving this work tells you to move the card or end the session as a final step, SKIP it — it is handled for you (those tools are disabled for this run). Finish the implementation, commit, and stop.`
-    });
-    log20.info(TAG19, `Generated prompt for #${card.short_id} — ${result.contextSummary.memoryCount} memories, ${result.tokenEstimate} tokens`);
-    return result.prompt + pastEpisodesSection;
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    log20.warn(TAG19, `Failed to generate prompt via API, using fallback: ${msg}`);
-    const commentsSection = await renderCommentsSection(client, card.id);
-    return buildFallbackPrompt(enriched, branchName, worktreePath) + commentsSection + pastEpisodesSection;
-  }
-}
-async function renderCommentsSection(client, cardId) {
-  try {
-    const { comments } = await client.request("GET", `/cards/${encodeURIComponent(cardId)}/comments?limit=200&order=desc`);
-    if (!Array.isArray(comments) || comments.length === 0)
-      return "";
-    const section = serializeCommentThread(comments, {
-      heading: "Comments",
-      maxComments: 40
-    });
-    return section ? `
-
-${section}` : "";
-  } catch (err) {
-    log20.warn(TAG19, "comment-thread fetch failed", {
-      event: "comment_fetch_failed",
-      error: err instanceof Error ? err.message : String(err)
-    });
-    return "";
-  }
-}
-async function renderPastEpisodesSection(client, title, description, workspaceId, projectId) {
-  if (!projectId)
-    return "";
-  try {
-    const query = `${title}
-${description}`.trim();
-    const { entities } = await client.harmonyRecall({
-      workspaceId,
-      projectId,
-      query,
-      type: ["solution", "error"],
-      memory_tier: "episode",
-      scope: "project",
-      topK: 3
-    });
-    if (entities.length === 0)
-      return "";
-    const bullets = entities.map((entity) => {
-      const e = entity;
-      const meta = e.metadata ?? {};
-      const outcomeTag = meta.outcome ? `[${meta.outcome}]` : "[?]";
-      const approach = meta.approach_summary ?? "";
-      const lines = [
-        `- ${outcomeTag} ${e.title ?? "(untitled episode)"}`,
-        `  Approach: ${approach}`
-      ];
-      if (meta.key_insight)
-        lines.push(`  Key insight: ${meta.key_insight}`);
-      if (meta.changed_files && meta.changed_files.length > 0) {
-        const shown = meta.changed_files.slice(0, 8);
-        const extra = meta.changed_files.length - shown.length;
-        const suffix = extra > 0 ? ` (+${extra} more)` : "";
-        lines.push(`  Changed files: ${shown.join(", ")}${suffix}`);
-      }
-      return lines.join(`
-`);
-    }).join(`
-`);
-    return `
-
-## Similar past tasks
-${bullets}`;
-  } catch (err) {
-    log20.warn(TAG19, "past-episodes recall failed", {
-      event: "episode_recall_failed",
-      error: err instanceof Error ? err.message : String(err)
-    });
-    return "";
-  }
-}
-function buildFallbackPrompt(enriched, branchName, worktreePath) {
-  const { card, column, labels, subtasks } = enriched;
-  const labelStr = labels.length > 0 ? labels.map((l) => l.name).join(", ") : "none";
-  const subtaskStr = subtasks.length > 0 ? subtasks.map((s) => `- [${s.completed ? "x" : " "}] ${s.title}`).join(`
-`) : "No subtasks defined.";
-  const description = card.description?.trim() || "No description provided.";
-  return `You are an AI agent working on a task from the Harmony project board.
-
-## Card: #${card.short_id} - ${card.title}
-**Labels**: ${labelStr}
-**Column**: ${column.name}
-**Priority**: ${card.priority}
-
-## Description
-${description}
-
-## Subtasks
-${subtaskStr}
-
-## Instructions
-1. Read the codebase and understand the context needed for this task
-2. Report progress via harmony_update_agent_progress at key milestones:
-   - After reading codebase and forming a plan (~20%)
-   - After each major implementation step (~30-60%)
-   - After completing each subtask (also toggle via harmony_toggle_subtask)
-   - Before committing (~65%)
-   Include a brief currentTask description.
-3. Implement the changes on branch \`${branchName}\`
-4. Commit your work with clear, descriptive commit messages
-5. When the work is committed, STOP. The daemon owns the run lifecycle: it ends the agent session, pushes the branch, and moves the card to Review for you. Do NOT call harmony_end_agent_session, do NOT start a new session, and do NOT move the card or change its column yourself — those tools are disabled for this run.
-
-You are working in a git worktree at \`${worktreePath}\` on branch \`${branchName}\`.
-Do NOT push to main. All your work stays on \`${branchName}\`.`;
-}
-var TAG19 = "prompt";
-var init_prompt = __esm(() => {
-  init_dist();
-});
-
 // src/stage-advance.ts
 import { gateConfigErrorReason, log as log21 } from "@gethmy/harness";
 function handoffText(stage) {
@@ -6388,10 +7008,7 @@ async function advanceStageOnGate(card, stage, stageIndex, def, evaluation, deps
   }
   const next = nextStageAfter(def, stageIndex);
   if (next.kind === "terminal") {
-    await persistStagePointer(deps.client, card, {
-      currentStage: null,
-      done: true
-    });
+    await persistStagePointer(deps.client, card, { currentStage: null });
     deps.sink?.recordPlaybookAdvanced({
       fromStageId: stage.id,
       fromStageName: stage.name,
@@ -6401,7 +7018,7 @@ async function advanceStageOnGate(card, stage, stageIndex, def, evaluation, deps
       reason: "Playbook complete — final stage gate passed."
     });
     deps.stateStore.recordOutcome(card.id, "success").catch(() => {});
-    log21.info(TAG20, `#${card.short_id} terminal stage "${stage.name}" passed — marked done`);
+    log21.info(TAG20, `#${card.short_id} terminal stage "${stage.name}" passed — playbook complete (done left to the column)`);
     return { kind: "completed_terminal" };
   }
   if (next.kind === "out_of_range") {
@@ -6508,6 +7125,7 @@ var init_stage_advance = __esm(() => {
 });
 
 // src/worker.ts
+import { execFileSync as execFileSync5 } from "node:child_process";
 import { rmSync } from "node:fs";
 import { dirname as dirname3 } from "node:path";
 import {
@@ -6521,12 +7139,15 @@ import {
   makeBranchName,
   normalizeGateSpec,
   pushBranch as pushBranch3,
-  reapGroup,
+  readWorktreeHead,
+  reapGroup as reapGroup2,
   SdkAgentRunner,
   signalGroup as signalGroup2,
-  spawnInGroup as spawnInGroup2,
+  sizeRun,
+  sizingEventSource,
+  spawnInGroup as spawnInGroup3,
   teardownWorktree as teardownWorktree2,
-  terminateGroup as terminateGroup2,
+  terminateGroup as terminateGroup3,
   WorktreeBaseError
 } from "@gethmy/harness";
 function sdkDraftLogLine(ev) {
@@ -6574,12 +7195,6 @@ function buildStagePreamble(stage) {
   return lines.filter(Boolean).join(`
 `);
 }
-function buildSteeringPrompt(messages) {
-  if (messages.length === 1)
-    return messages[0];
-  return messages.map((m, i) => `${i + 1}. ${m}`).join(`
-`);
-}
 function computeRunSpawnGating(stageAllowedTools) {
   const denylist = stageDisallowedTools();
   return {
@@ -6587,6 +7202,14 @@ function computeRunSpawnGating(stageAllowedTools) {
     ...denylist ? { disallowedTools: denylist } : {}
   };
 }
+function buildRunFailureSummary(apiKind, baseError, msg) {
+  if (apiKind !== null)
+    return describeApiError(apiKind);
+  if (baseError) {
+    return `${msg.slice(0, 300)} — requeued without counting an attempt`;
+  }
+  return `Run failed: ${msg.slice(0, 300)}`;
+}
 
 class Worker {
   config;
@@ -6603,6 +7226,7 @@ class Worker {
   cardId = null;
   branchName = null;
   worktreePath = null;
+  runBaselineSha = null;
   startedAt = null;
   process = null;
   timeoutTimer = null;
@@ -6615,14 +7239,23 @@ class Worker {
   aborted = false;
   timedOut = false;
   verificationFailed = false;
+  lastStopReason = null;
+  lastActionSummary = null;
   held = false;
   sessionConflict = false;
   activeRunSpawnOpts = null;
   completionStarted = false;
   sessionId = null;
+  sizing = null;
+  modelChoice = null;
   runId = null;
   cliSessionId = null;
   lastDrainedSeq = 0;
+  grantedTurns = null;
+  resumeMessage = null;
+  get effectiveMaxTurns() {
+    return this.grantedTurns ?? this.config.claude.maxTurns;
+  }
   runCostCents = 0;
   runTurns = 0;
   lastRunText = "";
@@ -6698,6 +7331,8 @@ class Worker {
     this.aborted = false;
     this.timedOut = false;
     this.verificationFailed = false;
+    this.lastStopReason = null;
+    this.lastActionSummary = null;
     this.held = false;
     this.sessionConflict = false;
     this.completionStarted = false;
@@ -6707,92 +7342,138 @@ class Worker {
     this.cliSessionId = null;
     this.lastDrainedSeq = 0;
     this.activeRunSpawnOpts = null;
+    this.grantedTurns = null;
+    this.resumeMessage = null;
+    this.sizing = null;
+    this.modelChoice = null;
     this.cardId = card.id;
     this.startedAt = Date.now();
     this.runId = newRunId();
+    const resuming = this.stateStore.getResumableRunForCard(card.id);
+    if (resuming) {
+      this.runId = resuming.runId;
+      this.worktreePath = resuming.worktreePath;
+      this.branchName = resuming.branchName;
+      this.cliSessionId = resuming.cliSessionId ?? null;
+      this.sessionId = resuming.sessionId;
+      this.grantedTurns = resuming.grantedTurns ?? null;
+      this.resumeMessage = resuming.resumeMessage ?? null;
+      try {
+        await this.stateStore.updateRun(resuming.runId, {
+          grantedTurns: null,
+          resumeMessage: null
+        });
+      } catch (err) {
+        log22.warn(this.tag, `Failed to clear the consumed grant: ${err}`);
+      }
+    }
     try {
       this.state = "preparing";
-      this.branchName = makeBranchName(card.short_id, card.title, this.config.worktree.failedBranchPrefix);
-      log22.info(this.tag, `Preparing #${card.short_id} "${card.title}"`);
+      if (!resuming) {
+        this.branchName = makeBranchName(card.short_id, card.title, this.config.worktree.failedBranchPrefix);
+      }
+      log22.info(this.tag, resuming ? `Resuming #${card.short_id} "${card.title}" with ${this.grantedTurns ?? "the default"} more turns` : `Preparing #${card.short_id} "${card.title}"`);
       const attemptCount = await this.stateStore.incrementAttempt(card.id);
       const isRework = attemptCount > 1;
+      const recordedBranch = extractBranchRef(card.description);
+      const continuesPushedWork = isRework || recordsPushedWorkOn(card.description, this.branchName);
+      if (continuesPushedWork && !isRework) {
+        log22.info(this.tag, `Card records completed work on ${this.branchName} — continuing that branch instead of rebuilding from ${this.config.worktree.baseBranch}`);
+      } else if (recordedBranch && recordedBranch !== this.branchName) {
+        log22.warn(this.tag, `Card records branch ${recordedBranch} but this run targets ${this.branchName} — starting fresh; the recorded branch is left untouched`);
+      }
       this.startHeartbeat();
-      await this.stateStore.insertRun({
-        runId: this.runId,
-        cardId: card.id,
-        cardShortId: card.short_id,
-        pipeline: "implement",
-        workerId: this.id,
-        sessionId: null,
-        worktreePath: null,
-        branchName: this.branchName,
-        daemonPid: process.pid,
-        phase: "preparing",
-        startedAt: this.startedAt,
-        lastHeartbeatAt: this.startedAt,
-        endedAt: null,
-        status: "active",
-        costCents: 0,
-        numTurns: 0
-      });
+      this.sizing = await this.sizeThisRun(card);
       const implementModel = this.selectImplementModel(card);
-      let session;
-      try {
-        const started = await this.client.startAgentSession(card.id, {
-          agentIdentifier: agentIdentifier(this.id),
-          agentName: AGENT_NAME,
-          agentId: this.identity.agentId,
-          status: "working",
-          currentTask: "Setting up worktree",
-          progressPercent: 5,
-          modelName: implementModel,
-          driver: "daemon"
+      let stageCtx = { kind: "generic" };
+      if (!resuming) {
+        await this.stateStore.insertRun({
+          runId: this.runId,
+          cardId: card.id,
+          cardShortId: card.short_id,
+          pipeline: "implement",
+          workerId: this.id,
+          sessionId: null,
+          worktreePath: null,
+          branchName: this.branchName,
+          daemonPid: process.pid,
+          phase: "preparing",
+          startedAt: this.startedAt,
+          lastHeartbeatAt: this.startedAt,
+          endedAt: null,
+          status: "active",
+          costCents: 0,
+          numTurns: 0
         });
-        session = started.session;
-      } catch (err) {
-        if (isSessionConflict(err)) {
-          this.sessionConflict = true;
-          log22.info(this.tag, `Skipping #${card.short_id}: ${err instanceof Error ? err.message : String(err)}`);
-          await this.stateStore.decrementAttempt(card.id);
-          return;
+        let session;
+        try {
+          const started = await this.client.startAgentSession(card.id, {
+            agentIdentifier: agentIdentifier(this.id),
+            agentName: AGENT_NAME,
+            agentId: this.identity.agentId,
+            status: "working",
+            currentTask: "Setting up worktree",
+            progressPercent: 5,
+            modelName: implementModel,
+            driver: "daemon",
+            awaitingDecisionUntil: null
+          });
+          session = started.session;
+        } catch (err) {
+          if (isSessionConflict(err)) {
+            this.sessionConflict = true;
+            log22.info(this.tag, `Skipping #${card.short_id}: ${err instanceof Error ? err.message : String(err)}`);
+            await this.stateStore.decrementAttempt(card.id);
+            return;
+          }
+          throw err;
         }
-        throw err;
-      }
-      const sid = session && typeof session === "object" && "id" in session ? session.id : null;
-      if (!sid) {
-        log22.warn(TAG21, "startAgentSession returned no session id");
+        const sid = session && typeof session === "object" && "id" in session ? session.id : null;
+        if (!sid) {
+          log22.warn(TAG21, "startAgentSession returned no session id");
+        }
+        this.sessionId = sid;
       }
-      this.sessionId = sid;
       if (this.sessionId) {
         this.cliRunner = new CliAgentRunner(this.client, card.id, this.sessionId);
-        this.cliRunner.recordRunStarted({
-          runner: this.config.runner,
-          model: implementModel
-        });
+        if (!resuming) {
+          this.cliRunner.recordRunStarted({
+            runner: this.config.runner,
+            model: implementModel
+          });
+          this.recordRunSized();
+        }
       }
       await this.recordPhase("preparing");
-      const moved = await moveCardAndAddLabel(this.client, card, IN_PROGRESS_COLUMN, "agent");
-      if (!moved) {
-        log22.warn(this.tag, `Card #${card.short_id} was NOT moved to "In Progress" — check API logs`);
+      if (!resuming) {
+        const moved = await moveCardAndAddLabel(this.client, card, IN_PROGRESS_COLUMN, "agent");
+        if (!moved) {
+          log22.warn(this.tag, `Card #${card.short_id} was NOT moved to "In Progress" — check API logs`);
+        }
       }
       if (this.aborted)
         return;
-      card = await this.autoBindPlaybookAtPickup(card, labels);
+      if (!resuming) {
+        card = await this.autoBindPlaybookAtPickup(card, labels);
+      }
       if (this.aborted)
         return;
-      const stageCtx = await this.resolveStageContext(card);
+      stageCtx = await this.resolveStageContext(card);
       if (stageCtx.kind === "hold") {
         this.held = true;
         await this.holdStageCard(card, stageCtx.reason, stageCtx.wait);
         return;
       }
-      this.worktreePath = createWorktree(this.config.worktree.basePath, this.config.worktree.baseBranch, this.branchName, {
-        continueExisting: stageCtx.kind === "run" || stageCtx.kind === "motor" || isRework
-      });
+      if (!resuming) {
+        this.worktreePath = createWorktree(this.config.worktree.basePath, this.config.worktree.baseBranch, this.branchName, {
+          continueExisting: stageCtx.kind === "run" || stageCtx.kind === "motor" || continuesPushedWork
+        });
+        this.runBaselineSha = readWorktreeHead(this.worktreePath);
+      }
       if (this.aborted)
         return;
-      if (stageCtx.kind === "motor") {
-        await this.runMotorStageCtx(card, stageCtx);
+      if (!resuming && stageCtx.kind === "motor") {
+        await this.runMotorStageCtx(card, stageCtx, subtasks);
         return;
       }
       const enriched = {
@@ -6802,12 +7483,12 @@ class Worker {
         subtasks,
         mode: "implement"
       };
-      if (stageCtx.kind !== "run" && shouldRunContract(this.config.contractFirst)) {
+      if (!resuming && stageCtx.kind !== "run" && shouldRunContract(this.config.contractFirst)) {
         await this.runContractPhase(enriched);
         if (this.aborted)
           return;
       }
-      if (shouldPlan(enriched, this.config.planning)) {
+      if (!resuming && shouldPlan(enriched, this.config.planning)) {
         this.state = "planning";
         await this.recordPhase("planning");
         const parked = await this.runPlanningPhase(enriched);
@@ -6829,33 +7510,40 @@ class Worker {
         prompt = [buildStagePreamble(stageCtx.stage), inherited, basePrompt].filter(Boolean).join(`
 
 `);
-        this.cliRunner?.recordStageEntered({
-          stageId: stageCtx.stage.id,
-          stageName: stageCtx.stage.name,
-          owner: stageCtx.stage.owner
-        });
-        if (isLoop && loop) {
-          const priorIterations = this.stateStore.getLoopIterations(card.id, stageCtx.stage.id);
-          this.cliRunner?.recordLoopIterationStarted({
+        if (!resuming) {
+          this.cliRunner?.recordStageEntered({
             stageId: stageCtx.stage.id,
             stageName: stageCtx.stage.name,
-            iteration: priorIterations + 1,
-            maxIterations: Math.max(1, Math.floor(loop.max_iterations) || 1),
-            mode: loop.mode
+            owner: stageCtx.stage.owner
           });
+          if (isLoop && loop) {
+            const priorIterations = this.stateStore.getLoopIterations(card.id, stageCtx.stage.id);
+            this.cliRunner?.recordLoopIterationStarted({
+              stageId: stageCtx.stage.id,
+              stageName: stageCtx.stage.name,
+              iteration: priorIterations + 1,
+              maxIterations: Math.max(1, Math.floor(loop.max_iterations) || 1),
+              mode: loop.mode
+            });
+          }
         }
-      } else if (isRework) {
+      } else if (continuesPushedWork) {
         const digest = renderPreviousAttemptsSection(this.stateStore.getRecentFailures(card.id, 3));
         if (digest)
           prompt = `${digest}
 
 ${basePrompt}`;
+      }
+      if (resuming && this.resumeMessage) {
+        prompt = `${buildSteeringPrompt([this.resumeMessage])}
+
+${prompt}`;
       }
       await this.client.updateAgentProgress(card.id, {
         agentIdentifier: agentIdentifier(this.id),
         agentName: AGENT_NAME,
         status: "working",
-        currentTask: stageCtx.kind === "run" ? `Running stage "${stageCtx.stage.name}"` : "Running Claude CLI",
+        currentTask: resuming ? "Resuming Claude CLI" : stageCtx.kind === "run" ? `Running stage "${stageCtx.stage.name}"` : "Running Claude CLI",
         progressPercent: 10
       });
       this.timeoutTimer = setTimeout(() => {
@@ -6866,6 +7554,8 @@ ${basePrompt}`;
       this.activeRunSpawnOpts = computeRunSpawnGating(stageCtx.kind === "run" ? stageCtx.allowedTools : null);
       await this.spawnClaude(prompt, card, subtasks, {
         model: implementModel,
+        maxTurns: this.grantedTurns ?? undefined,
+        resumeSessionId: this.cliSessionId ?? undefined,
         ...this.activeRunSpawnOpts ?? {}
       });
       if (this.aborted)
@@ -6899,7 +7589,11 @@ ${basePrompt}`;
         stageGateEvaluation = await this.collectStageGateEvidence(card, stageRun.stage, worktreePath, subtasks);
         return stageEndDisposition(stageGateEvaluation, stageRun.stage, stageRun.index, stageRun.def);
       } : undefined;
-      const completed = await runCompletion(this.client, card, this.branchName, this.worktreePath, this.config, this.id, this.lastSessionStats, this.workspaceId, this.sessionId, this.stateStore, this.onCardCompleted, onBeforeWorktreeCleanup);
+      const completed = await runCompletion(this.client, card, this.branchName, this.worktreePath, this.config, this.id, this.lastSessionStats, this.workspaceId, this.sessionId, this.stateStore, this.onCardCompleted, onBeforeWorktreeCleanup, this.runBaselineSha, this.effectiveMaxTurns);
+      if (completed === "park") {
+        await this.parkForDecision(card, "max_turns");
+        return;
+      }
       this.worktreePath = null;
       this.verificationFailed = !completed;
       if (completed && stageRun) {
@@ -6920,6 +7614,14 @@ ${basePrompt}`;
         }
       }
     } catch (err) {
+      if (err instanceof BudgetPauseError) {
+        await this.parkForDecision(card, err.trigger);
+        return;
+      }
+      if (resuming && isSessionConflict(err)) {
+        await this.holdParkOnSessionConflict(card, err);
+        return;
+      }
       this.state = "error";
       const msg = err instanceof Error ? err.message : String(err);
       log22.error(this.tag, `Error on #${card.short_id}: ${msg}`);
@@ -6950,7 +7652,7 @@ ${basePrompt}`;
         this.worktreePath = null;
       }
       const failureReason = apiError ? errClass.kind : "other";
-      const failureSummary = apiError ? describeApiError(errClass.kind) : baseError ? "Could not fetch current base branch — requeued without counting an attempt" : `Run failed: ${msg.slice(0, 300)}`;
+      const failureSummary = buildRunFailureSummary(errClass.kind, baseError, msg);
       try {
         await runTransition(this.client, card, {
           move: { columnName: this.config.pickupColumns[0] ?? "To Do" },
@@ -6978,8 +7680,8 @@ ${basePrompt}`;
         }
       }
     } finally {
-      const succeeded = this.runId && !this.held && !this.sessionConflict && this.state !== "error" && !this.aborted && !this.verificationFailed;
-      if (this.held) {} else if (this.sessionConflict) {
+      const succeeded = this.runId && !this.held && !this.sessionConflict && this.state !== "error" && this.state !== "parked" && !this.aborted && !this.verificationFailed;
+      if (this.state === "parked") {} else if (this.held) {} else if (this.sessionConflict) {
         if (this.runId) {
           try {
             await this.stateStore.endRun(this.runId, "paused", {
@@ -7067,6 +7769,11 @@ ${basePrompt}`;
             status: "stopped",
             stopReason: "user_requested"
           });
+        } else if (this.state === "parked") {
+          this.cliRunner.recordFinished({
+            status: "stopped",
+            stopReason: "user_requested"
+          });
         } else if (succeeded) {
           this.cliRunner.recordFinished({ status: "completed" });
         } else if (this.timedOut) {
@@ -7098,8 +7805,6 @@ ${basePrompt}`;
       const { playbooks } = await this.client.request("GET", `/playbooks?workspaceId=${encodeURIComponent(this.workspaceId)}`);
       const subject = {
         labels: labels.map((label) => label.name.toLowerCase()),
-        ...card.intent != null ? { intent: card.intent } : {},
-        ...card.complexity_score != null ? { complexity_score: card.complexity_score } : {},
         ...card.priority != null ? { priority: card.priority } : {}
       };
       const { pick, reason } = selectAutoPlaybook(subject, playbooks ?? []);
@@ -7211,28 +7916,115 @@ ${basePrompt}`;
       await this.client.addComment(card.id, reason, { commentType: "blocker" });
     } catch {}
     try {
-      await runTransition(this.client, card, {
-        removeLabels: ["agent"],
-        endSession: {
-          status: wait ? "blocked" : "paused",
-          blockers: wait ? [reason] : undefined,
-          failureReason: "other",
-          failureSummary: reason.slice(0, 300)
-        }
+      await runTransition(this.client, card, {
+        removeLabels: ["agent"],
+        endSession: {
+          status: wait ? "blocked" : "paused",
+          blockers: wait ? [reason] : undefined,
+          failureReason: "other",
+          failureSummary: reason.slice(0, 300)
+        }
+      });
+    } catch (tErr) {
+      log22.warn(this.tag, `hold transition failed on #${card.short_id}: ${tErr instanceof TransitionError ? tErr.detail : tErr}`);
+    }
+    if (this.runId) {
+      try {
+        await this.stateStore.endRun(this.runId, "paused", {
+          errorMessage: "stage_hold",
+          ...this.runLedger()
+        });
+      } catch {}
+    }
+  }
+  async holdParkOnSessionConflict(card, err) {
+    this.state = "parked";
+    this.progressTracker?.stop();
+    this.progressTracker = null;
+    const holderMessage = err instanceof Error ? err.message : String(err);
+    const waitHours = this.config.budget.pause.waitHours;
+    const until = computeDecisionDeadline(waitHours);
+    log22.warn(this.tag, `#${card.short_id} stays parked — the resume could not reclaim its session: ${holderMessage}`);
+    try {
+      await this.client.addComment(card.id, formatResumeConflictComment({
+        holderMessage,
+        branchName: this.branchName,
+        cliSessionId: this.cliSessionId,
+        waitHours
+      }), {
+        commentType: "blocker",
+        agentSessionId: this.sessionId ?? undefined
+      });
+    } catch (commentErr) {
+      log22.warn(this.tag, `Failed to post the resume-conflict note for #${card.short_id}: ${commentErr}`);
+    }
+    if (this.runId) {
+      const run = this.stateStore.getRun(this.runId);
+      try {
+        await this.stateStore.parkRun(this.runId, {
+          pauseTrigger: run?.pauseTrigger ?? "timeout",
+          blockerCommentId: run?.blockerCommentId ?? null,
+          awaitingDecisionUntil: until
+        });
+      } catch (storeErr) {
+        log22.error(this.tag, `#${card.short_id} could not be re-parked after a resume conflict — the daemon has no hold on it: ${storeErr}`);
+      }
+    }
+  }
+  async parkForDecision(card, trigger) {
+    this.state = "parked";
+    const stats = this.lastSessionStats;
+    this.progressTracker?.stop();
+    this.progressTracker = null;
+    const waitHours = this.config.budget.pause.waitHours;
+    const until = computeDecisionDeadline(waitHours);
+    log22.warn(this.tag, `#${card.short_id} parked (${trigger}) — awaiting a human decision for ${waitHours}h`);
+    const body = formatBudgetComment({
+      trigger,
+      numTurns: stats?.cost?.numTurns ?? 0,
+      maxTurns: this.effectiveMaxTurns,
+      toolCalls: stats?.toolCalls ?? 0,
+      durationMs: stats?.cost?.durationMs ?? 0,
+      costUsd: stats?.cost?.totalCostUsd ?? 0,
+      lastAction: this.lastActionSummary,
+      branchName: this.branchName,
+      waitHours
+    });
+    let commentId = null;
+    try {
+      const res = await this.client.addComment(card.id, body, {
+        commentType: "blocker"
+      });
+      commentId = res?.comment?.id ?? null;
+    } catch (err) {
+      log22.warn(this.tag, `Failed to post the budget-pause comment: ${err}`);
+    }
+    try {
+      await this.client.updateAgentProgress(card.id, {
+        agentIdentifier: agentIdentifier(this.id),
+        agentName: AGENT_NAME,
+        status: "blocked",
+        currentTask: "Waiting for your decision on the turn budget",
+        awaitingDecisionUntil: new Date(until).toISOString()
       });
-    } catch (tErr) {
-      log22.warn(this.tag, `hold transition failed on #${card.short_id}: ${tErr instanceof TransitionError ? tErr.detail : tErr}`);
+    } catch (err) {
+      log22.warn(this.tag, `Failed to mark the session blocked: ${err}`);
     }
     if (this.runId) {
       try {
-        await this.stateStore.endRun(this.runId, "paused", {
-          errorMessage: "stage_hold",
-          ...this.runLedger()
+        await this.stateStore.parkRun(this.runId, {
+          pauseTrigger: trigger,
+          blockerCommentId: commentId,
+          awaitingDecisionUntil: until,
+          costCents: Math.round((stats?.cost?.totalCostUsd ?? 0) * 100),
+          numTurns: stats?.cost?.numTurns ?? 0
         });
-      } catch {}
+      } catch (err) {
+        log22.error(this.tag, `#${card.short_id} parkRun failed after the blocker comment + blocked session were already written — the daemon has no local record of this park: ${err}`);
+      }
     }
   }
-  async runMotorStageCtx(card, ctx) {
+  async runMotorStageCtx(card, ctx, subtasks = []) {
     const stageId = ctx.stage.id;
     const worktreePath = this.worktreePath;
     const sessionId = this.sessionId;
@@ -7267,7 +8059,31 @@ ${basePrompt}`;
       this.timedOut = true;
       this.cancel("timeout");
     }, this.config.maxTimeout);
+    const motorTracker = new ProgressTracker(this.client, card.id, this.id, subtasks, "exploring");
+    if (this.cliRunner)
+      motorTracker.setRunEventSink(this.cliRunner);
+    let motorTrackerLive = false;
+    let motorRunSettled = false;
+    const onMotorLine = (line) => {
+      if (line.type !== "agent_event") {
+        log22.info(this.tag, `motor: ${line.type}`);
+        return;
+      }
+      if (motorRunSettled)
+        return;
+      log22.debug(this.tag, `motor: agent_event ${line.event.kind}`);
+      if (line.event.kind === "tool_started" && STAGE_DAEMON_OWNED_TOOLS.includes(line.event.payload.toolName)) {
+        return;
+      }
+      if (!motorTrackerLive) {
+        motorTrackerLive = true;
+        this.progressTracker = motorTracker;
+      }
+      motorTracker.ingest(line.event);
+    };
     const heartbeat = setInterval(() => {
+      if (motorTrackerLive && !motorTracker.isStopped)
+        return;
       this.client.updateAgentProgress(card.id, {
         agentIdentifier: agentIdentifier(this.id),
         agentName: AGENT_NAME,
@@ -7293,7 +8109,7 @@ ${basePrompt}`;
           apiUrl: this.client.getApiUrl(),
           apiKey: this.client.getApiKey()
         },
-        onLine: (line) => log22.info(this.tag, `motor: ${line.type}`),
+        onLine: onMotorLine,
         signal: motorAbort.signal
       });
     } finally {
@@ -7302,6 +8118,17 @@ ${basePrompt}`;
         this.timeoutTimer = null;
       }
       clearInterval(heartbeat);
+      motorRunSettled = true;
+      if (motorTrackerLive) {
+        this.lastSessionStats = motorTracker.stats;
+        const motorCost = this.lastSessionStats.cost;
+        if (motorCost) {
+          this.runCostCents += Math.round(motorCost.totalCostUsd * 100);
+          this.runTurns += motorCost.numTurns;
+        }
+      }
+      motorTracker.stop();
+      this.progressTracker = null;
       this.motorAbort = null;
       if (metricsPath) {
         try {
@@ -7494,12 +8321,59 @@ ${basePrompt}`;
   }
   selectImplementModel(card) {
     const attempts = this.stateStore.getCard(card.id)?.attempts ?? 1;
-    const { model, escalated, source } = chooseImplementModel(this.config.claude, card, attempts);
+    const choice = chooseImplementModel(this.config.claude, card, attempts, this.sizing ?? undefined);
+    this.modelChoice = choice;
+    const { model, escalated, source } = choice;
     if (source !== "policy" || escalated) {
-      log22.info(this.tag, `Implement model "${model}" (source=${source}, escalated=${escalated}, attempts=${attempts}, priority=${card.priority ?? "none"}, tier=${card.model_tier ?? "none"})`);
+      log22.info(this.tag, `Implement model "${model}" (source=${source}, escalated=${escalated}, attempts=${attempts}, priority=${card.priority ?? "none"}, tier=${this.sizing?.tier ?? "none"})`);
     }
     return model;
   }
+  async sizeThisRun(card) {
+    const model = this.config.claude.sizingModel;
+    if (!model)
+      return null;
+    let repoRoot;
+    try {
+      repoRoot = execFileSync5("git", ["rev-parse", "--show-toplevel"], {
+        encoding: "utf-8"
+      }).trim();
+    } catch (err) {
+      log22.warn(this.tag, `Sizing #${card.short_id}: could not resolve the repo root (${err instanceof Error ? err.message : String(err)}) — using the policy fallback`);
+      return null;
+    }
+    const sized = await sizeRun({
+      cwd: repoRoot,
+      cardId: card.id,
+      workspaceId: this.workspaceId,
+      runId: this.runId ?? card.id,
+      title: card.title,
+      description: card.description,
+      model
+    });
+    log22.info(this.tag, sized ? `Sized #${card.short_id}: complexity ${sized.complexity}/10 -> ${sized.tier}` : `Sizing #${card.short_id} produced no verdict — using the policy fallback`);
+    return sized;
+  }
+  recordRunSized() {
+    if (!this.modelChoice)
+      return;
+    const { model, escalated, source } = this.modelChoice;
+    this.cliRunner?.record({
+      kind: "run_sized",
+      source: "system",
+      payload: {
+        source: sizingEventSource(source),
+        model,
+        escalated,
+        ...this.sizing ? {
+          tier: this.sizing.tier,
+          complexity: this.sizing.complexity,
+          ...this.sizing.reasoning ? { reasoning: this.sizing.reasoning } : {},
+          ...this.sizing.filesInspected ? { filesInspected: this.sizing.filesInspected } : {}
+        } : {}
+      }
+    });
+  }
   async recordOutcome(cardId, outcome) {
     try {
       const cost = this.lastSessionStats?.cost;
@@ -7512,15 +8386,41 @@ ${basePrompt}`;
         const max = this.config.budget.maxAttemptsPerCard;
         const attempts = this.stateStore.getCard(cardId)?.attempts ?? 0;
         if (attempts >= max) {
+          let giveUpCommentId = null;
           try {
-            const body = buildGaveUpComment(max, this.stateStore.getRecentFailures(cardId, 3));
-            await this.client.addComment(cardId, body, {
+            const body = buildGaveUpComment(max, this.stateStore.getRecentFailures(cardId, 3), this.config.budget.pause.enabled);
+            const res = await this.client.addComment(cardId, body, {
               commentType: "blocker"
             });
+            giveUpCommentId = res?.comment?.id ?? null;
             log22.warn(this.tag, `gave up on ${cardId} after ${attempts} attempts`);
           } catch (err) {
             log22.warn(this.tag, `failed to post give-up comment for ${cardId}: ${err instanceof Error ? err.message : err}`);
           }
+          if (this.config.budget.pause.enabled) {
+            const waitHours = this.config.budget.pause.waitHours;
+            const until = computeDecisionDeadline(waitHours);
+            try {
+              await this.client.updateAgentProgress(cardId, {
+                agentIdentifier: agentIdentifier(this.id),
+                agentName: AGENT_NAME,
+                status: "blocked",
+                currentTask: "Waiting for your decision on the attempt budget",
+                awaitingDecisionUntil: new Date(until).toISOString()
+              });
+            } catch (err) {
+              log22.warn(this.tag, `Failed to mark the attempt cap pending for ${cardId}: ${err}`);
+            }
+            try {
+              await this.stateStore.markAwaitingDecision(cardId, {
+                until,
+                blockerCommentId: giveUpCommentId,
+                agentIdentifier: agentIdentifier(this.id)
+              });
+            } catch (err) {
+              log22.warn(this.tag, `Failed to record the attempt-cap decision locally for ${cardId}: ${err}`);
+            }
+          }
         }
       }
     } catch (err) {
@@ -7580,7 +8480,7 @@ ${basePrompt}`;
     if (this.sdkRunner) {
       await this.sdkRunner.stop(this.timedOut ? "timeout" : "user_requested");
     } else if (this.process && !this.process.killed) {
-      await terminateGroup2(this.process, {
+      await terminateGroup3(this.process, {
         sigintTimeoutMs: CANCEL_SIGINT_TIMEOUT2,
         sigtermTimeoutMs: CANCEL_SIGTERM_TIMEOUT2
       });
@@ -7617,7 +8517,7 @@ ${basePrompt}`;
       if (this.sdkRunner) {
         this.sdkRunner.stop("timeout").catch(() => {});
       } else if (this.process && !this.process.killed) {
-        terminateGroup2(this.process, {
+        terminateGroup3(this.process, {
           sigintTimeoutMs: 1e4,
           sigtermTimeoutMs: 5000
         }).catch(() => {});
@@ -7735,7 +8635,7 @@ ${basePrompt}`;
       if (this.sdkRunner) {
         this.sdkRunner.stop("timeout").catch(() => {});
       } else if (this.process && !this.process.killed) {
-        terminateGroup2(this.process, {
+        terminateGroup3(this.process, {
           sigintTimeoutMs: 1e4,
           sigtermTimeoutMs: 5000
         }).catch(() => {});
@@ -7862,7 +8762,7 @@ ${basePrompt}`;
 
 `);
       }
-      this.process = spawnInGroup2("claude", args, {
+      this.process = spawnInGroup3("claude", args, {
         cwd: this.worktreePath,
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -7892,6 +8792,9 @@ ${basePrompt}`;
 [parse_error] ${msg}
 `);
       });
+      parser.on("result", (stop) => {
+        this.lastStopReason = stop;
+      });
       let stderr = "";
       this.process.stderr?.on("data", (data) => {
         stderr += data.toString();
@@ -7905,6 +8808,7 @@ ${basePrompt}`;
         this.process = null;
         this.captureCliSessionId(parser.sessionId);
         this.lastSessionStats = this.progressTracker?.stats;
+        this.lastActionSummary = this.progressTracker?.lastActionSummary ?? null;
         const spawnCost = this.lastSessionStats?.cost;
         if (spawnCost) {
           this.runCostCents += Math.round(spawnCost.totalCostUsd * 100);
@@ -7919,11 +8823,22 @@ ${basePrompt}`;
 `);
           runLog.stream.end();
         }
-        reapGroup(leaderPid);
-        if (this.aborted) {
+        reapGroup2(leaderPid);
+        const trigger = this.config.budget.pause.enabled ? classifyRunExit({
+          exitCode: code ?? 1,
+          stopReason: this.lastStopReason,
+          numTurns: this.lastSessionStats?.cost?.numTurns ?? 0,
+          maxTurns,
+          timedOut: this.timedOut
+        }) : null;
+        if (this.timedOut && trigger) {
+          reject(new BudgetPauseError(trigger));
+        } else if (this.aborted) {
           resolve2();
         } else if (code === 0) {
           resolve2();
+        } else if (trigger) {
+          reject(new BudgetPauseError(trigger));
         } else {
           const err = new Error(`claude exited with code ${code}${stderr ? `: ${stderr.slice(0, 500)}` : ""}`);
           err.stderr = stderr;
@@ -7998,6 +8913,7 @@ ${basePrompt}`;
     } finally {
       this.captureCliSessionId(runner.sessionId);
       this.lastSessionStats = this.progressTracker?.stats;
+      this.lastActionSummary = this.progressTracker?.lastActionSummary ?? null;
       const spawnCost = this.lastSessionStats?.cost;
       if (spawnCost) {
         this.runCostCents += Math.round(spawnCost.totalCostUsd * 100);
@@ -8015,9 +8931,30 @@ ${basePrompt}`;
       this.process = null;
       this.sdkRunner = null;
     }
+    if (this.timedOut && failure && this.config.budget.pause.enabled) {
+      const timeoutTrigger = classifyRunExit({
+        exitCode: 1,
+        stopReason: null,
+        numTurns: this.lastSessionStats?.cost?.numTurns ?? 0,
+        maxTurns,
+        timedOut: true
+      });
+      if (timeoutTrigger)
+        throw new BudgetPauseError(timeoutTrigger);
+    }
     if (this.aborted)
       return;
     if (failure) {
+      const trigger = classifyRunExit({
+        exitCode: 1,
+        stopReason: null,
+        numTurns: this.lastSessionStats?.cost?.numTurns ?? 0,
+        maxTurns,
+        timedOut: this.timedOut
+      });
+      if (trigger && this.config.budget.pause.enabled) {
+        throw new BudgetPauseError(trigger);
+      }
       const err = new Error(failure);
       err.stderr = runner.capturedStderrText;
       err.errorKind = failureKind;
@@ -8040,7 +8977,7 @@ ${basePrompt}`;
       clearTimeout(this.timeoutTimer);
       this.timeoutTimer = null;
     }
-    if (this.worktreePath && (this.state === "error" || this.timedOut || this.aborted)) {
+    if (this.worktreePath && this.state !== "parked" && (this.state === "error" || this.timedOut || this.aborted)) {
       try {
         await teardownWorktree2(this.client, this.cardId, this.worktreePath, this.branchName ?? undefined);
       } catch {
@@ -8050,6 +8987,7 @@ ${basePrompt}`;
     this.process = null;
     this.cardId = null;
     this.branchName = null;
+    this.runBaselineSha = null;
     this.worktreePath = null;
     this.startedAt = null;
     this.runId = null;
@@ -8062,6 +9000,7 @@ var TAG21 = "worker", CANCEL_SIGINT_TIMEOUT2 = 30000, CANCEL_SIGTERM_TIMEOUT2 =
 var init_worker = __esm(() => {
   init_dist();
   init_board_helpers();
+  init_budget_pause();
   init_cli_agent_runner();
   init_completion();
   init_contract_phase();
@@ -8086,8 +9025,31 @@ import {
   describeApiError as describeApiError2,
   log as log23
 } from "@gethmy/harness";
+async function routeBudgetDecision(d, run, actions, cardId) {
+  if (!run) {
+    if (!cardId)
+      return;
+    if (d.decision === "continue")
+      await actions.grantAttempt(cardId);
+    else
+      await actions.stopAttemptCap(cardId);
+    return;
+  }
+  if (d.decision === "stop") {
+    await actions.stopRun(run);
+    return;
+  }
+  await actions.continueRun(run, {
+    extraTurns: d.extraTurns,
+    message: d.message
+  });
+}
+function hasParkedRun(store, cardId) {
+  return store.getParkedRunForCard(cardId) !== null;
+}
 
 class Pool {
+  config;
   client;
   identity;
   projectId;
@@ -8103,6 +9065,7 @@ class Pool {
   authPaused = false;
   onCardCompleted = null;
   constructor(config, client, identity, workspaceId, projectId, stateStore) {
+    this.config = config;
     this.client = client;
     this.identity = identity;
     this.projectId = projectId;
@@ -8249,7 +9212,7 @@ class Pool {
     await this.stateStore.resetAttempts(cardId);
   }
   isCardActive(cardId) {
-    return this.implWorkers.some((w) => w.cardId === cardId && w.isActive) || this.reviewWorkers.some((w) => w.cardId === cardId && w.isActive);
+    return hasParkedRun(this.stateStore, cardId) || this.implWorkers.some((w) => w.cardId === cardId && w.isActive) || this.reviewWorkers.some((w) => w.cardId === cardId && w.isActive);
   }
   isCardKnown(cardId) {
     return this.implQueue.has(cardId) || this.reviewQueue.has(cardId) || this.isCardActive(cardId);
@@ -8270,6 +9233,10 @@ class Pool {
     return ids;
   }
   async handleAgentCommand(cardId, command) {
+    if (command === "continue") {
+      await this.drainBudgetDecisions(cardId);
+      return;
+    }
     const worker = this.implWorkers.find((w) => w.cardId === cardId && w.isActive) ?? this.reviewWorkers.find((w) => w.cardId === cardId && w.isActive);
     if (!worker) {
       log23.debug(TAG22, `No active worker for card ${cardId}, ignoring ${command}`);
@@ -8333,6 +9300,268 @@ class Pool {
     this.sleepGuard.stop();
     log23.info(TAG22, "Pool shutdown complete");
   }
+  async drainBudgetDecisions(cardId) {
+    const targets = cardId ? [cardId] : [
+      ...new Set([
+        ...this.stateStore.getParkedRuns().map((r) => r.cardId),
+        ...this.stateStore.getResumableRuns().map((r) => r.cardId),
+        ...this.stateStore.listCards().filter((c) => c.attempts >= this.config.budget.maxAttemptsPerCard).map((c) => c.cardId)
+      ])
+    ];
+    for (const id of targets) {
+      await this.drainBudgetDecisionsForCard(id);
+    }
+  }
+  draining = new Set;
+  async drainBudgetDecisionsForCard(cardId) {
+    if (this.draining.has(cardId))
+      return;
+    this.draining.add(cardId);
+    try {
+      const granted = this.stateStore.getResumableRunForCard(cardId);
+      if (granted) {
+        await this.adoptGrantedRun(granted);
+        return;
+      }
+      const run = this.stateStore.getParkedRunForCard(cardId);
+      const sinceMs = run ? run.parkedAt ?? run.startedAt : this.stateStore.getCard(cardId)?.lastAttemptAt ?? 0;
+      let decisions;
+      try {
+        ({ decisions } = await this.client.getBudgetDecisions(cardId, new Date(sinceMs).toISOString()));
+      } catch (err) {
+        log23.warn(TAG22, `getBudgetDecisions failed for ${cardId}: ${err}`);
+        return;
+      }
+      if (decisions.length > 0) {
+        await routeBudgetDecision(decisions[0], run, {
+          continueRun: (r, opts) => this.continueRun(r, opts),
+          stopRun: (r) => this.stopRun(r),
+          grantAttempt: (id) => this.grantAttempt(id),
+          stopAttemptCap: (id) => this.stopAttemptCap(id)
+        }, cardId);
+        return;
+      }
+      if (run && run.awaitingDecisionUntil != null && run.awaitingDecisionUntil < Date.now()) {
+        await this.releaseExpiredPark(run);
+        return;
+      }
+      const card = this.stateStore.getCard(cardId);
+      if (!run && card?.awaitingDecisionUntil != null && card.awaitingDecisionUntil < Date.now()) {
+        await this.releaseExpiredAttemptCap(cardId, card.blockerCommentId);
+      }
+    } finally {
+      this.draining.delete(cardId);
+    }
+  }
+  async releaseExpiredPark(run) {
+    try {
+      await this.client.addComment(run.cardId, formatExpiredParkComment({
+        branchName: run.branchName,
+        cliSessionId: run.cliSessionId ?? null
+      }), {
+        commentType: "summary",
+        agentSessionId: run.sessionId ?? undefined,
+        ...run.blockerCommentId ? { replyToId: run.blockerCommentId } : {}
+      });
+    } catch (err) {
+      log23.warn(TAG22, `Failed to post the expired-park closing comment for ${run.cardId}: ${err}`);
+    }
+    try {
+      const { card } = await this.client.getCard(run.cardId);
+      const failColumn = this.failColumnFor(run.pipeline);
+      if (failColumn) {
+        await runTransition(this.client, card, {
+          move: { columnName: failColumn }
+        });
+      }
+    } catch (err) {
+      log23.error(TAG22, `Failed to move #${run.cardShortId} after an expired park: ${err}`);
+    }
+    try {
+      await this.stateStore.endRun(run.runId, "failed", {
+        errorMessage: "budget decision expired"
+      });
+    } catch (err) {
+      log23.warn(TAG22, `Failed to release the expired park for ${run.cardId}: ${err}`);
+    }
+  }
+  async releaseExpiredAttemptCap(cardId, blockerCommentId) {
+    try {
+      await this.client.addComment(cardId, formatExpiredAttemptCapComment(), {
+        commentType: "summary",
+        ...blockerCommentId ? { replyToId: blockerCommentId } : {}
+      });
+    } catch (err) {
+      log23.warn(TAG22, `Failed to post the expired attempt-cap note for ${cardId}: ${err}`);
+    }
+    try {
+      await this.client.endAgentSession(cardId, {
+        status: "failed",
+        failureReason: "budget",
+        failureSummary: "The attempt-budget decision expired with no answer. Reassign the card to grant a fresh attempt."
+      });
+    } catch (err) {
+      log23.warn(TAG22, `Failed to end the expired attempt-cap session for ${cardId}: ${err}`);
+    }
+    await this.stateStore.clearAwaitingDecision(cardId);
+  }
+  async adoptGrantedRun(run) {
+    if (this.isCardKnown(run.cardId))
+      return;
+    log23.warn(TAG22, `#${run.cardShortId}: granted continue never reached a worker — re-enqueueing (${run.pipeline})`);
+    await this.enqueueCard(run.cardId, run.pipeline);
+  }
+  sessionIdentityFor(run) {
+    return {
+      agentIdentifier: agentIdentifier(run.workerId),
+      agentName: run.pipeline === "review" ? `${AGENT_NAME} (Review)` : AGENT_NAME
+    };
+  }
+  attemptCapIdentityFor(cardId) {
+    return {
+      agentIdentifier: this.stateStore.getCard(cardId)?.awaitingDecisionAgentIdentifier ?? agentIdentifier(0),
+      agentName: AGENT_NAME
+    };
+  }
+  async continueRun(run, opts) {
+    await this.stateStore.decrementAttempt(run.cardId);
+    const grantedTurns = opts.extraTurns > 0 ? Math.min(opts.extraTurns, MAX_GRANTED_TURNS) : this.config.budget.pause.extraTurns ?? this.defaultTurnsFor(run.pipeline);
+    await this.stateStore.updateRun(run.runId, {
+      status: "active",
+      awaitingDecisionUntil: null,
+      grantedTurns,
+      resumeMessage: opts.message ?? null,
+      daemonPid: process.pid,
+      lastHeartbeatAt: Date.now()
+    });
+    try {
+      await this.client.updateAgentProgress(run.cardId, {
+        ...this.sessionIdentityFor(run),
+        awaitingDecisionUntil: null
+      });
+    } catch (err) {
+      log23.warn(TAG22, `Failed to clear the decision deadline for ${run.cardId}: ${err}`);
+    }
+    if (run.blockerCommentId) {
+      try {
+        await this.client.updateComment(run.blockerCommentId, {
+          resolve: true
+        });
+      } catch (err) {
+        log23.warn(TAG22, `Failed to resolve the blocker comment: ${err}`);
+      }
+    }
+    await this.enqueueCard(run.cardId, run.pipeline);
+  }
+  async stopRun(run) {
+    if (run.blockerCommentId) {
+      try {
+        await this.client.updateComment(run.blockerCommentId, {
+          resolve: true
+        });
+      } catch (err) {
+        log23.warn(TAG22, `Failed to resolve the blocker comment: ${err}`);
+      }
+    }
+    try {
+      await this.client.updateAgentProgress(run.cardId, {
+        ...this.sessionIdentityFor(run),
+        awaitingDecisionUntil: null
+      });
+    } catch (err) {
+      log23.warn(TAG22, `Failed to clear the decision deadline for ${run.cardId}: ${err}`);
+    }
+    try {
+      const { card } = await this.client.getCard(run.cardId);
+      const failColumn = this.failColumnFor(run.pipeline);
+      await runTransition(this.client, card, {
+        ...failColumn ? { move: { columnName: failColumn } } : {},
+        endSession: {
+          status: "failed",
+          failureReason: "budget",
+          failureSummary: "Stopped by a human decision on the turn budget."
+        }
+      });
+    } catch (err) {
+      log23.error(TAG22, `Failed to hand #${run.cardShortId} back after a stop: ${err}`);
+    }
+    try {
+      await this.stateStore.endRun(run.runId, "failed", {
+        errorMessage: "budget_decision_stop"
+      });
+    } catch (err) {
+      log23.warn(TAG22, `Failed to end the local run record for ${run.cardId}: ${err}`);
+    }
+  }
+  async grantAttempt(cardId) {
+    const identity = this.attemptCapIdentityFor(cardId);
+    await this.stateStore.resetAttempts(cardId);
+    await this.stateStore.clearAwaitingDecision(cardId);
+    try {
+      await this.client.updateAgentProgress(cardId, {
+        ...identity,
+        awaitingDecisionUntil: null
+      });
+    } catch (err) {
+      log23.warn(TAG22, `Failed to clear the attempt-cap decision deadline for ${cardId}: ${err}`);
+    }
+    await this.enqueueCard(cardId, "implement");
+  }
+  async stopAttemptCap(cardId) {
+    const blockerCommentId = this.stateStore.getCard(cardId)?.blockerCommentId ?? null;
+    const identity = this.attemptCapIdentityFor(cardId);
+    if (blockerCommentId) {
+      try {
+        await this.client.updateComment(blockerCommentId, { resolve: true });
+      } catch (err) {
+        log23.warn(TAG22, `Failed to resolve the blocker comment: ${err}`);
+      }
+    }
+    try {
+      await this.client.updateAgentProgress(cardId, {
+        ...identity,
+        awaitingDecisionUntil: null
+      });
+    } catch (err) {
+      log23.warn(TAG22, `Failed to clear the decision deadline for ${cardId}: ${err}`);
+    }
+    try {
+      await this.client.endAgentSession(cardId, {
+        status: "failed",
+        failureReason: "budget",
+        failureSummary: "Stopped by a human decision on the attempt budget."
+      });
+    } catch (err) {
+      log23.warn(TAG22, `Failed to end the attempt-cap session for ${cardId}: ${err}`);
+    }
+    await this.stateStore.clearAwaitingDecision(cardId);
+  }
+  failColumnFor(pipeline) {
+    return pipeline === "review" ? this.config.review.failColumn : this.config.pickupColumns[0];
+  }
+  defaultTurnsFor(pipeline) {
+    return pipeline === "review" ? this.config.claude.reviewMaxTurns : this.config.claude.maxTurns;
+  }
+  async enqueueCard(cardId, mode) {
+    try {
+      const { card } = await this.client.getCard(cardId);
+      const board = await this.client.getBoard(this.projectId, {
+        summary: true
+      });
+      const columns = board.columns ?? [];
+      const column = columns.find((c) => c.id === card.column_id);
+      if (!column) {
+        log23.warn(TAG22, `#${card.short_id}: column not found — cannot re-enqueue`);
+        return;
+      }
+      const labelMap = buildLabelMap(board.labels ?? []);
+      const cardLabels = resolveCardLabels(card, labelMap);
+      const subtasks = card.subtasks ?? [];
+      await this.enqueue(card, column, cardLabels, subtasks, mode);
+    } catch (err) {
+      log23.error(TAG22, `Failed to re-enqueue ${cardId} after a budget decision: ${err}`);
+    }
+  }
   reservations = new Set;
   cardDataCache = new Map;
   tryDispatchFor(workers, queue, label) {
@@ -8361,9 +9590,12 @@ class Pool {
 }
 var TAG22 = "pool";
 var init_pool = __esm(() => {
+  init_board_helpers();
+  init_budget_pause();
   init_queue();
   init_review_worker();
   init_sleep_guard();
+  init_transitions();
   init_types2();
   init_unblock();
   init_worker();
@@ -8478,6 +9710,11 @@ async function recoverOrphans(store, client, config) {
       errors: []
     };
     outcomes.push(outcome);
+    if (isBudgetHeldRun(run)) {
+      log25.info(TAG24, `run ${run.runId} (#${run.cardShortId}) is held for a human budget decision — leaving it`);
+      outcome.actions.push("skipped: held for a human budget decision");
+      continue;
+    }
     if (isProcessAlive(run.daemonPid, process.pid)) {
       log25.warn(TAG24, `run ${run.runId} claims live daemon pid ${run.daemonPid} — skipping`);
       outcome.actions.push("skipped: daemon pid still alive");
@@ -8560,6 +9797,7 @@ async function recoverRun(run, store, client, config, outcome, opts = {}) {
 var TAG24 = "recovery", RECOVERED_LABEL = "agent-recovered", RECOVERED_LABEL_COLOR = "#f59e0b";
 var init_recovery = __esm(() => {
   init_board_helpers();
+  init_state_store();
 });
 
 // src/claim.ts
@@ -8703,6 +9941,10 @@ class Reconciler {
     const active = this.stateStore.getActiveRuns();
     const pool = this.pool;
     for (const run of active) {
+      if (isBudgetHeldRun(run)) {
+        log28.info(TAG27, `run ${run.runId} (#${run.cardShortId}) is held for a human budget decision — leaving it`);
+        continue;
+      }
       const foreignDaemon = run.daemonPid !== process.pid;
       const daemonDead = foreignDaemon && !isProcessAlive(run.daemonPid, process.pid);
       const heartbeatStale = now - run.lastHeartbeatAt > stale;
@@ -8866,6 +10108,11 @@ class Reconciler {
       if (this.stateStore && this.agentConfig) {
         await this.recoverStaleRuns();
       }
+      try {
+        await this.pool.drainBudgetDecisions();
+      } catch (err) {
+        log28.error(TAG27, `budget decisions were not drained this tick: ${err instanceof Error ? err.message : err}`);
+      }
       await this.recoverStrandedInProgress(cards, columns, knownCardIds);
       await this.recoverStrandedReview(cards, columns, labelMap, knownCardIds);
       for (const knownId of knownCardIds) {
@@ -8886,6 +10133,7 @@ var init_reconcile = __esm(() => {
   init_board_helpers();
   init_recovery();
   init_review_worktree();
+  init_state_store();
   init_strand_recovery();
   init_types2();
 });
@@ -9179,6 +10427,9 @@ class Watcher {
   reconnectTimer = null;
   reconnectAttempts = 0;
   broadcastGen = 0;
+  presenceReconnectTimer = null;
+  presenceReconnectAttempts = 0;
+  presenceGen = 0;
   get isConnected() {
     return this.connected;
   }
@@ -9206,29 +10457,85 @@ class Watcher {
       log30.info(TAG29, "Connecting to Supabase realtime (broadcast)...");
     }
     this.supabase = createClient(this.credentials.supabaseUrl, this.credentials.supabaseAnonKey);
-    const presenceChannel = this.supabase.channel(`board-presence-${this.projectId}`);
     this.subscribeBroadcast();
+    this.subscribePresence();
+  }
+  subscribePresence() {
+    if (!this.supabase)
+      return;
+    const gen = ++this.presenceGen;
+    const presenceChannel = this.supabase.channel(`board-presence-${this.projectId}`);
+    this.presenceChannel = presenceChannel;
     presenceChannel.on("presence", { event: "sync" }, () => {
       log30.debug(TAG29, "Presence sync");
     }).subscribe(async (status) => {
+      if (gen !== this.presenceGen)
+        return;
       if (status === "SUBSCRIBED") {
-        await presenceChannel.track({
-          daemonId: this.daemonId,
-          startedAt: new Date().toISOString(),
-          userId: this.identity.userId,
-          agentId: this.identity.agentId,
-          userEmail: this.identity.userEmail,
-          agentIdentifier: this.identity.agentIdentifier,
-          agentName: this.identity.agentName
-        });
+        let trackStatus;
+        try {
+          trackStatus = await presenceChannel.track({
+            daemonId: this.daemonId,
+            startedAt: new Date().toISOString(),
+            userId: this.identity.userId,
+            agentId: this.identity.agentId,
+            userEmail: this.identity.userEmail,
+            agentIdentifier: this.identity.agentIdentifier,
+            agentName: this.identity.agentName
+          });
+        } catch (err) {
+          trackStatus = `error (${String(err)})`;
+        }
+        if (this.stopping || gen !== this.presenceGen)
+          return;
+        if (trackStatus !== "ok") {
+          this.presenceTracked = false;
+          if (!this.stopping) {
+            log30.warn(TAG29, `Presence track returned "${trackStatus}" — scheduling reconnect`);
+            this.schedulePresenceReconnect();
+          }
+          return;
+        }
         if (!isPretty2() || !this.suppressStartupLogs) {
           log30.info(TAG29, "Presence tracked on board-presence channel");
         }
         this.presenceTracked = true;
+        this.presenceReconnectAttempts = 0;
         this.maybeResolveReady();
+      } else if (status === "CHANNEL_ERROR" || status === "TIMED_OUT" || status === "CLOSED") {
+        this.presenceTracked = false;
+        if (!this.stopping) {
+          log30.warn(TAG29, `Presence subscription ${status} — scheduling reconnect`);
+          this.schedulePresenceReconnect();
+        }
       }
     });
-    this.presenceChannel = presenceChannel;
+  }
+  schedulePresenceReconnect() {
+    if (this.stopping || this.presenceReconnectTimer)
+      return;
+    const delay = Math.min(30000, 1000 * 2 ** this.presenceReconnectAttempts);
+    this.presenceReconnectAttempts++;
+    this.presenceReconnectTimer = setTimeout(() => {
+      this.presenceReconnectTimer = null;
+      this.reconnectPresence();
+    }, delay);
+  }
+  async reconnectPresence() {
+    if (this.stopping || !this.supabase)
+      return;
+    log30.warn(TAG29, `Reconnecting presence subscription (attempt ${this.presenceReconnectAttempts})`);
+    if (this.presenceChannel) {
+      const old = this.presenceChannel;
+      this.presenceChannel = null;
+      this.presenceGen++;
+      try {
+        await this.supabase.removeChannel(old);
+      } catch {}
+    }
+    if (this.stopping || !this.supabase)
+      return;
+    this.subscribePresence();
   }
   subscribeBroadcast() {
     if (!this.supabase)
@@ -9295,6 +10602,8 @@ class Watcher {
         await this.supabase.removeChannel(old);
       } catch {}
     }
+    if (this.stopping || !this.supabase)
+      return;
     this.subscribeBroadcast();
   }
   async stop() {
@@ -9303,6 +10612,10 @@ class Watcher {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
     }
+    if (this.presenceReconnectTimer) {
+      clearTimeout(this.presenceReconnectTimer);
+      this.presenceReconnectTimer = null;
+    }
     if (this.presenceChannel) {
       await this.supabase?.removeChannel(this.presenceChannel);
       this.presenceChannel = null;
@@ -9316,6 +10629,7 @@ class Watcher {
       this.supabase = null;
     }
     this.connected = false;
+    this.presenceTracked = false;
     log30.info(TAG29, "Broadcast subscription stopped");
   }
 }
@@ -9330,7 +10644,7 @@ __export(exports_worktree_gc, {
   isTransientGitNetworkError: () => isTransientGitNetworkError,
   WorktreeGc: () => WorktreeGc
 });
-import { execFileSync as execFileSync4 } from "node:child_process";
+import { execFileSync as execFileSync6 } from "node:child_process";
 import { readdirSync, statSync as statSync2 } from "node:fs";
 import { resolve as resolve2 } from "node:path";
 import { cleanupWorktree as cleanupWorktree4, log as log31 } from "@gethmy/harness";
@@ -9399,7 +10713,7 @@ function runWorktreeGc(basePath, store, opts = {}) {
     }
   }
   try {
-    execFileSync4("git", ["worktree", "prune", "--expire=now"], {
+    execFileSync6("git", ["worktree", "prune", "--expire=now"], {
       cwd: repoRoot,
       stdio: "pipe"
     });
@@ -9430,7 +10744,7 @@ function pruneFailedRemoteBranches(opts) {
     return result;
   }
   try {
-    execFileSync4("git", ["fetch", "--prune", "origin"], {
+    execFileSync6("git", ["fetch", "--prune", "origin"], {
       cwd: repoRoot,
       stdio: "pipe",
       ...GIT_NETWORK_EXEC
@@ -9446,7 +10760,7 @@ function pruneFailedRemoteBranches(opts) {
   const refPattern = `refs/remotes/origin/${opts.prefix}*`;
   let listing = "";
   try {
-    listing = execFileSync4("git", [
+    listing = execFileSync6("git", [
       "for-each-ref",
       "--format=%(refname:strip=3) %(committerdate:unix)",
       refPattern
@@ -9481,7 +10795,7 @@ function pruneFailedRemoteBranches(opts) {
       break;
     }
     try {
-      execFileSync4("git", ["push", "origin", `:refs/heads/${ref}`], {
+      execFileSync6("git", ["push", "origin", `:refs/heads/${ref}`], {
         cwd: repoRoot,
         stdio: "pipe",
         ...GIT_NETWORK_EXEC
@@ -9544,7 +10858,7 @@ class WorktreeGc {
 }
 function getRepoRoot2() {
   try {
-    return execFileSync4("git", ["rev-parse", "--show-toplevel"], {
+    return execFileSync6("git", ["rev-parse", "--show-toplevel"], {
       encoding: "utf-8"
     }).trim();
   } catch {
@@ -9583,7 +10897,7 @@ __export(exports_src, {
   validatePrerequisites: () => validatePrerequisites,
   main: () => main
 });
-import { execFileSync as execFileSync5 } from "node:child_process";
+import { execFileSync as execFileSync7 } from "node:child_process";
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { createRequire as createRequire3 } from "node:module";
 import {
@@ -9593,7 +10907,7 @@ import {
 } from "@gethmy/harness";
 async function validatePrerequisites(config, banner) {
   try {
-    const ver = execFileSync5("claude", ["--version"], {
+    const ver = execFileSync7("claude", ["--version"], {
       encoding: "utf-8"
     }).trim();
     banner.check(`Claude CLI ${ver}`);
@@ -9608,20 +10922,23 @@ async function validatePrerequisites(config, banner) {
     validateGitProviderCli(provider);
   }
   try {
-    const status = execFileSync5("git", ["status", "--porcelain"], {
-      encoding: "utf-8"
+    const status = execFileSync7("git", ["status", "--porcelain"], {
+      encoding: "utf-8",
+      stdio: "pipe"
     }).trim();
     if (status) {
       banner.warn(`Working directory has uncommitted changes:
 ${status}`);
     }
-    execFileSync5("git", ["rev-parse", "--verify", `origin/${config.agent.worktree.baseBranch}`], {
-      encoding: "utf-8",
-      stdio: "pipe"
-    });
   } catch {
-    throw new Error(`Git base branch "origin/${config.agent.worktree.baseBranch}" not found. Fetch or configure a different base branch.`);
+    throw new Error(`Not a git repository: ${process.cwd()}. Start the daemon from the checkout its worktrees should branch from.`);
   }
+  const base = config.agent.worktree.baseBranch;
+  const resolution = resolveBaseBranch(base, BASE_REMOTE, createGitProbe(process.cwd()));
+  if (!resolution.ok) {
+    throw new Error(`Git base branch "${BASE_REMOTE}/${base}" is unusable. ${resolution.message}`);
+  }
+  banner.check(resolution.fetched ? `Base branch ${BASE_REMOTE}/${base} (fetched)` : `Base branch ${BASE_REMOTE}/${base}`);
   const client = createApiClient(config);
   try {
     await client.listWorkspaces();
@@ -9687,10 +11004,17 @@ async function main() {
   const { agent: registeredAgent } = await client.registerWorkspaceAgent(config.workspaceId, {
     identifier: config.agentIdentifier,
     name: config.agentName,
-    color: config.agentColor
+    color: config.agentColor,
+    declaredGateMetrics: declaredMetricNames(config.agent.playbooks.metrics)
   });
   const agentId = registeredAgent.id;
   banner.check(`Agent registered (${config.agentName})`);
+  try {
+    const undeclared = await findUndeclaredGateMetrics(client, config.projectId, config.agent);
+    for (const finding of undeclared) {
+      banner.warn(formatUndeclaredMetricWarning(finding));
+    }
+  } catch {}
   const identity = { userId: agentUserId, agentId };
   const realtimeCreds = await fetchRealtimeCredentials(client);
   banner.check("Realtime credentials");
@@ -9920,14 +11244,16 @@ async function tryEnqueueCard(cardId, client, pool, config, agentId) {
   }
   await pool.enqueue(card, column, cardLabels, subtasks, mode);
 }
-var TAG31 = "daemon", PKG_VERSION;
+var TAG31 = "daemon", BASE_REMOTE = "origin", PKG_VERSION;
 var init_src = __esm(() => {
+  init_base_branch();
   init_board_helpers();
   init_board_reviewer();
   init_config();
   init_config_validation();
   init_http_server();
   init_merge_monitor();
+  init_metric_validation();
   init_pool();
   init_port_registry();
   init_reconcile();
@@ -10148,7 +11474,7 @@ function computeRunStats(runs, cards, logs = []) {
   const verifyFailCount = failureReasons.verification ?? 0;
   return {
     totalRuns: runs.length,
-    activeRuns: runs.length - ended.length,
+    activeRuns: runs.length - ended.length - byStatus.parked,
     endedRuns: ended.length,
     byPipeline,
     byStatus,
@@ -10195,6 +11521,7 @@ function buildRunListRows(runs, logs, opts = {}) {
 }
 var EMPTY_STATUS_HISTOGRAM = () => ({
   active: 0,
+  parked: 0,
   completed: 0,
   paused: 0,
   failed: 0,
@@ -10370,10 +11697,12 @@ async function recoverCommand() {
   const { buildLabelMap: buildLabelMap2 } = await Promise.resolve().then(() => (init_board_helpers(), exports_board_helpers));
   const config = loadDaemonConfig2();
   const client = createApiClient2(config);
+  const { declaredMetricNames: declaredMetricNames2 } = await Promise.resolve().then(() => exports_declared_metrics);
   const { agent: registeredAgent } = await client.registerWorkspaceAgent(config.workspaceId, {
     identifier: config.agentIdentifier,
     name: config.agentName,
-    color: config.agentColor
+    color: config.agentColor,
+    declaredGateMetrics: declaredMetricNames2(config.agent.playbooks.metrics)
   });
   const agentId = registeredAgent.id;
   const monitor = new MergeMonitor2(client, config.projectId, config.agent);
@@ -10633,12 +11962,12 @@ async function statsCommand() {
     return 0;
   }
   const pct = (x) => `${(x * 100).toFixed(0)}%`;
-  out.write(`runs        total=${stats.totalRuns}  active=${stats.activeRuns}  ended=${stats.endedRuns}  (failure rate ${pct(stats.runFailureRate)})
+  out.write(`runs        total=${stats.totalRuns}  active=${stats.activeRuns}  parked=${stats.byStatus.parked}  ended=${stats.endedRuns}  (failure rate ${pct(stats.runFailureRate)})
 `);
   out.write(`pipelines   implement=${stats.byPipeline.implement}  review=${stats.byPipeline.review}
 `);
   const s = stats.byStatus;
-  out.write(`status      completed=${s.completed}  failed=${s.failed}  orphaned=${s.orphaned}  paused=${s.paused}  active=${s.active}
+  out.write(`status      completed=${s.completed}  failed=${s.failed}  orphaned=${s.orphaned}  paused=${s.paused}  parked=${s.parked}  active=${s.active}
 `);
   out.write(`cards       distinct=${stats.distinctCards}  avg runs/card=${stats.avgRunsPerCard.toFixed(1)}
 `);