claude-code-session-manager 0.21.1 → 0.21.3

package/src/main/transcripts.cjs

@@ -43,6 +43,44 @@ function transcriptPath(cwd, sessionUuid) {
   return path.join(os.homedir(), '.claude', 'projects', encodeCwd(cwd), `${sessionUuid}.jsonl`);
 }
 
+const MAX_RAW_STR = 4096;
+
+// Block types whose text/content fields are parsed structurally by
+// orchestrator.ts / race.ts — truncating them produces mid-token "…" and
+// unparseable JSON, so they are exempt from the size cap.
+const EXEMPT_TYPES = new Set(['tool_result', 'tool_use']);
+
+/**
+ * Cap string fields in a content block array so arbitrary tool output doesn't
+ * bloat the ring buffer. Blocks whose type is in EXEMPT_TYPES are passed
+ * through intact so that structured result payloads survive to the digest
+ * parsers in race.ts / orchestrator.ts.
+ */
+function trimContentArray(content) {
+  if (!Array.isArray(content)) return content;
+  return content.map((block) => {
+    if (!block || typeof block !== 'object') return block;
+    if (EXEMPT_TYPES.has(block.type)) return block;
+    const b = { ...block };
+    if (typeof b.text === 'string' && b.text.length > MAX_RAW_STR) {
+      b.text = b.text.slice(0, MAX_RAW_STR) + '…';
+    }
+    if (typeof b.content === 'string' && b.content.length > MAX_RAW_STR) {
+      b.content = b.content.slice(0, MAX_RAW_STR) + '…';
+    }
+    if (Array.isArray(b.content)) {
+      b.content = trimContentArray(b.content);
+    }
+    return b;
+  });
+}
+
+/** Build the slim raw projection used by race.ts and orchestrator.ts. */
+function makeRaw(obj) {
+  const msgContent = obj?.message?.content;
+  return { message: { content: trimContentArray(msgContent) } };
+}
+
 /**
  * Parse one JSONL line defensively. Real schema drifts, so we pass through
  * anything that parses and tag a coarse `kind`.
@@ -56,7 +94,7 @@ function classifyLine(obj) {
 
   // Usage rollups arrive as summary events.
   if (obj.usage || msg?.usage) {
-    return { kind: 'usage', data: obj.usage || msg.usage, raw: obj };
+    return { kind: 'usage', data: obj.usage || msg.usage, raw: makeRaw(obj) };
   }
 
   // Tool uses: scan content array for tool_use blocks.
@@ -64,31 +102,31 @@ function classifyLine(obj) {
     for (const block of content) {
       if (block?.type === 'tool_use') {
         if (block.name === 'TodoWrite') {
-          return { kind: 'todo_write', data: block.input?.todos || block.input || [], raw: obj };
+          return { kind: 'todo_write', data: block.input?.todos || block.input || [], raw: makeRaw(obj) };
         }
         if (block.name === 'ExitPlanMode' || block.name === 'EnterPlanMode') {
-          return { kind: 'plan', data: block.input, raw: obj };
+          return { kind: 'plan', data: block.input, raw: makeRaw(obj) };
         }
         if (block.name === 'Agent' || block.name === 'Task') {
           // Include block.id as toolUseId so the live store can match the
           // corresponding tool_result and update per-agent lastActivityAt.
-          return { kind: 'agent_spawn', data: { ...block.input, toolUseId: block.id }, raw: obj };
+          return { kind: 'agent_spawn', data: { ...block.input, toolUseId: block.id }, raw: makeRaw(obj) };
         }
         return {
           kind: 'tool_use',
           data: { name: block.name, input: block.input, id: block.id },
-          raw: obj,
+          raw: makeRaw(obj),
         };
       }
       // tool_result carries the tool_use_id of the completed Task/Agent call.
       // The live store uses this to update the agent's lastActivityAt bookend.
       if (block?.type === 'tool_result' && block.tool_use_id) {
-        return { kind: 'tool_result', data: { toolUseId: block.tool_use_id }, raw: obj };
+        return { kind: 'tool_result', data: { toolUseId: block.tool_use_id }, raw: makeRaw(obj) };
       }
     }
   }
 
-  return { kind: type || 'message', data: obj, raw: obj };
+  return { kind: type || 'message', data: obj, raw: makeRaw(obj) };
 }
 
 /**
@@ -129,7 +167,7 @@ async function readDelta(sub) {
   }
 }
 
-async function flush(sub, { emit = true } = {}) {
+async function doFlush(sub, { emit = true, replay = false } = {}) {
   const lines = await readDelta(sub);
   for (const line of lines) {
     let obj;
@@ -150,6 +188,7 @@ async function flush(sub, { emit = true } = {}) {
       cwd: sub.cwd,
       sessionUuid: sub.sessionUuid,
       ev,
+      replay,
     });
     if (emit) sendIfAlive(window, `transcript:event:${sub.tabId}`, ev);
     // Mirror to OTEL — no-op when disabled. We emit on the initial drain too
@@ -164,10 +203,86 @@ async function flush(sub, { emit = true } = {}) {
   }
 }
 
+// Serialised flush scheduler — at most one readDelta per sub in flight at a
+// time. Uses a dirty flag for trailing-edge re-run: if a chokidar event fires
+// while a flush is in progress, dirty stays true and the loop runs one more
+// time after the current read completes, guaranteeing no event is dropped.
+function scheduleFlush(sub) {
+  sub.dirty = true;
+  if (sub.flushing) return sub.flushing;
+  sub.flushing = (async () => {
+    while (sub.dirty) {
+      sub.dirty = false;
+      await doFlush(sub);
+    }
+  })()
+    .catch((e) => {
+      logs.writeLine({ level: 'warn', scope: 'transcripts', message: 'flush error', meta: { error: e?.message } });
+    })
+    .finally(() => {
+      sub.flushing = null;
+    });
+  return sub.flushing;
+}
+
 const MAX_TRANSCRIPT_SUBS = 20;
 
+/**
+ * LRU pool of released-but-cached subscriptions. When a renderer consumer
+ * calls release(), the sub stays alive (offset + buffer preserved) so a
+ * subsequent tab-switch back resumes from the current offset instead of
+ * re-reading the entire transcript from byte 0. Oldest entries are evicted
+ * once the pool exceeds LRU_CAP.
+ */
+const LRU_CAP = 6;
+const lruReleased = []; // tabIds with no active consumer, ordered oldest→newest
+
+function _closeSub(tabId) {
+  const sub = subs.get(tabId);
+  if (!sub) return;
+  sub.watcher?.close().catch(() => {});
+  subs.delete(tabId);
+  usageMatrix.removeTab(tabId);
+  const i = lruReleased.indexOf(tabId);
+  if (i !== -1) lruReleased.splice(i, 1);
+}
+
+/**
+ * release(tabId) — called when the renderer's last consumer unmounts (view
+ * switch). Keeps the sub alive in the LRU cache so a quick revisit resumes
+ * from the persisted offset. Evicts the oldest cached sub if over LRU_CAP.
+ */
+function release(tabId) {
+  if (!subs.has(tabId)) return;
+  if (!lruReleased.includes(tabId)) {
+    lruReleased.push(tabId);
+  }
+  while (lruReleased.length > LRU_CAP) {
+    const oldest = lruReleased.shift();
+    _closeSub(oldest);
+  }
+}
+
+/** closeTab(tabId) — genuine tab close; always destroys the sub immediately. */
+function closeTab(tabId) {
+  _closeSub(tabId);
+}
+
 async function subscribe({ tabId, cwd, sessionUuid }) {
-  if (subs.has(tabId)) return { ok: true, path: subs.get(tabId).filePath };
+  if (subs.has(tabId)) {
+    // Tab is in the LRU cache — promote it back to active.
+    const i = lruReleased.indexOf(tabId);
+    if (i !== -1) lruReleased.splice(i, 1);
+    return { ok: true, path: subs.get(tabId).filePath };
+  }
+  if (subs.size >= MAX_TRANSCRIPT_SUBS) {
+    // Before rejecting a genuinely new subscription, evict an idle LRU-cached
+    // entry — it occupies a slot but has no active consumer. Only reject if no
+    // idle entries are available to free.
+    if (lruReleased.length > 0) {
+      _closeSub(lruReleased[0]);
+    }
+  }
   if (subs.size >= MAX_TRANSCRIPT_SUBS) {
     logs.writeLine({
       level: 'warn',
@@ -189,34 +304,33 @@ async function subscribe({ tabId, cwd, sessionUuid }) {
     pending: '',
     buffer: [],
     watcher: null,
+    flushing: null,
+    dirty: false,
   };
   // If the file already exists, read current content as replay. Do not emit
   // during this initial drain — the renderer drains sub.buffer via
   // `transcript:buffer` after `transcript:subscribe` resolves. Emitting here
   // would race the renderer's onEvent listener registration and drop events.
+  // replay:true prevents historical usage events from entering the 5-min window.
   if (fs.existsSync(filePath)) {
-    await flush(sub, { emit: false });
+    await doFlush(sub, { emit: false, replay: true });
   }
   const watcher = chokidar.watch(filePath, {
     ignoreInitial: false,
     persistent: true,
     awaitWriteFinish: { stabilityThreshold: 30, pollInterval: 20 },
   });
-  watcher.on('add', () => flush(sub).catch(() => {}));
-  watcher.on('change', () => flush(sub).catch(() => {}));
+  watcher.on('add', () => scheduleFlush(sub));
+  watcher.on('change', () => scheduleFlush(sub));
   watcher.on('error', (err) => logs.writeLine({ level: 'warn', scope: 'transcripts', message: 'chokidar watcher error', meta: { error: err?.message } }));
   sub.watcher = watcher;
   subs.set(tabId, sub);
   return { ok: true, path: filePath };
 }
 
+/** @deprecated Use release() for view-switch, closeTab() for genuine close. */
 function unsubscribe(tabId) {
-  const sub = subs.get(tabId);
-  if (!sub) return;
-  sub.watcher?.close().catch(() => {});
-  subs.delete(tabId);
-  // Drop the tab from the AgOps matrix — "active sessions" only.
-  usageMatrix.removeTab(tabId);
+  release(tabId);
 }
 
 function getBuffer(tabId) {
@@ -233,8 +347,14 @@ function closeAll() {
 function registerTranscriptHandlers() {
   const { schemas: s, validated: v } = require('./ipcSchemas.cjs');
   ipcMain.handle('transcript:subscribe', v(s.transcriptSubscribe, (payload) => subscribe(payload)));
+  // transcript:unsubscribe is now an alias for release (view-switch, not close).
   ipcMain.handle('transcript:unsubscribe', v(s.transcriptTabId, ({ tabId }) => {
-    unsubscribe(tabId);
+    release(tabId);
+    return { ok: true };
+  }));
+  // transcript:close is the genuine close used when a tab is removed.
+  ipcMain.handle('transcript:close', v(s.transcriptTabId, ({ tabId }) => {
+    closeTab(tabId);
     return { ok: true };
   }));
   ipcMain.handle('transcript:buffer', v(s.transcriptTabId, ({ tabId }) => getBuffer(tabId)));
@@ -245,6 +365,8 @@ module.exports = {
   attachWindow,
   registerTranscriptHandlers,
   closeAll,
+  release,
+  closeTab,
   encodeCwd,
   transcriptPath,
   classifyLine,

package/src/main/usageMatrix.cjs

@@ -85,7 +85,7 @@ function ensureTab(tabId, cwd, sessionUuid) {
  * Feed one classified transcript event into the per-tab aggregator. Called
  * from transcripts.cjs for every event, both during replay and live.
  */
-function recordEvent({ tabId, cwd, sessionUuid, ev }) {
+function recordEvent({ tabId, cwd, sessionUuid, ev, replay = false }) {
   if (!tabId || !ev) return;
   const t = ensureTab(tabId, cwd, sessionUuid);
   const now = Date.now();
@@ -109,8 +109,12 @@ function recordEvent({ tabId, cwd, sessionUuid, ev }) {
       t.perTurnInputTokens.push(inTok);
       if (t.perTurnInputTokens.length > TURN_RING) t.perTurnInputTokens.shift();
 
-      t.tokenWindow.push({ ts: now, tokens: inTok + outTok });
-      pruneWindow(t.tokenWindow, now);
+      // Historical events must not enter the 5-min sliding window — doing so
+      // would make tokensPerMin spike to "critical" on every tab switch.
+      if (!replay) {
+        t.tokenWindow.push({ ts: now, tokens: inTok + outTok });
+        pruneWindow(t.tokenWindow, now);
+      }
       dirty = true;
       break;
     }