claude-code-session-manager 0.98.0 → 0.101.0

package/src/main/__tests__/procname-sm-processes.test.cjs

@@ -1,127 +0,0 @@
-/**
- * procname-sm-processes.test.cjs — PRD pn-03: Session Manager's own processes
- * (main, MCP server, watchdog, inhibit holder, terminal shells) get
- * self-describing kernel `comm` names. Headless: reads /proc/<pid>/comm.
- * HOME is redirected BEFORE procName loads (ALIAS_ROOT is fixed at require time).
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/procname-sm-processes.test.cjs
- */
-'use strict';
-
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { spawn, spawnSync, execFileSync } = require('node:child_process');
-
-const LINUX = process.platform === 'linux' && fs.existsSync('/proc/self/comm');
-const REPO = path.resolve(__dirname, '..', '..', '..');
-const sleepMs = (ms) => new Promise((r) => setTimeout(r, ms));
-const commOf = (pid) => fs.readFileSync(`/proc/${pid}/comm`, 'utf8').trim();
-
-let tmpHome; let realHome; let names; let procName;
-
-beforeAll(() => {
-  realHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-pn03-'));
-  process.env.HOME = tmpHome;
-  for (const m of ['procName', 'smProcNames']) delete require.cache[require.resolve(`../lib/${m}.cjs`)];
-  procName = require('../lib/procName.cjs');
-  names = require('../lib/smProcNames.cjs');
-});
-afterAll(() => {
-  process.env.HOME = realHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-async function waitComm(pid, want, ms = 8000) {
-  const end = Date.now() + ms;
-  let last = '';
-  while (Date.now() < end) {
-    try { last = commOf(pid); if (last === want) return last; } catch { /* not yet */ }
-    await sleepMs(50);
-  }
-  return last;
-}
-
-describe('names', () => {
-  it('every name is <= 15 chars and distinct', () => {
-    const vals = Object.values(names.PROC_NAMES);
-    for (const v of vals) expect(v.length).toBeLessThanOrEqual(15);
-    expect(new Set(vals).size).toBe(vals.length);
-    expect(names.PROC_NAMES.main).toBe('session-manager');
-    expect(names.PROC_NAMES.main.length).toBe(15);
-  });
-});
-
-describe.skipIf(!LINUX)('process.title', () => {
-  it('sets comm and does not disturb process.argv', () => {
-    const out = execFileSync(process.execPath, ['-e', `
-      const n = require(${JSON.stringify(path.join(REPO, 'src/main/lib/smProcNames.cjs'))});
-      n.setProcessTitle(n.PROC_NAMES.main);
-      console.log(require('fs').readFileSync('/proc/self/comm','utf8').trim() + '|' + process.argv.slice(1).join(','));
-    `, 'a', '--simple'], { encoding: 'utf8', env: { ...process.env, HOME: tmpHome } }).trim();
-    expect(out).toBe('session-manager|a,--simple');
-  });
-
-  it('scheduler-mcp-server.cjs reports sm-mcp-server', async () => {
-    const child = spawn(process.execPath, [path.join(REPO, 'scripts/scheduler-mcp-server.cjs')], { stdio: ['pipe', 'ignore', 'ignore'], env: { ...process.env, HOME: tmpHome } });
-    try { expect(await waitComm(child.pid, 'sm-mcp-server')).toBe('sm-mcp-server'); } finally { child.kill('SIGKILL'); }
-  });
-
-  it('scheduler-watchdog.cjs names itself before any other work (static) and the setter yields sm-watchdog', async () => {
-    // Not spawned for real: a stale-heartbeat run relaunches the app via npx.
-    const src = fs.readFileSync(path.join(REPO, 'scripts/scheduler-watchdog.cjs'), 'utf8');
-    const first = src.indexOf('setProcessTitle(PROC_NAMES.watchdog)');
-    expect(first).toBeGreaterThan(-1);
-    expect(first).toBeLessThan(src.indexOf("require('node:fs')"));
-    const child = spawn(process.execPath, ['-e', `require(${JSON.stringify(path.join(REPO, 'src/main/lib/smProcNames.cjs'))}).setProcessTitle('sm-watchdog'); setTimeout(()=>{},20000)`], { stdio: 'ignore', env: { ...process.env, HOME: tmpHome } });
-    try { expect(await waitComm(child.pid, 'sm-watchdog')).toBe('sm-watchdog'); } finally { child.kill('SIGKILL'); }
-  });
-
-  it('inhibit holder shell aliased to sm-inhibit-hold runs the poll loop', async () => {
-    const child = spawn(names.inhibitHolderShell(), ['-c', `while kill -0 ${process.pid} 2>/dev/null; do sleep 1; done`], { stdio: 'ignore' });
-    try { expect(await waitComm(child.pid, 'sm-inhibit-hold')).toBe('sm-inhibit-hold'); } finally { child.kill('SIGKILL'); }
-  });
-
-  it('bash login shell via sm-shell still sources rc files and keeps $SHELL', () => {
-    const bash = ['/bin/bash', '/usr/bin/bash'].find((p) => fs.existsSync(p));
-    if (!bash) return;
-    const bin = names.aliasedShellBin(bash);
-    expect(path.basename(bin)).toBe('sm-shell');
-    fs.writeFileSync(path.join(tmpHome, '.bash_profile'), 'export SM_RC_MARK=sourced\n');
-    fs.writeFileSync(path.join(tmpHome, '.bashrc'), 'export SM_RC_MARK=sourced\n');
-    const r = spawnSync(bin, ['-il', '-c', 'echo "$SM_RC_MARK|$SHELL|$(cat /proc/$$/comm)"'], { encoding: 'utf8', env: { HOME: tmpHome, SHELL: bash, PATH: process.env.PATH } });
-    expect(r.stdout.trim().split('\n').pop()).toBe(`sourced|${bash}|sm-shell`);
-  });
-
-  it('loadGate top-CPU line (ps comm) shows an aliased process', async () => {
-    const child = spawn(names.inhibitHolderShell(), ['-c', 'while :; do :; done'], { stdio: 'ignore' });
-    try {
-      await waitComm(child.pid, 'sm-inhibit-hold');
-      const out = execFileSync('ps', ['-eo', 'pid,pcpu,comm', '--sort=-pcpu'], { encoding: 'utf8' });
-      expect(out).toMatch(new RegExp(`^\\s*${child.pid}\\s+\\S+\\s+sm-inhibit-hold$`, 'm'));
-    } finally { child.kill('SIGKILL'); }
-  });
-});
-
-describe('shell aliasing rules', () => {
-  it('skips non-bash/zsh shells (fish, nu, unknown) and non-strings', () => {
-    for (const s of ['/usr/bin/fish', '/usr/bin/nu', '/opt/weird/xsh', '', undefined]) expect(names.aliasedShellBin(s)).toBe(s);
-  });
-  it('aliases zsh by path basename', () => {
-    const fake = path.join(tmpHome, 'zsh');
-    fs.writeFileSync(fake, '#!/bin/sh\n', { mode: 0o755 });
-    expect(path.basename(names.aliasedShellBin(fake))).toBe('sm-shell');
-  });
-  it('fails open when ALIAS_ROOT is unwritable', () => {
-    fs.rmSync(procName.procnamesRoot(), { recursive: true, force: true });
-    fs.mkdirSync(path.dirname(procName.procnamesRoot()), { recursive: true });
-    fs.writeFileSync(procName.procnamesRoot(), 'a file, so mkdir/symlink under it fails');
-    try {
-      expect(names.inhibitHolderShell()).toBe('/bin/sh');
-      const bash = ['/bin/bash', '/usr/bin/bash'].find((p) => fs.existsSync(p));
-      if (bash) expect(names.aliasedShellBin(bash)).toBe(bash);
-    } finally { fs.rmSync(procName.procnamesRoot(), { force: true }); }
-  });
-});

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

@@ -1,177 +0,0 @@
-/**
- * projectHomeAdminRoutes.test.cjs — lib/projectHomeAdminRoutes.cjs's single
- * route, POST /admin/project-home/write {cwd, html}, and its self-contained-
- * HTML validator.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/projectHomeAdminRoutes.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 { registerAdminRoute, validateHomeHtml, MAX_HTML_BYTES } = require('../lib/projectHomeAdminRoutes.cjs');
-
-const tmpDirs = [];
-afterEach(async () => {
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-async function mkProjectCwd() {
-  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-project-home-admin-'));
-  config.addAllowedRoot(dir);
-  fs.mkdirSync(path.join(dir, 'session-manager-operations'), { recursive: true });
-  tmpDirs.push(dir);
-  return dir;
-}
-
-/** Fake adminHttp stub: captures registered routes and invokes one directly. */
-function makeFakeAdminHttp() {
-  const routes = new Map();
-  return {
-    registerRoute(method, url, handler) {
-      routes.set(`${method} ${url}`, handler);
-    },
-    async call(method, url, { rawBody, body } = {}) {
-      const handler = routes.get(`${method} ${url}`);
-      if (!handler) throw new Error(`no route registered for ${method} ${url}`);
-      const text = rawBody !== undefined ? rawBody : body !== undefined ? JSON.stringify(body) : '';
-      const chunks = text ? [Buffer.from(text)] : [];
-      const req = {
-        on(event, cb) {
-          if (event === 'data') chunks.forEach((c) => cb(c));
-          if (event === 'end') cb();
-          return req;
-        },
-      };
-      let status = null;
-      let payload = null;
-      const res = {
-        writeHead(s) { status = s; },
-        end(b) { payload = b ? JSON.parse(b) : null; },
-      };
-      await handler(req, res, new URLSearchParams());
-      return { status, body: payload };
-    },
-    routes,
-  };
-}
-
-const GOOD_HTML = '<!DOCTYPE html><html><head><style>body{background:url(data:image/png;base64,AAAA)}</style></head><body><script>1+1</script></body></html>';
-
-test('registers exactly one route: POST /admin/project-home/write', () => {
-  const adminHttp = makeFakeAdminHttp();
-  registerAdminRoute(adminHttp);
-  expect([...adminHttp.routes.keys()]).toEqual(['POST /admin/project-home/write']);
-});
-
-test('valid html is written atomically to project-pages/home.html', async () => {
-  const cwd = await mkProjectCwd();
-  const adminHttp = makeFakeAdminHttp();
-  registerAdminRoute(adminHttp);
-  const { status, body } = await adminHttp.call('POST', '/admin/project-home/write', { body: { cwd, html: GOOD_HTML } });
-  expect(status).toBe(200);
-  expect(body.ok).toBe(true);
-  const target = path.join(fs.realpathSync(cwd), 'session-manager-operations', 'project-pages', 'home.html');
-  expect(body.path).toBe(target);
-  expect(fs.readFileSync(target, 'utf8')).toBe(GOOD_HTML);
-  // no per-lens / summary / manifest side files
-  expect(fs.readdirSync(path.dirname(target))).toEqual(['home.html']);
-});
-
-test('a second write replaces the first', async () => {
-  const cwd = await mkProjectCwd();
-  const adminHttp = makeFakeAdminHttp();
-  registerAdminRoute(adminHttp);
-  await adminHttp.call('POST', '/admin/project-home/write', { body: { cwd, html: '<p>one</p>' } });
-  await adminHttp.call('POST', '/admin/project-home/write', { body: { cwd, html: '<p>two</p>' } });
-  const target = path.join(fs.realpathSync(cwd), 'session-manager-operations', 'project-pages', 'home.html');
-  expect(fs.readFileSync(target, 'utf8')).toBe('<p>two</p>');
-});
-
-test.each([
-  ['empty', ''],
-  ['whitespace only', '  \n '],
-  ['script src', '<html><script src="app.js"></script></html>'],
-  ['script src (remote, single quotes, attrs first)', "<script defer type='module' src='https://cdn.example.com/x.js'></script>"],
-  ['link href http', '<link rel="stylesheet" href="https://fonts.googleapis.com/css">'],
-  ['link href protocol-relative', '<link rel="stylesheet" href="//cdn.example.com/a.css">'],
-  ['@import', '<style>@import url("https://x.com/a.css");</style>'],
-  ['@import bare string', '<style>@import "a.css";</style>'],
-  ['css url(http)', '<style>a{background:url(https://x.com/a.png)}</style>'],
-  ['css url(quoted http)', "<style>a{background:url( 'http://x.com/a.png')}</style>"],
-])('rejects %s with 400 and writes nothing', async (_label, html) => {
-  const cwd = await mkProjectCwd();
-  const adminHttp = makeFakeAdminHttp();
-  registerAdminRoute(adminHttp);
-  const { status, body } = await adminHttp.call('POST', '/admin/project-home/write', { body: { cwd, html } });
-  expect(status).toBe(400);
-  expect(body.ok).toBe(false);
-  expect(fs.existsSync(path.join(cwd, 'session-manager-operations', 'project-pages'))).toBe(false);
-});
-
-test('rejects html over 1MB', async () => {
-  const cwd = await mkProjectCwd();
-  const adminHttp = makeFakeAdminHttp();
-  registerAdminRoute(adminHttp);
-  const html = 'a'.repeat(MAX_HTML_BYTES + 1);
-  const { status, body } = await adminHttp.call('POST', '/admin/project-home/write', { body: { cwd, html } });
-  expect(status).toBe(400);
-  expect(body.error).toContain('limit');
-});
-
-test('a request body far beyond the cap is a clean 400, not a throw', async () => {
-  const cwd = await mkProjectCwd();
-  const adminHttp = makeFakeAdminHttp();
-  registerAdminRoute(adminHttp);
-  const html = 'a'.repeat(MAX_HTML_BYTES * 3);
-  const { status, body } = await adminHttp.call('POST', '/admin/project-home/write', { body: { cwd, html } });
-  expect(status).toBe(400);
-  expect(body.error).toContain('limit');
-});
-
-test('accepts an inline <link> to a local/data href and plain http text content', () => {
-  expect(validateHomeHtml('<p>see https://example.com in prose</p>')).toBeNull();
-  expect(validateHomeHtml('<link rel="icon" href="data:image/png;base64,AAAA">')).toBeNull();
-});
-
-test('validateHomeHtml exact 1MB is accepted, non-string rejected', () => {
-  expect(validateHomeHtml('a'.repeat(MAX_HTML_BYTES))).toBeNull();
-  expect(validateHomeHtml(undefined)).toMatch(/non-empty/);
-});
-
-test('bad JSON, missing/relative cwd, non-project cwd, and unknown keys are 400s', async () => {
-  const adminHttp = makeFakeAdminHttp();
-  registerAdminRoute(adminHttp);
-  const route = '/admin/project-home/write';
-  expect((await adminHttp.call('POST', route, { rawBody: '{nope' })).status).toBe(400);
-  expect((await adminHttp.call('POST', route, { body: { html: 'x' } })).status).toBe(400);
-  expect((await adminHttp.call('POST', route, { body: { cwd: 'relative/dir', html: 'x' } })).status).toBe(400);
-  expect((await adminHttp.call('POST', route, { body: { cwd: '/x', html: 'x', extra: 1 } })).status).toBe(400);
-
-  const bare = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-project-home-bare-'));
-  tmpDirs.push(bare);
-  config.addAllowedRoot(bare);
-  const res = await adminHttp.call('POST', route, { body: { cwd: bare, html: '<p>x</p>' } });
-  expect(res.status).toBe(400);
-  expect(res.body.error).toContain('not a Session Manager project');
-});
-
-test('one-file contract: project-pages holds exactly home.html after one write and after a regenerate', async () => {
-  const cwd = await mkProjectCwd();
-  const adminHttp = makeFakeAdminHttp();
-  registerAdminRoute(adminHttp);
-  const pagesDir = path.join(fs.realpathSync(cwd), 'session-manager-operations', 'project-pages');
-  await adminHttp.call('POST', '/admin/project-home/write', { body: { cwd, html: '<p>first</p>' } });
-  expect(fs.readdirSync(pagesDir)).toEqual(['home.html']);
-  await adminHttp.call('POST', '/admin/project-home/write', { body: { cwd, html: '<p>second, different</p>' } });
-  expect(fs.readdirSync(pagesDir)).toEqual(['home.html']);
-  expect(fs.readFileSync(path.join(pagesDir, 'home.html'), 'utf8')).toBe('<p>second, different</p>');
-});

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

@@ -1,137 +0,0 @@
-/**
- * projectPages.test.cjs — projectPages.cjs's read-only surface: get() of the
- * single project-pages/home.html ({html|null, mtimeMs}) plus the refcounted
- * watcher that pushes `project-pages:changed`.
- *
- * 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,
-  attachWindow,
-  watchOutput,
-  unwatchOutput,
-  closeAllOutputWatchers,
-  _outputWatchers,
-} = require('../projectPages.cjs');
-
-const tmpDirs = [];
-afterEach(async () => {
-  closeAllOutputWatchers();
-  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 pagesDir(cwd) {
-  return path.join(cwd, 'session-manager-operations', 'project-pages');
-}
-
-function writeHome(cwd, html) {
-  fs.mkdirSync(pagesDir(cwd), { recursive: true });
-  fs.writeFileSync(path.join(pagesDir(cwd), 'home.html'), html);
-}
-
-function makeFakeWindow(sent) {
-  return {
-    isDestroyed: () => false,
-    webContents: {
-      isDestroyed: () => false,
-      isCrashed: () => false,
-      send: (channel, payload) => sent.push({ channel, payload }),
-    },
-  };
-}
-
-async function waitFor(predicate, ms = 5000) {
-  const deadline = Date.now() + ms;
-  while (!predicate() && Date.now() < deadline) {
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-}
-
-test('get() returns the home.html text and its mtimeMs', async () => {
-  const cwd = await mkTmpCwd();
-  writeHome(cwd, '<html>HOME</html>');
-  const result = await get({ cwd });
-  expect(result.html).toBe('<html>HOME</html>');
-  expect(typeof result.mtimeMs).toBe('number');
-  expect(Object.keys(result).sort()).toEqual(['html', 'mtimeMs']);
-});
-
-test('get() with no home.html returns {html: null, mtimeMs: null} — no shipped default', async () => {
-  const cwd = await mkTmpCwd();
-  expect(await get({ cwd })).toEqual({ html: null, mtimeMs: null });
-});
-
-test('get() ignores legacy manifest/lens files — only home.html counts', async () => {
-  const cwd = await mkTmpCwd();
-  const out = path.join(pagesDir(cwd), 'output');
-  fs.mkdirSync(out, { recursive: true });
-  fs.writeFileSync(path.join(out, 'home.html'), 'OLD');
-  fs.writeFileSync(path.join(out, 'manifest.json'), '{"generatedAt":"2026-08-02T00:00:00.000Z"}');
-  expect(await get({ cwd })).toEqual({ html: null, mtimeMs: null });
-});
-
-test('get() with an ephemeral cwd (os.tmpdir() itself) returns null instead of throwing', async () => {
-  config.addAllowedRoot(os.tmpdir());
-  expect(await get({ cwd: os.tmpdir() })).toEqual({ html: null, mtimeMs: null });
-});
-
-test('watchOutput() on an ephemeral cwd refuses instead of crashing', async () => {
-  config.addAllowedRoot(os.tmpdir());
-  expect(await watchOutput(os.tmpdir())).toEqual({ ok: false, reason: 'ephemeral' });
-  expect(_outputWatchers.size).toBe(0);
-});
-
-test('watchOutput() is refcounted: two watches share one watcher, closed at the last unwatch', async () => {
-  const cwd = await mkTmpCwd();
-  expect(await watchOutput(cwd)).toEqual({ ok: true });
-  expect(await watchOutput(cwd)).toEqual({ ok: true });
-  expect(_outputWatchers.size).toBe(1);
-  unwatchOutput(cwd);
-  expect(_outputWatchers.size).toBe(1);
-  unwatchOutput(cwd);
-  expect(_outputWatchers.size).toBe(0);
-});
-
-test('watchOutput() pushes {cwd, html, mtimeMs} on project-pages:changed when home.html lands, ignoring sibling files', async () => {
-  const cwd = await mkTmpCwd();
-  const sent = [];
-  attachWindow(makeFakeWindow(sent));
-
-  expect(await watchOutput(cwd)).toEqual({ ok: true });
-  expect(_outputWatchers.size).toBe(1);
-
-  fs.writeFileSync(path.join(pagesDir(cwd), 'summary.json'), '{}');
-  writeHome(cwd, '<html>HOME</html>');
-  await waitFor(() => sent.length > 0);
-
-  expect(sent.length).toBeGreaterThan(0);
-  for (const msg of sent) expect(msg.channel).toBe('project-pages:changed');
-  const last = sent[sent.length - 1];
-  expect(last.payload.cwd).toBe(fs.realpathSync(cwd));
-  expect(last.payload.html).toBe('<html>HOME</html>');
-  expect(typeof last.payload.mtimeMs).toBe('number');
-  // summary.json alone must not have produced a push carrying no html
-  expect(sent.every((m) => m.payload.html === '<html>HOME</html>')).toBe(true);
-
-  unwatchOutput(cwd);
-  expect(_outputWatchers.size).toBe(0);
-}, 10_000);

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

@@ -1,234 +0,0 @@
-/**
- * promptSessionEvents.test.cjs — unit tests for appendResponseEventIfKnown
- * (PRD 814): the scheduler's main-process counterpart to promptSessions.ts's
- * event chain, used to route a PRD-finished notification into a known
- * PromptSession's own event chain instead of an unrelated tab.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/promptSessionEvents.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach, vi } 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 {
-  appendResponseEventIfKnown,
-  promptSessionActiveIndexPath,
-  attachWindow,
-  EVENT_APPENDED_CHANNEL,
-} = require('../promptSessionEvents.cjs');
-
-let cwd;
-
-beforeEach(async () => {
-  cwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prompt-session-events-'));
-  config.addAllowedRoot(cwd);
-});
-
-async function writeIndex(index) {
-  const indexPath = promptSessionActiveIndexPath(cwd);
-  await fsp.mkdir(path.dirname(indexPath), { recursive: true });
-  await fsp.writeFile(indexPath, JSON.stringify(index, null, 2));
-}
-
-test('returns false when no active-index.json exists for the cwd', async () => {
-  const routed = await appendResponseEventIfKnown(cwd, 'psess-unknown', 'hi');
-  expect(routed).toBe(false);
-});
-
-test('returns false when the sourcePromptId is not in the index', async () => {
-  await writeIndex({ sessions: {}, events: {} });
-  const routed = await appendResponseEventIfKnown(cwd, 'psess-unknown', 'hi');
-  expect(routed).toBe(false);
-});
-
-test('returns false when the session is completed (no longer active)', async () => {
-  await writeIndex({
-    sessions: { 'psess-1': { id: 'psess-1', cwd, status: 'completed' } },
-    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', 'hi');
-  expect(routed).toBe(false);
-});
-
-test('appends a response event chained to the current tail and returns true', 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' },
-        { id: 'pevt-2', promptSessionId: 'psess-1', kind: 'prd_created', causedByEventId: 'pevt-1', at: '2026-01-01T00:01:00.000Z', prdSlug: '814-foo' },
-      ],
-    },
-  });
-
-  const routed = await appendResponseEventIfKnown(cwd, 'psess-1', 'PRD 814-foo finished: completed.');
-  expect(routed).toBe(true);
-
-  const onDisk = JSON.parse(await fsp.readFile(promptSessionActiveIndexPath(cwd), 'utf8'));
-  const events = onDisk.events['psess-1'];
-  expect(events).toHaveLength(3);
-  expect(events[2].kind).toBe('response');
-  expect(events[2].causedByEventId).toBe('pevt-2');
-  expect(events[2].text).toBe('PRD 814-foo finished: completed.');
-});
-
-test('two different PromptSessions in the same cwd each get their own non-interleaved event appended', async () => {
-  await writeIndex({
-    sessions: {
-      'psess-a': { id: 'psess-a', cwd, status: 'active' },
-      'psess-b': { id: 'psess-b', cwd, status: 'active' },
-    },
-    events: {
-      'psess-a': [{ id: 'pevt-a1', promptSessionId: 'psess-a', kind: 'prompt', causedByEventId: null, at: '2026-01-01T00:00:00.000Z' }],
-      'psess-b': [{ id: 'pevt-b1', promptSessionId: 'psess-b', kind: 'prompt', causedByEventId: null, at: '2026-01-01T00:00:00.000Z' }],
-    },
-  });
-
-  const [routedA, routedB] = await Promise.all([
-    appendResponseEventIfKnown(cwd, 'psess-a', 'PRD A finished'),
-    appendResponseEventIfKnown(cwd, 'psess-b', 'PRD B finished'),
-  ]);
-  expect(routedA).toBe(true);
-  expect(routedB).toBe(true);
-
-  const onDisk = JSON.parse(await fsp.readFile(promptSessionActiveIndexPath(cwd), 'utf8'));
-  expect(onDisk.events['psess-a']).toHaveLength(2);
-  expect(onDisk.events['psess-b']).toHaveLength(2);
-  expect(onDisk.events['psess-a'][1].text).toBe('PRD A finished');
-  expect(onDisk.events['psess-a'][1].causedByEventId).toBe('pevt-a1');
-  expect(onDisk.events['psess-b'][1].text).toBe('PRD B finished');
-  expect(onDisk.events['psess-b'][1].causedByEventId).toBe('pevt-b1');
-});
-
-test('returns false (never throws) when cwd or sourcePromptId is missing', async () => {
-  await expect(appendResponseEventIfKnown(null, 'psess-1', 'hi')).resolves.toBe(false);
-  await expect(appendResponseEventIfKnown(cwd, null, 'hi')).resolves.toBe(false);
-});
-
-test('broadcasts EVENT_APPENDED_CHANNEL to the attached window on a successful append', 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 send = vi.fn();
-  const fakeWindow = { isDestroyed: () => false, webContents: { isDestroyed: () => false, send } };
-  attachWindow(fakeWindow);
-  try {
-    const routed = await appendResponseEventIfKnown(cwd, 'psess-1', 'PRD finished');
-    expect(routed).toBe(true);
-    expect(send).toHaveBeenCalledTimes(1);
-    const [channel, payload] = send.mock.calls[0];
-    expect(channel).toBe(EVENT_APPENDED_CHANNEL);
-    expect(payload.cwd).toBe(cwd);
-    expect(payload.promptSessionId).toBe('psess-1');
-    expect(payload.event.kind).toBe('response');
-    expect(payload.event.text).toBe('PRD finished');
-    expect(payload.event.causedByEventId).toBe('pevt-1');
-  } finally {
-    attachWindow(null);
-  }
-});
-
-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' } },
-    events: {
-      'psess-1': [
-        { id: 'pevt-1', promptSessionId: 'psess-1', kind: 'prompt', causedByEventId: null, at: '2026-01-01T00:00:00.000Z' },
-      ],
-    },
-  });
-
-  attachWindow(null);
-  await expect(appendResponseEventIfKnown(cwd, 'psess-1', 'no window yet')).resolves.toBe(true);
-
-  const destroyedWindow = { isDestroyed: () => true, webContents: { isDestroyed: () => false, send: vi.fn() } };
-  attachWindow(destroyedWindow);
-  await expect(appendResponseEventIfKnown(cwd, 'psess-1', 'window destroyed')).resolves.toBe(true);
-  expect(destroyedWindow.webContents.send).not.toHaveBeenCalled();
-  attachWindow(null);
-});