grepmax 0.21.3 → 0.22.0

package/dist/lib/search/searcher.js

@@ -374,7 +374,7 @@ class Searcher {
     }
     search(query, top_k, _search_options, _filters, pathPrefix, intent, signal) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
             const finalLimit = top_k !== null && top_k !== void 0 ? top_k : 10;
             // ColBERT rerank is opt-in as of v0.17.1. On the 97-case eval it
             // regresses MRR@10 by ~3% and doubles query latency; sweep across
@@ -413,7 +413,7 @@ class Searcher {
             try {
                 table = yield this.db.ensureTable();
             }
-            catch (_q) {
+            catch (_r) {
                 return { data: [] };
             }
             // Ensure FTS index exists (lazy init, retry periodically on failure)
@@ -496,7 +496,7 @@ class Searcher {
                             this.ftsAvailable = true;
                             console.warn("[Searcher] Rebuilt FTS index with position support — retry search");
                         }
-                        catch (_r) { }
+                        catch (_s) { }
                     }
                     else {
                         console.warn(`[Searcher] FTS search failed (will retry later): ${msg}`);
@@ -670,6 +670,10 @@ class Searcher {
             if (stage2Candidates.length === 0) {
                 return { data: [] };
             }
+            const envMaxPerFile = Number.parseInt((_m = process.env.GMAX_MAX_PER_FILE) !== null && _m !== void 0 ? _m : "", 10);
+            const MAX_PER_FILE = Number.isFinite(envMaxPerFile) && envMaxPerFile > 0 ? envMaxPerFile : 3;
+            const displayWindow = Math.min(stage2Candidates.length, Math.max(finalLimit * MAX_PER_FILE, finalLimit, RERANK_TOP));
+            const displayCandidates = stage2Candidates.slice(0, displayWindow);
             const rerankCandidates = stage2Candidates.slice(0, RERANK_TOP);
             // Symbol-definition promotion (1/2): membership. For a bare-symbol query,
             // ensure the chunk(s) that actually DEFINE the symbol reach the rerank set
@@ -681,6 +685,7 @@ class Searcher {
             // (2/2) below then lets them win dedup over their own method-child chunks.
             if (symbolQuery && rerankCandidates.length > 0) {
                 const present = new Set(rerankCandidates.map((d) => d.id).filter(Boolean));
+                const displayPresent = new Set(displayCandidates.map((d) => d.id).filter(Boolean));
                 const MAX_INJECT = 5;
                 let injected = 0;
                 for (const d of topCandidates) {
@@ -691,6 +696,10 @@ class Searcher {
                     if (readSymbolArray(d.defined_symbols).includes(symbolQuery)) {
                         rerankCandidates.push(d);
                         present.add(d.id);
+                        if (!displayPresent.has(d.id)) {
+                            displayCandidates.push(d);
+                            displayPresent.add(d.id);
+                        }
                         injected++;
                     }
                 }
@@ -719,8 +728,9 @@ class Searcher {
                     }
                 }
             }
-            const scores = doRerank
-                ? yield pool.rerank({
+            const rerankScoreByKey = new Map();
+            if (doRerank && rerankCandidates.length > 0) {
+                const scores = yield pool.rerank({
                     query: queryMatrixRaw,
                     docs: rerankCandidates.map((doc) => {
                         var _a;
@@ -733,28 +743,25 @@ class Searcher {
                         });
                     }),
                     colbertDim,
-                }, signal)
-                : rerankCandidates.map((doc, idx) => {
-                    var _a;
-                    // If rerank is disabled, fall back to fusion ordering with structural boost
+                }, signal);
+                for (const [idx, doc] of rerankCandidates.entries()) {
                     const key = doc.id || `${doc.path}:${doc.chunk_index}`;
-                    const fusedScore = (_a = candidateScores.get(key)) !== null && _a !== void 0 ? _a : 0;
-                    // Small tie-breaker so later items don't all share 0
-                    return fusedScore || 1 / (idx + 1);
-                });
+                    rerankScoreByKey.set(key, (_o = scores === null || scores === void 0 ? void 0 : scores[idx]) !== null && _o !== void 0 ? _o : 0);
+                }
+            }
             // Symbol-definition promotion (2/2): score. Multiplicatively boost any
             // candidate that defines the queried symbol so the definition chunk outranks
             // its own method-child chunks (e.g. the `BeyondError` class chunk vs its
             // constructor/toJSON, which otherwise score higher on the literal and evict
             // the parent in overlap dedup). Multiplicative keeps it scale-invariant
             // across the rerank-on (ColBERT maxsim) and rerank-off (fusion) score ranges.
-            const envDefBoost = Number.parseFloat((_m = process.env.GMAX_DEF_BOOST) !== null && _m !== void 0 ? _m : "");
+            const envDefBoost = Number.parseFloat((_p = process.env.GMAX_DEF_BOOST) !== null && _p !== void 0 ? _p : "");
             const DEF_MATCH_BOOST = Number.isFinite(envDefBoost) && envDefBoost >= 1 ? envDefBoost : 5;
-            const scored = rerankCandidates.map((doc, idx) => {
+            const scored = displayCandidates.map((doc, idx) => {
                 var _a, _b;
-                const base = (_a = scores === null || scores === void 0 ? void 0 : scores[idx]) !== null && _a !== void 0 ? _a : 0;
                 const key = doc.id || `${doc.path}:${doc.chunk_index}`;
-                const fusedScore = (_b = candidateScores.get(key)) !== null && _b !== void 0 ? _b : 0;
+                const fusedScore = (_a = candidateScores.get(key)) !== null && _a !== void 0 ? _a : 0;
+                const base = (_b = rerankScoreByKey.get(key)) !== null && _b !== void 0 ? _b : (fusedScore || 1 / (idx + 1));
                 const blended = base + FUSED_WEIGHT * fusedScore;
                 let boosted = this.applyStructureBoost(doc, blended, searchIntent);
                 if (symbolQuery &&
@@ -782,7 +789,7 @@ class Searcher {
                 try {
                     const { scores: prScores, max: prMax } = yield (0, pagerank_1.loadOrComputePageRank)(this.db, pathPrefix);
                     if (prMax > 0) {
-                        const envWeight = Number.parseFloat((_o = process.env.GMAX_PR_WEIGHT) !== null && _o !== void 0 ? _o : "");
+                        const envWeight = Number.parseFloat((_q = process.env.GMAX_PR_WEIGHT) !== null && _q !== void 0 ? _q : "");
                         const PR_WEIGHT = Number.isFinite(envWeight) && envWeight >= 0 ? envWeight : 0.05;
                         for (const item of scored) {
                             const raw = item.record
@@ -799,7 +806,7 @@ class Searcher {
                                         defs = arr.filter((v) => typeof v === "string");
                                     }
                                 }
-                                catch (_s) { }
+                                catch (_t) { }
                             }
                             const norm = (0, pagerank_1.pageRankBoostForSymbols)(defs, prScores, prMax);
                             item.score += PR_WEIGHT * norm;
@@ -817,8 +824,6 @@ class Searcher {
             // Item 10: Per-file diversification
             const seenFiles = new Map();
             const diversified = [];
-            const envMaxPerFile = Number.parseInt((_p = process.env.GMAX_MAX_PER_FILE) !== null && _p !== void 0 ? _p : "", 10);
-            const MAX_PER_FILE = Number.isFinite(envMaxPerFile) && envMaxPerFile > 0 ? envMaxPerFile : 3;
             for (const item of uniqueScored) {
                 const path = item.record.path || "";
                 const count = seenFiles.get(path) || 0;

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

@@ -68,6 +68,17 @@ function isLanceCorruptionError(err) {
     const msg = err instanceof Error ? err.message : String(err);
     return /Not found:.*\.lance(?:[^a-z]|$)/i.test(msg);
 }
+function isMissingTableError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const tableMissing = /table.*chunks.*(?:not found|does not exist)/i.test(msg) ||
+        /(?:not found|does not exist).*table.*chunks/i.test(msg) ||
+        /no such table.*chunks/i.test(msg);
+    if (tableMissing)
+        return true;
+    if (isLanceCorruptionError(err))
+        return false;
+    return false;
+}
 const TABLE_NAME = "chunks";
 const MAINTENANCE_INTERVAL_MS = 5 * 60 * 1000;
 class VectorDB {
@@ -389,21 +400,24 @@ class VectorDB {
     ensureTable() {
         return __awaiter(this, void 0, void 0, function* () {
             const db = yield this.getDb();
+            let table;
             try {
-                const table = yield db.openTable(TABLE_NAME);
-                yield this.validateSchema(table);
-                yield this.evolveSchema(table);
-                return table;
+                table = yield db.openTable(TABLE_NAME);
             }
-            catch (_err) {
+            catch (err) {
+                if (!isMissingTableError(err))
+                    throw err;
                 (0, logger_1.log)("db", `Creating table (${this.vectorDim}d)`);
                 const schema = this.buildSchema();
-                const table = yield db.createTable(TABLE_NAME, [this.seedRow()], {
+                table = yield db.createTable(TABLE_NAME, [this.seedRow()], {
                     schema,
                 });
                 yield table.delete('id = "seed"');
                 return table;
             }
+            yield this.validateSchema(table);
+            yield this.evolveSchema(table);
+            return table;
         });
     }
     insertBatch(records) {

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

@@ -47,6 +47,7 @@ exports.isDaemonRunning = isDaemonRunning;
 exports.isDaemonHeartbeatFresh = isDaemonHeartbeatFresh;
 exports.readDaemonPid = readDaemonPid;
 exports.waitForProcessExit = waitForProcessExit;
+exports.waitForDaemonDrain = waitForDaemonDrain;
 exports.writeDrainingMarker = writeDrainingMarker;
 exports.clearDrainingMarker = clearDrainingMarker;
 exports.isDaemonDraining = isDaemonDraining;
@@ -56,6 +57,8 @@ const fs = __importStar(require("node:fs"));
 const net = __importStar(require("node:net"));
 const config_1 = require("../../config");
 const DEFAULT_TIMEOUT_MS = 5000;
+const DAEMON_READY_TIMEOUT_MS = 30000;
+const DAEMON_READY_POLL_MS = 200;
 // A live daemon refreshes daemon.lock mtime every 60s (HEARTBEAT_INTERVAL_MS).
 // Treat mtime younger than 2.5x that as proof of life, even if a ping times
 // out — a busy daemon with a blocked event loop can still be heartbeating.
@@ -126,6 +129,15 @@ function isDaemonRunning(opts) {
         return resp.ok === true;
     });
 }
+function isDaemonReady(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const resp = yield sendDaemonCommand({ cmd: "ping" }, { timeoutMs: (_a = opts === null || opts === void 0 ? void 0 : opts.timeoutMs) !== null && _a !== void 0 ? _a : 2000 });
+        // Old daemons do not include `ready`; treat missing as ready so an upgraded
+        // CLI does not hang on a still-running daemon from the previous release.
+        return resp.ok === true && resp.ready !== false;
+    });
+}
 /**
  * Lock-file-based liveness probe. A running daemon refreshes daemon.lock's
  * mtime every 60s via its heartbeat loop; a fresh mtime means the daemon is
@@ -194,6 +206,11 @@ function waitForProcessExit(pid, timeoutMs) {
 // LLM/MLX teardown. Treat a draining marker as authoritative for this long; past
 // it, assume the draining daemon wedged and let killStaleProcesses reclaim it.
 const DRAIN_GRACE_MS = 90000;
+function waitForDaemonDrain(pid_1) {
+    return __awaiter(this, arguments, void 0, function* (pid, timeoutMs = DRAIN_GRACE_MS) {
+        return waitForProcessExit(pid, timeoutMs);
+    });
+}
 /**
  * Record that this daemon (pid) has begun graceful shutdown, so a successor's
  * killStaleProcesses() won't SIGKILL it mid-cleanup after it drops its
@@ -240,20 +257,23 @@ function isDaemonDraining(pid) {
     }
 }
 /**
- * Ensure the daemon is running — start it if needed, poll up to 5s.
+ * Ensure the daemon is running — start it if needed, then wait for resources.
  * Returns true if daemon is ready, false if it couldn't be started.
  */
 function ensureDaemonRunning() {
     return __awaiter(this, void 0, void 0, function* () {
-        if (yield isDaemonRunning())
+        if (yield isDaemonReady())
             return true;
-        const { spawnDaemon } = yield Promise.resolve().then(() => __importStar(require("./daemon-launcher")));
-        const pid = spawnDaemon();
-        if (!pid)
-            return false;
-        for (let i = 0; i < 25; i++) {
-            yield new Promise((r) => setTimeout(r, 200));
-            if (yield isDaemonRunning())
+        if (!(yield isDaemonRunning())) {
+            const { spawnDaemon } = yield Promise.resolve().then(() => __importStar(require("./daemon-launcher")));
+            const pid = spawnDaemon();
+            if (!pid)
+                return false;
+        }
+        const deadline = Date.now() + DAEMON_READY_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            yield new Promise((r) => setTimeout(r, DAEMON_READY_POLL_MS));
+            if (yield isDaemonReady())
                 return true;
         }
         return false;
@@ -315,6 +335,12 @@ function sendStreamingCommand(cmd, onProgress, opts) {
                         // (DB flush, compaction). Reset the watchdog; do not surface.
                         resetTimer();
                     }
+                    else if (msg.ok === false) {
+                        const error = typeof msg.error === "string"
+                            ? msg.error
+                            : "daemon command failed";
+                        finish(new Error(error));
+                    }
                 }
                 catch (_a) {
                     console.warn("[daemon-client] Malformed response line:", line.slice(0, 200));

package/dist/lib/workers/pool.js

@@ -203,6 +203,7 @@ class WorkerPool {
         this.destroyed = false;
         this.destroyPromise = null;
         this.consecutiveRespawns = 0;
+        this.respawnLimitReached = false;
         this.idleReapInterval = null;
         const resolved = resolveProcessWorker();
         this.modulePath = resolved.filename;
@@ -246,6 +247,37 @@ class WorkerPool {
         if (idx !== -1)
             this.taskQueue.splice(idx, 1);
     }
+    hasUnassignedTasks() {
+        const hasUnassigned = (queue) => queue.some((id) => {
+            const t = this.tasks.get(id);
+            return t && !t.worker;
+        });
+        return hasUnassigned(this.priorityQueue) || hasUnassigned(this.taskQueue);
+    }
+    rejectUnassignedTasks(message) {
+        for (const task of Array.from(this.tasks.values())) {
+            if (task.worker)
+                continue;
+            task.reject(new Error(message));
+            this.completeTask(task, null);
+        }
+    }
+    maybeRespawn(reason, hasPendingTasks) {
+        if (this.destroyed || this.respawnLimitReached)
+            return false;
+        this.consecutiveRespawns++;
+        (0, logger_1.log)("pool", `respawn #${this.consecutiveRespawns} after ${reason} (workers=${this.workers.length} pending=${hasPendingTasks})`);
+        if (this.consecutiveRespawns > WorkerPool.MAX_RESPAWNS) {
+            this.respawnLimitReached = true;
+            const message = `Worker respawn limit reached (${WorkerPool.MAX_RESPAWNS}). Not spawning more workers.`;
+            console.error(`[pool] ${message}`);
+            if (this.workers.length === 0)
+                this.rejectUnassignedTasks(message);
+            return false;
+        }
+        this.spawnWorker();
+        return true;
+    }
     completeTask(task, worker) {
         this.clearTaskTimeout(task);
         this.tasks.delete(task.id);
@@ -280,19 +312,9 @@ class WorkerPool {
         this.workers = this.workers.filter((w) => w !== worker);
         if (!this.destroyed) {
             // Only respawn if we have no workers left or there are pending tasks
-            const hasUnassigned = (queue) => queue.some((id) => {
-                const t = this.tasks.get(id);
-                return t && !t.worker;
-            });
-            const hasPendingTasks = hasUnassigned(this.priorityQueue) || hasUnassigned(this.taskQueue);
+            const hasPendingTasks = this.hasUnassignedTasks();
             if (this.workers.length === 0 || hasPendingTasks) {
-                this.consecutiveRespawns++;
-                (0, logger_1.log)("pool", `respawn #${this.consecutiveRespawns} after exit (workers=${this.workers.length} pending=${hasPendingTasks})`);
-                if (this.consecutiveRespawns > WorkerPool.MAX_RESPAWNS) {
-                    console.error(`[pool] Worker respawn limit reached (${WorkerPool.MAX_RESPAWNS}). Not spawning more workers.`);
-                    return;
-                }
-                this.spawnWorker();
+                this.maybeRespawn(reason, hasPendingTasks);
             }
             this.dispatch();
         }
@@ -350,6 +372,7 @@ class WorkerPool {
             }
             this.completeTask(task, worker);
             this.consecutiveRespawns = 0;
+            this.respawnLimitReached = false;
             this.recycleIfBloated(worker);
             this.dispatch();
         };
@@ -452,7 +475,7 @@ class WorkerPool {
         catch (_e) { }
         this.workers = this.workers.filter((w) => w !== worker);
         if (!this.destroyed) {
-            this.spawnWorker();
+            this.maybeRespawn(`timeout (${reason})`, this.hasUnassignedTasks());
         }
         this.dispatch();
     }
@@ -472,6 +495,12 @@ class WorkerPool {
             return;
         // Lazy spawn: if no idle worker and below max, spawn one
         if (!idle && this.workers.length < this.maxWorkers) {
+            if (this.respawnLimitReached) {
+                if (this.workers.length === 0) {
+                    this.rejectUnassignedTasks(`Worker respawn limit reached (${WorkerPool.MAX_RESPAWNS}). Not spawning more workers.`);
+                }
+                return;
+            }
             this.spawnWorker();
             idle = this.workers[this.workers.length - 1];
         }
@@ -691,22 +720,35 @@ class WorkerPool {
             this.taskQueue = [];
             this.priorityQueue = [];
             const killPromises = this.workers.map((w) => new Promise((resolve) => {
+                var _a, _b;
+                let settled = false;
+                let force;
+                let fallback;
+                const cleanup = () => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    if (force)
+                        clearTimeout(force);
+                    if (fallback)
+                        clearTimeout(fallback);
+                    resolve();
+                };
                 w.cleanedUp = true;
                 w.child.removeAllListeners("message");
                 w.child.removeAllListeners("exit");
                 w.child.removeAllListeners("error");
-                w.child.once("exit", () => resolve());
-                w.child.kill("SIGTERM");
-                const force = setTimeout(() => {
+                w.child.once("exit", cleanup);
+                force = setTimeout(() => {
                     try {
                         w.child.kill("SIGKILL");
                     }
                     catch (_a) { }
                 }, FORCE_KILL_GRACE_MS);
-                setTimeout(() => {
-                    clearTimeout(force);
-                    resolve();
-                }, config_1.WORKER_TIMEOUT_MS);
+                (_a = force.unref) === null || _a === void 0 ? void 0 : _a.call(force);
+                fallback = setTimeout(cleanup, config_1.WORKER_TIMEOUT_MS);
+                (_b = fallback.unref) === null || _b === void 0 ? void 0 : _b.call(fallback);
+                w.child.kill("SIGTERM");
             }));
             this.destroyPromise = Promise.allSettled(killPromises).then(() => {
                 this.workers = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.21.3",
+  "version": "0.22.0",
   "author": "Robert Owens <78518764+reowens@users.noreply.github.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {
@@ -10,7 +10,7 @@
     "type": "git",
     "url": "https://github.com/reowens/grepmax.git"
   },
-  "main": "index.js",
+  "main": "dist/index.js",
   "bin": {
     "gmax": "dist/index.js"
   },
@@ -19,7 +19,7 @@
   },
   "scripts": {
     "postinstall": "node scripts/postinstall.js",
-    "prebuild": "mkdir -p dist",
+    "prebuild": "rm -rf dist tsconfig.tsbuildinfo && mkdir -p dist",
     "build": "tsc",
     "postbuild": "chmod +x dist/index.js",
     "dev": "npx tsc && node dist/index.js",
@@ -96,6 +96,11 @@
     "web-tree-sitter": "^0.26.9",
     "zod": "^4.4.3"
   },
+  "pnpm": {
+    "overrides": {
+      "mathjs": "15.2.0"
+    }
+  },
   "devDependencies": {
     "@biomejs/biome": "2.4.10",
     "@types/node": "^26.0.1",

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

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.21.3",
+  "version": "0.22.0",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",
@@ -10,11 +10,5 @@
   "homepage": "https://github.com/reowens/grepmax",
   "repository": "https://github.com/reowens/grepmax",
   "license": "Apache-2.0",
-  "keywords": [
-    "search",
-    "semantic",
-    "grep",
-    "code-search",
-    "semantic-search"
-  ]
+  "keywords": ["search", "semantic", "grep", "code-search", "semantic-search"]
 }

package/scripts/postinstall.js

@@ -1,121 +1,14 @@
 #!/usr/bin/env node
 /**
- * Postinstall: sync plugin files to all installed integrations.
- * Runs after `npm install -g grepmax@latest` to automatically update
- * skills, hooks, and configs without manual re-installation.
+ * Postinstall intentionally does not modify user-home agent configuration.
+ * Users can install or update integrations explicitly with:
  *
- * Supported integrations:
- * - Claude Code: sync skills/hooks to plugin cache
- * - OpenCode: re-run installer (regenerates tool shim + plugin)
- * - Codex: re-run installer (updates AGENTS.md + MCP registration)
- * - Factory Droid: re-run installer (updates skills + hooks)
+ *   gmax plugin add
+ *   gmax plugin update
  */
-const fs = require("node:fs");
-const path = require("node:path");
-const os = require("node:os");
-const { execSync } = require("node:child_process");
 
-const sourcePlugin = path.join(__dirname, "..", "plugins", "grepmax");
-
-// --- Claude Code: sync files to plugin cache ---
-const pluginCacheBase = path.join(
-  os.homedir(),
-  ".claude",
-  "plugins",
-  "cache",
-  "grepmax",
-  "grepmax",
-);
-
-if (fs.existsSync(pluginCacheBase) && fs.existsSync(sourcePlugin)) {
-  let entries;
-  try {
-    entries = fs.readdirSync(pluginCacheBase, { withFileTypes: true });
-  } catch {
-    entries = [];
-  }
-
-  const versionDirs = entries
-    .filter((e) => e.isDirectory())
-    .map((e) => e.name);
-
-  function copyRecursive(src, dest) {
-    if (!fs.existsSync(src)) return;
-    const stat = fs.statSync(src);
-    if (stat.isDirectory()) {
-      fs.mkdirSync(dest, { recursive: true });
-      for (const entry of fs.readdirSync(src)) {
-        copyRecursive(path.join(src, entry), path.join(dest, entry));
-      }
-    } else {
-      fs.mkdirSync(path.dirname(dest), { recursive: true });
-      fs.copyFileSync(src, dest);
-    }
-  }
-
-  for (const ver of versionDirs) {
-    const destDir = path.join(pluginCacheBase, ver);
-    try {
-      copyRecursive(
-        path.join(sourcePlugin, "skills"),
-        path.join(destDir, "skills"),
-      );
-      copyRecursive(
-        path.join(sourcePlugin, "hooks"),
-        path.join(destDir, "hooks"),
-      );
-      const hooksJson = path.join(sourcePlugin, "hooks.json");
-      if (fs.existsSync(hooksJson)) {
-        fs.copyFileSync(hooksJson, path.join(destDir, "hooks.json"));
-      }
-    } catch {
-      // Best-effort
-    }
-  }
-}
-
-// --- OpenCode: re-run installer if tool shim or plugin exists ---
-const ocToolPath = path.join(
-  os.homedir(),
-  ".config",
-  "opencode",
-  "tool",
-  "gmax.ts",
-);
-const ocPluginPath = path.join(
-  os.homedir(),
-  ".config",
-  "opencode",
-  "plugins",
-  "gmax.ts",
-);
-if (fs.existsSync(ocToolPath) || fs.existsSync(ocPluginPath)) {
-  try {
-    execSync("gmax install-opencode", { stdio: "ignore", timeout: 10000 });
-  } catch {}
-}
-
-// --- Codex: re-run installer if AGENTS.md has gmax skill ---
-const codexAgentsPath = path.join(os.homedir(), ".codex", "AGENTS.md");
-if (fs.existsSync(codexAgentsPath)) {
-  try {
-    const content = fs.readFileSync(codexAgentsPath, "utf-8");
-    if (content.includes("gmax")) {
-      execSync("gmax install-codex", { stdio: "ignore", timeout: 10000 });
-    }
-  } catch {}
-}
-
-// --- Factory Droid: re-run installer if skill exists ---
-const droidSkillPath = path.join(
-  os.homedir(),
-  ".factory",
-  "skills",
-  "gmax",
-  "SKILL.md",
-);
-if (fs.existsSync(droidSkillPath)) {
-  try {
-    execSync("gmax install-droid", { stdio: "ignore", timeout: 10000 });
-  } catch {}
+if (process.env.GMAX_POSTINSTALL_QUIET !== "1") {
+  console.log(
+    "gmax installed. To install or update editor plugins, run: gmax plugin update",
+  );
 }