squish-memory 1.0.1 → 1.1.5

package/dist/index.js

@@ -1,62 +1,165 @@
 #!/usr/bin/env node
 /**
- * Squish v1.0.0 - Universal Memory Plugin System
- *
- * Modes:
- * - CLI Mode: For any MCP client bash execution (e.g., `squish remember "text"`)
- * - MCP Mode: For AI assistants (Claude Code, OpenClaw, OpenCode, Codex, etc.)
- *
- * Features:
- * - Hybrid Search: BM25 + vector search with RRF
- * - Importance Scoring: Auto-score memories with temporal decay
- * - Consolidation: Summarize old, low-importance memory clusters
- * - 16 MCP tools
- * - Local mode: SQLite with FTS5
- * - Team mode: PostgreSQL + pgvector
- * - Universal Plugin: Works with 7+ AI assistants
+ * Squish - Universal Memory Plugin System
+ * CLI + MCP server for persistent memory with hybrid search and encryption
  */
 import 'dotenv/config';
 import fs from 'node:fs';
+import { existsSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { spawnSync } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { Command } from 'commander';
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
 import { logger } from './core/logger.js';
-import { checkDatabaseHealth, config } from './db/index.js';
-import { checkRedisHealth, closeCache } from './core/cache.js';
-import { rememberMemory, getMemoryById, searchMemories } from './core/memory/memories.js';
-import { createObservation } from './core/observations.js';
-import { getProjectContext } from './core/context.js';
-import { setImportanceScore } from './core/memory/importance.js';
+import { checkDatabaseHealth, config, getDb } from './db/index.js';
+import { getSchema } from './db/schema.js';
+import { eq } from 'drizzle-orm';
+import { checkRedisHealth } from './core/storage/cache.js';
+import { rememberMemory, getMemory, search, getRecent, setConfidence } from './core/memory/memories.js';
+import { serializeTags } from './core/memory/serialization.js';
+import { createLearning } from './core/ingestion/learnings.js';
 import { getMemoryStats } from './core/memory/stats.js';
-import { ensureProject } from './core/projects.js';
-import { consolidateMemories as consolidateMemoriesImpl, getConsolidationStats } from './core/memory/consolidation.js';
-import { startWebServer } from './api/web/web.js';
-import { handleDetectDuplicates } from './algorithms/handlers/detect-duplicates.js';
-import { handleListProposals } from './algorithms/handlers/list-proposals.js';
-import { handlePreviewMerge } from './algorithms/handlers/preview-merge.js';
-import { handleApproveMerge } from './algorithms/handlers/approve-merge.js';
-import { handleRejectMerge } from './algorithms/handlers/reject-merge.js';
-import { handleReverseMerge } from './algorithms/handlers/reverse-merge.js';
-import { handleGetMergeStats } from './algorithms/handlers/get-stats.js';
-import { pinMemory, unpinMemory } from './core/governance.js';
-import { searchWithQMD, isQMDAvailable } from './core/search/qmd-search.js';
-import { initializeCoreMemory, getCoreMemory, editCoreMemorySection, appendCoreMemorySection, getCoreMemoryStats, } from './core/core-memory.js';
-import { loadMemoryToContext, evictMemoryFromContext, viewLoadedMemories, getContextStatus, } from './core/context-paging.js';
+import { ensureProject, getAllProjects, getOrCreateProject } from './core/projects.js';
+import { startWebServer } from './webui/server.js';
+import { getRelatedMemories, createAssociation } from './core/associations.js';
+import { pinMemory, unpinMemory } from './core/security/governance.js';
+import { determineOverallStatus } from './core/lib/utils.js';
+import { validateLimit } from './core/lib/validation.js';
+import { runDeduplicationJob, runFullConsolidationJob } from './core/consolidation.js';
 import { ensureDataDirectory } from './db/bootstrap.js';
-import { performAutoLoad, shouldAutoLoad, getAutoLoadConfig } from './core/session/auto-load.js';
-import { initializeScheduler, registerJobHandler } from './core/scheduler/cron-scheduler.js';
-import { startHeartbeatChecking, heartbeat } from './core/scheduler/heartbeat.js';
-import { runNightlyJob, runWeeklyJob } from './core/scheduler/job-runner.js';
-const VERSION = '1.0.1';
+import { getDataDir } from './config.js';
+import { handleSessionStart, handlePostToolUse, handleSessionEnd, handlePreCompact, } from './core/hooks/agent-hooks.js';
+import { initializeDefaultPlaces, walkPlace, walkAllPlaces, quickTour, } from './core/places/index.js';
+const VERSION = '1.1.5';
+// Output Formatting Utilities
+// ============================================================================
+function formatOutput(data, pretty = false) {
+    if (!pretty) {
+        return JSON.stringify(data, null, 2);
+    }
+    if (Array.isArray(data)) {
+        return data.map((item, i) => `${i + 1}. ${formatItem(item)}`).join('\n');
+    }
+    if (data.results) {
+        return data.results.map((item, i) => `${i + 1}. ${formatItem(item)}`).join('\n');
+    }
+    if (data.matches) {
+        return data.matches.map((item, i) => `${i + 1}. ${formatItem(item)}`).join('\n');
+    }
+    if (data.count !== undefined) {
+        let output = `\nFound ${data.count} results:\n`;
+        if (data.results) {
+            output += data.results.map((item, i) => `  ${i + 1}. ${formatItem(item)}`).join('\n');
+        }
+        return output;
+    }
+    return JSON.stringify(data, null, 2);
+}
+function formatItem(item) {
+    if (typeof item === 'string')
+        return item.substring(0, 100);
+    const content = item.content || item.summary || item.memory?.content || '';
+    const type = item.type || '';
+    return `[${type}] ${content.substring(0, 80)}${content.length > 80 ? '...' : ''}`;
+}
+function printSuccess(message) {
+    console.log(`\n  ✓ ${message}\n`);
+}
+function printError(message) {
+    console.error(`\n  ✗ ${message}\n`);
+}
+function printInfo(message) {
+    console.log(`\n  ℹ ${message}\n`);
+}
+// Config Management (for project path persistence)
+// ============================================================================
+const USER_CONFIG_PATH = path.join(os.homedir(), '.squish', 'config.json');
+function loadUserConfig() {
+    try {
+        if (fs.existsSync(USER_CONFIG_PATH)) {
+            return JSON.parse(fs.readFileSync(USER_CONFIG_PATH, 'utf-8'));
+        }
+    }
+    catch (e) { }
+    return {};
+}
+function saveUserConfig(config) {
+    const dir = path.dirname(USER_CONFIG_PATH);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(USER_CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+function getDefaultProjectPath() {
+    const userConfig = loadUserConfig();
+    if (userConfig.project)
+        return userConfig.project;
+    return process.cwd();
+}
+function resolveProjectPath(projectOption) {
+    if (projectOption)
+        return projectOption;
+    return getDefaultProjectPath();
+}
+// Date parsing for time-based queries
+// ============================================================================
+function parseDate(input) {
+    if (!input)
+        return null;
+    const now = new Date();
+    const lower = input.toLowerCase().trim();
+    // Direct date parse
+    const parsed = new Date(input);
+    if (!isNaN(parsed.getTime()))
+        return parsed;
+    // Relative parsing
+    const dayMatch = lower.match(/(\d+)\s*day/i);
+    const weekMatch = lower.match(/(\d+)\s*week/i);
+    const monthMatch = lower.match(/(\d+)\s*month/i);
+    if (lower === 'today') {
+        const d = new Date(now);
+        d.setHours(0, 0, 0, 0);
+        return d;
+    }
+    if (lower === 'yesterday')
+        return new Date(now.getTime() - 86400000);
+    if (lower === 'thisweek' || lower === 'this week') {
+        const d = new Date(now);
+        d.setDate(d.getDate() - d.getDay());
+        d.setHours(0, 0, 0, 0);
+        return d;
+    }
+    if (lower === 'lastweek' || lower === 'last week') {
+        const d = new Date(now);
+        d.setDate(d.getDate() - d.getDay() - 7);
+        return d;
+    }
+    if (dayMatch)
+        return new Date(now.getTime() - parseInt(dayMatch[1]) * 86400000);
+    if (weekMatch)
+        return new Date(now.getTime() - parseInt(weekMatch[1]) * 604800000);
+    if (monthMatch)
+        return new Date(now.getTime() - parseInt(monthMatch[1]) * 2592000000);
+    return null;
+}
+function filterByDateRange(items, since, until) {
+    const sinceDate = parseDate(since || '');
+    const untilDate = parseDate(until || '');
+    return items.filter(item => {
+        if (!item.createdAt)
+            return true;
+        const created = new Date(item.createdAt);
+        if (sinceDate && created < sinceDate)
+            return false;
+        if (untilDate && created > untilDate)
+            return false;
+        return true;
+    });
+}
 // Load plugin manifest for self-verification
 function loadPluginManifest() {
     try {
-        const manifestPath = path.join(process.cwd(), 'config', 'plugin-manifest.json');
+        const manifestPath = path.join(getDefaultProjectPath(), 'config', 'plugin-manifest.json');
         if (fs.existsSync(manifestPath)) {
             return JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
         }
@@ -88,26 +191,258 @@ function verifyManifest(manifest) {
     });
     return { ok: errors.length === 0, errors };
 }
+async function buildHealthStatus() {
+    const dbHealth = await checkDatabaseHealth();
+    const redisHealth = await checkRedisHealth();
+    const database = dbHealth ? 'ok' : 'error';
+    const cache = config.redisEnabled ? (redisHealth ? 'ok' : 'error') : 'unavailable';
+    const overallStatus = config.redisEnabled
+        ? determineOverallStatus(database, redisHealth)
+        : (dbHealth ? 'ok' : 'error');
+    return {
+        ok: overallStatus === 'ok',
+        version: VERSION,
+        mode: config.isTeamMode ? 'team' : 'local',
+        database,
+        cache,
+        dataDirectory: config.dataDir,
+        dataDirectoryExists: fs.existsSync(config.dataDir),
+        status: overallStatus,
+        timestamp: new Date().toISOString(),
+    };
+}
+// HELPER FUNCTIONS
 // ============================================================================
+function showHelp() {
+    console.log(`
+Squish Memory v${VERSION} - Universal Memory Plugin System
+
+Usage:
+  squish                      Start interactive wizard
+  squish run mcp              Start MCP server
+  squish run web              Start Web UI only
+  squish <command> [options]  Run CLI commands for agents
+
+CLI Commands (for agents):
+  squish config [action]      Manage Squish configuration
+  squish remember <content>   Store a memory
+  squish note <content>       Save a quick note
+  squish learn <type> <text>  Record learning: success, failure, fix, insight
+  squish search <query>       Search memories (--pretty for human output)
+  squish recall <query>       Search or get by ID (--pretty for human output)
+  squish recent --period      Recent memories (today/yesterday/thisweek/7days/30days)
+  squish update <memoryId>    Update memory
+  squish forget <memoryId>    Delete memory (single or bulk with --older-than --search)
+  squish pin <memoryId>       Pin/unpin memory
+  squish confidence <id>      Set confidence
+  squish tag <action>         Manage tags
+  squish stale                Show stale memories
+  squish link <action>        Manage links (find/add/list)
+  squish migrate              Migrate memories between .squish directories
+  squish clean                Dedup + consolidate (maintenance)
+  squish context              Show context or list projects
+  squish stats                View memory statistics
+
+Examples:
+  squish run mcp              # Start MCP server (for agents)
+  squish run web              # Start Web UI only
+  squish config set project /repo/path
+  squish remember "Hello"     # Store memory
+  squish note "Ship v1 first" # Save a quick note
+  squish learn observation "Updated auth flow" --action edit
+  squish learn fix "Patched auth middleware" --target middleware.ts
+  squish search "query"       # Search memories
+  squish context --list-projects
+  squish clean                # Run deduplication and consolidation
+
+For more info: https://github.com/michielhdoteth/squish
+`);
+}
+async function runInteractiveInstaller() {
+    const { select } = await import('@clack/prompts');
+    const { isCancel } = await import('@clack/prompts');
+    const { log } = await import('@clack/prompts');
+    const { intro, outro } = await import('@clack/prompts');
+    intro(`Squish Memory v${VERSION}`);
+    const options = [
+        { value: 'mcp', label: 'Start MCP Server (for AI Assistants: Claude Code, OpenCode, etc.)' },
+        { value: 'web', label: 'Start Web UI Only' },
+        { value: 'health', label: 'Health & Stats' },
+        { value: 'help', label: 'Show Help' },
+        { value: 'exit', label: 'Exit' }
+    ];
+    const selected = await select({
+        message: 'What would you like to do?',
+        options: options,
+    });
+    if (isCancel(selected)) {
+        outro('Cancelled');
+        process.exit(0);
+        return;
+    }
+    switch (selected) {
+        case 'mcp':
+            log.step('Starting MCP server...');
+            const { spawn } = await import('child_process');
+            spawn('npx', ['squish-mcp'], { stdio: 'inherit', shell: true });
+            break;
+        case 'web':
+            log.step('Starting Web UI...');
+            await runWebOnly();
+            break;
+        case 'health':
+            log.step('Checking health...');
+            await runCliCommand('health');
+            await runCliCommand('stats');
+            break;
+        case 'help':
+            showHelp();
+            process.exit(0);
+            break;
+        case 'exit':
+            outro('Goodbye! 👋');
+            process.exit(0);
+            break;
+    }
+}
+async function runCliCommand(command) {
+    // Run CLI command programmatically
+    const program = new Command();
+    program.hook('preAction', async () => {
+        await ensureDataDirectory();
+    });
+    if (command === 'health') {
+        const status = await buildHealthStatus();
+        console.log(`\n  Squish Memory v${VERSION}`);
+        console.log(`  ====================`);
+        console.log(`  Mode:     ${status.mode}`);
+        console.log(`  Database: ${status.database}`);
+        console.log(`  Cache:    ${status.cache}`);
+        console.log(`  Data Dir: ${status.dataDirectory}`);
+        console.log(`  Status:   ${status.ok ? 'HEALTHY' : 'UNHEALTHY'}\n`);
+    }
+    else if (command === 'stats') {
+        const stats = await getMemoryStats(getDefaultProjectPath());
+        console.log(JSON.stringify({ ok: true, ...stats }, null, 2));
+    }
+}
+async function spawnInstallerWizard() {
+    const distDir = path.dirname(fileURLToPath(import.meta.url));
+    const packageDir = path.dirname(distDir);
+    const installScript = path.join(packageDir, 'scripts', 'install-interactive.mjs');
+    if (!fs.existsSync(installScript)) {
+        console.error('Installer not found at:', installScript);
+        process.exit(1);
+    }
+    console.log('\nLaunching full installer wizard...\n');
+    const result = spawnSync('node', [`"${installScript}"`], {
+        stdio: 'inherit',
+        shell: true,
+        cwd: packageDir
+    });
+    process.exit(result.status || 0);
+}
+function isDatabaseInitialized() {
+    try {
+        const dataDir = getDataDir();
+        const dbPath = path.join(dataDir, 'squish.db');
+        return existsSync(dataDir) && existsSync(dbPath);
+    }
+    catch (error) {
+        return false;
+    }
+}
+async function runWebOnly() {
+    console.log(`[squish] Starting Web UI only...`);
+    await ensureDataDirectory();
+    await startWebServer();
+}
 // CLI MODE DETECTION
 // ============================================================================
 const args = process.argv.slice(2);
-const hasCliArgs = args.length > 0 && args[0] !== '--mcp';
-if (hasCliArgs) {
-    // === CLI MODE (for OpenClaw) ===
-    runCliMode().catch((e) => {
-        console.error(JSON.stringify({ error: e.message }, null, 2));
-        process.exit(1);
-    });
+const firstArg = args[0];
+// Detect command type
+const isNoArgs = args.length === 0;
+const isRunCommand = firstArg === 'run';
+const isHelpCommand = firstArg === '--help' || firstArg === '-h' || firstArg === 'help';
+if (isNoArgs) {
+    // Check if database exists - if not, run installer automatically
+    if (!isDatabaseInitialized()) {
+        console.log(`[squish] No existing database found. Launching installer wizard...\n`);
+        await spawnInstallerWizard();
+    }
+    else {
+        // INTERACTIVE WIZARD (default when no args) ===
+        runInteractiveInstaller().catch((e) => {
+            console.error('Installer error:', e.message);
+            process.exit(1);
+        });
+    }
+}
+else if (isRunCommand) {
+    // RUN SUBCOMMAND ===
+    const subcommand = args[1];
+    if (subcommand === 'mcp') {
+        (async () => {
+            try {
+                // Initialize data directory before starting MCP
+                await ensureDataDirectory();
+                // Start MCP server as child process (stdio mode for agents)
+                const mcpProcess = spawn('npx', ['squish-mcp'], {
+                    stdio: 'inherit',
+                    shell: true
+                });
+                // Forward MCP exit code when it exits
+                mcpProcess.on('exit', (code) => {
+                    process.exit(code ?? 0);
+                });
+                // Clean shutdown: forward signals to MCP child
+                const cleanup = () => {
+                    mcpProcess.kill('SIGTERM');
+                    setTimeout(() => process.exit(0), 100);
+                };
+                process.on('SIGINT', cleanup);
+                process.on('SIGTERM', cleanup);
+            }
+            catch (error) {
+                console.error('[squish] Failed to start MCP server:', error.message);
+                process.exit(1);
+            }
+        })();
+    }
+    else if (subcommand === 'web') {
+        runWebOnly().catch((e) => {
+            logger.error('Web server error', e);
+            process.exit(1);
+        });
+    }
+    else {
+        console.log(`
+Usage: squish run <command>
+
+Commands:
+  mcp    Start MCP server (for agents like Claude Code)
+  web    Start Web UI only
+
+Examples:
+  squish run mcp   # Start MCP server (agents connect automatically)
+  squish run web   # Start Web UI at http://localhost:37777
+`);
+        process.exit(subcommand ? 1 : 0);
+    }
+}
+else if (isHelpCommand) {
+    // SHOW HELP ===
+    showHelp();
+    process.exit(0);
 }
 else {
-    // === MCP MODE (for Claude Code) - DEFAULT ===
-    runMcpMode().catch((e) => {
-        logger.error('Fatal error', e);
+    // CLI MODE (for agents/OpenClaw) ===
+    runCliMode().catch((e) => {
+        console.error(JSON.stringify({ error: e.message }, null, 2));
         process.exit(1);
     });
 }
-// ============================================================================
 // CLI MODE (for OpenClaw bash execution)
 // ============================================================================
 async function runCliMode() {
@@ -120,20 +455,136 @@ async function runCliMode() {
     program.hook('preAction', async () => {
         await ensureDataDirectory();
     });
+    // squish config [get] [key] or squish config set <key> <value>
+    program
+        .command('config')
+        .description('Manage Squish configuration')
+        .argument('[action]', 'get, set, or list', 'list')
+        .argument('[key]', 'Config key (e.g., project)')
+        .argument('[value]', 'Config value (for set action)')
+        .action(async (action, key, value) => {
+        const userConfig = loadUserConfig();
+        if (action === 'set') {
+            if (!key || value === undefined) {
+                console.log(JSON.stringify({ ok: false, error: 'Usage: squish config set <key> <value>' }, null, 2));
+                process.exit(1);
+            }
+            userConfig[key] = value;
+            saveUserConfig(userConfig);
+            console.log(JSON.stringify({ ok: true, message: `Set ${key} = ${value}` }, null, 2));
+        }
+        else if (action === 'get') {
+            if (!key) {
+                console.log(JSON.stringify({ ok: false, error: 'Usage: squish config get <key>' }, null, 2));
+                process.exit(1);
+            }
+            console.log(JSON.stringify({ ok: true, [key]: userConfig[key] || null }, null, 2));
+        }
+        else {
+            console.log(JSON.stringify({ ok: true, config: userConfig }, null, 2));
+        }
+    });
+    // squish mount /path/to/folder - Enable external memory
+    program
+        .command('mount')
+        .description('Mount an external folder as memory storage')
+        .argument('[path]', 'Path to external folder (or "status" or "unmount")')
+        .action(async (pathOrAction) => {
+        const { getExternalMemory } = await import('./core/external-folder/index.js');
+        const externalMemory = getExternalMemory();
+        if (pathOrAction === 'status') {
+            // Show mount status
+            const status = await externalMemory.getStatus();
+            console.log(JSON.stringify({ ok: true, status }, null, 2));
+        }
+        else if (pathOrAction === 'unmount') {
+            // Unmount
+            externalMemory.unmount();
+            console.log(JSON.stringify({ ok: true, message: 'External memory unmounted' }, null, 2));
+        }
+        else if (pathOrAction) {
+            // Mount at path
+            const result = await externalMemory.mount(pathOrAction);
+            if (result.success) {
+                console.log(JSON.stringify({ ok: true, message: `Mounted at ${pathOrAction}` }, null, 2));
+            }
+            else {
+                console.log(JSON.stringify({ ok: false, error: result.error }, null, 2));
+            }
+        }
+        else {
+            console.log(JSON.stringify({ ok: false, error: 'Usage: squish mount <path> or squish mount status' }, null, 2));
+        }
+    });
     // squish remember "content" --type fact --tags tag1,tag2
     program
         .command('remember <content>')
         .description('Store a memory')
         .option('-t, --type <type>', 'Memory type (observation, fact, decision, context, preference)', 'observation')
         .option('-T, --tags <tags>', 'Comma-separated tags', '')
-        .option('-p, --project <project>', 'Project path', process.cwd())
+        .option('-p, --project <project>', 'Project path', getDefaultProjectPath())
+        .option('-s, --source <source>', 'Source of this memory (e.g., "voice", "chat", "document")')
+        .option('-r, --reasoning <reasoning>', 'Why this memory is important')
+        .option('-c, --context <context>', 'What triggered this memory')
+        .option('-e, --examples <examples>', 'When to apply this knowledge')
+        .option('-x, --exceptions <exceptions>', 'When NOT to apply this')
+        .option('-m, --memory', 'Store as markdown file in .squish/memory/ (not in database)', false)
+        .option('-H, --hot', 'Store in hot tier (active, high priority) in database', false)
+        .option('-C, --cold', 'Store in cold tier (archived, lower priority) in database', false)
         .action(async (content, options) => {
         try {
+            // Markdown file storage (not in database)
+            if (options.memory) {
+                const { saveToMarkdown } = await import('./core/memory/markdown/markdown-storage.js');
+                const memoryFile = await saveToMarkdown({
+                    content,
+                    type: options.type,
+                    tags: options.tags ? options.tags.split(',').map((t) => t.trim()) : [],
+                    project: options.project,
+                    source: options.source,
+                    reasoning: options.reasoning,
+                    memoryContext: options.context,
+                    examples: options.examples,
+                    exceptions: options.exceptions,
+                });
+                // Trigger hooks
+                const { triggerMemoryCreated } = await import('./core/memory/hooks.js');
+                await triggerMemoryCreated({
+                    memoryId: memoryFile.id,
+                    content: memoryFile.content,
+                    type: memoryFile.type,
+                    tags: memoryFile.tags,
+                    project: memoryFile.project,
+                    source: memoryFile.source,
+                    tier: 'hot',
+                });
+                console.log(JSON.stringify({ ok: true, memory: true, ...memoryFile }, null, 2));
+                return;
+            }
+            // Database storage: determine tier
+            const tier = options.cold ? 'cold' : 'hot';
             const result = await rememberMemory({
                 content,
                 type: options.type,
                 tags: options.tags ? options.tags.split(',').map((t) => t.trim()) : [],
                 project: options.project,
+                source: options.source,
+                reasoning: options.reasoning,
+                memoryContext: options.context,
+                examples: options.examples,
+                exceptions: options.exceptions,
+                tier,
+            });
+            // Trigger hooks for DB storage
+            const { triggerMemoryCreated } = await import('./core/memory/hooks.js');
+            await triggerMemoryCreated({
+                memoryId: result.id,
+                content: result.content,
+                type: result.type,
+                tags: result.tags,
+                project: result.projectId || undefined,
+                source: options.source || 'cli',
+                tier,
             });
             console.log(JSON.stringify({ ok: true, ...result }, null, 2));
         }
@@ -142,218 +593,559 @@ async function runCliMode() {
             process.exit(1);
         }
     });
-    // squish search "query" --type fact --limit 10
+    // squish search "query" --type fact --limit 10 --since "3 days ago" --place workshop
     program
         .command('search <query>')
         .description('Search memories')
         .option('-t, --type <type>', 'Filter by memory type')
         .option('-l, --limit <number>', 'Max results', '10')
-        .option('-p, --project <project>', 'Project path', process.cwd())
+        .option('-p, --project <project>', 'Project path', getDefaultProjectPath())
+        .option('-s, --since <date>', 'Filter: created after this date (e.g., "3 days ago", "2026-01-01")')
+        .option('-u, --until <date>', 'Filter: created before this date (e.g., "yesterday", "2026-01-15")')
+        .option('-P, --pretty', 'Human-friendly output', false)
+        .option('-m, --memory', 'Search memory files instead of database', false)
+        .option('--place <type>', 'Filter by place type: entry_hall, library, workshop, lab, office, garden, archive')
         .action(async (query, options) => {
         try {
-            const results = await searchMemories({
+            // Markdown file search
+            if (options.memory) {
+                const { getMarkdownMemories } = await import('./core/memory/markdown/markdown-storage.js');
+                const memoryFiles = await getMarkdownMemories({
+                    type: options.type,
+                    project: options.project,
+                });
+                // Simple text search (can be enhanced with QMD later)
+                const searchLower = query.toLowerCase();
+                const filtered = memoryFiles.filter(m => m.content.toLowerCase().includes(searchLower) ||
+                    m.tags.some(t => t.toLowerCase().includes(searchLower))).slice(0, validateLimit(options.limit, 10, 1, 100));
+                if (options.pretty) {
+                    console.log(`\n  Memory Search: "${query}"`);
+                    console.log(`  Found ${filtered.length} results:\n`);
+                    filtered.forEach((r, i) => {
+                        console.log(`  ${i + 1}. [${r.type || 'memory'}] ${(r.content || '').substring(0, 60)}...`);
+                    });
+                    console.log('');
+                }
+                else {
+                    console.log(JSON.stringify({ ok: true, query, source: 'memory', count: filtered.length, results: filtered }, null, 2));
+                }
+                return;
+            }
+            // Database search
+            const results = await search({
                 query,
                 type: options.type,
-                limit: parseInt(options.limit, 10),
+                limit: validateLimit(options.limit, 10, 1, 100) * 2,
                 project: options.project,
             });
-            console.log(JSON.stringify({ ok: true, query, count: results?.length || 0, results }, null, 2));
+            const filtered = filterByDateRange(results, options.since, options.until);
+            let limited = filtered.slice(0, validateLimit(options.limit, 10, 1, 100));
+            // Add place info to results
+            const { getMemoryPlace } = await import('./core/places/index.js');
+            const limitedWithPlace = await Promise.all(limited.map(async (r) => {
+                const placeId = await getMemoryPlace(r.id);
+                return { ...r, placeId };
+            }));
+            // Filter by place if specified
+            if (options.place) {
+                const placeFiltered = [];
+                for (const r of limitedWithPlace) {
+                    if (r.placeId) {
+                        const { getPlace } = await import('./core/places/index.js');
+                        const place = await getPlace(r.placeId);
+                        if (place && place.placeType === options.place) {
+                            placeFiltered.push({ ...r, place: place.name || null, placeType: place.placeType || null });
+                        }
+                    }
+                }
+                limited = placeFiltered;
+            }
+            else if (limitedWithPlace.length > 0) {
+                // Add place info to results even without filter
+                for (const r of limitedWithPlace) {
+                    if (r.placeId) {
+                        const { getPlace } = await import('./core/places/index.js');
+                        const place = await getPlace(r.placeId);
+                        if (place) {
+                            r.place = place.name || null;
+                            r.placeType = place.placeType || null;
+                        }
+                    }
+                }
+                limited = limitedWithPlace;
+            }
+            if (options.pretty) {
+                console.log(`\n  Search: "${query}"`);
+                console.log(`  Found ${limited.length} results:\n`);
+                limited.forEach((r, i) => {
+                    const placeTag = r.place ? ` (${r.place})` : '';
+                    console.log(`  ${i + 1}. [${r.type || 'memory'}] ${(r.content || '').substring(0, 60)}...${placeTag}`);
+                });
+                console.log('');
+            }
+            else {
+                console.log(JSON.stringify({ ok: true, query, count: limited.length, since: options.since, until: options.until, placeFilter: options.place || null, results: limited }, null, 2));
+            }
         }
         catch (error) {
             console.log(JSON.stringify({ ok: false, error: error.message }, null, 2));
             process.exit(1);
         }
     });
-    // squish recall <memoryId>
+    // squish forget <memoryId> -- Delete single or bulk delete memories
     program
-        .command('recall <memoryId>')
-        .description('Retrieve a memory by ID')
-        .action(async (memoryId) => {
+        .command('forget [memoryId]')
+        .description('Delete a memory by ID, or bulk delete with filters')
+        .option('-o, --older-than <date>', 'Bulk delete memories older than (e.g., "30 days", "6 months")')
+        .option('-t, --type <type>', 'Filter by memory type')
+        .option('-s, --search <query>', 'Search query to match specific memories')
+        .option('-c, --confirm', 'Actually delete (default is dry-run)', false)
+        .option('-l, --limit <number>', 'Max memories to delete', '100')
+        .option('-p, --project <project>', 'Project path', getDefaultProjectPath())
+        .action(async (memoryId, options) => {
         try {
-            const memory = await getMemoryById(String(memoryId));
-            console.log(JSON.stringify({ ok: true, found: !!memory, memory }, null, 2));
+            // Single memory deletion
+            if (memoryId) {
+                const db = await getDb();
+                const schema = await getSchema();
+                const sqliteDb = db;
+                // Get memory content before deleting for hook
+                const [memory] = await sqliteDb.select().from(schema.memories).where(eq(schema.memories.id, memoryId));
+                await sqliteDb.delete(schema.memories).where(eq(schema.memories.id, memoryId));
+                // Trigger memoryDeleted hook
+                if (memory) {
+                    const { triggerMemoryDeleted } = await import('./core/memory/hooks.js');
+                    await triggerMemoryDeleted({
+                        memoryId: memory.id,
+                        content: memory.content,
+                        type: memory.type,
+                        tags: typeof memory.tags === 'string' ? memory.tags.split(',') : [],
+                        project: memory.projectId || undefined,
+                        source: memory.source || undefined,
+                        tier: memory.tier,
+                    });
+                }
+                console.log(JSON.stringify({ ok: true, message: `Memory ${memoryId} deleted` }, null, 2));
+                return;
+            }
+            // Bulk deletion
+            if (!options.olderThan && !options.search) {
+                console.log(JSON.stringify({ ok: false, error: 'Provide memory ID or use --older-than / --search for bulk delete' }, null, 2));
+                process.exit(1);
+            }
+            const query = options.search || '';
+            const limit = validateLimit(options.limit, 100, 1, 100);
+            const results = await search({ query, type: options.type, limit, project: options.project });
+            let filtered = results;
+            if (options.olderThan) {
+                filtered = filterByDateRange(results, '', options.olderThan);
+            }
+            const db = await getDb();
+            const schema = await getSchema();
+            const sqliteDb = db;
+            const deleted = [];
+            for (const mem of filtered) {
+                await sqliteDb.delete(schema.memories).where(eq(schema.memories.id, mem.id));
+                deleted.push(mem.id);
+            }
+            console.log(JSON.stringify({ ok: true, matched: filtered.length, deleted: deleted.length, dryRun: !options.confirm }, null, 2));
         }
         catch (error) {
             console.log(JSON.stringify({ ok: false, error: error.message }, null, 2));
             process.exit(1);
         }
     });
-    // squish core_memory view
-    // squish core_memory edit persona --content "I am helpful"
-    // squish core_memory append user_info --text "Prefers TypeScript"
+    // squish link - Unified graph operations (find related, add links, list associations)
     program
-        .command('core_memory')
-        .description('Manage core memory (always-visible context)')
-        .argument('[action]', 'view, edit, append', 'view')
-        .option('-s, --section <section>', 'Section: persona, user_info, project_context, working_notes')
-        .option('-c, --content <content>', 'New content (for edit)')
-        .option('-t, --text <text>', 'Text to append (for append)')
-        .option('-p, --project <project>', 'Project path', process.cwd())
-        .action(async (action, options) => {
+        .command('link')
+        .description('Manage memory associations: find, add, list')
+        .argument('<action>', 'Action: find, add, or list')
+        .argument('[args...]', 'Additional arguments')
+        .option('-p, --project <project>', 'Project path', getDefaultProjectPath())
+        .action(async (action, args, options) => {
         try {
-            const projectPath = options.project;
-            const projectRecord = await ensureProject(projectPath);
-            if (!projectRecord) {
-                console.log(JSON.stringify({ ok: false, error: 'Project not found and could not be created' }, null, 2));
-                process.exit(1);
+            // link find <memoryId> [--depth N] [--min-weight N]
+            if (action === 'find') {
+                const memoryId = args[0];
+                if (!memoryId) {
+                    console.log(JSON.stringify({ ok: false, error: 'Usage: squish link find <memoryId> [--depth N] [--min-weight N]' }, null, 2));
+                    process.exit(1);
+                }
+                const depth = validateLimit(args[1], 2, 1, 5);
+                const minWeight = parseFloat(args[2]) || 0.3;
+                const related = await getRelatedMemories(memoryId, depth * 5);
+                const filtered = related.filter((r) => r.weight >= minWeight);
+                console.log(JSON.stringify({ ok: true, count: filtered.length, related: filtered }, null, 2));
+                return;
             }
-            const projectId = projectRecord.id;
-            switch (action) {
-                case 'view':
-                    await initializeCoreMemory(projectId);
-                    const core = await getCoreMemory(projectId);
-                    const stats = await getCoreMemoryStats(projectId);
-                    console.log(JSON.stringify({ ok: true, action, content: core, stats }, null, 2));
-                    break;
-                case 'edit':
-                    if (!options.section || !options.content) {
-                        console.log(JSON.stringify({ ok: false, error: '--section and --content required for edit' }, null, 2));
-                        process.exit(1);
-                    }
-                    await initializeCoreMemory(projectId);
-                    const editResult = await editCoreMemorySection(projectId, options.section, String(options.content));
-                    console.log(JSON.stringify({ ok: editResult.success, action: 'edit', section: options.section, ...editResult }, null, 2));
-                    break;
-                case 'append':
-                    if (!options.section || !options.text) {
-                        console.log(JSON.stringify({ ok: false, error: '--section and --text required for append' }, null, 2));
-                        process.exit(1);
-                    }
-                    await initializeCoreMemory(projectId);
-                    const appendResult = await appendCoreMemorySection(projectId, options.section, String(options.text));
-                    console.log(JSON.stringify({ ok: appendResult.success, action: 'append', section: options.section, ...appendResult }, null, 2));
-                    break;
-                default:
-                    console.log(JSON.stringify({ ok: false, error: `Unknown action: ${action}` }, null, 2));
+            // link add <fromId> <toId> <type>
+            if (action === 'add') {
+                const fromMemoryId = args[0];
+                const toMemoryId = args[1];
+                const type = args[2] || 'relates_to';
+                if (!fromMemoryId || !toMemoryId) {
+                    console.log(JSON.stringify({ ok: false, error: 'Usage: squish link add <fromId> <toId> <type>' }, null, 2));
                     process.exit(1);
+                }
+                await createAssociation(fromMemoryId, toMemoryId, type, 0.5);
+                console.log(JSON.stringify({ ok: true, message: `Linked ${fromMemoryId} -> ${toMemoryId} (${type})` }, null, 2));
+                return;
             }
+            // link list - List all associations
+            if (action === 'list') {
+                const db = await getDb();
+                const schema = await getSchema();
+                const sqliteDb = db;
+                const associations = await sqliteDb.select().from(schema.memoryAssociations).limit(100);
+                console.log(JSON.stringify({ ok: true, count: associations.length, associations }, null, 2));
+                return;
+            }
+            console.log(JSON.stringify({ ok: false, error: 'Usage: squish link <find|add|list> [args]' }, null, 2));
         }
         catch (error) {
             console.log(JSON.stringify({ ok: false, error: error.message }, null, 2));
             process.exit(1);
         }
     });
-    // squish set-importance <memoryId> --importance 80
+    // squish learn <type> <content> - Record learning: success, failure, fix, or insight
     program
-        .command('set-importance <memoryId>')
-        .description('Manually set importance score for a memory (0-100)')
-        .option('-i, --importance <number>', 'Importance score (0-100)', '50')
-        .action(async (memoryId, options) => {
+        .command('learn <type> <content>')
+        .description('Record learning: success, failure, fix, or insight')
+        .option('-c, --context <context>', 'Additional context about what happened')
+        .option('-a, --action <action>', 'Action performed')
+        .option('-t, --target <target>', 'Target file or resource')
+        .option('-m, --memory-id <memoryId>', 'Optional memory ID to link this learning to')
+        .option('-p, --project <project>', 'Project path', getDefaultProjectPath())
+        .action(async (type, content, options) => {
         try {
-            const score = parseInt(options.importance, 10);
-            if (isNaN(score) || score < 0 || score > 100) {
-                console.log(JSON.stringify({ ok: false, error: 'Importance must be between 0 and 100' }, null, 2));
+            const validTypes = ['success', 'failure', 'fix', 'insight'];
+            if (!validTypes.includes(type)) {
+                console.log(JSON.stringify({ ok: false, error: `Invalid type. Must be: ${validTypes.join(', ')}` }, null, 2));
                 process.exit(1);
             }
-            await setImportanceScore(String(memoryId), score);
-            console.log(JSON.stringify({ ok: true, memoryId, importanceScore: score }, null, 2));
+            const learning = await createLearning({
+                type: type,
+                content,
+                context: options.context,
+                action: options.action,
+                target: options.target,
+                project: options.project,
+                memoryId: options.memoryId,
+            });
+            console.log(JSON.stringify({ ok: true, learning }, null, 2));
         }
         catch (error) {
             console.log(JSON.stringify({ ok: false, error: error.message }, null, 2));
             process.exit(1);
         }
     });
-    // squish pin <memoryId>
     program
-        .command('pin <memoryId>')
-        .description('Pin a memory to prevent pruning/consolidation')
-        .action(async (memoryId) => {
+        .command('update <memoryId>')
+        .description('Update a memory')
+        .option('-c, --content <content>', 'New content')
+        .option('-t, --type <type>', 'New type (observation, fact, decision, context, preference)')
+        .option('-T, --tags <tags>', 'Comma-separated tags')
+        .action(async (memoryId, options) => {
         try {
-            await pinMemory(String(memoryId));
-            console.log(JSON.stringify({ ok: true, memoryId, pinned: true }, null, 2));
+            const updates = {};
+            if (options.content)
+                updates.content = options.content;
+            if (options.type)
+                updates.type = options.type;
+            if (options.tags)
+                updates.tags = serializeTags(options.tags.split(','));
+            const db = await getDb();
+            const schema = await getSchema();
+            const sqliteDb = db;
+            // Get old memory for hook
+            const [oldMemory] = await sqliteDb.select().from(schema.memories).where(eq(schema.memories.id, memoryId));
+            await sqliteDb.update(schema.memories).set(updates).where(eq(schema.memories.id, memoryId));
+            // Trigger memoryUpdated hook
+            if (oldMemory) {
+                const { triggerMemoryUpdated } = await import('./core/memory/hooks.js');
+                const newContent = options.content || oldMemory.content;
+                await triggerMemoryUpdated({
+                    memoryId: oldMemory.id,
+                    content: newContent,
+                    type: options.type || oldMemory.type,
+                    tags: options.tags ? options.tags.split(',') : (typeof oldMemory.tags === 'string' ? oldMemory.tags.split(',') : []),
+                    project: oldMemory.projectId || undefined,
+                    source: oldMemory.source || undefined,
+                    tier: oldMemory.tier,
+                    importance: oldMemory.importanceScore || oldMemory.relevanceScore || 50,
+                }, oldMemory.content);
+            }
+            console.log(JSON.stringify({ ok: true, message: `Memory ${memoryId} updated` }, null, 2));
         }
         catch (error) {
             console.log(JSON.stringify({ ok: false, error: error.message }, null, 2));
             process.exit(1);
         }
     });
-    // squish unpin <memoryId>
+    // squish recall <query or memoryId> - Search or get by ID
     program
-        .command('unpin <memoryId>')
-        .description('Unpin a memory')
-        .action(async (memoryId) => {
+        .command('recall <query>')
+        .description('Search memories by query or get by ID (if UUID provided)')
+        .option('-l, --limit <number>', 'Max results', '5')
+        .option('-t, --type <type>', 'Filter by memory type')
+        .option('-p, --project <project>', 'Project path', getDefaultProjectPath())
+        .option('-s, --since <date>', 'Filter: created after this date (e.g., "3 days ago", "yesterday")')
+        .option('-u, --until <date>', 'Filter: created before this date (e.g., "today", "2026-01-15")')
+        .option('-P, --pretty', 'Human-friendly output', false)
+        .option('--place <type>', 'Filter by place type: entry_hall, library, workshop, lab, office, garden, archive')
+        .action(async (query, options) => {
         try {
-            await unpinMemory(String(memoryId));
-            console.log(JSON.stringify({ ok: true, memoryId, pinned: false }, null, 2));
+            const isUUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(query);
+            if (isUUID) {
+                const memory = await getMemory(query);
+                // Add place info to single memory retrieval
+                if (memory) {
+                    const { getMemoryPlace, getPlace } = await import('./core/places/index.js');
+                    const placeId = await getMemoryPlace(memory.id);
+                    if (placeId) {
+                        const place = await getPlace(placeId);
+                        memory.place = place?.name || null;
+                        memory.placeType = place?.placeType || null;
+                    }
+                }
+                if (options.pretty && memory) {
+                    const placeInfo = memory.place ? ` (${memory.place})` : '';
+                    console.log(`\n  Memory: ${memory.id}`);
+                    console.log(`  Type: ${memory.type}`);
+                    console.log(`  Content: ${memory.content}\n`);
+                    if (placeInfo)
+                        console.log(`  Place: ${memory.place}\n`);
+                }
+                else {
+                    console.log(JSON.stringify({ ok: true, found: !!memory, memory }, null, 2));
+                }
+            }
+            else {
+                const results = await search({
+                    query,
+                    type: options.type,
+                    limit: validateLimit(options.limit, 5, 1, 100) * 2,
+                    project: options.project,
+                });
+                const filtered = filterByDateRange(results, options.since, options.until);
+                let limited = filtered.slice(0, validateLimit(options.limit, 5, 1, 100));
+                // Add place info to results
+                const { getMemoryPlace, getPlace } = await import('./core/places/index.js');
+                const limitedWithPlace = await Promise.all(limited.map(async (r) => {
+                    const placeId = await getMemoryPlace(r.id);
+                    let placeInfo = {};
+                    if (placeId) {
+                        const place = await getPlace(placeId);
+                        placeInfo = { place: place?.name || null, placeType: place?.placeType || null };
+                    }
+                    return { ...r, ...placeInfo };
+                }));
+                // Filter by place if specified
+                if (options.place) {
+                    limited = limitedWithPlace.filter((r) => r.placeType === options.place);
+                }
+                else {
+                    limited = limitedWithPlace;
+                }
+                if (options.pretty) {
+                    console.log(`\n  Recall: "${query}"`);
+                    console.log(`  Found ${limited.length} matches:\n`);
+                    limited.forEach((r, i) => {
+                        const placeTag = r.place ? ` (${r.place})` : '';
+                        console.log(`  ${i + 1}. [${r.type || 'memory'}] ${(r.content || '').substring(0, 60)}...${placeTag} (${(r.similarity ?? 0).toFixed(2)})`);
+                    });
+                    console.log('');
+                }
+                else {
+                    const matches = limited.map((r) => ({
+                        id: r.id,
+                        score: r.similarity ?? 0,
+                        type: r.type,
+                        content: r.content.length > 200 ? r.content.slice(0, 200) + '...' : r.content,
+                        tags: r.tags,
+                        place: r.place,
+                        placeType: r.placeType,
+                    }));
+                    console.log(JSON.stringify({ ok: true, query, count: matches.length, since: options.since, until: options.until, placeFilter: options.place || null, matches }, null, 2));
+                }
+            }
         }
         catch (error) {
             console.log(JSON.stringify({ ok: false, error: error.message }, null, 2));
             process.exit(1);
         }
     });
-    // squish consolidate --project-id <id> --min-age 90
+    // squish recent --period <period> - Show recent memories
     program
-        .command('consolidate')
-        .description('Trigger manual memory consolidation')
-        .option('-p, --project-id <id>', 'Project ID', process.cwd())
-        .option('-a, --min-age <number>', 'Minimum age in days', '90')
-        .option('-i, --max-importance <number>', 'Maximum importance to consolidate', '30')
-        .option('-t, --threshold <number>', 'Similarity threshold (0-1)', '0.7')
-        .option('-l, --limit <number>', 'Max memories to process', '100')
+        .command('recent')
+        .description('Show recent memories by period')
+        .option('-p, --period <period>', 'Period: today, yesterday, thisweek, 7days, 30days, or custom like "3 days"', 'today')
+        .option('-s, --since <date>', 'Start date (alternative to --period)')
+        .option('-u, --until <date>', 'End date (alternative to --period)')
+        .option('-l, --limit <number>', 'Max results', '10')
+        .option('-P, --project <project>', 'Project path', getDefaultProjectPath())
         .action(async (options) => {
         try {
-            const results = await consolidateMemoriesImpl({
-                projectId: String(options.projectId),
-                minAge: parseInt(options.minAge, 10),
-                maxImportance: parseInt(options.maxImportance, 10),
-                similarityThreshold: parseFloat(options.threshold),
-                limit: parseInt(options.limit, 10),
-            });
-            console.log(JSON.stringify({ ok: true, consolidated: results.length, results }, null, 2));
+            let since, until;
+            if (options.since && options.until) {
+                since = options.since;
+                until = options.until;
+            }
+            else if (options.since) {
+                since = options.since;
+                until = 'now';
+            }
+            else {
+                const periodMap = {
+                    today: ['today', 'now'],
+                    yesterday: ['yesterday', 'today'],
+                    thisweek: ['thisweek', 'now'],
+                    '7days': ['7 days', 'now'],
+                    '14days': ['14 days', 'now'],
+                    '30days': ['30 days', 'now'],
+                    '90days': ['90 days', 'now'],
+                };
+                const mapped = periodMap[options.period];
+                if (mapped) {
+                    [since, until] = mapped;
+                }
+                else {
+                    since = options.period;
+                    until = 'now';
+                }
+            }
+            const results = await getRecent(options.project, 100);
+            const filtered = filterByDateRange(results, since, until);
+            const limited = filtered.slice(0, validateLimit(options.limit, 10, 1, 100));
+            console.log(JSON.stringify({ ok: true, period: options.period, since, until, count: limited.length, results: limited }, null, 2));
         }
         catch (error) {
             console.log(JSON.stringify({ ok: false, error: error.message }, null, 2));
             process.exit(1);
         }
     });
-    // squish consolidation-stats --project-id <id>
+    // squish confidence <memoryId> [level] - Set or view confidence level
     program
-        .command('consolidation-stats')
-        .description('Get consolidation statistics for a project')
-        .option('-p, --project-id <id>', 'Project ID', process.cwd())
-        .action(async (options) => {
+        .command('confidence <memoryId> [level]')
+        .description('Set or view confidence level (certain/speculative/outdated)')
+        .action(async (memoryId, level) => {
         try {
-            const stats = await getConsolidationStats(String(options.projectId));
-            console.log(JSON.stringify({ ok: true, ...stats }, null, 2));
+            if (!level) {
+                const memory = await getMemory(String(memoryId));
+                if (!memory) {
+                    console.log(JSON.stringify({ ok: false, error: 'Memory not found' }, null, 2));
+                    process.exit(1);
+                }
+                console.log(JSON.stringify({ ok: true, memoryId, confidenceLevel: memory.confidenceLevel ?? 'certain' }, null, 2));
+            }
+            else {
+                const validLevels = ['certain', 'speculative', 'outdated'];
+                if (!validLevels.includes(level)) {
+                    console.log(JSON.stringify({ ok: false, error: 'Invalid level. Use: certain, speculative, or outdated' }, null, 2));
+                    process.exit(1);
+                }
+                await setConfidence(String(memoryId), level);
+                console.log(JSON.stringify({ ok: true, memoryId, confidenceLevel: level }, null, 2));
+            }
         }
         catch (error) {
             console.log(JSON.stringify({ ok: false, error: error.message }, null, 2));
             process.exit(1);
         }
     });
-    // squish health
+    // squish pin <memoryId> [--unpin]
     program
-        .command('health')
-        .description('Check service health and configuration')
-        .option('-j, --json', 'Output as JSON', false)
-        .action(async (options) => {
+        .command('pin <memoryId>')
+        .description('Pin/unpin a memory to prevent pruning/consolidation')
+        .option('-u, --unpin', 'Unpin the memory instead of pinning', false)
+        .action(async (memoryId, options) => {
         try {
-            const dbHealth = await checkDatabaseHealth();
-            const redisHealth = await checkRedisHealth();
-            const dataDir = process.env.SQUISH_DATA_DIR || path.join(os.homedir(), '.squish');
-            const dirExists = fs.existsSync(dataDir);
-            const status = {
-                version: VERSION,
-                mode: config.isTeamMode ? 'team' : 'local',
-                database: dbHealth ? 'ok' : 'error',
-                cache: redisHealth ? 'ok' : 'unavailable',
-                dataDirectory: dataDir,
-                dataDirectoryExists: dirExists,
-                timestamp: new Date().toISOString()
-            };
-            if (options.json) {
-                console.log(JSON.stringify({ ok: true, ...status }, null, 2));
+            if (options.unpin) {
+                await unpinMemory(String(memoryId));
+                console.log(JSON.stringify({ ok: true, memoryId, pinned: false }, null, 2));
             }
             else {
-                console.log(`\n  Squish Memory v${VERSION}`);
-                console.log(`  ====================`);
-                console.log(`  Mode:     ${status.mode}`);
-                console.log(`  Database: ${status.database}`);
-                console.log(`  Cache:    ${status.cache}`);
-                console.log(`  Data Dir: ${status.dataDirectory}`);
-                console.log(`  Status:   ${dbHealth ? 'HEALTHY' : 'UNHEALTHY'}\n`);
-            }
-            if (!dbHealth) {
+                await pinMemory(String(memoryId));
+                console.log(JSON.stringify({ ok: true, memoryId, pinned: true }, null, 2));
+            }
+        }
+        catch (error) {
+            console.log(JSON.stringify({ ok: false, error: error.message }, null, 2));
+            process.exit(1);
+        }
+    });
+    // squish tag add <tag> --search <query> --confirm
+    // squish tag remove <tag> --older-than "30 days" --confirm
+    program
+        .command('tag')
+        .description('Manage tags on memories (bulk)')
+        .argument('<action>', 'add or remove')
+        .argument('<tag>', 'Tag name')
+        .option('-s, --search <query>', 'Search query to match memories')
+        .option('-o, --older-than <date>', 'Only tag memories older than (e.g., "30 days")')
+        .option('-t, --type <type>', 'Filter by memory type')
+        .option('-c, --confirm', 'Actually execute the changes (default is dry-run)', false)
+        .option('-l, --limit <number>', 'Max memories to process', '50')
+        .option('-p, --project <project>', 'Project path', getDefaultProjectPath())
+        .action(async (action, tag, options) => {
+        try {
+            if (!options.search && !options.olderThan) {
+                console.log(JSON.stringify({ ok: false, error: 'Provide --search <query> or --older-than <date>' }, null, 2));
+                process.exit(1);
+            }
+            const limit = validateLimit(options.limit, 50, 1, 100);
+            let results;
+            const searchInput = { query: options.search, limit, project: options.project };
+            if (options.type)
+                searchInput.type = options.type;
+            if (options.search) {
+                results = await search(searchInput);
+            }
+            else {
+                results = await getRecent(options.project, limit * 2);
+            }
+            let filtered = results;
+            if (options.olderThan) {
+                filtered = filterByDateRange(results, '', options.olderThan);
+            }
+            const db = await getDb();
+            const schema = await getSchema();
+            if (action === 'add') {
+                const updated = [];
+                for (const mem of filtered) {
+                    try {
+                        const tags = new Set((mem.tags || []));
+                        if (!tags.has(tag)) {
+                            tags.add(tag);
+                            await db.update(schema.memories)
+                                .set({ tags: serializeTags(Array.from(tags)), updatedAt: new Date() })
+                                .where(eq(schema.memories.id, mem.id));
+                            updated.push(mem.id);
+                        }
+                    }
+                    catch (e) {
+                        console.error('DEBUG: error updating', mem.id, e.message);
+                        throw e;
+                    }
+                }
+                console.log(JSON.stringify({ ok: true, action: 'add', tag, matched: filtered.length, updated: updated.length, dryRun: !options.confirm }, null, 2));
+            }
+            else if (action === 'remove') {
+                const updated = [];
+                for (const mem of filtered) {
+                    const tags = new Set((mem.tags || []));
+                    if (tags.has(tag)) {
+                        tags.delete(tag);
+                        await db.update(schema.memories)
+                            .set({ tags: serializeTags(Array.from(tags)), updatedAt: new Date() })
+                            .where(eq(schema.memories.id, mem.id));
+                        updated.push(mem.id);
+                    }
+                }
+                console.log(JSON.stringify({ ok: true, action: 'remove', tag, matched: filtered.length, updated: updated.length, dryRun: !options.confirm }, null, 2));
+            }
+            else {
+                console.log(JSON.stringify({ ok: false, error: 'Use: squish tag add <tag> or squish tag remove <tag>' }, null, 2));
                 process.exit(1);
             }
         }
@@ -362,13 +1154,62 @@ async function runCliMode() {
             process.exit(1);
         }
     });
+    // squish stale --days 30 - Show old, low-confidence, unaccessed memories
+    program
+        .command('stale')
+        .description('Show stale memories (old, low-confidence, or rarely accessed)')
+        .option('-d, --days <number>', 'Show memories older than N days', '30')
+        .option('-c, --confidence <level>', 'Max confidence level to show (outdated, speculative)', 'speculative')
+        .option('-l, --limit <number>', 'Max results', '20')
+        .option('-p, --project <project>', 'Project path', getDefaultProjectPath())
+        .action(async (options) => {
+        try {
+            const days = validateLimit(options.days, 30, 1, 365);
+            const cutoffDate = new Date(Date.now() - days * 86400000);
+            // Get recent memories - larger limit to find stale ones
+            const results = await getRecent(options.project, 500);
+            const stale = results.filter((m) => {
+                const created = m.createdAt ? new Date(m.createdAt) : null;
+                const isOld = created && created < cutoffDate;
+                const isLowConfidence = m.confidenceLevel === 'outdated' || m.confidenceLevel === 'speculative';
+                const hasLowImportance = (m.importance || 50) < 40;
+                return isOld || isLowConfidence || hasLowImportance;
+            });
+            const limited = stale.slice(0, validateLimit(options.limit, 20, 1, 100));
+            const summary = {
+                totalStale: stale.length,
+                old: stale.filter((m) => m.createdAt && new Date(m.createdAt) < cutoffDate).length,
+                lowConfidence: stale.filter((m) => m.confidenceLevel === 'outdated' || m.confidenceLevel === 'speculative').length,
+                lowImportance: stale.filter((m) => (m.importance || 50) < 40).length,
+            };
+            console.log(JSON.stringify({ ok: true, summary, memories: limited }, null, 2));
+        }
+        catch (error) {
+            console.log(JSON.stringify({ ok: false, error: error.message }, null, 2));
+            process.exit(1);
+        }
+    });
     // squish stats
     program
         .command('stats')
-        .description('Get memory statistics')
-        .option('-p, --project <project>', 'Project path', process.cwd())
+        .description('View statistics')
+        .option('-p, --project <project>', 'Project path', getDefaultProjectPath())
+        .option('-m, --memory', 'Show memory file storage stats instead of database', false)
         .action(async (options) => {
         try {
+            // Memory file stats
+            if (options.memory) {
+                const { getMemoryStats, isMemoryStorageAvailable } = await import('./core/memory/markdown/markdown-storage.js');
+                const available = isMemoryStorageAvailable();
+                if (!available) {
+                    console.log(JSON.stringify({ ok: false, error: 'Memory file storage not available' }, null, 2));
+                    process.exit(1);
+                }
+                const stats = await getMemoryStats();
+                console.log(JSON.stringify({ ok: true, source: 'memory', ...stats }, null, 2));
+                return;
+            }
+            // Database stats
             const stats = await getMemoryStats(options.project);
             console.log(JSON.stringify({ ok: true, ...stats }, null, 2));
         }
@@ -377,475 +1218,460 @@ async function runCliMode() {
             process.exit(1);
         }
     });
-    // squish install (for OpenClaw self-install)
+    // squish install
     program
         .command('install')
-        .description('Install Squish for OpenClaw (self-configure MCP)')
-        .option('-o, --openclaw-dir <dir>', 'OpenClaw directory')
-        .option('-n, --dry-run', 'Show what would be done without making changes', false)
-        .option('--skip-install', 'Skip global npm install step', false)
-        .action(async (options) => {
-        // Find the install script - it's in scripts/ relative to the package root
-        // When running from dist/index.js, scripts is at ../scripts/
-        const distDir = path.dirname(fileURLToPath(import.meta.url));
-        const packageDir = path.dirname(distDir);
-        const installScript = path.join(packageDir, 'scripts', 'install.mjs');
-        // Check if the script exists
-        if (!fs.existsSync(installScript)) {
-            console.log(JSON.stringify({
-                ok: false,
-                error: `Install script not found at: ${installScript}`,
-                hint: 'Please ensure squish-memory is installed correctly'
-            }, null, 2));
-            process.exit(1);
+        .description('Run the interactive installer wizard')
+        .action(async () => {
+        await spawnInstallerWizard();
+    });
+    // squish note "my thought here" - quick brain dump
+    program
+        .command('note <content>')
+        .description('Quick brain dump - store a raw memory to process later')
+        .option('-p, --project <project>', 'Project path', getDefaultProjectPath())
+        .action(async (content, options) => {
+        try {
+            const result = await rememberMemory({
+                content,
+                type: 'observation',
+                tags: ['note', 'quick'],
+                project: options.project,
+            });
+            console.log(JSON.stringify({ ok: true, message: 'Note saved', id: result.id }, null, 2));
         }
-        // Build command with quoted path for Windows compatibility
-        const args = [`"${installScript}"`];
-        if (options.dryRun)
-            args.push('--dry-run');
-        if (options.openclawDir)
-            args.push('--openclaw-dir', `"${options.openclawDir}"`);
-        if (options.skipInstall)
-            args.push('--skip-install');
-        const result = spawnSync('node', args, {
-            stdio: 'inherit',
-            shell: true,
-            cwd: packageDir
-        });
-        if (result.status !== 0) {
-            process.exit(result.status || 1);
+        catch (error) {
+            console.log(JSON.stringify({ ok: false, error: error.message }, null, 2));
+            process.exit(1);
         }
     });
-    await program.parseAsync(process.argv);
-}
-// ============================================================================
-// MCP MODE (for Claude Code) - DEFAULT
-// ============================================================================
-async function runMcpMode() {
-    const TOOLS = [
-        // Core Memory Tool
-        {
-            name: 'core_memory',
-            description: 'View or edit your core memory (always-visible). Use this to see your persona, user info, project context, and working notes.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    action: { type: 'string', enum: ['view', 'edit', 'append'] },
-                    projectId: { type: 'string' },
-                    section: { type: 'string', enum: ['persona', 'user_info', 'project_context', 'working_notes'] },
-                    content: { type: 'string' },
-                    text: { type: 'string' },
-                },
-                required: ['action', 'projectId']
-            }
-        },
-        // Context Paging
-        {
-            name: 'context_paging',
-            description: 'Manage your working memory set. Load, evict, or view loaded memories.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    action: { type: 'string', enum: ['load', 'evict', 'view'] },
-                    sessionId: { type: 'string' },
-                    memoryId: { type: 'string' },
-                },
-                required: ['action', 'sessionId']
-            }
-        },
-        {
-            name: 'context_status',
-            description: 'View comprehensive context window status and token usage',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    sessionId: { type: 'string' },
-                    projectId: { type: 'string' },
-                },
-                required: ['sessionId', 'projectId']
-            }
-        },
-        // Memory Tools
-        {
-            name: 'remember',
-            description: 'Store information for future use. Perfect for facts, decisions, code snippets, configuration details, or user preferences.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    content: { type: 'string' },
-                    type: { type: 'string', enum: ['observation', 'fact', 'decision', 'context', 'preference'] },
-                    tags: { type: 'array', items: { type: 'string' } },
-                    project: { type: 'string' },
-                    metadata: { type: 'object' },
-                },
-                required: ['content']
-            }
-        },
-        {
-            name: 'recall',
-            description: 'Retrieve a specific stored memory by ID',
-            inputSchema: {
-                type: 'object',
-                properties: { id: { type: 'string' } },
-                required: ['id']
-            }
-        },
-        {
-            name: 'search',
-            description: 'Search your stored memories. Leave query empty to list recent memories.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    query: { type: 'string' },
-                    scope: { type: 'string', enum: ['memories', 'conversations', 'recent'], default: 'memories' },
-                    type: { type: 'string', enum: ['observation', 'fact', 'decision', 'context', 'preference'] },
-                    tags: { type: 'array', items: { type: 'string' } },
-                    limit: { type: 'number', default: 10 },
-                    project: { type: 'string' },
-                }
-            }
-        },
-        {
-            name: 'observe',
-            description: 'Record an observation about your work (tool usage, patterns, errors)',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    type: { type: 'string', enum: ['tool_use', 'file_change', 'error', 'pattern', 'insight'] },
-                    action: { type: 'string' },
-                    target: { type: 'string' },
-                    summary: { type: 'string' },
-                    details: { type: 'object' },
-                },
-                required: ['type', 'action', 'summary']
-            }
-        },
-        {
-            name: 'context',
-            description: 'Get project context',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    project: { type: 'string' },
-                    include: { type: 'array', items: { type: 'string' }, default: ['memories', 'observations'] },
-                    limit: { type: 'number', default: 10 }
-                },
-                required: ['project']
-            }
-        },
-        {
-            name: 'init',
-            description: 'Initialize Squish memory system for the current project',
-            inputSchema: {
-                type: 'object',
-                properties: { projectPath: { type: 'string' } }
-            }
-        },
-        {
-            name: 'health',
-            description: 'Check service status',
-            inputSchema: { type: 'object', properties: {} }
-        },
-        {
-            name: 'merge',
-            description: 'Manage memory merges: detect, list, preview, approve, reject, reverse',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    action: { type: 'string', enum: ['detect', 'list', 'preview', 'stats', 'approve', 'reject', 'reverse'] },
-                    projectId: { type: 'string' },
-                    proposalId: { type: 'string' },
-                    threshold: { type: 'number' },
-                },
-                required: ['action']
-            }
-        },
-        {
-            name: 'qmd_search',
-            description: 'Search memories using QMD hybrid search (BM25 + vector + rerank)',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    query: { type: 'string' },
-                    type: { type: 'string', enum: ['observation', 'fact', 'decision', 'context', 'preference'] },
-                    limit: { type: 'number', default: 10 },
-                },
-                required: ['query']
-            }
-        },
-        // v0.8.0: Importance Scoring Tools
-        {
-            name: 'set_importance',
-            description: 'Manually set importance score for a memory (0-100)',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    memoryId: { type: 'string' },
-                    importance: { type: 'number', minimum: 0, maximum: 100 },
-                },
-                required: ['memoryId', 'importance']
-            }
-        },
-        {
-            name: 'pin_memory',
-            description: 'Pin a memory to prevent pruning/consolidation (or unpin it)',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    memoryId: { type: 'string' },
-                    pinned: { type: 'boolean', default: true },
-                },
-                required: ['memoryId']
-            }
-        },
-        // v0.8.0: Consolidation Tool
-        {
-            name: 'consolidate',
-            description: 'Trigger manual memory consolidation - summarizes old, low-importance memories',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    projectId: { type: 'string' },
-                    threshold: { type: 'number', default: 0.7 },
-                    minAge: { type: 'number', default: 90 },
-                    limit: { type: 'number', default: 100 },
-                },
-                required: ['projectId']
-            }
-        },
-        {
-            name: 'consolidation_stats',
-            description: 'Get consolidation statistics for a project',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    projectId: { type: 'string' },
-                },
-                required: ['projectId']
+    // squish context - Show project context (memories + observations + places)
+    program
+        .command('context')
+        .description('Show project context or list available projects')
+        .option('-p, --project <project>', 'Project path', getDefaultProjectPath())
+        .option('-l, --limit <number>', 'Number of items to show', '10')
+        .option('-i, --include <items>', 'What to include: memories, observations, entities, places', 'memories,observations,places')
+        .option('--list-projects', 'List registered projects instead of loading context', false)
+        .option('-j, --json', 'Output as JSON', false)
+        .option('--place <type>', 'Filter by place type: entry_hall, library, workshop, lab, office, garden, archive')
+        .option('--tier <level>', 'Disclosure level: quick (place names), medium (top 3), full (all)', 'medium')
+        .option('--has-memories', 'Only show places with memories', true)
+        .option('--sync', 'Recalculate memory counts for all places', false)
+        .option('--archive', 'Move memories > 30 days to Archive place', false)
+        .option('--task <description>', 'Task description for auto-place detection (e.g., "fix bug", "design API")')
+        .action(async (options) => {
+        try {
+            // Auto-detect place from task if provided
+            let placeFilter = options.place || null;
+            if (options.task && !placeFilter) {
+                // Simple keyword detection
+                const task = options.task.toLowerCase();
+                if (task.includes('fix') || task.includes('bug') || task.includes('error'))
+                    placeFilter = 'workshop';
+                else if (task.includes('design') || task.includes('plan') || task.includes('api'))
+                    placeFilter = 'library';
+                else if (task.includes('task') || task.includes('todo') || task.includes('manage'))
+                    placeFilter = 'office';
+                else if (task.includes('test') || task.includes('experiment'))
+                    placeFilter = 'lab';
+                if (placeFilter)
+                    console.log(`Auto-detected place: ${placeFilter}`);
             }
-        }
-    ];
-    class Squish {
-        server;
-        projectPath;
-        constructor() {
-            this.projectPath = process.env.CLAUDE_WORKING_DIRECTORY || process.cwd();
-            this.server = new Server({ name: 'squish', version: VERSION }, {
-                capabilities: { tools: {} },
-            });
-            this.setup();
-        }
-        async onSessionInitialized() {
-            if (!shouldAutoLoad()) {
-                logger.info('[Session] Auto-load disabled');
+            if (options.listProjects) {
+                const projects = await getAllProjects();
+                if (options.json) {
+                    console.log(JSON.stringify({ ok: true, count: projects.length, projects }, null, 2));
+                }
+                else {
+                    console.log(`\n Registered Projects (${projects.length})`);
+                    console.log(` ================================`);
+                    for (const project of projects) {
+                        console.log(`\n ${project.name}`);
+                        console.log(`   Path: ${project.path}`);
+                        console.log(`   ID: ${project.id}`);
+                    }
+                    console.log('');
+                }
                 return;
             }
-            try {
-                logger.info('[Session] Performing auto-load...');
-                const result = await performAutoLoad(this.projectPath, getAutoLoadConfig());
-                if (result.warnings.length > 0) {
-                    logger.warn('[Session] Auto-load warnings:', result.warnings);
-                }
-                logger.info(`[Session] Auto-load complete: ${result.memoriesLoaded} memories, ~${result.tokensUsed} tokens`);
+            // Get project context
+            const projectPath = resolveProjectPath(options.project);
+            await ensureProject(projectPath);
+            const project = await getOrCreateProject(projectPath);
+            if (!project) {
+                console.log(JSON.stringify({ ok: false, error: 'Project not found' }, null, 2));
+                process.exit(1);
             }
-            catch (error) {
-                logger.error('[Session] Auto-load failed:', error);
+            const limit = parseInt(options.limit);
+            const include = (options.include || 'memories,observations,places').split(',');
+            const tier = options.tier || 'full';
+            const hasMemoriesOnly = options.hasMemories !== false; // Default true now
+            const existingPlaceFilter = options.place || null;
+            const result = { project: project.name, tier };
+            // Get memories
+            if (include.includes('memories')) {
+                const memories = await getRecent(projectPath, limit);
+                result.memories = memories.map((m) => ({
+                    id: m.id,
+                    type: m.type,
+                    content: m.content?.substring(0, 100),
+                    tags: m.tags,
+                }));
             }
-        }
-        setup() {
-            this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-                tools: TOOLS
-            }));
-            this.server.setRequestHandler(CallToolRequestSchema, async (req) => {
-                const { name } = req.params;
-                const args = (req.params.arguments ?? {});
-                try {
-                    switch (name) {
-                        case 'core_memory':
-                            return await this.handleCoreMemory(args);
-                        case 'context_paging':
-                            return await this.handleContextPaging(args);
-                        case 'context_status': {
-                            const result = await getContextStatus(String(args.sessionId), String(args.projectId));
-                            return this.jsonResponse({ ok: true, ...result });
-                        }
-                        case 'remember': {
-                            return this.jsonResponse({ ok: true, data: await rememberMemory(args) });
-                        }
-                        case 'recall': {
-                            const memory = await getMemoryById(String(args.id));
-                            return this.jsonResponse({ ok: true, found: !!memory, data: memory });
-                        }
-                        case 'search': {
-                            return this.jsonResponse({ ok: true, data: await searchMemories(args) });
-                        }
-                        case 'observe':
-                            return this.jsonResponse({ ok: true, data: await createObservation(args) });
-                        case 'context':
-                            return this.jsonResponse({ ok: true, data: await getProjectContext(args) });
-                        case 'init': {
-                            await ensureDataDirectory();
-                            const project = await ensureProject(args.projectPath || process.cwd());
-                            return this.jsonResponse({ success: true, project });
-                        }
-                        case 'health':
-                            return this.health();
-                        case 'merge':
-                            return await this.handleMerge(args);
-                        case 'qmd_search': {
-                            const available = await isQMDAvailable();
-                            if (!available) {
-                                return this.jsonResponse({ ok: true, qmdAvailable: false, data: await searchMemories(args) });
-                            }
-                            return this.jsonResponse({ ok: true, qmdAvailable: true, data: await searchWithQMD(args) });
-                        }
-                        // v0.8.0: Importance scoring tools
-                        case 'set_importance': {
-                            await setImportanceScore(String(args.memoryId), Number(args.importance));
-                            return this.jsonResponse({
-                                ok: true,
-                                message: `Importance score set to ${args.importance} for memory ${args.memoryId}`
+            // Get observations (learnings)
+            if (include.includes('observations')) {
+                const { getObservations } = await import('./core/ingestion/learnings.js');
+                const observations = await getObservations(projectPath, limit);
+                result.observations = observations.map((o) => ({
+                    id: o.id,
+                    type: o.type,
+                    content: o.content?.substring(0, 100),
+                }));
+            }
+            // Get places (spatial memory) with filtering
+            if (include.includes('places')) {
+                const { initializeDefaultPlaces, getProjectPlaces, walkPlace, getPlaceByType, syncAllPlaceMemoryCounts } = await import('./core/places/index.js');
+                await initializeDefaultPlaces(project.id);
+                // Sync memory counts if requested
+                if (options.sync) {
+                    await syncAllPlaceMemoryCounts(project.id);
+                    console.log('Synced memory counts for all places.');
+                }
+                // Auto-archive old memories if requested
+                if (options.archive) {
+                    const { autoArchiveOldMemories } = await import('./core/places/index.js');
+                    const archiveResult = await autoArchiveOldMemories(project.id, 30);
+                    console.log(`Archived ${archiveResult.archived} old memories to Archive (${archiveResult.failed} failed).`);
+                }
+                let places = await getProjectPlaces(project.id);
+                // Apply --has-memories filter
+                if (hasMemoriesOnly) {
+                    places = places.filter((p) => p.memoryCount > 0);
+                }
+                // Apply --place filter (from --place or --task auto-detect)
+                if (placeFilter) {
+                    const filtered = places.filter((p) => p.placeType === placeFilter);
+                    if (filtered.length > 0) {
+                        places = filtered;
+                    }
+                }
+                // Format places based on tier
+                if (tier === 'quick') {
+                    // Just place names (~50 tokens)
+                    result.places = places.map((p) => ({
+                        name: p.name,
+                        type: p.placeType,
+                    }));
+                }
+                else if (tier === 'medium') {
+                    // Top 3 memories per place (~170 tokens)
+                    const placesWithMemories = [];
+                    for (const p of places) {
+                        if (p.memoryCount > 0) {
+                            const walkResult = await walkPlace(project.id, p.placeType, {
+                                tokenBudget: 170,
+                                maxMemoriesPerPlace: 3,
+                                compressWithToon: false,
                             });
-                        }
-                        case 'pin_memory': {
-                            const pinned = args.pinned !== undefined ? Boolean(args.pinned) : true;
-                            if (pinned) {
-                                await pinMemory(String(args.memoryId));
-                            }
-                            else {
-                                await unpinMemory(String(args.memoryId));
-                            }
-                            return this.jsonResponse({
-                                ok: true,
-                                message: `Memory ${args.memoryId} ${pinned ? 'pinned' : 'unpinned'}`
+                            placesWithMemories.push({
+                                name: p.name,
+                                type: p.placeType,
+                                purpose: p.purpose,
+                                memories: p.memoryCount,
+                                preview: walkResult?.memories.slice(0, 3).map((m) => m.content?.substring(0, 80)) || [],
                             });
                         }
-                        // v0.8.0: Consolidation tools
-                        case 'consolidate': {
-                            const results = await consolidateMemoriesImpl({
-                                projectId: String(args.projectId),
-                                minAge: args.minAge ? Number(args.minAge) : 90,
-                                maxImportance: 30,
-                                similarityThreshold: args.threshold ? Number(args.threshold) : 0.7,
-                                limit: args.limit ? Number(args.limit) : 100,
-                            });
-                            return this.jsonResponse({
-                                ok: true,
-                                consolidated: results.length,
-                                results
-                            });
+                    }
+                    result.places = placesWithMemories;
+                }
+                else {
+                    // Full - all memories (~500 tokens)
+                    result.places = places.map((p) => ({
+                        name: p.name,
+                        type: p.placeType,
+                        purpose: p.purpose,
+                        memories: p.memoryCount,
+                    }));
+                }
+            }
+            if (options.json) {
+                console.log(JSON.stringify({ ok: true, ...result }, null, 2));
+            }
+            else {
+                // Human readable output
+                console.log(`\n=== ${project.name} Context ===\n`);
+                if (result.places && result.places.length > 0) {
+                    console.log('Spatial Memory Places:');
+                    result.places.forEach((p) => {
+                        if (tier === 'quick') {
+                            console.log(`  ${p.name} (${p.type})`);
+                        }
+                        else if (tier === 'medium') {
+                            console.log(`  ${p.name} (${p.memories} memories) - ${p.purpose}`);
+                            if (p.preview && p.preview.length > 0) {
+                                p.preview.forEach((m) => {
+                                    console.log(`    - ${m}...`);
+                                });
+                            }
                         }
-                        case 'consolidation_stats': {
-                            const stats = await getConsolidationStats(String(args.projectId));
-                            return this.jsonResponse({ ok: true, ...stats });
+                        else {
+                            console.log(`  ${p.name} (${p.memories} memories) - ${p.purpose}`);
                         }
-                        default:
-                            throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                    }
+                    });
+                    console.log('');
                 }
-                catch (error) {
-                    if (error instanceof McpError)
-                        throw error;
-                    throw new McpError(ErrorCode.InternalError, `Tool '${name}' failed`);
+                if (result.memories && result.memories.length > 0) {
+                    console.log('Recent Memories:');
+                    result.memories.slice(0, 5).forEach((m) => {
+                        console.log(`  [${m.type}] ${m.content}`);
+                    });
+                    console.log('');
                 }
+            }
+        }
+        catch (error) {
+            console.log(JSON.stringify({ ok: false, error: error.message }, null, 2));
+            process.exit(1);
+        }
+    });
+    // squish migrate - Migrate memories between databases
+    program
+        .command('migrate')
+        .description('Migrate memories from one .squish directory to another')
+        .option('-f, --from <path>', 'Source .squish directory (read from)', '')
+        .option('-t, --to <path>', 'Target .squish directory (write to)', '')
+        .option('--delete-source', 'Delete source after migration (use with caution)', false)
+        .option('--dry-run', 'Preview migration without applying', false)
+        .action(async (options) => {
+        try {
+            if (!options.from || !options.to) {
+                console.log(JSON.stringify({
+                    ok: false,
+                    error: 'Usage: squish migrate --from /path/to/old/.squish --to /path/to/new/.squish'
+                }, null, 2));
+                process.exit(1);
+            }
+            const sourcePath = path.join(options.from, 'squish.db');
+            const targetPath = path.join(options.to, 'squish.db');
+            if (!existsSync(sourcePath)) {
+                console.log(JSON.stringify({ ok: false, error: `Source database not found: ${sourcePath}` }, null, 2));
+                process.exit(1);
+            }
+            if (!existsSync(targetPath)) {
+                console.log(JSON.stringify({ ok: false, error: `Target database not found: ${targetPath}` }, null, 2));
+                process.exit(1);
+            }
+            console.log(`Migrating memories from:\n  ${options.from}\nto:\n  ${options.to}\n`);
+            // Import database modules dynamically
+            const { migrateMemories } = await import('./core/memory/migrate.js');
+            const result = await migrateMemories(options.from, options.to, {
+                dryRun: options.dryRun,
+                deleteSource: options.deleteSource
             });
-            this.server.onerror = (e) => logger.error('MCP Server error', e);
-            process.on('SIGINT', () => this.shutdown());
-            process.on('SIGTERM', () => this.shutdown());
+            console.log(JSON.stringify({ ok: true, ...result }, null, 2));
         }
-        jsonResponse(payload) {
-            return {
-                content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }]
-            };
+        catch (error) {
+            console.log(JSON.stringify({ ok: false, error: error.message }, null, 2));
+            process.exit(1);
         }
-        async handleCoreMemory(args) {
-            const action = args.action;
-            const projectId = String(args.projectId);
-            await initializeCoreMemory(projectId);
-            const actions = {
-                view: async () => {
-                    const content = await getCoreMemory(projectId);
-                    const stats = await getCoreMemoryStats(projectId);
-                    return this.jsonResponse({ ok: true, action: 'view', content, stats });
-                },
-                edit: async () => {
-                    const result = await editCoreMemorySection(projectId, args.section, String(args.content));
-                    return this.jsonResponse({ ok: true, action: 'edit', ...result });
-                },
-                append: async () => {
-                    const result = await appendCoreMemorySection(projectId, args.section, String(args.text));
-                    return this.jsonResponse({ ok: true, action: 'append', ...result });
+    });
+    // squish clean - Run deduplication and consolidation
+    program
+        .command('clean')
+        .description('Run maintenance: deduplication + consolidation')
+        .option('-t, --threshold <number>', 'Similarity threshold for dedup (0-1)', '0.85')
+        .option('-d, --min-age <days>', 'Minimum age for consolidation', '90')
+        .option('-i, --max-importance <number>', 'Max importance to consolidate (0-100)', '30')
+        .option('-c, --min-cluster <number>', 'Minimum cluster size', '3')
+        .option('-p, --project <project>', 'Project path', getDefaultProjectPath())
+        .option('--dry-run', 'Preview changes without applying', false)
+        .action(async (options) => {
+        try {
+            console.log('Running maintenance: deduplication + consolidation...\n');
+            // Step 1: Deduplication
+            console.log('Step 1: Finding duplicate memories...');
+            const dedupResult = await runDeduplicationJob(options.project);
+            console.log(`  Found ${dedupResult.duplicatesFound} duplicates, merged ${dedupResult.mergedCount}`);
+            // Step 2: Consolidation
+            console.log('\nStep 2: Consolidating old memories...');
+            const consolidateResult = await runFullConsolidationJob(options.project);
+            console.log(`  Clustered ${consolidateResult.clustered}, merged ${consolidateResult.merged}, consolidated ${consolidateResult.consolidated}`);
+            console.log(JSON.stringify({
+                ok: true,
+                dedup: {
+                    duplicatesFound: dedupResult.duplicatesFound,
+                    mergedCount: dedupResult.mergedCount,
+                    tokensRecovered: dedupResult.tokensRecovered
                 },
-            };
-            const handler = actions[action];
-            if (!handler)
-                throw new McpError(ErrorCode.InvalidParams, `Unknown action: ${action}`);
-            return handler();
-        }
-        async handleContextPaging(args) {
-            const action = args.action;
-            const sessionId = String(args.sessionId);
-            const actions = {
-                load: () => loadMemoryToContext(sessionId, String(args.memoryId)),
-                evict: () => evictMemoryFromContext(sessionId, String(args.memoryId)),
-                view: () => viewLoadedMemories(sessionId),
-            };
-            const handler = actions[action];
-            if (!handler)
-                throw new McpError(ErrorCode.InvalidParams, `Unknown action: ${action}`);
-            return this.jsonResponse(await handler());
-        }
-        async handleMerge(args) {
-            const action = args.action;
-            const handlers = {
-                detect: () => handleDetectDuplicates(args),
-                list: () => handleListProposals(args),
-                preview: () => handlePreviewMerge(args),
-                stats: () => handleGetMergeStats(args),
-                approve: () => handleApproveMerge(args),
-                reject: () => handleRejectMerge(args),
-                reverse: () => handleReverseMerge(args),
-            };
-            const handler = handlers[action];
-            if (!handler)
-                throw new McpError(ErrorCode.InvalidParams, `Unknown action: ${action}`);
-            return this.jsonResponse(await handler());
+                consolidate: {
+                    clustered: consolidateResult.clustered,
+                    merged: consolidateResult.merged,
+                    consolidated: consolidateResult.consolidated
+                }
+            }, null, 2));
         }
-        async shutdown() {
-            await closeCache();
-            process.exit(0);
+        catch (error) {
+            console.log(JSON.stringify({ ok: false, error: error.message }, null, 2));
         }
-        async health() {
-            const dbOk = await checkDatabaseHealth();
-            const redisOk = await checkRedisHealth();
-            return this.jsonResponse({
-                version: VERSION,
-                mode: config.isTeamMode ? 'team' : 'local',
-                status: dbOk ? 'ok' : 'error',
-            });
+    });
+    // squish hooks session-start --agent claude-code --mode startup
+    program
+        .command('hooks')
+        .description('Handle agent hooks (session-start, post-tool-use, session-end, pre-compact)')
+        .argument('<event>', 'Event type: session-start, post-tool-use, session-end, pre-compact')
+        .option('-a, --agent <agent>', 'Agent type: claude-code, opencode, cursor, windsurf', 'claude-code')
+        .option('-m, --mode <mode>', 'Mode for session-start: startup, resume, compact', 'startup')
+        .option('-p, --project <project>', 'Project path', getDefaultProjectPath())
+        .option('-t, --tool <tool>', 'Tool name for post-tool-use')
+        .option('--tool-input <json>', 'Tool input as JSON string')
+        .option('--tool-result <json>', 'Tool result as JSON string')
+        .option('--wip <work>', 'Work in progress for session-end')
+        .action(async (event, options) => {
+        try {
+            const agentType = options.agent;
+            const projectPath = options.project;
+            let result;
+            switch (event) {
+                case 'session-start':
+                    result = await handleSessionStart({
+                        projectPath,
+                        mode: options.mode,
+                        agentType,
+                    });
+                    console.log(JSON.stringify({ ok: true, ...result }, null, 2));
+                    break;
+                case 'post-tool-use':
+                    if (!options.tool) {
+                        console.log(JSON.stringify({ ok: false, error: '--tool required for post-tool-use' }, null, 2));
+                        process.exit(1);
+                    }
+                    const toolInput = options.toolInput ? JSON.parse(options.toolInput) : {};
+                    const toolResult = options.toolResult ? JSON.parse(options.toolResult) : {};
+                    result = await handlePostToolUse({
+                        toolName: options.tool,
+                        toolInput,
+                        toolResult,
+                        projectPath,
+                        agentType,
+                    });
+                    console.log(JSON.stringify({ ok: true, ...result }, null, 2));
+                    break;
+                case 'session-end':
+                    result = await handleSessionEnd({
+                        projectPath,
+                        agentType,
+                        workInProgress: options.wip,
+                    });
+                    console.log(JSON.stringify({ ok: true, ...result }, null, 2));
+                    break;
+                case 'pre-compact':
+                    result = await handlePreCompact({
+                        projectPath,
+                        agentType,
+                    });
+                    console.log(JSON.stringify({ ok: true, ...result }, null, 2));
+                    break;
+                default:
+                    console.log(JSON.stringify({ ok: false, error: `Unknown event: ${event}` }, null, 2));
+                    process.exit(1);
+            }
+        }
+        catch (error) {
+            console.log(JSON.stringify({ ok: false, error: error.message }, null, 2));
+            process.exit(1);
         }
-        async run() {
-            // Verify plugin manifest (universal plugin self-check)
-            const manifest = loadPluginManifest();
-            const verification = verifyManifest(manifest);
-            if (!verification.ok) {
-                logger.warn('Plugin manifest verification failed:', verification.errors);
+    });
+    // squish walk - Walk through spatial memory places
+    program
+        .command('walk [place]')
+        .description('Walk through spatial memory places (entry_hall, library, workshop, lab, office, garden, archive, or --all)')
+        .option('-a, --all', 'Walk all places in order', false)
+        .option('-t, --tokens <number>', 'Max tokens budget (default: 170)', '170')
+        .option('-m, --max <number>', 'Max memories per place', '10')
+        .option('-p, --project <project>', 'Project path', getDefaultProjectPath())
+        .option('-q, --quick', 'Quick tour (place names only)', false)
+        .option('-j, --json', 'Output as JSON', false)
+        .action(async (place, options) => {
+        try {
+            const projectPath = resolveProjectPath(options.project);
+            await ensureProject(projectPath);
+            const project = await getOrCreateProject(projectPath);
+            if (!project) {
+                console.log(JSON.stringify({ ok: false, error: 'Project not found' }, null, 2));
+                process.exit(1);
+            }
+            // Ensure places are initialized
+            await initializeDefaultPlaces(project.id);
+            if (options.quick) {
+                const tour = await quickTour(project.id);
+                if (options.json) {
+                    console.log(JSON.stringify({ ok: true, ...tour }, null, 2));
+                }
+                else {
+                    console.log(`\n=== Spatial Memory Tour ===\n`);
+                    console.log(`Total Memories: ${tour.totalMemories}\n`);
+                    for (const p of tour.places) {
+                        console.log(`${p.name} (${p.memoryCount} memories)`);
+                        console.log(`  ${p.purpose}\n`);
+                    }
+                }
+                return;
+            }
+            const tokenBudget = parseInt(options.tokens);
+            const maxMemories = parseInt(options.max);
+            if (options.all) {
+                const results = await walkAllPlaces(project.id, {
+                    tokenBudget: Math.floor(tokenBudget / 7),
+                    maxMemoriesPerPlace: maxMemories,
+                    compressWithToon: true,
+                });
+                if (options.json) {
+                    console.log(JSON.stringify({ ok: true, places: results }, null, 2));
+                }
+                else {
+                    console.log(`\n=== Walking All Places ===\n`);
+                    for (const r of results) {
+                        console.log(`## ${r.place.name} (${r.memories.length} memories, ~${r.totalTokens} tokens)`);
+                        r.memories.forEach((m, i) => {
+                            console.log(`  ${i + 1}. ${m.content.substring(0, 60)}...`);
+                        });
+                        console.log('');
+                    }
+                }
+            }
+            else if (place) {
+                const validPlaces = ['entry_hall', 'library', 'workshop', 'lab', 'office', 'garden', 'archive'];
+                const placeType = validPlaces.includes(place) ? place : 'workshop';
+                const result = await walkPlace(project.id, placeType, {
+                    tokenBudget,
+                    maxMemoriesPerPlace: maxMemories,
+                    compressWithToon: true,
+                });
+                if (options.json) {
+                    console.log(JSON.stringify({ ok: true, ...result }, null, 2));
+                }
+                else if (result) {
+                    console.log(`\n=== ${result.place.name} ===\n`);
+                    console.log(`Purpose: ${result.place.purpose || 'N/A'}\n`);
+                    result.memories.forEach((m, i) => {
+                        console.log(`${i + 1}. [${m.type}] ${m.content.substring(0, 80)}`);
+                    });
+                    console.log(`\n~${result.totalTokens} tokens`);
+                }
+                else {
+                    console.log(JSON.stringify({ ok: false, error: `Place not found: ${place}` }, null, 2));
+                }
             }
-            else {
-                logger.info(`Squish v${VERSION} - Plugin manifest verified`);
-            }
-            const transport = new StdioServerTransport();
-            await this.server.connect(transport);
-            logger.info(`v${VERSION}`);
-            registerJobHandler('nightly_maintenance', runNightlyJob);
-            registerJobHandler('weekly_maintenance', runWeeklyJob);
-            await initializeScheduler();
-            startHeartbeatChecking();
-            await this.onSessionInitialized();
-            await heartbeat();
-            startWebServer();
         }
-    }
-    new Squish().run();
+        catch (error) {
+            console.log(JSON.stringify({ ok: false, error: error.message }, null, 2));
+            process.exit(1);
+        }
+    });
+    await program.parseAsync(process.argv);
 }
+// MCP server: core/commands/mcp-server.ts
+// Run with: npx squish-mcp
+// ============================================================================
 //# sourceMappingURL=index.js.map