vexp-cli 3.3.2 → 3.3.4

package/dist/agent-config.js

@@ -130,6 +130,25 @@ function codexHomeArtefacts() {
     const codexHome = process.env.CODEX_HOME ? path.resolve(process.env.CODEX_HOME) : path.join(os.homedir(), ".codex");
     return ["auth.json", "sessions", "session_index.jsonl", "history.jsonl", "installation_id", "version.json"].map((f) => path.join(codexHome, f));
 }
+/**
+ * Does this machine show Windsurf (Devin Desktop since 2026-06-02)? What the
+ * tool itself keeps in its folder under ~/.codeium, for either channel:
+ * anything there beside mcp_config.json and the backups of it. That one file
+ * proves nothing: vexp writes it, and until 3.3.3 created it with its folder
+ * on machines that never had the tool. Lockstep with the extension, which
+ * can also ask the editor it runs in; a terminal has no editor to ask, and
+ * `--agents Windsurf` is there for that case.
+ */
+function windsurfOnThisMachine() {
+    return ["windsurf", "windsurf-next"].some((channel) => {
+        try {
+            return fs.readdirSync(path.join(os.homedir(), ".codeium", channel)).some((e) => !e.startsWith("mcp_config.json"));
+        }
+        catch {
+            return false;
+        }
+    });
+}
 const AGENT_DETECTORS = [
     {
         agent: "Claude Code",
@@ -155,10 +174,21 @@ const AGENT_DETECTORS = [
     },
     {
         agent: "Windsurf",
-        detectPath: ".windsurf",
-        // Windsurf became Devin Desktop (2026-06-02); a project set up for the new
-        // agent carries `.devin/` instead of `.windsurf/`.
-        detectPaths: [".devin"],
+        // What Cascade itself reads: its rules folder, the legacy root file, and
+        // the rules of Devin Desktop (Windsurf's name since 2026-06-02). The
+        // `.windsurf` and `.devin` folders alone are a hint: repositories ship
+        // them for the teammates who use the tool, and on a checkout of one a
+        // setup wrote the rule, .devin/mcp_config.json and a machine-wide
+        // ~/.codeium/windsurf/mcp_config.json on a machine with no Windsurf
+        // (field report, 2026-10-08). The rules prove the project, not the
+        // person: they set Windsurf up without a question only where the machine
+        // shows Windsurf as well. Lockstep with the extension, which changed
+        // first: for a day the two planners disagreed, and `vexp setup` wrote
+        // what the extension had learnt to ask about (review, 2026-10-08).
+        detectPath: ".windsurf/rules",
+        detectPaths: [".windsurfrules", ".devin/rules"],
+        detectHints: [".windsurf", ".devin"],
+        onThisMachine: windsurfOnThisMachine,
         configFile: ".windsurf/rules/vexp.md",
         templateName: "windsurf",
         // MCP is NOT project-level here: Cascade reads only the machine-global
@@ -193,7 +223,16 @@ const AGENT_DETECTORS = [
     },
     {
         agent: "GitHub Copilot",
-        detectPath: ".github",
+        // What Copilot itself reads: the repository instructions (with text of
+        // the user's in them: the file is also the one vexp writes), the
+        // path-specific instructions and the prompt files. `.github` alone is a
+        // hint: most repositories have it for their CI workflows, and even an
+        // empty one got copilot-instructions.md and .vscode/mcp.json written
+        // unasked (same field report as Windsurf above). Lockstep with the
+        // extension.
+        detectPath: ".github/copilot-instructions.md",
+        detectPaths: [".github/instructions", ".github/prompts"],
+        detectHints: [".github"],
         configFile: ".github/copilot-instructions.md",
         templateName: "copilot",
     },
@@ -310,9 +349,10 @@ const AGENT_DETECTORS = [
  * such a file proves only that vexp ran here: a `.clinerules` written because
  * Cline's VS Code storage exists "detected" Cline in that project at every
  * start after, the loop AGENTS.md closed for Codex through 3.2.5. It counts
- * only when someone put content of their own in it.
+ * only when someone put content of their own in it. Windsurf's rules folder
+ * is in the list for the same reason: vexp's own rule is a file in it.
  */
-const VEXP_WRITTEN_MARKERS = new Set(AGENT_DETECTORS.map((d) => d.configFile));
+const VEXP_WRITTEN_MARKERS = new Set([...AGENT_DETECTORS.map((d) => d.configFile), ".windsurf/rules"]);
 /** `text` without vexp's `<!-- vexp ... -->` … `<!-- /vexp -->` block (to
  *  the end of the file for the old unterminated format). */
 function withoutVexpSection(text) {
@@ -326,6 +366,22 @@ function withoutVexpSection(text) {
     const end = endIdx === -1 ? text.length : endIdx + VEXP_MARKER_END.length;
     return text.slice(0, start) + text.slice(end);
 }
+/**
+ * Is `rest`, what a file holds beside vexp's block, the front matter vexp
+ * itself puts above that block and nothing else? The Windsurf and Cursor
+ * rules open with it (it is what makes the rule always on), and its
+ * description line has been vexp's own since the first one written. Left
+ * alone it is not the user's text: counted as such, a
+ * `.windsurf/rules/vexp.md` that vexp wrote would prove Windsurf at every
+ * setup after.
+ */
+function isVexpFrontMatter(rest) {
+    const lines = rest.trim().split(/\r?\n/);
+    return (lines.length >= 2 &&
+        lines[0] === "---" &&
+        lines.indexOf("---", 1) === lines.length - 1 &&
+        lines.some((l) => l.startsWith("description: vexp ")));
+}
 /** Does a vexp-written marker hold anything of the user's? Unreadable counts
  *  as yes: when in doubt, detection behaves as it always did. */
 function hasOwnContent(p) {
@@ -348,7 +404,11 @@ function hasOwnContent(p) {
         return entries.some((e) => e !== "vexp.md" || hasOwnContent(path.join(p, e)));
     }
     try {
-        return withoutVexpSection(fs.readFileSync(p, "utf-8")).trim() !== "";
+        const text = fs.readFileSync(p, "utf-8");
+        const rest = withoutVexpSection(text);
+        if (rest !== text && isVexpFrontMatter(rest))
+            return false;
+        return rest.trim() !== "";
     }
     catch {
         return true;
@@ -362,21 +422,33 @@ function isDirectory(p) {
         return false;
     }
 }
-/** Where `d` is found for this workspace, if anywhere. */
-export function classifyAgent(d, workspaceRoot) {
-    const markers = [d.detectPath, ...(d.detectPaths ?? [])];
-    const inProject = markers.some((m) => {
+/** The marker of `d` this project holds, if any: something the agent itself reads. */
+function projectMarker(d, workspaceRoot) {
+    return [d.detectPath, ...(d.detectPaths ?? [])].find((m) => {
         const p = path.join(workspaceRoot, m);
         if (!fs.existsSync(p))
             return false;
         return !VEXP_WRITTEN_MARKERS.has(m) || hasOwnContent(p);
     });
-    if (inProject)
+}
+/**
+ * What in this project hints at `d` without showing that its user runs it:
+ * the agent's own files, which classifyAgent takes as a marker wherever the
+ * machine shows the agent, or a folder the agent shares with other things.
+ */
+function projectHint(d, workspaceRoot) {
+    return projectMarker(d, workspaceRoot) ?? (d.detectHints ?? []).find((h) => isDirectory(path.join(workspaceRoot, h)));
+}
+/** Where `d` is found for this workspace, if anywhere. */
+export function classifyAgent(d, workspaceRoot) {
+    if (projectMarker(d, workspaceRoot) && (!d.onThisMachine || d.onThisMachine()))
         return "project";
     if (d.detectHome && isDirectory(path.join(os.homedir(), d.detectHome)))
         return "machine";
     if (d.detectAbsPaths && d.detectAbsPaths().some((p) => fs.existsSync(p)))
         return "machine";
+    if (projectHint(d, workspaceRoot))
+        return "hint";
     return undefined;
 }
 /** Every agent found for this workspace, in detector order. */
@@ -392,13 +464,19 @@ export function classifyAgents(workspaceRoot) {
 /**
  * What a setup does without asking. Project markers and earlier "yes"
  * answers are configured as they always were; traces on the machine alone
- * (Codex's login, Antigravity's folder, Cline's storage, ~/.claude) wait for
- * the user. Nothing vexp wrote counts as an answer: a 3.2.5 user whose Codex
- * setup came from AGENTS.md is asked once, like everyone else.
+ * (Codex's login, Antigravity's folder, Cline's storage, ~/.claude) and a
+ * hint in the project (a bare `.github`, a `.windsurf` folder) wait for the
+ * user. Nothing vexp wrote counts as an answer: a 3.2.5 user whose Codex
+ * setup came from AGENTS.md is asked once, like everyone else, and so is a
+ * 3.3.3 user whose Copilot setup came from a `.github` folder.
  */
 export function planAgentSetup(workspaceRoot, consent = readAgentConsent()) {
     const plan = { configure: [], offer: [], declined: [], kinds: {} };
     const key = consentKey(workspaceRoot);
+    // The extension asks one question after another, and one left open keeps
+    // the rest from being seen: a tool the machine shows goes before one the
+    // project only hints at. The same order here, so the two plans compare.
+    const hinted = [];
     for (const d of AGENT_DETECTORS) {
         const kind = classifyAgent(d, workspaceRoot);
         if (kind)
@@ -406,9 +484,16 @@ export function planAgentSetup(workspaceRoot, consent = readAgentConsent()) {
         const decision = decisionForKey(consent, key, d.agent);
         if (kind === "project" || decision === "yes")
             plan.configure.push(d.agent);
+        else if (decision === "no" || decision === "never") {
+            if (kind)
+                plan.declined.push(d.agent);
+        }
         else if (kind === "machine")
-            (decision === "no" || decision === "never" ? plan.declined : plan.offer).push(d.agent);
+            plan.offer.push(d.agent);
+        else if (kind === "hint")
+            hinted.push(d.agent);
     }
+    plan.offer.push(...hinted);
     return plan;
 }
 /** The command that configures `agents` here and does nothing else: `vexp
@@ -429,7 +514,13 @@ export function setupAgentsCommand(agents, dir) {
 export function nonInteractiveAgentChoice(plan, dir) {
     const notes = [];
     if (plan.offer.length > 0) {
-        notes.push(`Found on this machine, not set up for this project: ${plan.offer.join(", ")}.`);
+        // A hint is in the project, not on the machine: each said as what it is.
+        const hinted = plan.offer.filter((a) => plan.kinds[a] === "hint");
+        const onMachine = plan.offer.filter((a) => plan.kinds[a] !== "hint");
+        if (onMachine.length > 0)
+            notes.push(`Found on this machine, not set up for this project: ${onMachine.join(", ")}.`);
+        if (hinted.length > 0)
+            notes.push(`Hinted at by this project's folders, which alone do not show it uses ${hinted.length === 1 ? "it" : "them"}: ${hinted.join(", ")}. Not set up.`);
         notes.push(`To set ${plan.offer.length === 1 ? "it" : "them"} up here: ${setupAgentsCommand(plan.offer, dir)}`);
     }
     if (plan.configure.length === 0) {
@@ -1252,7 +1343,7 @@ export function resolveNodeCommand() {
     if (execPath && (execBase === "node" || execBase === "node.exe")) {
         try {
             fs.accessSync(execPath, fs.constants.X_OK);
-            return execPath;
+            return stableNodeAlias(execPath, nodeCandidates(process.platform, os.homedir(), process.env));
         }
         catch { /* not executable */ }
     }
@@ -1265,6 +1356,44 @@ export function resolveNodeCommand() {
         return fromShell;
     return "node";
 }
+/**
+ * The spelling of this node that outlives an upgrade.
+ *
+ * Node reports `process.execPath` with every link followed, and a package
+ * manager keeps each build in a directory of its own: under Homebrew that is
+ * `<prefix>/Cellar/node/<build>/bin/node`, which the next `brew upgrade node`
+ * removes. An MCP entry written with it stops starting on that day, and
+ * nothing on our side says why (field report, 2026-10-10). The manager's own
+ * link to the same file is the one to write: `<prefix>/bin/node`, or
+ * `<prefix>/opt/<formula>/bin/node` for a formula not linked into bin. Any
+ * other candidate that resolves to the same file serves as well; with no
+ * such link, the path as it is.
+ *
+ * Lockstep with the extension, which carries the same function.
+ */
+export function stableNodeAlias(execPath, candidates, real = fs.realpathSync) {
+    let target;
+    try {
+        target = real(execPath);
+    }
+    catch {
+        return execPath;
+    }
+    const keg = /^(.*)[\\/]Cellar[\\/]([^\\/]+)[\\/][^\\/]+[\\/]bin[\\/]node$/.exec(target);
+    const links = keg
+        ? [path.join(keg[1], "bin", "node"), path.join(keg[1], "opt", keg[2], "bin", "node"), ...candidates]
+        : candidates;
+    for (const link of links) {
+        if (link === target)
+            continue;
+        try {
+            if (real(link) === target)
+                return link;
+        }
+        catch { /* no such link */ }
+    }
+    return execPath;
+}
 /**
  * Absolute locations a node binary is commonly installed at, newest version
  * manager entries first. A GUI-launched editor (Dock, Start menu) has the
@@ -1381,6 +1510,32 @@ export function isBareInterpreter(entry) {
         command = command.path;
     return typeof command === "string" && command.length > 0 && !/[\\/]/.test(command);
 }
+/**
+ * An entry whose interpreter is the path of ONE build of node, on a machine
+ * where a link that outlives the build exists. Every setup before
+ * `stableNodeAlias` wrote such an entry under Homebrew, and the path is
+ * still there on the day setup runs again, so `vexpEntryStillResolves`
+ * adopted it as already working and it stayed until the upgrade that
+ * removes it (field report, 2026-10-10: a Claude Code entry). No writer
+ * keeps one: the next `vexp setup` replaces it. An entry already written
+ * with the link, a bare `node` and a custom launcher are none of this.
+ */
+export function pinsOneNodeBuild(entry) {
+    const command = entryCommand(entry);
+    if (!command || !path.isAbsolute(command))
+        return false;
+    // A command that itself goes through a link is not a build's own path,
+    // whatever else points at the same file: the manager's second link
+    // (<prefix>/opt/node/bin/node beside <prefix>/bin/node), one the user made.
+    try {
+        if (fs.realpathSync(command) !== command)
+            return false;
+    }
+    catch {
+        return false;
+    }
+    return stableNodeAlias(command, nodeCandidates(process.platform, os.homedir(), process.env)) !== command;
+}
 /**
  * Adopt a foreign entry only when it resolves AND pins its interpreter. Used by
  * the GUI-editor writers (VS Code/Copilot, Cursor/Windsurf/Kiro/Trae, Zed),
@@ -1388,7 +1543,7 @@ export function isBareInterpreter(entry) {
  * (opencode, Claude Code) keep adopting a bare interpreter — it works there.
  */
 function adoptableEntry(entry) {
-    return vexpEntryStillResolves(entry) && !isBareInterpreter(entry) && !isEditorExecutable(entry);
+    return vexpEntryStillResolves(entry) && !isBareInterpreter(entry) && !isEditorExecutable(entry) && !pinsOneNodeBuild(entry);
 }
 /**
  * Is `recorded` strictly older than `mine`? Copy of the extension's
@@ -2610,8 +2765,9 @@ export function configureOpencodeMcp(workspaceRoot, binaryPath, mcpServerPath) {
     // A working entry is already here — either another vexp install, or the user's
     // own hand-written block (this bug made several people write one). Don't fight
     // it: only the install path may differ, and `envMatches` still gates on the
-    // VEXP_WORKSPACE pin so a moved project is repinned normally.
-    if (envMatches && prev?.["enabled"] === true && vexpEntryStillResolves(prev))
+    // VEXP_WORKSPACE pin so a moved project is repinned normally. An entry that
+    // names one build of node is not kept (pinsOneNodeBuild).
+    if (envMatches && prev?.["enabled"] === true && vexpEntryStillResolves(prev) && !pinsOneNodeBuild(prev))
         return null;
     mcp["vexp"] = { type: "local", command, env, enabled: true };
     cfg.mcp = mcp;
@@ -2651,8 +2807,9 @@ export function configureKiloMcp(workspaceRoot, binaryPath, mcpServerPath) {
     // Another vexp install already left a working entry here — don't fight it.
     // Kilo's shape is `command: ["node", "<script>"]`. Only the install path may
     // differ: `envMatches` still gates on the VEXP_WORKSPACE pin, and `enabled`
-    // must be true or the user turned it off deliberately.
-    if (envMatches && prev?.["enabled"] === true && vexpEntryStillResolves(prev))
+    // must be true or the user turned it off deliberately. An entry that names
+    // one build of node is not kept (pinsOneNodeBuild).
+    if (envMatches && prev?.["enabled"] === true && vexpEntryStillResolves(prev) && !pinsOneNodeBuild(prev))
         return null;
     mcp["vexp"] = { type: "local", command, env, enabled: true };
     cfg.mcp = mcp;
@@ -2765,7 +2922,12 @@ version) {
     // 3.2.5 machines still pointing at 3.2.4, 2026-09-24). Take over an older
     // one, keep a newer one, and keep anything we cannot version (the npm
     // CLI's own path, a custom launcher). Lockstep with the extension.
-    if (removed.length === 0 && prevEnv === undefined && vexpEntryStillResolves(existing)) {
+    //
+    // Nor is an entry kept whose node is one build's own path while a link
+    // that outlives the build exists: it resolves today and stops at the next
+    // `brew upgrade node`. The entry this was reported on is this one (field
+    // report, 2026-10-10; pinsOneNodeBuild).
+    if (removed.length === 0 && prevEnv === undefined && vexpEntryStillResolves(existing) && !pinsOneNodeBuild(existing)) {
         const theirs = vexpInstallVersion(existing);
         const ours = vexpInstallVersion({ command: desiredCommand, args: desiredArgs }) ?? version;
         if (!theirs || !ours || !isOlderVexpVersion(theirs, ours))

package/dist/autostart.js

@@ -2,7 +2,7 @@ import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 import { execFileSync, spawnSync } from "child_process";
-import { migrateClaudeCodeUnpin } from "./agent-config.js";
+import { migrateClaudeCodeUnpin, nodeCandidates, stableNodeAlias } from "./agent-config.js";
 const LABEL = "io.vexp.serve";
 const BEGIN_MARKER = "# vexp-autostart-begin";
 const END_MARKER = "# vexp-autostart-end";
@@ -14,15 +14,23 @@ function installMarkerPath() {
     return path.join(homedir(), ".vexp", INSTALL_MARKER_FILE);
 }
 /** Resolve the launcher the OS should execute. Prefers the `vexp` bin in
- *  PATH; falls back to node+dist/cli.cjs if invoked from a dev checkout. */
-function resolveLauncher() {
+ *  PATH; falls back to node+dist/cli.cjs if invoked from a dev checkout.
+ *
+ *  The node is not written as Node reports it. Under Homebrew that path
+ *  names one build (<prefix>/Cellar/node/<build>/bin/node), and a login item
+ *  written with it stops starting at the next `brew upgrade node`, the same
+ *  way an MCP entry did (field report, 2026-10-10; stableNodeAlias). */
+export function resolveLauncher(execPath = process.execPath, script = process.argv[1]) {
     if (process.env.VEXP_AUTOSTART_LAUNCHER) {
         const parts = process.env.VEXP_AUTOSTART_LAUNCHER.split(" ");
         return { bin: parts[0], args: [...parts.slice(1), "serve"] };
     }
     // `vexp` launches the commander CLI with argv-dispatch; argv[2] = "serve".
-    const hint = process.execPath && process.argv[1]
-        ? { bin: process.execPath, args: [process.argv[1], "serve"] }
+    const hint = execPath && script
+        ? {
+            bin: stableNodeAlias(execPath, nodeCandidates(process.platform, os.homedir(), process.env)),
+            args: [script, "serve"],
+        }
         : { bin: "vexp", args: ["serve"] };
     // On Windows, prefer the global shim when available so the user's PATH
     // can be used without baking in an absolute node path.

package/dist/cli.js

@@ -22,6 +22,8 @@ import { runDoctor } from "./doctor.js";
 import { socketPathFor } from "./socket-path.js";
 import { isStateHome } from "./state-home.js";
 import { forgetRegistryRows, removeIndexArtifacts } from "./forget.js";
+import { parseDaemonRows, daemonsToStop, engineSaid, daemonWasStopped, stopNotes, supervisorNoteDue, stopAllSummary } from "./stop-all.js";
+import { replaceOlderDaemon, parseEngineVersion, commandMayReplaceDaemon } from "./daemon-upgrade.js";
 import { mutableOutput, askSecretOn } from "./secret-prompt.js";
 import { isTraceEnabled } from "./trace.js";
 import { resolveParentWorkspace, listWorkspaceRepos, addRepoToWorkspace, } from "./workspace-repos.js";
@@ -110,7 +112,11 @@ program.hook("preAction", async (_thisCmd, actionCmd) => {
     }
     // Full bootstrap: daemon + MCP + autostart-if-needed. All three steps are
     // internally idempotent — no duplicate processes across invocations.
-    await ensureBootstrap(eff.root, binaryPath);
+    // A daemon that is up and older than this engine is replaced here, except
+    // before the commands commandMayReplaceDaemon names.
+    await ensureBootstrap(eff.root, binaryPath, {
+        replaceOlder: commandMayReplaceDaemon(actionCmd.name(), actionCmd.opts()),
+    });
 });
 // ────────────────────────────────────────────────────
 // Resolve the platform binary (no network — bundled via npm)
@@ -256,18 +262,60 @@ function isDaemonPidAlive(workspaceRoot) {
         return { alive: false };
     }
 }
+/** The version of the engine at `binaryPath`, from its own `--version`. */
+function engineVersionOf(binaryPath) {
+    const r = spawnSync(binaryPath, ["--version"], {
+        encoding: "utf-8",
+        env: binaryEnv(binaryPath),
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 2_500,
+        windowsHide: true,
+    });
+    return r.status === 0 ? parseEngineVersion(r.stdout ?? "") : undefined;
+}
 /**
  * Ensure the vexp-core daemon is running for the given workspace. Fast when
  * it's already up (single socket probe). Idempotent lato Rust (PID file
  * check + `kill -0`), so re-invoking when up is a no-op.
  *
- * Silent on success. On failure prints a one-liner pointing at the log.
+ * With `replaceOlder`, a daemon that is up and older than this engine is
+ * restarted (daemon-upgrade.ts has the rules). "Up" used to be the end of
+ * it: after `npm install -g vexp-cli@latest` the daemon of every project
+ * kept serving the build it had started with (field report, 2026-10-10).
+ * The probe is then the daemon's own `index_status`, one connection that
+ * says both that it is up and what it is; the version is held against
+ * CLI_VERSION first, so the engine is asked for its own only when the
+ * daemon is behind.
+ *
+ * Silent on success, but for one dim line when a daemon was replaced. On
+ * failure prints a one-liner pointing at the log.
  * Honors VEXP_NO_AUTOSTART=1 as opt-out.
  */
-async function ensureDaemonRunning(workspaceRoot, binaryPath) {
+async function ensureDaemonRunning(workspaceRoot, binaryPath, opts = {}) {
     if (process.env.VEXP_NO_AUTOSTART === "1")
         return;
-    if (await isSocketAlive(socketPathFor(workspaceRoot)))
+    const socketPath = socketPathFor(workspaceRoot);
+    if (opts.replaceOlder) {
+        const outcome = await replaceOlderDaemon({
+            workspace: workspaceRoot,
+            socket: socketPath,
+            launcherVersion: CLI_VERSION,
+            engineVersion: () => engineVersionOf(binaryPath),
+            restart: (dir) => runBinaryAsync(binaryPath, ["daemon-cmd", "restart"], { silent: true, cwd: dir }),
+            // Not said when it is not true: a daemon that answers afterwards
+            // and is still the older one was not replaced.
+            confirm: true,
+        });
+        if (outcome.replaced) {
+            console.error(chalk.dim(`vexp daemon of this workspace restarted: it was v${outcome.running}, this engine is v${outcome.engine}`));
+            return;
+        }
+        // It answered and stays as it is. Anything else (no answer, a restart
+        // that stopped it and could not start it) goes on to the probe below.
+        if (outcome.up)
+            return;
+    }
+    if (await isSocketAlive(socketPath))
         return;
     try {
         await runBinaryAsync(binaryPath, ["daemon-cmd", "start"], {
@@ -284,7 +332,9 @@ async function ensureDaemonRunning(workspaceRoot, binaryPath) {
  * Full lazy bootstrap for any `vexp` invocation. Each step is already
  * idempotent on its own — calling this from multiple places (preAction,
  * REPL, setup) can never spawn duplicates:
- *   - `ensureDaemonRunning`   → socket probe, skips spawn if alive
+ *   - `ensureDaemonRunning`   → socket probe, skips spawn if alive; with
+ *     `replaceOlder`, restarts a daemon older than this engine (at most once
+ *     in ten minutes per workspace)
  *   - `ensureMcpHttpServer`   → ~/.vexp/mcp.pid + port probe, no-op if live
  *
  * The point of this wrapper is to ensure users who upgraded via
@@ -300,10 +350,10 @@ async function ensureDaemonRunning(workspaceRoot, binaryPath) {
  *
  * Honors VEXP_NO_AUTOSTART=1 as a global bypass.
  */
-async function ensureBootstrap(workspaceRoot, binaryPath) {
+async function ensureBootstrap(workspaceRoot, binaryPath, opts = {}) {
     if (process.env.VEXP_NO_AUTOSTART === "1")
         return;
-    await ensureDaemonRunning(workspaceRoot, binaryPath);
+    await ensureDaemonRunning(workspaceRoot, binaryPath, opts);
     try {
         await ensureMcpHttpServer({ owner: "cli" });
     }
@@ -547,7 +597,7 @@ program
 });
 program
     .command("daemons")
-    .description("List every vexp daemon on this machine: which workspace holds each concurrent-workspace slot, version, index size, uptime")
+    .description("List every vexp daemon on this machine: which workspace holds each concurrent-workspace slot, version, process id, memory, index size, uptime")
     .option("--json", "Emit machine-readable JSON")
     .action(async (opts) => {
     const binaryPath = ensureBinary();
@@ -556,11 +606,83 @@ program
         args.push("--json");
     runBinary(binaryPath, args);
 });
+/**
+ * `vexp stop --all`: every live daemon on the machine, one after the other.
+ * The engine lists them and the engine stops each one, from its own
+ * workspace, exactly as `vexp stop <workspace>` does; one line per workspace
+ * with what it answered, then the count. Exits 1 when a daemon the listing
+ * saw could not be stopped.
+ */
+function stopAllDaemons(binaryPath) {
+    const listed = spawnSync(binaryPath, ["daemons", "--json"], {
+        encoding: "utf-8",
+        env: binaryEnv(binaryPath),
+        stdio: ["ignore", "pipe", "pipe"],
+        // The listing asks every registered socket for its status in turn.
+        timeout: 60_000,
+    });
+    const rows = listed.status === 0 ? parseDaemonRows(listed.stdout ?? "") : null;
+    if (!rows) {
+        const why = listed.error?.message ?? (engineSaid(listed.stderr, listed.stdout) || "its answer was not the listing");
+        console.error(chalk.red(`Could not list the daemons on this machine (vexp daemons --json): ${why}`));
+        process.exit(1);
+    }
+    const targets = daemonsToStop(rows);
+    if (targets.length === 0) {
+        console.log("No vexp daemon is running on this machine.");
+        return;
+    }
+    const results = [];
+    for (const target of targets) {
+        let said;
+        let stopped = false;
+        if (!fs.existsSync(target.workspace)) {
+            // daemon-cmd stop finds the daemon through the folder it runs in.
+            said = `not stopped: the folder is gone, and the stop works from it${target.pid !== undefined ? ` (pid ${target.pid})` : ""}`;
+        }
+        else {
+            const stop = spawnSync(binaryPath, ["daemon-cmd", "stop"], {
+                cwd: target.workspace,
+                encoding: "utf-8",
+                env: binaryEnv(binaryPath),
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            said = engineSaid(stop.stdout, stop.stderr) || (stop.error ? stop.error.message : "the engine said nothing");
+            stopped = daemonWasStopped(said, stop.status);
+        }
+        const result = { target, said, stopped };
+        results.push(result);
+        console.log(`  ${target.workspace}: ${said}`);
+        for (const note of stopNotes(result))
+            console.log(chalk.dim(`    ${note}`));
+    }
+    // Once, not per workspace: see the note `vexp stop <workspace>` prints.
+    if (supervisorNoteDue(results, (ws) => fs.existsSync(path.join(ws, ".vexp", "manifest.json")))) {
+        console.log(chalk.dim("  (a login supervisor restarts registered workspaces within a minute — to unregister one for good: vexp forget <workspace>)"));
+    }
+    const summary = stopAllSummary(results);
+    if (summary.ok) {
+        console.log(chalk.green(`✓ ${summary.line}`));
+    }
+    else {
+        console.log(chalk.yellow(`  ${summary.line}`));
+        process.exit(1);
+    }
+}
 program
     .command("stop [workspace]")
-    .description("Stop the vexp daemon of a workspace (default: current directory). Accepts any path shown by the concurrent-workspace cap message")
-    .action(async (workspace) => {
+    .description("Stop the vexp daemon of a workspace (default: current directory), or with --all every daemon on this machine. Accepts any path shown by the concurrent-workspace cap message")
+    .option("--all", "Stop every live vexp daemon on this machine, one after the other")
+    .action(async (workspace, opts) => {
+    if (opts.all && workspace !== undefined) {
+        console.error(`--all stops every daemon on this machine and takes no workspace: run 'vexp stop --all', or 'vexp stop "${workspace}"' for that one.`);
+        process.exit(1);
+    }
     const binaryPath = ensureBinary();
+    if (opts.all) {
+        stopAllDaemons(binaryPath);
+        return;
+    }
     const target = path.resolve(workspace ?? process.cwd());
     if (!fs.existsSync(target)) {
         console.error(`No such directory: ${target}`);
@@ -1604,7 +1726,8 @@ async function interactiveMode() {
             const binaryPath = getBinaryPath();
             // Effective root: in a connected secondary repo this boots the PARENT
             // daemon (which serves this repo too) instead of a conflicting child one.
-            await ensureBootstrap(eff.root, binaryPath);
+            // Opening the menu is a use of the CLI: an older daemon is replaced.
+            await ensureBootstrap(eff.root, binaryPath, { replaceOlder: true });
         }
         catch { /* banner will reflect actual state */ }
     }