claude-code-session-manager 0.38.4 → 0.38.6

package/src/main/superagent.cjs

@@ -1,212 +0,0 @@
-/**
- * SuperAgent — "boss" runner that dispatches specialist subagents.
- *
- * Ported (in MVP form) from ClaudeCodeUnleashed's SuperAgent feature.
- * Differs significantly from upstream:
- *   - We don't call Groq/OpenAI. The boss IS Claude — we send a structured
- *     prompt to the active PTY tab asking Claude to act as the boss, pick
- *     specialists, and report progress in a parseable format.
- *   - No autonomous output-parsing / fast-path / WAIT logic. State machine
- *     is renderer-driven via transcript events (see live.ts pattern).
- *   - Per-tab run state lives here so the renderer can poll status across
- *     navigation, and so a future supervisor probe can act on stuck runs.
- *
- * Channels:
- *   superagent:start({ tabId, prompt, specialistCount, depth })
- *     → { ok, error? } and broadcasts the boss prompt to the tab's PTY.
- *   superagent:status(tabId) → SuperAgentRunState | null
- *   superagent:stop(tabId) → { ok }
- *
- * Broadcasts:
- *   superagent:state-changed → { tabId, state } whenever a run starts/stops.
- *
- * The PTY write is intentionally done via the existing ptyManager.write
- * indirection, NOT a fresh spawn — SuperAgent runs inside the user's current
- * Claude session.
- */
-
-const { ipcMain } = require('electron');
-const { schemas } = require('./ipcSchemas.cjs');
-const { manager: ptyManager } = require('./pty.cjs');
-const logs = require('./logs.cjs');
-
-// Per-tab run state. Single live run per tab — starting a new run on a tab
-// that's already running stops the existing one first.
-//
-// Shape (also exposed on the renderer via api.d.ts SuperAgentRunState):
-//   { status: 'idle' | 'running' | 'done' | 'error',
-//     prompt, specialistCount, depth,
-//     startedAt: number | null, finishedAt: number | null,
-//     error?: string }
-const runs = new Map();
-
-let mainWindow = null;
-
-function attachWindow(win) {
-  mainWindow = win;
-}
-
-function broadcast(tabId) {
-  if (!mainWindow || mainWindow.isDestroyed()) return;
-  const state = runs.get(tabId) ?? null;
-  try {
-    mainWindow.webContents.send('superagent:state-changed', { tabId, state });
-  } catch { /* renderer gone */ }
-}
-
-/**
- * Build the prompt we send to Claude to act as the boss. Structured so the
- * renderer can (in a follow-up) pattern-match progress markers off the
- * transcript without us having to parse PTY output ourselves.
- *
- * O(1) string concat — the prompt is bounded by the zod max(8KiB).
- */
-function buildBossPrompt({ prompt, specialistCount, depth }) {
-  const depthLine = depth === 'quick'
-    ? 'Quick pass — surface-level analysis, single-shot specialist work.'
-    : depth === 'deep'
-      ? 'Deep pass — multi-step plans per specialist, recurse on findings.'
-      : 'Standard pass — moderate detail, one or two iterations per specialist.';
-
-  return [
-    '## SuperAgent boss mode',
-    '',
-    `You are coordinating ${specialistCount} specialist subagent(s) for the user's task.`,
-    depthLine,
-    '',
-    'Workflow:',
-    `  1. Pick ${specialistCount} specialist subagent type(s) that best match the task.`,
-    '     Report them as: [SUPERAGENT] specialists: <type1>, <type2>, ...',
-    '  2. Dispatch them via the Task tool, one at a time or in parallel as appropriate.',
-    '  3. After each specialist returns, report: [SUPERAGENT] progress: <specialist> done',
-    '  4. When the task is complete, summarize results and report: [SUPERAGENT] complete',
-    '',
-    'User task:',
-    prompt,
-  ].join('\n');
-}
-
-function startRun(payload) {
-  const { tabId, prompt, specialistCount, depth } = payload;
-
-  // Stop any in-flight run on this tab — single run-per-tab invariant.
-  const existing = runs.get(tabId);
-  if (existing && existing.status === 'running') {
-    runs.set(tabId, {
-      ...existing,
-      status: 'done',
-      finishedAt: Date.now(),
-    });
-  }
-
-  const fullPrompt = buildBossPrompt({ prompt, specialistCount, depth });
-
-  // PTY write — exactly the pattern docstring'd at the top of the task brief.
-  // The trailing carriage-return submits the prompt in Claude's TUI.
-  let writeErr = null;
-  try {
-    ptyManager.write({ tabId, data: fullPrompt + '\r' });
-  } catch (e) {
-    writeErr = e?.message ?? String(e);
-  }
-
-  if (writeErr) {
-    const errState = {
-      status: 'error',
-      prompt,
-      specialistCount,
-      depth,
-      startedAt: Date.now(),
-      finishedAt: Date.now(),
-      error: writeErr,
-    };
-    runs.set(tabId, errState);
-    broadcast(tabId);
-    logs.writeLine({
-      scope: 'superagent',
-      level: 'error',
-      message: 'start failed',
-      meta: { tabId, error: writeErr },
-    });
-    return { ok: false, error: writeErr };
-  }
-
-  const state = {
-    status: 'running',
-    prompt,
-    specialistCount,
-    depth,
-    startedAt: Date.now(),
-    finishedAt: null,
-  };
-  runs.set(tabId, state);
-  broadcast(tabId);
-
-  logs.writeLine({
-    scope: 'superagent',
-    level: 'info',
-    message: 'start',
-    meta: { tabId, specialistCount, depth, promptBytes: prompt.length },
-  });
-
-  return { ok: true };
-}
-
-function stopRun(tabId) {
-  const existing = runs.get(tabId);
-  if (!existing || existing.status !== 'running') {
-    return { ok: true };
-  }
-  runs.set(tabId, {
-    ...existing,
-    status: 'done',
-    finishedAt: Date.now(),
-  });
-  broadcast(tabId);
-  logs.writeLine({
-    scope: 'superagent',
-    level: 'info',
-    message: 'stop',
-    meta: { tabId },
-  });
-  return { ok: true };
-}
-
-function getStatus(tabId) {
-  return runs.get(tabId) ?? null;
-}
-
-function dropTab(tabId) {
-  if (runs.has(tabId)) {
-    runs.delete(tabId);
-    if (process.env.SM_DEBUG_LEAKS === '1') {
-      console.log('[superagent] dropTab', tabId, 'runs.size=', runs.size);
-    }
-  }
-}
-
-function registerSuperAgentHandlers() {
-  ipcMain.handle('superagent:start', (_e, payload) => {
-    const parsed = schemas.superagentStart.parse(payload);
-    return startRun(parsed);
-  });
-
-  ipcMain.handle('superagent:status', (_e, payload) => {
-    const { tabId } = schemas.superagentTabId.parse(payload);
-    return getStatus(tabId);
-  });
-
-  ipcMain.handle('superagent:stop', (_e, payload) => {
-    const { tabId } = schemas.superagentTabId.parse(payload);
-    return stopRun(tabId);
-  });
-}
-
-module.exports = {
-  attachWindow,
-  registerSuperAgentHandlers,
-  dropTab,
-  // Exposed for tests.
-  buildBossPrompt,
-  _runs: runs,
-};

package/src/main/usageMatrix.cjs

@@ -1,340 +0,0 @@
-/**
- * usageMatrix.cjs — per-tab agentic-ops aggregator.
- *
- * Watches the same classified transcript events that transcripts.cjs streams
- * to the renderer and maintains a small rolling state per tab: turn count,
- * token velocity (5-min window), cache age, subagent fan-out, and behavioral
- * flags (geometric context growth, cache cold-start risk, long session).
- *
- * Lives in main rather than the renderer so a renderer reload does not lose
- * the rolling counters — multi-hour sessions are the primary use case and
- * losing the velocity series at a reload would make the dashboard useless
- * exactly when it matters most.
- *
- * Broadcasts `usage:matrix:tick` on a 5-second cadence (and once on demand
- * via the `usage:matrix:snapshot` handler at mount).
- */
-
-'use strict';
-
-const path = require('node:path');
-const { ipcMain } = require('electron');
-const { sendIfAlive } = require('./lib/sendToRenderer.cjs');
-
-const TICK_MS = 5_000;
-const TOKEN_WINDOW_MS = 5 * 60_000; // 5 min rolling window for tokens/min
-const TURN_RING = 20;               // per-turn input-token series cap
-const TOOL_RING = 100;              // recent tool-name series cap
-const CACHE_TTL_MS = 60 * 60_000;   // Anthropic prefix cache ~60 min
-const CACHE_WARN_MS = 50 * 60_000;  // start warning at 50 min
-
-const BURN_LOW = 5_000;       // tokens/min
-const BURN_CRITICAL = 30_000; // tokens/min
-const LONG_SESSION_TURNS = 70;
-const GEOMETRIC_MIN_TOKENS = 50_000; // don't flag tiny series
-
-/** Map<tabId, TabState> */
-const tabs = new Map();
-let window = null;
-let tickTimer = null;
-let dirty = false;
-
-function attachWindow(w) {
-  window = w;
-  if (!tickTimer) {
-    tickTimer = setInterval(broadcastIfChanged, TICK_MS);
-  }
-}
-
-function workspaceName(cwd) {
-  if (!cwd) return '(unknown)';
-  return path.basename(cwd) || cwd;
-}
-
-function blankTab(tabId, cwd, sessionUuid) {
-  return {
-    tabId,
-    cwd,
-    sessionUuid,
-    workspace: workspaceName(cwd),
-    startedAt: Date.now(),
-    lastEventAt: 0,
-    lastAssistantAt: 0,
-    lastUserAt: 0,
-    lastPlanAt: 0,
-    turns: 0,
-    cumulativeUsage: { input: 0, output: 0, cacheRead: 0, cacheCreate: 0 },
-    perTurnInputTokens: [],
-    tokenWindow: [], // [{ts, tokens}]
-    toolSeries: [],  // [{ts, name}]
-    agentSpawns: 0,
-    agentsActive: new Map(), // toolUseId -> {at}
-  };
-}
-
-function ensureTab(tabId, cwd, sessionUuid) {
-  let t = tabs.get(tabId);
-  if (!t) {
-    t = blankTab(tabId, cwd, sessionUuid);
-    tabs.set(tabId, t);
-  }
-  return t;
-}
-
-/**
- * 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, replay = false }) {
-  if (!tabId || !ev) return;
-  const t = ensureTab(tabId, cwd, sessionUuid);
-  const now = Date.now();
-  t.lastEventAt = now;
-
-  switch (ev.kind) {
-    case 'usage': {
-      // Each usage rollup = one assistant turn in Claude Code's transcript.
-      const u = ev.data || {};
-      const inTok = (u.input_tokens || 0)
-        + (u.cache_creation_input_tokens || 0)
-        + (u.cache_read_input_tokens || 0);
-      const outTok = u.output_tokens || 0;
-      t.cumulativeUsage.input += u.input_tokens || 0;
-      t.cumulativeUsage.output += outTok;
-      t.cumulativeUsage.cacheRead += u.cache_read_input_tokens || 0;
-      t.cumulativeUsage.cacheCreate += u.cache_creation_input_tokens || 0;
-      t.turns += 1;
-      t.lastAssistantAt = now;
-
-      t.perTurnInputTokens.push(inTok);
-      if (t.perTurnInputTokens.length > TURN_RING) t.perTurnInputTokens.shift();
-
-      // 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;
-    }
-    case 'tool_use': {
-      const name = ev.data?.name;
-      if (name) {
-        t.toolSeries.push({ ts: now, name });
-        if (t.toolSeries.length > TOOL_RING) t.toolSeries.shift();
-      }
-      dirty = true;
-      break;
-    }
-    case 'agent_spawn': {
-      t.agentSpawns += 1;
-      const id = ev.data?.toolUseId;
-      if (id) t.agentsActive.set(id, { at: now });
-      dirty = true;
-      break;
-    }
-    case 'tool_result': {
-      const id = ev.data?.toolUseId;
-      if (id && t.agentsActive.has(id)) {
-        t.agentsActive.delete(id);
-        dirty = true;
-      }
-      break;
-    }
-    case 'plan': {
-      t.lastPlanAt = now;
-      dirty = true;
-      break;
-    }
-    default:
-      break;
-  }
-}
-
-function pruneWindow(arr, now) {
-  const cutoff = now - TOKEN_WINDOW_MS;
-  while (arr.length && arr[0].ts < cutoff) arr.shift();
-}
-
-function removeTab(tabId) {
-  if (tabs.delete(tabId)) dirty = true;
-}
-
-/**
- * Build a derived snapshot. Heavy work happens here, not on the hot
- * recordEvent path — recordEvent only appends to ring buffers and flips a
- * dirty bit.
- */
-function buildSnapshot() {
-  const now = Date.now();
-  const out = [];
-
-  let totalSubagentsActive = 0;
-  let totalSubagentsSpawned = 0;
-  let totalTokensToday = 0;
-  let combinedTokensPerMin = 0;
-
-  for (const t of tabs.values()) {
-    pruneWindow(t.tokenWindow, now);
-    const windowTokens = t.tokenWindow.reduce((s, e) => s + e.tokens, 0);
-    const windowMin = Math.min(TOKEN_WINDOW_MS, now - (t.tokenWindow[0]?.ts ?? now)) / 60_000;
-    const tokensPerMin = windowMin > 0.1 ? Math.round(windowTokens / windowMin) : 0;
-    combinedTokensPerMin += tokensPerMin;
-
-    const intensity = tokensPerMin >= BURN_CRITICAL
-      ? 'critical'
-      : tokensPerMin >= BURN_LOW
-      ? 'medium'
-      : tokensPerMin > 0
-      ? 'low'
-      : 'idle';
-
-    const cacheAgeMs = t.lastAssistantAt ? now - t.lastAssistantAt : null;
-    const cacheState = cacheAgeMs == null
-      ? 'cold'
-      : cacheAgeMs > CACHE_TTL_MS
-      ? 'cold'
-      : cacheAgeMs > CACHE_WARN_MS
-      ? 'expiring'
-      : 'warm';
-
-    const avgPerTurn = t.perTurnInputTokens.length > 0
-      ? Math.round(t.perTurnInputTokens.reduce((s, n) => s + n, 0) / t.perTurnInputTokens.length)
-      : 0;
-
-    const geometricGrowth = detectGeometricGrowth(t.perTurnInputTokens);
-
-    // State derivation. Order matters — earlier branches win.
-    let state;
-    if (t.lastPlanAt > 0 && (now - t.lastPlanAt) < 60_000 && t.lastPlanAt >= t.lastAssistantAt) {
-      state = 'plan';
-    } else if (t.agentsActive.size > 0 && (now - t.lastAssistantAt) > 10_000) {
-      state = 'background';
-    } else if (t.lastEventAt > 0 && (now - t.lastEventAt) < 30_000) {
-      state = 'executing';
-    } else {
-      state = 'idle';
-    }
-
-    const subagentsActive = t.agentsActive.size;
-    totalSubagentsActive += subagentsActive;
-    totalSubagentsSpawned += t.agentSpawns;
-    totalTokensToday += t.cumulativeUsage.input + t.cumulativeUsage.output;
-
-    const alerts = [];
-    if (geometricGrowth) {
-      alerts.push({
-        level: 'warn',
-        code: 'geometric-growth',
-        message: `Per-turn input grew geometrically (avg ${(avgPerTurn / 1000).toFixed(0)}k). Run /compact.`,
-      });
-    }
-    if (t.turns >= LONG_SESSION_TURNS) {
-      alerts.push({
-        level: 'warn',
-        code: 'long-session',
-        message: `Session is at turn ${t.turns}. Context resubmissions cost ${(avgPerTurn / 1000).toFixed(0)}k tokens each.`,
-      });
-    }
-    if (cacheState === 'expiring' && state === 'idle') {
-      const minLeft = Math.max(0, Math.round((CACHE_TTL_MS - (cacheAgeMs ?? 0)) / 60_000));
-      alerts.push({
-        level: 'info',
-        code: 'cache-cold-start',
-        message: `Cache cold-start in ${minLeft}m. Next command will incur full cache_creation cost.`,
-      });
-    }
-    if (cacheState === 'cold' && t.lastAssistantAt > 0) {
-      alerts.push({
-        level: 'info',
-        code: 'cache-cold',
-        message: 'Cache expired. Next command pays full cache_creation pricing.',
-      });
-    }
-    if (subagentsActive >= 4) {
-      alerts.push({
-        level: 'info',
-        code: 'subagent-fanout',
-        message: `${subagentsActive} subagents in flight. Consider waiting before fanning out more.`,
-      });
-    }
-
-    out.push({
-      tabId: t.tabId,
-      workspace: t.workspace,
-      cwd: t.cwd,
-      state,
-      turns: t.turns,
-      lastEventAt: t.lastEventAt,
-      lastAssistantAt: t.lastAssistantAt,
-      cacheAgeMs,
-      cacheState,
-      tokensPerMin,
-      intensity,
-      avgTokensPerTurn: avgPerTurn,
-      cumulativeUsage: { ...t.cumulativeUsage },
-      subagentsActive,
-      subagentsSpawned: t.agentSpawns,
-      geometricGrowth,
-      alerts,
-    });
-  }
-
-  // Most active first.
-  out.sort((a, b) => b.tokensPerMin - a.tokensPerMin || b.lastEventAt - a.lastEventAt);
-
-  return {
-    generatedAt: now,
-    tabs: out,
-    totals: {
-      activeSessions: out.length,
-      subagentsActive: totalSubagentsActive,
-      subagentsSpawned: totalSubagentsSpawned,
-      tokensTotal: totalTokensToday,
-      combinedTokensPerMin,
-    },
-  };
-}
-
-/**
- * Geometric growth: avg of last 3 turns > 1.8 × avg of prior 3 turns,
- * and last-3 avg above GEOMETRIC_MIN_TOKENS so trivial sessions don't flag.
- */
-function detectGeometricGrowth(series) {
-  if (series.length < 6) return false;
-  const tail = series.slice(-3);
-  const prev = series.slice(-6, -3);
-  const tailAvg = tail.reduce((s, n) => s + n, 0) / 3;
-  const prevAvg = prev.reduce((s, n) => s + n, 0) / 3;
-  if (tailAvg < GEOMETRIC_MIN_TOKENS) return false;
-  if (prevAvg <= 0) return false;
-  return tailAvg / prevAvg >= 1.8;
-}
-
-function broadcastIfChanged() {
-  if (!dirty) return;
-  dirty = false;
-  if (!window) return;
-  sendIfAlive(window, 'usage:matrix:tick', buildSnapshot());
-}
-
-function registerHandlers() {
-  ipcMain.handle('usage:matrix:snapshot', () => buildSnapshot());
-}
-
-function closeAll() {
-  if (tickTimer) {
-    clearInterval(tickTimer);
-    tickTimer = null;
-  }
-  tabs.clear();
-}
-
-module.exports = {
-  attachWindow,
-  recordEvent,
-  removeTab,
-  registerHandlers,
-  closeAll,
-};