claude-code-session-manager 0.32.0 → 0.32.1

package/dist/index.html

@@ -7,7 +7,7 @@
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=Newsreader:ital,opsz,wght@0,6..72,400;0,6..72,500;0,6..72,600;0,6..72,700;1,6..72,400&family=Geist:wght@300;400;500;600;700&family=IBM+Plex+Mono:wght@400;500;600&display=swap" rel="stylesheet">
-    <script type="module" crossorigin src="./assets/index-CHTpW79G.js"></script>
+    <script type="module" crossorigin src="./assets/index-CogvVs0W.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/monaco-editor-BW5C4Iv1.js">
     <link rel="stylesheet" crossorigin href="./assets/monaco-editor-BTnBOi8r.css">
     <link rel="stylesheet" crossorigin href="./assets/index-DMIi9YZH.css">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-session-manager",
-  "version": "0.32.0",
+  "version": "0.32.1",
   "description": "Local cockpit for the Claude Code CLI — multi-tab terminal, full config surface, scheduler, voice dictation, and live observability.",
   "type": "module",
   "main": "src/main/index.cjs",

package/src/main/kg.cjs

@@ -40,6 +40,8 @@ const os = require('node:os');
 const { resolveClaudeBin } = require('./lib/claudeBin.cjs');
 const { encodeCwd } = require('./lib/encodeCwd.cjs');
 const { writeJson } = require('./config.cjs');
+const { pruneGraph } = require('./lib/kgPrune.cjs');
+const { canonicalize, ENTITY_TYPES, liteExtract } = require('./lib/kgLite.cjs');
 
 const HOME = os.homedir();
 const KG_DIR = path.join(HOME, '.claude', 'knowledge-log');
@@ -47,6 +49,61 @@ const LOG_PATH = path.join(KG_DIR, 'prompts.jsonl');
 const GRAPHS_DIR = path.join(KG_DIR, 'graphs');
 const INGEST_STATE_PATH = path.join(KG_DIR, 'ingest-state.json');
 const PROMPT_INDEX_PATH = path.join(KG_DIR, 'prompt-index.json');
+const KG_CONFIG_PATH = path.join(KG_DIR, 'kg-config.json');
+
+const DEFAULT_MAX_GRAPH_NODES = 300;
+
+/** Read kg-config.json; returns defaults when file is absent or malformed.
+ *  `captureMode` is derived from the explicit field (new) or the legacy
+ *  `extractionEnabled` boolean (old configs) for backward compatibility. */
+function kgConfig() {
+  try {
+    const c = JSON.parse(fs.readFileSync(KG_CONFIG_PATH, 'utf8'));
+    let captureMode;
+    if (c.captureMode === 'lite' || c.captureMode === 'off' || c.captureMode === 'llm') {
+      captureMode = c.captureMode;
+    } else {
+      // Legacy: derive from extractionEnabled boolean.
+      captureMode = c.extractionEnabled === false ? 'off' : 'llm';
+    }
+    return {
+      extractionEnabled: captureMode !== 'off',
+      captureMode,
+      // 0 = cap disabled; undefined/null → default
+      maxGraphNodes: typeof c.maxGraphNodes === 'number' ? c.maxGraphNodes : DEFAULT_MAX_GRAPH_NODES,
+    };
+  } catch {
+    return { extractionEnabled: true, captureMode: 'llm', maxGraphNodes: DEFAULT_MAX_GRAPH_NODES };
+  }
+}
+
+/** Active capture mode — SM_KG_DISABLE=1 forces 'off' regardless of config. */
+function currentCaptureMode() {
+  if (process.env.SM_KG_DISABLE === '1') return 'off';
+  return kgConfig().captureMode;
+}
+
+/** Extraction toggle — lets the user stop the recurring `claude -p` cost when
+ *  they aren't using the graph. Default ON; env SM_KG_DISABLE=1 forces OFF. */
+function extractionEnabled() {
+  return currentCaptureMode() !== 'off';
+}
+
+async function setExtractionEnabled(enabled) {
+  const current = kgConfig();
+  // Toggling off → 'off'; toggling on → restore prior active mode or default 'llm'.
+  const newMode = enabled ? (current.captureMode === 'off' ? 'llm' : current.captureMode) : 'off';
+  await writeJson(KG_CONFIG_PATH, { ...current, captureMode: newMode, extractionEnabled: !!enabled });
+  return { ok: true, extractionEnabled: !!enabled };
+}
+
+/** Set capture mode: 'llm' | 'lite' | 'off'. */
+async function setCaptureMode(mode) {
+  if (mode !== 'llm' && mode !== 'lite' && mode !== 'off') return { ok: false, error: 'invalid mode' };
+  const current = kgConfig();
+  await writeJson(KG_CONFIG_PATH, { ...current, captureMode: mode, extractionEnabled: mode !== 'off' });
+  return { ok: true, captureMode: mode };
+}
 const BATCH = 20;                 // prompts per extraction call (also a per-project cap)
 const KNOWN_VOCAB = 200;          // top node names pre-seeded for dedup-at-extraction
 const MAX_TAIL_BYTES = 8 * 1024 * 1024;   // bound bytes scanned per ingest run
@@ -63,7 +120,7 @@ const MAX_LOG_BYTES = 256 * 1024 * 1024;
 // lets prompts accumulate into fuller batches; the KG tab tolerates the lag.
 const WATCH_COALESCE_MS = 5 * 60_000;
 
-const ENTITY_TYPES = ['project', 'feature', 'tool', 'tech', 'concept', 'goal', 'person'];
+// ENTITY_TYPES and canonicalize are imported from ./lib/kgLite.cjs (single source of truth).
 
 // Prompts our own `claude -p` calls send. The SM_KG_INTERNAL env guard on the
 // logging hook prevents NEW ones; these prefixes drop any already in the log.
@@ -150,9 +207,45 @@ async function loadGraphFor(cwd) {
 }
 
 async function saveGraph(g) {
+  const { maxGraphNodes } = kgConfig();
+  if (maxGraphNodes && g.nodes.length > maxGraphNodes) {
+    const result = pruneGraph(g, maxGraphNodes, Date.now());
+    g.nodes = result.nodes;
+    g.edges = result.edges;
+    if (result.evicted > 0) {
+      logger.writeLine({ scope: 'kg', level: 'info', message: 'graph pruned', meta: { cwd: g.cwd, evicted: result.evicted, remaining: g.nodes.length, cap: maxGraphNodes } });
+    }
+  }
   await writeJson(graphPath(g.cwd), g);
 }
 
+/** Purge ONE project's graph. The global ingest cursor has already passed those
+ *  prompt lines, so this is a forget (no auto-rebuild) — exactly what a "this
+ *  graph is a useless hairball, reset it" button wants. */
+async function clearGraph(cwd) {
+  const target = cwd || await defaultCwd();
+  try { await fsp.unlink(graphPath(target)); } catch { /* already gone */ }
+  try {
+    const idx = await readPromptIndex();
+    if (idx) { delete idx[encodeCwd(target)]; await savePromptIndex(idx); }
+  } catch { /* index best-effort */ }
+  return { ok: true, cleared: shortLabel(target) };
+}
+
+/** Purge ALL project graphs. Leaves prompts.jsonl/cursor intact so future
+ *  prompts still build fresh graphs (unless extraction is disabled). */
+async function clearAllGraphs() {
+  let removed = 0;
+  try {
+    for (const f of fs.readdirSync(GRAPHS_DIR)) {
+      if (!f.endsWith('.json')) continue;
+      try { fs.unlinkSync(path.join(GRAPHS_DIR, f)); removed++; } catch { /* skip */ }
+    }
+  } catch { /* no dir yet */ }
+  try { await savePromptIndex({}); } catch { /* */ }
+  return { ok: true, removed };
+}
+
 async function loadIngestState() {
   try {
     const s = JSON.parse(await fsp.readFile(INGEST_STATE_PATH, 'utf8'));
@@ -201,16 +294,6 @@ async function savePromptIndex(idx) {
   await writeJson(PROMPT_INDEX_PATH, idx);
 }
 
-/** Canonical dedup key: lowercase, strip leading article, collapse whitespace. */
-function canonicalize(name) {
-  return String(name || '')
-    .trim()
-    .toLowerCase()
-    .replace(/^(the|a|an)\s+/i, '')
-    .replace(/\s+/g, ' ')
-    .replace(/[.,;:!?]+$/, '');
-}
-
 /** Read every prompt line currently in the log (real prompts only). */
 async function readAllPrompts() {
   let raw;
@@ -376,6 +459,8 @@ function planUnits(tailText) {
  */
 async function ingest() {
   if (ingesting) return { ok: false, error: 'already running' };
+  const mode = currentCaptureMode();
+  if (mode === 'off') return { ok: true, added: 0, note: 'extraction disabled' };
   ingesting = true;
   broadcast('kg:ingest-progress', { phase: 'start', ingesting: true });
   try {
@@ -462,34 +547,42 @@ async function ingest() {
       const g = await graphFor(u.cwd);
       const byKey = new Map(g.nodes.map((n) => [n.key, n]));
       const byEdge = new Map(g.edges.map((e) => [`${e.src} ${e.relation} ${e.dst}`, e]));
-      const known = [...byKey.values()].sort((a, b) => b.count - a.count).slice(0, KNOWN_VOCAB).map((n) => ({ key: n.key, name: n.name }));
-
-      const r = await runClaude(EXTRACTION_PROMPT(u.entries, known), { model: 'haiku', timeoutMs: 180_000, systemPrompt: EXTRACTION_SYSTEM });
-      extractions++;
-      // Transient failure (timeout / spawn error / rate-limit): stop and stay
-      // resumable — do NOT advance the watermark, so we retry these exact prompts.
-      if (!r.ok) { logger.writeLine({ scope: 'kg', level: 'warn', message: 'extraction failed; pausing (resumable)', meta: { cwd: u.cwd, error: r.error } }); failed = true; break; }
-      const parsed = extractJson(r.out);
-      // Content failure (model refused / returned non-JSON): these prompts are
-      // un-extractable. QUARANTINE the batch — advance past it and CONTINUE so a
-      // single bad batch can't freeze the whole graph (the head-of-line bug).
-      if (!parsed) {
-        logger.writeLine({ scope: 'kg', level: 'warn', message: 'extraction unparseable; skipping batch', meta: { cwd: u.cwd, prompts: u.entries.length } });
-        skipped += u.entries.length;
-        st.lastOffset += u.bytes;
-        st.lastTs = u.entries[u.entries.length - 1].ts || st.lastTs;
-        st.updatedAt = new Date().toISOString();
-        // Write index before advancing watermark: if we crash between these two
-        // writes, the watermark hasn't moved so the batch will be re-processed
-        // (the index count may be slightly high) rather than advanced past a
-        // batch whose index entry was never written.
-        if (!promptIdx[u.enc]) promptIdx[u.enc] = { count: 0, cwd: u.cwd };
-        promptIdx[u.enc].count += u.entries.length;
-        promptIdx[u.enc].cwd = u.cwd;
-        await savePromptIndex(promptIdx);
-        await saveIngestState(st);
-        if (extractions >= MAX_EXTRACTIONS_PER_RUN) { capped = true; break; }
-        continue;
+      const known = [...byKey.values()].sort((a, b) => b.count - a.count).slice(0, KNOWN_VOCAB).map((n) => ({ key: n.key, name: n.name, type: n.type }));
+
+      // Derive entities/relations: heuristic (lite) or LLM (llm).
+      let parsed;
+      if (mode === 'lite') {
+        // Heuristic extraction — O(W) per prompt, always succeeds, no claude spawn.
+        parsed = liteExtract(u.entries, known);
+      } else {
+        // LLM extraction (mode === 'llm')
+        const r = await runClaude(EXTRACTION_PROMPT(u.entries, known), { model: 'haiku', timeoutMs: 180_000, systemPrompt: EXTRACTION_SYSTEM });
+        extractions++;
+        // Transient failure (timeout / spawn error / rate-limit): stop and stay
+        // resumable — do NOT advance the watermark, so we retry these exact prompts.
+        if (!r.ok) { logger.writeLine({ scope: 'kg', level: 'warn', message: 'extraction failed; pausing (resumable)', meta: { cwd: u.cwd, error: r.error } }); failed = true; break; }
+        parsed = extractJson(r.out);
+        // Content failure (model refused / returned non-JSON): these prompts are
+        // un-extractable. QUARANTINE the batch — advance past it and CONTINUE so a
+        // single bad batch can't freeze the whole graph (the head-of-line bug).
+        if (!parsed) {
+          logger.writeLine({ scope: 'kg', level: 'warn', message: 'extraction unparseable; skipping batch', meta: { cwd: u.cwd, prompts: u.entries.length } });
+          skipped += u.entries.length;
+          st.lastOffset += u.bytes;
+          st.lastTs = u.entries[u.entries.length - 1].ts || st.lastTs;
+          st.updatedAt = new Date().toISOString();
+          // Write index before advancing watermark: if we crash between these two
+          // writes, the watermark hasn't moved so the batch will be re-processed
+          // (the index count may be slightly high) rather than advanced past a
+          // batch whose index entry was never written.
+          if (!promptIdx[u.enc]) promptIdx[u.enc] = { count: 0, cwd: u.cwd };
+          promptIdx[u.enc].count += u.entries.length;
+          promptIdx[u.enc].cwd = u.cwd;
+          await savePromptIndex(promptIdx);
+          await saveIngestState(st);
+          if (extractions >= MAX_EXTRACTIONS_PER_RUN) { capped = true; break; }
+          continue;
+        }
       }
 
       const batchTs = u.entries[u.entries.length - 1].ts || st.lastTs || new Date().toISOString();
@@ -519,7 +612,8 @@ async function ingest() {
       // Tell the renderer this batch landed so it can refresh the graph live.
       broadcast('kg:ingest-progress', { phase: 'batch', ingesting: true, batch: batchNo, totalBatches, cwd: u.cwd, added });
 
-      if (extractions >= MAX_EXTRACTIONS_PER_RUN) { capped = true; break; }
+      // Cap only applies to LLM mode (lite has negligible cost; no claude calls to bound).
+      if (mode === 'llm' && extractions >= MAX_EXTRACTIONS_PER_RUN) { capped = true; break; }
     }
 
     // More to do? Either we hit the per-run cap, or the bounded tail didn't reach
@@ -603,6 +697,7 @@ async function getState(cwd) {
   } else {
     totalPrompts = idx[enc]?.count ?? 0;
   }
+  const cfg = kgConfig();
   return {
     cwd: target,
     label: shortLabel(target),
@@ -615,6 +710,9 @@ async function getState(cwd) {
       lastIngest: g.updatedAt,
       ingesting,
       logPath: LOG_PATH,
+      extractionEnabled: cfg.extractionEnabled,
+      captureMode: cfg.captureMode,
+      maxGraphNodes: cfg.maxGraphNodes,
     },
   };
 }
@@ -666,6 +764,9 @@ function registerHandlers() {
   ipcMain.handle('kg:projects', () => listProjects());
   ipcMain.handle('kg:ingest', () => ingest());
   ipcMain.handle('kg:ask', (_e, { question, cwd } = {}) => ask(question, cwd));
+  ipcMain.handle('kg:clear', (_e, arg = {}) => (arg.all ? clearAllGraphs() : clearGraph(arg.cwd)));
+  ipcMain.handle('kg:set-extraction', (_e, arg = {}) => setExtractionEnabled(arg.enabled));
+  ipcMain.handle('kg:set-capture-mode', (_e, arg = {}) => setCaptureMode(arg.mode));
 }
 
 /** Watch the log; debounce-ingest new prompts. Cheap — only new bytes are read. */

package/src/main/lib/kgLite.cjs

@@ -0,0 +1,195 @@
+'use strict';
+
+/**
+ * kgLite.cjs — Heuristic knowledge-graph extraction (no LLM, no network).
+ *
+ * Exports `canonicalize` and `ENTITY_TYPES` as the shared vocabulary contract
+ * (kg.cjs imports these so there is ONE definition for both paths), and
+ * `liteExtract` which is the cheap alternative to the `claude -p` extractor.
+ *
+ * Precision vs LLM path:
+ *   Higher precision on known-vocab entities (exact canonical-key match).
+ *   Lower recall on novel entities — extracts capitalized phrases, quoted
+ *   identifiers, CamelCase tokens, and tech keywords; misses entities stated
+ *   only in plain lowercase prose. Relations are always generic `related_to`
+ *   co-occurrences (no semantic labelling). A lite graph grows meaningfully
+ *   but is sparser and less richly typed than the LLM path. Good for
+ *   cost-sensitive setups where search/Q&A value matters but per-prompt
+ *   claude -p cost does not.
+ */
+
+/** Canonical dedup key: lowercase, strip leading article, collapse whitespace.
+ *  This function is the SINGLE definition shared with kg.cjs — any change here
+ *  affects both extraction paths equally. */
+function canonicalize(name) {
+  return String(name || '')
+    .trim()
+    .toLowerCase()
+    .replace(/^(the|a|an)\s+/i, '')
+    .replace(/\s+/g, ' ')
+    .replace(/[.,;:!?]+$/, '');
+}
+
+const ENTITY_TYPES = ['project', 'feature', 'tool', 'tech', 'concept', 'goal', 'person'];
+
+// Tech terms that map directly to type 'tech' on first encounter.
+const TECH_KEYWORDS = new Set([
+  'react', 'electron', 'typescript', 'javascript', 'python', 'node', 'nodejs',
+  'vite', 'tailwind', 'zustand', 'xterm', 'playwright', 'sqlite', 'postgres',
+  'postgresql', 'redis', 'docker', 'kubernetes', 'webpack', 'esbuild', 'jest',
+  'vitest', 'graphql', 'rest', 'api', 'http', 'https', 'websocket', 'pty',
+  'ipc', 'mcp', 'git', 'npm', 'npx', 'pnpm', 'yarn', 'bash', 'zsh', 'curl',
+  'json', 'yaml', 'tsx', 'jsx', 'cjs', 'esm', 'commonjs', 'llm', 'rag',
+  'openai', 'anthropic', 'claude', 'oauth', 'jwt', 'cors',
+]);
+
+// File extensions that mark a quoted/path identifier as type 'tech'.
+const TECH_EXTS = new Set([
+  '.ts', '.tsx', '.cjs', '.mjs', '.js', '.jsx', '.py', '.go', '.rs', '.sh',
+  '.md', '.json', '.yaml', '.yml', '.toml', '.env',
+]);
+
+// Common English words that appear capitalized at sentence start or as pronouns
+// and are NOT meaningful developer-domain entities. Filter before adding.
+const STOP_CAPS = new Set([
+  'I', 'A', 'An', 'The', 'In', 'On', 'At', 'To', 'For', 'Of', 'With', 'By',
+  'From', 'As', 'Is', 'Was', 'Are', 'Were', 'Be', 'Been', 'Have', 'Has', 'Had',
+  'Do', 'Does', 'Did', 'Will', 'Would', 'Could', 'Should', 'May', 'Might',
+  'Can', 'If', 'But', 'And', 'Or', 'Not', 'So', 'This', 'That', 'These',
+  'Those', 'We', 'You', 'They', 'It', 'My', 'Your', 'Our', 'Its', 'Their',
+  'When', 'Where', 'Who', 'What', 'How', 'Why', 'Which', 'Then', 'Just', 'Now',
+  'Also', 'Here', 'There', 'Add', 'Get', 'Use', 'Run', 'Make', 'Fix', 'New',
+  'Yes', 'No', 'Ok', 'Let', 'See', 'Set', 'Put', 'Try', 'Keep', 'Show', 'Go',
+  'Tab', 'Now', 'Out', 'Up', 'Down', 'All', 'Any', 'Some', 'One', 'Two', 'Its',
+]);
+
+/** Infer entity type from surface form when not in known vocab. */
+function inferType(raw) {
+  const lower = raw.toLowerCase();
+  if (TECH_KEYWORDS.has(lower)) return 'tech';
+  const extM = raw.match(/(\.[a-zA-Z0-9]+)$/);
+  if (extM && TECH_EXTS.has(extM[1].toLowerCase())) return 'tech';
+  return 'concept';
+}
+
+/**
+ * Heuristic entity/relation extraction — no network, no child_process.spawn.
+ *
+ * Algorithm per prompt (Time: O(W) for extraction, O(k²) for edges):
+ *   1. Known-vocab scan: tokenize on whitespace/punctuation, look up each
+ *      token and adjacent bigram in the vocab Map — O(W) with Map lookups.
+ *   2. Multi-word capitalized phrases + acronyms (regex pass): "Knowledge
+ *      Graph", "Session Manager", "PRD". Higher precision than singles.
+ *   3. CamelCase identifiers (regex pass): `KnowledgeGraph`, `SchedulerDock`.
+ *   4. Quoted identifiers (regex pass): `scheduler.cjs`, "lite mode".
+ *   5. Single capitalized words (regex pass, STOP_CAPS filtered): "Scheduler".
+ *   6. Co-occurrence edges among all entities found in the same prompt.
+ *      O(k²) where k = distinct entities per prompt — typically < 10.
+ *
+ * Dedup: canonicalize() maps every surface form to the same key ("The
+ * Scheduler" / "scheduler" / "Scheduler" all → key "scheduler"), so
+ * entityMap never accumulates duplicates.
+ *
+ * @param {Array<{prompt:string,ts?:string}>} prompts
+ * @param {Array<{key:string,name:string,type?:string}>} knownVocab  top-N nodes from the graph
+ * @returns {{ entities: Array<{key,name,type,description}>, relations: Array<{src,dst,relation,description}> }}
+ */
+function liteExtract(prompts, knownVocab) {
+  // O(V) build once; per-prompt lookups are O(1).
+  const vocabByKey = new Map((knownVocab || []).map((n) => [n.key, n]));
+
+  // Canonical key → entity — ensures no duplicates across the whole batch.
+  const entityMap = new Map();
+
+  function addEnt(raw, typeHint) {
+    const key = canonicalize(raw);
+    // Skip empty, pure-digit, or single-char keys.
+    if (!key || key.length < 2 || /^\d+$/.test(key)) return null;
+    if (!entityMap.has(key)) {
+      const known = vocabByKey.get(key);
+      const type = (known && ENTITY_TYPES.includes(known.type)) ? known.type
+                 : ENTITY_TYPES.includes(typeHint) ? typeHint
+                 : 'concept';
+      entityMap.set(key, { key, name: known ? known.name : raw, type, description: '' });
+    }
+    return key;
+  }
+
+  const relationSet = new Set(); // "src relation dst" dedup key
+  const relations = [];
+
+  // Regexes used across prompts — reset lastIndex per prompt.
+  // Multi-word capitalized phrase OR all-caps acronym (>=2 chars).
+  const CAP_PHRASE_RE = /\b([A-Z][a-zA-Z]*(?:\s+[A-Z][a-zA-Z]*)+|[A-Z]{2,})\b/g;
+  // CamelCase: two or more capitalized segments joined without space.
+  const CAMEL_RE = /\b([A-Z][a-z]+(?:[A-Z][a-z]*)+)\b/g;
+  // Quoted identifier. Backreference \1 ensures the closing delimiter matches
+  // the opening one — prevents "`foo` isn't" from closing the backtick-span
+  // on the apostrophe in "isn't" and extracting a garbage entity.
+  const QUOTED_RE = /([`"'])([^`"'\n]{2,40})\1/g;
+  // Single capitalized word (Title Case, not an acronym — handled by CAP_PHRASE_RE).
+  const CAP_WORD_RE = /\b([A-Z][a-z]{1,})\b/g;
+
+  for (const p of prompts) {
+    const text = String(p.prompt || '');
+    const promptKeys = [];
+
+    function record(key) {
+      if (key && !promptKeys.includes(key)) promptKeys.push(key);
+    }
+
+    // 1. Known-vocab scan: split on whitespace + punctuation, check token and bigram.
+    const tokens = text.split(/[\s,;:.!?()\[\]{}<>|/\\]+/).filter(Boolean);
+    for (let i = 0; i < tokens.length; i++) {
+      const k1 = canonicalize(tokens[i]);
+      if (vocabByKey.has(k1)) record(addEnt(tokens[i], vocabByKey.get(k1).type));
+      if (i + 1 < tokens.length) {
+        const bigram = tokens[i] + ' ' + tokens[i + 1];
+        const k2 = canonicalize(bigram);
+        if (vocabByKey.has(k2)) record(addEnt(bigram, vocabByKey.get(k2).type));
+      }
+    }
+
+    // 2. Multi-word capitalized phrases + acronyms — highest precision.
+    let m;
+    CAP_PHRASE_RE.lastIndex = 0;
+    while ((m = CAP_PHRASE_RE.exec(text)) !== null) {
+      if (!STOP_CAPS.has(m[1])) record(addEnt(m[1], inferType(m[1])));
+    }
+
+    // 3. CamelCase identifiers: KnowledgeGraph, SchedulerDock, etc.
+    CAMEL_RE.lastIndex = 0;
+    while ((m = CAMEL_RE.exec(text)) !== null) {
+      record(addEnt(m[1], inferType(m[1])));
+    }
+
+    // 4. Quoted identifiers: `scheduler.cjs`, "lite mode", etc.
+    QUOTED_RE.lastIndex = 0;
+    while ((m = QUOTED_RE.exec(text)) !== null) {
+      const raw = m[2].trim();
+      if (raw.length >= 2) record(addEnt(raw, inferType(raw)));
+    }
+
+    // 5. Single capitalized words (mid-sentence entities like "Scheduler").
+    //    STOP_CAPS filters common sentence-start words and English pronouns.
+    CAP_WORD_RE.lastIndex = 0;
+    while ((m = CAP_WORD_RE.exec(text)) !== null) {
+      if (!STOP_CAPS.has(m[1])) record(addEnt(m[1], inferType(m[1])));
+    }
+
+    // Emit co-occurrence edges: O(k²) where k = promptKeys.length (typically <10).
+    for (let i = 0; i < promptKeys.length; i++) {
+      for (let j = i + 1; j < promptKeys.length; j++) {
+        const ek = `${promptKeys[i]} related_to ${promptKeys[j]}`;
+        if (!relationSet.has(ek)) {
+          relationSet.add(ek);
+          relations.push({ src: promptKeys[i], dst: promptKeys[j], relation: 'related_to', description: '' });
+        }
+      }
+    }
+  }
+
+  return { entities: [...entityMap.values()], relations };
+}
+
+module.exports = { canonicalize, ENTITY_TYPES, liteExtract };

package/src/main/lib/kgPrune.cjs

@@ -0,0 +1,87 @@
+'use strict';
+
+/**
+ * kgPrune.cjs — decay-based node eviction for per-project knowledge graphs.
+ *
+ * API:
+ *   nodeEvictionScore(node, degree, nowMs) → number   (higher = keep)
+ *   pruneGraph(graph, maxNodes, nowMs)     → { nodes, edges, evicted }
+ *
+ * Complexity:
+ *   nodeEvictionScore: O(1)
+ *   pruneGraph: O(E + N log N) where N=nodes, E=edges
+ *     - one O(E) pass to build degree map
+ *     - one O(N log N) sort to select top-maxNodes
+ *     - one O(E) pass to drop dangling edges
+ */
+
+const HALF_LIFE_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
+const W_RECENCY = 0.5;  // freshness — recently-touched nodes stay relevant
+const W_DEGREE  = 0.3;  // connectivity — hubs link disparate ideas together
+const W_COUNT   = 0.2;  // frequency — often-mentioned = important to the dev
+
+/**
+ * Score a node for retention. Higher = more worth keeping.
+ *
+ * Weighting rationale:
+ *   Recency (50%): a node last seen 30 days ago decays to ~50% of a just-seen
+ *   node — exponential decay keeps the graph current without hard cutoffs.
+ *   Degree (30%): hub nodes (many connections) preserve graph coherence; without
+ *   them the remaining graph fragments into disconnected islands.
+ *   Count (20%): how often the developer mentioned something matters, but a
+ *   high-count stale node should still decay below a freshly-active low-count one.
+ *
+ * @param {object} node    KgNode with lastTs (ISO string|null), count (number)
+ * @param {number} degree  edge count touching this node (src or dst)
+ * @param {number} nowMs   Date.now() equivalent from caller (kept pure/testable)
+ * @returns {number}
+ */
+function nodeEvictionScore(node, degree, nowMs) {
+  let recency = 0;
+  if (node.lastTs) {
+    const ageMs = nowMs - new Date(node.lastTs).getTime();
+    recency = Math.exp(-ageMs / HALF_LIFE_MS);   // 1.0 = just seen, decays to 0
+  }
+  const degScore  = Math.log1p(degree);           // log scale: 0→0, 1→0.69, 10→2.4
+  const cntScore  = Math.log1p(node.count ?? 0);  // same — avoids linear blow-up
+  return W_RECENCY * recency + W_DEGREE * degScore + W_COUNT * cntScore;
+}
+
+/**
+ * Prune a graph to at most maxNodes nodes, evicting the lowest-scored ones and
+ * all edges that referenced evicted nodes.
+ *
+ * @param {{ nodes: object[], edges: object[] }} graph
+ * @param {number} maxNodes  cap; 0 = disabled (returns graph unchanged)
+ * @param {number} nowMs     caller-supplied timestamp (keeps scorer pure)
+ * @returns {{ nodes: object[], edges: object[], evicted: number }}
+ */
+function pruneGraph(graph, maxNodes, nowMs) {
+  if (!maxNodes || graph.nodes.length <= maxNodes) {
+    return { nodes: graph.nodes, edges: graph.edges, evicted: 0 };
+  }
+
+  // O(E): build id → degree map in a single pass over edges.
+  const degree = new Map();
+  for (const e of graph.edges) {
+    degree.set(e.src, (degree.get(e.src) ?? 0) + 1);
+    degree.set(e.dst, (degree.get(e.dst) ?? 0) + 1);
+  }
+
+  // O(N log N): score + sort; keep the top maxNodes.
+  const scored = graph.nodes.map((n) => ({ n, s: nodeEvictionScore(n, degree.get(n.id) ?? 0, nowMs) }));
+  scored.sort((a, b) => b.s - a.s);   // descending: highest score first
+  const kept = scored.slice(0, maxNodes);
+  const evicted = scored.length - kept.length;
+
+  if (evicted === 0) return { nodes: graph.nodes, edges: graph.edges, evicted: 0 };
+
+  const keptIds = new Set(kept.map((x) => x.n.id));
+
+  // O(E): drop every edge whose src or dst was evicted (no dangling references).
+  const edges = graph.edges.filter((e) => keptIds.has(e.src) && keptIds.has(e.dst));
+
+  return { nodes: kept.map((x) => x.n), edges, evicted };
+}
+
+module.exports = { nodeEvictionScore, pruneGraph };

package/src/preload/api.d.ts

@@ -1129,6 +1129,12 @@ export interface SessionManagerAPI {
     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;
   };
 }
@@ -1179,6 +1185,11 @@ export interface KgState {
     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 {

package/src/preload/index.cjs

@@ -326,6 +326,12 @@ contextBridge.exposeInMainWorld('api', {
     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) => {
       const listener = (_e, payload) => handler(payload);
       ipcRenderer.on('kg:ingest-progress', listener);