codeam-cli 2.61.91 → 2.61.92

package/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to `codeam-cli` are documented here.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.61.91] — 2026-08-08
+
+### Fixed
+
+- **cli:** Self-heal the Headroom proxy before every turn (no more ConnectionRefused after resume) (#600)
+
 ## [2.61.90] — 2026-08-08
 
 ### Fixed

package/dist/index.js

@@ -90,11 +90,11 @@ var require_src = __commonJS({
 });
 
 // src/integrations/stdio-proxy.ts
-var import_node_child_process31, import_node_readline3, RESTART_CHECK_INTERVAL_MS, SIGKILL_ESCALATION_MS, TOOL_CALL_TIMEOUT_MS, REPLAY_INIT_ID, RestartableStdioProxy;
+var import_node_child_process32, import_node_readline3, RESTART_CHECK_INTERVAL_MS, SIGKILL_ESCALATION_MS, TOOL_CALL_TIMEOUT_MS, REPLAY_INIT_ID, RestartableStdioProxy;
 var init_stdio_proxy = __esm({
   "src/integrations/stdio-proxy.ts"() {
     "use strict";
-    import_node_child_process31 = require("child_process");
+    import_node_child_process32 = require("child_process");
     import_node_readline3 = __toESM(require("readline"));
     RESTART_CHECK_INTERVAL_MS = 3e4;
     SIGKILL_ESCALATION_MS = 2e3;
@@ -271,7 +271,7 @@ var init_stdio_proxy = __esm({
       }
       async spawnChild(stdout, preResolved) {
         const spec = preResolved ?? await this.opts.spawnSpec();
-        const spawn44 = this.opts.spawnImpl ?? import_node_child_process31.spawn;
+        const spawn44 = this.opts.spawnImpl ?? import_node_child_process32.spawn;
         const child = spawn44(spec.command, spec.args, {
           env: { ...process.env, ...spec.env },
           // env only — never argv
@@ -2635,6 +2635,144 @@ function normalizeGuardrailPolicy(raw) {
   return out2;
 }
 
+// ../../packages/shared/src/packs/roles.ts
+var SPECIFIER_PROMPT = `# Role: Specifier
+
+You turn the user's task into a precise, testable specification the rest of the pipeline implements against. You do NOT write implementation code.
+
+Method:
+1. Read the task and explore the relevant parts of the codebase until you understand the real problem, the desired outcome, and the constraints the code imposes.
+2. Write the specification to \`SPEC.pack.md\` at the repo root:
+   - **Problem** \u2014 what is wrong or missing, and for whom.
+   - **Outcome** \u2014 what must be true when this is done.
+   - **Acceptance criteria** \u2014 a numbered checklist of observable, testable conditions. Each criterion must be verifiable by a test or a concrete manual check. They must fully cover the outcome.
+   - **Out of scope** \u2014 what this task deliberately does not touch.
+   - **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".
+
+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
+
+You implement the task with test-driven discipline. You are the only stage that adds behavior.
+
+Method:
+1. Read the task \u2014 and \`SPEC.pack.md\` if a Specifier stage produced one; its acceptance criteria are your contract. Without a spec, derive the minimal criteria from the task itself before coding.
+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.
+
+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
+
+You are a skeptical senior reviewer with fresh eyes \u2014 you did NOT write this code, and your job is to find what's wrong, not to approve it. You also own architectural cleanliness for this change.
+
+Method:
+1. Read the task, \`SPEC.pack.md\` (when present), and the diff of the pipeline's commits (\`git log\` + \`git diff\` against the state before the pipeline's first commit). Read enough surrounding code to judge in context.
+2. Audit, in priority order:
+   - **Correctness** \u2014 logic, edge cases, error paths. For each acceptance criterion: point to the test that proves it, and check the test would FAIL if the behavior broke.
+   - **Scope** \u2014 anything beyond the task is flagged and reverted unless it is load-bearing.
+   - **Design** \u2014 duplication, dead code, needless complexity, dependency direction, encapsulation. Verify every API/library call actually exists in the project's dependencies.
+   - **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).`;
+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.
+
+Handoff bar: the report is committed; every verdict carries evidence; the conclusion is honest about anything unverified.`;
+
+// ../../packages/shared/src/packs/registry.ts
+var PACK_REGISTRY = {
+  "quick-pack": {
+    id: "quick-pack",
+    name: "Quick Pack",
+    tagline: "Implement, then a fresh-eyes review \u2014 the tight loop.",
+    gate: "free",
+    stages: [
+      {
+        role: "coder",
+        name: "Coder",
+        description: "Implements the task with tests, TDD-first.",
+        skillIds: ["spec-driven-development"],
+        prompt: CODER_PROMPT
+      },
+      {
+        role: "reviewer",
+        name: "Reviewer",
+        description: "Skeptical review in a fresh context \u2014 finds and fixes what the coder missed.",
+        skillIds: ["code-review", "code-naming"],
+        prompt: REVIEWER_PROMPT
+      }
+    ]
+  },
+  "full-pack": {
+    id: "full-pack",
+    name: "Full Pack",
+    tagline: "Spec \u2192 implement \u2192 review \u2192 verify. Every quality gate, one run.",
+    gate: "pro",
+    stages: [
+      {
+        role: "specifier",
+        name: "Specifier",
+        description: "Turns the task into testable acceptance criteria before any code.",
+        skillIds: ["spec-driven-development"],
+        prompt: SPECIFIER_PROMPT
+      },
+      {
+        role: "coder",
+        name: "Coder",
+        description: "Implements the acceptance criteria with tests, TDD-first.",
+        skillIds: [],
+        prompt: CODER_PROMPT
+      },
+      {
+        role: "reviewer",
+        name: "Reviewer",
+        description: "Audits correctness, scope, design, and conventions with fresh eyes.",
+        skillIds: ["code-review", "code-naming"],
+        prompt: REVIEWER_PROMPT
+      },
+      {
+        role: "qa",
+        name: "QA",
+        description: "Verifies every acceptance criterion end to end and writes the final report.",
+        skillIds: [],
+        prompt: QA_PROMPT
+      }
+    ]
+  }
+};
+function isPackId(id) {
+  return Object.prototype.hasOwnProperty.call(PACK_REGISTRY, id);
+}
+function getPackDefinition(id) {
+  return isPackId(id) ? PACK_REGISTRY[id] : null;
+}
+
+// ../../packages/shared/src/packs/workflow-article.ts
+var PACK_WORKFLOW_ARTICLE = `## Pipeline rules (you are one stage of an assembly line)
+
+You are ONE specialist role in a multi-role pipeline running on this repository. Other specialist roles ran before you and/or run after you, each in a separate conversation. Follow these rules exactly:
+
+- **Do only your role's job.** The next stage exists for a reason \u2014 don't do its work, and don't redo a previous stage's work unless your role explicitly calls for correcting it.
+- **Work from the handoff.** The previous stage's handoff (commit + summary) is your input. Start by reading the current state of the working tree \u2014 it already contains all prior stages' work.
+- **Commit your work when your stage is complete.** One or more focused commits; the final state of the tree IS your handoff to the next stage. End every commit message with your role byline on its own line: \`By <role>.\`
+- **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.`;
+
 // ../../packages/shared/src/api-url.ts
 var DEFAULT_API_BASE_URL = "https://api.codeagent-mobile.com";
 var DEV_API_BASE_URL = "https://dev-api.codeagent-mobile.com";
@@ -2781,7 +2919,12 @@ var USER_EVENTS = {
    *  toast when the review runs server-side (Inngest). Mobile-only surface,
    *  produced by api-v2 (the CLI neither produces nor consumes it). Mirrored in
    *  repo A. */
-  PR_REVIEW_LAUNCH: "pr_review_launch"
+  PR_REVIEW_LAUNCH: "pr_review_launch",
+  /** Agent Packs — full `PackRunState` republished by the backend on every
+   *  pipeline transition (stage start/done, pause, stall, completion). CLI
+   *  posts to /api/packs/events; mobile's pack.store renders the pipeline.
+   *  Mirrored in repo A's app-shared events.ts. */
+  PACK_STATE: "pack_state"
 };
 
 // ../../packages/shared/src/preview-prompts.ts
@@ -2972,11 +3115,11 @@ function quiet(fn) {
     log.debug(TAG, "ignored sync error", err);
   }
 }
-function rmIfExistsQuiet(path87) {
+function rmIfExistsQuiet(path89) {
   try {
-    fs2.rmSync(path87, { force: true });
+    fs2.rmSync(path89, { force: true });
   } catch (err) {
-    log.debug(TAG, `rmIfExists failed for ${path87}`, err);
+    log.debug(TAG, `rmIfExists failed for ${path89}`, err);
   }
 }
 function killQuiet(target, signal = "SIGTERM") {
@@ -3160,8 +3303,8 @@ function createGetModuleFromFilename(basePath = process.argv[1] ? (0, import_pat
     return decodedFile;
   };
 }
-function normalizeWindowsPath(path87) {
-  return path87.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
+function normalizeWindowsPath(path89) {
+  return path89.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
 }
 
 // ../../node_modules/@posthog/core/dist/featureFlagUtils.mjs
@@ -5641,9 +5784,9 @@ async function addSourceContext(frames) {
   LRU_FILE_CONTENTS_CACHE.reduce();
   return frames;
 }
-function getContextLinesFromFile(path87, ranges, output) {
+function getContextLinesFromFile(path89, ranges, output) {
   return new Promise((resolve9) => {
-    const stream = (0, import_node_fs.createReadStream)(path87);
+    const stream = (0, import_node_fs.createReadStream)(path89);
     const lineReaded = (0, import_node_readline.createInterface)({
       input: stream
     });
@@ -5658,7 +5801,7 @@ function getContextLinesFromFile(path87, ranges, output) {
     let rangeStart = range[0];
     let rangeEnd = range[1];
     function onStreamError() {
-      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path87, 1);
+      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path89, 1);
       lineReaded.close();
       lineReaded.removeAllListeners();
       destroyStreamAndResolve();
@@ -5719,8 +5862,8 @@ function clearLineContext(frame) {
   delete frame.context_line;
   delete frame.post_context;
 }
-function shouldSkipContextLinesForFile(path87) {
-  return path87.startsWith("node:") || path87.endsWith(".min.js") || path87.endsWith(".min.cjs") || path87.endsWith(".min.mjs") || path87.startsWith("data:");
+function shouldSkipContextLinesForFile(path89) {
+  return path89.startsWith("node:") || path89.endsWith(".min.js") || path89.endsWith(".min.cjs") || path89.endsWith(".min.mjs") || path89.startsWith("data:");
 }
 function shouldSkipContextLinesForFrame(frame) {
   if (void 0 !== frame.lineno && frame.lineno > MAX_CONTEXTLINES_LINENO) return true;
@@ -7874,7 +8017,7 @@ function readAnonId() {
 }
 function superProperties() {
   return {
-    cliVersion: true ? "2.61.91" : "0.0.0-dev",
+    cliVersion: true ? "2.61.92" : "0.0.0-dev",
     nodeVersion: process.version,
     platform: process.platform,
     arch: process.arch,
@@ -8055,7 +8198,7 @@ var os4 = __toESM(require("os"));
 // package.json
 var package_default = {
   name: "codeam-cli",
-  version: "2.61.91",
+  version: "2.61.92",
   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",
@@ -9360,7 +9503,7 @@ 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.61.91" ? { ideVersion: "2.61.91" } : {}
+      ..."2.61.92" ? { ideVersion: "2.61.92" } : {}
     }).then(() => log.trace("relay", `heartbeat ok online=${online}`)).catch((err) => log.trace("relay", `heartbeat failed online=${online}`, err));
   }
   /**
@@ -15969,8 +16112,8 @@ function pickLine(obj) {
 function toHunk(raw, groupSeverity) {
   if (!raw || typeof raw !== "object") return null;
   const o = raw;
-  const path87 = asString(pick(o, ["file_path", "filePath", "file", "path", "filename", "fileName"])) ?? asString(pick(o, ["location"])?.path);
-  if (!path87) return null;
+  const path89 = asString(pick(o, ["file_path", "filePath", "file", "path", "filename", "fileName"])) ?? asString(pick(o, ["location"])?.path);
+  if (!path89) return null;
   const message = asString(
     pick(o, [
       "comment",
@@ -15987,7 +16130,7 @@ function toHunk(raw, groupSeverity) {
   const severity = normSeverity(pick(o, ["severity", "level", "priority", "impact"])) ?? normSeverity(groupSeverity);
   const locObj = pick(o, ["location"]) ?? o;
   return {
-    path: path87.trim(),
+    path: path89.trim(),
     line: pickLine(o) ?? pickLine(locObj),
     severity,
     message: (title && message ? `${title}: ${message}` : title || message).trim() || "(no message)"
@@ -16070,10 +16213,10 @@ function parsePlain(stdout) {
   for (const line of stdout.split(/\r?\n/)) {
     const m = line.match(HUNK_LINE_RE);
     if (!m) continue;
-    const [, path87, lineNo, sevToken, message] = m;
-    if (!path87 || !lineNo || !message) continue;
+    const [, path89, lineNo, sevToken, message] = m;
+    if (!path89 || !lineNo || !message) continue;
     hunks.push({
-      path: path87.trim(),
+      path: path89.trim(),
       line: Number(lineNo),
       severity: sevToken ? SEVERITY_MAP[sevToken.toLowerCase()] : void 0,
       message: message.trim().replace(/^[*-]\s+/, "")
@@ -20533,7 +20676,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.61.91" : null;
+  const current2 = true ? "2.61.92" : null;
   if (!current2) return;
   const cache = readCache();
   const fresh = cache && Date.now() - cache.fetchedAt < TTL_MS;
@@ -20550,7 +20693,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.61.91" : null;
+  const current2 = true ? "2.61.92" : null;
   if (!current2) return;
   const cache = readCache();
   const fresh = cache && Date.now() - cache.fetchedAt < TTL_MS;
@@ -20570,7 +20713,7 @@ var SELF_UPDATE_INTERVAL_MS = 60 * 60 * 1e3;
 var SELF_UPDATE_VIEW_TIMEOUT_MS = 3e4;
 var SELF_UPDATE_INSTALL_TIMEOUT_MS = 18e4;
 function currentCliVersion() {
-  return true ? "2.61.91" : null;
+  return true ? "2.61.92" : null;
 }
 function runCmd(cmd, args2, timeoutMs) {
   return new Promise((resolve9) => {
@@ -25926,13 +26069,13 @@ function resolveGlobalNodeModulesDir(opts) {
 var STALE_STAGING_AGE_MS = CLI_UPDATE_INSTALL_TIMEOUT_MS;
 function sweepStaleCliStagingDirs(nodeModulesDir, now = Date.now(), deps) {
   if (!nodeModulesDir) return 0;
-  const readdirSync13 = deps?.readdirSync ?? fs62.readdirSync;
+  const readdirSync14 = deps?.readdirSync ?? fs62.readdirSync;
   const statSync17 = deps?.statSync ?? fs62.statSync;
   const rmSync9 = deps?.rmSync ?? fs62.rmSync;
   let removed = 0;
   let entries;
   try {
-    entries = readdirSync13(nodeModulesDir);
+    entries = readdirSync14(nodeModulesDir);
   } catch {
     return 0;
   }
@@ -26815,11 +26958,11 @@ function resolveTokenValue(args2) {
   }
   const fileFlag = args2.find((a) => a.startsWith("--token-file="));
   if (fileFlag) {
-    const path87 = fileFlag.slice("--token-file=".length);
+    const path89 = fileFlag.slice("--token-file=".length);
     try {
-      const content = fs63.readFileSync(path87, "utf8").trim();
-      if (content.length === 0) fail(`--token-file ${path87} is empty`);
-      rmIfExistsQuiet(path87);
+      const content = fs63.readFileSync(path89, "utf8").trim();
+      if (content.length === 0) fail(`--token-file ${path89} is empty`);
+      rmIfExistsQuiet(path89);
       return content;
     } catch (err) {
       fail(`Could not read --token-file: ${err.message}`);
@@ -27465,14 +27608,14 @@ function defaultSdkDir() {
   return resolveSdkDirViaRequire();
 }
 function resolveClaudeNativeBinary(deps = {}) {
-  const existsSync28 = deps.existsSync ?? import_fs6.default.existsSync;
+  const existsSync29 = deps.existsSync ?? import_fs6.default.existsSync;
   const platformKey = deps.platformKey ?? currentPlatformKey();
   const sdkDir = deps.sdkDir !== void 0 ? deps.sdkDir : defaultSdkDir();
   if (!sdkDir) return null;
   const scopeDir = import_path8.default.dirname(sdkDir);
   const binName = platformKey.startsWith("win32-") ? "claude.exe" : "claude";
   const candidate = import_path8.default.join(scopeDir, `claude-agent-sdk-${platformKey}`, binName);
-  return existsSync28(candidate) ? candidate : null;
+  return existsSync29(candidate) ? candidate : null;
 }
 var realSleep = (ms) => new Promise((resolve9) => setTimeout(resolve9, ms));
 async function waitForClaudeNativeBinary(opts = {}) {
@@ -27523,18 +27666,18 @@ async function waitForCommandOnPath(cmd, opts = {}) {
   return check();
 }
 function resolveCursorAgentBinary(deps = {}) {
-  const existsSync28 = deps.existsSync ?? import_fs6.default.existsSync;
+  const existsSync29 = deps.existsSync ?? import_fs6.default.existsSync;
   const platform3 = deps.platform ?? process.platform;
   const env = deps.env ?? process.env;
   if (platform3 === "win32") {
     const localAppData = env.LOCALAPPDATA;
     if (!localAppData) return null;
     const exe = import_path8.default.win32.join(localAppData, "cursor-agent", "cursor-agent.exe");
-    return existsSync28(exe) ? exe : null;
+    return existsSync29(exe) ? exe : null;
   }
   const home = deps.homedir ?? import_os11.default.homedir();
   const unix = import_path8.default.posix.join(home, ".local", "bin", "cursor-agent");
-  return existsSync28(unix) ? unix : null;
+  return existsSync29(unix) ? unix : null;
 }
 async function waitForCursorAgent(opts = {}) {
   const timeoutMs = opts.timeoutMs ?? 18e4;
@@ -33078,6 +33221,28 @@ var AcpClient = class {
    * reply cleanly. The `finally` guarantees the guard clears even if the load
    * throws, so a failed recovery can't wedge streaming off.
    */
+  /**
+   * Start a BRAND-NEW conversation on the SAME running adapter process and make
+   * it the active session. Agent Packs' stage boundary: each pipeline role runs
+   * in a fresh conversation (fresh context — the reviewer must not see the
+   * coder's conversation), so the pack runner calls this between stages instead
+   * of respawning the agent. Same `session/new` the startup handshake and
+   * {@link reestablishSession} send; callers own re-pointing the history anchor
+   * (`AcpHistory.switchActiveSession` + `onActiveSessionChanged`), exactly like
+   * the `resume_session` rail.
+   */
+  async newConversation() {
+    if (!this.connection) {
+      throw new Error("AcpClient.newConversation called before start()");
+    }
+    const ns = await this.connection.newSession({
+      cwd: this.opts.cwd,
+      mcpServers: this.opts.mcpServers ?? []
+    });
+    this.sessionId = ns.sessionId;
+    log.info("acpClient", `newConversation \u2190 ok sid=${ns.sessionId.slice(0, 8)}`);
+    return ns.sessionId;
+  }
   async reestablishSession() {
     if (!this.connection) throw new Error("AcpClient.reestablishSession: no connection");
     const cwd = this.opts.cwd;
@@ -34559,7 +34724,7 @@ function defaultRunGit(cwd, args2) {
   });
 }
 async function discoverRepos(workingDir, maxDepth = 4) {
-  const fs77 = await import("fs/promises");
+  const fs79 = await import("fs/promises");
   const out2 = [];
   await walk(workingDir, 0);
   return out2;
@@ -34567,7 +34732,7 @@ async function discoverRepos(workingDir, maxDepth = 4) {
     if (depth > maxDepth) return;
     let entries = [];
     try {
-      const dirents = await fs77.readdir(dir, { withFileTypes: true });
+      const dirents = await fs79.readdir(dir, { withFileTypes: true });
       entries = dirents.filter((d3) => !d3.name.startsWith(".") || d3.name === ".git").map((d3) => ({ name: d3.name, isDirectory: d3.isDirectory() }));
     } catch {
       return;
@@ -35210,6 +35375,514 @@ async function postBudgetReached(opts, fetchImpl = fetch) {
   }
 }
 
+// src/packs/gates.ts
+var import_node_child_process30 = require("child_process");
+var fs71 = __toESM(require("fs"));
+var path77 = __toESM(require("path"));
+var defaultCommandRunner = (file, args2, cwd, timeoutMs) => new Promise((resolve9) => {
+  (0, import_node_child_process30.execFile)(
+    file,
+    args2,
+    { cwd, timeout: timeoutMs, maxBuffer: 4 * 1024 * 1024 },
+    (err, stdout, stderr) => {
+      let code = 0;
+      if (err) {
+        const rawCode = err.code;
+        code = typeof rawCode === "number" ? rawCode : 1;
+      }
+      resolve9({ code, stdout: stdout ?? "", stderr: stderr ?? "" });
+    }
+  );
+});
+var GIT_TIMEOUT_MS = 15e3;
+async function gitHead(run, cwd) {
+  const res = await run("git", ["rev-parse", "HEAD"], cwd, GIT_TIMEOUT_MS);
+  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);
+  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;
+}
+async function diffStat(run, cwd, from, to) {
+  const res = await run("git", ["diff", "--stat", `${from}..${to}`], cwd, GIT_TIMEOUT_MS);
+  if (res.code !== 0) return "";
+  const lines = res.stdout.trim().split("\n").filter(Boolean);
+  return lines.length > 0 ? lines[lines.length - 1].trim() : "";
+}
+var NO_TEST_PLACEHOLDER = 'echo "Error: no test specified"';
+var CHECKS_TIMEOUT_MS = 5 * 6e4;
+function detectChecksCommand(cwd) {
+  try {
+    const cfg = JSON.parse(fs71.readFileSync(path77.join(cwd, ".codeam", "pack.json"), "utf8"));
+    if (typeof cfg.checksCommand === "string" && cfg.checksCommand.trim().length > 0) {
+      return cfg.checksCommand.trim();
+    }
+  } catch {
+  }
+  try {
+    const pkg = JSON.parse(fs71.readFileSync(path77.join(cwd, "package.json"), "utf8"));
+    const test = pkg.scripts?.test;
+    if (typeof test === "string" && test.trim().length > 0 && !test.includes(NO_TEST_PLACEHOLDER)) {
+      return "npm test";
+    }
+  } catch {
+  }
+  return null;
+}
+async function runChecks(run, cwd, command2) {
+  const res = await run("sh", ["-c", command2], cwd, CHECKS_TIMEOUT_MS);
+  const combined = `${res.stdout}
+${res.stderr}`.trim();
+  const tail = combined.split("\n").slice(-12).join("\n").slice(-1500);
+  return { command: command2, passed: res.code === 0, tail };
+}
+
+// src/packs/run-store.ts
+var fs72 = __toESM(require("fs"));
+var path78 = __toESM(require("path"));
+var crypto5 = __toESM(require("crypto"));
+function packsDir(cwd) {
+  return path78.join(cwd, ".codeam", "packs");
+}
+function runDir(cwd, runId) {
+  return path78.join(packsDir(cwd), runId);
+}
+function newRunId() {
+  return `pk_${Date.now().toString(36)}_${crypto5.randomBytes(4).toString("hex")}`;
+}
+function writeJsonAtomic(file, value) {
+  fs72.mkdirSync(path78.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp`;
+  fs72.writeFileSync(tmp, JSON.stringify(value, null, 2));
+  fs72.renameSync(tmp, file);
+}
+function saveRun(cwd, state) {
+  writeJsonAtomic(path78.join(runDir(cwd, state.runId), "run.json"), state);
+}
+function saveStageHandoff(cwd, runId, stageIndex, role, handoff) {
+  const name = `${String(stageIndex + 1).padStart(2, "0")}-${role}.json`;
+  writeJsonAtomic(path78.join(runDir(cwd, runId), name), handoff);
+}
+function loadLatestRun(cwd) {
+  try {
+    const dir = packsDir(cwd);
+    const entries = fs72.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+    for (let i = entries.length - 1; i >= 0; i--) {
+      const file = path78.join(dir, entries[i], "run.json");
+      try {
+        const parsed = JSON.parse(fs72.readFileSync(file, "utf8"));
+        if (parsed && typeof parsed.runId === "string") return parsed;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function ensureLedgerIgnored(cwd) {
+  try {
+    const gitDir = path78.join(cwd, ".git");
+    if (!fs72.existsSync(gitDir)) return;
+    const exclude = path78.join(gitDir, "info", "exclude");
+    let existing = "";
+    try {
+      existing = fs72.readFileSync(exclude, "utf8");
+    } catch {
+    }
+    if (existing.includes(".codeam/packs/")) return;
+    fs72.mkdirSync(path78.dirname(exclude), { recursive: true });
+    fs72.writeFileSync(exclude, `${existing.trimEnd()}
+.codeam/packs/
+`.trimStart());
+  } catch {
+  }
+}
+
+// src/packs/events.ts
+async function postPackState(opts, state, fetchImpl = fetch) {
+  const url2 = `${resolveApiBaseUrl()}/api/packs/events`;
+  const body = JSON.stringify({ sessionId: opts.sessionId, pluginId: opts.pluginId, state });
+  try {
+    const makeHeaders = (token) => ({
+      "Content-Type": "application/json",
+      "X-Plugin-Auth-Token": token
+    });
+    const response = await fetchImpl(url2, {
+      method: "POST",
+      headers: makeHeaders(opts.pluginAuthToken),
+      body
+    });
+    if (response.status === 401 || response.status === 403) {
+      const freshToken = await fetchCurrentPluginAuthToken(
+        opts.sessionId,
+        opts.pluginId,
+        opts.pollSecret
+      );
+      if (freshToken !== null) {
+        await fetchImpl(url2, { method: "POST", headers: makeHeaders(freshToken), body });
+      }
+    }
+  } catch {
+  }
+}
+
+// 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) {
+  const stage = pack.stages[stageIndex];
+  const pipeline2 = pack.stages.map((s, i) => i === stageIndex ? `[${s.name}]` : s.name).join(" \u2192 ");
+  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}.\``,
+    `## Task
+${task}`
+  ];
+  if (previous) {
+    parts.push(
+      `## Previous stage handoff (${previous.role})
+commit: ${previous.handoff.commit}
+${previous.handoff.diffStat}
+
+${previous.handoff.summary}`
+    );
+  }
+  return parts.join("\n\n");
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var PackRunner = class _PackRunner {
+  constructor(deps, pack, initial) {
+    this.deps = deps;
+    this.pack = pack;
+    this.state = initial;
+  }
+  deps;
+  pack;
+  state;
+  control = "run";
+  looping = false;
+  static create(deps, packId, task, runId) {
+    const pack = getPackDefinition(packId);
+    if (!pack) throw new Error(`unknown pack: ${packId}`);
+    const stages = pack.stages.map((s) => ({
+      role: s.role,
+      name: s.name,
+      status: "pending"
+    }));
+    const state = {
+      runId,
+      packId: pack.id,
+      task,
+      status: "running",
+      currentStage: 0,
+      stages,
+      startedAt: nowIso(),
+      updatedAt: nowIso()
+    };
+    return new _PackRunner(deps, pack, state);
+  }
+  getState() {
+    return this.state;
+  }
+  /** Persist + post the current state (ledger first — it's the truth). */
+  async publish() {
+    this.state = { ...this.state, updatedAt: nowIso() };
+    try {
+      this.deps.ledger.saveRun(this.state);
+    } catch (err) {
+      this.deps.log(`pack ledger save failed: ${err.message}`);
+    }
+    await this.deps.postState(this.state);
+  }
+  async settle(status2, stalledReason) {
+    this.state = { ...this.state, status: status2, stalledReason };
+    await this.publish();
+  }
+  // ── Control surface (relay `pack_action`) ────────────────────────────────
+  async applyAction(action) {
+    switch (action) {
+      case "pause":
+        this.control = "pause";
+        if (this.state.status === "running") {
+          this.state = { ...this.state, status: "paused" };
+          await this.publish();
+        }
+        break;
+      case "resume":
+        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();
+        }
+        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();
+        }
+        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();
+        }
+        break;
+      }
+      case "abort":
+        this.control = "abort";
+        await this.deps.driver.cancel().catch(() => void 0);
+        if (!this.looping) await this.settle("aborted");
+        break;
+    }
+    return this.state;
+  }
+  // ── The loop ──────────────────────────────────────────────────────────────
+  async run() {
+    if (this.looping) return;
+    this.looping = true;
+    try {
+      while (this.state.currentStage < this.state.stages.length) {
+        if (this.control === "abort") {
+          await this.settle("aborted");
+          return;
+        }
+        if (this.control === "pause") {
+          await this.settle("paused");
+          return;
+        }
+        const advanced = await this.runStage(this.state.currentStage);
+        if (!advanced) return;
+      }
+      await this.settle("completed");
+      this.deps.log(`pack run ${this.state.runId} completed`);
+    } catch (err) {
+      await this.settle("failed", err.message).catch(() => void 0);
+    } finally {
+      this.looping = false;
+    }
+  }
+  /** Run one stage to its handoff. True = advanced; false = run settled. */
+  async runStage(index) {
+    const stageDef = this.pack.stages[index];
+    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") {
+        await this.settle("aborted");
+        return false;
+      }
+      let endSha = await this.deps.gates.head();
+      if (!endSha || endSha === startSha) {
+        reply = await this.deps.driver.runTurn(NUDGE_PROMPT, "\u25B6 Waiting for the stage commit\u2026");
+        endSha = await this.deps.gates.head();
+        if (!endSha || endSha === startSha) {
+          return this.stall(index, "stage produced no commit", reply);
+        }
+      }
+      const commit = await this.deps.gates.canonicalCommit(endSha);
+      if (!commit) return this.stall(index, "stage HEAD did not resolve to a commit", reply);
+      const handoff = {
+        commit,
+        summary: reply.trim().slice(-SUMMARY_MAX_CHARS),
+        diffStat: startSha ? await this.deps.gates.diffStat(startSha, endSha) : "",
+        checks: await this.deps.gates.runChecks() ?? void 0,
+        durationMs: Date.now() - startedMs
+      };
+      stages = this.state.stages.slice();
+      stages[index] = { ...stages[index], status: "done", handoff };
+      this.state = { ...this.state, stages, currentStage: index + 1 };
+      try {
+        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;
+    } catch (err) {
+      if (this.control === "abort") {
+        await this.settle("aborted");
+        return false;
+      }
+      return this.stall(index, err.message);
+    }
+  }
+  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.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--) {
+      const s = this.state.stages[i];
+      if (s.status === "done" && s.handoff) return { role: s.role, handoff: s.handoff };
+    }
+    return null;
+  }
+};
+
+// src/packs/active.ts
+var active = null;
+function setActivePackRunner(runner) {
+  active = runner;
+}
+function getActivePackRunner() {
+  return active;
+}
+
+// src/packs/handlers.ts
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "aborted", "failed"]);
+var PACK_ACTIONS = /* @__PURE__ */ new Set(["pause", "resume", "retry_stage", "skip_stage", "abort"]);
+function buildPackRunnerDeps(ctx) {
+  const cwd = ctx.opts.cwd;
+  const run = defaultCommandRunner;
+  return {
+    driver: {
+      newConversation: async () => {
+        const id = await ctx.client.newConversation();
+        ctx.history.switchActiveSession(id);
+        ctx.onActiveSessionChanged?.(id);
+        return id;
+      },
+      runTurn: async (prompt, displayLine) => {
+        await ctx.streaming.beginTurn();
+        ctx.history.appendUserPrompt(displayLine);
+        await ctx.client.prompt(prompt);
+        const text = ctx.streaming.getCurrentText();
+        await ctx.streaming.closeTurnWithInteractiveDetection();
+        ctx.history.appendAgentReply(text);
+        await ctx.history.flush();
+        return text;
+      },
+      cancel: () => ctx.client.cancel(),
+      mountSkills: (skillIds) => {
+        for (const id of skillIds) {
+          try {
+            configureSkill("add", id);
+          } catch (err) {
+            log.warn("packs", `skill mount failed for ${id}: ${err.message}`);
+          }
+        }
+      }
+    },
+    gates: {
+      head: () => gitHead(run, cwd),
+      canonicalCommit: (sha) => canonicalCommit(run, cwd, sha),
+      diffStat: (from, to) => diffStat(run, cwd, from, to),
+      runChecks: async () => {
+        const command2 = detectChecksCommand(cwd);
+        return command2 ? runChecks(run, cwd, command2) : null;
+      }
+    },
+    ledger: {
+      saveRun: (state) => saveRun(cwd, state),
+      saveStageHandoff: (runId, index, role, handoff) => saveStageHandoff(cwd, runId, index, role, handoff)
+    },
+    postState: (state) => postPackState(
+      {
+        sessionId: ctx.opts.sessionId,
+        pluginId: ctx.opts.pluginId,
+        pluginAuthToken: ctx.opts.pluginAuthToken,
+        pollSecret: ctx.opts.pollSecret
+      },
+      state
+    ),
+    log: (message) => log.info("packs", message)
+  };
+}
+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)"}` });
+    return;
+  }
+  if (task.length === 0) {
+    await ctx.relay.sendResult(ctx.cmd.id, "failed", { error: "pack_start requires a non-empty task" });
+    return;
+  }
+  const existing = getActivePackRunner();
+  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",
+      state: existing.getState()
+    });
+    return;
+  }
+  ensureLedgerIgnored(ctx.opts.cwd);
+  const runner = PackRunner.create(buildPackRunnerDeps(ctx), packId, task, newRunId());
+  setActivePackRunner(runner);
+  log.info("packs", `pack_start ${packId} run=${runner.getState().runId}`);
+  await ctx.relay.sendResult(ctx.cmd.id, "completed", {
+    accepted: true,
+    runId: runner.getState().runId,
+    state: runner.getState()
+  });
+  void runner.run();
+};
+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)"}` });
+    return;
+  }
+  const runner = getActivePackRunner();
+  if (!runner) {
+    await ctx.relay.sendResult(ctx.cmd.id, "failed", {
+      error: "no active pack run in this session",
+      state: loadLatestRun(ctx.opts.cwd)
+    });
+    return;
+  }
+  const state = await runner.applyAction(action);
+  await ctx.relay.sendResult(ctx.cmd.id, "completed", { state });
+};
+var packStatusH = async (ctx) => {
+  const state = getActivePackRunner()?.getState() ?? loadLatestRun(ctx.opts.cwd);
+  await ctx.relay.sendResult(ctx.cmd.id, "completed", { state });
+};
+
 // src/integrations/provision.ts
 function buildMcpServersForStart(ctx) {
   const manifest = readIntegrationsManifest();
@@ -35348,7 +36021,7 @@ async function detectRepoStack(cwd, runtime) {
 }
 
 // src/agents/acp/command-handlers.ts
-var import_node_child_process30 = require("child_process");
+var import_node_child_process31 = require("child_process");
 
 // src/agents/acp/buildAcpPromptBlocks.ts
 var MIME_FROM_EXT = {
@@ -35385,35 +36058,35 @@ function buildAcpPromptBlocks(payload) {
 }
 
 // src/agents/agent-standard.ts
-var fs72 = __toESM(require("fs"));
-var path78 = __toESM(require("path"));
+var fs74 = __toESM(require("fs"));
+var path80 = __toESM(require("path"));
 var os57 = __toESM(require("os"));
 function ensureAgentStandard(homeDir2 = os57.homedir()) {
   try {
-    const file = path78.join(homeDir2, ".claude", "CLAUDE.md");
+    const file = path80.join(homeDir2, ".claude", "CLAUDE.md");
     let existing = "";
     try {
-      existing = fs72.readFileSync(file, "utf8");
+      existing = fs74.readFileSync(file, "utf8");
     } catch {
     }
     if (existing.includes(AGENT_STANDARD_MARKER)) return;
-    fs72.mkdirSync(path78.dirname(file), { recursive: true });
+    fs74.mkdirSync(path80.dirname(file), { recursive: true });
     const next = existing.trim() ? `${existing.trimEnd()}
 
 ${AGENT_STANDARD_BLOCK}
 ` : `${AGENT_STANDARD_BLOCK}
 `;
-    fs72.writeFileSync(file, next);
+    fs74.writeFileSync(file, next);
   } catch {
   }
 }
 var _agentStandardSeam = {
   isLocalSession: () => isLocalSession(),
-  markerPath: (sessionId) => path78.join(os57.homedir(), ".codeam", "agent-standard", `${sessionId}.done`),
-  exists: (p2) => fs72.existsSync(p2),
+  markerPath: (sessionId) => path80.join(os57.homedir(), ".codeam", "agent-standard", `${sessionId}.done`),
+  exists: (p2) => fs74.existsSync(p2),
   write: (p2) => {
-    fs72.mkdirSync(path78.dirname(p2), { recursive: true });
-    fs72.writeFileSync(p2, "");
+    fs74.mkdirSync(path80.dirname(p2), { recursive: true });
+    fs74.writeFileSync(p2, "");
   }
 };
 function isClaude(agent) {
@@ -36042,7 +36715,7 @@ async function prewarmNewMcpEntries(manifest, previousIds) {
     fresh.map(
       (e) => new Promise((resolve9) => {
         const mcp = e.delivery.mcp;
-        const child = (0, import_node_child_process30.execFile)(
+        const child = (0, import_node_child_process31.execFile)(
           mcp.command,
           [...mcp.args, "--help"],
           { timeout: 9e4 },
@@ -36123,7 +36796,10 @@ var ACP_COMMAND_HANDLERS = {
   preview_start: previewH,
   preview_stop: previewH,
   save_preview_config: previewH,
-  skills_configure: skillsConfigureH2
+  skills_configure: skillsConfigureH2,
+  pack_start: packStartH,
+  pack_action: packActionH,
+  pack_status: packStatusH
 };
 async function dispatchAcpCommand(ctx) {
   const handler = ACP_COMMAND_HANDLERS[ctx.cmd.type];
@@ -38034,7 +38710,7 @@ function fetchQuotaUsage(runtime, historySvc) {
 
 // src/agents/claude/credential-sync.ts
 var import_chokidar2 = __toESM(require("chokidar"));
-var crypto5 = __toESM(require("crypto"));
+var crypto6 = __toESM(require("crypto"));
 var CLAUDE_PUBLIC_AGENT_ID = "claude_code";
 function startClaudeCredentialSync(opts) {
   const push = opts.push ?? postCredentialSync;
@@ -38046,7 +38722,7 @@ function startClaudeCredentialSync(opts) {
     try {
       const tok = await read2();
       if (!tok || !tok.credential) return;
-      const hash = crypto5.createHash("sha256").update(tok.credential).digest("hex");
+      const hash = crypto6.createHash("sha256").update(tok.credential).digest("hex");
       if (hash === lastHash) return;
       lastHash = hash;
       await push({
@@ -38083,8 +38759,8 @@ function startClaudeCredentialSync(opts) {
 }
 
 // src/beads/workflow-hint.ts
-var fs73 = __toESM(require("fs"));
-var path79 = __toESM(require("path"));
+var fs75 = __toESM(require("fs"));
+var path81 = __toESM(require("path"));
 var os58 = __toESM(require("os"));
 var BEADS_HINT_MARKER = "<!-- codeam:beads-workflow -->";
 var BEADS_HINT = `${BEADS_HINT_MARKER}
@@ -38101,20 +38777,20 @@ This environment uses **bd (beads)** for issue/task tracking and persistent memo
 ${BEADS_HINT_MARKER}`;
 function ensureBeadsWorkflowHint(homeDir2 = os58.homedir()) {
   try {
-    const file = path79.join(homeDir2, ".claude", "CLAUDE.md");
+    const file = path81.join(homeDir2, ".claude", "CLAUDE.md");
     let existing = "";
     try {
-      existing = fs73.readFileSync(file, "utf8");
+      existing = fs75.readFileSync(file, "utf8");
     } catch {
     }
     if (existing.includes(BEADS_HINT_MARKER)) return;
-    fs73.mkdirSync(path79.dirname(file), { recursive: true });
+    fs75.mkdirSync(path81.dirname(file), { recursive: true });
     const next = existing.trim() ? `${existing.trimEnd()}
 
 ${BEADS_HINT}
 ` : `${BEADS_HINT}
 `;
-    fs73.writeFileSync(file, next);
+    fs75.writeFileSync(file, next);
   } catch {
   }
 }
@@ -38486,7 +39162,7 @@ var AcpDriver = class {
 };
 
 // src/baton/transcript-mirror.ts
-var fs74 = __toESM(require("fs"));
+var fs76 = __toESM(require("fs"));
 var TranscriptMirror = class {
   constructor(deps) {
     this.deps = deps;
@@ -38553,7 +39229,7 @@ var TranscriptMirror = class {
   }
 };
 function defaultWatch(file, onChange) {
-  const w3 = fs74.watch(file, { persistent: false }, () => onChange());
+  const w3 = fs76.watch(file, { persistent: false }, () => onChange());
   return () => w3.close();
 }
 
@@ -38815,16 +39491,16 @@ function toEpochMs(ts) {
 }
 
 // src/agents/claude/onboarding.ts
-var fs75 = __toESM(require("fs"));
+var fs77 = __toESM(require("fs"));
 var os60 = __toESM(require("os"));
-var path80 = __toESM(require("path"));
+var path82 = __toESM(require("path"));
 var ONBOARDING_VERSION_SENTINEL = "9999.0.0";
 function ensureClaudeOnboarded(cwd) {
   try {
-    const file = path80.join(os60.homedir(), ".claude.json");
+    const file = path82.join(os60.homedir(), ".claude.json");
     let config = {};
     try {
-      config = JSON.parse(fs75.readFileSync(file, "utf8"));
+      config = JSON.parse(fs77.readFileSync(file, "utf8"));
     } catch {
     }
     let changed = false;
@@ -38849,8 +39525,8 @@ function ensureClaudeOnboarded(cwd) {
       }
     }
     if (!changed) return;
-    fs75.mkdirSync(path80.dirname(file), { recursive: true });
-    fs75.writeFileSync(file, JSON.stringify(config, null, 2));
+    fs77.mkdirSync(path82.dirname(file), { recursive: true });
+    fs77.writeFileSync(file, JSON.stringify(config, null, 2));
     log.info(
       "claude",
       `pre-completed Claude onboarding${cwd ? ` + trusted workspace ${cwd}` : ""}`
@@ -39522,13 +40198,13 @@ var import_picocolors7 = __toESM(require("picocolors"));
 function status() {
   showIntro();
   const config = getConfig();
-  const active = config.sessions.find((s) => s.id === config.activeSessionId) ?? null;
+  const active2 = config.sessions.find((s) => s.id === config.activeSessionId) ?? null;
   console.log(import_picocolors7.default.bold("  Status\n"));
   console.log(`  Plugin ID   ${import_picocolors7.default.dim(config.pluginId || "not generated yet")}`);
   console.log(`  Sessions    ${config.sessions.length} paired`);
-  if (active) {
-    console.log(`  Active      ${import_picocolors7.default.bold(active.userName)}  ${import_picocolors7.default.cyan(active.plan)}`);
-    console.log(`  Session ID  ${import_picocolors7.default.dim(active.id)}`);
+  if (active2) {
+    console.log(`  Active      ${import_picocolors7.default.bold(active2.userName)}  ${import_picocolors7.default.cyan(active2.plan)}`);
+    console.log(`  Session ID  ${import_picocolors7.default.dim(active2.id)}`);
   } else {
     console.log(`  Active      ${import_picocolors7.default.yellow("none")}  ${import_picocolors7.default.dim("run codeam pair to connect")}`);
   }
@@ -39580,7 +40256,7 @@ var import_picocolors11 = __toESM(require("picocolors"));
 var import_child_process29 = require("child_process");
 var import_util4 = require("util");
 var import_picocolors9 = __toESM(require("picocolors"));
-var path81 = __toESM(require("path"));
+var path83 = __toESM(require("path"));
 var execFileP6 = (0, import_util4.promisify)(import_child_process29.execFile);
 var MAX_BUFFER = 8 * 1024 * 1024;
 function resetStdinForChild() {
@@ -40069,7 +40745,7 @@ var GitHubCodespacesProvider = class {
     });
   }
   async uploadFile(workspaceId, remotePath, contents, options = {}) {
-    const remoteDir = path81.posix.dirname(remotePath);
+    const remoteDir = path83.posix.dirname(remotePath);
     const parts = [
       `mkdir -p ${shellQuote(remoteDir)}`,
       `cat > ${shellQuote(remotePath)}`
@@ -40139,7 +40815,7 @@ function shellQuote(s) {
 // src/services/providers/gitpod.ts
 var import_child_process30 = require("child_process");
 var import_util5 = require("util");
-var path82 = __toESM(require("path"));
+var path84 = __toESM(require("path"));
 var import_picocolors10 = __toESM(require("picocolors"));
 var execFileP7 = (0, import_util5.promisify)(import_child_process30.execFile);
 var MAX_BUFFER2 = 8 * 1024 * 1024;
@@ -40379,7 +41055,7 @@ var GitpodProvider = class {
     });
   }
   async uploadFile(workspaceId, remotePath, contents, options = {}) {
-    const remoteDir = path82.posix.dirname(remotePath);
+    const remoteDir = path84.posix.dirname(remotePath);
     const parts = [
       `mkdir -p ${shellQuote2(remoteDir)}`,
       `cat > ${shellQuote2(remotePath)}`
@@ -40415,7 +41091,7 @@ function shellQuote2(s) {
 // src/services/providers/gitlab-workspaces.ts
 var import_child_process31 = require("child_process");
 var import_util6 = require("util");
-var path83 = __toESM(require("path"));
+var path85 = __toESM(require("path"));
 var execFileP8 = (0, import_util6.promisify)(import_child_process31.execFile);
 var MAX_BUFFER3 = 8 * 1024 * 1024;
 var GITLAB_API_BASE = process.env.CODEAM_GITLAB_API_URL ?? "https://gitlab.com/api/v4";
@@ -40675,7 +41351,7 @@ Docs: https://docs.gitlab.com/ee/user/workspace/configuration.html`
   }
   async uploadFile(workspaceId, remotePath, contents, options = {}) {
     const sshHost = process.env.CODEAM_GITLAB_SSH_HOST ?? "workspaces.gitlab.com";
-    const remoteDir = path83.posix.dirname(remotePath);
+    const remoteDir = path85.posix.dirname(remotePath);
     const parts = [`mkdir -p ${shellQuote3(remoteDir)}`, `cat > ${shellQuote3(remotePath)}`];
     if (options.mode != null) {
       parts.push(`chmod ${options.mode.toString(8)} ${shellQuote3(remotePath)}`);
@@ -40743,7 +41419,7 @@ function shellQuote3(s) {
 // src/services/providers/railway.ts
 var import_child_process32 = require("child_process");
 var import_util7 = require("util");
-var path84 = __toESM(require("path"));
+var path86 = __toESM(require("path"));
 var execFileP9 = (0, import_util7.promisify)(import_child_process32.execFile);
 var MAX_BUFFER4 = 8 * 1024 * 1024;
 function resetStdinForChild4() {
@@ -40979,7 +41655,7 @@ var RailwayProvider = class {
     if (!projectId || !serviceId) {
       throw new Error("Invalid Railway workspace id (expected projectId/serviceId).");
     }
-    const remoteDir = path84.posix.dirname(remotePath);
+    const remoteDir = path86.posix.dirname(remotePath);
     const parts = [`mkdir -p ${shellQuote4(remoteDir)}`, `cat > ${shellQuote4(remotePath)}`];
     if (options.mode != null) {
       parts.push(`chmod ${options.mode.toString(8)} ${shellQuote4(remotePath)}`);
@@ -41510,9 +42186,9 @@ async function probeCodeamPair(provider, workspace) {
 }
 async function stopWorkspaceFromLocal(target) {
   if (target.provider.id === "github-codespaces") {
-    const { execFile: execFile15 } = await import("child_process");
+    const { execFile: execFile16 } = await import("child_process");
     const { promisify: promisify11 } = await import("util");
-    const execFileP10 = promisify11(execFile15);
+    const execFileP10 = promisify11(execFile16);
     await execFileP10("gh", ["codespace", "stop", "-c", target.id], { maxBuffer: 8 * 1024 * 1024 });
     return;
   }
@@ -41625,8 +42301,8 @@ async function invite() {
 var import_node_dns = require("dns");
 var import_node_util5 = require("util");
 var import_node_crypto13 = require("crypto");
-var fs76 = __toESM(require("fs"));
-var path85 = __toESM(require("path"));
+var fs78 = __toESM(require("fs"));
+var path87 = __toESM(require("path"));
 var import_picocolors14 = __toESM(require("picocolors"));
 var dnsResolveP = (0, import_node_util5.promisify)(import_node_dns.resolve);
 async function checkDns(apiBase2) {
@@ -41682,13 +42358,13 @@ async function checkHealth(apiBase2) {
   }
 }
 function checkConfigDir() {
-  const dir = path85.join(require("os").homedir(), ".codeam");
+  const dir = path87.join(require("os").homedir(), ".codeam");
   try {
-    fs76.mkdirSync(dir, { recursive: true, mode: 448 });
-    const probe = path85.join(dir, ".doctor-probe");
-    fs76.writeFileSync(probe, "ok", { mode: 384 });
-    const read2 = fs76.readFileSync(probe, "utf8");
-    fs76.unlinkSync(probe);
+    fs78.mkdirSync(dir, { recursive: true, mode: 448 });
+    const probe = path87.join(dir, ".doctor-probe");
+    fs78.writeFileSync(probe, "ok", { mode: 384 });
+    const read2 = fs78.readFileSync(probe, "utf8");
+    fs78.unlinkSync(probe);
     if (read2 !== "ok") throw new Error("write/read round-trip mismatch");
     return {
       id: "config-dir",
@@ -41752,7 +42428,7 @@ function checkNodePty() {
       detail: "not required on this platform"
     };
   }
-  const vendoredPath = path85.join(__dirname, "vendor", "node-pty");
+  const vendoredPath = path87.join(__dirname, "vendor", "node-pty");
   for (const target of [vendoredPath, "node-pty"]) {
     try {
       require(target);
@@ -41794,7 +42470,7 @@ function checkChokidar() {
 }
 async function doctor(args2 = []) {
   const json = args2.includes("--json");
-  const cliVersion = true ? "2.61.91" : "0.0.0-dev";
+  const cliVersion = true ? "2.61.92" : "0.0.0-dev";
   const apiBase2 = resolveApiBaseUrl();
   const diagnosticId = (0, import_node_crypto13.randomUUID)();
   log.info("doctor", `run id=${diagnosticId} cli=${cliVersion}`);
@@ -41991,7 +42667,7 @@ async function completion(args2) {
 }
 
 // src/integrations/mcp-run.ts
-var import_node_child_process32 = require("child_process");
+var import_node_child_process33 = require("child_process");
 var import_node_fs12 = require("fs");
 var import_node_os14 = __toESM(require("os"));
 var import_node_path12 = __toESM(require("path"));
@@ -42066,7 +42742,7 @@ function resolveDelivery(id) {
 function commandExists(command2) {
   try {
     const probe = process.platform === "win32" ? "where" : "which";
-    (0, import_node_child_process32.execFileSync)(probe, [command2], { stdio: "ignore" });
+    (0, import_node_child_process33.execFileSync)(probe, [command2], { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -42099,7 +42775,7 @@ function ensureCommand(command2) {
   }
   if (command2 === "uvx") {
     try {
-      (0, import_node_child_process32.execSync)("curl -LsSf https://astral.sh/uv/install.sh | sh", {
+      (0, import_node_child_process33.execSync)("curl -LsSf https://astral.sh/uv/install.sh | sh", {
         stdio: ["ignore", process.stderr, process.stderr],
         timeout: 18e4,
         env: { ...process.env, UV_NO_MODIFY_PATH: "1" }
@@ -42108,7 +42784,7 @@ function ensureCommand(command2) {
     }
     if (resolveLauncherPath(command2) !== command2) return;
     try {
-      (0, import_node_child_process32.execSync)("python3 -m pip install --user --quiet uv", {
+      (0, import_node_child_process33.execSync)("python3 -m pip install --user --quiet uv", {
         stdio: ["ignore", process.stderr, process.stderr],
         timeout: 18e4
       });
@@ -42185,7 +42861,7 @@ async function mcpRun(args2) {
 // src/commands/version.ts
 var import_picocolors15 = __toESM(require("picocolors"));
 function version2() {
-  const v = true ? "2.61.91" : "unknown";
+  const v = true ? "2.61.92" : "unknown";
   console.log(`${import_picocolors15.default.bold("codeam-cli")} ${import_picocolors15.default.cyan(v)}`);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeam-cli",
-  "version": "2.61.91",
+  "version": "2.61.92",
   "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 — async. The terminal companion for CodeAgent Mobile.",
   "type": "commonjs",
   "main": "dist/index.js",