context-mode 1.0.161 → 1.0.163

package/build/cache-heal.js

@@ -0,0 +1,150 @@
+/**
+ * Plugin cache self-heal — fixes broken CLAUDE_PLUGIN_ROOT references.
+ *
+ * Claude Code's plugin auto-update can leave installed_plugins.json pointing
+ * to a non-existent directory (anthropics/claude-code#46915). This module
+ * detects and repairs the mismatch by creating symlinks.
+ *
+ * 4-layer defense:
+ *   1. start.mjs startup — reverse heal (registry → symlink to us)
+ *   2. server.ts first tool call — mid-session heal
+ *   3. postinstall.mjs — backward symlink on new install
+ *   4. global hook auto-deploy — survives total plugin cache breakage
+ */
+import { existsSync, readFileSync, symlinkSync, mkdirSync, writeFileSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { homedir } from "node:os";
+/**
+ * Core heal: if installed_plugins.json points to a non-existent directory,
+ * create a symlink from that path to our actual directory.
+ *
+ * @param currentDir - The directory we're actually running from
+ * @param installedPluginsPath - Path to installed_plugins.json (injectable for testing)
+ */
+export function healRegistryMismatch(currentDir, installedPluginsPath) {
+    const ipPath = installedPluginsPath ?? resolve(homedir(), ".claude", "plugins", "installed_plugins.json");
+    if (!existsSync(ipPath))
+        return { healed: false, action: "none" };
+    if (!existsSync(currentDir))
+        return { healed: false, action: "none" };
+    let ip;
+    try {
+        ip = JSON.parse(readFileSync(ipPath, "utf-8"));
+    }
+    catch {
+        return { healed: false, action: "none" };
+    }
+    for (const [key, entries] of Object.entries(ip.plugins ?? {})) {
+        if (!key.toLowerCase().includes("context-mode"))
+            continue;
+        for (const entry of entries) {
+            const registryPath = entry.installPath;
+            if (!registryPath)
+                continue;
+            // Registry path exists — no healing needed
+            if (existsSync(registryPath))
+                continue;
+            // Registry path doesn't exist — create symlink to our directory
+            try {
+                const parent = dirname(registryPath);
+                if (!existsSync(parent))
+                    mkdirSync(parent, { recursive: true });
+                if (process.platform === "win32") {
+                    // Windows: use junction (no admin required)
+                    symlinkSync(currentDir, registryPath, "junction");
+                }
+                else {
+                    symlinkSync(currentDir, registryPath);
+                }
+                return { healed: true, action: "symlink", from: registryPath, to: currentDir };
+            }
+            catch {
+                return { healed: false, action: "none" };
+            }
+        }
+    }
+    return { healed: false, action: "none" };
+}
+/**
+ * Deploy a global SessionStart hook that heals plugin cache mismatches.
+ * This hook lives outside the plugin directory, so it survives cache breakage.
+ *
+ * Written to ~/.claude/hooks/context-mode-cache-heal.sh
+ */
+export function deployGlobalHealHook() {
+    const hooksDir = resolve(homedir(), ".claude", "hooks");
+    const hookPath = resolve(hooksDir, "context-mode-cache-heal.sh");
+    // Already deployed
+    if (existsSync(hookPath))
+        return { healed: false, action: "none" };
+    try {
+        if (!existsSync(hooksDir))
+            mkdirSync(hooksDir, { recursive: true });
+        const script = `#!/usr/bin/env bash
+# context-mode plugin cache self-heal — auto-deployed by context-mode MCP server
+# Fixes anthropics/claude-code#46915: auto-update breaks CLAUDE_PLUGIN_ROOT
+# This hook runs at SessionStart (global, not plugin-level) so it works even
+# when the plugin cache is broken.
+
+set -euo pipefail
+
+PLUGINS_FILE="$HOME/.claude/plugins/installed_plugins.json"
+[[ -f "$PLUGINS_FILE" ]] || exit 0
+
+# Find context-mode entries and heal missing directories
+node -e '
+const fs = require("fs");
+const path = require("path");
+try {
+  const ip = JSON.parse(fs.readFileSync(process.argv[1], "utf-8"));
+  for (const [key, entries] of Object.entries(ip.plugins || {})) {
+    if (!key.toLowerCase().includes("context-mode")) continue;
+    for (const entry of entries) {
+      const p = entry.installPath;
+      if (!p || fs.existsSync(p)) continue;
+      const parent = path.dirname(p);
+      if (!fs.existsSync(parent)) continue;
+      const dirs = fs.readdirSync(parent).filter(d => /^\\d+\\.\\d+/.test(d) && fs.statSync(path.join(parent, d)).isDirectory());
+      if (dirs.length === 0) continue;
+      dirs.sort((a, b) => {
+        const pa = a.split(".").map(Number), pb = b.split(".").map(Number);
+        for (let i = 0; i < 3; i++) { if ((pa[i]||0) !== (pb[i]||0)) return (pa[i]||0) - (pb[i]||0); }
+        return 0;
+      });
+      const target = path.join(parent, dirs[dirs.length - 1]);
+      try { fs.symlinkSync(target, p); } catch {}
+    }
+  }
+} catch {}
+' "$PLUGINS_FILE" 2>/dev/null || true
+`;
+        writeFileSync(hookPath, script, { mode: 0o755 });
+        return { healed: true, action: "global-hook", from: hookPath };
+    }
+    catch {
+        return { healed: false, action: "none" };
+    }
+}
+/**
+ * Backward symlink: during postinstall, if the registry points to a
+ * non-existent OLD path, create a symlink from old → new (our directory).
+ * Same as healRegistryMismatch but called from postinstall context.
+ */
+export { healRegistryMismatch as healBackwardCompat };
+/** One-shot flag for mid-session heal in server.ts */
+let _midSessionHealed = false;
+/**
+ * Mid-session heal — call on first MCP tool invocation.
+ * Checks if registry path differs from our running directory.
+ * Creates symlink if needed. Runs only once per process.
+ */
+export function healMidSession(currentDir) {
+    if (_midSessionHealed)
+        return { healed: false, action: "none" };
+    _midSessionHealed = true;
+    return healRegistryMismatch(currentDir);
+}
+/** Reset mid-session flag (for testing only) */
+export function _resetMidSession() {
+    _midSessionHealed = false;
+}

package/build/cli.js

@@ -62,6 +62,7 @@ const HOOK_MAP = {
         precompact: "hooks/precompact.mjs",
         sessionstart: "hooks/sessionstart.mjs",
         userpromptsubmit: "hooks/userpromptsubmit.mjs",
+        stop: "hooks/stop.mjs",
     },
     "gemini-cli": {
         beforeagent: "hooks/gemini-cli/beforeagent.mjs",
@@ -101,6 +102,22 @@ const HOOK_MAP = {
         precompact: "hooks/jetbrains-copilot/precompact.mjs",
         sessionstart: "hooks/jetbrains-copilot/sessionstart.mjs",
     },
+    "copilot-cli": {
+        pretooluse: "hooks/copilot-cli/pretooluse.mjs",
+        posttooluse: "hooks/copilot-cli/posttooluse.mjs",
+        precompact: "hooks/copilot-cli/precompact.mjs",
+        sessionstart: "hooks/copilot-cli/sessionstart.mjs",
+        userpromptsubmit: "hooks/copilot-cli/userpromptsubmit.mjs",
+        stop: "hooks/copilot-cli/stop.mjs",
+    },
+    // Antigravity CLI (`agy`) — bounded PreToolUse enforcement plus capture-only
+    // PostToolUse/Stop hooks. Configured via an installed agy plugin's
+    // hooks/hooks.json or ~/.gemini/config/hooks.json.
+    "antigravity-cli": {
+        pretooluse: "hooks/antigravity-cli/pretooluse.mjs",
+        posttooluse: "hooks/antigravity-cli/posttooluse.mjs",
+        stop: "hooks/antigravity-cli/stop.mjs",
+    },
     "kimi": {
         pretooluse: "hooks/kimi/pretooluse.mjs",
         posttooluse: "hooks/kimi/posttooluse.mjs",
@@ -132,7 +149,16 @@ async function hookDispatch(platform, event) {
     }
     const scriptPath = HOOK_MAP[platform]?.[event];
     if (!scriptPath) {
-        process.exit(1);
+        // Fail OPEN. context-mode has no hook for this platform/event — most often
+        // because a newer adapter's hook command (`context-mode hook copilot-cli …`)
+        // is running against an OLDER global binary that predates that adapter
+        // (version skew). Exit 0 (no decision) so the host ALLOWS the tool. Exiting
+        // non-zero here makes some hosts treat it as a hook ERROR and DENY the tool:
+        // verified against GitHub Copilot CLI 1.0.59, where an exit-1 + empty-stdout
+        // PreToolUse hook blocks EVERY tool ("Denied by preToolUse hook (hook
+        // errored)") — bricking the agent during a skew instead of just disabling
+        // context-mode's instrumentation.
+        process.exit(0);
     }
     const pluginRoot = getPluginRoot();
     await import(pathToFileURL(join(pluginRoot, scriptPath)).href);
@@ -205,7 +231,7 @@ else if (args[0] === "hook") {
     hookDispatch(args[1], args[2]);
 }
 else if (args[0] === "insight") {
-    insight(args[1] ? Number(args[1]) : 4747);
+    insight();
 }
 else if (args[0] === "statusline") {
     // Status line implementation lives in bin/statusline.mjs to keep it
@@ -1030,102 +1056,16 @@ async function doctor() {
     return 0;
 }
 /* -------------------------------------------------------
- * Insight — analytics dashboard
+ * Insight — hosted analytics dashboard
  * ------------------------------------------------------- */
-async function insight(port) {
-    try {
-        const { execSync, spawn } = await import("node:child_process");
-        const { statSync, mkdirSync, cpSync } = await import("node:fs");
-        const insightSource = resolve(getPluginRoot(), "insight");
-        // Detect platform + adapter for correct session/content paths
-        const detection = detectPlatform();
-        const adapter = await getAdapter(detection.platform);
-        const sessDir = ensureWritableStorageDir(resolveSessionStorageDir(() => adapter.getSessionDir()));
-        const contentDir = ensureWritableStorageDir(resolveContentStorageDir(() => sessDir));
-        const cacheDir = join(dirname(sessDir), "insight-cache");
-        if (!existsSync(join(insightSource, "server.mjs"))) {
-            console.error("Error: Insight source not found. Try upgrading context-mode.");
-            process.exit(1);
-        }
-        mkdirSync(cacheDir, { recursive: true });
-        // Copy source if newer
-        const srcMtime = statSync(join(insightSource, "server.mjs")).mtimeMs;
-        const cacheMtime = existsSync(join(cacheDir, "server.mjs"))
-            ? statSync(join(cacheDir, "server.mjs")).mtimeMs : 0;
-        if (srcMtime > cacheMtime) {
-            console.log("Copying Insight source...");
-            cpSync(insightSource, cacheDir, { recursive: true, force: true });
-        }
-        // Install deps
-        if (!existsSync(join(cacheDir, "node_modules"))) {
-            console.log("Installing dependencies (first run)...");
-            try {
-                npmExec("npm install --production=false", { cwd: cacheDir, stdio: "inherit", timeout: 300000 });
-            }
-            catch {
-                // Clean up partial install so next run retries fresh
-                try {
-                    rmSync(join(cacheDir, "node_modules"), { recursive: true, force: true });
-                }
-                catch { }
-                throw new Error("npm install failed — please retry");
-            }
-            // Sentinel check: verify install completed (cold cache can timeout leaving partial node_modules)
-            if (!existsSync(join(cacheDir, "node_modules", "vite")) || !existsSync(join(cacheDir, "node_modules", "better-sqlite3"))) {
-                rmSync(join(cacheDir, "node_modules"), { recursive: true, force: true });
-                throw new Error("npm install incomplete — please retry");
-            }
-        }
-        // Build
-        console.log("Building dashboard...");
-        execSync("npx vite build", { cwd: cacheDir, stdio: "pipe", timeout: 60000 });
-        // Start server
-        const url = `http://localhost:${port}`;
-        console.log(`\n  context-mode Insight\n  ${url}\n`);
-        const child = spawn("node", [join(cacheDir, "server.mjs")], {
-            cwd: cacheDir,
-            env: {
-                ...process.env,
-                PORT: String(port),
-                INSIGHT_SESSION_DIR: sessDir,
-                INSIGHT_CONTENT_DIR: contentDir,
-            },
-            stdio: "inherit",
-        });
-        child.on("error", () => { }); // prevent unhandled error crash
-        // Wait for server to be ready, then verify it started
-        await new Promise(r => setTimeout(r, 1500));
-        try {
-            const { request } = await import("node:http");
-            await new Promise((resolve, reject) => {
-                const req = request(`http://127.0.0.1:${port}/api/overview`, { timeout: 3000 }, (res) => {
-                    resolve();
-                    res.resume();
-                });
-                req.on("error", reject);
-                req.on("timeout", () => { req.destroy(); reject(new Error("timeout")); });
-                req.end();
-            });
-        }
-        catch {
-            console.error(`\nError: Port ${port} appears to be in use. Either a previous dashboard is still running, or another service is using this port.`);
-            console.error(`\nTo fix:`);
-            console.error(`  Kill the existing process: ${process.platform === "win32" ? `netstat -ano | findstr :${port}` : `lsof -ti:${port} | xargs kill`}`);
-            console.error(`  Or use a different port:   context-mode insight ${port + 1}`);
-            child.kill();
-            process.exit(1);
-        }
-        // Open browser — execFile with arg array, no shell interpolation.
-        openInBrowser(url);
-        // Keep alive until Ctrl+C
-        process.on("SIGINT", () => { child.kill(); process.exit(0); });
-        process.on("SIGTERM", () => { child.kill(); process.exit(0); });
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.error(`\nInsight error: ${msg}`);
-        process.exit(1);
-    }
+// Insight pivoted from a locally-built dashboard to the hosted product at
+// context-mode.com/insight (the landing page is the single source of truth).
+// The command now just opens that URL in the default browser.
+async function insight() {
+    const url = "https://context-mode.com/insight";
+    console.log(`\n  context-mode Insight\n  ${url}\n`);
+    // Open browser — execFile with arg array, no shell interpolation.
+    openInBrowser(url);
 }
 /* -------------------------------------------------------
  * Upgrade — adapter-aware hook configuration

package/build/executor.d.ts

@@ -13,6 +13,31 @@ export declare function buildSpawnOptions(platform: NodeJS.Platform): {
 };
 /** Pure helper — exported for unit testing. Restores parent PATH after shell startup. */
 export declare function buildShellScriptContent(code: string, inheritedPath: string | undefined, platform: NodeJS.Platform): string;
+export declare function buildPowerShellScriptContent(code: string): string;
+/**
+ * Pure helper — exported for unit testing. Issue #782.
+ *
+ * On Windows, the sandbox shell runtime is Git Bash. A bare `mvn` invocation
+ * runs Maven's POSIX shell script, which on the `mingw=true` branch (uname →
+ * MINGW64_NT-*) fails to convert `CLASSWORLDS_JAR` from a POSIX path
+ * (`/c/tools/maven/boot/plexus-classworlds-*.jar`) to a Windows path. Native
+ * `java.exe` then can't resolve the bootstrap jar → ClassNotFoundException for
+ * `org.codehaus.plexus.classworlds.launcher.Launcher`.
+ *
+ * The third-way fix (issue Option C): rewrite the bare `mvn` token to `mvn.cmd`,
+ * the native Windows launcher that uses Windows-native paths and bypasses the
+ * broken mingw shell branch entirely. This does NOT touch the global MSYS
+ * path-conversion env (MSYS_NO_PATHCONV / MSYS2_ARG_CONV_EXCL), which #826/#791
+ * deliberately leave unset so native git.exe launched from bash keeps its
+ * /tmp→C:\ argument conversion. Re-enabling global suppression would re-break
+ * native git; rewriting only the mvn token keeps both correct.
+ *
+ * Only a `mvn` that starts a command (start of string, or after a shell
+ * separator `&& | ; ( newline`) is rewritten. `mvnw`, `mvnd`, `mymvn`,
+ * paths like `./mvnw`, and an already-`mvn.cmd` token are left untouched
+ * (the token must be exactly `mvn` followed by whitespace or end-of-string).
+ */
+export declare function rewriteWindowsBuildTools(code: string, platform: NodeJS.Platform): string;
 interface ExecuteOptions {
     language: Language;
     code: string;

package/build/executor.js

@@ -55,6 +55,21 @@ export function buildShellScriptContent(code, inheritedPath, platform) {
         return code;
     return `export PATH=${quoteForPosixShell(inheritedPath)}\n${code}`;
 }
+function isPowerShell(shellPath) {
+    const shellName = shellPath?.toLowerCase() ?? "";
+    return shellName.includes("powershell") || shellName.includes("pwsh");
+}
+export function buildPowerShellScriptContent(code) {
+    // Prefix a UTF-8 BOM so Windows PowerShell 5.1 reliably detects the script
+    // file as UTF-8 (without it, 5.1 falls back to the ANSI code page and
+    // mangles non-ASCII characters in the script body).
+    return [
+        "\uFEFF[Console]::InputEncoding = [System.Text.UTF8Encoding]::new()",
+        "[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new()",
+        "$OutputEncoding = [System.Text.UTF8Encoding]::new()",
+        code,
+    ].join("\n");
+}
 /**
  * Resolve the real OS temp directory, bypassing any TMPDIR env override.
  * os.tmpdir() reads TMPDIR from the environment, which some shells/tools
@@ -72,6 +87,86 @@ const OS_TMPDIR = (() => {
     catch { /* fall through */ }
     return "/tmp";
 })();
+/**
+ * Pure helper — exported for unit testing. Issue #782.
+ *
+ * On Windows, the sandbox shell runtime is Git Bash. A bare `mvn` invocation
+ * runs Maven's POSIX shell script, which on the `mingw=true` branch (uname →
+ * MINGW64_NT-*) fails to convert `CLASSWORLDS_JAR` from a POSIX path
+ * (`/c/tools/maven/boot/plexus-classworlds-*.jar`) to a Windows path. Native
+ * `java.exe` then can't resolve the bootstrap jar → ClassNotFoundException for
+ * `org.codehaus.plexus.classworlds.launcher.Launcher`.
+ *
+ * The third-way fix (issue Option C): rewrite the bare `mvn` token to `mvn.cmd`,
+ * the native Windows launcher that uses Windows-native paths and bypasses the
+ * broken mingw shell branch entirely. This does NOT touch the global MSYS
+ * path-conversion env (MSYS_NO_PATHCONV / MSYS2_ARG_CONV_EXCL), which #826/#791
+ * deliberately leave unset so native git.exe launched from bash keeps its
+ * /tmp→C:\ argument conversion. Re-enabling global suppression would re-break
+ * native git; rewriting only the mvn token keeps both correct.
+ *
+ * Only a `mvn` that starts a command (start of string, or after a shell
+ * separator `&& | ; ( newline`) is rewritten. `mvnw`, `mvnd`, `mymvn`,
+ * paths like `./mvnw`, and an already-`mvn.cmd` token are left untouched
+ * (the token must be exactly `mvn` followed by whitespace or end-of-string).
+ */
+export function rewriteWindowsBuildTools(code, platform) {
+    if (platform !== "win32")
+        return code;
+    // Rewrite a bare `mvn` command token to `mvn.cmd` (Maven's native Windows launcher).
+    // Algorithmic (no regex): only at a command-start position (string start or right
+    // after a shell separator ; & | ( newline, skipping leading spaces/tabs) and only
+    // when the token is exactly `mvn` followed by whitespace or end — leaves
+    // mvnw / mvnd / ./mvnw / already-mvn.cmd untouched.
+    const SEP = new Set([";", "&", "|", "(", "\n"]);
+    let out = "";
+    let atStart = true;
+    let i = 0;
+    while (i < code.length) {
+        const ch = code[i];
+        if (atStart && (ch === " " || ch === "\t")) {
+            out += ch;
+            i++;
+            continue;
+        }
+        if (atStart && code.startsWith("mvn", i)) {
+            const after = code[i + 3];
+            if (after === undefined || after === " " || after === "\t" || after === "\n") {
+                out += "mvn.cmd";
+                i += 3;
+                atStart = false;
+                continue;
+            }
+        }
+        out += ch;
+        atStart = SEP.has(ch);
+        i++;
+    }
+    return out;
+}
+/**
+ * Remove a sandbox temp dir, retrying on Windows. Issue #788.
+ *
+ * On Windows, a child process that opened SQLite databases inside the sandbox
+ * can leave `*-wal` / `*-shm` files with handles that linger briefly after the
+ * process exits. A single `rmSync` then throws EBUSY/EPERM/ENOTEMPTY and the
+ * old silent `catch {}` swallowed it, leaking `.ctx-mode-*` directories under
+ * `%TEMP%`. Node's `rmSync({ maxRetries, retryDelay })` is purpose-built for
+ * exactly this Windows-handle race, so let it back off and retry.
+ */
+function cleanupTmpDir(tmpDir) {
+    try {
+        rmSync(tmpDir, {
+            recursive: true,
+            force: true,
+            maxRetries: isWin ? 8 : 2,
+            retryDelay: 100,
+        });
+    }
+    catch {
+        /* best-effort — OS will reclaim %TEMP% eventually */
+    }
+}
 /** Kill process tree — on Windows uses taskkill /T; on Unix kills the process group. */
 function killTree(proc) {
     if (isWin && proc.pid) {
@@ -142,29 +237,27 @@ export class PolyglotExecutor {
             if (cmd[0] === "__rust_compile_run__") {
                 return await this.#compileAndRun(filePath, tmpDir, timeout);
             }
-            // Shell commands run in the project directory so git, relative paths,
-            // and other project-aware tools work naturally. Non-shell languages
-            // run in the temp directory where their script file is written.
-            // Issue #45 — `cwdOverride` lets per-call sites (Codex MCP handlers)
-            // pin shell cwd without mutating process-wide state.
-            const cwd = language === "shell"
-                ? (cwdOverride ?? this.#projectRoot)
-                : tmpDir;
+            // Every language runs in the project directory so git, relative paths,
+            // and other project-aware tools resolve naturally. The script FILE lives
+            // in the sandbox tmpDir and is passed to the runtime by absolute path
+            // (see buildCommand), so cwd is free to be the project root.
+            //
+            // Issue #788 — previously only `shell` used the project root; non-shell
+            // runtimes (python/js/ts/…) used tmpDir, so repo-relative checks like
+            // `pathlib.Path("package.json").exists()` silently failed depending on
+            // the chosen language. Unifying cwd removes that surprise.
+            // Issue #45 — `cwdOverride` lets per-call sites (Codex MCP handlers) pin
+            // cwd without mutating process-wide state.
+            const cwd = cwdOverride ?? this.#projectRoot;
             const result = await this.#spawn(cmd, cwd, tmpDir, timeout, background);
             // Skip tmpDir cleanup if process was backgrounded — it may still need files
             if (!result.backgrounded) {
-                try {
-                    rmSync(tmpDir, { recursive: true, force: true });
-                }
-                catch { /* ignore */ }
+                cleanupTmpDir(tmpDir);
             }
             return result;
         }
         catch (err) {
-            try {
-                rmSync(tmpDir, { recursive: true, force: true });
-            }
-            catch { /* ignore */ }
+            cleanupTmpDir(tmpDir);
             throw err;
         }
     }
@@ -190,7 +283,15 @@ export class PolyglotExecutor {
         }
         const fp = join(tmpDir, buildScriptFilename(language, process.platform, language === "shell" ? this.#runtimes.shell : null));
         if (language === "shell") {
-            writeFileSync(fp, buildShellScriptContent(code, process.env.PATH, process.platform), { encoding: "utf-8", mode: 0o700 });
+            const shellPath = this.#runtimes.shell;
+            // #782 — on Windows Git Bash, rewrite bare `mvn` → `mvn.cmd` so Maven
+            // uses its native Windows launcher (correct path handling) instead of
+            // the broken mingw shell branch. No-op on non-Windows.
+            const rewritten = rewriteWindowsBuildTools(code, process.platform);
+            const shellCode = isWin && isPowerShell(shellPath)
+                ? buildPowerShellScriptContent(rewritten)
+                : rewritten;
+            writeFileSync(fp, buildShellScriptContent(shellCode, process.env.PATH, process.platform), { encoding: "utf-8", mode: 0o700 });
         }
         else {
             writeFileSync(fp, code, "utf-8");
@@ -289,8 +390,20 @@ export class PolyglotExecutor {
                     if (proc.pid)
                         this.#backgroundedPids.add(proc.pid);
                     proc.unref();
-                    proc.stdout.destroy();
-                    proc.stderr.destroy();
+                    // Do NOT destroy stdout/stderr — closing the read end of the pipe
+                    // sends SIGPIPE to the child on its next write, killing it.
+                    // Instead, replace the data listeners with no-op drains that
+                    // consume the stream without accumulating buffers. This keeps
+                    // the pipe open and prevents the child from blocking on a full
+                    // pipe buffer.
+                    if (proc.stdout) {
+                        proc.stdout.removeAllListeners("data");
+                        proc.stdout.on("data", () => { });
+                    }
+                    if (proc.stderr) {
+                        proc.stderr.removeAllListeners("data");
+                        proc.stderr.on("data", () => { });
+                    }
                     const rawStdout = Buffer.concat(stdoutChunks).toString("utf-8");
                     const rawStderr = Buffer.concat(stderrChunks).toString("utf-8");
                     res({
@@ -493,10 +606,18 @@ export class PolyglotExecutor {
         if (!env["PATH"]) {
             env["PATH"] = isWin ? "" : "/usr/local/bin:/usr/bin:/bin";
         }
-        // Windows-critical env vars and path fixes
+        // Windows-critical PATH fixes.
         if (isWin) {
-            env["MSYS_NO_PATHCONV"] = "1";
-            env["MSYS2_ARG_CONV_EXCL"] = "*";
+            // Do not carry global MSYS path-conversion blockers into Git Bash.
+            // Native Windows tools launched from bash (notably git.exe) need MSYS
+            // to convert /tmp-style arguments to Windows paths so sibling tools see
+            // the same filesystem location (#791).
+            for (const key of Object.keys(env)) {
+                const upper = key.toUpperCase();
+                if (upper === "MSYS_NO_PATHCONV" || upper === "MSYS2_ARG_CONV_EXCL") {
+                    delete env[key];
+                }
+            }
             const gitUsrBin = "C:\\Program Files\\Git\\usr\\bin";
             const gitBin = "C:\\Program Files\\Git\\bin";
             if (!env["PATH"].includes(gitUsrBin)) {

package/build/opencode-plugin.js

@@ -179,7 +179,7 @@ async function createContextModePlugin(ctx) {
             const toolInput = output.args ?? {};
             let decision;
             try {
-                decision = routing.routePreToolUse(toolName, toolInput, projectDir, getPlatform());
+                decision = routing.routePreToolUse(toolName, toolInput, projectDir, platform);
             }
             catch {
                 return; // Routing failure → allow passthrough
@@ -194,7 +194,10 @@ async function createContextModePlugin(ctx) {
                 // Mutate output.args — OpenCode reads the mutated output object
                 Object.assign(output.args, decision.updatedInput);
             }
-            // "context" action → no-op (OpenCode doesn't support context injection)
+            if (decision.action === "context" && decision.additionalContext) {
+                // Mutate output.args — OpenCode reads the mutated output object
+                output.args.additionalContext = decision.additionalContext;
+            }
         },
         // ── PostToolUse: Session event capture ──────────────
         "tool.execute.after": async (input, output) => {

package/build/routing-block.d.ts

@@ -0,0 +1,8 @@
+import type { ToolNamer } from "./tool-naming.js";
+export interface RoutingBlockOptions {
+    includeCommands?: boolean;
+}
+export declare function createRoutingBlock(t: ToolNamer, options?: RoutingBlockOptions): string;
+export declare function createReadGuidance(t: ToolNamer): string;
+export declare function createGrepGuidance(t: ToolNamer): string;
+export declare function createBashGuidance(t: ToolNamer): string;