claude-code-session-manager 0.50.0 → 0.52.0

package/src/main/scheduler.cjs

@@ -85,7 +85,7 @@ const queueOps = require('./queueOps.cjs');
 // Plain Node module, no Electron dependency; queuePath/prdsDir defaults already
 // match ROOT/QUEUE_PATH below since both resolve the same ~/.claude/session-manager
 // home-dir layout.
-const { resolvePrdsDirs, resolvePrdWriteDir, listEpicPrdDirs, listArchivedPrdDirs } = require('./lib/prdLocations.cjs');
+const { resolvePrdsDirs, resolveArchivedPrdsDirs, resolvePrdWriteDir, listEpicPrdDirs, listArchivedPrdDirs } = require('./lib/prdLocations.cjs');
 const { ensureEpic, appendPrdCreatedEvent, readActiveIndex } = require('./lib/epicMint.cjs');
 
 // ---------- origin session resolution (PRD 832) ----------
@@ -486,6 +486,35 @@ function candidatePrdsDirs() {
   return [PRDS_DIR, ...resolvePrdsDirs()];
 }
 
+/**
+ * Every `prds-archived/` dir across every project (the sibling-of-source
+ * layout archiveCompletedPrd writes into — see that function's comment).
+ * Used only by list-prds so the PRDs/Runs tabs can show an Epic's REAL
+ * historical PRD count, not just its currently-pending one. Deliberately
+ * excludes the flat legacy PRDS_ARCHIVE_DIR (manual `schedule:archive-prd`
+ * timestamped-subdir layout) — that path is for a different, unused-by-
+ * any-renderer manual archive flow, not Epic-scoped completion archiving.
+ */
+function candidateArchivedPrdsDirs() {
+  return resolveArchivedPrdsDirs();
+}
+
+/**
+ * Resolve an archived PRD's real terminal outcome for `schedule:list-prds`:
+ * its live queue.json row (if the job hasn't aged out yet), else its
+ * history.jsonl row, else 'completed' — archiveCompletedPrd only ever
+ * archives a job whose effective status is 'completed' (a 'failed' job's
+ * PRD source stays in the live prds/ dir), so 'completed' is a safe
+ * default, not a guess; the live/history lookups are defensive in case
+ * that archiving invariant ever changes. Exported as a pure function (no
+ * IPC/fs) so this fallback chain is unit-testable without an Electron
+ * harness.
+ */
+function resolveArchivedPrdStatus(slug, liveStatusBySlug, histBySlug) {
+  const resolved = liveStatusBySlug.get(slug) ?? histBySlug.get(slug)?.status ?? 'completed';
+  return resolved === 'failed' ? 'failed' : 'completed';
+}
+
 /** The PRD-source directory for a given job cwd (falls back to DEFAULT_PROJECT_CWD). */
 function prdDirForCwd(cwd) {
   return resolvePrdWriteDir(cwd || DEFAULT_PROJECT_CWD);
@@ -2458,6 +2487,16 @@ async function spawnInvestigation(failedJob, runDir) {
     return { deferred: false };
   }
 
+  // Mark the job 'investigating' so the Queue UI shows an active status for
+  // the whole probe duration — previously this left the job's persisted
+  // status frozen at 'failed'/'needs_review' the entire time, which read as
+  // "nothing is happening" even though an Opus process was actively running.
+  await mutate((s) => {
+    const j = s.jobs.find((x) => x.slug === failedJob.slug);
+    if (j) j.status = 'investigating';
+  });
+  await broadcast({ flush: true });
+
   const claudeBin = resolveClaudeBin();
   const childEnv = cleanChildEnv({ PATH: pathWithUserBins() }); // Homebrew/user bins for macOS
 
@@ -2495,6 +2534,14 @@ async function spawnInvestigation(failedJob, runDir) {
     watchdogs: [deadmanWatchdog],
     onExit({ exitCode, error, spawnFailed, safeLog: sl }) {
       releaseSlot();
+      // Restore the pre-investigation status now that the probe has exited —
+      // 'investigating' must never be the job's resting state.
+      mutate((s) => {
+        const j = s.jobs.find((x) => x.slug === failedJob.slug);
+        if (j && j.status === 'investigating') j.status = failedJob.status || 'failed';
+      })
+        .then(() => broadcast({ flush: true }))
+        .catch(() => {});
       if (error) {
         const errMsg = spawnFailed
           ? `investigation spawn failed: ${error?.message ?? String(error)}`
@@ -2541,8 +2588,15 @@ async function spawnInvestigation(failedJob, runDir) {
   return { deferred: false };
   } catch (e) {
     // A synchronous throw before onExit is wired (e.g. resolveClaudeBin not found,
-    // openLog failure, spawn setup) must not strand the reserved slot.
+    // openLog failure, spawn setup) must not strand the reserved slot, and must
+    // not strand the job on the transient 'investigating' status either.
     releaseSlot();
+    mutate((s) => {
+      const j = s.jobs.find((x) => x.slug === failedJob.slug);
+      if (j && j.status === 'investigating') j.status = failedJob.status || 'failed';
+    })
+      .then(() => broadcast({ flush: true }))
+      .catch(() => {});
     throw e;
   }
 }
@@ -3167,7 +3221,11 @@ async function maybeLaunchWhenAvailable(state) {
  */
 async function reapDeadRunningJobs() {
   try {
-    if (runningSet.size === 0) return; // fast path: no in-flight jobs
+    // Do NOT gate on runningSet: spawnJob()'s finally block unconditionally
+    // deletes a job's slug from runningSet even when the preceding completion
+    // mutate() threw and was swallowed, leaving queue.json stuck at
+    // status:"running" with no slug left in runningSet to trigger reconciliation.
+    // queue.json is the source of truth for which jobs are actually running.
     const state = await readQueue();
     const dead = [];
     for (const j of state.jobs) {
@@ -3925,7 +3983,9 @@ function registerScheduleHandlers() {
   ipcMain.handle('schedule:list-prds', async () => {
     ensureDirs();
     const out = [];
-    for (const dir of candidatePrdsDirs()) {
+    const seenSlugs = new Set();
+
+    async function readDirInto(dir, { archived }) {
       let entries;
       try {
         entries = await fsp.readdir(dir);
@@ -3933,15 +3993,21 @@ function registerScheduleHandlers() {
         if (e?.code !== 'ENOENT') {
           logs.writeLine({ level: 'warn', scope: 'scheduler', message: 'list-prds: readdir failed', meta: { dir, error: e?.message } });
         }
-        continue;
+        return;
       }
       for (const name of entries) {
         if (!name.endsWith('.md') || name.startsWith('.')) continue;
         const filePath = path.join(dir, name);
         try {
           const parsed = await parsePrd(filePath);
+          // A slug can't be both live and archived at once, but a duplicate
+          // slug found in two archive dirs (shouldn't happen — archiving is
+          // a single rename — but is cheap to guard) is skipped rather than
+          // double-counted.
+          if (seenSlugs.has(parsed.slug)) continue;
+          seenSlugs.add(parsed.slug);
           const stat = await fsp.stat(filePath);
-          out.push({
+          const entry = {
             slug: parsed.slug,
             parallelGroup: parsed.parallelGroup,
             title: parsed.title,
@@ -3950,12 +4016,46 @@ function registerScheduleHandlers() {
             sourcePromptId: parsed.sourcePromptId,
             epicId: parsed.epicId ?? null,
             mtimeMs: stat.mtimeMs,
-          });
+            archived,
+          };
+          out.push(entry);
         } catch (e) {
           logs.writeLine({ level: 'warn', scope: 'scheduler', message: 'list-prds: skipping unparseable file', meta: { name, error: e?.message } });
         }
       }
     }
+
+    // Live PRDs first, so an archived duplicate (shouldn't exist, but a
+    // stale rename copy is possible) never shadows the still-runnable live
+    // entry.
+    for (const dir of candidatePrdsDirs()) {
+      await readDirInto(dir, { archived: false });
+    }
+
+    const archivedStart = out.length;
+    for (const dir of candidateArchivedPrdsDirs()) {
+      await readDirInto(dir, { archived: true });
+    }
+
+    // Archived PRDs need a status: archiveCompletedPrd (scheduler.cjs) only
+    // ever archives a job whose effective status is 'completed' — a 'failed'
+    // job's PRD source stays in the live prds/ dir (still visible/countable
+    // there already). Still resolve the real job status defensively (live
+    // queue row, falling back to history.jsonl) rather than hard-coding
+    // 'completed', so this stays correct if that archiving invariant ever
+    // changes.
+    if (out.length > archivedStart) {
+      const [state, histBySlug] = await Promise.all([
+        readQueue(),
+        queueHistory.historyTerminalBySlug().catch(() => new Map()),
+      ]);
+      const liveStatusBySlug = new Map(state.jobs.map((j) => [j.slug, j.status]));
+      for (let i = archivedStart; i < out.length; i++) {
+        const entry = out[i];
+        entry.archivedStatus = resolveArchivedPrdStatus(entry.slug, liveStatusBySlug, histBySlug);
+      }
+    }
+
     out.sort((a, b) => a.slug.localeCompare(b.slug, undefined, { numeric: true }));
     return out;
   });
@@ -4380,4 +4480,4 @@ function registerAdminRoutes(adminHttp, remoteObj = remote) {
   });
 }
 
-module.exports = { registerScheduleHandlers, attachWindow, init, ROOT, PRDS_DIR, writeQueue, reconcile, reconcileSourcePromptId, allocateParallelGroup, selectHistoryJobs, parsePorcelain, FINISH_PROTOCOL, remote, pickNextBatch, pickForProject, reapDeadRunningJobs, pollRecoveryClearSource, memoryLimitedBatchSize, availableForJobs, reverifyNeedsReview, isRescanCandidate, isPromotableOriginal, selectAutoFixTargets, isEligibleForImmediateAutoFix, resolveRunId, isUnresolvableNeedsReview, healTargetForFix, buildInvestigationPrompt, committedInWindow, computeCommittedDuringRun, classifySigtermWithCommit, isFixPlanSlug, isFixPlanBeyondDepthCap, MAX_INVESTIGATION_DEPTH, forceTickOutcome, applyPauseCleared, detectNetworkErrorInLog, detectRateLimitInLog, classifyFailureOutcome, commitGuardVerdict, TRANSIENT_RETRY_CAP, buildScheduleStatePayload, partitionBootOrphans, applyOrphanOutcome, BOOT_ORPHAN_KILL_GRACE_MS, registerAdminRoutes, notifyOriginatingTab, isNotifiableTerminalStatus, extractResultTextFromLog, candidatePrdsDirs, prdDirForCwd, prdPathForJob, archivedPrdPathForJob, archivedTwinExists, findPrdDir, runPrdMigration, shouldSkipInvestigationForCleanRun, archiveCompletedPrd, retireCompletedSlugs, SCHEDULER_BOOTED_AT, SCHEDULER_CODE_SHA, resetJobFields };
+module.exports = { registerScheduleHandlers, attachWindow, init, ROOT, PRDS_DIR, writeQueue, reconcile, reconcileSourcePromptId, allocateParallelGroup, selectHistoryJobs, parsePorcelain, FINISH_PROTOCOL, remote, pickNextBatch, pickForProject, reapDeadRunningJobs, pollRecoveryClearSource, memoryLimitedBatchSize, availableForJobs, reverifyNeedsReview, isRescanCandidate, isPromotableOriginal, selectAutoFixTargets, isEligibleForImmediateAutoFix, resolveRunId, isUnresolvableNeedsReview, healTargetForFix, buildInvestigationPrompt, committedInWindow, computeCommittedDuringRun, classifySigtermWithCommit, isFixPlanSlug, isFixPlanBeyondDepthCap, MAX_INVESTIGATION_DEPTH, forceTickOutcome, applyPauseCleared, detectNetworkErrorInLog, detectRateLimitInLog, classifyFailureOutcome, commitGuardVerdict, TRANSIENT_RETRY_CAP, buildScheduleStatePayload, partitionBootOrphans, applyOrphanOutcome, BOOT_ORPHAN_KILL_GRACE_MS, registerAdminRoutes, notifyOriginatingTab, isNotifiableTerminalStatus, extractResultTextFromLog, candidatePrdsDirs, candidateArchivedPrdsDirs, resolveArchivedPrdStatus, prdDirForCwd, prdPathForJob, archivedPrdPathForJob, archivedTwinExists, findPrdDir, runPrdMigration, shouldSkipInvestigationForCleanRun, archiveCompletedPrd, retireCompletedSlugs, SCHEDULER_BOOTED_AT, SCHEDULER_CODE_SHA, resetJobFields };

package/src/preload/api.d.ts

@@ -385,7 +385,7 @@ export interface ScheduleConfig {
   schemaVersion: 1;
 }
 
-export type ScheduleJobStatus = 'pending' | 'running' | 'completed' | 'failed' | 'needs_review';
+export type ScheduleJobStatus = 'pending' | 'running' | 'investigating' | 'completed' | 'failed' | 'needs_review';
 
 export interface ScheduleJobRuntime {
   pid: number;
@@ -490,6 +490,15 @@ export interface PrdListItem {
   sourcePromptId?: string | null;
   /** Owning Epic id, derived from the PRD's directory. See ScheduleJob.epicId. */
   epicId?: string | null;
+  /** True when this PRD's source .md was found in a `prds-archived/` dir
+   *  (its scheduler job already ran to completion) rather than the live
+   *  `prds/` dir. Archived PRDs have no matching queue.json job row (the
+   *  row may have aged out into history.jsonl), so consumers must read
+   *  `archivedStatus` instead of joining on a job to know the outcome. */
+  archived?: boolean;
+  /** Only present when `archived` is true — the resolved terminal outcome
+   *  ('completed' vs 'failed') of the job that produced this archived PRD. */
+  archivedStatus?: 'completed' | 'failed';
 }
 
 export interface SupervisorConfig {
@@ -959,6 +968,19 @@ export type ProjectBriefUpdateResult =
   | { ok: true; brief: ProjectBrief }
   | { ok: false; error: string };
 
+// ────────────────────────────────────────────── Project Pages (PRD 929-932)
+export interface ProjectPagesOutput {
+  marketing: string;
+  feature: string;
+  architecture: string;
+  generatedAt: string;
+}
+
+export interface ProjectPagesGetResult {
+  /** null when no manifest/output files exist yet — the empty-state signal. */
+  output: ProjectPagesOutput | null;
+}
+
 // ────────────────────────────────────────────── Per-subagent memory
 // Stored at ~/.claude/session-manager/agent-memory/<agentId>.json. Keyed by
 // agent name (the .md filename in ~/.claude/agents/), not by workspace cwd.
@@ -1109,7 +1131,7 @@ export interface ChatCreatePrdPayload {
   /** Originating tab id — used at job completion to route a status prompt back into the tab. */
   sourceTabId?: string;
   /** User-selected Feature/Bug tag (PRD 774) carried from the originating PromptTicket. */
-  tag?: 'feature' | 'bug' | 'discussion' | 'build';
+  tag?: 'feature' | 'bug' | 'discussion' | 'build' | 'project-home-builder';
 }
 
 export type ChatCreatePrdResult =
@@ -1520,6 +1542,10 @@ export interface SessionManagerAPI {
     /** Hand-edit brief.json in place — no LLM cost. Edited pinnable blocks are auto-pinned so the next refresh preserves them. */
     update: (cwd: string, patch: ProjectBriefPatch) => Promise<ProjectBriefUpdateResult>;
   };
+  projectPages: {
+    /** Read output/*.html + manifest.json (or `{output: null}` if none exist yet). Never fires an LLM call. */
+    get: (cwd: string) => Promise<ProjectPagesGetResult>;
+  };
   promptSessionTranscript: {
     /** Append one full-text turn to an Epic's durable JSONL transcript. Best-effort — resolves `{ok:false}` rather than throwing on failure. */
     append: (

package/src/preload/index.cjs

@@ -330,6 +330,9 @@ contextBridge.exposeInMainWorld('api', {
     setPin: (cwd, block, pinned) => ipcRenderer.invoke('project-brief:set-pin', { cwd, block, pinned }),
     update: (cwd, patch) => ipcRenderer.invoke('project-brief:update', { cwd, patch }),
   },
+  projectPages: {
+    get: (cwd) => ipcRenderer.invoke('project-pages:get', { cwd }),
+  },
   promptSessionTranscript: {
     append: (cwd, epicId, turn) =>
       ipcRenderer.invoke('promptSessionTranscript:append', { cwd, epicId, ...turn }),