claude-code-session-manager 0.87.0 → 0.88.1

package/src/main/__tests__/runVerify-landed-commit-outranks.test.cjs

@@ -0,0 +1,181 @@
+/**
+ * runVerify-landed-commit-outranks.test.cjs — ground truth (exit 0 + a commit
+ * landed THIS run + no explicit FAIL sentinel) outranks the transcript-
+ * pattern heuristics (final-20% is_error, FAIL/Traceback,
+ * ModuleNotFoundError), so a self-recovered tool error no longer parks a
+ * green, committed run.
+ *
+ * Fixture: the REAL run log for 1218-fo-01-move-scripts-lib-into-src-main-lib
+ * (session-manager-operations/reviews/2026-09-13-scheduler-stability-
+ * investigation.md), copied verbatim from
+ * ~/.claude/session-manager/scheduled-plans/runs/2026-09-13T21-52-51-192Z/ —
+ * a `git apply` "patch does not apply" tool error at event 179/209 (inside
+ * the final 20% of the transcript) that the agent retried and resolved 3
+ * events later, in a run that landed commit d1edf15 and was STILL parked
+ * needs_review (verdicts.json: verdict transcript_errors, reason
+ * "is_error=true in final 20% of transcript (event 179/209)"), spawning a
+ * $3.74 fix-plan investigation into work that needed no fix.
+ *
+ * The real run's own SCHEDULER_VERDICT sentinel is an explicit FAIL — an
+ * honest, UNRELATED report that test:unit was red for proven pre-existing/
+ * environmental reasons (shared /tmp contention), not a regression from this
+ * PRD's move. Per this PRD's own AC, an explicit FAIL sentinel must keep
+ * today's behavior byte-for-byte, so scenarios (a)/(b)/(d) below use a
+ * variant of the fixture with that trailing SCHEDULER_VERDICT line stripped
+ * (sentinel === null) — the majority real-world park shape this rule targets
+ * (the findings report measured 77 of 212 parks as transcript_errors with NO
+ * sentinel at all, vs. this one specific row's own additional, unrelated
+ * FAIL claim). Scenario (c) reuses the pristine, byte-for-byte-unmodified
+ * fixture to prove the real, still-present FAIL sentinel is honored exactly
+ * as before this change.
+ *
+ * Run standalone: timeout 120 npx vitest run src/main/__tests__/runVerify-landed-commit-outranks.test.cjs
+ */
+
+import { test } from 'vitest';
+const assert = require('node:assert/strict');
+const os = require('node:os');
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const { verifyRun } = require('../runVerify.cjs');
+
+const SLUG = '1218-fo-01-move-scripts-lib-into-src-main-lib';
+const FIXTURE_PATH = path.join(__dirname, 'fixtures', `${SLUG}.log`);
+const LANDED_COMMIT = 'd1edf15be50a783f08a55e6de328780f0feb3cb0';
+
+function makeTmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'run-verify-landed-commit-outranks-test-'));
+}
+
+function rmdir(dir) {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* */ }
+}
+
+function makeTmpGitRepo() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'run-verify-landed-commit-outranks-repo-'));
+  execFileSync('git', ['init', '-q'], { cwd: dir });
+  execFileSync('git', ['config', 'user.email', 'test@example.com'], { cwd: dir });
+  execFileSync('git', ['config', 'user.name', 'Test'], { cwd: dir });
+  fs.writeFileSync(path.join(dir, 'README.md'), 'init\n');
+  execFileSync('git', ['add', 'README.md'], { cwd: dir });
+  execFileSync('git', ['commit', '-q', '-m', 'init'], { cwd: dir });
+  return dir;
+}
+
+function writePrd(dir, slug) {
+  const text = '---\ntitle: Test PRD\ncwd: /tmp\nestimateMinutes: 30\n---\n# Move scripts/lib into src/main/lib\n';
+  fs.writeFileSync(path.join(dir, `${slug}.md`), text);
+  return path.join(dir, `${slug}.md`);
+}
+
+/**
+ * Load the real fixture log, optionally stripping the trailing
+ * `SCHEDULER_VERDICT: FAIL ...` line from the final `{"type":"result",...}`
+ * event's `result` field so the sentinel scan sees no sentinel at all.
+ */
+function loadFixture({ stripFailSentinel }) {
+  const raw = fs.readFileSync(FIXTURE_PATH, 'utf8');
+  if (!stripFailSentinel) return raw;
+  const lines = raw.split('\n');
+  const idx = lines.findIndex((l) => l.includes('"type":"result"'));
+  assert.ok(idx !== -1, 'fixture must contain a type:result line');
+  const obj = JSON.parse(lines[idx]);
+  assert.ok(/SCHEDULER_VERDICT:\s*FAIL/.test(obj.result), 'fixture result must carry the real FAIL sentinel before stripping');
+  obj.result = obj.result.replace(/\n?SCHEDULER_VERDICT:\s*FAIL[^\n]*$/, '');
+  assert.ok(!/SCHEDULER_VERDICT/.test(obj.result), 'sentinel must be fully removed from the stripped variant');
+  lines[idx] = JSON.stringify(obj);
+  return lines.join('\n');
+}
+
+function writeLog(dir, slug, text) {
+  fs.writeFileSync(path.join(dir, `${slug}.log`), text);
+}
+
+// (a) exit 0 + commit landed THIS run + no sentinel at all → clean, demoted to annotation.
+test('exit 0 + landed commit this run + no FAIL sentinel → clean with annotation (1218-fo-01)', async () => {
+  const tmp = makeTmpDir();
+  const repo = makeTmpGitRepo();
+  try {
+    writeLog(tmp, SLUG, loadFixture({ stripFailSentinel: true }));
+    const prdPath = writePrd(tmp, SLUG);
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug: SLUG, status: 'running', cwd: repo },
+      allJobs: [],
+      committedDuringRun: false,
+      jobLandedCommitThisRun: LANDED_COMMIT,
+      exitCode: 0,
+    });
+    assert.equal(verdict.verdict, 'clean', `expected clean, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, null);
+    const sidecar = JSON.parse(fs.readFileSync(path.join(tmp, `${SLUG}.verdicts.json`), 'utf8'));
+    assert.ok(Array.isArray(sidecar.annotations) && sidecar.annotations.length > 0, 'the demoted is_error hit must be recorded as an annotation');
+    assert.ok(sidecar.annotations.some((a) => a.verdict === 'transcript_errors'), 'annotation must carry the original transcript_errors verdict');
+  } finally { rmdir(tmp); rmdir(repo); }
+});
+
+// (b) the same (stripped-sentinel) log, but exitCode !== 0 → keeps today's behavior.
+test('non-zero exit → transcript_errors (evidence never applies to a failing run)', async () => {
+  const tmp = makeTmpDir();
+  const repo = makeTmpGitRepo();
+  try {
+    writeLog(tmp, SLUG, loadFixture({ stripFailSentinel: true }));
+    const prdPath = writePrd(tmp, SLUG);
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug: SLUG, status: 'running', cwd: repo },
+      allJobs: [],
+      committedDuringRun: false,
+      jobLandedCommitThisRun: LANDED_COMMIT,
+      exitCode: 1,
+    });
+    assert.equal(verdict.verdict, 'transcript_errors', `expected transcript_errors, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, 'needs_review');
+  } finally { rmdir(tmp); rmdir(repo); }
+});
+
+// (c) the pristine, byte-for-byte-unmodified fixture — its own real FAIL sentinel — keeps today's behavior.
+test('explicit FAIL sentinel (the real, unmodified fixture) → transcript_errors byte-for-byte', async () => {
+  const tmp = makeTmpDir();
+  const repo = makeTmpGitRepo();
+  try {
+    writeLog(tmp, SLUG, loadFixture({ stripFailSentinel: false }));
+    const prdPath = writePrd(tmp, SLUG);
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug: SLUG, status: 'running', cwd: repo },
+      allJobs: [],
+      committedDuringRun: false,
+      jobLandedCommitThisRun: LANDED_COMMIT,
+      exitCode: 0,
+    });
+    assert.equal(verdict.verdict, 'transcript_errors', `expected transcript_errors, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, 'needs_review');
+    assert.equal(verdict.sentinel, 'fail');
+  } finally { rmdir(tmp); rmdir(repo); }
+});
+
+// (d) no landed-commit evidence at all → transcript_errors (evidence gate requires attribution).
+test('no landed commit evidence → transcript_errors (evidence gate requires attribution)', async () => {
+  const tmp = makeTmpDir();
+  const repo = makeTmpGitRepo();
+  try {
+    writeLog(tmp, SLUG, loadFixture({ stripFailSentinel: true }));
+    const prdPath = writePrd(tmp, SLUG);
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug: SLUG, status: 'running', cwd: repo },
+      allJobs: [],
+      committedDuringRun: false,
+      jobLandedCommitThisRun: null,
+      exitCode: 0,
+    });
+    assert.equal(verdict.verdict, 'transcript_errors', `expected transcript_errors, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, 'needs_review');
+  } finally { rmdir(tmp); rmdir(repo); }
+});

package/src/main/__tests__/runVerify.test.cjs

@@ -1140,7 +1140,7 @@ function noOpRunEvents(resultText) {
 test('no_verdict_sentinel: no tool_result issues, no sentinel, no commit → needs_review', async () => {
   const tmp = makeTmpDir();
   try {
-    const slug = '406-browser-capture-panel-ui';
+    const slug = '406-capture-panel-ui';
     writeLog(tmp, slug, noOpRunEvents('I need clarification on which capture API to target before proceeding.'));
     const prdPath = writePrd(tmp, slug, '# Browser capture panel UI');
     const verdict = await verifyRun({
@@ -1160,7 +1160,7 @@ test('no_verdict_sentinel: no tool_result issues, no sentinel, no commit → nee
 test('no_verdict_sentinel guard: same run but committedDuringRun:true → stays clean', async () => {
   const tmp = makeTmpDir();
   try {
-    const slug = '406-browser-capture-panel-ui-committed';
+    const slug = '406-capture-panel-ui-committed';
     writeLog(tmp, slug, noOpRunEvents('I need clarification on which capture API to target before proceeding.'));
     const prdPath = writePrd(tmp, slug, '# Browser capture panel UI');
     const verdict = await verifyRun({
@@ -1180,7 +1180,7 @@ test('no_verdict_sentinel guard: same run but committedDuringRun:true → stays
 test('no_verdict_sentinel guard: same run but with SCHEDULER_VERDICT: PASS sentinel + a commit → stays clean', async () => {
   const tmp = makeTmpDir();
   try {
-    const slug = '406-browser-capture-panel-ui-sentinel';
+    const slug = '406-capture-panel-ui-sentinel';
     writeLog(tmp, slug, noOpRunEvents('All acceptance criteria verified.\nSCHEDULER_VERDICT: PASS'));
     const prdPath = writePrd(tmp, slug, '# Browser capture panel UI');
     const verdict = await verifyRun({
@@ -1634,7 +1634,7 @@ test('isMergeMainSlug matches the NN-prXXX-merge-main and NN-fix-prXXX-merge-mai
   assert.equal(isMergeMainSlug('565-pr188-merge-main'), true);
   assert.equal(isMergeMainSlug('571-fix-pr141-merge-main'), true);
   assert.equal(isMergeMainSlug('523-fix-bounded-fix-plan-retry'), false);
-  assert.equal(isMergeMainSlug('406-browser-capture-panel-ui'), false);
+  assert.equal(isMergeMainSlug('406-capture-panel-ui'), false);
   assert.equal(isMergeMainSlug(''), false);
   assert.equal(isMergeMainSlug(undefined), false);
 });
@@ -1727,7 +1727,7 @@ test('merge-main exemption: gh call throws → falls through to pass_no_commit,
 test('merge-main exemption: non-merge-main slug never attempts a gh call', async () => {
   const tmp = makeTmpDir();
   try {
-    const slug = '406-browser-capture-panel-ui';
+    const slug = '406-capture-panel-ui';
     writeLog(tmp, slug, noOpRunEvents('All acceptance criteria verified.\nSCHEDULER_VERDICT: PASS'));
     const prdPath = writePrd(tmp, slug, '# Browser capture panel UI');
     let ghCalls = 0;

package/src/main/__tests__/scheduleJobStatusDrift.test.cjs

@@ -6,7 +6,7 @@
  * is types-only (erased at build time, nothing to import at test runtime), so
  * each consumer keeps its own hand-written mirror of the status enum:
  *   - src/preload/api.d.ts's `ScheduleJobStatus` union
- *   - src/renderer/components/ui/StatusBadge.tsx's `JobStatus` union
+ *   - src/renderer/lib/jobStatus.ts's `JobStatus` union
  *   - src/renderer/components/SchedulePanel.tsx's `FilterStatus` union
  *     (which also carries the UI-only 'all' meta-value)
  *
@@ -52,8 +52,8 @@ test('src/preload/api.d.ts ScheduleJobStatus matches JOB_STATUSES', () => {
   expect(sorted(values)).toEqual(sorted(JOB_STATUSES));
 });
 
-test('src/renderer/components/ui/StatusBadge.tsx JobStatus matches JOB_STATUSES', () => {
-  const source = readSource('src/renderer/components/ui/StatusBadge.tsx');
+test('src/renderer/lib/jobStatus.ts JobStatus matches JOB_STATUSES', () => {
+  const source = readSource('src/renderer/lib/jobStatus.ts');
   const values = extractQuotedList(source, /export type JobStatus = ([^\n]+)/);
   expect(sorted(values)).toEqual(sorted(JOB_STATUSES));
 });

package/src/main/__tests__/scheduleJobTransitions.test.cjs

@@ -24,8 +24,8 @@ function uniqueSlug(label) {
 }
 
 function readAuditRecordsForSlug(slug) {
-  if (!fs.existsSync(auditLog.AUDIT_LOG_PATH)) return [];
-  return fs.readFileSync(auditLog.AUDIT_LOG_PATH, 'utf8')
+  if (!fs.existsSync(auditLog.auditLogPath())) return [];
+  return fs.readFileSync(auditLog.auditLogPath(), 'utf8')
     .split('\n')
     .filter(Boolean)
     .map((line) => {

package/src/main/__tests__/scheduler-adopted-run-supervision.test.cjs

@@ -0,0 +1,143 @@
+/**
+ * scheduler-adopted-run-supervision.test.cjs — an executor the boot spared
+ * (`adoptedAtBoot`) is supervised like a freshly spawned one: budget, idle-tail
+ * and deadman re-armed from the durable record, quietMachine lease re-acquired,
+ * and a budget kill parks needs_review/budget_exceeded via classifyBudgetKill.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-adopted-run-supervision.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, vi, beforeEach, afterEach } from 'vitest';
+const { superviseAdoptedRuns, evaluateAdoptedRun } = require('../lib/adoptedRunSupervisor.cjs');
+const quietMachineLease = require('../lib/quietMachineLease.cjs');
+const { classifyBudgetKill } = require('../scheduler.cjs');
+
+const MIN = 60_000;
+const T0 = Date.parse('2026-09-18T12:00:00Z');
+
+beforeEach(() => {
+  vi.useFakeTimers();
+  vi.setSystemTime(T0);
+  quietMachineLease.__resetForTests();
+});
+afterEach(() => {
+  vi.useRealTimers();
+  quietMachineLease.__resetForTests();
+});
+
+function harness({ rows, records, logMtimeMs = () => Date.now(), alive = () => true }) {
+  const kills = [];
+  const stamps = [];
+  const supervised = [];
+  const registry = new Map();
+  const ctx = {
+    registry,
+    runDir: (j) => `/runs/${j.runId}`,
+    readRecord: (_dir, slug) => records[slug] ?? null,
+    lease: quietMachineLease,
+    markSupervised: async (j) => { supervised.push(j.slug); },
+    makeDeps: (j, record) => ({
+      logPath: `/runs/${j.runId}/${j.slug}.log`,
+      statLogMtimeMs: () => logMtimeMs(j.slug),
+      pidAlive: alive,
+      identityOf: () => record.identity,
+      isDifferentProcess: () => false,
+      killGroup: (pgid, signal) => { kills.push({ slug: j.slug, pgid, signal }); },
+      stampKill: async (kind, reason) => { stamps.push({ slug: j.slug, kind, reason }); },
+      checkIntervalMs: MIN,
+      sigkillAfterMs: 30_000,
+      defaultMaxDurationMs: 4 * 60 * MIN,
+    }),
+  };
+  return { ctx, kills, stamps, supervised, registry, run: () => superviseAdoptedRuns(rows, ctx) };
+}
+
+const row = (slug, extra = {}) => ({ slug, status: 'running', runId: 'r1', adoptedAtBoot: new Date(T0).toISOString(), ...extra });
+const record = (slug, extra = {}) => ({
+  slug, pid: 4242, pgid: 4242, identity: { startTicks: 1 }, startedAt: T0, budgetMs: 45 * MIN, maxDurationMs: null, idleKillMs: 20 * MIN, ...extra,
+});
+
+test('an adopted run past its budget is killed and its budget kill classifies needs_review/budget_exceeded', async () => {
+  const h = harness({ rows: [row('over')], records: { over: record('over', { startedAt: T0 - 50 * MIN }) } });
+  expect(await h.run()).toEqual(['over']);
+  await vi.advanceTimersByTimeAsync(0);
+  expect(h.stamps).toHaveLength(1);
+  expect(h.stamps[0].kind).toBe('budget');
+  expect(h.kills).toEqual([{ slug: 'over', pgid: 4242, signal: 'SIGTERM' }]);
+  // SIGKILL follows if the group survives SIGTERM.
+  await vi.advanceTimersByTimeAsync(30_000);
+  expect(h.kills.map((k) => k.signal)).toEqual(['SIGTERM', 'SIGKILL']);
+  // Same classifier as a native budget kill.
+  const outcome = classifyBudgetKill({ killedByWatchdog: h.stamps[0].kind, budgetKillReason: h.stamps[0].reason, exitCode: null }, null);
+  expect(outcome.status).toBe('needs_review');
+  expect(outcome.reason).toMatch(/wall-clock budget exceeded/);
+});
+
+test('a run within budget is untouched until the interval crosses the budget', async () => {
+  const h = harness({ rows: [row('ok')], records: { ok: record('ok', { startedAt: T0 - 10 * MIN }) } });
+  await h.run();
+  await vi.advanceTimersByTimeAsync(5 * MIN);
+  expect(h.kills).toEqual([]);
+  expect(h.stamps).toEqual([]);
+  // 10m + 36m elapsed > 45m budget: the re-armed interval now fires.
+  await vi.advanceTimersByTimeAsync(31 * MIN);
+  expect(h.stamps.map((s) => s.kind)).toEqual(['budget']);
+  expect(h.kills[0].signal).toBe('SIGTERM');
+});
+
+test('idle-tail: a stalled log past idleKillMs is SIGTERMed; deadman SIGKILLs at maxDurationMs', async () => {
+  const idle = harness({
+    rows: [row('idle')], records: { idle: record('idle', { startedAt: T0 - 5 * MIN }) },
+    logMtimeMs: () => T0 - 25 * MIN,
+  });
+  await idle.run();
+  await vi.advanceTimersByTimeAsync(0);
+  expect(idle.stamps.map((s) => s.kind)).toEqual(['idle-tail']);
+  expect(idle.kills[0].signal).toBe('SIGTERM');
+
+  const dead = harness({
+    rows: [row('dm')], records: { dm: record('dm', { startedAt: T0 - 5 * MIN, budgetMs: null, maxDurationMs: 4 * 60 * MIN }) },
+  });
+  await dead.run();
+  await vi.advanceTimersByTimeAsync(4 * 60 * MIN);
+  expect(dead.stamps.map((s) => s.kind)).toEqual(['deadman']);
+  expect(dead.kills.map((k) => k.signal)).toEqual(['SIGKILL']);
+});
+
+test('a null record.maxDurationMs falls back to the native 4h deadman', () => {
+  const rec = record('x', { budgetMs: null, startedAt: T0 - 5 * 60 * MIN });
+  expect(evaluateAdoptedRun(rec, { now: T0, logMtimeMs: T0, defaultMaxDurationMs: 4 * 60 * MIN })?.kind).toBe('deadman');
+});
+
+test('the quietMachine lease is re-acquired, supervisedAt stamped once, and an exempt (null budget) run is not budget-killed', async () => {
+  const h = harness({
+    rows: [row('quiet', { quietMachine: true })],
+    records: { quiet: record('quiet', { budgetMs: null, startedAt: T0 - 90 * MIN }) },
+  });
+  expect(await h.run()).toEqual(['quiet']);
+  expect(quietMachineLease.holder()).toBe('quiet');
+  expect(h.supervised).toEqual(['quiet']);
+  await vi.advanceTimersByTimeAsync(10 * MIN);
+  expect(h.kills).toEqual([]);
+  // A second dispatch-loop pass does not re-arm or re-stamp.
+  expect(await h.run()).toEqual([]);
+  expect(h.supervised).toEqual(['quiet']);
+});
+
+test('a pid that is gone is never signalled; rows that stop running drop their supervisor', async () => {
+  const h = harness({
+    rows: [row('gone')], records: { gone: record('gone', { startedAt: T0 - 90 * MIN }) }, alive: () => false,
+  });
+  await h.run();
+  await vi.advanceTimersByTimeAsync(2 * MIN);
+  expect(h.kills).toEqual([]);
+  expect(h.stamps).toEqual([]);
+
+  const live = harness({ rows: [row('fin')], records: { fin: record('fin') } });
+  await live.run();
+  expect(live.registry.size).toBe(1);
+  await superviseAdoptedRuns([{ slug: 'fin', status: 'completed', runId: 'r1' }], live.ctx);
+  expect(live.registry.size).toBe(0);
+});

package/src/main/__tests__/scheduler-autofix-select.test.cjs

@@ -1,12 +1,12 @@
 /**
  * scheduler-autofix-select.test.cjs — unit tests for selectAutoFixTargets.
  *
- * Run: timeout 120 node --test src/main/__tests__/scheduler-autofix-select.test.cjs
+ * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-autofix-select.test.cjs
  */
 
 'use strict';
 
-const { test } = require('node:test');
+import { test } from 'vitest';
 const assert = require('node:assert/strict');
 const {
   selectAutoFixTargets, isUnresolvableNeedsReview, isRescanCandidate,

package/src/main/__tests__/scheduler-autopromote.test.cjs

@@ -1,12 +1,12 @@
 /**
  * scheduler-autopromote.test.cjs — unit tests for isPromotableOriginal.
  *
- * Run: timeout 120 node --test src/main/__tests__/scheduler-autopromote.test.cjs
+ * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-autopromote.test.cjs
  */
 
 'use strict';
 
-const { test } = require('node:test');
+import { test } from 'vitest';
 const assert = require('node:assert/strict');
 const { isPromotableOriginal, healTargetForFix } = require('../scheduler.cjs');
 

package/src/main/__tests__/scheduler-bash-timeout-env.test.cjs

@@ -26,6 +26,7 @@ import { test, expect, beforeAll, afterAll, afterEach } from 'vitest';
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
+const claudeStub = require('../../../tests/helpers/claudeStub.cjs');
 
 let tmpHome;
 let originalHome;
@@ -53,8 +54,7 @@ afterEach(() => {
 // Stub `claude` binary: dumps the two env vars it received into a marker
 // file, then emits a stream-json success result and exits 0.
 function writeClaudeStub() {
-  const stubPath = path.join(os.tmpdir(), `sm-claude-stub-env-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
-  const body = `
+  return claudeStub.writeClaudeStub({ body: `
     const fs = require('fs');
     const path = require('path');
     fs.writeFileSync(path.join(process.cwd(), 'env.marker'), JSON.stringify({
@@ -63,9 +63,7 @@ function writeClaudeStub() {
     }), 'utf8');
     process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok' }) + '\\n');
     process.exit(0);
-  `;
-  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}\n`, { mode: 0o755 });
-  return stubPath;
+  ` });
 }
 
 test('BASH_MAX_TIMEOUT_MS stays strictly below IDLE_OUTPUT_KILL_MS with real margin', () => {