claude-code-session-manager 0.97.0 → 0.100.0

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);
-});

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

@@ -1,101 +0,0 @@
-/**
- * promptSessionSchema.test.cjs — unit tests for the canonical PromptSession
- * zod schema and its assertValidPromptSession fail-closed helper.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/promptSessionSchema.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const { PromptSessionSchema, assertValidPromptSession } = require('../lib/promptSessionSchema.cjs');
-
-test('a valid full record parses', () => {
-  const full = {
-    id: 'epic-abc12345',
-    cwd: '/home/bilko/Projects/session-manager',
-    goalText: 'do the thing',
-    claudeSessionId: 'c1b2a3d4-0000-0000-0000-000000000000',
-    status: 'proposed',
-    createdAt: '2026-08-02T00:00:00.000Z',
-    completedAt: null,
-    resumedFromId: 'old-epic-id',
-    tag: 'feature',
-    openingPrompt: 'full body of the first prompt',
-    source: {
-      producer: 'new-epic-ui',
-      prdSlug: '123-fix-thing',
-      runId: 'run-1',
-      sourceTabId: 'tab-1',
-    },
-    agentType: 'architect',
-  };
-  expect(() => assertValidPromptSession(full)).not.toThrow();
-  expect(PromptSessionSchema.safeParse(full).success).toBe(true);
-});
-
-test('a valid minimal record (only required fields) parses', () => {
-  const minimal = {
-    id: 'epic-abc12345',
-    cwd: '/home/bilko/Projects/session-manager',
-    goalText: 'do the thing',
-    claudeSessionId: 'c1b2a3d4-0000-0000-0000-000000000000',
-    status: 'active',
-    createdAt: '2026-08-02T00:00:00.000Z',
-    completedAt: null,
-  };
-  expect(() => assertValidPromptSession(minimal)).not.toThrow();
-});
-
-test('missing a required field fails', () => {
-  const missingGoalText = {
-    id: 'epic-abc12345',
-    cwd: '/home/bilko/Projects/session-manager',
-    claudeSessionId: 'c1b2a3d4-0000-0000-0000-000000000000',
-    status: 'active',
-    createdAt: '2026-08-02T00:00:00.000Z',
-    completedAt: null,
-  };
-  expect(() => assertValidPromptSession(missingGoalText)).toThrow(/goalText/);
-});
-
-test('an invalid status value fails', () => {
-  const badStatus = {
-    id: 'epic-abc12345',
-    cwd: '/home/bilko/Projects/session-manager',
-    goalText: 'do the thing',
-    claudeSessionId: 'c1b2a3d4-0000-0000-0000-000000000000',
-    status: 'in-progress',
-    createdAt: '2026-08-02T00:00:00.000Z',
-    completedAt: null,
-  };
-  expect(() => assertValidPromptSession(badStatus)).toThrow(/status/);
-});
-
-test('an invalid tag value fails', () => {
-  const badTag = {
-    id: 'epic-abc12345',
-    cwd: '/home/bilko/Projects/session-manager',
-    goalText: 'do the thing',
-    claudeSessionId: 'c1b2a3d4-0000-0000-0000-000000000000',
-    status: 'active',
-    createdAt: '2026-08-02T00:00:00.000Z',
-    completedAt: null,
-    tag: 'not-a-real-tag',
-  };
-  expect(() => assertValidPromptSession(badTag)).toThrow(/tag/);
-});
-
-test('a source object missing its required producer fails', () => {
-  const badSource = {
-    id: 'epic-abc12345',
-    cwd: '/home/bilko/Projects/session-manager',
-    goalText: 'do the thing',
-    claudeSessionId: 'c1b2a3d4-0000-0000-0000-000000000000',
-    status: 'active',
-    createdAt: '2026-08-02T00:00:00.000Z',
-    completedAt: null,
-    source: { prdSlug: '123-fix-thing' },
-  };
-  expect(() => assertValidPromptSession(badSource)).toThrow(/producer/);
-});