claude-code-session-manager 0.124.0 → 0.125.0

package/dist-web/index.html

@@ -0,0 +1,16 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Claude Session Manager</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Newsreader:ital,opsz,wght@0,6..72,400;0,6..72,500;0,6..72,600;0,6..72,700;1,6..72,400&family=Geist:wght@300;400;500;600;700&family=IBM+Plex+Mono:wght@400;500;600&display=swap" rel="stylesheet">
+    <script type="module" crossorigin src="./assets/app.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/app.css">
+  </head>
+  <body class="bg-bg text-fg font-sans antialiased">
+    <div id="root"></div>
+  </body>
+</html>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-session-manager",
-  "version": "0.124.0",
+  "version": "0.125.0",
   "description": "Local cockpit for the Claude Code CLI — multi-tab terminal, full config surface, scheduler, voice dictation, and live observability.",
   "type": "module",
   "main": "src/main/index.cjs",
@@ -37,7 +37,7 @@
     "dev": "concurrently -k -n vite,electron -c magenta,cyan \"npm:dev:renderer\" \"npm:dev:electron\"",
     "dev:renderer": "vite",
     "dev:electron": "wait-on http://localhost:5173 && SM_DEV=1 electron .",
-    "build": "vite build",
+    "build": "vite build && vite build --config vite.web.config.ts",
     "build:web": "vite build --config vite.web.config.ts",
     "dist:stage": "npm run build && node scripts/package/stage.cjs",
     "dist:mac": "npm run dist:stage && electron-builder --config electron-builder.yml --mac --publish never",
@@ -47,7 +47,7 @@
     "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.main.json",
     "start": "electron .",
     "prepack": "node scripts/write-build-info.cjs",
-    "prepublishOnly": "node scripts/write-build-info.cjs && vite build",
+    "prepublishOnly": "node scripts/write-build-info.cjs && npm run build",
     "test:unit": "vitest run",
     "test:unit:stability": "bash scripts/test-unit-stability.sh",
     "bench": "node scripts/bench/main-bench.cjs",

package/plugins/session-manager-dev/skills/builder/3-publish/SKILL.md

@@ -40,24 +40,37 @@ to ask for reconfirmation once `builder:gate` has passed.
 
 5. **Create the isolated worktree from that tag:**
    ```
-   git worktree add /tmp/sm-publish-v<version> v<version>
+   mkdir -p "$HOME/.cache/sm-publish"
+   git worktree add "$HOME/.cache/sm-publish/v<version>" v<version>
    ```
+   **Never under `/tmp`** (or anywhere under `os.tmpdir()`): the test suite treats such paths as
+   test fixtures, so `src/main/__tests__/opsErrorLog.test.cjs` ("a real project root is
+   refused") fails inside a `/tmp` worktree.
 
-6. **Move into the worktree and build clean:**
+6. **Move into the worktree, build clean, and run the in-tree gate:**
    ```
-   cd /tmp/sm-publish-v<version>
+   cd "$HOME/.cache/sm-publish/v<version>"
    npm ci
    npm run typecheck
+   npm run test:unit
    ```
    `npm ci` gives a fully clean `node_modules` from the lockfile — no leftover local state
-   from the dirty main repo can leak into the published artifact.
+   from the dirty main repo can leak into the published artifact. Typecheck and unit tests
+   must both pass here; stop before `npm publish` on any failure.
+
+   After the build step (run the project's build, e.g. `npm run build` plus any web build that
+   produces `dist-web/`), check that every `files` entry exists:
+   ```
+   test -f dist-web/index.html && test -f dist/index.html
+   ```
+   If either is missing, stop before `npm publish` and report.
 
 7. **Publish from inside the worktree:**
    ```
    npm publish
    ```
    This project's `prepublishOnly` script runs `vite build` — because step 6 already `cd`'d
-   into `/tmp/sm-publish-v<version>`, that build runs **inside the clean worktree**, never
+   into `$HOME/.cache/sm-publish/v<version>`, that build runs **inside the clean worktree**, never
    touching (or being affected by) the live/dirty working directory back in the main repo.
    This is the entire reason the worktree exists: it decouples "what's uncommitted in my
    editor right now" from "what gets built and shipped."
@@ -81,16 +94,21 @@ to ask for reconfirmation once `builder:gate` has passed.
 
 9. **Clean up the worktree:**
    ```
-   git worktree remove /tmp/sm-publish-v<version> --force
+   git worktree remove "$HOME/.cache/sm-publish/v<version>" --force
    ```
 
-10. **Verify the publish actually landed on the registry:**
+10. **Verify the publish actually landed on the registry.** `npm view` is cached and lags for
+    minutes after a real publish, so check a cache-busted packument and the tarball first:
     ```
+    curl -s "https://registry.npmjs.org/<packageName>?t=$(date +%s)"   # dist-tags.latest + versions
+    curl -sI <tarball URL from versions["<version>"].dist.tarball>      # expect HTTP 200
     npm view <packageName> version
     npm view <packageName> dist-tags
     ```
-    Confirm the reported version matches `<version>` and `latest` points to it (unless the
-    project intentionally publishes to a different dist-tag).
+    Confirm `dist-tags.latest` is `<version>`, `<version>` is in `versions`, and the tarball
+    returns 200 (unless the project intentionally publishes to a different dist-tag). If the
+    packument is current, an unchanged `npm view` for a few minutes is normal lag, not a
+    failure — do not republish.
 
 11. **Post-publish: verify the installer release.** Pushing `v<version>` (step 8) triggers
     `.github/workflows/release.yml`. Confirm the tag push succeeded, then poll (bounded: at most
@@ -109,7 +127,7 @@ to ask for reconfirmation once `builder:gate` has passed.
 Stop at that step. Do not proceed. Report which step failed and its output. If the worktree
 was already created (step 5+), leave it in place if its state is relevant evidence for
 diagnosing the failure; otherwise remove it (step 9) before reporting, so a retry doesn't
-collide with a stale `/tmp/sm-publish-v<version>` path.
+collide with a stale `$HOME/.cache/sm-publish/v<version>` path.
 
 ## Output
 

package/src/main/build-info.json

@@ -1,8 +1,8 @@
 {
-  "version": "0.124.0",
-  "gitSha": "9d159322bc6717eba697e3ff96379bc0876eda3f",
-  "gitShortSha": "9d159322",
+  "version": "0.125.0",
+  "gitSha": "3b39163b6942d4b5b636b06dc2d737366b1d78e2",
+  "gitShortSha": "3b39163b",
   "gitBranch": "HEAD",
-  "builtAt": "2026-10-26T06:06:09.256Z",
+  "builtAt": "2026-10-27T02:44:41.942Z",
   "dirty": false
 }

package/src/main/chatRunner.cjs

@@ -52,6 +52,7 @@ const { resolveEpicEffort, effortArgs } = require('./lib/claude/agentEffortResol
 const { planEpicSpawn } = require('./lib/epic/epicSpawnPlan.cjs');
 const epicWorktreeMint = require('./lib/epic/epicWorktreeMint.cjs');
 const logs = require('./logs.cjs');
+const { feedChildStdin } = require('./lib/process/childStdin.cjs');
 const { createHeadTailBuffer } = require('./lib/util/headTailBuffer.cjs');
 
 // Caps on per-run stream buffers (a run can last hours).
@@ -627,7 +628,7 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
     // used for the flag-swap retry so both attempts share one construction path.
     const buildArgs = (resumeFlag) => {
       const a = [
-        '-p', fullPrompt,
+        '-p',
         '--model', model,
         ...effortFlags,
         '--dangerously-skip-permissions',
@@ -712,9 +713,11 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
     // One spawn of the CLI. Per-attempt state (buffers, child) lives in here;
     // everything turn-level (timers, latch, lane) is in the enclosing scope.
     const startAttempt = (resumeFlag, attemptNo) => {
-    // Spawn with stdin closed (mirrors scheduler's 'ignore' — prevents the
-    // "claude -p stdin must be closed" gotcha from kg.cjs). stdout is piped for
-    // real-time NDJSON streaming; stderr piped for error-message capture.
+    // Spawn with a stdin pipe: the prompt is fed on stdin (never argv — E2BIG
+    // above 128 KB per argument on Linux, 8191 chars on Windows cmd.exe) and
+    // feedChildStdin closes it, satisfying "claude -p stdin must be closed".
+    // stdout is piped for real-time NDJSON streaming; stderr piped for
+    // error-message capture.
     let thisChild;
     try {
       const chatArgs = buildArgs(resumeFlag);
@@ -724,7 +727,7 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
         ...(target.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
         cwd: execCwd,
         env: childEnv,
-        stdio: ['ignore', 'pipe', 'pipe'],
+        stdio: ['pipe', 'pipe', 'pipe'],
         ...detachedSpawnOpts(), // own process group so killTree can SIGTERM descendants
       });
     } catch (err) {
@@ -739,6 +742,9 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
       return;
     }
     child = thisChild;
+    feedChildStdin(thisChild, fullPrompt, {
+      log: (m) => logs.writeLine({ scope: 'chatRunner', level: 'warn', message: m }),
+    });
 
     // ─── Stream parsing ────────────────────────────────────────────────────
     // stdout is newline-delimited JSON (stream-json format). We buffer partial

package/src/main/docEdit.cjs

@@ -20,6 +20,7 @@ const { spawn } = require('node:child_process');
 const crypto = require('node:crypto');
 const { resolveClaudeBin, claudeSpawnTarget } = require('./lib/claude/claudeBin.cjs');
 const { headlessPermissionArgs, ensureCliCapsProbed } = require('./lib/claude/claudeCliCaps.cjs');
+const { feedChildStdin } = require('./lib/process/childStdin.cjs');
 const { withProcRole } = require('./lib/process/cleanEnv.cjs');
 const { extractJson } = require('./lib/util/extractJson.cjs');
 const { assertInsideHome } = require('./lib/insideHome.cjs');
@@ -94,7 +95,7 @@ async function runClaude(prompt, { model = 'sonnet', timeoutMs = 90_000, systemP
     let bin;
     try { bin = resolveClaudeBin(); } catch (e) { resolve({ ok: false, error: `claude not found: ${e?.message}` }); return; }
     const args = [
-      '-p', prompt,
+      '-p',
       '--model', model,
       '--dangerously-skip-permissions',
       ...headlessPermissionArgs(),
@@ -102,11 +103,13 @@ async function runClaude(prompt, { model = 'sonnet', timeoutMs = 90_000, systemP
       '--output-format', 'text',
     ];
     if (systemPrompt) args.push('--append-system-prompt', systemPrompt);
-    // stdin MUST be closed ('ignore') — `claude -p` otherwise blocks waiting
-    // for piped stdin and returns empty. SM_KG_INTERNAL=1 tells the
+    // The prompt goes on stdin (argv caps one argument at 128 KB -> E2BIG) and
+    // stdin is closed right after the write, never left open — `claude -p`
+    // otherwise blocks waiting on it and returns empty. SM_KG_INTERNAL=1 tells the
     // prompt-logging hook to skip this invocation.
     const target = claudeSpawnTarget('aux', 'docedit', bin);
-    const child = spawn(target.command, args, { env: withProcRole({ ...process.env, SM_KG_INTERNAL: '1' }, 'aux'), stdio: ['ignore', 'pipe', 'pipe'], ...(target.argv0 ? { argv0: target.argv0 } : {}) });
+    const child = spawn(target.command, args, { env: withProcRole({ ...process.env, SM_KG_INTERNAL: '1' }, 'aux'), stdio: ['pipe', 'pipe', 'pipe'], ...(target.argv0 ? { argv0: target.argv0 } : {}) });
+    feedChildStdin(child, prompt);
     let out = '';
     let err = '';
     // Cap accumulated stdout — the model output shouldn't grow `out` without
@@ -250,6 +253,7 @@ module.exports = {
   parseDocEdit,
   editPrompt,
   runDocEdit,
+  runClaude,
   docEditViaSession,
   MAX_DOC_CONTEXT,
   truncateDocumentText,

package/src/main/ipcSchemas.cjs

@@ -252,7 +252,10 @@ const promptSessionsMergeToMain = z.object({
   // integrateEpicBranch can apply the same carried-wip-only skip the job
   // path already gets. Absent on a worktree created before this field
   // existed, or one whose base tree was clean at creation.
-  carriedPaths: z.array(z.string().min(1).max(4096)).max(2000).optional(),
+  // The renderer sends the Epic's full carried diff (`git diff HEAD --name-only`),
+  // which is uncapped; 3,306 paths were seen on 2026-10-26. A tight cap rejects
+  // every merge for such an Epic.
+  carriedPaths: z.array(z.string().min(1).max(4096)).max(100000).optional(),
 });
 
 // Renderer entry points for the per-project "disable Epic worktree

package/src/main/lib/classifyPromptTicket.cjs

@@ -18,6 +18,7 @@
 const { spawn } = require('node:child_process');
 const { resolveClaudeBin, claudeSpawnTarget } = require('./claude/claudeBin.cjs');
 const { cleanChildEnv, pathWithUserBins } = require('./process/cleanEnv.cjs');
+const { feedChildStdin } = require('./process/childStdin.cjs');
 
 const CLASSIFY_TIMEOUT_MS = 30_000;
 const CLASSIFY_MODEL = 'sonnet';
@@ -61,8 +62,10 @@ function classifyPromptTicket(text) {
       return;
     }
     const childEnv = cleanChildEnv({ PATH: pathWithUserBins() });
+    // The prompt goes on stdin, never argv: a >128 KB argv element fails spawn with E2BIG.
+    const prompt = `${CLASSIFY_PROMPT_PREFIX}${text}`;
     const args = [
-      '-p', `${CLASSIFY_PROMPT_PREFIX}${text}`,
+      '-p',
       '--model', CLASSIFY_MODEL,
       '--strict-mcp-config',
       '--output-format', 'text',
@@ -78,9 +81,11 @@ function classifyPromptTicket(text) {
     };
 
     try {
-      // stdin closed — `claude -p` otherwise blocks waiting for piped stdin.
+      // stdin is a pipe fed with the prompt and then ended (feedChildStdin), so
+      // `claude -p` neither blocks on stdin nor sees an oversized argv element.
       const target = claudeSpawnTarget('aux', 'classify', claudeBin);
-      child = spawnImpl(target.command, args, { env: childEnv, stdio: ['ignore', 'pipe', 'pipe'], ...(target.argv0 ? { argv0: target.argv0 } : {}) });
+      child = spawnImpl(target.command, args, { env: childEnv, stdio: ['pipe', 'pipe', 'pipe'], ...(target.argv0 ? { argv0: target.argv0 } : {}) });
+      feedChildStdin(child, prompt);
     } catch {
       finish('inline');
       return;
@@ -115,4 +120,4 @@ function classifyPromptTicket(text) {
   });
 }
 
-module.exports = { classifyPromptTicket, parseVerdict, CLASSIFY_TIMEOUT_MS, __setSpawnForTest };
+module.exports = { classifyPromptTicket, CLASSIFY_PROMPT_PREFIX, parseVerdict, CLASSIFY_TIMEOUT_MS, __setSpawnForTest };

package/src/main/lib/claude/runClaudeP.cjs

@@ -7,8 +7,9 @@
  * cost-gated synthesis caller (Memory Clusters, the Project Brief) shares one
  * spawn/timeout/output-cap implementation instead of forking it per feature.
  *
- * Pattern: stdin closed ('ignore' — `claude -p` blocks forever waiting for
- * piped stdin otherwise), model pinned explicitly by the caller, hard
+ * Pattern: the prompt is written to stdin (never argv — Linux caps one
+ * argument at 128 KB, E2BIG) and stdin is closed right after the write, never
+ * left open (`claude -p` blocks forever waiting on an open pipe), model pinned explicitly by the caller, hard
  * timeout that resolves {ok:false} rather than hanging, SM_KG_INTERNAL=1 so
  * the prompt-logging hook skips these internal calls, and an output-size cap
  * so a runaway response can't grow `out` unbounded.
@@ -17,6 +18,7 @@
 const { spawn } = require('node:child_process');
 const { resolveClaudeBin, claudeSpawnTarget } = require('./claudeBin.cjs');
 const { headlessPermissionArgs, ensureCliCapsProbed } = require('./claudeCliCaps.cjs');
+const { feedChildStdin } = require('../process/childStdin.cjs');
 const { withProcRole } = require('../process/cleanEnv.cjs');
 
 const MAX_OUT_BYTES = 8 * 1024 * 1024;
@@ -28,7 +30,7 @@ async function runClaudeP(prompt, { model = 'sonnet', timeoutMs = 180_000, syste
     let bin;
     try { bin = resolveClaudeBin(); } catch (e) { resolve({ ok: false, error: `claude not found: ${e?.message}` }); return; }
     const args = [
-      '-p', prompt,
+      '-p',
       '--model', model,
       '--dangerously-skip-permissions',
       ...headlessPermissionArgs(),
@@ -37,7 +39,8 @@ async function runClaudeP(prompt, { model = 'sonnet', timeoutMs = 180_000, syste
     ];
     if (systemPrompt) args.push('--append-system-prompt', systemPrompt);
     const target = claudeSpawnTarget('aux', 'runclaudep', bin);
-    const child = spawn(target.command, args, { env: withProcRole({ ...process.env, SM_KG_INTERNAL: '1' }, 'aux'), stdio: ['ignore', 'pipe', 'pipe'], ...(target.argv0 ? { argv0: target.argv0 } : {}) });
+    const child = spawn(target.command, args, { env: withProcRole({ ...process.env, SM_KG_INTERNAL: '1' }, 'aux'), stdio: ['pipe', 'pipe', 'pipe'], ...(target.argv0 ? { argv0: target.argv0 } : {}) });
+    feedChildStdin(child, prompt);
     let out = '';
     let err = '';
     let killedForSize = false;

package/src/main/lib/process/childStdin.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+/**
+ * childStdin.cjs — write a prompt/text to a child's stdin and close it.
+ *
+ * Why prompts go on stdin, not argv: Linux caps a single argument at
+ * MAX_ARG_STRLEN (131072 bytes) and Windows cmd.exe caps a command line at
+ * 8191 characters; a larger argv element fails the spawn with E2BIG
+ * (incident 2026-10-26, spawn E2BIG). Ending the pipe also satisfies the rule
+ * that `claude -p`'s stdin must be closed (claude CLI 2.1.302 read a 204 KB
+ * prompt from stdin and exited 0).
+ *
+ * The EPIPE handling lives here, in one place: a child that exits without
+ * reading raises an 'error' on the pipe; it is logged once and swallowed.
+ */
+
+/**
+ * @param {{ stdin?: any } | null | undefined} child
+ * @param {string} text
+ * @param {{ log?: (msg: string) => void }} [opts]
+ * @returns {boolean} true when the text was handed to child.stdin
+ */
+function feedChildStdin(child, text, { log } = {}) {
+  if (!child || !child.stdin) return false;
+  let logged = false;
+  // Listener FIRST: the write can fail asynchronously with EPIPE.
+  child.stdin.on('error', (err) => {
+    if (logged) return;
+    logged = true;
+    if (typeof log !== 'function') return;
+    try {
+      log(`[childStdin] stdin write failed (${(err && (err.code || err.message)) || 'unknown'}): the child exited before reading its input\n`);
+    } catch { /* logging must never throw */ }
+  });
+  child.stdin.end(text, 'utf8');
+  return true;
+}
+
+module.exports = { feedChildStdin };

package/src/main/lib/process/childWithLog.cjs

@@ -53,6 +53,7 @@
 const fs = require('node:fs');
 const { spawn, execFile } = require('node:child_process');
 const { killTree } = require('./killTree.cjs');
+const { feedChildStdin } = require('./childStdin.cjs');
 
 // Injectable for tests (enumeration-failure coverage).
 const deps = { execFile };
@@ -205,6 +206,16 @@ function sweepChildProcessGroup(child, detached, safeLog) {
     .then((leaked) => { kill(); return leaked; });
 }
 
+/**
+ * Spawn a child with its stdout/stderr on the log fd and supervise it.
+ *
+ * `spawn.stdinText` (optional string): when given, the child's stdin is a pipe
+ * that receives the text (UTF-8) and is then closed; otherwise stdin is
+ * 'ignore'. It exists because argv is a poor channel for large input: Linux
+ * caps a single argument at MAX_ARG_STRLEN (131072 bytes, spawn E2BIG) and
+ * Windows cmd.exe caps a command line at 8191 characters. A stdin error
+ * (EPIPE when the child never reads) is logged once and otherwise ignored.
+ */
 function withChildAndLog({ fd, logPath, safeLog, closeFd, spawn: spawnSpec, watchdogs = [], onExit }) {
   const startedAt = Date.now();
 
@@ -296,11 +307,12 @@ function withChildAndLog({ fd, logPath, safeLog, closeFd, spawn: spawnSpec, watc
 
   // Attempt synchronous spawn. On failure, call handleDone immediately so the
   // caller's onExit can resolve any pending Promise before we return null.
+  const stdinText = typeof spawnSpec.stdinText === 'string' ? spawnSpec.stdinText : null;
   let child;
   try {
     child = spawn(spawnSpec.command, spawnSpec.args, {
       ...spawnSpec.options,
-      stdio: ['ignore', fd, fd],
+      stdio: [stdinText !== null ? 'pipe' : 'ignore', fd, fd],
     });
   } catch (e) {
     handleDone(-1, null, e, /* spawnFailed */ true);
@@ -309,6 +321,8 @@ function withChildAndLog({ fd, logPath, safeLog, closeFd, spawn: spawnSpec, watc
 
   ctx.child = child;
 
+  if (stdinText !== null) feedChildStdin(child, stdinText, { log: safeLog });
+
   child.on('error', (err) => handleDone(-1, null, err, false));
   child.on('exit', (code, signal) => handleDone(code, signal, undefined, false));
 

package/src/main/lib/scheduler/launchFailure.cjs

@@ -57,6 +57,38 @@ const LAUNCH_FAILURE_KINDS = Object.freeze({
   API_ERROR: 'api_error',
 });
 
+/**
+ * Argv-size guard (incident 2026-10-26, social-signals-trader): an oversized
+ * `-p` argument made `spawn` fail with E2BIG (exit -1 in ~86 ms), which
+ * became `impl_failed:exit_-1` and spawned a fix-plan that failed the same
+ * way. Linux caps ONE argv string at MAX_ARG_STRLEN = 131072 bytes, counting
+ * the NUL terminator. The cause is one job's input, not the persona's
+ * environment, so this never arms the per-persona launch breaker.
+ */
+const MAX_ARG_BYTES = 131072;
+
+/** First argv element whose utf8 bytes + NUL exceed `limit`, else null. */
+function findOversizedArg(args, limit = MAX_ARG_BYTES) {
+  if (!Array.isArray(args)) return null;
+  for (let index = 0; index < args.length; index++) {
+    const a = args[index];
+    if (typeof a !== 'string') continue;
+    const bytes = Buffer.byteLength(a, 'utf8') + 1;
+    if (bytes <= limit) continue;
+    let flag = '(positional)';
+    for (let j = index - 1; j >= 0; j--) {
+      if (typeof args[j] === 'string' && args[j].startsWith('--')) { flag = args[j]; break; }
+    }
+    return { index, flag, bytes };
+  }
+  return null;
+}
+
+/** True when a spawn error message is the OS refusing an oversized argv. */
+function isArgvTooLargeSpawnError(message) {
+  return /E2BIG|ENAMETOOLONG/.test(String(message ?? ''));
+}
+
 /** Tail bytes scanned for the `result` event — same budget classifyRunOutcome uses. */
 const RESULT_TAIL_BYTES = 65536;
 
@@ -310,9 +342,10 @@ function evaluateLaunchGate(block, { now, claudeVersion } = {}) {
  * closed set so operators never have to open a transcript to tell a
  * non-start from an implementation failure from a verifier downgrade.
  */
-function deriveTerminalReason({ effectiveStatus, exitCode, verifyResult, sigtermOverride, worktreeIntegrationFailure, budgetKill }) {
+function deriveTerminalReason({ effectiveStatus, exitCode, verifyResult, sigtermOverride, worktreeIntegrationFailure, budgetKill, launchError }) {
   if (worktreeIntegrationFailure) return 'worktree_integration_failed';
   if (effectiveStatus === 'completed') return 'completed';
+  if (launchError === 'argv_too_large') return 'launch_failure:argv_too_large';
   if (budgetKill) return 'budget_exceeded';
   if (sigtermOverride) return 'signal_kill_with_commit';
   if (exitCode === 143 || exitCode === 137) return 'signal_kill';
@@ -338,6 +371,9 @@ function writeOutcomeSidecar(runDir, slug, outcome) {
 }
 
 module.exports = {
+  MAX_ARG_BYTES,
+  findOversizedArg,
+  isArgvTooLargeSpawnError,
   LAUNCH_FAILURE_KINDS,
   LAUNCH_BLOCK_MAX_ATTEMPTS,
   LAUNCH_PROBE_STALE_MS,