grepmax 0.13.6 → 0.14.1

package/README.md

@@ -135,6 +135,9 @@ Plugins auto-update when you run `npm install -g grepmax@latest` — no need to
 | `impact_analysis` | Dependents + affected tests for a symbol or file. |
 | `find_similar` | Vector similarity search. |
 | `build_context` | Token-budgeted topic summary. |
+| `investigate` | Agentic codebase Q&A using local LLM + gmax tools. |
+| `review_commit` | Review a git commit for bugs, security issues, and breaking changes. |
+| `review_report` | Get accumulated code review findings for the current project. |
 
 ## Search Options
 
@@ -174,6 +177,61 @@ gmax status                   # See all projects + watcher status
 
 The daemon auto-starts when you run `gmax add`, `gmax index`, `gmax remove`, or `gmax summarize`. It shuts down after 30 minutes of inactivity.
 
+## Local LLM (optional)
+
+gmax can use a local LLM (via llama-server) for agentic codebase investigation. This is entirely opt-in and disabled by default — gmax works fine without it.
+
+```bash
+gmax llm on                   # Enable LLM features (persists to config)
+gmax llm start                # Start llama-server (auto-starts daemon too)
+gmax llm status               # Check server status
+gmax llm stop                 # Stop llama-server
+gmax llm off                  # Disable LLM + stop server
+```
+
+### Investigate
+
+Ask questions about your codebase — the LLM autonomously uses gmax tools (search, trace, peek, impact, related) to gather evidence and synthesize an answer.
+
+```bash
+gmax investigate "how does authentication work?"
+gmax investigate "what would break if I changed VectorDB?" -v
+gmax investigate "where are API routes defined?" --root ~/project
+```
+
+### Review
+
+Automatic code review on git commits. Extracts the diff, gathers codebase context (callers, dependents, related files), and prompts the LLM for structured findings.
+
+```bash
+gmax review                           # Review HEAD
+gmax review --commit abc1234          # Review specific commit
+gmax review --commit HEAD~3 -v        # Verbose — shows context gathering + LLM progress
+gmax review report                    # Show accumulated findings
+gmax review report --json             # Raw JSON output
+gmax review clear                     # Clear report
+```
+
+#### Post-commit hook
+
+Install a git hook that automatically reviews every commit in the background via the daemon:
+
+```bash
+gmax review install                   # Install in current repo
+gmax review install ~/other-repo      # Install in another repo
+```
+
+The hook sends an IPC message to the daemon and returns instantly — it never blocks `git commit`. Findings accumulate in the report.
+
+### LLM Configuration
+
+| Variable | Description | Default |
+| --- | --- | --- |
+| `GMAX_LLM_MODEL` | Path to GGUF model file | (none) |
+| `GMAX_LLM_BINARY` | llama-server binary | `llama-server` |
+| `GMAX_LLM_PORT` | Server port | `8079` |
+| `GMAX_LLM_IDLE_TIMEOUT` | Minutes before auto-stop | `30` |
+
 ## Architecture
 
 All data lives in `~/.gmax/`:

package/dist/commands/mcp.js

@@ -305,6 +305,28 @@ const TOOLS = [
             required: ["question"],
         },
     },
+    {
+        name: "review_commit",
+        description: "Review a git commit for bugs, breaking changes, and security issues using local LLM + codebase context. Returns structured findings. Requires LLM to be enabled (gmax llm on).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                commit: { type: "string", description: "Git ref to review (default: HEAD)" },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "review_report",
+        description: "Get the accumulated code review report for the current project. Returns findings from all reviewed commits.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                json: { type: "boolean", description: "Return raw JSON instead of text (default: false)" },
+            },
+            required: [],
+        },
+    },
 ];
 // ---------------------------------------------------------------------------
 // Helpers
@@ -1833,7 +1855,7 @@ exports.mcp = new commander_1.Command("mcp")
         return { tools: TOOLS };
     }));
     server.setRequestHandler(types_js_1.CallToolRequestSchema, (request) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e, _f, _g;
         const { name, arguments: args } = request.params;
         const toolArgs = (args !== null && args !== void 0 ? args : {});
         const startMs = Date.now();
@@ -1919,26 +1941,77 @@ exports.mcp = new commander_1.Command("mcp")
                 }
                 break;
             }
+            case "review_commit": {
+                const commitRef = String(toolArgs.commit || "HEAD");
+                try {
+                    const { isDaemonRunning, sendDaemonCommand } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
+                    if (yield isDaemonRunning()) {
+                        const llmResp = yield sendDaemonCommand({ cmd: "llm-start" }, { timeoutMs: 90000 });
+                        if (!llmResp.ok) {
+                            result = err(`LLM server not available: ${llmResp.error}. Run \`gmax llm on && gmax llm start\`.`);
+                            break;
+                        }
+                    }
+                    else {
+                        result = err("LLM server not available. Run `gmax llm on && gmax llm start`.");
+                        break;
+                    }
+                    const { reviewCommit } = yield Promise.resolve().then(() => __importStar(require("../lib/llm/review")));
+                    const rev = yield reviewCommit({ commitRef, projectRoot });
+                    if (rev.clean) {
+                        result = ok(`Clean commit (${rev.commit}) — no issues found in ${rev.duration}s.`);
+                    }
+                    else {
+                        const { readReport } = yield Promise.resolve().then(() => __importStar(require("../lib/llm/report")));
+                        const report = readReport(projectRoot);
+                        const entry = report === null || report === void 0 ? void 0 : report.reviews.find((r) => r.commit === rev.commit);
+                        result = ok(JSON.stringify({ commit: rev.commit, findings: (_a = entry === null || entry === void 0 ? void 0 : entry.findings) !== null && _a !== void 0 ? _a : [], duration: rev.duration }, null, 2));
+                    }
+                }
+                catch (e) {
+                    result = err(`Review failed: ${e instanceof Error ? e.message : String(e)}`);
+                }
+                break;
+            }
+            case "review_report": {
+                try {
+                    const { readReport, formatReportText } = yield Promise.resolve().then(() => __importStar(require("../lib/llm/report")));
+                    const report = readReport(projectRoot);
+                    if (!report || report.reviews.length === 0) {
+                        result = ok("No review findings yet.");
+                    }
+                    else if (toolArgs.json) {
+                        result = ok(JSON.stringify(report, null, 2));
+                    }
+                    else {
+                        result = ok(formatReportText(report));
+                    }
+                }
+                catch (e) {
+                    result = err(`Report failed: ${e instanceof Error ? e.message : String(e)}`);
+                }
+                break;
+            }
             default:
                 return err(`Unknown tool: ${name}`);
         }
         // Best-effort query logging
         try {
             const { logQuery } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/query-log")));
-            const text = (_c = (_b = (_a = result.content) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : "";
+            const text = (_d = (_c = (_b = result.content) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.text) !== null && _d !== void 0 ? _d : "";
             const resultLines = text.split("\n").filter((l) => l.trim()).length;
             logQuery({
                 ts: new Date().toISOString(),
                 source: "mcp",
                 tool: name,
-                query: String((_f = (_e = (_d = toolArgs.query) !== null && _d !== void 0 ? _d : toolArgs.symbol) !== null && _e !== void 0 ? _e : toolArgs.target) !== null && _f !== void 0 ? _f : ""),
+                query: String((_g = (_f = (_e = toolArgs.query) !== null && _e !== void 0 ? _e : toolArgs.symbol) !== null && _f !== void 0 ? _f : toolArgs.target) !== null && _g !== void 0 ? _g : ""),
                 project: projectRoot,
                 results: resultLines,
                 ms: Date.now() - startMs,
                 error: result.isError ? text.slice(0, 200) : undefined,
             });
         }
-        catch (_g) { }
+        catch (_h) { }
         return result;
     }));
     yield server.connect(transport);

package/dist/commands/review.js

@@ -0,0 +1,237 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.review = void 0;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const commander_1 = require("commander");
+const exit_1 = require("../lib/utils/exit");
+const project_root_1 = require("../lib/utils/project-root");
+exports.review = new commander_1.Command("review")
+    .description("Review code changes using local LLM + codebase context")
+    .option("--commit <ref>", "Commit to review", "HEAD")
+    .option("--root <dir>", "Project root directory")
+    .option("--background", "Run review asynchronously via daemon", false)
+    .option("-v, --verbose", "Print progress to stderr", false)
+    .addHelpText("after", `
+Examples:
+  gmax review                           Review HEAD
+  gmax review --commit abc1234          Review specific commit
+  gmax review --background              Run async via daemon
+
+Subcommands:
+  gmax review report [--json]           Show accumulated findings
+  gmax review clear                     Clear report
+  gmax review install [DIR]             Install post-commit hook
+`)
+    .action((opts) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    try {
+        const root = opts.root ? path.resolve(opts.root) : process.cwd();
+        const projectRoot = (_a = (0, project_root_1.findProjectRoot)(root)) !== null && _a !== void 0 ? _a : root;
+        const commitRef = opts.commit;
+        if (opts.background) {
+            // Fire-and-forget via daemon
+            const { ensureDaemonRunning, sendDaemonCommand } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
+            if (!(yield ensureDaemonRunning())) {
+                console.error("Failed to start daemon");
+                process.exitCode = 1;
+                return;
+            }
+            const resp = yield sendDaemonCommand({ cmd: "review", root: projectRoot, commitRef }, { timeoutMs: 5000 });
+            if (!resp.ok) {
+                console.error(`Review failed: ${resp.error}`);
+                process.exitCode = 1;
+                return;
+            }
+            console.log(`Review queued for ${commitRef}`);
+            return;
+        }
+        // Foreground: ensure LLM server is running
+        const { ensureDaemonRunning, sendDaemonCommand } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
+        if (!(yield ensureDaemonRunning())) {
+            console.error("Failed to start daemon");
+            process.exitCode = 1;
+            return;
+        }
+        const llmResp = yield sendDaemonCommand({ cmd: "llm-start" }, { timeoutMs: 90000 });
+        if (!llmResp.ok) {
+            console.error(`LLM server error: ${llmResp.error}`);
+            console.error("Run `gmax llm on` to enable the LLM server.");
+            process.exitCode = 1;
+            return;
+        }
+        const { reviewCommit } = yield Promise.resolve().then(() => __importStar(require("../lib/llm/review")));
+        const result = yield reviewCommit({
+            commitRef,
+            projectRoot,
+            verbose: opts.verbose,
+        });
+        if (result.clean) {
+            console.log(`${result.commit} — clean (${result.duration}s)`);
+        }
+        else {
+            console.log(`${result.commit} — ${result.findingCount} finding(s) (${result.duration}s)`);
+            console.log("Run `gmax review report` to see details.");
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Review failed: ${msg}`);
+        process.exitCode = 1;
+    }
+    finally {
+        yield (0, exit_1.gracefulExit)();
+    }
+}));
+// --- Subcommands ---
+exports.review
+    .command("report")
+    .description("Show accumulated review findings")
+    .option("--json", "Output raw JSON", false)
+    .option("--root <dir>", "Project root directory")
+    .action((opts) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    try {
+        const root = opts.root ? path.resolve(opts.root) : process.cwd();
+        const projectRoot = (_a = (0, project_root_1.findProjectRoot)(root)) !== null && _a !== void 0 ? _a : root;
+        const { readReport, formatReportText } = yield Promise.resolve().then(() => __importStar(require("../lib/llm/report")));
+        const report = readReport(projectRoot);
+        if (!report || report.reviews.length === 0) {
+            console.log("No review findings yet.");
+            return;
+        }
+        if (opts.json) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log(formatReportText(report));
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Report failed: ${msg}`);
+        process.exitCode = 1;
+    }
+    finally {
+        yield (0, exit_1.gracefulExit)();
+    }
+}));
+exports.review
+    .command("clear")
+    .description("Clear the review report")
+    .option("--root <dir>", "Project root directory")
+    .action((opts) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    try {
+        const root = opts.root ? path.resolve(opts.root) : process.cwd();
+        const projectRoot = (_a = (0, project_root_1.findProjectRoot)(root)) !== null && _a !== void 0 ? _a : root;
+        const { clearReport } = yield Promise.resolve().then(() => __importStar(require("../lib/llm/report")));
+        clearReport(projectRoot);
+        console.log("Report cleared.");
+    }
+    finally {
+        yield (0, exit_1.gracefulExit)();
+    }
+}));
+exports.review
+    .command("install [dir]")
+    .description("Install post-commit hook for automatic review")
+    .action((dir) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        let targetDir;
+        if (dir) {
+            targetDir = path.resolve(dir);
+        }
+        else {
+            try {
+                targetDir = (0, node_child_process_1.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
+                    encoding: "utf-8",
+                }).trim();
+            }
+            catch (_a) {
+                console.error("Not in a git repo and no directory specified.");
+                process.exitCode = 1;
+                return;
+            }
+        }
+        const hooksDir = path.join(targetDir, ".git", "hooks");
+        if (!fs.existsSync(hooksDir)) {
+            console.error(`Not a git repo: ${targetDir}`);
+            process.exitCode = 1;
+            return;
+        }
+        const hookFile = path.join(hooksDir, "post-commit");
+        // Backup existing hook if it doesn't mention gmax
+        if (fs.existsSync(hookFile)) {
+            const existing = fs.readFileSync(hookFile, "utf-8");
+            if (!existing.includes("gmax review")) {
+                fs.copyFileSync(hookFile, `${hookFile}.gmax-backup`);
+                console.log("Backed up existing post-commit hook.");
+            }
+        }
+        // Resolve gmax binary path
+        let gmaxBin = "gmax";
+        try {
+            gmaxBin = (0, node_child_process_1.execFileSync)("which", ["gmax"], { encoding: "utf-8" }).trim();
+        }
+        catch (_b) { }
+        const hookContent = `#!/usr/bin/env bash
+# gmax review — async code review on commit
+# Always exits 0 to never block git
+"${gmaxBin}" review --commit HEAD --background --root "${targetDir}" || true
+`;
+        fs.writeFileSync(hookFile, hookContent, { mode: 0o755 });
+        console.log(`Installed post-commit hook in ${targetDir}`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Install failed: ${msg}`);
+        process.exitCode = 1;
+    }
+    finally {
+        yield (0, exit_1.gracefulExit)();
+    }
+}));

package/dist/index.js

@@ -57,6 +57,7 @@ const peek_1 = require("./commands/peek");
 const project_1 = require("./commands/project");
 const recent_1 = require("./commands/recent");
 const related_1 = require("./commands/related");
+const review_1 = require("./commands/review");
 const opencode_1 = require("./commands/opencode");
 const plugin_1 = require("./commands/plugin");
 const remove_1 = require("./commands/remove");
@@ -114,6 +115,7 @@ commander_1.program.addCommand(mcp_1.mcp);
 commander_1.program.addCommand(summarize_1.summarize);
 commander_1.program.addCommand(llm_1.llm);
 commander_1.program.addCommand(investigate_1.investigateCmd);
+commander_1.program.addCommand(review_1.review);
 // Setup & diagnostics
 commander_1.program.addCommand(setup_1.setup);
 commander_1.program.addCommand(config_1.config);

package/dist/lib/daemon/daemon.js

@@ -41,6 +41,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -131,8 +138,9 @@ class Daemon {
             // 7. Register daemon (only after resources are open)
             (0, watcher_store_1.registerDaemon)(process.pid);
             // 7. Subscribe to all registered projects (skip missing directories)
-            const projects = (0, project_registry_1.listProjects)().filter((p) => p.status === "indexed");
-            for (const p of projects) {
+            const allProjects = (0, project_registry_1.listProjects)();
+            const indexed = allProjects.filter((p) => p.status === "indexed");
+            for (const p of indexed) {
                 if (!fs.existsSync(p.root)) {
                     console.log(`[daemon] Skipping ${path.basename(p.root)} — directory not found`);
                     continue;
@@ -144,6 +152,13 @@ class Daemon {
                     console.error(`[daemon] Failed to watch ${path.basename(p.root)}:`, err);
                 }
             }
+            // 7b. Index pending projects in the background
+            const pending = allProjects.filter((p) => p.status === "pending" && fs.existsSync(p.root));
+            for (const p of pending) {
+                this.indexPendingProject(p.root).catch((err) => {
+                    console.error(`[daemon] Failed to index pending ${path.basename(p.root)}:`, err);
+                });
+            }
             // 8. Heartbeat
             this.heartbeatInterval = setInterval(() => {
                 (0, watcher_store_1.heartbeat)(process.pid);
@@ -265,10 +280,88 @@ class Daemon {
                 status: "watching",
                 lastHeartbeat: Date.now(),
             });
+            // Catchup scan — find files changed while daemon was offline
+            this.catchupScan(root, processor).catch((err) => {
+                console.error(`[daemon:${path.basename(root)}] Catchup scan failed:`, err);
+            });
             this.pendingOps.delete(root);
             console.log(`[daemon] Watching ${root}`);
         });
     }
+    catchupScan(root, processor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            const { walk } = yield Promise.resolve().then(() => __importStar(require("../index/walker")));
+            const { INDEXABLE_EXTENSIONS } = yield Promise.resolve().then(() => __importStar(require("../../config")));
+            const { isFileCached } = yield Promise.resolve().then(() => __importStar(require("../utils/cache-check")));
+            let queued = 0;
+            try {
+                for (var _d = true, _e = __asyncValues(walk(root, {
+                    additionalPatterns: ["**/.git/**", "**/.gmax/**", "**/.osgrep/**"],
+                })), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const relPath = _c;
+                    const absPath = path.join(root, relPath);
+                    const ext = path.extname(absPath).toLowerCase();
+                    const bn = path.basename(absPath).toLowerCase();
+                    if (!INDEXABLE_EXTENSIONS.has(ext) && !INDEXABLE_EXTENSIONS.has(bn))
+                        continue;
+                    try {
+                        const stats = yield fs.promises.stat(absPath);
+                        const cached = this.metaCache.get(absPath);
+                        if (!isFileCached(cached, stats)) {
+                            processor.handleFileEvent("change", absPath);
+                            queued++;
+                        }
+                    }
+                    catch (_g) { }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            if (queued > 0) {
+                console.log(`[daemon:${path.basename(root)}] Catchup: ${queued} file(s) changed while offline`);
+            }
+        });
+    }
+    indexPendingProject(root) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.withProjectLock(root, () => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                if (!this.vectorDb || !this.metaCache)
+                    return;
+                console.log(`[daemon] Indexing pending project: ${path.basename(root)}`);
+                this.vectorDb.pauseMaintenanceLoop();
+                try {
+                    const result = yield (0, syncer_1.initialSync)({
+                        projectRoot: root,
+                        vectorDb: this.vectorDb,
+                        metaCache: this.metaCache,
+                        onProgress: () => { this.resetActivity(); },
+                    });
+                    const proj = (0, project_registry_1.getProject)(root);
+                    if (proj) {
+                        (0, project_registry_1.registerProject)(Object.assign(Object.assign({}, proj), { lastIndexed: new Date().toISOString(), chunkCount: result.indexed, status: "indexed" }));
+                    }
+                    yield this.watchProject(root);
+                    console.log(`[daemon] Indexed ${path.basename(root)} (${result.total} files, ${result.indexed} chunks)`);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    console.error(`[daemon] indexPendingProject failed for ${path.basename(root)}: ${msg}`);
+                }
+                finally {
+                    (_a = this.vectorDb) === null || _a === void 0 ? void 0 : _a.resumeMaintenanceLoop();
+                }
+            }));
+        });
+    }
     unwatchProject(root) {
         return __awaiter(this, void 0, void 0, function* () {
             const processor = this.processors.get(root);
@@ -539,6 +632,24 @@ class Daemon {
         var _a;
         (_a = this.llmServer) === null || _a === void 0 ? void 0 : _a.touchIdle();
     }
+    reviewCommit(root, commitRef) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.resetActivity();
+            try {
+                if (!this.llmServer) {
+                    console.log("[review] daemon not initialized, skipping");
+                    return;
+                }
+                yield this.llmServer.ensure();
+                const { reviewCommit } = yield Promise.resolve().then(() => __importStar(require("../llm/review")));
+                const result = yield reviewCommit({ commitRef, projectRoot: root });
+                console.log(`[review] ${result.commit} — ${result.findingCount} finding(s) in ${result.duration}s`);
+            }
+            catch (err) {
+                console.error(`[review] failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        });
+    }
     shutdown() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c, _d;

package/dist/lib/daemon/ipc-handler.js

@@ -102,6 +102,14 @@ function handleCommand(daemon, cmd, conn) {
                     return null;
                 }
                 // --- LLM server management ---
+                case "review": {
+                    const root = String(cmd.root || "");
+                    const commitRef = String(cmd.commitRef || "HEAD");
+                    if (!root)
+                        return { ok: false, error: "missing root" };
+                    setImmediate(() => daemon.reviewCommit(root, commitRef));
+                    return { ok: true };
+                }
                 case "llm-start":
                     return yield daemon.llmStart();
                 case "llm-stop":

package/dist/lib/index/batch-processor.js

@@ -53,6 +53,7 @@ const pool_1 = require("../workers/pool");
 const watcher_batch_1 = require("./watcher-batch");
 const DEBOUNCE_MS = 2000;
 const MAX_RETRIES = 5;
+const MAX_BATCH_SIZE = 50;
 class ProjectBatchProcessor {
     constructor(opts) {
         this.pending = new Map();
@@ -112,12 +113,22 @@ class ProjectBatchProcessor {
                 (0, logger_1.log)(this.wtag, `Batch timed out after ${this.batchTimeoutMs}ms, aborting`);
                 batchAc.abort();
             }, this.batchTimeoutMs);
-            const batch = new Map(this.pending);
-            this.pending.clear();
+            const batch = new Map();
+            let taken = 0;
+            for (const [absPath, event] of this.pending) {
+                batch.set(absPath, event);
+                taken++;
+                if (taken >= MAX_BATCH_SIZE)
+                    break;
+            }
+            for (const key of batch.keys()) {
+                this.pending.delete(key);
+            }
             const filenames = [...batch.keys()].map((p) => path.basename(p));
             (0, logger_1.log)(this.wtag, `Processing ${batch.size} changed files: ${filenames.join(", ")}`);
             const start = Date.now();
             let reindexed = 0;
+            let processed = 0;
             try {
                 // No lock needed — daemon is the single writer to LanceDB/MetaCache
                 const pool = (0, pool_1.getWorkerPool)();
@@ -130,6 +141,10 @@ class ProjectBatchProcessor {
                     if (batchAc.signal.aborted)
                         break;
                     attempted.add(absPath);
+                    processed++;
+                    if (batch.size > 10 && (processed % 10 === 0 || processed === batch.size)) {
+                        (0, logger_1.log)(this.wtag, `Progress: ${processed}/${batch.size} (${reindexed} reindexed)`);
+                    }
                     if (event === "unlink") {
                         deletes.push(absPath);
                         metaDeletes.push(absPath);
@@ -219,7 +234,8 @@ class ProjectBatchProcessor {
                 if (reindexed > 0) {
                     (_a = this.onReindex) === null || _a === void 0 ? void 0 : _a.call(this, reindexed, duration);
                 }
-                (0, logger_1.log)(this.wtag, `Batch complete: ${batch.size} files, ${reindexed} reindexed (${(duration / 1000).toFixed(1)}s)`);
+                const remaining = this.pending.size;
+                (0, logger_1.log)(this.wtag, `Batch complete: ${batch.size} files, ${reindexed} reindexed (${(duration / 1000).toFixed(1)}s)${remaining > 0 ? ` — ${remaining} remaining` : ""}`);
                 for (const absPath of batch.keys()) {
                     this.retryCount.delete(absPath);
                 }