vexp-mcp 2.0.24 → 2.0.25

package/dist/daemon-client.js

@@ -51,7 +51,7 @@ export class DaemonClient {
         this.lastSpawnAttemptMs = now;
         if (process.env.VEXP_NO_AUTOSTART === "1")
             return;
-        const workspaceRoot = this.spawnWorkspaceRoot ?? process.env.VEXP_WORKSPACE ?? discoverWorkspaceRoot();
+        const workspaceRoot = resolveWorkspaceRoot(this.spawnWorkspaceRoot);
         if (!fs.existsSync(path.join(workspaceRoot, ".vexp", "manifest.json")))
             return;
         const binary = resolveVexpCoreBinary();
@@ -84,7 +84,7 @@ export class DaemonClient {
     }
     /** Tail of the daemon log files, for actionable connection errors. */
     daemonLogTail(maxLines = 12) {
-        const workspaceRoot = this.spawnWorkspaceRoot ?? process.env.VEXP_WORKSPACE ?? discoverWorkspaceRoot();
+        const workspaceRoot = resolveWorkspaceRoot(this.spawnWorkspaceRoot);
         for (const name of ["daemon.log", "vexp.log"]) {
             try {
                 const p = path.join(workspaceRoot, ".vexp", name);
@@ -383,16 +383,31 @@ export function fnvHash(input) {
  */
 function discoverWorkspaceRoot() {
     const cwd = process.cwd();
+    // Pass 1: nearest ancestor with an INITIALIZED .vexp/ (manifest.json or
+    // index.db) — a real indexed workspace, not a stray/empty .vexp/ dir.
+    // MUST stay in lockstep with vexp-core/src/utils.rs::discover_workspace_root.
     let current = cwd;
     while (true) {
-        const vexpDir = path.join(current, ".vexp");
-        if (fs.existsSync(vexpDir))
+        const vexp = path.join(current, ".vexp");
+        if (fs.existsSync(path.join(vexp, "manifest.json")) || fs.existsSync(path.join(vexp, "index.db"))) {
             return current;
+        }
         const parent = path.dirname(current);
         if (parent === current)
             break;
         current = parent;
     }
+    // Pass 2: nearest ancestor with a bare .vexp/ (workspace mid-first-index).
+    current = cwd;
+    while (true) {
+        if (fs.existsSync(path.join(current, ".vexp")))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    // Pass 3: .git/ fallback.
     current = cwd;
     while (true) {
         const gitDir = path.join(current, ".git");
@@ -405,6 +420,25 @@ function discoverWorkspaceRoot() {
     }
     return cwd;
 }
+/**
+ * Resolve the workspace root for daemon spawn / socket targeting.
+ *
+ * Precedence:
+ *   1. `explicit` — an HTTP per-workspace client's pinned root
+ *   2. `VEXP_WORKSPACE` env — VS Code / hand-config pin
+ *   3. `CLAUDE_PROJECT_DIR` env — Claude Code ALWAYS sets this to the launching
+ *      session's project root. This is the reliable per-session signal that lets
+ *      parallel Claude Code sessions each target their OWN project even though the
+ *      user-scope ~/.claude.json MCP entry is shared (and intentionally no longer
+ *      pins VEXP_WORKSPACE — see agent-config.ts:configureClaudeCodeGlobal).
+ *   4. cwd walk-up ({@link discoverWorkspaceRoot})
+ */
+export function resolveWorkspaceRoot(explicit) {
+    return (explicit ??
+        process.env["VEXP_WORKSPACE"] ??
+        process.env["CLAUDE_PROJECT_DIR"] ??
+        discoverWorkspaceRoot());
+}
 /**
  * Read `~/.vexp/daemons.json` and pick the best entry for the given workspace.
  *
@@ -419,8 +453,14 @@ function discoverWorkspaceRoot() {
  *   1. Exact workspace match
  *   2. Longest workspace that is a prefix of `workspaceHint` (handles
  *      submodule / nested-directory cwd pointing at a parent daemon)
- *   3. If registry has exactly one entry, use it
- *   4. Otherwise `null` (caller should error clearly)
+ *   3. Otherwise `null` (caller surfaces a clear "no daemon for this workspace"
+ *      error and/or respawns the right one).
+ *
+ * Deliberately NO "if exactly one entry, use it" fallback: in a multi-repo /
+ * multi-agent setup that silently routes a child meant for repo-A to the only
+ * other registered daemon (repo-B) → the "Repos indexed: 1 / wrong-repo" drift.
+ * A non-match returns null so resolution falls back to the workspace-local socket
+ * / spawn path, never to an unrelated repo.
  */
 function pickFromDaemonRegistry(workspaceHint) {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
@@ -469,53 +509,74 @@ function pickFromDaemonRegistry(workspaceHint) {
     }
     if (bestSock)
         return bestSock;
-    if (entries.length === 1)
-        return entries[0][1];
     return null;
 }
 /**
- * Resolve the daemon socket path / named pipe, cross-platform, using:
- *   1. `VEXP_SOCKET` env — explicit override (highest precedence)
- *   2. Workspace-local socket if it exists (`<workspaceRoot>/.vexp/daemon.sock`)
- *   3. Global daemon registry `~/.vexp/daemons.json` (written by the Rust
- *      daemon at startup on all platforms)
- *   4. Platform-specific fallback (Windows hash pipe, otherwise `null` →
- *      caller surfaces a clear "no daemon" error)
+ * Resolve the daemon socket/pipe AND record which signal decided the target.
+ * Single source of truth for `resolveDaemonSocket()` (which discards the
+ * metadata) and the targeting diagnostics.
  *
- * Does NOT fall back to `~/.vexp/daemon.sock` — the daemon never writes
- * there; that path is a dead-end that masks the real error.
+ * Precedence (matches {@link resolveWorkspaceRoot} + the socket lookup that
+ * `resolveDaemonSocket` historically used — `.socket` is byte-for-byte unchanged):
+ *   1. `VEXP_SOCKET` env — explicit socket override (highest precedence)
+ *   2. workspace root (VEXP_WORKSPACE > CLAUDE_PROJECT_DIR > cwd walk-up), then:
+ *      a. workspace-local socket/pipe (`<root>/.vexp/daemon.{sock,pipe}`)
+ *      b. global daemon registry `~/.vexp/daemons.json`
+ *      c. Windows hash-pipe fallback, otherwise `null`
+ *
+ * Does NOT fall back to `~/.vexp/daemon.sock` — the daemon never writes there.
  */
-export function resolveDaemonSocket() {
+export function resolveTargeting() {
+    // Which signal gives us the workspace root? (Reported even when VEXP_SOCKET
+    // overrides the socket, so the diagnostics still show the intended project.)
+    let source;
+    let workspaceRoot;
+    if (process.env["VEXP_WORKSPACE"]) {
+        workspaceRoot = process.env["VEXP_WORKSPACE"];
+        source = "VEXP_WORKSPACE";
+    }
+    else if (process.env["CLAUDE_PROJECT_DIR"]) {
+        workspaceRoot = process.env["CLAUDE_PROJECT_DIR"];
+        source = "CLAUDE_PROJECT_DIR";
+    }
+    else {
+        workspaceRoot = discoverWorkspaceRoot();
+        source = "cwd-discovery";
+    }
     const explicit = process.env["VEXP_SOCKET"];
-    if (explicit)
-        return explicit;
-    const workspaceRoot = process.env["VEXP_WORKSPACE"] ?? discoverWorkspaceRoot();
+    if (explicit) {
+        return { socket: explicit, source, socketOrigin: "explicit", workspaceRoot };
+    }
     if (process.platform === "win32") {
         // Workspace-specific pipe name file written by the daemon
         const pipeFile = path.join(workspaceRoot, ".vexp", "daemon.pipe");
         try {
             const pipeName = fs.readFileSync(pipeFile, "utf-8").trim();
             if (pipeName)
-                return pipeName;
+                return { socket: pipeName, source, socketOrigin: "workspace-local", workspaceRoot };
         }
         catch { /* missing */ }
         // Registry
         const fromRegistry = pickFromDaemonRegistry(workspaceRoot);
         if (fromRegistry)
-            return fromRegistry;
+            return { socket: fromRegistry, source, socketOrigin: "registry", workspaceRoot };
         // Hash-based last-ditch (daemon should always register, so this is rare)
         const hash = fnvHash(workspaceRoot.toLowerCase());
-        return `\\\\.\\pipe\\vexp-${hash.slice(0, 8)}`;
+        return { socket: `\\\\.\\pipe\\vexp-${hash.slice(0, 8)}`, source, socketOrigin: "hash-fallback", workspaceRoot };
     }
     // Unix: prefer workspace-local if the socket file actually exists
     const cwdSocket = path.join(workspaceRoot, ".vexp", "daemon.sock");
     if (fs.existsSync(cwdSocket))
-        return cwdSocket;
-    // Registry (Linux + macOS) — the piece that was missing
+        return { socket: cwdSocket, source, socketOrigin: "workspace-local", workspaceRoot };
+    // Registry (Linux + macOS)
     const fromRegistry = pickFromDaemonRegistry(workspaceRoot);
     if (fromRegistry)
-        return fromRegistry;
-    return null;
+        return { socket: fromRegistry, source, socketOrigin: "registry", workspaceRoot };
+    return { socket: null, source, socketOrigin: "none", workspaceRoot };
+}
+/** Resolve the daemon socket path / named pipe (metadata discarded). */
+export function resolveDaemonSocket() {
+    return resolveTargeting().socket;
 }
 /** Back-compat wrapper: some callers expect a string (old behavior).
  *  Returns the resolved path or the nominal workspace path so the caller's
@@ -524,7 +585,7 @@ function getDefaultSocketPath() {
     const resolved = resolveDaemonSocket();
     if (resolved)
         return resolved;
-    const workspaceRoot = process.env["VEXP_WORKSPACE"] ?? discoverWorkspaceRoot();
+    const workspaceRoot = resolveWorkspaceRoot();
     return path.join(workspaceRoot, ".vexp", "daemon.sock");
 }
 export { discoverWorkspaceRoot };
@@ -602,7 +663,7 @@ function socketPathForWorkspace(ws) {
 /** Human-friendly hint printed when a connection attempt fails — enumerates
  *  what we tried to make the failure actionable instead of misleading. */
 function daemonRunHint() {
-    const workspaceRoot = process.env["VEXP_WORKSPACE"] ?? discoverWorkspaceRoot();
+    const workspaceRoot = resolveWorkspaceRoot();
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
     const candidates = [];
     if (process.env["VEXP_SOCKET"])

package/dist/tools/index-status.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { resolveTargeting } from "../daemon-client.js";
 export const IndexStatusSchema = z.object({});
 export const INDEX_STATUS_DEFINITION = {
     name: "index_status",
@@ -13,10 +14,18 @@ export const INDEX_STATUS_DEFINITION = {
 };
 export async function handleIndexStatus(params, daemon) {
     IndexStatusSchema.parse(params);
+    // Client-side: how THIS MCP process resolved its target (before talking to any
+    // daemon). Compared against the daemon's self-report below to surface mis-targets.
+    const targeting = resolveTargeting();
     const result = await daemon.call("index_status", {});
-    return formatStatusAsText(result);
+    return formatStatusAsText(result, targeting);
 }
-function formatStatusAsText(status) {
+/** Normalize a workspace path for a tolerant equality check (case-insensitive,
+ *  trailing separators stripped) — just for the mismatch heuristic. */
+function normRoot(p) {
+    return p.replace(/[\\/]+$/, "").toLowerCase();
+}
+function formatStatusAsText(status, targeting) {
     const lines = [];
     const statusEmoji = {
         healthy: "✓",
@@ -27,6 +36,32 @@ function formatStatusAsText(status) {
     lines.push(`# vexp Index Status`);
     lines.push(`> ${statusEmoji} ${status.status.toUpperCase()} | v${status.daemon_version} | uptime ${formatUptime(status.daemon_uptime_s)}`);
     lines.push("");
+    // Targeting — which workspace THIS MCP process resolved to (client) vs which
+    // workspace the daemon it reached actually serves (daemon). A mismatch means this
+    // session is talking to the wrong project's daemon (the parallel-session bug).
+    if (targeting || status.workspace_root) {
+        const clientRoot = targeting?.workspaceRoot;
+        const daemonRoot = status.workspace_root;
+        lines.push("## Targeting");
+        if (targeting) {
+            lines.push(`- This MCP resolved to: \`${clientRoot}\` (via ${targeting.source})`);
+            if (targeting.socket)
+                lines.push(`- Socket/pipe: \`${targeting.socket}\` (${targeting.socketOrigin})`);
+        }
+        if (daemonRoot) {
+            const repos = status.served_aliases?.length ? ` — repos: ${status.served_aliases.join(", ")}` : "";
+            lines.push(`- Daemon serving: \`${daemonRoot}\`${repos}`);
+        }
+        if (clientRoot && daemonRoot && normRoot(clientRoot) !== normRoot(daemonRoot)) {
+            lines.push(`- ⚠️ MISMATCH: this session resolved a different workspace than the daemon it reached. ` +
+                `Likely a parallel-session mis-target — set VEXP_WORKSPACE for this session, or launch \`claude\` from \`${clientRoot}\`.`);
+        }
+        const others = status.other_daemons ?? [];
+        lines.push(others.length > 0
+            ? `- Other live daemons: ${others.map((d) => `\`${d.root}\``).join(", ")}`
+            : `- Other live daemons: none`);
+        lines.push("");
+    }
     if (status.status === "error" && status.error) {
         lines.push(`**Error:** ${status.error}`);
         lines.push("");

package/dist/tools/run-pipeline.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { resolveTargeting } from "../daemon-client.js";
 import { coerceArray, coerceBool, coerceNumber } from "./coerce.js";
 export const RunPipelineSchema = z.object({
     task: z.string().describe("Description of your task"),
@@ -133,8 +134,13 @@ export const RUN_PIPELINE_DEFINITION = {
 };
 export async function handleRunPipeline(params, daemon) {
     const validated = RunPipelineSchema.parse(params);
+    // One-line target banner so the user can SEE which workspace this session
+    // resolved to (the parallel-session mis-target is otherwise invisible). Computed
+    // client-side from env/cwd — no extra daemon round-trip.
+    const targeting = resolveTargeting();
     const result = (await daemon.call("run_pipeline", validated));
-    // The Rust engine already produces formatted text output.
-    // We return it directly — no additional formatting needed.
-    return result.output;
+    const scoped = validated.repos?.length ? `, repos: ${validated.repos.join(", ")}` : "";
+    const banner = `> vexp target: ${targeting.workspaceRoot} (via ${targeting.source}${scoped})`;
+    // The Rust engine already produces formatted text output; we only prepend the banner.
+    return `${banner}\n${result.output}`;
 }

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "vexp-mcp",
-  "version": "2.0.24",
+  "version": "2.0.25",
   "description": "vexp MCP server — AI context tools for coding agents",
   "type": "module",
   "main": "dist/index.js",
   "scripts": {
     "build": "tsc",
     "dev": "tsx src/index.ts",
-    "test": "node --experimental-vm-modules node_modules/.bin/jest",
+    "test": "node --import tsx --test test/*.test.ts",
     "clean": "rm -rf dist",
     "clean:artifacts": "node -e \"const fs=require('fs'),p=require('path');function w(d){if(!fs.existsSync(d))return;for(const e of fs.readdirSync(d,{withFileTypes:true})){const f=p.join(d,e.name);if(e.isDirectory())w(f);else if(/\\.(map|d\\.ts|d\\.ts\\.map)$/.test(e.name))fs.unlinkSync(f);}}w('dist');\"",
     "prepublishOnly": "npm run build && npm run clean:artifacts"
@@ -30,9 +30,6 @@
     "@types/node": "^20.11.0",
     "@types/uuid": "^9.0.7",
     "typescript": "^5.4.0",
-    "tsx": "^4.7.0",
-    "jest": "^29.7.0",
-    "@jest/globals": "^29.7.0",
-    "ts-jest": "^29.1.2"
+    "tsx": "^4.7.0"
   }
 }