claude-code-session-manager 0.51.0 → 0.52.0

package/dist/index.html

@@ -7,10 +7,10 @@
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=Newsreader:ital,opsz,wght@0,6..72,400;0,6..72,500;0,6..72,600;0,6..72,700;1,6..72,400&family=Geist:wght@300;400;500;600;700&family=IBM+Plex+Mono:wght@400;500;600&display=swap" rel="stylesheet">
-    <script type="module" crossorigin src="./assets/index-DPY5vv68.js"></script>
+    <script type="module" crossorigin src="./assets/index-hNso_ykJ.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/monaco-editor-BW5C4Iv1.js">
     <link rel="stylesheet" crossorigin href="./assets/monaco-editor-BTnBOi8r.css">
-    <link rel="stylesheet" crossorigin href="./assets/index-BXzDjHNE.css">
+    <link rel="stylesheet" crossorigin href="./assets/index-CKP60_3d.css">
   </head>
   <body class="bg-bg text-fg font-sans antialiased">
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-session-manager",
-  "version": "0.51.0",
+  "version": "0.52.0",
   "description": "Local cockpit for the Claude Code CLI — multi-tab terminal, full config surface, scheduler, voice dictation, and live observability.",
   "type": "module",
   "main": "src/main/index.cjs",
@@ -28,6 +28,8 @@
     "dev:renderer": "vite",
     "dev:electron": "wait-on http://localhost:5173 && SM_DEV=1 electron .",
     "build": "vite build",
+    "build:project-pages": "node scripts/build-project-pages-renderer.mjs",
+    "build:project-pages-logic": "node scripts/build-project-pages-logic.mjs",
     "typecheck": "tsc --noEmit",
     "start": "electron .",
     "postinstall": "node scripts/postinstall.cjs",
@@ -124,6 +126,7 @@
     "@vitejs/plugin-react": "^4.3.3",
     "autoprefixer": "^10.4.20",
     "concurrently": "^9.1.0",
+    "esbuild": "^0.25.12",
     "jsdom": "^29.1.1",
     "postcss": "^8.4.49",
     "react": "^18.3.1",

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

@@ -0,0 +1,152 @@
+/**
+ * prdLocationsArchived.test.cjs — unit tests for the archived-PRD discovery
+ * that backs `schedule:list-prds` including archived PRDs (PRD 926): an
+ * Epic's "PRDs" tab count must reflect its REAL historical PRD count, not
+ * just whatever is still sitting in its live `prds/` dir — a completed
+ * PRD's source .md moves to the sibling `prds-archived/` dir the instant its
+ * scheduler job finishes (scheduler.cjs's archiveCompletedPrd), which the
+ * old list-prds handler never read.
+ *
+ * Covers:
+ *   - resolveArchivedPrdsDirs finds an Epic's own `prds-archived/` dir
+ *     alongside the project's flat sibling one.
+ *   - deriveEpicIdFromPrdPath resolves an epicId for a file under
+ *     `prds-archived/`, not just the live `prds/` dir.
+ *   - scheduler.cjs's candidateArchivedPrdsDirs + candidatePrdsDirs
+ *     together surface both a still-pending PRD and an already-archived one
+ *     for the same Epic, without double-counting.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/prdLocationsArchived.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 {
+  resolveArchivedPrdsDirs,
+  resolvePrdsDirs,
+  resolveEpicPrdWriteDir,
+  deriveEpicIdFromPrdPath,
+} = require('../lib/prdLocations.cjs');
+const { candidatePrdsDirs, candidateArchivedPrdsDirs, resolveArchivedPrdStatus } = require('../scheduler.cjs');
+
+const tmpDirs = [];
+afterEach(async () => {
+  while (tmpDirs.length) {
+    const d = tmpDirs.pop();
+    await fsp.rm(d, { recursive: true, force: true });
+  }
+});
+
+function mkEpicProject() {
+  return fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-archived-cwd-'));
+}
+
+test('resolveArchivedPrdsDirs finds an Epic\'s own prds-archived/ dir for an active project', async () => {
+  const projectsDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-archived-projects-'));
+  tmpDirs.push(projectsDir);
+  const projectCwd = await mkEpicProject();
+  tmpDirs.push(projectCwd);
+
+  const epicPrdsDir = resolveEpicPrdWriteDir(projectCwd, 'epic-1');
+  const epicArchiveDir = path.join(epicPrdsDir, '..', 'prds-archived');
+  fs.mkdirSync(epicArchiveDir, { recursive: true });
+
+  const projDir = path.join(projectsDir, 'epic-project');
+  fs.mkdirSync(projDir, { recursive: true });
+  const transcript = path.join(projDir, 'session1.jsonl');
+  fs.writeFileSync(transcript, `${JSON.stringify({ cwd: projectCwd })}\n`);
+
+  const dirs = resolveArchivedPrdsDirs(90, { projectsDir });
+  expect(dirs).toContain(path.resolve(epicArchiveDir));
+});
+
+test('deriveEpicIdFromPrdPath resolves epicId for a file under prds-archived/, not just prds/', async () => {
+  const projectCwd = await mkEpicProject();
+  tmpDirs.push(projectCwd);
+
+  const epicPrdsDir = resolveEpicPrdWriteDir(projectCwd, 'epic-42');
+  const epicArchiveDir = path.join(epicPrdsDir, '..', 'prds-archived');
+  fs.mkdirSync(epicArchiveDir, { recursive: true });
+
+  const archivedFile = path.join(epicArchiveDir, '917-example.md');
+  fs.writeFileSync(archivedFile, '---\ntitle: example\n---\n\n# Goal\n');
+
+  expect(deriveEpicIdFromPrdPath(archivedFile)).toBe('epic-42');
+  // Still works for the live dir too — no regression.
+  const liveFile = path.join(epicPrdsDir, '918-example.md');
+  fs.mkdirSync(epicPrdsDir, { recursive: true });
+  fs.writeFileSync(liveFile, '---\ntitle: example\n---\n\n# Goal\n');
+  expect(deriveEpicIdFromPrdPath(liveFile)).toBe('epic-42');
+});
+
+test('deriveEpicIdFromPrdPath returns null for an unrelated dir name', () => {
+  expect(deriveEpicIdFromPrdPath('/some/random/dir/917-example.md')).toBeNull();
+});
+
+test('resolvePrdsDirs + resolveArchivedPrdsDirs together surface a pending PRD dir and an archived PRD dir for the same Epic, with no overlap', async () => {
+  const projectsDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-both-projects-'));
+  tmpDirs.push(projectsDir);
+  const projectCwd = await mkEpicProject();
+  tmpDirs.push(projectCwd);
+
+  const epicId = `test-epic-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
+  const epicPrdsDir = resolveEpicPrdWriteDir(projectCwd, epicId);
+  const epicArchiveDir = path.join(epicPrdsDir, '..', 'prds-archived');
+  fs.mkdirSync(epicPrdsDir, { recursive: true });
+  fs.mkdirSync(epicArchiveDir, { recursive: true });
+
+  const pendingSlug = `926-pending-${process.pid}`;
+  const archivedSlug = `917-archived-${process.pid}`;
+  fs.writeFileSync(path.join(epicPrdsDir, `${pendingSlug}.md`), `---\ntitle: pending\ncwd: ${projectCwd}\n---\n\n# Goal\n`);
+  fs.writeFileSync(path.join(epicArchiveDir, `${archivedSlug}.md`), `---\ntitle: archived\ncwd: ${projectCwd}\n---\n\n# Goal\n`);
+
+  const projDir = path.join(projectsDir, 'both-project');
+  fs.mkdirSync(projDir, { recursive: true });
+  fs.writeFileSync(path.join(projDir, 'session1.jsonl'), `${JSON.stringify({ cwd: projectCwd })}\n`);
+
+  const liveDirs = resolvePrdsDirs(90, { projectsDir });
+  const archivedDirs = resolveArchivedPrdsDirs(90, { projectsDir });
+  expect(liveDirs).toContain(epicPrdsDir);
+  expect(archivedDirs.map((d) => path.resolve(d))).toContain(path.resolve(epicArchiveDir));
+
+  // No overlap between the two dir sets for this Epic — an archived PRD's
+  // dir is never also scanned as a live one, and vice versa.
+  expect(liveDirs).not.toContain(epicArchiveDir);
+  expect(archivedDirs).not.toContain(epicPrdsDir);
+});
+
+test('resolveArchivedPrdStatus prefers the live queue.json row over history', () => {
+  const liveStatusBySlug = new Map([['917-slug', 'failed']]);
+  const histBySlug = new Map([['917-slug', { status: 'completed' }]]);
+  expect(resolveArchivedPrdStatus('917-slug', liveStatusBySlug, histBySlug)).toBe('failed');
+});
+
+test('resolveArchivedPrdStatus falls back to history.jsonl when there is no live row', () => {
+  const liveStatusBySlug = new Map();
+  const histBySlug = new Map([['917-slug', { status: 'failed' }]]);
+  expect(resolveArchivedPrdStatus('917-slug', liveStatusBySlug, histBySlug)).toBe('failed');
+});
+
+test('resolveArchivedPrdStatus defaults to completed when neither source has the slug', () => {
+  expect(resolveArchivedPrdStatus('917-slug', new Map(), new Map())).toBe('completed');
+});
+
+test('resolveArchivedPrdStatus normalizes any non-failed status (e.g. needs_review) to completed', () => {
+  const liveStatusBySlug = new Map([['917-slug', 'needs_review']]);
+  expect(resolveArchivedPrdStatus('917-slug', liveStatusBySlug, new Map())).toBe('completed');
+});
+
+test('scheduler.cjs exports candidateArchivedPrdsDirs alongside candidatePrdsDirs', () => {
+  expect(typeof candidatePrdsDirs).toBe('function');
+  expect(typeof candidateArchivedPrdsDirs).toBe('function');
+  // Both scan the real machine's projects — just assert they run without
+  // throwing and return arrays; per-Epic coverage is exercised above via
+  // the opts-injectable prdLocations functions directly.
+  expect(Array.isArray(candidatePrdsDirs())).toBe(true);
+  expect(Array.isArray(candidateArchivedPrdsDirs())).toBe(true);
+});

package/src/main/__tests__/scheduler-reap-dead-running-jobs.test.cjs

@@ -0,0 +1,103 @@
+/**
+ * scheduler-reap-dead-running-jobs.test.cjs — regression cover for PRD 935
+ * (reapDeadRunningJobs runningSet desync).
+ *
+ * spawnJob()'s completion path can write terminal run artifacts to disk and
+ * have its child process fully exit, yet still throw between executeJob()
+ * resolving and the completion mutate() finishing (e.g. writeQueue's
+ * unreadable guard). That throw is swallowed by spawnJob()'s catch, but its
+ * `finally` unconditionally deletes the job's slug from the in-memory
+ * runningSet — leaving queue.json stuck at status:"running" with a dead pid
+ * while runningSet no longer names it. reapDeadRunningJobs() used to gate its
+ * entire body on `runningSet.size === 0`, so this exact state made it return
+ * before ever reading queue.json — permanently invisible to reconciliation.
+ *
+ * This test reproduces that desync directly: a project queue.json job row
+ * with status:"running" and a dead pid, while runningSet (freshly loaded,
+ * never populated) does not contain its slug. It asserts the job still gets
+ * reconciled to a terminal status.
+ *
+ * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs, since every
+ * path this code touches (queueStore's MACHINE_STATE_PATH, activeSessions'
+ * project scan root, scheduler.cjs's ROOT/RUNS_DIR, schedulerBatch's
+ * DEFAULT_PROJECT_CWD) is baked into a top-level const from os.homedir() at
+ * require time — this test must never be able to read or write real state.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-reap-dead-running-jobs.test.cjs
+ */
+
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'reap-dead-running-jobs-test-'));
+process.env.HOME = tmpHome;
+
+const { reapDeadRunningJobs } = require('../scheduler.cjs');
+
+function registerActiveProject(cwd) {
+  const projectsDir = path.join(tmpHome, '.claude', 'projects');
+  const slugDir = path.join(projectsDir, 'fake-project-slug');
+  fs.mkdirSync(slugDir, { recursive: true });
+  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
+}
+
+function writeProjectQueue(cwd, jobs) {
+  const stateDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'state');
+  fs.mkdirSync(stateDir, { recursive: true });
+  fs.writeFileSync(path.join(stateDir, 'queue.json'), JSON.stringify({ jobs }, null, 2));
+  return path.join(stateDir, 'queue.json');
+}
+
+function writeRunLog(runId, slug, lines) {
+  const runDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', runId);
+  fs.mkdirSync(runDir, { recursive: true });
+  fs.writeFileSync(path.join(runDir, `${slug}.log`), lines.join('\n') + '\n');
+}
+
+test('reapDeadRunningJobs reconciles a queue.json row stuck at status:running with a dead pid, even when runningSet does not name its slug (desync repro)', async () => {
+  const projectCwd = path.join(tmpHome, 'a-project');
+  fs.mkdirSync(projectCwd, { recursive: true });
+  registerActiveProject(projectCwd);
+
+  const queuePath = writeProjectQueue(projectCwd, [
+    {
+      slug: 'desynced-job',
+      status: 'running',
+      cwd: projectCwd,
+      runId: 'run-desynced',
+      runtime: { pid: 999999 }, // guaranteed-dead pid (see reaperHelpers tests)
+    },
+  ]);
+  writeRunLog('run-desynced', 'desynced-job', [
+    '{"type":"result","subtype":"success","result":"done","is_error":false}',
+  ]);
+
+  // runningSet is a fresh module-level Set with nothing in it — this is the
+  // exact desynced state spawnJob()'s finally block can leave behind.
+  await reapDeadRunningJobs();
+
+  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
+  assert.equal(jobs.length, 1);
+  assert.equal(jobs[0].status, 'completed', 'job must be reconciled from disk state, not skipped via the runningSet gate');
+  assert.equal(jobs[0].exitCode, 0);
+  assert.equal(jobs[0].runtime, undefined);
+});
+
+test('reapDeadRunningJobs is a no-op when no job is actually running in queue.json', async () => {
+  const projectCwd = path.join(tmpHome, 'b-project');
+  fs.mkdirSync(projectCwd, { recursive: true });
+  registerActiveProject(projectCwd);
+  const queuePath = writeProjectQueue(projectCwd, [
+    { slug: 'already-done', status: 'completed', cwd: projectCwd, exitCode: 0 },
+  ]);
+
+  await assert.doesNotReject(() => reapDeadRunningJobs());
+
+  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
+  assert.equal(jobs.length, 1);
+  assert.equal(jobs[0].status, 'completed');
+});

package/src/main/index.cjs

@@ -58,6 +58,7 @@ const schedulerConfig = require('./lib/schedulerConfig.cjs');
 const memoryTool = require('./memoryTool.cjs');
 const { registerMemoryAggregateIpc } = require('./memoryAggregate.cjs');
 const { registerProjectBriefIpc } = require('./projectBrief.cjs');
+const { registerProjectPagesIpc } = require('./projectPages.cjs');
 const promptSessionTranscript = require('./promptSessionTranscript.cjs');
 const agentMemory = require('./agentMemory.cjs');
 const git = require('./git.cjs');
@@ -789,6 +790,7 @@ pluginInstall.registerPluginInstallHandlers();
 memoryTool.registerMemoryHandlers();
 registerMemoryAggregateIpc();
 registerProjectBriefIpc();
+registerProjectPagesIpc();
 ipcMain.handle('promptSessionTranscript:append', validated(schemas.promptSessionTranscriptAppend, async ({ cwd, epicId, role, text, at, eventId }) => {
   const ok = await promptSessionTranscript.appendTurn(cwd, epicId, { role, text, at, eventId });
   return { ok };

package/src/main/ipcSchemas.cjs

@@ -313,7 +313,7 @@ const schedulerCreatePrd = z.object({
   originClaudeSessionId: z.string().min(1).max(128).regex(NO_NEWLINE_RE, 'must not contain newlines').optional(),
   // User-selected Feature/Bug tag (PRD 774) carried from the originating
   // PromptTicket — deterministic, never LLM-classified.
-  tag: z.enum(['feature', 'bug', 'discussion', 'build']).optional(),
+  tag: z.enum(['feature', 'bug', 'discussion', 'build', 'project-home-builder']).optional(),
 });
 
 // Bulk archive: slug list, capped to limit unbounded retag/archive payloads.
@@ -446,6 +446,13 @@ const PROJECT_BRIEF_BLOCK = z.enum(['what', 'conventions']);
 const projectBriefCwd = z.object({
   cwd: z.string().min(1).max(4096),
 }).strict();
+
+// ──────────────────────────────────────────── Project Pages (PRD 932)
+// Same validation split as projectBriefCwd above: real path validation is
+// config.cjs's validatePath at first fs access in projectPages.cjs.
+const projectPagesCwd = z.object({
+  cwd: z.string().min(1).max(4096),
+}).strict();
 const projectBriefSetPin = z.object({
   cwd: z.string().min(1).max(4096),
   block: PROJECT_BRIEF_BLOCK,
@@ -877,6 +884,7 @@ module.exports = {
     memoryAggregate,
     memoryStale,
     projectBriefCwd,
+    projectPagesCwd,
     projectBriefSetPin,
     projectBriefUpdate,
     promptSessionTranscriptAppend,

package/src/main/lib/epicMint.cjs

@@ -208,11 +208,21 @@ function ensureEpic(cwd, { goalText, tag, reuseByGoal = false, epicId: explicitE
     const index = readActiveIndex(cwd);
 
     // A dispatch that already knows its Epic (sourcePromptId frontmatter from
-    // an Epic-conversation dispatch) joins it rather than minting a sibling.
+    // an Epic-conversation dispatch) joins it rather than minting a sibling —
+    // but only while that Epic is still open. Joining unconditionally here
+    // let a stale/hallucinated sourcePromptId silently attach a PRD (and its
+    // follow-on events/chat activity) to an unrelated or even completed
+    // Epic — the "this session ran again without my knowledge, and it was
+    // really another Epic's prompt" cross-contamination bug. Mirrors
+    // findJoinableEpicInIndex()'s preferEpicId open-check (line ~124).
     if (explicitEpicId && hasOwn(index.sessions, explicitEpicId)) {
-      const prdDir = resolveEpicPrdWriteDir(cwd, explicitEpicId);
-      fs.mkdirSync(prdDir, { recursive: true });
-      return { epicId: explicitEpicId, prdDir, created: false };
+      const preferred = index.sessions[explicitEpicId];
+      if (preferred && (preferred.status === 'proposed' || preferred.status === 'active')) {
+        const prdDir = resolveEpicPrdWriteDir(cwd, explicitEpicId);
+        fs.mkdirSync(prdDir, { recursive: true });
+        return { epicId: explicitEpicId, prdDir, created: false };
+      }
+      console.warn(`[epicMint] ensureEpic: explicit epicId ${explicitEpicId} exists but is not open (status=${preferred?.status ?? 'unknown'}) — refusing to join, falling through`);
     }
 
     if (reuseByGoal) {

package/src/main/lib/prdLocations.cjs

@@ -145,6 +145,39 @@ function resolvePrdsDirs(maxAgeMin, opts) {
   return dirs;
 }
 
+/**
+ * resolveArchivedPrdsDirs(maxAgeMin?, opts?) → string[]
+ *
+ * The `prds-archived/` counterpart of resolvePrdsDirs — every archive dir
+ * (the flat per-project sibling plus each Epic's own sibling, per
+ * listArchivedPrdDirs) that exists on disk, across every historical AND
+ * currently-active project. Same "not recency-filtered" rationale as
+ * resolvePrdsDirs: a quiet project's completed-PRD history is still real
+ * history, not something list-prds should stop counting.
+ */
+function resolveArchivedPrdsDirs(maxAgeMin, opts) {
+  const dirs = [];
+  const seen = new Set();
+  const add = (dir) => {
+    if (seen.has(dir)) return;
+    seen.add(dir);
+    dirs.push(dir);
+  };
+
+  for (const cwd of allProjectCwds(opts)) {
+    for (const dir of listArchivedPrdDirs(cwd)) {
+      if (fs.existsSync(dir)) add(dir);
+    }
+  }
+  for (const cwd of activeProjectCwds(maxAgeMin, opts)) {
+    for (const dir of listArchivedPrdDirs(cwd)) {
+      if (fs.existsSync(dir)) add(dir);
+    }
+  }
+
+  return dirs;
+}
+
 /**
  * deriveEpicIdFromPrdPath(filePath) → epicId | null
  *
@@ -160,7 +193,11 @@ function resolvePrdsDirs(maxAgeMin, opts) {
 function deriveEpicIdFromPrdPath(filePath) {
   if (!filePath || typeof filePath !== 'string') return null;
   const prdsDir = path.dirname(filePath);
-  if (path.basename(prdsDir) !== 'prds') return null;
+  // Accept both an Epic's live `prds/` dir and its sibling `prds-archived/`
+  // dir — archived PRDs still belong to the Epic they were dispatched from,
+  // and callers (parsePrdRaw, list-prds) need epicId for archived files too.
+  const dirName = path.basename(prdsDir);
+  if (dirName !== 'prds' && dirName !== 'prds-archived') return null;
   const epicDir = path.dirname(prdsDir);
   const epicId = path.basename(epicDir);
   if (!epicId || epicId === '.' || epicId === path.sep) return null;
@@ -168,13 +205,14 @@ function deriveEpicIdFromPrdPath(filePath) {
   for (let i = 0; i < EPICS_SUBPATH.length; i++) projectCwd = path.dirname(projectCwd);
   let epicsRoot;
   try { epicsRoot = resolveEpicsRoot(projectCwd); } catch { return null; }
-  if (path.join(epicsRoot, epicId, 'prds') !== prdsDir) return null;
+  if (path.join(epicsRoot, epicId, dirName) !== prdsDir) return null;
   return epicId;
 }
 
 module.exports = {
   resolvePrdWriteDir,
   resolvePrdsDirs,
+  resolveArchivedPrdsDirs,
   resolveEpicsRoot,
   resolveEpicPrdWriteDir,
   listEpicPrdDirs,

package/src/main/projectPages.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+/**
+ * projectPages.cjs — read-only backend for Project Home's Project Pages
+ * display (PRD 932). Reads what the `project-home-builder` Epic's own
+ * session writes directly with its Write tool
+ * (`session-manager-operations/project-pages/output/*.html` + manifest.json)
+ * — this module never writes anything, matching the corrected "not an
+ * OWNERS namespace" storage/ownership note in
+ * session-manager-operations/architecture/project-pages-pipeline.md and
+ * session-manager-operations/project-pages/README.md. Structure mirrors
+ * projectBrief.cjs's `get()`: validatePath first, config.cjs read helpers,
+ * one ipcMain.handle registered from index.cjs's registerXHandlers() pattern.
+ */
+
+const { ipcMain } = require('electron');
+const path = require('node:path');
+const config = require('./config.cjs');
+
+function outputDir(cwd) {
+  return path.join(cwd, 'session-manager-operations', 'project-pages', 'output');
+}
+
+const LENSES = ['marketing', 'feature', 'architecture'];
+
+async function get({ cwd }) {
+  const realCwd = config.validatePath(cwd);
+  const dir = outputDir(realCwd);
+  const manifestResult = await config.readJson(path.join(dir, 'manifest.json'));
+  if (!manifestResult.exists || !manifestResult.data || manifestResult.parseError) {
+    return { output: null };
+  }
+
+  const htmlResults = await Promise.all(
+    LENSES.map((lens) => config.readText(path.join(dir, `${lens}.html`))),
+  );
+  if (htmlResults.some((r) => !r.exists)) {
+    return { output: null };
+  }
+
+  const [marketing, feature, architecture] = htmlResults;
+  const generatedAt = typeof manifestResult.data.generatedAt === 'string' ? manifestResult.data.generatedAt : null;
+  if (!generatedAt) {
+    return { output: null };
+  }
+
+  return {
+    output: {
+      marketing: marketing.text,
+      feature: feature.text,
+      architecture: architecture.text,
+      generatedAt,
+    },
+  };
+}
+
+function registerProjectPagesIpc() {
+  const { schemas: s, validated: v } = require('./ipcSchemas.cjs');
+  ipcMain.handle('project-pages:get', v(s.projectPagesCwd, get));
+}
+
+module.exports = {
+  registerProjectPagesIpc,
+  get,
+};