grepmax 0.26.54 → 0.26.56

package/dist/lib/daemon/mlx-server-manager.js

@@ -203,8 +203,8 @@ class MlxServerManager {
     }
     ensureInternal(model) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
-            var _d, _e, _f, _g, _h;
+            var _a, _b, _c, _d, _e;
+            var _f, _g, _h, _j, _k;
             this.phase = "probing";
             const health = yield this.probeHealth(this.port);
             if (this.shouldStop())
@@ -256,15 +256,31 @@ class MlxServerManager {
                 console.warn("[daemon] MLX embed server not found — falling back to CPU embeddings");
                 return;
             }
-            const owner = (_d = (_b = (_a = this.deps).createOwnerToken) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _d !== void 0 ? _d : (0, node_crypto_1.randomUUID)();
-            const openLog = (_e = this.deps.openLog) !== null && _e !== void 0 ? _e : log_rotate_1.openRotatedLog;
-            const closeFd = (_f = this.deps.closeFd) !== null && _f !== void 0 ? _f : fs.closeSync;
+            // A health/termination await may outlive the daemon's outer admission.
+            // Refusal must not leak a log descriptor or look like a successful startup.
+            // Disable automatic retries until an explicit admitted ensure occurs;
+            // fire-and-forget health callers must catch the propagated rejection.
+            try {
+                (_b = (_a = this.deps).assertExpansionAdmission) === null || _b === void 0 ? void 0 : _b.call(_a);
+            }
+            catch (error) {
+                this.enabled = false;
+                this.phase = "failed";
+                this.lastError = `MLX expansion admission refused: ${error instanceof Error ? error.message : "host admission unavailable"}`;
+                console.error(`[daemon] ${this.lastError}`);
+                throw new Error(this.lastError);
+            }
+            if (this.shouldStop())
+                return;
+            const owner = (_f = (_d = (_c = this.deps).createOwnerToken) === null || _d === void 0 ? void 0 : _d.call(_c)) !== null && _f !== void 0 ? _f : (0, node_crypto_1.randomUUID)();
+            const openLog = (_g = this.deps.openLog) !== null && _g !== void 0 ? _g : log_rotate_1.openRotatedLog;
+            const closeFd = (_h = this.deps.closeFd) !== null && _h !== void 0 ? _h : fs.closeSync;
             const logFd = openLog(path.join(config_1.PATHS.logsDir, "mlx-embed-server.log"));
             const env = Object.assign(Object.assign({}, process.env), { MLX_EMBED_MODEL: model, GMAX_EMBED_OWNER_TOKEN: owner, HF_HOME: (0, mlx_hf_cache_1.resolveMlxHfHome)(model) });
             this.phase = "starting";
             let child;
             try {
-                child = ((_g = this.deps.spawn) !== null && _g !== void 0 ? _g : node_child_process_1.spawn)("uv", ["run", "python", "server.py"], {
+                child = ((_j = this.deps.spawn) !== null && _j !== void 0 ? _j : node_child_process_1.spawn)("uv", ["run", "python", "server.py"], {
                     cwd: serverDir,
                     detached: true,
                     stdio: ["ignore", logFd, logFd],
@@ -281,7 +297,7 @@ class MlxServerManager {
                 try {
                     closeFd(logFd);
                 }
-                catch (_j) { }
+                catch (_l) { }
             }
             if (!child.pid) {
                 this.lastError = "spawned MLX process has no PID";
@@ -340,7 +356,7 @@ class MlxServerManager {
             child.off("error", onError);
             child.off("exit", onExit);
             yield this.terminateOwned(candidate);
-            this.lastError = (_h = (_c = startup.error) === null || _c === void 0 ? void 0 : _c.message) !== null && _h !== void 0 ? _h : (this.shouldStop() ? "MLX startup cancelled" : "MLX startup timed out");
+            this.lastError = (_k = (_e = startup.error) === null || _e === void 0 ? void 0 : _e.message) !== null && _k !== void 0 ? _k : (this.shouldStop() ? "MLX startup cancelled" : "MLX startup timed out");
             if (!this.shouldStop()) {
                 this.phase = "failed";
                 console.error(`[daemon] ${this.lastError} — falling back to CPU embeddings`);

package/dist/lib/store/maintenance-policy.js

@@ -0,0 +1,172 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiskPressureError = exports.FULL_TABLE_MAINTENANCE_DISABLED_REASON = void 0;
+exports.fullTableMaintenanceDisabled = fullTableMaintenanceDisabled;
+exports.availableStoreDiskBytes = availableStoreDiskBytes;
+exports.assertFreshDiskMutationAllowed = assertFreshDiskMutationAllowed;
+exports.storeMutationDeniedReason = storeMutationDeniedReason;
+exports.assertStoreMutationAllowed = assertStoreMutationAllowed;
+exports.maintenancePolicyPath = maintenancePolicyPath;
+exports.recordMaintenanceContainment = recordMaintenanceContainment;
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const config_1 = require("../../config");
+const autostart_1 = require("../utils/autostart");
+const safety_latch_1 = require("../utils/safety-latch");
+exports.FULL_TABLE_MAINTENANCE_DISABLED_REASON = "full-table maintenance disabled by host-safety containment; disk recovery is pending";
+/** This release has no production override: force, configuration and persisted
+ * state cannot enable rewriting. Tests may mock this module to cover the old
+ * native algorithm without turning it into a supported production entry point. */
+function fullTableMaintenanceDisabled() {
+    return true;
+}
+class DiskPressureError extends Error {
+    constructor(message = "Disk critically low or unknown — writes suspended") {
+        super(message);
+        this.name = "DiskPressureError";
+    }
+}
+exports.DiskPressureError = DiskPressureError;
+/** Fresh, bounded filesystem sample. ENOENT alone permits trying an ancestor;
+ * permission errors, invalid values and all other uncertainty refuse writes. */
+function availableStoreDiskBytes(storeDir) {
+    let existing = path.resolve(storeDir);
+    for (;;) {
+        try {
+            const stats = fs.statfsSync(existing);
+            const available = stats.bavail * stats.bsize;
+            return Number.isFinite(available) && available >= 0
+                ? available
+                : Number.NaN;
+        }
+        catch (error) {
+            const parent = path.dirname(existing);
+            if (error.code !== "ENOENT" ||
+                parent === existing)
+                return Number.NaN;
+            existing = parent;
+        }
+    }
+}
+/** Reusable admission for LMDB and other store mutations. Never cached. */
+function assertFreshDiskMutationAllowed(storeDir) {
+    const available = availableStoreDiskBytes(storeDir);
+    if (!Number.isFinite(available) || available < config_1.DISK_CRITICAL_BYTES)
+        throw new DiskPressureError();
+    return available;
+}
+function storeMutationDeniedReason() {
+    const safety = (0, safety_latch_1.safetyStopReason)();
+    if (safety !== null)
+        return `host safety stop: ${safety}`;
+    return (0, autostart_1.autostartDisabledReason)() !== null
+        ? "store mutations are quarantined while daemon autostart is disabled"
+        : null;
+}
+function assertStoreMutationAllowed() {
+    const reason = storeMutationDeniedReason();
+    if (reason !== null)
+        throw new Error(`gmax store mutation blocked: ${reason}`);
+}
+function maintenancePolicyPath(storeDir) {
+    return path.join(storeDir, ".gmax-maintenance-policy.json");
+}
+/** Persist a zero-rewrite receipt once. Unknown/corrupt/unwritable state never
+ * weakens the immutable default. No timestamps or budgets authorize native work. */
+function recordMaintenanceContainment(storeDir) {
+    let temporary;
+    try {
+        fs.mkdirSync(storeDir, { recursive: true, mode: 0o700 });
+        const storeIdentity = fs.realpathSync(storeDir);
+        const target = maintenancePolicyPath(storeIdentity);
+        if (fs.existsSync(target)) {
+            const stat = fs.lstatSync(target);
+            if (!stat.isFile() || stat.size > 16 * 1024)
+                throw new Error("unsafe maintenance policy file");
+            const previous = JSON.parse(fs.readFileSync(target, "utf8"));
+            if (previous.schemaVersion === 1 &&
+                previous.storeIdentity === storeIdentity &&
+                previous.mode === "disabled" &&
+                previous.rewriteBudgetBytes === 0 &&
+                previous.cleanupPending === true) {
+                fs.chmodSync(target, 0o600);
+                return exports.FULL_TABLE_MAINTENANCE_DISABLED_REASON;
+            }
+        }
+        const policy = {
+            schemaVersion: 1,
+            storeIdentity,
+            mode: "disabled",
+            reason: exports.FULL_TABLE_MAINTENANCE_DISABLED_REASON,
+            recordedAt: Date.now(),
+            rewriteBudgetBytes: 0,
+            cleanupPending: true,
+        };
+        temporary = path.join(storeIdentity, `.gmax-maintenance-${(0, node_crypto_1.randomUUID)()}.tmp`);
+        const descriptor = fs.openSync(temporary, "wx", 0o600);
+        try {
+            fs.writeFileSync(descriptor, `${JSON.stringify(policy)}\n`);
+            fs.fsyncSync(descriptor);
+        }
+        finally {
+            fs.closeSync(descriptor);
+        }
+        fs.renameSync(temporary, target);
+        temporary = undefined;
+        const directory = fs.openSync(storeIdentity, "r");
+        try {
+            fs.fsyncSync(directory);
+        }
+        finally {
+            fs.closeSync(directory);
+        }
+        return exports.FULL_TABLE_MAINTENANCE_DISABLED_REASON;
+    }
+    catch (_a) {
+        return `${exports.FULL_TABLE_MAINTENANCE_DISABLED_REASON}; persistent policy unavailable or invalid (still disabled)`;
+    }
+    finally {
+        if (temporary) {
+            try {
+                fs.unlinkSync(temporary);
+            }
+            catch (_b) {
+                // Failed receipt cleanup cannot authorize maintenance.
+            }
+        }
+    }
+}

package/dist/lib/store/meta-cache.js

@@ -67,14 +67,39 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const lmdb_1 = require("lmdb");
 const cleanup_1 = require("../utils/cleanup");
+const maintenance_policy_1 = require("./maintenance-policy");
 class MetaCache {
     constructor(lmdbPath) {
+        this.lmdbPath = lmdbPath;
         this.closed = false;
-        fs.mkdirSync(path.dirname(lmdbPath), { recursive: true });
+        let diskAllowsWrites = false;
+        try {
+            (0, maintenance_policy_1.assertFreshDiskMutationAllowed)(lmdbPath);
+            diskAllowsWrites = true;
+        }
+        catch (_a) {
+            /* Unknown/critical disk allows existing-cache reads only. */
+        }
+        this.readOnly = (0, maintenance_policy_1.storeMutationDeniedReason)() !== null || !diskAllowsWrites;
+        if (this.readOnly) {
+            // Quarantine permits reads of an existing cache, never creating one.
+            try {
+                fs.lstatSync(lmdbPath);
+            }
+            catch (_b) {
+                throw new Error("gmax metadata cache is quarantined or disk-constrained and unavailable");
+            }
+        }
+        else {
+            (0, maintenance_policy_1.assertStoreMutationAllowed)();
+            (0, maintenance_policy_1.assertFreshDiskMutationAllowed)(lmdbPath);
+            fs.mkdirSync(path.dirname(lmdbPath), { recursive: true });
+        }
         this.db = (0, lmdb_1.open)({
             path: lmdbPath,
             compression: true,
             cache: true,
+            readOnly: this.readOnly,
         });
         this.unregisterCleanup = (0, cleanup_1.registerCleanup)(() => this.close());
     }
@@ -129,11 +154,19 @@ class MetaCache {
         });
     }
     put(filePath, entry) {
+        this.assertWritable();
         this.db.put(filePath, entry);
     }
     delete(filePath) {
+        this.assertWritable();
         this.db.remove(filePath);
     }
+    assertWritable() {
+        (0, maintenance_policy_1.assertStoreMutationAllowed)();
+        (0, maintenance_policy_1.assertFreshDiskMutationAllowed)(this.lmdbPath);
+        if (this.readOnly)
+            throw new Error("gmax metadata cache was opened read-only; reopen after reviewing containment");
+    }
     entries() {
         return __asyncGenerator(this, arguments, function* entries_1() {
             var _a, e_3, _b, _c;

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

@@ -66,6 +66,7 @@ const query_timeout_1 = require("../utils/query-timeout");
 const ann_config_1 = require("./ann-config");
 const compaction_result_1 = require("./compaction-result");
 const lancedb = __importStar(require("./lance-sdk"));
+const maintenance_policy_1 = require("./maintenance-policy");
 const store_lease_1 = require("./store-lease");
 /**
  * Find abandoned Lance scratch files under `<lancedbDir>/ *.lance/data`.
@@ -134,13 +135,8 @@ function sweepStaleLanceTempFiles(lancedbDir, minAgeMs = config_1.STALE_TEMP_FIL
     }
     return { filesRemoved, bytesFreed };
 }
-class DiskPressureError extends Error {
-    constructor(message = "Disk critically low — writes suspended") {
-        super(message);
-        this.name = "DiskPressureError";
-    }
-}
-exports.DiskPressureError = DiskPressureError;
+var maintenance_policy_2 = require("./maintenance-policy");
+Object.defineProperty(exports, "DiskPressureError", { enumerable: true, get: function () { return maintenance_policy_2.DiskPressureError; } });
 /**
  * Detects "Not found: <hash>.lance" errors from LanceDB — these indicate the
  * manifest references a fragment file that doesn't exist on disk, typically
@@ -279,6 +275,10 @@ class VectorDB {
      * Call once from the daemon — replaces per-processor maintenance intervals.
      */
     startMaintenanceLoop(runOperation) {
+        if ((0, maintenance_policy_1.fullTableMaintenanceDisabled)()) {
+            this.recordSkippedCompaction((0, maintenance_policy_1.recordMaintenanceContainment)(this.lancedbDir));
+            return;
+        }
         if (runOperation)
             this.maintenanceRunner = runOperation;
         if (this.maintenanceTimer)
@@ -370,11 +370,20 @@ class VectorDB {
             if (this.closed) {
                 throw new Error("VectorDB connection is closed");
             }
+            const creatingStore = !fs.existsSync(this.lancedbDir);
+            if (creatingStore) {
+                (0, maintenance_policy_1.assertStoreMutationAllowed)();
+                (0, maintenance_policy_1.assertFreshDiskMutationAllowed)(this.lancedbDir);
+            }
             yield this.getLease();
             if (this.closed) {
                 throw new Error("VectorDB connection is closed");
             }
             if (!this.db) {
+                if (creatingStore || !fs.existsSync(this.lancedbDir)) {
+                    (0, maintenance_policy_1.assertStoreMutationAllowed)();
+                    (0, maintenance_policy_1.assertFreshDiskMutationAllowed)(this.lancedbDir);
+                }
                 fs.mkdirSync(this.lancedbDir, { recursive: true });
                 this.session = createLanceSession();
                 // 0.38 accepts the legacy third argument in its types but drops it in
@@ -469,23 +478,18 @@ class VectorDB {
         });
     }
     getAvailableBytes() {
-        try {
-            const stats = fs.statfsSync(this.lancedbDir);
-            return stats.bavail * stats.bsize;
-        }
-        catch (_a) {
-            return Number.MAX_SAFE_INTEGER; // fail-open
-        }
+        return (0, maintenance_policy_1.availableStoreDiskBytes)(this.lancedbDir);
     }
-    checkDiskPressure() {
+    checkDiskPressure(fresh = false) {
         const now = Date.now();
-        if (now - this.lastDiskCheckMs < VectorDB.DISK_CHECK_INTERVAL_MS) {
+        if (!fresh &&
+            now - this.lastDiskCheckMs < VectorDB.DISK_CHECK_INTERVAL_MS) {
             return this.diskPressure;
         }
         this.lastDiskCheckMs = now;
         const avail = this.getAvailableBytes();
         let level;
-        if (avail < config_1.DISK_CRITICAL_BYTES) {
+        if (!Number.isFinite(avail) || avail < 0 || avail < config_1.DISK_CRITICAL_BYTES) {
             level = "critical";
         }
         else if (avail < config_1.DISK_LOW_BYTES) {
@@ -497,7 +501,7 @@ class VectorDB {
         if (level !== this.lastLoggedPressure) {
             const freeStr = `${(avail / 1024 / 1024 / 1024).toFixed(1)}GB`;
             if (level === "critical") {
-                (0, logger_1.log)("vectordb", `CRITICAL: disk space critically low (${freeStr} free) — writes suspended`);
+                (0, logger_1.log)("vectordb", `CRITICAL: ${Number.isFinite(avail) ? `disk space critically low (${freeStr} free)` : "disk space unknown"} — writes suspended`);
             }
             else if (level === "low") {
                 (0, logger_1.log)("vectordb", `WARNING: disk space low (${freeStr} free) — compaction limited`);
@@ -511,8 +515,8 @@ class VectorDB {
         return level;
     }
     ensureDiskOk() {
-        if (this.checkDiskPressure() === "critical") {
-            throw new DiskPressureError();
+        if (this.checkDiskPressure(true) === "critical") {
+            throw new maintenance_policy_1.DiskPressureError();
         }
     }
     /**
@@ -522,6 +526,8 @@ class VectorDB {
      */
     withWriteGate(fn) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, maintenance_policy_1.assertStoreMutationAllowed)();
+            this.ensureDiskOk();
             while (this.exclusiveMutationPromise || this.compactingPromise) {
                 if (this.closed)
                     throw new Error("VectorDB connection is closed");
@@ -529,6 +535,8 @@ class VectorDB {
             }
             if (this.closed)
                 throw new Error("VectorDB connection is closed");
+            (0, maintenance_policy_1.assertStoreMutationAllowed)();
+            this.ensureDiskOk();
             this.activeWrites++;
             try {
                 return yield fn();
@@ -567,6 +575,8 @@ class VectorDB {
     }
     withExclusiveTableMutation(mutation) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, maintenance_policy_1.assertStoreMutationAllowed)();
+            this.ensureDiskOk();
             if (this.closed)
                 throw new Error("VectorDB connection is closed");
             if (this.exclusiveMutationPromise) {
@@ -592,6 +602,8 @@ class VectorDB {
                             });
                         }
                         yield Promise.all([this.drainWrites(), this.drainCompactions()]);
+                        (0, maintenance_policy_1.assertStoreMutationAllowed)();
+                        this.ensureDiskOk();
                         const db = yield this.getDb();
                         const result = yield mutation(db);
                         this.markWriteCommitted();
@@ -761,6 +773,14 @@ class VectorDB {
     }
     ensureTable() {
         return __awaiter(this, void 0, void 0, function* () {
+            if ((0, maintenance_policy_1.storeMutationDeniedReason)() !== null ||
+                this.checkDiskPressure(true) === "critical") {
+                const existing = yield this.openExistingTableUnsafe();
+                if (!existing)
+                    throw new Error("gmax store is quarantined and has no existing table");
+                yield this.validateSchema(existing);
+                return existing;
+            }
             return this.withWriteGate(() => this.ensureTableUnsafe());
         });
     }
@@ -774,6 +794,7 @@ class VectorDB {
             catch (err) {
                 if (!isMissingTableError(err))
                     throw err;
+                (0, maintenance_policy_1.assertStoreMutationAllowed)();
                 (0, logger_1.log)("db", `Creating table (${this.vectorDim}d)`);
                 const schema = this.buildSchema();
                 table = yield db.createTable(TABLE_NAME, [this.seedRow()], {
@@ -784,6 +805,7 @@ class VectorDB {
                 return table;
             }
             yield this.validateSchema(table);
+            (0, maintenance_policy_1.assertStoreMutationAllowed)();
             yield this.evolveSchema(table);
             return table;
         });
@@ -903,6 +925,12 @@ class VectorDB {
     }
     createFTSIndex() {
         return __awaiter(this, arguments, void 0, function* (rebuild = false, retries = 5) {
+            if ((0, maintenance_policy_1.fullTableMaintenanceDisabled)()) {
+                if (rebuild)
+                    throw new Error(maintenance_policy_1.FULL_TABLE_MAINTENANCE_DISABLED_REASON);
+                // Existing indexes remain searchable; absence does not authorize a build.
+                return this.adoptFTSIndex();
+            }
             return this.withWriteGate(() => this.createFTSIndexUnsafe(rebuild, retries));
         });
     }
@@ -939,7 +967,9 @@ class VectorDB {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.ftsIndexEnsured)
                 return;
-            const table = yield this.ensureTable();
+            const table = yield this.openExistingTableUnsafe();
+            if (!table)
+                throw new Error("[vector-db] No existing table or FTS index; index maintenance is disabled");
             const indices = yield table.listIndices();
             const existing = indices.find((index) => index.name === "content_idx" || index.columns.includes("content"));
             if (!existing) {
@@ -950,6 +980,10 @@ class VectorDB {
     }
     createVectorIndex() {
         return __awaiter(this, arguments, void 0, function* (rebuild = false, retries = 5, checkOnly = false) {
+            if ((0, maintenance_policy_1.fullTableMaintenanceDisabled)()) {
+                (0, logger_1.debug)("vectordb", "ANN/index maintenance disabled by host-safety containment");
+                return false;
+            }
             if (this.checkDiskPressure() !== "ok") {
                 (0, logger_1.debug)("vectordb", "ANN index skipped under disk pressure");
                 return false;
@@ -1182,6 +1216,10 @@ class VectorDB {
         return __awaiter(this, arguments, void 0, function* (retries = COMPACTION_MAX_ATTEMPTS, retentionMs = 0, bypassExclusiveMutation = false) {
             var _a;
             var _b;
+            if ((0, maintenance_policy_1.fullTableMaintenanceDisabled)()) {
+                this.lastOptimizeDidWork = false;
+                return this.recordSkippedCompaction((0, maintenance_policy_1.recordMaintenanceContainment)(this.lancedbDir));
+            }
             if (!bypassExclusiveMutation) {
                 while (this.exclusiveMutationPromise)
                     yield this.exclusiveMutationPromise;
@@ -1372,10 +1410,14 @@ class VectorDB {
     /**
      * Run FTS rebuild + optimize as a single serialized operation.
      * Safe to call from multiple project processors — only one runs at a time.
-     * Checks disk bloat ratio and retries optimize when bloat persists.
+     * Reports bloat without another whole-table rewrite.
      */
     runMaintenance() {
         return __awaiter(this, arguments, void 0, function* (options = {}) {
+            if ((0, maintenance_policy_1.fullTableMaintenanceDisabled)()) {
+                this.lastOptimizeDidWork = false;
+                return this.recordSkippedCompaction((0, maintenance_policy_1.recordMaintenanceContainment)(this.lancedbDir));
+            }
             if (this.maintenanceRunning) {
                 (0, logger_1.debug)("vectordb", "Maintenance already running, skipping");
                 return (0, compaction_result_1.skippedCompaction)("maintenance already running");
@@ -1426,7 +1468,7 @@ class VectorDB {
                     // 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.
-                    let didWork = this.lastOptimizeDidWork;
+                    const didWork = this.lastOptimizeDidWork;
                     if (result.status === "completed" && this.lastOptimizeDidWork) {
                         const table = yield this.openExistingTableUnsafe();
                         if (table) {
@@ -1443,17 +1485,17 @@ class VectorDB {
                             const diskSize = this.getDirectorySize(this.lancedbDir);
                             const logicalSize = stats.totalBytes;
                             const bloatRatio = logicalSize > 0 ? diskSize / logicalSize : 0;
-                            // Only retry if disk is still ok after optimize (don't spiral)
-                            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));
-                                result = yield this.optimize(5, 0, true);
-                                didWork = didWork || this.lastOptimizeDidWork;
+                            if (bloatRatio > 2.0) {
+                                (0, logger_1.log)("vectordb", `Bloat remains after optimize: ${bloatRatio.toFixed(1)}x; additional rewrite disabled`);
                             }
                         }
                     }
                     this.noteCompaction(didWork);
                 }
+                if (result && result.status !== "completed")
+                    return result;
+                if (result === null || result === void 0 ? void 0 : result.cleanupReason)
+                    return result;
                 const maintainedTable = yield this.openExistingTableUnsafe();
                 this.maintainedTableVersion =
                     yield this.readTableVersion(maintainedTable);
@@ -1509,6 +1551,11 @@ class VectorDB {
     }
     compactIfNeeded() {
         return __awaiter(this, arguments, void 0, function* (threshold = config_1.FRAGMENT_COMPACT_THRESHOLD) {
+            if ((0, maintenance_policy_1.fullTableMaintenanceDisabled)()) {
+                this.lastOptimizeDidWork = false;
+                this.recordSkippedCompaction((0, maintenance_policy_1.recordMaintenanceContainment)(this.lancedbDir));
+                return false;
+            }
             if (this.maintenanceRunning)
                 return false;
             this.maintenanceRunning = true;

package/dist/lib/utils/autostart.js

@@ -35,10 +35,13 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.autostartDisabledReason = autostartDisabledReason;
 exports.isAutostartDisabled = isAutostartDisabled;
+exports.daemonStartDeniedReason = daemonStartDeniedReason;
 exports.autostartDisabledUndo = autostartDisabledUndo;
 exports.autostartDisabledNotice = autostartDisabledNotice;
 const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
 const config_1 = require("../../config");
+const safety_latch_1 = require("./safety-latch");
 /**
  * Kill switch for *implicit* daemon auto-start. Create
  * ~/.gmax/autostart-disabled (or export GMAX_NO_AUTOSTART=1) to keep session
@@ -46,8 +49,8 @@ const config_1 = require("../../config");
  * reviving the daemon — needed when the host is quarantined and the daemon's
  * write volume is the thing under investigation.
  *
- * Explicit `gmax watch --daemon` is never gated: typing it is the user asking
- * for a daemon in that moment.
+ * Safety containment also gates explicit daemon launches. A launch is not
+ * authorization to remove an existing host quarantine.
  *
  * plugins/grepmax/hooks/watch-lease.js carries a plain-JS copy of these semantics
  * (env var checked first, then the file) because a SessionStart hook cannot
@@ -56,16 +59,35 @@ const config_1 = require("../../config");
 function autostartDisabledReason() {
     if (process.env.GMAX_NO_AUTOSTART === "1")
         return "env";
-    try {
-        return fs.existsSync(config_1.PATHS.autostartDisabledFile) ? "file" : null;
-    }
-    catch (_a) {
-        return null;
+    if ((0, safety_latch_1.safetyStopReason)() !== null)
+        return "safety";
+    const markers = new Set([
+        config_1.PATHS.autostartDisabledFile,
+        ...(config_1.PATHS.sharedRoot
+            ? [path.join(config_1.PATHS.sharedRoot, "autostart-disabled")]
+            : []),
+    ]);
+    for (const marker of markers) {
+        try {
+            fs.lstatSync(marker);
+            return "file";
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                return "file";
+        }
     }
+    return null;
 }
 function isAutostartDisabled() {
     return autostartDisabledReason() !== null;
 }
+function daemonStartDeniedReason() {
+    const safety = (0, safety_latch_1.safetyStopReason)();
+    if (safety !== null)
+        return `host safety stop: ${safety}`;
+    return isAutostartDisabled() ? "daemon startup is quarantined" : null;
+}
 /**
  * One-line notice for commands that fell back to in-process work because the
  * kill switch is on, or null when it isn't. Names the specific undo step so
@@ -76,11 +98,16 @@ function autostartDisabledUndo() {
     const reason = autostartDisabledReason();
     if (!reason)
         return null;
+    if (reason === "safety")
+        return "review the persistent host safety stop before resuming";
     return reason === "env"
         ? "unset GMAX_NO_AUTOSTART"
         : `rm ${config_1.PATHS.autostartDisabledFile}`;
 }
 function autostartDisabledNotice() {
+    const safety = (0, safety_latch_1.safetyStopReason)();
+    if (safety !== null)
+        return `Gmax is paused by a persistent host safety stop: ${safety}. Mutations remain blocked until containment is reviewed.`;
     // A secondary store (src/bin.ts) runs in-process by design, not because the
     // kill switch is on, so say that instead of naming an undo step. Callers use
     // a non-null notice as the gate, so this must stay non-null.