claude-code-session-manager 0.33.1 → 0.34.0

package/src/main/historyAggregator.cjs

@@ -42,12 +42,6 @@ class LRUCache {
  */
 const aggrCache = new LRUCache(CACHE_MAX);
 
-/**
- * Cache for parseConversationMeta results.
- * Entry shape: { mtimeMs: number, size: number, readOffset: number, inode: number, result: MetaResult }
- */
-const metaCache = new LRUCache(CACHE_MAX);
-
 // ── date helpers ──────────────────────────────────────────────────────────────
 
 function decodeCwd(encoded) {
@@ -143,31 +137,6 @@ function scanAggrLines(lines, acc, captureFirst) {
   return firstTs;
 }
 
-/**
- * Scan JSONL lines into a conversation-meta accumulator (mutates meta).
- * captureFirst=true: record the first timestamp seen as meta.firstTs.
- */
-function scanMetaLines(lines, meta, captureFirst) {
-  for (const raw of lines) {
-    const line = raw.trim();
-    if (!line) continue;
-    let obj;
-    try { obj = JSON.parse(line); } catch { continue; }
-    const ts = obj.ts ?? obj.timestamp;
-    if (ts) {
-      if (captureFirst && meta.firstTs === null) meta.firstTs = ts;
-      meta.lastTs = ts;
-    }
-    const usage = obj.usage ?? obj.message?.usage;
-    if (usage && typeof usage === 'object') {
-      const inT = usage.input_tokens ?? usage.inputTokens;
-      const outT = usage.output_tokens ?? usage.outputTokens;
-      if (typeof inT === 'number') meta.inputTokens += inT;
-      if (typeof outT === 'number') meta.outputTokens += outT;
-    }
-  }
-}
-
 // ── cached file parsers ───────────────────────────────────────────────────────
 
 /**
@@ -271,71 +240,6 @@ async function parseJSONL(filePath, stat) {
   return { result: acc, cacheHit: false };
 }
 
-/**
- * Parse a JSONL transcript for per-conversation metadata.
- * Returns { result, cacheHit } — same caching strategy as parseJSONL.
- */
-async function parseConversationMeta(filePath, stat) {
-  const emptyMeta = () => ({
-    firstTs: null,
-    lastTs: null,
-    inputTokens: 0,
-    outputTokens: 0,
-    skipped: false,
-  });
-
-  if (stat.size > MAX_FILE_BYTES) {
-    return { result: { ...emptyMeta(), skipped: true }, cacheHit: false };
-  }
-
-  const cached = metaCache.get(filePath);
-  if (cached) {
-    if (cached.size === stat.size && cached.mtimeMs === stat.mtimeMs) {
-      return { result: cached.result, cacheHit: true };
-    }
-
-    if (stat.size > cached.size) {
-      if (cached.inode !== undefined && cached.inode !== stat.ino) {
-        // inode changed → file replaced; fall through to full parse
-      } else {
-        try {
-          const readFrom = cached.readOffset ?? cached.size;
-          const tail = await readSlice(filePath, readFrom, stat.size);
-          const delta = emptyMeta();
-          scanMetaLines(tail.split('\n'), delta, false);
-          const prev = cached.result;
-          const merged = {
-            firstTs: prev.firstTs, // first timestamp never changes on appends
-            lastTs: delta.lastTs ?? prev.lastTs,
-            inputTokens: prev.inputTokens + delta.inputTokens,
-            outputTokens: prev.outputTokens + delta.outputTokens,
-            skipped: false,
-          };
-          const lastNl = tail.lastIndexOf('\n');
-          const readOffset = lastNl >= 0 ? readFrom + lastNl + 1 : readFrom;
-          metaCache.set(filePath, { mtimeMs: stat.mtimeMs, size: stat.size, readOffset, inode: stat.ino, result: merged });
-          return { result: merged, cacheHit: false };
-        } catch {
-          // fall through to full parse
-        }
-      }
-    }
-  }
-
-  // Full parse
-  let text;
-  try { text = await fsp.readFile(filePath, 'utf8'); } catch {
-    return { result: emptyMeta(), cacheHit: false };
-  }
-
-  const meta = emptyMeta();
-  scanMetaLines(text.split('\n'), meta, true);
-  const lastNlMeta = text.lastIndexOf('\n');
-  const readOffsetMeta = lastNlMeta >= 0 ? lastNlMeta + 1 : 0;
-  metaCache.set(filePath, { mtimeMs: stat.mtimeMs, size: stat.size, readOffset: readOffsetMeta, inode: stat.ino, result: meta });
-  return { result: meta, cacheHit: false };
-}
-
 // ── aggregate ─────────────────────────────────────────────────────────────────
 
 async function aggregate(req) {
@@ -490,72 +394,6 @@ function registerHistoryAggregatorHandlers() {
     sessions.sort((a, b) => b.mtimeMs - a.mtimeMs);
     return { sessions, scannedMs: Date.now() - t0 };
   });
-
-  /** Per-conversation metadata: one row per JSONL with derived duration +
-   *  token totals. Used by the Overview detailed-stats panel to compute
-   *  hourly/daily distribution + top-projects. */
-  ipcMain.handle('history:list-conversations', async () => {
-    const t0 = Date.now();
-    const conversations = [];
-    let truncated = false;
-    let skippedBudgetFiles = 0;
-    let parseBudgetSpentMs = 0;
-
-    let projectEntries;
-    try {
-      projectEntries = await fsp.readdir(PROJECTS_DIR, { withFileTypes: true });
-    } catch {
-      return { conversations: [], truncated: false, scannedMs: Date.now() - t0 };
-    }
-
-    outer:
-    for (const ent of projectEntries) {
-      if (!ent.isDirectory()) continue;
-      const projectDir = path.join(PROJECTS_DIR, ent.name);
-      const projectFolder = '/' + ent.name.replace(/-/g, '/');
-      let files;
-      try { files = await fsp.readdir(projectDir, { withFileTypes: true }); } catch { continue; }
-
-      for (const f of files) {
-        if (!f.isFile() || !f.name.endsWith('.jsonl')) continue;
-        const filePath = path.join(projectDir, f.name);
-        let stat;
-        try { stat = await fsp.stat(filePath); } catch { continue; }
-
-        const t1 = Date.now();
-        const { result: meta, cacheHit } = await parseConversationMeta(filePath, stat);
-        if (!cacheHit) parseBudgetSpentMs += Date.now() - t1;
-
-        if (!meta.skipped) {
-          const firstTs = meta.firstTs || new Date(stat.mtimeMs).toISOString();
-          const duration =
-            meta.firstTs && meta.lastTs
-              ? Math.max(0, Date.parse(meta.lastTs) - Date.parse(meta.firstTs))
-              : undefined;
-          conversations.push({
-            timestamp: firstTs,
-            projectFolder,
-            stats: {
-              ...(duration !== undefined ? { duration } : {}),
-              estimatedTokens: meta.inputTokens + meta.outputTokens,
-            },
-          });
-        }
-
-        if (!cacheHit && parseBudgetSpentMs > PARSE_BUDGET_MS) {
-          skippedBudgetFiles++;
-          truncated = true;
-          console.warn(
-            `[historyAggregator] list-conversations: parse budget exhausted after ${parseBudgetSpentMs}ms; ` +
-            `at least ${skippedBudgetFiles} file(s) skipped`
-          );
-          break outer;
-        }
-      }
-    }
-
-    return { conversations, truncated, scannedMs: Date.now() - t0 };
-  });
 }
 
 const remote = { aggregate };

package/src/main/index.cjs

@@ -31,16 +31,18 @@ const otel = require('./otel.cjs');
 const otelSettings = require('./otelSettings.cjs');
 const { registerHistoryAggregatorHandlers } = require('./historyAggregator.cjs');
 const memoryTool = require('./memoryTool.cjs');
+const { registerMemoryAggregateIpc } = require('./memoryAggregate.cjs');
 const agentMemory = require('./agentMemory.cjs');
 const { registerDocEditorHandlers } = require('./docEditor.cjs');
 const git = require('./git.cjs');
 const superagent = require('./superagent.cjs');
-const kg = require('./kg.cjs');
 const filesIpc = require('./files.cjs');
 const searchIpc = require('./search.cjs');
 const repoAnalyzer = require('./repoAnalyzer.cjs');
 const hivesIpc = require('./hives.cjs');
 const webRemote = require('./webRemote.cjs');
+const chatRunner = require('./chatRunner.cjs');
+const { listExchanges } = require('./exchanges.cjs');
 const { resolveClaudeBin } = require('./lib/claudeBin.cjs');
 const { checkInsideHome, assertInsideHome } = require('./lib/insideHome.cjs');
 const { openInEditor, openFileInEditor, openInFinder, openInTerminal } = require('./lib/openExternalApp.cjs');
@@ -270,6 +272,7 @@ async function rebootApp() {
     watchers.attachWindow(mainWindow);
     pluginInstall.attachWindow(mainWindow);
     superagent.attachWindow(mainWindow);
+    chatRunner.attachWindow(mainWindow);
     rebooting = false;
     return;
   }
@@ -581,57 +584,66 @@ ipcMain.handle('app:git-branch', validated(schemas.appGitBranch, async ({ cwd })
 // in lib/insideHome.cjs — single chokepoint for the /home/bilkoEVIL prefix-trap.
 // Editor / finder / terminal logic lives in lib/openExternalApp.cjs.
 
-ipcMain.handle('app:open-in-editor', validated(schemas.openInEditor, async ({ cwd, editor }) => {
-  const r = checkInsideHome(cwd);
-  if (!r.ok) throw new Error(r.error);
-  return openInEditor({ cwd, editor });
-}));
-
-ipcMain.handle('app:open-external', validated(schemas.openExternal, async ({ url }) => {
-  // URL filter mirrors setWindowOpenHandler at line ~631: without it, the
-  // renderer could be tricked into asking shell.openExternal to launch
-  // `file:///etc/passwd`, `javascript:…`, or `mailto:…`. Stick to web URLs.
-  if (!url.startsWith('http://') && !url.startsWith('https://')) {
-    return { ok: false, error: 'only http/https URLs are allowed' };
-  }
-  await shell.openExternal(url);
-  return { ok: true };
-}));
-
-ipcMain.handle('app:open-file-in-editor', validated(schemas.openFileInEditor, async ({ path: p, line, col, editor }) => {
-  const home = os.homedir();
-  const abs = path.isAbsolute(p) ? p : path.resolve(home, p);
-  // Allowed roots: $HOME (the usual case) plus our own clipboard temp dir
-  // (clipboard-paste writes PNGs there; clicks on those paths from the
-  // terminal must resolve). Resolve symlinks on both sides — on macOS
-  // /tmp is a symlink to /private/tmp, so a literal prefix check fails.
-  const clipboardDirRaw = path.join(os.tmpdir(), 'session-manager-clipboard');
-  let clipboardDirReal = clipboardDirRaw;
-  try { clipboardDirReal = fs.realpathSync(clipboardDirRaw); } catch { /* not yet created */ }
-  let absReal = abs;
-  try { absReal = fs.realpathSync(abs); } catch { /* file may not exist yet — fall through to access() below */ }
-  const inClipboardTmp =
-    absReal === clipboardDirReal ||
-    absReal.startsWith(clipboardDirReal + path.sep) ||
-    abs === clipboardDirRaw ||
-    abs.startsWith(clipboardDirRaw + path.sep);
-  if (!inClipboardTmp) {
-    const r = checkInsideHome(abs);
-    if (!r.ok) throw new Error(r.error);
+// Consolidated shell open/reveal endpoint. One channel, discriminated on `as`,
+// replaces five app:open-* handlers plus files:open-external / show-in-finder.
+// Each branch keeps its own boundary guard (home-scope or http(s)-only).
+ipcMain.handle('shell:open', validated(schemas.shellOpen, async (opts) => {
+  switch (opts.as) {
+    case 'editor': {
+      const r = checkInsideHome(opts.cwd);
+      if (!r.ok) throw new Error(r.error);
+      return openInEditor({ cwd: opts.cwd, editor: opts.editor });
+    }
+    case 'finder': {
+      const r = checkInsideHome(opts.cwd);
+      if (!r.ok) throw new Error(r.error);
+      return openInFinder({ cwd: opts.cwd });
+    }
+    case 'terminal': {
+      const r = checkInsideHome(opts.cwd);
+      if (!r.ok) throw new Error(r.error);
+      return openInTerminal({ cwd: opts.cwd });
+    }
+    case 'external': {
+      // Without this, the renderer could ask shell.openExternal to launch
+      // `file:///etc/passwd`, `javascript:…`, or `mailto:…`. Web URLs only.
+      const url = opts.url;
+      if (!url.startsWith('http://') && !url.startsWith('https://')) {
+        return { ok: false, error: 'only http/https URLs are allowed' };
+      }
+      await shell.openExternal(url);
+      return { ok: true };
+    }
+    case 'fileInEditor': {
+      const home = os.homedir();
+      const abs = path.isAbsolute(opts.path) ? opts.path : path.resolve(home, opts.path);
+      // Allowed roots: $HOME plus our own clipboard temp dir (clipboard-paste
+      // writes PNGs there; terminal clicks on those paths must resolve).
+      // Resolve symlinks on both sides — on macOS /tmp → /private/tmp.
+      const clipboardDirRaw = path.join(os.tmpdir(), 'session-manager-clipboard');
+      let clipboardDirReal = clipboardDirRaw;
+      try { clipboardDirReal = fs.realpathSync(clipboardDirRaw); } catch { /* not yet created */ }
+      let absReal = abs;
+      try { absReal = fs.realpathSync(abs); } catch { /* may not exist yet — access() below */ }
+      const inClipboardTmp =
+        absReal === clipboardDirReal ||
+        absReal.startsWith(clipboardDirReal + path.sep) ||
+        abs === clipboardDirRaw ||
+        abs.startsWith(clipboardDirRaw + path.sep);
+      if (!inClipboardTmp) {
+        const r = checkInsideHome(abs);
+        if (!r.ok) throw new Error(r.error);
+      }
+      return openFileInEditor({ path: abs, line: opts.line, col: opts.col, editor: opts.editor });
+    }
+    case 'openPath':
+      // validateHomePath runs inside filesIpc.openExternal.
+      return filesIpc.openExternal(opts.path);
+    case 'revealPath':
+      return filesIpc.showInFinder(opts.path);
+    default:
+      return { ok: false, error: 'unknown open target' };
   }
-  return openFileInEditor({ path: abs, line, col, editor });
-}));
-
-ipcMain.handle('app:open-in-finder', validated(schemas.openInFinder, async ({ cwd }) => {
-  const r = checkInsideHome(cwd);
-  if (!r.ok) throw new Error(r.error);
-  return openInFinder({ cwd });
-}));
-
-ipcMain.handle('app:open-in-terminal', validated(schemas.openInTerminal, async ({ cwd }) => {
-  const r = checkInsideHome(cwd);
-  if (!r.ok) throw new Error(r.error);
-  return openInTerminal({ cwd });
 }));
 
 ipcMain.handle('app:archive-project', validated(schemas.archiveProject, async ({ encoded }) => {
@@ -659,6 +671,7 @@ queueOps.registerQueueOpsHandlers();
 registerHistoryAggregatorHandlers();
 pluginInstall.registerPluginInstallHandlers();
 memoryTool.registerMemoryHandlers();
+registerMemoryAggregateIpc();
 agentMemory.registerAgentMemoryHandlers();
 registerDocEditorHandlers();
 git.register(ipcMain);
@@ -668,6 +681,17 @@ searchIpc.registerSearchHandlers();
 repoAnalyzer.register(ipcMain);
 hivesIpc.registerHiveHandlers();
 webRemote.registerRemoteHandlers();
+chatRunner.registerChatHandlers();
+
+// Exchanges: read the durable per-exchange log (written by chatRunner → recordExchange).
+ipcMain.handle('exchanges:list', validated(schemas.exchangesList, async (payload) => {
+  try {
+    return await listExchanges(payload);
+  } catch (e) {
+    logs.writeLine({ scope: 'exchanges', level: 'error', message: 'listExchanges failed', meta: { error: e?.message } });
+    return [];
+  }
+}));
 
 // OTEL telemetry export (opt-in via ~/.config/session-manager/otel.json).
 ipcMain.handle('otel:get-config', async () => otelSettings.load());
@@ -954,8 +978,8 @@ app.whenReady().then(async () => {
   watchers.attachWindow(mainWindow);
   pluginInstall.attachWindow(mainWindow);
   superagent.attachWindow(mainWindow);
-  kg.attachWindow(mainWindow);
   webRemote.attachWindow(mainWindow);
+  chatRunner.attachWindow(mainWindow);
   scheduler.init().catch((e) => {
     logs.writeLine({ scope: 'scheduler', level: 'error', message: 'init failed', meta: { error: e?.message } });
   });
@@ -968,11 +992,6 @@ app.whenReady().then(async () => {
   webRemote.init().catch((e) => {
     logs.writeLine({ scope: 'webRemote', level: 'error', message: 'init failed', meta: { error: e?.message } });
   });
-  // Knowledge Graph: watch the prompt log + register kg:* IPC. Best-effort.
-  try { kg.init({ logger: logs }); } catch (e) {
-    logs.writeLine({ scope: 'kg', level: 'error', message: 'init failed', meta: { error: e?.message } });
-  }
-
   // Keep the machine awake while the app is open. The scheduler polls billing
   // usage every 2 min and runs `claude -p` jobs that must survive an idle
   // laptop — a system suspend (GNOME/Pop!_OS idle or lid timeout) would freeze

package/src/main/ipcSchemas.cjs

@@ -141,29 +141,22 @@ const scheduleRetagPrd = z.object({
 // ──────────────────────────────────────────── Projects
 const ENCODED_SLUG_RE = /^[A-Za-z0-9._-]+$/;
 
-const openInEditor = z.object({
-  cwd: z.string().min(1).max(4096),
-  editor: z.string().max(256).nullable().optional(),
-});
-
-const openExternal = z.object({
-  url: z.string().min(1).max(4096),
-});
-
-const openFileInEditor = z.object({
-  path: z.string().min(1).max(4096),
-  line: z.number().int().positive().optional(),
-  col: z.number().int().positive().optional(),
-  editor: z.string().max(256).nullable().optional(),
-});
-
-const openInFinder = z.object({
-  cwd: z.string().min(1).max(4096),
-});
-
-const openInTerminal = z.object({
-  cwd: z.string().min(1).max(4096),
-});
+// Consolidated shell "open/reveal" API. One channel (shell:open) replaces the
+// former app:open-in-editor / open-file-in-editor / open-in-finder /
+// open-in-terminal / open-external + files:open-external / show-in-finder.
+// Discriminated on `as`; each variant carries only its own fields. Per-variant
+// path/URL guards still run inside the handler (checkInsideHome / http(s) only).
+const _pathStr = z.string().min(1).max(4096);
+const _editorStr = z.string().max(256).nullable().optional();
+const shellOpen = z.discriminatedUnion('as', [
+  z.object({ as: z.literal('editor'), cwd: _pathStr, editor: _editorStr }),
+  z.object({ as: z.literal('fileInEditor'), path: _pathStr, line: z.number().int().positive().optional(), col: z.number().int().positive().optional(), editor: _editorStr }),
+  z.object({ as: z.literal('finder'), cwd: _pathStr }),
+  z.object({ as: z.literal('terminal'), cwd: _pathStr }),
+  z.object({ as: z.literal('external'), url: _pathStr }),
+  z.object({ as: z.literal('openPath'), path: _pathStr }),
+  z.object({ as: z.literal('revealPath'), path: _pathStr }),
+]);
 
 const archiveProject = z.object({
   encoded: z.string().regex(ENCODED_SLUG_RE).min(1).max(4096),
@@ -223,6 +216,16 @@ const memoryCreate = z.object({
   description: z.string().max(2048).optional(),
 }).strict();
 
+// memory:aggregate — Memory Clusters (PRD 356). `workspace` here is already
+// the encoded cwd slug (memoryAggregate.cjs reads directly from
+// ~/.claude/projects/<workspace>/memory/), same regex as the other memory:*
+// handlers. `refresh: true` is the cost gate that fires the single claude -p
+// clustering pass; falsy returns the cached result.
+const memoryAggregate = z.object({
+  workspace: z.string().regex(MEMORY_WORKSPACE_RE),
+  refresh: z.boolean().optional(),
+}).strict();
+
 // ──────────────────────────────────────────── Per-subagent memory
 // Distinct from the workspace-scoped Memory tool: agentMemory is keyed by
 // subagent name (the .md filename in ~/.claude/agents/, e.g. "code-reviewer"),
@@ -253,6 +256,37 @@ const agentMemoryDelete = z.object({
   entryId: z.string().regex(AGENT_MEMORY_ID_RE),
 }).strict();
 
+// ──────────────────────────────────────────── Exchanges (PRD 324 read path)
+const SESSION_ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
+
+const exchangesList = z.object({
+  cwd: z.string().min(1).max(4096),
+  sessionId: z.string().regex(SESSION_ID_RE).optional(),
+  limit: z.number().int().min(1).max(500).optional(),
+  offset: z.number().int().min(0).max(100000).optional(),
+}).strict();
+
+// ──────────────────────────────────────────── Chat runner (PRD 319)
+// Prompt cap: 100 KiB. Matches a generous interactive message budget while
+// preventing accidental megabyte pastes from reaching claude -p.
+const CHAT_PROMPT_MAX_BYTES = 100 * 1024;
+
+const chatRun = z.object({
+  tabId: z.string().min(1).max(128),
+  sessionId: z.string().min(1).max(128),
+  // Non-empty; capped so a malformed renderer can't spawn a 100 MB child argv.
+  prompt: z.string().min(1).refine(
+    (s) => Buffer.byteLength(s, 'utf8') <= CHAT_PROMPT_MAX_BYTES,
+    `prompt must be ≤ ${CHAT_PROMPT_MAX_BYTES} bytes`,
+  ),
+  cwd: z.string().min(1).max(4096),
+  resume: z.boolean().optional().default(false),
+});
+
+const chatCancel = z.object({
+  tabId: z.string().min(1).max(128),
+});
+
 // ──────────────────────────────────────────── Web Remote
 // OTP is 8 uppercase alphanumeric chars (case-insensitive entry, normalised to upper in handler).
 const WEB_REMOTE_OTP_RE = /^[A-Z0-9]{8}$/i;
@@ -285,7 +319,7 @@ const historyAggregate = z.object({
 const VOICE_ACCELERATOR_RE = /^(CommandOrControl|CmdOrCtrl|Cmd|Command|Ctrl|Control|Alt|Option|Shift|Super|Meta)(\+(CommandOrControl|CmdOrCtrl|Cmd|Command|Ctrl|Control|Alt|Option|Shift|Super|Meta))*\+([A-Z]|[0-9]|F([1-9]|1[0-9]|2[0-4])|Space|Tab|Enter|Backspace|Delete|Escape|Esc)$/;
 
 const voiceSetHotkey = z.object({
-  accelerator: z.string().regex(VOICE_ACCELERATOR_RE),
+  accelerator: z.string().max(128).regex(VOICE_ACCELERATOR_RE),
   mode: z.enum(['hold', 'toggle']),
   global: z.boolean(),
   schemaVersion: z.number().int().optional(),
@@ -357,7 +391,9 @@ const repoAnalyze = z.object({
 
 // Plugin install: mirrors pluginInstall.cjs SLUG_RE + length cap. Defense in
 // depth — install() re-checks; the schema rejects earlier.
-const PLUGIN_SLUG_RE = /^[a-z0-9\-/]+$/;
+// Leading char must be alphanumeric — a `-` prefix would be parsed as a CLI flag
+// by `claude plugin install` (argv injection). Mirrors pluginInstall.cjs SLUG_RE.
+const PLUGIN_SLUG_RE = /^[a-z0-9][a-z0-9\-/]*$/;
 const PLUGIN_MKT_ADD_RE = /^[A-Za-z0-9][A-Za-z0-9._\-]*\/[A-Za-z0-9._\-]+$/;
 const pluginsInstall = z.object({
   slug: z.string().regex(PLUGIN_SLUG_RE).min(1).max(128),
@@ -434,6 +470,10 @@ const SAS_GATED_READS = new Set([
   'cmd:history:aggregate',
   // subscribe initiates a live stream of session state/summary — sensitive.
   'cmd:session:subscribe',
+  // NOTE: cmd:exchanges:list is intentionally NOT allowlisted — webRemote.cjs has
+  // no dispatch handler for it, so an allowlist entry would only fail closed with
+  // an opaque reject. Re-add here together with the handler when remote exchanges
+  // are wired, so the allowlist always mirrors an actual capability.
 ]);
 
 const MUTATE_COMMANDS = new Set([
@@ -487,11 +527,7 @@ module.exports = {
     scheduleArchivePrd,
     scheduleRetagPrd,
     setConfigSchema,
-    openInEditor,
-    openExternal,
-    openFileInEditor,
-    openInFinder,
-    openInTerminal,
+    shellOpen,
     archiveProject,
     historyAggregate,
     voiceSetHotkey,
@@ -512,6 +548,7 @@ module.exports = {
     memoryWrite,
     memoryDelete,
     memoryCreate,
+    memoryAggregate,
     agentMemoryList,
     agentMemoryGet,
     agentMemorySet,
@@ -520,6 +557,9 @@ module.exports = {
     watchersList,
     watchersRemove,
     watchersKillTab,
+    chatRun,
+    chatCancel,
+    exchangesList,
   },
   validated,
 };

package/src/main/lib/kgExchangePairing.cjs

@@ -0,0 +1,75 @@
+'use strict';
+
+/**
+ * kgExchangePairing.cjs — helpers for enriching KG prompt entries with their
+ * corresponding exchange results (prompt+outcome pairs from exchanges.cjs).
+ *
+ * Pure functions + one async file loader. No electron dependency — directly
+ * testable with node:test.
+ */
+
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const { encodeCwd } = require('./encodeCwd.cjs');
+
+/**
+ * Stable lookup key for a prompt: lowercased, whitespace-collapsed, first 500
+ * chars. Both prompt-log entries and exchange records use this so matching is
+ * tolerant of minor whitespace differences (e.g. trailing newline in one source).
+ */
+function normalizePromptKey(text) {
+  return String(text || '').trim().slice(0, 500).toLowerCase().replace(/\s+/g, ' ');
+}
+
+/**
+ * Build an in-memory index from an exchanges JSONL file for the given cwd.
+ * Returns Map<normalizedPromptKey, exchangeRecord> (last-write wins for
+ * duplicate prompts). Returns an empty Map when the file is absent or unreadable
+ * so callers always fall back gracefully to prompt-only behavior.
+ *
+ * @param {string} exchangesDir  absolute path to the exchanges directory
+ * @param {string} cwd           project working directory
+ * @returns {Promise<Map<string, object>>}
+ */
+async function loadExchangeIndex(exchangesDir, cwd) {
+  const filePath = path.join(exchangesDir, `${encodeCwd(cwd)}.jsonl`);
+  try {
+    const raw = await fsp.readFile(filePath, 'utf8');
+    const index = new Map();
+    for (const line of raw.split('\n')) {
+      const t = line.trim();
+      if (!t) continue;
+      try {
+        const rec = JSON.parse(t);
+        if (rec && rec.prompt) {
+          index.set(normalizePromptKey(rec.prompt), rec);
+        }
+      } catch { /* skip malformed lines */ }
+    }
+    return index;
+  } catch {
+    // File missing or unreadable — fall back to prompt-only; never block ingest.
+    return new Map();
+  }
+}
+
+/**
+ * Enrich prompt-log entries with result/summary from the exchange index.
+ * Returns a new array; entries without a match are returned unchanged.
+ *
+ * @param {Array<{ts: string, prompt: string, [key: string]: any}>} entries
+ * @param {Map<string, object>} exchangeIndex  from loadExchangeIndex()
+ * @returns {Array<object>}
+ */
+function enrichEntries(entries, exchangeIndex) {
+  return entries.map((entry) => {
+    const key = normalizePromptKey(entry.prompt);
+    const exchange = exchangeIndex.get(key);
+    if (exchange && (exchange.result || exchange.summary)) {
+      return { ...entry, result: exchange.result, summary: exchange.summary };
+    }
+    return entry;
+  });
+}
+
+module.exports = { normalizePromptKey, loadExchangeIndex, enrichEntries };

package/src/main/lib/reaperHelpers.cjs

@@ -64,4 +64,10 @@ function classifyRunOutcome(logPath) {
   }
 }
 
-module.exports = { claudePidAlive, classifyRunOutcome };
+// Max times an orphaned job may be re-queued before giving up (marking failed).
+// Single source of truth: both the in-app reaper (scheduler.cjs) and the external
+// offline watchdog (watchdogHelpers.cjs) import this so their give-up budgets can
+// never drift apart (they increment the SAME j.orphanRetries field).
+const ORPHAN_REQUEUE_CAP = 5;
+
+module.exports = { claudePidAlive, classifyRunOutcome, ORPHAN_REQUEUE_CAP };