@misterhuydo/cairn-mcp 1.4.2 → 1.6.2

package/README.md

@@ -73,11 +73,29 @@ No manual steps. The index lives in `.cairn/index.db` inside your project — li
 | `cairn_outline` | Project-wide structural outline + heuristic issue detection (god classes, lifecycle gaps, naming inconsistencies, missing tests) |
 | `cairn_code_graph` | Dependency health — instability, cycles, load-bearing modules |
 | `cairn_security` | Scan for XSS, SQLi, hardcoded secrets, weak crypto, and more |
+| `cairn_todos` | Scan codebase for TODO/FIXME/HACK comments, add manual items, resolve and list them |
 | `cairn_bundle` | Minified source snapshot (auto-handled by hooks) |
 | `cairn_checkpoint` | Save session state (auto-handled by hooks) |
 
 ---
 
+## TODO tracking
+
+`cairn_todos` scans every file Cairn indexes for `TODO`, `FIXME`, `HACK`, `XXX`, and `NOTE` comments and stores them in the project database. Manual items you add yourself are never overwritten by a scan.
+
+```
+cairn_todos { action: "list" }                          → all todos (open + done)
+cairn_todos { action: "list", status: "open" }          → open only
+cairn_todos { action: "list", source: "manual" }        → items you added yourself
+cairn_todos { action: "add", text: "...", kind: "FIXME" } → add a manual item
+cairn_todos { action: "resolve", id: 42 }               → mark done
+cairn_todos { action: "scan" }                          → re-scan without full maintain
+```
+
+Stats are included automatically in `cairn_maintain` (`todos_found`) and `cairn_resume` (`open_todos`), so you always know the backlog at a glance.
+
+---
+
 ## Supported languages
 
 | Language | What Cairn extracts |

package/bin/cairn-cli.js

@@ -18,11 +18,16 @@ process.on('uncaughtException', (e) => {
 
 const subcommand = process.argv[2];
 
-if (subcommand === 'minify') {
+if (subcommand === '--version' || subcommand === '-v') {
+  const pkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+  console.log(pkg.version);
+  process.exit(0);
+
+} else if (subcommand === 'minify') {
   // PreToolUse[Read] hook.
   // Per-file state machine stored in .cairn/minify-map.json:
   //   no entry      → minify, write to .cairn/views/, block Read (exit 2) with inline content or outline
-  //   'compressed'  → re-read after edit-guard blocked; advance to 'edit-ready', pass through (exit 0)
+  //   'compressed'  → edit-guard blocked Edit + provided content; if re-read happens, advance to 'edit-ready'
   //   'edit-ready'  → Edit is imminent; pass through without touching state (exit 0)
   let stdinData = '';
   process.stdin.setEncoding('utf8');
@@ -64,7 +69,8 @@ if (subcommand === 'minify') {
     }
 
     if (entry?.state === 'compressed') {
-      // Re-read requested by edit-guard: advance to edit-ready so Edit can proceed
+      // edit-guard already advanced to 'edit-ready' and showed content inline.
+      // If Claude re-reads the original anyway, advance to edit-ready and pass through.
       entry.state = 'edit-ready';
       saveMap(cairnDir, map);
       process.exit(0);
@@ -129,19 +135,22 @@ if (subcommand === 'minify') {
   });
 
 } else if (subcommand === 'edit-guard') {
-  // PreToolUse[Edit] hook.
+  // PreToolUse[Edit|Write] hook.
   // Per-file state:
-  //   no entry      → file was never minified (full content always shown), allow Edit
-  //   'compressed'  → block Edit, instruct Claude to re-read original first
-  //   'edit-ready'  → re-read was done with full content, allow Edit and clear entry
+  //   no entry      → file was never minified (full content always shown), allow Edit/Write
+  //   'compressed'  → block Edit; advance to 'edit-ready' and provide full content inline
+  //                   Write always allowed (it supplies its own content); clears entry
+  //   'edit-ready'  → content was provided/re-read, allow Edit and clear entry
   let stdinData = '';
   process.stdin.setEncoding('utf8');
   process.stdin.on('data', chunk => { stdinData += chunk; });
   process.stdin.on('end', () => {
     let filePath = '(unknown)';
+    let toolName = 'Edit';
     try {
       const input = JSON.parse(stdinData);
       filePath = input?.tool_input?.file_path || '(unknown)';
+      toolName = input?.tool_name || 'Edit';
     } catch { }
 
     const resolvedPath = path.resolve(filePath);
@@ -159,18 +168,44 @@ if (subcommand === 'minify') {
       process.exit(0);
     }
 
+    // Write replaces the entire file — no need to show old content. Clear and allow.
+    if (toolName === 'Write') {
+      delete map[resolvedPath];
+      saveMap(cairnDir, map);
+      process.exit(0);
+    }
+
     if (entry.state === 'edit-ready') {
       delete map[resolvedPath];
       saveMap(cairnDir, map);
       process.exit(0);
     }
 
-    // state='compressed': Claude hasn't re-read with full content yet
-    saveMap(cairnDir, map); // save any cleanup from validateMap
-    process.stderr.write(
-      `[cairn] Re-read the file before editing: Read("${filePath}")\n` +
-      `The file content was compressed by cairn. Re-read it now to get full content, then retry the Edit.\n`
-    );
+    // state='compressed': Claude hasn't re-read with full content yet.
+    // Advance to 'edit-ready' now so the next Edit attempt is allowed regardless
+    // of whether Claude re-reads the original or the cached view.
+    entry.state = 'edit-ready';
+    saveMap(cairnDir, map);
+
+    // For small-to-medium files, provide full content inline so Claude can retry
+    // without a separate Read round-trip, and so there's no cached-view confusion.
+    let fullContent = null;
+    try {
+      const raw = fs.readFileSync(resolvedPath, 'utf8');
+      if (raw.split('\n').length <= 300) fullContent = raw;
+    } catch { }
+
+    if (fullContent !== null) {
+      process.stdout.write(
+        `[cairn] File was compressed in context. Full source content:\n\n${fullContent}\n\n` +
+        `Re-apply your Edit using the exact content above (state is now edit-ready).\n`
+      );
+    } else {
+      process.stdout.write(
+        `[cairn] Re-read the file before editing: Read("${filePath}")\n` +
+        `The file content was compressed by cairn. Re-read it now to get full content, then retry the Edit.\n`
+      );
+    }
     process.exit(2);
   });
 
@@ -274,7 +309,12 @@ if (subcommand === 'minify') {
   }
   const session = JSON.parse(fs.readFileSync(sessionPath, 'utf8'));
   const when = new Date(session.checkpoint_at).toLocaleString();
-  process.stdout.write(`[cairn] Prior session: "${session.message}" (${when}). Call cairn_resume to restore prior context.\n`);
+  process.stdout.write([
+    `[cairn] Prior session: "${session.message}" (${when}).`,
+    `[cairn] SESSION: call cairn_resume to restore context (or cairn_maintain for a fresh index). At end of session call cairn_checkpoint with message + active_files + notes.`,
+    `[cairn] TOOLS: prefer cairn_search / cairn_bundle / cairn_describe over manual file browsing. Use cairn_outline for structural overview, cairn_todos for backlog, cairn_security before PRs.`,
+    `[cairn] MEMORY: IMPORTANT — call cairn_memo IMMEDIATELY and SILENTLY (do NOT ask the user, do NOT list what you are about to save, do NOT confirm afterward) when you observe — preference: user corrects/confirms your behaviour; experience: non-trivial problem solved; decision: architectural choice made; knowledge: non-obvious codebase fact discovered. cairn_employ_memory is explicit only — never call it unless asked.`,
+  ].join('\n') + '\n');
   fs.writeFileSync(lockPath, new Date().toISOString(), 'utf8');
   process.exit(0);
 
@@ -306,7 +346,8 @@ if (subcommand === 'minify') {
   console.log('');
   console.log('Active hooks:');
   console.log('  PreToolUse[Read]    -> cairn minify            (compress source files for reading)');
-  console.log('  PreToolUse[Edit]    -> cairn edit-guard        (block Edit until re-read with full content)');
+  console.log('  PreToolUse[Edit]    -> cairn edit-guard        (block Edit until re-read with full content)')
+  console.log('  PreToolUse[Write]   -> cairn edit-guard        (clear minify state before full file overwrite)');
   console.log('  Stop                -> cairn checkpoint --auto  (auto-save session)');
   console.log('  UserPromptSubmit    -> cairn resume-hint        (remind Claude of prior session)');
   console.log('');
@@ -325,13 +366,14 @@ if (subcommand === 'minify') {
   console.log('');
   console.log('Active hooks:');
   console.log('  PreToolUse[Read]    -> cairn minify            (compress source files for reading)');
-  console.log('  PreToolUse[Edit]    -> cairn edit-guard        (block Edit until re-read with full content)');
+  console.log('  PreToolUse[Edit]    -> cairn edit-guard        (block Edit until re-read with full content)')
+  console.log('  PreToolUse[Write]   -> cairn edit-guard        (clear minify state before full file overwrite)');
   console.log('  Stop                -> cairn checkpoint --auto  (auto-save session)');
   console.log('  UserPromptSubmit    -> cairn resume-hint        (remind Claude of prior session)');
   process.exit(0);
 
 } else {
-  console.error('Usage: cairn <install | install-hooks [--global] | minify | edit-guard | validate-map | checkpoint --auto | resume-hint>');
+  console.error('Usage: cairn <--version | install | install-hooks [--global] | minify | edit-guard | validate-map | checkpoint --auto | resume-hint>');
   process.exit(1);
 }
 
@@ -355,6 +397,9 @@ function applyHooks(settingsDir, isGlobal) {
   if (!cleanedPreHooks.some(h => h.matcher === 'Edit' && h.hooks?.some(hh => hh.command === 'cairn edit-guard'))) {
     cleanedPreHooks.push({ matcher: 'Edit', hooks: [{ type: 'command', command: 'cairn edit-guard' }] });
   }
+  if (!cleanedPreHooks.some(h => h.matcher === 'Write' && h.hooks?.some(hh => hh.command === 'cairn edit-guard'))) {
+    cleanedPreHooks.push({ matcher: 'Write', hooks: [{ type: 'command', command: 'cairn edit-guard' }] });
+  }
   settings.hooks.PreToolUse = cleanedPreHooks;
 
   // Stop: cairn checkpoint --auto

package/index.js

@@ -13,6 +13,10 @@ import { checkpoint }   from './src/tools/checkpoint.js';
 import { resume }       from './src/tools/resume.js';
 import { minify }       from './src/tools/minify.js';
 import { outlineProject } from './src/tools/outline.js';
+import { todos }        from './src/tools/todos.js';
+import { memo }         from './src/tools/memo.js';
+import { switchProject } from './src/tools/switch.js';
+import { employMemory } from './src/tools/employMemory.js';
 
 const db = openDB();
 
@@ -139,7 +143,7 @@ Typical workflow: cairn_search → find files → cairn_bundle those paths → C
     },
     {
       name: 'cairn_resume',
-      description: 'Restore the last saved session state. Detects which files changed since the checkpoint and incrementally re-indexes only those files. Call at the start of a session instead of cairn_maintain when resuming work.',
+      description: 'Restore the last saved session state. Detects which files changed since the checkpoint and incrementally re-indexes only those files. Also loads preference memories and surfaces the memory index. Call at the start of a session instead of cairn_maintain when resuming work. If the project was moved to a different drive or directory, paths are repaired automatically.',
       inputSchema: {
         type: 'object',
         properties: {},
@@ -187,6 +191,87 @@ Use to: get a project-wide bird's-eye view, triage code quality, find where to l
         required: ['file_path'],
       },
     },
+    {
+      name: 'cairn_memo',
+      description: 'Persist and retrieve typed memories in .cairn/memory/. Use this — not the auto-memory system — for all project-level memories. Triggered by: "save cairn memory", "cairn remember", "build cairn memories", "save experience to cairn". Four types: preference (user working style — always loaded on resume), experience (transferable lessons learned — migrated between projects), decision (project-specific architectural choices), knowledge (project-specific codebase facts). Memories survive context loss and accumulate across sessions.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          action: {
+            type: 'string',
+            enum: ['write', 'read', 'list', 'delete'],
+            description: 'write: save/update a memory | read: load a memory by name | list: show all memories with index | delete: remove a memory',
+          },
+          name: { type: 'string', description: 'Memory identifier (required for write/read/delete)' },
+          type: {
+            type: 'string',
+            enum: ['preference', 'experience', 'decision', 'knowledge'],
+            description: 'Memory type (required for write)',
+          },
+          content: { type: 'string', description: 'Memory body — what should be remembered (required for write)' },
+          description: { type: 'string', description: 'One-line summary shown in the memory index' },
+          origin: { type: 'string', description: 'Optional: source project path, for traceability of migrated memories' },
+        },
+        required: ['action'],
+      },
+    },
+    {
+      name: 'cairn_switch',
+      description: 'Switch the active Cairn project context to a different directory. Detects the project root automatically from any path within the project (via .git, package.json, .cairn, etc.). Call cairn_resume or cairn_maintain after switching. Call with no arguments to return to the original session\'s project.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          project_path: {
+            type: 'string',
+            description: 'Any path inside the target project (file or directory). Omit to restore the original session root.',
+          },
+        },
+      },
+    },
+    {
+      name: 'cairn_employ_memory',
+      description: 'Migrate memories from another project\'s .cairn/memory/ into the current project. By default copies only transferable types (preference + experience) — skips project-specific decision and knowledge. Imported memories are tagged with their origin project path for traceability.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          source_path: {
+            type: 'string',
+            description: 'Path to the source project (any file/directory inside it, or its .cairn directory)',
+          },
+          types: {
+            type: 'array',
+            items: { type: 'string', enum: ['preference', 'experience', 'decision', 'knowledge'] },
+            description: 'Optional: memory types to migrate (default: ["preference", "experience"])',
+          },
+          overwrite: {
+            type: 'boolean',
+            default: false,
+            description: 'Overwrite existing memories with the same filename (default: false)',
+          },
+        },
+        required: ['source_path'],
+      },
+    },
+    {
+      name: 'cairn_todos',
+      description: 'Manage TODO/FIXME/HACK/XXX items. Scans the codebase for TODO-style comments and lets you add your own. Stats are included in cairn_maintain and cairn_resume reports.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          action: {
+            type: 'string',
+            enum: ['list', 'add', 'resolve', 'scan'],
+            description: 'list: show todos | add: create a manual todo | resolve: mark done by id | scan: re-scan codebase',
+          },
+          text:   { type: 'string',  description: 'Text for the new todo (add action)' },
+          kind:   { type: 'string',  enum: ['TODO', 'FIXME', 'HACK', 'XXX', 'NOTE'], description: 'Kind for new todo (default: TODO)' },
+          id:     { type: 'number',  description: 'Todo ID to resolve (resolve action)' },
+          status: { type: 'string',  enum: ['open', 'done'], description: 'Filter by status (list action)' },
+          source: { type: 'string',  enum: ['scan', 'manual'], description: 'Filter by source (list action)' },
+        },
+        required: ['action'],
+      },
+    },
   ],
 }));
 
@@ -203,6 +288,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     case 'cairn_resume':      return await resume(db);
     case 'cairn_outline':     return outlineProject(db, args);
     case 'cairn_minify':      return minify(db, args);
+    case 'cairn_todos':          return await todos(db, args);
+    case 'cairn_memo':           return memo(db, args);
+    case 'cairn_switch':         return switchProject(db, args);
+    case 'cairn_employ_memory':  return employMemory(db, args);
     default: throw new Error(`Unknown tool: ${name}`);
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@misterhuydo/cairn-mcp",
-  "version": "1.4.2",
+  "version": "1.6.2",
   "description": "MCP server that gives Claude Code persistent memory across sessions. Index your codebase once, search symbols, bundle source, scan for vulnerabilities, and checkpoint/resume work — across Java, TypeScript, Vue, Python, SQL and more.",
   "type": "module",
   "main": "index.js",

package/src/graph/cwd.js

@@ -1,11 +1,31 @@
 import fs from 'fs';
 import path from 'path';
 
+let _activeProjectRoot = null;
+
+export function getProjectRoot() {
+  return _activeProjectRoot || process.cwd();
+}
+
+export function setActiveProjectRoot(rootPath) {
+  const previous = _activeProjectRoot;
+  _activeProjectRoot = rootPath;
+  return previous;
+}
+
 export function getCairnDir() {
-  const cairnDir = path.join(process.cwd(), '.cairn');
+  const cairnDir = path.join(getProjectRoot(), '.cairn');
   fs.mkdirSync(path.join(cairnDir, 'bundles'), { recursive: true });
   // Write sentinel so findCairnDir() recognises this as a cairn project directory
   const sentinel = path.join(cairnDir, '.cairn-project');
   if (!fs.existsSync(sentinel)) fs.writeFileSync(sentinel, '', 'utf8');
   return cairnDir;
 }
+
+export function getMemoryDir() {
+  const memoryDir = path.join(getCairnDir(), 'memory');
+  fs.mkdirSync(memoryDir, { recursive: true });
+  const indexPath = path.join(memoryDir, 'MEMORY.md');
+  if (!fs.existsSync(indexPath)) fs.writeFileSync(indexPath, '# Memory Index\n', 'utf8');
+  return memoryDir;
+}

package/src/graph/db.js

@@ -57,6 +57,18 @@ const SCHEMA = `
   CREATE TABLE IF NOT EXISTS sub_indexes (
     path TEXT PRIMARY KEY
   );
+
+  CREATE TABLE IF NOT EXISTS todos (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    source      TEXT NOT NULL DEFAULT 'manual',
+    file        TEXT,
+    line        INTEGER,
+    kind        TEXT NOT NULL DEFAULT 'TODO',
+    text        TEXT NOT NULL,
+    status      TEXT NOT NULL DEFAULT 'open',
+    created_at  TEXT NOT NULL DEFAULT (datetime('now')),
+    resolved_at TEXT
+  );
 `;
 
 // Each sub-DB gets its IDs offset by this multiplier to prevent collisions

package/src/indexer/todoScanner.js

@@ -0,0 +1,41 @@
+import fs from 'fs/promises';
+
+// Matches TODO/FIXME/HACK/XXX/NOTE in single-line comments (//, #),
+// block comment lines (* or /*), and HTML comments (<!--).
+const TODO_RE = /(?:\/\/|#|\/\*|\*|<!--)\s*(TODO|FIXME|HACK|XXX|NOTE)[:\s]+(.*)/i;
+
+/**
+ * Delete all scan-sourced todos, then re-scan filePaths for TODO-style comments.
+ * Manual todos are always preserved.
+ * Returns the number of todos found.
+ */
+export async function scanTodos(db, filePaths) {
+  db.prepare('DELETE FROM main.todos WHERE source = ?').run('scan');
+
+  const insert = db.prepare(
+    'INSERT INTO main.todos (source, file, line, kind, text) VALUES (?, ?, ?, ?, ?)'
+  );
+
+  let count = 0;
+  for (const filePath of filePaths) {
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      const lines = content.split('\n');
+      for (let i = 0; i < lines.length; i++) {
+        const match = TODO_RE.exec(lines[i]);
+        if (match) {
+          const kind = match[1].toUpperCase();
+          const text = match[2].trim();
+          if (text) {
+            insert.run('scan', filePath, i + 1, kind, text);
+            count++;
+          }
+        }
+      }
+    } catch {
+      // skip unreadable files
+    }
+  }
+
+  return count;
+}

package/src/tools/employMemory.js

@@ -0,0 +1,135 @@
+import fs from 'fs';
+import path from 'path';
+import { getMemoryDir } from '../graph/cwd.js';
+import { detectProjectRoot } from './switch.js';
+import { loadIndexEntries, TRANSFERABLE_TYPES } from './memo.js';
+
+export function employMemory(_db, { source_path, types, overwrite = false }) {
+  if (!source_path) throw new Error('source_path is required');
+
+  // Resolve source .cairn/memory/ directory
+  let sourceMemoryDir;
+  const normalized = source_path.replace(/\\/g, '/');
+
+  if (normalized.endsWith('/.cairn/memory') || normalized.endsWith('\\.cairn\\memory')) {
+    sourceMemoryDir = source_path;
+  } else if (normalized.endsWith('/.cairn') || normalized.endsWith('\\.cairn')) {
+    sourceMemoryDir = path.join(source_path, 'memory');
+  } else {
+    const projectRoot = detectProjectRoot(source_path);
+    if (!projectRoot) {
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            migrated: false,
+            reason: 'Could not detect a project root from source_path.',
+            source_path,
+          }, null, 2),
+        }],
+      };
+    }
+    sourceMemoryDir = path.join(projectRoot, '.cairn', 'memory');
+  }
+
+  if (!fs.existsSync(sourceMemoryDir)) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          migrated: false,
+          reason: 'Source project has no .cairn/memory directory. Run cairn_maintain or cairn_resume there first.',
+          source_memory_dir: sourceMemoryDir,
+        }, null, 2),
+      }],
+    };
+  }
+
+  const allowedTypes = types && types.length > 0 ? types : TRANSFERABLE_TYPES;
+  const sourceEntries = loadIndexEntries(sourceMemoryDir).filter(e => allowedTypes.includes(e.type));
+
+  if (sourceEntries.length === 0) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          migrated: false,
+          reason: `No memories of types [${allowedTypes.join(', ')}] found in source project.`,
+          source_memory_dir: sourceMemoryDir,
+        }, null, 2),
+      }],
+    };
+  }
+
+  const targetMemoryDir = getMemoryDir();
+
+  // Determine origin label from source path
+  const originLabel = path.dirname(path.dirname(sourceMemoryDir)); // project root
+
+  // Load target index
+  const targetEntries = loadIndexEntries(targetMemoryDir);
+  const targetFileSet = new Set(targetEntries.map(e => e.file));
+
+  const results = { copied: [], skipped: [], errors: [] };
+
+  for (const entry of sourceEntries) {
+    const srcFile = path.join(sourceMemoryDir, entry.file);
+    if (!fs.existsSync(srcFile)) {
+      results.errors.push({ name: entry.name, reason: 'source file missing' });
+      continue;
+    }
+
+    const destFile = path.join(targetMemoryDir, entry.file);
+    const alreadyExists = targetFileSet.has(entry.file);
+
+    if (alreadyExists && !overwrite) {
+      results.skipped.push({ name: entry.name, reason: 'already exists (use overwrite: true to replace)' });
+      continue;
+    }
+
+    // Read source, inject origin if not already set
+    let raw = fs.readFileSync(srcFile, 'utf8');
+    if (!raw.includes('\norigin:')) {
+      raw = raw.replace('---\n\n', `---\norigin: ${originLabel}\n\n`);
+      // fallback if pattern doesn't match
+      if (!raw.includes(`origin: ${originLabel}`)) {
+        raw = raw.replace(/^---\n/, `---\norigin: ${originLabel}\n`);
+      }
+    }
+
+    try {
+      fs.writeFileSync(destFile, raw, 'utf8');
+      if (!alreadyExists) {
+        targetEntries.push({ ...entry });
+        targetFileSet.add(entry.file);
+      }
+      results.copied.push({ name: entry.name, type: entry.type, origin: originLabel });
+    } catch (e) {
+      results.errors.push({ name: entry.name, reason: e.message });
+    }
+  }
+
+  // Rewrite target MEMORY.md index
+  if (results.copied.length > 0) {
+    const lines = ['# Memory Index', ''];
+    for (const e of targetEntries) {
+      lines.push(`- [${e.name}](${e.file}) — ${e.description} \`[${e.type}]\``);
+    }
+    fs.writeFileSync(path.join(targetMemoryDir, 'MEMORY.md'), lines.join('\n') + '\n', 'utf8');
+  }
+
+  return {
+    content: [{
+      type: 'text',
+      text: JSON.stringify({
+        migrated: results.copied.length > 0,
+        source: originLabel,
+        types_migrated: allowedTypes,
+        copied: results.copied.length,
+        skipped: results.skipped.length,
+        errors: results.errors.length,
+        details: results,
+      }, null, 2),
+    }],
+  };
+}

package/src/tools/maintain.js

@@ -9,6 +9,7 @@ import { parseGradle } from '../indexer/buildParsers/gradleParser.js';
 import { upsertFile, upsertSymbol, clearFileData } from '../graph/nodes.js';
 import { insertDependency, insertBuildDep, insertSecurityFinding } from '../graph/edges.js';
 import { registerSubIndexes, refreshFederatedViews } from '../graph/db.js';
+import { scanTodos } from '../indexer/todoScanner.js';
 
 function inferFileType(filePath) {
   const fp = filePath.toLowerCase();
@@ -85,6 +86,7 @@ export async function maintain(db, { languages } = {}) {
     symbols_total: 0,
     dependencies_mapped: 0,
     security_findings: 0,
+    todos_found: 0,
   };
 
   // Walk only files NOT already covered by a sub-project index
@@ -108,6 +110,8 @@ export async function maintain(db, { languages } = {}) {
     }
   }
 
+  stats.todos_found = await scanTodos(db, files);
+
   rebuildFts(db);
 
   // Register sub-indexes and attach them so queries are federated immediately