claude-code-session-manager 0.35.18 → 0.37.0

package/src/main/historyDashboard.cjs

@@ -0,0 +1,226 @@
+/**
+ * historyDashboard.cjs — `history:dashboard` IPC: answers entirely from the
+ * durable rollup store (src/main/lib/historyRollup.cjs), never touching a
+ * transcript .jsonl file. This is what lets the History dashboard render
+ * instantly regardless of transcript corpus size or retention/cleanup.
+ *
+ * Only imports historyRollup.cjs (the rollup reader) and pure helpers
+ * re-exported from historyAggregator.cjs (pricing table + date math) — never
+ * fs/promises, never PROJECTS_DIR. See historyDashboard.test.cjs's zero-scan
+ * guarantee test.
+ */
+
+'use strict';
+
+const { ipcMain } = require('electron');
+const historyRollup = require('./lib/historyRollup.cjs');
+const {
+  MODEL_PRICING,
+  resolvePricingKey,
+  localDate,
+  subtractDays,
+} = require('./historyAggregator.cjs');
+const { schemas } = require('./ipcSchemas.cjs');
+
+// Read range start for rangeDays=0 ("all time"). Rollup dates are always
+// after this, so it's an effective "no lower bound".
+const EARLIEST_DATE = '1970-01-01';
+
+function emptyProjectRow(date, projectDir) {
+  return {
+    date,
+    projectDir,
+    promptCount: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheCreationTokens: 0,
+    toolCallCount: 0,
+    toolBreakdown: {},
+    sessionCount: 0,
+    errorCount: 0,
+    activeMinutes: 0,
+    byModel: {},
+  };
+}
+
+/** Fold one rollup bucket (totals line or per-model line) into a row. */
+function foldBucketIntoRow(row, bucket) {
+  if (bucket.modelId === historyRollup.TOTALS_MODEL_ID) {
+    row.promptCount += bucket.promptCount || 0;
+    row.toolCallCount += bucket.toolCallCount || 0;
+    row.errorCount += bucket.errorCount || 0;
+    row.sessionCount += bucket.sessionCount || 0;
+    row.activeMinutes += bucket.activeMinutes || 0;
+    for (const [tool, cnt] of Object.entries(bucket.toolBreakdown || {})) {
+      row.toolBreakdown[tool] = (row.toolBreakdown[tool] ?? 0) + cnt;
+    }
+  } else {
+    const dst = row.byModel[bucket.modelId] ?? (row.byModel[bucket.modelId] = {
+      inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0,
+    });
+    dst.inputTokens += bucket.inputTokens || 0;
+    dst.outputTokens += bucket.outputTokens || 0;
+    dst.cacheReadTokens += bucket.cacheReadTokens || 0;
+    dst.cacheCreationTokens += bucket.cacheCreationTokens || 0;
+    row.inputTokens += bucket.inputTokens || 0;
+    row.outputTokens += bucket.outputTokens || 0;
+    row.cacheReadTokens += bucket.cacheReadTokens || 0;
+    row.cacheCreationTokens += bucket.cacheCreationTokens || 0;
+  }
+}
+
+/** Compute per-model + row-level cost at read time — never stored. */
+function computeRowCost(row) {
+  const byModel = {};
+  let estimatedCostUsd = 0;
+  for (const [modelId, bucket] of Object.entries(row.byModel)) {
+    const { key, estimated } = resolvePricingKey(modelId);
+    const pricing = MODEL_PRICING[key];
+    const costUsd =
+      (bucket.inputTokens + bucket.cacheCreationTokens) * pricing.i / 1e6 +
+      bucket.outputTokens * pricing.o / 1e6 +
+      bucket.cacheReadTokens * pricing.c / 1e6;
+    byModel[modelId] = { ...bucket, costUsd, ...(estimated ? { estimated: true } : {}) };
+    estimatedCostUsd += costUsd;
+  }
+  return { ...row, byModel, estimatedCostUsd };
+}
+
+function emptyTotals() {
+  return {
+    promptCount: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheCreationTokens: 0,
+    toolCallCount: 0,
+    sessionCount: 0,
+    errorCount: 0,
+    activeMinutes: 0,
+    estimatedCostUsd: 0,
+  };
+}
+
+function addRowToTotals(totals, row) {
+  totals.promptCount += row.promptCount;
+  totals.inputTokens += row.inputTokens;
+  totals.outputTokens += row.outputTokens;
+  totals.cacheReadTokens += row.cacheReadTokens;
+  totals.cacheCreationTokens += row.cacheCreationTokens;
+  totals.toolCallCount += row.toolCallCount;
+  totals.sessionCount += row.sessionCount;
+  totals.errorCount += row.errorCount;
+  totals.activeMinutes += row.activeMinutes;
+  totals.estimatedCostUsd += row.estimatedCostUsd;
+}
+
+/**
+ * Answer the History dashboard's full request purely from rollup lines.
+ * O(rollup lines in range) — no transcript file is ever opened.
+ */
+async function computeDashboard(req) {
+  const rangeDays = req?.rangeDays ?? 30;
+  const isAll = rangeDays === 0;
+  const today = localDate(new Date());
+  const to = today;
+  const from = isAll ? EARLIEST_DATE : subtractDays(today, rangeDays - 1);
+  const prevFrom = isAll ? null : subtractDays(from, rangeDays);
+  const prevTo = isAll ? null : subtractDays(from, 1);
+  const readFrom = isAll ? EARLIEST_DATE : prevFrom;
+
+  const map = await historyRollup.readRollup(readFrom, to);
+
+  const daysMap = new Map(); // date -> Map(projectDir -> row)
+  const prevRow = emptyProjectRow('', '');
+  const finalizedDates = new Set();
+
+  for (const bucket of map.values()) {
+    if (bucket.projectDir === historyRollup.FINALIZED_PROJECT_ID && bucket.modelId === historyRollup.FINALIZED_MODEL_ID) {
+      if (bucket.finalizedAt) finalizedDates.add(bucket.date);
+      continue;
+    }
+
+    const inCurrent = bucket.date >= from && bucket.date <= to;
+    if (inCurrent) {
+      let projMap = daysMap.get(bucket.date);
+      if (!projMap) { projMap = new Map(); daysMap.set(bucket.date, projMap); }
+      let row = projMap.get(bucket.projectDir);
+      if (!row) { row = emptyProjectRow(bucket.date, bucket.projectDir); projMap.set(bucket.projectDir, row); }
+      foldBucketIntoRow(row, bucket);
+      continue;
+    }
+
+    const inPrev = !isAll && bucket.date >= prevFrom && bucket.date <= prevTo;
+    if (inPrev) foldBucketIntoRow(prevRow, bucket);
+  }
+
+  const days = [];
+  const totals = emptyTotals();
+  const byProjectTotals = {};
+  const byModelTotals = {};
+  const toolsByProject = {};
+
+  const sortedDates = Array.from(daysMap.keys()).sort();
+  for (const date of sortedDates) {
+    const projMap = daysMap.get(date);
+    const byProject = {};
+    for (const [projectDir, row] of projMap) {
+      const rowWithCost = computeRowCost(row);
+      byProject[projectDir] = rowWithCost;
+      addRowToTotals(totals, rowWithCost);
+
+      if (!byProjectTotals[projectDir]) byProjectTotals[projectDir] = emptyTotals();
+      addRowToTotals(byProjectTotals[projectDir], rowWithCost);
+
+      if (!toolsByProject[projectDir]) toolsByProject[projectDir] = {};
+      for (const [tool, cnt] of Object.entries(row.toolBreakdown)) {
+        toolsByProject[projectDir][tool] = (toolsByProject[projectDir][tool] ?? 0) + cnt;
+      }
+
+      for (const [modelId, mb] of Object.entries(rowWithCost.byModel)) {
+        const dst = byModelTotals[modelId] ?? (byModelTotals[modelId] = {
+          inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, costUsd: 0,
+        });
+        dst.inputTokens += mb.inputTokens;
+        dst.outputTokens += mb.outputTokens;
+        dst.cacheReadTokens += mb.cacheReadTokens;
+        dst.cacheCreationTokens += mb.cacheCreationTokens;
+        dst.costUsd += mb.costUsd;
+        if (mb.estimated) dst.estimated = true;
+      }
+    }
+    days.push({ date, byProject });
+  }
+
+  const prevTotals = emptyTotals();
+  addRowToTotals(prevTotals, computeRowCost(prevRow));
+
+  const provisionalDates = sortedDates.filter((d) => !finalizedDates.has(d));
+
+  return {
+    from,
+    to,
+    days,
+    prevTotals,
+    totals,
+    byProjectTotals,
+    byModelTotals,
+    toolsByProject,
+    generatedAt: Date.now(),
+    provisionalDates,
+  };
+}
+
+function registerHistoryDashboardHandlers() {
+  ipcMain.handle('history:dashboard', async (_e, rawReq) => {
+    const parsed = schemas.historyDashboard.safeParse(rawReq);
+    const req = parsed.success ? parsed.data : { rangeDays: 30 };
+    return computeDashboard(req);
+  });
+}
+
+module.exports = {
+  registerHistoryDashboardHandlers,
+  computeDashboard,
+};

package/src/main/index.cjs

@@ -41,13 +41,17 @@ const pluginInstall = require('./pluginInstall.cjs');
 const { seedDevPlugin } = require('./seedDevPlugin.cjs');
 const otel = require('./otel.cjs');
 const otelSettings = require('./otelSettings.cjs');
-const { registerHistoryAggregatorHandlers } = require('./historyAggregator.cjs');
+const { registerHistoryAggregatorHandlers, finalizeClosedDays, refreshIntradayToday } = require('./historyAggregator.cjs');
+const { registerHistoryDashboardHandlers } = require('./historyDashboard.cjs');
+const { tryAcquireLock, releaseLock, DEFAULT_LOCK_PATH } = require('../../scripts/lib/watchdogHelpers.cjs');
+const schedulerConfig = require('./lib/schedulerConfig.cjs');
 const memoryTool = require('./memoryTool.cjs');
 const { registerMemoryAggregateIpc } = require('./memoryAggregate.cjs');
 const agentMemory = require('./agentMemory.cjs');
 const git = require('./git.cjs');
 const superagent = require('./superagent.cjs');
 const filesIpc = require('./files.cjs');
+const { registerDocEditHandlers } = require('./docEdit.cjs');
 const searchIpc = require('./search.cjs');
 const repoAnalyzer = require('./repoAnalyzer.cjs');
 const hivesIpc = require('./hives.cjs');
@@ -150,6 +154,20 @@ ipcMain.handle = function trackedHandle(channel, listener) {
 
 const REBOOT_LOG = path.join(os.homedir(), '.claude', 'session-manager-reboot.log');
 
+// Guards refreshIntradayToday() with the same O_EXCL lock file the external
+// watchdog's finalize pass uses, so an in-app refresh tick and an offline
+// finalize pass never interleave writes to the rollup file. A contended lock
+// just means this tick is skipped — the next timer tick (or the next boot)
+// retries, so skipping is always safe.
+function runIntradayRefresh() {
+  if (!tryAcquireLock(DEFAULT_LOCK_PATH)) return;
+  refreshIntradayToday()
+    .catch((e) => {
+      logs.writeLine({ scope: 'history-rollup', level: 'error', message: 'refreshIntradayToday failed', meta: { error: e?.message } });
+    })
+    .finally(() => releaseLock(DEFAULT_LOCK_PATH));
+}
+
 function logReboot(line) {
   try {
     fs.mkdirSync(path.dirname(REBOOT_LOG), { recursive: true });
@@ -742,6 +760,7 @@ watchers.registerWatcherHandlers();
 teams.registerTeamsHandlers();
 queueOps.registerQueueOpsHandlers();
 registerHistoryAggregatorHandlers();
+registerHistoryDashboardHandlers();
 pluginInstall.registerPluginInstallHandlers();
 memoryTool.registerMemoryHandlers();
 registerMemoryAggregateIpc();
@@ -749,6 +768,7 @@ agentMemory.registerAgentMemoryHandlers();
 git.register(ipcMain);
 superagent.registerSuperAgentHandlers();
 filesIpc.registerFilesHandlers();
+registerDocEditHandlers();
 searchIpc.registerSearchHandlers();
 repoAnalyzer.register(ipcMain);
 hivesIpc.registerHiveHandlers();
@@ -1078,6 +1098,22 @@ app.whenReady().then(async () => {
   webRemote.init().catch((e) => {
     logs.writeLine({ scope: 'webRemote', level: 'error', message: 'init failed', meta: { error: e?.message } });
   });
+  // History rollup finalize pass: deferred 30s past boot so it never competes
+  // with first-paint, fire-and-forget (cron/offline refresh is PRD 651 — this
+  // is just the one-shot in-app pass).
+  setTimeout(() => {
+    finalizeClosedDays().catch((e) => {
+      logs.writeLine({ scope: 'history-rollup', level: 'error', message: 'finalizeClosedDays failed', meta: { error: e?.message } });
+    });
+    runIntradayRefresh();
+  }, 30_000);
+  // Keep TODAY's rollup line current so the History dashboard never needs to
+  // fall back to a live transcript scan. Shares the same O_EXCL lock file as
+  // the external watchdog's finalize pass (scripts/lib/watchdogHelpers.cjs)
+  // so the two never interleave writes to the rollup; a contended lock just
+  // means this tick's refresh is skipped (harmless — the next tick retries).
+  const intradayTimer = setInterval(runIntradayRefresh, schedulerConfig.HISTORY_INTRADAY_REFRESH_MS);
+  if (intradayTimer.unref) intradayTimer.unref();
   // Keep the machine awake while the app is open. The scheduler polls billing
   // usage every 2 min and runs `claude -p` jobs that must survive an idle
   // laptop — a system suspend (GNOME/Pop!_OS idle or lid timeout) would freeze

package/src/main/ipcSchemas.cjs

@@ -351,6 +351,14 @@ const memoryCreate = z.object({
   description: z.string().max(2048).optional(),
 }).strict();
 
+// memory:stale — deterministic staleness scorer (PRD 601). `cwd`, when given,
+// is only used for the dead-ref existence check and is re-validated via
+// config.validatePath in memoryTool.cjs before use.
+const memoryStale = z.object({
+  workspace: z.string().regex(MEMORY_WORKSPACE_RE).optional(),
+  cwd: z.string().max(4096).optional(),
+}).strict();
+
 // memory:aggregate — Memory Clusters (PRD 356). `workspace` here is already
 // the encoded cwd slug (memoryAggregate.cjs reads directly from
 // ~/.claude/projects/<workspace>/memory/), same regex as the other memory:*
@@ -401,6 +409,19 @@ const exchangesList = z.object({
   offset: z.number().int().min(0).max(100000).optional(),
 }).strict();
 
+// ──────────────────────────────────────────── Files (duplicate)
+// files:duplicate — the rest of files:* keeps its schemas local to files.cjs;
+// this one lives here per PRD 638 so it's reusable without importing files.cjs.
+const filesDuplicate = z.object({ path: z.string().min(1).max(4096) });
+
+// ──────────────────────────────────────────── Doc Edit (PRD 638 rewrite runner)
+// docedit:run — consumed by docEdit.cjs's registerDocEditHandlers.
+const docEditRun = z.object({
+  path: z.string().min(1).max(4096),
+  before: z.string().min(1).max(8000),
+  instruction: z.string().min(1).max(2000),
+}).strict();
+
 // ──────────────────────────────────────────── Chat runner (PRD 319)
 // Prompt cap: 100 KiB. Matches a generous interactive message budget while
 // preventing accidental megabyte pastes from reaching claude -p.
@@ -453,6 +474,10 @@ const historyAggregate = z.object({
   toDate: z.string().regex(DATE_YYYY_MM_DD).optional(),
 }).nullish();
 
+const historyDashboard = z.object({
+  rangeDays: z.union([z.literal(30), z.literal(60), z.literal(90), z.literal(0)]),
+}).strict();
+
 // ──────────────────────────────────────────── Voice (F1/F5/F7/F8)
 // Mirrors voiceSettings.cjs isValidConfig / isValidDevicePref / isValid…
 // validators (ad-hoc on disk). Schemas here gate the IPC boundary so a
@@ -686,6 +711,7 @@ module.exports = {
     shellOpen,
     archiveProject,
     historyAggregate,
+    historyDashboard,
     voiceSetHotkey,
     voiceSetDevicePref,
     voiceSetTurnDetector,
@@ -705,6 +731,7 @@ module.exports = {
     memoryDelete,
     memoryCreate,
     memoryAggregate,
+    memoryStale,
     agentMemoryList,
     agentMemoryGet,
     agentMemorySet,
@@ -713,6 +740,8 @@ module.exports = {
     watchersList,
     watchersRemove,
     watchersKillTab,
+    filesDuplicate,
+    docEditRun,
     chatRun,
     chatCancel,
     chatProbeContext,

package/src/main/lib/broadcastCoalescer.cjs

@@ -0,0 +1,46 @@
+'use strict';
+
+/**
+ * Trailing-edge debounce for a broadcast send. `schedule()` arms a timer on
+ * the first call; further calls before it fires are no-ops — they do NOT
+ * reset the timer (this is a fixed coalescing window, not an inactivity
+ * debounce). When the timer fires, `getPayload()` is invoked fresh so the
+ * sent payload reflects every mutation that happened during the window, not
+ * just the one that armed it. `flush()` cancels any pending timer and sends
+ * immediately, for callers where latency matters more than coalescing.
+ */
+function createBroadcastCoalescer({ delayMs, send, getPayload }) {
+  let timer = null;
+
+  async function fire() {
+    timer = null;
+    try {
+      const payload = await getPayload();
+      send(payload);
+    } catch (e) {
+      // Self-heals: the next schedule()/flush() call arms a fresh timer/send
+      // since `timer` is already null. Log so a persistent getPayload()
+      // failure (e.g. a corrupt queue.json) isn't silently invisible.
+      console.error('[broadcastCoalescer] fire() failed', e?.message ?? e);
+    }
+  }
+
+  function schedule() {
+    if (timer) return;
+    timer = setTimeout(() => { fire(); }, delayMs);
+    if (timer && typeof timer.unref === 'function') timer.unref();
+  }
+
+  async function flush() {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    const payload = await getPayload();
+    send(payload);
+  }
+
+  return { schedule, flush };
+}
+
+module.exports = { createBroadcastCoalescer };

package/src/main/lib/historyRollup.cjs

@@ -0,0 +1,148 @@
+/**
+ * Durable daily history rollup — persists per (localDate, projectDir, modelId)
+ * scalar aggregates to `~/.claude/session-manager/history-rollup.jsonl` so
+ * closed (pre-today) History dashboard days survive an Electron restart and
+ * transcript retention/cleanup, instead of being recomputed from raw .jsonl
+ * transcripts every cold start.
+ *
+ * Storage shape: one JSON line per bucket. Lines are append-only; the latest
+ * line for a given key wins (last-write-wins), so backfill/re-finalize simply
+ * appends a corrected line rather than rewriting history. The file is
+ * compacted (deduped + rewritten) once it exceeds COMPACT_THRESHOLD_BYTES.
+ *
+ * Two kinds of lines share the same shape:
+ *   - totals line   (modelId === TOTALS_MODEL_ID ''): promptCount,
+ *     toolCallCount, toolBreakdown, errorCount, sessionCount are populated;
+ *     token fields are 0. One per (date, projectDir).
+ *   - per-model line (modelId === a real model id): inputTokens,
+ *     outputTokens, cacheReadTokens, cacheCreationTokens are populated; the
+ *     rest are 0/empty. Cost is NOT stored — it's computed at read time from
+ *     MODEL_PRICING so a pricing fix retroactively corrects displayed cost.
+ *   - finalized marker (projectDir === '', modelId === FINALIZED_MODEL_ID):
+ *     one per date, carries only `finalizedAt`. A date only counts as closed
+ *     (safe to trust the rollup with no live re-scan) once this exists.
+ */
+
+'use strict';
+
+const path = require('node:path');
+const os = require('node:os');
+const config = require('../config.cjs');
+
+const ROLLUP_PATH = path.join(os.homedir(), '.claude', 'session-manager', 'history-rollup.jsonl');
+const COMPACT_THRESHOLD_BYTES = 5 * 1024 * 1024;
+
+const TOTALS_MODEL_ID = '';
+const FINALIZED_MODEL_ID = '__finalized__';
+const FINALIZED_PROJECT_ID = '';
+// Bumped when a bucket/finalized-marker line's shape changes in a way that
+// requires re-deriving it from transcripts (v1 → v2 added `activeMinutes`).
+// isDateFinalized() gates on this so old-shape finalized days get re-scanned
+// by the existing finalizeClosedDays() budget/resume loop instead of a new
+// migration path.
+const ROLLUP_VERSION = 2;
+
+function rollupKey(date, projectDir, modelId) {
+  return `${date}|${projectDir}|${modelId}`;
+}
+
+/**
+ * Merge JSONL lines into a Map<key, bucket>, last-write-wins per rollupKey.
+ * Malformed lines are skipped rather than throwing, so one corrupt line
+ * doesn't take down the whole rollup.
+ */
+function mergeRollupLines(lines) {
+  const map = new Map();
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line) continue;
+    let obj;
+    try { obj = JSON.parse(line); } catch { continue; }
+    if (!obj || typeof obj.date !== 'string') continue;
+    const projectDir = typeof obj.projectDir === 'string' ? obj.projectDir : '';
+    const modelId = typeof obj.modelId === 'string' ? obj.modelId : '';
+    // v1 lines predate activeMinutes — default so every reader sees a number.
+    if (typeof obj.activeMinutes !== 'number') obj.activeMinutes = 0;
+    map.set(rollupKey(obj.date, projectDir, modelId), obj);
+  }
+  return map;
+}
+
+/**
+ * Read all rollup lines and return the merged buckets whose `date` falls
+ * within [fromDate, toDate] inclusive (both are localDate 'YYYY-MM-DD'
+ * strings). Finalized-marker lines are included in the result — callers that
+ * only want data lines should filter on modelId/projectDir.
+ */
+async function readRollup(fromDate, toDate) {
+  const { exists, text } = await config.readText(ROLLUP_PATH);
+  if (!exists || !text) return new Map();
+  const merged = mergeRollupLines(text.split('\n'));
+  const filtered = new Map();
+  for (const [key, bucket] of merged) {
+    if (bucket.date >= fromDate && bucket.date <= toDate) filtered.set(key, bucket);
+  }
+  return filtered;
+}
+
+/**
+ * True if `date` (< today, by convention) has a finalized marker on disk
+ * written at ROLLUP_VERSION or later. A marker written under an older schema
+ * (no `v`, or v < ROLLUP_VERSION) is treated as NOT finalized so the existing
+ * finalizeClosedDays() budget/resume pass re-scans and upgrades it in place —
+ * no separate migration machinery needed.
+ */
+function isDateFinalized(mergedMap, date) {
+  const bucket = mergedMap.get(rollupKey(date, FINALIZED_PROJECT_ID, FINALIZED_MODEL_ID));
+  if (!bucket?.finalizedAt) return false;
+  return (bucket.v ?? 1) >= ROLLUP_VERSION;
+}
+
+/**
+ * Append bucket entries (append-only) to the rollup file, then compact
+ * (dedupe + rewrite) if the file has grown past COMPACT_THRESHOLD_BYTES.
+ * Uses config.cjs's validatePath/validateWrite for boundary safety and
+ * writeTextAtomic (tmp + rename) for the compaction rewrite — never hand
+ * rolls its own atomic-write scheme.
+ */
+async function appendRollupDays(entries) {
+  if (!entries || entries.length === 0) return;
+
+  const real = config.validatePath(ROLLUP_PATH);
+  config.validateWrite(real);
+  const fsp = require('node:fs/promises');
+  await fsp.mkdir(path.dirname(real), { recursive: true });
+
+  const lines = entries.map((e) => JSON.stringify(e)).join('\n') + '\n';
+  await fsp.appendFile(real, lines, 'utf8');
+
+  let size = 0;
+  try { size = (await fsp.stat(real)).size; } catch { /* just wrote it */ }
+  if (size > COMPACT_THRESHOLD_BYTES) {
+    await compact();
+  }
+}
+
+/** Dedupe the rollup file down to its last-write-wins merged lines. */
+async function compact() {
+  const { exists, text } = await config.readText(ROLLUP_PATH);
+  if (!exists || !text) return;
+  const merged = mergeRollupLines(text.split('\n'));
+  const rewritten = Array.from(merged.values()).map((b) => JSON.stringify(b)).join('\n') + '\n';
+  await config.writeTextAtomic(ROLLUP_PATH, rewritten);
+}
+
+module.exports = {
+  ROLLUP_PATH,
+  COMPACT_THRESHOLD_BYTES,
+  TOTALS_MODEL_ID,
+  FINALIZED_MODEL_ID,
+  FINALIZED_PROJECT_ID,
+  ROLLUP_VERSION,
+  rollupKey,
+  mergeRollupLines,
+  readRollup,
+  isDateFinalized,
+  appendRollupDays,
+  compact,
+};

package/src/main/lib/memoryStale.cjs

@@ -0,0 +1,116 @@
+'use strict';
+
+/**
+ * Pure, deterministic staleness scorer for workspace memories. No fs/electron
+ * access — all IO is injected via `entries` (pre-read) and `existsPath`
+ * (predicate), so this module is unit-testable with zero mocking.
+ */
+
+const DAY_MS = 86_400_000;
+const AGE_STALE_DAYS = 90;
+const MAX_DEAD_REF_CANDIDATES = 20;
+
+const WIKILINK_RE = /\[\[([^\]]+)\]\]/g;
+// Backtick-quoted repo-path-shaped tokens, optionally suffixed with a :line.
+const PATH_TOKEN_RE = /`([A-Za-z0-9_./-]+\.[A-Za-z0-9]{1,5}(?::\d+)?)`/g;
+
+const KNOWN_SOURCE_EXTENSIONS = new Set([
+  'js', 'jsx', 'ts', 'tsx', 'cjs', 'mjs', 'json', 'md', 'py', 'rb', 'go', 'rs',
+  'java', 'c', 'h', 'cpp', 'hpp', 'css', 'scss', 'html', 'yml', 'yaml', 'sh',
+  'txt', 'toml', 'lock', 'sql', 'php', 'swift', 'kt', 'vue',
+]);
+
+function stripName(name) {
+  return name.replace(/\.md$/, '');
+}
+
+/**
+ * Extract dead-ref candidate paths from a memory body.
+ * Complexity: O(body length) — one regex pass, then O(candidates) filtering.
+ */
+function extractCandidates(body) {
+  const seen = new Set();
+  const out = [];
+  let m;
+  PATH_TOKEN_RE.lastIndex = 0;
+  while ((m = PATH_TOKEN_RE.exec(body)) !== null) {
+    if (out.length >= MAX_DEAD_REF_CANDIDATES) break;
+    let token = m[1].replace(/:\d+$/, '');
+    if (token.startsWith('/') || token.startsWith('~')) continue; // not repo-relative
+    const ext = token.includes('.') ? token.split('.').pop().toLowerCase() : '';
+    const hasSlash = token.includes('/');
+    if (!hasSlash && !KNOWN_SOURCE_EXTENSIONS.has(ext)) continue;
+    if (seen.has(token)) continue;
+    seen.add(token);
+    out.push(token);
+  }
+  return out;
+}
+
+/**
+ * scoreMemories({ entries, now, existsPath })
+ *
+ * entries: Array<{ name, mtimeMs, body }>
+ * now: ms epoch
+ * existsPath: (relPath: string) => boolean
+ *
+ * Complexity: O(total body bytes) — a single pass per entry to extract
+ * wikilink targets and dead-ref candidates; the inbound-link fold is
+ * O(entries + total links), NOT O(n^2) substring scans.
+ */
+function scoreMemories({ entries, now, existsPath }) {
+  // Signal 2 (pass 1): per-entry set of wikilink targets, deduped so repeated
+  // links to the same slug within one body count once toward that slug's
+  // inbound count.
+  const perEntryTargets = entries.map((e) => {
+    const targets = new Set();
+    let m;
+    WIKILINK_RE.lastIndex = 0;
+    while ((m = WIKILINK_RE.exec(e.body)) !== null) {
+      targets.add(m[1].trim());
+    }
+    return targets;
+  });
+
+  const inboundCounts = new Map();
+  entries.forEach((e, i) => {
+    const selfSlug = stripName(e.name);
+    for (const target of perEntryTargets[i]) {
+      if (target === selfSlug) continue; // a memory linking itself isn't an inbound reference
+      inboundCounts.set(target, (inboundCounts.get(target) || 0) + 1);
+    }
+  });
+
+  return entries.map((e) => {
+    const ageDays = Math.floor((now - e.mtimeMs) / DAY_MS);
+    const slug = stripName(e.name);
+    const inboundLinks = inboundCounts.get(slug) || 0;
+
+    const candidates = extractCandidates(e.body);
+    const deadRefs = candidates.filter((c) => !existsPath(c));
+
+    const reasons = [];
+    if (deadRefs.length > 0) {
+      reasons.push(
+        deadRefs.length === 1
+          ? 'references 1 path that no longer exists'
+          : `references ${deadRefs.length} paths that no longer exist`
+      );
+    }
+    const oldAndUnlinked = ageDays > AGE_STALE_DAYS && inboundLinks === 0;
+    if (oldAndUnlinked) {
+      reasons.push('90+ days old with no inbound links');
+    }
+
+    return {
+      name: e.name,
+      ageDays,
+      inboundLinks,
+      deadRefs,
+      stale: deadRefs.length > 0 || oldAndUnlinked,
+      reasons,
+    };
+  });
+}
+
+module.exports = { scoreMemories };