claude-code-session-manager 0.58.0 → 0.59.0

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

@@ -0,0 +1,291 @@
+/**
+ * epicValidationHook.test.cjs — PRD 986: a PRD check-in triggers validation
+ * in the authoring Epic; it never asserts the PRD is done.
+ *
+ * Covers the PRD's five required cases:
+ *   (a) a completed check-in enqueues exactly one validation prompt naming
+ *       the PRD slug;
+ *   (b) a check-in for a non-active Epic enqueues nothing;
+ *   (c) a second check-in for the same (epicId, prdSlug) enqueues nothing;
+ *   (d) the enqueued prompt contains the PRD's absolute path and the
+ *       VERIFIED/REFUTED instruction (plus the not-evidence warning and the
+ *       git diff --stat / empty-diff-is-REFUTED rule);
+ *   (e) LOOP GUARD — an appended event that is a validation result never
+ *       enqueues a further prompt.
+ * Plus: the SM_EPIC_VALIDATION_DISABLE kill-switch, the born-'unvalidated'
+ * stamp, and end-to-end wiring through notifyOriginatingTab.
+ *
+ * Run: timeout 300 npx vitest run src/main/__tests__/epicValidationHook.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, vi, beforeEach, afterEach } from 'vitest';
+const {
+  maybeEnqueueValidationPrompt,
+  buildValidationPrompt,
+  __resetForTests,
+} = require('../lib/epicValidationHook.cjs');
+const { notifyOriginatingTab } = require('../scheduler.cjs');
+
+const EPIC = 'epic-986';
+const SLUG = '986-example-prd';
+const PRD_PATH = '/abs/path/to/session-manager-operations/scheduler/epics/epic-986/prds-archived/986-example-prd.md';
+
+/** An active-index snapshot AS IT LOOKS RIGHT AFTER the scheduler's check-in
+ *  append: exactly one validation-stamped response event for this prdSlug. */
+function indexAfterCheckin({ status = 'active', extraEvents = [] } = {}) {
+  return {
+    sessions: { [EPIC]: { id: EPIC, status } },
+    events: {
+      [EPIC]: [
+        { id: 'e1', promptSessionId: EPIC, kind: 'prompt', causedByEventId: null, at: '2026-08-02T00:00:00Z', text: 'goal' },
+        {
+          id: 'e2', promptSessionId: EPIC, kind: 'response', causedByEventId: 'e1',
+          at: '2026-08-02T01:00:00Z', text: `PRD ${SLUG} finished: completed.`,
+          prdSlug: SLUG, outcome: 'completed', validation: 'unvalidated',
+        },
+        ...extraEvents,
+      ],
+    },
+  };
+}
+
+function callArgs(overrides = {}) {
+  return {
+    cwd: '/some/cwd',
+    epicId: EPIC,
+    prdSlug: SLUG,
+    prdPath: PRD_PATH,
+    outcome: 'completed',
+    eventValidation: 'unvalidated',
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  __resetForTests();
+  delete process.env.SM_EPIC_VALIDATION_DISABLE;
+});
+
+afterEach(() => {
+  delete process.env.SM_EPIC_VALIDATION_DISABLE;
+});
+
+// ─── (a) completed check-in → exactly one prompt naming the slug ────────────
+
+test('(a) a completed check-in enqueues exactly one validation prompt naming the PRD slug', () => {
+  const sendPrompt = vi.fn();
+  const readActiveIndex = vi.fn(() => indexAfterCheckin());
+
+  const res = maybeEnqueueValidationPrompt(callArgs(), { sendPrompt, readActiveIndex });
+
+  expect(res.enqueued).toBe(true);
+  expect(sendPrompt).toHaveBeenCalledTimes(1);
+  expect(sendPrompt).toHaveBeenCalledWith(EPIC, expect.stringContaining(SLUG));
+});
+
+// ─── (b) non-active Epic → nothing ──────────────────────────────────────────
+
+test('(b) a check-in for a completed (non-active) Epic enqueues nothing', () => {
+  const sendPrompt = vi.fn();
+  const readActiveIndex = vi.fn(() => indexAfterCheckin({ status: 'completed' }));
+
+  const res = maybeEnqueueValidationPrompt(callArgs(), { sendPrompt, readActiveIndex });
+
+  expect(res).toEqual({ enqueued: false, reason: 'epic-not-active' });
+  expect(sendPrompt).not.toHaveBeenCalled();
+});
+
+test('(b) an unknown Epic (no active-index entry) enqueues nothing — join-only, never creates an Epic', () => {
+  const sendPrompt = vi.fn();
+  const readActiveIndex = vi.fn(() => ({ sessions: {}, events: {} }));
+
+  const res = maybeEnqueueValidationPrompt(callArgs(), { sendPrompt, readActiveIndex });
+
+  expect(res).toEqual({ enqueued: false, reason: 'epic-not-active' });
+  expect(sendPrompt).not.toHaveBeenCalled();
+});
+
+// ─── (c) second check-in for the same (epicId, prdSlug) → nothing ───────────
+
+test('(c) a second check-in for the same (epicId, prdSlug) enqueues nothing (in-memory guard)', () => {
+  const sendPrompt = vi.fn();
+  const readActiveIndex = vi.fn(() => indexAfterCheckin());
+
+  expect(maybeEnqueueValidationPrompt(callArgs(), { sendPrompt, readActiveIndex }).enqueued).toBe(true);
+  const second = maybeEnqueueValidationPrompt(callArgs(), { sendPrompt, readActiveIndex });
+
+  expect(second).toEqual({ enqueued: false, reason: 'already-fired' });
+  expect(sendPrompt).toHaveBeenCalledTimes(1);
+});
+
+test('(c) durable guard: two validation-stamped check-in events already on the chain skip even after a process restart emptied the in-memory set', () => {
+  const sendPrompt = vi.fn();
+  // Chain carries the current check-in PLUS an earlier one for the same slug
+  // (a re-notify after restart appends a second response event).
+  const readActiveIndex = vi.fn(() => indexAfterCheckin({
+    extraEvents: [{
+      id: 'e3', promptSessionId: EPIC, kind: 'response', causedByEventId: 'e2',
+      at: '2026-08-02T02:00:00Z', text: `PRD ${SLUG} finished: completed.`,
+      prdSlug: SLUG, outcome: 'completed', validation: 'unvalidated',
+    }],
+  }));
+
+  __resetForTests(); // simulate the restart: in-memory set is empty
+  const res = maybeEnqueueValidationPrompt(callArgs(), { sendPrompt, readActiveIndex });
+
+  expect(res).toEqual({ enqueued: false, reason: 'already-fired-durable' });
+  expect(sendPrompt).not.toHaveBeenCalled();
+});
+
+test('(c) a different PRD slug for the same Epic still fires — the guard is per (epicId, prdSlug) pair, not per Epic', () => {
+  const sendPrompt = vi.fn();
+  const readActiveIndex = vi.fn(() => indexAfterCheckin());
+
+  expect(maybeEnqueueValidationPrompt(callArgs(), { sendPrompt, readActiveIndex }).enqueued).toBe(true);
+  const other = maybeEnqueueValidationPrompt(
+    callArgs({ prdSlug: '987-other-prd', prdPath: '/abs/987-other-prd.md' }),
+    { sendPrompt, readActiveIndex: vi.fn(() => ({ sessions: { [EPIC]: { id: EPIC, status: 'active' } }, events: { [EPIC]: [{ id: 'x', kind: 'response', prdSlug: '987-other-prd', validation: 'unvalidated' }] } })) },
+  );
+
+  expect(other.enqueued).toBe(true);
+  expect(sendPrompt).toHaveBeenCalledTimes(2);
+});
+
+// ─── (d) prompt content ─────────────────────────────────────────────────────
+
+test('(d) the enqueued prompt contains the PRD absolute path, the unverified-claim label, and the VERIFIED/REFUTED instruction', () => {
+  const sendPrompt = vi.fn();
+  const readActiveIndex = vi.fn(() => indexAfterCheckin());
+
+  maybeEnqueueValidationPrompt(callArgs(), { sendPrompt, readActiveIndex });
+
+  const prompt = sendPrompt.mock.calls[0][1];
+  expect(prompt).toContain(PRD_PATH);
+  expect(prompt).toContain(SLUG);
+  expect(prompt).toContain('UNVERIFIED CLAIM');
+  expect(prompt).toContain('"completed"');
+  expect(prompt).toContain('VERIFIED or REFUTED');
+  expect(prompt).toMatch(/file:line|command output/);
+  // AC #3: the not-evidence warning + the git diff --stat / empty-diff rule.
+  expect(prompt).toContain('exit code of 0');
+  expect(prompt).toContain('NOT evidence');
+  expect(prompt).toContain('git diff --stat');
+  expect(prompt).toMatch(/empty diff.*REFUTED/i);
+  // Acceptance-criteria-against-working-tree instruction.
+  expect(prompt).toMatch(/Acceptance criteria/i);
+  expect(prompt).toMatch(/working tree/i);
+});
+
+test('(d) buildValidationPrompt degrades gracefully when the PRD path could not be resolved', () => {
+  const prompt = buildValidationPrompt({ prdSlug: SLUG, prdPath: null, outcome: 'failed' });
+  expect(prompt).toContain(SLUG);
+  expect(prompt).toContain('path could not be resolved');
+  expect(prompt).toContain('"failed"');
+});
+
+// ─── (e) LOOP GUARD ─────────────────────────────────────────────────────────
+
+test('(e) LOOP GUARD: an appended event that is a validation result never enqueues a further prompt', () => {
+  const sendPrompt = vi.fn();
+  const readActiveIndex = vi.fn(() => indexAfterCheckin());
+
+  for (const eventValidation of ['verified', 'refuted', 'validating', undefined]) {
+    const res = maybeEnqueueValidationPrompt(callArgs({ eventValidation }), { sendPrompt, readActiveIndex });
+    expect(res).toEqual({ enqueued: false, reason: 'not-a-checkin' });
+  }
+  expect(sendPrompt).not.toHaveBeenCalled();
+});
+
+// ─── kill-switch ────────────────────────────────────────────────────────────
+
+test('SM_EPIC_VALIDATION_DISABLE=1 turns the hook off entirely', () => {
+  process.env.SM_EPIC_VALIDATION_DISABLE = '1';
+  const sendPrompt = vi.fn();
+  const readActiveIndex = vi.fn(() => indexAfterCheckin());
+
+  const res = maybeEnqueueValidationPrompt(callArgs(), { sendPrompt, readActiveIndex });
+
+  expect(res).toEqual({ enqueued: false, reason: 'disabled' });
+  expect(sendPrompt).not.toHaveBeenCalled();
+  expect(readActiveIndex).not.toHaveBeenCalled();
+});
+
+// ─── never throws ───────────────────────────────────────────────────────────
+
+test('a sendPrompt that throws is swallowed and logged, never propagated (fire-and-forget contract)', () => {
+  const sendPrompt = vi.fn(() => { throw new Error('IPC gone'); });
+  const readActiveIndex = vi.fn(() => indexAfterCheckin());
+  const log = { error: vi.fn() };
+
+  let res;
+  expect(() => {
+    res = maybeEnqueueValidationPrompt(callArgs(), { sendPrompt, readActiveIndex, log });
+  }).not.toThrow();
+  expect(res).toEqual({ enqueued: false, reason: 'error' });
+  expect(log.error).toHaveBeenCalled();
+});
+
+// ─── wiring through notifyOriginatingTab ────────────────────────────────────
+
+test('notifyOriginatingTab: a routed check-in stamps validation:unvalidated and fires the validation hook once with the Epic id + slug', async () => {
+  const sendPrompt = vi.fn();
+  const appendResponseEvent = vi.fn(async () => true);
+  const enqueueValidation = vi.fn(() => ({ enqueued: true }));
+  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: EPIC, path: PRD_PATH }));
+  const loadSessions = vi.fn(async () => ({ tabs: [] }));
+
+  await notifyOriginatingTab(
+    { slug: SLUG, status: 'completed', cwd: '/some/cwd' },
+    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent, enqueueValidation },
+  );
+
+  expect(appendResponseEvent).toHaveBeenCalledWith(
+    '/some/cwd', EPIC, expect.stringContaining(SLUG),
+    expect.objectContaining({ prdSlug: SLUG, outcome: 'completed', validation: 'unvalidated' }),
+  );
+  expect(enqueueValidation).toHaveBeenCalledTimes(1);
+  expect(enqueueValidation).toHaveBeenCalledWith(
+    expect.objectContaining({
+      cwd: '/some/cwd',
+      epicId: EPIC,
+      prdSlug: SLUG,
+      outcome: 'completed',
+      eventValidation: 'unvalidated',
+    }),
+    expect.objectContaining({ sendPrompt }),
+  );
+  // The check-in routed into the Epic chain — no tab-prompt fallback fires.
+  expect(sendPrompt).not.toHaveBeenCalled();
+});
+
+test('notifyOriginatingTab: a REFUSED append (unknown/completed Epic) never fires the validation hook', async () => {
+  const sendPrompt = vi.fn();
+  const appendResponseEvent = vi.fn(async () => false);
+  const enqueueValidation = vi.fn();
+  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: EPIC, sourceTabId: 'tab-x' }));
+  const loadSessions = vi.fn(async () => ({ tabs: [] }));
+
+  await notifyOriginatingTab(
+    { slug: SLUG, status: 'completed', cwd: '/some/cwd' },
+    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent, enqueueValidation },
+  );
+
+  expect(enqueueValidation).not.toHaveBeenCalled();
+});
+
+test('notifyOriginatingTab: a validation hook that throws never blocks the notification path', async () => {
+  const sendPrompt = vi.fn();
+  const appendResponseEvent = vi.fn(async () => true);
+  const enqueueValidation = vi.fn(() => { throw new Error('boom'); });
+  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: EPIC, path: PRD_PATH }));
+  const loadSessions = vi.fn(async () => ({ tabs: [] }));
+
+  await expect(
+    notifyOriginatingTab(
+      { slug: SLUG, status: 'failed', cwd: '/some/cwd' },
+      { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent, enqueueValidation },
+    ),
+  ).resolves.not.toThrow();
+});

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' } },