vexp-cli 2.2.4 → 2.3.0

package/dist/cli.js

@@ -8,7 +8,7 @@ import * as fs from "fs";
 import * as net from "net";
 import { checkbox, confirm } from "@inquirer/prompts";
 import { getBinaryPath, getInstalledVersion, getMcpServerPath, binaryEnv } from "./binary.js";
-import { detectAgents, getAgentList, configureSelectedAgents, resolveAgentName, suggestAgentName } from "./agent-config.js";
+import { detectAgents, getAgentList, configureSelectedAgents, resolveAgentName, suggestAgentName, setGuardMode } from "./agent-config.js";
 import { CLI_VERSION } from "./version.js";
 import { activateLicense, deactivateLicense, readLicenseLimits, readDeviceBlocked, } from "./license.js";
 import { checkForUpdate } from "./update-check.js";
@@ -533,8 +533,10 @@ program
     .option("--agents [list]", "Filter agents to configure (comma-separated). Without value: auto-detect all")
     .option("--dry-run", "Show what would be configured without writing files")
     .option("--personal", "Personal mode: index locally without writing agent configs or git hooks to the shared repo")
+    .option("--guard-strict", "Install the Grep/Glob deny hooks (opt-in since 2.3; default setup removes them)")
     .action(async (dir, opts) => {
     const workspaceRoot = path.resolve(dir ?? process.cwd());
+    setGuardMode(opts.guardStrict ? "strict" : "off");
     console.log(chalk.bold(`\nvexp setup — ${workspaceRoot}\n`));
     // Step 1: Ensure binary
     const spinner1 = ora("Checking vexp binary...").start();
@@ -737,7 +739,9 @@ program
 program
     .command("setup-agents [dir]")
     .description("Configure AI coding agents to use vexp MCP (interactive multi-select)")
-    .action(async (dir) => {
+    .option("--guard-strict", "Install the Grep/Glob deny hooks (opt-in since 2.3; default removes them)")
+    .action(async (dir, opts) => {
+    setGuardMode(opts.guardStrict ? "strict" : "off");
     await runSetupAgents(dir);
 });
 async function runSetupAgents(dir) {

package/dist/doctor.js

@@ -48,6 +48,32 @@ function resolveWorkspace() {
 // it — so doctor probed a pipe name the daemon never binds for ~6% of Windows
 // workspaces and declared a healthy daemon down.
 const socketForWorkspace = socketPathFor;
+/** One-shot daemon query over the newline-JSON socket protocol. Returns the
+ *  `result` payload or null on any failure — doctor must never hang or throw. */
+function queryDaemon(sock, tool, timeoutMs = 2500) {
+    return new Promise((resolve) => {
+        const c = process.platform === "win32" ? net.createConnection(sock) : net.createConnection({ path: sock });
+        let buf = "";
+        const t = setTimeout(() => { c.destroy(); resolve(null); }, timeoutMs);
+        c.on("connect", () => c.write(JSON.stringify({ id: 1, tool, params: {} }) + "\n"));
+        c.on("data", (d) => {
+            buf += d.toString();
+            const i = buf.indexOf("\n");
+            if (i !== -1) {
+                clearTimeout(t);
+                c.destroy();
+                try {
+                    const parsed = JSON.parse(buf.slice(0, i));
+                    resolve(parsed?.result ?? null);
+                }
+                catch {
+                    resolve(null);
+                }
+            }
+        });
+        c.on("error", () => { clearTimeout(t); resolve(null); });
+    });
+}
 function reachable(sock, timeoutMs = 600) {
     return new Promise((resolve) => {
         const c = process.platform === "win32" ? net.createConnection(sock) : net.createConnection({ path: sock });
@@ -111,6 +137,34 @@ export async function runDoctor() {
     line(live ? OK : WARN, `daemon socket ${live ? "reachable" : "NOT reachable"}: ${sock}`);
     if (!live)
         console.log(chalk.dim(`        → run: vexp daemon-cmd start   (or 'vexp daemon-cmd restart')`));
+    // 2.3 B1/B2 — live daemon truth: coverage + active compressor. The config can
+    // say "LLM enabled" while the daemon serves rule-compressed output (config
+    // race / stale daemon / non-LLM build); only the daemon knows what's active.
+    if (live) {
+        const st = await queryDaemon(sock, "index_status");
+        if (st) {
+            const comp = st.compressor === "llm"
+                ? `llm (${st.llm_model ?? "?"}, ${st.llm_inference ?? "?"})`
+                : 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) {
+                line(WARN, `local LLM is installed and enabled in config but this daemon runs the RULE compressor — results are not LLM-compressed. Run 'vexp daemon-cmd restart' to load the model.`);
+            }
+            // 2.3 C1 — which agent sessions actually used vexp (a session with zero
+            // calls never shows up here; that absence is the diagnostic).
+            const sessions = Array.isArray(st.sessions) ? st.sessions : [];
+            if (sessions.length > 0) {
+                const total = sessions.reduce((n, s) => n + (Number(s.pipeline_calls) || 0), 0);
+                line(OK, `sessions (4h): ${sessions.length} active, ${total} pipeline calls total`);
+            }
+            else if (Number(st.daemon_uptime_s) > 600) {
+                line(WARN, `no agent session has called vexp since daemon start — if an agent is working here, it is not using vexp (check its MCP config)`);
+            }
+            else {
+                line(OK, `no session calls yet (daemon just started)`);
+            }
+        }
+    }
     // 2) Daemon registry (~/.vexp/daemons.json) — stale entries are a drift source.
     console.log(chalk.bold("\nDaemon registry (~/.vexp/daemons.json)"));
     const regPath = path.join(home, ".vexp", "daemons.json");

package/dist/serve.js

@@ -89,17 +89,71 @@ async function resurrectDaemon(workspaceRoot, socketPath) {
         return false;
     }
 }
+/** True when `sock` is the canonical socket for `ws` itself (unix path or the
+ *  win32 named pipe derived from `ws`). A registry row that FAILS this is a
+ *  ROUTING entry: a connected secondary repo mapped to its parent workspace's
+ *  socket so lookups route correctly. */
+export function isOwnerEntry(ws, sock) {
+    if (process.platform === "win32") {
+        // Named pipes carry no path; treat the row as owner unless another row
+        // with the same pipe proves otherwise (handled by the grouping below).
+        return true;
+    }
+    return path.resolve(sock) === path.resolve(path.join(ws, ".vexp", "daemon.sock"));
+}
+/** One (workspace, socket) spawn per SOCKET, always the socket's OWNER root.
+ *  Field incident (2026-07-23): the registry legitimately maps a connected
+ *  repo to its PARENT workspace's socket for routing; resurrecting that row
+ *  verbatim spawned `daemon --workspace <child> --socket <parent sock>` — a
+ *  cross-wired daemon serving the child's index on the parent's socket, which
+ *  then blocked every legitimate restart of the parent (it held the bind) and
+ *  never matched the parent's config. Routing rows must never be spawned. */
+export function resurrectionPlan(reg) {
+    const bySock = new Map();
+    for (const [ws, sock] of Object.entries(reg)) {
+        const list = bySock.get(sock) ?? [];
+        list.push(ws);
+        bySock.set(sock, list);
+    }
+    const plan = [];
+    for (const [sock, roots] of bySock) {
+        const owner = roots.find((ws) => isOwnerEntry(ws, sock));
+        if (owner) {
+            plan.push({ ws: owner, sock });
+        }
+        else if (roots.length === 1 && !sock.endsWith(path.join(".vexp", "daemon.sock"))) {
+            // Long-path /tmp-fallback socket (lives OUTSIDE any repo): a single
+            // registrant is unambiguous, keep prior behavior. A canonical
+            // in-repo socket that is NOT under the registrant is a routing row
+            // whose owner vanished from the registry — never cross-spawn it.
+            plan.push({ ws: roots[0], sock });
+        }
+        else {
+            appendLog(`registry: no owner for socket ${sock} (roots: ${roots.join(", ")}) — skipping resurrect`);
+        }
+    }
+    return plan;
+}
 async function resurrectAll() {
     const reg = readRegistry();
     const live = {};
+    // Prune rows whose workspace vanished, but keep routing rows alive in the
+    // registry — they are data, not spawn instructions.
+    const pruned = {};
     for (const [ws, sock] of Object.entries(reg)) {
         const manifest = path.join(ws, ".vexp", "manifest.json");
         if (!fs.existsSync(manifest)) {
             appendLog(`registry prune: ${ws} (no manifest)`);
             continue;
         }
-        const ok = await resurrectDaemon(ws, sock);
-        if (ok)
+        pruned[ws] = sock;
+    }
+    const resurrected = new Map();
+    for (const { ws, sock } of resurrectionPlan(pruned)) {
+        resurrected.set(sock, await resurrectDaemon(ws, sock));
+    }
+    for (const [ws, sock] of Object.entries(pruned)) {
+        if (resurrected.get(sock))
             live[ws] = sock;
     }
     writeRegistry(live);