vexp-cli 2.6.3 → 3.0.1

package/dist/agent-config.js

@@ -10,7 +10,7 @@ import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
 import * as crypto from "crypto";
-import { VEXP_GUARD_HOOK, VEXP_OPENCODE_GUARD, VEXP_CURSOR_GUARD, vexpHintHookScript, vexpStopGateHookScript, vexpSessionContextHookScript, vexpOpencodeHintPlugin } from "./hook-template.js";
+import { VEXP_GUARD_HOOK, VEXP_OPENCODE_GUARD, VEXP_CURSOR_GUARD, vexpHintHookScript, vexpSearchHookScript, vexpHintHookCmdScript, vexpStopGateHookScript, vexpSessionContextHookScript, vexpOpencodeHintPlugin, vexpOpencodeCompressPlugin, bakeEditHintHook, bakeReadHintHook, bakeBashCapHook } from "./hook-template.js";
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -102,6 +102,13 @@ export function setGuardMode(mode) {
 export function guardMode() {
     return activeGuardMode;
 }
+let activeInterventionMode = "off";
+export function setInterventionMode(mode) {
+    activeInterventionMode = mode;
+}
+export function interventionMode() {
+    return activeInterventionMode;
+}
 // ---------------------------------------------------------------------------
 // Agent detectors - mirrors VS Code extension's AGENT_DETECTORS
 // ---------------------------------------------------------------------------
@@ -123,7 +130,7 @@ const AGENT_DETECTORS = [
     {
         agent: "Windsurf",
         detectPath: ".windsurf",
-        configFile: ".windsurf/rules.md",
+        configFile: ".windsurf/rules/vexp.md",
         templateName: "windsurf",
         mcpConfigFile: ".windsurf/mcp.json",
     },
@@ -244,7 +251,7 @@ const AGENT_DETECTORS = [
  * true but badly incomplete story. Kept next to the installers, with a
  * lockstep test asserting every detector has an entry.
  */
-export function plannedWrites(agent, guard = guardMode()) {
+export function plannedWrites(agent, guard = guardMode(), interventions = interventionMode()) {
     const det = AGENT_DETECTORS.find((d) => d.agent === agent);
     if (!det)
         return [];
@@ -255,8 +262,11 @@ export function plannedWrites(agent, guard = guardMode()) {
         case "Claude Code":
             out.push("~/.claude.json  (MCP server entry, user scope)");
             out.push(".claude/hooks/vexp-hint.sh + settings.json hooks.UserPromptSubmit  (orientation)");
-            out.push(".claude/hooks/vexp-verify.sh + settings.json hooks.Stop  (verification gate)");
             out.push(".claude/hooks/vexp-restore.sh + settings.json hooks.SessionStart  (context restore)");
+            if (interventions === "on") {
+                out.push(".claude/hooks/vexp-verify.sh + settings.json hooks.Stop  (verification gate, opt-in)");
+                out.push(".claude/hooks/vexp-edit-hint.sh + settings.json hooks.PostToolUse  (coupling, opt-in)");
+            }
             if (guard === "strict") {
                 out.push(".claude/hooks/vexp-guard.sh + settings.json hooks.PreToolUse  (guard, opt-in)");
             }
@@ -334,6 +344,14 @@ export function configureAgents(workspaceRoot, binaryPath, version, agentFilter,
     for (const detector of agents) {
         const configFilePath = path.join(workspaceRoot, detector.configFile);
         const alreadyExists = fs.existsSync(configFilePath);
+        // Sweep the location we used to write to. For several releases the
+        // Windsurf rules went to `.windsurf/rules.md`, which Cascade does not
+        // read: its rules are `.windsurf/rules/*.md`, `.devin/rules/*.md`, or the
+        // legacy root `.windsurfrules`. Upgrading users would otherwise keep a
+        // stale, unread copy of our instructions beside the live one.
+        if (detector.agent === "Windsurf") {
+            removeVexpSection(path.join(workspaceRoot, ".windsurf", "rules.md"));
+        }
         const content = generateAgentConfig(detector.templateName, {
             workspaceRoot,
             binaryPath,
@@ -403,6 +421,16 @@ export function configureAgents(workspaceRoot, binaryPath, version, agentFilter,
             // Event-driven hint hook: default-on (non-blocking, fail-open — the
             // 2.3 A2 opt-in applies to DENY hooks, this one cannot block).
             const hintResult = installClaudeCodeHintHook(workspaceRoot, binaryPath);
+            installClaudeCodeSearchHook(workspaceRoot, binaryPath);
+            // Both doors. Bounding either alone measured as no change at all: the
+            // work simply moves to the other one.
+            if (interventionMode() === "on") {
+                installClaudeCodeReadHint(workspaceRoot, binaryPath);
+                installClaudeCodeBashCap(workspaceRoot, binaryPath);
+            }
+            else {
+                removeClaudeCodePreToolHooks(workspaceRoot);
+            }
             installClaudeCodeStopGate(workspaceRoot, binaryPath);
             installClaudeCodeSessionContext(workspaceRoot, binaryPath);
             if (hintResult) {
@@ -472,6 +500,7 @@ export function configureAgents(workspaceRoot, binaryPath, version, agentFilter,
             if (wrote)
                 mcpConfigs.push(wrote);
             installOpencodeHintPlugin(workspaceRoot, binaryPath, ".kilo/plugin");
+            installOpencodeCompressPlugin(workspaceRoot, binaryPath, ".kilo/plugin");
             // Kilo v7 vendors opencode, so it takes the same guard plugin — the rules
             // markdown alone was demonstrably not enough (a reported session loaded
             // vexp.md, quoted it back, and still read five files by hand).
@@ -525,6 +554,18 @@ export function configureAgents(workspaceRoot, binaryPath, version, agentFilter,
                     action: "removed",
                 });
             }
+            // v5: the coupling on edit. Default-ON and independent of the guard —
+            // it blocks nothing, so there is no reason to make it opt-in.
+            const edit = installCursorEditHint(workspaceRoot, binaryPath);
+            if (edit) {
+                results.push({
+                    agent: "Cursor Edit Hint",
+                    configFile: path.join(".cursor", "hooks", "vexp-edit-hint.sh"),
+                    content: "",
+                    alreadyExists: edit === "updated",
+                    action: edit,
+                });
+            }
         }
         // Cline: rules in .clinerules (generic template, handled by the writer
         // above); MCP registry is machine-global VS Code storage.
@@ -544,6 +585,7 @@ export function configureAgents(workspaceRoot, binaryPath, version, agentFilter,
         if (detector.agent === "Opencode") {
             const wroteMcp = configureOpencodeMcp(workspaceRoot, binaryPath, mcpServerPath);
             installOpencodeHintPlugin(workspaceRoot, binaryPath, ".opencode/plugin");
+            installOpencodeCompressPlugin(workspaceRoot, binaryPath, ".opencode/plugin");
             if (wroteMcp)
                 mcpConfigs.push(wroteMcp);
             if (guardMode() === "strict") {
@@ -673,6 +715,11 @@ export function configureSelectedAgents(workspaceRoot, binaryPath, version, sele
                 fs.mkdirSync(mcpDir, { recursive: true });
             }
         }
+        // Same sweep as the other writer: the Windsurf rules moved out of
+        // `.windsurf/rules.md`, which Cascade never read.
+        if (detector.agent === "Windsurf") {
+            removeVexpSection(path.join(workspaceRoot, ".windsurf", "rules.md"));
+        }
         const alreadyExists = fs.existsSync(configFilePath);
         const content = generateAgentConfig(detector.templateName, {
             workspaceRoot,
@@ -720,6 +767,13 @@ export function configureSelectedAgents(workspaceRoot, binaryPath, version, sele
             if (wrote)
                 mcpConfigs.push("~/.claude.json");
             installClaudeCodeHintHook(workspaceRoot, binaryPath);
+            if (interventionMode() === "on") {
+                installClaudeCodeReadHint(workspaceRoot, binaryPath);
+                installClaudeCodeBashCap(workspaceRoot, binaryPath);
+            }
+            else {
+                removeClaudeCodePreToolHooks(workspaceRoot);
+            }
             installClaudeCodeStopGate(workspaceRoot, binaryPath);
             installClaudeCodeSessionContext(workspaceRoot, binaryPath);
             if (guardMode() === "strict")
@@ -760,12 +814,17 @@ export function configureSelectedAgents(workspaceRoot, binaryPath, version, sele
             if (wrote)
                 mcpConfigs.push(wrote);
             installOpencodeHintPlugin(workspaceRoot, binaryPath, ".opencode/plugin");
+            installOpencodeCompressPlugin(workspaceRoot, binaryPath, ".opencode/plugin");
             if (guardMode() === "strict")
                 installOpencodePlugin(workspaceRoot);
             else
                 uninstallOpencodePlugin(workspaceRoot);
         }
         if (detector.agent === "Cursor") {
+            if (interventionMode() === "on") {
+                installCursorReadHint(workspaceRoot, binaryPath);
+                installCursorBashCap(workspaceRoot, binaryPath);
+            }
             if (guardMode() === "strict")
                 installCursorHook(workspaceRoot);
             else
@@ -780,6 +839,7 @@ export function configureSelectedAgents(workspaceRoot, binaryPath, version, sele
             if (wrote)
                 mcpConfigs.push(wrote);
             installOpencodeHintPlugin(workspaceRoot, binaryPath, ".kilo/plugin");
+            installOpencodeCompressPlugin(workspaceRoot, binaryPath, ".kilo/plugin");
             if (guardMode() === "strict")
                 installKiloPlugin(workspaceRoot);
             else
@@ -1009,13 +1069,68 @@ function warnUnparseable(filePath) {
     }
     process.stderr.write(`  [!] ${filePath} could not be parsed - leaving it untouched. Fix the file or add vexp manually, then re-run setup.\n`);
 }
+/**
+ * Remove a vexp section from a file we no longer write to, and delete the file
+ * when nothing of the user's is left in it.
+ *
+ * Needed because vexp wrote its Windsurf rules to `.windsurf/rules.md` for
+ * several releases. Cascade reads `.windsurf/rules/*.md` (a directory),
+ * `.devin/rules/*.md`, or the legacy root `.windsurfrules` — never that path.
+ * Leaving the old file behind would put a stale, unread copy of our
+ * instructions next to the live one.
+ */
+export function removeVexpSection(filePath) {
+    if (!fs.existsSync(filePath))
+        return "absent";
+    let existing;
+    try {
+        existing = fs.readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return "absent";
+    }
+    const marker = existing.match(VEXP_MARKER_RE);
+    const endIdx = existing.indexOf(VEXP_MARKER_END);
+    if (!marker || endIdx === -1)
+        return "absent";
+    const markerIdx = existing.indexOf(marker[0]);
+    let startIdx = markerIdx;
+    while (startIdx > 0 && existing[startIdx - 1] !== "\n")
+        startIdx--;
+    const rest = (existing.slice(0, startIdx) + existing.slice(endIdx + VEXP_MARKER_END.length)).trim();
+    if (rest === "") {
+        try {
+            fs.unlinkSync(filePath);
+            return "deleted";
+        }
+        catch {
+            return "absent";
+        }
+    }
+    try {
+        fs.writeFileSync(filePath, rest + "\n", "utf-8");
+        return "stripped";
+    }
+    catch {
+        return "absent";
+    }
+}
 function appendOrCreate(filePath, content, version) {
     if (!fs.existsSync(filePath)) {
         fs.mkdirSync(path.dirname(filePath), { recursive: true });
         fs.writeFileSync(filePath, content, "utf-8");
         return "created";
     }
-    const existing = fs.readFileSync(filePath, "utf-8");
+    let existing = fs.readFileSync(filePath, "utf-8");
+    // Front matter has to stay the FIRST thing in the file, and the splice below
+    // preserves whatever sits above our marker — so a rewrite would leave the
+    // old block above and insert a second one. One rule file, one front matter.
+    if (content.startsWith("---\n")) {
+        const lead = existing.match(/^---\n[\s\S]*?\n---\n/);
+        if (lead) {
+            existing = existing.slice(lead[0].length).replace(/^\s*\n/, "");
+        }
+    }
     const markerMatch = existing.match(VEXP_MARKER_RE);
     if (!markerMatch) {
         fs.appendFileSync(filePath, "\n\n" + content);
@@ -1289,7 +1404,15 @@ function buildCodexSection(opts) {
     const wsHash = opts.workspaceRoot ? workspaceHash(opts.workspaceRoot) : "";
     const urlPath = wsHash ? `/ws/${wsHash}/mcp` : "/mcp";
     const desiredUrl = `http://127.0.0.1:${opts.mcpPort}${urlPath}`;
-    return `\n[mcp_servers.vexp]\n${CODEX_MANAGED_MARKER}: http transport (set VEXP_CODEX_TRANSPORT=direct for stdio)\nurl = "${desiredUrl}"\ntool_timeout_sec = 120\n\n[mcp_servers.vexp.http_headers]\nAuthorization = "Bearer ${opts.token}"\n`;
+    return `
+[mcp_servers.vexp]
+${CODEX_MANAGED_MARKER}: http transport (set VEXP_CODEX_TRANSPORT=direct for stdio)
+url = "${desiredUrl}"
+tool_timeout_sec = 120
+
+[mcp_servers.vexp.http_headers]
+Authorization = "Bearer ${opts.token}"
+`;
 }
 /**
  * Configure MCP in ~/.codex/config.toml (global).
@@ -1964,11 +2087,27 @@ export function installClaudeCodeStopGate(workspaceRoot, binaryPath) {
     const hookPath = path.join(hookDir, "vexp-verify.sh");
     const settingsPath = path.join(workspaceRoot, ".claude", "settings.json");
     fs.mkdirSync(hookDir, { recursive: true });
-    const script = vexpStopGateHookScript(binaryPath);
+    // Opt-in since the measurement: the gate bought 15 to 32 extra turns per 13
+    // bench sessions, and they land at the END of a session where the
+    // transcript is heaviest, so one of them costs more than a session's entire
+    // tool output. See InterventionMode above. When off, a previously installed
+    // gate is removed and de-registered so upgrades converge.
+    const gateOn = interventionMode() === "on";
     const existed = fs.existsSync(hookPath);
-    const scriptIdentical = existed && fs.readFileSync(hookPath, "utf8") === script;
-    if (!scriptIdentical) {
-        fs.writeFileSync(hookPath, script, { mode: 0o755 });
+    const script = vexpStopGateHookScript(binaryPath);
+    const scriptIdentical = gateOn && existed && fs.readFileSync(hookPath, "utf8") === script;
+    if (gateOn) {
+        if (!scriptIdentical) {
+            fs.writeFileSync(hookPath, script, { mode: 0o755 });
+        }
+    }
+    else if (existed) {
+        try {
+            fs.unlinkSync(hookPath);
+        }
+        catch {
+            /* a hook we cannot remove is still de-registered below */
+        }
     }
     const read = readJsonConfigSafe(settingsPath);
     if (!read.ok) {
@@ -1980,16 +2119,20 @@ export function installClaudeCodeStopGate(workspaceRoot, binaryPath) {
     const existing = Array.isArray(hooks.Stop) ? hooks.Stop : [];
     const filtered = existing.filter((h) => !isVexpHookEntry(h, "vexp-verify"));
     // Cross-OS shape as everywhere: bash + QUOTED path; timeout in SECONDS.
-    filtered.push({
-        hooks: [
-            {
-                type: "command",
-                command: 'bash "$CLAUDE_PROJECT_DIR/.claude/hooks/vexp-verify.sh"',
-                timeout: 15,
-            },
-        ],
-    });
+    if (gateOn) {
+        filtered.push({
+            hooks: [
+                {
+                    type: "command",
+                    command: 'bash "$CLAUDE_PROJECT_DIR/.claude/hooks/vexp-verify.sh"',
+                    timeout: 15,
+                },
+            ],
+        });
+    }
     const merged = { ...hooks, Stop: filtered };
+    if (filtered.length === 0)
+        delete merged.Stop;
     const settingsIdentical = JSON.stringify(merged) === JSON.stringify(settings.hooks ?? {});
     if (scriptIdentical && settingsIdentical)
         return null;
@@ -2001,6 +2144,10 @@ export function installClaudeCodeStopGate(workspaceRoot, binaryPath) {
     }
     return existed ? "updated" : "created";
 }
+function isVexpEditHintHookEntry(entry) {
+    const cmds = JSON.stringify(entry ?? "");
+    return cmds.includes("vexp-edit-hint");
+}
 function isVexpHintHookEntry(h) {
     if (!h || typeof h !== "object")
         return false;
@@ -2026,12 +2173,196 @@ function isVexpHintHookEntry(h) {
  * opt-in applies to DENY hooks, which add a failure mode; this one cannot
  * block anything).
  */
+/** Does this PreToolUse entry belong to us? */
+function isVexpSearchHookEntry(h) {
+    if (!h || typeof h !== "object")
+        return false;
+    const hks = h.hooks;
+    return Array.isArray(hks) && hks.some((hook) => typeof hook?.command === "string" &&
+        hook.command.includes("vexp-search"));
+}
+/**
+ * v4 M1: install the search answer as a PreToolUse hook on Bash.
+ *
+ * Matcher is Bash and nothing else. The hook rewrites only a recursive grep
+ * for names this index defines, keeps the original command after a `||`, and
+ * prints nothing at all in every other case — so a session where vexp has no
+ * opinion is byte-for-byte a session without vexp.
+ *
+ * Why a hook rather than a tool: 9 of 227 measured agent sessions called the
+ * MCP tools. All 227 called Bash.
+ */
+/**
+ * Install one of the compression hooks into Claude Code's PreToolUse.
+ *
+ * Shared because the two are one mechanism seen from two sides. Bounding reads
+ * alone did nothing measurable: Read-tool tokens fell 54% and shell output rose
+ * 39%, and the total sat inside the band between two identical stock runs. An
+ * agent takes what it needs through whichever door is open.
+ */
+/**
+ * Undo the two compression hooks, so a workspace configured by an older
+ * version converges on the next setup instead of quietly keeping a default
+ * that was measured and withdrawn.
+ *
+ * Same contract as the guard's removal: take the files out AND de-register
+ * them. A hook left in settings.json pointing at a script that no longer
+ * exists is worse than either state on its own — Claude Code runs it, it
+ * fails, and every Read or Bash call carries the failure.
+ */
+function removeClaudeCodePreToolHooks(workspaceRoot) {
+    const hookDir = path.join(workspaceRoot, ".claude", "hooks");
+    for (const name of ["read-hint", "bash-cap"]) {
+        const p = path.join(hookDir, `vexp-${name}.sh`);
+        if (fs.existsSync(p)) {
+            try {
+                fs.unlinkSync(p);
+            }
+            catch {
+                /* still de-registered below */
+            }
+        }
+    }
+    const settingsPath = path.join(workspaceRoot, ".claude", "settings.json");
+    const read = readJsonConfigSafe(settingsPath);
+    if (!read.ok || !read.existed)
+        return;
+    const settings = read.data;
+    const hooks = (settings.hooks ?? {});
+    const existing = Array.isArray(hooks.PreToolUse) ? hooks.PreToolUse : [];
+    const filtered = existing.filter((h) => !/vexp-(read-hint|bash-cap)/.test(JSON.stringify(h)));
+    if (filtered.length === existing.length)
+        return;
+    const merged = { ...hooks, PreToolUse: filtered };
+    if (filtered.length === 0)
+        delete merged.PreToolUse;
+    settings.hooks = merged;
+    backupConfig(settingsPath);
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+}
+function installClaudeCodePreToolHook(workspaceRoot, binaryPath, name, matcher, script) {
+    const hookDir = path.join(workspaceRoot, ".claude", "hooks");
+    const hookPath = path.join(hookDir, `vexp-${name}.sh`);
+    const settingsPath = path.join(workspaceRoot, ".claude", "settings.json");
+    fs.mkdirSync(hookDir, { recursive: true });
+    const existed = fs.existsSync(hookPath);
+    const scriptIdentical = existed && fs.readFileSync(hookPath, "utf-8") === script;
+    if (!scriptIdentical)
+        fs.writeFileSync(hookPath, script, { mode: 0o755 });
+    const read = readJsonConfigSafe(settingsPath);
+    if (!read.ok) {
+        warnUnparseable(settingsPath);
+        return scriptIdentical ? null : existed ? "updated" : "created";
+    }
+    const settings = read.data;
+    const hooks = (settings.hooks ?? {});
+    const existing = Array.isArray(hooks.PreToolUse) ? hooks.PreToolUse : [];
+    const filtered = existing.filter((h) => !JSON.stringify(h).includes(`vexp-${name}`));
+    // Shell form with a quoted path: exec form cannot run a .sh on Windows, and
+    // an unquoted path word-splits on "C:\\Program Files" (c4a0b9e).
+    filtered.push({
+        matcher,
+        hooks: [
+            {
+                type: "command",
+                command: `bash "$CLAUDE_PROJECT_DIR/.claude/hooks/vexp-${name}.sh"`,
+                timeout: 10,
+            },
+        ],
+    });
+    const merged = { ...hooks, PreToolUse: filtered };
+    const settingsIdentical = JSON.stringify(merged) === JSON.stringify(settings.hooks ?? {});
+    if (scriptIdentical && settingsIdentical)
+        return null;
+    settings.hooks = merged;
+    fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    return existed ? "updated" : "created";
+}
+export function installClaudeCodeReadHint(workspaceRoot, binaryPath) {
+    return installClaudeCodePreToolHook(workspaceRoot, binaryPath, "read-hint", "Read", bakeReadHintHook(binaryPath));
+}
+export function installClaudeCodeBashCap(workspaceRoot, binaryPath) {
+    return installClaudeCodePreToolHook(workspaceRoot, binaryPath, "bash-cap", "Bash", bakeBashCapHook(binaryPath));
+}
+export function installClaudeCodeSearchHook(workspaceRoot, binaryPath) {
+    const hookDir = path.join(workspaceRoot, ".claude", "hooks");
+    const hookPath = path.join(hookDir, "vexp-search.sh");
+    const settingsPath = path.join(workspaceRoot, ".claude", "settings.json");
+    const script = vexpSearchHookScript(binaryPath);
+    fs.mkdirSync(hookDir, { recursive: true });
+    const existed = fs.existsSync(hookPath);
+    const scriptIdentical = existed && fs.readFileSync(hookPath, "utf-8") === script;
+    if (!scriptIdentical)
+        fs.writeFileSync(hookPath, script, { mode: 0o755 });
+    const read = readJsonConfigSafe(settingsPath);
+    if (!read.ok) {
+        warnUnparseable(settingsPath);
+        return scriptIdentical ? null : existed ? "updated" : "created";
+    }
+    const settings = read.data;
+    const hooks = (settings.hooks ?? {});
+    const existing = Array.isArray(hooks.PreToolUse) ? hooks.PreToolUse : [];
+    const filtered = existing.filter((h) => !isVexpSearchHookEntry(h));
+    // Same shell-form-with-quoted-path shape as every other hook we write: exec
+    // form cannot run a .sh on Windows, and an unquoted path word-splits on
+    // "C:\Program Files" (both learned the hard way, c4a0b9e).
+    filtered.push({
+        matcher: "Bash",
+        hooks: [
+            {
+                type: "command",
+                command: 'bash "$CLAUDE_PROJECT_DIR/.claude/hooks/vexp-search.sh"',
+                timeout: 10,
+            },
+        ],
+    });
+    const merged = { ...hooks, PreToolUse: filtered };
+    const settingsIdentical = JSON.stringify(merged) === JSON.stringify(settings.hooks ?? {});
+    if (scriptIdentical && settingsIdentical)
+        return null;
+    settings.hooks = merged;
+    if (!settingsIdentical) {
+        if (read.existed)
+            backupConfig(settingsPath);
+        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    }
+    return existed ? "updated" : "created";
+}
 export function installClaudeCodeHintHook(workspaceRoot, binaryPath) {
     const hookDir = path.join(workspaceRoot, ".claude", "hooks");
     const hookPath = path.join(hookDir, "vexp-hint.sh");
     const settingsPath = path.join(workspaceRoot, ".claude", "settings.json");
     const script = vexpHintHookScript(binaryPath);
     fs.mkdirSync(hookDir, { recursive: true });
+    // v5: the edit-time coupling hook, written beside the prompt-time one -
+    // but only when interventions are on. It is one of the two mechanisms that
+    // ask the agent to go do something, and a turn costs 65,521 tokens. See
+    // InterventionMode above for the measurement.
+    const editHookPath = path.join(hookDir, "vexp-edit-hint.sh");
+    const couplingOn = interventionMode() === "on";
+    if (couplingOn) {
+        const editScript = bakeEditHintHook(binaryPath);
+        const editExisted = fs.existsSync(editHookPath);
+        if (!editExisted || fs.readFileSync(editHookPath, "utf-8") !== editScript) {
+            fs.writeFileSync(editHookPath, editScript, { mode: 0o755 });
+        }
+        try {
+            fs.chmodSync(editHookPath, 0o755);
+        }
+        catch {
+            /* Windows has no exec bit; Git Bash runs it anyway. */
+        }
+    }
+    else if (fs.existsSync(editHookPath)) {
+        // Converge an upgraded workspace without asking anyone to clean up.
+        try {
+            fs.unlinkSync(editHookPath);
+        }
+        catch {
+            /* a hook we cannot remove is still de-registered below */
+        }
+    }
     const existed = fs.existsSync(hookPath);
     const scriptIdentical = existed && fs.readFileSync(hookPath, "utf-8") === script;
     if (!scriptIdentical) {
@@ -2059,7 +2390,35 @@ export function installClaudeCodeHintHook(workspaceRoot, binaryPath) {
             },
         ],
     });
-    const merged = { ...hooks, UserPromptSubmit: filtered };
+    // v5: the coupling on the edit that needs it. PostToolUse rather than
+    // PreToolUse because a deny on an edit stops real work, and this must never
+    // block — it adds no turn and no permission decision, only a line the model
+    // reads as a system-reminder.
+    const existingPost = Array.isArray(hooks.PostToolUse)
+        ? hooks.PostToolUse
+        : [];
+    const filteredPost = existingPost.filter((h) => !isVexpEditHintHookEntry(h));
+    if (couplingOn) {
+        filteredPost.push({
+            matcher: "Edit|Write|NotebookEdit",
+            hooks: [
+                {
+                    type: "command",
+                    command: 'bash "$CLAUDE_PROJECT_DIR/.claude/hooks/vexp-edit-hint.sh"',
+                    timeout: 5,
+                },
+            ],
+        });
+    }
+    const merged = {
+        ...hooks,
+        UserPromptSubmit: filtered,
+        PostToolUse: filteredPost,
+    };
+    // An empty array is not "no hook": it leaves a key behind that reads like a
+    // configured-but-broken event. Drop it, as the extension copy does.
+    if (filteredPost.length === 0)
+        delete merged.PostToolUse;
     const settingsIdentical = JSON.stringify(merged) === JSON.stringify(settings.hooks ?? {});
     if (scriptIdentical && settingsIdentical)
         return null;
@@ -2076,6 +2435,21 @@ export function installClaudeCodeHintHook(workspaceRoot, binaryPath) {
  * unlike the deny guard (strict-only), this cannot break a session; it only
  * ever appends an orientation line the daemon judged useful.
  */
+/**
+ * opencode / Kilo compression plugin: both doors, mutating rather than
+ * blocking. Their `tool.execute.before` can rewrite `output.args`, which is
+ * the whole mechanism.
+ */
+export function installOpencodeCompressPlugin(workspaceRoot, binaryPath, pluginDir) {
+    const pluginPath = path.join(workspaceRoot, pluginDir, "vexp-compress.js");
+    const content = vexpOpencodeCompressPlugin(binaryPath);
+    fs.mkdirSync(path.dirname(pluginPath), { recursive: true });
+    const existed = fs.existsSync(pluginPath);
+    if (existed && fs.readFileSync(pluginPath, "utf-8") === content)
+        return null;
+    fs.writeFileSync(pluginPath, content);
+    return existed ? "updated" : "created";
+}
 export function installOpencodeHintPlugin(workspaceRoot, binaryPath, pluginDir) {
     const pluginPath = path.join(workspaceRoot, pluginDir, "vexp-hint.js");
     const content = vexpOpencodeHintPlugin(binaryPath);
@@ -2100,10 +2474,33 @@ export function installCodexHintHook(workspaceRoot, binaryPath) {
     const script = vexpHintHookScript(binaryPath);
     fs.mkdirSync(dir, { recursive: true });
     const existed = fs.existsSync(hookPath);
-    const scriptIdentical = existed && fs.readFileSync(hookPath, "utf-8") === script;
+    let scriptIdentical = existed && fs.readFileSync(hookPath, "utf-8") === script;
     if (!scriptIdentical) {
         fs.writeFileSync(hookPath, script, { mode: 0o755 });
     }
+    // Windows gets a batch twin. Codex runs a hook command through
+    // `cmd.exe /C` (COMSPEC, codex-rs/hooks command_runner), so `bash "..."`
+    // reaches a shell that has never heard of bash: a user with neither Git
+    // Bash nor WSL got "bash not found" on every prompt and orientation was
+    // inert. Codex's own answer is `commandWindows`, an optional per-OS
+    // override on the command handler (openai/codex#22159, ~0.131, months
+    // before the version that requires the nested `hooks` shape we already
+    // write). Older builds ignore the field rather than reject the file —
+    // the handler is not deny_unknown_fields, unlike the top level.
+    const cmdPath = path.join(dir, "vexp-hint.cmd");
+    let cmdCommand;
+    if (process.platform === "win32") {
+        const cmdScript = vexpHintHookCmdScript(binaryPath);
+        const cmdExisted = fs.existsSync(cmdPath);
+        if (!cmdExisted || fs.readFileSync(cmdPath, "utf-8") !== cmdScript) {
+            fs.writeFileSync(cmdPath, cmdScript);
+            scriptIdentical = false;
+        }
+        // Quoted: Codex hands `cmd /C` the whole line wrapped in one more pair
+        // of quotes, and cmd then strips the outermost pair — which leaves this
+        // path quoted and therefore safe to contain spaces.
+        cmdCommand = `"${cmdPath}"`;
+    }
     let root = {};
     if (fs.existsSync(hooksJsonPath)) {
         try {
@@ -2141,6 +2538,7 @@ export function installCodexHintHook(workspaceRoot, binaryPath) {
             {
                 type: "command",
                 command: `bash "${hookPath.replace(/\\/g, "/")}"`,
+                ...(cmdCommand ? { commandWindows: cmdCommand } : {}),
                 timeout: 5,
             },
         ],
@@ -2229,6 +2627,58 @@ export function uninstallOpencodePlugin(workspaceRoot) {
  * `failClosed` is left at its default (false): a crashing guard must let the
  * agent work, not lock it out.
  */
+/**
+ * Register a compression hook with Cursor.
+ *
+ * Cursor's `preToolUse` takes the SAME input as Claude Code's — `tool_name`,
+ * `tool_input` — and answers in a different shape: `permission` plus a
+ * snake_case `updated_input`. The binary emits either on request, so nothing
+ * here has to know the difference beyond passing `--protocol cursor`.
+ *
+ * The binary is registered directly rather than through a shell script: there
+ * is no `$CLAUDE_PROJECT_DIR` to expand here and no bash to assume on Windows.
+ */
+function installCursorCompressionHook(workspaceRoot, binaryPath, sub, matcher) {
+    const cfgPath = path.join(workspaceRoot, ".cursor", "hooks.json");
+    const command = `${binaryPath} ${sub} --protocol cursor`;
+    const read = readJsonConfigSafe(cfgPath);
+    if (!read.ok) {
+        warnUnparseable(cfgPath);
+        return false;
+    }
+    const cfg = read.data;
+    const hooks = cfg.hooks ?? {};
+    const preToolUse = Array.isArray(hooks.preToolUse) ? [...hooks.preToolUse] : [];
+    // Idempotent by SUBCOMMAND, not by exact command: the binary path changes
+    // between installs and must replace its own entry rather than add one.
+    const mine = (e) => !!e &&
+        typeof e === "object" &&
+        typeof e.command === "string" &&
+        (e.command).includes(` ${sub} --protocol cursor`);
+    const entry = { command, matcher };
+    const at = preToolUse.findIndex(mine);
+    if (at >= 0 && JSON.stringify(preToolUse[at]) === JSON.stringify(entry))
+        return false;
+    if (at >= 0)
+        preToolUse[at] = entry;
+    else
+        preToolUse.push(entry);
+    hooks.preToolUse = preToolUse;
+    cfg.hooks = hooks;
+    if (cfg.version === undefined)
+        cfg.version = 1;
+    fs.mkdirSync(path.dirname(cfgPath), { recursive: true });
+    if (read.existed)
+        backupConfig(cfgPath);
+    fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2), "utf-8");
+    return true;
+}
+export function installCursorReadHint(workspaceRoot, binaryPath) {
+    return installCursorCompressionHook(workspaceRoot, binaryPath, "read-hint", "Read");
+}
+export function installCursorBashCap(workspaceRoot, binaryPath) {
+    return installCursorCompressionHook(workspaceRoot, binaryPath, "bash-cap", "Bash");
+}
 export function installCursorHook(workspaceRoot) {
     const rel = path.join(".cursor", "hooks", "vexp-guard.js");
     const hookPath = path.join(workspaceRoot, rel);
@@ -2336,6 +2786,58 @@ export function uninstallKiloPlugin(workspaceRoot) {
     }
     return removed;
 }
+/**
+ * v5: the edit-time coupling for Cursor.
+ *
+ * Cursor sees a prompt but cannot inject at prompt time — `beforeSubmitPrompt`
+ * is read-only. Its injectable channel is `postToolUse`, which is exactly
+ * where this signal belongs anyway: the file has just been edited and the
+ * coupling is what the plan is about to miss.
+ *
+ * Same binary, same daemon op, same fail-open contract as the Claude Code
+ * hook. The point of doing both is that a signal only one agent receives is a
+ * feature of that agent, not of the product.
+ */
+export function installCursorEditHint(workspaceRoot, binaryPath) {
+    const dir = path.join(workspaceRoot, ".cursor", "hooks");
+    const scriptPath = path.join(dir, "vexp-edit-hint.sh");
+    const script = bakeEditHintHook(binaryPath);
+    fs.mkdirSync(dir, { recursive: true });
+    const existed = fs.existsSync(scriptPath);
+    if (!existed || fs.readFileSync(scriptPath, "utf-8") !== script) {
+        fs.writeFileSync(scriptPath, script, { mode: 0o755 });
+    }
+    try {
+        fs.chmodSync(scriptPath, 0o755);
+    }
+    catch {
+        /* no exec bit on Windows */
+    }
+    const cfgPath = path.join(workspaceRoot, ".cursor", "hooks.json");
+    const read = readJsonConfigSafe(cfgPath);
+    if (!read.ok) {
+        warnUnparseable(cfgPath);
+        return null;
+    }
+    const cfg = read.data;
+    const hooks = cfg.hooks ?? {};
+    const post = Array.isArray(hooks.postToolUse) ? hooks.postToolUse : [];
+    const filtered = post.filter((e) => {
+        if (!e || typeof e !== "object")
+            return true;
+        const cmd = e.command;
+        return typeof cmd !== "string" || !cmd.includes("vexp-edit-hint");
+    });
+    filtered.push({ command: `bash "${scriptPath}"` });
+    hooks.postToolUse = filtered;
+    const merged = { ...cfg, hooks };
+    if (JSON.stringify(merged) === JSON.stringify(cfg) && existed)
+        return null;
+    if (read.existed)
+        backupConfig(cfgPath);
+    fs.writeFileSync(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
+    return read.existed ? "updated" : "created";
+}
 /** Remove the Cursor guard (2.3 A2 default): delete the hook script and drop
  *  our preToolUse entry from .cursor/hooks.json. */
 export function uninstallCursorHook(workspaceRoot) {
@@ -2384,12 +2886,47 @@ export function uninstallCursorHook(workspaceRoot) {
  * Shared by every prose template so the wording cannot drift again. ASCII only
  * (these land in files that get read on Windows).
  */
-const QUERY_SHAPE = `### Query shape (do this)
-- Anchor the task on real identifiers (ClassName, functionName) or file paths:
-  \`run_pipeline({ "task": "fix JWT expiry in AuthService.validateToken" })\`
-- A pure natural-language question ("why does login fail?") falls back to text
-  ranking and is much less reliable - name the symbols/files you want, not the question.`;
-function generateAgentConfig(template, vars) {
+/**
+ * The standing mandate, and it is deliberately short.
+ *
+ * Whatever this file says is resident in the agent's context on EVERY turn,
+ * while a tool call happens at most once. Measured over 13 full bench
+ * sessions: 37.1 API turns against a transcript averaging 65,521 tokens, so
+ * a line here is billed 37 times and a call is billed once. The templates
+ * this replaces ran 282 tokens (Claude Code) to 959 (generic) - up to 35,000
+ * replayed tokens per session - and most of what they carried was a second
+ * copy of the tool descriptions the MCP schemas already send.
+ *
+ * So this keeps only the three things a schema cannot carry:
+ *
+ *   1. WHEN to call, and when not to - the schema says what a tool returns,
+ *      not whether this task wants it.
+ *   2. The two guardrails that stop wasted calls: text sweeps belong to
+ *      native search, and the index covers repo source only (logs, dist/,
+ *      node_modules are not in it - read those directly).
+ *   3. The privacy line, because users ask and compliance reviews ask.
+ *
+ * Everything else was deleted, not shortened. See the catalog diet in
+ * mcp_stdio.rs for the same argument applied one layer down.
+ */
+const MANDATE_CORE = `### Context strategy: call run_pipeline ONCE at task start
+If the task already names the files/symbols to touch, SKIP vexp. Otherwise one
+\`run_pipeline({ "task": "..." })\` returns ranked pivot files with line ranges and
+blast radius. Do NOT open files one by one to find your way around - every extra
+tool call costs a turn. Call it again ONLY when the task moves to a new area.
+\`get_skeleton\` for files to understand, not edit. \`verify_done\` before calling a
+multi-file task complete, then RUN the tests it names.
+
+### Query shape (do this)
+Anchor the task on real identifiers (ClassName, functionName) or file paths:
+\`run_pipeline({ "task": "fix JWT expiry in AuthService.validateToken" })\`
+
+vexp runs entirely on this machine, index in \`.vexp/\`;
+\`run_pipeline\` transmits nothing to any external service.
+On \`status: "degraded"\` or 0 pivots the index is still building - use your own tools.
+For literal string sweeps use your native search - do NOT route text sweeps through vexp.
+Repo SOURCE only: logs, dist/, node_modules/ and files outside the repo are NOT indexed.`;
+export function generateAgentConfig(template, vars) {
     switch (template) {
         case "claude-code":
             return claudeCodeTemplate(vars);
@@ -2418,469 +2955,72 @@ function generateAgentConfig(template, vars) {
 // ---------------------------------------------------------------------------
 function claudeCodeTemplate(vars) {
     return `## vexp - Context-Aware AI Coding <!-- vexp v${vars.version} -->
-vexp runs entirely on this machine: local daemon, index in \`.vexp/\`.
-\`run_pipeline\` transmits nothing to any external service.
-- \`run_pipeline({ "task": "..." })\` - orientation in one call (ranked pivot
-  files with line ranges + blast radius + session notes) when a task does NOT
-  name the files/symbols to touch. If it does, SKIP vexp - use your normal tools.
-- \`get_skeleton\` - file structure at 70-90% token savings for files you only
-  need to understand, not edit.
-- \`verify_done\` - call once BEFORE declaring a multi-file task complete:
-  returns mechanically broken references (imports of removed names, parse
-  errors), untouched dependents of the files you changed (file:line), and
-  the impacted tests - RUN those tests before declaring done.
-- vexp may append a one-line hint to a prompt when orientation would help;
-  otherwise it stays silent.
 
-### Query shape (do this)
-Anchor the task on real identifiers (ClassName, functionName) or file paths:
-\`run_pipeline({ "task": "fix JWT expiry in AuthService.validateToken" })\`
+${MANDATE_CORE}
 <!-- /vexp -->`;
 }
 function cursorTemplate(vars) {
     return `## vexp rules for Cursor <!-- vexp v${vars.version} -->
 
-**Call \`run_pipeline\` ONCE at task start for orientation - then use your normal tools.**
-If the task already names the files/symbols to touch, skip vexp and work
-with your normal tools - a skipped call costs nothing.
-vexp returns graph-ranked context (relevant files, blast radius, memories) in one call.
-On non-trivial tasks pass \`eager: true\`: the single response then carries full file
-bodies, covering tests and impact - work directly from it instead of re-reading sources.
-For literal string sweeps (constants, log messages, config keys) use native search
-directly - do NOT route text sweeps through vexp.
-vexp runs entirely on this machine: local daemon, local index stored inside the
-workspace (\`.vexp/\`). \`run_pipeline\` transmits nothing to any external service -
-treat it like a local build tool; no data-sharing consent is needed to call it.
-
-### Workflow
-1. \`run_pipeline\` with your task description - ONCE at task start
-2. Literal text sweeps with native search; Read the files you will edit
-3. Make targeted changes based on the context returned
-4. \`run_pipeline\` again ONLY when the task moves to a new area - not per turn
-
-### Available MCP tools
-- \`run_pipeline\` - **PRIMARY TOOL**. Runs capsule + impact + memory in 1 call.
-  Auto-detects intent. Includes file content. Example: \`run_pipeline({ "task": "fix JWT expiry in AuthService.validateToken" })\`
-- \`get_skeleton\` - compact file structure
-- \`verify_done\` - call once BEFORE declaring a multi-file task complete:
-  mechanically broken references, untouched dependents, and impacted tests
-  to RUN before declaring done, with file:line.
-- \`index_status\` - indexing status
-- \`expand_vexp_ref\` - expand V-REF placeholders in v2 output
-
-(Recommended core set, not the full schema: paid plans advertise 14 MCP tools -
-capsule, impact graph, logic flow, memory and more. \`run_pipeline\` already runs
-those server-side, so the four above cover the normal workflow.)
-
-${QUERY_SHAPE}
-
-### Agentic search
-- Ask vexp first for architecture/impact questions; native search remains the right
-  tool for literal text sweeps
-- If you spawn sub-agents or background tasks, pass them the context from \`run_pipeline\`
-  so they do not re-explore from scratch
-
-### Tips
-- Add \`include_tests: true\` when debugging
-- Use \`preset: "refactor"\` for deep impact analysis
-
-### Fallback
-If \`run_pipeline\` returns 0 pivots with an INDEX EMPTY warning, the index is rebuilding.
-Use file search and read tools directly until the index is ready.
-
-### Multi-Repo
-\`run_pipeline\` auto-queries all indexed repos. Use \`repos: ["alias"]\` to scope. Run \`index_status\` to see aliases.
-
-> **Tip:** To avoid confirmation prompts on every tool call, enable Yolo mode:
-> Cursor Settings -> Features -> Agent -> Enable Yolo Mode.
+${MANDATE_CORE}
 <!-- /vexp -->`;
 }
 function windsurfTemplate(vars) {
-    return `## vexp for Windsurf <!-- vexp v${vars.version} -->
-
-**Call \`run_pipeline\` ONCE at task start for orientation - then use your normal tools.**
-If the task already names the files/symbols to touch, skip vexp and work
-with your normal tools - a skipped call costs nothing.
-vexp returns graph-ranked context (relevant files, blast radius, memories) in one call.
-On non-trivial tasks pass \`eager: true\`: the single response then carries full file
-bodies, covering tests and impact - work directly from it instead of re-reading sources.
-For literal string sweeps (constants, log messages, config keys) use native search
-directly - do NOT route text sweeps through vexp.
-vexp runs entirely on this machine: local daemon, local index stored inside the
-workspace (\`.vexp/\`). \`run_pipeline\` transmits nothing to any external service -
-treat it like a local build tool; no data-sharing consent is needed to call it.
-
-### Workflow
-1. \`run_pipeline\` with your task description - ONCE at task start
-2. Literal text sweeps with native search; Read the files you will edit
-3. Make targeted changes based on the context returned
-4. \`run_pipeline\` again ONLY when the task moves to a new area - not per turn
-
-### Available MCP tools
-- \`run_pipeline\` - **PRIMARY TOOL**. Runs capsule + impact + memory in 1 call.
-  Auto-detects intent. Includes file content. Example: \`run_pipeline({ "task": "fix JWT expiry in AuthService.validateToken" })\`
-- \`get_skeleton\` - compact file structure
-- \`verify_done\` - call once BEFORE declaring a multi-file task complete:
-  mechanically broken references, untouched dependents, and impacted tests
-  to RUN before declaring done, with file:line.
-- \`index_status\` - indexing status
-- \`expand_vexp_ref\` - expand V-REF placeholders in v2 output
-
-(Recommended core set, not the full schema: paid plans advertise 14 MCP tools -
-capsule, impact graph, logic flow, memory and more. \`run_pipeline\` already runs
-those server-side, so the four above cover the normal workflow.)
-
-${QUERY_SHAPE}
-
-### Agentic search
-- Ask vexp first for architecture/impact questions; native search remains the right
-  tool for literal text sweeps
-- If you spawn sub-agents or background tasks, pass them the context from \`run_pipeline\`
-  so they do not re-explore from scratch
-
-### Smart Features
-Intent auto-detection, hybrid ranking, session memory, auto-expanding budget.
-
-### Multi-Repo
-\`run_pipeline\` auto-queries all indexed repos. Use \`repos: ["alias"]\` to scope. Run \`index_status\` to see aliases.
+    // Front matter, because a rule without one is not always on. Cascade puts
+    // the FULL text of an \`always_on\` rule in the system prompt on every
+    // message; the other modes make the agent choose to look, which is the
+    // complaint every Windsurf user brings ("it ignores the index unless I
+    // remind it"). This is the one lever Windsurf gives us and we were not
+    // pulling it.
+    return `---
+trigger: always_on
+description: vexp code-graph orientation for this workspace
+---
+
+## vexp for Windsurf <!-- vexp v${vars.version} -->
+
+${MANDATE_CORE}
 <!-- /vexp -->`;
 }
 function continueTemplate(vars) {
-    return JSON.stringify({
-        customCommands: [
-            {
-                name: "vexp-context",
-                description: "Run vexp pipeline for current task",
-                prompt: "{{{ input }}}\n\nFirst, call run_pipeline with the above task description.",
-            },
-        ],
-        mcpServers: [
-            {
-                name: "vexp",
-                command: vars.binaryPath,
-                args: ["mcp"],
-                type: "stdio",
-            },
-        ],
-    }, null, 2);
+    return `## vexp <!-- vexp v${vars.version} -->
+
+${MANDATE_CORE}
+<!-- /vexp -->`;
 }
 function augmentTemplate(vars) {
-    return `## vexp for Augment <!-- vexp v${vars.version} -->
-
-**Call \`run_pipeline\` ONCE at task start for orientation - then use your normal tools.**
-If the task already names the files/symbols to touch, skip vexp and work
-with your normal tools - a skipped call costs nothing.
-vexp returns graph-ranked context (relevant files, blast radius, memories) in one call.
-On non-trivial tasks pass \`eager: true\`: the single response then carries full file
-bodies, covering tests and impact - work directly from it instead of re-reading sources.
-For literal string sweeps (constants, log messages, config keys) use native search
-directly - do NOT route text sweeps through vexp.
-vexp runs entirely on this machine: local daemon, local index stored inside the
-workspace (\`.vexp/\`). \`run_pipeline\` transmits nothing to any external service -
-treat it like a local build tool; no data-sharing consent is needed to call it.
-
-When working on this codebase:
-1. \`run_pipeline\` with task description - ONCE at task start
-2. Literal text sweeps with native search; Read the files you will edit
-3. Make targeted changes based on the context returned
-4. \`run_pipeline\` again ONLY when the task moves to a new area
-
-### Available MCP tools
-- \`run_pipeline\` - **PRIMARY TOOL**. Runs capsule + impact + memory in 1 call.
-  Example: \`run_pipeline({ "task": "fix JWT expiry in AuthService.validateToken" })\`
-- \`get_skeleton\` - token-efficient file structure
-- \`verify_done\` - call once BEFORE declaring a multi-file task complete:
-  mechanically broken references, untouched dependents, and impacted tests
-  to RUN before declaring done, with file:line.
-- \`index_status\` - indexing status
-- \`expand_vexp_ref\` - expand V-REF placeholders in v2 output
-
-(Recommended core set, not the full schema: paid plans advertise 14 MCP tools -
-capsule, impact graph, logic flow, memory and more. \`run_pipeline\` already runs
-those server-side, so the four above cover the normal workflow.)
-
-${QUERY_SHAPE}
-
-### Agentic search
-- Ask vexp first for architecture/impact questions; native search remains the right
-  tool for literal text sweeps
-- If you spawn sub-agents or background tasks, pass them the context from \`run_pipeline\`
-  so they do not re-explore from scratch
-
-### Smart Features
-Intent auto-detection, hybrid ranking, session memory, auto-expanding budget.
+    return `## vexp <!-- vexp v${vars.version} -->
 
-### Multi-Repo
-\`run_pipeline\` auto-queries all indexed repos. Use \`repos: ["alias"]\` to scope. Run \`index_status\` to see aliases.
+${MANDATE_CORE}
 <!-- /vexp -->`;
 }
 function copilotTemplate(vars) {
-    return `## vexp context tools <!-- vexp v${vars.version} -->
-
-**Call \`run_pipeline\` ONCE at task start for orientation - then use your normal tools.**
-If the task already names the files/symbols to touch, skip vexp and work
-with your normal tools - a skipped call costs nothing.
-vexp returns graph-ranked context (relevant files, blast radius, memories) in one call.
-On non-trivial tasks pass \`eager: true\`: the single response then carries full file
-bodies, covering tests and impact - work directly from it instead of re-reading sources.
-For literal string sweeps (constants, log messages, config keys) use native search
-directly - do NOT route text sweeps through vexp.
-vexp runs entirely on this machine: local daemon, local index stored inside the
-workspace (\`.vexp/\`). \`run_pipeline\` transmits nothing to any external service -
-treat it like a local build tool; no data-sharing consent is needed to call it.
-
-### Workflow
-1. \`run_pipeline\` with your task description - ONCE at task start
-2. Literal text sweeps with native search; Read the files you will edit
-3. Make targeted changes based on the context returned
-4. \`run_pipeline\` again ONLY when the task moves to a new area - not per turn
-
-### Available MCP tools
-- \`run_pipeline\` - **PRIMARY TOOL**. Runs capsule + impact + memory in 1 call.
-  Auto-detects intent. Includes file content. Example: \`run_pipeline({ "task": "fix JWT expiry in AuthService.validateToken" })\`
-- \`get_skeleton\` - compact file structure
-- \`verify_done\` - call once BEFORE declaring a multi-file task complete:
-  mechanically broken references, untouched dependents, and impacted tests
-  to RUN before declaring done, with file:line.
-- \`index_status\` - indexing status
-- \`expand_vexp_ref\` - expand V-REF placeholders in v2 output
-
-(Recommended core set, not the full schema: paid plans advertise 14 MCP tools -
-capsule, impact graph, logic flow, memory and more. \`run_pipeline\` already runs
-those server-side, so the four above cover the normal workflow.)
-
-${QUERY_SHAPE}
-
-### Agentic search
-- Ask vexp first for architecture/impact questions; native search remains the right
-  tool for literal text sweeps
-- If you spawn sub-agents or background tasks, pass them the context from \`run_pipeline\`
-  so they do not re-explore from scratch
-
-### Smart Features
-Intent auto-detection, hybrid ranking, session memory, auto-expanding budget.
+    return `## vexp <!-- vexp v${vars.version} -->
 
-### Multi-Repo
-\`run_pipeline\` auto-queries all indexed repos. Use \`repos: ["alias"]\` to scope. Run \`index_status\` to see aliases.
+${MANDATE_CORE}
 <!-- /vexp -->`;
 }
 function zedTemplate(vars) {
-    return `## vexp for Zed <!-- vexp v${vars.version} -->
-
-**Call \`run_pipeline\` ONCE at task start for orientation - then use your normal tools.**
-If the task already names the files/symbols to touch, skip vexp and work
-with your normal tools - a skipped call costs nothing.
-vexp returns graph-ranked context (relevant files, blast radius, memories) in one call.
-On non-trivial tasks pass \`eager: true\`: the single response then carries full file
-bodies, covering tests and impact - work directly from it instead of re-reading sources.
-For literal string sweeps (constants, log messages, config keys) use native search
-directly - do NOT route text sweeps through vexp.
-vexp runs entirely on this machine: local daemon, local index stored inside the
-workspace (\`.vexp/\`). \`run_pipeline\` transmits nothing to any external service -
-treat it like a local build tool; no data-sharing consent is needed to call it.
-
-### Workflow
-1. \`run_pipeline\` with your task description - ONCE at task start
-2. Literal text sweeps with native search; Read the files you will edit
-3. Make targeted changes based on the context returned
-4. \`run_pipeline\` again ONLY when the task moves to a new area - not per turn
-
-### Available MCP tools
-- \`run_pipeline\` - **PRIMARY TOOL**. Runs capsule + impact + memory in 1 call.
-  Example: \`run_pipeline({ "task": "fix JWT expiry in AuthService.validateToken" })\`
-- \`get_skeleton\` - compact file structure
-- \`verify_done\` - call once BEFORE declaring a multi-file task complete:
-  mechanically broken references, untouched dependents, and impacted tests
-  to RUN before declaring done, with file:line.
-- \`index_status\` - indexing status
-- \`expand_vexp_ref\` - expand V-REF placeholders in v2 output
-
-(Recommended core set, not the full schema: paid plans advertise 14 MCP tools -
-capsule, impact graph, logic flow, memory and more. \`run_pipeline\` already runs
-those server-side, so the four above cover the normal workflow.)
-
-${QUERY_SHAPE}
-
-### Agentic search
-- Ask vexp first for architecture/impact questions; native search remains the right
-  tool for literal text sweeps
-- If you spawn sub-agents or background tasks, pass them the context from \`run_pipeline\`
-  so they do not re-explore from scratch
-
-### Smart Features
-Intent auto-detection, hybrid ranking, session memory, auto-expanding budget.
+    return `## vexp <!-- vexp v${vars.version} -->
 
-### Multi-Repo
-\`run_pipeline\` auto-queries all indexed repos. Use \`repos: ["alias"]\` to scope. Run \`index_status\` to see aliases.
+${MANDATE_CORE}
 <!-- /vexp -->`;
 }
 function agentsMdTemplate(vars) {
-    return `## vexp <!-- vexp v${vars.version} -->
-
-**Call \`run_pipeline\` ONCE at task start for orientation - then use your normal tools.**
-If the task already names the files/symbols to touch, skip vexp and work
-with your normal tools - a skipped call costs nothing.
-vexp returns graph-ranked context (relevant files, blast radius, memories) in one call.
-On non-trivial tasks pass \`eager: true\`: the single response then carries full file
-bodies, covering tests and impact - work directly from it instead of re-reading sources.
-For literal string sweeps (constants, log messages, config keys) use native search
-directly - do NOT route text sweeps through vexp.
-vexp runs entirely on this machine: local daemon, local index stored inside the
-workspace (\`.vexp/\`). \`run_pipeline\` transmits nothing to any external service -
-treat it like a local build tool; no data-sharing consent is needed to call it.
-
-### Workflow
-1. \`run_pipeline\` with your task description - ONCE at task start
-2. Literal text sweeps with native search; Read the files you will edit
-3. Make targeted changes based on the context returned
-4. \`run_pipeline\` again ONLY when the task moves to a new area - not per turn
-
-### Available MCP tools
-- \`run_pipeline\` - **PRIMARY TOOL**. Runs capsule + impact + memory in 1 call.
-  Auto-detects intent. Includes file content. Example: \`run_pipeline({ "task": "fix JWT expiry in AuthService.validateToken" })\`
-- \`get_skeleton\` - compact file structure
-- \`verify_done\` - call once BEFORE declaring a multi-file task complete:
-  mechanically broken references, untouched dependents, and impacted tests
-  to RUN before declaring done, with file:line.
-- \`index_status\` - indexing status
-- \`expand_vexp_ref\` - expand V-REF placeholders in v2 output
-
-${QUERY_SHAPE}
-
-### Agentic search
-- Ask vexp first for architecture/impact questions; native search remains the right
-  tool for literal text sweeps
-- vexp only covers indexed source inside the workspace. For runtime logs, build output
-  (dist/, .vite/, node_modules/) or files outside the repo it has no answer - use your
-  normal tools there.
-- If you spawn sub-agents or background tasks, pass them the context from \`run_pipeline\`
-  so they do not re-explore from scratch
-
-### Smart Features
-Intent auto-detection, hybrid ranking, session memory, auto-expanding budget.
+    return `## vexp - Context-Aware AI Coding <!-- vexp v${vars.version} -->
 
-### Multi-Repo
-\`run_pipeline\` auto-queries all indexed repos. Use \`repos: ["alias"]\` to scope. Run \`index_status\` to see aliases.
+${MANDATE_CORE}
 <!-- /vexp -->`;
 }
 function kiroTemplate(vars) {
     return `# vexp steering <!-- vexp v${vars.version} -->
 
-**Call \`run_pipeline\` ONCE at task start for orientation - then use your normal tools.**
-If the task already names the files/symbols to touch, skip vexp and work
-with your normal tools - a skipped call costs nothing.
-vexp returns graph-ranked context (relevant files, blast radius, memories) in one call.
-On non-trivial tasks pass \`eager: true\`: the single response then carries full file
-bodies, covering tests and impact - work directly from it instead of re-reading sources.
-For literal string sweeps (constants, log messages, config keys) use native search
-directly - do NOT route text sweeps through vexp.
-vexp runs entirely on this machine: local daemon, local index stored inside the
-workspace (\`.vexp/\`). \`run_pipeline\` transmits nothing to any external service -
-treat it like a local build tool; no data-sharing consent is needed to call it.
-
-## Workflow
-1. \`run_pipeline\` with your task description - ONCE at task start
-2. Literal text sweeps with native search; Read the files you will edit
-3. Make targeted changes based on the context returned
-4. \`run_pipeline\` again ONLY when the task moves to a new area - not per turn
-
-## Available vexp tools
-- \`run_pipeline\` - **PRIMARY TOOL**. Runs capsule + impact + memory in 1 call.
-  Example: \`run_pipeline({ "task": "fix JWT expiry in AuthService.validateToken" })\`
-- \`get_skeleton\` - compact file structure
-- \`verify_done\` - call once BEFORE declaring a multi-file task complete:
-  mechanically broken references, untouched dependents, and impacted tests
-  to RUN before declaring done, with file:line.
-- \`index_status\` - indexing status
-- \`expand_vexp_ref\` - expand V-REF placeholders in v2 output
-
-(Recommended core set, not the full schema: paid plans advertise 14 MCP tools -
-capsule, impact graph, logic flow, memory and more. \`run_pipeline\` already runs
-those server-side, so the four above cover the normal workflow.)
-
-${QUERY_SHAPE}
-
-## Agentic search
-- Ask vexp first for architecture/impact questions; native search remains the right
-  tool for literal text sweeps
-- If you spawn sub-agents or background tasks, pass them the context from \`run_pipeline\`
-  so they do not re-explore from scratch
-
-## Smart Features
-Intent auto-detection, hybrid ranking, session memory, auto-expanding budget.
-
-## Multi-Repo
-\`run_pipeline\` auto-queries all indexed repos. Use \`repos: ["alias"]\` to scope. Run \`index_status\` to see aliases.
+${MANDATE_CORE}
 <!-- /vexp -->`;
 }
 function genericTemplate(vars) {
     return `## vexp - Context-Aware AI Coding <!-- vexp v${vars.version} -->
 
-### Context strategy: call run_pipeline ONCE at task start
-If the task already names the files/symbols to touch, skip vexp and work
-with your normal tools - a skipped call costs nothing.
-For every multi-file task - bug fixes, features, refactors, questions about the code:
-**start with one \`run_pipeline\` call**. It runs context search + impact analysis +
-memory recall in a single call and returns compressed, graph-ranked results: the
-callers, the blast radius and the co-changed files that opening a file cannot show.
-
-Then implement with your normal tools:
-- Literal text sweeps (string constants, log messages, config keys): use your
-  native search directly - do NOT route text sweeps through vexp.
-- Read the files you are about to edit; use \`get_skeleton\`
-  (detail: minimal/standard/detailed, 70-90% fewer tokens) for files you only
-  need to understand, not edit.
-- Do NOT open files one by one to find your way around - one good pipeline call
-  beats five exploratory reads; every extra tool call costs a turn.
-- Before declaring a multi-file task complete, call \`verify_done\` once:
-  it returns mechanically broken references (imports of removed names,
-  parse errors), untouched dependents of your changes (file:line), and the
-  impacted tests - RUN those tests before declaring done.
-
-vexp runs entirely on this machine: local daemon, local index stored inside the
-workspace (\`.vexp/\`). \`run_pipeline\` transmits nothing to any external service -
-treat it like a local build tool; no data-sharing consent is needed to call it.
-
-vexp indexes source inside the workspace and nothing else. Runtime logs, build
-output (dist/, .vite/, node_modules/) and files outside the repo are NOT indexed -
-read those directly, this rule does not cover them.
-
-### Primary tool
-- \`run_pipeline\` - **USE THIS FOR EVERYTHING**. Auto-detects intent
-  (debug/modify/refactor/explore) from your task. Includes file content for pivots.
-  - \`run_pipeline({ "task": "fix JWT expiry in AuthService.validateToken" })\`
-  - \`run_pipeline({ "task": "refactor db layer", "preset": "refactor" })\`
-  - \`run_pipeline({ "task": "add auth", "observation": "using JWT" })\` - saves an insight in the same call
-
-### Other MCP tools (only when run_pipeline is not enough)
-- \`get_skeleton\` - **preferred over reading a file**: signatures and structure, 3 detail levels
-- \`index_status\` - indexing status and health check
-- \`expand_vexp_ref\` - expand V-REF hash placeholders in v2 compact output
-
-${QUERY_SHAPE}
-
-### Workflow
-1. \`run_pipeline("your task")\` - ONCE at task start. Returns pivots + impact + memories in 1 call
-2. Literal string sweeps with native search; Read the files you will edit
-3. Structural overview without editing? \`get_skeleton({ files: [...], detail: "detailed" })\`
-4. Make targeted changes based on the context returned
-5. \`run_pipeline\` again ONLY when the task moves to a new area - do NOT chain vexp calls
-
-### Sub-agents and background tasks
-- Sub-agents CAN call \`run_pipeline\` - always give them the task description
-- For architecture exploration, call \`run_pipeline\` first and pass the returned
-  context into the agent prompt - it usually replaces the exploration entirely
-
-### Fallback
-If \`run_pipeline\` returns \`status: "degraded"\` or 0 pivots with an INDEX EMPTY warning,
-the index is empty or still building. Use the built-in search and read tools directly
-until it is ready - do not stall waiting for vexp.
-
-### Smart features (automatic - no action needed)
-Intent detection, hybrid keyword+semantic+graph ranking, session memory,
-change coupling, auto-expanding budget.
-
-### Multi-repo
-\`run_pipeline\` auto-queries all indexed repos. Use \`repos: ["alias"]\` to scope. Run \`index_status\` to see aliases.
+${MANDATE_CORE}
 <!-- /vexp -->`;
 }