codeam-cli 2.75.7 → 2.75.9

package/dist/index.js

@@ -2865,6 +2865,11 @@ function normalizeGuardrailPolicy(raw) {
   return out2;
 }
 
+// ../../packages/shared/src/packs/types.ts
+var PACK_FINDINGS_FILE = "REVIEW-FINDINGS.pack.json";
+var MAX_PACK_FINDINGS = 50;
+var PACK_HANDOFF_HEADING = "## Handoff";
+
 // ../../packages/shared/src/packs/roles.ts
 var SPECIFIER_PROMPT = `# Role: Specifier
 
@@ -2880,6 +2885,8 @@ Method:
    - **Verification plan** \u2014 for each criterion, the level that proves it (unit / integration / manual) and why.
 3. Right-size: if the task is clearly too large for one pipeline run, narrow the criteria to a coherent first slice and record the rest under "Out of scope / next".
 
+4. Close with a \`## Handoff\` section: the criteria count, what you scoped out, and any assumption the Coder must know.
+
 Handoff bar: the spec file is committed; every acceptance criterion is testable as written; a competent implementer could start without asking you anything.`;
 var CODER_PROMPT = `# Role: Coder
 
@@ -2890,6 +2897,7 @@ Method:
 2. Test-first where it fits: write the test that proves a criterion, watch it fail, implement until it passes. Where strict test-first doesn't fit, still land tests alongside the change.
 3. Match the project's existing style, structure, and conventions. Simplest design that fully solves the problem \u2014 no speculative abstractions, no "while I'm here" changes.
 4. Run the project's tests / linters / build and make them pass.
+5. Close with a \`## Handoff\` section: which criteria are implemented (by number) and where their tests live, anything you consciously did NOT do, and what the Reviewer should look at first.
 
 Handoff bar: every acceptance criterion is implemented and covered by a test; the project's checks pass; the work is committed in focused commits.`;
 var REVIEWER_PROMPT = `# Role: Reviewer
@@ -2905,21 +2913,42 @@ Method:
    - **Conventions & naming** \u2014 matches the surrounding code; names say what things are.
    - **Safety** \u2014 no secrets, credentials, or debugging remnants in code, tests, or fixtures.
 3. Fix what is justified \u2014 smallest change that resolves the finding, keeping behavior. Re-run the checks after material fixes.
-4. Record your findings honestly in your closing summary: what you found, what you fixed, what you deliberately left, and what you could not verify.
-
-Handoff bar: checks pass on YOUR final commit; every fix is committed; your summary lists findings \u2192 resolutions (an empty findings list must say what you checked).`;
+4. Write your findings as DATA to \`REVIEW-FINDINGS.pack.json\` at the repo root \u2014 the next stage verifies them one by one, so what is not in this file does not get verified. Exact shape:
+   \`\`\`json
+   {
+     "findings": [
+       {
+         "id": "R1",
+         "severity": "blocker | major | minor | nit",
+         "title": "one line: what is wrong",
+         "detail": "why it matters and what you did about it",
+         "file": "src/path/to/file.ts",
+         "line": 42,
+         "resolution": "fixed | deferred | wont_fix | needs_verification",
+         "commit": "abcdef1234"
+       }
+     ],
+     "checked": ["what you audited when the list is empty: e.g. error paths of X, test coverage of Y"]
+   }
+   \`\`\`
+   Every finding you fixed says \`fixed\` with its commit; anything you deliberately left says \`deferred\` or \`wont_fix\` with the reason in \`detail\`; anything you could not verify says \`needs_verification\`. An empty \`findings\` array is a valid, honest result \u2014 then \`checked\` must say what you looked at. Commit this file with your stage.
+5. Close with a \`## Handoff\` section: what you found (counts by severity), what you fixed, what you deliberately left, and what the next stage must verify.
+
+Handoff bar: checks pass on YOUR final commit; every fix is committed; \`REVIEW-FINDINGS.pack.json\` is committed and lists every finding with its resolution (an empty list says what you checked).`;
 var QA_PROMPT = `# Role: QA
 
 You are the final gate. You verify the delivered work against the acceptance criteria as a whole \u2014 end to end, the way a demanding user would \u2014 and produce the run's closing report.
 
 Method:
 1. Read the task and \`SPEC.pack.md\` (when present). Your contract is the acceptance criteria; without a spec, derive them from the task.
-2. For EACH criterion, verify it against the real project: run the relevant tests, execute the code paths where feasible, inspect actual behavior/output. Do not take earlier stages' word for anything.
-3. Run the project's full checks (tests, lint, types, build) one final time.
-4. Write \`QA-REPORT.pack.md\` at the repo root: per-criterion verdict (\u2705 verified / \u26A0\uFE0F partially / \u274C failed \u2014 with evidence for each), the checks' results, anything not verifiable in this environment (stated plainly), and a short "ready to ship?" conclusion.
-5. If a criterion FAILS: fix it only when the fix is small and unambiguous; otherwise mark it failed with exact evidence \u2014 the user decides. Never paper over a failure.
+2. Read \`REVIEW-FINDINGS.pack.json\` (when present \u2014 the Reviewer's structured findings, also summarized in your handoff input). Every finding there is an item on YOUR checklist: a \`fixed\` one must be verified fixed without regression; a \`deferred\`/\`wont_fix\` one must be judged acceptable or escalated; a \`needs_verification\` one is yours to settle.
+3. For EACH criterion, verify it against the real project: run the relevant tests, execute the code paths where feasible, inspect actual behavior/output. Do not take earlier stages' word for anything.
+4. Run the project's full checks (tests, lint, types, build) one final time.
+5. Write \`QA-REPORT.pack.md\` at the repo root with two sections: **Acceptance criteria** \u2014 per-criterion verdict (\u2705 verified / \u26A0\uFE0F partially / \u274C failed \u2014 with evidence for each); **Review findings** \u2014 per finding id, verdict (\u2705 verified fixed / \u26A0\uFE0F still open / \u274C regressed \u2014 with evidence). Then the checks' results, anything not verifiable in this environment (stated plainly), and a short "ready to ship?" conclusion.
+6. If a criterion FAILS: fix it only when the fix is small and unambiguous; otherwise mark it failed with exact evidence \u2014 the user decides. Never paper over a failure.
+7. Close with a \`## Handoff\` section: the ship/no-ship conclusion, the failed or open items by id, and what you could not verify.
 
-Handoff bar: the report is committed; every verdict carries evidence; the conclusion is honest about anything unverified.`;
+Handoff bar: the report is committed; every verdict carries evidence; every finding id from the Reviewer appears in the report; the conclusion is honest about anything unverified.`;
 
 // ../../packages/shared/src/packs/registry.ts
 var PACK_REGISTRY = {
@@ -2943,7 +2972,9 @@ var PACK_REGISTRY = {
         skillIds: ["code-review", "code-naming"],
         prompt: REVIEWER_PROMPT,
         // Review-only: approving clean with no change is success, not a stall.
-        requiresCommit: false
+        requiresCommit: false,
+        // Leaves REVIEW-FINDINGS.pack.json — the next stage gets a list, not prose.
+        producesFindings: true
       }
     ]
   },
@@ -2974,7 +3005,9 @@ var PACK_REGISTRY = {
         skillIds: ["code-review", "code-naming"],
         prompt: REVIEWER_PROMPT,
         // Review-only: approving clean with no change is success, not a stall.
-        requiresCommit: false
+        requiresCommit: false,
+        // Leaves REVIEW-FINDINGS.pack.json — the next stage gets a list, not prose.
+        producesFindings: true
       },
       {
         role: "qa",
@@ -3004,8 +3037,140 @@ You are ONE specialist role in a multi-role pipeline running on this repository.
 - **Never leave the tree broken.** Run the project's checks before finishing when the project has them; your stage ends with a working tree the next role can build on.
 - **Do not push, force-push, or touch remotes** \u2014 the pipeline works locally; publishing is the user's call at the end.
 - **Never read, edit, or commit anything under \`.codeam/\`** \u2014 that is the pipeline's own ledger, not project code.
-- **Finish decisively.** When your stage's job is done and committed, say so in 2-4 lines (what you did, what you verified, anything the next stage should know) and stop. Don't ask "should I continue?" \u2014 the pipeline advances automatically.
-- **If you are genuinely blocked** (contradictory requirements, missing access), say exactly what is blocking you and stop \u2014 the user is supervising and will decide.`;
+- **Finish with a \`## Handoff\` section.** When your stage's job is done and committed, end your reply with a heading \`## Handoff\` followed by 2-6 lines: what you did, what you verified, anything the next stage must know. That section \u2014 not the rest of your reply \u2014 is what the next role receives. Don't ask "should I continue?" \u2014 the pipeline advances automatically.
+- **If you need the user's decision** (contradictory requirements, a real product choice), ask ONE clear question and end your reply with 2-4 numbered options on their own lines (\`1. \u2026\`), then stop. The pipeline pauses until they answer in this conversation; keep working in it once they do, and commit as usual.
+- **If you are genuinely blocked** (missing access, a broken environment you cannot fix), say exactly what is blocking you and stop \u2014 the user is supervising and will decide.`;
+
+// ../../packages/shared/src/packs/findings.ts
+var SEVERITIES = /* @__PURE__ */ new Set([
+  "blocker",
+  "major",
+  "minor",
+  "nit"
+]);
+var RESOLUTIONS = /* @__PURE__ */ new Set([
+  "fixed",
+  "deferred",
+  "wont_fix",
+  "needs_verification"
+]);
+var TITLE_MAX = 200;
+var DETAIL_MAX = 1200;
+function parsePackFindings(raw) {
+  const text = stripFence(raw).trim();
+  if (text.length === 0) return { ok: false, error: "findings file is empty" };
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    const salvaged = salvageJson(text);
+    if (salvaged === null) return { ok: false, error: "findings file is not valid JSON" };
+    data = salvaged;
+  }
+  const container = Array.isArray(data) ? { findings: data } : data;
+  if (!isRecord(container) || !Array.isArray(container.findings)) {
+    return { ok: false, error: 'findings file has no "findings" array' };
+  }
+  const findings = [];
+  let dropped = 0;
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of container.findings) {
+    const f = coerceFinding(entry, findings.length + 1);
+    if (!f) {
+      dropped += 1;
+      continue;
+    }
+    if (seen.has(f.id)) f.id = `${f.id}-${findings.length + 1}`;
+    seen.add(f.id);
+    findings.push(f);
+    if (findings.length >= MAX_PACK_FINDINGS) break;
+  }
+  const truncated = container.findings.length - dropped - findings.length;
+  const checked = Array.isArray(container.checked) ? container.checked.filter((c2) => typeof c2 === "string" && c2.trim().length > 0).slice(0, 20) : void 0;
+  const notes = [];
+  if (dropped > 0) notes.push(`${dropped} malformed entr${dropped === 1 ? "y" : "ies"} dropped`);
+  if (truncated > 0)
+    notes.push(`list truncated to ${MAX_PACK_FINDINGS} (${truncated} more in the file)`);
+  return {
+    ok: true,
+    value: {
+      findings,
+      ...checked && checked.length > 0 ? { checked } : {},
+      ...notes.length > 0 ? { note: notes.join("; ") } : {}
+    }
+  };
+}
+function coerceFinding(entry, ordinal) {
+  if (!isRecord(entry)) return null;
+  const title = str(entry.title) ?? str(entry.summary);
+  if (!title) return null;
+  const id = str(entry.id) ?? `R${ordinal}`;
+  const severityRaw = (str(entry.severity) ?? "").toLowerCase();
+  const resolutionRaw = (str(entry.resolution) ?? str(entry.status) ?? "").toLowerCase().replace(/[\s-]+/g, "_");
+  const line = typeof entry.line === "number" && Number.isFinite(entry.line) && entry.line > 0 ? Math.floor(entry.line) : void 0;
+  const detail = str(entry.detail) ?? str(entry.description);
+  const file = str(entry.file) ?? str(entry.path);
+  const commit = str(entry.commit);
+  return {
+    id: id.slice(0, 32),
+    severity: SEVERITIES.has(severityRaw) ? severityRaw : "major",
+    title: title.slice(0, TITLE_MAX),
+    ...detail ? { detail: detail.slice(0, DETAIL_MAX) } : {},
+    ...file ? { file: file.slice(0, 300) } : {},
+    ...line !== void 0 ? { line } : {},
+    resolution: RESOLUTIONS.has(resolutionRaw) ? resolutionRaw : "needs_verification",
+    ...commit && /^[0-9a-f]{7,40}$/i.test(commit) ? { commit: commit.slice(0, 10) } : {}
+  };
+}
+function extractHandoffSection(reply) {
+  const lines = reply.split("\n");
+  const want = PACK_HANDOFF_HEADING.replace(/^#+\s*/, "").toLowerCase();
+  let start2 = -1;
+  let level = 0;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const m = lines[i].match(/^\s{0,3}(#{1,4})\s+(.+?)\s*#*\s*$/);
+    if (m && m[2].trim().toLowerCase().replace(/[:.]+$/, "") === want) {
+      start2 = i;
+      level = m[1].length;
+      break;
+    }
+  }
+  if (start2 < 0) return null;
+  const body = [];
+  for (let i = start2 + 1; i < lines.length; i++) {
+    const m = lines[i].match(/^\s{0,3}(#{1,6})\s+/);
+    if (m && m[1].length <= level) break;
+    body.push(lines[i]);
+  }
+  const text = body.join("\n").trim();
+  return text.length > 0 ? text : null;
+}
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function str(v) {
+  return typeof v === "string" && v.trim().length > 0 ? v.trim() : void 0;
+}
+function stripFence(raw) {
+  const m = raw.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  return m ? m[1] : raw;
+}
+function salvageJson(text) {
+  for (const [open, close] of [
+    ["{", "}"],
+    ["[", "]"]
+  ]) {
+    const a = text.indexOf(open);
+    const b = text.lastIndexOf(close);
+    if (a >= 0 && b > a) {
+      try {
+        return JSON.parse(text.slice(a, b + 1));
+      } catch {
+      }
+    }
+  }
+  return null;
+}
 
 // ../../packages/shared/src/api-url.ts
 var DEFAULT_API_BASE_URL = "https://api.codeagent-mobile.com";
@@ -8689,7 +8854,7 @@ var TOPLEVEL_SENTINELS = [
     field: "window_id"
   }
 ];
-function isRecord(value) {
+function isRecord2(value) {
   return "object" == typeof value && null !== value && !Array.isArray(value);
 }
 function toRfc3339(timestamp) {
@@ -8708,7 +8873,7 @@ function relocateInto(properties, key, value) {
   if (void 0 !== value && !(key in properties)) properties[key] = value;
 }
 function buildV1Event(message) {
-  const sourceProperties = isRecord(message.properties) ? message.properties : {};
+  const sourceProperties = isRecord2(message.properties) ? message.properties : {};
   const properties = {
     ...sourceProperties
   };
@@ -10344,7 +10509,7 @@ function readAnonId() {
 }
 function superProperties() {
   return {
-    cliVersion: true ? "2.75.7" : "0.0.0-dev",
+    cliVersion: true ? "2.75.9" : "0.0.0-dev",
     nodeVersion: process.version,
     platform: process.platform,
     arch: process.arch,
@@ -10586,7 +10751,7 @@ var http = __toESM(require("http"));
 // package.json
 var package_default = {
   name: "codeam-cli",
-  version: "2.75.7",
+  version: "2.75.9",
   description: "Workflow-continuity bridge for AI coding agents. Wrap Claude Code or Codex in a PTY and supervise, approve, and redirect the session from any device \u2014 async. The terminal companion for CodeAgent Mobile.",
   type: "commonjs",
   main: "dist/index.js",
@@ -11384,6 +11549,9 @@ var streamHost = new StreamHostSelector(
 );
 
 // src/services/command-relay.service.ts
+function isRecord3(v) {
+  return typeof v === "object" && v !== null;
+}
 function httpStatusOf(err) {
   if (typeof err === "object" && err !== null && "statusCode" in err) {
     const status2 = err.statusCode;
@@ -11394,6 +11562,8 @@ function httpStatusOf(err) {
 var API_BASE2 = resolveApiBaseUrl();
 var PENDING_STREAM_PATH = "/api/commands/pending/stream";
 var SSE_LIVENESS_TIMEOUT_MS = 45e3;
+var HEARTBEAT_RETRY_MS = 3e3;
+var HEARTBEAT_WARN_INTERVAL_MS = 6e4;
 var SSE_WATCHDOG_INTERVAL_MS = 1e4;
 var CommandRelayService = class _CommandRelayService {
   constructor(pluginId, onCommand, agentMeta, agentsOverride, explicitPollSecret, onHeartbeat) {
@@ -11412,6 +11582,18 @@ var CommandRelayService = class _CommandRelayService {
   onHeartbeat;
   _running = false;
   pairingInvalid = false;
+  /**
+   * Heartbeat health. Before 2026-09-23 a failed heartbeat was a `log.trace`,
+   * i.e. INVISIBLE in a normal `~/.codeam/debug-*.log` — a user whose beats
+   * never reached the origin (every other request did) spent a day on "Server
+   * Failed to Start" with nothing in his log to show for it. Failures are now
+   * WARN (rate-limited per streak) + a PostHog event, and the process exits
+   * when the backend answers `paired:false`.
+   */
+  heartbeatFailStreak = 0;
+  heartbeatLastWarnAt = 0;
+  sessionGone = false;
+  onSessionGone;
   heartbeatTimer = null;
   agentsTimer = null;
   /** Injectable for tests; defaults to real fs/fetch/spawn wiring. */
@@ -11530,6 +11712,17 @@ var CommandRelayService = class _CommandRelayService {
   stop() {
     void this.stopAndFlush();
   }
+  /**
+   * Called ONCE when a heartbeat answers `paired:false` — the backend no longer
+   * has a live session for this pluginId (deleted / disconnected from the
+   * app). The relay has already stopped itself by then; the owner should exit
+   * the process like a Ctrl-C would. Backstop for a process whose
+   * `session_terminated` command was consumed by a sibling on the same
+   * pluginId (two `codeam start` on one saved session, 2026-09-23).
+   */
+  setOnSessionGone(cb) {
+    this.onSessionGone = cb;
+  }
   /**
    * Same teardown as {@link stop}, but resolves only once the `online:false`
    * heartbeat POST has settled — so a caller can `await` it before exiting.
@@ -11877,8 +12070,9 @@ var CommandRelayService = class _CommandRelayService {
     });
   }
   // ─── Heartbeat + agents ──────────────────────────────────────────
-  async sendHeartbeat(online) {
-    await _postJson(`${API_BASE2}/api/plugin/heartbeat`, {
+  async sendHeartbeat(online, attempt = 0) {
+    if (this.sessionGone && online) return;
+    const body = {
       pluginId: this.pluginId,
       online,
       agentId: this.agentMeta.id,
@@ -11887,8 +12081,58 @@ var CommandRelayService = class _CommandRelayService {
       // fresh + clear the "CLI update available" banner after a self-update
       // (a codespace that reinstalls @latest reconnects via heartbeat, not
       // pair/reconnect). Older backends ignore the extra field.
-      ..."2.75.7" ? { ideVersion: "2.75.7" } : {}
-    }).then(() => log.trace("relay", `heartbeat ok online=${online}`)).catch((err) => log.trace("relay", `heartbeat failed online=${online}`, err));
+      ..."2.75.9" ? { ideVersion: "2.75.9" } : {}
+    };
+    try {
+      const res = await _postJson(`${API_BASE2}/api/plugin/heartbeat`, body);
+      this.heartbeatFailStreak = 0;
+      log.trace("relay", `heartbeat ok online=${online}`);
+      const data = res?.data;
+      if (online && isRecord3(data) && data.paired === false) this.handleSessionGone();
+    } catch (err) {
+      if (!online) {
+        log.trace("relay", "goodbye heartbeat failed", err);
+        return;
+      }
+      this.heartbeatFailStreak += 1;
+      this.noteHeartbeatFailure(err);
+      if (attempt === 0 && this._running) {
+        const t2 = setTimeout(() => {
+          void this.sendHeartbeat(true, 1);
+        }, HEARTBEAT_RETRY_MS);
+        t2.unref?.();
+      }
+    }
+  }
+  noteHeartbeatFailure(err) {
+    const status2 = httpStatusOf(err);
+    const code = err?.code;
+    const reason = status2 ? `status_${status2}` : typeof code === "string" ? code : (err instanceof Error ? err.message : String(err)).slice(0, 80);
+    const now = Date.now();
+    const firstOfStreak = this.heartbeatFailStreak === 1;
+    if (!firstOfStreak && now - this.heartbeatLastWarnAt < HEARTBEAT_WARN_INTERVAL_MS) return;
+    this.heartbeatLastWarnAt = now;
+    log.warn(
+      "relay",
+      `heartbeat failed (${reason}, streak=${this.heartbeatFailStreak}) \u2014 two misses in a row and the app shows this session OFFLINE even though it is running`
+    );
+    capture("heartbeat_failed", {
+      pluginId: this.pluginId,
+      agentId: this.agentMeta.id,
+      reason,
+      streak: this.heartbeatFailStreak
+    });
+  }
+  handleSessionGone() {
+    if (this.sessionGone) return;
+    log.warn("relay", "backend reports this session no longer exists (paired:false) \u2014 stopping");
+    capture("session_gone_detected", { pluginId: this.pluginId, agentId: this.agentMeta.id });
+    process.stderr.write(
+      "[codeam] This session was deleted or disconnected from the app \u2014 exiting. Run `codeam pair` to start a new one.\n"
+    );
+    this.stop();
+    this.sessionGone = true;
+    this.onSessionGone?.();
   }
   /**
    * Refresh {@link cachedBranch} without blocking the event loop.
@@ -31218,14 +31462,14 @@ var zGuardCreateElicitationResponseCancel = z7.object({
 
 // ../../node_modules/@agentclientprotocol/sdk/dist/jsonrpc.js
 var CANCEL_REQUEST_METHOD = "$/cancel_request";
-function isRecord2(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null;
 }
 function isJsonRpcId(value) {
   return value === null || typeof value === "string" || typeof value === "number" && Number.isFinite(value);
 }
 function cancelRequestId(params) {
-  if (!isRecord2(params) || !isJsonRpcId(params["requestId"])) {
+  if (!isRecord4(params) || !isJsonRpcId(params["requestId"])) {
     return void 0;
   }
   return params["requestId"];
@@ -31657,7 +31901,7 @@ var Connection = class {
     if (this.abortController.signal.aborted) {
       return;
     }
-    if (!isRecord2(message)) {
+    if (!isRecord4(message)) {
       console.error("Invalid message", { message });
       return;
     }
@@ -31750,7 +31994,7 @@ var Connection = class {
       pendingResponse.cleanup?.();
       if ("result" in response) {
         pendingResponse.resolve(response.result);
-      } else if ("error" in response && isRecord2(response.error)) {
+      } else if ("error" in response && isRecord4(response.error)) {
         const { code, message, data } = response.error;
         pendingResponse.reject(new RequestError(code, message, data));
       } else {
@@ -32023,7 +32267,7 @@ function ndJsonStream(output, input) {
         if (trimmedLine) {
           try {
             const message = JSON.parse(trimmedLine);
-            if (isRecord2(message)) {
+            if (isRecord4(message)) {
               controller.enqueue(message);
             } else {
               console.warn("Skipping JSON line that is not an object:", trimmedLine);
@@ -37277,11 +37521,16 @@ async function postCredentialSync(opts, fetchImpl = fetch) {
 var import_node_child_process22 = require("child_process");
 var fs60 = __toESM(require("fs"));
 var path70 = __toESM(require("path"));
-var defaultCommandRunner = (file, args2, cwd, timeoutMs) => new Promise((resolve11) => {
+var defaultCommandRunner = (file, args2, cwd, timeoutMs, env) => new Promise((resolve11) => {
   (0, import_node_child_process22.execFile)(
     file,
     args2,
-    { cwd, timeout: timeoutMs, maxBuffer: 4 * 1024 * 1024 },
+    {
+      cwd,
+      timeout: timeoutMs,
+      maxBuffer: 4 * 1024 * 1024,
+      env: env ? { ...process.env, ...env } : process.env
+    },
     (err, stdout, stderr) => {
       let code = 0;
       if (err) {
@@ -37298,7 +37547,12 @@ async function gitHead(run, cwd) {
   return res.code === 0 ? res.stdout.trim() : null;
 }
 async function canonicalCommit(run, cwd, sha) {
-  const verify = await run("git", ["rev-parse", "--verify", `${sha}^{commit}`], cwd, GIT_TIMEOUT_MS);
+  const verify = await run(
+    "git",
+    ["rev-parse", "--verify", `${sha}^{commit}`],
+    cwd,
+    GIT_TIMEOUT_MS
+  );
   if (verify.code !== 0) return null;
   const short = await run("git", ["rev-parse", "--short=10", sha], cwd, GIT_TIMEOUT_MS);
   return short.code === 0 ? short.stdout.trim() : null;
@@ -37309,6 +37563,18 @@ async function diffStat(run, cwd, from, to) {
   const lines = res.stdout.trim().split("\n").filter(Boolean);
   return lines.length > 0 ? lines[lines.length - 1].trim() : "";
 }
+async function changedFiles(run, cwd, from, to) {
+  const res = await run("git", ["diff", "--name-only", `${from}..${to}`], cwd, GIT_TIMEOUT_MS);
+  if (res.code !== 0) return [];
+  return res.stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+}
+function readWorkspaceFile(cwd, relPath) {
+  try {
+    return fs60.readFileSync(path70.join(cwd, relPath), "utf8");
+  } catch {
+    return null;
+  }
+}
 var NO_TEST_PLACEHOLDER = 'echo "Error: no test specified"';
 var CHECKS_TIMEOUT_MS = 5 * 6e4;
 function detectChecksCommand(cwd) {
@@ -37330,7 +37596,7 @@ function detectChecksCommand(cwd) {
   return null;
 }
 async function runChecks(run, cwd, command2) {
-  const res = await run("sh", ["-c", command2], cwd, CHECKS_TIMEOUT_MS);
+  const res = await run("sh", ["-c", command2], cwd, CHECKS_TIMEOUT_MS, { CI: "1" });
   const combined = `${res.stdout}
 ${res.stderr}`.trim();
   const tail = combined.split("\n").slice(-12).join("\n").slice(-1500);
@@ -37427,33 +37693,109 @@ async function postPackState(opts, state, fetchImpl = fetch) {
 }
 
 // src/packs/runner.ts
-var NUDGE_PROMPT = "Your stage is not committed yet. Commit your completed work now (focused commits, ending with your role byline `By <role>.` on its own line), then summarize in 2-4 lines and stop. If you are blocked, say exactly what is blocking you instead.";
-var SUMMARY_MAX_CHARS = 600;
-function composeStagePrompt(pack, stageIndex, task, previous) {
+var TERMINAL_PACK_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "aborted",
+  "failed"
+]);
+var NUDGE_PROMPT = "Your stage is not committed yet. Commit your completed work now (focused commits, ending with your role byline `By <role>.` on its own line), then close with your `## Handoff` section and stop. If you are blocked, say exactly what is blocking you instead.";
+var SUMMARY_TAIL_MAX_CHARS = 600;
+var SUMMARY_SECTION_MAX_CHARS = 1500;
+var EARLIER_HANDOFF_MAX_CHARS = 400;
+function composeStagePrompt(pack, stageIndex, task, ctx) {
   const stage = pack.stages[stageIndex];
   const pipeline2 = pack.stages.map((s, i) => i === stageIndex ? `[${s.name}]` : s.name).join(" \u2192 ");
+  const position = [
+    `${pack.name}: ${pipeline2} \u2014 you are stage ${stageIndex + 1} of ${pack.stages.length}. Your commit byline: \`By ${stage.role}.\``
+  ];
+  if (ctx.baseCommit) {
+    position.push(
+      `Pipeline base commit: \`${ctx.baseCommit}\` \u2014 everything the pipeline has done so far is \`git log ${ctx.baseCommit}..HEAD\` / \`git diff ${ctx.baseCommit}..HEAD\`. Use that range; do not guess it.`
+    );
+  }
   const parts = [
     stage.prompt,
     PACK_WORKFLOW_ARTICLE,
     `## Your pipeline position
-${pack.name}: ${pipeline2} \u2014 you are stage ${stageIndex + 1} of ${pack.stages.length}. Your commit byline: \`By ${stage.role}.\``,
+${position.join("\n")}`,
     `## Task
 ${task}`
   ];
-  if (previous) {
+  const done = ctx.prior.filter((p2) => p2.status === "done" && p2.handoff);
+  const skipped = ctx.prior.filter((p2) => p2.status === "skipped");
+  if (done.length > 0) {
+    const last = done[done.length - 1];
+    const earlier = done.slice(0, -1);
+    if (earlier.length > 0) {
+      parts.push(
+        `## Earlier handoffs
+${earlier.map((p2) => renderHandoff(p2, EARLIER_HANDOFF_MAX_CHARS)).join("\n\n")}`
+      );
+    }
     parts.push(
-      `## Previous stage handoff (${previous.role})
-commit: ${previous.handoff.commit}
-${previous.handoff.diffStat}
-
-${previous.handoff.summary}`
+      `## Previous stage handoff (${last.role})
+${renderHandoff(last, SUMMARY_SECTION_MAX_CHARS)}`
+    );
+  }
+  if (skipped.length > 0) {
+    parts.push(
+      `## Skipped stages
+${skipped.map((p2) => `- ${p2.name} (${p2.role}) was skipped by the user \u2014 its artifacts do not exist; do not assume them.`).join("\n")}`
+    );
+  }
+  if (ctx.attempt > 1) {
+    parts.push(
+      `## Previous attempt of this stage
+Attempt ${ctx.attempt - 1} did not hand off${ctx.previousAttemptError ? `: ${ctx.previousAttemptError}` : "."}
+The working tree may contain that attempt's partial work. Inspect it first, keep what is right, and finish the stage properly.`
     );
   }
   return parts.join("\n\n");
 }
+function renderHandoff(p2, summaryMax) {
+  const h = p2.handoff;
+  const head = [`### ${p2.name} (${p2.role})`, `commit: ${h.commit}`];
+  if (h.diffStat) head.push(h.diffStat);
+  if (h.checks)
+    head.push(`checks (\`${h.checks.command}\`): ${h.checks.passed ? "passed" : "FAILED"}`);
+  const lines = [head.join("\n")];
+  const summary = h.summary.trim();
+  if (summary) lines.push(summary.length > summaryMax ? `\u2026${summary.slice(-summaryMax)}` : summary);
+  if (h.checks && !h.checks.passed && h.checks.tail) {
+    lines.push(`Checks output (tail):
+${h.checks.tail}`);
+  }
+  if (h.findings) {
+    lines.push(renderFindings(h.findings, h.findingsNote));
+  } else if (h.findingsNote) {
+    lines.push(`Structured findings: ${h.findingsNote}`);
+  }
+  return lines.join("\n\n");
+}
+function renderFindings(findings, note) {
+  const list = findings ?? [];
+  const header = `Structured findings (${PACK_FINDINGS_FILE}): ${list.length}${note ? ` \u2014 ${note}` : ""}`;
+  if (list.length === 0) return header;
+  const rows = list.map((f) => {
+    const where = f.file ? ` @ ${f.file}${f.line ? `:${f.line}` : ""}` : "";
+    return `- [${f.id}] ${f.severity.toUpperCase()} \u2014 ${f.title}${where} \u2192 ${f.resolution}${f.commit ? ` (${f.commit})` : ""}`;
+  });
+  return `${header}
+${rows.join("\n")}`;
+}
+function summarizeReply(text) {
+  const section = extractHandoffSection(text);
+  if (section)
+    return section.length > SUMMARY_SECTION_MAX_CHARS ? section.slice(0, SUMMARY_SECTION_MAX_CHARS) : section;
+  return text.trim().slice(-SUMMARY_TAIL_MAX_CHARS);
+}
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
+function sameCommit(a, b) {
+  if (!a || !b) return a === b;
+  return a.startsWith(b) || b.startsWith(a);
+}
 var PackRunner = class _PackRunner {
   constructor(deps, pack, initial) {
     this.deps = deps;
@@ -37465,6 +37807,10 @@ var PackRunner = class _PackRunner {
   state;
   control = "run";
   looping = false;
+  inTurn = false;
+  /** Next `runStage` continues the current stage in place (no new prompt). */
+  resumeInPlace = false;
+  mountedSkills = [];
   static create(deps, packId, task, runId) {
     const pack = getPackDefinition(packId);
     if (!pack) throw new Error(`unknown pack: ${packId}`);
@@ -37485,9 +37831,51 @@ var PackRunner = class _PackRunner {
     };
     return new _PackRunner(deps, pack, state);
   }
+  /**
+   * Rebuild a runner from the workspace ledger after a CLI restart. The
+   * in-memory run died with the process; its conversation is gone. A stage
+   * that was mid-turn is marked failed with the real reason (never left
+   * "active" forever), and the run lands paused/stalled so Resume / Retry /
+   * Skip / Abort all work again. Null when the pack id is unknown.
+   */
+  static rehydrate(deps, stored) {
+    const pack = getPackDefinition(stored.packId);
+    if (!pack) return null;
+    const interrupted = stored.stages.some((s) => s.status === "active");
+    const stages = stored.stages.map(
+      (s) => s.status === "active" ? {
+        ...s,
+        status: "failed",
+        error: "the CLI restarted while this stage was running",
+        conversationId: void 0,
+        awaitingUser: void 0
+      } : s
+    );
+    let status2 = stored.status;
+    let stalledReason = stored.stalledReason;
+    if (interrupted) {
+      status2 = "stalled";
+      stalledReason = "The CLI restarted mid-stage. Resume re-checks whether the stage committed its work; Retry stage runs it again in a fresh conversation.";
+    } else if (status2 === "running") {
+      status2 = "paused";
+      stalledReason = "The CLI restarted between stages \u2014 tap Resume to continue.";
+    }
+    const state = {
+      ...stored,
+      stages,
+      status: status2,
+      stalledReason,
+      pendingControl: void 0
+    };
+    return new _PackRunner(deps, pack, state);
+  }
   getState() {
     return this.state;
   }
+  /** Persist + post the current state without changing it (rehydration announce). */
+  async announce() {
+    await this.publish();
+  }
   /** Persist + post the current state (ledger first — it's the truth). */
   async publish() {
     this.state = { ...this.state, updatedAt: nowIso() };
@@ -37499,64 +37887,101 @@ var PackRunner = class _PackRunner {
     await this.deps.postState(this.state);
   }
   async settle(status2, stalledReason) {
-    this.state = { ...this.state, status: status2, stalledReason };
+    this.state = { ...this.state, status: status2, stalledReason, pendingControl: void 0 };
     await this.publish();
   }
+  patchStage(index, patch) {
+    const stages = this.state.stages.slice();
+    stages[index] = { ...stages[index], ...patch };
+    this.state = { ...this.state, stages };
+  }
   // ── Control surface (relay `pack_action`) ────────────────────────────────
   async applyAction(action) {
+    const status2 = this.state.status;
+    const idx = this.state.currentStage;
+    const reject = (why) => ({ state: this.state, rejected: why });
+    if (TERMINAL_PACK_STATUSES.has(status2)) return reject(`the run already finished (${status2})`);
     switch (action) {
-      case "pause":
+      case "pause": {
+        if (status2 === "paused" || status2 === "stalled") return { state: this.state };
         this.control = "pause";
-        if (this.state.status === "running") {
-          this.state = { ...this.state, status: "paused" };
-          await this.publish();
-        }
+        this.state = { ...this.state, pendingControl: "pause" };
+        await this.publish();
         break;
-      case "resume":
+      }
+      case "resume": {
+        if (status2 !== "paused" && status2 !== "stalled")
+          return reject(`nothing to resume \u2014 the run is ${status2}`);
         this.control = "run";
-        if (this.state.status === "paused" || this.state.status === "stalled") {
-          this.state = { ...this.state, status: "running", stalledReason: void 0 };
-          await this.publish();
-          void this.run();
-        }
+        const stage = this.state.stages[idx];
+        this.resumeInPlace = !!stage && (stage.awaitingUser === true || stage.status === "failed");
+        this.state = {
+          ...this.state,
+          status: "running",
+          stalledReason: void 0,
+          pendingControl: void 0
+        };
+        await this.publish();
+        void this.run();
         break;
+      }
       case "retry_stage": {
-        const idx = this.state.currentStage;
-        if (idx < this.state.stages.length) {
-          const stages = this.state.stages.slice();
-          stages[idx] = { role: stages[idx].role, name: stages[idx].name, status: "pending" };
-          this.control = "run";
-          this.state = { ...this.state, stages, status: "running", stalledReason: void 0 };
-          await this.publish();
-          void this.run();
-        }
+        if (status2 === "running" || this.inTurn)
+          return reject("the stage is still running \u2014 pause or abort first");
+        if (idx >= this.state.stages.length) return reject("no stage left to retry");
+        const prev = this.state.stages[idx];
+        this.patchStage(idx, {
+          status: "pending",
+          conversationId: void 0,
+          handoff: void 0,
+          awaitingUser: void 0,
+          startCommit: void 0,
+          attempts: prev.attempts,
+          error: prev.error
+        });
+        this.resumeInPlace = false;
+        this.control = "run";
+        this.state = {
+          ...this.state,
+          status: "running",
+          stalledReason: void 0,
+          pendingControl: void 0
+        };
+        await this.publish();
+        void this.run();
         break;
       }
       case "skip_stage": {
-        const idx = this.state.currentStage;
-        if (idx < this.state.stages.length) {
-          const stages = this.state.stages.slice();
-          stages[idx] = { ...stages[idx], status: "skipped" };
-          this.control = "run";
-          this.state = {
-            ...this.state,
-            stages,
-            currentStage: idx + 1,
-            status: "running",
-            stalledReason: void 0
-          };
-          await this.publish();
-          void this.run();
-        }
+        if (status2 === "running" || this.inTurn)
+          return reject("the stage is still running \u2014 pause or abort first");
+        if (idx >= this.state.stages.length) return reject("no stage left to skip");
+        this.patchStage(idx, { status: "skipped", awaitingUser: void 0, error: void 0 });
+        this.resumeInPlace = false;
+        this.control = "run";
+        this.state = {
+          ...this.state,
+          currentStage: idx + 1,
+          status: "running",
+          stalledReason: void 0,
+          pendingControl: void 0
+        };
+        await this.publish();
+        void this.run();
         break;
       }
-      case "abort":
+      case "abort": {
         this.control = "abort";
-        await this.deps.driver.cancel().catch(() => void 0);
-        if (!this.looping) await this.settle("aborted");
+        if (this.looping) {
+          this.state = { ...this.state, pendingControl: "abort" };
+          await this.publish();
+          await this.deps.driver.cancel().catch(() => void 0);
+        } else {
+          await this.settle("aborted");
+        }
         break;
+      }
     }
-    return this.state;
+    return { state: this.state };
   }
   // ── The loop ──────────────────────────────────────────────────────────────
   async run() {
@@ -37581,104 +38006,225 @@ var PackRunner = class _PackRunner {
       await this.settle("failed", err.message).catch(() => void 0);
     } finally {
       this.looping = false;
+      this.inTurn = false;
     }
   }
   /** Run one stage to its handoff. True = advanced; false = run settled. */
   async runStage(index) {
     const stageDef = this.pack.stages[index];
+    const inPlace = this.resumeInPlace;
+    this.resumeInPlace = false;
     const startedMs = Date.now();
-    const startSha = await this.deps.gates.head();
-    let stages = this.state.stages.slice();
-    stages[index] = { ...stages[index], status: "active" };
-    this.state = { ...this.state, stages, status: "running" };
     try {
-      const conversationId = await this.deps.driver.newConversation();
-      stages = this.state.stages.slice();
-      stages[index] = { ...stages[index], conversationId };
-      this.state = { ...this.state, stages };
-      await this.publish();
-      this.deps.driver.mountSkills(stageDef.skillIds);
-      const previous = this.previousHandoff(index);
-      const prompt = composeStagePrompt(this.pack, index, this.state.task, previous);
-      const displayLine = `\u25B6 ${this.pack.name} \u2014 stage ${index + 1}/${this.pack.stages.length}: ${stageDef.name}`;
-      let reply = await this.deps.driver.runTurn(prompt, displayLine);
-      if (this.control === "abort") {
+      let startSha;
+      let turn;
+      if (inPlace) {
+        startSha = this.state.stages[index].startCommit ?? await this.deps.gates.head();
+        this.patchStage(index, { status: "active", awaitingUser: void 0, error: void 0 });
+        this.state = { ...this.state, status: "running" };
+        await this.publish();
+        turn = { text: "", awaitingUser: false };
+      } else {
+        startSha = await this.deps.gates.head();
+        const prevStage = this.state.stages[index];
+        const attempt = (prevStage.attempts ?? 0) + 1;
+        const previousAttemptError = attempt > 1 ? prevStage.error : void 0;
+        const startCommit = startSha ? await this.deps.gates.canonicalCommit(startSha) : null;
+        this.patchStage(index, {
+          status: "active",
+          attempts: attempt,
+          startCommit: startCommit ?? void 0,
+          conversationId: void 0,
+          handoff: void 0,
+          awaitingUser: void 0,
+          error: void 0
+        });
+        if (index === 0 && !this.state.baseCommit && startCommit) {
+          this.state = { ...this.state, baseCommit: startCommit };
+        }
+        this.state = { ...this.state, status: "running" };
+        const conversationId = await this.deps.driver.newConversation();
+        this.patchStage(index, { conversationId });
+        await this.publish();
+        this.swapSkills(stageDef.skillIds);
+        const prompt = composeStagePrompt(this.pack, index, this.state.task, {
+          baseCommit: this.state.baseCommit,
+          prior: this.priorOutcomes(index),
+          attempt,
+          previousAttemptError
+        });
+        const displayLine = `\u25B6 ${this.pack.name} \u2014 stage ${index + 1}/${this.pack.stages.length}: ${stageDef.name}`;
+        turn = await this.drive(prompt, displayLine);
+      }
+      if (this.aborted()) {
         await this.settle("aborted");
         return false;
       }
+      if (turn.awaitingUser) return this.awaitUser(index);
       const commitOptional = stageDef.requiresCommit === false;
+      let text = turn.text;
       let endSha = await this.deps.gates.head();
-      if (!endSha || endSha === startSha) {
-        if (commitOptional && reply.trim().length > 0) {
-          const reviewedCommit = startSha ? await this.deps.gates.canonicalCommit(startSha) : null;
-          const handoff2 = {
-            commit: reviewedCommit ?? "(no changes)",
-            summary: reply.trim().slice(-SUMMARY_MAX_CHARS),
-            diffStat: "reviewed \u2014 no changes needed",
-            durationMs: Date.now() - startedMs
-          };
-          return this.recordHandoff(index, stageDef.role, handoff2);
+      if (!endSha || sameCommit(endSha, startSha)) {
+        if (commitOptional && text.trim().length > 0) {
+          return this.recordHandoff(
+            index,
+            stageDef,
+            await this.noChangeHandoff(startSha, text, startedMs)
+          );
         }
-        reply = await this.deps.driver.runTurn(NUDGE_PROMPT, "\u25B6 Waiting for the stage commit\u2026");
+        if (!this.state.stages[index].conversationId) {
+          return this.stall(
+            index,
+            "stage produced no commit \u2014 Retry stage to run it again in a fresh conversation"
+          );
+        }
+        const nudged = await this.drive(NUDGE_PROMPT, "\u25B6 Waiting for the stage commit\u2026");
+        if (this.aborted()) {
+          await this.settle("aborted");
+          return false;
+        }
+        if (nudged.awaitingUser) return this.awaitUser(index);
+        text = nudged.text.trim().length > 0 ? nudged.text : text;
         endSha = await this.deps.gates.head();
-        if (!endSha || endSha === startSha) {
-          if (commitOptional && reply.trim().length > 0) {
-            const reviewedCommit = startSha ? await this.deps.gates.canonicalCommit(startSha) : null;
-            return this.recordHandoff(index, stageDef.role, {
-              commit: reviewedCommit ?? "(no changes)",
-              summary: reply.trim().slice(-SUMMARY_MAX_CHARS),
-              diffStat: "reviewed \u2014 no changes needed",
-              durationMs: Date.now() - startedMs
-            });
+        if (!endSha || sameCommit(endSha, startSha)) {
+          if (commitOptional && text.trim().length > 0) {
+            return this.recordHandoff(
+              index,
+              stageDef,
+              await this.noChangeHandoff(startSha, text, startedMs)
+            );
           }
-          return this.stall(index, "stage produced no commit", reply);
+          return this.stall(index, "stage produced no commit", text);
         }
       }
       const commit = await this.deps.gates.canonicalCommit(endSha);
-      if (!commit) return this.stall(index, "stage HEAD did not resolve to a commit", reply);
+      if (!commit) return this.stall(index, "stage HEAD did not resolve to a commit", text);
       const handoff = {
         commit,
-        summary: reply.trim().slice(-SUMMARY_MAX_CHARS),
+        summary: summarizeReply(text),
         diffStat: startSha ? await this.deps.gates.diffStat(startSha, endSha) : "",
         checks: await this.deps.gates.runChecks() ?? void 0,
         durationMs: Date.now() - startedMs
       };
-      return this.recordHandoff(index, stageDef.role, handoff);
+      if (stageDef.producesFindings) {
+        Object.assign(handoff, await this.captureFindings(startSha, endSha));
+      }
+      return this.recordHandoff(index, stageDef, handoff);
     } catch (err) {
-      if (this.control === "abort") {
+      if (this.aborted()) {
         await this.settle("aborted");
         return false;
       }
       return this.stall(index, err.message);
     }
   }
+  /** Read through a method: `control` flips from another call while a turn is
+   *  awaited, which TS's property narrowing would otherwise hide. */
+  aborted() {
+    return this.control === "abort";
+  }
+  async drive(prompt, displayLine) {
+    this.inTurn = true;
+    try {
+      return await this.deps.driver.runTurn(prompt, displayLine);
+    } finally {
+      this.inTurn = false;
+    }
+  }
+  swapSkills(next) {
+    const stale = this.mountedSkills.filter((id) => !next.includes(id));
+    const fresh = next.filter((id) => !this.mountedSkills.includes(id));
+    if (stale.length > 0) this.deps.driver.unmountSkills(stale);
+    if (fresh.length > 0) this.deps.driver.mountSkills(fresh);
+    this.mountedSkills = next.slice();
+  }
+  async noChangeHandoff(startSha, text, startedMs) {
+    const reviewedCommit = startSha ? await this.deps.gates.canonicalCommit(startSha) : null;
+    return {
+      commit: reviewedCommit ?? "(no changes)",
+      summary: summarizeReply(text),
+      diffStat: "reviewed \u2014 no changes needed",
+      durationMs: Date.now() - startedMs
+    };
+  }
+  /**
+   * Parse the stage's `PACK_FINDINGS_FILE` into the handoff. Only a file the
+   * stage itself touched counts — a stale one left by an earlier run must not
+   * masquerade as this review's verdict. Every failure path leaves an honest
+   * `findingsNote`; none of them stalls the run.
+   */
+  async captureFindings(startSha, endSha) {
+    try {
+      if (startSha) {
+        const changed = await this.deps.gates.changedFiles(startSha, endSha);
+        if (!changed.includes(PACK_FINDINGS_FILE)) {
+          return {
+            findingsNote: `${PACK_FINDINGS_FILE} was not written by this stage \u2014 no structured findings`
+          };
+        }
+      }
+      const raw = await this.deps.gates.readFile(PACK_FINDINGS_FILE);
+      if (raw === null)
+        return { findingsNote: `no ${PACK_FINDINGS_FILE} \u2014 the stage left no structured findings` };
+      const parsed = parsePackFindings(raw);
+      if (!parsed.ok) return { findingsNote: `${PACK_FINDINGS_FILE}: ${parsed.error}` };
+      const notes = [];
+      if (parsed.value.findings.length === 0 && parsed.value.checked) {
+        notes.push(`no findings; checked: ${parsed.value.checked.join(", ")}`);
+      }
+      if (parsed.value.note) notes.push(parsed.value.note);
+      return {
+        findings: parsed.value.findings,
+        ...notes.length > 0 ? { findingsNote: notes.join(" \u2014 ") } : {}
+      };
+    } catch (err) {
+      return { findingsNote: `could not read ${PACK_FINDINGS_FILE}: ${err.message}` };
+    }
+  }
   /** Mark a stage `done` with its handoff, persist, and advance. */
-  async recordHandoff(index, role, handoff) {
-    const stages = this.state.stages.slice();
-    stages[index] = { ...stages[index], status: "done", handoff };
-    this.state = { ...this.state, stages, currentStage: index + 1 };
+  async recordHandoff(index, stageDef, handoff) {
+    this.patchStage(index, { status: "done", handoff, awaitingUser: void 0, error: void 0 });
+    this.state = { ...this.state, currentStage: index + 1 };
     try {
-      this.deps.ledger.saveStageHandoff(this.state.runId, index, role, handoff);
+      this.deps.ledger.saveStageHandoff(this.state.runId, index, stageDef.role, handoff);
     } catch (err) {
       this.deps.log(`pack handoff save failed: ${err.message}`);
     }
     await this.publish();
     return true;
   }
+  /** The stage asked the user something: park the run, keep the conversation. */
+  async awaitUser(index) {
+    const name = this.state.stages[index].name;
+    this.patchStage(index, { awaitingUser: true });
+    this.control = "pause";
+    await this.settle(
+      "paused",
+      `${name} asked you a question \u2014 answer it in the stage chat, then tap Resume.`
+    );
+    this.deps.log(
+      `pack run ${this.state.runId} paused at stage ${index + 1}: awaiting the user's answer`
+    );
+    return false;
+  }
   async stall(index, reason, lastReply) {
-    const stages = this.state.stages.slice();
-    stages[index] = { ...stages[index], status: "failed", error: reason };
-    this.state = { ...this.state, stages };
-    await this.settle("stalled", lastReply ? `${reason} \u2014 last reply: ${lastReply.slice(-300)}` : reason);
+    this.patchStage(index, { status: "failed", error: reason, awaitingUser: void 0 });
+    await this.settle(
+      "stalled",
+      lastReply ? `${reason} \u2014 last reply: ${lastReply.slice(-300)}` : reason
+    );
     this.deps.log(`pack run ${this.state.runId} stalled at stage ${index + 1}: ${reason}`);
     return false;
   }
-  previousHandoff(index) {
-    for (let i = index - 1; i >= 0; i--) {
+  priorOutcomes(index) {
+    const out2 = [];
+    for (let i = 0; i < index; i++) {
       const s = this.state.stages[i];
-      if (s.status === "done" && s.handoff) return { role: s.role, handoff: s.handoff };
+      if (s.status === "done" && s.handoff)
+        out2.push({ role: s.role, name: s.name, status: "done", handoff: s.handoff });
+      else if (s.status === "skipped") out2.push({ role: s.role, name: s.name, status: "skipped" });
     }
-    return null;
+    return out2;
   }
 };
 
@@ -37692,7 +38238,7 @@ function getActivePackRunner() {
 }
 
 // src/packs/handlers.ts
-var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "aborted", "failed"]);
+var TERMINAL_STATUSES = TERMINAL_PACK_STATUSES;
 var PACK_ACTIONS = /* @__PURE__ */ new Set(["pause", "resume", "retry_stage", "skip_stage", "abort"]);
 function buildPackRunnerDeps(ctx) {
   const cwd = ctx.opts.cwd;
@@ -37712,10 +38258,10 @@ function buildPackRunnerDeps(ctx) {
         ctx.history.appendUserPrompt(displayLine);
         await ctx.client.prompt(prompt);
         const text = ctx.streaming.getCurrentText();
-        await ctx.streaming.closeTurnWithInteractiveDetection();
+        const awaitingUser = await ctx.streaming.closeTurnWithInteractiveDetection();
         ctx.history.appendAgentReply(text);
         await ctx.history.flush();
-        return text;
+        return { text, awaitingUser };
       },
       cancel: () => ctx.client.cancel(),
       mountSkills: (skillIds) => {
@@ -37726,16 +38272,27 @@ function buildPackRunnerDeps(ctx) {
             log.warn("packs", `skill mount failed for ${id}: ${err.message}`);
           }
         }
+      },
+      unmountSkills: (skillIds) => {
+        for (const id of skillIds) {
+          try {
+            configureSkill("remove", id);
+          } catch (err) {
+            log.warn("packs", `skill unmount failed for ${id}: ${err.message}`);
+          }
+        }
       }
     },
     gates: {
       head: () => gitHead(run, cwd),
       canonicalCommit: (sha) => canonicalCommit(run, cwd, sha),
       diffStat: (from, to) => diffStat(run, cwd, from, to),
+      changedFiles: (from, to) => changedFiles(run, cwd, from, to),
       runChecks: async () => {
         const command2 = detectChecksCommand(cwd);
         return command2 ? runChecks(run, cwd, command2) : null;
-      }
+      },
+      readFile: async (relPath) => readWorkspaceFile(cwd, relPath)
     },
     ledger: {
       saveRun: (state) => saveRun(cwd, state),
@@ -37753,19 +38310,38 @@ function buildPackRunnerDeps(ctx) {
     log: (message) => log.info("packs", message)
   };
 }
+async function ensureRunner(ctx) {
+  const active2 = getActivePackRunner();
+  if (active2) return active2;
+  const stored = loadLatestRun(ctx.opts.cwd);
+  if (!stored || TERMINAL_STATUSES.has(stored.status)) return null;
+  const runner = PackRunner.rehydrate(buildPackRunnerDeps(ctx), stored);
+  if (!runner) return null;
+  setActivePackRunner(runner);
+  log.info(
+    "packs",
+    `rehydrated run ${stored.runId} from the ledger (was ${stored.status}) \u2192 ${runner.getState().status}`
+  );
+  await runner.announce();
+  return runner;
+}
 var packStartH = async (ctx) => {
   const payload = ctx.cmd.payload;
   const packId = typeof payload?.packId === "string" ? payload.packId : "";
   const task = typeof payload?.task === "string" ? payload.task.trim() : "";
   if (!isPackId(packId)) {
-    await ctx.relay.sendResult(ctx.cmd.id, "failed", { error: `unknown pack: ${packId || "(none)"}` });
+    await ctx.relay.sendResult(ctx.cmd.id, "failed", {
+      error: `unknown pack: ${packId || "(none)"}`
+    });
     return;
   }
   if (task.length === 0) {
-    await ctx.relay.sendResult(ctx.cmd.id, "failed", { error: "pack_start requires a non-empty task" });
+    await ctx.relay.sendResult(ctx.cmd.id, "failed", {
+      error: "pack_start requires a non-empty task"
+    });
     return;
   }
-  const existing = getActivePackRunner();
+  const existing = await ensureRunner(ctx);
   if (existing && !TERMINAL_STATUSES.has(existing.getState().status)) {
     await ctx.relay.sendResult(ctx.cmd.id, "failed", {
       error: "a pack run is already active on this session \u2014 pause/abort it first",
@@ -37788,10 +38364,12 @@ var packActionH = async (ctx) => {
   const payload = ctx.cmd.payload;
   const action = typeof payload?.action === "string" ? payload.action : "";
   if (!PACK_ACTIONS.has(action)) {
-    await ctx.relay.sendResult(ctx.cmd.id, "failed", { error: `unknown pack action: ${action || "(none)"}` });
+    await ctx.relay.sendResult(ctx.cmd.id, "failed", {
+      error: `unknown pack action: ${action || "(none)"}`
+    });
     return;
   }
-  const runner = getActivePackRunner();
+  const runner = await ensureRunner(ctx);
   if (!runner) {
     await ctx.relay.sendResult(ctx.cmd.id, "failed", {
       error: "no active pack run in this session",
@@ -37799,11 +38377,20 @@ var packActionH = async (ctx) => {
     });
     return;
   }
-  const state = await runner.applyAction(action);
-  await ctx.relay.sendResult(ctx.cmd.id, "completed", { state });
+  const outcome = await runner.applyAction(action);
+  if (outcome.rejected) {
+    log.info("packs", `pack_action ${action} rejected: ${outcome.rejected}`);
+    await ctx.relay.sendResult(ctx.cmd.id, "failed", {
+      error: outcome.rejected,
+      state: outcome.state
+    });
+    return;
+  }
+  await ctx.relay.sendResult(ctx.cmd.id, "completed", { state: outcome.state });
 };
 var packStatusH = async (ctx) => {
-  const state = getActivePackRunner()?.getState() ?? loadLatestRun(ctx.opts.cwd);
+  const runner = await ensureRunner(ctx);
+  const state = runner?.getState() ?? loadLatestRun(ctx.opts.cwd);
   await ctx.relay.sendResult(ctx.cmd.id, "completed", { state });
 };
 
@@ -40600,6 +41187,7 @@ async function runAcpSession(opts) {
   };
   process.once("SIGINT", () => void shutdown("SIGINT"));
   process.once("SIGTERM", () => void shutdown("SIGTERM"));
+  relay.setOnSessionGone(() => void shutdown("SIGTERM"));
   process.once("SIGHUP", () => void shutdown("SIGHUP"));
   await new Promise(() => {
   });
@@ -42730,6 +43318,7 @@ async function runBatonSession(opts) {
   process.once("SIGINT", onSignal);
   process.once("SIGTERM", onSignal);
   process.once("SIGHUP", onSignal);
+  relay.setOnSessionGone(onSignal);
   showInfo(`Starting ${opts.agent} baton (local) \u2014 native TUI + mobile take-control\u2026`);
   await controller.begin();
   relay.start();
@@ -43170,6 +43759,9 @@ async function start(requestedAgent, presetSession) {
     })
   );
   ctx.relay = relay;
+  relay.setOnSessionGone(() => {
+    void sigintHandler();
+  });
   void beadsReady.then((started) => {
     ctx.beads = started;
   });
@@ -46422,7 +47014,7 @@ async function autoUpgradeBeforeCriticalCommand() {
   if (process.env.NODE_ENV === "test") return;
   if (process.env.CODEAM_DISABLE_UPDATE_CHECK === "1") return;
   if (process.env.CI) return;
-  const current2 = true ? "2.75.7" : null;
+  const current2 = true ? "2.75.9" : null;
   if (!current2) return;
   const cache = readCache();
   const fresh = cache && Date.now() - cache.fetchedAt < TTL_MS;
@@ -46439,7 +47031,7 @@ function checkForUpdates() {
   if (process.env.CODEAM_DISABLE_UPDATE_CHECK === "1") return;
   if (process.env.CI) return;
   if (!process.stdout.isTTY) return;
-  const current2 = true ? "2.75.7" : null;
+  const current2 = true ? "2.75.9" : null;
   if (!current2) return;
   const cache = readCache();
   const fresh = cache && Date.now() - cache.fetchedAt < TTL_MS;
@@ -46462,7 +47054,7 @@ var SELF_UPDATE_INSTALL_TIMEOUT_MS = 18e4;
 var SELF_UPDATE_LS_TIMEOUT_MS = 15e3;
 var SUDO_PREFLIGHT_TIMEOUT_MS = 5e3;
 function currentCliVersion() {
-  return true ? "2.75.7" : null;
+  return true ? "2.75.9" : null;
 }
 async function installedVersion(deps) {
   const ls = await deps.run(
@@ -48202,7 +48794,7 @@ function checkChokidar() {
 }
 async function doctor(args2 = []) {
   const json = args2.includes("--json");
-  const cliVersion = true ? "2.75.7" : "0.0.0-dev";
+  const cliVersion = true ? "2.75.9" : "0.0.0-dev";
   const apiBase2 = resolveApiBaseUrl();
   const diagnosticId = (0, import_node_crypto12.randomUUID)();
   log.info("doctor", `run id=${diagnosticId} cli=${cliVersion}`);
@@ -48726,7 +49318,7 @@ async function mcpWarm(argv = [], opts = {}) {
 // src/commands/version.ts
 var import_picocolors15 = __toESM(require("picocolors"));
 function version2() {
-  const v = true ? "2.75.7" : "unknown";
+  const v = true ? "2.75.9" : "unknown";
   console.log(`${import_picocolors15.default.bold("codeam-cli")} ${import_picocolors15.default.cyan(v)}`);
 }