claude-code-session-manager 0.58.0 → 0.60.0

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

@@ -170,3 +170,163 @@ test('migratePrds moves multiple PRDs to different projects independently', asyn
   expect(fs.existsSync(path.join(resolvePrdWriteDir(cwdA), '05-a.md'))).toBe(true);
   expect(fs.existsSync(path.join(resolvePrdWriteDir(cwdB), '06-b.md'))).toBe(true);
 });
+
+/* ------------------------------------------------------------------------ *
+ * PRD 992 — consolidateFlatPrds must not archive a PRD with a live queue job.
+ *
+ * The scheduler still scans the retired flat `scheduler/prds/` dir as a PRD
+ * *source* (prdLocations.cjs's resolvePrdsDirs), so a file there can have a
+ * pending/running job. Consolidation used to move every .md unconditionally,
+ * stranding that job with no resolvable source. Observed live 2026-08-02:
+ * 980-fix-chat-typed-event-renderers.md sat there with status `running`.
+ * ------------------------------------------------------------------------ */
+
+const { consolidateFlatPrds, LIVE_JOB_STATUSES } = require('../lib/prdMigration.cjs');
+
+function opsRoot(root) {
+  return path.join(root, 'session-manager-operations', 'scheduler');
+}
+
+async function makeFlatProject(root, files) {
+  const flat = path.join(opsRoot(root), 'prds');
+  await fsp.mkdir(flat, { recursive: true });
+  for (const name of files) {
+    await fsp.writeFile(path.join(flat, name), `---\ntitle: ${name}\n---\n# Goal\n`, 'utf8');
+  }
+  return flat;
+}
+
+async function writeQueue(root, jobs) {
+  const stateDir = path.join(opsRoot(root), 'state');
+  await fsp.mkdir(stateDir, { recursive: true });
+  await fsp.writeFile(path.join(stateDir, 'queue.json'), JSON.stringify({ jobs }), 'utf8');
+}
+
+function newRoot() {
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-consolidate-'));
+  tmpDirs.push(d);
+  return d;
+}
+
+for (const status of LIVE_JOB_STATUSES) {
+  test(`consolidateFlatPrds leaves a file in place when its job is ${status}`, async () => {
+    const root = newRoot();
+    const flat = await makeFlatProject(root, ['980-fix-chat-typed-event-renderers.md']);
+    await writeQueue(root, [{ slug: '980-fix-chat-typed-event-renderers', status }]);
+
+    const r = await consolidateFlatPrds(root);
+
+    expect(r.moved).toBe(0);
+    expect(r.skipped).toEqual([
+      { file: '980-fix-chat-typed-event-renderers.md', reason: 'live queue job — source must survive' },
+    ]);
+    expect(fs.existsSync(path.join(flat, '980-fix-chat-typed-event-renderers.md'))).toBe(true);
+  });
+}
+
+for (const status of ['completed', 'failed']) {
+  test(`consolidateFlatPrds archives a file whose job is ${status}`, async () => {
+    const root = newRoot();
+    const flat = await makeFlatProject(root, ['700-done.md']);
+    await writeQueue(root, [{ slug: '700-done', status }]);
+
+    const r = await consolidateFlatPrds(root);
+
+    expect(r.moved).toBe(1);
+    expect(r.skipped).toEqual([]);
+    expect(fs.existsSync(path.join(flat, '700-done.md'))).toBe(false);
+    expect(fs.existsSync(path.join(opsRoot(root), 'prds-archived', '700-done.md'))).toBe(true);
+  });
+}
+
+test('consolidateFlatPrds archives a file with no job at all', async () => {
+  const root = newRoot();
+  await makeFlatProject(root, ['701-orphan.md']);
+  await writeQueue(root, []);
+
+  const r = await consolidateFlatPrds(root);
+
+  expect(r.moved).toBe(1);
+  expect(fs.existsSync(path.join(opsRoot(root), 'prds-archived', '701-orphan.md'))).toBe(true);
+});
+
+test('consolidateFlatPrds mixed dir: only the live one survives', async () => {
+  const root = newRoot();
+  const flat = await makeFlatProject(root, ['800-live.md', '801-done.md', '802-none.md']);
+  await writeQueue(root, [
+    { slug: '800-live', status: 'running' },
+    { slug: '801-done', status: 'completed' },
+  ]);
+
+  const r = await consolidateFlatPrds(root);
+
+  expect(r.moved).toBe(2);
+  expect(r.skipped.map((s) => s.file)).toEqual(['800-live.md']);
+  expect(fs.existsSync(path.join(flat, '800-live.md'))).toBe(true);
+});
+
+test('consolidateFlatPrds never touches dotfiles (NN allocation still uses them)', async () => {
+  const root = newRoot();
+  const flat = await makeFlatProject(root, ['900-x.md']);
+  await fsp.writeFile(path.join(flat, '.max-allocated-group'), '992', 'utf8');
+
+  await consolidateFlatPrds(root, { liveSlugs: new Set() });
+
+  expect(fs.existsSync(path.join(flat, '.max-allocated-group'))).toBe(true);
+});
+
+test('consolidateFlatPrds is idempotent and creates no -legacy- duplicate', async () => {
+  const root = newRoot();
+  await makeFlatProject(root, ['910-a.md']);
+  await writeQueue(root, []);
+
+  const first = await consolidateFlatPrds(root);
+  const second = await consolidateFlatPrds(root);
+
+  expect(first.moved).toBe(1);
+  expect(second.moved).toBe(0);
+  expect(fs.readdirSync(path.join(opsRoot(root), 'prds-archived'))).toEqual(['910-a.md']);
+});
+
+test('consolidateFlatPrds protects a live job across repeat runs, not just the first', async () => {
+  const root = newRoot();
+  await makeFlatProject(root, ['920-live.md']);
+  await writeQueue(root, [{ slug: '920-live', status: 'pending' }]);
+
+  await consolidateFlatPrds(root);
+  const second = await consolidateFlatPrds(root);
+
+  expect(second.moved).toBe(0);
+  expect(second.skipped).toHaveLength(1);
+});
+
+test('consolidateFlatPrds treats an absent queue.json as "no jobs", not an error', async () => {
+  const root = newRoot();
+  await makeFlatProject(root, ['930-fresh.md']);
+
+  const r = await consolidateFlatPrds(root);
+
+  expect(r.moved).toBe(1);
+  expect(r.skipped).toEqual([]);
+});
+
+test('consolidateFlatPrds FAILS CLOSED on an unparseable queue.json', async () => {
+  const root = newRoot();
+  const flat = await makeFlatProject(root, ['940-a.md', '941-b.md']);
+  const stateDir = path.join(opsRoot(root), 'state');
+  await fsp.mkdir(stateDir, { recursive: true });
+  await fsp.writeFile(path.join(stateDir, 'queue.json'), '{ not json', 'utf8');
+
+  const r = await consolidateFlatPrds(root);
+
+  expect(r.moved).toBe(0);
+  expect(r.skipped).toHaveLength(2);
+  expect(r.skipped[0].reason).toMatch(/queue state unreadable/);
+  expect(fs.existsSync(path.join(flat, '940-a.md'))).toBe(true);
+  expect(fs.existsSync(path.join(flat, '941-b.md'))).toBe(true);
+});
+
+test('consolidateFlatPrds returns the full shape when the flat dir is missing', async () => {
+  const r = await consolidateFlatPrds(newRoot());
+  expect(r).toEqual({ moved: 0, failed: [], skipped: [] });
+});

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

@@ -0,0 +1,151 @@
+/**
+ * projectPages.test.cjs — unit tests for projectPages.cjs's read-only get(),
+ * including the regression this PRD's AC calls out explicitly: adding the
+ * 5th 'brief' lens must not make every pre-existing 4-lens project suddenly
+ * read as having no output at all — and the shipped-default fallback added
+ * by the "project-home-hosted-html-spec" PRD: a project with no generated
+ * output gets the build-time default home.html (isDefault: true) instead of
+ * the bare `{ output: null }` empty-state signal.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/projectPages.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, afterEach } from 'vitest';
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const config = require('../config.cjs');
+const { get, DEFAULT_HOME_PATH, readDefaultHomeHtml } = require('../projectPages.cjs');
+
+const tmpDirs = [];
+afterEach(async () => {
+  while (tmpDirs.length) {
+    const d = tmpDirs.pop();
+    await fsp.rm(d, { recursive: true, force: true });
+  }
+});
+
+async function mkTmpCwd() {
+  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-project-pages-'));
+  config.addAllowedRoot(dir);
+  tmpDirs.push(dir);
+  return dir;
+}
+
+function outputDir(cwd) {
+  return path.join(cwd, 'session-manager-operations', 'project-pages', 'output');
+}
+
+function writeOutput(cwd, lenses, manifest = { generatedAt: '2026-08-02T00:00:00.000Z' }) {
+  const dir = outputDir(cwd);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, 'manifest.json'), JSON.stringify(manifest));
+  for (const [lens, html] of Object.entries(lenses)) {
+    fs.writeFileSync(path.join(dir, `${lens}.html`), html);
+  }
+}
+
+test('the shipped default asset exists on disk at a fixed app-relative path', () => {
+  expect(fs.existsSync(DEFAULT_HOME_PATH)).toBe(true);
+  expect(path.isAbsolute(DEFAULT_HOME_PATH)).toBe(true);
+});
+
+test('(a) generated output present: get() returns it with isDefault false', async () => {
+  const cwd = await mkTmpCwd();
+  writeOutput(cwd, {
+    home: 'HOME',
+    marketing: 'MARKETING',
+    feature: 'FEATURE',
+    architecture: 'ARCHITECTURE',
+    brief: 'BRIEF',
+  });
+  const result = await get({ cwd });
+  expect(result.output).not.toBeNull();
+  expect(result.output.home).toBe('HOME');
+  expect(result.output.brief).toBe('BRIEF');
+  expect(result.output.generatedAt).toBe('2026-08-02T00:00:00.000Z');
+  expect(result.output.isDefault).toBe(false);
+});
+
+// The regression this PRD's AC explicitly guards against: a project that
+// generated its output BEFORE the 'brief' lens existed has the original 4
+// files but no brief.html — that must still read as "has output", not the
+// shipped-default fallback, and `brief` must simply be absent from the payload.
+test('4 original lenses present but brief.html missing still returns generated output, with brief omitted', async () => {
+  const cwd = await mkTmpCwd();
+  writeOutput(cwd, {
+    home: 'HOME',
+    marketing: 'MARKETING',
+    feature: 'FEATURE',
+    architecture: 'ARCHITECTURE',
+  });
+  const result = await get({ cwd });
+  expect(result.output).not.toBeNull();
+  expect(result.output.home).toBe('HOME');
+  expect(result.output.marketing).toBe('MARKETING');
+  expect(result.output.feature).toBe('FEATURE');
+  expect(result.output.architecture).toBe('ARCHITECTURE');
+  expect(result.output.brief).toBeUndefined();
+  expect(result.output.isDefault).toBe(false);
+});
+
+// (b) output absent → returns the shipped default with isDefault true.
+test('(b) no manifest at all: get() returns the shipped default with isDefault true', async () => {
+  const cwd = await mkTmpCwd();
+  const result = await get({ cwd });
+  expect(result.output).not.toBeNull();
+  expect(result.output.isDefault).toBe(true);
+  expect(result.output.generatedAt).toBeNull();
+  expect(result.output.home).toBe(readDefaultHomeHtml());
+  expect(result.output.marketing).toBeUndefined();
+  expect(result.output.feature).toBeUndefined();
+  expect(result.output.architecture).toBeUndefined();
+});
+
+test('one of the required 4 lenses missing falls back to the shipped default, even if brief.html exists', async () => {
+  const cwd = await mkTmpCwd();
+  writeOutput(cwd, {
+    home: 'HOME',
+    marketing: 'MARKETING',
+    feature: 'FEATURE',
+    // architecture.html deliberately missing
+    brief: 'BRIEF',
+  });
+  const result = await get({ cwd });
+  expect(result.output).not.toBeNull();
+  expect(result.output.isDefault).toBe(true);
+  expect(result.output.home).toBe(readDefaultHomeHtml());
+});
+
+test('manifest with no generatedAt string falls back to the shipped default', async () => {
+  const cwd = await mkTmpCwd();
+  writeOutput(
+    cwd,
+    { home: 'HOME', marketing: 'MARKETING', feature: 'FEATURE', architecture: 'ARCHITECTURE', brief: 'BRIEF' },
+    {},
+  );
+  const result = await get({ cwd });
+  expect(result.output).not.toBeNull();
+  expect(result.output.isDefault).toBe(true);
+});
+
+// (c) the default path resolution does not depend on cwd.
+test('(c) default fallback content is identical regardless of which project cwd requests it', async () => {
+  const cwdA = await mkTmpCwd();
+  const cwdB = await mkTmpCwd();
+  const resultA = await get({ cwd: cwdA });
+  const resultB = await get({ cwd: cwdB });
+  expect(resultA.output.isDefault).toBe(true);
+  expect(resultB.output.isDefault).toBe(true);
+  expect(resultA.output.home).toBe(resultB.output.home);
+  expect(resultA.output.home).toBe(readDefaultHomeHtml());
+});
+
+test('the shipped default is honest: no fabricated project-specific content, and prompts Generate My Project Home', () => {
+  const html = readDefaultHomeHtml();
+  expect(html).toContain('Generate My Project Home');
+  expect(html.toLowerCase()).not.toContain('lorem ipsum');
+});

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

@@ -139,6 +139,80 @@ test('broadcasts EVENT_APPENDED_CHANNEL to the attached window on a successful a
   }
 });
 
+test('appending with { prdSlug, outcome } persists both onto the event on disk', async () => {
+  await writeIndex({
+    sessions: { 'psess-1': { id: 'psess-1', cwd, status: 'active' } },
+    events: {
+      'psess-1': [
+        { id: 'pevt-1', promptSessionId: 'psess-1', kind: 'prompt', causedByEventId: null, at: '2026-01-01T00:00:00.000Z' },
+      ],
+    },
+  });
+
+  const routed = await appendResponseEventIfKnown(cwd, 'psess-1', 'PRD 976-foo finished: completed.', {
+    prdSlug: '976-foo',
+    outcome: 'completed',
+  });
+  expect(routed).toBe(true);
+
+  const onDisk = JSON.parse(await fsp.readFile(promptSessionActiveIndexPath(cwd), 'utf8'));
+  const event = onDisk.events['psess-1'][1];
+  expect(event.prdSlug).toBe('976-foo');
+  expect(event.outcome).toBe('completed');
+});
+
+// PRD 986: a scheduler check-in event is born 'unvalidated' — the stamp is
+// persisted from meta, and events appended without it carry no validation
+// key at all (pre-existing events keep rendering as they do today).
+test('appending with { validation } persists the stamp; without it no validation key exists', async () => {
+  await writeIndex({
+    sessions: { 'psess-1': { id: 'psess-1', cwd, status: 'active' } },
+    events: {
+      'psess-1': [
+        { id: 'pevt-1', promptSessionId: 'psess-1', kind: 'prompt', causedByEventId: null, at: '2026-01-01T00:00:00.000Z' },
+      ],
+    },
+  });
+
+  const routed = await appendResponseEventIfKnown(cwd, 'psess-1', 'PRD 986-foo finished: completed.', {
+    prdSlug: '986-foo',
+    outcome: 'completed',
+    validation: 'unvalidated',
+  });
+  expect(routed).toBe(true);
+
+  await appendResponseEventIfKnown(cwd, 'psess-1', 'plain response, no meta');
+
+  const raw = await fsp.readFile(promptSessionActiveIndexPath(cwd), 'utf8');
+  const onDisk = JSON.parse(raw);
+  const [, checkin, plain] = onDisk.events['psess-1'];
+  expect(checkin.validation).toBe('unvalidated');
+  expect('validation' in plain).toBe(false);
+});
+
+test('appending without { prdSlug, outcome } persists an event with neither key set', async () => {
+  await writeIndex({
+    sessions: { 'psess-1': { id: 'psess-1', cwd, status: 'active' } },
+    events: {
+      'psess-1': [
+        { id: 'pevt-1', promptSessionId: 'psess-1', kind: 'prompt', causedByEventId: null, at: '2026-01-01T00:00:00.000Z' },
+      ],
+    },
+  });
+
+  const routed = await appendResponseEventIfKnown(cwd, 'psess-1', 'no meta here');
+  expect(routed).toBe(true);
+
+  const raw = await fsp.readFile(promptSessionActiveIndexPath(cwd), 'utf8');
+  const onDisk = JSON.parse(raw);
+  const event = onDisk.events['psess-1'][1];
+  expect('prdSlug' in event).toBe(false);
+  expect('outcome' in event).toBe(false);
+  // Also assert the raw JSON text has no undefined-valued keys serialized in.
+  expect(raw).not.toMatch(/"prdSlug"/);
+  expect(raw).not.toMatch(/"outcome"/);
+});
+
 test('does not throw broadcasting before a window is attached, or after it is destroyed', async () => {
   await writeIndex({
     sessions: { 'psess-1': { id: 'psess-1', cwd, status: 'active' } },

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

@@ -2,6 +2,12 @@
  * scheduler-effective-concurrency.test.cjs — unit tests for the
  * effectiveConcurrency field on buildScheduleStatePayload.
  *
+ * The scheduler's private `concurrencyCap` is retired: the machine-wide
+ * sessionSlots pool is the ONLY concurrency limit, so effectiveConcurrency
+ * now reports the pool (and its SM_SESSION_SLOTS override), not a config
+ * field. See lib/sessionSlots.cjs's charter — caps belong to Session-Manager,
+ * not to each consumer.
+ *
  * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-effective-concurrency.test.cjs
  */
 
@@ -9,23 +15,26 @@
 
 import { test, expect, beforeEach, afterEach } from 'vitest';
 const { buildScheduleStatePayload } = require('../scheduler.cjs');
+const sessionSlots = require('../lib/sessionSlots.cjs');
 
-const ENV_KEY = 'SM_SCHEDULER_MAX_CONCURRENCY';
+const ENV_KEY = 'SM_SESSION_SLOTS';
 let savedEnv;
 
 beforeEach(() => {
   savedEnv = process.env[ENV_KEY];
   delete process.env[ENV_KEY];
+  sessionSlots.__resetForTests();
 });
 
 afterEach(() => {
   if (savedEnv === undefined) delete process.env[ENV_KEY];
   else process.env[ENV_KEY] = savedEnv;
+  sessionSlots.__resetForTests();
 });
 
-function fakeState(concurrencyCap) {
+function fakeState() {
   return {
-    config: { concurrencyCap },
+    config: {},
     jobs: [],
     scheduledFor: null,
     lastRunAt: null,
@@ -33,19 +42,30 @@ function fakeState(concurrencyCap) {
   };
 }
 
-test('effectiveConcurrency is config-sourced when env var is unset', () => {
-  const payload = buildScheduleStatePayload(fakeState(5));
-  expect(payload.effectiveConcurrency).toEqual({ cap: 5, source: 'config' });
+test('effectiveConcurrency reports the pool when no env override is set', () => {
+  const payload = buildScheduleStatePayload(fakeState());
+  expect(payload.effectiveConcurrency.source).toBe('pool');
+  expect(payload.effectiveConcurrency.cap).toBe(sessionSlots.totalSlots());
+  expect(payload.effectiveConcurrency.free).toBe(sessionSlots.available());
 });
 
-test('effectiveConcurrency is env-sourced and wins over config when env var is set', () => {
+test('effectiveConcurrency is env-sourced when SM_SESSION_SLOTS is set', () => {
   process.env[ENV_KEY] = '7';
-  const payload = buildScheduleStatePayload(fakeState(5));
-  expect(payload.effectiveConcurrency).toEqual({ cap: 7, source: 'env' });
+  const payload = buildScheduleStatePayload(fakeState());
+  expect(payload.effectiveConcurrency).toEqual({ cap: 7, free: 7, source: 'env' });
 });
 
-test('effectiveConcurrency clamps env var into [1, 20]', () => {
+test('effectiveConcurrency clamps the env var into the pool range [0, 10]', () => {
   process.env[ENV_KEY] = '999';
-  const payload = buildScheduleStatePayload(fakeState(5));
-  expect(payload.effectiveConcurrency).toEqual({ cap: 20, source: 'env' });
+  const payload = buildScheduleStatePayload(fakeState());
+  expect(payload.effectiveConcurrency).toEqual({ cap: 10, free: 10, source: 'env' });
+});
+
+test('free is net of held slots — a chat run shrinks it without changing cap', () => {
+  process.env[ENV_KEY] = '5';
+  const token = sessionSlots.acquire('chat:test-tab');
+  expect(token).toBeTruthy();
+  const payload = buildScheduleStatePayload(fakeState());
+  expect(payload.effectiveConcurrency).toEqual({ cap: 5, free: 4, source: 'env' });
+  sessionSlots.release(token);
 });

package/src/main/__tests__/scheduler-epic-digest.test.cjs

@@ -107,8 +107,15 @@ test('prepends the Epic context digest when job.epicId resolves to a known Epic'
 
     const digestText = await buildContextDigest({ cwd: projectCwd, epicId });
     expect(digestText.length).toBeGreaterThan(0);
-    expect(capturedPrompt.startsWith(digestText)).toBe(true);
-    expect(capturedPrompt.endsWith(bodyText + FINISH_PROTOCOL)).toBe(true);
+    // The PRD body (plus FINISH_PROTOCOL) comes first; the digest is fenced
+    // as background afterward, and the prompt ends with the task restatement
+    // rather than the digest itself (composeExecutorPrompt, PRD 987 Part A).
+    expect(capturedPrompt.startsWith(bodyText + FINISH_PROTOCOL)).toBe(true);
+    const bodyIndex = capturedPrompt.indexOf(bodyText);
+    const digestIndex = capturedPrompt.indexOf(digestText);
+    expect(digestIndex).toBeGreaterThan(bodyIndex);
+    expect(capturedPrompt).toContain('BEGIN EPIC CONTEXT (background only');
+    expect(capturedPrompt.trim().endsWith('Your task is the PRD at the top of this prompt. Implement it now.')).toBe(true);
 
     // The PRD source on disk must never be rewritten with the digest merged in.
     const onDiskPrd = fs.readFileSync(path.join(projectCwd, 'session-manager-operations', 'scheduler', 'prds', `${slug}.md`), 'utf8');

package/src/main/__tests__/scheduler-heal-refusal.test.cjs

@@ -0,0 +1,61 @@
+/**
+ * scheduler-heal-refusal.test.cjs — PRD 983.
+ *
+ * Guards the needs_review → completed self-heal in reverifyNeedsReview.
+ *
+ * Incident being regression-tested: job 972 (2026-08-03) ran 34 s, edited zero
+ * files, exited 0. verifyRun correctly raised `no_verdict_sentinel` /
+ * downgradeTo 'needs_review'. One minute later the self-heal pass promoted it
+ * to `completed` and the false green shipped. Cause: the rescan recomputes
+ * `committedDuringRun` from `committedInWindow`, a repo-wide
+ * `git log --all --since --until` with no author/message/slug filter — a
+ * CONCURRENT job's commit inside the window was credited to this job, which
+ * suppressed the no_verdict_sentinel check on re-verify and let the verdict
+ * conclude `clean`.
+ *
+ * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-heal-refusal.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const { healRefusalReason } = require('../scheduler.cjs');
+
+const CLEAN = { verdict: 'clean', reason: 'no issues detected' };
+
+test('REGRESSION (PRD 983): a no_verdict_sentinel job with no landedCommit is NOT healed, even on a clean re-verify', () => {
+  const job = { slug: '972-notify', verifierVerdict: 'no_verdict_sentinel', landedCommit: null };
+  const refusal = healRefusalReason(job, CLEAN, true);
+  expect(refusal).toBeTruthy();
+  expect(refusal).toContain('no job-attributable commit');
+});
+
+test('a no_verdict_sentinel job WITH its own landedCommit is allowed to heal', () => {
+  const job = { slug: '900-real', verifierVerdict: 'no_verdict_sentinel', landedCommit: 'abc1234' };
+  expect(healRefusalReason(job, CLEAN, true)).toBeNull();
+});
+
+test('other verdict classes are untouched — transcript_errors still heals on a clean re-verify', () => {
+  const job = { slug: '901-transcript', verifierVerdict: 'transcript_errors', landedCommit: null };
+  expect(healRefusalReason(job, CLEAN, true)).toBeNull();
+});
+
+test('verify_unavailable (the other pre-sentinel-heal class) is untouched', () => {
+  const job = { slug: '902-unavailable', verifierVerdict: 'verify_unavailable', landedCommit: null };
+  expect(healRefusalReason(job, CLEAN, true)).toBeNull();
+});
+
+test('a non-completed-equivalent re-verify verdict is left to the existing path, not refused here', () => {
+  const job = { slug: '903-still-bad', verifierVerdict: 'no_verdict_sentinel', landedCommit: null };
+  expect(healRefusalReason(job, { verdict: 'transcript_errors', reason: 'x' }, false)).toBeNull();
+});
+
+test('an honest no-op exemption verdict still heals when the job recorded its own commit', () => {
+  const job = { slug: '904-shipped', verifierVerdict: 'no_verdict_sentinel', landedCommit: 'deadbee' };
+  expect(healRefusalReason(job, { verdict: 'pass_no_commit_already_shipped', reason: 'x' }, false)).toBeNull();
+});
+
+test('null/missing inputs never throw and never refuse', () => {
+  expect(healRefusalReason(null, CLEAN, true)).toBeNull();
+  expect(healRefusalReason({ slug: 'x' }, null, true)).toBeNull();
+});

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

@@ -116,6 +116,7 @@ test('routes into the known PromptSession event chain and never falls back to a
     '/some/cwd',
     'psess-1',
     expect.stringContaining('814-notify'),
+    { prdSlug: '814-notify', outcome: 'completed', validation: 'unvalidated' },
   );
   expect(sendPrompt).not.toHaveBeenCalled();
 });
@@ -186,3 +187,76 @@ test('falls back to the tab-external-ticket path when appendResponseEvent itself
 
   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());
+});