claude-code-session-manager 0.97.0 → 0.100.0

package/src/main/__tests__/scheduler-no-dead-end-status.test.cjs

@@ -1,152 +0,0 @@
-/**
- * scheduler-no-dead-end-status.test.cjs
- *
- * Structural guard for the no-human-intervention guarantee (this PRD): every
- * value in `JOB_STATUSES` (imported from scheduleJobSchema.cjs — the real
- * array, never a hand-written copy) must either be genuinely final
- * (completed/skipped) or have at least one AUTOMATED selector that can move
- * a row parked in it, with no human action required.
- *
- * Each non-final status is asserted by CONSTRUCTING a representative parked
- * row (a stale timestamp + a counter positioned so the row is still
- * selectable) and showing the named selector actually returns it — not by
- * asserting a hand-maintained status -> selector-name string map, which
- * would pass even if the real wiring silently broke. If a future change adds
- * a new status to JOB_STATUSES with no automated exit wired up here, this
- * test fails loudly instead of the row becoming a new, silent dead end.
- *
- * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs — same
- * reason as scheduler-failed-autoreset.test.cjs (appendAuditEvent writes
- * under $HOME/.claude/session-manager/audit-log.jsonl).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-no-dead-end-status.test.cjs
- */
-
-'use strict';
-
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'no-dead-end-status-test-'));
-process.env.HOME = tmpHome;
-
-const { JOB_STATUSES } = require('../lib/scheduleJobSchema.cjs');
-const {
-  selectFailedAutoResetTargets,
-  FAILED_AUTORESET_CAP,
-  selectExhaustedNeedsReviewTargets,
-  NEEDS_REVIEW_RESOLVE_CAP,
-  selectQuarantineAutoResolveTargets,
-  QUARANTINE_RESOLVE_CAP,
-  findStrandedInvestigations,
-  INVESTIGATION_MAX_MS,
-} = require('../scheduler.cjs');
-const { selectReapableJobs } = require('../lib/reaperHelpers.cjs');
-const { pickForProject } = require('../lib/schedulerBatch.cjs');
-
-const MIN_MS = 60_000;
-
-// Every terminal status (no automated exit needed — nothing should ever
-// move a row out of these) and every non-terminal status's proof that a
-// row parked there is reachable by an automated selector, keyed only for
-// this test's own assertions (never treated as authoritative wiring below).
-const FINAL_STATUSES = new Set(['completed', 'skipped']);
-
-test('JOB_STATUSES contains exactly the statuses this test accounts for (fails loudly on drift)', () => {
-  // Not a hand-maintained selector map — just a manifest of what this file
-  // below actually exercises, so an entirely new, unhandled status trips
-  // this assertion instead of silently passing the loop below with zero
-  // coverage.
-  const accountedFor = new Set([
-    'pending', 'running', 'investigating', 'completed', 'skipped', 'failed', 'needs_review', 'quarantined',
-  ]);
-  const unaccounted = JOB_STATUSES.filter((s) => !accountedFor.has(s));
-  if (unaccounted.length > 0) {
-    throw new Error(
-      `HALT: JOB_STATUSES has status(es) with no automated-exit test coverage: ${unaccounted.join(', ')} — `
-      + 'add a case to scheduler-no-dead-end-status.test.cjs before shipping this status.',
-    );
-  }
-});
-
-test('every terminal status in JOB_STATUSES is genuinely final (completed/skipped only)', () => {
-  for (const status of JOB_STATUSES) {
-    if (status === 'completed' || status === 'skipped') continue;
-    assert.ok(!FINAL_STATUSES.has(status), `${status} must not be treated as final`);
-  }
-});
-
-test('pending: a fresh pending row with no blockers is picked for dispatch by pickForProject', () => {
-  assert.ok(JOB_STATUSES.includes('pending'));
-  const job = { slug: 'pending-row', cwd: '/home/user/project', status: 'pending' };
-  const { batch } = pickForProject([job], new Set(), 5);
-  assert.ok(batch.some((j) => j.slug === 'pending-row'), 'pending row must be dispatch-eligible with no blockers');
-});
-
-test('running: a running row whose pid is provably dead is reaped by selectReapableJobs', () => {
-  assert.ok(JOB_STATUSES.includes('running'));
-  const job = {
-    slug: 'dead-running-row',
-    cwd: '/home/user/project',
-    status: 'running',
-    runtime: { pid: 12345 },
-  };
-  const { reapable } = selectReapableJobs([job], Date.now(), { pidAlive: () => false, grace: 5 * MIN_MS });
-  assert.ok(reapable.some((r) => r.slug === 'dead-running-row'), 'a running row with a dead pid must be reapable');
-});
-
-test('investigating: a stranded investigation (stale, no live pid) is found by findStrandedInvestigations', () => {
-  assert.ok(JOB_STATUSES.includes('investigating'));
-  const job = {
-    slug: 'stranded-investigation',
-    cwd: '/home/user/project',
-    status: 'investigating',
-    statusHistory: [{ to: 'investigating', from: 'failed', at: new Date(Date.now() - (INVESTIGATION_MAX_MS + 5 * MIN_MS)).toISOString() }],
-  };
-  const found = findStrandedInvestigations([job], Date.now(), INVESTIGATION_MAX_MS, () => false);
-  assert.ok(found.some((f) => f.slug === 'stranded-investigation'), 'a stale investigating row with no live pid must be found');
-});
-
-test('failed: a stale failed row under its auto-reset cap is selected by selectFailedAutoResetTargets', () => {
-  assert.ok(JOB_STATUSES.includes('failed'));
-  const job = {
-    slug: 'stale-failed-row',
-    cwd: '/home/user/project',
-    status: 'failed',
-    failedAutoResetAttempts: FAILED_AUTORESET_CAP - 1,
-    statusHistory: [{ to: 'failed', at: new Date(Date.now() - 60 * MIN_MS).toISOString() }],
-  };
-  const found = selectFailedAutoResetTargets([job], Date.now(), 10 * MIN_MS);
-  assert.ok(found.some((f) => f.slug === 'stale-failed-row'), 'a stale failed row under the cap must be auto-reset-selectable');
-});
-
-test('needs_review: an exhausted, stale needs_review row is selected by selectExhaustedNeedsReviewTargets', () => {
-  assert.ok(JOB_STATUSES.includes('needs_review'));
-  const job = {
-    slug: 'exhausted-needs-review-row',
-    cwd: '/home/user/project',
-    status: 'needs_review',
-    autoFixAttempted: true,
-    autoFixOutcome: 'no-plan',
-    autoFixRetries: 1,
-    exhaustedResolveAttempts: NEEDS_REVIEW_RESOLVE_CAP,
-    statusHistory: [{ to: 'needs_review', at: new Date(Date.now() - 60 * MIN_MS).toISOString() }],
-  };
-  const found = selectExhaustedNeedsReviewTargets([job], Date.now(), 30 * MIN_MS);
-  assert.ok(found.some((f) => f.slug === 'exhausted-needs-review-row'), 'an exhausted, stale needs_review row must be auto-resolve-selectable');
-});
-
-test('quarantined: a stale quarantined row under its resolve cap is selected by selectQuarantineAutoResolveTargets', () => {
-  assert.ok(JOB_STATUSES.includes('quarantined'));
-  const job = {
-    slug: 'stale-quarantined-row',
-    cwd: '/home/user/project',
-    status: 'quarantined',
-    quarantineResolveAttempts: QUARANTINE_RESOLVE_CAP - 1,
-    statusHistory: [{ to: 'quarantined', at: new Date(Date.now() - 60 * MIN_MS).toISOString() }],
-  };
-  const found = selectQuarantineAutoResolveTargets([job], Date.now(), 30 * MIN_MS);
-  assert.ok(found.some((f) => f.slug === 'stale-quarantined-row'), 'a stale quarantined row under the cap must be auto-resolve-selectable');
-});

package/src/main/__tests__/scheduler-no-orphan-run-dir.test.cjs

@@ -1,81 +0,0 @@
-/**
- * scheduler-no-orphan-run-dir.test.cjs — PRD 1120: pickRunDir() must not
- * mkdir a run directory until a dispatch actually commits (executeJob's
- * first write). A dispatch that aborts inside spawnJob before that point —
- * e.g. sessionSlots.acquire() returning null, the earliest exit in spawnJob
- * — must leave RUNS_DIR untouched.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-no-orphan-run-dir.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 originalSlots;
-let scheduler;
-let sessionSlots;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-no-orphan-rundir-'));
-  process.env.HOME = tmpHome;
-  originalSlots = process.env.SM_SESSION_SLOTS;
-  scheduler = require('../scheduler.cjs');
-  sessionSlots = require('../lib/sessionSlots.cjs');
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  if (originalSlots === undefined) delete process.env.SM_SESSION_SLOTS;
-  else process.env.SM_SESSION_SLOTS = originalSlots;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-afterEach(() => {
-  sessionSlots.__resetForTests();
-});
-
-function runsDirEntryCount() {
-  const runsDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs');
-  try {
-    return fs.readdirSync(runsDir).length;
-  } catch {
-    return 0;
-  }
-}
-
-test('pickRunDir() allocates a runId/dir pair without creating the directory', () => {
-  const before = runsDirEntryCount();
-  const { runId, dir } = scheduler.pickRunDir();
-  expect(runId).toBeTruthy();
-  expect(fs.existsSync(dir)).toBe(false);
-  expect(runsDirEntryCount()).toBe(before);
-});
-
-test('a dispatch that bails at slot-acquisition (earliest spawnJob exit) leaves no directory under RUNS_DIR', async () => {
-  // Force sessionSlots.acquire() to return null immediately — no slots at all.
-  process.env.SM_SESSION_SLOTS = '0';
-  const before = runsDirEntryCount();
-
-  const slug = `1120-slot-miss-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-no-orphan-rundir-project-'));
-  try {
-    await scheduler.spawnJob({ slug, cwd: projectCwd }, `run-${slug}`, path.join(
-      tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', `run-${slug}`
-    ), projectCwd);
-
-    expect(runsDirEntryCount()).toBe(before);
-    expect(fs.existsSync(path.join(
-      tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', `run-${slug}`
-    ))).toBe(false);
-  } finally {
-    delete process.env.SM_SESSION_SLOTS;
-    fs.rmSync(projectCwd, { recursive: true, force: true });
-  }
-});

package/src/main/__tests__/scheduler-notify-originating-tab-transcript.test.cjs

@@ -1,87 +0,0 @@
-/**
- * scheduler-notify-originating-tab-transcript.test.cjs — unit tests for the
- * PRD 863 addition to notifyOriginatingTab: persisting the job's real
- * result text (read from the run's log) to the durable per-Epic transcript
- * store, independent of the existing short-status-chip notification.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-notify-originating-tab-transcript.test.cjs
- */
-
-'use strict';
-
-import { test, expect, vi } from 'vitest';
-const { notifyOriginatingTab, extractResultTextFromLog } = require('../scheduler.cjs');
-
-test('extractResultTextFromLog returns null for a missing log path', () => {
-  expect(extractResultTextFromLog(null)).toBeNull();
-  expect(extractResultTextFromLog('/does/not/exist.log')).toBeNull();
-});
-
-test('appends the job result text to the transcript store when sourcePromptId is known', async () => {
-  const appendTranscriptTurn = vi.fn(async () => true);
-  const readResultFromLog = vi.fn(() => 'the real agent result text');
-  const appendResponseEvent = vi.fn(async () => true);
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-abc' }));
-
-  await notifyOriginatingTab(
-    { slug: '863-transcript', status: 'completed', cwd: '/some/cwd', runId: 'run-1' },
-    { parsePrdRaw, appendResponseEvent, appendTranscriptTurn, readResultFromLog },
-  );
-
-  expect(appendTranscriptTurn).toHaveBeenCalledTimes(1);
-  expect(appendTranscriptTurn).toHaveBeenCalledWith('/some/cwd', 'psess-abc', {
-    role: 'assistant',
-    text: 'the real agent result text',
-    eventId: 'prd-result:863-transcript:run-1',
-  });
-});
-
-test('falls back to the short status message when the run log has no result text', async () => {
-  const appendTranscriptTurn = vi.fn(async () => true);
-  const readResultFromLog = vi.fn(() => null);
-  const appendResponseEvent = vi.fn(async () => true);
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-abc' }));
-
-  await notifyOriginatingTab(
-    { slug: '863-fallback', status: 'completed', cwd: '/some/cwd', runId: 'run-1' },
-    { parsePrdRaw, appendResponseEvent, appendTranscriptTurn, readResultFromLog },
-  );
-
-  expect(appendTranscriptTurn).toHaveBeenCalledWith(
-    '/some/cwd',
-    'psess-abc',
-    expect.objectContaining({ text: expect.stringContaining('863-fallback') }),
-  );
-});
-
-test('a throwing transcript append never breaks the existing notification path', async () => {
-  const appendTranscriptTurn = vi.fn(async () => {
-    throw new Error('disk full');
-  });
-  const readResultFromLog = vi.fn(() => 'result text');
-  const appendResponseEvent = vi.fn(async () => true);
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-abc' }));
-
-  await expect(
-    notifyOriginatingTab(
-      { slug: '863-safe', status: 'completed', cwd: '/some/cwd', runId: 'run-1' },
-      { parsePrdRaw, appendResponseEvent, appendTranscriptTurn, readResultFromLog },
-    ),
-  ).resolves.toBeUndefined();
-
-  expect(appendResponseEvent).toHaveBeenCalledTimes(1);
-});
-
-test('no cwd on the job skips the transcript append but does not throw', async () => {
-  const appendTranscriptTurn = vi.fn(async () => true);
-  const readResultFromLog = vi.fn(() => 'result text');
-  const appendResponseEvent = vi.fn(async () => true);
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-abc' }));
-
-  await notifyOriginatingTab(
-    { slug: '863-nocwd', status: 'completed', cwd: null, runId: 'run-1' },
-    { parsePrdRaw, appendResponseEvent, appendTranscriptTurn, readResultFromLog },
-  );
-
-  expect(appendTranscriptTurn).not.toHaveBeenCalled();
-});

package/src/main/__tests__/scheduler-notify-originating-tab.test.cjs

@@ -1,343 +0,0 @@
-/**
- * scheduler-notify-originating-tab.test.cjs — unit tests for
- * notifyOriginatingTab (PRD 761): on a job's terminal completed/failed
- * transition, push a short status prompt into the chat tab that originated
- * it via enqueueExternalPrompt (PRD 753).
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-notify-originating-tab.test.cjs
- */
-
-'use strict';
-
-import { test, expect, vi } from 'vitest';
-const { notifyOriginatingTab, isNotifiableTerminalStatus } = require('../scheduler.cjs');
-
-test('isNotifiableTerminalStatus: completed and failed are notifiable', () => {
-  expect(isNotifiableTerminalStatus('completed')).toBe(true);
-  expect(isNotifiableTerminalStatus('failed')).toBe(true);
-});
-
-test('isNotifiableTerminalStatus: needs_review is not notifiable (may still auto-fix)', () => {
-  expect(isNotifiableTerminalStatus('needs_review')).toBe(false);
-});
-
-test('isNotifiableTerminalStatus: a rateLimited exit never reaches an effectiveStatus (undefined) and is not notifiable', () => {
-  // spawnJob's treatAsPending branch (rateLimited || paused for rate_limit)
-  // resets the job to pending and returns before effectiveStatus is ever
-  // computed — so this hook is only ever evaluated with undefined/pending,
-  // never with a real status, on that path.
-  expect(isNotifiableTerminalStatus(undefined)).toBe(false);
-  expect(isNotifiableTerminalStatus('pending')).toBe(false);
-});
-
-test('resolves via sourceTabId when present on the PRD frontmatter', async () => {
-  const sendPrompt = vi.fn();
-  const parsePrdRaw = vi.fn(async () => ({ sourceTabId: 'tab-from-frontmatter' }));
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-
-  await notifyOriginatingTab(
-    { slug: '761-notify', status: 'completed', cwd: '/some/cwd' },
-    { parsePrdRaw, loadSessions, sendPrompt },
-  );
-
-  expect(loadSessions).not.toHaveBeenCalled();
-  expect(sendPrompt).toHaveBeenCalledTimes(1);
-  expect(sendPrompt).toHaveBeenCalledWith(
-    'tab-from-frontmatter',
-    expect.stringContaining('761-notify'),
-  );
-});
-
-test('falls back to the first open tab whose cwd matches the job cwd', async () => {
-  const sendPrompt = vi.fn();
-  const parsePrdRaw = vi.fn(async () => ({ sourceTabId: null }));
-  const loadSessions = vi.fn(async () => ({
-    tabs: [
-      { id: 'tab-other', cwd: '/other/cwd' },
-      { id: 'tab-match', cwd: '/some/cwd' },
-      { id: 'tab-second-match', cwd: '/some/cwd' },
-    ],
-  }));
-
-  await notifyOriginatingTab(
-    { slug: '761-notify', status: 'failed', cwd: '/some/cwd' },
-    { parsePrdRaw, loadSessions, sendPrompt },
-  );
-
-  expect(sendPrompt).toHaveBeenCalledTimes(1);
-  expect(sendPrompt).toHaveBeenCalledWith('tab-match', expect.stringContaining('761-notify'));
-});
-
-test('no-ops without throwing when neither sourceTabId nor a cwd-matching tab resolves', async () => {
-  const sendPrompt = vi.fn();
-  const parsePrdRaw = vi.fn(async () => ({ sourceTabId: null }));
-  const loadSessions = vi.fn(async () => ({ tabs: [{ id: 'tab-other', cwd: '/unrelated' }] }));
-
-  await expect(
-    notifyOriginatingTab(
-      { slug: '761-notify', status: 'completed', cwd: '/some/cwd' },
-      { parsePrdRaw, loadSessions, sendPrompt },
-    ),
-  ).resolves.not.toThrow();
-
-  expect(sendPrompt).not.toHaveBeenCalled();
-});
-
-test('no-ops when parsing the PRD frontmatter throws', async () => {
-  const sendPrompt = vi.fn();
-  const parsePrdRaw = vi.fn(async () => { throw new Error('ENOENT'); });
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-
-  await expect(
-    notifyOriginatingTab(
-      { slug: '761-notify', status: 'completed', cwd: '/some/cwd' },
-      { parsePrdRaw, loadSessions, sendPrompt },
-    ),
-  ).resolves.not.toThrow();
-
-  expect(sendPrompt).not.toHaveBeenCalled();
-});
-
-// PRD 814: a dev-work ticket's completion notification routes into its own
-// PromptSession's event chain instead of an unrelated tab, when the PRD's
-// sourcePromptId resolves to a known, still-active PromptSession.
-test('routes into the known PromptSession event chain and never falls back to a tab prompt', async () => {
-  const sendPrompt = vi.fn();
-  const appendResponseEvent = vi.fn(async () => true);
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-1', sourceTabId: 'tab-x' }));
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-
-  await notifyOriginatingTab(
-    { slug: '814-notify', status: 'completed', cwd: '/some/cwd' },
-    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent },
-  );
-
-  expect(appendResponseEvent).toHaveBeenCalledWith(
-    '/some/cwd',
-    'psess-1',
-    expect.stringContaining('814-notify'),
-    { prdSlug: '814-notify', outcome: 'completed', validation: 'unvalidated' },
-  );
-  expect(sendPrompt).not.toHaveBeenCalled();
-});
-
-test('falls back to the tab-external-ticket path when sourcePromptId does not resolve to a known PromptSession', async () => {
-  const sendPrompt = vi.fn();
-  const appendResponseEvent = vi.fn(async () => false);
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-unknown', sourceTabId: 'tab-x' }));
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-
-  await notifyOriginatingTab(
-    { slug: '814-notify', status: 'completed', cwd: '/some/cwd' },
-    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent },
-  );
-
-  expect(appendResponseEvent).toHaveBeenCalled();
-  expect(sendPrompt).toHaveBeenCalledWith('tab-x', expect.stringContaining('814-notify'));
-});
-
-test('falls back to the tab-external-ticket path when the PRD has no sourcePromptId at all (pre-813 PRD)', async () => {
-  const sendPrompt = vi.fn();
-  const appendResponseEvent = vi.fn(async () => true);
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: null, sourceTabId: 'tab-x' }));
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-
-  await notifyOriginatingTab(
-    { slug: '814-notify', status: 'completed', cwd: '/some/cwd' },
-    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent },
-  );
-
-  expect(appendResponseEvent).not.toHaveBeenCalled();
-  expect(sendPrompt).toHaveBeenCalledWith('tab-x', expect.stringContaining('814-notify'));
-});
-
-// PRD 854: a PRD dispatched straight from an Epic's own composer
-// (dispatchPromptSessionToPrd) never sets sourceTabId — only sourcePromptId.
-// If the Epic has since gone completed (appendResponseEvent returns false),
-// the fallback must still target sourcePromptId itself as the chat:external-
-// send id, since the renderer now resolves that id against known Epics too.
-test('falls back to sourcePromptId as the external-send target when sourceTabId is absent', async () => {
-  const sendPrompt = vi.fn();
-  const appendResponseEvent = vi.fn(async () => false);
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'epic-1', sourceTabId: null }));
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-
-  await notifyOriginatingTab(
-    { slug: '854-notify', status: 'completed', cwd: '/some/cwd' },
-    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent },
-  );
-
-  expect(appendResponseEvent).toHaveBeenCalled();
-  expect(loadSessions).not.toHaveBeenCalled();
-  expect(sendPrompt).toHaveBeenCalledWith('epic-1', expect.stringContaining('854-notify'));
-});
-
-test('falls back to the tab-external-ticket path when appendResponseEvent itself throws', async () => {
-  const sendPrompt = vi.fn();
-  const appendResponseEvent = vi.fn(async () => { throw new Error('disk error'); });
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-1', sourceTabId: 'tab-x' }));
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-
-  await expect(
-    notifyOriginatingTab(
-      { slug: '814-notify', status: 'completed', cwd: '/some/cwd' },
-      { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent },
-    ),
-  ).resolves.not.toThrow();
-
-  expect(sendPrompt).toHaveBeenCalledWith('tab-x', expect.stringContaining('814-notify'));
-});
-
-// ─── PRD 985: real path resolution ───────────────────────────────────────────
-// Every test above injects a stubbed `parsePrdRaw`, which is exactly why the
-// bug PRD 985 fixes shipped green: notifyOriginatingTab resolved its PRD via
-// prdPathForJob → the RETIRED flat `scheduler/prds/` dir (today only
-// `.reserved-NNN` stubs, no PRDs), and archiveCompletedPrd renames the file
-// into `prds-archived/` immediately BEFORE notify runs anyway. `prd` was
-// therefore always null on the completed path and no response event was ever
-// appended. These two tests use the REAL parsePrdRaw against a temp tree so
-// the resolution logic itself is covered, not mocked away.
-
-const fs = require('node:fs');
-const os = require('node:os');
-const nodePath = require('node:path');
-
-function makeEpicTree({ epicId, slug, archived }) {
-  const cwd = fs.mkdtempSync(nodePath.join(os.tmpdir(), 'sm-notify-985-'));
-  const dir = nodePath.join(
-    cwd, 'session-manager-operations', 'scheduler', 'epics', epicId,
-    archived ? 'prds-archived' : 'prds',
-  );
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(
-    nodePath.join(dir, `${slug}.md`),
-    `---\ntitle: notify 985\ncwd: ${cwd}\nsourcePromptId: ${epicId}\n---\n\nbody\n`,
-    'utf8',
-  );
-  return cwd;
-}
-
-test('PRD 985: an ARCHIVED-only PRD still routes its check-in to the authoring Epic', async () => {
-  const epicId = 'psess-985-archived';
-  const slug = '985-archived-twin';
-  const cwd = makeEpicTree({ epicId, slug, archived: true });
-
-  const appendResponseEvent = vi.fn(async () => true);
-  const appendTranscriptTurn = vi.fn(async () => {});
-  const sendPrompt = vi.fn();
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-
-  // NOTE: no parsePrdRaw override — the real one runs against the temp tree.
-  await notifyOriginatingTab(
-    { slug, status: 'completed', cwd, epicId: null },
-    { loadSessions, sendPrompt, appendResponseEvent, appendTranscriptTurn, readResultFromLog: () => null },
-  );
-
-  expect(appendResponseEvent).toHaveBeenCalledTimes(1);
-  expect(appendResponseEvent).toHaveBeenCalledWith(
-    cwd, epicId, expect.stringContaining(slug),
-    expect.objectContaining({ prdSlug: slug, outcome: 'completed' }),
-  );
-  expect(appendTranscriptTurn).toHaveBeenCalledWith(cwd, epicId, expect.anything());
-  expect(sendPrompt).not.toHaveBeenCalled();
-});
-
-test('PRD 985: a PRD missing entirely still routes via the job row\'s own epicId', async () => {
-  const cwd = fs.mkdtempSync(nodePath.join(os.tmpdir(), 'sm-notify-985-none-'));
-  const appendResponseEvent = vi.fn(async () => true);
-  const appendTranscriptTurn = vi.fn(async () => {});
-  const sendPrompt = vi.fn();
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-
-  await notifyOriginatingTab(
-    { slug: '985-no-prd-on-disk', status: 'failed', cwd, epicId: 'psess-985-from-queue-row' },
-    { loadSessions, sendPrompt, appendResponseEvent, appendTranscriptTurn, readResultFromLog: () => null },
-  );
-
-  expect(appendResponseEvent).toHaveBeenCalledWith(
-    cwd, 'psess-985-from-queue-row', expect.stringContaining('985-no-prd-on-disk'),
-    expect.objectContaining({ prdSlug: '985-no-prd-on-disk', outcome: 'failed' }),
-  );
-  expect(appendTranscriptTurn).toHaveBeenCalledWith(cwd, 'psess-985-from-queue-row', expect.anything());
-});
-
-// ─── PRD 1407: validator jobs stamp verdicts onto the authoring Epic ────────
-// A completed validator job's result text carries one `VALIDATION: <slug>
-// VERIFIED|REFUTED` line per PRD it checked. Each parsed verdict becomes its
-// own response event BEFORE the validator's own (still-unvalidated)
-// check-in, and the validator's check-in never enqueues a validation prompt
-// for itself.
-test('PRD 1407: a validator job with two sentinel lines appends two verdict events plus its own check-in, and never enqueues validation', async () => {
-  const sendPrompt = vi.fn();
-  const appendResponseEvent = vi.fn(async () => true);
-  const appendTranscriptTurn = vi.fn(async () => {});
-  const enqueueValidation = vi.fn();
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-validator-1' }));
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-  const readResultFromLog = vi.fn(() => [
-    'VALIDATION: 111-alpha VERIFIED',
-    'VALIDATION: 222-beta REFUTED — missing coverage',
-  ].join('\n'));
-
-  await notifyOriginatingTab(
-    { slug: '1407-validator-run', status: 'completed', cwd: '/some/cwd', agentType: 'validator' },
-    {
-      parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent,
-      appendTranscriptTurn, readResultFromLog, enqueueValidation,
-    },
-  );
-
-  expect(appendResponseEvent).toHaveBeenCalledTimes(3);
-  expect(appendResponseEvent).toHaveBeenNthCalledWith(
-    1, '/some/cwd', 'psess-validator-1', expect.stringContaining('111-alpha'),
-    { prdSlug: '111-alpha', outcome: 'completed', validation: 'verified' },
-  );
-  expect(appendResponseEvent).toHaveBeenNthCalledWith(
-    2, '/some/cwd', 'psess-validator-1', expect.stringContaining('222-beta'),
-    { prdSlug: '222-beta', outcome: 'completed', validation: 'refuted' },
-  );
-  expect(appendResponseEvent).toHaveBeenNthCalledWith(
-    3, '/some/cwd', 'psess-validator-1', expect.stringContaining('1407-validator-run'),
-    { prdSlug: '1407-validator-run', outcome: 'completed', validation: 'unvalidated' },
-  );
-  expect(enqueueValidation).not.toHaveBeenCalled();
-});
-
-// ─── PRD 1408: a downstream validator suppresses the per-PRD validation ask ─
-test('skips enqueueValidation when loadJobs reports a pending validator row depending on this job', async () => {
-  const sendPrompt = vi.fn();
-  const appendResponseEvent = vi.fn(async () => true);
-  const enqueueValidation = vi.fn();
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-1' }));
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-  const loadJobs = vi.fn(async () => ([
-    { slug: '1408-work-item' },
-    { slug: '1408-validate', agentType: 'validator', status: 'pending', dependsOn: ['1408-work-item'] },
-  ]));
-
-  await notifyOriginatingTab(
-    { slug: '1408-work-item', status: 'completed', cwd: '/some/cwd' },
-    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent, enqueueValidation, loadJobs },
-  );
-
-  expect(appendResponseEvent).toHaveBeenCalledTimes(1);
-  expect(loadJobs).toHaveBeenCalledTimes(1);
-  expect(enqueueValidation).not.toHaveBeenCalled();
-});
-
-test('still enqueues validation when loadJobs reports no downstream validator', async () => {
-  const sendPrompt = vi.fn();
-  const appendResponseEvent = vi.fn(async () => true);
-  const enqueueValidation = vi.fn();
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-1' }));
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-  const loadJobs = vi.fn(async () => ([{ slug: '1408-work-item' }]));
-
-  await notifyOriginatingTab(
-    { slug: '1408-work-item', status: 'completed', cwd: '/some/cwd' },
-    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent, enqueueValidation, loadJobs },
-  );
-
-  expect(appendResponseEvent).toHaveBeenCalledTimes(1);
-  expect(enqueueValidation).toHaveBeenCalledTimes(1);
-});