synabun 1.3.0 → 2.0.0

package/neural-interface/lib/session-chunker.js

@@ -0,0 +1,344 @@
+/**
+ * Session Chunker — Pure function that splits parsed JSONL lines into task-boundary chunks.
+ * No I/O, no external dependencies. Fully testable.
+ */
+
+const TASK_BOUNDARY_GAP_MS = 120_000; // 2 minutes between human turns = new task
+const MAX_CONTENT_CHARS = 8000;       // Max synthesized content per chunk
+const MAX_USER_MESSAGES = 5;          // Max user messages to include in synthesis
+const MAX_USER_MSG_CHARS = 200;       // Max chars per user message in synthesis
+const MAX_ASSISTANT_CHARS = 500;      // Max chars for assistant text per chunk
+
+/**
+ * @typedef {Object} ParsedLine
+ * @property {string} type - queue-operation | file-history-snapshot | progress | user | assistant
+ * @property {string} [sessionId]
+ * @property {string} [cwd]
+ * @property {string} [gitBranch]
+ * @property {string} [timestamp]
+ * @property {string} [uuid]
+ * @property {boolean} [isMeta]
+ * @property {boolean} [isSidechain]
+ * @property {Object} [message]
+ * @property {Object} [toolUseResult]
+ * @property {string} [sourceToolAssistantUUID]
+ */
+
+/**
+ * @typedef {Object} RawChunk
+ * @property {number} chunkIndex
+ * @property {string} startTimestamp
+ * @property {string} endTimestamp
+ * @property {string[]} userMessages - Cleaned human prompts
+ * @property {string[]} assistantTexts - Assistant response snippets
+ * @property {string[]} toolsUsed
+ * @property {string[]} filesModified
+ * @property {string[]} filesRead
+ * @property {number} turnCount - Human turns in this chunk
+ * @property {string} content - Synthesized text for embedding
+ * @property {string} summary - One-line human-readable summary
+ * @property {number} startLineIndex
+ * @property {number} endLineIndex
+ */
+
+/**
+ * Check if a user message is a real human prompt (not a tool result or meta).
+ */
+function isHumanMessage(line) {
+  if (line.type !== 'user') return false;
+  if (line.isMeta) return false;
+  if (line.toolUseResult || line.sourceToolAssistantUUID) return false;
+  // Check content for actual text (not just tool results)
+  const content = line.message?.content;
+  if (!content) return false;
+  if (Array.isArray(content)) {
+    return content.some(block =>
+      block.type === 'text' && block.text && block.text.length > 5
+    );
+  }
+  return typeof content === 'string' && content.length > 5;
+}
+
+/**
+ * Extract clean text from a user message, stripping IDE/system tags.
+ */
+function extractUserText(line) {
+  const content = line.message?.content;
+  if (!content) return '';
+  const blocks = Array.isArray(content) ? content : [{ type: 'text', text: content }];
+  const texts = [];
+  for (const block of blocks) {
+    if (block.type !== 'text' || !block.text) continue;
+    // Strip system-reminder, ide_opened_file, and antml tags
+    let text = block.text
+      .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '')
+      .replace(/<ide_opened_file>[\s\S]*?<\/ide_opened_file>/g, '')
+      .replace(/<[\s\S]*?<\/antml:[^>]+>/g, '')
+      .trim();
+    if (text.length > 5) texts.push(text);
+  }
+  return texts.join(' ').trim();
+}
+
+/**
+ * Extract assistant text blocks from an assistant message.
+ */
+function extractAssistantText(line) {
+  const content = line.message?.content;
+  if (!content || !Array.isArray(content)) return '';
+  const texts = [];
+  for (const block of content) {
+    if (block.type === 'text' && block.text) {
+      texts.push(block.text);
+    }
+    // Skip 'thinking' blocks — internal reasoning
+  }
+  return texts.join(' ').trim();
+}
+
+/**
+ * Extract tool use info from an assistant message.
+ */
+function extractToolUses(line) {
+  const content = line.message?.content;
+  if (!content || !Array.isArray(content)) return [];
+  const tools = [];
+  for (const block of content) {
+    if (block.type === 'tool_use' && block.name) {
+      const tool = { name: block.name, input: block.input || {} };
+      tools.push(tool);
+    }
+  }
+  return tools;
+}
+
+/**
+ * Extract file paths from tool use inputs.
+ */
+function extractFilesFromToolUse(toolUse) {
+  const modified = [];
+  const read = [];
+  const name = toolUse.name;
+  const input = toolUse.input || {};
+
+  if (name === 'Write' || name === 'Edit' || name === 'NotebookEdit') {
+    const fp = input.file_path || input.notebook_path;
+    if (fp) modified.push(normalizePath(fp));
+  } else if (name === 'Read') {
+    const fp = input.file_path;
+    if (fp) read.push(normalizePath(fp));
+  } else if (name === 'Grep' || name === 'Glob') {
+    // These search but don't read specific files
+  }
+
+  return { modified, read };
+}
+
+/**
+ * Normalize a file path for display (strip drive letter prefix, use forward slashes).
+ */
+function normalizePath(fp) {
+  return fp.replace(/\\/g, '/').replace(/^[A-Za-z]:/, '');
+}
+
+/**
+ * Normalize tool name (strip mcp__ prefix for display).
+ */
+function normalizeToolName(name) {
+  return name.replace(/^mcp__\w+__/, '');
+}
+
+/**
+ * Parse a single JSONL line safely.
+ */
+export function parseLine(line) {
+  if (!line || !line.trim()) return null;
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Main chunking function.
+ * @param {ParsedLine[]} lines - Parsed JSONL objects (already JSON.parse'd)
+ * @param {Object} sessionMeta - { sessionId, project, gitBranch, cwd }
+ * @returns {RawChunk[]}
+ */
+export function chunkSession(lines, sessionMeta) {
+  const chunks = [];
+  let current = createEmptyChunk(0);
+  let lastTimestamp = null;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) continue;
+
+    // Skip non-content types
+    if (line.type === 'queue-operation' || line.type === 'file-history-snapshot' || line.type === 'progress') {
+      continue;
+    }
+
+    // Skip sidechains (subagent messages logged in main transcript)
+    if (line.isSidechain) continue;
+
+    const ts = line.timestamp;
+
+    if (isHumanMessage(line)) {
+      // Check for task boundary: time gap > threshold
+      if (lastTimestamp && ts) {
+        const gap = new Date(ts).getTime() - new Date(lastTimestamp).getTime();
+        if (gap > TASK_BOUNDARY_GAP_MS && current.turnCount > 0) {
+          chunks.push(finalizeChunk(current, sessionMeta));
+          current = createEmptyChunk(chunks.length);
+        }
+      }
+
+      // Check for interruption pattern in content
+      const userText = extractUserText(line);
+      if (userText) {
+        current.userMessages.push(userText.slice(0, MAX_USER_MSG_CHARS));
+        current.turnCount++;
+      }
+      if (ts && !current.startTimestamp) current.startTimestamp = ts;
+      if (ts) current.endTimestamp = ts;
+      current.startLineIndex = Math.min(current.startLineIndex, i);
+      current.endLineIndex = i;
+
+    } else if (line.type === 'user' && line.isMeta) {
+      // Skip meta messages
+      continue;
+
+    } else if (line.type === 'user' && (line.toolUseResult || line.sourceToolAssistantUUID)) {
+      // Tool result — extract file info from toolUseResult
+      if (ts) current.endTimestamp = ts;
+      current.endLineIndex = i;
+
+    } else if (line.type === 'assistant') {
+      // Extract assistant text
+      const assistantText = extractAssistantText(line);
+      if (assistantText) {
+        current.assistantTexts.push(assistantText);
+      }
+
+      // Extract tool uses
+      const toolUses = extractToolUses(line);
+      for (const tu of toolUses) {
+        const toolName = normalizeToolName(tu.name);
+        if (!current._toolCounts[toolName]) current._toolCounts[toolName] = 0;
+        current._toolCounts[toolName]++;
+
+        const files = extractFilesFromToolUse(tu);
+        for (const f of files.modified) {
+          if (!current.filesModified.includes(f)) current.filesModified.push(f);
+        }
+        for (const f of files.read) {
+          if (!current.filesRead.includes(f)) current.filesRead.push(f);
+        }
+      }
+
+      if (ts && !current.startTimestamp) current.startTimestamp = ts;
+      if (ts) {
+        current.endTimestamp = ts;
+        lastTimestamp = ts;
+      }
+      current.endLineIndex = i;
+    }
+  }
+
+  // Finalize last chunk if it has content
+  if (current.turnCount > 0) {
+    chunks.push(finalizeChunk(current, sessionMeta));
+  }
+
+  // Post-process: split oversized chunks
+  const result = [];
+  for (const chunk of chunks) {
+    if (chunk.content.length > MAX_CONTENT_CHARS) {
+      // For now, just truncate — splitting at tool boundaries is complex
+      chunk.content = chunk.content.slice(0, MAX_CONTENT_CHARS);
+    }
+    result.push(chunk);
+  }
+
+  return result;
+}
+
+function createEmptyChunk(index) {
+  return {
+    chunkIndex: index,
+    startTimestamp: '',
+    endTimestamp: '',
+    userMessages: [],
+    assistantTexts: [],
+    toolsUsed: [],
+    filesModified: [],
+    filesRead: [],
+    turnCount: 0,
+    content: '',
+    summary: '',
+    startLineIndex: Infinity,
+    endLineIndex: 0,
+    _toolCounts: {}, // internal, removed during finalize
+  };
+}
+
+function finalizeChunk(chunk, sessionMeta) {
+  // Build tools_used from counts
+  chunk.toolsUsed = Object.entries(chunk._toolCounts)
+    .sort((a, b) => b[1] - a[1])
+    .map(([name, count]) => name);
+
+  // Build tool counts string for synthesis
+  const toolCountStr = Object.entries(chunk._toolCounts)
+    .sort((a, b) => b[1] - a[1])
+    .map(([name, count]) => `${name}(${count})`)
+    .join(', ');
+
+  // Build synthesized content for embedding
+  const parts = [];
+
+  // Header
+  const date = chunk.startTimestamp ? new Date(chunk.startTimestamp).toISOString().split('T')[0] : 'unknown';
+  parts.push(`[Project: ${sessionMeta.project || 'unknown'} | Branch: ${sessionMeta.gitBranch || 'unknown'} | ${date}]`);
+
+  // User messages (max 5)
+  const userMsgs = chunk.userMessages.slice(0, MAX_USER_MESSAGES);
+  for (const msg of userMsgs) {
+    parts.push(`USER: "${msg}"`);
+  }
+
+  // Assistant summary (combine and truncate)
+  const fullAssistant = chunk.assistantTexts.join(' ');
+  if (fullAssistant) {
+    const truncated = fullAssistant.slice(0, MAX_ASSISTANT_CHARS);
+    parts.push(`ASSISTANT: ${truncated}`);
+  }
+
+  // Tools and files
+  if (toolCountStr) {
+    parts.push(`TOOLS: ${toolCountStr}`);
+  }
+  if (chunk.filesModified.length > 0) {
+    parts.push(`FILES MODIFIED: ${chunk.filesModified.slice(0, 10).join(', ')}`);
+  }
+  if (chunk.filesRead.length > 0) {
+    parts.push(`FILES READ: ${chunk.filesRead.slice(0, 10).join(', ')}`);
+  }
+
+  chunk.content = parts.join('\n');
+
+  // Build summary (first user message, truncated)
+  chunk.summary = userMsgs[0]
+    ? userMsgs[0].slice(0, 100)
+    : (fullAssistant ? fullAssistant.slice(0, 100) : 'No content');
+
+  // Clean up internals
+  delete chunk._toolCounts;
+
+  // Limit user messages for storage
+  chunk.userMessages = userMsgs;
+
+  return chunk;
+}

package/neural-interface/lib/session-indexer.js

@@ -0,0 +1,327 @@
+import { queueMemoryCapture, captureMemoryFileBatch } from './memory-session-capture.js';
+/**
+ * Session Indexer — Pipeline orchestrator for indexing Claude Code session transcripts.
+ * Queues local JSONL files through the shared, incremental memory event intake.
+ *
+ * Runs in the Neural Interface server process. Uses shared SQLite database + local embeddings
+ * via lib/db.js (same memory.db as MCP server, WAL mode for concurrent access).
+ */
+
+import { readFileSync, writeFileSync, existsSync, statSync, readdirSync, mkdirSync, renameSync } from 'node:fs';
+import { join, basename, dirname } from 'node:path';
+import { getDataHome } from '../../lib/paths.js';
+import { getDb, getMemoryById, memoryVectors } from './db.js';
+import { upsertMemory as sharedUpsert } from '../../mcp-server/dist/services/sqlite.js';
+
+const DATA_HOME = getDataHome();
+const DATA_DIR = join(DATA_HOME, 'data');
+const STATE_FILE = join(DATA_DIR, 'session-index-state.json');
+
+const UPSERT_BATCH_SIZE = 50;
+
+// --- State management ---
+
+function loadState() {
+  try {
+    if (existsSync(STATE_FILE)) {
+      return JSON.parse(readFileSync(STATE_FILE, 'utf-8'));
+    }
+  } catch { /* ignore */ }
+  return { version: 1, sessions: {} };
+}
+
+function saveState(state) {
+  mkdirSync(dirname(STATE_FILE),{recursive:true});
+  const temporary=STATE_FILE+'.'+process.pid+'.tmp';
+  writeFileSync(temporary, JSON.stringify(state, null, 2));
+  renameSync(temporary,STATE_FILE);
+}
+
+// --- Project detection ---
+
+// Project detection — uses registered projects from claude-code-projects.json (dynamic, no hardcoded names)
+
+function loadRegisteredProjects() {
+  const projectsPath = join(DATA_HOME, 'data', 'claude-code-projects.json');
+  try {
+    if (existsSync(projectsPath)) {
+      return JSON.parse(readFileSync(projectsPath, 'utf-8'));
+    }
+  } catch { /* ignore */ }
+  return [];
+}
+
+/** Derive project label from Claude's directory name (e.g. "j--Sites-MyApp" → "myapp") */
+function detectProjectFromDir(dirName) {
+  if (!dirName) return 'global';
+  const lower = dirName.toLowerCase();
+  const projects = loadRegisteredProjects();
+
+  for (const p of projects) {
+    const label = p.label.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+    if (lower.includes(label)) return label;
+  }
+
+  const parts = dirName.split('-').filter(Boolean);
+  return (parts[parts.length - 1] || 'global').toLowerCase();
+}
+
+function upsertMemories(points) {
+  const d=getDb(); d.exec('BEGIN IMMEDIATE');
+  try { for(const point of points) sharedUpsert(point.id,point.vector,point.payload);d.exec('COMMIT'); }
+  catch(error){d.exec('ROLLBACK');memoryVectors.invalidate();throw error;}
+}
+
+// --- Main indexing pipeline ---
+
+/**
+ * @typedef {Object} IndexingOptions
+ * @property {string} [project] - Filter to a specific project path
+ * @property {boolean} [reindex] - Re-index already-indexed sessions
+ * @property {string[]} [sessionIds] - Index only specific session IDs
+ * @property {function} [onProgress] - Progress callback: (event) => void
+ * @property {function} [isCancelled] - Returns true if indexing should stop
+ */
+
+/**
+ * Start the indexing pipeline.
+ * @param {IndexingOptions} options
+ * @returns {Promise<{ totalSessions: number, totalChunks: number, errors: number }>}
+ */
+export async function startIndexing(options = {}) {
+  const { onProgress, isCancelled } = options;
+  const emit = onProgress || (() => {});
+
+  // Load indexing state
+  const state = loadState();
+
+  // Discover sessions to index by scanning ~/.claude/projects/ directly
+  const homeDir = process.env.USERPROFILE || process.env.HOME;
+  const claudeProjectsDir = options.projectsDir || join(homeDir, '.claude', 'projects');
+
+  const sessionsToIndex = [];
+
+  let projectDirs = [];
+  try {
+    projectDirs = readdirSync(claudeProjectsDir, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => ({ name: d.name, path: join(claudeProjectsDir, d.name) }));
+  } catch { /* no projects dir */ }
+
+  if (options.project) {
+    const projLower = options.project.toLowerCase();
+    projectDirs = projectDirs.filter(d => d.name.toLowerCase().includes(projLower));
+  }
+
+  for (const projDir of projectDirs) {
+    let files;
+    try { files = readdirSync(projDir.path).filter(f => f.endsWith('.jsonl')); } catch { continue; }
+
+    for (const file of files) {
+      const sessionId = file.replace('.jsonl', '');
+      const filePath = join(projDir.path, file);
+
+      if (options.sessionIds && !options.sessionIds.includes(sessionId)) continue;
+
+      if (!options.reindex && state.sessions[sessionId]) {
+        const entry = state.sessions[sessionId];
+        if (entry.status === 'complete') {
+          try {
+            const stat = statSync(filePath);
+            if (stat.size === entry.file_size && stat.mtime.toISOString() === entry.file_mtime) {
+              continue;
+            }
+          } catch { continue; }
+        }
+      }
+
+      try {
+        const stat = statSync(filePath);
+        if (stat.size === 0) continue;
+        sessionsToIndex.push({
+          sessionId,
+          filePath,
+          fileSize: stat.size,
+          fileMtime: stat.mtime.toISOString(),
+          projectDir: projDir.name,
+        });
+      } catch { continue; }
+    }
+  }
+
+  sessionsToIndex.sort((a, b) => new Date(b.fileMtime) - new Date(a.fileMtime));
+
+  const totalSessions = sessionsToIndex.length;
+  emit({ type: 'indexing:started', totalSessions, project: options.project || 'all' });
+
+  let totalChunks = 0;
+  let errors = 0;
+  const startedAt = new Date().toISOString();
+
+  for (let si = 0; si < sessionsToIndex.length; si++) {
+    if (isCancelled && isCancelled()) {
+      emit({ type: 'indexing:cancelled', completedSessions: si, totalSessions });
+      break;
+    }
+
+    const session = sessionsToIndex[si];
+    emit({ type: 'indexing:session-started', sessionId: session.sessionId, sessionIndex: si, totalSessions });
+
+    try {
+      // All providers use the same durable event intake and local embedding queue.
+      // Preserve this entry point and its UI progress events for Claude hooks.
+      queueMemoryCapture({host:'claude-code',sessionId:session.sessionId,filePath:session.filePath,project:detectProjectFromDir(session.projectDir)});
+      let complete=false;
+      while(!isCancelled?.()) {
+        const before=getDb().prepare('SELECT byte_offset,status FROM memory_capture_files WHERE host=? AND session_id=?').get('claude-code',session.sessionId);
+        const outcome=await captureMemoryFileBatch({host:'claude-code',sessionId:session.sessionId});
+        if(outcome?.busy){await new Promise(resolve=>setTimeout(resolve,20));continue;}
+        if(outcome?.paused)break;
+        const after=getDb().prepare('SELECT byte_offset,status,error FROM memory_capture_files WHERE host=? AND session_id=?').get('claude-code',session.sessionId);
+        if(after?.status==='failed')throw new Error(after.error);
+        if(after?.status==='complete'){complete=true;break;}
+        if(after?.byte_offset===before?.byte_offset)break; // incomplete JSONL tail
+        emit({type:'indexing:session-progress',sessionId:session.sessionId,phase:'indexing'});
+      }
+      const chunks=getDb().prepare('SELECT chunk_id FROM memory_session_sources WHERE host=? AND session_id=?').all('claude-code',session.sessionId);
+      totalChunks+=chunks.length;
+      state.sessions[session.sessionId]={session_id:session.sessionId,file_path:session.filePath,file_size:session.fileSize,file_mtime:session.fileMtime,
+        chunk_count:chunks.length,chunk_ids:chunks.map(r=>r.chunk_id),indexed_at:new Date().toISOString(),project:detectProjectFromDir(session.projectDir),
+        status:complete ? 'complete' : 'partial',last_line_indexed:0};
+      saveState(state);
+      emit({type:'indexing:session-complete',sessionId:session.sessionId,chunkCount:chunks.length,sessionIndex:si,totalSessions});
+
+    } catch (err) {
+      errors++;
+      state.sessions[session.sessionId] = {
+        ...state.sessions[session.sessionId],
+        session_id: session.sessionId,
+        file_path: session.filePath,
+        file_size: session.fileSize,
+        file_mtime: session.fileMtime,
+        status: 'partial',
+        indexed_at: new Date().toISOString(),
+        project: detectProjectFromDir(session.projectDir),
+      };
+      saveState(state);
+      emit({ type: 'indexing:error', sessionId: session.sessionId, error: err.message });
+    }
+  }
+
+  state.last_run = {
+    started_at: startedAt,
+    completed_at: new Date().toISOString(),
+    total_sessions: totalSessions,
+    total_chunks: totalChunks,
+    errors,
+  };
+  saveState(state);
+
+  emit({ type: 'indexing:complete', totalSessions, totalChunks, errors, durationMs: Date.now() - new Date(startedAt).getTime() });
+
+  return { totalSessions, totalChunks, errors };
+}
+
+/**
+ * One-time migration: copy existing session_chunks into memories as conversations.
+ * Uses vectors already stored in SQLite — no re-embedding needed.
+ * Skips chunks that already exist in memories (same UUID) or have dedup_memory_id.
+ * @param {function} [onProgress] - Progress callback
+ * @returns {Promise<{ mirrored: number, skipped: number, errors: number }>}
+ */
+export async function mirrorExistingChunks(onProgress) {
+  const emit = onProgress || (() => {});
+  const d = getDb();
+
+  let mirrored = 0;
+  let skipped = 0;
+  let errors = 0;
+
+  emit({ type: 'mirror:started' });
+
+  // Get all session chunks with vectors
+  const rows = d.prepare(`SELECT id, vector, content, summary, session_id, project, git_branch,
+    cwd, chunk_index, start_timestamp, end_timestamp, tools_used, files_modified,
+    files_read, user_messages, turn_count, related_memory_ids, dedup_memory_id, indexed_at
+    FROM session_chunks`).all();
+
+  const mirrorPoints = [];
+
+  for (const row of rows) {
+    const dedupMemoryId = row.dedup_memory_id;
+    if (dedupMemoryId) {
+      skipped++;
+      continue;
+    }
+
+    // Check if already mirrored
+    const existing = getMemoryById(row.id);
+    if (existing) {
+      skipped++;
+      continue;
+    }
+
+    const toolsUsed = JSON.parse(row.tools_used || '[]');
+    const filesModified = JSON.parse(row.files_modified || '[]');
+    const relatedMemoryIds = JSON.parse(row.related_memory_ids || '[]');
+
+    const mirrorPayload = {
+      content: row.content,
+      category: 'conversations',
+      subcategory: 'session-chunk',
+      project: row.project || 'global',
+      tags: [
+        'session-index',
+        ...(row.git_branch ? [`branch:${row.git_branch}`] : []),
+        ...toolsUsed.slice(0, 3),
+      ],
+      importance: 3,
+      source: 'auto-saved',
+      created_at: row.start_timestamp || new Date().toISOString(),
+      updated_at: row.indexed_at || new Date().toISOString(),
+      accessed_at: row.indexed_at || new Date().toISOString(),
+      access_count: 0,
+      related_files: filesModified.slice(0, 20),
+      related_memory_ids: relatedMemoryIds,
+      source_session_chunks: [{ session_id: row.session_id, chunk_id: row.id }],
+    };
+
+    mirrorPoints.push({
+      id: row.id,
+      vector: Array.from(new Float32Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength / 4)),
+      payload: mirrorPayload,
+    });
+  }
+
+  // Batch upsert to memories
+  if (mirrorPoints.length > 0) {
+    try {
+      for (let i = 0; i < mirrorPoints.length; i += UPSERT_BATCH_SIZE) {
+        const batch = mirrorPoints.slice(i, i + UPSERT_BATCH_SIZE);
+        upsertMemories(batch);
+        mirrored += batch.length;
+        emit({ type: 'mirror:progress', mirrored, skipped, errors, batch: Math.floor(i / UPSERT_BATCH_SIZE) });
+      }
+    } catch (err) {
+      errors += mirrorPoints.length - mirrored;
+      emit({ type: 'mirror:error', error: err.message });
+    }
+  }
+
+  emit({ type: 'mirror:complete', mirrored, skipped, errors });
+  return { mirrored, skipped, errors };
+}
+
+/**
+ * Get current indexing status.
+ */
+export function getIndexingStatus() {
+  const state = loadState();
+  const indexed = Object.values(state.sessions).filter(s => s.status === 'complete');
+  return {
+    indexedSessions: indexed.length,
+    totalChunks: indexed.reduce((sum, s) => sum + (s.chunk_count || 0), 0),
+    lastRun: state.last_run || null,
+    indexedSessionIds: new Set(indexed.map(s => s.session_id)),
+  };
+}