claude-code-session-manager 0.33.1 → 0.34.0

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 {

package/src/preload/index.cjs

@@ -9,11 +9,6 @@ contextBridge.exposeInMainWorld('api', {
     pickDirectory: () => ipcRenderer.invoke('app:pick-directory'),
     gitBranch: (cwd) => ipcRenderer.invoke('app:git-branch', { cwd }),
     rebootApp: () => ipcRenderer.send('app:reboot-app'),
-    openInEditor: (cwd, editor) => ipcRenderer.invoke('app:open-in-editor', { cwd, editor }),
-    openExternal: (url) => ipcRenderer.invoke('app:open-external', { url }),
-    openFileInEditor: (filePath, line, col, editor) => ipcRenderer.invoke('app:open-file-in-editor', { path: filePath, line, col, editor }),
-    openInFinder: (cwd) => ipcRenderer.invoke('app:open-in-finder', { cwd }),
-    openInTerminal: (cwd) => ipcRenderer.invoke('app:open-in-terminal', { cwd }),
     archiveProject: (encoded) => ipcRenderer.invoke('app:archive-project', { encoded }),
     testFireHook: (args) => ipcRenderer.invoke('app:test-fire-hook', args),
     // F7: lets the renderer suppress the wizard auto-trigger under SM_E2E=1.
@@ -121,7 +116,6 @@ contextBridge.exposeInMainWorld('api', {
     },
     getHotkeyConfig: () => ipcRenderer.invoke('voice:get-hotkey-config'),
     setHotkeyConfig: (cfg) => ipcRenderer.invoke('voice:set-hotkey', cfg),
-    getHotkeyConfigPath: () => ipcRenderer.invoke('voice:get-hotkey-config-path'),
     setRecording: (recording) => ipcRenderer.send('voice:set-recording', !!recording),
     // F5 device picker prefs (~/.config/session-manager/voice.json `device` key).
     getDevicePref: () => ipcRenderer.invoke('voice:get-device-pref'),
@@ -158,7 +152,6 @@ contextBridge.exposeInMainWorld('api', {
   },
   history: {
     aggregate: (req) => ipcRenderer.invoke('history:aggregate', req),
-    listConversations: () => ipcRenderer.invoke('history:list-conversations'),
     scanProjects: () => ipcRenderer.invoke('history:scan-projects'),
   },
   files: {
@@ -168,8 +161,11 @@ contextBridge.exposeInMainWorld('api', {
     create: (parentPath, name, kind) => ipcRenderer.invoke('files:create', { parentPath, name, kind }),
     rename: (path, newName) => ipcRenderer.invoke('files:rename', { path, newName }),
     delete: (path) => ipcRenderer.invoke('files:delete', { path }),
-    openExternal: (path) => ipcRenderer.invoke('files:open-external', { path }),
-    showInFinder: (path) => ipcRenderer.invoke('files:show-in-finder', { path }),
+  },
+  // Consolidated shell open/reveal — see shell:open in index.cjs.
+  // as: 'editor' | 'fileInEditor' | 'finder' | 'terminal' | 'external' | 'openPath' | 'revealPath'
+  shell: {
+    open: (opts) => ipcRenderer.invoke('shell:open', opts),
   },
   search: {
     files: (cwd, query, opts) => ipcRenderer.invoke('search:files', { cwd, query, opts }),
@@ -191,7 +187,6 @@ contextBridge.exposeInMainWorld('api', {
     runNow: () => ipcRenderer.invoke('schedule:run-now'),
     forceTick: () => ipcRenderer.invoke('schedule:force-tick'),
     resume: () => ipcRenderer.invoke('schedule:resume'),
-    refreshReset: () => ipcRenderer.invoke('schedule:refresh-reset'),
     rescan: () => ipcRenderer.invoke('schedule:rescan'),
     clearQueue: () => ipcRenderer.invoke('schedule:clear-queue'),
     openFolder: () => ipcRenderer.invoke('schedule:open-folder'),
@@ -244,6 +239,8 @@ contextBridge.exposeInMainWorld('api', {
       if (workspace) payload.workspace = workspace;
       return ipcRenderer.invoke('memory:create', payload);
     },
+    aggregate: (workspace, refresh) =>
+      ipcRenderer.invoke('memory:aggregate', refresh ? { workspace, refresh: true } : { workspace }),
   },
   agentMemory: {
     list: (agentId) => ipcRenderer.invoke('agent-memory:list', { agentId }),
@@ -254,7 +251,6 @@ contextBridge.exposeInMainWorld('api', {
       return ipcRenderer.invoke('agent-memory:set', payload);
     },
     delete: (agentId, entryId) => ipcRenderer.invoke('agent-memory:delete', { agentId, entryId }),
-    listAgents: () => ipcRenderer.invoke('agent-memory:list-agents'),
   },
   docEditor: {
     pickFile: (payload) => ipcRenderer.invoke('doc-editor:pick-file', payload),
@@ -320,25 +316,45 @@ contextBridge.exposeInMainWorld('api', {
       return () => ipcRenderer.removeListener('webRemote:revoked-all', listener);
     },
   },
-  kg: {
-    /** Knowledge Graph distilled from the prompt log (~/.claude/knowledge-log),
-     *  segregated per project. `cwd` selects which project's graph; omit for the
-     *  most-active project. */
-    get: (cwd) => ipcRenderer.invoke('kg:get', { cwd }),
-    /** Projects seen in the log, with per-project graph stats (for the selector). */
-    projects: () => ipcRenderer.invoke('kg:projects'),
-    ingest: () => ipcRenderer.invoke('kg:ingest'),
-    ask: (question, cwd) => ipcRenderer.invoke('kg:ask', { question, cwd }),
-    /** Purge graphs: one project (cwd) or all (`{ all: true }`). */
-    clear: (arg) => ipcRenderer.invoke('kg:clear', arg ?? {}),
-    /** Toggle the recurring `claude -p` extraction on/off. */
-    setExtraction: (enabled) => ipcRenderer.invoke('kg:set-extraction', { enabled }),
-    /** Set capture mode: 'llm' | 'lite' | 'off'. */
-    setCaptureMode: (mode) => ipcRenderer.invoke('kg:set-capture-mode', { mode }),
-    onIngestProgress: (handler) => {
+  chat: {
+    /** Spawn a headless claude -p job. Results arrive via the on* listeners. */
+    run: (payload) => ipcRenderer.invoke('chat:run', payload),
+    /** Cancel an in-flight run for the given tabId. No-op if none running. */
+    cancel: (tabId) => ipcRenderer.send('chat:cancel', { tabId }),
+    onQueued: (handler) => {
+      const listener = (_e, payload) => handler(payload);
+      ipcRenderer.on('chat:run:queued', listener);
+      return () => ipcRenderer.removeListener('chat:run:queued', listener);
+    },
+    onRunStarted: (handler) => {
+      const listener = (_e, payload) => handler(payload);
+      ipcRenderer.on('chat:run:started', listener);
+      return () => ipcRenderer.removeListener('chat:run:started', listener);
+    },
+    onOutput: (handler) => {
+      const listener = (_e, payload) => handler(payload);
+      ipcRenderer.on('chat:run:output', listener);
+      return () => ipcRenderer.removeListener('chat:run:output', listener);
+    },
+    onNeedsInput: (handler) => {
+      const listener = (_e, payload) => handler(payload);
+      ipcRenderer.on('chat:run:needs-input', listener);
+      return () => ipcRenderer.removeListener('chat:run:needs-input', listener);
+    },
+    onComplete: (handler) => {
       const listener = (_e, payload) => handler(payload);
-      ipcRenderer.on('kg:ingest-progress', listener);
-      return () => ipcRenderer.removeListener('kg:ingest-progress', listener);
+      ipcRenderer.on('chat:run:complete', listener);
+      return () => ipcRenderer.removeListener('chat:run:complete', listener);
     },
+    onError: (handler) => {
+      const listener = (_e, payload) => handler(payload);
+      ipcRenderer.on('chat:run:error', listener);
+      return () => ipcRenderer.removeListener('chat:run:error', listener);
+    },
+  },
+  exchanges: {
+    /** List exchanges for a project (durable chat-run log), newest-first.
+     *  `sessionId` filters to one session; `limit`/`offset` for pagination. */
+    list: (payload) => ipcRenderer.invoke('exchanges:list', payload),
   },
 });