vexp-cli 3.3.8 → 3.4.0

package/dist/doctor.js

@@ -6,8 +6,12 @@ import { execFileSync, spawnSync } from "child_process";
 import { fileURLToPath } from "url";
 import chalk from "chalk";
 import { fnvHash, socketPathFor, socketPathMargin } from "./socket-path.js";
-import { agentConsentPath, decisionFor, loadAgentConsentFile, readAgentConsent } from "./agent-consent.js";
-import { parseJsonc, isWsl, windsurfWslBridgeNote, windsurfGlobalMcpPath, getAgentList, isVexpZcodeHookEntry, setupAgentsCommand, zcodeUserConfigPath } from "./agent-config.js";
+import { agentConsentPath, decisionFor, inheritedAnswers, loadAgentConsentFile, readAgentConsent } from "./agent-consent.js";
+import { extensionStartsOnOpen, linkedWorktreeMain } from "./git-worktree.js";
+import { parseJsonc, isWsl, windsurfWslBridgeNote, windsurfGlobalMcpPath, getAgentList, isVexpZcodeHookEntry, setupAgentsCommand, zcodeUserConfigPath, isDeadAntigravityEntry, antigravityOnThisMachine, antigravityGlobalMcpPath, gitTrackedPath, vexpCleansAntigravityFile, holdsOnlyVexp, projectFileLink, zcodeMcpTarget, projectMcpJsonVexp, worktreeMcpJsonNote, gitIn, expandedPin, dotMcpJsonPin, vexpPinOf, sameFolderAsExtension, dotMcpJsonMiss, dotMcpJsonKeptLine, } from "./agent-config.js";
+// The pin and folder rules live with the writers, which apply the same .mcp.json
+// condition (M2); the doctor's tests and the extension's lockstep import them here.
+export { vexpPinOf, sameFolderAsExtension };
 import { resolveParentWorkspace, listWorkspaceRepos } from "./workspace-repos.js";
 import { CLI_VERSION } from "./version.js";
 import { formatCheckIn, registrationState } from "./license.js";
@@ -16,6 +20,7 @@ import { slowMountNotice } from "./slow-mount.js";
 import { cloudSyncNotice } from "./cloud-sync.js";
 import { vexpHome, isStateHome } from "./state-home.js";
 import { canonicalWorkspaceRoot } from "./socket-path.js";
+import { devmindOff, devmindOffNote, isEndpointUnreachable, llmStatusReportLines } from "./devmind.js";
 import { codexHome, codexHookTrust, codexOtherConfigLayers, codexTrustCandidates, codexTrustFindings } from "./codex-trust.js";
 // `vexp doctor` — audit the vexp MCP/daemon state WITHOUT connecting to a daemon.
 // Surfaces the failure modes behind the Codex drift report: stale daemons.json
@@ -26,19 +31,40 @@ const WARN = chalk.yellow("WARN");
 const BAD = chalk.red("FAIL");
 // Said, not counted: a check doctor cannot make here, with nothing wrong found.
 const INFO = chalk.cyan("INFO");
+/** The nearest folder at or above `start` that is the root of a linked git worktree, or null (vexp-mcp linkedWorktreeRootOf). */
+function linkedWorktreeRootOf(start) {
+    let cur = path.resolve(start);
+    while (true) {
+        if (linkedWorktreeMain(cur))
+            return cur;
+        const parent = path.dirname(cur);
+        if (parent === cur)
+            return null;
+        cur = parent;
+    }
+}
 /** Walk up for the nearest INITIALIZED .vexp (manifest/index), then bare .vexp,
- *  then .git — mirrors discover_workspace_root / discoverWorkspaceRoot. */
-function discoverWorkspaceRoot(start) {
-    for (const test of [
-        (d) => fs.existsSync(path.join(d, ".vexp", "manifest.json")) || fs.existsSync(path.join(d, ".vexp", "index.db")),
+ *  then .git — mirrors discover_workspace_root / discoverWorkspaceRoot.
+ *  The first two passes never climb past the root of a linked git worktree:
+ *  inside one the worktree is the root, with no .vexp yet when it is fresh,
+ *  and the main checkout's index above it never holds its files. Run there,
+ *  doctor diagnosed the main checkout's daemon as this workspace's (the
+ *  3.4.0 worktree release; lockstep with both MCP servers). */
+export function discoverWorkspaceRoot(start) {
+    const boundary = linkedWorktreeRootOf(start);
+    const passes = [
+        { test: (d) => fs.existsSync(path.join(d, ".vexp", "manifest.json")) || fs.existsSync(path.join(d, ".vexp", "index.db")), walled: true },
         // Bare .vexp — except home/VEXP_HOME, whose .vexp is vexp's state dir.
-        (d) => fs.existsSync(path.join(d, ".vexp")) && path.resolve(d) !== path.resolve(vexpHome()),
-        (d) => fs.existsSync(path.join(d, ".git")),
-    ]) {
-        let cur = start;
+        { test: (d) => fs.existsSync(path.join(d, ".vexp")) && path.resolve(d) !== path.resolve(vexpHome()), walled: true },
+        { test: (d) => fs.existsSync(path.join(d, ".git")), walled: false },
+    ];
+    for (const { test, walled } of passes) {
+        let cur = path.resolve(start);
         while (true) {
             if (test(cur))
                 return cur;
+            if (walled && cur === boundary)
+                break;
             const parent = path.dirname(cur);
             if (parent === cur)
                 break;
@@ -47,11 +73,18 @@ function discoverWorkspaceRoot(start) {
     }
     return start;
 }
+/** A workspace variable, unset when empty or when it still holds an editor variable (`${workspaceFolder}`): both MCP servers read it so (workspace_env_value / workspaceEnv). */
+function workspaceEnvValue(name) {
+    const v = process.env[name];
+    return v && v.trim() !== "" && !v.includes("${") ? v : undefined;
+}
 function resolveWorkspace() {
-    if (process.env.VEXP_WORKSPACE)
-        return { root: process.env.VEXP_WORKSPACE, source: "VEXP_WORKSPACE" };
-    if (process.env.CLAUDE_PROJECT_DIR)
-        return { root: process.env.CLAUDE_PROJECT_DIR, source: "CLAUDE_PROJECT_DIR" };
+    const vw = workspaceEnvValue("VEXP_WORKSPACE");
+    if (vw)
+        return { root: vw, source: "VEXP_WORKSPACE" };
+    const cpd = workspaceEnvValue("CLAUDE_PROJECT_DIR");
+    if (cpd)
+        return { root: cpd, source: "CLAUDE_PROJECT_DIR" };
     return { root: discoverWorkspaceRoot(process.cwd()), source: "cwd-discovery" };
 }
 // Was a fifth hand-rolled copy of the hash, and one of the two that zero-padded
@@ -647,7 +680,8 @@ export function idleStopFinding(idle) {
  * It used to be one WARN and "run: vexp daemon-cmd start", whoever read it.
  * With the IDE extension that is the ordinary state of a project that is not
  * open: the extension starts a project's daemon when its window opens (if
- * the project has an index) and stops it when the window closes. The reader
+ * the project has an index, or is a git worktree of a checkout set up for
+ * vexp) and stops it when the window closes. The reader
  * has no `vexp` command, and through npx that remedy starts a daemon out of
  * the npx cache that no window owns or stops (field report, 2026-10-08).
  * Doctor cannot see whether a window is open, so it says what it knows and
@@ -702,7 +736,7 @@ export function daemonDownFindings(o) {
             },
         ];
     }
-    if (ext && !o.hasIndex) {
+    if (ext && !o.startsOnOpen) {
         return [
             {
                 level: INFO,
@@ -961,8 +995,14 @@ export function claudeNotSetUpFinding(o) {
  */
 export function gitHooksVerdict(hooksPath, repoRoot, installedCount, 
 /** The first line of .vexp/git-hooks.declined, when this clone said no to the hooks. */
-declined) {
-    const ourHooksDir = path.join(repoRoot, ".git", "hooks");
+declined, 
+/** Where vexp's hooks are (repositoryHooksFolder); `<repoRoot>/.git/hooks` when not given. */
+hooksDir = path.join(repoRoot, ".git", "hooks")) {
+    const ourHooksDir = hooksDir;
+    // The folder the lines name: ".git/hooks" for a normal checkout, as they
+    // always said; where .git is a file (a submodule, a separate git dir, a
+    // linked worktree) the folder git resolves, which is not <root>/.git/hooks.
+    const where = path.resolve(hooksDir) === path.resolve(repoRoot, ".git", "hooks") ? ".git/hooks" : hooksDir;
     if (declined !== undefined && installedCount === 0) {
         // "Skip" in VS Code, `vexp setup --personal` or `vexp hooks remove`: the
         // daemon installs none while .vexp/git-hooks.declined is there.
@@ -973,7 +1013,7 @@ declined) {
     }
     if (!hooksPath) {
         if (installedCount === 3) {
-            return { level: OK, message: "vexp hooks present in .git/hooks and git will run them" };
+            return { level: OK, message: `vexp hooks present in ${where} and git will run them` };
         }
         if (installedCount === 0) {
             return { level: OK, message: "no vexp git hooks (index refreshes on demand)" };
@@ -987,7 +1027,7 @@ declined) {
     if (path.resolve(resolved) === path.resolve(ourHooksDir)) {
         return {
             level: OK,
-            message: `core.hooksPath points at .git/hooks (${installedCount}/3 vexp hooks present)`,
+            message: `core.hooksPath points at ${where} (${installedCount}/3 vexp hooks present)`,
         };
     }
     if (installedCount === 0) {
@@ -995,11 +1035,118 @@ declined) {
     }
     return {
         level: WARN,
-        message: `core.hooksPath = ${resolved} — git runs hooks ONLY from there, so the ${installedCount} vexp hook(s) in .git/hooks never run.\n` +
+        message: `core.hooksPath = ${resolved} — git runs hooks ONLY from there, so the ${installedCount} vexp hook(s) in ${where} never run.\n` +
             `        the index still refreshes: the daemon watches the tree live and reconciles it against disk every 5 minutes (VEXP_RECONCILE_INTERVAL_SECS).\n` +
             `        the hooks only make that immediate — if you want them and a tool manages this directory (moon, husky, lefthook), add 'vexp index --finalize || true' through ITS config, not the generated file.`,
     };
 }
+/** The hooks vexp installs (vexp-core hook_installer.rs). */
+const VEXP_GIT_HOOKS = ["pre-commit", "post-merge", "post-checkout"];
+/**
+ * The hooks folder vexp-core writes its hooks into for `root`, by its rule
+ * (hook_installer.rs repository_hooks_dir): `<root>/.git/hooks` where .git
+ * is a folder, with no git call; where .git is a file (a linked worktree, a
+ * submodule), what `git rev-parse --git-path hooks --git-common-dir` says in
+ * `root` (gitIn: no shell, the GIT_DIR family removed, 3 s): the folder git
+ * runs, when it is the common dir's hooks folder, else the common dir's,
+ * with `overridden` (core.hooksPath sends git elsewhere). git giving no
+ * answer: a worktree's main checkout's .git/hooks. `<wt>/.git/hooks` is a
+ * path inside a .git FILE, which this check read in a worktree and so said
+ * "no vexp git hooks" while the main checkout's ran there. Lockstep with
+ * the extension's doctor-lines.ts.
+ */
+export function repositoryHooksFolder(root) {
+    const dotGit = path.join(root, ".git");
+    let st;
+    try {
+        st = fs.statSync(dotGit);
+    }
+    catch {
+        st = undefined;
+    }
+    if (st?.isDirectory())
+        return { dir: path.join(dotGit, "hooks"), overridden: false };
+    if (st?.isFile()) {
+        const r = gitIn(root, ["rev-parse", "--git-path", "hooks", "--git-common-dir"]);
+        const lines = r && r.status === 0 ? r.stdout.split(/\r?\n/).map((l) => l.trim()).filter((l) => l !== "") : [];
+        if (lines.length >= 2) {
+            // git prints forward slashes on Windows too: normalized, the folder
+            // reads as the OS spells it, as in every other doctor line.
+            const absolute = (l) => path.normalize(path.isAbsolute(l) ? l : path.join(root, l));
+            const canon = (p) => {
+                try {
+                    return fs.realpathSync(p);
+                }
+                catch {
+                    return path.resolve(p);
+                }
+            };
+            const named = absolute(lines[0]);
+            const common = path.join(absolute(lines[1]), "hooks");
+            return canon(named) === canon(common) ? { dir: named, overridden: false } : { dir: common, overridden: true };
+        }
+        const main = linkedWorktreeMain(root);
+        if (main)
+            return { dir: path.join(main, ".git", "hooks"), overridden: false };
+    }
+    return { dir: path.join(dotGit, "hooks"), overridden: false };
+}
+/** How many of vexp's three git hooks are in `dir` (a hook that mentions vexp). */
+export function vexpGitHooksIn(dir) {
+    return VEXP_GIT_HOOKS.filter((h) => {
+        try {
+            return fs.readFileSync(path.join(dir, h), "utf-8").includes("vexp");
+        }
+        catch {
+            return false;
+        }
+    }).length;
+}
+/**
+ * The git hooks line of a linked worktree `root` of `main`, whose hooks git
+ * runs from `dir` with `vexpHooks` of vexp's in it. What is true there: git
+ * runs one hooks folder for every checkout of a repository; vexp's hooks
+ * return at once in a linked worktree unless VEXP_WORKTREE_INDEX=1 (the
+ * guard in their body, hook_installer.rs); the worktree's own daemon
+ * watches its tree and reconciles it every 5 minutes (VEXP_RECONCILE_INTERVAL_SECS).
+ * Starts with the words the extension logs when it does not ask the hooks
+ * question there (X2). ASCII, word for word the extension doctor's.
+ */
+export function worktreeGitHooksText(root, main, dir, vexpHooks) {
+    const head = `git hooks: ${root} is a git worktree of ${main}, whose hooks also run here (from ${dir}); `;
+    const tail = "so this worktree's index refreshes on demand: its own daemon watches the tree and reconciles it against disk every 5 minutes while it runs";
+    return vexpHooks > 0
+        ? `${head}the vexp hooks among them (${vexpHooks}/3) skip linked worktrees unless VEXP_WORKTREE_INDEX=1 is set, ${tail}`
+        : `${head}none of them is vexp's, ${tail}`;
+}
+/**
+ * The "Git hooks (index refresh)" verdict for `root`. A normal checkout: as
+ * it always was (gitHooksVerdict on `<root>/.git/hooks`). Any checkout whose
+ * .git is a file (a linked worktree, a submodule, a separate git dir): the
+ * folder git resolves there (repositoryHooksFolder), where vexp-core
+ * installs its hooks; `<root>/.git/hooks` is a path inside that file, and
+ * reading it said "no vexp git hooks" in a submodule right after a
+ * successful `vexp hooks install` (review, 2026-11-07). A linked worktree
+ * gets worktreeGitHooksText, or, where core.hooksPath sends git to a folder
+ * vexp does not write, gitHooksVerdict on the folder vexp does write, with
+ * the "no git hooks" answer read where the hooks' owner keeps it (the main
+ * checkout's .vexp/ when it has one, as vexp-core's answer_root_of).
+ */
+export function gitHooksFinding(root, hooksPath) {
+    const main = linkedWorktreeMain(root);
+    // No git call where .git is a folder or missing (repositoryHooksFolder).
+    const folder = repositoryHooksFolder(root);
+    const installed = vexpGitHooksIn(folder.dir);
+    if (main && !folder.overridden)
+        return { level: OK, message: worktreeGitHooksText(root, main, folder.dir, installed) };
+    const answerRoot = main && fs.existsSync(path.join(main, ".vexp")) ? main : root;
+    let declined;
+    try {
+        declined = fs.readFileSync(path.join(answerRoot, ".vexp", "git-hooks.declined"), "utf-8").split(/\r?\n/)[0];
+    }
+    catch { /* not declined */ }
+    return gitHooksVerdict(hooksPath, root, installed, declined, folder.dir);
+}
 /**
  * The size-skip verdict, from `.vexp/coverage.json` (3.1 shape), as data.
  *
@@ -1083,7 +1230,33 @@ export function partialParseVerdict(cov, coveragePath = ".vexp/coverage.json") {
  * upgrade removed), or Chat is not in Agent mode — the only mode that offers
  * MCP tools. doctor can prove the first two; it can only say the third.
  */
-export function vsCodeMcpVerdict(cfg, wsRoot, exists = (p) => fs.existsSync(p)) {
+export function vsCodeMcpVerdict(cfg, wsRoot, exists = (p) => fs.existsSync(p), link) {
+    const v = vsCodeMcpEntryVerdict(cfg, wsRoot, exists);
+    // Setup leaves a .vscode/mcp.json that leads out of the project through a
+    // link untouched (agent-config's projectFileLink), so "re-run 'vexp setup'"
+    // alone sent the user round in a loop (review, 2026-11-07, round 4).
+    if (!link || v.level === OK)
+        return v;
+    return { level: v.level, message: `${v.message}\n        but ${vsCodeMcpLinkNote(link)}` };
+}
+/**
+ * Why 'vexp setup' leaves .vscode/mcp.json untouched, and what to do
+ * instead: it leads outside this project through a link, or through a link
+ * to nothing (agent-config's projectFileLink).
+ */
+export function vsCodeMcpLinkNote(link) {
+    return "outside" in link
+        ? `'vexp setup' leaves .vscode/mcp.json untouched, since it leads outside this project through a link (${link.outside}): replace the link with a real file or folder in this project, then re-run 'vexp setup'`
+        : "'vexp setup' leaves .vscode/mcp.json untouched, since a link on its way leads to nothing: remove that link, then re-run 'vexp setup'";
+}
+/** The no-file line of the Copilot section: setup writes the file, unless a link stops it (vsCodeMcpLinkNote). */
+export function vsCodeMcpAbsentLine(link) {
+    if (link)
+        return `no .vscode/mcp.json (Copilot MCP not configured in this folder; ${vsCodeMcpLinkNote(link)})`;
+    return "no .vscode/mcp.json (Copilot MCP not configured in this folder — 'vexp setup --agents \"GitHub Copilot\"' writes it)";
+}
+/** vsCodeMcpVerdict for the entry as read, with the remedies setup carries out. */
+function vsCodeMcpEntryVerdict(cfg, wsRoot, exists) {
     if (!cfg || typeof cfg !== "object")
         return { level: WARN, message: ".vscode/mcp.json is present but not valid JSON — VS Code will ignore every server in it; fix the syntax and re-run 'vexp setup'" };
     const servers = cfg.servers;
@@ -1106,10 +1279,11 @@ export function vsCodeMcpVerdict(cfg, wsRoot, exists = (p) => fs.existsSync(p))
         return { level: WARN, message: `.vscode/mcp.json vexp command does not exist: ${command} — re-run 'vexp setup' to repin it` };
     if (script && !exists(script))
         return { level: WARN, message: `.vscode/mcp.json vexp server bundle is missing: ${script} (an editor upgrade removed the old extension folder?) — re-run 'vexp setup'` };
-    const pinned = typeof vexp.env?.VEXP_WORKSPACE === "string" ? vexp.env.VEXP_WORKSPACE : undefined;
-    if (pinned && !samePath(pinned, wsRoot)) {
-        return { level: WARN, message: `.vscode/mcp.json vexp server is pinned to ${pinned}, but this workspace is ${wsRoot} — re-run 'vexp setup' here` };
-    }
+    // The pin is pinnedElsewhereFindings' (D2), which every MCP file agents
+    // read here gets: "re-run 'vexp setup' here" could not clear it, since
+    // setup writes "${workspaceFolder}" (W1), which this check took for
+    // another folder, and keeps the pin of a committed file another checkout
+    // wrote (W3).
     return { level: OK, message: `.vscode/mcp.json vexp server: ${command} ${script ?? args.join(" ")}` };
 }
 /**
@@ -2524,10 +2698,10 @@ function zcodeLabel(file, i) {
     return file;
 }
 /** One vexp MCP entry of ZCode's, checked. */
-function zcodeEntryFinding(entry, label, userScope, i, setup) {
+function zcodeEntryFinding(entry, label, userScope, i, setup, fix = (r) => r) {
     const e = asObject(entry);
     if (!e)
-        return { level: BAD, message: `${label}: the vexp server entry is not an object - ZCode cannot start it; re-run '${setup}'` };
+        return { level: BAD, message: `${label}: the vexp server entry is not an object - ZCode cannot start it; ${fix(`re-run '${setup}'`)}` };
     const command = typeof e.command === "string" ? e.command.trim() : "";
     const args = Array.isArray(e.args) ? e.args.filter((a) => typeof a === "string") : [];
     const env = asObject(e.env);
@@ -2535,11 +2709,11 @@ function zcodeEntryFinding(entry, label, userScope, i, setup) {
     if (!command) {
         if (typeof e.url === "string")
             return { level: INFO, message: `${label}: vexp server over http (${e.url}) - not checked here` };
-        return { level: BAD, message: `${label}: the vexp server entry has no command - ZCode cannot start it; re-run '${setup}'` };
+        return { level: BAD, message: `${label}: the vexp server entry has no command - ZCode cannot start it; ${fix(`re-run '${setup}'`)}` };
     }
     const abs = i.platform === "win32" ? path.win32.isAbsolute(command) : path.posix.isAbsolute(command);
     if (abs && !i.exists(command)) {
-        return { level: BAD, message: `${label}: the vexp server command does not exist: ${command} - ZCode cannot start it, so there are no vexp tools (an upgrade moved the binary?); re-run '${setup}'` };
+        return { level: BAD, message: `${label}: the vexp server command does not exist: ${command} - ZCode cannot start it, so there are no vexp tools (an upgrade moved the binary?); ${fix(`re-run '${setup}'`)}` };
     }
     // The Kiro lesson: a GUI app started from the Dock or the Start menu does
     // not get the shell's PATH, and a server it cannot spawn fails silently.
@@ -2549,7 +2723,7 @@ function zcodeEntryFinding(entry, label, userScope, i, setup) {
     if (!/[\\/]/.test(command) && ["node", "node.exe", "npx", "npx.cmd", "npx.exe"].includes(base)) {
         return {
             level: WARN,
-            message: `${label}: the vexp server starts through '${command}' - ZCode is a GUI app, and launched from the Dock or Start menu it may not have node on its PATH (the server then never starts and no vexp tools appear); re-run '${setup}', which writes the vexp binary itself`,
+            message: `${label}: the vexp server starts through '${command}' - ZCode is a GUI app, and launched from the Dock or Start menu it may not have node on its PATH (the server then never starts and no vexp tools appear); ${fix(`re-run '${setup}'`)}, which writes the vexp binary itself`,
         };
     }
     // An absolute npx outside Windows is a `#!/usr/bin/env node` script: it
@@ -2558,13 +2732,13 @@ function zcodeEntryFinding(entry, label, userScope, i, setup) {
     if (i.platform !== "win32" && base === "npx") {
         return {
             level: WARN,
-            message: `${label}: the vexp server starts through ${command}, a script that runs node from ZCode's PATH, which a GUI app launched from the Dock may lack (then no vexp tools appear) - delete the vexp entry there, then run '${setup}', which writes the vexp binary itself`,
+            message: `${label}: the vexp server starts through ${command}, a script that runs node from ZCode's PATH, which a GUI app launched from the Dock may lack (then no vexp tools appear) - ${fix(`delete the vexp entry there, then run '${setup}'`)}, which writes the vexp binary itself`,
         };
     }
     if (!/[\\/]/.test(command)) {
         return {
             level: WARN,
-            message: `${label}: the vexp server command is a bare '${command}', looked up on ZCode's PATH, which a GUI app launched from the Dock or Start menu usually lacks; re-run '${setup}' to write the absolute path`,
+            message: `${label}: the vexp server command is a bare '${command}', looked up on ZCode's PATH, which a GUI app launched from the Dock or Start menu usually lacks; ${fix(`re-run '${setup}'`)} to write the absolute path`,
         };
     }
     if (pin && !samePath(pin, i.root)) {
@@ -2572,8 +2746,8 @@ function zcodeEntryFinding(entry, label, userScope, i, setup) {
             level: WARN,
             message: `${label}: the vexp server is pinned to ${pin} (VEXP_WORKSPACE), but this project is ${i.root} - ZCode sessions here query that project's index. ` +
                 (userScope
-                    ? `That entry is in your user config and serves every project: run '${setup}' here to give this project its own entry.`
-                    : `Re-run '${setup}' to repin it.`),
+                    ? `That entry is in your user config and serves every project: ${fix(`run '${setup}' here`)} to give this project its own entry.`
+                    : `${i.projectLink ? fix(`re-run '${setup}'`) : `Re-run '${setup}'`} to repin it.`),
         };
     }
     return { level: OK, message: `${label}: vexp server ${command}${args.length ? ` ${args.join(" ")}` : ""}${pin ? `, pinned to ${pin}` : ", no workspace pin"}` };
@@ -2581,6 +2755,14 @@ function zcodeEntryFinding(entry, label, userScope, i, setup) {
 /** The ZCode section of doctor, as data (the log has its own function). */
 export function zcodeFindings(i) {
     const setup = setupAgentsCommand(["ZCode"], i.root);
+    // A remedy that runs setup to write the project's MCP file names the link
+    // that stops setup instead, when one does (projectLink): setup leaves
+    // that file untouched (R4), and the doctor printed the same line after
+    // it, for ever (review, 2026-11-07, round 5). `run` is the same remedy
+    // at the start of a sentence; without a link both are as before.
+    const pl = i.projectLink;
+    const fix = (remedy) => (pl ? projectLinkRemedy(zcodeLabel(pl.file, i), pl.link, remedy) : remedy);
+    const run = pl ? fix(`run '${setup}'`) : `Run '${setup}'`;
     if (!zcodeInUse(i)) {
         // vexp's hook runs in every folder ZCode opens, this one included: say
         // what opening it in ZCode would lack, never as a fault of a project
@@ -2590,7 +2772,7 @@ export function zcodeFindings(i) {
                 {
                     level: INFO,
                     message: `vexp's ZCode hook (~/.zcode/cli/config.json) runs in every folder ZCode opens, but this project has no vexp MCP entry for ZCode (.zcode/config.json, .agents/mcp.json)` +
-                        (i.consent === "no" || i.consent === "never" ? " - you said no to ZCode here" : `: if you open it in ZCode, run '${setup}'`),
+                        (i.consent === "no" || i.consent === "never" ? " - you said no to ZCode here" : `: if you open it in ZCode, ${fix(`run '${setup}'`)}`),
                 },
             ];
         }
@@ -2636,38 +2818,38 @@ export function zcodeFindings(i) {
     const names = (s) => Object.keys(s ?? {});
     let served = false;
     if (wsNative?.vexp) {
-        out.push(zcodeEntryFinding(wsNative.vexp, zcodeLabel(i.workspaceNative.file, i), false, i, setup));
+        out.push(zcodeEntryFinding(wsNative.vexp, zcodeLabel(i.workspaceNative.file, i), false, i, setup, fix));
         served = true;
     }
     else if (names(wsNative).length > 0 && wsCompat?.vexp) {
         out.push({
             level: BAD,
             message: `${zcodeLabel(i.workspaceCompat.file, i)} holds the vexp server, but ${zcodeLabel(i.workspaceNative.file, i)} defines servers of its own (${names(wsNative).join(", ")}): ` +
-                `ZCode skips .agents/mcp.json whenever .zcode/config.json defines servers, so no vexp tools here. Run '${setup}': it writes the vexp entry into .zcode/config.json.`,
+                `ZCode skips .agents/mcp.json whenever .zcode/config.json defines servers, so no vexp tools here. ${run}: it writes the vexp entry into .zcode/config.json.`,
         });
     }
     else if (wsCompat?.vexp) {
-        out.push(zcodeEntryFinding(wsCompat.vexp, zcodeLabel(i.workspaceCompat.file, i), false, i, setup));
+        out.push(zcodeEntryFinding(wsCompat.vexp, zcodeLabel(i.workspaceCompat.file, i), false, i, setup, fix));
         served = true;
     }
     if (!served) {
         if (usNative?.vexp) {
-            out.push(zcodeEntryFinding(usNative.vexp, zcodeLabel(i.userNative.file, i), true, i, setup));
+            out.push(zcodeEntryFinding(usNative.vexp, zcodeLabel(i.userNative.file, i), true, i, setup, fix));
         }
         else if (names(usNative).length > 0 && usCompat?.vexp) {
             out.push({
                 level: BAD,
                 message: `${zcodeLabel(i.userCompat.file, i)} holds the vexp server, but ${zcodeLabel(i.userNative.file, i)} defines servers of its own (${names(usNative).join(", ")}): ` +
-                    `ZCode skips ~/.agents/mcp.json whenever ~/.zcode/cli/config.json defines servers. Run '${setup}': it writes the vexp entry into this project's .zcode/config.json.`,
+                    `ZCode skips ~/.agents/mcp.json whenever ~/.zcode/cli/config.json defines servers. ${run}: it writes the vexp entry into this project's .zcode/config.json.`,
             });
         }
         else if (usCompat?.vexp) {
-            out.push(zcodeEntryFinding(usCompat.vexp, zcodeLabel(i.userCompat.file, i), true, i, setup));
+            out.push(zcodeEntryFinding(usCompat.vexp, zcodeLabel(i.userCompat.file, i), true, i, setup, fix));
         }
         else if (!(names(wsNative).length > 0 && wsCompat?.vexp)) {
             out.push({
                 level: BAD,
-                message: `no vexp MCP server for ZCode here: none in .zcode/config.json, .agents/mcp.json, ~/.zcode/cli/config.json or ~/.agents/mcp.json, so ZCode sessions get no vexp tools. Run '${setup}'.`,
+                message: `no vexp MCP server for ZCode here: none in .zcode/config.json, .agents/mcp.json, ~/.zcode/cli/config.json or ~/.agents/mcp.json, so ZCode sessions get no vexp tools. ${run}.`,
             });
         }
     }
@@ -2745,6 +2927,437 @@ export function zcodeFindings(i) {
     }
     return out;
 }
+const AG_PROJECT = ".agents/mcp_config.json";
+const AG_GLOBAL = "~/.gemini/config/mcp_config.json";
+const AG_LEGACY = "~/.gemini/antigravity/mcp_config.json";
+/**
+ * Where an entry with no VEXP_WORKSPACE serves: Antigravity starts an MCP
+ * server in its own process's folder and passes no workspace variable
+ * (agy 1.5.3, measured 2026-11-07). Lockstep with the extension.
+ */
+const AG_UNPINNED = "serves whatever folder Antigravity starts it from: the window's first folder in VS Code, often the home folder in the Antigravity app, where it lists no tools";
+/**
+ * Why a global `vexp` beside the project's is the one used: its servers
+ * start with Antigravity, the project's load per conversation, and the
+ * server already running keeps the name (agy 1.5.3, measured 2026-11-07).
+ */
+const AG_SHADOW = `a vexp in ${AG_GLOBAL} starts with Antigravity, before any conversation, so it keeps the name and the project's .agents entry is not used`;
+/**
+ * A project entry whose binary is not on this machine: another machine or a
+ * container may share the folder. It follows the remedy, which runs a
+ * setup, and the setup is what rewrites it: nothing in the CLI or vexp-core
+ * rewrites the file at a start, so "vexp writes its own at its next start
+ * here" was false for a CLI-only user. Lockstep with the extension.
+ */
+const AG_SHARED_FOLDER = " (another machine or a container that shares this folder may have written it; the setup rewrites it with this machine's paths)";
+/** The same case when the project file is reached through a link out of the project: the setup leaves that file untouched, so it rewrites nothing there. Lockstep with the extension. */
+const AG_SHARED_LINK = " (another machine or a container that shares that folder may have written it)";
+/**
+ * The remedy for the project file: the reader's setup, unless setup leaves
+ * the file untouched because it leads outside the project through a link,
+ * or through a link to nothing (agent-config's projectFileLink). A remedy
+ * that runs setup could never work there: setup refused, and the doctor
+ * printed the same line again (review, 2026-11-07, round 4). The way out
+ * is a file of the project's own: a file shared through the link holds one
+ * machine's (or one project's) paths, and an edit by hand for this one
+ * breaks it for the other. The doctor still reads the file through the
+ * link, since Antigravity does. Lockstep with the extension.
+ */
+function agProjectRemedy(i) {
+    return projectLinkRemedy(AG_PROJECT, i.projectLink, i.remedy);
+}
+/**
+ * A remedy that runs setup to write the project file `file` (as the line
+ * names it), unless setup leaves that file untouched because it leads
+ * outside the project through a link, or through a link to nothing
+ * (agent-config's projectFileLink): then the link is named first, and the
+ * remedy follows it. Antigravity's and ZCode's lines. Lockstep with the
+ * extension's projectLinkRemedy (doctor-lines.ts).
+ */
+export function projectLinkRemedy(file, link, remedy) {
+    if (!link)
+        return remedy;
+    if ("outside" in link) {
+        return `vexp's setup leaves ${file} untouched, since it leads outside this project through a link (${link.outside}): replace the link with a real file or folder in this project, then ${remedy}`;
+    }
+    return `vexp's setup leaves ${file} untouched, since a link on its way leads to nothing: remove that link, then ${remedy}`;
+}
+/**
+ * Does the project file hold nothing but vexp's server, as setup leaves it
+ * (one with no mcpServers yet gets vexp's)? Only such a file is vexp's to
+ * keep out of git (agent-config's holdsOnlyVexp), and only for it does
+ * `git rm --cached` stick. Lockstep with the extension.
+ */
+function agOnlyVexp(f) {
+    if (f.state !== "ok")
+        return false;
+    return holdsOnlyVexp(f.data.mcpServers === undefined ? { ...f.data, mcpServers: {} } : f.data);
+}
+/**
+ * What a vexp server still in the 1.x file does. No current build reads
+ * that file, but until ~/.gemini/config/.migrated exists the first start of
+ * the Antigravity IDE or of its VS Code extension MOVES it over the global
+ * file, replacing the servers there, and the vexp in it then runs before
+ * any conversation (agy 1.5.3, measured 2026-11-07): "it does nothing" is
+ * true only after that move. Setup takes out vexp's own dead entry, and
+ * the file with it when nothing else is left. Lockstep with the extension.
+ */
+function agLegacyNote(lv, i, isDead) {
+    const what = i.migrated
+        ? `${AG_LEGACY} still has a vexp server, in a file current Antigravity builds no longer read, so it does nothing`
+        : `${AG_LEGACY} still has a vexp server; that file is not read, but the first start of the Antigravity IDE or of its VS Code extension moves it over ${AG_GLOBAL}, replacing the servers there`;
+    if (isDead(lv))
+        return `${what} - ${i.remedy} to take it out`;
+    return i.migrated ? what : `${what} - remove it from that file (vexp takes out only the entries it wrote there)`;
+}
+/**
+ * The command that stops git tracking the project file, from wherever the
+ * reader is in the repository: the plain path when the workspace is the
+ * top level, else the path from the top level as a `:/` pathspec, which
+ * git reads the same from any folder (`:(top,literal)` when the path holds
+ * a wildcard, which a pathspec would match as one), quoted for the shell.
+ * A bare top-level path failed when run from the workspace, and one with a
+ * space split in two (review, 2026-11-07). Lockstep with the extension.
+ */
+function agUntrack(tracked, platform) {
+    if (tracked === AG_PROJECT)
+        return `git rm --cached ${AG_PROJECT}`;
+    const spec = /[*?[\\]/.test(tracked) ? `:(top,literal)${tracked}` : `:/${tracked}`;
+    return `git rm --cached ${platform === "win32" ? `"${spec}"` : `'${spec.split("'").join("'\\''")}'`}`;
+}
+/**
+ * An absolute path on either kind of system. An entry in a folder shared
+ * between Windows and WSL or a container may have been written on the
+ * other side: `C:\...\vexp-core.exe` read on Linux is a binary that is not
+ * here, never "a relative path". Lockstep with the extension.
+ */
+function agAbsolute(p) {
+    return path.win32.isAbsolute(p) || path.posix.isAbsolute(p);
+}
+/** The three files Antigravity's section reads. agy's migration may leave the 1.x name a link to the global file: it is then that file, read once. */
+export function readAntigravityFiles(root, home) {
+    const globalPath = path.join(home, ".gemini", "config", "mcp_config.json");
+    const legacyPath = path.join(home, ".gemini", "antigravity", "mcp_config.json");
+    let sameFile = false;
+    try {
+        sameFile = fs.realpathSync(legacyPath) === fs.realpathSync(globalPath);
+    }
+    catch {
+        /* either one absent: two files */
+    }
+    return {
+        project: readJsonFileState(path.join(root, ".agents", "mcp_config.json")),
+        global: readJsonFileState(globalPath),
+        legacy: sameFile ? { file: legacyPath, state: "absent" } : readJsonFileState(legacyPath),
+    };
+}
+/** The `vexp` entry of a file's mcpServers, when there is one. */
+function agVexp(f) {
+    if (f.state !== "ok")
+        return undefined;
+    const v = asObject(f.data.mcpServers)?.vexp;
+    return v === null ? undefined : v;
+}
+/**
+ * The folder an entry makes vexp serve, as vexp-core reads it: `--workspace`,
+ * then env VEXP_WORKSPACE, then env CLAUDE_PROJECT_DIR, then the `cwd` the
+ * server is started in. Lockstep with the extension.
+ */
+function agPin(e) {
+    const args = Array.isArray(e.args) ? e.args : [];
+    const i = args.indexOf("--workspace");
+    if (i >= 0 && typeof args[i + 1] === "string" && args[i + 1].trim())
+        return args[i + 1];
+    const eq = args.find((a) => typeof a === "string" && a.startsWith("--workspace=") && a.length > 12);
+    if (eq)
+        return eq.slice(12);
+    const env = asObject(e.env);
+    if (typeof env?.VEXP_WORKSPACE === "string" && env.VEXP_WORKSPACE.trim())
+        return env.VEXP_WORKSPACE;
+    if (typeof env?.CLAUDE_PROJECT_DIR === "string" && env.CLAUDE_PROJECT_DIR.trim())
+        return env.CLAUDE_PROJECT_DIR;
+    if (typeof e.cwd === "string" && e.cwd.trim())
+        return e.cwd;
+    return undefined;
+}
+/**
+ * Is a pin this workspace, as vexp-core resolves it: an absolute path that
+ * is the root (in letter case only on Windows: samePath folds case on every
+ * platform, and read a pin to another folder on Linux as this one), or the
+ * same folder behind a link. A relative pin resolves against the folder
+ * Antigravity starts vexp in, never against the doctor's own cwd. Lockstep
+ * with the extension.
+ */
+function agPinnedHere(pin, i) {
+    if (pin.includes("${") || !agAbsolute(pin))
+        return false;
+    if (i.platform === "win32" ? samePath(pin, i.root) : path.posix.resolve(pin) === path.posix.resolve(i.root))
+        return true;
+    try {
+        return fs.realpathSync(pin) === fs.realpathSync(i.root);
+    }
+    catch {
+        return false;
+    }
+}
+/** Is Antigravity set up for this project: exactly what planAgentSetup
+ *  (both twins) configures, its marker here (on a machine that shows
+ *  Antigravity: `marker`) or a "yes" on record; the extension's doctor
+ *  checks the files only for an agent its plan configures. The marker sets
+ *  Antigravity up whatever was answered: a "Never" here read "no
+ *  Antigravity setup" over a start that set it up and failed, while the
+ *  extension's doctor warned (review, 2026-11-07). A vexp entry in the
+ *  project file is no such evidence: a teammate's committed file, on a
+ *  machine with no Antigravity, made `vexp doctor` FAIL where the
+ *  extension said nothing and no setup would write the entry (review,
+ *  2026-11-07, round 3). Project evidence only, as for ZCode: the global
+ *  file serves every project. */
+export function antigravityInUse(i) {
+    return i.marker || i.consent === "yes";
+}
+/** The project's vexp entry, checked as Antigravity would start it. */
+function agProjectEntryFinding(entry, i) {
+    const R = agProjectRemedy(i);
+    const e = asObject(entry);
+    if (!e)
+        return { level: BAD, message: `Antigravity: ${AG_PROJECT} has a vexp server entry that is not an object, so Antigravity cannot start it - ${R}` };
+    const command = typeof e.command === "string" ? e.command.trim() : "";
+    if (!command) {
+        const url = typeof e.serverUrl === "string" ? e.serverUrl : typeof e.url === "string" ? e.url : undefined;
+        if (url)
+            return { level: INFO, message: `Antigravity: ${AG_PROJECT} reaches vexp over http (${url}) - not checked here` };
+        return { level: BAD, message: `Antigravity: ${AG_PROJECT} has a vexp server entry with no command, so Antigravity cannot start it - ${R}` };
+    }
+    if (agAbsolute(command) && !i.exists(command)) {
+        return {
+            level: BAD,
+            message: `Antigravity: ${AG_PROJECT} starts vexp from ${command}, which does not exist, so Antigravity has no vexp tools in this workspace - ${R}${i.projectLink ? AG_SHARED_LINK : AG_SHARED_FOLDER}`,
+        };
+    }
+    // The Kiro lesson: an app started from the Dock or the Start menu does not
+    // get the shell's PATH, and a server it cannot spawn fails in silence.
+    if (!/[\\/]/.test(command)) {
+        return {
+            level: WARN,
+            message: `Antigravity: ${AG_PROJECT} starts vexp with a bare '${command}', looked up on Antigravity's PATH, which an app launched from the Dock or Start menu usually lacks - ${R}`,
+        };
+    }
+    const args = Array.isArray(e.args) ? e.args.filter((a) => typeof a === "string") : [];
+    if (!args.includes("mcp")) {
+        return {
+            level: BAD,
+            message: `Antigravity: ${AG_PROJECT} starts ${command} without the mcp subcommand, so it serves no MCP and Antigravity has no vexp tools in this workspace - ${R}`,
+        };
+    }
+    const pin = agPin(e);
+    if (pin === undefined) {
+        return {
+            level: WARN,
+            message: `Antigravity: ${AG_PROJECT} starts vexp with no VEXP_WORKSPACE, so it ${AG_UNPINNED} - ${R}`,
+        };
+    }
+    if (pin.includes("${")) {
+        return {
+            level: WARN,
+            message: `Antigravity: ${AG_PROJECT} pins vexp to '${pin}', which vexp gets as written: Antigravity expands no \${...} in mcp_config.json, so vexp serves no project - ${R}`,
+        };
+    }
+    if (!agAbsolute(pin)) {
+        return {
+            level: WARN,
+            message: `Antigravity: ${AG_PROJECT} pins vexp to '${pin}', a relative path, which vexp resolves against the folder Antigravity starts it in, not against this workspace - ${R}`,
+        };
+    }
+    if (!agPinnedHere(pin, i)) {
+        const effect = i.exists(pin) ? "query that project's index" : "get no vexp tools (that folder does not exist)";
+        return { level: WARN, message: `Antigravity: ${AG_PROJECT} pins vexp to ${pin}, not to this workspace (${i.root}), so Antigravity sessions here ${effect} - ${R}` };
+    }
+    // A switch the writers keep across a rewrite (ANTIGRAVITY_USER_KEYS):
+    // Antigravity then starts no vexp server, whatever the rest says.
+    if (e.disabled === true) {
+        return {
+            level: WARN,
+            message: `Antigravity: ${AG_PROJECT} has vexp turned off ("disabled": true), so Antigravity starts no vexp server in this workspace - remove "disabled" from vexp's entry there to turn it on`,
+        };
+    }
+    return { level: OK, message: `Antigravity: ${AG_PROJECT} starts vexp (${[command, ...args].join(" ")}), pinned to this workspace` };
+}
+/** The extension version an entry's command or args point into (vexp.vexp-vscode-<ver>). Lockstep with the extension and the writers. */
+function agInstallVersion(e) {
+    const parts = [e.command, ...(Array.isArray(e.args) ? e.args : [])];
+    for (const p of parts) {
+        const m = typeof p === "string" ? p.match(/vexp\.vexp-vscode-(\d+\.\d+\.\d+)/) : null;
+        if (m)
+            return m[1];
+    }
+    return undefined;
+}
+/** Is version `a` strictly older than `b`? What does not parse is never older. Lockstep with the extension. */
+function agOlder(a, b) {
+    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 x = parts(a);
+    const y = parts(b);
+    if (!x || !y)
+        return false;
+    for (let k = 0; k < 3; k++)
+        if (x[k] !== y[k])
+            return x[k] < y[k];
+    return false;
+}
+/**
+ * A `vexp` server in the global file: it has the project entry's name. No
+ * vexp setup writes or updates that file, so an entry pinned here is
+ * checked as Antigravity would start it, and beside a project entry it is
+ * a second server of the same name (review, 2026-11-07). `projectEntry`:
+ * the project file holds a vexp server.
+ */
+function agGlobalFinding(entry, i, isDead, projectEntry) {
+    const pin = agPin(entry);
+    // Setup takes out only what it would remove (agent-config's
+    // antigravityFilesVexpCleans): vexp's own dead entry, and in this file
+    // only behind agy's migration link. Any other vexp here is the user's to
+    // remove, a dead-looking one too.
+    const fix = isDead(entry) && i.globalCleaned
+        ? `${i.remedy} to take it out`
+        : isDead(entry)
+            ? `remove it from that file (vexp edits that file only while ${AG_LEGACY} links to it)`
+            : "remove it from that file (vexp takes out only the entries it wrote there)";
+    // Beside no project entry it has nothing to shadow yet: the one setup
+    // writes is what it will shadow (review, 2026-11-07).
+    const shadows = projectEntry ? `it shadows the entry in ${AG_PROJECT}` : `it will shadow the entry vexp sets up in ${AG_PROJECT}`;
+    if (pin === undefined) {
+        return {
+            level: WARN,
+            message: `Antigravity: ${AG_GLOBAL} has a server named vexp with no VEXP_WORKSPACE, so it ${AG_UNPINNED}; and ${shadows} (${AG_SHADOW}) - ${fix}`,
+        };
+    }
+    if (!agPinnedHere(pin, i)) {
+        return {
+            level: WARN,
+            message: `Antigravity: ${AG_GLOBAL} has a server named vexp pinned to ${pin}, so ${shadows} with that project's index (${AG_SHADOW}) - ${fix}`,
+        };
+    }
+    // Beside no project entry, the setup writes one first: unless it leaves
+    // the project file untouched (agProjectRemedy).
+    const remove = projectEntry
+        ? `remove it from that file, so the entry vexp keeps current in ${AG_PROJECT} is used (${AG_SHADOW})`
+        : i.projectLink
+            ? `${agProjectRemedy(i)}, then remove it from ${AG_GLOBAL}`
+            : `${i.remedy}, then remove it from that file`;
+    const command = typeof entry.command === "string" ? entry.command.trim() : "";
+    if (command && agAbsolute(command) && !i.exists(command)) {
+        return {
+            level: WARN,
+            message: `Antigravity: ${AG_GLOBAL} has a server named vexp pinned to this workspace that starts vexp from ${command}, which does not exist, so Antigravity cannot start it, and vexp never updates that file - ${remove}`,
+        };
+    }
+    const theirs = agInstallVersion(entry);
+    if (theirs && i.version && agOlder(theirs, i.version)) {
+        return {
+            level: WARN,
+            message: `Antigravity: ${AG_GLOBAL} has a server named vexp pinned to this workspace that starts vexp from the ${theirs} extension folder, older than this build (${i.version}), and vexp never updates that file - ${remove}`,
+        };
+    }
+    if (projectEntry) {
+        return {
+            level: WARN,
+            message: `Antigravity: ${AG_GLOBAL} has a server named vexp pinned to this workspace, beside the vexp entry in ${AG_PROJECT}, and vexp never updates the global one - ${remove}`,
+        };
+    }
+    return {
+        level: INFO,
+        message: `Antigravity: ${AG_GLOBAL} has a server named vexp pinned to this workspace: it serves this project here, but that file is global, so in other workspaces it shadows their own vexp entry (${AG_SHADOW})`,
+    };
+}
+/** The Antigravity section of doctor, as data. */
+export function antigravityFindings(i) {
+    const R = i.remedy;
+    const isDead = i.isDead ?? isDeadAntigravityEntry;
+    const pv = agVexp(i.project);
+    const gv = agVexp(i.global);
+    const lv = agVexp(i.legacy);
+    if (!antigravityInUse(i)) {
+        // The global file serves every project: say what this one would get
+        // from it, never as a fault of a project that may not use Antigravity.
+        // "Not here" is this project's answer, "Never" the machine's.
+        const declined = i.consent === "no" ? " - you said no to Antigravity here" : i.consent === "never" ? " - you said Never to Antigravity on this machine" : "";
+        if (gv !== undefined) {
+            return [
+                {
+                    level: INFO,
+                    message: `no Antigravity setup for this project, but ${AG_GLOBAL} has a server named vexp, which Antigravity reads in every workspace` +
+                        (declined || `: if you open this project in Antigravity, ${R}`),
+                },
+            ];
+        }
+        if (lv !== undefined) {
+            return [{ level: INFO, message: `no Antigravity setup for this project; ${agLegacyNote(lv, i, isDead)}` }];
+        }
+        return [{ level: OK, message: `no Antigravity setup for this project${declined}` }];
+    }
+    const out = [];
+    let legacyNamed = false;
+    // The project file's remedy (agProjectRemedy); R stays for the 1.x and
+    // global entries, which setup takes out whatever the project file is.
+    const PR = agProjectRemedy(i);
+    if (i.project.state === "unparseable") {
+        out.push({ level: WARN, message: `Antigravity: ${AG_PROJECT} is not valid JSON, and vexp does not rewrite a file it cannot read - ${i.projectLink ? PR : `fix the file, then ${R}`}` });
+    }
+    else if (pv !== undefined) {
+        out.push(agProjectEntryFinding(pv, i));
+    }
+    else if (gv !== undefined) {
+        const g = asObject(gv);
+        const pin = g ? agPin(g) : undefined;
+        const here = pin !== undefined && agPinnedHere(pin, i);
+        out.push({ level: here ? INFO : WARN, message: `Antigravity: no vexp server in ${AG_PROJECT}, the entry vexp sets up for this workspace - ${PR}` });
+    }
+    else if (lv !== undefined) {
+        legacyNamed = true;
+        out.push({
+            level: WARN,
+            message: `Antigravity: vexp's server is only in ${AG_LEGACY}, a file current Antigravity builds no longer read (they read ${AG_PROJECT} and ${AG_GLOBAL}), so Antigravity has no vexp tools in this workspace - ${PR}`,
+        });
+    }
+    else {
+        out.push({ level: WARN, message: `Antigravity: no vexp server in ${AG_PROJECT} or ${AG_GLOBAL}, so Antigravity has no vexp tools in this workspace - ${PR}` });
+    }
+    // A file that holds only vexp's entry is vexp's: setup keeps it out of
+    // git (the exclude file), also after the `git rm --cached` below, so the
+    // advice sticks. One with the project's own servers or keys is the
+    // project's business: setup never excludes it, so after that command the
+    // next `git add -A` committed it again, and the untracking commit took
+    // the project's servers out of every other checkout (review, 2026-11-07,
+    // round 4). For it the doctor says what committing vexp's entry costs,
+    // and never to untrack it. A file it cannot read gets neither.
+    if (i.tracked && agOnlyVexp(i.project)) {
+        out.push({
+            level: INFO,
+            message: `Antigravity: ${AG_PROJECT} is committed to git, but it holds this machine's paths (the vexp binary and this folder) and vexp rewrites it with each machine's own - run: ${agUntrack(i.tracked, i.platform)}`,
+        });
+    }
+    else if (i.tracked && i.project.state === "ok") {
+        out.push({
+            level: INFO,
+            message: `Antigravity: ${AG_PROJECT} is committed to git with the project's own servers or keys, and the vexp entry setup writes there holds this machine's paths (the vexp binary and this folder), which vexp rewrites with each machine's own - commit the file without vexp's entry (each machine's setup adds its own), and keep it tracked: untracking it takes the project's servers out of every other checkout`,
+        });
+    }
+    if (i.global.state === "unparseable") {
+        out.push({ level: INFO, message: `Antigravity: ${AG_GLOBAL} is not valid JSON, so whether it holds a server named vexp is not known - vexp leaves a file it cannot read as it is` });
+    }
+    else {
+        const g = asObject(gv);
+        if (g)
+            out.push(agGlobalFinding(g, i, isDead, pv !== undefined));
+    }
+    if (lv !== undefined && !legacyNamed) {
+        out.push({ level: INFO, message: `Antigravity: ${agLegacyNote(lv, i, isDead)}` });
+    }
+    return out;
+}
 /**
  * A log line as text twice over: `match` holds the string values only, keys
  * left out (`"error": null` is not an error); `show` keeps each key next to
@@ -2998,6 +3611,15 @@ export function buildDoctorReport(i) {
     if (i.mountNotice)
         parts.push("", `> **Filesystem:** ${i.mountNotice}`);
     parts.push("", "## Doctor", "", "```", stripAnsi(i.doctorText).trim(), "```");
+    // Whether DevMind runs on this machine, and why not: the daemon's reason
+    // alone left support guessing at the GPU, the driver and the config
+    // (review, 2026-11-08). The engine's own lines, an allow-list of them, no
+    // key among them.
+    parts.push("", "## Local LLM (DevMind): setup-llm --status", "");
+    if (i.llmStatus && i.llmStatus.length > 0)
+        parts.push("```", ...i.llmStatus, "```");
+    else
+        parts.push(`setup-llm --status unavailable: ${i.llmStatusError ?? (i.llmStatus ? "it printed none of the LLM lines" : "not run")}`);
     parts.push("", "## Usage ledger", "");
     parts.push(i.ledgerMarkdown?.trim() || `ledger unavailable: ${i.ledgerError ?? "unknown error"}`);
     parts.push("", `## Daemon log${i.logName ? ` (.vexp/${i.logName})` : ""}: warnings and errors`, "");
@@ -3266,6 +3888,29 @@ export async function writeDoctorReport(o) {
     }
     else
         ledgerMarkdown = String(ledger.stdout);
+    // Read-only: the config, the hardware probe and the workspace daemon's
+    // answer. It loads the CUDA plugin to see whether it loads, hence the
+    // longer wait. The workspace is pinned and the cwd is not in it: a
+    // backend library a cloned repository carries was loaded from the cwd
+    // (review, 2026-11-08). Lockstep with the extension's LLM Status.
+    const llm = bin
+        ? spawnSync(bin, ["setup-llm", "--status"], {
+            cwd: os.tmpdir(),
+            env: { ...process.env, VEXP_WORKSPACE: o.root },
+            timeout: 20000,
+            encoding: "utf-8",
+        })
+        : null;
+    let llmStatus = null;
+    let llmStatusError;
+    if (!llm)
+        llmStatusError = "vexp-core binary not found";
+    else if (llm.error)
+        llmStatusError = llm.error.message;
+    else if (llm.status !== 0)
+        llmStatusError = String(llm.stderr ?? "").trim().split("\n")[0] || `exit ${llm.status}`;
+    else
+        llmStatus = llmStatusReportLines(String(llm.stdout));
     let logName = null;
     let logWarnings = [];
     const logs = [];
@@ -3320,6 +3965,8 @@ export async function writeDoctorReport(o) {
         configProblem,
         configEncoding,
         mountNotice: [slowMountNotice(o.root), cloudSyncHere(o.root)].filter(Boolean).join(" ") || null,
+        llmStatus,
+        llmStatusError,
     });
     const dest = o.outFile ? path.resolve(o.outFile) : path.join(o.root, DEFAULT_REPORT_FILE);
     fs.mkdirSync(path.dirname(dest), { recursive: true });
@@ -3356,6 +4003,253 @@ export async function runDoctor(opts = {}) {
         console.log("");
     }
 }
+// ---------------------------------------------------------------------------
+// Git worktrees (3.4.0). A window on a linked worktree was served by the
+// main checkout's index, through an entry pinned to it in a file every
+// checkout reads, and the doctors said only that a daemon answered and two
+// counts that did not match (field report, 2026-11-07: "203 files" against
+// "335"). These findings say which folder the daemon serves, which MCP files
+// pin vexp to another checkout, where a worktree's answers come from, and
+// what each extra daemon of one repository costs with the local model.
+// Lockstep with the extension's doctor-lines.ts, word for word (its
+// doctor-worktree-lockstep.test.ts holds the two to it). ASCII only.
+// ---------------------------------------------------------------------------
+/**
+ * D1: the folder the daemon that answered serves (index_status
+ * `workspace_root`), against this workspace; in a linked worktree, which
+ * checkout it is a worktree of. null from a daemon too old to say.
+ */
+export function servedRootFinding(served, root, main = linkedWorktreeMain(root)) {
+    if (typeof served !== "string" || served.trim() === "")
+        return null;
+    if (!sameFolderAsExtension(served, root))
+        return { level: WARN, message: `daemon serves ${served}, not this workspace (${root})` };
+    return { level: OK, message: main ? `serves ${root} (a git worktree of ${main})` : `serves ${root}` };
+}
+/**
+ * D2's finding for one file: word for word the extension's
+ * pinnedElsewhereLine, remedy by where the pin is (`from`), and for a pin to
+ * a folder that is not on this machine, what agents get there (`exists`).
+ */
+export function pinnedElsewhereFinding(file, pin, root, from = "env", exists = fs.existsSync) {
+    const get = exists(pin) ? `get the index of ${pin}` : "get no vexp tools (that folder does not exist)";
+    const remedy = from === "args" ? "remove --workspace from that entry's args" : "remove VEXP_WORKSPACE from that entry";
+    return {
+        level: WARN,
+        message: `${file} has a vexp server pinned to ${pin}, not to this workspace (${root}): agents that read it here ${get} - ${remedy}, and each checkout then serves itself`,
+    };
+}
+/**
+ * D2: every MCP file agents read here (`files`: <root>/.mcp.json and
+ * <root>/.vscode/mcp.json) that holds a server named vexp, in any letter
+ * case, pinned to a folder other than this root, each file read by its own
+ * rules. In .vscode/mcp.json (key "servers") a pin of "${workspaceFolder}"
+ * names whichever checkout reads it, so this one; ${userHome} and
+ * ${env:NAME} are expanded as VS Code does there (expandedPin); any other
+ * variable, and a relative pin, is not compared. In .mcp.json (key
+ * "mcpServers") the pin is read as VS Code expands it in that file
+ * (dotMcpJsonPin, the reading of M2's dotMcpJsonMiss): ${NAME} from the
+ * environment, a relative pin against this root; what still holds `${` names
+ * no folder, and the servers then serve this one. Read with .vscode/mcp.json's
+ * rules, one entry got this warning and D4's [OK] in one run (review,
+ * 2026-11-08). A file that is absent or does not parse says nothing here
+ * (its own section does). The Antigravity files have their own findings
+ * (antigravityFindings).
+ */
+export function pinnedElsewhereFindings(files, root, exists = fs.existsSync) {
+    const out = [];
+    const seen = new Set();
+    for (const { file, key } of files) {
+        if (seen.has(path.resolve(file)))
+            continue;
+        seen.add(path.resolve(file));
+        const f = readJsonFileState(file);
+        if (f.state !== "ok")
+            continue;
+        const servers = asObject(f.data[key]);
+        if (!servers)
+            continue;
+        for (const [name, entry] of Object.entries(servers)) {
+            if (name.toLowerCase() !== "vexp")
+                continue;
+            const p = vexpPinOf(entry);
+            const folder = p === undefined ? undefined : key === "mcpServers" ? dotMcpJsonPin(p.pin, root) : expandedPin(p.pin, root);
+            if (p === undefined || folder === undefined || !(path.win32.isAbsolute(folder) || path.posix.isAbsolute(folder)) || sameFolderAsExtension(folder, root))
+                continue;
+            out.push(pinnedElsewhereFinding(file, folder, root, p.from, exists));
+        }
+    }
+    return out;
+}
+/** D3: a linked worktree whose answers come from its main checkout (agent-consent's inheritedAnswers). */
+export function inheritedAnswersFinding(main) {
+    return { level: INFO, message: `agent answers for this git worktree come from ${main}` };
+}
+/**
+ * D4's condition, lockstep with the extension doctor: .vscode/mcp.json is
+ * absent, or it parses and holds no server named vexp in any letter case. A
+ * file that does not parse proves nothing: vexp's writer never edits it, so
+ * its own entry may still be there, and VS Code may still read it. The
+ * extension read such a file as "no vexp" and said "[OK] vexp for VS Code
+ * comes from .mcp.json" where the CLI warned that it is not valid JSON
+ * (review, 2026-11-07).
+ */
+export function vsCodeMcpLeavesVexpOut(file) {
+    if (!fs.existsSync(file))
+        return true;
+    let data;
+    try {
+        data = parseJsonc(fs.readFileSync(file, "utf-8"));
+    }
+    catch {
+        return false;
+    }
+    if (data === null)
+        return false;
+    const servers = typeof data === "object" ? asObject(data.servers) : undefined;
+    return !(servers && Object.keys(servers).some((k) => k.toLowerCase() === "vexp"));
+}
+/**
+ * D4's INFO condition (M2), lockstep with the extension doctor:
+ * .vscode/mcp.json parses and holds a server named vexp in any letter case,
+ * the one VS Code uses when the .mcp.json entry would not serve this root.
+ * Absent or not parsing proves nothing either way.
+ */
+export function vsCodeMcpHoldsVexp(file) {
+    if (!fs.existsSync(file))
+        return false;
+    let data;
+    try {
+        data = parseJsonc(fs.readFileSync(file, "utf-8"));
+    }
+    catch {
+        return false;
+    }
+    const servers = data !== null && typeof data === "object" ? asObject(data.servers) : undefined;
+    return !!servers && Object.keys(servers).some((k) => k.toLowerCase() === "vexp");
+}
+/** D4: .mcp.json defines vexp, and vexp left itself out of .vscode/mcp.json (W4). Word for word the extension's. */
+export const DOT_MCP_JSON_SERVES = "vexp for VS Code comes from .mcp.json";
+/**
+ * Is the local model switched on in vexp's config.toml (`[llm]` with
+ * `enabled = true`, or a top-level `llm.enabled = true`)? What
+ * LlmConfig::load_user_global reads; every daemon of this user starts with
+ * it, and each loads the model into its own memory. Lockstep with the
+ * extension's llmEnabledInConfig.
+ */
+export function llmEnabledInConfig(toml) {
+    let section = "";
+    for (const raw of toml.split(/\r?\n/)) {
+        const l = raw.replace(/#.*$/, "").trim();
+        const header = /^\[\s*([^\]]+?)\s*\]$/.exec(l);
+        if (header) {
+            section = header[1];
+            continue;
+        }
+        const kv = /^([A-Za-z0-9_.-]+)\s*=\s*(\S+)$/.exec(l);
+        if (!kv)
+            continue;
+        const key = section ? `${section}.${kv[1]}` : kv[1];
+        if (key === "llm.enabled")
+            return kv[2] === "true";
+    }
+    return false;
+}
+/**
+ * The registered daemon roots of the repository `root` belongs to: its main
+ * checkout and that checkout's linked worktrees (vexp-core's
+ * git_project_root collapse). Liveness is the caller's: the registry keeps
+ * rows of daemons that are gone. Lockstep with the extension's
+ * repositoryDaemonRoots.
+ */
+export function repositoryDaemonRoots(registryRoots, root, mainOf = linkedWorktreeMain) {
+    const repo = (dir) => mainOf(dir) ?? dir;
+    const ours = repo(root);
+    return registryRoots.filter((r) => sameFolderAsExtension(repo(r), ours));
+}
+/**
+ * D5: more than one live daemon of this repository while the local model is
+ * on. Only when the daemon serving here runs the model (`servedCompressor`
+ * "llm"): where DevMind stays off, or the daemon runs the rule compressor
+ * for any reason, no daemon holds a copy, and the line told of a cost that
+ * did not exist (review, 2026-11-08). Nor when the model is an [llm]
+ * endpoint's (`servedModel` "openai-compat:..."): the daemons share that one
+ * server and load nothing (final verify, 2026-11-08). Lockstep with the
+ * extension's llmDaemonsLine (packages/vexp-vscode/src/doctor-lines.ts).
+ */
+export function llmDaemonsFinding(live, servedCompressor, servedModel) {
+    if (live < 2 || servedCompressor !== "llm")
+        return null;
+    if (typeof servedModel === "string" && servedModel.startsWith("openai-compat:"))
+        return null;
+    return {
+        level: INFO,
+        message: `LLM compression: ${live} vexp daemons of this repository are running (its main checkout and git worktrees), and each loads its own copy of the model`,
+    };
+}
+/**
+ * What doctor says when LLM compression is on in the config and the daemon
+ * runs the rule compressor (`llm_configured_but_inactive`), from the
+ * daemon's own cause.
+ *
+ * DevMind off by policy (no GPU it can use, an Intel Mac, prefer_gpu =
+ * false, ...) is no fault: an INFO that counts as no warning and brings no
+ * restart tip, with the way out. It was a WARN saying "restarting will NOT
+ * change this - fix the cause above" to users with nothing to fix (field
+ * report, 2026-11-08: an hour spent on it). An endpoint that did not answer
+ * is a fault a restart does fix once the server is up. A build with no
+ * local model needs only the leftover setting turned off. Everything else
+ * keeps the advice it had. The INFO line is word for word the extension
+ * Doctor's (packages/vexp-vscode doctor-lines.ts); `devmindOff` reads the
+ * cause as packages/vexp-vscode/src/ui/llm-advice.ts does.
+ */
+export function llmCompressorFinding(st) {
+    if (!st || st.llm_configured_but_inactive !== true)
+        return null;
+    const off = devmindOff(st);
+    if (off)
+        return { level: INFO, message: devmindOffNote(off) };
+    const why = typeof st.llm_inactive_reason === "string" ? st.llm_inactive_reason : undefined;
+    const daemon = `\n        daemon: v${st.daemon_version ?? "?"} at ${st.workspace_root ?? "?"}`;
+    if (isEndpointUnreachable(why)) {
+        return {
+            level: WARN,
+            message: "the [llm] endpoint did not answer when this daemon started, so it runs the RULE compressor - results are not LLM-compressed." +
+                `\n        reason: ${why}` +
+                "\n        once that server answers, run 'vexp daemon-cmd restart'" +
+                daemon,
+        };
+    }
+    if (why !== undefined && /vanilla build/i.test(why)) {
+        return {
+            level: INFO,
+            message: "this build of vexp has no local LLM, and your config still switches it on, left from a build that had one: " +
+                "'vexp setup-llm --disable' turns that off. Everything else works the same, with the rule-based compressor.",
+        };
+    }
+    // The daemon knows WHY, and doctor was throwing it away: it printed the
+    // same "restart to load the model" the sidebar prints, to a user whose
+    // model fails on every start. Restarting is advice only when the cause
+    // can change between starts.
+    const restartIsPointless = why !== undefined &&
+        /vanilla build|model load failed|incomplete|did not survive|worker did not start|needs a GPU/i.test(why);
+    // A daemon still running its startup sync has not REACHED the model
+    // yet. Restarting there is worse than useless: it starts the sync over,
+    // and the user never arrives.
+    const stillStarting = why !== undefined && /still completing its startup/i.test(why);
+    return {
+        level: WARN,
+        message: `local LLM is installed and enabled in config but this daemon runs the RULE compressor — results are not LLM-compressed.` +
+            (why ? `\n        reason: ${why}` : "") +
+            (stillStarting
+                ? `\n        wait for the sync to finish — do NOT restart, that begins it again` +
+                    `\n        the daemon logs 'LlmWorker active' when the model is up`
+                : restartIsPointless
+                    ? `\n        restarting will NOT change this — fix the cause above`
+                    : `\n        run 'vexp daemon-cmd restart' to load the model`) +
+            daemon,
+    };
+}
 async function doctorChecks(onWorkspace) {
     const home = vexpHome();
     const regPath = path.join(home, ".vexp", "daemons.json");
@@ -3422,8 +4316,18 @@ async function doctorChecks(onWorkspace) {
     // No daemon, the extension and no `vexp` command: most often a project
     // that is simply not open in the IDE, which is no fault at all.
     let closedInIde = false;
-    if (live)
+    // index_status, asked once: the folder it serves is said here, the rest
+    // of its answer below.
+    const status = live ? await queryDaemon(sock, "index_status") : null;
+    if (live) {
         line(OK, `daemon socket reachable: ${sock}`);
+        // Which folder that daemon serves (D1): in a worktree, two file counts
+        // that did not match were the only clue that the main checkout's index
+        // answered. Lockstep with the extension's doctor.
+        const served = status ? servedRootFinding(status.workspace_root, ws.root) : null;
+        if (served)
+            emit(served);
+    }
     else {
         let startBlocked;
         try {
@@ -3439,7 +4343,7 @@ async function doctorChecks(onWorkspace) {
         const down = daemonDownFindings({
             sock,
             install,
-            hasIndex: fs.existsSync(path.join(ws.root, ".vexp", "index.db")),
+            startsOnOpen: extensionStartsOnOpen(ws.root),
             startBlocked,
             outside: what ? { root: ws.root, what } : undefined,
             idleExit,
@@ -3467,13 +4371,17 @@ async function doctorChecks(onWorkspace) {
     // probes below weigh their own failures against it.
     let hookPrompts7d = 0;
     if (live) {
-        const st = await queryDaemon(sock, "index_status");
+        const st = 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).
+            // Only where the config switches the LLM on: a daemon of 3.4.0
+            // with nothing configured no longer says "still loading", and one
+            // from before did, during every startup sync (review, 2026-11-08).
             const loading = st.compressor !== "llm"
+                && st.llm_configured_but_inactive === true
                 && typeof st.llm_inactive_reason === "string"
                 && /still loading|finishing its startup/i.test(st.llm_inactive_reason);
             const comp = st.compressor === "llm"
@@ -3485,28 +4393,10 @@ async function doctorChecks(onWorkspace) {
             const idleStop = idleStopFinding(st.idle_stop);
             if (idleStop)
                 emit(idleStop);
-            if (st.llm_configured_but_inactive === true) {
-                // The daemon knows WHY, and doctor was throwing it away: it printed
-                // the same "restart to load the model" the sidebar prints, to a user
-                // whose model fails on every start. Restarting is advice only when
-                // the cause can change between starts.
-                const why = typeof st.llm_inactive_reason === "string" ? st.llm_inactive_reason : undefined;
-                const restartIsPointless = why !== undefined &&
-                    /vanilla build|model load failed|incomplete|did not survive|worker did not start/i.test(why);
-                // A daemon still running its startup sync has not REACHED the model
-                // yet. Restarting there is worse than useless: it starts the sync
-                // over, and the user never arrives.
-                const stillStarting = why !== undefined && /still completing its startup/i.test(why);
-                line(WARN, `local LLM is installed and enabled in config but this daemon runs the RULE compressor — results are not LLM-compressed.` +
-                    (why ? `\n        reason: ${why}` : "") +
-                    (stillStarting
-                        ? `\n        wait for the sync to finish — do NOT restart, that begins it again` +
-                            `\n        the daemon logs 'LlmWorker active' when the model is up`
-                        : restartIsPointless
-                            ? `\n        restarting will NOT change this — fix the cause above`
-                            : `\n        run 'vexp daemon-cmd restart' to load the model`) +
-                    `\n        daemon: v${st.daemon_version ?? "?"} at ${st.workspace_root ?? "?"}`);
-            }
+            // Why the config's LLM is not what the daemon runs (see llmCompressorFinding).
+            const llm = llmCompressorFinding(st);
+            if (llm)
+                emit(llm);
             // 2.4.0 upgrade guard (CLI side): a daemon surviving an upgrade keeps
             // serving the OLD feature set and its gaps read as product bugs
             // (field case: pre-ledger daemon after the 2.4.0 install). The VS Code
@@ -3569,6 +4459,35 @@ async function doctorChecks(onWorkspace) {
                 emit(f);
         }
     }
+    // A linked worktree with no answers of its own uses its main checkout's
+    // (D3): said, so an agent set up in a worktree that was never asked is no
+    // mystery. Lockstep with the extension's doctor.
+    {
+        let inherited;
+        try {
+            inherited = inheritedAnswers(readAgentConsent(), ws.root);
+        }
+        catch { /* unreadable answers: said in their own section */ }
+        if (inherited)
+            emit(inheritedAnswersFinding(inherited.main));
+    }
+    // The local model is per daemon (D5): the main checkout and each of its
+    // worktrees with a daemon load one copy each, when the daemon here runs
+    // it. Lockstep with the extension.
+    {
+        let toml = "";
+        try {
+            toml = fs.readFileSync(configTomlPath(), "utf-8");
+        }
+        catch { /* no config: the model is off */ }
+        if (llmEnabledInConfig(toml) && status?.compressor === "llm") {
+            const roots = repositoryDaemonRoots(Object.keys(registry), ws.root);
+            const alive = (await Promise.all(roots.map((r) => (typeof registry[r] === "string" ? reachable(registry[r]) : Promise.resolve(false))))).filter(Boolean).length;
+            const many = llmDaemonsFinding(alive, status.compressor, status.llm_model);
+            if (many)
+                emit(many);
+        }
+    }
     // Where the agent hooks ran from, as the hook client recorded it: read from
     // disk, so it speaks also when no daemon answers here, which is exactly
     // when an agent with the parent folder open leaves its only trace.
@@ -3857,22 +4776,57 @@ async function doctorChecks(onWorkspace) {
     console.log(chalk.bold("\nGitHub Copilot / VS Code (.vscode/mcp.json)"));
     {
         const mcpPath = path.join(ws.root, ".vscode", "mcp.json");
-        if (!fs.existsSync(mcpPath)) {
-            line(OK, "no .vscode/mcp.json (Copilot MCP not configured in this folder — 'vexp setup --agents \"GitHub Copilot\"' writes it)");
-        }
-        else {
-            let cfg = null;
+        const link = projectFileLink(mcpPath, ws.root);
+        // <root>/.mcp.json defines vexp and .vscode/mcp.json holds none: setup
+        // left vexp out of it on purpose (W4), and VS Code takes vexp from
+        // .mcp.json (D4). "no vexp server - run setup" sent the user to a
+        // setup that leaves it out again.
+        let cfg = null;
+        const present = fs.existsSync(mcpPath);
+        if (present) {
             try {
                 cfg = parseJsonc(fs.readFileSync(mcpPath, "utf-8"));
             }
             catch {
                 cfg = null;
             }
-            const v = vsCodeMcpVerdict(cfg, ws.root);
+        }
+        // Only a .mcp.json entry that would serve this root from VS Code is where
+        // VS Code takes vexp from (M2, the writer's dotMcpJsonMiss); one pinned to
+        // another folder, or whose command does not start here, gets vexp's own
+        // entry in .vscode/mcp.json instead, said as INFO below.
+        const dotMcp = projectMcpJsonVexp(ws.root);
+        const dotMiss = dotMcp ? dotMcpJsonMiss(dotMcp.entry, ws.root) : undefined;
+        const fromDotMcp = dotMcp !== undefined && dotMiss === undefined && vsCodeMcpLeavesVexpOut(mcpPath);
+        if (fromDotMcp) {
+            line(OK, DOT_MCP_JSON_SERVES);
+        }
+        else if (!present) {
+            line(OK, vsCodeMcpAbsentLine(link));
+        }
+        else {
+            const v = vsCodeMcpVerdict(cfg, ws.root, undefined, link);
             line(v.level, v.message);
             console.log(chalk.dim("        VS Code shows it under Extensions → MCP SERVERS - INSTALLED; vexp tools appear only in Copilot Chat AGENT mode (tools picker → 'MCP Server: vexp')."));
             console.log(chalk.dim("        server log: Command Palette → 'MCP: List Servers' → vexp → Show Output (channel 'MCP: vexp'); daemon log: .vexp/daemon.log"));
         }
+        // A file agents read here that pins vexp to another checkout (D2), and a
+        // worktree's vexp-only .vscode/mcp.json beside a main checkout whose
+        // untracked copy holds other servers (D4, W5). Lockstep with the
+        // extension's doctor.
+        for (const f of pinnedElsewhereFindings([
+            { file: path.join(ws.root, ".mcp.json"), key: "mcpServers" },
+            { file: mcpPath, key: "servers" },
+        ], ws.root))
+            emit(f);
+        // M2: .mcp.json defines vexp but would not serve this root from VS Code,
+        // so the entry in .vscode/mcp.json is the one VS Code uses: said after
+        // D2, in the extension doctor's order.
+        if (dotMiss && vsCodeMcpHoldsVexp(mcpPath))
+            emit({ level: INFO, message: dotMcpJsonKeptLine(ws.root, dotMiss) });
+        const missing = worktreeMcpJsonNote(ws.root, mcpPath);
+        if (missing)
+            emit({ level: INFO, message: missing });
     }
     // 5a-bis) WSL: agents on the Windows side read Windows-side configs, which
     // nothing running in WSL can see or write. Say so, and for Windsurf hand
@@ -4053,21 +5007,10 @@ async function doctorChecks(onWorkspace) {
             const v = String(r.stdout ?? "").trim();
             return r.status === 0 && v ? v : null;
         })();
-        const ours = path.join(ws.root, ".git", "hooks");
-        const installed = ["pre-commit", "post-merge", "post-checkout"].filter((h) => {
-            try {
-                return fs.readFileSync(path.join(ours, h), "utf-8").includes("vexp");
-            }
-            catch {
-                return false;
-            }
-        });
-        let declined;
-        try {
-            declined = fs.readFileSync(path.join(ws.root, ".vexp", "git-hooks.declined"), "utf-8").split(/\r?\n/)[0];
-        }
-        catch { /* not declined */ }
-        const verdict = gitHooksVerdict(hooksPath, ws.root, installed.length, declined);
+        // Where .git is a file (a linked worktree, a submodule, a separate git
+        // dir) the hooks folder is the one git resolves (gitHooksFinding); a
+        // normal checkout reads .git/hooks as before.
+        const verdict = gitHooksFinding(ws.root, hooksPath);
         line(verdict.level, verdict.message);
     }
     console.log(chalk.bold("\nClaude Code orientation hooks (.claude/settings.json)"));
@@ -4386,6 +5329,12 @@ async function doctorChecks(onWorkspace) {
             zcodeHomeExists: fs.existsSync(path.join(home, ".zcode")),
             consent: decisionFor(readAgentConsent(), ws.root, "ZCode"),
         };
+        // The file setup writes, and the link that stops it, if any: its
+        // remedies then name the link (ZcodeInput.projectLink).
+        const zcodeTarget = zcodeMcpTarget(ws.root);
+        const zcodeLink = projectFileLink(zcodeTarget, ws.root);
+        if (zcodeLink)
+            input.projectLink = { file: zcodeTarget, link: zcodeLink };
         const inUse = zcodeInUse(input);
         const spec = inUse ? zcodeProbeSpec(input) : null;
         if (spec) {
@@ -4416,6 +5365,36 @@ async function doctorChecks(onWorkspace) {
         // Never the reason doctor stops: the sections below still run.
         line(INFO, `ZCode: not checked (${e?.message ?? String(e)})`);
     }
+    // 5b-quater) Antigravity. Setup wrote an entry no current Antigravity
+    // reads, and no doctor looked at it (field report, 2026-11-07). Every
+    // decision is in antigravityFindings; this block only reads.
+    console.log(chalk.bold("\nAntigravity (.agents/mcp_config.json, ~/.gemini/config/mcp_config.json)"));
+    try {
+        const exists = (p) => fs.existsSync(p);
+        const home = os.homedir();
+        const input = {
+            root: ws.root,
+            platform: process.platform,
+            ...readAntigravityFiles(ws.root, home),
+            // As planAgentSetup reads them: the project's files set Antigravity up
+            // only where the machine shows it.
+            marker: (exists(path.join(ws.root, "GEMINI.md")) || exists(path.join(ws.root, ".agent"))) && antigravityOnThisMachine(),
+            consent: decisionFor(readAgentConsent(), ws.root, "Antigravity"),
+            exists,
+            remedy: setupAgentsRemedy(install, ["Antigravity"], ws.root),
+            version: CLI_VERSION,
+            tracked: gitTrackedPath(ws.root),
+            globalCleaned: vexpCleansAntigravityFile(home, antigravityGlobalMcpPath(home)),
+            migrated: exists(path.join(home, ".gemini", "config", ".migrated")),
+            projectLink: projectFileLink(path.join(ws.root, ".agents", "mcp_config.json"), ws.root),
+        };
+        for (const f of antigravityFindings(input))
+            emit(f);
+    }
+    catch (e) {
+        // Never the reason doctor stops: the sections below still run.
+        line(INFO, `Antigravity: not checked (${e?.message ?? String(e)})`);
+    }
     // 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