daedalus-cli 0.4.0

package/dist/index.js

@@ -0,0 +1,1386 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import readline from 'readline';
+import os from 'os';
+import pc from 'picocolors';
+import { BUILTIN_TOOLS } from './tools/definitions.js';
+import { executeToolCalls } from './tools/executor.js';
+import { setRouterClient } from './tools/builtin/delegation.js';
+import { mcpRegistry } from './tools/mcp/registry.js';
+import { createRouter } from './router/index.js';
+import { loadConfig, getConfigDirPath, discoverLocalServers } from './config/index.js';
+import crypto from 'crypto';
+import { getSessionTodos, setSessionTodos } from './tools/builtin/todo.js';
+import { searchSymbols as ftsSearch } from './indexing/fts.js';
+import { SessionManager } from './session/manager.js';
+import { runOnboarding } from './onboarding/wizard.js';
+import { DaedalusSpinner } from './tools/daedalus-spinner.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Load configuration
+const config = loadConfig();
+const configDir = getConfigDirPath();
+// Session state
+const activeFiles = new Map(); // Absolute path -> filename key
+const messages = [];
+// Token tracking for current turn
+let currentTurnInputTokens = 0;
+let currentTurnOutputTokens = 0;
+let turnStartTime = 0;
+let currentAbortController = null;
+// Compute stable projectHash once
+const projectHash = crypto.createHash('sha256').update(path.resolve(process.cwd())).digest('hex').slice(0, 12);
+// Initialize session manager
+const sessionManager = new SessionManager();
+sessionManager.init();
+const initialSession = sessionManager.startSession();
+let sessionId = initialSession.sessionId;
+// If there are turns from the loaded session, restore them (skip system prompt ones)
+if (initialSession.turns.length > 0) {
+    const nonSystemTurns = initialSession.turns.filter(t => t.role !== 'system');
+    messages.push(...nonSystemTurns);
+}
+// Restore active files from session
+if (initialSession.activeFiles.size > 0) {
+    for (const [k, v] of initialSession.activeFiles.entries()) {
+        activeFiles.set(k, v);
+    }
+}
+// Restore todos from session
+if (initialSession.todos.length > 0) {
+    setSessionTodos(sessionId, initialSession.todos);
+}
+// Ensure CLI temp directory exists
+const cliTempDir = path.join(os.homedir(), '.daedalus', 'temp');
+if (!fs.existsSync(cliTempDir)) {
+    fs.mkdirSync(cliTempDir, { recursive: true });
+}
+// Initialize local router
+const router = createRouter(config.router);
+// Tool context for executions
+const toolContext = {
+    sessionId,
+    projectRoot: process.cwd(),
+    projectHash,
+    activeFiles,
+    agentRole: config.agents.default,
+    abortSignal: new AbortController().signal,
+    autoApplyEdits: 'prompt',
+    patchHistory: [],
+    pauseSpinner: () => { },
+    resumeSpinner: () => { },
+};
+// Enable delegation tool
+setRouterClient(router);
+// Default system prompt
+const systemPrompt = `You are Daedalus, an expert software developer and coding assistant.
+You run locally on the user's machine with an embedded model router.
+You have access to local LLM servers (LM Studio, Ollama, llama.cpp, vLLM) and a full toolset.
+
+Your goal: help the user modify their codebase efficiently. Speed and precision matter.
+
+## CODEBASE INDEX (FTS5) — always available
+A FTS5 symbol index is maintained automatically. The following tools let you search it:
+- \`find_symbol(query, limit)\` — fuzzy search functions, classes, types across the project
+- \`get_definition(name)\` — exact lookup returning file path, line range, and signature
+- \`get_references(name)\` — show every call-site referencing a symbol (call graph)
+- \`index_codebase(exclude, extensions)\` — manually trigger a re-index (usually automatic)
+
+The index context is automatically injected before each user turn. When working on a task, check it first for relevant symbols before reading files.
+
+## CRITICAL TOOL RULES
+
+### Editing existing files — ALWAYS use patch, NEVER write_file
+- ALWAYS use \`patch\` to modify existing files. NEVER use \`write_file\` on a file that already exists.
+- \`write_file\` is ONLY for creating brand-new files that do not yet exist on disk.
+- Rewriting an entire file with \`write_file\` when only a few lines need changing is a serious mistake.
+
+### patch best practices
+- Your \`old_string\` must be the EXACT text from the file — same indentation, same spacing.
+- Use read_file first if you are not 100% certain of the exact text. Do not guess.
+- Make \`old_string\` as short as possible while still being unique (3-10 lines is ideal).
+- If patch fails with "not found", immediately use read_file to verify the exact text, then retry.
+- CRLF note: files on Windows may use CRLF line endings. The patch tool handles this automatically — always write your strings with plain \\n and the tool will match correctly.
+
+### Before any edit
+1. If you have not read the file yet this turn, use \`read_file\` to verify the current content.
+2. Identify the smallest possible change (the fewest lines to replace).
+3. Use \`patch\` with that minimal old_string → new_string.
+
+### Tool selection guide
+| Goal | Use |
+|------|-----|
+| Read part of a file | \`read_file\` with offset+limit |
+| Make a surgical edit | \`patch\` |
+| Create a new file | \`write_file\` |
+| Find where something is | \`search_files\` |
+| Search code symbols | \`find_symbol\` (FTS5 fuzzy search) |
+| Look up a definition | \`get_definition\` (exact name) |
+| Find callers | \`get_references\` (call-graph) |
+| Index the codebase | \`index_codebase\` (automatic on startup) |
+| Run a build/test/script | \`terminal\` |
+| Track multi-step work | \`todo\` |
+
+## CODEBASE INDEX
+A FTS5 symbol index is built automatically on startup. Use \`find_symbol\` to search classes, functions, interfaces, types across the project. Use \`get_definition\` to pinpoint a symbol's file and line. Use \`get_references\` to see the call graph. The index is incremental (SHA-based) so re-indexing is fast.
+
+## EFFICIENCY RULES
+- Batch related patches: if you need to change 3 functions in the same file, do them in 3 sequential patch calls — not 3 reads.
+- Do NOT re-read a file you just read unless the content changed.
+- If a task has more than 3 steps, create a todo list first so you can track progress without losing context.
+- Be concise in responses — the user can see the tool check-ins. Skip narrating each step.
+
+## PATCH OUTCOMES — what to do in each case
+
+| Result | Meaning | What YOU must do |
+|--------|---------|-----------------|
+| \`Patched <file>\` | ✅ Success — change written to disk | Continue to next step |
+| error contains \`PATCH_DECLINED\` | 🚫 User reviewed the diff and said No or Skip | STOP retrying. Tell the user what you tried to change and ask how they'd like to proceed |
+| error contains \`not found\` | ❌ old_string didn't match the file | Immediately call \`read_file\` on that file, find the exact text, then retry \`patch\` with the corrected old_string |
+| error contains \`multiple locations\` | ❌ old_string is too generic | Add more surrounding lines to old_string to make it unique, then retry |
+| error contains \`File not found\` | ❌ Wrong path | Use \`search_files\` or \`list_files\` to find the correct path |
+
+**Never freeze or loop silently.** If a patch fails, take one corrective action and tell the user what happened.`;
+// Build system prompt with project memory
+function getSystemPromptWithMemory() {
+    let prompt = systemPrompt;
+    const memPrompt = sessionManager.getMemoryPrompt();
+    if (memPrompt) {
+        prompt += '\n' + memPrompt;
+    }
+    return prompt;
+}
+messages.push({ role: 'system', content: getSystemPromptWithMemory() });
+// Setup Readline Interface with tab completion
+const COMMANDS = [
+    '/add', '/remove', '/context', '/clear',
+    '/spawn', '/delegate', '/orchestrate',
+    '/memory', '/fact', '/convention',
+    '/index', '/find', '/refs', '/def',
+    '/commit', '/undo', '/test',
+    '/models', '/tools', '/config', '/project', '/doctor', '/session', '/onboard',
+    '/help', 'exit', 'quit', '?',
+];
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    completer: (line) => {
+        const prefix = line.toLowerCase();
+        const hits = prefix.startsWith('/') || prefix.startsWith('?') || prefix.startsWith('exit') || prefix.startsWith('quit')
+            ? COMMANDS.filter(c => c.startsWith(prefix))
+            : [];
+        return [hits.length ? hits : COMMANDS, prefix];
+    },
+});
+// ─────────────────────────────────────────────────────────────────────────────
+//  B A N N E R
+// ─────────────────────────────────────────────────────────────────────────────
+// Each row of the block-letter art, rendered as segments so we can colour
+// the left half cyan and the right half white for a pseudo-gradient effect.
+const LOGO_ROWS = [
+    ' ██████╗   █████╗  ███████╗ ██████╗   █████╗  ██╗     ██╗   ██╗ ███████╗ ',
+    ' ██╔══██╗ ██╔══██╗ ██╔════╝ ██╔══██╗ ██╔══██╗ ██║     ██║   ██║ ██╔════╝ ',
+    ' ██║  ██║ ███████║ █████╗   ██║  ██║ ███████║ ██║     ██║   ██║ ███████╗ ',
+    ' ██║  ██║ ██╔══██║ ██╔══╝   ██║  ██║ ██╔══██║ ██║     ██║   ██║ ╚════██║ ',
+    ' ██████╔╝ ██║  ██║ ███████╗ ██████╔╝ ██║  ██║ ███████╗╚██████╔╝ ███████║ ',
+    ' ╚═════╝  ╚═╝  ╚═╝ ╚══════╝ ╚═════╝  ╚═╝  ╚═╝ ╚══════╝ ╚═════╝  ╚══════╝ ',
+];
+const W = 76; // inner width (between the border pipes)
+function box(inner, borderColor) {
+    return borderColor('║') + inner + borderColor('║');
+}
+function hRule(l, r, fill, len, color) {
+    return color(l + fill.repeat(len) + r);
+}
+function centred(text, width, color) {
+    const pad = Math.max(0, width - text.length);
+    const left = Math.floor(pad / 2);
+    const right = pad - left;
+    return ' '.repeat(left) + color(text) + ' '.repeat(right);
+}
+function printBanner() {
+    const cyan = pc.cyan.bind(pc);
+    const white = pc.white.bind(pc);
+    const bold = pc.bold.bind(pc);
+    const dim = pc.dim.bind(pc);
+    const mag = pc.magenta.bind(pc);
+    // Top border
+    console.log(hRule('╔', '╗', '═', W, cyan));
+    console.log(box(' '.repeat(W), cyan));
+    // Logo rows — left half cyan, right half white, fading across
+    LOGO_ROWS.forEach((row, i) => {
+        const mid = Math.floor(row.length * (0.4 + i * 0.04)); // gradient cut shifts right each row
+        const left = cyan(row.slice(0, mid));
+        const right = white(row.slice(mid));
+        const inner = left + right;
+        // Pad to exactly W chars
+        const visLen = row.length;
+        const padded = inner + ' '.repeat(Math.max(0, W - visLen));
+        console.log(box(padded, cyan));
+    });
+    console.log(box(' '.repeat(W), cyan));
+    // Tagline strip
+    const tagline = '⬡  local-first  ·  embedded router  ·  multi-agent  ·  mcp-ready  ⬡';
+    console.log(box(centred(tagline, W, dim), cyan));
+    // Bottom border
+    console.log(hRule('╚', '╝', '═', W, cyan));
+    // Version / author badge — pill style
+    const badge = `  v0.2.0-beta`;
+    const author = `bgill55_dev  `;
+    const divider = ` · `;
+    console.log('');
+    console.log('  ' +
+        pc.bgCyan(pc.black(bold(` DAEDALUS `))) +
+        pc.bgBlack(pc.cyan(bold(badge))) +
+        pc.bgBlack(dim(divider)) +
+        pc.bgBlack(pc.white(author)));
+    console.log('');
+}
+// ─────────────────────────────────────────────────────────────────────────────
+//  S T A R T U P   I N F O
+// ─────────────────────────────────────────────────────────────────────────────
+function printConfigInfo() {
+    const enabledCount = config.router.chain.filter(m => m.enabled).length;
+    const strategy = config.router.strategy;
+    const configPath = configDir + '/config.json';
+    const contentLine = `strategy  ${strategy}    models  ${enabledCount}   config  ${configPath}`;
+    const boxInnerWidth = contentLine.length + 2; // padding inside
+    const top = pc.dim('  ┌─ ') + pc.cyan('router') + pc.dim(' ' + '─'.repeat(Math.max(0, boxInnerWidth - 6)) + '┐');
+    const mid = pc.dim('  │ ') + pc.white(contentLine) + pc.dim(' │');
+    const bot = pc.dim('  └' + '─'.repeat(boxInnerWidth + 2) + '┘');
+    console.log(top);
+    console.log(mid);
+    console.log(bot);
+    console.log('');
+    // ── Quick tip ────────────────────────────────────────────────────────────
+    console.log(`  ${pc.dim('Type')} ${pc.cyan('?')} ${pc.dim('for commands  ·  Tab completes')}`);
+    console.log('');
+}
+// Parse initial arguments (e.g. if started as `daedalus src/index.ts`)
+const initialArgs = process.argv.slice(2);
+if (initialArgs.length > 0) {
+    initialArgs.forEach(fileArg => {
+        const absPath = path.resolve(fileArg);
+        activeFiles.set(absPath, fileArg);
+        toolContext.activeFiles = new Map(activeFiles);
+        console.log(pc.green(`✔ Added file on startup: ${pc.bold(fileArg)}`));
+    });
+}
+// Build file context for LLM
+function buildFileContext() {
+    if (activeFiles.size === 0)
+        return '';
+    let ctx = '--- ACTIVE FILES CONTEXT ---\n';
+    for (const [absPath, filename] of activeFiles) {
+        let content = '';
+        if (fs.existsSync(absPath)) {
+            content = fs.readFileSync(absPath, 'utf8');
+        }
+        else {
+            content = '[New file - does not exist yet]';
+        }
+        ctx += `[File: ${filename}]\n\`\`\`\n${content}\n\`\`\`\n\n`;
+    }
+    ctx += '----------------------------\n\n';
+    return ctx;
+}
+// Build index context — auto-inject relevant symbols from FTS5 index
+async function buildIndexContext(userMessage) {
+    if (!config.indexing.enabled || !toolContext.indexDb)
+        return '';
+    const indexDb = toolContext.indexDb;
+    // Extract likely symbol names from the user message (camelCase, snake_case, class names)
+    const symbolCandidates = userMessage.match(/\b[A-Z][a-zA-Z0-9_]*\b/g) || [];
+    const words = userMessage.split(/\s+/).filter(w => w.length > 2);
+    const allTerms = [...symbolCandidates, ...words];
+    if (allTerms.length === 0)
+        return '';
+    let ctx = '\n--- RELEVANT CODE SYMBOLS (from FTS5 index) ---\n';
+    let count = 0;
+    const seen = new Set();
+    try {
+        for (const term of allTerms) {
+            if (count >= 8)
+                break;
+            const results = ftsSearch(indexDb, term, projectHash, 3);
+            for (const s of results) {
+                const key = `${s.name}:${s.file_path}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                ctx += `  [${s.kind}] ${s.name} → ${s.file_path}:${s.line_start}`;
+                if (s.signature)
+                    ctx += `  (${s.signature.slice(0, 80)})`;
+                ctx += '\n';
+                count++;
+            }
+        }
+    }
+    catch {
+        // Index not available — skip
+    }
+    if (count === 0)
+        return '';
+    ctx += '------------------------------------------\n\n';
+    return ctx;
+}
+// Initialize session state from a loaded session snapshot
+function initializeSessionState(loaded) {
+    sessionId = loaded.sessionId;
+    toolContext.sessionId = loaded.sessionId;
+    activeFiles.clear();
+    for (const [k, v] of loaded.activeFiles.entries()) {
+        activeFiles.set(k, v);
+    }
+    toolContext.activeFiles = new Map(activeFiles);
+    messages.length = 0;
+    const sysPrompt = getSystemPromptWithMemory();
+    messages.push({ role: 'system', content: sysPrompt });
+    if (loaded.turns.length > 0) {
+        const userOrAssistantTurns = loaded.turns.filter(t => t.role !== 'system');
+        messages.push(...userOrAssistantTurns);
+    }
+    setSessionTodos(loaded.sessionId, loaded.todos);
+    console.log(pc.gray(`Active files in context: ${activeFiles.size}`));
+    console.log(pc.gray(`Loaded ${loaded.turns.length} message turn(s)`));
+}
+// Handle /spawn and /delegate commands
+async function handleSpawn(role, task) {
+    const validRoles = ['coder', 'reviewer', 'debugger', 'researcher', 'planner'];
+    if (!validRoles.includes(role)) {
+        console.log(pc.red(`⚠ Unknown role: ${role}. Valid: ${validRoles.join(', ')}`));
+        return;
+    }
+    console.log(pc.cyan(`\n🤝 Spawning ${role} agent for: ${task.slice(0, 80)}...`));
+    const context = `Active files: ${Array.from(activeFiles.values()).join(', ') || 'none'}`;
+    const fakeToolCall = {
+        id: `call_${Date.now()}`,
+        type: 'function',
+        function: {
+            name: 'delegate_task',
+            arguments: JSON.stringify({ goal: task, context, role }),
+        },
+    };
+    const results = await executeToolCalls([fakeToolCall], toolContext);
+    for (const result of results) {
+        const status = result.success ? pc.green('✔') : pc.red('✗');
+        console.log(`\n${status} ${role} agent completed`);
+        console.log(pc.white(result.content));
+        if (!result.success && result.error) {
+            console.log(pc.red(`Error: ${result.error}`));
+        }
+    }
+}
+// Handle /orchestrate command
+async function handleOrchestrate(goal) {
+    console.log(pc.cyan(`\n🎭 Starting orchestration for: ${goal}`));
+    const { Orchestrator } = await import('./agents/orchestrator.js');
+    const orchestrator = new Orchestrator(router, messages, toolContext);
+    const result = await orchestrator.run(goal);
+    console.log(pc.white(`\n${result}`));
+}
+// Handle /models command
+async function handleModels() {
+    console.log(pc.bold('\n--- Available Models ---'));
+    const models = await router.listModels();
+    if (models.length === 0) {
+        console.log(pc.yellow('  No models found. Check your local servers (LM Studio, Ollama, etc.)'));
+    }
+    else {
+        for (const model of models) {
+            console.log(`  • ${pc.cyan(model)}`);
+        }
+    }
+    const { checkModelHealth } = await import('./router/health.js');
+    const healthyModels = router.getHealthyModels();
+    console.log(pc.bold('\n--- Healthy Models ---'));
+    for (const model of healthyModels) {
+        const health = await checkModelHealth(model, 5000);
+        const status = health?.healthy ? pc.green('●') : pc.red('●');
+        console.log(`  ${status} ${pc.cyan(model.name)} (${model.endpoint}) - ${model.model}`);
+    }
+    console.log(pc.bold('----------------------\n'));
+}
+// Handle /config command
+function handleConfig() {
+    // Max chars of tool output stored in message history (prevents context-window overflow)
+    const TOOL_RESULT_MAX_CHARS = 32_000;
+    console.log(pc.bold('\n--- Current Configuration ---'));
+    console.log(JSON.stringify(config, null, 2));
+    console.log(pc.bold('-----------------------------'));
+    console.log(pc.gray(`\nEdit ${configDir}/config.json to modify settings.`));
+    console.log(pc.gray('Run `daedalus /doctor` to auto-discover local servers.'));
+}
+// Handle /doctor command
+async function handleDoctor() {
+    console.log(pc.bold('\n--- Daedalus Doctor ---'));
+    console.log(pc.gray('Checking local server connections...\n'));
+    const discovered = await discoverLocalServers();
+    if (discovered.length === 0) {
+        console.log(pc.yellow('  No local servers detected.'));
+        console.log(pc.gray('  Start one of:'));
+        console.log(pc.gray('    • LM Studio (http://localhost:1234)'));
+        console.log(pc.gray('    • Ollama (http://localhost:11434)'));
+        console.log(pc.gray('    • llama.cpp server (--server, default :8080)'));
+        console.log(pc.gray('    • vLLM (http://localhost:8000)'));
+    }
+    else {
+        console.log(pc.green(`  Found ${discovered.length} running server(s):\n`));
+        for (const server of discovered) {
+            console.log(`  ${pc.green('●')} ${server.name} at ${server.endpoint}`);
+            for (const model of server.models.slice(0, 5)) {
+                console.log(`      - ${model}`);
+            }
+            if (server.models.length > 5) {
+                console.log(pc.gray(`      ... and ${server.models.length - 5} more`));
+            }
+        }
+    }
+    console.log(pc.bold('\n--- Router Health ---'));
+    const healthyModels = router.getHealthyModels();
+    for (const model of healthyModels) {
+        const { checkModelHealth } = await import('./router/health.js');
+        const health = await checkModelHealth(model, 5000);
+        const status = health.healthy ? pc.green('●') : pc.red('●');
+        const latency = health.latencyMs ? ` (${health.latencyMs}ms)` : '';
+        console.log(`  ${status} ${model.name}: ${model.model}${latency}`);
+    }
+    console.log(pc.bold('----------------------\n'));
+}
+// Handle /index command
+async function handleIndex(opts) {
+    console.log(pc.bold('\n--- Indexing Codebase ---'));
+    console.log(pc.gray(`Project: ${process.cwd()}`));
+    const indexDbPath = path.join(os.homedir(), '.daedalus', 'sessions', projectHash, 'index.sqlite');
+    if (!fs.existsSync(path.dirname(indexDbPath))) {
+        fs.mkdirSync(path.dirname(indexDbPath), { recursive: true });
+    }
+    const { initIndexDb } = await import('./indexing/fts.js');
+    const { indexCodebase } = await import('./indexing/indexer.js');
+    const db = initIndexDb(indexDbPath);
+    console.log(pc.gray('\nScanning files...'));
+    const start = Date.now();
+    try {
+        const barWidth = 20;
+        let lastPct = -1;
+        const onProgress = ({ current, total, file }) => {
+            const pct = Math.round((current / total) * 100);
+            if (pct === lastPct)
+                return;
+            lastPct = pct;
+            const filled = Math.round((current / total) * barWidth);
+            const bar = '█'.repeat(filled) + '░'.repeat(barWidth - filled);
+            process.stdout.write(`\r  ${pc.cyan(bar)} ${pc.white(`${current}/${total}`)} ${pc.gray(file.slice(-40))}`);
+        };
+        const result = indexCodebase(db, process.cwd(), projectHash, { ...opts, onProgress });
+        process.stdout.write('\n');
+        const elapsed = Date.now() - start;
+        console.log(pc.green(`\n✔ Indexing complete in ${elapsed}ms`));
+        console.log(pc.white(`  Total files:     ${result.totalFiles}`));
+        console.log(pc.white(`  Indexed files:   ${result.indexedFiles}`));
+        console.log(pc.white(`  Skipped (unchanged): ${result.skippedFiles}`));
+        if (result.errors.length > 0) {
+            console.log(pc.yellow(`\nErrors (${result.errors.length}):`));
+            result.errors.slice(0, 10).forEach(e => console.log(pc.red(`  - ${e}`)));
+            if (result.errors.length > 10) {
+                console.log(pc.gray(`  ... and ${result.errors.length - 10} more`));
+            }
+        }
+    }
+    catch (err) {
+        console.error(pc.red(`\n❌ Indexing failed: ${err.message}`));
+    }
+}
+// Handle /find <query> [limit]
+async function handleFindSymbol(query, limit) {
+    const indexDbPath = path.join(os.homedir(), '.daedalus', 'sessions', projectHash, 'index.sqlite');
+    if (!fs.existsSync(indexDbPath)) {
+        console.log(pc.yellow('⚠ No index found. Run /index first.'));
+        return;
+    }
+    const { initIndexDb, searchSymbols } = await import('./indexing/fts.js');
+    const db = initIndexDb(indexDbPath);
+    console.log(pc.bold(`\n--- Symbol Search: "${query}" ---`));
+    const symbols = searchSymbols(db, query, projectHash, limit);
+    if (symbols.length === 0) {
+        console.log(pc.gray('  No symbols found.'));
+        return;
+    }
+    console.log(pc.white(`\nFound ${symbols.length} symbol(s):`));
+    for (const s of symbols) {
+        const kindColor = s.kind === 'function' ? pc.cyan : s.kind === 'class' ? pc.green : s.kind === 'interface' ? pc.blue : pc.white;
+        const loc = `${s.file_path}:${s.line_start}${s.line_end !== s.line_start ? '-' + s.line_end : ''}`;
+        console.log(`  ${kindColor(`[${s.kind}]`)} ${pc.bold(s.name)} ${pc.dim(`(${loc})`)}`);
+        if (s.signature) {
+            console.log(pc.dim(`    ${s.signature.slice(0, 100)}${s.signature.length > 100 ? '...' : ''}`));
+        }
+    }
+}
+// Handle /refs <symbol>
+async function handleGetReferences(symbol) {
+    const indexDbPath = path.join(os.homedir(), '.daedalus', 'sessions', projectHash, 'index.sqlite');
+    if (!fs.existsSync(indexDbPath)) {
+        console.log(pc.yellow('⚠ No index found. Run /index first.'));
+        return;
+    }
+    const { initIndexDb, findReferences } = await import('./indexing/fts.js');
+    const db = initIndexDb(indexDbPath);
+    console.log(pc.bold(`\n--- References to: ${symbol} ---`));
+    const refs = findReferences(db, symbol, projectHash);
+    if (refs.length === 0) {
+        console.log(pc.gray('  No references found.'));
+        return;
+    }
+    // Group by caller
+    const byCaller = new Map();
+    for (const r of refs) {
+        const key = `${r.caller_name} (${r.caller_file}:${r.caller_line})`;
+        if (!byCaller.has(key))
+            byCaller.set(key, []);
+        byCaller.get(key).push(r);
+    }
+    console.log(pc.white(`\nFound ${refs.length} reference(s) from ${byCaller.size} caller(s):`));
+    for (const [caller, refs] of byCaller) {
+        console.log(pc.cyan(`\n  ${caller}:`));
+        for (const r of refs.slice(0, 5)) {
+            console.log(pc.dim(`    ${r.callee_name} at ${r.callee_file}:${r.callee_line}`));
+        }
+        if (refs.length > 5) {
+            console.log(pc.dim(`    ... and ${refs.length - 5} more`));
+        }
+    }
+}
+// Handle /def <symbol>
+async function handleGetDefinition(symbol) {
+    const indexDbPath = path.join(os.homedir(), '.daedalus', 'sessions', projectHash, 'index.sqlite');
+    if (!fs.existsSync(indexDbPath)) {
+        console.log(pc.yellow('⚠ No index found. Run /index first.'));
+        return;
+    }
+    const { initIndexDb, findDefinitions } = await import('./indexing/fts.js');
+    const db = initIndexDb(indexDbPath);
+    console.log(pc.bold(`\n--- Definition: ${symbol} ---`));
+    const defs = findDefinitions(db, symbol, projectHash);
+    if (defs.length === 0) {
+        console.log(pc.gray('  No definitions found.'));
+        return;
+    }
+    console.log(pc.white(`\nFound ${defs.length} definition(s):`));
+    for (const d of defs) {
+        const kindColor = d.kind === 'function' ? pc.cyan : d.kind === 'class' ? pc.green : d.kind === 'interface' ? pc.blue : pc.white;
+        const loc = `${d.file_path}:${d.line_start}${d.line_end !== d.line_start ? '-' + d.line_end : ''}`;
+        console.log(`  ${kindColor(`[${d.kind}]`)} ${pc.bold(d.name)} ${pc.dim(`(${loc})`)}`);
+        if (d.signature) {
+            console.log(pc.dim(`    ${d.signature.slice(0, 120)}${d.signature.length > 120 ? '...' : ''}`));
+        }
+    }
+}
+// Max chars of tool output stored in message history (prevents context-window overflow)
+const TOOL_RESULT_MAX_CHARS = 32_000;
+function truncateToolResult(content) {
+    if (content.length <= TOOL_RESULT_MAX_CHARS)
+        return content;
+    const kept = content.slice(0, TOOL_RESULT_MAX_CHARS);
+    const dropped = content.length - TOOL_RESULT_MAX_CHARS;
+    return `${kept}\n... [truncated ${dropped} chars — use read_file with offset/limit to see more]`;
+}
+// Streaming response handler with tool call support — iterative, not recursive
+const MAX_TOOL_TURNS = 40;
+async function callModelWithTools(userContent) {
+    // Auto-inject index context on first user turn (not on tool-result rounds)
+    if (userContent) {
+        const indexCtx = await buildIndexContext(userContent);
+        const augmentedContent = indexCtx ? indexCtx + userContent : userContent;
+        messages.push({ role: 'user', content: augmentedContent });
+    }
+    // Combine built-in tools with MCP tools (stable across turns)
+    const allTools = [...BUILTIN_TOOLS, ...mcpRegistry.getToolDefinitions()];
+    turnStartTime = Date.now();
+    let lastContent = '';
+    let turn = 0;
+    while (turn < MAX_TOOL_TURNS) {
+        const spinner = new DaedalusSpinner({ text: 'Daedalus thinking', color: (s) => pc.cyan(s) });
+        spinner.start();
+        let fullContent = '';
+        const toolCallMap = new Map();
+        let blockOpened = false;
+        const turnStart = Date.now();
+        const openBlock = () => {
+            if (!blockOpened) {
+                blockOpened = true;
+                spinner.stop();
+                openAssistantBlock();
+            }
+        };
+        currentAbortController = new AbortController();
+        const signal = currentAbortController.signal;
+        try {
+            const stream = await router.chatStream({
+                model: 'auto',
+                messages: messages,
+                temperature: 0.1,
+                tools: allTools,
+                tool_choice: 'auto',
+                stream: true,
+                signal,
+            });
+            for await (const chunk of stream) {
+                if (signal.aborted)
+                    break;
+                const choice = chunk.choices[0];
+                if (!choice)
+                    continue;
+                const delta = choice.delta;
+                if (delta.content) {
+                    openBlock();
+                    fullContent += delta.content;
+                    writeAssistantChunk(delta.content);
+                }
+                if (delta.tool_calls) {
+                    openBlock();
+                    for (const tc of delta.tool_calls) {
+                        const index = tc.index ?? 0;
+                        if (!toolCallMap.has(index)) {
+                            toolCallMap.set(index, {
+                                id: tc.id ?? `call_${Date.now()}_${index}`,
+                                type: 'function',
+                                function: { name: '', arguments: '' },
+                            });
+                        }
+                        const call = toolCallMap.get(index);
+                        if (tc.function?.name)
+                            call.function.name = tc.function.name;
+                        if (tc.function?.arguments)
+                            call.function.arguments += tc.function.arguments;
+                    }
+                }
+                if (choice.finish_reason === 'tool_calls' || choice.finish_reason === 'stop' || choice.finish_reason === 'length') {
+                    break;
+                }
+            }
+            // Ensure spinner is stopped even if no output was produced
+            if (!blockOpened)
+                spinner.stop();
+            // Check for user cancellation
+            if (signal.aborted) {
+                if (blockOpened)
+                    closeAssistantBlock(fullContent.length, Date.now() - turnStart);
+                console.log(pc.dim('\n  ⏹ Stopped'));
+                currentAbortController = null;
+                return { content: fullContent, toolCalls: [] };
+            }
+        }
+        catch (error) {
+            if (signal.aborted) {
+                spinner.stop();
+                console.log(pc.dim('\n  ⏹ Stopped'));
+                currentAbortController = null;
+                return { content: '', toolCalls: [] };
+            }
+            spinner.stop();
+            console.error(pc.red(`\n❌ Error calling model: ${error.message}`));
+            throw error;
+        }
+        currentAbortController = null;
+        const toolCallArray = Array.from(toolCallMap.values()).filter(tc => tc.function.name);
+        lastContent = fullContent;
+        // Close assistant block after streaming, before tool results
+        if (blockOpened) {
+            closeAssistantBlock(fullContent.length, Date.now() - turnStart, toolCallArray.length);
+        }
+        if (toolCallArray.length === 0) {
+            // No tool calls — model is done
+            messages.push({ role: 'assistant', content: fullContent });
+            return { content: fullContent, toolCalls: [] };
+        }
+        // Push assistant turn with tool calls
+        messages.push({
+            role: 'assistant',
+            content: fullContent || '',
+            tool_calls: toolCallArray,
+        });
+        console.log(`\n  ${pc.dim('🔧')} ${pc.dim(`Executing ${toolCallArray.length} tool call(s)...`)}`);
+        const results = await executeToolCalls(toolCallArray, toolContext);
+        for (const result of results) {
+            messages.push({
+                role: 'tool',
+                content: truncateToolResult(result.content),
+                tool_call_id: result.toolCallId,
+            });
+            const status = result.success ? pc.green('✔') : pc.red('✗');
+            console.log(`  ${status} ${result.name}`);
+            if (!result.success && result.error) {
+                console.log(pc.red(`     Error: ${result.error}`));
+            }
+            // Show inline preview of successful tool results
+            if (result.success && result.content) {
+                const contentStr = result.content;
+                const lines = contentStr.split('\n');
+                const previewLines = lines.slice(0, 3);
+                for (const line of previewLines) {
+                    const truncated = line.length > 120 ? line.slice(0, 120) + '…' : line;
+                    if (truncated.trim())
+                        console.log(`  ${pc.dim('┃')} ${pc.gray(truncated)}`);
+                }
+                if (lines.length > 3) {
+                    console.log(`  ${pc.dim('┃')} ${pc.dim(`… ${lines.length - 3} more line${lines.length - 3 > 1 ? 's' : ''}`)}`);
+                }
+            }
+        }
+        turn++;
+    }
+    // Reached max turns without a clean stop
+    console.log(`\n  ${pc.yellow('⚠')} ${pc.yellow(`Reached max tool turns (${MAX_TOOL_TURNS}). Stopping.`)}`);
+    messages.push({ role: 'assistant', content: lastContent });
+    return { content: lastContent, toolCalls: [] };
+}
+// Fallback: Structured output for models without tool support
+async function callModelWithFallback(userContent) {
+    messages.push({ role: 'user', content: userContent });
+    console.log(pc.gray('🤖 Thinking (fallback mode)...'));
+    try {
+        const response = await router.chat.completions.create({
+            model: 'auto',
+            messages: messages,
+            temperature: 0.1,
+        });
+        const reply = response.choices[0].message?.content || '';
+        messages.push({ role: 'assistant', content: reply });
+        openAssistantBlock();
+        writeAssistantChunk(reply);
+        const usage = response.usage;
+        const elapsed = Date.now() - turnStartTime;
+        closeAssistantBlock(reply.length, elapsed);
+        return reply;
+    }
+    catch (error) {
+        console.error(pc.red(`\n❌ Fallback error: ${error.message}`));
+        throw error;
+    }
+}
+// Promisify a single readline question
+function askLine(prompt) {
+    return new Promise((resolve) => rl.question(prompt, resolve));
+}
+// ── Visual formatting helpers ──────────────────────────────────────────────────
+function printUserTurn(userMessage) {
+    const bdr = (s) => pc.dim(pc.yellow(s));
+    const lines = userMessage.split('\n');
+    const w = 52;
+    console.log(`\n  ${bdr('╭─')} ${pc.yellow(pc.bold('⬡ You'))} ${bdr('─'.repeat(Math.max(0, w - 8)))}${bdr('╮')}`);
+    for (const line of lines) {
+        const t = line.length > 70 ? line.slice(0, 70) + '…' : line;
+        console.log(`  ${bdr('│')} ${pc.white(t)}${' '.repeat(Math.max(1, w - t.length))}${bdr('│')}`);
+    }
+    console.log(`  ${bdr('╰')}${bdr('─'.repeat(w))}${bdr('╯')}`);
+    console.log();
+}
+let _assistantLineBuf = '';
+function openAssistantBlock() {
+    const bdr = (s) => pc.dim(pc.cyan(s));
+    const w = 52;
+    console.log(`  ${bdr('╭─')} ${pc.dim('◇')} ${pc.dim('Daedalus')} ${bdr('─'.repeat(Math.max(0, w - 11)))}${bdr('╮')}`);
+}
+function writeAssistantChunk(chunk) {
+    _assistantLineBuf += chunk;
+    const lines = _assistantLineBuf.split('\n');
+    _assistantLineBuf = lines.pop() || '';
+    const bdr = (s) => pc.dim(pc.cyan(s));
+    const w = 52;
+    for (const line of lines) {
+        const t = line.length > 70 ? line.slice(0, 70) + '…' : line;
+        console.log(`  ${bdr('│')} ${pc.white(t)}${' '.repeat(Math.max(1, w - t.length))}${bdr('│')}`);
+    }
+}
+function closeAssistantBlock(tokens, elapsedMs, toolCount) {
+    const bdr = (s) => pc.dim(pc.cyan(s));
+    const w = 52;
+    if (_assistantLineBuf) {
+        const t = _assistantLineBuf.length > 70 ? _assistantLineBuf.slice(0, 70) + '…' : _assistantLineBuf;
+        console.log(`  ${bdr('│')} ${pc.white(t)}${' '.repeat(Math.max(1, w - t.length))}${bdr('│')}`);
+        _assistantLineBuf = '';
+    }
+    const meta = toolCount !== undefined
+        ? `${toolCount} tool(s)  ·  ~${Math.round(tokens / 4)}t out  ·  ${elapsedMs}ms`
+        : `~${Math.round(tokens / 4)}t out  ·  ${elapsedMs}ms`;
+    console.log(`  ${bdr('╰')}${bdr('─'.repeat(w))}${bdr('╯')}  ${pc.dim(meta)}`);
+}
+function turnSeparator() {
+    const ts = new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit' });
+    console.log(`  ${pc.dim('─'.repeat(58))} ${pc.dim(ts)}`);
+}
+// Main chat loop — iterative, no recursive Promise chains
+async function chatLoop() {
+    while (true) {
+        const prompt = activeFiles.size > 0
+            ? `\n${pc.cyan('  ⬡')} ${pc.dim(`[${activeFiles.size} file${activeFiles.size > 1 ? 's' : ''}]`)} ${pc.bold(pc.white('›'))} `
+            : `\n${pc.cyan('  ⬡')} ${pc.bold(pc.white('›'))} `;
+        const input = await askLine(prompt);
+        const trimmedInput = input.trim();
+        if (!trimmedInput)
+            continue;
+        const lowerInput = trimmedInput.toLowerCase();
+        // Handle Exit
+        if (lowerInput === 'exit' || lowerInput === 'quit') {
+            const todos = getSessionTodos(sessionId);
+            sessionManager.saveSessionState(messages, activeFiles, todos);
+            console.log(pc.gray(`Session saved: ${sessionManager.sessionId}`));
+            console.log(pc.yellow('\nEnding session. Goodbye! 👋\n'));
+            rl.close();
+            process.exit(0);
+        }
+        // Command quickref
+        if (lowerInput === '?' || lowerInput === 'help') {
+            console.log(`\n  ${pc.bold('Commands')}`);
+            console.log(`  ${pc.dim('────────────────────────────────────')}`);
+            console.log(`  ${pc.cyan('/add')}      Add file to context`);
+            console.log(`  ${pc.cyan('/remove')}   Remove file from context`);
+            console.log(`  ${pc.cyan('/context')}  Show active file context`);
+            console.log(`  ${pc.cyan('/commit')}   Stage and commit changes`);
+            console.log(`  ${pc.cyan('/undo')}     Undo last file patch`);
+            console.log(`  ${pc.cyan('/test')}     Run tests and auto-fix failures`);
+            console.log(`  ${pc.cyan('/index')}    Index codebase for symbol search`);
+            console.log(`  ${pc.cyan('/find')}     Search indexed symbols`);
+            console.log(`  ${pc.cyan('/refs')}    Find symbol references`);
+            console.log(`  ${pc.cyan('/def')}     Get symbol definition`);
+            console.log(`  ${pc.cyan('/project')} View or set project config`);
+            console.log(`  ${pc.cyan('/session')} Manage chat sessions`);
+            console.log(`  ${pc.cyan('?')}         Show this help menu`);
+            console.log(`  ${pc.cyan('exit')}     Save and quit\n`);
+            continue;
+        }
+        // Command: /add <file>
+        if (trimmedInput.startsWith('/add ')) {
+            const fileArg = trimmedInput.substring(5).trim();
+            if (!fileArg) {
+                console.log(pc.red('⚠ Please specify a file path. Example: /add src/App.tsx'));
+            }
+            else {
+                const absPath = path.resolve(fileArg);
+                activeFiles.set(absPath, fileArg);
+                toolContext.activeFiles = new Map(activeFiles);
+                console.log(pc.green(`✔ Added file to context: ${pc.bold(fileArg)}`));
+            }
+            continue;
+        }
+        // Command: /remove <file>
+        if (trimmedInput.startsWith('/remove ')) {
+            const fileArg = trimmedInput.substring(8).trim();
+            if (!fileArg) {
+                console.log(pc.red('⚠ Please specify a file path. Example: /remove src/App.tsx'));
+            }
+            else {
+                const absPath = path.resolve(fileArg);
+                if (activeFiles.delete(absPath)) {
+                    toolContext.activeFiles = new Map(activeFiles);
+                    console.log(pc.green(`✔ Removed file from context: ${pc.bold(fileArg)}`));
+                }
+                else {
+                    console.log(pc.yellow(`⚠ File was not in context: ${fileArg}`));
+                }
+            }
+            continue;
+        }
+        // Command: /context
+        if (lowerInput === '/context') {
+            console.log(pc.bold('\n--- Monitored Files in Context ---'));
+            if (activeFiles.size === 0) {
+                console.log(pc.gray('  (No active files. Use "/add <filepath>" to add files)'));
+            }
+            else {
+                activeFiles.forEach((filename) => {
+                    console.log(`  • ${pc.cyan(filename)}`);
+                });
+            }
+            console.log(pc.bold('----------------------------------'));
+            continue;
+        }
+        // Command: /session list|load|new|delete
+        if (lowerInput.startsWith('/session')) {
+            const parts = trimmedInput.substring(9).trim().split(/\s+/);
+            const subCmd = parts[0]?.toLowerCase();
+            if (subCmd === 'list') {
+                const list = sessionManager.getSessionsForProject();
+                console.log(pc.bold('\n--- Sessions for this Project ---'));
+                if (list.length === 0) {
+                    console.log(pc.gray('  No saved sessions.'));
+                }
+                else {
+                    list.forEach((s) => {
+                        const dateStr = new Date(s.updated_at).toLocaleString();
+                        const activeMarker = s.id === sessionManager.sessionId ? pc.green(' * ') : '   ';
+                        console.log(`${activeMarker}${s.title} (ID: ${pc.cyan(s.id)}) - Last updated: ${dateStr}`);
+                    });
+                }
+                console.log(pc.bold('---------------------------------'));
+            }
+            else if (subCmd === 'load') {
+                const targetId = parts[1]?.trim();
+                if (!targetId) {
+                    console.log(pc.red('⚠ Usage: /session load <id>'));
+                }
+                else {
+                    try {
+                        const todos = getSessionTodos(sessionId);
+                        sessionManager.saveSessionState(messages, activeFiles, todos);
+                        const loaded = sessionManager.startSession(targetId);
+                        initializeSessionState(loaded);
+                        console.log(pc.green(`✔ Loaded session: ${sessionManager.sessionTitle} (${sessionManager.sessionId})`));
+                    }
+                    catch (err) {
+                        console.log(pc.red(`⚠ Failed to load session: ${err.message}`));
+                    }
+                }
+            }
+            else if (subCmd === 'new') {
+                const title = parts.slice(1).join(' ').trim();
+                const todos = getSessionTodos(sessionId);
+                sessionManager.saveSessionState(messages, activeFiles, todos);
+                const loaded = sessionManager.startSession(undefined, title || undefined);
+                initializeSessionState(loaded);
+                console.log(pc.green(`✔ Started new session: ${sessionManager.sessionTitle} (${sessionManager.sessionId})`));
+            }
+            else if (subCmd === 'delete') {
+                const targetId = parts[1]?.trim();
+                if (!targetId) {
+                    console.log(pc.red('⚠ Usage: /session delete <id>'));
+                }
+                else {
+                    sessionManager.deleteSession(targetId);
+                    console.log(pc.green(`✔ Deleted session: ${targetId}`));
+                }
+            }
+            else {
+                console.log(pc.red('⚠ Usage: /session list | load <id> | new [title] | delete <id>'));
+            }
+            continue;
+        }
+        // Command: /memory
+        if (lowerInput === '/memory') {
+            const mem = sessionManager.loadMemory();
+            console.log(pc.bold('\n--- Project Facts & Conventions (Memory) ---'));
+            console.log(pc.bold('Conventions:'));
+            if (Object.keys(mem.conventions).length === 0) {
+                console.log(pc.gray('  No conventions saved.'));
+            }
+            else {
+                for (const [k, v] of Object.entries(mem.conventions)) {
+                    console.log(`  • ${pc.cyan(k)}: ${v}`);
+                }
+            }
+            console.log(pc.bold('\nFacts:'));
+            if (mem.facts.length === 0) {
+                console.log(pc.gray('  No facts saved.'));
+            }
+            else {
+                mem.facts.forEach(f => {
+                    console.log(`  • ${pc.cyan(f.key)}: ${f.value} (source: ${f.source})`);
+                });
+            }
+            console.log(pc.bold('------------------------------------------'));
+            continue;
+        }
+        // Command: /fact <key> = <value>
+        if (lowerInput.startsWith('/fact ')) {
+            const argStr = trimmedInput.substring(6).trim();
+            const eqIdx = argStr.indexOf('=');
+            if (eqIdx < 0) {
+                console.log(pc.red('⚠ Usage: /fact <key> = <value>'));
+            }
+            else {
+                const key = argStr.slice(0, eqIdx).trim();
+                const value = argStr.slice(eqIdx + 1).trim();
+                sessionManager.addFact(key, value, 'user');
+                console.log(pc.green(`✔ Saved fact: ${key} = ${value}`));
+            }
+            continue;
+        }
+        // Command: /convention <key> = <value>
+        if (lowerInput.startsWith('/convention ')) {
+            const argStr = trimmedInput.substring(12).trim();
+            const eqIdx = argStr.indexOf('=');
+            if (eqIdx < 0) {
+                console.log(pc.red('⚠ Usage: /convention <key> = <value>'));
+            }
+            else {
+                const key = argStr.slice(0, eqIdx).trim();
+                const value = argStr.slice(eqIdx + 1).trim();
+                sessionManager.setConvention(key, value);
+                console.log(pc.green(`✔ Saved convention: ${key} = ${value}`));
+            }
+            continue;
+        }
+        // Command: /clear
+        if (lowerInput === '/clear') {
+            messages.length = 0;
+            messages.push({ role: 'system', content: getSystemPromptWithMemory() });
+            console.log(pc.green('✔ Conversation history cleared!'));
+            continue;
+        }
+        // Command: /tools
+        if (lowerInput === '/tools') {
+            console.log(pc.bold('\n--- Available Tools ---'));
+            BUILTIN_TOOLS.forEach(t => {
+                console.log(`  • ${pc.cyan(t.function.name)}: ${t.function.description}`);
+            });
+            const mcpTools = mcpRegistry.getToolDefinitions();
+            if (mcpTools.length > 0) {
+                console.log(pc.bold('\n--- MCP Tools ---'));
+                mcpTools.forEach(t => {
+                    console.log(`  • ${pc.cyan(t.function.name)}: ${t.function.description}`);
+                });
+            }
+            console.log(pc.bold('-----------------------'));
+            continue;
+        }
+        // Command: /spawn <role> <task>
+        if (lowerInput.startsWith('/spawn ')) {
+            const parts = trimmedInput.substring(7).trim().split(' ');
+            if (parts.length < 2) {
+                console.log(pc.red('⚠ Usage: /spawn <role> <task>'));
+                console.log(pc.gray('  Roles: coder, reviewer, debugger, researcher, planner'));
+            }
+            else {
+                const role = parts[0].toLowerCase();
+                const task = parts.slice(1).join(' ');
+                await handleSpawn(role, task);
+            }
+            continue;
+        }
+        // Command: /delegate <task> to <role>
+        if (lowerInput.startsWith('/delegate ')) {
+            const match = trimmedInput.substring(10).match(/^(.+)\s+to\s+(\w+)$/i);
+            if (!match) {
+                console.log(pc.red('⚠ Usage: /delegate <task> to <role>'));
+            }
+            else {
+                const task = match[1].trim();
+                const role = match[2].toLowerCase();
+                await handleSpawn(role, task);
+            }
+            continue;
+        }
+        // Command: /orchestrate <goal>
+        if (lowerInput.startsWith('/orchestrate ')) {
+            const goal = trimmedInput.substring(13).trim();
+            if (!goal) {
+                console.log(pc.red('⚠ Usage: /orchestrate <goal>'));
+            }
+            else {
+                await handleOrchestrate(goal);
+            }
+            continue;
+        }
+        // Command: /models
+        if (lowerInput === '/models') {
+            await handleModels();
+            continue;
+        }
+        // Command: /config
+        if (lowerInput === '/config') {
+            handleConfig();
+            continue;
+        }
+        // Command: /doctor
+        if (lowerInput === '/doctor') {
+            await handleDoctor();
+            continue;
+        }
+        // Command: /onboard
+        if (lowerInput === '/onboard') {
+            console.log(pc.cyan('\n🔄 Re-running onboarding wizard...\n'));
+            await runOnboarding(true);
+            continue;
+        }
+        // Command: /undo — revert the last patch
+        if (lowerInput === '/undo') {
+            const history = toolContext.patchHistory;
+            if (!history || history.length === 0) {
+                console.log(pc.yellow('⚠ No patches to undo.'));
+            }
+            else {
+                const last = history[history.length - 1];
+                try {
+                    const currentContent = fs.readFileSync(last.filePath, 'utf8');
+                    if (currentContent === last.newContent) {
+                        fs.writeFileSync(last.filePath, last.oldContent, 'utf8');
+                        console.log(pc.green(`✔ Undid patch to ${last.filePath} (${last.description})`));
+                    }
+                    else {
+                        console.log(pc.yellow(`⚠ File ${last.filePath} has been modified since last patch. Cannot auto-undo.`));
+                    }
+                    history.pop();
+                }
+                catch (err) {
+                    console.log(pc.red(`⚠ Failed to undo: ${err.message}`));
+                }
+            }
+            continue;
+        }
+        // Command: /commit — stage and commit changes
+        if (lowerInput === '/commit' || lowerInput.startsWith('/commit ')) {
+            const msg = trimmedInput.startsWith('/commit ') ? trimmedInput.substring(8).trim() : '';
+            try {
+                const { execute: termExec } = await import('./tools/builtin/terminal.js');
+                const statusResult = await termExec({ command: 'git status --short', timeout: 10, workdir: process.cwd() }, toolContext);
+                console.log(pc.bold('\n--- Git Status ---'));
+                console.log(statusResult.content || pc.gray('(clean)'));
+                if (!statusResult.content?.trim()) {
+                    console.log(pc.yellow('Nothing to commit.'));
+                    continue;
+                }
+                const addResult = await termExec({ command: 'git add -A', timeout: 10, workdir: process.cwd() }, toolContext);
+                if (!addResult.success) {
+                    console.log(pc.red(`Stage failed: ${addResult.error}`));
+                    continue;
+                }
+                let commitMsg = msg;
+                if (!commitMsg) {
+                    const diffResult = await termExec({ command: 'git diff --cached --stat', timeout: 10, workdir: process.cwd() }, toolContext);
+                    if (diffResult.content)
+                        console.log(pc.gray(diffResult.content));
+                    commitMsg = await askLine(pc.cyan('  Commit message: '));
+                    if (!commitMsg.trim()) {
+                        console.log(pc.yellow('Commit cancelled — empty message.'));
+                        await termExec({ command: 'git reset', timeout: 10, workdir: process.cwd() }, toolContext);
+                        continue;
+                    }
+                }
+                const commitResult = await termExec({ command: `git commit -m ${JSON.stringify(commitMsg)}`, timeout: 10, workdir: process.cwd() }, toolContext);
+                if (commitResult.success) {
+                    console.log(pc.green(`\n✔ Commit: ${commitMsg.slice(0, 60)}`));
+                }
+                else {
+                    console.log(pc.red(`Commit failed: ${commitResult.error}`));
+                }
+            }
+            catch (err) {
+                console.log(pc.red(`⚠ Commit error: ${err.message}`));
+            }
+            continue;
+        }
+        // Command: /project — show/edit project-level config
+        if (lowerInput === '/project') {
+            const { loadProjectConfig } = await import('./tools/builtin/project-config.js');
+            const cfg = loadProjectConfig(process.cwd());
+            console.log(pc.bold('\n--- Project Config (.daedalus) ---'));
+            console.log(JSON.stringify(cfg, null, 2));
+            console.log(pc.bold('----------------------------------'));
+            console.log(pc.gray('Use /project set <key> <value> to update'));
+            continue;
+        }
+        if (lowerInput.startsWith('/project set ')) {
+            const rest = trimmedInput.substring(13).trim();
+            const eqIdx = rest.indexOf('=');
+            let key, value;
+            if (eqIdx >= 0) {
+                key = rest.slice(0, eqIdx).trim();
+                value = rest.slice(eqIdx + 1).trim();
+            }
+            else {
+                const parts = rest.split(/\s+/);
+                key = parts[0];
+                value = parts.slice(1).join(' ');
+            }
+            if (!key || !value) {
+                console.log(pc.red('⚠ Usage: /project set <key> = <value>'));
+            }
+            else {
+                const { loadProjectConfig, saveProjectConfig } = await import('./tools/builtin/project-config.js');
+                const cfg = loadProjectConfig(process.cwd());
+                cfg[key] = value;
+                saveProjectConfig(cfg);
+                console.log(pc.green(`✔ Set ${key} = ${value}`));
+            }
+            continue;
+        }
+        // Command: /test — run tests and auto-fix failures (TDD loop)
+        if (lowerInput === '/test' || lowerInput.startsWith('/test ')) {
+            const maxLoops = lowerInput.startsWith('/test ') ? parseInt(trimmedInput.substring(6).trim(), 10) || 3 : 3;
+            const { loadProjectConfig } = await import('./tools/builtin/project-config.js');
+            const { execute: termExec } = await import('./tools/builtin/terminal.js');
+            const cfg = loadProjectConfig(process.cwd());
+            const testCmd = cfg.testCommand || 'npm test';
+            console.log(pc.bold(`\n🧪 Test-Run-Fix Loop (max ${maxLoops} iterations)`));
+            console.log(pc.gray(`Test command: ${testCmd}\n`));
+            for (let i = 0; i < maxLoops; i++) {
+                console.log(pc.cyan(`\n─── Run ${i + 1}/${maxLoops} ───`));
+                const result = await termExec({ command: testCmd, timeout: 120, workdir: process.cwd() }, toolContext);
+                console.log(result.content?.slice(0, 2000) || pc.gray('(no output)'));
+                if (result.success) {
+                    console.log(pc.green('\n✔ All tests passed!'));
+                    break;
+                }
+                if (i === maxLoops - 1) {
+                    console.log(pc.yellow(`\n⚠ Max loops (${maxLoops}) reached. Tests still failing.`));
+                    break;
+                }
+                const failureCtx = `Tests failed (run ${i + 1}/${maxLoops}). Here's the output:\n\n${result.content?.slice(0, 8000) || 'Unknown failure'}\n\nAnalyze the failures and fix the code.`;
+                const filesContext = buildFileContext();
+                const userContent = `${filesContext}User Prompt: ${failureCtx}`;
+                await callModelWithTools(userContent);
+            }
+            continue;
+        }
+        // Command: /index [options]
+        if (lowerInput.startsWith('/index')) {
+            const args = trimmedInput.substring(6).trim().split(/\s+/);
+            const opts = {};
+            for (const arg of args) {
+                if (arg.startsWith('--exclude=')) {
+                    opts.exclude = arg.split('=')[1].split(',');
+                }
+                else if (arg.startsWith('--ext=')) {
+                    opts.extensions = arg.split('=')[1].split(',');
+                }
+            }
+            await handleIndex(opts);
+            continue;
+        }
+        // Command: /find <query> [limit]
+        if (lowerInput.startsWith('/find ')) {
+            const parts = trimmedInput.substring(6).trim().split(/\s+/);
+            if (parts.length === 0) {
+                console.log(pc.red('⚠ Usage: /find <query> [limit]'));
+            }
+            else {
+                const query = parts[0];
+                const limit = parts[1] ? parseInt(parts[1], 10) : 30;
+                if (isNaN(limit)) {
+                    console.log(pc.red('⚠ Invalid limit'));
+                }
+                else {
+                    await handleFindSymbol(query, limit);
+                }
+            }
+            continue;
+        }
+        // Command: /refs <symbol>
+        if (lowerInput.startsWith('/refs ')) {
+            const symbol = trimmedInput.substring(6).trim();
+            if (!symbol) {
+                console.log(pc.red('⚠ Usage: /refs <symbol>'));
+            }
+            else {
+                await handleGetReferences(symbol);
+            }
+            continue;
+        }
+        // Command: /def <symbol>
+        if (lowerInput.startsWith('/def ')) {
+            const symbol = trimmedInput.substring(5).trim();
+            if (!symbol) {
+                console.log(pc.red('⚠ Usage: /def <symbol>'));
+            }
+            else {
+                await handleGetDefinition(symbol);
+            }
+            continue;
+        }
+        // User Message Processing
+        try {
+            const filesContext = buildFileContext();
+            const indexCtx = await buildIndexContext(trimmedInput);
+            const userContent = `${indexCtx}${filesContext}User Prompt: ${trimmedInput}`;
+            printUserTurn(trimmedInput);
+            await callModelWithTools(userContent);
+        }
+        catch (error) {
+            console.error(pc.red(`\n❌ Error: ${error.message}`));
+            try {
+                const filesContext = buildFileContext();
+                const userContent = `${filesContext}User Prompt: ${trimmedInput}`;
+                console.log(pc.yellow('\n🔄 Trying fallback mode...'));
+                await callModelWithFallback(userContent);
+            }
+            catch (fallbackErr) {
+                console.error(pc.red(`\n❌ Fallback also failed: ${fallbackErr.message}`));
+                console.error(pc.gray('Check that at least one local server is running.'));
+            }
+        }
+        turnSeparator();
+    }
+}
+// Start health checks and REPL
+async function main() {
+    // SIGINT handler — cancel generation if streaming, otherwise exit
+    process.on('SIGINT', () => {
+        if (currentAbortController) {
+            currentAbortController.abort();
+            return;
+        }
+        router.stopHealthChecks?.();
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode?.(false);
+        process.stdout.write('\n');
+        process.exit(0);
+    });
+    // Clean up health checks on normal exit too
+    process.on('exit', () => {
+        router.stopHealthChecks?.();
+    });
+    // Print the awesome banner first!
+    printBanner();
+    printConfigInfo();
+    try {
+        await router.startHealthChecks();
+        console.log(pc.green('\n✔ Router started. Health checks running every 30s.'));
+    }
+    catch (err) {
+        console.error(pc.yellow(`\n⚠ Router health checks failed: ${err.message}`));
+    }
+    // Initialize MCP registry
+    try {
+        await mcpRegistry.connectAll();
+        const servers = mcpRegistry.getConnectedServers();
+        if (servers.length > 0) {
+            console.log(pc.green(`\n✔ MCP connected: ${servers.join(', ')}`));
+        }
+    }
+    catch (err) {
+        console.error(pc.yellow(`\n⚠ MCP initialization failed: ${err.message}`));
+    }
+    // Auto-index at startup (non-blocking, background)
+    if (config.indexing.enabled) {
+        (async () => {
+            try {
+                const indexDbPath = path.join(os.homedir(), '.daedalus', 'sessions', projectHash, 'index.sqlite');
+                if (!fs.existsSync(indexDbPath)) {
+                    console.log(pc.cyan('\n  ⚡ Auto-indexing codebase (background)...'));
+                    const { initIndexDb } = await import('./indexing/fts.js');
+                    const { indexCodebase } = await import('./indexing/indexer.js');
+                    const db = initIndexDb(indexDbPath);
+                    const result = indexCodebase(db, process.cwd(), projectHash, {
+                        exclude: config.indexing.exclude,
+                    });
+                    console.log(pc.green(`  ✔ Indexed ${result.indexedFiles} files (${result.skippedFiles} unchanged)`));
+                    if (result.errors.length > 0) {
+                        console.log(pc.yellow(`  ⚠ ${result.errors.length} file(s) had errors`));
+                    }
+                    toolContext.indexDb = db;
+                }
+                else {
+                    // Re-index incrementally (fast — checks SHA hashes)
+                    const { initIndexDb } = await import('./indexing/fts.js');
+                    const { indexCodebase } = await import('./indexing/indexer.js');
+                    const db = initIndexDb(indexDbPath);
+                    const result = indexCodebase(db, process.cwd(), projectHash, {
+                        exclude: config.indexing.exclude,
+                    });
+                    if (result.indexedFiles > 0) {
+                        console.log(pc.gray(`  📚 Re-indexed ${result.indexedFiles} changed file(s)`));
+                    }
+                    toolContext.indexDb = db;
+                }
+            }
+            catch (err) {
+                console.error(pc.yellow(`  ⚠ Auto-index failed: ${err.message}`));
+            }
+        })();
+    }
+    await chatLoop();
+}
+main().catch(console.error);
+//# sourceMappingURL=index.js.map