aidimag 1.0.0

package/dist/cli/commands/capture.js

@@ -0,0 +1,357 @@
+/**
+ * Capture & review commands: mine (commits/PRs), bootstrap, harvest, review.
+ */
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { MemoryStore, findRepoRoot } from "../../db/store.js";
+import { mineCommits, describeMineResult } from "../../capture/commit-miner.js";
+import { fail, autoSync, maybeRegenerateContext, printProposal, createPrompter } from "../shared.js";
+/**
+ * Conversational review: walk the queue one proposal at a time —
+ * keep / reword / drop / skip. The human gate, made friendly.
+ */
+async function interactiveReview(store) {
+    const { triagePending } = await import("../../capture/triage.js");
+    const triaged = triagePending(store, 1000);
+    const pending = triaged.map((t) => t.proposal);
+    const scoreOf = new Map(triaged.map((t) => [t.proposal.id, t]));
+    if (pending.length === 0) {
+        console.log("✨ Nothing waiting on you — the review queue is empty.");
+        return { kept: 0, rejected: 0 };
+    }
+    const { ask, close } = await createPrompter("q"); // closed stdin = quit
+    let kept = 0;
+    let rejected = 0;
+    let skipped = 0;
+    // T2: lazy ticket enrichment — fetched at review time, never at capture time
+    const reviewRoot = findRepoRoot();
+    const { ticketProviderFor } = await import("../../tickets/provider.js");
+    const provider = reviewRoot ? ticketProviderFor(reviewRoot) : null;
+    const plural = pending.length === 1 ? "proposal is" : "proposals are";
+    console.log(`🧠 ${pending.length} memory ${plural} waiting for your review (best first).\n`);
+    try {
+        for (let i = 0; i < pending.length; i++) {
+            const p = pending[i];
+            const src = p.source === "commit-miner" ? `mined from commit ${p.sourceRef?.slice(0, 8) ?? "?"}` : `proposed by ${p.source}`;
+            const tri = scoreOf.get(p.id);
+            console.log(`── ${i + 1} of ${pending.length} ── ${p.kind} · ${src}${tri ? ` · score ${tri.score.toFixed(2)}` : ""}`);
+            if (tri?.reasons.length)
+                console.log(`   (${tri.reasons.join(", ")})`);
+            console.log(`\n   “${p.claim}”\n`);
+            if (p.paths.length || p.symbols.length)
+                console.log(`   applies to: ${[...p.paths, ...p.symbols].join(", ")}`);
+            if (p.evidence.length)
+                console.log(`   evidence:   ${p.evidence.map((e) => `${e.type}:${e.payload.slice(0, 60)}`).join("  ")}`);
+            if (p.ticketRef) {
+                let ticketLine = p.ticketRef;
+                if (provider) {
+                    const t = await provider.getTicket(p.ticketRef).catch(() => null);
+                    if (t) {
+                        ticketLine = `${t.id} “${t.title}” (${t.type}, ${t.status}) — ${t.url}`;
+                        if (t.body)
+                            console.log(`   ticket:     ${ticketLine}\n               ${t.body.slice(0, 200).replace(/\s+/g, " ")}${t.body.length > 200 ? "…" : ""}`);
+                        else
+                            console.log(`   ticket:     ${ticketLine}`);
+                    }
+                    else {
+                        console.log(`   ticket:     ${ticketLine} (couldn't fetch — provider offline or ticket missing)`);
+                    }
+                }
+                else {
+                    console.log(`   ticket:     ${ticketLine}`);
+                }
+            }
+            if (p.rationale)
+                console.log(`   why:        ${p.rationale}`);
+            const ans = (await ask("\n   Keep this? [y]es · [e]dit wording · [n]o, drop it · [s]kip · [q]uit  "))
+                .trim()
+                .toLowerCase();
+            if (ans === "q" || ans === "quit") {
+                skipped += pending.length - i;
+                break;
+            }
+            else if (ans === "y" || ans === "yes") {
+                const m = store.approveProposal(p.id);
+                kept++;
+                console.log(`   ✓ Remembered (${m.id.slice(0, 8)}).\n`);
+            }
+            else if (ans === "e" || ans === "edit") {
+                const claim = (await ask("   Your wording (enter keeps the original):\n   › ")).trim();
+                const m = store.approveProposal(p.id, claim ? { claim } : undefined);
+                kept++;
+                console.log(claim ? `   ✓ Remembered with your wording (${m.id.slice(0, 8)}).\n` : `   ✓ Remembered as-is (${m.id.slice(0, 8)}).\n`);
+            }
+            else if (ans === "n" || ans === "no") {
+                store.rejectProposal(p.id);
+                rejected++;
+                console.log("   ✗ Dropped — it won't be proposed again.\n");
+            }
+            else {
+                skipped++;
+                console.log("   ↷ Skipped — it'll be here next time.\n");
+            }
+        }
+    }
+    finally {
+        close();
+    }
+    const bits = [
+        kept ? `${kept} remembered` : null,
+        rejected ? `${rejected} dropped` : null,
+        skipped ? `${skipped} left for later` : null,
+    ].filter(Boolean);
+    console.log(`Done — ${bits.length ? bits.join(", ") : "no changes"}.${kept ? " Run `dim verify` to put the new memories to the test." : ""}`);
+    return { kept, rejected };
+}
+export function registerCaptureCommands(program) {
+    program
+        .command("mine")
+        .description("Mine git history for memory candidates (queued for review, never auto-saved)")
+        .option("-n, --max <n>", "Max commits to scan", "500")
+        .option("--full", "Rescan from the beginning of history (ignore cursor)")
+        .option("--llm", "Deep mining: LLM reads each commit's message AND diff, synthesizes claims + suggested checks (needs Ollama/OPENAI_API_KEY; slower, much higher quality)")
+        .option("--prs", "Mine merged GitHub PRs + review comments instead of commits (needs the `gh` CLI and an LLM provider; review threads carry the unwritten rules)")
+        .option("-q, --quiet", "Only speak up when candidates are found (for the post-commit hook)")
+        .action(async (opts) => {
+        const root = findRepoRoot() ?? fail("not inside a git repo");
+        if (!existsSync(path.join(root, ".git")))
+            fail("commit mining requires a git repo");
+        const store = MemoryStore.open(root, { create: true });
+        if (opts.prs) {
+            const { minePrs, ghAvailable } = await import("../../capture/pr-miner.js");
+            if (!ghAvailable(root)) {
+                store.close();
+                fail("PR mining needs the GitHub CLI — install `gh` and run `gh auth login`");
+            }
+            const r = await minePrs(store, root, { max: opts.max ? parseInt(opts.max, 10) : undefined, all: Boolean(opts.full) });
+            if (!r.provider) {
+                store.close();
+                fail("no LLM provider available — review threads need synthesis; run Ollama or set OPENAI_API_KEY (see AIDIMAG_LLM)");
+            }
+            console.log(`Scanned ${r.scanned} merged PR(s) with ${r.provider}: ${r.proposed.length} proposal(s) queued` +
+                (r.skippedDuplicates ? `, ${r.skippedDuplicates} duplicate(s) skipped` : ""));
+            for (const p of r.proposed)
+                printProposal(p);
+            if (r.proposed.length)
+                console.log(`\nReview with \`dim review\`.`);
+            else if (r.scanned === 0)
+                console.log("No newly merged PRs since the last run (use --full to rescan).");
+            store.close();
+            return;
+        }
+        let res;
+        let llmProvider = null;
+        if (opts.llm) {
+            const { mineCommitsLlm } = await import("../../capture/commit-miner.js");
+            const r = await mineCommitsLlm(store, root, {
+                maxCommits: parseInt(opts.max, 10),
+                full: Boolean(opts.full),
+            });
+            res = r;
+            llmProvider = r.provider;
+            if (!llmProvider && !opts.quiet) {
+                console.log("(no LLM provider available — fell back to keyword mining; run Ollama or set OPENAI_API_KEY)");
+            }
+        }
+        else {
+            res = mineCommits(store, root, {
+                maxCommits: parseInt(opts.max, 10),
+                full: Boolean(opts.full),
+            });
+        }
+        if (opts.quiet) {
+            // post-commit hook mode: a single gentle nudge, nothing else
+            if (res.proposed.length > 0) {
+                const total = store.listProposals("PENDING", 1000).length;
+                console.log(`🧠 aidimag: this commit looks memory-worthy — ${res.proposed.length} proposal(s) queued` +
+                    ` (${total} pending). Review with \`dim review\`.`);
+            }
+            store.close();
+            return;
+        }
+        if (res.noCommits || res.noNewCommits) {
+            console.log(describeMineResult(res, { llmProvider, llmRequested: Boolean(opts.llm) }));
+            store.close();
+            return;
+        }
+        console.log(describeMineResult(res, { llmProvider, llmRequested: Boolean(opts.llm) }));
+        for (const p of res.proposed)
+            printProposal(p);
+        store.close();
+    });
+    program
+        .command("bootstrap")
+        .description("Give a fresh repo an instant brain: survey README/docs/manifests/structure/churn and LLM-extract an initial memory set (queued for review)")
+        .option("--force", "Re-run even if this repo was already bootstrapped")
+        .action(async (opts) => {
+        const root = findRepoRoot() ?? fail("not inside a git repo");
+        const store = MemoryStore.open(root, { create: true });
+        const { bootstrapRepo } = await import("../../capture/bootstrap.js");
+        console.log("Surveying the repo (docs, manifests, structure, churn)…");
+        const res = await bootstrapRepo(store, root, { force: Boolean(opts.force) });
+        if (res.alreadyBootstrapped) {
+            console.log("Already bootstrapped — use --force to re-run (dedupe absorbs repeats).");
+        }
+        else if (!res.provider) {
+            fail("no LLM provider available — run Ollama locally or set OPENAI_API_KEY (see AIDIMAG_LLM)");
+        }
+        else {
+            console.log(`Surveyed ${res.surveyedFiles.length} file(s) with ${res.provider}: ` +
+                `${res.proposed} proposal(s) queued${res.duplicates ? `, ${res.duplicates} duplicate(s) skipped` : ""}.`);
+            if (res.proposed) {
+                console.log(`\nYour repo's starter brain is ready for review: \`dim review\``);
+                console.log(`(then \`dim verify\` to put the suggested checks to the test)`);
+            }
+            else {
+                console.log("No durable claims extracted — the survey found little written-down knowledge. Feed docs into knowledge/ or use `dim mine --llm`.");
+            }
+        }
+        store.close();
+    });
+    program
+        .command("harvest")
+        .description("Harvest durable facts YOU typed into AI chats (Claude Code transcripts) into the review queue — local-only, secrets redacted")
+        .option("--all", "Rescan every session (ignore cursor; dedupe absorbs repeats)")
+        .option("--install-hook", "Wire `dim harvest -q` into this repo's Claude Code SessionEnd hook (.claude/settings.json)")
+        .option("-q, --quiet", "Only speak up when proposals are queued (for the SessionEnd hook)")
+        .action(async (opts) => {
+        const root = findRepoRoot() ?? fail("not inside a git repo");
+        const { harvestClaudeSessions, installClaudeSessionEndHook, claudeProjectDir } = await import("../../capture/harvest.js");
+        if (opts.installHook) {
+            const { installed, settingsPath } = installClaudeSessionEndHook(root);
+            console.log(installed
+                ? `✓ SessionEnd hook installed in ${settingsPath} — every Claude Code session is now harvested on close.`
+                : `Hook already present in ${settingsPath} — nothing to do.`);
+            return;
+        }
+        const store = MemoryStore.open(root, { create: true });
+        const res = await harvestClaudeSessions(store, root, { all: Boolean(opts.all) });
+        if (opts.quiet) {
+            if (res.proposed > 0) {
+                console.log(`🧠 aidimag: harvested ${res.proposed} memory candidate(s) from your AI chat — review with \`dim review\`.`);
+            }
+            store.close();
+            return;
+        }
+        if (!res.transcriptDir) {
+            console.log(`No Claude Code transcripts found for this repo (${claudeProjectDir(root) ?? "~/.claude/projects/<repo-slug>"} missing).`);
+            console.log("Transcripts appear after your first Claude Code session here. Cursor/Copilot chat harvesting: planned.");
+        }
+        else if (!res.provider) {
+            fail("no LLM provider available — run Ollama locally or set OPENAI_API_KEY (see AIDIMAG_LLM)");
+        }
+        else if (res.sessionsScanned === 0) {
+            console.log("No new sessions since the last harvest. Use --all to rescan everything.");
+        }
+        else {
+            console.log(`Scanned ${res.sessionsScanned} session(s), ${res.messagesConsidered} user message(s) via ${res.provider}: ` +
+                `${res.proposed} proposal(s) queued` +
+                (res.duplicates ? `, ${res.duplicates} duplicate(s) skipped` : "") +
+                ".");
+            if (res.proposed)
+                console.log(`Review with \`dim review\`.`);
+        }
+        if (!opts.installHook && res.transcriptDir) {
+            console.log(`(tip: \`dim harvest --install-hook\` runs this automatically when each Claude Code session ends)`);
+        }
+        store.close();
+    });
+    program
+        .command("review")
+        .description("Review pending memory proposals — interactive walkthrough by default (list | approve | reject for scripting)")
+        .argument("[action]", "interactive (default in a terminal) | list | approve | reject")
+        .argument("[id]", "Proposal id (8-char prefix ok); 'all' with approve/reject applies to every pending proposal")
+        .option("-n, --limit <n>", "Max proposals to list", "50")
+        .option("--min-score <s>", "With 'approve all': only approve proposals triaged at or above this score (0–1)")
+        .action(async (action, id, opts) => {
+        const store = MemoryStore.open();
+        const effective = action ?? (process.stdin.isTTY && process.stdout.isTTY ? "interactive" : "list");
+        switch (effective) {
+            case "interactive": {
+                const { kept, rejected } = await interactiveReview(store);
+                if (kept + rejected > 0)
+                    await autoSync(store);
+                break;
+            }
+            case "list": {
+                const { triagePending } = await import("../../capture/triage.js");
+                const triaged = triagePending(store, parseInt(opts.limit, 10));
+                if (triaged.length === 0)
+                    console.log("No pending proposals.");
+                for (const t of triaged) {
+                    console.log(`  score ${t.score.toFixed(2)}${t.reasons.length ? ` (${t.reasons.join(", ")})` : ""}`);
+                    printProposal(t.proposal);
+                }
+                if (triaged.length) {
+                    console.log(`\nApprove: dim review approve <id> | Reject: dim review reject <id> | Walkthrough: dim review`);
+                    console.log(`Batch: dim review approve all --min-score 0.7`);
+                }
+                break;
+            }
+            case "approve": {
+                if (!id)
+                    fail("usage: dim review approve <id|all> [--min-score <s>]");
+                let targets;
+                if (id === "all") {
+                    const { triagePending } = await import("../../capture/triage.js");
+                    const minScore = opts.minScore !== undefined ? parseFloat(opts.minScore) : null;
+                    const triaged = triagePending(store, 1000);
+                    const chosen = minScore === null ? triaged : triaged.filter((t) => t.score >= minScore);
+                    targets = chosen.map((t) => t.proposal.id);
+                    if (minScore !== null) {
+                        console.log(`${chosen.length} of ${triaged.length} pending proposal(s) scored ≥ ${minScore}.`);
+                    }
+                }
+                else {
+                    targets = [id];
+                }
+                for (const t of targets) {
+                    const entry = store.approveProposal(t);
+                    console.log(`✓ approved → memory ${entry.id.slice(0, 8)}: ${entry.claim}`);
+                }
+                break;
+            }
+            case "reject": {
+                if (!id)
+                    fail("usage: dim review reject <id|all>");
+                const targets = id === "all" ? store.listProposals("PENDING", 1000).map((p) => p.id) : [id];
+                for (const t of targets) {
+                    const p = store.rejectProposal(t);
+                    console.log(`✗ rejected ${p.id.slice(0, 8)}: ${p.claim}`);
+                }
+                break;
+            }
+            default:
+                fail(`unknown action '${action}'. Use: list | approve | reject (or no action for the walkthrough)`);
+        }
+        if (effective === "approve" || effective === "reject")
+            await autoSync(store);
+        await maybeRegenerateContext(store);
+        store.close();
+    });
+    const proposalsCmd = program.command("proposals").description("Proposal housekeeping");
+    proposalsCmd
+        .command("gc")
+        .description("Remove resolved (approved/rejected) proposal rows and tombstone for team sync")
+        .option("--dry-run", "Report how many rows would be removed without deleting")
+        .action(async (opts) => {
+        const store = MemoryStore.open();
+        try {
+            const { removed } = store.gcResolvedProposals({ dryRun: Boolean(opts.dryRun) });
+            if (removed === 0) {
+                console.log("No resolved proposals to remove.");
+            }
+            else if (opts.dryRun) {
+                console.log(`${removed} resolved proposal row(s) would be removed. Run without --dry-run to apply.`);
+            }
+            else {
+                console.log(`Removed ${removed} resolved proposal row(s). Run \`dim sync\` to propagate deletions.`);
+                await autoSync(store);
+            }
+        }
+        finally {
+            store.close();
+        }
+    });
+}
+//# sourceMappingURL=capture.js.map

package/dist/cli/commands/hosts.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Host-process & integration commands: ui (dashboard), generate-context, mcp.
+ */
+import type { Command } from "commander";
+export declare function registerHostCommands(program: Command): void;

package/dist/cli/commands/hosts.js

@@ -0,0 +1,98 @@
+/**
+ * Host-process & integration commands: ui (dashboard), generate-context, mcp.
+ */
+import { MemoryStore, findRepoRoot } from "../../db/store.js";
+import { fail, openBrowser } from "../shared.js";
+export function registerHostCommands(program) {
+    program
+        .command("ui")
+        .argument("[action]", "start (default) | stop")
+        .description("Manage the local web dashboard (memory list, review queue, visual graph)")
+        .option("-p, --port <n>", "Port", "4517")
+        .option("--no-open", "Don't open the browser automatically (start only)")
+        .action(async (action, opts) => {
+        const effectiveAction = action ?? "start";
+        if (effectiveAction === "stop") {
+            const port = parseInt(opts.port, 10);
+            const { exec } = await import("node:child_process");
+            const { promisify } = await import("node:util");
+            const execAsync = promisify(exec);
+            try {
+                // Find process listening on the port
+                const cmd = process.platform === "win32"
+                    ? `netstat -ano | findstr :${port}`
+                    : `lsof -ti:${port}`;
+                const { stdout } = await execAsync(cmd);
+                if (!stdout.trim()) {
+                    console.log(`No server found running on port ${port}`);
+                    return;
+                }
+                // Kill the process
+                const pids = process.platform === "win32"
+                    ? stdout.split("\n").map(line => line.trim().split(/\s+/).pop()).filter(Boolean)
+                    : stdout.trim().split("\n");
+                for (const pid of pids) {
+                    const killCmd = process.platform === "win32" ? `taskkill /F /PID ${pid}` : `kill ${pid}`;
+                    await execAsync(killCmd);
+                }
+                console.log(`✓ Stopped server on port ${port}`);
+            }
+            catch (err) {
+                if (err instanceof Error && "code" in err && err.code === 1) {
+                    console.log(`No server found running on port ${port}`);
+                }
+                else {
+                    fail(`Failed to stop server: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+        }
+        else if (effectiveAction === "start") {
+            const root = findRepoRoot() ?? fail("not inside a repo");
+            const store = MemoryStore.open(root);
+            const { startUiServer } = await import("../../ui/server.js");
+            const url = await startUiServer(store, root, parseInt(opts.port, 10));
+            console.log(`aidimag dashboard: ${url}  (Ctrl+C to stop)`);
+            if (opts.open)
+                await openBrowser(url);
+        }
+        else {
+            fail(`unknown action '${action}'. Use: start | stop`);
+        }
+    });
+    program
+        .command("generate-context")
+        .description("Render trustworthy memory into a static context file (CLAUDE.md, .cursorrules, .windsurfrules, AGENTS.md, copilot-instructions) for non-MCP AI tools")
+        .option("-f, --format <format>", "claude | cursorrules | copilot | windsurfrules | agents | all", "claude")
+        .option("--auto", "Also persist generateContext.auto in .aidimag/config.json so verify/review/sync keep it fresh")
+        .option("--no-auto", "Disable auto-regeneration (clears generateContext.auto)")
+        .action(async (opts) => {
+        const root = findRepoRoot() ?? fail("not inside a repo");
+        const store = MemoryStore.open(root);
+        const { generateContext } = await import("../../context/generate.js");
+        const format = String(opts.format).toLowerCase();
+        if (!["claude", "cursorrules", "copilot", "windsurfrules", "agents", "all"].includes(format)) {
+            fail(`invalid --format '${opts.format}'. Use: claude | cursorrules | copilot | windsurfrules | agents | all`);
+        }
+        const r = generateContext(store, root, format);
+        console.log(`📝 Wrote ${r.files.join(", ")} — ${r.total} memories (${r.pinned} pinned).`);
+        if (r.total === 0) {
+            console.log("   (no verified memories yet — run `dim remember` or approve proposals with `dim review`)");
+        }
+        // commander sets opts.auto=false only when --no-auto is passed; undefined otherwise
+        if (opts.auto === true || opts.auto === false) {
+            const { writeConfig } = await import("../../config.js");
+            writeConfig(root, { generateContext: opts.auto ? { auto: true, format: format } : { auto: false } });
+            console.log(opts.auto
+                ? `🔄 Auto-regeneration ON — verify/review/sync will refresh ${format === "all" ? "the context files" : r.files[0]}.`
+                : `Auto-regeneration OFF.`);
+        }
+        store.close();
+    });
+    program
+        .command("mcp")
+        .description("Run the aidimag MCP server (stdio)")
+        .action(async () => {
+        await import("../../mcp/server.js");
+    });
+}
+//# sourceMappingURL=hosts.js.map

package/dist/cli/commands/knowledge.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Knowledge-inbox commands: knowledge sync | status | list | watch.
+ */
+import type { Command } from "commander";
+export declare function registerKnowledgeCommands(program: Command): void;

package/dist/cli/commands/knowledge.js

@@ -0,0 +1,121 @@
+/**
+ * Knowledge-inbox commands: knowledge sync | status | list | watch.
+ */
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import { MemoryStore, findRepoRoot } from "../../db/store.js";
+import { resolveKnowledgeConfig } from "../../config.js";
+import { fail, autoSync, maybeRegenerateContext, printIngestReport } from "../shared.js";
+export function registerKnowledgeCommands(program) {
+    const knowledge = program
+        .command("knowledge")
+        .description("Manage the knowledge inbox: summarize dropped docs into reviewed, pinned memories")
+        .action(() => knowledge.help());
+    knowledge
+        .command("sync", { isDefault: true })
+        .description("Process the knowledge inbox now: summarize new docs into proposals (review with `dim review`)")
+        .action(async () => {
+        const root = findRepoRoot() ?? fail("not inside a repo");
+        const store = MemoryStore.open(root);
+        const { ingestAll } = await import("../../knowledge/ingest.js");
+        const cfg = resolveKnowledgeConfig(root);
+        const report = await ingestAll(store, root, cfg);
+        printIngestReport(report);
+        // Auto-approved knowledge (requireReview=false) becomes active memory → keep context fresh.
+        if (report.processed.some((d) => d.pinned)) {
+            await autoSync(store);
+            await maybeRegenerateContext(store);
+        }
+        store.close();
+    });
+    knowledge
+        .command("status")
+        .description("Show pending / skipped / processed counts for the knowledge inbox")
+        .action(async () => {
+        const root = findRepoRoot() ?? fail("not inside a repo");
+        const { knowledgeStatus } = await import("../../knowledge/ingest.js");
+        const s = await knowledgeStatus(root, resolveKnowledgeConfig(root));
+        console.log(`Knowledge inbox: ${s.folder}/`);
+        console.log(`  pending      ${s.pending.length}${s.pending.length ? "  → run \`dim knowledge sync\`" : ""}`);
+        for (const p of s.pending)
+            console.log(`    • ${p.file} (${p.bytes} bytes)`);
+        console.log(`  unsupported  ${s.unsupported.length}${s.unsupported.length ? "  (will move to skipped/ on next sync)" : ""}`);
+        for (const u of s.unsupported)
+            console.log(`    • ${u.file} — ${u.reason}`);
+        console.log(`  skipped/     ${s.skippedOnDisk.length}`);
+        for (const f of s.skippedOnDisk)
+            console.log(`    • ${f}`);
+        console.log(`  processed    ${s.processed.length}`);
+    });
+    knowledge
+        .command("list")
+        .description("List processed knowledge docs and the memories they produced")
+        .action(async () => {
+        const root = findRepoRoot() ?? fail("not inside a repo");
+        const { readManifest } = await import("../../knowledge/ingest.js");
+        const docs = readManifest(root).docs;
+        if (!docs.length) {
+            console.log("No knowledge docs processed yet. Drop files in the inbox and run `dim knowledge sync`.");
+            return;
+        }
+        for (const d of docs) {
+            const memo = d.memoryIds.length ? `${d.memoryIds.length} pinned` : `${d.proposalIds.length} proposed`;
+            console.log(`📄 ${d.file}  ·  ${d.claimCount} claim(s) (${memo})  ·  via ${d.via}  ·  ${d.date.slice(0, 10)}`);
+        }
+    });
+    knowledge
+        .command("watch")
+        .description("Foreground watcher: process the inbox automatically whenever a doc is dropped (Ctrl-C to stop)")
+        .option("-d, --debounce <ms>", "Settle time before processing a batch of drops", "750")
+        .action(async (opts) => {
+        const root = findRepoRoot() ?? fail("not inside a repo");
+        const cfg = resolveKnowledgeConfig(root);
+        const inbox = path.join(root, cfg.folder);
+        mkdirSync(inbox, { recursive: true });
+        const { ingestAll } = await import("../../knowledge/ingest.js");
+        const debounceMs = Math.max(100, parseInt(opts.debounce, 10) || 750);
+        let running = false;
+        let queued = false;
+        const run = async () => {
+            if (running) {
+                queued = true;
+                return;
+            }
+            running = true;
+            try {
+                const store = MemoryStore.open(root);
+                const report = await ingestAll(store, root, cfg);
+                if (report.processed.length || report.skipped.length || report.duplicates.length) {
+                    printIngestReport(report);
+                    if (report.processed.some((d) => d.pinned)) {
+                        await autoSync(store);
+                        await maybeRegenerateContext(store);
+                    }
+                }
+                store.close();
+            }
+            catch (err) {
+                console.error(`dim knowledge watch: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            finally {
+                running = false;
+                if (queued) {
+                    queued = false;
+                    void run();
+                }
+            }
+        };
+        let timer;
+        const { watch } = await import("node:fs");
+        const watcher = watch(inbox, { persistent: true }, () => {
+            if (timer)
+                clearTimeout(timer);
+            timer = setTimeout(() => void run(), debounceMs);
+        });
+        console.log(`👀 Watching ${cfg.folder}/ for dropped docs — Ctrl-C to stop.`);
+        await run(); // catch up on anything already sitting in the inbox
+        process.on("SIGINT", () => { watcher.close(); console.log("\nStopped."); process.exit(0); });
+        await new Promise(() => { });
+    });
+}
+//# sourceMappingURL=knowledge.js.map

package/dist/cli/commands/memory.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Core memory commands: init, remember, recall, reindex, status, log, gaps,
+ * refute, pin, unpin, forget.
+ */
+import type { Command } from "commander";
+export declare function registerMemoryCommands(program: Command): void;