claude-code-session-manager 0.57.1 → 0.59.0

package/src/main/lib/agentModelResolve.cjs

@@ -0,0 +1,97 @@
+'use strict';
+
+/**
+ * agentModelResolve.cjs — resolves the `--model` an Epic's session should
+ * launch a headless `claude -p` (or Terminal `claude`) process with: its
+ * agentType persona's own `model` field (Agent Library) when the Epic has
+ * one set and it isn't 'inherit', else `fallbackModel`.
+ *
+ * Extracted from PRD agent-model-default-terminal (which wired this for the
+ * Terminal-view launch in EpicTerminalPane.tsx) so chatRunner.cjs's headless
+ * Chat-view launch resolves the SAME persona-derived model — Chat and
+ * Terminal are two VIEWS over one Epic session (CLAUDE.md) and must agree on
+ * which model that session launches with.
+ *
+ * Plain Node module (sync fs) — no Electron deps, mirrors epicMint.cjs's
+ * readActiveIndex so this can be called from chatRunner.cjs's synchronous
+ * executeRun() without restructuring it into an async flow.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { splitFrontmatter } = require('./prdFrontmatter.cjs');
+const { readActiveIndex } = require('./epicMint.cjs');
+const configMgr = require('../config.cjs');
+
+/** The hardcoded floor every branch of resolveEpicModel falls back to — --model must never be omitted (CLAUDE.md "Automation model pinning"). */
+const FALLBACK_MODEL = 'sonnet';
+
+/**
+ * Looks up the agentType an Epic (PromptSession) was created with, by the
+ * Epic's own claudeSessionId — the same domain-model join `prdCreate.cjs`'s
+ * resolveSourcePromptIdFromClaudeSession uses (Epic:claude-session is 1:1).
+ * Returns null if no matching Epic is found or it has no agentType set.
+ */
+function findAgentTypeByClaudeSessionId(cwd, claudeSessionId, deps = {}) {
+  if (!cwd || !claudeSessionId) return null;
+  const load = deps.readActiveIndex || readActiveIndex;
+  const { sessions } = load(cwd);
+  for (const session of Object.values(sessions)) {
+    if (session && session.claudeSessionId === claudeSessionId) return session.agentType || null;
+  }
+  return null;
+}
+
+/**
+ * Reads a global agent persona's `model` frontmatter field by name
+ * (`~/.claude/agents/<agentType>.md`), sync. Returns null on any miss
+ * (no such file, unreadable, no `model` key) — never throws.
+ */
+function readPersonaModel(agentType, deps = {}) {
+  if (!agentType) return null;
+  const globalDir = deps.globalDir || path.join(os.homedir(), '.claude', 'agents');
+  const validatePath = deps.validatePath || configMgr.validatePath;
+  let real;
+  try {
+    real = validatePath(path.join(globalDir, `${agentType}.md`));
+  } catch {
+    return null;
+  }
+  let text;
+  try {
+    text = fs.readFileSync(real, 'utf8');
+  } catch {
+    return null;
+  }
+  const { fm } = splitFrontmatter(text);
+  return fm.model || null;
+}
+
+/**
+ * Resolves the `--model` value for an Epic-backed session launch. Never
+ * throws — any lookup failure (missing Epic, missing persona, unreadable
+ * file) falls back to `fallbackModel` (default: 'sonnet', the same literal
+ * every claude -p call site pins per CLAUDE.md's model-pinning rule).
+ *
+ * @param {{ cwd: string, claudeSessionId: string, fallbackModel?: string, deps?: object }} opts
+ * @returns {string}
+ */
+function resolveEpicModel({ cwd, claudeSessionId, fallbackModel = FALLBACK_MODEL, deps = {} } = {}) {
+  try {
+    const agentType = findAgentTypeByClaudeSessionId(cwd, claudeSessionId, deps);
+    if (!agentType) return fallbackModel;
+    const model = readPersonaModel(agentType, deps);
+    if (!model || model === 'inherit') return fallbackModel;
+    return model;
+  } catch {
+    return fallbackModel;
+  }
+}
+
+module.exports = {
+  FALLBACK_MODEL,
+  resolveEpicModel,
+  findAgentTypeByClaudeSessionId,
+  readPersonaModel,
+};

package/src/main/lib/auditLog.cjs

@@ -8,10 +8,10 @@
  * survive even if the project's ops root doesn't exist yet.
  *
  * Best-effort only: a logging failure must never block the mint/create it is
- * observing (same posture as rcaFeedbackHook.cjs / dodDrainHook.cjs).
+ * observing (same posture as rcaReport.cjs / dodDrainHook.cjs).
  *
  * Plain Node module (no Electron deps) so scripts/mint-epic.cjs and
- * scripts/propose-epic.cjs (which run outside Electron) can require it too.
+ * scripts/mint-epic.cjs (which runs outside Electron) can require it too.
  */
 'use strict';
 

package/src/main/lib/classifyTranscriptLine.cjs

@@ -1,17 +1,34 @@
 'use strict';
 
+// Bound on any single string field kept inline in the in-memory `raw`
+// projection stored per event (events are ring-buffered up to 500 deep,
+// see transcripts.cjs's sub.buffer). Anything longer is truncated here —
+// the full untruncated line is still recoverable via the event's `ref`
+// (byte offset/length into the transcript file on disk, see makeEvent).
 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']);
+// Bound on the short human-scannable preview attached to every event.
+// Deliberately much smaller than MAX_RAW_STR — previewText is for a
+// glance, not a document; the full payload is always one disk read away
+// via `ref`.
+const PREVIEW_CHARS = 280;
+
+// Historically tool_use/tool_result blocks were exempted from the
+// MAX_RAW_STR cap so orchestrator.ts/race.ts could structurally re-parse
+// them without a truncated mid-token "…". Both files were deleted
+// 2026-07-30 (commit e3848c3, "delete Subagents-only dead code") along
+// with the rest of the Subagents tab, and no current consumer needs an
+// untruncated tool_result/tool_use block in the in-memory `raw`
+// projection — holding one verbatim (e.g. a large Read tool_result) in a
+// 500-entry ring buffer was a real memory-cliff incident. Every block
+// type is now trimmed the same way; this stays exported (empty) in case
+// a future structural consumer needs to opt a block type back out.
+const EXEMPT_TYPES = new Set();
 
 /**
- * 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.
+ * 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 (currently no type is exempt — see comment above).
  */
 function trimContentArray(content) {
   if (!Array.isArray(content)) return content;
@@ -32,58 +49,124 @@ function trimContentArray(content) {
   });
 }
 
-/** Build the slim raw projection used by race.ts and orchestrator.ts. */
+/**
+ * Build the raw projection carried on every event. Preserves every
+ * top-level field on the line (attribution*, effort, gitBranch,
+ * isSidechain, isMeta, requestId, isApiErrorMessage,
+ * interruptedByShutdown, permissionMode, promptSource, toolUseResult,
+ * etc.) — not just message.content — so the renderer can surface all of
+ * it, however trivial or redundant. message.content is still run through
+ * trimContentArray to bound size in the ring buffer.
+ */
 function makeRaw(obj) {
-  const msgContent = obj?.message?.content;
-  return { message: { content: trimContentArray(msgContent) } };
+  if (!obj || typeof obj !== 'object') return {};
+  const raw = {};
+  for (const key of Object.keys(obj)) {
+    if (key === 'message') continue;
+    raw[key] = obj[key];
+  }
+  if (obj.message && typeof obj.message === 'object') {
+    raw.message = { ...obj.message, content: trimContentArray(obj.message.content) };
+  }
+  return raw;
+}
+
+/** Bounded, human-scannable preview of an event's data — never the source of truth. */
+function buildPreviewText(data) {
+  let s;
+  if (typeof data === 'string') {
+    s = data;
+  } else {
+    try {
+      s = JSON.stringify(data);
+    } catch {
+      s = String(data);
+    }
+  }
+  if (!s) return '';
+  return s.length > PREVIEW_CHARS ? s.slice(0, PREVIEW_CHARS) + '…' : s;
+}
+
+/**
+ * Build one event. `ref` (optional) is `{ filePath, byteOffset, byteLength }`
+ * pointing at the exact bytes of the source line on disk, so the full,
+ * untruncated line can be re-read on demand instead of being held in
+ * memory. classifyLine stays a pure function of (obj, ref) — callers that
+ * don't have file context (e.g. unit tests) may omit ref.
+ */
+function makeEvent(kind, data, obj, ref) {
+  return { kind, data, raw: makeRaw(obj), previewText: buildPreviewText(data), ref: ref || null };
 }
 
 /**
- * Parse one JSONL line defensively. Real schema drifts, so we pass through
- * anything that parses and tag a coarse `kind`.
+ * Classify one content block and push its event(s) onto `events`. Known
+ * tool_use names get a specific kind (todo_write/plan/agent_spawn/tool_use);
+ * tool_result blocks get 'tool_result'; text blocks inherit the message's
+ * own type (assistant/user/…) so existing type-based consumers keep
+ * working. Any other block type — including ones Anthropic hasn't shipped
+ * yet — is surfaced under its own `content_<type>` kind rather than
+ * silently dropped, so new block kinds stay visible instead of vanishing.
  */
-function classifyLine(obj) {
-  if (!obj || typeof obj !== 'object') return null;
-  // Many shapes exist — try several common fields.
+function classifyBlock(block, obj, ref, type, events) {
+  if (!block || typeof block !== 'object') return;
+  if (block.type === 'tool_use') {
+    if (block.name === 'TodoWrite') {
+      events.push(makeEvent('todo_write', block.input?.todos || block.input || [], obj, ref));
+    } else if (block.name === 'ExitPlanMode' || block.name === 'EnterPlanMode') {
+      events.push(makeEvent('plan', block.input, obj, ref));
+    } else 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.
+      events.push(makeEvent('agent_spawn', { ...block.input, toolUseId: block.id }, obj, ref));
+    } else {
+      events.push(makeEvent('tool_use', { name: block.name, input: block.input, id: block.id }, obj, ref));
+    }
+    return;
+  }
+  // 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) {
+    events.push(makeEvent('tool_result', { toolUseId: block.tool_use_id }, obj, ref));
+    return;
+  }
+  if (block.type === 'text' && typeof block.text === 'string') {
+    events.push(makeEvent(type || 'text', block.text, obj, ref));
+    return;
+  }
+  events.push(makeEvent(block.type ? `content_${block.type}` : 'content_block', block, obj, ref));
+}
+
+/**
+ * Parse one JSONL line defensively. Real schema drifts, so we pass
+ * through anything that parses and tag a coarse `kind` per event.
+ *
+ * Returns an ARRAY of events (empty array for an unclassifiable line) —
+ * a single line can legitimately carry more than one event: a usage
+ * rollup alongside real content, or an assistant turn with text plus
+ * several tool calls in the same content array. No caller may assume a
+ * line produces at most one event.
+ */
+function classifyLine(obj, ref) {
+  if (!obj || typeof obj !== 'object') return [];
+  const events = [];
   const type = obj.type || obj.event || obj.role;
   const msg = obj.message || obj;
   const content = msg?.content;
+  const usage = obj.usage || msg?.usage;
 
-  // Usage rollups arrive as summary events.
-  if (obj.usage || msg?.usage) {
-    return { kind: 'usage', data: obj.usage || msg.usage, raw: makeRaw(obj) };
+  // Usage rollups arrive as summary events — emitted alongside whatever
+  // content the same line carries, never instead of it.
+  if (usage) {
+    events.push(makeEvent('usage', usage, obj, ref));
   }
 
-  // Tool uses: scan content array for tool_use blocks.
-  if (Array.isArray(content)) {
-    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: makeRaw(obj) };
-        }
-        if (block.name === 'ExitPlanMode' || block.name === 'EnterPlanMode') {
-          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: makeRaw(obj) };
-        }
-        return {
-          kind: 'tool_use',
-          data: { name: block.name, input: block.input, id: block.id },
-          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: makeRaw(obj) };
-      }
-    }
+  if (Array.isArray(content) && content.length > 0) {
+    for (const block of content) classifyBlock(block, obj, ref, type, events);
+  } else if (!usage) {
+    events.push(makeEvent(type || 'message', obj, obj, ref));
   }
 
-  return { kind: type || 'message', data: obj, raw: makeRaw(obj) };
+  return events;
 }
 
-module.exports = { MAX_RAW_STR, EXEMPT_TYPES, trimContentArray, makeRaw, classifyLine };
+module.exports = { MAX_RAW_STR, PREVIEW_CHARS, EXEMPT_TYPES, trimContentArray, makeRaw, buildPreviewText, classifyLine };

package/src/main/lib/epicContextDigest.cjs

@@ -0,0 +1,78 @@
+'use strict';
+
+/**
+ * epicContextDigest.cjs — condensed, real (never fabricated) digest of an
+ * Epic's own session, for later injection into a scheduled PRD job's opening
+ * prompt (wiring is a separate, dependent PRD — this module is groundwork
+ * only). Composes the Epic's goalText (active-index.json, via epicMint.cjs's
+ * readActiveIndex) with its most-recent turns (the JSONL transcript, via
+ * promptSessionTranscript.cjs's readTurns) — never reimplements either read.
+ *
+ * Plain Node module (no Electron deps), matching sessionSlots.cjs's and
+ * promptSessionTranscript.cjs's own posture, so it is callable from
+ * scheduler.cjs.
+ */
+
+const { readTurns } = require('../promptSessionTranscript.cjs');
+const { readActiveIndex } = require('./epicMint.cjs');
+
+const DEFAULT_MAX_CHARS = 4000;
+const TURN_LIMIT = 40;
+
+function formatTurn(turn) {
+  return `[${turn.role}] ${turn.text}`;
+}
+
+/**
+ * buildContextDigest({ cwd, epicId, maxChars }) → Promise<string>
+ *
+ * Best-effort: every internal call is wrapped so a failure here can never
+ * propagate to a caller — returns '' on any error, missing epicId, an epicId
+ * absent from the cwd's active-index.json, or an empty transcript.
+ */
+async function buildContextDigest({ cwd, epicId, maxChars } = {}) {
+  try {
+    if (!cwd || !epicId) return '';
+    const limit = typeof maxChars === 'number' && maxChars > 0 ? maxChars : DEFAULT_MAX_CHARS;
+
+    const index = readActiveIndex(cwd);
+    if (!Object.prototype.hasOwnProperty.call(index.sessions, epicId)) return '';
+    const session = index.sessions[epicId];
+    const goalText = session && typeof session.goalText === 'string' ? session.goalText.trim() : '';
+
+    const turns = await readTurns(cwd, epicId, { limit: TURN_LIMIT });
+
+    const header = goalText;
+    const headerChars = header ? header.length + 1 : 0; // +1 for trailing newline before turns
+
+    // Drop whole turns from the oldest first until the joined digest fits —
+    // never a hard mid-string slice that could cut a turn's text in half.
+    let kept = turns.slice();
+    while (kept.length > 0) {
+      const lines = kept.map(formatTurn);
+      const bodyChars = lines.length > 0 ? lines.join('\n').length : 0;
+      const total = headerChars + bodyChars;
+      if (total <= limit) break;
+      kept = kept.slice(1);
+    }
+
+    const parts = [];
+    if (header) parts.push(header);
+    if (kept.length > 0) parts.push(kept.map(formatTurn).join('\n'));
+
+    let digest = parts.join('\n');
+    if (digest.length > limit) {
+      // Header alone (no turns fit) can still exceed maxChars — clip the
+      // header itself rather than exceeding the caller's bound.
+      digest = digest.slice(0, limit);
+    }
+    return digest;
+  } catch (e) {
+    console.error('[epicContextDigest] buildContextDigest error', cwd, epicId, e);
+    return '';
+  }
+}
+
+module.exports = {
+  buildContextDigest,
+};