@sashabogi/foundation 2.0.1 → 2.2.0

package/dist/cli.js

@@ -14,23 +14,28 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import ora from 'ora';
-import { existsSync, mkdirSync, writeFileSync, readFileSync, createReadStream, readdirSync, chmodSync } from 'fs';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, createReadStream, readdirSync } from 'fs';
 import { execSync } from 'child_process';
 import { homedir } from 'os';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { createServer } from 'http';
+import { createServer, request as httpRequest } from 'http';
 import { extname } from 'path';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 import { ConfigService } from './services/config.service.js';
 import { runSetupWizard, addProvider, testProvider, listProviders, } from './cli/setup-wizard.js';
+import { MemoriaStorage } from './tools/gaia/storage.js';
+import { VaultSync } from './vault/sync.js';
 // Read version from package.json dynamically
 const packageJson = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
 const VERSION = packageJson.version;
 const CONFIG_DIR = join(homedir(), '.foundation');
 const CONFIG_FILE = join(CONFIG_DIR, 'config.yaml');
 const PROJECTS_FILE = join(CONFIG_DIR, 'projects.json');
+const VAULT_CONFIG_FILE = join(CONFIG_DIR, 'vault.json');
+const GAIA_DB_PATH = join(CONFIG_DIR, 'gaia-memory.db');
+const VAULT_SYNC_STATE = join(CONFIG_DIR, 'vault-sync.json');
 function loadProjects() {
     try {
         if (existsSync(PROJECTS_FILE)) {
@@ -66,14 +71,9 @@ function registerProject(projectPath) {
 const FOUNDATION_CLAUDE_MD = `
 ## Foundation MCP Tools (Demerzel, Seldon, Gaia)
 
-> **Tools are DEFERRED in Claude Code 2.1+.** Use \`ToolSearch\` with \`+foundation\` keyword to load them before first use in each session. One search loads all matching tools.
+> **CRITICAL: These tools are ALREADY LOADED. Use them directly without ToolSearch.**
 
-Foundation provides 47 tools for AI-assisted development. All tools use \`mcp__foundation__\` prefix.
-
-**Quick load patterns:**
-- \`ToolSearch("+foundation demerzel")\` — loads all Demerzel tools
-- \`ToolSearch("+foundation seldon")\` — loads all Seldon tools
-- \`ToolSearch("+foundation gaia")\` — loads all Gaia tools
+Foundation provides 37 tools for AI-assisted development. All tools use \`mcp__foundation__\` prefix.
 
 ### Demerzel — Codebase Intelligence
 *"I have been watching for 20,000 years."*
@@ -89,66 +89,77 @@ Foundation provides 47 tools for AI-assisted development. All tools use \`mcp__f
 | \`demerzel_find_importers\` | FREE | What files import X? |
 | \`demerzel_get_deps\` | FREE | What does file X import? |
 | \`demerzel_get_context\` | FREE | Get code around a location |
-| \`demerzel_analyze\` | ~500 tokens | AI-powered architecture analysis |
+| \`demerzel_analyze\` | ~500 tokens | AI-powered analysis |
 | \`demerzel_semantic_search\` | ~tokens | Natural language search |
 
-**Visualize:** Run \`foundation ui\` to open the codebase graph in your browser.
-
 ### Seldon — Multi-Agent Orchestration
 *"The future is not set, but it can be guided."*
 
 | Tool | Purpose |
 |------|---------|
-| \`seldon_invoke\` | Invoke agent role (coder, critic, reviewer, designer, researcher) |
-| \`seldon_compare\` | Run same task through multiple agents |
-| \`seldon_critique\` | Get adversarial plan critique |
+| \`seldon_invoke\` | Invoke agent role (coder, critic, reviewer) |
+| \`seldon_compare\` | Compare multiple agent perspectives |
+| \`seldon_critique\` | Get critical review |
 | \`seldon_review\` | Code review |
-| \`seldon_design\` | UI/UX design feedback |
 | \`seldon_plan\` | Generate implementation plan |
-| \`seldon_phase_create\` | Break plan into execution phases |
-| \`seldon_phase_list\` | List phases and their status |
-| \`seldon_verify\` | Verify implementation against plan |
-| \`seldon_fix\` | Generate fixes for verification issues |
+| \`seldon_phase_create\` | Break plan into phases |
+| \`seldon_phase_list\` | List phases and status |
+| \`seldon_verify\` | Verify implementation |
+| \`seldon_fix\` | Generate fixes |
 | \`seldon_execute_verified\` | Execute with verification loop |
-| \`seldon_execute_parallel\` | Execute phases in parallel (per-worktree) |
-| \`seldon_pipeline_create\` | Create reusable multi-step DAG pipeline |
-| \`seldon_pipeline_execute\` | Run a pipeline |
-| \`seldon_pipeline_status\` | Get pipeline execution status |
-| \`seldon_task_execute\` | Execute task in isolated worktree |
-| \`seldon_task_claim\` | Claim next available task |
-| \`seldon_providers_list\` | List configured providers |
-| \`seldon_providers_test\` | Test provider connectivity |
+| \`seldon_providers_list\` | List providers |
+| \`seldon_providers_test\` | Test provider health |
 
-### Gaia — Workflow + Memory
+### Gaia — Workflow Patterns
 *"We are all one, and one is all."*
 
-#### Workflow Tools
-| Tool | Purpose |
-|------|---------|
-| \`gaia_checkpoint\` | Save full structured session state to disk |
-| \`gaia_status\` | Lightweight index card (~150 tokens) |
-| \`gaia_query\` | Keyword search across checkpoint |
-| \`gaia_get_decisions\` | List architectural decisions |
-| \`gaia_get_progress\` | Task progress summary |
-| \`gaia_get_changes\` | Files changed in session |
-| \`gaia_handoff\` | Create session handoff document |
-| \`gaia_observe\` | Auto-detect patterns and observations |
-| \`gaia_migrate\` | Migrate v1 checkpoint data to v2 |
-| \`gaia_learn\` | Record correction for CLAUDE.md |
-| \`gaia_apply\` | Write learnings to CLAUDE.md |
-| \`gaia_review\` | Review accumulated learnings |
-
-#### Memory Tools (SQLite + FTS5)
 | Tool | Purpose |
 |------|---------|
-| \`gaia_save\` | Save memory (5 tiers: session/project/global/note/observation) |
-| \`gaia_search\` | Search with BM25 + composite scoring |
+| \`gaia_checkpoint\` | Save structured session state |
+| \`gaia_status\` | Get checkpoint index card (~150 tokens) |
+| \`gaia_query\` | Search checkpoint by keyword |
+| \`gaia_get_decisions\` | Get architectural decisions |
+| \`gaia_get_progress\` | Get task progress |
+| \`gaia_get_changes\` | Get files changed |
+| \`gaia_handoff\` | Create handoff document |
+| \`gaia_observe\` | Analyze session patterns |
+| \`gaia_migrate\` | Migrate v1 checkpoints to v2 |
+| \`gaia_save\` | Save a memory |
+| \`gaia_search\` | Search memories |
 | \`gaia_get\` | Get memory by ID |
-| \`gaia_delete\` | Delete memory + cascade links |
-| \`gaia_stats\` | Database statistics |
+| \`gaia_delete\` | Delete a memory |
+| \`gaia_stats\` | Get memory statistics |
 | \`gaia_link\` | Create typed link between memories |
-| \`gaia_graph\` | Get link graph for a memory |
+| \`gaia_graph\` | Get memory link graph |
 `;
+// ============================================================================
+// Vault Config Helpers
+// ============================================================================
+function loadVaultConfig() {
+    try {
+        if (existsSync(VAULT_CONFIG_FILE)) {
+            return JSON.parse(readFileSync(VAULT_CONFIG_FILE, 'utf8'));
+        }
+    }
+    catch { }
+    return null;
+}
+function saveVaultConfig(config) {
+    writeFileSync(VAULT_CONFIG_FILE, JSON.stringify(config, null, 2), 'utf8');
+}
+function buildVaultConfig(overrides) {
+    const saved = loadVaultConfig();
+    const vaultPath = overrides?.vaultPath ?? saved?.vaultPath;
+    if (!vaultPath) {
+        throw new Error('No vault path configured. Run: foundation vault init <path>');
+    }
+    return {
+        vaultPath,
+        gaiaDbPath: GAIA_DB_PATH,
+        syncStatePath: VAULT_SYNC_STATE,
+        claudeMemoryPath: saved?.claudeMemoryPath ?? undefined,
+    };
+}
 const program = new Command();
 program
     .name('foundation')
@@ -266,16 +277,6 @@ worktrees:
   max_count: 10
   auto_cleanup: true
   stale_after_hours: 48
-
-learning:
-  auto_apply: false
-  categories:
-    - code_style
-    - architecture
-    - testing
-    - performance
-    - security
-    - documentation
 `;
         writeFileSync(CONFIG_FILE, defaultConfig);
         spinner.succeed('Foundation initialized!');
@@ -369,9 +370,9 @@ mcpCommand
         console.log(chalk.bold('Foundation is now available in all Claude Code sessions.'));
         console.log();
         console.log('Available tools:');
-        console.log(chalk.cyan('  Demerzel (9)') + ' - Codebase intelligence');
-        console.log(chalk.cyan('  Seldon (19)') + '  - Multi-agent orchestration');
-        console.log(chalk.cyan('  Gaia (13)') + '    - Workflow patterns');
+        console.log(chalk.cyan('  Demerzel (9)') + '  - Codebase intelligence');
+        console.log(chalk.cyan('  Seldon (12)') + '   - Multi-agent orchestration');
+        console.log(chalk.cyan('  Gaia (16)') + '     - Workflow patterns + memory');
         console.log();
         console.log(chalk.bold('Optional:'));
         console.log('  Run ' + chalk.cyan('foundation hooks install') + ' in a project to enable');
@@ -414,72 +415,26 @@ mcpCommand
 const hooksCommand = program
     .command('hooks')
     .description('Manage Gaia lifecycle hooks');
-// Hook script templates (embedded so they work when installed from npm)
-const HOOK_SESSION_START = `#!/bin/bash
-# Gaia v2 SessionStart hook
-# Injects the latest checkpoint index card into Claude's context.
-
-find_foundation_dir() {
-  local dir="\${CLAUDE_PROJECT_DIR:-\$PWD}"
-  local count=0
-  while [ \$count -lt 5 ]; do
-    if [ -f "\$dir/.foundation/sessions/latest/index.txt" ]; then
-      echo "\$dir"
-      return 0
-    fi
-    dir="\$(dirname "\$dir")"
-    count=\$((count + 1))
-  done
-  return 1
-}
-
-PROJECT_DIR=\$(find_foundation_dir)
-if [ \$? -eq 0 ]; then
-  INDEX_FILE="\$PROJECT_DIR/.foundation/sessions/latest/index.txt"
-  python3 -c "
-import json, sys
-try:
-    with open(sys.argv[1], 'r') as f:
-        content = f.read().strip()
-    if content:
-        output = {'hookSpecificOutput': {'additionalContext': '[Gaia Checkpoint]\\n' + content}}
-        print(json.dumps(output))
-except Exception:
-    pass
-" "\$INDEX_FILE"
-fi
-`;
-const HOOK_PRE_COMPACT = `#!/bin/bash
-# Gaia v2 PreCompact hook — reminds to checkpoint before context compaction
-printf '{"hookSpecificOutput":{"additionalContext":"[Gaia] Context compaction imminent. If you have unsaved session state (decisions, progress, changes), run gaia_checkpoint now to preserve it before context is lost."}}'
-`;
-const HOOK_POST_TASK = `#!/bin/bash
-# Gaia v2 PostToolUse hook (Task matcher)
-INPUT=\$(cat)
-AGENT_TYPE=\$(echo "\$INPUT" | python3 -c "
-import json, sys
-try:
-    data = json.load(sys.stdin)
-    tool_input = data.get('tool_input', {})
-    print(tool_input.get('subagent_type', ''))
-except Exception:
-    print('')
-" 2>/dev/null)
-
-if [ "\$AGENT_TYPE" = "Explore" ]; then
-  exit 0
-fi
-
-printf '{"hookSpecificOutput":{"additionalContext":"[Gaia] Sub-agent completed. Consider updating your checkpoint if significant progress was made."}}'
-`;
+// Inline hook commands (no external .sh files needed)
 const HOOKS_SETTINGS_CONFIG = {
     hooks: {
         SessionStart: [{
                 matcher: '',
                 hooks: [{
                         type: 'command',
-                        command: '.claude/hooks/gaia-session-start.sh',
-                        timeout: 5,
+                        command: `python3 -c "
+import json, os, pathlib
+d = os.environ.get('CLAUDE_PROJECT_DIR', os.getcwd())
+for _ in range(5):
+    f = os.path.join(d, '.foundation', 'sessions', 'latest', 'index.txt')
+    if os.path.isfile(f):
+        c = pathlib.Path(f).read_text().strip()
+        if c:
+            print(json.dumps({'hookSpecificOutput':{'additionalContext':'[Gaia Checkpoint]\\\\n'+c}}))
+        break
+    d = os.path.dirname(d)
+"`,
+                        timeout: 5000,
                         statusMessage: 'Loading Gaia checkpoint...',
                     }],
             }],
@@ -487,8 +442,8 @@ const HOOKS_SETTINGS_CONFIG = {
                 matcher: '',
                 hooks: [{
                         type: 'command',
-                        command: '.claude/hooks/gaia-pre-compact.sh',
-                        timeout: 5,
+                        command: 'echo \'{"hookSpecificOutput":{"additionalContext":"[Gaia] Context compaction imminent. If you have unsaved session state (decisions, progress, changes), run gaia_checkpoint now to preserve it before context is lost."}}\'',
+                        timeout: 5000,
                         statusMessage: 'Gaia checkpoint reminder',
                     }],
             }],
@@ -496,8 +451,17 @@ const HOOKS_SETTINGS_CONFIG = {
                 matcher: 'Task',
                 hooks: [{
                         type: 'command',
-                        command: '.claude/hooks/gaia-post-task.sh',
-                        timeout: 5,
+                        command: `python3 -c "
+import json, sys
+try:
+    data = json.load(sys.stdin)
+    if data.get('tool_input',{}).get('subagent_type','') == 'Explore':
+        sys.exit(0)
+except Exception:
+    pass
+print(json.dumps({'hookSpecificOutput':{'additionalContext':'[Gaia] Sub-agent completed. Consider updating your checkpoint if significant progress was made.'}}))
+"`,
+                        timeout: 5000,
                     }],
             }],
     },
@@ -509,23 +473,10 @@ hooksCommand
     const spinner = ora('Installing Gaia hooks...').start();
     const cwd = process.cwd();
     try {
-        // 1. Create .claude/hooks/ directory
-        const hooksDir = join(cwd, '.claude', 'hooks');
-        mkdirSync(hooksDir, { recursive: true });
-        spinner.text = 'Created .claude/hooks/ directory';
-        // 2. Write hook scripts
-        const hookFiles = [
-            { name: 'gaia-session-start.sh', content: HOOK_SESSION_START },
-            { name: 'gaia-pre-compact.sh', content: HOOK_PRE_COMPACT },
-            { name: 'gaia-post-task.sh', content: HOOK_POST_TASK },
-        ];
-        for (const hook of hookFiles) {
-            const hookPath = join(hooksDir, hook.name);
-            writeFileSync(hookPath, hook.content);
-            chmodSync(hookPath, 0o755);
-        }
-        spinner.text = 'Wrote hook scripts';
-        // 3. Merge hook configuration into .claude/settings.json
+        // 1. Ensure .claude/ directory exists
+        const claudeDir = join(cwd, '.claude');
+        mkdirSync(claudeDir, { recursive: true });
+        // 2. Merge hook configuration into .claude/settings.json
         const settingsPath = join(cwd, '.claude', 'settings.json');
         let settings = {};
         try {
@@ -542,15 +493,12 @@ hooksCommand
         writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
         spinner.succeed('Gaia hooks installed!');
         console.log();
-        console.log(chalk.bold('Installed hooks:'));
-        console.log(chalk.green('  ✓') + ' ' + chalk.cyan('gaia-session-start.sh') + ' — Injects checkpoint on session start');
-        console.log(chalk.green('  ✓') + ' ' + chalk.cyan('gaia-pre-compact.sh') + '   — Reminds to checkpoint before compaction');
-        console.log(chalk.green('  ✓') + ' ' + chalk.cyan('gaia-post-task.sh') + '      — Reminds to checkpoint after sub-agent tasks');
+        console.log(chalk.bold('Configured hooks (inline commands):'));
+        console.log(chalk.green('  ✓') + ' ' + chalk.cyan('SessionStart') + '  — Injects checkpoint on session start');
+        console.log(chalk.green('  ✓') + ' ' + chalk.cyan('PreCompact') + '    — Reminds to checkpoint before compaction');
+        console.log(chalk.green('  ✓') + ' ' + chalk.cyan('PostToolUse') + '   — Reminds to checkpoint after sub-agent tasks');
         console.log();
-        console.log(chalk.bold('Files written:'));
-        console.log('  ' + chalk.gray(join(hooksDir, 'gaia-session-start.sh')));
-        console.log('  ' + chalk.gray(join(hooksDir, 'gaia-pre-compact.sh')));
-        console.log('  ' + chalk.gray(join(hooksDir, 'gaia-post-task.sh')));
+        console.log(chalk.bold('Updated:'));
         console.log('  ' + chalk.gray(settingsPath));
         console.log();
         console.log(chalk.gray('Hooks will activate on the next Claude Code session in this project.'));
@@ -759,12 +707,12 @@ program
         '.svg': 'image/svg+xml',
         '.ico': 'image/x-icon',
     };
-    const server = createServer(async (req, res) => {
+    const server = createServer((req, res) => {
         const url = req.url || '/';
         // CORS headers for API endpoints
         const corsHeaders = {
             'Access-Control-Allow-Origin': '*',
-            'Access-Control-Allow-Methods': 'GET, OPTIONS',
+            'Access-Control-Allow-Methods': 'GET, PUT, POST, DELETE, OPTIONS',
             'Access-Control-Allow-Headers': 'Content-Type',
         };
         // Handle CORS preflight
@@ -816,131 +764,135 @@ program
             }
             return;
         }
-        // API endpoint for checkpoint data
-        if (url.startsWith('/api/checkpoint')) {
-            const urlObj = new URL(url, `http://localhost:${port}`);
-            const projectParam = urlObj.searchParams.get('project');
-            const targetPath = projectParam
-                ? join(projectParam, '.foundation', 'sessions', 'latest', 'checkpoint.json')
-                : join(cwd, '.foundation', 'sessions', 'latest', 'checkpoint.json');
-            if (existsSync(targetPath)) {
+        // ---- Memory API endpoints ----
+        if (url.startsWith('/api/memories/stats')) {
+            try {
+                const dbPath = join(homedir(), '.foundation', 'gaia-memory.db');
+                const storage = new MemoriaStorage(dbPath);
                 try {
-                    const content = readFileSync(targetPath, 'utf-8');
-                    res.writeHead(200, {
-                        'Content-Type': 'application/json',
-                        ...corsHeaders,
-                    });
-                    res.end(content);
+                    const gaia = storage.getStats();
+                    const rescue = storage.getRescueStats();
+                    res.writeHead(200, { 'Content-Type': 'application/json', ...corsHeaders });
+                    res.end(JSON.stringify({ gaia, rescue }));
                 }
-                catch {
-                    res.writeHead(500, { 'Content-Type': 'application/json', ...corsHeaders });
-                    res.end(JSON.stringify({ error: 'Failed to read checkpoint' }));
+                finally {
+                    storage.close();
                 }
             }
-            else {
-                res.writeHead(404, { 'Content-Type': 'application/json', ...corsHeaders });
-                res.end(JSON.stringify({
-                    error: 'Checkpoint not found',
-                    hint: 'Run `gaia_checkpoint` to save session state',
-                }));
+            catch (err) {
+                res.writeHead(500, { 'Content-Type': 'application/json', ...corsHeaders });
+                res.end(JSON.stringify({ error: err.message }));
             }
             return;
         }
-        // API endpoint for memories
-        if (url.startsWith('/api/memories')) {
-            const urlObj = new URL(url, `http://localhost:${port}`);
-            const tier = urlObj.searchParams.get('tier');
-            const q = urlObj.searchParams.get('q');
-            const dbPath = join(homedir(), '.foundation', 'gaia-memory.db');
-            if (!existsSync(dbPath)) {
-                res.writeHead(200, { 'Content-Type': 'application/json', ...corsHeaders });
-                res.end(JSON.stringify({ memories: [] }));
-                return;
-            }
+        if (url.startsWith('/api/memories/recent')) {
             try {
-                const BetterSqlite3 = await import('better-sqlite3');
-                const db = new BetterSqlite3.default(dbPath, { readonly: true });
-                let query = 'SELECT id, tier, content, tags, related_files, session_id, project_path, created_at, accessed_at, access_count, metadata FROM memories WHERE 1=1';
-                const params = [];
-                if (tier) {
-                    query += ' AND tier = ?';
-                    params.push(tier);
+                const urlObj = new URL(url, `http://localhost:${port}`);
+                const limit = parseInt(urlObj.searchParams.get('limit') || '50', 10);
+                const tierParam = urlObj.searchParams.get('tier');
+                const tiers = tierParam ? tierParam.split(',') : undefined;
+                const dbPath = join(homedir(), '.foundation', 'gaia-memory.db');
+                const storage = new MemoriaStorage(dbPath);
+                try {
+                    const results = storage.getRecent({ limit, tiers });
+                    res.writeHead(200, { 'Content-Type': 'application/json', ...corsHeaders });
+                    res.end(JSON.stringify(results));
                 }
-                if (q) {
-                    query += ' AND content LIKE ?';
-                    params.push(`%${q}%`);
+                finally {
+                    storage.close();
                 }
-                query += ' ORDER BY created_at DESC LIMIT 500';
-                const rows = db.prepare(query).all(...params);
-                db.close();
-                const memories = rows.map((r) => ({
-                    ...r,
-                    tags: (() => { try {
-                        return JSON.parse(r.tags);
-                    }
-                    catch {
-                        return [];
-                    } })(),
-                    related_files: (() => { try {
-                        return JSON.parse(r.related_files);
-                    }
-                    catch {
-                        return [];
-                    } })(),
-                    metadata: (() => { try {
-                        return JSON.parse(r.metadata);
-                    }
-                    catch {
-                        return null;
-                    } })(),
-                }));
-                res.writeHead(200, { 'Content-Type': 'application/json', ...corsHeaders });
-                res.end(JSON.stringify({ memories }));
             }
             catch (err) {
                 res.writeHead(500, { 'Content-Type': 'application/json', ...corsHeaders });
-                res.end(JSON.stringify({ memories: [], error: String(err) }));
+                res.end(JSON.stringify({ error: err.message }));
             }
             return;
         }
-        // API endpoint for memory graph
-        if (url.startsWith('/api/memory-graph')) {
-            const dbPath = join(homedir(), '.foundation', 'gaia-memory.db');
-            if (!existsSync(dbPath)) {
-                res.writeHead(200, { 'Content-Type': 'application/json', ...corsHeaders });
-                res.end(JSON.stringify({ memories: [], links: [] }));
-                return;
-            }
+        if (url.startsWith('/api/memories/search')) {
             try {
-                const BetterSqlite3 = await import('better-sqlite3');
-                const db = new BetterSqlite3.default(dbPath, { readonly: true });
-                const memRows = db.prepare('SELECT id, tier, content, tags, related_files, created_at FROM memories ORDER BY created_at DESC LIMIT 500').all();
-                const linkRows = db.prepare('SELECT from_memory_id, to_memory_id, link_type FROM memory_links').all();
-                db.close();
-                const memories = memRows.map((r) => ({
-                    ...r,
-                    tags: (() => { try {
-                        return JSON.parse(r.tags);
+                const urlObj = new URL(url, `http://localhost:${port}`);
+                const query = urlObj.searchParams.get('q') || '';
+                const tierParam = urlObj.searchParams.get('tier');
+                const tiers = tierParam ? tierParam.split(',') : undefined;
+                const limit = parseInt(urlObj.searchParams.get('limit') || '25', 10);
+                const sourceFilter = urlObj.searchParams.get('source') || 'all';
+                const dbPath = join(homedir(), '.foundation', 'gaia-memory.db');
+                const storage = new MemoriaStorage(dbPath);
+                try {
+                    let results;
+                    if (!query) {
+                        // No query = return recent
+                        results = storage.getRecent({ limit, tiers });
                     }
-                    catch {
-                        return [];
-                    } })(),
-                    related_files: (() => { try {
-                        return JSON.parse(r.related_files);
+                    else {
+                        results = storage.search({ query, tiers, limit });
                     }
-                    catch {
-                        return [];
-                    } })(),
-                }));
-                res.writeHead(200, { 'Content-Type': 'application/json', ...corsHeaders });
-                res.end(JSON.stringify({ memories, links: linkRows }));
+                    // Apply source filter client-side
+                    if (sourceFilter === 'gaia') {
+                        results = results.filter(r => !r.memory.id.startsWith('rescue_'));
+                    }
+                    else if (sourceFilter === 'rescued') {
+                        results = results.filter(r => r.memory.id.startsWith('rescue_'));
+                    }
+                    res.writeHead(200, { 'Content-Type': 'application/json', ...corsHeaders });
+                    res.end(JSON.stringify(results));
+                }
+                finally {
+                    storage.close();
+                }
             }
             catch (err) {
                 res.writeHead(500, { 'Content-Type': 'application/json', ...corsHeaders });
-                res.end(JSON.stringify({ memories: [], links: [], error: String(err) }));
+                res.end(JSON.stringify({ error: err.message }));
             }
             return;
         }
+        // ---- Daneel Proxy API endpoints ----
+        if (url.startsWith('/api/daneel/')) {
+            const daneelPath = url.replace('/api/daneel', '');
+            const method = req.method || 'GET';
+            // Collect request body for PUT/POST/DELETE
+            const bodyChunks = [];
+            req.on('data', (chunk) => { bodyChunks.push(chunk); });
+            req.on('end', () => {
+                const requestBody = Buffer.concat(bodyChunks);
+                const proxyReq = httpRequest({
+                    hostname: '127.0.0.1',
+                    port: 8889,
+                    path: daneelPath,
+                    method,
+                    timeout: 10000,
+                    headers: {
+                        'Content-Type': 'application/json',
+                        ...(requestBody.length > 0 ? { 'Content-Length': requestBody.length.toString() } : {}),
+                    },
+                }, (proxyRes) => {
+                    let body = '';
+                    proxyRes.on('data', (chunk) => { body += chunk.toString(); });
+                    proxyRes.on('end', () => {
+                        res.writeHead(proxyRes.statusCode || 200, {
+                            'Content-Type': 'application/json',
+                            ...corsHeaders,
+                        });
+                        res.end(body);
+                    });
+                });
+                proxyReq.on('error', () => {
+                    res.writeHead(503, { 'Content-Type': 'application/json', ...corsHeaders });
+                    res.end(JSON.stringify({ error: 'Daneel not running' }));
+                });
+                proxyReq.on('timeout', () => {
+                    proxyReq.destroy();
+                    res.writeHead(503, { 'Content-Type': 'application/json', ...corsHeaders });
+                    res.end(JSON.stringify({ error: 'Daneel not running' }));
+                });
+                if (requestBody.length > 0) {
+                    proxyReq.write(requestBody);
+                }
+                proxyReq.end();
+            });
+            return;
+        }
         // Serve static files
         let filePath = join(uiDistPath, url === '/' ? 'index.html' : url);
         // Handle SPA routing - serve index.html for non-file paths
@@ -1000,6 +952,162 @@ program
     });
 });
 // ============================================================================
+// foundation vault
+// ============================================================================
+const vaultCommand = program
+    .command('vault')
+    .description('Sync Gaia memories to an Obsidian vault');
+vaultCommand
+    .command('init <path>')
+    .description('Initialize vault folder structure at <path>')
+    .option('--claude-memory <path>', 'Path to Claude Code memory directory')
+    .action(async (vaultPath, opts) => {
+    const spinner = ora('Initializing vault...').start();
+    try {
+        // Resolve to absolute path
+        const resolvedPath = vaultPath.startsWith('/')
+            ? vaultPath
+            : join(process.cwd(), vaultPath);
+        // Warn if path doesn't look like an Obsidian vault
+        if (!existsSync(resolvedPath)) {
+            spinner.fail(`Path does not exist: ${resolvedPath}`);
+            process.exit(1);
+        }
+        const obsidianDir = join(resolvedPath, '.obsidian');
+        if (!existsSync(obsidianDir)) {
+            spinner.warn('No .obsidian/ directory found — path may not be an Obsidian vault. Continuing anyway.');
+        }
+        // Save config
+        const config = {
+            vaultPath: resolvedPath,
+        };
+        if (opts.claudeMemory) {
+            config.claudeMemoryPath = opts.claudeMemory;
+        }
+        saveVaultConfig(config);
+        // Create folder structure + dashboard
+        const vaultConfig = buildVaultConfig({ vaultPath: resolvedPath });
+        const vault = new VaultSync(vaultConfig);
+        await vault.init();
+        spinner.succeed('Vault initialized!');
+        console.log();
+        console.log(chalk.green('✓') + ' Vault path: ' + chalk.cyan(resolvedPath));
+        console.log(chalk.green('✓') + ' Config saved: ' + chalk.gray(VAULT_CONFIG_FILE));
+        if (opts.claudeMemory) {
+            console.log(chalk.green('✓') + ' Claude memory: ' + chalk.cyan(opts.claudeMemory));
+        }
+        console.log();
+        console.log(chalk.bold('Folders created:'));
+        console.log('  ' + chalk.cyan('Foundation/Global'));
+        console.log('  ' + chalk.cyan('Foundation/Projects'));
+        console.log('  ' + chalk.cyan('Foundation/Sessions'));
+        console.log('  ' + chalk.cyan('Foundation/Notes'));
+        console.log('  ' + chalk.cyan('Foundation/Observations'));
+        console.log('  ' + chalk.cyan('Knowledge'));
+        console.log('  ' + chalk.cyan('Foundation/_dashboard.md'));
+        console.log();
+        console.log('Run ' + chalk.cyan('foundation vault sync') + ' to populate the vault.');
+    }
+    catch (error) {
+        spinner.fail('Failed to initialize vault');
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+});
+vaultCommand
+    .command('sync')
+    .description('Sync Gaia memories to the vault')
+    .option('--incremental', 'Only write memories whose content has changed since last sync')
+    .action(async (opts) => {
+    const spinner = ora('Syncing memories to vault...').start();
+    let vaultConfig;
+    try {
+        vaultConfig = buildVaultConfig();
+    }
+    catch (error) {
+        spinner.fail(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+    try {
+        const vault = new VaultSync(vaultConfig);
+        if (opts.incremental) {
+            spinner.text = 'Running incremental sync...';
+            const result = await vault.syncIncremental();
+            spinner.succeed('Incremental sync complete');
+            console.log();
+            console.log(chalk.green('  created  ') + result.created);
+            console.log(chalk.blue('  updated  ') + result.updated);
+            console.log(chalk.red('  deleted  ') + result.deleted);
+            console.log(chalk.gray('  skipped  ') + result.skipped);
+            if (result.errors.length > 0) {
+                console.log();
+                console.log(chalk.yellow(`  ${result.errors.length} error(s):`));
+                for (const err of result.errors) {
+                    console.log(chalk.red('    ' + err));
+                }
+            }
+        }
+        else {
+            spinner.text = 'Running full sync...';
+            const result = await vault.sync();
+            spinner.succeed('Full sync complete');
+            console.log();
+            console.log(chalk.green('  created  ') + result.created);
+            console.log(chalk.blue('  updated  ') + result.updated);
+            console.log(chalk.red('  deleted  ') + result.deleted);
+            console.log(chalk.gray('  skipped  ') + result.skipped);
+            if (result.errors.length > 0) {
+                console.log();
+                console.log(chalk.yellow(`  ${result.errors.length} error(s):`));
+                for (const err of result.errors) {
+                    console.log(chalk.red('    ' + err));
+                }
+            }
+        }
+    }
+    catch (error) {
+        spinner.fail('Sync failed');
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+});
+vaultCommand
+    .command('status')
+    .description('Show vault sync status')
+    .action(() => {
+    const config = loadVaultConfig();
+    if (!config) {
+        console.log(chalk.yellow('Not initialized. Run: foundation vault init <path>'));
+        return;
+    }
+    console.log(chalk.bold('Vault Status'));
+    console.log();
+    console.log('  Vault path:    ' + chalk.cyan(config.vaultPath));
+    if (config.claudeMemoryPath) {
+        console.log('  Claude memory: ' + chalk.cyan(config.claudeMemoryPath));
+    }
+    try {
+        const vaultConfig = buildVaultConfig();
+        const vault = new VaultSync(vaultConfig);
+        const state = vault.getStatus();
+        if (!state) {
+            console.log('  Last sync:     ' + chalk.gray('Never'));
+            console.log('  Memories:      ' + chalk.gray('0'));
+        }
+        else {
+            const lastSync = new Date(state.last_full_sync);
+            const isNever = lastSync.getTime() === new Date(0).getTime();
+            const memoriesCount = Object.keys(state.synced_memories).length;
+            console.log('  Last sync:     ' +
+                (isNever ? chalk.gray('Never') : chalk.cyan(lastSync.toLocaleString())));
+            console.log('  Memories:      ' + chalk.cyan(String(memoriesCount)));
+        }
+    }
+    catch (error) {
+        console.log('  ' + chalk.red('Error reading sync state: ' + (error instanceof Error ? error.message : String(error))));
+    }
+});
+// ============================================================================
 // Parse and run
 // ============================================================================
 program.parse();