claude-code-session-manager 0.33.0 → 0.34.0

package/src/main/usage.cjs

@@ -16,6 +16,7 @@
  *   }
  */
 
+const fs = require('node:fs');
 const fsp = require('node:fs/promises');
 const path = require('node:path');
 const os = require('node:os');
@@ -30,28 +31,74 @@ function envEnabled(v) {
   return v != null && v !== '' && v !== '0' && String(v).toLowerCase() !== 'false';
 }
 
+/**
+ * Reads enterprise-auth signals from Claude Code's own settings files — the
+ * `env` block and `apiKeyHelper`. This is where corporate gateways are usually
+ * configured (a managed/enterprise policy or the user's settings.json), NOT as
+ * exported shell vars. It matters most on macOS, where a GUI-launched app does
+ * not inherit the shell's environment, so `process.env` looks like a clean
+ * consumer install even when `claude` itself is talking to a gateway.
+ *
+ * Precedence mirrors Claude Code: managed (enterprise) settings, then user
+ * settings, then user-local settings. Missing/unreadable/invalid files are
+ * skipped. Returns `{ env, apiKeyHelper }`.
+ */
+function readClaudeSettingsAuth() {
+  const merged = {};
+  let apiKeyHelper = false;
+  const managed = process.platform === 'darwin'
+    ? '/Library/Application Support/ClaudeCode/managed-settings.json'
+    : '/etc/claude-code/managed-settings.json';
+  const files = [
+    managed,
+    path.join(os.homedir(), '.claude', 'settings.json'),
+    path.join(os.homedir(), '.claude', 'settings.local.json'),
+  ];
+  for (const f of files) {
+    try {
+      const data = JSON.parse(fs.readFileSync(f, 'utf8'));
+      if (data && typeof data.env === 'object' && data.env) Object.assign(merged, data.env);
+      if (data && data.apiKeyHelper) apiKeyHelper = true;
+    } catch { /* missing / unreadable / invalid JSON → skip */ }
+  }
+  return { env: merged, apiKeyHelper };
+}
+
 /**
  * Is the consumer 5-hour usage meter (/api/oauth/usage) even applicable here?
  *
  * That endpoint only exists for OAuth/subscription auth against
  * api.anthropic.com. Enterprise auth modes have no such meter, so polling it
- * just 404s/times-out — and the scheduler must NOT gate on (or pause for) it.
- * Detected modes: Amazon Bedrock, Google Vertex, raw API-key, a custom auth
- * token, or a non-Anthropic base URL (corporate gateway/proxy).
+ * just 404s/times-out (or 401s with no credentials file) — and the scheduler
+ * must NOT gate on (or pause for) it. Detected modes: Amazon Bedrock, Google
+ * Vertex, raw API-key, a custom auth token, a non-Anthropic base URL (corporate
+ * gateway/proxy), or an `apiKeyHelper` script.
+ *
+ * Signals are read from BOTH process.env and Claude Code's settings files, so a
+ * gateway configured purely in settings.json (the common enterprise case) is
+ * detected even when the GUI process inherited a clean environment.
  *
  * Returns false → caller should treat usage as unavailable-by-design and fire
  * work on its own (pending + memory) instead of waiting on a meter.
  */
-function usageMeterApplicable(env = process.env) {
-  if (envEnabled(env.CLAUDE_CODE_USE_BEDROCK)) return false;
-  if (envEnabled(env.CLAUDE_CODE_USE_VERTEX)) return false;
-  if (env.ANTHROPIC_API_KEY) return false;
-  if (env.ANTHROPIC_AUTH_TOKEN) return false;
-  if (env.ANTHROPIC_BASE_URL) {
+function usageMeterApplicable(env = process.env, settings = readClaudeSettingsAuth()) {
+  // Manual escape hatch: if detection misses an unusual gateway setup, the user
+  // can force "no consumer meter" so the scheduler stops pausing on 'auth'.
+  if (envEnabled(env.SM_NO_USAGE_METER)) return false;
+  // An apiKeyHelper means `claude` mints its own key → non-OAuth, no meter.
+  if (settings && settings.apiKeyHelper) return false;
+  // Effective env: settings.json provides values the GUI process didn't
+  // inherit; a real process.env var wins when both define the same key.
+  const eff = { ...(settings && settings.env), ...env };
+  if (envEnabled(eff.CLAUDE_CODE_USE_BEDROCK)) return false;
+  if (envEnabled(eff.CLAUDE_CODE_USE_VERTEX)) return false;
+  if (eff.ANTHROPIC_API_KEY) return false;
+  if (eff.ANTHROPIC_AUTH_TOKEN) return false;
+  if (eff.ANTHROPIC_BASE_URL) {
     // Parse the host rather than substring-match, so a deceptive gateway like
     // https://anthropic.com.attacker.example is correctly treated as enterprise.
     let host;
-    try { host = new URL(env.ANTHROPIC_BASE_URL).hostname.toLowerCase(); }
+    try { host = new URL(eff.ANTHROPIC_BASE_URL).hostname.toLowerCase(); }
     catch { return false; } // unparseable custom URL → treat as a gateway
     if (host !== 'anthropic.com' && !host.endsWith('.anthropic.com')) return false;
   }
@@ -197,4 +244,4 @@ function registerBillingHandlers() {
   });
 }
 
-module.exports = { registerBillingHandlers, fetchUsage, classifyUsageResponse, usageMeterApplicable };
+module.exports = { registerBillingHandlers, fetchUsage, classifyUsageResponse, usageMeterApplicable, readClaudeSettingsAuth };

package/src/main/voiceHotkey.cjs

@@ -313,8 +313,6 @@ function registerHotkeyHandlers() {
     return { ok: true, config: currentConfig };
   }));
 
-  ipcMain.handle('voice:get-hotkey-config-path', () => voiceSettings.storePath());
-
   // F5 — device picker preference (additive subtree on voice.json).
   ipcMain.handle('voice:get-device-pref', async () => {
     return await voiceSettings.loadDevice();

package/src/main/webRemote.cjs

@@ -28,6 +28,7 @@ const { writeTextAtomic, validatePath } = require('./config.cjs');
 const logs = require('./logs.cjs');
 const { sendIfAlive } = require('./lib/sendToRenderer.cjs');
 const { schemas } = require('./ipcSchemas.cjs');
+const { summarize: _sharedSummarize } = require('./lib/summarize.cjs');
 const { makeState, confirmSas: confirmSasLogic } = require('./lib/e2eStateMachine.cjs');
 
 // ─── Constants ───────────────────────────────────────────────────────────────
@@ -740,70 +741,9 @@ function startSessionListPush() {
 }
 
 // ─── SM-V2-03: mobile summary via Claude Haiku 4.5 ───────────────────────────
+// Summarization logic lives in lib/summarize.cjs (shared with exchanges.cjs).
 
-const SUMMARY_MIN_CHARS = 280;       // below this, push raw — not worth an API call
-const SUMMARY_MODEL = 'claude-haiku-4-5';
-const SUMMARY_MAX_INPUT_CHARS = 24_000; // cap the turn text sent to Haiku (~6k tokens)
-const SUMMARY_SYSTEM =
-  'Summarize this Claude Code assistant turn for a phone screen in 2 sentences max, ' +
-  'followed by an optional list of up to 3 short action items. Plain text only — no ' +
-  'markdown headers, no code blocks. Lead with what was done or decided.';
-
-let _anthropicKeyCache = null; // memoized found key only (string); null = re-resolve
-
-/** Resolve the Anthropic API key: env → web-remote.json → null (degrade to raw).
- *  Only a FOUND key is cached — if absent we re-resolve each call (cheap, loadConfig
- *  is TTL-cached) so adding the key to web-remote.json later takes effect without a restart. */
-async function resolveAnthropicKey() {
-  if (_anthropicKeyCache) return _anthropicKeyCache;
-  const fromEnv = process.env.ANTHROPIC_API_KEY;
-  if (fromEnv && fromEnv.trim()) { _anthropicKeyCache = fromEnv.trim(); return _anthropicKeyCache; }
-  try {
-    const cfg = await loadConfig();
-    const k = cfg.anthropicApiKey;
-    if (typeof k === 'string' && k.trim()) { _anthropicKeyCache = k.trim(); return _anthropicKeyCache; }
-  } catch { /* fall through to null → re-resolve next time */ }
-  return null;
-}
-
-/** POST to the Anthropic Messages API. Returns the first text block, or throws. */
-function anthropicSummarize(apiKey, text) {
-  const body = JSON.stringify({
-    model: SUMMARY_MODEL,
-    max_tokens: 320,
-    system: SUMMARY_SYSTEM,
-    messages: [{ role: 'user', content: text.slice(0, SUMMARY_MAX_INPUT_CHARS) }],
-  });
-  return new Promise((resolve, reject) => {
-    const req = https.request('https://api.anthropic.com/v1/messages', {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-        'x-api-key': apiKey,
-        'anthropic-version': '2023-06-01',
-        'content-length': Buffer.byteLength(body),
-      },
-      timeout: 20_000,
-    }, (res) => {
-      let data = '';
-      res.on('data', (c) => { data += c; });
-      res.on('end', () => {
-        if (res.statusCode < 200 || res.statusCode >= 300) {
-          return reject(new Error(`anthropic HTTP ${res.statusCode}`));
-        }
-        try {
-          const json = JSON.parse(data);
-          const block = Array.isArray(json.content) ? json.content.find((b) => b.type === 'text') : null;
-          if (!block?.text) return reject(new Error('no text in response'));
-          resolve(block.text.trim());
-        } catch (e) { reject(e); }
-      });
-    });
-    req.on('error', reject);
-    req.on('timeout', () => req.destroy(new Error('anthropic request timed out')));
-    req.end(body);
-  });
-}
+const SUMMARY_MIN_CHARS = 280; // below this, push raw — not worth an API call
 
 /**
  * Produce a mobile summary of the watcher's last completed assistant turn and push it.
@@ -823,22 +763,15 @@ async function maybeSummarize(w) {
     return;
   }
 
-  const apiKey = await resolveAnthropicKey();
-  if (!apiKey) {
-    // Degrade gracefully: push a trimmed raw message + a hint flag the app can surface.
-    pushEvent('event:session:summary', {
-      tabId: w.tabId, summary: text.slice(0, 600), ofMessageId, model: 'raw', degraded: 'no_api_key', ts: Date.now(),
-    });
-    return;
-  }
-
-  try {
-    const summary = await anthropicSummarize(apiKey, text);
-    pushEvent('event:session:summary', { tabId: w.tabId, summary, ofMessageId, model: SUMMARY_MODEL, ts: Date.now() });
-  } catch (e) {
-    logs.writeLine({ scope: 'webRemote', level: 'warn', message: 'summary failed; pushing raw', meta: { error: e?.message } });
-    pushEvent('event:session:summary', { tabId: w.tabId, summary: text.slice(0, 600), ofMessageId, model: 'raw', degraded: 'api_error', ts: Date.now() });
+  const { summary, model, degraded } = await _sharedSummarize(text);
+  if (degraded) {
+    logs.writeLine({ scope: 'webRemote', level: 'warn', message: `summary degraded: ${degraded}`, meta: {} });
   }
+  pushEvent('event:session:summary', {
+    tabId: w.tabId, summary, ofMessageId, model,
+    ...(degraded ? { degraded } : {}),
+    ts: Date.now(),
+  });
 }
 
 // ─── Message handling & command dispatch ─────────────────────────────────────

package/src/preload/api.d.ts

@@ -443,24 +443,6 @@ export interface HistoryAggregateResult {
   scannedMs: number;
 }
 
-export interface ConversationSummary {
-  /** ISO 8601 timestamp of the first event in the conversation (or file mtime fallback). */
-  timestamp: string;
-  /** Decoded project cwd, e.g. /home/user/Projects/foo. */
-  projectFolder: string;
-  stats: {
-    /** Wall-clock duration in ms (first event ts → last event ts). Omitted when unknown. */
-    duration?: number;
-    /** Sum of input + output tokens across the file. 0 when no usage blocks present. */
-    estimatedTokens: number;
-  };
-}
-
-export interface ListConversationsResult {
-  conversations: ConversationSummary[];
-  scannedMs: number;
-}
-
 export interface SessionScanEntry {
   sessionId: string;
   projectEncoded: string;
@@ -490,7 +472,6 @@ export interface FilesWriteResult { ok: boolean; error: string | null }
 export interface FilesCreateResult { ok: boolean; path?: string; error: string | null }
 export interface FilesRenameResult { ok: boolean; newPath?: string; error: string | null }
 export interface FilesDeleteResult { ok: boolean; error: string | null }
-export interface FilesShellResult { ok: boolean; error?: string }
 
 export interface SearchFileEntry {
   name: string;
@@ -681,6 +662,29 @@ export interface MemoryMutationResult {
   error: string | null;
 }
 
+export interface MemoryClusterLink {
+  from: string;
+  to: string;
+  label?: string;
+}
+
+export interface MemoryCluster {
+  id: string;
+  name: string;
+  summary: string;
+  memberSlugs: string[];
+  links: MemoryClusterLink[];
+}
+
+export interface MemoryAggregateResult {
+  workspace: string;
+  generatedAt: number | null;
+  clusters: MemoryCluster[];
+  orphans: string[];
+  cached: boolean;
+  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.
@@ -712,17 +716,6 @@ export interface AgentMemoryMutationResult {
   error: string | null;
 }
 
-export interface AgentMemoryAgentSummary {
-  agentId: string;
-  bytes: number;
-  mtimeMs: number;
-}
-
-export interface AgentMemoryListAgentsResult {
-  agents: AgentMemoryAgentSummary[];
-  error: string | null;
-}
-
 // ────────────────────────────────────────────── Git status (richer than app:git-branch)
 
 /** Mirrors the status returned by src/main/git.cjs mapStatus(). */
@@ -845,6 +838,59 @@ export interface WebRemoteAuditTailResult {
   error?: string;
 }
 
+// ────────────────────────────────────────────── Chat runner (PRD 319)
+
+export interface ChatRunPayload {
+  tabId: string;
+  /** UUID for the claude session — created by the caller; stays the same across
+   *  resumes so transcript context carries forward. */
+  sessionId: string;
+  prompt: string;
+  cwd: string;
+  /** When true, use --resume <sessionId> instead of --session-id. */
+  resume?: boolean;
+}
+
+export interface ChatRunQueuedEvent {
+  tabId: string;
+  sessionId: string;
+  /** 1-based position in the FIFO queue while waiting behind a busy lane. */
+  position: number;
+}
+
+export interface ChatRunStartedEvent {
+  tabId: string;
+  sessionId: string;
+}
+
+export interface ChatRunOutputEvent {
+  tabId: string;
+  /** Incremental text delta from one assistant content block. */
+  delta: string;
+}
+
+export interface ChatRunNeedsInputEvent {
+  tabId: string;
+  sessionId: string;
+  /** Questions the agent is blocked on. */
+  questions: string[];
+  /** Full raw assistant text including the stop-signal sentinel. */
+  raw: string;
+}
+
+export interface ChatRunCompleteEvent {
+  tabId: string;
+  sessionId: string;
+  /** The run's own final assistant message verbatim. */
+  finalMessage: string;
+}
+
+export interface ChatRunErrorEvent {
+  tabId: string;
+  sessionId: string;
+  message: string;
+}
+
 export interface SessionManagerAPI {
   app: {
     version: () => Promise<string>;
@@ -867,16 +913,6 @@ export interface SessionManagerAPI {
     homeSelfCheck: () => Promise<{ ok: boolean; error?: string; realCwd?: string }>;
     onNewSession: (handler: () => void) => () => void;
     onRebootSession: (handler: () => void) => () => void;
-    openInEditor: (cwd: string, editor?: string | null) => Promise<{ ok: boolean; opener?: string; error?: string }>;
-    /** Open an http/https URL in the OS default browser. file://, javascript:,
-     *  and other schemes are rejected with `ok:false` to prevent abuse. */
-    openExternal: (url: string) => Promise<{ ok: boolean; error?: string }>;
-    /** Open a specific file at line:col in the user's editor. Editors with
-     *  goto-line support (code/cursor/subl) get the `-g file:line:col` form;
-     *  others open the file alone. Image files are routed to the OS default viewer. */
-    openFileInEditor: (filePath: string, line?: number, col?: number, editor?: string | null) => Promise<{ ok: boolean; opener?: string; error?: string }>;
-    openInFinder: (cwd: string) => Promise<{ ok: boolean; opener?: string; error?: string }>;
-    openInTerminal: (cwd: string) => Promise<{ ok: boolean; opener?: string; error?: string }>;
     archiveProject: (encoded: string) => Promise<{ ok: boolean; error?: string }>;
   };
   pty: {
@@ -929,7 +965,6 @@ export interface SessionManagerAPI {
     onHotkeyConfigChanged: (handler: (cfg: VoiceHotkeyConfig) => void) => () => void;
     getHotkeyConfig: () => Promise<VoiceHotkeyConfig>;
     setHotkeyConfig: (cfg: VoiceHotkeyConfig) => Promise<VoiceSetHotkeyResult>;
-    getHotkeyConfigPath: () => Promise<string>;
     setRecording: (recording: boolean) => void;
     /** F5: read persisted audio-input device preference. */
     getDevicePref: () => Promise<VoiceDevicePref>;
@@ -965,8 +1000,21 @@ export interface SessionManagerAPI {
     create: (parentPath: string, name: string, kind: 'file' | 'folder') => Promise<FilesCreateResult>;
     rename: (path: string, newName: string) => Promise<FilesRenameResult>;
     delete: (path: string) => Promise<FilesDeleteResult>;
-    openExternal: (path: string) => Promise<FilesShellResult>;
-    showInFinder: (path: string) => Promise<FilesShellResult>;
+  };
+  /** Consolidated shell open/reveal. One method, discriminated on `as`, replaces
+   *  the former app.openIn* / app.openExternal / files.openExternal / files.showInFinder.
+   *  Each variant's boundary guard (home-scope / http(s)-only) runs in the main handler. */
+  shell: {
+    open: (
+      opts:
+        | { as: 'editor'; cwd: string; editor?: string | null }
+        | { as: 'fileInEditor'; path: string; line?: number; col?: number; editor?: string | null }
+        | { as: 'finder'; cwd: string }
+        | { as: 'terminal'; cwd: string }
+        | { as: 'external'; url: string }
+        | { as: 'openPath'; path: string }
+        | { as: 'revealPath'; path: string }
+    ) => Promise<{ ok: boolean; opener?: string; error?: string }>;
   };
   search: {
     files: (cwd: string, query?: string, opts?: { limit?: number }) => Promise<SearchFilesResult>;
@@ -983,7 +1031,6 @@ export interface SessionManagerAPI {
   };
   history: {
     aggregate: (req?: HistoryAggregateRequest) => Promise<HistoryAggregateResult>;
-    listConversations: () => Promise<ListConversationsResult>;
     scanProjects: () => Promise<SessionScanResult>;
   };
   schedule: {
@@ -993,7 +1040,6 @@ export interface SessionManagerAPI {
     runNow: () => Promise<{ ok: boolean }>;
     forceTick: () => Promise<{ ok: boolean }>;
     resume: () => Promise<{ ok: boolean }>;
-    refreshReset: () => Promise<{ ok: boolean; nextReset: string | null }>;
     /** Re-scan prds/ and merge into queue.json; broadcasts updated state. */
     rescan: () => Promise<{ ok: boolean }>;
     /** Move all pending+failed PRDs to prds-archived/<ISO>/ and drop their
@@ -1057,6 +1103,8 @@ export interface SessionManagerAPI {
     delete: (name: string, workspace?: string) => Promise<MemoryMutationResult>;
     /** Create a new memory entry with starter frontmatter + body. */
     create: (name: string, description?: string, workspace?: string) => Promise<MemoryMutationResult>;
+    /** Aggregate workspace memories into semantic clusters. `refresh:true` fires a cost-gated `claude -p` pass; otherwise returns the cache only. */
+    aggregate: (workspace: string, refresh?: boolean) => Promise<MemoryAggregateResult>;
   };
   agentMemory: {
     /** List all memory entries for one subagent. Sorted newest first. */
@@ -1072,8 +1120,6 @@ export interface SessionManagerAPI {
     ) => Promise<AgentMemoryMutationResult>;
     /** Delete one entry. Removes the file outright when last entry is removed. */
     delete: (agentId: string, entryId: string) => Promise<AgentMemoryMutationResult>;
-    /** List all agents that currently have a memory file on disk. */
-    listAgents: () => Promise<AgentMemoryListAgentsResult>;
   };
   docEditor: {
     pickFile: (payload?: { lastDir?: string }) => Promise<{ path: string | null; error?: string }>;
@@ -1121,88 +1167,48 @@ export interface SessionManagerAPI {
      *  E2E session as authenticated and unblocks MUTATE-tier commands. */
     confirmSas: () => Promise<WebRemoteMutationResult>;
   };
-  kg: {
-    /** Distilled knowledge graph + ingest status for ONE project (`cwd`).
-     *  Omit `cwd` for the most-active project. */
-    get: (cwd?: string) => Promise<KgState>;
-    /** Projects seen in the prompt log, with per-project graph stats. */
-    projects: () => Promise<KgProject[]>;
-    /** Process new prompt-log lines into per-project graphs (incremental, global). */
-    ingest: () => Promise<{ ok: boolean; added?: number; projects?: number; stopped?: boolean; error?: string; note?: string }>;
-    /** Ask a question answered from ONE project's graph + prompts via claude -p. */
-    ask: (question: string, cwd?: string) => Promise<{ ok: boolean; answer?: string; cited?: { ts: string; prompt: string }[]; error?: string }>;
-    /** Purge graphs: one project (`{ cwd }`) or all (`{ all: true }`). */
-    clear: (arg?: { cwd?: string; all?: boolean }) => Promise<{ ok: boolean; cleared?: string; removed?: number }>;
-    /** Toggle the recurring claude -p extraction on/off (sets captureMode 'llm'/'off'). */
-    setExtraction: (enabled: boolean) => Promise<{ ok: boolean; extractionEnabled: boolean }>;
-    /** Set capture mode: 'llm' = claude -p extraction; 'lite' = heuristic (free); 'off' = disabled. */
-    setCaptureMode: (mode: 'llm' | 'lite' | 'off') => Promise<{ ok: boolean; captureMode?: string; error?: string }>;
-    onIngestProgress: (handler: (ev: KgIngestProgress) => void) => () => void;
+  chat: {
+    /** Spawn a headless `claude -p` run for a tab. Results arrive via the on* listeners. */
+    run: (payload: ChatRunPayload) => Promise<{ ok: boolean }>;
+    /** Cancel the in-flight run for a tab (SIGTERM→SIGKILL). No-op when idle. */
+    cancel: (tabId: string) => void;
+    onQueued: (handler: (e: ChatRunQueuedEvent) => void) => () => void;
+    onRunStarted: (handler: (e: ChatRunStartedEvent) => void) => () => void;
+    onOutput: (handler: (e: ChatRunOutputEvent) => void) => () => void;
+    onNeedsInput: (handler: (e: ChatRunNeedsInputEvent) => void) => () => void;
+    onComplete: (handler: (e: ChatRunCompleteEvent) => void) => () => void;
+    onError: (handler: (e: ChatRunErrorEvent) => void) => () => void;
+  };
+  exchanges: {
+    /** Durable per-exchange log entries for a project, newest-first (max 100 by default). */
+    list: (payload: {
+      cwd: string;
+      sessionId?: string;
+      limit?: number;
+      offset?: number;
+    }) => Promise<Exchange[]>;
   };
 }
 
-export interface KgProject {
-  cwd: string;
-  /** Last path segment of `cwd`, for display. */
-  label: string;
-  /** Prompts logged for this project (real prompts only). */
-  total: number;
-  /** Prompts already distilled into this project's graph. */
-  processed: number;
-  /** total - processed. */
-  pending: number;
-  nodes: number;
-  edges: number;
-  lastIngest: string | null;
-}
-
-export interface KgNode {
-  id: string;
-  key: string;
-  name: string;
-  type: string;
-  description: string;
-  count: number;
-  firstTs: string | null;
-  lastTs: string | null;
-}
-export interface KgEdge {
-  src: string;
-  dst: string;
-  relation: string;
-  weight: number;
-  lastTs: string | null;
-}
-export interface KgState {
-  /** The project this graph belongs to. */
+// ────────────────────────────────────────────── Exchanges (PRD 324 read path)
+
+export interface Exchange {
+  /** ISO 8601 timestamp when the exchange was recorded. */
+  ts: string;
+  /** Claude session UUID. */
+  sessionId: string;
+  /** Project cwd. */
   cwd: string;
-  /** Last path segment of `cwd`, for display. */
-  label: string;
-  nodes: KgNode[];
-  edges: KgEdge[];
-  status: {
-    promptCount: number;
-    totalPrompts: number;
-    pending: number;
-    lastIngest: string | null;
-    ingesting: boolean;
-    logPath: string;
-    extractionEnabled: boolean;
-    /** Active capture mode: 'llm' | 'lite' | 'off'. */
-    captureMode: 'llm' | 'lite' | 'off';
-    /** Node cap from kg-config.json; 0 = disabled; default 300. */
-    maxGraphNodes: number;
-  };
-}
-export interface KgIngestProgress {
-  phase: 'start' | 'extract' | 'batch' | 'done' | 'error';
-  ingesting: boolean;
-  batch?: number;
-  totalBatches?: number;
-  added?: number;
-  /** Set on `batch`: the project cwd whose graph just committed. */
-  cwd?: string;
-  error?: string;
+  /** The user prompt that started the exchange. */
+  prompt: string;
+  /** The verbatim assistant result. */
+  result: string;
+  /** Haiku-generated one-sentence summary. */
+  summary: string;
+  /** Haiku model used for the summary (informational). */
+  model?: string;
+  /** Set when summarization failed — `result` is available but `summary` may be empty. */
+  degraded?: boolean;
 }
 
 declare global {