claude-code-session-manager 0.122.1 → 0.123.1

package/src/main/crashDiagnostics.cjs

@@ -27,6 +27,7 @@ const { app, powerSaveBlocker, powerMonitor, crashReporter } = require('electron
 const fs = require('node:fs');
 const path = require('node:path');
 const { reportCrash, classifyUncleanShutdown, reportChildProcessGone } = require('./lib/telemetry/crashTelemetry.cjs');
+const { maybeCaptureMainHeap } = require('./lib/telemetry/mainHeapSnapshot.cjs');
 const { createLoopDelayMonitor, stallVerdict } = require('./lib/util/loopDelay.cjs');
 
 let logs = null;
@@ -124,6 +125,7 @@ function sampleMemory() {
     main: {
       rssMb: Math.round(mu.rss / 1048576),
       heapUsedMb: Math.round(mu.heapUsed / 1048576),
+      heapTotalMb: Math.round(mu.heapTotal / 1048576),
       externalMb: Math.round(mu.external / 1048576),
     },
     powerBlockerHeld: (() => {
@@ -152,6 +154,25 @@ function persistSentinel(clean) {
   } catch { /* best-effort */ }
 }
 
+let heapSkipLogged = false;
+function tryMainHeapSnapshot() {
+  try {
+    const t0 = Date.now();
+    const heapUsedMb = process.memoryUsage().heapUsed / 1048576;
+    const r = maybeCaptureMainHeap({ heapUsedMb });
+    if (r.captured) {
+      logs?.writeLine({ scope: 'crash-diag', level: 'warn', message: '[crash-diag] main heap snapshot',
+        meta: { filePath: r.filePath, ms: Date.now() - t0, heapUsedMb: Math.round(heapUsedMb) } });
+    } else if (r.reason !== 'below-threshold' && r.reason !== 'already-captured' && !heapSkipLogged) {
+      heapSkipLogged = true;
+      logs?.writeLine({ scope: 'crash-diag', level: 'warn', message: '[crash-diag] main heap snapshot skipped',
+        meta: { reason: r.reason, heapUsedMb: Math.round(heapUsedMb) } });
+    }
+  } catch (err) {
+    try { logs?.writeLine({ scope: 'crash-diag', level: 'error', message: `[crash-diag] main heap snapshot failed: ${err && err.message}` }); } catch { /* ignore */ }
+  }
+}
+
 function heartbeat() {
   lastSample = sampleMemory();
   const loop = loopMonitor ? loopMonitor.snapshot() : null;
@@ -167,11 +188,14 @@ function heartbeat() {
     meta: {
       totalMb: lastSample.totalMb,
       mainRssMb: lastSample.main.rssMb,
+      mainHeapUsedMb: lastSample.main.heapUsedMb,
+      mainHeapTotalMb: lastSample.main.heapTotalMb,
       powerBlockerHeld: lastSample.powerBlockerHeld,
       top: top.map((p) => `${p.type}:${p.mb}MB`),
       ...loop,
     },
   });
+  tryMainHeapSnapshot();
   const stall = loop && stallVerdict(loop);
   if (stall) logs?.writeLine({ scope: 'crash-diag', ...stall, meta: { ...loop } });
 }

package/src/main/historyAggregator.cjs

@@ -553,10 +553,30 @@ function rollupMapToRows(map, finalizedDates) {
  * opts.dryRun (optional): computes what would be finalized without writing
  * anything to the rollup file.
  */
-async function finalizeClosedDays({ budgetMs, dryRun = false } = {}) {
+async function finalizeClosedDays({ budgetMs, dryRun = false, cursorPath } = {}) {
   const deadline = typeof budgetMs === 'number' ? Date.now() + budgetMs : null;
   const today = localDate(new Date());
 
+  // Resumable cursor: { cycleStartedAt, lastDir, dates }. `dates` carries the
+  // closed days seen by earlier partial calls of this cycle so the completing
+  // call can stamp all of them. Missing/corrupt file => fresh cycle.
+  const atomicFs = require('./lib/util/atomicFs.cjs');
+  let resolvedCursor = cursorPath;
+  if (!resolvedCursor) {
+    try { resolvedCursor = require('./lib/scheduler/schedulerPaths.cjs').historyRollupCursorPath(); } catch { resolvedCursor = null; }
+  }
+  let cycleStartedAt = Date.now();
+  let lastDir = '';
+  const dates = new Set();
+  if (resolvedCursor) {
+    const c = atomicFs.readJsonOrSync(resolvedCursor, null);
+    if (c && typeof c === 'object' && typeof c.lastDir === 'string' && c.lastDir) {
+      lastDir = c.lastDir;
+      if (typeof c.cycleStartedAt === 'number') cycleStartedAt = c.cycleStartedAt;
+      if (Array.isArray(c.dates)) for (const d of c.dates) if (typeof d === 'string') dates.add(d);
+    }
+  }
+
   let projectDirs;
   try {
     projectDirs = await fsp.readdir(PROJECTS_DIR, { withFileTypes: true });
@@ -566,10 +586,12 @@ async function finalizeClosedDays({ budgetMs, dryRun = false } = {}) {
 
   projectDirs = projectDirs
     .filter((e) => e.isDirectory())
-    .sort((a, b) => a.name.localeCompare(b.name));
+    .sort((a, b) => a.name.localeCompare(b.name))
+    .filter((e) => !lastDir || e.name.localeCompare(lastDir) > 0);
 
   const buckets = new Map();
   let partial = false;
+  let walkedLast = lastDir;
 
   for (const projEntry of projectDirs) {
     if (deadline !== null && Date.now() >= deadline) {
@@ -581,7 +603,7 @@ async function finalizeClosedDays({ budgetMs, dryRun = false } = {}) {
     const projectDir = path.join(PROJECTS_DIR, encodedCwd);
 
     let files;
-    try { files = await fsp.readdir(projectDir, { withFileTypes: true }); } catch { continue; }
+    try { files = await fsp.readdir(projectDir, { withFileTypes: true }); } catch { walkedLast = encodedCwd; continue; }
 
     for (const fileEntry of files) {
       if (!fileEntry.name.endsWith('.jsonl')) continue;
@@ -600,23 +622,35 @@ async function finalizeClosedDays({ budgetMs, dryRun = false } = {}) {
       if (!buckets.has(key)) buckets.set(key, emptyBucket(sessionDate, encodedCwd));
       foldParsedIntoBucket(buckets.get(key), parsed);
     }
+    walkedLast = encodedCwd; // advance only after the directory is fully walked
   }
 
-  const dates = new Set();
   const entries = [];
   for (const b of buckets.values()) {
     dates.add(b.date);
     entries.push(...bucketToRollupLines(b));
   }
-  // Only stamp dates as finalized (safe to trust with no live re-scan) when
-  // the walk visited every project directory within budget — a partial walk
-  // may be missing contributions from directories not yet visited.
+  // Only stamp dates as finalized (safe to trust with no live re-scan) once a
+  // full cycle has covered every project directory — possibly across calls.
   if (!partial) {
     for (const date of dates) entries.push(finalizedMarkerLine(date));
   }
 
   if (!dryRun) {
     await appendRollupAndNotify(entries);
+    if (resolvedCursor) {
+      try {
+        if (partial) {
+          if (walkedLast !== lastDir) {
+            await atomicFs.writeJsonAtomic(resolvedCursor, { cycleStartedAt, lastDir: walkedLast, dates: Array.from(dates) });
+          }
+        } else {
+          await fsp.rm(resolvedCursor, { force: true });
+        }
+      } catch {
+        // Cursor is an optimisation; a failed write just means a re-walk.
+      }
+    }
   }
   return { finalizedDates: partial ? [] : Array.from(dates), partial };
 }

package/src/main/index.cjs

@@ -122,7 +122,6 @@ const heapSnapshot = require('./heapSnapshot.cjs');
 const filesIpc = require('./files.cjs');
 const { registerDocEditHandlers, attachWindow: attachDocEditWindow } = require('./docEdit.cjs');
 const webRemote = require('./webRemote.cjs');
-const { registerRemoteClientHandlers } = require('./remoteClientIpc.cjs');
 const { registerAgentsHandlers } = require('./agentsIpc.cjs');
 const { registerTelemetryHandlers } = require('./telemetryIpc.cjs');
 const { registerUpdaterIpc } = require('./updaterIpc.cjs');
@@ -627,8 +626,20 @@ ipcMain.handle('app:delegation-readiness', validated(schemas.delegationReadiness
   try {
     await ensureGuardsInstalled(cwd);
   } catch { /* auto-install must never block the readiness probe itself */ }
+  const first = await checkDelegationReadiness({ ...payload, cwd });
+  const failing = (first?.checks || []).some((c) => !c.ok && (c.id === 'dev-plugin' || c.id === 'scheduler-mcp'));
+  if (!failing) return first;
+  // Repair at point of use (at most once per check per app run) — the boot seeders give up after 3 attempts.
+  try {
+    await require('./lib/epic/delegationSelfHeal.cjs').selfHealDelegation({
+      checks: first.checks,
+      homeDir: os.homedir(),
+      deps: { awaitBootSeeding: () => bootSeedingPromise, cwd },
+    });
+  } catch { /* self-heal never blocks the probe */ }
   return checkDelegationReadiness({ ...payload, cwd });
 }));
+let bootSeedingPromise = Promise.resolve();
 
 // Every guard-install attempt is logged from MAIN, not the renderer — a
 // press that never reaches this process (e.g. a renderer talking to an
@@ -1041,7 +1052,6 @@ git.register(ipcMain);
 filesIpc.registerFilesHandlers();
 registerDocEditHandlers();
 webRemote.registerRemoteHandlers();
-registerRemoteClientHandlers(() => mainWindow);
 registerAgentsHandlers({ ipcMain, getWindow: () => mainWindow });
 try {
   registerUpdaterIpc({ ipcMain, getWindow: () => mainWindow, ptyManager });
@@ -1455,7 +1465,7 @@ app.whenReady().then(async () => {
   // Seeders run through ONE serial chain (runSeeders.cjs): plugin install and
   // `mcp add --scope user` both write Claude's config files, and concurrent
   // writes can drop an entry. Fire-and-forget relative to window creation.
-  runSeedersSerially([
+  bootSeedingPromise = runSeedersSerially([
     { name: 'dev-plugin', run: () => seedDevPlugin({ logger: console, writeLog: logs.writeLine }) },
     { name: 'agent-personas', run: () => seedAgentPersonas({ logger: console, writeLog: logs.writeLine }) },
     { name: 'scheduler-mcp', run: () => seedSchedulerMcp({ logger: console, writeLog: logs.writeLine }) },

package/src/main/ipcSchemas.cjs

@@ -450,6 +450,18 @@ const schedulerCreatePrd = z.object({
 // computed target (from the SAME backlog tree the UI renders — see
 // lib/backlogTree.ts); the main-process handler only validates the rewrite
 // is safe (prdDisposition.cjs), never re-derives "the" terminal itself.
+// Batch create (createPrdBatch): up to 40 entries, each the exact single-create
+// shape. Cross-entry rules (cycles, duplicate slugs, dependsOn naming siblings)
+// live in prdCreate.cjs; this only bounds the envelope.
+const PRD_BATCH_MAX = 40;
+const adminCreatePrds = z.object({
+  prds: z.array(schedulerCreatePrd).min(1).max(PRD_BATCH_MAX),
+  cwd: z.string().min(1).max(4096).regex(NO_NEWLINE_RE, 'must not contain newlines').optional(),
+  originClaudeSessionId: z.string().min(1).max(200).optional(),
+  originProjectRoot: z.string().min(1).max(4096).regex(NO_NEWLINE_RE, 'must not contain newlines').optional(),
+  sourcePromptId: z.string().min(1).max(128).regex(NO_NEWLINE_RE, 'must not contain newlines').optional(),
+});
+
 const scheduleSetPrdDisposition = z.object({
   slug: z.string().regex(SCHEDULE_SLUG_RE),
   cwd: z.string().min(1).max(4096).optional(),
@@ -554,9 +566,18 @@ const adminUpdatePrd = z.object({
     (s) => Buffer.byteLength(s, 'utf8') <= PRD_WRITE_MAX_BYTES,
     `body must be ≤ ${PRD_WRITE_MAX_BYTES} bytes`,
   ).optional(),
-}).refine(
-  (it) => (it.frontmatter && Object.keys(it.frontmatter).length > 0) || it.body !== undefined,
-  'at least one of frontmatter or body is required',
+  // Structured section patches, applied via prdBodyPatch.cjs (re-validated and
+  // re-rendered). Mutually exclusive with `body` (enforced in updatePrd too).
+  gate: z.array(z.string().min(1).max(2000)).min(1).max(50).optional(),
+  files: z.array(z.string().min(1).max(1000)).min(1).max(200).optional(),
+  acceptanceCriteria: z.array(z.string().min(1).max(2000)).min(1).max(100).optional(),
+}).strict().refine(
+  (it) => (it.frontmatter && Object.keys(it.frontmatter).length > 0) || it.body !== undefined
+    || it.gate !== undefined || it.files !== undefined || it.acceptanceCriteria !== undefined,
+  'at least one of frontmatter, body, gate, files or acceptanceCriteria is required',
+).refine(
+  (it) => it.body === undefined || (it.gate === undefined && it.files === undefined && it.acceptanceCriteria === undefined),
+  'body cannot be combined with gate, files or acceptanceCriteria',
 );
 
 const adminCancelJob = z.object({
@@ -1188,7 +1209,7 @@ function validated(schema, handler) {
 // Commands are split into three tiers:
 //   READ_COMMANDS      — return data; allowed when remoteEnabled=true.
 //   SAS_GATED_READS    — return sensitive user data (sessions, PRDs, logs,
-//                        transcript summaries); additionally require
+//                        transcript summaries, machine hostname); additionally require
 //                        _e2eAuthenticated=true (SAS confirmed by user).
 //                        A compromised relay cannot exfiltrate this data from
 //                        a session that has not been SAS-confirmed.
@@ -1198,22 +1219,17 @@ function validated(schema, handler) {
 // ALLOWED_COMMANDS is the union, kept for existing import compatibility.
 //
 // Ungated READ_COMMANDS (justify each):
-//   cmd:app:version      — exposes only the app semver string; no user data.
-//   cmd:app:info         — exposes only app semver + OS platform string; no user data.
 //   cmd:session:unsubscribe — teardown lifecycle; returns nothing sensitive.
 const READ_COMMANDS = new Set([
-  'cmd:app:version',
-  'cmd:app:info',
   // v2 mobile: unsubscribe is a teardown lifecycle call with no data payload.
   'cmd:session:unsubscribe',
 ]);
 
 // Sensitive reads — return user data; require SAS confirmation same as MUTATE.
 const SAS_GATED_READS = new Set([
-  'cmd:sessions:load',
-  // Same data the phone reads on demand (projects + their active Epics).
-  'cmd:sessions:list',
-  'cmd:history:aggregate',
+  // Web app's multi-desktop picker: { version, platform, hostname }. The
+  // hostname identifies the machine, so this is SAS-gated.
+  'cmd:app:info',
   // subscribe initiates a live stream of session state/summary — sensitive.
   'cmd:session:subscribe',
   // Picker data (projects, personas, tags, macros) for the phone's New Session.
@@ -1238,17 +1254,8 @@ const SAS_GATED_READS = new Set([
 ]);
 
 const MUTATE_COMMANDS = new Set([
-  'cmd:sessions:save',
-  'cmd:pty:spawn',
-  'cmd:pty:write',
-  // pty:kill terminates a live session; pty:resize drives the geometry of the
-  // user's interactive PTY — both write live process state, so they are gated
-  // behind remoteControlEnabled + SAS like every other mutation. A read-only
-  // mobile mirror has no business killing or resizing the desktop's session.
-  'cmd:pty:kill',
-  'cmd:pty:resize',
   // Pushes a prompt into an open tab's chat queue — a real mutation of that
-  // tab's session, same tier as pty:write.
+  // tab's session, a mutation.
   'cmd:chat:send',
   // Starts a new Session on the desktop via the renderer's launchSession.
   'cmd:session:create',
@@ -1299,6 +1306,7 @@ module.exports = {
     scheduleReadLog,
     scheduleWritePrd,
     schedulerCreatePrd,
+    adminCreatePrds,
     scheduleSetPrdDisposition,
     scheduleArchivePrd,
     scheduleRetagPrd,

package/src/main/lib/activeSessions.cjs

@@ -14,7 +14,8 @@ const os = require('node:os');
 const path = require('node:path');
 const { KIND_CONFIG: WORKTREE_KIND_CONFIG } = require('./git/gitWorktree.cjs');
 const { OPS_ROOT_DIR } = require('./opsOwnership.cjs');
-const { classifyCwd, worktreeMainRootOf } = require('./cwdClassify.cjs');
+const cwdClassify = require('./cwdClassify.cjs');
+const { worktreeMainRootOf } = cwdClassify;
 
 const HOME = os.homedir();
 const TMPDIR = os.tmpdir();
@@ -55,7 +56,7 @@ const TAIL_BYTES = 64 * 1024;
 // and leave the tail with no complete `cwd` row. Only on that miss the tail
 // grows (x16 per step) up to MAX_TAIL_BYTES, then up to MAX_FALLBACK_FILES
 // newest transcripts are tried before the project is given up on.
-const MAX_TAIL_BYTES = 16 * 1024 * 1024;
+const MAX_TAIL_BYTES = 1024 * 1024;
 const MAX_FALLBACK_FILES = 5;
 const TAIL_GROWTH = 16;
 
@@ -87,11 +88,45 @@ const CACHE_TTL_MS = 120_000;
 // Bounds how many project dirs the async rescan reads concurrently.
 const RESCAN_CONCURRENCY = 32;
 const EMPTY_CWDS = Object.freeze([]);
-const rawScanCache = new Map(); // projectsDir -> { dirMtimeMs, cachedAt, records, refreshPromise }
+// projectsDir -> { dirMtimeMs, cachedAt, records, dirs, refreshPromise }
+// `dirs` is Map<projectDirName, {rawCwd, newestMtimeMs, newestFile, newestSize}> — the
+// per-dir record cache that lets a changed projectsDir rescan only the added dirs.
+const rawScanCache = new Map();
+
+// rawCwd -> classifyCwd result. Never holds kind 'unknown' (an unresolvable
+// .git may resolve later). Bounded; cleared when exceeded or on a full first scan.
+const CLASSIFY_MEMO_MAX = 20000;
+const classifyMemo = new Map();
+function classifyMemoized(rawCwd) {
+  const hit = classifyMemo.get(rawCwd);
+  if (hit) return hit;
+  const classified = cwdClassify.classifyCwd(rawCwd);
+  if (classified.kind !== 'unknown') {
+    if (classifyMemo.size >= CLASSIFY_MEMO_MAX) classifyMemo.clear();
+    classifyMemo.set(rawCwd, classified);
+  }
+  return classified;
+}
 
-/** Forces the next activeProjectCwds/allProjectCwds call to rescan. */
-function bustProjectCwdCache() {
+/**
+ * Forces the next activeProjectCwds/allProjectCwds call to revalidate. Keeps the
+ * per-dir Map and classify memo (a full rescan of thousands of dirs is the cost
+ * this exists to avoid): entries are only marked stale so the next scan takes
+ * the incremental path. `deep` also re-lists/re-stats every KNOWN dir, tail-reading
+ * only those whose newest transcript changed.
+ */
+function bustProjectCwdCache({ deep = false } = {}) {
+  for (const entry of rawScanCache.values()) {
+    entry.dirMtimeMs = NaN;
+    entry.cachedAt = 0;
+    if (deep) entry.forceDeep = true;
+  }
+}
+
+/** Test isolation: the old full clear (cache + classify memo). */
+function __resetProjectCwdCacheForTests() {
   rawScanCache.clear();
+  classifyMemo.clear();
 }
 
 // The ops-root folder name. A transcript's `cwd` can point INSIDE it whenever
@@ -119,7 +154,7 @@ const OPS_DIRNAME = OPS_ROOT_DIR;
  * resolution) lives in cwdClassify.cjs.
  */
 function projectRootOf(cwd) {
-  return classifyCwd(cwd).projectRoot ?? cwd;
+  return cwdClassify.classifyCwd(cwd).projectRoot ?? cwd;
 }
 
 /**
@@ -160,11 +195,19 @@ function lastCwdInLines(lines) {
   return null;
 }
 
+/** True when the cached entry's newest transcript is unchanged (name, mtime, size). */
+function sameNewest(prev, newest) {
+  return !!prev && prev.newestFile === newest.tf && prev.newestMtimeMs === newest.mtimeMs
+    && prev.newestSize === newest.size;
+}
+
 /**
- * scanOneProjectDirSync(projDir) → {rawCwd, newestMtimeMs} | null
+ * scanOneProjectDirSync(projDir, prev?) → {rawCwd, newestMtimeMs} | null
  * Newest *.jsonl's mtime plus its last parseable `cwd`, for one project dir.
+ * With `prev` (a cached entry), the tail read is skipped entirely when the newest
+ * transcript's name, mtime and size are unchanged.
  */
-function scanOneProjectDirSync(projDir) {
+function scanOneProjectDirSync(projDir, prev) {
   let entries;
   try {
     entries = fs.readdirSync(projDir).filter((f) => f.endsWith('.jsonl'));
@@ -173,22 +216,26 @@ function scanOneProjectDirSync(projDir) {
   const files = [];
   for (const tf of entries) {
     const fp = path.join(projDir, tf);
-    try { files.push({ fp, mtimeMs: fs.statSync(fp).mtimeMs }); } catch { continue; }
+    try { const st = fs.statSync(fp); files.push({ fp, tf, mtimeMs: st.mtimeMs, size: st.size }); } catch { continue; }
   }
-  if (!files.length) return null;
+  if (!files.length) return { rawCwd: null, newestFile: null, newestMtimeMs: 0, newestSize: 0 };
   files.sort((x, y) => y.mtimeMs - x.mtimeMs);
   const newestMtimeMs = files[0].mtimeMs;
+  const newestFile = files[0].tf;
+  const newestSize = files[0].size;
+  if (sameNewest(prev, files[0])) return { ...prev, newestMtimeMs };
 
   for (const { fp } of files.slice(0, MAX_FALLBACK_FILES)) {
     let size = TAIL_BYTES;
     for (;;) {
       const rawCwd = lastCwdInLines(readTailLines(fp, size));
-      if (rawCwd) return { rawCwd, newestMtimeMs };
+      if (rawCwd) return { rawCwd, newestMtimeMs, newestFile, newestSize };
       if (size >= MAX_TAIL_BYTES || size >= fileSizeSync(fp)) break;
       size = Math.min(size * TAIL_GROWTH, MAX_TAIL_BYTES);
     }
   }
-  return null;
+  // No cwd found: cache the negative result under the same newest-file fingerprint.
+  return { rawCwd: null, newestMtimeMs, newestFile, newestSize };
 }
 
 /**
@@ -237,14 +284,21 @@ function scanProjectsDir(projectsDir) {
   let slugs;
   try { slugs = fs.readdirSync(projectsDir); } catch { rawScanCache.delete(projectsDir); return null; }
 
-  const records = [];
+  // Incremental: reuse every already-known dir's entry, scan only added names,
+  // drop names that vanished.
+  if (!cached) classifyMemo.clear();
+  const prevDirs = cached ? cached.dirs : null;
+  const deep = !!(cached && cached.forceDeep);
+  const dirs = new Map();
   for (const slug of slugs) {
-    const rec = scanOneProjectDirSync(path.join(projectsDir, slug));
-    if (rec) records.push(rec);
+    const known = prevDirs && prevDirs.get(slug);
+    if (known && !deep) { dirs.set(slug, known); continue; }
+    const rec = scanOneProjectDirSync(path.join(projectsDir, slug), known || undefined);
+    if (rec) dirs.set(slug, rec);
   }
 
-  Object.freeze(records);
-  rawScanCache.set(projectsDir, { dirMtimeMs, cachedAt: now0, records, refreshPromise: null });
+  const records = Object.freeze([...dirs.values()].filter((d) => d.rawCwd));
+  rawScanCache.set(projectsDir, { dirMtimeMs, cachedAt: now0, records, dirs, refreshPromise: null });
   return records;
 }
 
@@ -271,10 +325,10 @@ async function readTailLinesAsync(filePath, maxBytes) {
 }
 
 /**
- * scanOneProjectDirAsync(projDir) → Promise<{rawCwd, newestMtimeMs} | null>
+ * scanOneProjectDirAsync(projDir, prev?) → Promise<{rawCwd, newestMtimeMs} | null>
  * fs.promises counterpart of scanOneProjectDirSync, used only by the async rescan.
  */
-async function scanOneProjectDirAsync(projDir) {
+async function scanOneProjectDirAsync(projDir, prev) {
   let entries;
   try {
     entries = (await fsp.readdir(projDir)).filter((f) => f.endsWith('.jsonl'));
@@ -283,24 +337,28 @@ async function scanOneProjectDirAsync(projDir) {
   const files = [];
   for (const tf of entries) {
     const fp = path.join(projDir, tf);
-    try { files.push({ fp, mtimeMs: (await fsp.stat(fp)).mtimeMs }); } catch { continue; }
+    try { const st = await fsp.stat(fp); files.push({ fp, tf, mtimeMs: st.mtimeMs, size: st.size }); } catch { continue; }
   }
-  if (!files.length) return null;
+  if (!files.length) return { rawCwd: null, newestFile: null, newestMtimeMs: 0, newestSize: 0 };
   files.sort((x, y) => y.mtimeMs - x.mtimeMs);
   const newestMtimeMs = files[0].mtimeMs;
+  const newestFile = files[0].tf;
+  const newestSize = files[0].size;
+  if (sameNewest(prev, files[0])) return { ...prev, newestMtimeMs };
 
   for (const { fp } of files.slice(0, MAX_FALLBACK_FILES)) {
     let size = TAIL_BYTES;
     for (;;) {
       const rawCwd = lastCwdInLines(await readTailLinesAsync(fp, size));
-      if (rawCwd) return { rawCwd, newestMtimeMs };
+      if (rawCwd) return { rawCwd, newestMtimeMs, newestFile, newestSize };
       let fileSize = 0;
       try { fileSize = (await fsp.stat(fp)).size; } catch { /* gone: stop growing */ }
       if (size >= MAX_TAIL_BYTES || size >= fileSize) break;
       size = Math.min(size * TAIL_GROWTH, MAX_TAIL_BYTES);
     }
   }
-  return null;
+  // No cwd found: cache the negative result under the same newest-file fingerprint.
+  return { rawCwd: null, newestMtimeMs, newestFile, newestSize };
 }
 
 /**
@@ -311,25 +369,27 @@ async function scanOneProjectDirAsync(projDir) {
  * (missing dir, unreadable) is left to throw/reject — startAsyncRefresh's
  * caller catches it, logs once, and keeps the old cached record.
  */
-async function rescanProjectsDirAsync(projectsDir) {
+async function rescanProjectsDirAsync(projectsDir, prevDirs) {
   const dirMtimeMs = (await fsp.stat(projectsDir)).mtimeMs;
   const slugs = await fsp.readdir(projectsDir);
 
-  const records = [];
+  const dirs = new Map();
   let nextIdx = 0;
   async function worker() {
     for (;;) {
       const i = nextIdx++;
       if (i >= slugs.length) return;
-      const rec = await scanOneProjectDirAsync(path.join(projectsDir, slugs[i]));
-      if (rec) records.push(rec);
+      const rec = await scanOneProjectDirAsync(
+        path.join(projectsDir, slugs[i]), prevDirs && prevDirs.get(slugs[i]),
+      );
+      if (rec) dirs.set(slugs[i], rec);
     }
   }
   const workerCount = Math.min(RESCAN_CONCURRENCY, slugs.length);
   await Promise.all(Array.from({ length: workerCount }, worker));
 
-  Object.freeze(records);
-  return { dirMtimeMs, records };
+  const records = Object.freeze([...dirs.values()].filter((d) => d.rawCwd));
+  return { dirMtimeMs, records, dirs };
 }
 
 /**
@@ -345,12 +405,12 @@ function startAsyncRefresh(projectsDir) {
   if (!entry) return Promise.resolve();
   if (entry.refreshPromise) return entry.refreshPromise;
 
-  const promise = rescanProjectsDirAsync(projectsDir)
+  const promise = rescanProjectsDirAsync(projectsDir, entry.dirs)
     .then((result) => {
       const current = rawScanCache.get(projectsDir);
       if (!current) return; // busted mid-flight; nothing to swap into
       rawScanCache.set(projectsDir, {
-        dirMtimeMs: result.dirMtimeMs, cachedAt: Date.now(), records: result.records, refreshPromise: null,
+        dirMtimeMs: result.dirMtimeMs, cachedAt: Date.now(), records: result.records, dirs: result.dirs, refreshPromise: null,
       });
     })
     .catch((err) => {
@@ -394,7 +454,7 @@ function deriveCwds(records, maxAgeMin, maxCwds, tmpDropRoots) {
     // Normalize an ops-internal cwd up to its project root BEFORE any of the
     // checks below — the stray-ops-root incident (see OPS_DIRNAME above) got
     // through precisely because such a path is absolute and does exist.
-    const classified = classifyCwd(rawCwd);
+    const classified = classifyMemoized(rawCwd);
     // `unknown` (a .git file we cannot resolve) is non-registrable: registering
     // it would hand every consumer a project whose ops writes are refused.
     if (classified.kind === 'unknown') return;
@@ -487,5 +547,6 @@ module.exports = {
   worktreeMainRootOf,
   isSstHarnessCwd,
   bustProjectCwdCache,
+  __resetProjectCwdCacheForTests,
   __waitForPendingRefresh,
 };

package/src/main/lib/epic/delegationReadiness.cjs

@@ -880,4 +880,6 @@ module.exports = {
   INLINE_IMPLEMENTATION_GUARD_MATCHER,
   SELF_SCHEDULE_GUARD_SCRIPT,
   SELF_SCHEDULE_GUARD_MATCHER,
+  GUARD_DEFS,
+  checkGuard,
 };

package/src/main/lib/epic/delegationSelfHeal.cjs

@@ -0,0 +1,77 @@
+/**
+ * Point-of-use repair for the two delegation preconditions the boot seeders
+ * give up on after MAX_ATTEMPTS: the session-manager-dev plugin and the
+ * session-manager-scheduler MCP registration. Called by the
+ * app:delegation-readiness handler when either check is failing. Each check id
+ * is attempted at most once per app process, regardless of the seed marker.
+ * Never throws; failures go to opsErrorLog (scope 'delegationSelfHeal').
+ */
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const attempted = new Set();
+
+function readSettings(homeDir) {
+  try { return JSON.parse(fs.readFileSync(path.join(homeDir, '.claude', 'settings.json'), 'utf8')); } catch { return null; }
+}
+
+function defaultDeps(homeDir) {
+  const dev = require('../../seedDevPlugin.cjs');
+  const mcp = require('../../seedSchedulerMcp.cjs');
+  return {
+    install: (opts) => require('../../pluginInstall.cjs').install(opts),
+    mcpRepair: async () => {
+      await mcp.runClaudeMcpRemove(); // best-effort: add refuses when a stale entry exists
+      return mcp.runClaudeMcpAdd(mcp.serverScriptPath());
+    },
+    writeMarker: (id, state) => (id === 'dev-plugin' ? dev.writeMarker(state, homeDir) : mcp.writeMarker(state)),
+    readSettings,
+    log: (entry) => require('../telemetry/opsErrorLog.cjs').appendError(entry),
+    awaitBootSeeding: async () => {},
+  };
+}
+
+/**
+ * @param {{ checks: Array<{id:string, ok:boolean}>, homeDir?: string, deps?: object }} args
+ */
+async function selfHealDelegation({ checks, homeDir = os.homedir(), deps = {} } = {}) {
+  const d = { ...defaultDeps(homeDir), ...deps };
+  const failing = new Set((checks || []).filter((c) => c && !c.ok).map((c) => c.id));
+  const todo = ['dev-plugin', 'scheduler-mcp'].filter((id) => failing.has(id) && !attempted.has(id));
+  if (!todo.length) return { attempted: [] };
+  for (const id of todo) attempted.add(id); // claim synchronously: concurrent probes can't double-run
+  try { await d.awaitBootSeeding?.(); } catch { /* boot seeding failures are logged elsewhere */ }
+
+  const done = [];
+  for (const id of todo) {
+    try {
+      let r;
+      if (id === 'dev-plugin') {
+        const enabled = d.readSettings(homeDir)?.enabledPlugins?.['session-manager-dev@session-manager'];
+        if (enabled === false) continue; // deliberate disable stays
+        r = await d.install({ slug: 'session-manager-dev', marketplace: { add: 'bundled', name: 'session-manager' } });
+      } else {
+        r = await d.mcpRepair();
+      }
+      done.push(id);
+      if (r?.ok) d.writeMarker(id, { done: true, attempts: 0 });
+      else throw new Error(r?.error || `exit ${r?.exitCode}`);
+    } catch (err) {
+      try {
+        d.log({
+          cwd: d.cwd,
+          scope: 'delegationSelfHeal',
+          level: 'error',
+          message: `${id} self-heal failed: ${err?.message ?? err}`,
+          meta: { check: id },
+        });
+      } catch { /* logging is best-effort */ }
+    }
+  }
+  return { attempted: done };
+}
+
+function _resetForTests() { attempted.clear(); }
+
+module.exports = { selfHealDelegation, _resetForTests };

package/src/main/lib/epic/epicMint.cjs

@@ -382,7 +382,7 @@ function ensureEpic(cwd, { goalText, tag, epicId: explicitEpicId, status = 'prop
 
     const prdDir = resolveEpicPrdWriteDir(cwd, epicId);
     fs.mkdirSync(prdDir, { recursive: true });
-    telemetryCounters.trackEpicCreate();
+    telemetryCounters.trackEpicCreate({ tag, agentType });
     return { epicId, prdDir, created: true };
   });
 }