claude-code-session-manager 0.92.1 → 0.94.0

package/src/main/lib/childWithLog.cjs

@@ -21,7 +21,7 @@
  *       shouldFire(ctx) returns true, then calls action(ctx).
  *     - action() may call ctx.addTimer(t) to register secondary timers
  *       (e.g. SIGTERM → SIGKILL cascades) so they are also cleared on exit.
- *   Calls onExit() synchronously inside the child 'exit'/'error' handler,
+ *   Calls onExit() inside the child 'exit'/'error' handler,
  *   before calling closeFd(). Caller may call ctx.safeLog() inside onExit.
  *
  * WatchdogContext:
@@ -51,7 +51,10 @@
  */
 
 const fs = require('node:fs');
-const { spawn, execFileSync } = require('node:child_process');
+const { spawn, execFile } = require('node:child_process');
+
+// Injectable for tests (enumeration-failure coverage).
+const deps = { execFile };
 
 // Grace period between the post-exit SIGTERM sweep and the follow-up SIGKILL
 // sweep of a detached child's process group. See sweepChildProcessGroup below.
@@ -144,44 +147,58 @@ function openLog(logPath) {
 // Read-only — never throws, never blocks the caller's exit path. Used to
 // report what sweepChildProcessGroup is about to kill, since the kill itself
 // is silent (ESRCH on the normal empty-group case).
+// Async: resolves to the survivors list, rejects on ps failure/timeout. O(P) in
+// the process table, off the main event loop.
 function enumerateProcessGroupSurvivors(pgid) {
-  if (process.platform !== 'linux') return [];
-  if (!pgid || pgid <= 1) return [];
-  try {
-    const out = execFileSync('ps', ['-eo', 'pid,pgrp,pcpu,etimes,comm'], { encoding: 'utf8', timeout: 2000 });
-    const survivors = [];
-    for (const line of out.split('\n').slice(1)) {
-      const m = line.trim().match(/^(\d+)\s+(\d+)\s+([\d.]+)\s+(\d+)\s+(.+)$/);
-      if (!m) continue;
-      const [, pidStr, pgrpStr, pcpuStr, etimesStr, comm] = m;
-      if (Number(pgrpStr) !== pgid) continue;
-      survivors.push({ pid: Number(pidStr), pcpu: Number(pcpuStr), etimes: Number(etimesStr), comm });
-    }
-    return survivors;
-  } catch {
-    return [];
-  }
+  if (process.platform !== 'linux') return Promise.resolve([]);
+  if (!pgid || pgid <= 1) return Promise.resolve([]);
+  return new Promise((resolve, reject) => {
+    try {
+      deps.execFile('ps', ['-eo', 'pid,pgrp,pcpu,etimes,comm'], { encoding: 'utf8', timeout: 2000 }, (err, out) => {
+        if (err) { reject(err); return; }
+        const survivors = [];
+        for (const line of String(out).split('\n').slice(1)) {
+          const m = line.trim().match(/^(\d+)\s+(\d+)\s+([\d.]+)\s+(\d+)\s+(.+)$/);
+          if (!m) continue;
+          const [, pidStr, pgrpStr, pcpuStr, etimesStr, comm] = m;
+          if (Number(pgrpStr) !== pgid) continue;
+          survivors.push({ pid: Number(pidStr), pcpu: Number(pcpuStr), etimes: Number(etimesStr), comm });
+        }
+        resolve(survivors);
+      });
+    } catch (e) { reject(e); }
+  });
 }
 
-// Returns the leaked descendants found (see enumerateProcessGroupSurvivors),
-// having enumerated them BEFORE issuing SIGTERM so the report reflects what
-// was actually swept, not what happened to still be running afterward.
-function sweepChildProcessGroup(child, detached) {
-  if (!detached) return [];
-  if (!child || !child.pid || child.pid <= 1) return [];
+// Returns null when there is nothing to enumerate/sweep (non-detached, missing or
+// invalid pid, our own group) so the caller can finish synchronously. Otherwise
+// returns a promise for the leaked descendants: enumeration runs FIRST so the
+// report reflects what the sweep is about to reap, and SIGTERM (+ the delayed
+// SIGKILL) is issued only once it has SETTLED — resolved or rejected. The 2 s ps
+// timeout bounds that wait. The promise never rejects: a failed enumeration
+// resolves [] after a safeLog line, and the group is still killed.
+function sweepChildProcessGroup(child, detached, safeLog) {
+  if (!detached) return null;
+  if (!child || !child.pid || child.pid <= 1) return null;
   // Defensive: never target the Session Manager process's own group.
-  if (child.pid === process.pid) return [];
-
-  const leaked = enumerateProcessGroupSurvivors(child.pid).filter((p) => p.pid !== child.pid);
+  if (child.pid === process.pid) return null;
 
-  try { process.kill(-child.pid, 'SIGTERM'); } catch { /* ESRCH: empty group, the normal case */ }
-
-  const t = setTimeout(() => {
-    try { process.kill(-child.pid, 'SIGKILL'); } catch { /* ESRCH: empty group, the normal case */ }
-  }, POST_EXIT_GROUP_SWEEP_GRACE_MS);
-  if (t.unref) t.unref();
+  const pid = child.pid;
+  const kill = () => {
+    try { process.kill(-pid, 'SIGTERM'); } catch { /* ESRCH: empty group, the normal case */ }
+    const t = setTimeout(() => {
+      try { process.kill(-pid, 'SIGKILL'); } catch { /* ESRCH: empty group, the normal case */ }
+    }, POST_EXIT_GROUP_SWEEP_GRACE_MS);
+    if (t.unref) t.unref();
+  };
 
-  return leaked;
+  return enumerateProcessGroupSurvivors(pid)
+    .then((all) => all.filter((p) => p.pid !== pid))
+    .catch((e) => {
+      safeLog(`[childWithLog] process-group enumeration failed; leak report omitted: ${e && e.message}\n`);
+      return [];
+    })
+    .then((leaked) => { kill(); return leaked; });
 }
 
 function withChildAndLog({ fd, logPath, safeLog, closeFd, spawn: spawnSpec, watchdogs = [], onExit }) {
@@ -220,9 +237,15 @@ function withChildAndLog({ fd, logPath, safeLog, closeFd, spawn: spawnSpec, watc
   // O(|watchdogs|) setup, O(1) per poll tick.
   const clearFns = watchdogs.map((wd) => {
     const t = setInterval(() => {
-      if (wd.shouldFire(ctx)) {
-        clearInterval(t);
-        wd.action(ctx);
+      try {
+        if (wd.shouldFire(ctx)) {
+          clearInterval(t);
+          wd.action(ctx);
+        }
+      } catch (e) {
+        // A throwing shouldFire is retried next tick; a throwing action has
+        // already cleared its interval. Never let it escape the timer.
+        safeLog(`[childWithLog] watchdog "${wd.label}" threw: ${e && e.message}\n`);
       }
     }, wd.intervalMs);
     if (t.unref) t.unref();
@@ -238,19 +261,37 @@ function withChildAndLog({ fd, logPath, safeLog, closeFd, spawn: spawnSpec, watc
   // calls onExit (caller may still safeLog inside), then closes the fd.
   const handleDone = (exitCode, signal, error, spawnFailed) => {
     clearAllTimers();
-    const leakedDescendants = sweepChildProcessGroup(ctx.child, !!spawnSpec.options?.detached);
-    if (onExit) {
-      onExit({
-        exitCode,
-        signal: signal ?? null,
-        killedByWatchdog: ctx.killedByWatchdog,
-        error,
-        spawnFailed: spawnFailed ?? false,
-        leakedDescendants,
-        safeLog,
-      });
-    }
-    closeFd();
+    const finish = (leakedDescendants) => {
+      try {
+        if (onExit) {
+          onExit({
+            exitCode,
+            signal: signal ?? null,
+            killedByWatchdog: ctx.killedByWatchdog,
+            error,
+            spawnFailed: spawnFailed ?? false,
+            leakedDescendants,
+            safeLog,
+          });
+        }
+      } catch (e) {
+        // Log while the fd is still open (closeFd below makes safeLog a no-op),
+        // then rethrow: sync callers see the throw as before PRD 1353; the
+        // deferred path contains it below.
+        const stack = e && e.stack ? String(e.stack).split('\n').slice(0, 3).join('\n') : '';
+        safeLog(`[childWithLog] onExit threw: ${e && e.message}${stack ? `\n${stack}` : ''}\n`);
+        throw e;
+      } finally {
+        closeFd();
+      }
+    };
+    const pending = sweepChildProcessGroup(ctx.child, !!spawnSpec.options?.detached, safeLog);
+    // Nothing to enumerate: stay synchronous. Otherwise onExit + closeFd wait
+    // (bounded by the 2 s ps timeout) for the leak report; a throwing onExit
+    // must not become an unhandled rejection.
+    if (!pending) { finish([]); return; }
+    // finish() already logged the throw and closed the fd; just contain it.
+    pending.then(finish).catch(() => {});
   };
 
   // Attempt synchronous spawn. On failure, call handleDone immediately so the
@@ -282,4 +323,4 @@ function withChildAndLog({ fd, logPath, safeLog, closeFd, spawn: spawnSpec, watc
   return { child, cancel };
 }
 
-module.exports = { openLog, withChildAndLog, POST_EXIT_GROUP_SWEEP_GRACE_MS };
+module.exports = { openLog, withChildAndLog, POST_EXIT_GROUP_SWEEP_GRACE_MS, _deps: deps };

package/src/main/lib/delegationReadiness.cjs

@@ -662,6 +662,8 @@ async function checkDelegationReadiness({ cwd, homeDir = os.homedir() }) {
  * failure must not prevent the guard install it's reporting on.
  */
 function logAutoInstallEvent({ cwd, guard, action, error }) {
+  // A no-op outcome is not an event worth an error-log row (24 rows/3 days of boot noise).
+  if (action === 'already-installed') return;
   try {
     const opsErrorLog = require('./opsErrorLog.cjs');
     opsErrorLog.appendError({
@@ -743,7 +745,7 @@ async function ensureGuardsInstalled(cwd, { homeDir = os.homedir() } = {}) {
     return { ok: false, root: null, guards: {}, error: err?.message ?? String(err) };
   }
 
-  const cacheKey = `${root}${homeDir}`;
+  const cacheKey = `${root}\0${homeDir}`;
   const cached = guardsInstalledCache.get(cacheKey);
   if (cached) return cached;
 

package/src/main/lib/effectiveModelInfo.cjs

@@ -13,11 +13,11 @@
  * "we don't know; the CLI resolves this alias at launch." The two must
  * never collapse into one optimistic string.
  *
- * Effort-level resolution is deliberately NOT here — it already exists,
- * unused, in the renderer's `useEffectiveSettings.ts` (a scope-chain reader
- * with a file watcher). This module supplies only the half that genuinely
- * needs main-process filesystem access: persona lookup (overlay-aware) and
- * concrete-model evidence (scheduler run logs, session transcripts).
+ * PERSONA effort IS here now (agentEffortResolve.cjs): it needs the same
+ * main-process, overlay-aware persona read as the persona model, and a launch
+ * now actually passes it as `--effort`. The settings.json effortLevel
+ * scope-chain read stays in the renderer (`useEffectiveSettings.ts`) as the
+ * FALLBACK when the persona sets no level — this module never reads settings.
  *
  * Never throws — every lookup failure degrades a field to null, same
  * contract as agentModelResolve.cjs's resolveEpicModel.
@@ -29,12 +29,17 @@ const os = require('node:os');
 const { splitFrontmatter } = require('./prdFrontmatter.cjs');
 const { resolveEpicTranscriptPath } = require('./epicTranscriptPath.cjs');
 
-// Mirrors rawSessionModel.ts's RAW_MODELS — duplicated rather than imported
+// Deliberately stays a FIXED alias set (reviewed against the catalog-driven raw picker): it answers
+// "alias vs concrete id", not "which options to offer", so live catalog ids must not enter it.
+// Mirrors rawSessionModel.ts's RAW_MODELS fallback — duplicated rather than imported
 // because that file is a renderer ES module and this is a main-process CJS
 // module (CLAUDE.md: "No CommonJS in renderer, no ES modules in main").
 // Anything NOT in this set is treated as an already-concrete pinned model id
 // (e.g. 'claude-opus-5'), never as an alias needing evidence.
-const KNOWN_MODEL_ALIASES = new Set(['opus', 'sonnet', 'haiku', 'fable']);
+// Also the non-family CLI aliases the Agent Library picker can now write
+// (best / opusplan / default); a trailing `[1m]`-style suffix is stripped
+// before the lookup (see isConcreteModelId), so 'opus[1m]' is an alias too.
+const KNOWN_MODEL_ALIASES = new Set(['opus', 'sonnet', 'haiku', 'fable', 'best', 'opusplan', 'default']);
 
 // Run-log evidence (scheduler.cjs's executeJob, ~line 4473) is written
 // essentially at dispatch time, before any of the run's own stdout streams
@@ -54,10 +59,14 @@ function runsDir(homeDir) {
 }
 
 function isConcreteModelId(modelAlias) {
-  return Boolean(modelAlias) && !KNOWN_MODEL_ALIASES.has(modelAlias);
+  if (!modelAlias) return false;
+  // 'opus[1m]' is an alias with a context suffix; 'claude-opus-4-7[1m]' keeps its id.
+  return !KNOWN_MODEL_ALIASES.has(modelAlias.replace(/\[[^\]]*\]$/, ''));
 }
 
 /**
+ * ENV-VAR question only (`effortEnvReachable`): persona effort now travels on argv as `--effort`,
+ * which cleanChildEnv cannot strip — so this says nothing about whether effort reaches the CLI.
  * True when this app's spawn path (cleanEnv.cjs's cleanChildEnv) would strip
  * an effort env var before a child ever saw it — i.e. whether the settings
  * schema's env-var effort configuration path is actually reachable for an
@@ -65,7 +74,7 @@ function isConcreteModelId(modelAlias) {
  * hardcoding a boolean, so this self-corrects if that deletion list ever
  * changes instead of silently drifting stale.
  */
-function computeEffortReachable(deps) {
+function computeEffortEnvReachable(deps) {
   try {
     const { cleanChildEnv } = deps.cleanEnv || require('./cleanEnv.cjs');
     const probe = cleanChildEnv({ CLAUDE_EFFORT: 'high', CLAUDE_CODE_EFFORT_LEVEL: 'high' });
@@ -106,15 +115,18 @@ async function resolvePersonaModelAlias(cwd, agentType, deps) {
   } catch {
     persona = null;
   }
-  if (!persona) return { modelAlias: null, modelSource: 'fallback' };
+  if (!persona) return { modelAlias: null, modelSource: 'fallback', provenance: {} };
 
-  const { fm } = splitFrontmatter(persona.text);
-  const fromOverlay = isProjectOverlayPersonaPath(cwd, agentType, persona.path, deps);
+  // getPersonaBody returns the MERGED persona with per-field provenance; a bare
+  // `{ path, text }` (older injected reader) falls back to whole-file provenance.
+  const fm = persona.fm || splitFrontmatter(persona.text).fm;
+  const provenance = persona.provenance
+    || Object.fromEntries(Object.keys(fm).map((k) => [k, isProjectOverlayPersonaPath(cwd, agentType, persona.path, deps) ? 'overlay' : 'global']));
 
   if (fm.model && fm.model !== 'inherit') {
-    return { modelAlias: fm.model, modelSource: fromOverlay ? 'persona-overlay' : 'persona' };
+    return { modelAlias: fm.model, modelSource: provenance.model === 'overlay' ? 'persona-overlay' : 'persona', provenance };
   }
-  return { modelAlias: null, modelSource: 'inherit' };
+  return { modelAlias: null, modelSource: 'inherit', provenance };
 }
 
 /** Best-effort read of `<cwd>/session-manager-operations/scheduler/state/queue.json`'s hot jobs[]. */
@@ -268,21 +280,25 @@ function findLatestTranscriptModel(cwd, agentType, deps) {
 
 /**
  * resolveEffectiveModelInfo({ cwd, agentType, deps? }) →
- *   { agentType, modelAlias, modelSource, resolvedModelId, resolvedFrom, effortReachable }
+ *   { agentType, modelAlias, modelSource, resolvedModelId, resolvedFrom, effortEnvReachable,
+ *     personaEffort, personaEffortSource }
  *
  * Never throws. `cwd` is normalized through the same worktree/ops-internal
  * -aware resolver every ops-root reader goes through, so a job worktree cwd
  * resolves to its main project tree before anything is looked up.
  */
 async function resolveEffectiveModelInfo({ cwd, agentType, deps = {} } = {}) {
-  const effortReachable = computeEffortReachable(deps);
+  const effortEnvReachable = computeEffortEnvReachable(deps);
   const miss = {
     agentType: agentType || null,
     modelAlias: null,
     modelSource: 'fallback',
+    personaProvenance: {},
     resolvedModelId: null,
     resolvedFrom: null,
-    effortReachable,
+    effortEnvReachable,
+    personaEffort: null,
+    personaEffortSource: null,
   };
   if (!cwd || !agentType) return miss;
 
@@ -291,8 +307,10 @@ async function resolveEffectiveModelInfo({ cwd, agentType, deps = {} } = {}) {
     const normalizedCwd = projectRootOf(path.resolve(cwd));
     if (!normalizedCwd) return miss;
 
-    const { modelAlias, modelSource } = await resolvePersonaModelAlias(normalizedCwd, agentType, deps);
-    const result = { agentType, modelAlias, modelSource, resolvedModelId: null, resolvedFrom: null, effortReachable };
+    const { modelAlias, modelSource, provenance: personaProvenance } = await resolvePersonaModelAlias(normalizedCwd, agentType, deps);
+    const { effort: personaEffort, source: personaEffortSource } = (deps.agentEffortResolve || require('./agentEffortResolve.cjs'))
+      .resolveEpicEffort({ cwd: normalizedCwd, agentType, deps });
+    const result = { agentType, modelAlias, modelSource, personaProvenance, resolvedModelId: null, resolvedFrom: null, effortEnvReachable, personaEffort, personaEffortSource };
 
     if (isConcreteModelId(modelAlias)) {
       // Already a concrete pinned id — echo it back, fabricate no evidence.
@@ -327,6 +345,6 @@ async function resolveEffectiveModelInfo({ cwd, agentType, deps = {} } = {}) {
 module.exports = {
   resolveEffectiveModelInfo,
   isConcreteModelId,
-  computeEffortReachable,
+  computeEffortEnvReachable,
   KNOWN_MODEL_ALIASES,
 };

package/src/main/lib/epicMint.cjs

@@ -208,7 +208,7 @@ function withPathLock(lockPath, task) {
 }
 
 /**
- * ensureEpic(cwd, { epicId?, goalText, tag?, status?, openingPrompt?, source?, agentType?, mintAuthority? }) → Promise<{ epicId, prdDir, created }>
+ * ensureEpic(cwd, { epicId?, goalText, tag?, status?, openingPrompt?, source?, agentType?, model?, effort?, mintAuthority? }) → Promise<{ epicId, prdDir, created }>
  *
  * Two behaviors, and only two:
  *  - JOIN (the default, for every automated caller): `epicId` names an Epic
@@ -227,7 +227,7 @@ function withPathLock(lockPath, task) {
  * The Epic's id doubles as its directory name under scheduler/epics/, so the
  * PromptSession ↔ on-disk Epic mapping is 1:1 with no lookup table.
  */
-function ensureEpic(cwd, { goalText, tag, epicId: explicitEpicId, status = 'proposed', openingPrompt = null, sections = null, source = null, agentType = null, mintAuthority = null } = {}, deps = {}) {
+function ensureEpic(cwd, { goalText, tag, epicId: explicitEpicId, status = 'proposed', openingPrompt = null, sections = null, source = null, agentType = null, model = null, effort = null, mintAuthority = null } = {}, deps = {}) {
   if (!cwd || typeof cwd !== 'string') throw new Error('ensureEpic: cwd is required');
   // A relative cwd (e.g. a caller passing '.') would otherwise get stored
   // verbatim on the minted Epic's `cwd` field — the renderer's EpicsWorkspace
@@ -337,6 +337,9 @@ function ensureEpic(cwd, { goalText, tag, epicId: explicitEpicId, status = 'prop
       // ensureEpic IPC path (state/promptSessions.ts). Never affects which
       // claude CLI spawns.
       ...(agentType ? { agentType } : {}),
+      // Per-Epic runtime overrides — written only when set, so an Epic minted without one keeps its on-disk shape.
+      ...(typeof model === 'string' && model ? { model } : {}),
+      ...(typeof effort === 'string' && effort ? { effort } : {}),
     };
 
     // Validate the constructed record against the canonical PromptSession

package/src/main/lib/epicSpawnPlan.cjs

@@ -28,6 +28,7 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const { encodeCwd } = require('./encodeCwd.cjs');
+const { projectRootOf } = require('./activeSessions.cjs');
 const { readActiveIndex } = require('./epicMint.cjs');
 const { resolveEpicSpawnCwd } = require('./epicSpawnCwd.cjs');
 const { resolveEpicTranscriptPath } = require('./epicTranscriptPath.cjs');
@@ -71,7 +72,7 @@ function findEpic(cwd, claudeSessionId, deps) {
 /**
  * @param {{ cwd: string, claudeSessionId: string, fallbackResume?: boolean, deps?: object }} opts
  * @returns {{ ok: true, execCwd: string, useResume: boolean, transcriptPath: string|null }
- *   | { ok: false, code: 'epic_closed'|'session_unreachable', message: string }}
+ *   | { ok: false, code: 'epic_closed'|'session_unreachable'|'spawn_cwd_missing', message: string }}
  */
 function planEpicSpawn({ cwd, claudeSessionId, fallbackResume = false, deps = {} } = {}) {
   const statSync = deps.statSync || fs.statSync;
@@ -107,14 +108,24 @@ function planEpicSpawn({ cwd, claudeSessionId, fallbackResume = false, deps = {}
       const home = path.join(projectsDir, encodeCwd(dir));
       return resolved.existingPaths.find((p) => path.dirname(p) === home) || null;
     };
-    let hit = findReachable(execCwd);
-    if (!hit && execCwd !== cwd) {
-      // The transcript may already live under the project encoding; spawning there writes back to
-      // the directory it occupies, so nothing forks.
-      hit = findReachable(cwd);
-      if (hit) execCwd = cwd;
+    // The transcript may already live under the project encoding; spawning there writes back to
+    // the directory it occupies, so nothing forks. `projectRootOf(cwd)` only contributes for a LIVE
+    // worktree caller cwd (it returns a vanished worktree path unchanged, so it adds nothing there);
+    // `epic.cwd`/`worktree.baseCwd` are not probed — the Epic is only found via the caller cwd, which
+    // is already a candidate, so they could never change an outcome.
+    let projectRoot = null;
+    try { projectRoot = projectRootOf(cwd); } catch { /* unresolvable → skip */ }
+    const candidates = [...new Set([execCwd, cwd, projectRoot].filter((d) => typeof d === 'string' && d))];
+    let reachableDir = null;
+    for (const dir of candidates) {
+      if (findReachable(dir)) { reachableDir = dir; break; }
     }
-    if (!hit) {
+    if (reachableDir) {
+      execCwd = reachableDir;
+      unreachable.delete(claudeSessionId);
+    } else {
+      // Name a directory that would actually work: an existing candidate is only worth naming if
+      // its encoding owns a transcript, which none did — so name the recorded worktree checkout.
       const missing = brokenDir || execCwd;
       const wt = epic?.worktree;
       const recovery = wt?.status === 'merged'
@@ -128,6 +139,14 @@ function planEpicSpawn({ cwd, claudeSessionId, fallbackResume = false, deps = {}
     }
   }
 
+  if (!isDir(execCwd, statSync)) {
+    return {
+      ok: false,
+      code: 'spawn_cwd_missing',
+      message: `Cannot spawn session ${claudeSessionId}: directory ${execCwd} does not exist. Pass the Epic's project cwd (the project root, not a removed worktree path) as the caller cwd.`,
+    };
+  }
+
   return { ok: true, execCwd, useResume, transcriptPath: resolved?.path ?? null };
 }
 

package/src/main/lib/epicTranscriptPath.cjs

@@ -140,12 +140,16 @@ function resolveEpicTranscriptPath({ cwd, claudeSessionId, deps = {} } = {}) {
   const file = (dir) => path.join(projectsDir, encodeCwd(dir), `${claudeSessionId}.jsonl`);
 
   const worktreeDirs = [];
+  // Project cwd recorded on the Epic — the caller's `cwd` may itself be the vanished worktree
+  // path, whose encoding is not where a merged/swept Epic's transcript lives.
+  const recordedCwds = [];
   try {
     const sessions = cachedSessions(cwd, deps, statSync);
     let inIndex = false;
     for (const s of Object.values(sessions)) {
       if (s && s.claudeSessionId === claudeSessionId) {
         inIndex = true;
+        if (typeof s.cwd === 'string' && s.cwd) recordedCwds.push(s.cwd);
         if (typeof s.worktree?.dir === 'string' && s.worktree.dir) worktreeDirs.push(s.worktree.dir);
       }
     }
@@ -161,7 +165,7 @@ function resolveEpicTranscriptPath({ cwd, claudeSessionId, deps = {} } = {}) {
     spawnCwd = cwd;
   }
 
-  const candidates = [...new Set([file(spawnCwd), ...worktreeDirs.map(file), file(cwd)])];
+  const candidates = [...new Set([file(spawnCwd), ...worktreeDirs.map(file), file(cwd), ...recordedCwds.map(file)])];
 
   const existing = [];
   for (const p of candidates) {

package/src/main/lib/epicWorktreeMerge.cjs

@@ -9,10 +9,10 @@
  * This is the ONLY point where that per-Epic isolation resolves back into
  * the shared tree — never mid-session (see gitWorktree.cjs's own header
  * comment for the ff-only -> merge-commit -> abort-and-flag algorithm this
- * reuses verbatim). Callers reach it two ways: an explicit "merge to main"
- * action (renderer state's `mergeEpicToMain`), and `markCompleted`'s
- * merge-before-archive checkpoint — both funnel through this one handler so
- * the integration strategy is never duplicated.
+ * reuses verbatim). The single caller is `markCompleted`'s merge-before-archive
+ * checkpoint (via `attemptMergeToMainInternal` in
+ * `src/renderer/state/promptSessions.ts`); there is no explicit "merge to
+ * main" action.
  *
  * On success the worktree checkout is torn down (cleanupEpicWorktree) since
  * its content now safely lives on the main tree. On a real conflict, the
@@ -20,8 +20,9 @@
  * — so a human can still open a Terminal into `worktree.dir` (the spawn
  * resolution in epicSpawnCwd.cjs is status-aware: `needs_merge_resolution`
  * with an existing dir still lands there, while `merged`/`disabled` skip the
- * re-attach and fall back to the project cwd) and resolve it manually before
- * re-running this same action.
+ * re-attach and fall back to the project cwd) and resolve it manually — the
+ * branch and worktree dir are deliberately left intact so the human can merge
+ * them from the command line.
  */
 
 const { integrateEpicBranch, cleanupEpicWorktree } = require('./gitWorktree.cjs');

package/src/main/lib/headTailBuffer.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+// Bounded text accumulator: keeps the first HEAD chars (for error-detail
+// previews) plus a ring of the last `tailMax` chars (for regex matching).
+// Same trim-oldest idiom as pty.cjs `#appendReplay`. Memory is O(head + tailMax)
+// regardless of input size; append is O(tailMax) per chunk.
+
+const HEAD_PREVIEW_CHARS = 300;
+// One extra char lets preview() tell "exactly 300" from "longer than 300".
+const HEAD_KEEP = HEAD_PREVIEW_CHARS + 1;
+
+function createHeadTailBuffer(tailMax) {
+  let head = '';
+  let tail = '';
+  let truncated = false;
+  return {
+    append(str) {
+      if (!str) return;
+      if (head.length < HEAD_KEEP) {
+        // Skip leading whitespace so the head equals `text.trim().slice(0, …)`.
+        const s = head.length === 0 ? str.replace(/^\s+/, '') : str;
+        head += s.slice(0, HEAD_KEEP - head.length);
+      }
+      tail += str;
+      if (tail.length > tailMax) {
+        tail = tail.slice(tail.length - tailMax);
+        truncated = true;
+      }
+    },
+    /** Text to run regexes over: the tail, plus the head once the middle was dropped. */
+    matchText() {
+      return truncated ? `${head}\n${tail}` : tail;
+    },
+    /** Equivalent to `fullText.trim().slice(0, 300)`. */
+    preview() {
+      return head.length > HEAD_PREVIEW_CHARS ? head.slice(0, HEAD_PREVIEW_CHARS) : head.trimEnd();
+    },
+    /** Retained char count (head + tail). */
+    get size() { return head.length + tail.length; },
+  };
+}
+
+module.exports = { createHeadTailBuffer, HEAD_PREVIEW_CHARS };

package/src/main/lib/intradayRefresh.cjs

@@ -0,0 +1,33 @@
+/**
+ * intradayRefresh.cjs — lock-guarded runner for the in-app intraday rollup tick.
+ *
+ * Extracted from index.cjs so the failure paths are unit-testable. Guarantees:
+ * a lock-acquire throw is logged (never escapes the interval callback), and a
+ * synchronous OR asynchronous throw from `refresh` always releases the lock.
+ */
+'use strict';
+
+function createIntradayRefresh({ tryAcquireLock, releaseLock, lockPath, refresh, logs }) {
+  const logError = (message, e) =>
+    logs.writeLine({ scope: 'history-rollup', level: 'error', message, meta: { error: e?.message } });
+
+  return function runIntradayRefresh() {
+    let acquired;
+    try {
+      acquired = tryAcquireLock(lockPath);
+    } catch (e) {
+      logError('intraday lock acquire failed', e);
+      return;
+    }
+    if (!acquired) return;
+    // Promise.resolve().then would defer the call; use an async IIFE so a sync
+    // throw from refresh() lands in the same catch as a rejection.
+    (async () => { await refresh(); })()
+      .catch((e) => logError('refreshIntradayToday failed', e))
+      .finally(() => {
+        try { releaseLock(lockPath); } catch (e) { logError('intraday lock release failed', e); }
+      });
+  };
+}
+
+module.exports = { createIntradayRefresh };

package/src/main/lib/lruCache.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+/**
+ * Bounded LRU cache backed by an insertion-order Map: delete+re-insert on
+ * access = O(1) get/set/evict. Single implementation shared by
+ * historyAggregator.cjs and transcripts.cjs.
+ */
+class LRUCache {
+  constructor(max) {
+    this._max = max;
+    this._m = new Map();
+  }
+  get size() {
+    return this._m.size;
+  }
+  has(k) {
+    return this._m.has(k);
+  }
+  delete(k) {
+    return this._m.delete(k);
+  }
+  clear() {
+    this._m.clear();
+  }
+  get(k) {
+    if (!this._m.has(k)) return undefined;
+    const v = this._m.get(k);
+    this._m.delete(k);
+    this._m.set(k, v);
+    return v;
+  }
+  set(k, v) {
+    this._m.delete(k);
+    this._m.set(k, v);
+    if (this._m.size > this._max) this._m.delete(this._m.keys().next().value);
+  }
+}
+
+module.exports = { LRUCache };