mnueron 0.3.0 → 0.4.0

package/dist/cli.js

@@ -15,6 +15,7 @@ import { loadConfig, makeProvider } from './config.js';
 import { importClaudeExport } from './import/claude.js';
 import { importOpenAIExport } from './import/openai.js';
 import { runSetup, formatReport } from './setup.js';
+import { extractEntities } from './store/entity-extractor.js';
 const HERE = dirname(fileURLToPath(import.meta.url));
 async function main() {
     const [cmd, ...rest] = process.argv.slice(2);
@@ -31,6 +32,12 @@ async function main() {
         case 'migrate-to-hosted': return cmdMigrateToHosted(rest);
         case 'plugin': return cmdPlugin(rest);
         case 'primer': return cmdPrimer(rest);
+        case 'extract-entities': return cmdExtractEntities(rest);
+        case 'entities': return cmdEntities(rest); // P2.3 — list/show/merge
+        case 'graph': return cmdGraph(rest); // P3 + P4 — knowledge graph
+        case 'consolidate': return cmdConsolidate(rest); // P5 — detection-only review queue
+        case 'procedural': return cmdProcedural(rest); // Procedural memory (Mem0 leapfrog)
+        case 'watch': return cmdWatch(rest);
         case 'help':
         case '--help':
         case '-h':
@@ -53,6 +60,17 @@ Commands:
   mnueron import <file>           Bulk-import a Claude or OpenAI export
        [--ns <name>]              Target namespace (default: "default")
        [--format claude|openai]   Skip format auto-detection
+  mnueron import --claude-desktop Probe + auto-import the local Claude Desktop app
+       [--probe]                  Show what's found without importing
+       [--ns <name>]              Target namespace (default: "claude-desktop")
+  mnueron import --claude-cowork  Auto-import every Cowork (desktop "local agent")
+       [--probe]                    chat. Walks platform-specific roots
+       [--ns <name>]                (incl. the Microsoft Store sandboxed path);
+       [--limit <n>]                each session becomes a chunked memory;
+       [--dry-run]                  idempotent via source_ref dedup.
+       Example: mnueron import --claude-cowork --probe
+                mnueron import --claude-cowork --ns elevizio --limit 10
+                mnueron import --claude-cowork --dry-run
   mnueron search <query>          Search memories from the terminal
        [--ns <name>] [--k <n>]
   mnueron stats                   Show counts by namespace
@@ -85,6 +103,42 @@ Commands:
        [--recent <n>]               Sample n most-recent memory titles (default: 12).
        [--out <file>]               Write to file instead of stdout.
        Example: mnueron primer > CLAUDE.md
+  mnueron extract-entities        P2 — retroactively extract entities from existing memories.
+       [--ns <name>]                Restrict to one namespace.
+       [--since <epoch_ms>]         Only memories created on/after this time.
+       [--limit <n>]                Cap how many to process (default 100, max 1000).
+       [--force]                    Re-extract memories that already have entities.
+       [--dry-run]                  Preview without making LLM calls.
+       Requires ANTHROPIC_API_KEY or OPENAI_API_KEY in the environment.
+
+  mnueron entities <sub>           P2.3 — Canonical entity browser (resolved across memories).
+       list   [--type <t>] [--q <substr>] [--sort recent|mentions|alpha] [--limit <n>]
+       show   <entity-id> [--memories <n>]
+       merge  --winner <id> --loser <id>
+       Example: mnueron entities list --type person --sort mentions
+
+  mnueron graph <sub>              P3 + P4 — Knowledge graph (relationships + bi-temporal).
+       show       <entity-id> [--as-of <ISO-date>]
+       traverse   <entity-id> [--depth <n>] [--as-of <ISO-date>]
+       relations  [--from <id>] [--to <id>] [--predicate <p>] [--as-of <ISO-date>]
+       The --as-of flag enables "what was true at that point in time" recall.
+
+  mnueron consolidate <sub>        P5 — Self-revising memory (phase 5a: detection only).
+       detect   [--limit <n>] [--threshold <0..1>] [--ns <name>]
+       list     [--status pending|approved|rejected|all]
+       approve  <proposal-id>
+       reject   <proposal-id>
+       Detection scans for likely-duplicate memories via embedding similarity
+       and surfaces them as proposals. Phase 5a does NOT auto-merge.
+
+  mnueron watch                   Background sync — keep memory in step with new chats.
+       --claude-cowork              Watch the on-disk Cowork transcripts and
+       [--interval <minutes>]       incrementally import new/changed sessions.
+       [--ns <name>]                Default interval 5m. State at
+       [--once]                     ~/.mnueron/cowork-sync.json. Ctrl+C stops it.
+       Example: mnueron watch --claude-cowork
+                mnueron watch --claude-cowork --interval 2 --ns elevizio
+                mnueron watch --claude-cowork --once
 
 Environment:
   MNUERON_DB_PATH    Local SQLite location (default: ~/.mnueron/memories.db)
@@ -151,8 +205,138 @@ async function cmdSetup(args) {
     }
 }
 async function cmdImport(args) {
+    // v0.2.6 — `--claude-cowork` mode auto-imports every Cowork chat
+    // transcript from ~/.claude/projects/. No positional <file>.
+    if (args.includes('--claude-cowork')) {
+        const { probeClaudeCowork, autoImport } = await import('./import/claude_cowork.js');
+        const probeOnly = args.includes('--probe') || args.includes('--probe-only');
+        const dryRun = args.includes('--dry-run');
+        let ns = 'claude-cowork';
+        let limit;
+        for (let i = 0; i < args.length; i++) {
+            if (args[i] === '--ns' && args[i + 1])
+                ns = args[++i];
+            else if (args[i] === '--limit' && args[i + 1]) {
+                const n = Number(args[++i]);
+                if (Number.isFinite(n) && n > 0)
+                    limit = Math.floor(n);
+            }
+        }
+        const probe = probeClaudeCowork();
+        console.log('🧠  Claude Cowork probe');
+        if (probe.scannedRoots.length > 0) {
+            console.log(`    Scanned ${probe.scannedRoots.length} root(s):`);
+            for (const r of probe.scannedRoots)
+                console.log(`      - ${r}`);
+        }
+        else {
+            console.log(`    Scanned 0 root(s) — none of the candidate paths exist.`);
+            console.log(`    Paths attempted (${probe.pathsAttempted.length}):`);
+            for (const p of probe.pathsAttempted)
+                console.log(`      - ${p}`);
+        }
+        console.log(`    Cowork sessions: ${probe.sessions.length}`);
+        if (probe.sessions.length > 0) {
+            const preview = probe.sessions.slice(0, 5);
+            console.log('    Latest sessions:');
+            for (const s of preview) {
+                const title = s.title ?? '(untitled)';
+                const kb = (s.sizeBytes / 1024).toFixed(1);
+                console.log(`      • ${title} — ${s.messageCount} msgs, ${kb} KB  [${s.sessionId.slice(0, 8)}…]`);
+            }
+            if (probe.sessions.length > preview.length) {
+                console.log(`      … and ${probe.sessions.length - preview.length} more`);
+            }
+        }
+        for (const h of probe.hints)
+            console.log(`    ${h}`);
+        if (probeOnly) {
+            console.log('  (--probe mode — not importing anything)');
+            return;
+        }
+        if (!probe.found || probe.sessions.length === 0) {
+            console.error('✗ Nothing to import.');
+            process.exit(1);
+        }
+        try {
+            const provider = makeProvider(loadConfig());
+            const result = await autoImport(provider, ns, { dryRun, limit });
+            await provider.close();
+            if (dryRun) {
+                console.log(`  (--dry-run) Would import ${result.parsed} session(s), ` +
+                    `skip ${result.empty} empty, into namespace "${ns}".`);
+            }
+            else {
+                console.log(`✓ Imported ${result.parsed} / ${result.totalSessions} session(s)`);
+                console.log(`  Saved ${result.saved} memory item(s), empty ${result.empty}, errors ${result.errors}`);
+                console.log(`  Namespace: "${ns}". Re-runs are idempotent (source_ref dedup).`);
+            }
+        }
+        catch (e) {
+            console.error(`✗ ${e.message}`);
+            process.exit(1);
+        }
+        return;
+    }
+    // v0.2.5 — `--claude-desktop` mode probes for and auto-imports the
+    // user's locally-installed Claude Desktop export. No positional <file>.
+    if (args.includes('--claude-desktop')) {
+        const { probeClaudeDesktop, autoImport } = await import('./import/claude_desktop.js');
+        const probeOnly = args.includes('--probe') || args.includes('--probe-only');
+        let ns = 'claude-desktop';
+        let dirOverride = null;
+        for (let i = 0; i < args.length; i++) {
+            if (args[i] === '--ns' && args[i + 1])
+                ns = args[++i];
+            else if (args[i] === '--dir' && args[i + 1])
+                dirOverride = args[++i];
+        }
+        const probe = probeClaudeDesktop();
+        console.log('🧠  Claude Desktop probe');
+        console.log(`    Location: ${probe.path ?? 'NOT FOUND'}`);
+        if (!probe.path) {
+            console.log('    Paths tried:');
+            for (const p of probe.pathsAttempted)
+                console.log(`      - ${p}`);
+        }
+        else {
+            console.log(`    Contents: ${probe.contents.length} entries`);
+        }
+        if (probe.exportCandidates.length > 0) {
+            console.log('    Export candidates:');
+            for (const e of probe.exportCandidates)
+                console.log(`      • ${e}`);
+        }
+        if (probe.hints.length > 0) {
+            console.log('    Notes:');
+            for (const h of probe.hints)
+                console.log(`      ${h}`);
+        }
+        if (probeOnly) {
+            console.log('  (--probe mode — not importing anything)');
+            return;
+        }
+        if (dirOverride) {
+            console.log(`  --dir ${dirOverride}: custom-path import not yet implemented; use Settings → Privacy → Export data.`);
+            return;
+        }
+        try {
+            const provider = makeProvider(loadConfig());
+            const result = await autoImport(provider, ns);
+            await provider.close();
+            console.log(`✓ Imported from ${result.path}`);
+            console.log(`  Saved ${result.saved}, errors ${result.errors}, namespace="${ns}"`);
+        }
+        catch (e) {
+            console.error(`✗ ${e.message}`);
+            process.exit(1);
+        }
+        return;
+    }
     if (args.length === 0) {
         console.error('Usage: mnueron import <file> [--ns <namespace>] [--format claude|openai]');
+        console.error('       mnueron import --claude-desktop [--probe] [--ns <namespace>]');
+        console.error('       mnueron import --claude-cowork  [--probe] [--ns <namespace>] [--limit N] [--dry-run]');
         process.exit(1);
     }
     const file = args[0];
@@ -807,7 +991,1009 @@ function renderPrimer(input) {
     lines.push('');
     return lines.join('\n');
 }
-main().catch(e => {
+/**
+ * P2.4 — retroactive entity extraction for the local SQLite store.
+ *
+ * For each existing memory:
+ *   1. Skip if metadata.entities already exists (unless --force).
+ *   2. Extract entities via Haiku/OpenAI (whichever env key is set).
+ *   3. Stamp the extracted list into metadata.entities via provider.update().
+ *
+ * Note: this only does P1 (extraction) for local. Cross-session entity
+ * resolution (P2) on local SQLite is deferred — entities here are saved
+ * as standalone lists per-memory without canonical_id linking yet.
+ * Hosted-mode users get the full P1+P2 pipeline via /api/entities/backfill.
+ */
+async function cmdExtractEntities(args) {
+    let ns;
+    let since;
+    let limit = 100;
+    let force = false;
+    let dryRun = false;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--ns' && args[i + 1])
+            ns = args[++i];
+        else if (a === '--since' && args[i + 1])
+            since = parseInt(args[++i], 10);
+        else if (a === '--limit' && args[i + 1]) {
+            const v = parseInt(args[++i], 10);
+            if (Number.isFinite(v))
+                limit = Math.max(1, Math.min(1000, v));
+        }
+        else if (a === '--force')
+            force = true;
+        else if (a === '--dry-run')
+            dryRun = true;
+        else if (a === '--help' || a === '-h') {
+            console.log('Usage: mnueron extract-entities [--ns <name>] [--since <epoch_ms>]\n' +
+                '                                [--limit <n>] [--force] [--dry-run]');
+            return;
+        }
+    }
+    if (!process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY) {
+        console.error('mnueron extract-entities requires ANTHROPIC_API_KEY or OPENAI_API_KEY in the environment.');
+        process.exit(1);
+    }
+    const provider = makeProvider(loadConfig());
+    // update() is optional on the Provider interface — bail early with a
+    // clear error so TypeScript narrows it for the rest of this function.
+    if (typeof provider.update !== 'function') {
+        console.error('This provider does not support memory.update — cannot persist extracted entities.');
+        process.exit(1);
+    }
+    const updateFn = provider.update.bind(provider);
+    try {
+        // Pull candidates newest-first. The provider's list() honors namespace
+        // and date filters and returns memories with their metadata.
+        const memories = await provider.list({
+            namespace: ns,
+            created_after: since,
+            limit,
+            offset: 0,
+        });
+        if (memories.length === 0) {
+            console.log('No memories matched. Nothing to do.');
+            return;
+        }
+        console.log(`Found ${memories.length} candidate memor${memories.length === 1 ? 'y' : 'ies'}${ns ? ` in namespace "${ns}"` : ''}.`);
+        if (dryRun) {
+            let withEntities = 0;
+            for (const m of memories) {
+                const meta = (m.metadata ?? {});
+                if (Array.isArray(meta.entities) && meta.entities.length > 0) {
+                    withEntities += 1;
+                }
+            }
+            console.log(`[dry-run] Would extract for ${memories.length - withEntities} memories ` +
+                `(skipping ${withEntities} that already have entities; pass --force to override).`);
+            return;
+        }
+        let processed = 0;
+        let extracted = 0;
+        let skipped = 0;
+        let errors = 0;
+        for (const m of memories) {
+            const meta = (m.metadata ?? {});
+            const hasExisting = Array.isArray(meta.entities) && meta.entities.length > 0;
+            if (hasExisting && !force) {
+                skipped += 1;
+                process.stdout.write('.');
+                continue;
+            }
+            try {
+                const ents = await extractEntities(m.content, {});
+                processed += 1;
+                if (ents.length === 0) {
+                    process.stdout.write('-');
+                    continue;
+                }
+                extracted += ents.length;
+                // Merge into existing metadata; overwrite the entities key.
+                await updateFn(m.id, {
+                    metadata: { ...meta, entities: ents },
+                });
+                process.stdout.write('+');
+            }
+            catch (e) {
+                errors += 1;
+                process.stdout.write('x');
+                console.warn('\n[extract-entities] memory', m.id, 'failed:', e instanceof Error ? e.message : e);
+            }
+        }
+        process.stdout.write('\n');
+        console.log(`extract-entities done — extracted=${extracted} processed=${processed} skipped=${skipped} errors=${errors}`);
+    }
+    catch (e) {
+        console.error('extract-entities failed:', e);
+        process.exit(1);
+    }
+}
+/**
+ * P2.3 — `mnueron entities <list|show|merge>`
+ *
+ * Surfaces canonical entities the resolver has built up. Three subcommands:
+ *
+ *   list   — table view of entities, filtered by type / sorted by recent
+ *            / most-mentioned / alphabetical.
+ *   show   — full detail for one entity, including the linked memories.
+ *   merge  — collapse two duplicate canonicals into one (winner keeps id;
+ *            loser's memories + aliases absorbed into winner).
+ *
+ * All three only work with the local SQLite provider — hosted entity
+ * resolution lives on the mnueron.com backend and the SDK's `entities`
+ * namespace is the way to talk to it.
+ */
+async function cmdEntities(args) {
+    const [sub, ...rest] = args;
+    switch (sub) {
+        case 'list': return cmdEntitiesList(rest);
+        case 'show': return cmdEntitiesShow(rest);
+        case 'merge': return cmdEntitiesMerge(rest);
+        case 'backfill': return cmdEntitiesBackfill(rest);
+        case undefined:
+        case '--help':
+        case '-h':
+            console.log('Usage:\n' +
+                '  mnueron entities list   [--type <t>] [--q <substr>] [--sort recent|mentions|alpha] [--limit <n>]\n' +
+                '  mnueron entities show   <entity-id>  [--memories <n>]\n' +
+                '  mnueron entities merge  --winner <id> --loser <id>\n\n' +
+                'Examples:\n' +
+                '  mnueron entities list --type person --sort mentions\n' +
+                '  mnueron entities show ent-abc123 --memories 50\n' +
+                '  mnueron entities merge --winner ent-abc --loser ent-def');
+            return;
+        default:
+            console.error(`Unknown entities subcommand: ${sub}`);
+            process.exit(1);
+    }
+}
+async function cmdEntitiesList(args) {
+    let type;
+    let q;
+    let sort = 'recent';
+    let limit = 50;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--type' && args[i + 1])
+            type = args[++i];
+        else if (a === '--q' && args[i + 1])
+            q = args[++i];
+        else if (a === '--sort' && args[i + 1]) {
+            const s = args[++i];
+            if (s === 'recent' || s === 'mentions' || s === 'alpha')
+                sort = s;
+        }
+        else if (a === '--limit' && args[i + 1]) {
+            const v = parseInt(args[++i], 10);
+            if (Number.isFinite(v))
+                limit = Math.max(1, Math.min(500, v));
+        }
+    }
+    const provider = makeProvider(loadConfig());
+    if (typeof provider.listEntities !== 'function') {
+        console.error('This provider does not support entities (hosted-only — use the SDK / dashboard).');
+        process.exit(1);
+    }
+    const entities = await provider.listEntities({ type, q, sort, limit });
+    if (entities.length === 0) {
+        console.log('No entities yet. Save some memories with entity extraction enabled and they\'ll appear here.');
+        return;
+    }
+    // Pretty table. Truncate display_name + alias preview so 80-col terminals stay clean.
+    const trunc = (s, n) => (s.length > n ? s.slice(0, n - 1) + '…' : s);
+    const fmt = (d) => new Date(d).toISOString().slice(0, 10);
+    console.log('id'.padEnd(38) +
+        'type'.padEnd(14) +
+        'name'.padEnd(30) +
+        'mentions'.padStart(10) +
+        '  last seen');
+    console.log('-'.repeat(110));
+    for (const e of entities) {
+        console.log(e.id.padEnd(38) +
+            trunc(e.entity_type, 12).padEnd(14) +
+            trunc(e.display_name, 28).padEnd(30) +
+            String(e.mention_count).padStart(10) +
+            '  ' +
+            fmt(e.last_seen_at));
+    }
+    console.log(`\n${entities.length} entit${entities.length === 1 ? 'y' : 'ies'} shown.`);
+}
+async function cmdEntitiesShow(args) {
+    const id = args.find((a) => !a.startsWith('--'));
+    if (!id) {
+        console.error('Usage: mnueron entities show <entity-id> [--memories <n>]');
+        process.exit(1);
+    }
+    let memLimit = 20;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--memories' && args[i + 1]) {
+            const v = parseInt(args[++i], 10);
+            if (Number.isFinite(v))
+                memLimit = Math.max(1, Math.min(200, v));
+        }
+    }
+    const provider = makeProvider(loadConfig());
+    if (typeof provider.getEntity !== 'function' || typeof provider.getEntityMemories !== 'function') {
+        console.error('This provider does not support entities.');
+        process.exit(1);
+    }
+    const entity = await provider.getEntity(id);
+    if (!entity) {
+        console.error(`Entity not found: ${id}`);
+        process.exit(1);
+    }
+    console.log(`# ${entity.display_name}`);
+    console.log(`  id:            ${entity.id}`);
+    console.log(`  type:          ${entity.entity_type}`);
+    console.log(`  mentions:      ${entity.mention_count}`);
+    console.log(`  first seen:    ${new Date(entity.first_seen_at).toISOString()}`);
+    console.log(`  last seen:     ${new Date(entity.last_seen_at).toISOString()}`);
+    if (entity.aliases.length > 0) {
+        console.log(`  aliases:       ${entity.aliases.join(', ')}`);
+    }
+    const memories = await provider.getEntityMemories(entity.id, memLimit);
+    console.log(`\n## Linked memories (${memories.length}${memories.length >= memLimit ? '+' : ''})`);
+    for (const m of memories) {
+        const date = new Date(m.created_at).toISOString().slice(0, 10);
+        const preview = m.content.replace(/\s+/g, ' ').slice(0, 100);
+        const conf = m.confidence === 1 ? 'exact' : m.confidence.toFixed(2);
+        console.log(`  - [${date}] (${conf}) "${m.surface_form}" — ${preview}${m.content.length > 100 ? '…' : ''}`);
+        console.log(`      memory: ${m.id}  ns: ${m.namespace}`);
+    }
+}
+async function cmdEntitiesMerge(args) {
+    let winner;
+    let loser;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--winner' && args[i + 1])
+            winner = args[++i];
+        else if (args[i] === '--loser' && args[i + 1])
+            loser = args[++i];
+    }
+    if (!winner || !loser) {
+        console.error('Usage: mnueron entities merge --winner <id> --loser <id>');
+        process.exit(1);
+    }
+    if (winner === loser) {
+        console.error('Winner and loser must be different entities.');
+        process.exit(1);
+    }
+    const provider = makeProvider(loadConfig());
+    if (typeof provider.mergeEntities !== 'function') {
+        console.error('This provider does not support entities.');
+        process.exit(1);
+    }
+    const merged = await provider.mergeEntities(winner, loser);
+    if (!merged) {
+        console.error('Merge failed — one or both entities not found.');
+        process.exit(1);
+    }
+    console.log(`✅ Merged. Winner: ${merged.display_name} (${merged.id})`);
+    console.log(`   aliases now:  ${merged.aliases.join(', ')}`);
+    console.log(`   mention count: ${merged.mention_count}`);
+}
+/**
+ * P2.3 backfill — retro-fit canonical entity IDs onto memories that were
+ * saved before the resolver shipped.
+ *
+ * Two-stage walk per memory:
+ *   1. If `metadata.entities` is missing AND --extract was passed, run the
+ *      extractor (uses ANTHROPIC_API_KEY or OPENAI_API_KEY from env).
+ *   2. If `metadata.entities` is now populated but lacks canonical_id values,
+ *      run the resolver. Updates the entities/memory_entities tables AND
+ *      stamps canonical_id back onto the stored metadata.
+ *
+ * Idempotent — re-running skips memories that are already resolved.
+ *
+ * Flags:
+ *   --ns <name>         restrict to one namespace
+ *   --limit <n>         cap how many memories to process (default 100, max 1000)
+ *   --since <epoch_ms>  only memories created on/after this time
+ *   --extract           also call the extractor for memories with no entities
+ *   --dry-run           preview counts without writing
+ *   --force             re-resolve memories that already have canonical_ids
+ */
+async function cmdEntitiesBackfill(args) {
+    let ns;
+    let since;
+    let limit = 100;
+    let alsoExtract = false;
+    let dryRun = false;
+    let force = false;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--ns' && args[i + 1])
+            ns = args[++i];
+        else if (a === '--since' && args[i + 1])
+            since = parseInt(args[++i], 10);
+        else if (a === '--limit' && args[i + 1]) {
+            const v = parseInt(args[++i], 10);
+            if (Number.isFinite(v))
+                limit = Math.max(1, Math.min(10000, v));
+        }
+        else if (a === '--extract')
+            alsoExtract = true;
+        else if (a === '--dry-run')
+            dryRun = true;
+        else if (a === '--force')
+            force = true;
+        else if (a === '--help' || a === '-h') {
+            console.log('Usage: mnueron entities backfill [--ns <name>] [--limit <n>]\n' +
+                '                                  [--since <epoch_ms>] [--extract]\n' +
+                '                                  [--dry-run] [--force]\n\n' +
+                '  --extract  also runs the extractor for memories with no entities\n' +
+                '             (requires ANTHROPIC_API_KEY or OPENAI_API_KEY env var)\n' +
+                '  --force    re-resolve memories that already have canonical_ids');
+            return;
+        }
+    }
+    const provider = makeProvider(loadConfig());
+    if (typeof provider.backfillResolveMemory !== 'function' ||
+        typeof provider.update !== 'function') {
+        console.error('This provider does not support entity backfill.');
+        process.exit(1);
+    }
+    const resolveFn = provider.backfillResolveMemory.bind(provider);
+    const updateFn = provider.update.bind(provider);
+    if (alsoExtract && !process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY) {
+        console.error('--extract requires ANTHROPIC_API_KEY or OPENAI_API_KEY in the environment.');
+        process.exit(1);
+    }
+    const memories = await provider.list({
+        namespace: ns,
+        created_after: since,
+        limit,
+        offset: 0,
+    });
+    if (memories.length === 0) {
+        console.log('No memories matched. Nothing to do.');
+        return;
+    }
+    console.log(`Found ${memories.length} memor${memories.length === 1 ? 'y' : 'ies'}${ns ? ` in "${ns}"` : ''}.`);
+    let extracted = 0;
+    let resolved = 0;
+    let alreadyResolved = 0;
+    let noEntities = 0;
+    let errors = 0;
+    for (const m of memories) {
+        const meta = (m.metadata ?? {});
+        let entities = Array.isArray(meta.entities)
+            ? meta.entities
+            : [];
+        // Stage 1 — optional extraction
+        if (entities.length === 0) {
+            if (!alsoExtract) {
+                noEntities += 1;
+                process.stdout.write('.');
+                continue;
+            }
+            if (dryRun) {
+                process.stdout.write('e');
+                extracted += 1;
+                continue;
+            }
+            try {
+                const ents = await extractEntities(m.content, {});
+                if (ents.length === 0) {
+                    process.stdout.write('-');
+                    continue;
+                }
+                entities = ents;
+                extracted += ents.length;
+                await updateFn(m.id, { metadata: { ...meta, entities } });
+                process.stdout.write('e');
+            }
+            catch (e) {
+                errors += 1;
+                process.stdout.write('x');
+                // Surface the error so we can diagnose — silent failures hid a real
+                // bug in update() previously. Verbose by design: low-volume use case.
+                console.error(`\n  [extract/update failed] memory ${m.id}:`, e instanceof Error ? e.message : e);
+                continue;
+            }
+        }
+        // Stage 2 — resolve (skip if already resolved unless --force)
+        const allResolved = entities.every((e) => typeof e.canonical_id === 'string' && e.canonical_id);
+        if (allResolved && !force) {
+            alreadyResolved += 1;
+            process.stdout.write('=');
+            continue;
+        }
+        if (dryRun) {
+            resolved += entities.length;
+            process.stdout.write('r');
+            continue;
+        }
+        try {
+            const res = await resolveFn(m.id, entities.map((e) => ({ name: e.name, type: e.type, context: e.context })));
+            const stamped = entities.map((e, i) => ({
+                ...e,
+                canonical_id: res[i]?.canonical_id ?? null,
+            }));
+            await updateFn(m.id, { metadata: { ...meta, entities: stamped } });
+            resolved += entities.length;
+            process.stdout.write('+');
+        }
+        catch (e) {
+            errors += 1;
+            process.stdout.write('x');
+            console.error(`\n  [resolve failed] memory ${m.id}:`, e instanceof Error ? e.message : e);
+        }
+    }
+    process.stdout.write('\n');
+    console.log(`backfill done — resolved=${resolved} extracted=${extracted} already_resolved=${alreadyResolved} no_entities=${noEntities} errors=${errors}` +
+        (dryRun ? '  (dry-run — no writes)' : ''));
+    if (!dryRun && resolved > 0) {
+        console.log('\nRun "mnueron entities list --sort mentions" to see them.');
+    }
+}
+/**
+ * P3 + P4 — `mnueron graph <show|traverse|relations>`
+ *
+ *   show <entity-id>             — overview: entity + its direct relations.
+ *   traverse <entity-id>         — BFS out to --depth hops (default 2).
+ *   relations [--from <id>] [--to <id>] [--predicate <p>] [--as-of <iso>]
+ *                                — raw edge query. Useful for scripting.
+ *
+ * All three accept `--as-of <ISO-date>` for bi-temporal queries: "what
+ * relationships were valid at that point in time?" Falls through to "all
+ * relations" when --as-of isn't passed.
+ */
+async function cmdGraph(args) {
+    const [sub, ...rest] = args;
+    switch (sub) {
+        case 'show': return cmdGraphShow(rest);
+        case 'traverse': return cmdGraphTraverse(rest);
+        case 'relations': return cmdGraphRelations(rest);
+        case undefined:
+        case '--help':
+        case '-h':
+            console.log('Usage:\n' +
+                '  mnueron graph show <entity-id> [--as-of <ISO-date>]\n' +
+                '  mnueron graph traverse <entity-id> [--depth <n>] [--as-of <ISO-date>]\n' +
+                '  mnueron graph relations [--from <id>] [--to <id>] [--predicate <p>] [--as-of <ISO-date>] [--limit <n>]\n\n' +
+                'The --as-of flag enables bi-temporal recall ("what was true at that date").\n' +
+                'Example: mnueron graph traverse ent-john --depth 3 --as-of 2025-04-01');
+            return;
+        default:
+            console.error(`Unknown graph subcommand: ${sub}`);
+            process.exit(1);
+    }
+}
+/** Parse --as-of <ISO> into epoch ms, or undefined when absent. */
+function parseAsOf(args) {
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--as-of' && args[i + 1]) {
+            const t = Date.parse(args[i + 1]);
+            if (!Number.isFinite(t)) {
+                console.error(`Invalid --as-of date: ${args[i + 1]}`);
+                process.exit(1);
+            }
+            return t;
+        }
+    }
+    return undefined;
+}
+async function cmdGraphShow(args) {
+    const id = args.find((a) => !a.startsWith('--'));
+    if (!id) {
+        console.error('Usage: mnueron graph show <entity-id> [--as-of <ISO-date>]');
+        process.exit(1);
+    }
+    const asOf = parseAsOf(args);
+    const provider = makeProvider(loadConfig());
+    if (typeof provider.getEntity !== 'function' ||
+        typeof provider.getRelations !== 'function') {
+        console.error('This provider does not support the knowledge graph.');
+        process.exit(1);
+    }
+    const entity = await provider.getEntity(id);
+    if (!entity) {
+        console.error(`Entity not found: ${id}`);
+        process.exit(1);
+    }
+    console.log(`# ${entity.display_name}  (${entity.entity_type})`);
+    console.log(`  id: ${entity.id}`);
+    if (asOf)
+        console.log(`  as of: ${new Date(asOf).toISOString()}`);
+    const outgoing = await provider.getRelations({ fromEntityId: id, asOf, limit: 200 });
+    const incoming = await provider.getRelations({ toEntityId: id, asOf, limit: 200 });
+    console.log(`\n## Outgoing (${outgoing.length})`);
+    for (const rel of outgoing) {
+        const target = await provider.getEntity(rel.to_entity_id);
+        const targetName = target?.display_name ?? rel.to_entity_id;
+        console.log(`  -[${rel.predicate}]-> ${targetName}  (conf ${rel.confidence.toFixed(2)}${formatWindow(rel)})`);
+    }
+    console.log(`\n## Incoming (${incoming.length})`);
+    for (const rel of incoming) {
+        const source = await provider.getEntity(rel.from_entity_id);
+        const sourceName = source?.display_name ?? rel.from_entity_id;
+        console.log(`  ${sourceName} -[${rel.predicate}]-> ${entity.display_name}  (conf ${rel.confidence.toFixed(2)}${formatWindow(rel)})`);
+    }
+}
+async function cmdGraphTraverse(args) {
+    const id = args.find((a) => !a.startsWith('--'));
+    if (!id) {
+        console.error('Usage: mnueron graph traverse <entity-id> [--depth <n>] [--as-of <ISO-date>]');
+        process.exit(1);
+    }
+    let depth = 2;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--depth' && args[i + 1]) {
+            const v = parseInt(args[++i], 10);
+            if (Number.isFinite(v))
+                depth = Math.max(0, Math.min(5, v));
+        }
+    }
+    const asOf = parseAsOf(args);
+    const provider = makeProvider(loadConfig());
+    if (typeof provider.traverseGraph !== 'function') {
+        console.error('This provider does not support the knowledge graph.');
+        process.exit(1);
+    }
+    const hops = await provider.traverseGraph(id, { depth, asOf });
+    if (hops.length === 0) {
+        console.error(`Entity not found: ${id}`);
+        process.exit(1);
+    }
+    console.log(`# Traversal from ${hops[0].entity.display_name}  depth=${depth}${asOf ? `  as-of=${new Date(asOf).toISOString()}` : ''}`);
+    for (const hop of hops) {
+        const indent = '  '.repeat(hop.depth);
+        if (hop.depth === 0) {
+            console.log(`${indent}● ${hop.entity.display_name} (${hop.entity.entity_type})`);
+        }
+        else {
+            const arrow = hop.direction === 'out' ? '→' : '←';
+            const pred = hop.via?.predicate ?? '?';
+            console.log(`${indent}${arrow} [${pred}] ${hop.entity.display_name} (${hop.entity.entity_type})${formatWindow(hop.via)}`);
+        }
+    }
+    console.log(`\n${hops.length} node${hops.length === 1 ? '' : 's'} visited.`);
+}
+async function cmdGraphRelations(args) {
+    let from;
+    let to;
+    let predicate;
+    let limit = 100;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--from' && args[i + 1])
+            from = args[++i];
+        else if (args[i] === '--to' && args[i + 1])
+            to = args[++i];
+        else if (args[i] === '--predicate' && args[i + 1])
+            predicate = args[++i];
+        else if (args[i] === '--limit' && args[i + 1]) {
+            const v = parseInt(args[++i], 10);
+            if (Number.isFinite(v))
+                limit = Math.max(1, Math.min(1000, v));
+        }
+    }
+    const asOf = parseAsOf(args);
+    const provider = makeProvider(loadConfig());
+    if (typeof provider.getRelations !== 'function') {
+        console.error('This provider does not support the knowledge graph.');
+        process.exit(1);
+    }
+    const rels = await provider.getRelations({ fromEntityId: from, toEntityId: to, predicate, asOf, limit });
+    console.log(JSON.stringify(rels, null, 2));
+}
+/** Human-readable validity window: " (valid 2022→2025)" or "" if none. */
+function formatWindow(rel) {
+    if (!rel)
+        return '';
+    if (rel.valid_from == null && rel.valid_to == null)
+        return '';
+    const f = rel.valid_from ? new Date(rel.valid_from).toISOString().slice(0, 10) : '?';
+    const t = rel.valid_to ? new Date(rel.valid_to).toISOString().slice(0, 10) : 'now';
+    return `  (${f}→${t})`;
+}
+/**
+ * P5 — `mnueron consolidate <detect|review|list|approve|reject>`
+ *
+ * Phase 5a is detection-only — no automatic mutation of memories. The
+ * detector finds likely-duplicate pairs via embedding similarity and
+ * enqueues them as proposals. The user reviews from the dashboard or
+ * via these CLI commands.
+ *
+ *   detect              run the duplicate scan
+ *   list                show pending proposals
+ *   approve <id>        mark approved (5b will act on this; 5a just records the decision)
+ *   reject  <id>        mark rejected
+ */
+async function cmdConsolidate(args) {
+    const [sub, ...rest] = args;
+    switch (sub) {
+        case 'detect': return cmdConsolidateDetect(rest);
+        case 'list': return cmdConsolidateList(rest);
+        case 'approve': return cmdConsolidateReview(rest, 'approved');
+        case 'reject': return cmdConsolidateReview(rest, 'rejected');
+        case undefined:
+        case '--help':
+        case '-h':
+            console.log('Usage:\n' +
+                '  mnueron consolidate detect   [--limit <n>] [--threshold <0..1>] [--ns <name>]\n' +
+                '  mnueron consolidate list     [--status pending|approved|rejected] [--limit <n>]\n' +
+                '  mnueron consolidate approve <proposal-id>\n' +
+                '  mnueron consolidate reject  <proposal-id>\n\n' +
+                'Phase 5a — DETECTION ONLY. Approving a proposal records the decision\n' +
+                'but does not yet merge memories. Phase 5b will action approved merges.');
+            return;
+        default:
+            console.error(`Unknown consolidate subcommand: ${sub}`);
+            process.exit(1);
+    }
+}
+async function cmdConsolidateDetect(args) {
+    let limit = 200;
+    let threshold;
+    let namespace;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--limit' && args[i + 1]) {
+            const v = parseInt(args[++i], 10);
+            if (Number.isFinite(v))
+                limit = Math.max(1, Math.min(5000, v));
+        }
+        else if (args[i] === '--threshold' && args[i + 1]) {
+            const v = parseFloat(args[++i]);
+            if (Number.isFinite(v) && v >= 0 && v <= 1)
+                threshold = v;
+        }
+        else if (args[i] === '--ns' && args[i + 1]) {
+            namespace = args[++i];
+        }
+    }
+    const provider = makeProvider(loadConfig());
+    if (typeof provider.detectConsolidation !== 'function') {
+        console.error('This provider does not support consolidation (hosted-only — use the SDK).');
+        process.exit(1);
+    }
+    console.log(`Scanning up to ${limit} memories${namespace ? ` in namespace "${namespace}"` : ''}...`);
+    const result = await provider.detectConsolidation({ limit, threshold, namespace });
+    console.log(`consolidate detect done — scanned=${result.scanned} created=${result.proposalsCreated} already_known=${result.proposalsAlreadyKnown}`);
+    if (result.proposalsCreated > 0) {
+        console.log(`\nRun "mnueron consolidate list" to review pending proposals.`);
+    }
+}
+async function cmdConsolidateList(args) {
+    let status = 'pending';
+    let limit = 50;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--status' && args[i + 1]) {
+            const s = args[++i];
+            if (s === 'pending' || s === 'approved' || s === 'rejected')
+                status = s;
+            else if (s === 'all')
+                status = undefined;
+        }
+        else if (args[i] === '--limit' && args[i + 1]) {
+            const v = parseInt(args[++i], 10);
+            if (Number.isFinite(v))
+                limit = Math.max(1, Math.min(500, v));
+        }
+    }
+    const provider = makeProvider(loadConfig());
+    if (typeof provider.proposalsList !== 'function') {
+        console.error('This provider does not support consolidation.');
+        process.exit(1);
+    }
+    const props = await provider.proposalsList({ status, limit });
+    if (props.length === 0) {
+        console.log(`No ${status ?? ''} proposals.`);
+        return;
+    }
+    const trunc = (s, n) => (s.length > n ? s.slice(0, n - 1) + '…' : s);
+    console.log('id'.padEnd(38) +
+        'kind'.padEnd(14) +
+        'score'.padStart(6) +
+        '  ' +
+        'memory_a → memory_b');
+    console.log('-'.repeat(110));
+    for (const p of props) {
+        console.log(p.id.padEnd(38) +
+            trunc(p.kind, 12).padEnd(14) +
+            p.score.toFixed(2).padStart(6) +
+            '  ' +
+            `${p.memory_a_id.slice(0, 8)} → ${p.memory_b_id.slice(0, 8)}` +
+            (p.status !== 'pending' ? `  [${p.status}]` : ''));
+    }
+    console.log(`\n${props.length} proposal${props.length === 1 ? '' : 's'}.`);
+}
+async function cmdConsolidateReview(args, decision) {
+    const id = args.find((a) => !a.startsWith('--'));
+    if (!id) {
+        console.error(`Usage: mnueron consolidate ${decision === 'approved' ? 'approve' : 'reject'} <proposal-id>`);
+        process.exit(1);
+    }
+    const provider = makeProvider(loadConfig());
+    if (typeof provider.proposalReview !== 'function') {
+        console.error('This provider does not support consolidation.');
+        process.exit(1);
+    }
+    const updated = await provider.proposalReview(id, decision);
+    if (!updated) {
+        console.error(`Proposal not found: ${id}`);
+        process.exit(1);
+    }
+    console.log(`✅ Proposal ${id} marked ${decision}.`);
+}
+/**
+ * Procedural memory CLI — `mnueron procedural <sub>`
+ *
+ * The "remembered workflows" feature. Mem0 doesn't ship this — semantic +
+ * episodic only. Procedural memory captures step-by-step runbooks so an
+ * agent (or you) can recall "how do I deploy the API" and get the same
+ * sequence of steps that worked last time.
+ *
+ *   save <name> --steps "..."        Save explicit steps (JSON file or stdin)
+ *   save <name> --from-memory <id>   LLM-extract steps from an existing memory
+ *   list                             Show all procedural memories
+ *   show <name>                      Print the full runbook
+ *   recall <name>                    Same as show; bumps last_used_at
+ *   delete <id>                      Hard-delete a procedural memory
+ */
+async function cmdProcedural(args) {
+    const [sub, ...rest] = args;
+    switch (sub) {
+        case 'save': return cmdProceduralSave(rest);
+        case 'list': return cmdProceduralList(rest);
+        case 'show':
+        case 'recall': return cmdProceduralShow(rest, sub === 'recall');
+        case 'delete': return cmdProceduralDelete(rest);
+        case undefined:
+        case '--help':
+        case '-h':
+            console.log('Usage:\n' +
+                '  mnueron procedural save <name> --from-memory <memory-id> [--ns <name>]\n' +
+                '  mnueron procedural save <name> --steps-file <path.json> [--ns <name>] [--summary "..."]\n' +
+                '  mnueron procedural list   [--ns <name>] [--limit <n>]\n' +
+                '  mnueron procedural show   <name> [--ns <name>]\n' +
+                '  mnueron procedural recall <name> [--ns <name>]   (same as show, bumps last_used_at)\n' +
+                '  mnueron procedural delete <id>\n\n' +
+                'Examples:\n' +
+                '  mnueron procedural save deploy-api --from-memory abc-123\n' +
+                '  mnueron procedural recall deploy-api');
+            return;
+        default:
+            console.error(`Unknown procedural subcommand: ${sub}`);
+            process.exit(1);
+    }
+}
+async function cmdProceduralSave(args) {
+    const name = args.find((a) => !a.startsWith('--'));
+    if (!name) {
+        console.error('Usage: mnueron procedural save <name> [--from-memory <id> | --steps-file <path>] [--ns <name>] [--summary "..."]');
+        process.exit(1);
+    }
+    let fromMemory;
+    let stepsFile;
+    let ns;
+    let summary;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--from-memory' && args[i + 1])
+            fromMemory = args[++i];
+        else if (args[i] === '--steps-file' && args[i + 1])
+            stepsFile = args[++i];
+        else if (args[i] === '--ns' && args[i + 1])
+            ns = args[++i];
+        else if (args[i] === '--summary' && args[i + 1])
+            summary = args[++i];
+    }
+    const provider = makeProvider(loadConfig());
+    if (typeof provider.saveProcedural !== 'function') {
+        console.error('This provider does not support procedural memory.');
+        process.exit(1);
+    }
+    if (fromMemory) {
+        // LLM-extract path: pull the memory's content and ask Haiku/OpenAI
+        // to turn it into a runbook, then save the result.
+        if (!process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY) {
+            console.error('--from-memory requires ANTHROPIC_API_KEY or OPENAI_API_KEY in the environment.');
+            process.exit(1);
+        }
+        if (typeof provider.get !== 'function') {
+            console.error('Provider does not support memory.get.');
+            process.exit(1);
+        }
+        const memory = await provider.get(fromMemory);
+        if (!memory) {
+            console.error(`Memory not found: ${fromMemory}`);
+            process.exit(1);
+        }
+        const { extractProcedural } = await import('./store/procedural.js');
+        console.log('Extracting procedural memory via LLM…');
+        const extracted = await extractProcedural(memory.content, {});
+        if (!extracted) {
+            console.error('Could not extract a procedural memory from that content. Use --steps-file for explicit input.');
+            process.exit(1);
+        }
+        const saved = await provider.saveProcedural({
+            name: name,
+            namespace: ns,
+            summary: summary ?? extracted.summary,
+            steps: extracted.steps,
+            tools: extracted.tools,
+        });
+        console.log(`✅ Saved procedural memory "${saved.name}" (${saved.steps.length} steps)`);
+        return;
+    }
+    if (stepsFile) {
+        const fs = await import('node:fs/promises');
+        let raw;
+        try {
+            raw = await fs.readFile(stepsFile, 'utf8');
+        }
+        catch (e) {
+            console.error(`Could not read ${stepsFile}: ${e instanceof Error ? e.message : e}`);
+            process.exit(1);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (e) {
+            console.error('Steps file must be valid JSON.');
+            process.exit(1);
+        }
+        if (!Array.isArray(parsed)) {
+            console.error('Steps file must be a JSON array of { step, code?, why? } objects.');
+            process.exit(1);
+        }
+        const steps = parsed
+            .filter((s) => s && typeof s.step === 'string')
+            .map((s) => ({
+            step: String(s.step).trim(),
+            code: typeof s.code === 'string' ? s.code : undefined,
+            why: typeof s.why === 'string' ? s.why : undefined,
+        }));
+        if (steps.length === 0) {
+            console.error('No valid steps found in file.');
+            process.exit(1);
+        }
+        const saved = await provider.saveProcedural({
+            name,
+            namespace: ns,
+            summary: summary ?? '',
+            steps,
+        });
+        console.log(`✅ Saved procedural memory "${saved.name}" (${saved.steps.length} steps)`);
+        return;
+    }
+    console.error('Either --from-memory <id> or --steps-file <path.json> is required.');
+    process.exit(1);
+}
+async function cmdProceduralList(args) {
+    let ns;
+    let limit = 50;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--ns' && args[i + 1])
+            ns = args[++i];
+        else if (args[i] === '--limit' && args[i + 1]) {
+            const v = parseInt(args[++i], 10);
+            if (Number.isFinite(v))
+                limit = Math.max(1, Math.min(500, v));
+        }
+    }
+    const provider = makeProvider(loadConfig());
+    if (typeof provider.listProcedural !== 'function') {
+        console.error('This provider does not support procedural memory.');
+        process.exit(1);
+    }
+    const list = await provider.listProcedural({ namespace: ns, limit });
+    if (list.length === 0) {
+        console.log('No procedural memories yet. Use `mnueron procedural save` to create one.');
+        return;
+    }
+    const trunc = (s, n) => (s.length > n ? s.slice(0, n - 1) + '…' : s);
+    const fmt = (d) => new Date(d).toISOString().slice(0, 10);
+    console.log('name'.padEnd(28) +
+        'steps'.padStart(6) +
+        'used'.padStart(6) +
+        '  ' +
+        'last used'.padEnd(12) +
+        'summary');
+    console.log('-'.repeat(110));
+    for (const p of list) {
+        console.log(trunc(p.name, 26).padEnd(28) +
+            String(p.steps.length).padStart(6) +
+            String(p.use_count).padStart(6) +
+            '  ' +
+            fmt(p.last_used_at).padEnd(12) +
+            trunc(p.summary, 60));
+    }
+}
+async function cmdProceduralShow(args, bump) {
+    const name = args.find((a) => !a.startsWith('--'));
+    if (!name) {
+        console.error('Usage: mnueron procedural show <name> [--ns <name>]');
+        process.exit(1);
+    }
+    let ns;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--ns' && args[i + 1])
+            ns = args[++i];
+    }
+    const provider = makeProvider(loadConfig());
+    const fn = bump ? provider.recallProcedural : provider.getProcedural;
+    if (typeof fn !== 'function') {
+        console.error('This provider does not support procedural memory.');
+        process.exit(1);
+    }
+    const p = await fn.call(provider, name, ns);
+    if (!p) {
+        console.error(`Procedural memory not found: "${name}"${ns ? ` in namespace "${ns}"` : ''}`);
+        process.exit(1);
+    }
+    console.log(`# ${p.name}\n`);
+    if (p.summary)
+        console.log(`  ${p.summary}\n`);
+    console.log(`  id: ${p.id}`);
+    console.log(`  ns: ${p.namespace}`);
+    console.log(`  used: ${p.use_count} time${p.use_count === 1 ? '' : 's'}`);
+    console.log(`  last used: ${new Date(p.last_used_at).toISOString()}\n`);
+    console.log('## Steps');
+    p.steps.forEach((s, i) => {
+        console.log(`  ${i + 1}. ${s.step}`);
+        if (s.code)
+            console.log(`       $ ${s.code}`);
+        if (s.why)
+            console.log(`       — ${s.why}`);
+    });
+    if (p.tools.length > 0) {
+        console.log(`\n## Tools used\n  ${p.tools.join(', ')}`);
+    }
+}
+async function cmdProceduralDelete(args) {
+    const id = args.find((a) => !a.startsWith('--'));
+    if (!id) {
+        console.error('Usage: mnueron procedural delete <id>');
+        process.exit(1);
+    }
+    const provider = makeProvider(loadConfig());
+    if (typeof provider.deleteProcedural !== 'function') {
+        console.error('This provider does not support procedural memory.');
+        process.exit(1);
+    }
+    const ok = await provider.deleteProcedural(id);
+    if (!ok) {
+        console.error('Procedural memory not found.');
+        process.exit(1);
+    }
+    console.log('✅ Deleted.');
+}
+async function cmdWatch(args) {
+    // For now the only mode is `--claude-cowork`. Future modes can dispatch here.
+    if (!args.includes('--claude-cowork')) {
+        console.error('Usage: mnueron watch --claude-cowork [--interval <minutes>] [--ns <name>] [--once]');
+        process.exit(1);
+    }
+    let intervalMs;
+    let ns = 'claude-cowork';
+    let once = false;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--interval' && args[i + 1]) {
+            const n = Number(args[++i]);
+            if (Number.isFinite(n) && n > 0)
+                intervalMs = Math.floor(n * 60 * 1000);
+        }
+        else if (a === '--ns' && args[i + 1]) {
+            ns = args[++i];
+        }
+        else if (a === '--once') {
+            once = true;
+        }
+    }
+    const { runCoworkWatch } = await import('./watch/cowork.js');
+    const provider = makeProvider(loadConfig());
+    try {
+        await runCoworkWatch(provider, { intervalMs, namespace: ns, once });
+    }
+    finally {
+        await provider.close();
+    }
+}
+main().catch((e) => {
     console.error(e?.stack ?? e);
     process.exit(1);
 });