grepmax 0.26.41 → 0.26.43

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "grepmax",
       "source": "./plugins/grepmax",
       "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
-      "version": "0.26.41",
+      "version": "0.26.43",
       "author": {
         "name": "Robert Owens",
         "email": "robowens@me.com"

package/README.md

@@ -450,6 +450,12 @@ gmax watch restart            # Restart daemon
 
 `gmax doctor` reports ANN index state. `ANN: vector index not built` is normal with the default exact-search configuration.
 
+Compaction pauses index writes, waits for pending writes to commit, and opens a fresh table snapshot for each attempt. Each optimize call makes at most two attempts. Before each attempt it checks current free space against twice the table's logical size plus the critical-space reserve (5 GB by default). If there is insufficient headroom, it skips the rewrite and logs the required space; search remains available. A successful prune can reclaim fragment copies left by failed attempts.
+
+`~/.gmax/logs/daemon.log` records compaction attempts and outcomes, including duration, logical size, disk size before/after, free space, and bytes reclaimed. `gmax status --json` exposes the last outcome under `daemon.compaction`; its `at` timestamp identifies when it was recorded. Five-minute resource snapshots track footprint, RSS, heap, external/ArrayBuffer memory, Lance cache, workers and pending work for memory investigations. Reading status uses retained snapshots and does not scan the index directory. Logs rotate to `daemon.log.prev`.
+
+`gmax doctor --fix` reports completed, skipped, failed, or unverified optimization. It exits nonzero when a requested optimization did not complete or an older daemon could not verify its outcome. A busy or failed daemon is never retried as a second writer in the CLI process.
+
 ### Known issues
 
 Some log output looks alarming but is expected and self-healing. Before filing a bug, check

package/dist/commands/doctor.js

@@ -51,6 +51,7 @@ const commander_1 = require("commander");
 const config_1 = require("../config");
 const embedding_status_1 = require("../lib/index/embedding-status");
 const index_config_1 = require("../lib/index/index-config");
+const doctor_optimize_1 = require("../lib/utils/doctor-optimize");
 const doctor_status_1 = require("../lib/utils/doctor-status");
 const exit_1 = require("../lib/utils/exit");
 const lock_1 = require("../lib/utils/lock");
@@ -343,7 +344,7 @@ exports.doctor = new commander_1.Command("doctor")
     .option("--agent", "Compact output for AI agents", false)
     .action((opts) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b;
-    var _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+    var _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
     if (!opts.agent)
         console.log("gmax Doctor\n");
     const root = config_1.PATHS.globalRoot;
@@ -572,7 +573,7 @@ exports.doctor = new commander_1.Command("doctor")
                         ? "LOW"
                         : "ok";
         }
-        catch (_q) { }
+        catch (_p) { }
         const staleChunkerProjects = projects.filter((p) => { var _a; return p.status === "indexed" &&
             ((_a = p.chunkerVersion) !== null && _a !== void 0 ? _a : 1) < config_1.CONFIG.CHUNKER_VERSION; });
         const staleEmbeddingProjects = projects.filter((p) => p.status === "indexed" &&
@@ -787,7 +788,7 @@ exports.doctor = new commander_1.Command("doctor")
                         yield mc.close();
                     }
                 }
-                catch (_r) { }
+                catch (_q) { }
             }
         }
         // --fix auto-remediation
@@ -820,34 +821,22 @@ exports.doctor = new commander_1.Command("doctor")
                 // daemon up it owns compaction; without one we are the sole process
                 // and can do it in-process safely.
                 const { sendDaemonCommand } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
-                const resp = yield sendDaemonCommand({ cmd: "optimize" }, { timeoutMs: 10 * 60 * 1000 });
-                let via = "daemon";
-                if (!resp.ok) {
-                    // Only fall back when the daemon could not take it. A daemon that
-                    // answered with a real failure should surface, not be retried here
-                    // as a competing writer.
-                    const reason = String((_l = resp.error) !== null && _l !== void 0 ? _l : "");
-                    // Fall back ONLY when nothing is listening. A daemon that is merely
-                    // too old ("unknown command") or busy ("timeout") is still a live
-                    // writer on the store, so optimizing here would recreate the
-                    // two-writer case this routing exists to prevent.
-                    const daemonAbsent = reason.includes("ECONNREFUSED") || reason.includes("ENOENT");
-                    if (daemonAbsent) {
-                        yield db.optimize(3, 0);
-                        via = "in-process (no daemon)";
-                    }
-                    else if (reason.includes("unknown command")) {
-                        via = "";
-                        console.log("WARN  Optimize skipped: the running daemon predates the optimize command. Restart it (gmax watch --daemon -b) and re-run.");
+                // Release the diagnostic reader before the daemon prunes old files.
+                yield db.close();
+                const report = yield (0, doctor_optimize_1.runDoctorOptimize)(() => sendDaemonCommand({ cmd: "optimize" }, { timeoutMs: 10 * 60 * 1000 }), () => __awaiter(void 0, void 0, void 0, function* () {
+                    const repairDb = new VectorDB(config_1.PATHS.lancedbDir);
+                    try {
+                        return yield repairDb.optimize();
                     }
-                    else {
-                        via = "";
-                        console.log(`WARN  Optimize failed via daemon: ${reason}`);
+                    finally {
+                        yield repairDb.close();
                     }
-                }
-                if (via && !opts.agent)
-                    console.log(`ok  Optimize complete (${via})`);
-                fixed++;
+                }));
+                console.log((0, doctor_optimize_1.formatDoctorOptimize)(report, opts.agent));
+                if (report.status === "completed")
+                    fixed++;
+                else
+                    process.exitCode = 1;
             }
             // Only roots whose volume is mounted and whose directory is still gone
             // reach this list — projects on an unplugged drive are classified
@@ -877,7 +866,7 @@ exports.doctor = new commander_1.Command("doctor")
                         const done = yield sendStreamingCommand({ cmd: "index", root: p.root, reset: true }, () => { }).catch((e) => ({ ok: false, error: String(e) }));
                         if (done.ok &&
                             (!("degraded" in done) || done.degraded !== true)) {
-                            const chunks = (_m = done.indexed) !== null && _m !== void 0 ? _m : 0;
+                            const chunks = (_l = done.indexed) !== null && _l !== void 0 ? _l : 0;
                             if (opts.agent) {
                                 console.log(`stale_chunker_reindexed\tname=${name}\tchunks=${chunks}`);
                             }
@@ -889,14 +878,14 @@ exports.doctor = new commander_1.Command("doctor")
                         else if (!opts.agent) {
                             const degraded = "degraded" in done && done.degraded === true;
                             const reason = degraded
-                                ? `${(_o = ("scanErrors" in done ? done.scanErrors : 0)) !== null && _o !== void 0 ? _o : 0} scan errors, ${(_p = ("failedFiles" in done ? done.failedFiles : 0)) !== null && _p !== void 0 ? _p : 0} file failures`
+                                ? `${(_m = ("scanErrors" in done ? done.scanErrors : 0)) !== null && _m !== void 0 ? _m : 0} scan errors, ${(_o = ("failedFiles" in done ? done.failedFiles : 0)) !== null && _o !== void 0 ? _o : 0} file failures`
                                 : done.error;
                             console.log(`FAIL  ${name}: reindex failed (${reason})`);
                         }
                     }
                 }
             }
-            if (fixed === 0) {
+            if (fixed === 0 && !needsOptimize) {
                 if (!opts.agent)
                     console.log("ok  Nothing to fix");
             }

package/dist/commands/mcp.js

@@ -88,6 +88,7 @@ const searcher_1 = require("../lib/search/searcher");
 const annotator_1 = require("../lib/skeleton/annotator");
 const skeletonizer_1 = require("../lib/skeleton/skeletonizer");
 const symbol_extractor_1 = require("../lib/skeleton/symbol-extractor");
+const compaction_result_1 = require("../lib/store/compaction-result");
 const meta_cache_1 = require("../lib/store/meta-cache");
 const cross_project_1 = require("../lib/utils/cross-project");
 const daemon_client_1 = require("../lib/utils/daemon-client");
@@ -1786,6 +1787,7 @@ exports.mcp = new commander_1.Command("mcp")
                         ? `Last indexed: ${currentProject.lastIndexed}`
                         : "",
                     watcherLine,
+                    (0, compaction_result_1.formatCompactionStatus)(daemonStatus.compaction),
                     `Projects: ${projects.length} indexed (call list_projects for names + per-project chunk counts)`,
                 ].filter(Boolean);
                 return ok(lines.join("\n"));

package/dist/commands/status.js

@@ -96,7 +96,9 @@ function loadStatusView(projects) {
                         chunkCounts.set(project.root, stats.chunks);
                     }
                 }
-                const daemon = Object.assign(Object.assign({}, (resp.resources !== undefined
+                const daemon = Object.assign(Object.assign(Object.assign({}, (resp.compaction !== undefined
+                    ? { compaction: resp.compaction }
+                    : {})), (resp.resources !== undefined
                     ? { resources: resp.resources }
                     : {})), { pid: typeof resp.pid === "number" ? resp.pid : null, uptimeSec: typeof resp.uptime === "number" ? resp.uptime : null, 
                     // Older daemons do not report these.
@@ -200,7 +202,7 @@ function buildStatusJson(input) {
             : null);
     }
     return {
-        daemon: Object.assign({ running: d !== undefined, pid: (_d = d === null || d === void 0 ? void 0 : d.pid) !== null && _d !== void 0 ? _d : null, since: (d === null || d === void 0 ? void 0 : d.uptimeSec) != null ? now - d.uptimeSec * 1000 : null, workerThreads: (_e = d === null || d === void 0 ? void 0 : d.workerThreads) !== null && _e !== void 0 ? _e : null }, ((d === null || d === void 0 ? void 0 : d.resources) !== undefined ? { resources: d.resources } : {})),
+        daemon: Object.assign(Object.assign({ running: d !== undefined, pid: (_d = d === null || d === void 0 ? void 0 : d.pid) !== null && _d !== void 0 ? _d : null, since: (d === null || d === void 0 ? void 0 : d.uptimeSec) != null ? now - d.uptimeSec * 1000 : null, workerThreads: (_e = d === null || d === void 0 ? void 0 : d.workerThreads) !== null && _e !== void 0 ? _e : null }, ((d === null || d === void 0 ? void 0 : d.resources) !== undefined ? { resources: d.resources } : {})), ((d === null || d === void 0 ? void 0 : d.compaction) !== undefined ? { compaction: d.compaction } : {})),
         settings: {
             embedMode: globalConfig.embedMode,
             modelTier: globalConfig.modelTier,

package/dist/lib/daemon/daemon.js

@@ -609,13 +609,23 @@ class Daemon {
      * fall back to in-process only when no daemon answers, and are then the sole
      * writer themselves.
      */
+    compactionStatus() {
+        var _a;
+        var _b;
+        return (_b = (_a = this.vectorDb) === null || _a === void 0 ? void 0 : _a.compactionStatus()) !== null && _b !== void 0 ? _b : null;
+    }
     runOptimize() {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             const db = this.vectorDb;
             if (!db)
                 throw new Error("daemon resources not ready");
-            yield this.runSharedOperation("store-maintenance", undefined, () => db.runMaintenance({ force: true }));
-            return { ok: true };
+            const compaction = yield this.runSharedOperation("store-maintenance", undefined, () => db.runMaintenance({ force: true }));
+            if (!compaction)
+                return { ok: false, error: "maintenance produced no compaction outcome" };
+            return Object.assign({ ok: compaction.status === "completed", compaction }, (compaction.status === "completed"
+                ? {}
+                : { error: (_a = compaction.reason) !== null && _a !== void 0 ? _a : compaction.status }));
         });
     }
     operationStatus() {
@@ -1867,13 +1877,18 @@ class Daemon {
         if (this.recycleDueSinceMs === null &&
             !ageExceeded &&
             sampleFootprint &&
-            RSS_WATERMARK_MB > 0 &&
-            // A fresh daemon above the watermark would recycle in a loop; give the
-            // caches a chance to settle before judging the footprint.
-            ageMs > FOOTPRINT_RECYCLE_MIN_AGE_MS) {
+            RSS_WATERMARK_MB > 0) {
             footprintMb = (0, process_footprint_1.readFootprintMb)();
         }
-        const footprintExceeded = footprintMb !== null && footprintMb > RSS_WATERMARK_MB;
+        // The existing five-minute probe also records a baseline for memory soaks;
+        // the intervening heartbeat ticks add no footprint probe or snapshot.
+        if (sampleFootprint)
+            this.logResourceSnapshot("periodic", footprintMb);
+        const footprintExceeded = footprintMb !== null &&
+            footprintMb > RSS_WATERMARK_MB &&
+            // Sampling young daemons is useful; recycling them would loop before
+            // their caches have had a chance to settle.
+            ageMs > FOOTPRINT_RECYCLE_MIN_AGE_MS;
         if (this.recycleDueSinceMs === null) {
             if (!ageExceeded && !footprintExceeded)
                 return;

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

@@ -122,8 +122,8 @@ function startHeartbeat(conn, intervalMs = HEARTBEAT_INTERVAL_MS) {
  */
 function handleCommand(daemon, cmd, conn) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        var _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b;
+        var _c, _d, _e, _f, _g, _h, _j, _k, _l;
         try {
             (0, logger_1.debug)("daemon", `ipc cmd=${cmd.cmd}${cmd.root ? ` root=${cmd.root}` : ""}`);
             if (cmd.cmd !== "ping" &&
@@ -186,7 +186,8 @@ function handleCommand(daemon, cmd, conn) {
                         diskPressure: daemon.getDiskPressure(),
                         mlx: daemon.getMlxStatus(),
                         workers: daemon.workerCount(),
-                        resources: (_b = (_a = daemon.resourceSnapshot) === null || _a === void 0 ? void 0 : _a.call(daemon)) !== null && _b !== void 0 ? _b : null,
+                        resources: (_c = (_a = daemon.resourceSnapshot) === null || _a === void 0 ? void 0 : _a.call(daemon)) !== null && _c !== void 0 ? _c : null,
+                        compaction: (_d = (_b = daemon.compactionStatus) === null || _b === void 0 ? void 0 : _b.call(daemon)) !== null && _d !== void 0 ? _d : null,
                         workerThreads: config_1.WORKER_THREADS_SETTING,
                     };
                 case "optimize":
@@ -202,14 +203,14 @@ function handleCommand(daemon, cmd, conn) {
                     return Object.assign({ ok: true }, (yield daemon.projectStats(root)));
                 }
                 case "shutdown": {
-                    const reason = String((_c = cmd.reason) !== null && _c !== void 0 ? _c : "unknown");
-                    const fromPid = (_d = cmd.from_pid) !== null && _d !== void 0 ? _d : "?";
-                    const fromPpid = (_e = cmd.from_ppid) !== null && _e !== void 0 ? _e : "?";
-                    const fromVer = (_f = cmd.from_version) !== null && _f !== void 0 ? _f : "?";
+                    const reason = String((_e = cmd.reason) !== null && _e !== void 0 ? _e : "unknown");
+                    const fromPid = (_f = cmd.from_pid) !== null && _f !== void 0 ? _f : "?";
+                    const fromPpid = (_g = cmd.from_ppid) !== null && _g !== void 0 ? _g : "?";
+                    const fromVer = (_h = cmd.from_version) !== null && _h !== void 0 ? _h : "?";
                     const fromArgv = Array.isArray(cmd.from_argv)
                         ? cmd.from_argv.join(" ")
                         : "?";
-                    const fromParentCmd = (_g = cmd.from_parent_cmd) !== null && _g !== void 0 ? _g : "?";
+                    const fromParentCmd = (_j = cmd.from_parent_cmd) !== null && _j !== void 0 ? _j : "?";
                     console.log(`[daemon] shutdown command received via IPC: reason=${reason} from_pid=${fromPid} from_ppid=${fromPpid} from_version=${fromVer} from_argv=[${fromArgv}] from_parent_cmd=[${fromParentCmd}]`);
                     setImmediate(() => daemon.shutdown());
                     return { ok: true };
@@ -274,8 +275,8 @@ function handleCommand(daemon, cmd, conn) {
                                 return { ok: false, error: "invalid project_roots" };
                             }
                             for (const prefix of [
-                                ...((_h = filters === null || filters === void 0 ? void 0 : filters.inPrefixes) !== null && _h !== void 0 ? _h : []),
-                                ...((_j = filters === null || filters === void 0 ? void 0 : filters.excludePrefixes) !== null && _j !== void 0 ? _j : []),
+                                ...((_k = filters === null || filters === void 0 ? void 0 : filters.inPrefixes) !== null && _k !== void 0 ? _k : []),
+                                ...((_l = filters === null || filters === void 0 ? void 0 : filters.excludePrefixes) !== null && _l !== void 0 ? _l : []),
                             ]) {
                                 (0, path_containment_1.resolveContainedPath)(projectRoot, prefix);
                             }

package/dist/lib/store/compaction-result.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skippedCompaction = skippedCompaction;
+exports.parseCompactionResult = parseCompactionResult;
+exports.formatCompactionStatus = formatCompactionStatus;
+function skippedCompaction(reason) {
+    return {
+        status: "skipped",
+        reason,
+        at: Date.now(),
+        attempts: 0,
+        elapsedMs: 0,
+    };
+}
+function parseCompactionResult(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const r = value;
+    if (!["completed", "skipped", "failed"].includes(r.status) ||
+        !Number.isFinite(r.at) ||
+        Number.isNaN(new Date(r.at).getTime()) ||
+        !Number.isFinite(r.attempts) ||
+        !Number.isFinite(r.elapsedMs) ||
+        (r.reason !== undefined && typeof r.reason !== "string"))
+        return undefined;
+    return r;
+}
+function formatCompactionStatus(value) {
+    var _a;
+    const result = parseCompactionResult(value);
+    if (!result)
+        return undefined;
+    const reason = (_a = result.reason) === null || _a === void 0 ? void 0 : _a.replace(/[\r\n\t]/g, " ").slice(0, 512);
+    return `Last compaction: ${result.status} at ${new Date(result.at).toISOString()} (${result.attempts} attempts, ${result.elapsedMs}ms)${reason ? ` — ${reason}` : ""}`;
+}

package/dist/lib/store/vector-db.js

@@ -57,6 +57,7 @@ const cleanup_1 = require("../utils/cleanup");
 const filter_builder_1 = require("../utils/filter-builder");
 const logger_1 = require("../utils/logger");
 const ann_config_1 = require("./ann-config");
+const compaction_result_1 = require("./compaction-result");
 const store_lease_1 = require("./store-lease");
 /**
  * Find abandoned Lance scratch files under `<lancedbDir>/ *.lance/data`.
@@ -188,6 +189,9 @@ const COMPACTION_MIN_INTERVAL_MS = 30 * 60 * 1000;
  * so a store that cannot be improved stops paying for the attempt.
  */
 const COMPACTION_MAX_INTERVAL_MS = 6 * 60 * 60 * 1000;
+// Failed rewrites leave complete fragment copies until a later successful prune.
+// One fresh-snapshot retry is enough; five attempts stranded ~70 GB in Oct 2026.
+const COMPACTION_MAX_ATTEMPTS = 2;
 /**
  * Bounds for LanceDB's per-connection caches.
  *
@@ -227,6 +231,7 @@ class VectorDB {
         /** Only an index owner may create/rebuild shared indexes — see markIndexOwner. */
         this.indexOwner = false;
         this.lastOptimizeDidWork = false;
+        this.lastCompactionResult = null;
         /** Compaction rate limiter — see COMPACTION_MIN_INTERVAL_MS. */
         this.lastCompactionMs = 0;
         this.compactionIntervalMs = COMPACTION_MIN_INTERVAL_MS;
@@ -1082,8 +1087,18 @@ class VectorDB {
             }
         });
     }
+    compactionStatus() {
+        return this.lastCompactionResult ? Object.assign({}, this.lastCompactionResult) : null;
+    }
+    recordSkippedCompaction(reason) {
+        const result = (0, compaction_result_1.skippedCompaction)(reason);
+        this.lastCompactionResult = result;
+        (0, logger_1.log)("vectordb", `Compaction result: ${JSON.stringify(result)}`);
+        return Object.assign({}, result);
+    }
     optimize() {
-        return __awaiter(this, arguments, void 0, function* (retries = 5, retentionMs = 0, bypassExclusiveMutation = false) {
+        return __awaiter(this, arguments, void 0, function* (retries = COMPACTION_MAX_ATTEMPTS, retentionMs = 0, bypassExclusiveMutation = false) {
+            var _a;
             if (!bypassExclusiveMutation) {
                 while (this.exclusiveMutationPromise)
                     yield this.exclusiveMutationPromise;
@@ -1093,7 +1108,7 @@ class VectorDB {
             if (this.compactingPromise) {
                 (0, logger_1.debug)("vectordb", "Optimize already in progress, skipping");
                 yield this.compactingPromise;
-                return;
+                return ((_a = this.compactionStatus()) !== null && _a !== void 0 ? _a : (0, compaction_result_1.skippedCompaction)("compaction unavailable"));
             }
             this.lastOptimizeDidWork = false;
             let resolveCompacting;
@@ -1101,13 +1116,59 @@ class VectorDB {
                 resolveCompacting = resolve;
             });
             this.activeCompactions++;
+            const startedAt = Date.now();
+            let attempts = 0;
+            let logicalBytes;
+            let diskBytesBefore;
+            let freeBytesBefore;
+            const finish = (status, reason, bytesReclaimed) => {
+                const result = {
+                    status,
+                    at: Date.now(),
+                    attempts,
+                    elapsedMs: Date.now() - startedAt,
+                    reason: reason === null || reason === void 0 ? void 0 : reason.replace(/[\r\n\t]/g, " ").slice(0, 512),
+                    logicalBytes,
+                    diskBytesBefore,
+                    freeBytesBefore,
+                    diskBytesAfter: this.getDirectorySize(this.lancedbDir),
+                    freeBytesAfter: this.getAvailableBytes(),
+                    bytesReclaimed,
+                };
+                this.lastCompactionResult = result;
+                (0, logger_1.log)("vectordb", `Compaction result: ${JSON.stringify(result)}`);
+                return Object.assign({}, result);
+            };
             try {
-                const table = yield this.ensureTableUnsafe();
-                const cutoff = new Date(Date.now() - retentionMs);
+                const maxAttempts = Math.min(retries, COMPACTION_MAX_ATTEMPTS);
                 let rebuiltFts = false;
-                for (let attempt = 1; attempt <= retries; attempt++) {
+                for (let attempt = 1; attempt <= maxAttempts; attempt++) {
                     yield this.drainWrites();
                     try {
+                        // Open AFTER outstanding writes commit, and reopen on every retry.
+                        // A handle opened before drainWrites carries the old snapshot even
+                        // though new writes are gated. Reusing it repeats the same conflict.
+                        const table = yield this.ensureTableUnsafe();
+                        const { totalBytes } = yield table.stats();
+                        if (!Number.isFinite(totalBytes) || totalBytes < 0) {
+                            throw new Error("Cannot estimate compaction size from table stats");
+                        }
+                        // Bypass the cached pressure check: a failed attempt can consume a
+                        // whole table within its 30s cache window. Budget two logical copies
+                        // for rewrite/index overhead, leaving the critical reserve untouched.
+                        const availableBytes = this.getAvailableBytes();
+                        const requiredBytes = totalBytes * 2 + config_1.DISK_CRITICAL_BYTES;
+                        logicalBytes = totalBytes;
+                        const diskBytes = this.getDirectorySize(this.lancedbDir);
+                        diskBytesBefore !== null && diskBytesBefore !== void 0 ? diskBytesBefore : (diskBytesBefore = diskBytes);
+                        freeBytesBefore !== null && freeBytesBefore !== void 0 ? freeBytesBefore : (freeBytesBefore = availableBytes);
+                        if (availableBytes < requiredBytes) {
+                            const reason = `insufficient rewrite headroom (${(availableBytes / Math.pow(1024, 3)).toFixed(1)}GB free, ${(requiredBytes / Math.pow(1024, 3)).toFixed(1)}GB required)`;
+                            (0, logger_1.log)("vectordb", `Optimize skipped: ${reason}`);
+                            return finish("skipped", reason);
+                        }
+                        attempts++;
+                        (0, logger_1.log)("vectordb", `Compaction attempt: ${JSON.stringify({ attempt, maxAttempts, logicalBytes, diskBytes, freeBytes: availableBytes, requiredBytes })}`);
                         const done = (0, logger_1.timer)("vectordb", "optimize");
                         // deleteUnverified deletes files Lance cannot prove are unreferenced.
                         // LanceDB's own docs: only safe "if you can guarantee that no other
@@ -1119,7 +1180,8 @@ class VectorDB {
                         // Anything new that calls optimize() must preserve that: either be the
                         // daemon, or be the only process on the store.
                         const stats = yield table.optimize({
-                            cleanupOlderThan: cutoff,
+                            // Include fragment copies left by earlier failed attempts.
+                            cleanupOlderThan: new Date(Date.now() - retentionMs),
                             deleteUnverified: true,
                         });
                         done();
@@ -1136,24 +1198,25 @@ class VectorDB {
                         else {
                             (0, logger_1.debug)("vectordb", "Optimize: nothing to compact or prune");
                         }
-                        return;
+                        return finish("completed", undefined, prune.bytesRemoved);
                     }
                     catch (e) {
                         const msg = e instanceof Error ? e.message : String(e);
                         if (msg.includes("Nothing to do")) {
                             (0, logger_1.debug)("vectordb", "Optimize: nothing to do");
-                            return;
+                            return finish("completed", "nothing to compact or prune", 0);
                         }
+                        (0, logger_1.log)("vectordb", `Compaction attempt failed: ${JSON.stringify({ attempt, elapsedMs: Date.now() - startedAt, diskBytes: this.getDirectorySize(this.lancedbDir), freeBytes: this.getAvailableBytes(), reason: msg.slice(0, 512) })}`);
                         // ENOSPC: return immediately — retrying will only make things worse
                         if (msg.includes("No space left on device") ||
                             msg.includes("os error 28")) {
                             (0, logger_1.log)("vectordb", `Optimize failed (ENOSPC): disk full — skipping retries`);
-                            return;
+                            return finish("failed", "disk full — skipping retries");
                         }
-                        if (attempt < retries &&
+                        if (attempt < maxAttempts &&
                             (msg.includes("conflict") || msg.includes("Retryable"))) {
                             const delay = 1000 * Math.pow(2, (attempt - 1));
-                            (0, logger_1.log)("vectordb", `Optimize conflict (attempt ${attempt}/${retries}), retrying in ${delay}ms`);
+                            (0, logger_1.log)("vectordb", `Optimize conflict (attempt ${attempt}/${maxAttempts}), retrying with a fresh snapshot in ${delay}ms`);
                             yield new Promise((r) => setTimeout(r, delay));
                             continue;
                         }
@@ -1165,7 +1228,7 @@ class VectorDB {
                         // Unsafe variant: the public createFTSIndex waits on
                         // compactingPromise, which we hold.
                         if (msg.includes("Panic")) {
-                            if (attempt < retries &&
+                            if (attempt < maxAttempts &&
                                 !rebuiltFts &&
                                 !this.ftsPanicRecoveryExhausted) {
                                 rebuiltFts = true;
@@ -1178,7 +1241,7 @@ class VectorDB {
                                 catch (rebuildErr) {
                                     this.ftsPanicRecoveryExhausted = true;
                                     (0, logger_1.log)("vectordb", `FTS rebuild failed: ${rebuildErr}`);
-                                    return;
+                                    return finish("failed", `FTS rebuild failed: ${rebuildErr}`);
                                 }
                             }
                             if (rebuiltFts) {
@@ -1187,9 +1250,10 @@ class VectorDB {
                             }
                         }
                         (0, logger_1.log)("vectordb", `Optimize failed: ${msg}`);
-                        return;
+                        return finish("failed", msg);
                     }
                 }
+                return finish("skipped", "no compaction attempts requested");
             }
             finally {
                 this.compactingPromise = null;
@@ -1212,16 +1276,17 @@ class VectorDB {
         return __awaiter(this, arguments, void 0, function* (options = {}) {
             if (this.maintenanceRunning) {
                 (0, logger_1.debug)("vectordb", "Maintenance already running, skipping");
-                return;
+                return (0, compaction_result_1.skippedCompaction)("maintenance already running");
             }
             this.maintenanceRunning = true;
             const epochSnapshot = this.writeEpoch;
+            let result;
             try {
                 const pressure = this.checkDiskPressure();
                 if (pressure === "critical") {
                     const freeGb = (this.getAvailableBytes() / 1024 / 1024 / 1024).toFixed(1);
                     (0, logger_1.log)("vectordb", `Maintenance skipped: disk critically low (${freeGb}GB free)`);
-                    return;
+                    return this.recordSkippedCompaction(`disk critically low (${freeGb}GB free)`);
                 }
                 if (!options.force &&
                     epochSnapshot === this.maintainedEpoch &&
@@ -1250,12 +1315,12 @@ class VectorDB {
                 }
                 else if (pressure === "low") {
                     (0, logger_1.log)("vectordb", `Low disk — single-pass optimize (no bloat retry)`);
-                    yield this.optimize(1, 0, true);
+                    result = yield this.optimize(1, 0, true);
                     this.noteCompaction(this.lastOptimizeDidWork);
                 }
                 else {
                     // Normal maintenance: full optimize + bloat check
-                    yield this.optimize(5, 0, true);
+                    result = yield this.optimize(5, 0, true);
                     // Track across both passes: `lastOptimizeDidWork` is reset per optimize()
                     // call, so a productive first pass followed by a barren bloat retry would
                     // otherwise read as unproductive and trigger a spurious backoff.
@@ -1280,7 +1345,7 @@ class VectorDB {
                             if (bloatRatio > 2.0 && this.checkDiskPressure() === "ok") {
                                 (0, logger_1.log)("vectordb", `Bloat detected after optimize: ${(diskSize / 1024 / 1024).toFixed(0)}MB disk vs ${(logicalSize / 1024 / 1024).toFixed(0)}MB logical (${bloatRatio.toFixed(1)}x) — retrying`);
                                 yield new Promise((r) => setTimeout(r, 2000));
-                                yield this.optimize(5, 0, true);
+                                result = yield this.optimize(5, 0, true);
                                 didWork = didWork || this.lastOptimizeDidWork;
                             }
                         }
@@ -1292,6 +1357,7 @@ class VectorDB {
                     yield this.readTableVersion(maintainedTable);
                 this.maintainedEpoch = epochSnapshot;
                 this.lastMaintenanceMs = Date.now();
+                return result;
             }
             finally {
                 this.maintenanceRunning = false;
@@ -1356,9 +1422,9 @@ class VectorDB {
                         return false;
                     }
                     (0, logger_1.log)("vectordb", `Fragment threshold exceeded (${stats.fragmentStats.numSmallFragments} > ${threshold}) — compacting`);
-                    yield this.optimize(2, 0, true);
+                    const result = yield this.optimize(2, 0, true);
                     this.noteCompaction(this.lastOptimizeDidWork);
-                    return true;
+                    return result.status === "completed";
                 }
             }
             catch (err) {

package/dist/lib/utils/doctor-optimize.js

@@ -0,0 +1,81 @@
+"use strict";
+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.runDoctorOptimize = runDoctorOptimize;
+exports.formatDoctorOptimize = formatDoctorOptimize;
+const compaction_result_1 = require("../store/compaction-result");
+/** A live daemon's failed repair must never become a competing local rewrite. */
+function runDoctorOptimize(send, optimizeInProcess) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const response = yield send();
+        const result = (0, compaction_result_1.parseCompactionResult)(response.compaction);
+        if (result) {
+            return {
+                status: !response.ok && result.status === "completed"
+                    ? "failed"
+                    : result.status,
+                via: "daemon",
+                reason: (_a = result.reason) !== null && _a !== void 0 ? _a : (response.ok ? undefined : String(response.error)),
+                result,
+            };
+        }
+        if (response.ok) {
+            return {
+                status: "unverified",
+                via: "daemon",
+                reason: "daemon did not report a compaction outcome; restart it with the current gmax version",
+            };
+        }
+        const reason = String((_b = response.error) !== null && _b !== void 0 ? _b : "unknown failure");
+        // Socket errors are returned as exact errno codes by sendDaemonCommand.
+        // An ENOENT inside a daemon's failure message is not proof it is absent.
+        if (reason === "ECONNREFUSED" || reason === "ENOENT") {
+            try {
+                const local = yield optimizeInProcess();
+                return {
+                    status: local.status,
+                    via: "in-process",
+                    reason: local.reason,
+                    result: local,
+                };
+            }
+            catch (error) {
+                return { status: "failed", via: "in-process", reason: String(error) };
+            }
+        }
+        return {
+            status: reason.includes("unknown command") ? "skipped" : "failed",
+            via: "daemon",
+            reason,
+        };
+    });
+}
+function formatDoctorOptimize(report, agent) {
+    var _a;
+    const reason = (_a = report.reason) === null || _a === void 0 ? void 0 : _a.replace(/[\r\n\t]/g, " ").slice(0, 512);
+    if (agent) {
+        const r = report.result;
+        return [
+            `optimize`,
+            `status=${report.status}`,
+            `via=${report.via}`,
+            ...(r ? [`attempts=${r.attempts}`, `elapsed_ms=${r.elapsedMs}`] : []),
+            ...(typeof (r === null || r === void 0 ? void 0 : r.bytesReclaimed) === "number"
+                ? [`bytes_reclaimed=${r.bytesReclaimed}`]
+                : []),
+            ...(reason ? [`reason=${reason}`] : []),
+        ].join("\t");
+    }
+    if (report.status === "completed")
+        return `ok  Optimize complete (${report.via})`;
+    return `${report.status === "failed" ? "FAIL" : "WARN"}  Optimize ${report.status} (${report.via}): ${reason !== null && reason !== void 0 ? reason : "no outcome reported"}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.26.41",
+  "version": "0.26.43",
   "author": "Robert Owens <78518764+reowens@users.noreply.github.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {

package/plugins/grepmax/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.26.41",
+  "version": "0.26.43",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",