nano-brain 2026.4.1 → 2026.4.2

package/.opencode/command/nano-brain-init.md

@@ -2,35 +2,46 @@
 description: Initialize nano-brain persistent memory for the current workspace.
 ---
 
-## Prerequisites
+## Steps
 
-nano-brain MCP server must be configured in opencode.json. If `memory_status` tool is not available, tell user to add nano-brain to their MCP config first.
+**Try MCP first, fall back to CLI.**
 
-## Steps
+### Option A: MCP tools available
 
 1. Call `memory_status` tool to check current state
    - If codebase > 0 docs: already initialized, skip to step 4
-   - If error "tool not found": MCP not configured, stop and instruct user
+   - If error "tool not found": use Option B
 
 2. Call `memory_index_codebase` with `root` = current workspace path
-   - This indexes source files (respects .gitignore)
 
 3. Call `memory_update` to index sessions and curated notes
 
-4. Call `memory_status` again and report:
-   - Total documents indexed
-   - Pending embeddings count
-   - Embedding server status (connected/disconnected)
+4. Call `memory_status` again and report results
+
+### Option B: MCP tools NOT available (fallback)
+
+Run via Bash:
+
+```bash
+npx nano-brain init --root=$(pwd)
+```
+
+This does everything: indexes codebase + harvests sessions + indexes collections + generates embeddings.
+
+### Detection
+
+Try `memory_status` first. If it errors with "tool not found" or "MCP server not found", use Option B.
 
 ## Output Format
 
 ```
 nano-brain initialized:
 - Codebase: X files
-- Sessions: Y documents  
+- Symbol graph: A symbols, B edges
+- Sessions: Y documents
 - Pending embeddings: Z (processing in background)
-- Embedding server: ✅ connected / ❌ disconnected
+- Embedding server: connected / disconnected
 ```
 
 If pending embeddings > 0, explain they process automatically when MCP server runs.
-If embedding server disconnected, suggest: "Start Ollama: `ollama serve`"
+If embedding server disconnected, suggest checking config.yml embedding settings.

package/.opencode/command/nano-brain-reindex.md

@@ -7,25 +7,50 @@ description: Rescan codebase and refresh all nano-brain indexes after branch swi
 - After `git checkout`, `git pull`, or branch switch
 - After major code changes (new files, deleted files, refactors)
 - When search results seem stale or missing recent changes
+- When `code_context` / `code_impact` return "symbol not found"
 
 ## Steps
 
-1. Call `memory_index_codebase` with `root` = current workspace path
-   - Detects new, changed, and deleted files via content hash
-   - Only re-indexes what changed (incremental)
+**Try MCP first, fall back to CLI.**
+
+### Option A: MCP tools available
 
+1. Call `memory_index_codebase` with `root` = current workspace path
 2. Call `memory_update` to refresh session and note indexes
+3. Call `memory_status` and report results
+
+### Option B: MCP tools NOT available (fallback)
+
+Run via Bash:
+
+```bash
+npx nano-brain reindex
+```
+
+If `reindex` command is not yet available (older version), use:
+
+```bash
+npx nano-brain init
+```
+
+Note: `init` is safe without `--force` — it preserves all existing data and only re-scans.
+
+### Detection
+
+Try `memory_status` first. If it errors with "tool not found" or "MCP server not found", use Option B.
 
-3. Call `memory_status` and report:
+## Output Format
 
 ```
 Reindex complete:
-- Codebase: X files (Y new, Z updated)
+- Codebase: X files (Y new, Z unchanged)
+- Symbol graph: A symbols, B edges
 - Pending embeddings: N
 ```
 
 ## Notes
 
 - Reindexing is incremental — unchanged files are skipped
+- Symbol graph (code_symbols, symbol_edges) is rebuilt for changed files
 - New/changed files need embedding — happens in background
 - If many pending embeddings, they process automatically over time

package/.opencode/command/nano-brain-status.md

@@ -4,9 +4,26 @@ description: Show nano-brain memory health and statistics.
 
 ## Steps
 
+**Try MCP first, fall back to CLI.**
+
+### Option A: MCP tools available
+
 1. Call `memory_status` tool
+2. Present results (see format below)
+
+### Option B: MCP tools NOT available (fallback)
+
+Run via Bash:
+
+```bash
+npx nano-brain status
+```
+
+### Detection
+
+Try `memory_status` first. If it errors with "tool not found" or "MCP server not found", use Option B.
 
-2. Present results in this format:
+## Output Format
 
 ```
 nano-brain Status
@@ -17,7 +34,7 @@ Documents: X total
   - memory: C notes
 
 Embeddings: Y embedded, Z pending
-Server: ✅ connected (model) / ❌ disconnected
+Server: connected (model) / disconnected
 ```
 
 ## Suggested Actions
@@ -28,5 +45,5 @@ Based on status, suggest ONE relevant action:
 |-----------|------------|
 | codebase = 0 | "Run `/nano-brain-init` to index this workspace" |
 | pending > 100 | "Embeddings processing in background. Check again in a few minutes." |
-| server disconnected | "Start Ollama: `ollama serve`" |
-| all good | "Memory system healthy. Use `memory_query` to search." |
+| server disconnected | "Check config.yml embedding settings" |
+| all good | "Memory system healthy." |

package/AGENTS.md

@@ -55,6 +55,7 @@ npx nano-brain update
 
 
 
+
 ## File Writing Rules (MANDATORY)
 
 **NEVER write an entire file at once.** Always use chunk-by-chunk editing:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nano-brain",
-  "version": "2026.4.1",
+  "version": "2026.4.2",
   "type": "module",
   "bin": {
     "nano-brain": "./bin/cli.js"

package/src/codebase.ts

@@ -440,6 +440,10 @@ export async function indexCodebase(
     if (flowResult.flowsDetected > 0) {
       log('codebase', `Flow detection: ${flowResult.flowsDetected} flows from ${flowResult.entryPointsFound} entry points`)
     }
+  } else if (!db && isTreeSitterAvailable()) {
+    log('codebase', 'WARNING: db parameter not provided — symbol graph indexing skipped. Pass db to indexCodebase() to enable code intelligence.')
+  } else if (db && !isTreeSitterAvailable()) {
+    log('codebase', 'WARNING: tree-sitter not available — symbol graph indexing skipped. Install tree-sitter-wasms to enable code intelligence.')
   }
 
   const finalStorageUsed = store.getCollectionStorageSize('codebase')

package/src/index.ts

@@ -9,6 +9,8 @@ import { indexCodebase, embedPendingCodebase, getCodebaseStats } from './codebas
 import { findCycles } from './graph.js';
 import { handleBench } from './bench.js';
 import { resolveHostUrl } from './host.js';
+import { SymbolGraph } from './symbol-graph.js';
+import { isTreeSitterAvailable } from './treesitter.js';
 import { QdrantVecStore } from './providers/qdrant.js';
 import { createVectorStore } from './vector-store.js';
 import type { SearchResult, CollectionConfig, Store } from './types.js';
@@ -144,6 +146,20 @@ nano-brain - Memory system with hybrid search
     --type=<type>   Symbol type (required)
     --pattern=<pat> Pattern to analyze (required)
     --json          Output as JSON
+  context <name>    360° view of a code symbol (callers, callees, flows)
+    --file=<path>   Disambiguate when multiple symbols share the name
+    --json          Output as JSON
+  code-impact <name> Analyze impact of changing a symbol
+    --direction=<d> upstream (callers) or downstream (callees), default: upstream
+    --max-depth=<n> Max traversal depth (default: 5)
+    --min-confidence=<n> Min edge confidence 0-1 (default: 0)
+    --file=<path>   Disambiguate symbol
+    --json          Output as JSON
+  detect-changes    Map git changes to affected symbols and flows
+    --scope=<s>     unstaged, staged, or all (default: all)
+    --json          Output as JSON
+  reindex           Re-index codebase files and symbol graph
+    --root=<path>   Workspace root (default: current directory)
   reset             Delete nano-brain data (selective or all)
     --databases     Delete SQLite workspace databases (~/.nano-brain/data/*.sqlite)
     --sessions      Delete harvested session markdown (~/.nano-brain/sessions/)
@@ -250,6 +266,7 @@ async function handleMcp(globalOpts: GlobalOptions, commandArgs: string[]): Prom
   let port = 8282;
   let host = '127.0.0.1';
   let daemon = false;
+  let root: string | undefined;
   
   for (const arg of commandArgs) {
     if (arg === '--http') {
@@ -258,6 +275,8 @@ async function handleMcp(globalOpts: GlobalOptions, commandArgs: string[]): Prom
       port = parseInt(arg.substring(7), 10);
     } else if (arg.startsWith('--host=')) {
       host = arg.substring(7);
+    } else if (arg.startsWith('--root=')) {
+      root = arg.substring(7);
     } else if (arg === '--daemon') {
       daemon = true;
     } else if (arg === 'stop') {
@@ -273,6 +292,7 @@ async function handleMcp(globalOpts: GlobalOptions, commandArgs: string[]): Prom
     httpPort: useHttp ? port : undefined,
     httpHost: useHttp ? host : undefined,
     daemon,
+    root,
   });
 }
 
@@ -283,10 +303,13 @@ async function handleServe(globalOpts: GlobalOptions, commandArgs: string[]): Pr
   let port = 3100;
   let foreground = false;
   let subcommand: string | undefined;
+  let root: string | undefined;
 
   for (const arg of commandArgs) {
     if (arg.startsWith('--port=')) {
       port = parseInt(arg.substring(7), 10);
+    } else if (arg.startsWith('--root=')) {
+      root = arg.substring(7);
     } else if (arg === '--foreground' || arg === '-f') {
       foreground = true;
     } else if (arg === 'stop' || arg === 'status') {
@@ -321,7 +344,7 @@ async function handleServe(globalOpts: GlobalOptions, commandArgs: string[]): Pr
 
   // serve (start)
   if (foreground) {
-    return handleMcp(globalOpts, ['--http', `--port=${port}`, '--host=0.0.0.0', '--daemon']);
+    return handleMcp(globalOpts, ['--http', `--port=${port}`, '--host=0.0.0.0', '--daemon', ...(root ? [`--root=${root}`] : [])]);
   }
 
   // Check if already running
@@ -340,6 +363,9 @@ async function handleServe(globalOpts: GlobalOptions, commandArgs: string[]): Pr
 
   const cliPath = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../bin/cli.js');
   const args = [cliPath, 'mcp', '--http', `--port=${port}`, '--host=0.0.0.0', '--daemon'];
+  if (root) {
+    args.push(`--root=${root}`);
+  }
   if (globalOpts.configPath !== DEFAULT_CONFIG) {
     args.push(`--config=${globalOpts.configPath}`);
   }
@@ -653,6 +679,7 @@ async function handleStatus(globalOpts: GlobalOptions, commandArgs: string[]): P
   const workspaceRoot = process.cwd();
   const resolvedDbPath = resolveDbPath(globalOpts.dbPath, workspaceRoot);
   const workspaceName = extractWorkspaceName(resolvedDbPath);
+  const projectHash = crypto.createHash('sha256').update(workspaceRoot).digest('hex').substring(0, 12);
 
   let dbSize = 0;
   try {
@@ -696,6 +723,27 @@ async function handleStatus(globalOpts: GlobalOptions, commandArgs: string[]): P
     console.log('');
   }
 
+  // Code Intelligence (symbol graph)
+  try {
+    const symbolDb = new Database(resolvedDbPath);
+    const symbolCount = (symbolDb.prepare('SELECT COUNT(*) as cnt FROM code_symbols WHERE project_hash = ?').get(projectHash) as { cnt: number }).cnt;
+    const edgeCount = (symbolDb.prepare('SELECT COUNT(*) as cnt FROM symbol_edges WHERE project_hash = ?').get(projectHash) as { cnt: number }).cnt;
+    let flowCount = 0;
+    try {
+      flowCount = (symbolDb.prepare('SELECT COUNT(*) as cnt FROM execution_flows WHERE project_hash = ?').get(projectHash) as { cnt: number }).cnt;
+    } catch { /* table may not exist */ }
+    symbolDb.close();
+
+    console.log('Code Intelligence:');
+    console.log(`  Symbols:    ${symbolCount.toLocaleString()}`);
+    console.log(`  Edges:      ${edgeCount.toLocaleString()}`);
+    console.log(`  Flows:      ${flowCount.toLocaleString()}`);
+    if (symbolCount === 0) {
+      console.log('  ⚠️  Empty — run `npx nano-brain reindex` to populate');
+    }
+    console.log('');
+  } catch { /* code_symbols table may not exist in older DBs */ }
+
   await printEmbeddingServerStatus(config);
   console.log('');
 
@@ -1496,6 +1544,306 @@ async function handleImpact(globalOpts: GlobalOptions, commandArgs: string[]): P
   store.close()
 }
 
+function warnIfEmptySymbolGraph(db: Database.Database, projectHash: string): boolean {
+  const count = db.prepare('SELECT COUNT(*) as cnt FROM code_symbols WHERE project_hash = ?').get(projectHash) as { cnt: number };
+  if (count.cnt === 0) {
+    console.error('⚠️  Symbol graph is empty. Run `npx nano-brain reindex` first.');
+    return true;
+  }
+  return false;
+}
+
+async function handleContext(globalOpts: GlobalOptions, commandArgs: string[]): Promise<void> {
+  let name: string | undefined;
+  let filePath: string | undefined;
+  let format: 'text' | 'json' = 'text';
+
+  for (const arg of commandArgs) {
+    if (arg.startsWith('--file=')) {
+      filePath = arg.substring(7);
+    } else if (arg === '--json') {
+      format = 'json';
+    } else if (!arg.startsWith('-')) {
+      name = arg;
+    }
+  }
+
+  if (!name) {
+    console.error('Usage: context <symbol-name> [--file=<path>] [--json]');
+    process.exit(1);
+  }
+
+  log('cli', 'context name=' + name + ' file=' + (filePath || ''));
+  const workspaceRoot = process.cwd();
+  const projectHash = crypto.createHash('sha256').update(workspaceRoot).digest('hex').substring(0, 12);
+  const resolvedDbPath = resolveDbPath(globalOpts.dbPath, workspaceRoot);
+  const db = new Database(resolvedDbPath);
+
+  if (warnIfEmptySymbolGraph(db, projectHash)) {
+    db.close();
+    return;
+  }
+
+  const graph = new SymbolGraph(db);
+  const result = graph.handleContext({ name, filePath, projectHash });
+
+  if (format === 'json') {
+    console.log(JSON.stringify(result, null, 2));
+    db.close();
+    return;
+  }
+
+  if (!result.found) {
+    if (result.disambiguation) {
+      console.log(`Multiple symbols named "${name}". Use --file= to disambiguate:`);
+      for (const s of result.disambiguation) {
+        console.log(`  ${s.kind} ${s.name} — ${s.filePath}:${s.startLine}`);
+      }
+    } else {
+      console.log(`Symbol "${name}" not found.`);
+    }
+    db.close();
+    return;
+  }
+
+  const sym = result.symbol!;
+  console.log(`${sym.kind} ${sym.name}`);
+  console.log(`  File: ${sym.filePath}:${sym.startLine}-${sym.endLine}`);
+  console.log(`  Exported: ${sym.exported ? 'yes' : 'no'}`);
+  if (result.clusterLabel) {
+    console.log(`  Cluster: ${result.clusterLabel}`);
+  }
+  console.log('');
+
+  if (result.incoming && result.incoming.length > 0) {
+    console.log(`Callers (${result.incoming.length}):`);
+    for (const e of result.incoming) {
+      console.log(`  ← ${e.kind} ${e.name} (${e.filePath}) [${e.edgeType}]`);
+    }
+    console.log('');
+  }
+
+  if (result.outgoing && result.outgoing.length > 0) {
+    console.log(`Callees (${result.outgoing.length}):`);
+    for (const e of result.outgoing) {
+      console.log(`  → ${e.kind} ${e.name} (${e.filePath}) [${e.edgeType}]`);
+    }
+    console.log('');
+  }
+
+  if (result.flows && result.flows.length > 0) {
+    console.log(`Flows (${result.flows.length}):`);
+    for (const f of result.flows) {
+      console.log(`  ${f.flowType}: ${f.label} (step ${f.stepIndex})`);
+    }
+    console.log('');
+  }
+
+  if (result.infrastructureSymbols && result.infrastructureSymbols.length > 0) {
+    console.log(`Infrastructure:`);
+    for (const s of result.infrastructureSymbols) {
+      console.log(`  [${s.operation}] ${s.type}: ${s.pattern}`);
+    }
+  }
+
+  db.close();
+}
+
+async function handleCodeImpact(globalOpts: GlobalOptions, commandArgs: string[]): Promise<void> {
+  let target: string | undefined;
+  let direction: 'upstream' | 'downstream' = 'upstream';
+  let maxDepth = 5;
+  let minConfidence = 0;
+  let filePath: string | undefined;
+  let format: 'text' | 'json' = 'text';
+
+  for (const arg of commandArgs) {
+    if (arg.startsWith('--direction=')) {
+      const val = arg.substring(12);
+      if (val === 'upstream' || val === 'downstream') direction = val;
+    } else if (arg.startsWith('--max-depth=')) {
+      maxDepth = parseInt(arg.substring(12), 10);
+    } else if (arg.startsWith('--min-confidence=')) {
+      minConfidence = parseFloat(arg.substring(17));
+    } else if (arg.startsWith('--file=')) {
+      filePath = arg.substring(7);
+    } else if (arg === '--json') {
+      format = 'json';
+    } else if (!arg.startsWith('-')) {
+      target = arg;
+    }
+  }
+
+  if (!target) {
+    console.error('Usage: code-impact <symbol-name> [--direction=upstream|downstream] [--max-depth=N] [--min-confidence=N] [--file=<path>] [--json]');
+    process.exit(1);
+  }
+
+  log('cli', 'code-impact target=' + target + ' direction=' + direction + ' depth=' + maxDepth);
+  const workspaceRoot = process.cwd();
+  const projectHash = crypto.createHash('sha256').update(workspaceRoot).digest('hex').substring(0, 12);
+  const resolvedDbPath = resolveDbPath(globalOpts.dbPath, workspaceRoot);
+  const db = new Database(resolvedDbPath);
+
+  if (warnIfEmptySymbolGraph(db, projectHash)) {
+    db.close();
+    return;
+  }
+
+  const graph = new SymbolGraph(db);
+  const result = graph.handleImpact({ target, direction, maxDepth, minConfidence, filePath, projectHash });
+
+  if (format === 'json') {
+    console.log(JSON.stringify(result, null, 2));
+    db.close();
+    return;
+  }
+
+  if (!result.found) {
+    if (result.disambiguation) {
+      console.log(`Multiple symbols named "${target}". Use --file= to disambiguate:`);
+      for (const s of result.disambiguation) {
+        console.log(`  ${s.kind} ${s.name} — ${s.filePath}`);
+      }
+    } else {
+      console.log(`Symbol "${target}" not found.`);
+    }
+    db.close();
+    return;
+  }
+
+  const t = result.target!;
+  console.log(`Impact Analysis: ${t.kind} ${t.name} (${t.filePath})`);
+  console.log(`  Direction: ${direction}`);
+  console.log(`  Risk: ${result.risk}`);
+  console.log(`  Direct deps: ${result.summary.directDeps}, Total affected: ${result.summary.totalAffected}, Flows: ${result.summary.flowsAffected}`);
+  console.log('');
+
+  for (const [depth, symbols] of Object.entries(result.byDepth)) {
+    if (symbols.length > 0) {
+      console.log(`Depth ${depth} (${symbols.length}):`);
+      for (const s of symbols) {
+        console.log(`  ${s.kind} ${s.name} (${s.filePath}) [${s.edgeType}, confidence=${s.confidence}]`);
+      }
+    }
+  }
+
+  if (result.affectedFlows.length > 0) {
+    console.log('');
+    console.log(`Affected Flows (${result.affectedFlows.length}):`);
+    for (const f of result.affectedFlows) {
+      console.log(`  ${f.flowType}: ${f.label}`);
+    }
+  }
+
+  db.close();
+}
+
+async function handleDetectChanges(globalOpts: GlobalOptions, commandArgs: string[]): Promise<void> {
+  let scope: 'unstaged' | 'staged' | 'all' = 'all';
+  let format: 'text' | 'json' = 'text';
+
+  for (const arg of commandArgs) {
+    if (arg.startsWith('--scope=')) {
+      const val = arg.substring(8);
+      if (val === 'unstaged' || val === 'staged' || val === 'all') scope = val;
+    } else if (arg === '--json') {
+      format = 'json';
+    }
+  }
+
+  log('cli', 'detect-changes scope=' + scope);
+  const workspaceRoot = process.cwd();
+  const projectHash = crypto.createHash('sha256').update(workspaceRoot).digest('hex').substring(0, 12);
+  const resolvedDbPath = resolveDbPath(globalOpts.dbPath, workspaceRoot);
+  const db = new Database(resolvedDbPath);
+
+  if (warnIfEmptySymbolGraph(db, projectHash)) {
+    db.close();
+    return;
+  }
+
+  const graph = new SymbolGraph(db);
+  const result = graph.handleDetectChanges({ scope, workspaceRoot, projectHash });
+
+  if (format === 'json') {
+    console.log(JSON.stringify(result, null, 2));
+    db.close();
+    return;
+  }
+
+  if (result.changedFiles.length === 0) {
+    console.log('No changed files detected.');
+    db.close();
+    return;
+  }
+
+  console.log(`Risk Level: ${result.riskLevel}`);
+  console.log('');
+
+  console.log(`Changed Files (${result.changedFiles.length}):`);
+  for (const f of result.changedFiles) {
+    console.log(`  ${f}`);
+  }
+  console.log('');
+
+  if (result.changedSymbols.length > 0) {
+    console.log(`Changed Symbols (${result.changedSymbols.length}):`);
+    for (const s of result.changedSymbols) {
+      console.log(`  ${s.kind} ${s.name} (${s.filePath})`);
+    }
+    console.log('');
+  }
+
+  if (result.affectedFlows.length > 0) {
+    console.log(`Affected Flows (${result.affectedFlows.length}):`);
+    for (const f of result.affectedFlows) {
+      console.log(`  ${f.flowType}: ${f.label}`);
+    }
+  }
+
+  db.close();
+}
+
+async function handleReindex(globalOpts: GlobalOptions, commandArgs: string[]): Promise<void> {
+  let root = process.cwd();
+
+  for (const arg of commandArgs) {
+    if (arg.startsWith('--root=')) {
+      root = arg.substring(7);
+    }
+  }
+
+  log('cli', 'reindex root=' + root);
+  const resolvedDbPath = resolveDbPath(globalOpts.dbPath, root);
+  const store = createStore(resolvedDbPath);
+  const projectHash = crypto.createHash('sha256').update(root).digest('hex').substring(0, 12);
+
+  const config = loadCollectionConfig(globalOpts.configPath);
+  const wsConfig = getWorkspaceConfig(config, root);
+  const codebaseConfig = wsConfig?.codebase ?? { enabled: true };
+
+  console.log(`Reindexing codebase: ${root}`);
+  const db = new Database(resolvedDbPath);
+  const stats = await indexCodebase(store, root, codebaseConfig, projectHash, undefined, db);
+  console.log(`  Files: ${stats.filesIndexed} indexed, ${stats.filesSkippedUnchanged} unchanged`);
+
+  // Report symbol graph stats
+  const symbolCount = (db.prepare('SELECT COUNT(*) as cnt FROM code_symbols WHERE project_hash = ?').get(projectHash) as { cnt: number }).cnt;
+  const edgeCount = (db.prepare('SELECT COUNT(*) as cnt FROM symbol_edges WHERE project_hash = ?').get(projectHash) as { cnt: number }).cnt;
+  console.log(`  Symbols: ${symbolCount}, Edges: ${edgeCount}`);
+
+  if (symbolCount === 0 && isTreeSitterAvailable()) {
+    console.log('  ⚠️  No symbols indexed. Check if your files contain supported languages.');
+  } else if (!isTreeSitterAvailable()) {
+    console.log('  ⚠️  Tree-sitter not available — symbol graph skipped.');
+  }
+
+  db.close();
+  store.close();
+  console.log('✅ Reindex complete.');
+}
+
 async function handleCache(globalOpts: GlobalOptions, commandArgs: string[]): Promise<void> {
   const subcommand = commandArgs[0];
 
@@ -2800,6 +3148,14 @@ async function main() {
       return handleReset(globalOpts, commandArgs);
     case 'rm':
       return handleRm(globalOpts, commandArgs);
+    case 'context':
+      return handleContext(globalOpts, commandArgs);
+    case 'code-impact':
+      return handleCodeImpact(globalOpts, commandArgs);
+    case 'detect-changes':
+      return handleDetectChanges(globalOpts, commandArgs);
+    case 'reindex':
+      return handleReindex(globalOpts, commandArgs);
     default:
       console.error(`Unknown command: ${command}`);
       showHelp();

package/src/server.ts

@@ -31,6 +31,7 @@ export interface ServerOptions {
   httpPort?: number;
   httpHost?: string;
   daemon?: boolean;
+  root?: string;
 }
 
 export interface ServerDeps {
@@ -1417,7 +1418,7 @@ function setupSingletonGuard(pidPath: string, store: Store, stopWatcher: () => v
 }
 
 export async function startServer(options: ServerOptions): Promise<void> {
-  const { dbPath, configPath, httpPort, httpHost = '127.0.0.1', daemon } = options;
+  const { dbPath, configPath, httpPort, httpHost = '127.0.0.1', daemon, root } = options;
   
   const homeDir = os.homedir();
   const nanoBrainHome = path.join(homeDir, '.nano-brain');
@@ -1432,11 +1433,20 @@ export async function startServer(options: ServerOptions): Promise<void> {
   const storageConfig = parseStorageConfig(config?.storage);
   let resolvedWorkspaceRoot: string;
   if (daemon && config?.workspaces && Object.keys(config.workspaces).length > 0) {
-    resolvedWorkspaceRoot = Object.keys(config.workspaces)[0];
-    log('server', 'Daemon mode: using first configured workspace as primary');
-    console.error(`[memory] Daemon mode: primary workspace = ${resolvedWorkspaceRoot}`);
+    const configuredWorkspaces = Object.keys(config.workspaces);
+    const cwd = root || process.cwd();
+    const cwdMatch = configuredWorkspaces.find(ws => cwd === ws || cwd.startsWith(ws + '/'));
+    if (cwdMatch) {
+      resolvedWorkspaceRoot = cwdMatch;
+      log('server', 'Daemon mode: cwd matches configured workspace');
+      console.error(`[memory] Daemon mode: workspace from cwd = ${resolvedWorkspaceRoot}`);
+    } else {
+      resolvedWorkspaceRoot = configuredWorkspaces[0];
+      log('server', 'Daemon mode: cwd does not match any workspace, using first configured');
+      console.error(`[memory] Daemon mode: primary workspace = ${resolvedWorkspaceRoot}`);
+    }
   } else {
-    resolvedWorkspaceRoot = process.cwd();
+    resolvedWorkspaceRoot = root || process.cwd();
   }
   const wsConfig = getWorkspaceConfig(config, resolvedWorkspaceRoot);
   const resolvedCodebaseConfig = wsConfig.codebase;