vexp-cli 3.1.1 → 3.1.2

package/dist/agent-config.js

@@ -2918,7 +2918,11 @@ export function installCodexHintHook(workspaceRoot, binaryPath) {
     let root = {};
     if (fs.existsSync(hooksJsonPath)) {
         try {
-            root = JSON.parse(fs.readFileSync(hooksJsonPath, "utf-8"));
+            // parseJsonc, not JSON.parse: every other config reader here is
+            // BOM-tolerant and this one was missed. Windows PowerShell 5.1 writes
+            // JSON with a UTF-8 BOM, and a user who edits .codex/hooks.json by hand
+            // there would have the hook silently left unregistered.
+            root = parseJsonc(fs.readFileSync(hooksJsonPath, "utf-8"));
         }
         catch {
             warnUnparseable(hooksJsonPath);

package/dist/cli.js

@@ -66,13 +66,24 @@ program.hook("preAction", async (_thisCmd, actionCmd) => {
     // the parent, so we boot (or reuse) the parent daemon instead of spawning
     // a conflicting one for the child.
     const eff = findEffectiveWorkspace();
-    if (!eff)
+    // Say so. Bootstrapping is what replaces a stale daemon and takes over a
+    // stale MCP server on :7821, and it is silently skipped outside a
+    // configured workspace: a tester ran the command doctor had suggested from
+    // a package subdirectory of a monorepo, got no error and no takeover, and
+    // reasonably concluded the server had been replaced (tier-4 field report,
+    // 2026-09-05). Doing nothing quietly is the one outcome that cannot be
+    // told apart from success.
+    if (!eff) {
+        console.error(chalk.yellow(`  ⚠ no vexp workspace found from ${process.cwd()} — the daemon and the MCP server were NOT started or updated.`));
+        console.error(chalk.dim(`     vexp walks up for .vexp/manifest.json; run 'vexp setup' in the workspace root.`));
         return;
+    }
     let binaryPath;
     try {
         binaryPath = getBinaryPath();
     }
-    catch {
+    catch (err) {
+        console.error(chalk.yellow(`  ⚠ vexp-core binary not resolved (${err instanceof Error ? err.message : err}) — nothing was started or updated.`));
         return;
     }
     // Full bootstrap: daemon + MCP + autostart-if-needed. All three steps are
@@ -274,7 +285,12 @@ async function ensureBootstrap(workspaceRoot, binaryPath) {
     try {
         await ensureMcpHttpServer({ owner: "cli" });
     }
-    catch { /* non-fatal */ }
+    catch (err) {
+        // Non-fatal, but never silent: this is the step that replaces an MCP
+        // server left behind by an older install, and skipping it leaves every
+        // MCP client on the old build.
+        console.error(chalk.dim(`  ⚠ MCP HTTP server not started or taken over: ${err instanceof Error ? err.message : err}`));
+    }
 }
 /**
  * Start the vexp daemon and MCP HTTP server in the background.
@@ -725,6 +741,21 @@ program
             selectedNames = requested.map((n) => resolveAgentName(n));
             console.log(chalk.dim(`  Agents (from flag): ${selectedNames.join(", ")}`));
         }
+        else if (!process.stdin.isTTY) {
+            // No one is at the keyboard. This command is named as a remediation
+            // in doctor's own output, and an agent — or a CI step, or a script
+            // reading that line — cannot answer a prompt: it hangs until it is
+            // killed, which is worse than failing (field report, 2026-09-07: a
+            // tester followed doctor's advice and had to abandon the command).
+            // Configure what is detected, and say that is what happened.
+            selectedNames = allAgents.filter((a) => detectedNames.has(a.agent)).map((a) => a.agent);
+            if (selectedNames.length === 0) {
+                console.error(chalk.yellow("  No AI agent detected here and stdin is not a terminal — nothing to configure."));
+                console.error(chalk.dim("  Name them explicitly: vexp setup --agents \"Claude Code,Codex\""));
+                process.exit(1);
+            }
+            console.log(chalk.dim(`  Agents (detected, non-interactive): ${selectedNames.join(", ")}`));
+        }
         else {
             // Interactive selection
             console.log(chalk.bold("\n  Select AI agents to configure:\n"));

package/dist/doctor.js

@@ -207,7 +207,7 @@ export function gitHooksVerdict(hooksPath, repoRoot, installedCount) {
  * wherever it stands. Null when nothing was skipped for size, or when the
  * file predates 3.1 and has no skip keys.
  */
-export function coverageVerdict(cov) {
+export function coverageVerdict(cov, coveragePath = ".vexp/coverage.json") {
     if (!cov || typeof cov !== "object")
         return null;
     const c = cov;
@@ -225,7 +225,12 @@ export function coverageVerdict(cov) {
         level: WARN,
         message: `${oversized} file(s) over max_file_size_kb = ${cap} are NOT indexed — their symbols and callers are invisible to impact, search and run_pipeline:\n` +
             examples.map((e) => `        - ${e}`).join("\n") +
-            (more > 0 ? `\n        … +${more} more (full list: .vexp/coverage.json)` : "") +
+            (more > 0 ? `\n        … +${more} more` : "") +
+            // The path, not the name. coverage.json lives at the WORKSPACE root;
+            // a tester on a monorepo looked for it beside the package he was
+            // working in, found nothing, and concluded the feature had not
+            // shipped (tier-4 field report, 2026-09-05).
+            `\n        full list: ${coveragePath}` +
             `\n        raise max_file_size_kb in .vexp/vexp.toml (0 = no cap) to include them, or exclude them on purpose with exclude_patterns — excluded files stop being counted here at the next reindex ('vexp index').`,
     };
 }
@@ -334,7 +339,7 @@ export function workspaceCoverageFindings(root) {
         catch {
             continue; /* never indexed, or an index older than 2.7 */
         }
-        const v = coverageVerdict(cov);
+        const v = coverageVerdict(cov, path.join(t.dir, ".vexp", "coverage.json"));
         if (v)
             out.push({ level: v.level, message: targets.length > 1 ? `[${t.alias}] ${v.message}` : v.message });
     }
@@ -394,9 +399,18 @@ export async function runDoctor() {
     if (live) {
         const st = await queryDaemon(sock, "index_status");
         if (st) {
+            // A daemon that is still loading its model answers "rule", which reads
+            // as a downgrade for the ~20s it takes to settle. The daemon already
+            // says which of the two it is; doctor was printing the label and
+            // dropping the reason (tier-4 field report, 2026-09-05).
+            const loading = st.compressor !== "llm"
+                && typeof st.llm_inactive_reason === "string"
+                && /still loading|finishing its startup/i.test(st.llm_inactive_reason);
             const comp = st.compressor === "llm"
                 ? `llm (${st.llm_model ?? "?"}, ${st.llm_inference ?? "?"})`
-                : st.compressor ?? "unknown (older daemon)";
+                : loading
+                    ? "loading (the model is still starting — this is not the rule compressor settling in)"
+                    : st.compressor ?? "unknown (older daemon)";
             line(OK, `index: ${st.total_files ?? "?"} files · ${st.total_nodes ?? "?"} nodes · state ${st.status ?? "?"} · compressor ${comp}`);
             if (st.llm_configured_but_inactive === true) {
                 // The daemon knows WHY, and doctor was throwing it away: it printed
@@ -1004,22 +1018,53 @@ export async function runDoctor() {
             }
         }
     }
+    // A supervisor from an older install respawning the current bundle. It
+    // keeps reclaiming :7821 every 60s, and NO takeover rule on this side can
+    // stop it: the old process runs the old comparison. The only fix is to end
+    // it, so doctor has to name it — with its pid, which the record now
+    // carries. A tester spent a night on a :7821 server that came back with a
+    // new pid every two minutes, reported as v3.0.1 on a machine where 3.0.1
+    // was not installed anywhere: the LABEL came from a `vexp serve` resident
+    // since before the upgrade, holding its own version in memory
+    // (field report, 2026-09-06).
+    const staleSupervisorLine = (rec) => {
+        const by = typeof rec.spawnedBy === "string" ? rec.spawnedBy : undefined;
+        if (!by || by === CLI_VERSION)
+            return;
+        const pid = typeof rec.spawnedByPid === "number" ? rec.spawnedByPid : undefined;
+        const stillUp = pid !== undefined && isAlive(pid);
+        const who = rec.owner === "serve" ? "'vexp serve' supervisor" : `${rec.owner ?? "process"}`;
+        line(WARN, `that server was spawned by a ${who} running v${by}, not v${CLI_VERSION}` +
+            (pid ? ` (pid ${pid}${stillUp ? ", still running" : ", already gone"})` : "") +
+            `\n        an older supervisor reclaims :${rec.port} on its own schedule and cannot be stopped by re-running setup` +
+            // Ending it is the whole remediation: login autostart (or the next
+            // `vexp` command) starts a fresh supervisor, which reads the current
+            // package.json and serves the current build. The tester who did this
+            // had a correct server one second later without running anything
+            // else — and the `vexp setup` this line used to recommend blocks on
+            // an interactive prompt, which for the reader of a doctor line is a
+            // hang, not a fix (field report, 2026-09-07).
+            (stillUp ? `\n        end it — 'kill ${pid}' — a fresh supervisor starts on its own and serves the current build` : ""));
+    };
     // 6) HTTP MCP supervisor.
     console.log(chalk.bold("\nHTTP MCP supervisor (~/.vexp/mcp.pid)"));
     try {
         const rec = JSON.parse(fs.readFileSync(path.join(home, ".vexp", "mcp.pid"), "utf-8"));
         const alive = isAlive(rec.pid);
         line(alive ? OK : WARN, `pid ${rec.pid} on :${rec.port} — ${alive ? "alive" : "DEAD (stale pid file)"}${rec.version ? ` · v${rec.version}` : ""}`);
+        if (alive && rec.version === CLI_VERSION)
+            staleSupervisorLine(rec);
         // The supervisor is replaced on version mismatch only when a vexp command
         // next runs; until then every HTTP client (Codex http transport, a
         // `serverUrl` entry) talks to the OLD build — which advertises the old
         // tool surface (2 tools before 2.7.0) and none of the newer fixes. A user
         // saw two vexp servers with different tool counts and could not tell why.
         if (alive && rec.version && rec.version !== CLI_VERSION) {
-            line(WARN, `the HTTP MCP server on :${rec.port} is v${rec.version} but this CLI is v${CLI_VERSION} — HTTP clients get the old build until it is replaced — run 'vexp setup' (or any indexing/search command, e.g. 'vexp savings') in the project and the current CLI takes it over`);
+            line(WARN, `the HTTP MCP server on :${rec.port} is v${rec.version} but this CLI is v${CLI_VERSION} — HTTP clients get the old build until it is replaced — run 'vexp setup' in the WORKSPACE ROOT (the directory holding .vexp/) and the current CLI takes it over`);
+            staleSupervisorLine(rec);
         }
         else if (alive && !rec.version) {
-            line(WARN, `the HTTP MCP server on :${rec.port} predates version tracking (older than 2.4) — run 'vexp setup' (or 'vexp savings') in the project so the current CLI replaces it and HTTP clients get v${CLI_VERSION}`);
+            line(WARN, `the HTTP MCP server on :${rec.port} predates version tracking (older than 2.4) — run 'vexp setup' in the WORKSPACE ROOT so the current CLI replaces it and HTTP clients get v${CLI_VERSION}`);
         }
     }
     catch {

package/dist/mcp-supervisor.js

@@ -33,6 +33,8 @@ export function readPidRecord() {
                 // pass (measured 60.7s replacement period). The reuse fast path
                 // is only as good as the record it reads.
                 version: typeof rec.version === "string" ? rec.version : undefined,
+                spawnedBy: typeof rec.spawnedBy === "string" ? rec.spawnedBy : undefined,
+                spawnedByPid: typeof rec.spawnedByPid === "number" ? rec.spawnedByPid : undefined,
             };
         }
     }
@@ -97,6 +99,48 @@ export function resolveOrGenerateMcpToken() {
  * The MCP server is deliberately workspace-agnostic: clients disambiguate
  * via URL path /ws/<workspaceHash>/mcp. No VEXP_WORKSPACE env is passed.
  */
+/**
+ * Is the running server's version strictly older than ours?
+ *
+ * A record with no version predates version tracking (< 2.4) and counts as
+ * older. An unparseable version counts as older too: replacing it once is
+ * recoverable, whereas deferring to it forever is what the field report
+ * showed. A NEWER server is left alone — this process is the stale one.
+ */
+/**
+ * The version of the MCP bundle at `mcpPath`, read from the package.json that
+ * ships it — the build a client will actually be served, as opposed to the
+ * version of whatever process happens to be spawning it.
+ */
+export function mcpBundleVersion(mcpPath) {
+    const pkg = path.resolve(path.dirname(mcpPath), "..", "package.json");
+    try {
+        const parsed = JSON.parse(fs.readFileSync(pkg, "utf-8"));
+        if (typeof parsed.version === "string")
+            return parsed.version;
+    }
+    catch { /* not readable: fall back to the caller's own version */ }
+    return undefined;
+}
+export function isOlderVersion(recorded, mine) {
+    if (!recorded)
+        return true;
+    if (recorded === mine)
+        return false;
+    const parts = (v) => {
+        const nums = v.split("-")[0].split(".").map((n) => Number.parseInt(n, 10));
+        return nums.length === 3 && nums.every((n) => Number.isFinite(n)) ? nums : null;
+    };
+    const a = parts(recorded);
+    const b = parts(mine);
+    if (!a || !b)
+        return true;
+    for (let i = 0; i < 3; i++) {
+        if (a[i] !== b[i])
+            return a[i] < b[i];
+    }
+    return false;
+}
 export async function ensureMcpHttpServer(opts = {}) {
     const port = opts.port ?? DEFAULT_PORT;
     const owner = opts.owner ?? "unknown";
@@ -104,15 +148,23 @@ export async function ensureMcpHttpServer(opts = {}) {
     const mcpPath = getMcpServerPath();
     if (!mcpPath)
         return null;
-    // Fast path: already alive and tracked - but only if it is OUR version.
-    // Field report (Nathan): a 2.3.0 http server stayed authoritative for
-    // 9 days across extension upgrades because reuse never compared
-    // versions. On mismatch (or a legacy record without one) we take over:
-    // SIGTERM the old listener and spawn the current build.
+    // Fast path: already alive and tracked - but only if it is not OLDER than
+    // us. Field report (Nathan): a 2.3.0 http server stayed authoritative for
+    // 9 days across extension upgrades because reuse never compared versions.
+    // On an older server we take over: SIGTERM the old listener and spawn the
+    // current build.
+    //
+    // The comparison is ORDERED, not an equality check. Equality made takeover
+    // symmetric, so two installs of different versions each saw the other as
+    // "not mine" and reclaimed the port from it — and `vexp serve` re-runs this
+    // every 60s, so a supervisor left behind by an older install resurrected
+    // its own build indefinitely. A tester watched a v3.0.1 server come back
+    // after being replaced by v3.1.1, with a fresh pid (tier-4 field report,
+    // 2026-09-05). An older build now stands down and reuses what is there.
     {
         const existing = readPidRecord();
         if (existing && existing.port === port && isPidAlive(existing.pid) && (await isPortInUse(port))) {
-            if (existing.version === CLI_VERSION) {
+            if (!isOlderVersion(existing.version, CLI_VERSION)) {
                 return { pid: existing.pid, port, started: false };
             }
             try {
@@ -184,7 +236,15 @@ export async function ensureMcpHttpServer(opts = {}) {
         const pid = child.pid;
         if (!pid)
             return null;
-        writePidRecord({ pid, port, startedAt: Date.now(), owner, version: CLI_VERSION });
+        writePidRecord({
+            pid,
+            port,
+            startedAt: Date.now(),
+            owner,
+            version: mcpBundleVersion(mcpPath) ?? CLI_VERSION,
+            spawnedBy: CLI_VERSION,
+            spawnedByPid: process.pid,
+        });
         // Wait for the child to actually bind the port BEFORE releasing the
         // lock. Without this, a second caller arriving right after release
         // sees pidfile+live-pid but port-not-yet-bound → falsely concludes

package/dist/serve.js

@@ -207,7 +207,46 @@ async function resurrectAll() {
         if (resurrected.get(sock))
             live[ws] = sock;
     }
-    writeRegistry(live);
+    // A row this supervisor did not resurrect is not thereby dead.
+    //
+    // `live` used to become the WHOLE new registry, so every row the plan
+    // skipped — another supervisor's daemon, a linked worktree, a workspace
+    // whose manifest had moved — was deleted while its daemon was still
+    // running and answering on its socket. The health loop re-runs this every
+    // 60s, so the deletion was permanent and self-renewing: on a tester's
+    // machine two daemons that had been serving a pre-upgrade build for five
+    // days disappeared from `vexp daemons`, from `index_status`'s "other live
+    // daemons" and from the concurrency fence the moment a supervisor
+    // restarted, leaving a three-daemon box reporting a clean single-workspace
+    // install (field report, 2026-09-07).
+    //
+    // Liveness decides what stays in the registry, never ownership. The fence
+    // counts these rows, so dropping a live daemon also made the cap evadable
+    // by restarting a supervisor.
+    writeRegistry(await survivingRegistryRows(reg, live, isSocketAlive, appendLog));
+}
+/**
+ * The rows that stay in `~/.vexp/daemons.json` after a resurrection pass:
+ * everything this supervisor brought up, PLUS every other row whose daemon is
+ * still answering. Only a row that is neither is dropped.
+ *
+ * Separated out because the rule is the whole bug: a supervisor may only
+ * report what it could not find, never delete what it does not own.
+ */
+export async function survivingRegistryRows(before, resurrected, alive, log = () => { }) {
+    const canonical = (ws) => (process.platform === "win32" ? ws.toLowerCase() : ws);
+    const out = { ...resurrected };
+    const kept = new Set(Object.keys(out).map(canonical));
+    for (const [ws, sock] of Object.entries(before)) {
+        if (kept.has(canonical(ws)))
+            continue;
+        if (await alive(sock)) {
+            out[ws] = sock;
+            kept.add(canonical(ws));
+            log(`registry keep: ${ws} (not ours to resurrect, but its daemon is alive)`);
+        }
+    }
+    return out;
 }
 async function startMcp() {
     const port = parseInt(process.env.VEXP_PORT ?? String(DEFAULT_MCP_PORT), 10);