context-mode 1.0.136 → 1.0.137

package/build/lifecycle.js

@@ -14,35 +14,6 @@
  * Cross-platform: macOS, Linux, Windows.
  */
 import { execFileSync } from "node:child_process";
-/**
- * Resolve the idle-shutdown threshold (#565).
- *
- * Idle shutdown is OFF by default (#592) because most hosts (Claude
- * Code, Codex, editor MCP clients) keep registered tool handles after a
- * clean MCP child exit and do NOT transparently respawn on the next call.
- * The global 15 min default introduced in #568 solved OpenCode's child
- * accumulation, but stranded ctx_* tools in Claude Code/Codex-style
- * hosts once the MCP server exited cleanly while the editor stayed alive.
- *
- * Hosts that are known to benefit from idle shutdown MUST opt in via
- * CONTEXT_MODE_IDLE_TIMEOUT_MS in their MCP config. Today that is
- * OpenCode/KiloCode (their configs set 900000 = 15 min). Users and test
- * harnesses can also opt in explicitly with any positive integer.
- *
- * Missing or malformed env = 0 (disabled, safe default). Set env to
- * `0` to disable explicitly.
- *
- * Exported for unit-testing.
- */
-export function idleTimeoutForEnv(env = process.env) {
-    const raw = env.CONTEXT_MODE_IDLE_TIMEOUT_MS;
-    if (raw === undefined)
-        return 0;
-    const n = Number.parseInt(raw, 10);
-    if (!Number.isFinite(n) || n < 0)
-        return 0;
-    return n;
-}
 /** Read grandparent PID via `ps -o ppid= -p $PPID`. Returns NaN on failure or Windows. */
 function readGrandparentPpidImpl() {
     if (process.platform === "win32")
@@ -124,52 +95,25 @@ export function lifecycleGuardIntervalForEnv(env = process.env) {
     return 1000;
 }
 /**
- * Start the lifecycle guard. Returns a handle with `recordActivity` (call
- * on every MCP request to keep idle timer from firing) and `stop`.
- *
+ * Start the lifecycle guard. Returns a cleanup function.
  * Skipped automatically when stdin is a TTY (e.g. OpenCode ts-plugin).
  */
 export function startLifecycleGuard(opts) {
     const interval = opts.checkIntervalMs ?? lifecycleGuardIntervalForEnv();
     const check = opts.isParentAlive ?? defaultIsParentAlive;
-    const idleTimeoutMs = opts.idleTimeoutMs ?? idleTimeoutForEnv();
-    const now = opts.now ?? Date.now;
     let stopped = false;
-    let lastActivity = now();
     const shutdown = () => {
         if (stopped)
             return;
         stopped = true;
         opts.onShutdown();
     };
-    const recordActivity = () => {
-        lastActivity = now();
-    };
-    // P0: Periodic parent liveness check.
+    // P0: Periodic parent liveness check
     const timer = setInterval(() => {
         if (!check())
             shutdown();
     }, interval);
     timer.unref();
-    // P0+: Idle shutdown (#565). Runs on its OWN tick — distinct from the
-    // 30 s parent-liveness poll — so a 15 min idle timeout actually reacts
-    // close to 15 min instead of "next 30 s tick after 15 min". Pick the
-    // tick as min(idleTimeoutMs / 6, 30 s) so a short timeout (e.g. 3 s in
-    // e2e tests, 60 s in dev) reacts within ~16 % of its window while a
-    // production 15 min timeout still polls every 30 s (cheap).
-    //
-    // Skipped on TTY because interactive dev sessions are expected to
-    // sit idle between commands, and also when idleTimeoutMs is 0 (env
-    // opt-out via CONTEXT_MODE_IDLE_TIMEOUT_MS=0).
-    let idleTimer = null;
-    if (idleTimeoutMs > 0 && !process.stdin.isTTY) {
-        const idleTick = Math.max(50, Math.min(Math.floor(idleTimeoutMs / 6), 30_000));
-        idleTimer = setInterval(() => {
-            if (now() - lastActivity > idleTimeoutMs)
-                shutdown();
-        }, idleTick);
-        idleTimer.unref();
-    }
     // P0: OS signals — terminal close, kill, ctrl+c
     const signals = ["SIGTERM", "SIGINT"];
     if (process.platform !== "win32")
@@ -198,19 +142,11 @@ export function startLifecycleGuard(opts) {
     if (!process.stdin.isTTY) {
         process.stdin.on("end", onStdinEnd);
     }
-    const cleanup = () => {
+    return () => {
         stopped = true;
         clearInterval(timer);
-        if (idleTimer)
-            clearInterval(idleTimer);
         for (const sig of signals)
             process.removeListener(sig, shutdown);
         process.stdin.removeListener("end", onStdinEnd);
     };
-    // Hybrid: callable for legacy `const cleanup = startLifecycleGuard(...)`
-    // sites, with `.recordActivity` / `.stop` properties for the new contract.
-    const handle = cleanup;
-    handle.recordActivity = recordActivity;
-    handle.stop = cleanup;
-    return handle;
 }

package/build/server.d.ts

@@ -1,6 +1,25 @@
 #!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { type SpawnSyncOptions, type SpawnSyncReturns } from "node:child_process";
 import { ContentStore } from "./store.js";
+import { type PlatformId } from "./adapters/types.js";
+export declare const server: McpServer;
+export interface RegisteredCtxTool {
+    name: string;
+    config: Record<string, unknown>;
+    handler: (args: Record<string, unknown>) => Promise<unknown> | unknown;
+}
+export declare const REGISTERED_CTX_TOOLS: RegisteredCtxTool[];
+export declare function shouldSuppressMcpToolsForNativePluginHost(opts?: {
+    embedded?: string;
+    platform?: PlatformId;
+    settings?: Record<string, unknown> | null;
+}): boolean;
+type ToolContextOverride = {
+    projectDir: string;
+    sessionId?: string;
+};
+export declare function withProjectDirOverride<T>(projectDir: string | ToolContextOverride, fn: () => Promise<T>): Promise<T>;
 /**
  * Build the FK-attribution object passed to every ContentStore.index*() call
  * in this process. CLAUDE_SESSION_ID is the only MCP-side handle we have on

package/build/server.js

@@ -8,6 +8,7 @@ import { join, dirname, resolve, sep, isAbsolute } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir, tmpdir, cpus } from "node:os";
 import { request as httpsRequest } from "node:https";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { z } from "zod";
 import { PolyglotExecutor } from "./executor.js";
 import { runPool } from "./runPool.js";
@@ -43,19 +44,130 @@ const VERSION = (() => {
     }
     return "unknown";
 })();
-// Prevent silent server death from unhandled async errors
-process.on("unhandledRejection", (err) => {
-    process.stderr.write(`[context-mode] unhandledRejection: ${err}\n`);
-});
-process.on("uncaughtException", (err) => {
-    process.stderr.write(`[context-mode] uncaughtException: ${err?.message ?? err}\n`);
-});
+// Prevent silent MCP server death from unhandled async errors.
+//
+// Guarded for plugin-native OpenCode/Kilo imports (#574): when server.js is
+// imported only to reuse the ctx_* tool registry, these handlers would become
+// process-wide OpenCode/Kilo host handlers. In Node, adding an
+// `uncaughtException` listener changes default crash behavior, so only the
+// standalone MCP process may install them.
+if (process.env.CONTEXT_MODE_EMBEDDED_PLUGIN_TOOLS !== "1") {
+    process.on("unhandledRejection", (err) => {
+        process.stderr.write(`[context-mode] unhandledRejection: ${err}\n`);
+    });
+    process.on("uncaughtException", (err) => {
+        process.stderr.write(`[context-mode] uncaughtException: ${err?.message ?? err}\n`);
+    });
+}
 const runtimes = detectRuntimes();
 const available = getAvailableLanguages(runtimes);
-const server = new McpServer({
+export const server = new McpServer({
     name: "context-mode",
     version: VERSION,
 });
+export const REGISTERED_CTX_TOOLS = [];
+export function shouldSuppressMcpToolsForNativePluginHost(opts = {}) {
+    const embedded = opts.embedded ?? process.env.CONTEXT_MODE_EMBEDDED_PLUGIN_TOOLS;
+    if (embedded === "1")
+        return false;
+    const platform = opts.platform ?? detectPlatform().platform;
+    if (platform !== "opencode" && platform !== "kilo")
+        return false;
+    const settings = opts.settings ?? readNativePluginHostSettings(platform);
+    return settingsHasContextModePlugin(settings) && settingsHasLegacyContextModeMcp(settings);
+}
+function stripJsonComments(str) {
+    let out = "";
+    let inString = false;
+    let escaped = false;
+    let inBlockComment = false;
+    for (let i = 0; i < str.length; i++) {
+        const c = str[i];
+        const next = str[i + 1];
+        if (inBlockComment) {
+            if (c === "*" && next === "/") {
+                inBlockComment = false;
+                i++;
+            }
+            continue;
+        }
+        if (escaped) {
+            out += c;
+            escaped = false;
+            continue;
+        }
+        if (c === "\\") {
+            out += c;
+            escaped = inString;
+            continue;
+        }
+        if (c === '"') {
+            inString = !inString;
+            out += c;
+            continue;
+        }
+        if (!inString && c === "/" && next === "/") {
+            while (i < str.length && str[i] !== "\n")
+                i++;
+            if (i < str.length)
+                out += "\n";
+            continue;
+        }
+        if (!inString && c === "/" && next === "*") {
+            inBlockComment = true;
+            i++;
+            continue;
+        }
+        out += c;
+    }
+    return out
+        .replace(/,(\s*[}\]])/g, "$1");
+}
+function readNativePluginHostSettings(platform) {
+    const base = platform === "kilo" ? "kilo" : "opencode";
+    const paths = [
+        resolve(`${base}.json`),
+        resolve(`${base}.jsonc`),
+        resolve(`.${base}`, `${base}.json`),
+        resolve(`.${base}`, `${base}.jsonc`),
+        join(homedir(), ".config", base, `${base}.json`),
+        join(homedir(), ".config", base, `${base}.jsonc`),
+    ];
+    for (const p of paths) {
+        try {
+            if (!existsSync(p))
+                continue;
+            return JSON.parse(stripJsonComments(readFileSync(p, "utf8")));
+        }
+        catch { /* try next config path */ }
+    }
+    return null;
+}
+function settingsHasContextModePlugin(settings) {
+    const plugins = settings?.plugin;
+    return Array.isArray(plugins) && plugins.some((p) => typeof p === "string" && p.includes("context-mode"));
+}
+function settingsHasLegacyContextModeMcp(settings) {
+    const mcp = settings?.mcp;
+    return !!(mcp &&
+        typeof mcp === "object" &&
+        !Array.isArray(mcp) &&
+        Object.prototype.hasOwnProperty.call(mcp, "context-mode"));
+}
+const suppressMcpToolsForNativePluginHost = shouldSuppressMcpToolsForNativePluginHost();
+const originalRegisterTool = server.registerTool.bind(server);
+server.registerTool = (...args) => {
+    const [name, config, handler] = args;
+    if (suppressMcpToolsForNativePluginHost)
+        return undefined;
+    REGISTERED_CTX_TOOLS.push({ name, config, handler });
+    return originalRegisterTool(...args);
+};
+const projectDirOverride = new AsyncLocalStorage();
+export async function withProjectDirOverride(projectDir, fn) {
+    const ctx = typeof projectDir === "string" ? { projectDir } : projectDir;
+    return projectDirOverride.run(ctx, fn);
+}
 // Register empty prompts/resources handlers so MCP clients don't get -32601 (#168).
 // OpenCode calls listPrompts()/listResources() unconditionally — the error can poison
 // the SDK transport layer, causing subsequent listTools() calls to fail permanently.
@@ -76,6 +188,14 @@ const executor = new PolyglotExecutor({
 // This temp file is loaded via --require when batch commands spawn Node processes.
 const CM_FS_PRELOAD = join(tmpdir(), `cm-fs-preload-${process.pid}.js`);
 writeFileSync(CM_FS_PRELOAD, `(function(){var __cm_fs=0;process.on('exit',function(){if(__cm_fs>0)try{process.stderr.write('__CM_FS__:'+__cm_fs+'\\n')}catch(e){}});try{var f=require('fs');var ors=f.readFileSync;f.readFileSync=function(){var r=ors.apply(this,arguments);if(Buffer.isBuffer(r))__cm_fs+=r.length;else if(typeof r==='string')__cm_fs+=Buffer.byteLength(r);return r;};}catch(e){}})();\n`);
+// In the stdio MCP path, main() also removes this file during graceful
+// shutdown. Plugin-native OpenCode/Kilo imports skip main() (#574), so
+// register a top-level best-effort cleanup too to avoid leaking preload
+// snippets under /tmp when the host process exits.
+process.on("exit", () => { try {
+    unlinkSync(CM_FS_PRELOAD);
+}
+catch { /* best effort */ } });
 // Lazy singleton — no DB overhead unless index/search is used
 let _store = null;
 /**
@@ -87,6 +207,9 @@ let _store = null;
  * legacy unattributed rows readable.
  */
 export function currentAttribution() {
+    const override = projectDirOverride.getStore();
+    if (override?.sessionId)
+        return { sessionId: override.sessionId };
     // CLAUDE_SESSION_ID env var is NOT propagated to MCP servers (only to hooks).
     // Cross-adapter resolution: every adapter (15 of them) sets *_PROJECT_DIR env
     // and writes session_events via hooks. Read the most-recent session_id from
@@ -240,6 +363,9 @@ function getSessionDir() {
  * that don't set their own env var (Cursor, OpenClaw, Codex, Kiro, Zed).
  */
 function getProjectDir() {
+    const override = projectDirOverride.getStore();
+    if (override)
+        return override.projectDir;
     // Delegated to the shared resolver so the env-var chain rejects plugin
     // install paths (set by a prior MCP boot's start.mjs after `/ctx-upgrade`)
     // and prefers the shell-set PWD before the chdir'd cwd. v1.0.115 adds
@@ -3480,20 +3606,6 @@ server.registerTool("ctx_insight", {
 // Server startup
 // ─────────────────────────────────────────────────────────
 async function main() {
-    // Startup sibling sweep (#565). OpenCode/KiloCode spawn one MCP child
-    // per session/subagent and never reap them. When a new MCP child boots
-    // under a host that already has N stale idle siblings (sharing OUR
-    // ppid), reclaim them before opening our own DB / sentinel / stdio.
-    // Best effort — never blocks startup.
-    try {
-        const { startupSiblingSweep } = await import("./util/sibling-mcp.js");
-        const report = await startupSiblingSweep();
-        if (report.totalKilled > 0) {
-            console.error(`Reaped ${report.totalKilled} stale sibling MCP server(s) ` +
-                `(SIGTERM: ${report.terminatedBySigterm}, SIGKILL: ${report.terminatedBySigkill})`);
-        }
-    }
-    catch { /* best effort */ }
     // Clean up stale DB files from previous sessions
     const cleaned = cleanupStaleDBs();
     if (cleaned > 0) {
@@ -3543,38 +3655,7 @@ async function main() {
     process.on("SIGINT", () => { gracefulShutdown(); });
     process.on("SIGTERM", () => { gracefulShutdown(); });
     // Lifecycle guard: detect parent death + stdin close to prevent orphaned processes (#103)
-    // Also: idle self-shutdown (#565) — OpenCode/KiloCode open one MCP child per
-    // session AND per subagent and never tear them down for the host's lifetime,
-    // accumulating one stdio child per session (observed: 26 children / 1.6 GB
-    // RSS under a single `opencode serve` parent). Idle timeout reaps quiescent
-    // servers; live ones bump `recordActivity()` on every JSON-RPC request via
-    // the MCP SDK's `_onrequest` hook wrapped below.
-    const lifecycle = startLifecycleGuard({ onShutdown: () => gracefulShutdown() });
-    // Wrap the SDK's internal request entry so every JSON-RPC `tools/call`,
-    // `tools/list`, etc. resets the idle timer. We intercept at this layer
-    // rather than per-tool because (a) it covers ALL requests, including
-    // listTools / listPrompts / listResources / ping, and (b) it survives
-    // future tool additions without each handler needing to remember to opt in.
-    //
-    // The cast is necessary because `_onrequest` is intentionally undocumented
-    // in the SDK's public types. Best effort — if the field shape changes in
-    // a future SDK release the lifecycle still works, idle reset just degrades
-    // to "untriggered" which simply means the server lives until the next
-    // ppid/signal-based exit path fires. We never block the request path.
-    try {
-        const inner = server.server;
-        const origOnRequest = inner._onrequest;
-        if (typeof origOnRequest === "function") {
-            inner._onrequest = function (...args) {
-                try {
-                    lifecycle.recordActivity();
-                }
-                catch { /* never break request path */ }
-                return origOnRequest.apply(this, args);
-            };
-        }
-    }
-    catch { /* best effort — see comment above */ }
+    startLifecycleGuard({ onShutdown: () => gracefulShutdown() });
     const transport = new StdioServerTransport();
     await server.connect(transport);
     // Write MCP readiness sentinel (#230)
@@ -3642,7 +3723,9 @@ async function main() {
         }
     }
 }
-main().catch((err) => {
-    console.error("Fatal:", err);
-    process.exit(1);
-});
+if (process.env.CONTEXT_MODE_EMBEDDED_PLUGIN_TOOLS !== "1") {
+    main().catch((err) => {
+        console.error("Fatal:", err);
+        process.exit(1);
+    });
+}

package/build/session/db.d.ts

@@ -216,6 +216,12 @@ export declare class SessionDB extends SQLiteBase {
      * Return the most recently attributed project dir for a session.
      */
     getLatestAttributedProjectDir(sessionId: string): string | null;
+    /**
+     * Look up the project_dir from session_meta as a last-resort fallback
+     * for event attribution. Prevents project_dir='' orphans when the caller
+     * (e.g. pi adapter) omits the attribution parameter.
+     */
+    _getSessionProjectDir(sessionId: string): string;
     /**
      * Search events by text query scoped to a project directory.
      *

package/build/session/db.js

@@ -491,7 +491,7 @@ export class SessionDB extends SQLiteBase {
         // ── Search ──
         p(S.searchEvents, `SELECT id, session_id, category, type, data, created_at
        FROM session_events
-       WHERE project_dir = ?
+       WHERE (project_dir = ? OR project_dir = '')
          AND (data LIKE '%' || ? || '%' ESCAPE '\\' OR category LIKE '%' || ? || '%' ESCAPE '\\')
          AND (? IS NULL OR category = ?)
        ORDER BY id ASC
@@ -536,7 +536,7 @@ export class SessionDB extends SQLiteBase {
             .toUpperCase();
         const projectDir = String(attribution?.projectDir
             ?? event.project_dir
-            ?? "").trim();
+            ?? this._getSessionProjectDir(sessionId)).trim();
         const attributionSource = String(attribution?.source
             ?? event.attribution_source
             ?? "unknown");
@@ -595,7 +595,7 @@ export class SessionDB extends SQLiteBase {
                 .slice(0, 16)
                 .toUpperCase();
             const attribution = attributions?.[i];
-            const projectDir = String(attribution?.projectDir ?? event.project_dir ?? "").trim();
+            const projectDir = String(attribution?.projectDir ?? event.project_dir ?? this._getSessionProjectDir(sessionId) ?? "").trim();
             const attributionSource = String(attribution?.source ?? event.attribution_source ?? "unknown");
             const rawConfidence = Number(attribution?.confidence ?? event.attribution_confidence ?? 0);
             const attributionConfidence = Number.isFinite(rawConfidence)
@@ -681,6 +681,20 @@ export class SessionDB extends SQLiteBase {
         const row = this.stmt(S.getLatestAttributedProject).get(sessionId);
         return row?.project_dir || null;
     }
+    /**
+     * Look up the project_dir from session_meta as a last-resort fallback
+     * for event attribution. Prevents project_dir='' orphans when the caller
+     * (e.g. pi adapter) omits the attribution parameter.
+     */
+    _getSessionProjectDir(sessionId) {
+        try {
+            const row = this.db.prepare("SELECT project_dir FROM session_meta WHERE session_id = ?").get(sessionId);
+            return row?.project_dir || "";
+        }
+        catch {
+            return "";
+        }
+    }
     /**
      * Search events by text query scoped to a project directory.
      *

package/build/util/sibling-mcp.d.ts

@@ -38,21 +38,6 @@ export interface DiscoverOptions {
     platform?: NodeJS.Platform;
     /** Test injection point — defaults to `child_process.execFileSync`. */
     runCommand?: RunCommand;
-    /**
-     * When true, only return pids whose parent (ppid) is the SAME as the
-     * caller's own ppid (i.e. siblings under the same host process).
-     *
-     * Used by the startup sweep (#565) so an opencode-spawned MCP child
-     * only reaps OTHER opencode-spawned MCP children, never the children
-     * of a different opencode/Claude host running in parallel.
-     *
-     * Requires a way to read each pid's ppid. Defaults to a `ps -o ppid=`
-     * probe on POSIX and PowerShell `Get-CimInstance` on Windows. Set
-     * `readPpid` to inject in tests.
-     */
-    sameParentOnly?: boolean;
-    /** Test injection — read ppid for a given pid. Defaults to platform probe. */
-    readPpid?: (pid: number) => number;
 }
 export interface KillOptions {
     pids: readonly number[];
@@ -92,28 +77,3 @@ export declare function discoverSiblingMcpPids(opts: DiscoverOptions): number[];
  *      counted — they were not ours to kill.
  */
 export declare function killSiblingMcpServers(opts: KillOptions): Promise<KillReport>;
-/**
- * Startup-time sibling sweep (#565).
- *
- * Discovers any context-mode MCP server pids that share OUR parent process
- * (i.e. other MCP children of the same host like `opencode serve`) and
- * terminates them. The intent is "exactly one MCP child per host" — when a
- * new MCP client spawns inside an opencode host that already has 25 stale
- * idle siblings, this sweep reclaims them at boot rather than waiting for
- * the idle timeout to fire on each one independently.
- *
- * Gated by env (default-on but easy to disable):
- *
- *   CONTEXT_MODE_STARTUP_SWEEP=0   → disabled
- *   CONTEXT_MODE_STARTUP_SWEEP=1   → enabled (default)
- *
- * Safety:
- *   - `sameParentOnly: true` — never touches MCP children of a different host.
- *   - Best-effort throughout: failures never block server startup.
- *   - Composes with the idle-timeout path: if a sibling is actively in use
- *     by another session, the parent process will simply spawn a new MCP
- *     child on its next request. The cost is one cold-start (~1–3 s) for
- *     that session, which is identical to opencode's existing behaviour
- *     of spawning a fresh MCP child per session anyway.
- */
-export declare function startupSiblingSweep(env?: NodeJS.ProcessEnv): Promise<KillReport>;

package/build/util/sibling-mcp.js

@@ -26,70 +26,19 @@
  * cross-platform without spawning real processes.
  */
 import { execFileSync } from "node:child_process";
-// Match every shape an installed context-mode MCP server can take in argv:
-//
-//   1. `~/.claude/plugins/cache/context-mode/context-mode/<v>/start.mjs`
-//      and `~/.claude/plugins/marketplaces/context-mode/start.mjs` — Claude
-//      Code plugin shapes (original #559 case).
-//   2. `<prefix>/node_modules/context-mode/start.mjs` or `.../server.bundle.mjs`
-//      — npm-global, marketplace, manual installs.
-//   3. `<prefix>/bin/context-mode` — npm-global bin shim. This is the argv
-//      OpenCode + KiloCode see when they spawn `mcp.command = ["context-mode"]`.
-//      Without this entry, sibling discovery missed the 26-child / 1.6 GB
-//      RSS accumulation reported in #565.
-//   4. `bun .../context-mode/server.bundle.mjs` — Pi/Bun hosts.
-//
-// All four can be alive concurrently — VERDICT R1 dump confirmed multi-version
-// coexistence on real macOS, and #565 confirmed concurrent OpenCode children
-// alongside Claude Code children on Linux.
-const POSIX_PGREP_PATTERN = "(node|bun).*(plugins/(cache|marketplaces)/.*context-mode.*start\\.mjs" +
-    "|context-mode/start\\.mjs" +
-    "|context-mode/server\\.bundle\\.mjs" +
-    "|bin/context-mode($|[^a-zA-Z0-9_-]))";
+// Match BOTH `~/.claude/plugins/cache/context-mode/context-mode/<v>/start.mjs`
+// AND `~/.claude/plugins/marketplaces/context-mode/start.mjs` shapes.
+// Both can be alive concurrently — VERDICT R1 dump confirmed all four
+// PIDs simultaneously across three different versions on a real Mac.
+const POSIX_PGREP_PATTERN = "node.*plugins/(cache|marketplaces)/.*context-mode.*start\\.mjs";
 // Windows: PowerShell + Get-CimInstance (wmic deprecated since Win11 22H2).
-// Filter includes both node.exe and bun.exe (Pi/Bun hosts). CommandLine
-// matching covers the same four install shapes as POSIX_PGREP_PATTERN.
+// Filter on CommandLine because Win32_Process.Name is just "node.exe".
+// Two backslashes inside `start\.mjs` are needed because the Like operator
+// uses regex-ish escaping at the JS layer.
 const WIN_PS_SCRIPT = "Get-CimInstance Win32_Process " +
-    "-Filter \"Name='node.exe' OR Name='bun.exe'\" | " +
-    "Where-Object { $_.CommandLine -match " +
-    "'plugins[\\\\/](cache|marketplaces)[\\\\/].*context-mode.*start\\.mjs" +
-    "|context-mode[\\\\/]start\\.mjs" +
-    "|context-mode[\\\\/]server\\.bundle\\.mjs" +
-    "|bin[\\\\/]context-mode($|[^a-zA-Z0-9_-])' } | " +
+    "-Filter \"Name='node.exe'\" | " +
+    "Where-Object { $_.CommandLine -match 'plugins[\\\\/](cache|marketplaces)[\\\\/].*context-mode.*start\\.mjs' } | " +
     "Select-Object -ExpandProperty ProcessId";
-/** POSIX ppid probe — empty / NaN on failure. */
-function readPpidPosix(pid) {
-    try {
-        const out = execFileSync("ps", ["-o", "ppid=", "-p", String(pid)], {
-            encoding: "utf-8",
-            timeout: 2000,
-            stdio: ["ignore", "pipe", "ignore"],
-        }).trim();
-        const n = Number.parseInt(out, 10);
-        return Number.isFinite(n) ? n : NaN;
-    }
-    catch {
-        return NaN;
-    }
-}
-/** Windows ppid probe — empty / NaN on failure. */
-function readPpidWin32(pid) {
-    try {
-        const out = execFileSync("powershell", [
-            "-NoProfile",
-            "-Command",
-            `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").ParentProcessId`,
-        ], { encoding: "utf-8", timeout: 2000, stdio: ["ignore", "pipe", "ignore"] }).trim();
-        const n = Number.parseInt(out, 10);
-        return Number.isFinite(n) ? n : NaN;
-    }
-    catch {
-        return NaN;
-    }
-}
-function defaultReadPpid(pid) {
-    return process.platform === "win32" ? readPpidWin32(pid) : readPpidPosix(pid);
-}
 const defaultRun = (cmd, args) => execFileSync(cmd, [...args], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
 const defaultIsAlive = (pid) => {
     try {
@@ -145,18 +94,7 @@ export function discoverSiblingMcpPids(opts) {
     catch {
         return [];
     }
-    const candidates = parsePidList(stdout).filter((pid) => pid !== opts.ownPid && pid !== opts.ownPpid);
-    if (!opts.sameParentOnly)
-        return candidates;
-    // Startup-sweep mode (#565): only reap siblings sharing OUR ppid. This
-    // prevents an opencode-spawned MCP child from killing a Claude Code MCP
-    // child (or another concurrent opencode host's children) when both are
-    // present on the same machine.
-    const readPpid = opts.readPpid ?? defaultReadPpid;
-    return candidates.filter((pid) => {
-        const ppid = readPpid(pid);
-        return Number.isFinite(ppid) && ppid === opts.ownPpid;
-    });
+    return parsePidList(stdout).filter((pid) => pid !== opts.ownPid && pid !== opts.ownPpid);
 }
 /** Sleep helper — Promise-based for use inside the kill polling loop. */
 function delay(ms) {
@@ -241,46 +179,3 @@ export async function killSiblingMcpServers(opts) {
         totalKilled: terminatedBySigterm + terminatedBySigkill,
     };
 }
-/**
- * Startup-time sibling sweep (#565).
- *
- * Discovers any context-mode MCP server pids that share OUR parent process
- * (i.e. other MCP children of the same host like `opencode serve`) and
- * terminates them. The intent is "exactly one MCP child per host" — when a
- * new MCP client spawns inside an opencode host that already has 25 stale
- * idle siblings, this sweep reclaims them at boot rather than waiting for
- * the idle timeout to fire on each one independently.
- *
- * Gated by env (default-on but easy to disable):
- *
- *   CONTEXT_MODE_STARTUP_SWEEP=0   → disabled
- *   CONTEXT_MODE_STARTUP_SWEEP=1   → enabled (default)
- *
- * Safety:
- *   - `sameParentOnly: true` — never touches MCP children of a different host.
- *   - Best-effort throughout: failures never block server startup.
- *   - Composes with the idle-timeout path: if a sibling is actively in use
- *     by another session, the parent process will simply spawn a new MCP
- *     child on its next request. The cost is one cold-start (~1–3 s) for
- *     that session, which is identical to opencode's existing behaviour
- *     of spawning a fresh MCP child per session anyway.
- */
-export async function startupSiblingSweep(env = process.env) {
-    const empty = { terminatedBySigterm: 0, terminatedBySigkill: 0, totalKilled: 0 };
-    const raw = env.CONTEXT_MODE_STARTUP_SWEEP;
-    if (raw === "0" || raw === "false")
-        return empty;
-    try {
-        const pids = discoverSiblingMcpPids({
-            ownPid: process.pid,
-            ownPpid: process.ppid,
-            sameParentOnly: true,
-        });
-        if (pids.length === 0)
-            return empty;
-        return await killSiblingMcpServers({ pids });
-    }
-    catch {
-        return empty;
-    }
-}