vexp-cli 2.2.4 → 2.3.1

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

@@ -2,6 +2,7 @@ import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 import * as net from "net";
+import { spawnSync } from "child_process";
 import chalk from "chalk";
 import { socketPathFor } from "./socket-path.js";
 // `vexp doctor` — audit the vexp MCP/daemon state WITHOUT connecting to a daemon.
@@ -48,6 +49,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 +138,39 @@ 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) {
+                // Embedded caveat: a stdio MCP server (`vexp-core mcp`) spawned while
+                // the daemon was unreachable serves from its own in-process index and
+                // never attaches to the daemon later — its calls are real but
+                // invisible to these counters. Don't tell that user "the agent is not
+                // using vexp"; tell them how to converge on the daemon.
+                line(WARN, `no agent session has called vexp through this daemon since it started — either no agent is using vexp here (check its MCP config), or the agent's vexp MCP server started BEFORE the daemon and is running embedded (in-process). If calls do succeed in the agent, restart the agent (with the daemon already up) so its MCP server attaches to the daemon.`);
+            }
+            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");
@@ -166,32 +226,44 @@ export async function runDoctor() {
             line(OK, `${name}: valid, ~${days}d remaining`);
         }
     }
-    // 4) Codex MCP transport stanza.
-    console.log(chalk.bold("\nCodex (~/.codex/config.toml)"));
-    const codexPath = path.join(os.homedir(), ".codex", "config.toml");
-    if (!fs.existsSync(codexPath)) {
-        line(OK, "no ~/.codex/config.toml (Codex not configured)");
-    }
-    else {
-        const toml = fs.readFileSync(codexPath, "utf-8");
+    // 4) Codex MCP transport stanza — global AND project-level. Codex supports
+    // per-project `.codex/config.toml`; checking only the global file made
+    // doctor report "[OK] no stanza" to users whose (working) config lives in
+    // the workspace.
+    console.log(chalk.bold("\nCodex (config.toml)"));
+    const codexConfigs = [
+        { label: "~/.codex/config.toml", file: path.join(os.homedir(), ".codex", "config.toml") },
+        { label: `${ws.root}/.codex/config.toml (project)`, file: path.join(ws.root, ".codex", "config.toml") },
+    ];
+    let codexStanzaSeen = false;
+    for (const { label, file } of codexConfigs) {
+        if (!fs.existsSync(file)) {
+            line(OK, `${label}: absent`);
+            continue;
+        }
+        const toml = fs.readFileSync(file, "utf-8");
         const m = toml.match(/\n?\[mcp_servers\.vexp\][\s\S]*?(?=\n\[[A-Za-z_]|$)/);
         const section = m ? m[0] : "";
-        if (!section)
-            line(OK, "no [mcp_servers.vexp] stanza");
-        else {
-            const hasUrl = /^\s*url\s*=/m.test(section);
-            const hasCmd = /^\s*command\s*=/m.test(section);
-            if (hasUrl && hasCmd)
-                line(BAD, "stanza has BOTH 'url' and 'command' → 'url is not supported for stdio'. Re-run setup to rewrite cleanly.");
-            else if (hasUrl)
-                line(OK, "transport: http (url)");
-            else if (hasCmd) {
-                const wsm = section.match(/VEXP_WORKSPACE\s*=\s*['"]([^'"]+)['"]/);
-                line(OK, `transport: stdio (command)${wsm ? `, VEXP_WORKSPACE=${wsm[1]}` : ""}`);
-            }
-            else
-                line(WARN, "stanza present but neither url nor command found");
+        if (!section) {
+            line(OK, `${label}: no [mcp_servers.vexp] stanza`);
+            continue;
         }
+        codexStanzaSeen = true;
+        const hasUrl = /^\s*url\s*=/m.test(section);
+        const hasCmd = /^\s*command\s*=/m.test(section);
+        if (hasUrl && hasCmd)
+            line(BAD, `${label}: stanza has BOTH 'url' and 'command' → 'url is not supported for stdio'. Re-run setup to rewrite cleanly.`);
+        else if (hasUrl)
+            line(OK, `${label}: transport http (url)`);
+        else if (hasCmd) {
+            const wsm = section.match(/VEXP_WORKSPACE\s*=\s*['"]([^'"]+)['"]/);
+            line(OK, `${label}: transport stdio (command)${wsm ? `, VEXP_WORKSPACE=${wsm[1]}` : ""}`);
+        }
+        else
+            line(WARN, `${label}: stanza present but neither url nor command found`);
+    }
+    if (!codexStanzaSeen) {
+        console.log(chalk.dim("        → no vexp stanza in either file (Codex not configured for vexp)"));
     }
     // 5) Claude Code entry (should be UNPINNED after the multi-session fix).
     console.log(chalk.bold("\nClaude Code (~/.claude.json)"));
@@ -209,6 +281,144 @@ export async function runDoctor() {
     catch {
         line(OK, "no ~/.claude.json");
     }
+    // 5b) Claude Code guard hook — EXECUTE it the way Claude Code would, don't
+    // just check presence. A shell-form command that word-splits on a project
+    // path containing a space fails non-blocking on every call: the guard never
+    // denies anything while the config "looks correct" and presence-only checks
+    // report healthy (Nathan, 2026-07).
+    console.log(chalk.bold("\nClaude Code guard hook (.claude/settings.json)"));
+    {
+        const sPath = path.join(ws.root, ".claude", "settings.json");
+        let guardHooks = [];
+        let settingsReadable = false;
+        try {
+            const settings = JSON.parse(fs.readFileSync(sPath, "utf-8"));
+            settingsReadable = true;
+            const pre = Array.isArray(settings?.hooks?.PreToolUse) ? settings.hooks.PreToolUse : [];
+            for (const m of pre) {
+                const hks = Array.isArray(m?.hooks) ? m.hooks : [];
+                for (const h of hks) {
+                    if (typeof h?.command === "string" && h.command.includes("vexp-guard"))
+                        guardHooks.push(h);
+                }
+            }
+        }
+        catch { /* absent or unparseable */ }
+        if (!settingsReadable) {
+            line(OK, "no .claude/settings.json (guard not installed)");
+        }
+        else if (guardHooks.length === 0) {
+            line(OK, "no vexp guard configured (2.3 default — enable with 'vexp setup --guard-strict')");
+        }
+        else if (process.platform === "win32") {
+            line(OK, `guard configured (${guardHooks.length} entry) — live execution check skipped on Windows`);
+        }
+        else {
+            for (const h of guardHooks) {
+                const cmd = h.command;
+                const execForm = Array.isArray(h.args);
+                const timeoutS = typeof h.timeout === "number" ? h.timeout : 600;
+                if (!execForm && /\$\{?CLAUDE_PROJECT_DIR\}?\//.test(cmd) && !cmd.includes('"')) {
+                    line(ws.root.includes(" ") ? BAD : WARN, `shell-form hook command ('args' missing) — unquoted $CLAUDE_PROJECT_DIR word-splits on paths with spaces${ws.root.includes(" ") ? ` and THIS project path has one: the guard never runs` : ""}. Re-run 'vexp setup --guard-strict' to rewrite in exec form.`);
+                }
+                if (timeoutS > 600) {
+                    line(WARN, `hook timeout ${timeoutS} is in SECONDS (${Math.round(timeoutS / 60)} minutes) — likely meant milliseconds. Re-run 'vexp setup --guard-strict' to fix.`);
+                }
+                // Run it exactly as Claude Code would: exec form = direct spawn with
+                // the placeholder substituted by the host; shell form = sh -c with
+                // CLAUDE_PROJECT_DIR in the environment.
+                const substituted = cmd.replace(/\$\{CLAUDE_PROJECT_DIR\}/g, ws.root);
+                const r = execForm
+                    ? spawnSync(substituted, h.args.map((a) => String(a).replace(/\$\{CLAUDE_PROJECT_DIR\}/g, ws.root)), {
+                        env: { ...process.env, CLAUDE_PROJECT_DIR: ws.root },
+                        timeout: 5000,
+                        encoding: "utf-8",
+                    })
+                    : spawnSync("sh", ["-c", cmd], {
+                        env: { ...process.env, CLAUDE_PROJECT_DIR: ws.root },
+                        timeout: 5000,
+                        encoding: "utf-8",
+                    });
+                if (r.error) {
+                    line(BAD, `guard hook DID NOT RUN: ${r.error.code ?? r.error.message} spawning '${substituted}' — the guard is enforcing nothing. Re-run 'vexp setup --guard-strict'.`);
+                }
+                else if (r.status !== 0) {
+                    line(BAD, `guard hook exited ${r.status}${r.stderr ? ` — ${String(r.stderr).trim().slice(0, 200)}` : ""} — Claude Code treats this as a non-blocking failure, so searches proceed unguarded.`);
+                }
+                else {
+                    const decision = /"permissionDecision"\s*:\s*"(\w+)"/.exec(String(r.stdout ?? ""))?.[1];
+                    if (decision)
+                        line(OK, `guard hook runs (live decision here: ${decision})`);
+                    else
+                        line(WARN, `guard hook ran (exit 0) but produced no permissionDecision output — check ${path.join(".claude", "hooks", "vexp-guard.sh")}`);
+                }
+            }
+        }
+    }
+    // 5c) Cursor guard hook — same live-execution philosophy as 5b. Cursor's
+    // hooks fail OPEN too (`failClosed` defaults to false), so a guard that
+    // cannot spawn silently enforces nothing there as well. The guard's stdin
+    // protocol: JSON {tool_name, tool_input, workspace_roots, cwd}; a healthy
+    // run answers {"permission":"allow"} with exit 0 OR a deny verdict with
+    // exit 2 — BOTH mean "the hook works", anything else is a failure.
+    console.log(chalk.bold("\nCursor guard hook (.cursor/hooks.json)"));
+    {
+        const cursorCfgPath = path.join(ws.root, ".cursor", "hooks.json");
+        let cursorCmds = [];
+        let cursorReadable = false;
+        try {
+            const cfg = JSON.parse(fs.readFileSync(cursorCfgPath, "utf-8"));
+            cursorReadable = true;
+            const pre = Array.isArray(cfg?.hooks?.preToolUse) ? cfg.hooks.preToolUse : [];
+            for (const h of pre) {
+                if (typeof h?.command === "string" && h.command.includes("vexp-guard"))
+                    cursorCmds.push(h.command);
+            }
+        }
+        catch { /* absent or unparseable */ }
+        if (!cursorReadable) {
+            line(OK, "no .cursor/hooks.json (guard not installed)");
+        }
+        else if (cursorCmds.length === 0) {
+            line(OK, "no vexp guard configured (enable with 'vexp setup --guard-strict')");
+        }
+        else if (process.platform === "win32") {
+            line(OK, `guard configured (${cursorCmds.length} entry) — live execution check skipped on Windows`);
+        }
+        else {
+            // A benign Grep probe: with a healthy daemon the guard denies (exit 2),
+            // without one it allows (exit 0) — either proves the hook executes.
+            const probe = JSON.stringify({
+                tool_name: "Grep",
+                tool_input: {},
+                workspace_roots: [ws.root],
+                cwd: ws.root,
+            });
+            for (const cmd of cursorCmds) {
+                // Cursor runs project hooks from the project root; emulate that.
+                const r = spawnSync("sh", ["-c", cmd], {
+                    cwd: ws.root,
+                    input: probe,
+                    timeout: 5000,
+                    encoding: "utf-8",
+                });
+                if (r.error) {
+                    line(BAD, `guard hook DID NOT RUN: ${r.error.code ?? r.error.message} spawning '${cmd}' — Cursor hooks fail open, so the guard is enforcing nothing. Re-run 'vexp setup --guard-strict'.`);
+                    continue;
+                }
+                const decision = /"permission"\s*:\s*"(\w+)"/.exec(String(r.stdout ?? ""))?.[1];
+                if ((r.status === 0 || r.status === 2) && decision) {
+                    line(OK, `guard hook runs (live decision here: ${decision})`);
+                }
+                else if (r.status !== 0 && r.status !== 2) {
+                    line(BAD, `guard hook exited ${r.status}${r.stderr ? ` — ${String(r.stderr).trim().slice(0, 200)}` : ""} — Cursor treats hook failures as allow, so searches proceed unguarded.`);
+                }
+                else {
+                    line(WARN, `guard hook ran (exit ${r.status}) but produced no permission verdict — check ${path.join(".cursor", "hooks", "vexp-guard.js")}`);
+                }
+            }
+        }
+    }
     // 6) HTTP MCP supervisor.
     console.log(chalk.bold("\nHTTP MCP supervisor (~/.vexp/mcp.pid)"));
     try {

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);