grepmax 0.14.2 → 0.14.3

package/dist/commands/claude-code.js

@@ -53,8 +53,16 @@ function runClaudeCommand(args) {
             env: process.env,
             stdio: "inherit",
         });
-        child.on("error", (error) => reject(error));
+        const timeout = setTimeout(() => {
+            child.kill("SIGTERM");
+            reject(new Error("claude command timed out after 60s"));
+        }, 60000);
+        child.on("error", (error) => {
+            clearTimeout(timeout);
+            reject(error);
+        });
         child.on("exit", (code) => {
+            clearTimeout(timeout);
             if (code === 0) {
                 resolve();
             }

package/dist/commands/doctor.js

@@ -85,7 +85,7 @@ exports.doctor = new commander_1.Command("doctor")
     .option("--fix", "Auto-fix detected issues (compact, prune, remove stale locks)", false)
     .option("--agent", "Compact output for AI agents", false)
     .action((opts) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
+    var _a, _b, _c, _d;
     if (!opts.agent)
         console.log("gmax Doctor\n");
     const root = config_1.PATHS.globalRoot;
@@ -103,6 +103,9 @@ exports.doctor = new commander_1.Command("doctor")
     }
     const globalConfig = (0, index_config_1.readGlobalConfig)();
     const tier = (_a = config_1.MODEL_TIERS[globalConfig.modelTier]) !== null && _a !== void 0 ? _a : config_1.MODEL_TIERS.small;
+    if (!config_1.MODEL_TIERS[globalConfig.modelTier]) {
+        console.log(`WARN  Unknown model tier '${globalConfig.modelTier}', falling back to 'small'`);
+    }
     const embedModel = globalConfig.embedMode === "gpu" ? tier.mlxModel : tier.onnxModel;
     if (!opts.agent) {
         console.log(`\nEmbed mode: ${globalConfig.embedMode} | Model tier: ${globalConfig.modelTier} (${tier.vectorDim}d)`);
@@ -125,10 +128,39 @@ exports.doctor = new commander_1.Command("doctor")
             console.log(`INFO  No index found in current directory (run 'gmax index' to create one)`);
         }
         // Check MLX embed server
-        const embedUp = yield fetch("http://127.0.0.1:8100/health")
-            .then((r) => r.ok)
-            .catch(() => false);
-        console.log(`${embedUp ? "ok" : "WARN"}  MLX Embed: ${embedUp ? "running (port 8100)" : "not running"}`);
+        let embedUp = false;
+        let embedError = "";
+        try {
+            const res = yield fetch("http://127.0.0.1:8100/health");
+            embedUp = res.ok;
+        }
+        catch (err) {
+            embedError = err.code === "ECONNREFUSED" ? "connection refused" : (err.message || String(err));
+        }
+        console.log(`${embedUp ? "ok" : "WARN"}  MLX Embed: ${embedUp ? "running (port 8100)" : `not running${embedError ? ` (${embedError})` : ""}`}`);
+        if (embedUp) {
+            try {
+                const start = Date.now();
+                const embedRes = yield fetch("http://127.0.0.1:8100/embed", {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ texts: ["gmax health check"] }),
+                });
+                const embedData = yield embedRes.json();
+                const dim = (_d = (_c = (_b = embedData === null || embedData === void 0 ? void 0 : embedData.vectors) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0;
+                const ms = Date.now() - start;
+                const expectedDim = tier.vectorDim || 384;
+                if (dim === expectedDim) {
+                    console.log(`ok  Embedding: working (${dim}d, ${ms}ms)`);
+                }
+                else {
+                    console.log(`FAIL  Embedding: wrong dimensions (got ${dim}, expected ${expectedDim})`);
+                }
+            }
+            catch (err) {
+                console.log(`FAIL  Embedding: test failed (${err.message || err})`);
+            }
+        }
         // Check summarizer server
         const summarizerUp = yield fetch("http://127.0.0.1:8101/health")
             .then((r) => r.ok)
@@ -256,6 +288,26 @@ exports.doctor = new commander_1.Command("doctor")
             else if (projects.length > 0) {
                 console.log(`ok  Projects: ${projects.length} registered, all directories exist`);
             }
+            // Cache Coherence
+            if (projects.length > 0) {
+                console.log("\nCache Coherence\n");
+                try {
+                    const { MetaCache } = yield Promise.resolve().then(() => __importStar(require("../lib/store/meta-cache")));
+                    const mc = new MetaCache(config_1.PATHS.lmdbPath);
+                    for (const project of projects.filter(p => p.status === "indexed")) {
+                        const prefix = project.root.endsWith("/") ? project.root : `${project.root}/`;
+                        const cachedCount = (yield mc.getKeysWithPrefix(prefix)).size;
+                        const vectorCount = yield db.countDistinctFilesForPath(prefix);
+                        if (cachedCount > 0) {
+                            const pct = Math.round((vectorCount / cachedCount) * 100);
+                            const status = pct >= 80 ? "ok" : "WARN";
+                            console.log(`${status}  ${project.name || path.basename(project.root)}: ${vectorCount} indexed / ${cachedCount} cached (${pct}%)`);
+                        }
+                    }
+                    yield mc.close();
+                }
+                catch (_e) { }
+            }
         }
         // --fix auto-remediation
         if (opts.fix) {
@@ -291,7 +343,7 @@ exports.doctor = new commander_1.Command("doctor")
         }
         yield db.close();
     }
-    catch (_b) {
+    catch (_f) {
         if (opts.agent) {
             console.log("index_health\terror=could_not_check");
         }

package/dist/commands/mcp.js

@@ -462,7 +462,18 @@ exports.mcp = new commander_1.Command("mcp")
             _indexChildPid = (_a = child.pid) !== null && _a !== void 0 ? _a : null;
             child.unref();
             _indexProgress = `PID ${_indexChildPid}`;
+            const indexTimeout = setTimeout(() => {
+                try {
+                    child.kill("SIGKILL");
+                }
+                catch (_a) { }
+                _indexing = false;
+                _indexProgress = "";
+                _indexChildPid = null;
+                console.error("[MCP] Background indexing timed out after 30 minutes");
+            }, 30 * 60 * 1000);
             child.on("exit", (code) => {
+                clearTimeout(indexTimeout);
                 _indexing = false;
                 _indexProgress = "";
                 _indexChildPid = null;
@@ -503,6 +514,11 @@ exports.mcp = new commander_1.Command("mcp")
             if (_indexing) {
                 return ok(`Indexing in progress (${_indexProgress}). Results may be incomplete or empty — try again shortly.`);
             }
+            // Check if project is pending or has no chunks
+            const proj = (0, project_registry_1.getProject)(projectRoot);
+            if ((proj === null || proj === void 0 ? void 0 : proj.status) === "pending" || (proj && proj.chunkCount === 0)) {
+                return err("Project not indexed yet. Run `gmax add` to index it first.");
+            }
             try {
                 const searcher = getSearcher();
                 // Determine path prefix and display root for relative paths
@@ -1864,9 +1880,6 @@ exports.mcp = new commander_1.Command("mcp")
             case "semantic_search":
                 result = yield handleSemanticSearch(toolArgs, false);
                 break;
-            case "search_all":
-                result = yield handleSemanticSearch(toolArgs, true);
-                break;
             case "code_skeleton":
                 result = yield handleCodeSkeleton(toolArgs);
                 break;

package/dist/commands/status.js

@@ -125,7 +125,9 @@ Examples:
         }
         yield db.close();
     }
-    catch (_e) { }
+    catch (err) {
+        console.warn(`[status] Failed to query LanceDB for live chunk counts, using cached counts`);
+    }
     if (projects.length === 0) {
         if (opts.agent) {
             console.log("(none)");

package/dist/index.js

@@ -79,8 +79,8 @@ commander_1.program
     encoding: "utf-8",
 })).version)
     .option("--store <string>", "The store to use (auto-detected if not specified)", process.env.GMAX_STORE || undefined);
-// Detect legacy per-project .gmax/ or .osgrep/ directories
-const legacyProjectData = [".gmax", ".osgrep"]
+// Detect legacy per-project .gmax/ directory
+const legacyProjectData = [".gmax"]
     .map((d) => path.join(process.cwd(), d))
     .find((d) => fs.existsSync(path.join(d, "lancedb")));
 if (legacyProjectData) {

package/dist/lib/daemon/daemon.js

@@ -125,8 +125,10 @@ class Daemon {
             try {
                 fs.mkdirSync(config_1.PATHS.cacheDir, { recursive: true });
                 fs.mkdirSync(config_1.PATHS.lancedbDir, { recursive: true });
+                console.log("[daemon] Opening LanceDB:", config_1.PATHS.lancedbDir);
                 this.vectorDb = new vector_db_1.VectorDB(config_1.PATHS.lancedbDir);
                 this.vectorDb.startMaintenanceLoop();
+                console.log("[daemon] Opening MetaCache:", config_1.PATHS.lmdbPath);
                 this.metaCache = new meta_cache_1.MetaCache(config_1.PATHS.lmdbPath);
             }
             catch (err) {
@@ -175,6 +177,10 @@ class Daemon {
                 let buf = "";
                 conn.on("data", (chunk) => {
                     buf += chunk.toString();
+                    if (buf.length > 1000000) {
+                        conn.destroy();
+                        return;
+                    }
                     const nl = buf.indexOf("\n");
                     if (nl === -1)
                         return;
@@ -231,12 +237,19 @@ class Daemon {
                 projectRoot: root,
                 vectorDb: this.vectorDb,
                 metaCache: this.metaCache,
-                onReindex: (files, ms) => {
+                onReindex: (files, ms) => __awaiter(this, void 0, void 0, function* () {
                     console.log(`[daemon:${path.basename(root)}] Reindexed ${files} file${files !== 1 ? "s" : ""} (${(ms / 1000).toFixed(1)}s)`);
                     // Update project registry so gmax status shows fresh data
                     const proj = (0, project_registry_1.getProject)(root);
                     if (proj) {
-                        (0, project_registry_1.registerProject)(Object.assign(Object.assign({}, proj), { lastIndexed: new Date().toISOString() }));
+                        let chunkCount = proj.chunkCount;
+                        try {
+                            chunkCount = yield this.vectorDb.countRowsForPath(root);
+                        }
+                        catch (err) {
+                            console.warn(`[daemon:${path.basename(root)}] Failed to query chunk count: ${err}`);
+                        }
+                        (0, project_registry_1.registerProject)(Object.assign(Object.assign({}, proj), { lastIndexed: new Date().toISOString(), chunkCount }));
                     }
                     // Back to watching after batch completes
                     (0, watcher_store_1.registerWatcher)({
@@ -247,7 +260,7 @@ class Daemon {
                         lastHeartbeat: Date.now(),
                         lastReindex: Date.now(),
                     });
-                },
+                }),
                 onActivity: () => {
                     this.lastActivity = Date.now();
                     // Mark as syncing while processing
@@ -300,7 +313,7 @@ class Daemon {
             let queued = 0;
             try {
                 for (var _d = true, _e = __asyncValues(walk(root, {
-                    additionalPatterns: ["**/.git/**", "**/.gmax/**", "**/.osgrep/**"],
+                    additionalPatterns: ["**/.git/**", "**/.gmax/**"],
                 })), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
                     _c = _f.value;
                     _d = false;

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

@@ -210,6 +210,15 @@ class ProjectBatchProcessor {
                         this.pending.set(absPath, event);
                     }
                 }
+                // Requeue files that were attempted but not successfully processed
+                // (e.g. pool became unhealthy mid-batch before vectors were flushed)
+                for (const [absPath, event] of batch) {
+                    if (attempted.has(absPath) && !metaUpdates.has(absPath) && !metaDeletes.includes(absPath)) {
+                        if (!this.pending.has(absPath)) {
+                            this.pending.set(absPath, event);
+                        }
+                    }
+                }
                 // Flush to VectorDB: insert first, then delete old (preserving new)
                 const newIds = vectors.map((v) => v.id);
                 if (vectors.length > 0) {

package/dist/lib/index/ignore-patterns.js

@@ -33,7 +33,6 @@ exports.DEFAULT_IGNORE_PATTERNS = [
     ".gradle",
     ".m2",
     "vendor",
-    ".osgrep",
     ".gmax",
     ".gmax.json",
     // Minified/generated assets

package/dist/lib/index/syncer.js

@@ -239,6 +239,10 @@ function initialSync(options) {
                 // timeouts wrote MetaCache but not vectors, compaction failure, etc.).
                 // Clear the stale cache entries so those files get re-embedded.
                 const vectorFileCount = yield vectorDb.countDistinctFilesForPath(rootPrefix);
+                if (projectKeys.size > 0) {
+                    const pct = Math.round((vectorFileCount / projectKeys.size) * 100);
+                    (0, logger_1.log)("index", `Coherence: ${vectorFileCount} vectors / ${projectKeys.size} cached (${pct}%)`);
+                }
                 if (projectKeys.size > 0 && vectorFileCount === 0) {
                     (0, logger_1.log)("index", `Stale cache detected: ${projectKeys.size} cached files but no vectors — clearing cache`);
                     for (const key of projectKeys) {
@@ -272,6 +276,15 @@ function initialSync(options) {
             let total = 0;
             onProgress === null || onProgress === void 0 ? void 0 : onProgress({ processed: 0, indexed: 0, total, filePath: "Scanning..." });
             const pool = (0, pool_1.getWorkerPool)();
+            // Pre-flight: verify embedding pipeline is functional
+            const embedMode = process.env.GMAX_EMBED_MODE || "auto";
+            if (embedMode !== "cpu") {
+                const { isMlxUp } = yield Promise.resolve().then(() => __importStar(require("../workers/embeddings/mlx-client")));
+                const mlxReady = yield isMlxUp();
+                if (!mlxReady) {
+                    (0, logger_1.log)("index", "WARNING: MLX embed server not running — using CPU embeddings (slower)");
+                }
+            }
             // Get only this project's cached paths (scoped by prefix)
             const cachedPaths = dryRun || treatAsEmptyCache
                 ? new Set()
@@ -362,7 +375,7 @@ function initialSync(options) {
             });
             try {
                 for (var _e = true, _f = __asyncValues((0, walker_1.walk)(paths.root, {
-                    additionalPatterns: ["**/.git/**", "**/.gmax/**", "**/.osgrep/**"],
+                    additionalPatterns: ["**/.git/**", "**/.gmax/**"],
                 })), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
                     _c = _g.value;
                     _e = false;

package/dist/lib/llm/server.js

@@ -46,6 +46,7 @@ exports.LlmServer = void 0;
 const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
 const http = __importStar(require("node:http"));
+const path = __importStar(require("node:path"));
 const config_1 = require("../../config");
 const index_config_1 = require("../index/index-config");
 const log_rotate_1 = require("../utils/log-rotate");
@@ -70,8 +71,30 @@ class LlmServer {
                 path: "/v1/models",
                 timeout: HEALTH_TIMEOUT_MS,
             }, (res) => {
-                res.resume();
-                resolve(res.statusCode === 200);
+                if (res.statusCode !== 200) {
+                    res.resume();
+                    resolve(false);
+                    return;
+                }
+                const chunks = [];
+                res.on("data", (chunk) => chunks.push(chunk));
+                res.on("end", () => {
+                    var _a, _b;
+                    try {
+                        const body = JSON.parse(Buffer.concat(chunks).toString());
+                        const runningModel = (_b = (_a = body === null || body === void 0 ? void 0 : body.data) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.id;
+                        if (runningModel) {
+                            const configBasename = path.basename(this.config.model);
+                            if (runningModel !== configBasename && !configBasename.includes(runningModel) && !runningModel.includes(configBasename)) {
+                                console.log(`[llm] Model mismatch: running "${runningModel}" but config expects "${configBasename}"`);
+                            }
+                        }
+                    }
+                    catch (_c) {
+                        // ignore parse errors — server is still healthy
+                    }
+                    resolve(true);
+                });
             });
             req.on("error", () => resolve(false));
             req.on("timeout", () => {

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

@@ -442,6 +442,13 @@ class VectorDB {
             return rows.length > 0;
         });
     }
+    countRowsForPath(pathPrefix) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const table = yield this.ensureTable();
+            const prefix = pathPrefix.endsWith("/") ? pathPrefix : `${pathPrefix}/`;
+            return table.countRows(`path LIKE '${(0, filter_builder_1.escapeSqlString)(prefix)}%'`);
+        });
+    }
     countDistinctFilesForPath(pathPrefix) {
         return __awaiter(this, void 0, void 0, function* () {
             const table = yield this.ensureTable();

package/dist/lib/utils/daemon-client.js

@@ -180,7 +180,7 @@ function sendStreamingCommand(cmd, onProgress, opts) {
                     }
                 }
                 catch (_a) {
-                    // ignore partial/malformed lines
+                    console.warn("[daemon-client] Malformed response line:", line.slice(0, 200));
                 }
             }
         });

package/dist/lib/utils/project-registry.js

@@ -60,7 +60,9 @@ function loadRegistry() {
 }
 function saveRegistry(entries) {
     fs.mkdirSync(path.dirname(REGISTRY_PATH), { recursive: true });
-    fs.writeFileSync(REGISTRY_PATH, `${JSON.stringify(entries, null, 2)}\n`);
+    const tmp = REGISTRY_PATH + ".tmp";
+    fs.writeFileSync(tmp, `${JSON.stringify(entries, null, 2)}\n`);
+    fs.renameSync(tmp, REGISTRY_PATH);
 }
 function registerProject(entry) {
     const entries = loadRegistry();

package/dist/lib/workers/embeddings/mlx-client.js

@@ -47,6 +47,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMlxUp = isMlxUp;
 exports.mlxEmbed = mlxEmbed;
 exports.resetMlxCache = resetMlxCache;
 const http = __importStar(require("node:http"));
@@ -57,6 +58,8 @@ const EMBED_MODE = process.env.GMAX_EMBED_MODE || "auto";
 let mlxAvailable = null;
 let lastCheck = 0;
 const CHECK_INTERVAL_MS = 30000;
+let lastMlxWarning = 0;
+const MLX_WARNING_INTERVAL_MS = 60000;
 function postJSON(path, body) {
     return new Promise((resolve) => {
         const payload = JSON.stringify(body);
@@ -119,8 +122,15 @@ function isMlxUp() {
         let result = yield checkHealth();
         // On first check (cold start), retry once after 3s — server may still be loading
         if (!result && mlxAvailable === null) {
+            console.log("[mlx] Embed server not ready, retrying in 3s...");
             yield new Promise((r) => setTimeout(r, 3000));
             result = yield checkHealth();
+            if (result) {
+                console.log("[mlx] Embed server ready");
+            }
+            else {
+                console.warn("[mlx] Embed server not available after retry");
+            }
         }
         mlxAvailable = result;
         lastCheck = now;
@@ -137,9 +147,28 @@ function mlxEmbed(texts) {
             return null;
         if (!(yield isMlxUp()))
             return null;
-        const { ok, data } = yield postJSON("/embed", { texts });
+        let postResult;
+        try {
+            postResult = yield postJSON("/embed", { texts });
+        }
+        catch (error) {
+            mlxAvailable = false;
+            const now = Date.now();
+            if (now - lastMlxWarning >= MLX_WARNING_INTERVAL_MS) {
+                console.error("[mlx] Embed server failed:", error.message || error);
+                lastMlxWarning = now;
+            }
+            return null;
+        }
+        const { ok, data } = postResult;
         if (!ok || !(data === null || data === void 0 ? void 0 : data.vectors)) {
+            const wasPreviouslyAvailable = mlxAvailable !== false;
             mlxAvailable = false;
+            const now = Date.now();
+            if (wasPreviouslyAvailable || now - lastMlxWarning >= MLX_WARNING_INTERVAL_MS) {
+                console.error("[mlx] Embed server failed: bad response (ok=" + ok + ", hasVectors=" + !!(data === null || data === void 0 ? void 0 : data.vectors) + ")");
+                lastMlxWarning = now;
+            }
             return null;
         }
         return data.vectors.map((v) => new Float32Array(v));

package/dist/lib/workers/orchestrator.js

@@ -56,6 +56,7 @@ const colbert_math_1 = require("./colbert-math");
 const colbert_1 = require("./embeddings/colbert");
 const granite_1 = require("./embeddings/granite");
 const mlx_client_1 = require("./embeddings/mlx-client");
+let mlxFallbackWarned = false;
 const CACHE_DIR = config_1.PATHS.models;
 const LOG_MODELS = process.env.GMAX_DEBUG_MODELS === "1" ||
     process.env.GMAX_DEBUG_MODELS === "true";
@@ -105,7 +106,7 @@ class WorkerOrchestrator {
     }
     computeHybrid(texts, onProgress) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+            var _a;
             if (!texts.length)
                 return [];
             yield this.ensureReady();
@@ -119,7 +120,12 @@ class WorkerOrchestrator {
                     onProgress === null || onProgress === void 0 ? void 0 : onProgress();
                 const batchTexts = texts.slice(i, i + BATCH_SIZE);
                 // Try MLX GPU server first, fall back to ONNX CPU
-                const denseBatch = (_b = (yield (0, mlx_client_1.mlxEmbed)(batchTexts))) !== null && _b !== void 0 ? _b : (yield this.granite.runBatch(batchTexts));
+                const mlxResult = yield (0, mlx_client_1.mlxEmbed)(batchTexts);
+                if (!mlxResult && !mlxFallbackWarned) {
+                    console.warn("[embed] MLX unavailable, falling back to CPU (ONNX)");
+                    mlxFallbackWarned = true;
+                }
+                const denseBatch = mlxResult !== null && mlxResult !== void 0 ? mlxResult : (yield this.granite.runBatch(batchTexts));
                 const colbertBatch = yield this.colbert.runBatch(batchTexts, denseBatch, this.vectorDimensions);
                 results.push(...colbertBatch);
             }

package/dist/lib/workers/pool.js

@@ -275,20 +275,22 @@ class WorkerPool {
         });
     }
     handleTaskTimeout(task, worker) {
+        var _a, _b, _c, _d;
         if (this.destroyed || !this.tasks.has(task.id))
             return;
         this.clearTaskTimeout(task);
+        const filePath = (_d = (_b = (_a = task.payload) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : (_c = task.payload) === null || _c === void 0 ? void 0 : _c.absolutePath) !== null && _d !== void 0 ? _d : "unknown";
         if (task.method !== "processFile") {
-            console.warn(`[worker-pool] ${task.method} timed out after ${TASK_TIMEOUT_MS}ms; restarting worker.`);
+            console.warn(`[worker-pool] ${task.method} timed out after ${TASK_TIMEOUT_MS}ms on ${filePath}; restarting worker.`);
         }
         this.completeTask(task, null);
-        task.reject(new Error(`Worker task ${task.method} timed out after ${TASK_TIMEOUT_MS}ms`));
+        task.reject(new Error(`Worker task ${task.method} timed out after ${TASK_TIMEOUT_MS}ms on ${filePath}`));
         worker.child.removeAllListeners("message");
         worker.child.removeAllListeners("exit");
         try {
             worker.child.kill("SIGKILL");
         }
-        catch (_a) { }
+        catch (_e) { }
         this.workers = this.workers.filter((w) => w !== worker);
         if (!this.destroyed) {
             this.spawnWorker();

package/mlx-embed-server/server.py

@@ -29,7 +29,12 @@ warnings.filterwarnings("ignore", message=".*PyTorch.*")
 warnings.filterwarnings("ignore", message=".*resource_tracker.*")
 logging.getLogger("huggingface_hub").setLevel(logging.ERROR)
 
-
+logging.basicConfig(
+    format="%(asctime)s %(message)s",
+    datefmt="%Y-%m-%dT%H:%M:%S",
+    level=logging.INFO,
+)
+logger = logging.getLogger("mlx-embed")
 
 
 import mlx.core as mx
@@ -89,18 +94,18 @@ def embed_texts(texts: list[str]) -> mx.array:
 
 def load_model():
     global model, tokenizer
-    print(f"[mlx-embed] Loading {MODEL_ID}...")
+    logger.info(f"[mlx-embed] Loading {MODEL_ID}...")
     model, _ = load(MODEL_ID)
     tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
     _ = embed_texts(["warm up"])
-    print("[mlx-embed] Model ready on Metal GPU.")
+    logger.info("[mlx-embed] Model ready on Metal GPU.")
 
 
 async def idle_watchdog():
     while True:
         await asyncio.sleep(60)
         if time.time() - last_activity > IDLE_TIMEOUT_S:
-            print("[mlx-embed] Idle timeout, shutting down")
+            logger.info("[mlx-embed] Idle timeout, shutting down")
             os._exit(0)
 
 
@@ -158,14 +163,14 @@ def main():
 
     # Bail early if port is already taken
     if is_port_in_use(PORT):
-        print(f"[mlx-embed] Port {PORT} already in use — server is already running.")
+        logger.info(f"[mlx-embed] Port {PORT} already in use — server is already running.")
         return
 
-    print(f"[mlx-embed] Starting on port {PORT}")
+    logger.info(f"[mlx-embed] Starting on port {PORT}")
 
     # Clean shutdown — exit immediately, skip uvicorn's noisy teardown
     def handle_signal(sig, frame):
-        print("[mlx-embed] Stopped.")
+        logger.info("[mlx-embed] Stopped.")
         # Kill the resource_tracker child process before exit to prevent
         # its spurious "leaked semaphore" warning (Python 3.13 bug)
         try:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.14.2",
+  "version": "0.14.3",
   "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.14.2",
+  "version": "0.14.3",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",

package/plugins/grepmax/hooks/start.js

@@ -68,11 +68,39 @@ function startPythonServer(serverDir, scriptName, logName, processName) {
       VIRTUAL_ENV: "",
       CONDA_DEFAULT_ENV: "",
       GMAX_PROCESS_NAME: processName || logName,
+      HF_TOKEN_PATH: process.env.HF_TOKEN_PATH || _path.join(require("node:os").homedir(), ".cache", "huggingface", "token"),
     },
   });
   child.unref();
 }
 
+// --- Crash counter (Item 14) ---
+const CRASH_FILE = _path.join(require("node:os").homedir(), ".gmax", "mlx-embed-crashes.json");
+const MAX_CRASHES = 3;
+const CRASH_WINDOW_MS = 10 * 60 * 1000; // 10 minutes
+
+function readCrashCount() {
+  try {
+    const data = JSON.parse(fs.readFileSync(CRASH_FILE, "utf-8"));
+    if (data.lastCrash && Date.now() - new Date(data.lastCrash).getTime() > CRASH_WINDOW_MS) {
+      return { count: 0, lastCrash: null }; // Window expired, reset
+    }
+    return { count: data.count || 0, lastCrash: data.lastCrash };
+  } catch {
+    return { count: 0, lastCrash: null };
+  }
+}
+
+function writeCrashCount(count, lastCrash) {
+  try {
+    fs.writeFileSync(CRASH_FILE, JSON.stringify({ count, lastCrash }));
+  } catch {}
+}
+
+function resetCrashCount() {
+  try { fs.unlinkSync(CRASH_FILE); } catch {}
+}
+
 function isProjectRegistered() {
   try {
     const projectsPath = _path.join(
@@ -109,8 +137,30 @@ async function main() {
     const serverDir = findMlxServerDir();
 
     // Start MLX embed server (port 8100)
-    if (serverDir && !(await isServerRunning(8100))) {
-      startPythonServer(serverDir, "server.py", "mlx-embed-server", "gmax-embed");
+    const embedRunning = await isServerRunning(8100);
+    if (serverDir && !embedRunning) {
+      const crashes = readCrashCount();
+      if (crashes.count < MAX_CRASHES) {
+        startPythonServer(serverDir, "server.py", "mlx-embed-server", "gmax-embed");
+
+        // Fire-and-forget health verification (Item 13)
+        (async () => {
+          const maxAttempts = 5;
+          const delayMs = 2000;
+          for (let i = 0; i < maxAttempts; i++) {
+            await new Promise(r => setTimeout(r, delayMs));
+            if (await isServerRunning(8100)) {
+              resetCrashCount();
+              return;
+            }
+          }
+          // Server didn't start after 10s — record crash
+          const c = readCrashCount();
+          writeCrashCount(c.count + 1, new Date().toISOString());
+        })();
+      }
+    } else if (embedRunning) {
+      resetCrashCount();
     }
 
     // Start LLM summarizer server (port 8101) — opt-in only