claude-code-session-manager 0.75.3 → 0.77.0

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

@@ -1197,6 +1197,100 @@ test('no_verdict_sentinel guard: same run but with SCHEDULER_VERDICT: PASS senti
   }
 });
 
+// ─── abandoned_background_task: auto-backgrounded Bash + no sentinel/commit ─
+
+/** A run whose Bash command hit the harness's 120s foreground timeout and was
+ *  auto-backgrounded, then the run ended without ever coming back to commit
+ *  or emit the finish-protocol sentinel. */
+function abandonedBackgroundTaskRunEvents(resultText) {
+  return [
+    {
+      type: 'assistant',
+      message: {
+        role: 'assistant',
+        content: [{
+          type: 'tool_use',
+          id: 'toolu_bg_001',
+          name: 'Bash',
+          input: { command: 'npm run test:unit', description: 'Run full unit suite' },
+        }],
+      },
+    },
+    {
+      type: 'user',
+      message: {
+        role: 'user',
+        content: [{
+          type: 'tool_result',
+          tool_use_id: 'toolu_bg_001',
+          content: 'Command did not complete within its 120s timeout and was moved to the background (ID: bcn1lpvpd). Output is being written to: /tmp/claude-1000/tasks/bcn1lpvpd.output. You will be notified when it completes. To check interim output, use Read on that file path.',
+          is_error: false,
+        }],
+      },
+    },
+    { type: 'result', subtype: 'success', result: resultText },
+  ];
+}
+
+test('abandoned_background_task: background marker + no sentinel + no commit → abandoned_background_task', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '1116-encyclopedia-animations-section';
+    writeLog(tmp, slug, abandonedBackgroundTaskRunEvents('Waiting for the backgrounded test run to finish.'));
+    const prdPath = writePrd(tmp, slug, '# Encyclopedia animations section');
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running' },
+      allJobs: [],
+      committedDuringRun: false,
+    });
+    assert.equal(verdict.verdict, 'abandoned_background_task', `expected abandoned_background_task, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, 'needs_review');
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+test('abandoned_background_task guard: no background marker, no sentinel, no commit → stays plain no_verdict_sentinel', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '1116-no-background-marker';
+    writeLog(tmp, slug, noOpRunEvents('I need clarification on which capture API to target before proceeding.'));
+    const prdPath = writePrd(tmp, slug, '# Encyclopedia animations section');
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running' },
+      allJobs: [],
+      committedDuringRun: false,
+    });
+    assert.equal(verdict.verdict, 'no_verdict_sentinel', `expected plain no_verdict_sentinel, got ${verdict.verdict}: ${verdict.reason}`);
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+test('abandoned_background_task guard: background marker present but run DID commit → clean', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '1116-background-marker-but-committed';
+    writeLog(tmp, slug, abandonedBackgroundTaskRunEvents('Backgrounded test run finished green; work committed.'));
+    const prdPath = writePrd(tmp, slug, '# Encyclopedia animations section');
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running' },
+      allJobs: [],
+      committedDuringRun: true,
+    });
+    assert.equal(verdict.verdict, 'clean', `background marker with a landed commit should stay clean, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, null);
+  } finally {
+    rmdir(tmp);
+  }
+});
+
 // ─── pass_no_commit: PASS sentinel with no commit is not "clean" ───────────
 
 test('pass_no_commit: SCHEDULER_VERDICT: PASS but no commit landed → needs_review', async () => {

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

@@ -12,6 +12,7 @@ const {
   selectAutoFixTargets, isUnresolvableNeedsReview, isRescanCandidate,
   healTargetForFix, isFixPlanBeyondDepthCap, MAX_INVESTIGATION_DEPTH,
   isEligibleForImmediateAutoFix, isExhaustedAutoFix, isPlanUnqueued, fixSlugFor,
+  applyRcaClassification,
 } = require('../scheduler.cjs');
 
 const noSiblingOnDisk = () => false;
@@ -211,6 +212,12 @@ test('invariant: plan outcome WITH a queue row → not a target and NOT annotate
   assert.strictEqual(isAnnotatable, false);
 });
 
+test('excludes a job whose rcaRecoveryAction is archive (already-shipped stale re-run must never buy a fix-plan)', () => {
+  const jobs = [makeJob({ rcaRecoveryAction: 'archive', rcaFailureClass: 'already-shipped' })];
+  const result = selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk });
+  assert.strictEqual(result.length, 0);
+});
+
 test('excludes when fix sibling exists on disk', () => {
   const jobs = [makeJob()];
   // fixSlug = '05-fix-my-feature'
@@ -267,12 +274,18 @@ test('depth-1 (ordinary, no investigationDepth field) needs_review job is eligib
   assert.strictEqual(result.length, 1);
 });
 
-test('fix-plan job with investigationDepth: 2 is now ALSO eligible', () => {
-  const jobs = [makeJob({ slug: '05-fix-foo', investigationDepth: 2 })];
+test('fix-plan job with investigationDepth: 1 is still eligible (its first -fix follow-up)', () => {
+  const jobs = [makeJob({ slug: '05-fix-foo', investigationDepth: 1 })];
   const result = selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk });
   assert.strictEqual(result.length, 1);
 });
 
+test('fix-plan job with investigationDepth: 2 is now NOT eligible (cap lowered to permit at most -fix-fix)', () => {
+  const jobs = [makeJob({ slug: '05-fix-foo', investigationDepth: 2 })];
+  const result = selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk });
+  assert.strictEqual(result.length, 0);
+});
+
 test('fix-plan job with investigationDepth: 3 is NOT eligible (bound holds)', () => {
   const jobs = [makeJob({ slug: '05-fix-foo', investigationDepth: 3 })];
   const result = selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk });
@@ -289,7 +302,7 @@ test('isFixPlanBeyondDepthCap: non-fix-plan slug is never capped regardless of d
   assert.strictEqual(isFixPlanBeyondDepthCap('05-my-feature', 99), false);
 });
 
-test('isFixPlanBeyondDepthCap: fix-plan at depth 1 or 2 is not capped, depth 3 is', () => {
+test('isFixPlanBeyondDepthCap: fix-plan at depth 1 is not capped, depth 2 is', () => {
   assert.strictEqual(isFixPlanBeyondDepthCap('05-fix-foo', 1), false);
   assert.strictEqual(isFixPlanBeyondDepthCap('05-fix-foo', MAX_INVESTIGATION_DEPTH), false);
   assert.strictEqual(isFixPlanBeyondDepthCap('05-fix-foo', MAX_INVESTIGATION_DEPTH + 1), true);
@@ -349,6 +362,12 @@ test('isEligibleForImmediateAutoFix: fix-plan job beyond the depth cap is exclud
   assert.strictEqual(result, false);
 });
 
+test('isEligibleForImmediateAutoFix: fix-plan job at investigationDepth 2 is now excluded (previously eligible under the old cap)', () => {
+  const job = makeJob({ slug: '05-fix-foo', investigationDepth: 2 });
+  const result = isEligibleForImmediateAutoFix(job, [job], noSiblingOnDisk);
+  assert.strictEqual(result, false);
+});
+
 test('isEligibleForImmediateAutoFix: a different job in the same queue does not affect this job\'s eligibility', () => {
   const job = makeJob();
   const other = { slug: '05-fix-my-feature', status: 'pending', runId: null };
@@ -364,4 +383,40 @@ test('isEligibleForImmediateAutoFix: a job whose status is not needs_review (e.g
   assert.strictEqual(result, false);
 });
 
+// ---- applyRcaClassification (persists writeRcaReport's verdict onto the job row) ----
+
+test('applyRcaClassification: persists failureClass + recoveryAction onto a needs_review job', () => {
+  const job = makeJob({ status: 'needs_review' });
+  const applied = applyRcaClassification(job, { filed: true, failureClass: 'already-shipped', recoveryAction: 'archive' });
+  assert.strictEqual(applied, true);
+  assert.strictEqual(job.rcaFailureClass, 'already-shipped');
+  assert.strictEqual(job.rcaRecoveryAction, 'archive');
+});
+
+test('applyRcaClassification: no-op when the report was never filed', () => {
+  const job = makeJob({ status: 'needs_review' });
+  const applied = applyRcaClassification(job, { filed: false, reason: 'disabled' });
+  assert.strictEqual(applied, false);
+  assert.strictEqual(job.rcaFailureClass, undefined);
+});
+
+test('applyRcaClassification: no-op when the job has moved off needs_review', () => {
+  const job = makeJob({ status: 'completed' });
+  const applied = applyRcaClassification(job, { filed: true, failureClass: 'unknown', recoveryAction: 'investigate' });
+  assert.strictEqual(applied, false);
+  assert.strictEqual(job.rcaFailureClass, undefined);
+});
+
+test('applyRcaClassification: no-op when the job is missing (e.g. slug lookup miss)', () => {
+  const applied = applyRcaClassification(undefined, { filed: true, failureClass: 'unknown', recoveryAction: 'investigate' });
+  assert.strictEqual(applied, false);
+});
+
+test('applyRcaClassification result feeds selectAutoFixTargets: an archive-classified job is excluded', () => {
+  const job = makeJob({ status: 'needs_review' });
+  applyRcaClassification(job, { filed: true, failureClass: 'already-shipped', recoveryAction: 'archive' });
+  const result = selectAutoFixTargets([job], { fixSlugExists: noSiblingOnDisk });
+  assert.strictEqual(result.length, 0);
+});
+
 console.log('scheduler-autofix-select tests: PASS');

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

@@ -0,0 +1,103 @@
+/**
+ * scheduler-bash-timeout-env.test.cjs — PRD 1097.
+ *
+ * A headless `claude -p` job inherits the harness's 120s default foreground
+ * Bash timeout. Any legit gate command (a test suite, a build) that runs
+ * long gets auto-backgrounded, and the tool result promises a notification
+ * that a single-shot headless run can never receive — the run dead-ends
+ * with no commit and no verdict. The fix is to raise
+ * BASH_DEFAULT_TIMEOUT_MS / BASH_MAX_TIMEOUT_MS on the spawned child's env.
+ *
+ * This proves:
+ *   1. executeJob's real spawned child actually receives both env vars, with
+ *      the exported constant values (not just that the constants exist).
+ *   2. BASH_MAX_TIMEOUT_MS stays strictly below IDLE_OUTPUT_KILL_MS — the
+ *      coupling that makes this more than a one-liner: a long foreground
+ *      Bash emits no stream-json events, so the log mtime stalls and the
+ *      idle-tail watchdog would SIGTERM the job mid-gate if the two ever
+ *      crossed.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-bash-timeout-env.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeAll, afterAll, afterEach } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+let tmpHome;
+let originalHome;
+let executeJob;
+let BASH_DEFAULT_TIMEOUT_MS;
+let BASH_MAX_TIMEOUT_MS;
+let IDLE_OUTPUT_KILL_MS;
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-bash-timeout-env-'));
+  process.env.HOME = tmpHome;
+  ({ executeJob, BASH_DEFAULT_TIMEOUT_MS, BASH_MAX_TIMEOUT_MS, IDLE_OUTPUT_KILL_MS } = require('../scheduler.cjs'));
+});
+
+afterAll(() => {
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+afterEach(() => {
+  delete process.env.SM_CLAUDE_BIN;
+});
+
+// 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 = `
+    const fs = require('fs');
+    const path = require('path');
+    fs.writeFileSync(path.join(process.cwd(), 'env.marker'), JSON.stringify({
+      BASH_DEFAULT_TIMEOUT_MS: process.env.BASH_DEFAULT_TIMEOUT_MS,
+      BASH_MAX_TIMEOUT_MS: process.env.BASH_MAX_TIMEOUT_MS,
+    }), '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', () => {
+  expect(typeof BASH_DEFAULT_TIMEOUT_MS).toBe('number');
+  expect(typeof BASH_MAX_TIMEOUT_MS).toBe('number');
+  expect(typeof IDLE_OUTPUT_KILL_MS).toBe('number');
+  expect(BASH_DEFAULT_TIMEOUT_MS).toBeLessThanOrEqual(BASH_MAX_TIMEOUT_MS);
+  expect(BASH_MAX_TIMEOUT_MS).toBeLessThan(IDLE_OUTPUT_KILL_MS);
+  // Real margin, not a razor's edge.
+  expect(IDLE_OUTPUT_KILL_MS - BASH_MAX_TIMEOUT_MS).toBeGreaterThanOrEqual(60_000);
+});
+
+test('executeJob spawns the executor child with BASH_DEFAULT_TIMEOUT_MS and BASH_MAX_TIMEOUT_MS set', async () => {
+  const mainCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-bash-timeout-main-'));
+  fs.mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
+  const runDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'sm-bash-timeout-run-'));
+  try {
+    const slug = `1097-test-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
+    const prdsDir = path.join(mainCwd, 'session-manager-operations', 'scheduler', 'prds');
+    fs.mkdirSync(prdsDir, { recursive: true });
+    fs.writeFileSync(path.join(prdsDir, `${slug}.md`), 'Verify the env vars are set.', 'utf8');
+    process.env.SM_CLAUDE_BIN = writeClaudeStub();
+
+    const job = { slug, cwd: mainCwd };
+    const result = await executeJob(job, runDir, mainCwd, () => Promise.resolve());
+
+    expect(result.exitCode).toBe(0);
+    const marker = JSON.parse(fs.readFileSync(path.join(mainCwd, 'env.marker'), 'utf8'));
+    expect(marker.BASH_DEFAULT_TIMEOUT_MS).toBe(String(BASH_DEFAULT_TIMEOUT_MS));
+    expect(marker.BASH_MAX_TIMEOUT_MS).toBe(String(BASH_MAX_TIMEOUT_MS));
+  } finally {
+    fs.rmSync(mainCwd, { recursive: true, force: true });
+    fs.rmSync(runDir, { recursive: true, force: true });
+  }
+});

package/src/main/__tests__/scheduler-commit-guard-noop.test.cjs

@@ -165,6 +165,47 @@ test('commitGuardVerdict: self-commit skip still works (regression check)', () =
   expect(verdict).toBeNull();
 });
 
+test('commitGuardVerdict: ranInWorktree=true defeats siblingRunning — clean tree, no self-commit → silent_no_op (PRD 109 shape)', () => {
+  const verdict = commitGuardVerdict({
+    newlyDirty: [],
+    siblingRunning: true,
+    ranInWorktree: true,
+    jobSelfCommitted: false,
+    legitimateNoOp: false,
+    isFixPlanJob: false,
+    verifyResult: null,
+  });
+  expect(verdict).not.toBeNull();
+  expect(verdict.verdict).toBe('silent_no_op');
+  expect(verdict.downgradeTo).toBe('needs_review');
+});
+
+test('commitGuardVerdict: identical inputs with ranInWorktree=false → no flag (legacy shared-tree behaviour unchanged)', () => {
+  const verdict = commitGuardVerdict({
+    newlyDirty: [],
+    siblingRunning: true,
+    ranInWorktree: false,
+    jobSelfCommitted: false,
+    legitimateNoOp: false,
+    isFixPlanJob: false,
+    verifyResult: null,
+  });
+  expect(verdict).toBeNull();
+});
+
+test('commitGuardVerdict: ranInWorktree=true + siblingRunning=true but jobSelfCommitted=true → no flag (self-commit carve-out still applies)', () => {
+  const verdict = commitGuardVerdict({
+    newlyDirty: [],
+    siblingRunning: true,
+    ranInWorktree: true,
+    jobSelfCommitted: true,
+    legitimateNoOp: false,
+    isFixPlanJob: false,
+    verifyResult: null,
+  });
+  expect(verdict).toBeNull();
+});
+
 test('commitGuardVerdict: carries forward a non-clean prior verdict as an annotation', () => {
   const verifyResult = {
     verdict: 'transcript_errors',

package/src/main/__tests__/scheduler-effective-concurrency.test.cjs

@@ -69,3 +69,13 @@ test('free is net of held slots — a chat run shrinks it without changing cap',
   expect(payload.effectiveConcurrency).toEqual({ cap: 5, free: 4, source: 'env' });
   sessionSlots.release(token);
 });
+
+test('a row-level gateOutcome field survives the payload build unchanged (pass-through only, PRD 1109)', () => {
+  const state = fakeState();
+  state.jobs = [
+    { slug: 'a', status: 'failed', gateOutcome: 'never_ran' },
+    { slug: 'b', status: 'completed', gateOutcome: 'passed' },
+  ];
+  const payload = buildScheduleStatePayload(state);
+  expect(payload.jobs.map((j) => j.gateOutcome)).toEqual(['never_ran', 'passed']);
+});

package/src/main/__tests__/scheduler-foreign-wip-manifest.test.cjs

@@ -0,0 +1,78 @@
+/**
+ * scheduler-foreign-wip-manifest.test.cjs — capDirtyPaths/buildForeignWipSection,
+ * the pure helpers behind the pre-run foreign-WIP manifest injected into the
+ * executor prompt (see the "starry-night-ships PRD 148" postmortem: a job
+ * running in a shared or WIP-carrying tree must be told explicitly which
+ * paths it does not own, rather than having to bisect by content).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-foreign-wip-manifest.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const {
+  capDirtyPaths,
+  buildForeignWipSection,
+  PRE_RUN_DIRTY_PATHS_CAP,
+  FOREIGN_WIP_DELIMITER,
+  FOREIGN_WIP_END_DELIMITER,
+} = require('../scheduler.cjs');
+
+test('capDirtyPaths: [] for null/undefined/empty input', () => {
+  expect(capDirtyPaths(null)).toEqual([]);
+  expect(capDirtyPaths(undefined)).toEqual([]);
+  expect(capDirtyPaths([])).toEqual([]);
+});
+
+test('capDirtyPaths: returns the list unchanged when under the cap', () => {
+  expect(capDirtyPaths(['a.js', 'b.js'])).toEqual(['a.js', 'b.js']);
+});
+
+test('capDirtyPaths: truncates at the cap and appends a "+N more" marker', () => {
+  const many = Array.from({ length: PRE_RUN_DIRTY_PATHS_CAP + 7 }, (_, i) => `file-${i}.txt`);
+  const capped = capDirtyPaths(many);
+  expect(capped).toHaveLength(PRE_RUN_DIRTY_PATHS_CAP + 1);
+  expect(capped.slice(0, PRE_RUN_DIRTY_PATHS_CAP)).toEqual(many.slice(0, PRE_RUN_DIRTY_PATHS_CAP));
+  expect(capped[PRE_RUN_DIRTY_PATHS_CAP]).toBe('+7 more');
+});
+
+test('buildForeignWipSection: "" when both lists are empty/absent (clean spawn) — zero prompt tokens added', () => {
+  expect(buildForeignWipSection({})).toBe('');
+  expect(buildForeignWipSection({ preRunDirtyPaths: [], carriedPaths: [] })).toBe('');
+  expect(buildForeignWipSection()).toBe('');
+});
+
+test('buildForeignWipSection: shared dirty tree emits the manifest with the delimiter, paths verbatim, and do-not-touch wording', () => {
+  const section = buildForeignWipSection({ preRunDirtyPaths: ['src/foo.ts', 'src/bar.ts'] });
+  expect(section).toContain(FOREIGN_WIP_DELIMITER);
+  expect(section).toContain(FOREIGN_WIP_END_DELIMITER);
+  expect(section).toContain('src/foo.ts');
+  expect(section).toContain('src/bar.ts');
+  expect(section).toMatch(/SHARED working tree/);
+  expect(section).toMatch(/not this job's work/i);
+  expect(section).toMatch(/do not stage, commit, revert, or stash/i);
+  expect(section).toMatch(/not this job's regression/i);
+});
+
+test('buildForeignWipSection: carriedPaths (PRD 1094 base WIP) emits carry-over wording, not the shared-tree wording', () => {
+  const section = buildForeignWipSection({ carriedPaths: ['config/settings.json'] });
+  expect(section).toContain('config/settings.json');
+  expect(section).toMatch(/isolated git worktree/i);
+  expect(section).toMatch(/authoritative copy.*main tree/i);
+  expect(section).not.toMatch(/SHARED working tree/);
+});
+
+test('buildForeignWipSection: carriedPaths takes precedence over preRunDirtyPaths when both are somehow present', () => {
+  const section = buildForeignWipSection({
+    carriedPaths: ['carried.ts'],
+    preRunDirtyPaths: ['dirty.ts'],
+  });
+  expect(section).toContain('carried.ts');
+  expect(section).not.toContain('dirty.ts');
+  expect(section).toMatch(/isolated git worktree/i);
+});
+
+test('buildForeignWipSection: isolated-clean (worktree ok, no carried WIP) emits nothing', () => {
+  expect(buildForeignWipSection({ carriedPaths: [] })).toBe('');
+});