claude-code-session-manager 0.39.4 → 0.40.1

package/src/main/transcripts.cjs

@@ -262,6 +262,77 @@ function getBuffer(tabId) {
   return sub ? sub.buffer.slice() : [];
 }
 
+// Cap on the transcript file we'll fully re-read for a token-usage summary —
+// protects against OOM on a pathologically large transcript. Sessions over
+// this size report null (omitted by the renderer) rather than a partial sum.
+const MAX_USAGE_FILE_BYTES = 64 * 1024 * 1024;
+
+/** Map<filePath, { mtimeMs, size, usage: {inputTokens, outputTokens} }> */
+const usageCache = new Map();
+
+/**
+ * Sum `usage` events out of one session's JSONL transcript — same
+ * classifyLine()/field-name resolution live.ts's ingest uses for its running
+ * per-tab totals (input_tokens/output_tokens, snake_case on the wire).
+ * Cached by file mtime so repeat calls for an unchanged transcript are a
+ * single fs.stat.
+ */
+async function usageForOne(filePath) {
+  const stat = await fsp.stat(filePath).catch(() => null);
+  if (!stat) return null;
+  const cached = usageCache.get(filePath);
+  if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+    return cached.usage;
+  }
+  if (stat.size > MAX_USAGE_FILE_BYTES) {
+    logs.writeLine({
+      level: 'warn',
+      scope: 'transcripts',
+      message: 'usageForOne: transcript too large, skipping',
+      meta: { filePath, size: stat.size },
+    });
+    return null;
+  }
+  const text = await fsp.readFile(filePath, 'utf8').catch(() => null);
+  if (text === null) return null;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  for (const line of text.split('\n')) {
+    if (!line) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const ev = classifyLine(obj);
+    if (!ev || ev.kind !== 'usage') continue;
+    const u = ev.data || {};
+    inputTokens += u.input_tokens ?? u.inputTokens ?? 0;
+    outputTokens += u.output_tokens ?? u.outputTokens ?? 0;
+  }
+  const usage = { inputTokens, outputTokens };
+  usageCache.set(filePath, { mtimeMs: stat.mtimeMs, size: stat.size, usage });
+  return usage;
+}
+
+/**
+ * Batched token-usage lookup for the Epics workspace — one IPC call per
+ * visible set of Epics rather than a per-row round trip. Returns a map keyed
+ * by sessionId; a session with no transcript file yet (or one over the size
+ * cap) maps to null so callers can omit it rather than showing "0".
+ */
+async function usageFor(cwd, sessionIds) {
+  const out = {};
+  await Promise.all(
+    sessionIds.map(async (sessionId) => {
+      const filePath = transcriptPath(cwd, sessionId);
+      out[sessionId] = await usageForOne(filePath);
+    }),
+  );
+  return out;
+}
+
 function closeAll() {
   for (const sub of subs.values()) sub.watcher?.close().catch(() => {});
   subs.clear();
@@ -282,6 +353,7 @@ function registerTranscriptHandlers() {
   }));
   ipcMain.handle('transcript:buffer', v(s.transcriptTabId, ({ tabId }) => getBuffer(tabId)));
   ipcMain.handle('transcript:path', v(s.transcriptPath, ({ cwd, sessionUuid }) => transcriptPath(cwd, sessionUuid)));
+  ipcMain.handle('transcript:usageFor', v(s.transcriptUsageFor, ({ cwd, sessionIds }) => usageFor(cwd, sessionIds)));
 }
 
 module.exports = {
@@ -293,4 +365,5 @@ module.exports = {
   encodeCwd,
   transcriptPath,
   classifyLine,
+  usageFor,
 };

package/src/preload/api.d.ts

@@ -398,16 +398,22 @@ export interface ScheduleJob {
    */
   verifierVerdict?: string;
   /** Per-job values carried in queue.json for dependency checking. */
+  /** Explicit cross-PRD ordering (PRD 832): slugs that must complete before
+   *  this job is eligible. Replaces the retired shared-NN-parallel convention. */
   dependsOn?: string[];
+  /** The originating claude session — the Epic's claudeSessionId, resolved
+   *  from active-index.json at ingest (PRD 832). An Epic IS a tagged session. */
+  originSessionId?: string | null;
   /** Originating tab id (PRD frontmatter `sourceTabId`), refreshed from the
    *  PRD file on every reconcile. When the PRD was authored from inside a
    *  PromptSessionConversation, this equals that PromptSession's own id
    *  (its chat key) — lets the Scheduler UI trace a job back to the
    *  PromptSession that spawned it. */
   sourceTabId?: string | null;
-  /** Originating prompt id (PRD frontmatter `sourcePromptId`) — the chain-root
-   *  PromptTicket id this PRD was dispatched from. Kept alongside `sourceTabId`
-   *  for referential tracing even when the tab/session no longer resolves. */
+  /** Originating prompt id (PRD frontmatter `sourcePromptId`) — the
+   *  PromptSession (Epic) id this PRD was dispatched from. Kept alongside
+   *  `sourceTabId` for referential tracing even when the tab/session no
+   *  longer resolves. */
   sourcePromptId?: string | null;
 }
 
@@ -450,6 +456,9 @@ export interface PrdListItem {
   cwd: string;
   estimateMinutes: number | null;
   mtimeMs: number;
+  /** PRD frontmatter `sourcePromptId` — the PromptSession (Epic) id this PRD
+   *  was dispatched from, if any. */
+  sourcePromptId?: string | null;
 }
 
 export interface SupervisorConfig {
@@ -843,6 +852,58 @@ export interface MemoryStaleResult {
   error: string | null;
 }
 
+// ────────────────────────────────────────────── Project Brief (PRD 837)
+// Persisted at <cwd>/session-manager-operations/project-brief/brief.json.
+export type ProjectBriefPinnableBlock = 'what' | 'conventions';
+
+export interface ProjectBriefArea {
+  name: string;
+  files: number;
+  note: string;
+  epic: string | null;
+  heat: number;
+}
+
+export interface ProjectBriefScopeEntry {
+  when: string;
+  kind: 'added' | 'narrowed' | 'decided';
+  text: string;
+  src: string;
+}
+
+export interface ProjectBrief {
+  version: number;
+  synthesizedAt: string;
+  model: string;
+  purpose: string;
+  what: string[];
+  areas: ProjectBriefArea[];
+  scope: ProjectBriefScopeEntry[];
+  conventions: string[];
+  pins: { what: boolean; conventions: boolean };
+  pinned: { what: string[] | null; conventions: string[] | null };
+}
+
+export interface ProjectBriefSource {
+  label: string;
+  detail: string;
+  mtimeMs: number | null;
+  drift: boolean;
+}
+
+export interface ProjectBriefGetResult {
+  brief: ProjectBrief | null;
+  sources: ProjectBriefSource[];
+}
+
+export type ProjectBriefRefreshResult =
+  | { ok: true; brief: ProjectBrief }
+  | { ok: false; error: string };
+
+export type ProjectBriefSetPinResult =
+  | { ok: true; brief: ProjectBrief }
+  | { ok: false; error: string };
+
 // ────────────────────────────────────────────── Per-subagent memory
 // Stored at ~/.claude/session-manager/agent-memory/<agentId>.json. Keyed by
 // agent name (the .md filename in ~/.claude/agents/), not by workspace cwd.
@@ -1092,6 +1153,10 @@ export interface SessionManagerAPI {
     write: (payload: { tabId: string; data: string }) => void;
     resize: (payload: { tabId: string; cols: number; rows: number }) => void;
     kill: (tabId: string) => void;
+    /** Subset of `tabIds` (session keys) that currently have a live PTY —
+     *  used by the Epics workspace to reconcile Terminal-mode attachment
+     *  after a renderer reload (PRD 833 C1). */
+    alive: (tabIds: string[]) => Promise<string[]>;
     onData: (tabId: string, handler: (data: string) => void) => () => void;
     onExit: (tabId: string, handler: (info: PtyExit) => void) => () => void;
     onWriteError: (handler: (ev: WriteErrorEvent) => void) => () => void;
@@ -1161,6 +1226,10 @@ export interface SessionManagerAPI {
     closeTab: (tabId: string) => Promise<{ ok: boolean }>;
     buffer: (tabId: string) => Promise<TranscriptEvent[]>;
     pathFor: (cwd: string, sessionUuid: string) => Promise<string>;
+    /** Batched token-usage totals, one map entry per requested sessionId. A
+     *  session with no transcript file yet (or one over the main-process size
+     *  cap) maps to null. */
+    usageFor: (cwd: string, sessionIds: string[]) => Promise<Record<string, { inputTokens: number; outputTokens: number } | null>>;
     onEvent: (tabId: string, handler: (ev: TranscriptEvent) => void) => () => void;
   };
   sessions: {
@@ -1363,6 +1432,14 @@ export interface SessionManagerAPI {
     /** Deterministic, zero-LLM-cost staleness report. `cwd` (optional) scopes the dead-repo-ref check. */
     stale: (workspace?: string, cwd?: string) => Promise<MemoryStaleResult>;
   };
+  projectBrief: {
+    /** Read brief.json (or null if none yet) plus cheaply-computed source/drift metadata. Never fires an LLM call. */
+    get: (cwd: string) => Promise<ProjectBriefGetResult>;
+    /** Cost-gated headless synthesis. Acquires a machine session slot first; returns `{ok:false}` if none free or a refresh is already running for this cwd. */
+    refresh: (cwd: string) => Promise<ProjectBriefRefreshResult>;
+    /** Pin/unpin a synthesized block ('what' | 'conventions'), freezing or clearing its frozen copy. */
+    setPin: (cwd: string, block: ProjectBriefPinnableBlock, pinned: boolean) => Promise<ProjectBriefSetPinResult>;
+  };
   agentMemory: {
     /** List all memory entries for one subagent. Sorted newest first. */
     list: (agentId: string) => Promise<AgentMemoryListResult>;

package/src/preload/index.cjs

@@ -36,6 +36,7 @@ contextBridge.exposeInMainWorld('api', {
     write: (payload) => ipcRenderer.send('pty:write', payload),
     resize: (payload) => ipcRenderer.send('pty:resize', payload),
     kill: (tabId) => ipcRenderer.send('pty:kill', tabId),
+    alive: (tabIds) => ipcRenderer.invoke('pty:alive', { tabIds }),
     onData: (tabId, handler) => {
       const channel = `pty:data:${tabId}`;
       const listener = (_e, data) => handler(data);
@@ -121,6 +122,8 @@ contextBridge.exposeInMainWorld('api', {
     buffer: (tabId) => ipcRenderer.invoke('transcript:buffer', { tabId }),
     pathFor: (cwd, sessionUuid) =>
       ipcRenderer.invoke('transcript:path', { cwd, sessionUuid }),
+    usageFor: (cwd, sessionIds) =>
+      ipcRenderer.invoke('transcript:usageFor', { cwd, sessionIds }),
     onEvent: (tabId, handler) => {
       const channel = `transcript:event:${tabId}`;
       const listener = (_e, ev) => handler(ev);
@@ -313,6 +316,11 @@ contextBridge.exposeInMainWorld('api', {
     stale: (workspace, cwd) =>
       ipcRenderer.invoke('memory:stale', { ...(workspace ? { workspace } : {}), ...(cwd ? { cwd } : {}) }),
   },
+  projectBrief: {
+    get: (cwd) => ipcRenderer.invoke('project-brief:get', { cwd }),
+    refresh: (cwd) => ipcRenderer.invoke('project-brief:refresh', { cwd }),
+    setPin: (cwd, block, pinned) => ipcRenderer.invoke('project-brief:set-pin', { cwd, block, pinned }),
+  },
   agentMemory: {
     list: (agentId) => ipcRenderer.invoke('agent-memory:list', { agentId }),
     get: (agentId, entryId) => ipcRenderer.invoke('agent-memory:get', { agentId, entryId }),