context-mode 1.0.103 → 1.0.105

package/build/cli.js

@@ -13,7 +13,7 @@
  */
 import * as p from "@clack/prompts";
 import color from "picocolors";
-import { execFileSync } from "node:child_process";
+import { execFileSync, execFile as nodeExecFile } from "node:child_process";
 import { readFileSync, writeFileSync, cpSync, accessSync, existsSync, rmSync, closeSync, openSync, chmodSync, constants } from "node:fs";
 import { request as httpsRequest } from "node:https";
 import { resolve, dirname, join } from "node:path";
@@ -111,6 +111,11 @@ else if (args[0] === "hook") {
 else if (args[0] === "insight") {
     insight(args[1] ? Number(args[1]) : 4747);
 }
+else if (args[0] === "statusline") {
+    // Status line implementation lives in bin/statusline.mjs to keep it
+    // dependency-free and fast. Forward stdin and exit with its result.
+    statuslineForward();
+}
 else {
     // Default: start MCP server
     import("./server.js");
@@ -142,6 +147,37 @@ export function npmExec(command, opts = {}) {
         ...(isWin ? { shell: true } : {}),
     });
 }
+export function openInBrowser(url, platform = process.platform, runner = nodeExecFile) {
+    const opts = { stdio: "ignore" };
+    const hint = () => console.error(`\nCould not auto-open browser. Open manually: ${url}`);
+    try {
+        if (platform === "darwin") {
+            runner("open", [url], opts);
+        }
+        else if (platform === "win32") {
+            // `start` is a cmd.exe builtin; first arg after `start` is the
+            // window title — pass empty so the URL isn't consumed as a title.
+            runner("cmd", ["/c", "start", "", url], opts);
+        }
+        else {
+            // linux/bsd: try xdg-open, fall back to sensible-browser.
+            try {
+                runner("xdg-open", [url], opts);
+            }
+            catch {
+                try {
+                    runner("sensible-browser", [url], opts);
+                }
+                catch {
+                    hint();
+                }
+            }
+        }
+    }
+    catch {
+        hint();
+    }
+}
 function defaultPluginRoot() {
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = dirname(__filename);
@@ -152,15 +188,19 @@ function defaultPluginRoot() {
     }
     return __dirname;
 }
-// Opencode/Kilocode install plugins from npm into .cache folder
+// Opencode/Kilocode install plugins from npm into a per-package cache folder.
+// Layout (changed silently in late 2024 — see PR #376 / KiloCode#9503):
+//   POSIX  : ~/.cache/<platform>/packages/context-mode@latest/node_modules/context-mode
+//   Windows: %LOCALAPPDATA%\<platform>\packages\context-mode@latest\node_modules\context-mode
 function cachePluginRoot(platform) {
+    const subPath = ["packages", "context-mode@latest", "node_modules", "context-mode"];
     if (process.platform === "win32") {
         const localApp = process.env.LOCALAPPDATA;
         if (localApp)
-            return resolve(localApp, platform, "node_modules", "context-mode");
-        return resolve(homedir(), "AppData", "Local", platform, "node_modules", "context-mode");
+            return resolve(localApp, platform, ...subPath);
+        return resolve(homedir(), "AppData", "Local", platform, ...subPath);
     }
-    return resolve(homedir(), ".cache", platform, "node_modules", "context-mode");
+    return resolve(homedir(), ".cache", platform, ...subPath);
 }
 function getPluginRoot() {
     const platform = detectPlatform().platform;
@@ -477,17 +517,8 @@ async function insight(port) {
             child.kill();
             process.exit(1);
         }
-        // Open browser
-        const platform = process.platform;
-        try {
-            if (platform === "darwin")
-                execSync(`open "${url}"`, { stdio: "pipe" });
-            else if (platform === "win32")
-                execSync(`start "" "${url}"`, { stdio: "pipe" });
-            else
-                execSync(`xdg-open "${url}" 2>/dev/null || sensible-browser "${url}" 2>/dev/null`, { stdio: "pipe" });
-        }
-        catch { /* best effort */ }
+        // 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); });
@@ -737,3 +768,18 @@ async function upgrade() {
             color.dim(` — restart your ${adapter.name} session to pick up the new version`));
     }
 }
+/* -------------------------------------------------------
+ * statusline — forward to bin/statusline.mjs
+ * ------------------------------------------------------- */
+function statuslineForward() {
+    const scriptPath = resolve(getPluginRoot(), "bin", "statusline.mjs");
+    if (!existsSync(scriptPath)) {
+        process.stderr.write(`statusline script missing: ${scriptPath}\n`);
+        process.exit(1);
+    }
+    // Re-exec via dynamic import so stdin/stdout are inherited cleanly.
+    import(pathToFileURL(scriptPath).href).catch((err) => {
+        process.stderr.write(`statusline failed: ${err?.message ?? err}\n`);
+        process.exit(1);
+    });
+}

package/build/concurrency/runPool.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Generic in-flight-capped worker pool.
+ *
+ * Used by:
+ *   - runBatchCommands (ctx_batch_execute parallel branch)
+ *   - runBatchFetch    (ctx_fetch_and_index batch path)
+ *
+ * Returns Promise.allSettled-style results so one job's throw cannot
+ * strand siblings. Caller maps fulfilled/rejected per index. Output
+ * order is preserved by input index (not completion order).
+ *
+ * Designed to be the SINGLE concurrency primitive for the project —
+ * all "run N independent operations with at most M in flight" needs
+ * route here. Avoids the worker-pool copy-paste flagged in the
+ * concurrency PRD architectural review (finding G).
+ */
+export interface PoolJob<T> {
+    run(): Promise<T>;
+}
+export interface RunPoolOptions {
+    /** Hard concurrency cap (1-N). Auto-clamped to job count. */
+    concurrency: number;
+    /** Optional: also clamp by `os.cpus().length` (memory-pressure safety). Default false. */
+    capByCpuCount?: boolean;
+    /** Optional: per-settled callback (e.g. for progress reporting / metrics). */
+    onSettled?: (idx: number, result: PromiseSettledResult<unknown>) => void;
+}
+export interface RunPoolResult<T> {
+    /** Per-index settled result, ordered by input index. */
+    settled: PromiseSettledResult<T>[];
+    /** Concurrency actually used after all caps applied. */
+    effectiveConcurrency: number;
+    /** True when effectiveConcurrency < requested concurrency. */
+    capped: boolean;
+}
+export declare function runPool<T>(jobs: PoolJob<T>[], opts: RunPoolOptions): Promise<RunPoolResult<T>>;

package/build/concurrency/runPool.js

@@ -0,0 +1,51 @@
+/**
+ * Generic in-flight-capped worker pool.
+ *
+ * Used by:
+ *   - runBatchCommands (ctx_batch_execute parallel branch)
+ *   - runBatchFetch    (ctx_fetch_and_index batch path)
+ *
+ * Returns Promise.allSettled-style results so one job's throw cannot
+ * strand siblings. Caller maps fulfilled/rejected per index. Output
+ * order is preserved by input index (not completion order).
+ *
+ * Designed to be the SINGLE concurrency primitive for the project —
+ * all "run N independent operations with at most M in flight" needs
+ * route here. Avoids the worker-pool copy-paste flagged in the
+ * concurrency PRD architectural review (finding G).
+ */
+import { cpus } from "node:os";
+export async function runPool(jobs, opts) {
+    const { concurrency, capByCpuCount = false, onSettled } = opts;
+    if (jobs.length === 0) {
+        return { settled: [], effectiveConcurrency: 0, capped: false };
+    }
+    const requested = Math.max(1, concurrency);
+    const cpuCap = capByCpuCount ? Math.max(1, cpus().length) : requested;
+    const effectiveConcurrency = Math.min(requested, cpuCap, jobs.length);
+    const capped = effectiveConcurrency < requested;
+    const settled = new Array(jobs.length);
+    let nextIdx = 0;
+    async function worker() {
+        while (true) {
+            const idx = nextIdx++;
+            if (idx >= jobs.length)
+                return;
+            try {
+                const value = await jobs[idx].run();
+                settled[idx] = { status: "fulfilled", value };
+            }
+            catch (err) {
+                settled[idx] = { status: "rejected", reason: err };
+            }
+            onSettled?.(idx, settled[idx]);
+        }
+    }
+    const workers = [];
+    for (let w = 0; w < effectiveConcurrency; w++)
+        workers.push(worker());
+    // allSettled defends against any promise rejection escaping a worker
+    // (the worker already swallows its own errors, but this is belt-and-braces).
+    await Promise.allSettled(workers);
+    return { settled, effectiveConcurrency, capped };
+}

package/build/executor.d.ts

@@ -1,6 +1,16 @@
 import { type RuntimeMap, type Language } from "./runtime.js";
 export type { ExecResult } from "./types.js";
 import type { ExecResult } from "./types.js";
+/** Pure helper — exported for unit testing. Returns "script" or "script.<ext>". */
+export declare function buildScriptFilename(language: Language, platform: NodeJS.Platform, shellPath?: string | null): string;
+/**
+ * Pure helper — exported for unit testing. Adds `windowsHide: true` on Windows
+ * to prevent the spawned shell from creating a visible console window that
+ * intercepts stdout (issue #384).
+ */
+export declare function buildSpawnOptions(platform: NodeJS.Platform): {
+    windowsHide: boolean;
+};
 interface ExecuteOptions {
     language: Language;
     code: string;
@@ -15,7 +25,7 @@ export declare class PolyglotExecutor {
     #private;
     constructor(opts?: {
         hardCapBytes?: number;
-        projectRoot?: string;
+        projectRoot?: string | (() => string);
         runtimes?: RuntimeMap;
     });
     get runtimes(): RuntimeMap;

package/build/executor.js

@@ -4,6 +4,44 @@ import { join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 import { detectRuntimes, buildCommand, } from "./runtime.js";
 const isWin = process.platform === "win32";
+/**
+ * Pure helper: extension map for temp script files per language.
+ * On Windows, shell scripts usually get NO extension to avoid Windows
+ * file-association for `.sh` (which spawns a visible Git Bash window over the
+ * user's IDE). Windows PowerShell/pwsh is the exception because `-File`
+ * requires `.ps1` there.
+ */
+const SCRIPT_EXT = {
+    javascript: "js",
+    typescript: "ts",
+    python: "py",
+    shell: "sh",
+    ruby: "rb",
+    go: "go",
+    rust: "rs",
+    php: "php",
+    perl: "pl",
+    r: "R",
+    elixir: "exs",
+};
+/** Pure helper — exported for unit testing. Returns "script" or "script.<ext>". */
+export function buildScriptFilename(language, platform, shellPath) {
+    if (platform === "win32" && language === "shell") {
+        const shellName = shellPath?.toLowerCase() ?? "";
+        return shellName.includes("powershell") || shellName.includes("pwsh")
+            ? "script.ps1"
+            : "script";
+    }
+    return `script.${SCRIPT_EXT[language]}`;
+}
+/**
+ * Pure helper — exported for unit testing. Adds `windowsHide: true` on Windows
+ * to prevent the spawned shell from creating a visible console window that
+ * intercepts stdout (issue #384).
+ */
+export function buildSpawnOptions(platform) {
+    return { windowsHide: platform === "win32" };
+}
 /**
  * Resolve the real OS temp directory, bypassing any TMPDIR env override.
  * os.tmpdir() reads TMPDIR from the environment, which some shells/tools
@@ -39,15 +77,34 @@ function killTree(proc) {
 }
 export class PolyglotExecutor {
     #hardCapBytes;
-    #projectRoot;
+    /**
+     * Resolves the project root on every access. Stored as a thunk so the
+     * executor stays in sync with server-side env-cascade resolvers (e.g.
+     * `getProjectDir` in server.ts) instead of capturing a snapshot of
+     * `CLAUDE_PROJECT_DIR` at construction time. String inputs are wrapped
+     * to preserve constructor backward compatibility.
+     */
+    #projectRootResolver;
     #runtimes;
     /** PIDs of backgrounded processes — killed on cleanup to prevent zombies. */
     #backgroundedPids = new Set();
     constructor(opts) {
         this.#hardCapBytes = opts?.hardCapBytes ?? 100 * 1024 * 1024; // 100MB
-        this.#projectRoot = opts?.projectRoot ?? process.cwd();
+        const pr = opts?.projectRoot;
+        if (typeof pr === "function") {
+            this.#projectRootResolver = pr;
+        }
+        else if (typeof pr === "string") {
+            this.#projectRootResolver = () => pr;
+        }
+        else {
+            this.#projectRootResolver = () => process.cwd();
+        }
         this.#runtimes = opts?.runtimes ?? detectRuntimes();
     }
+    get #projectRoot() {
+        return this.#projectRootResolver();
+    }
     get runtimes() {
         return { ...this.#runtimes };
     }
@@ -63,7 +120,7 @@ export class PolyglotExecutor {
         this.#backgroundedPids.clear();
     }
     async execute(opts) {
-        const { language, code, timeout = 30_000, background = false } = opts;
+        const { language, code, timeout, background = false } = opts;
         const tmpDir = mkdtempSync(join(OS_TMPDIR, ".ctx-mode-"));
         try {
             const filePath = this.#writeScript(tmpDir, code, language);
@@ -95,25 +152,12 @@ export class PolyglotExecutor {
         }
     }
     async executeFile(opts) {
-        const { path: filePath, language, code, timeout = 30_000 } = opts;
+        const { path: filePath, language, code, timeout } = opts;
         const absolutePath = resolve(this.#projectRoot, filePath);
         const wrappedCode = this.#wrapWithFileContent(absolutePath, language, code);
         return this.execute({ language, code: wrappedCode, timeout });
     }
     #writeScript(tmpDir, code, language) {
-        const extMap = {
-            javascript: "js",
-            typescript: "ts",
-            python: "py",
-            shell: "sh",
-            ruby: "rb",
-            go: "go",
-            rust: "rs",
-            php: "php",
-            perl: "pl",
-            r: "R",
-            elixir: "exs",
-        };
         // Go needs a main package wrapper if not present
         if (language === "go" && !code.includes("package ")) {
             code = `package main\n\nimport "fmt"\n\nfunc main() {\n${code}\n}\n`;
@@ -127,7 +171,7 @@ export class PolyglotExecutor {
             const escaped = JSON.stringify(join(this.#projectRoot, "_build/dev/lib"));
             code = `Path.wildcard(Path.join(${escaped}, "*/ebin"))\n|> Enum.each(&Code.prepend_path/1)\n\n${code}`;
         }
-        const fp = join(tmpDir, `script.${extMap[language]}`);
+        const fp = join(tmpDir, buildScriptFilename(language, process.platform, language === "shell" ? this.#runtimes.shell : null));
         if (language === "shell") {
             writeFileSync(fp, code, { encoding: "utf-8", mode: 0o700 });
         }
@@ -139,11 +183,13 @@ export class PolyglotExecutor {
     async #compileAndRun(srcPath, cwd, timeout) {
         const binSuffix = isWin ? ".exe" : "";
         const binPath = srcPath.replace(/\.rs$/, "") + binSuffix;
-        // Compile
+        // Compile — cap rustc invocation at 60s when caller didn't bound the
+        // overall timeout (a hung compile shouldn't run forever even if the
+        // caller is fine with a long-running binary afterwards).
         try {
             execFileSync("rustc", [srcPath, "-o", binPath], {
                 cwd,
-                timeout: Math.min(timeout, 60_000),
+                timeout: timeout === undefined ? 60_000 : Math.min(timeout, 60_000),
                 encoding: "utf-8",
                 stdio: ["pipe", "pipe", "pipe"],
             });
@@ -186,10 +232,20 @@ export class PolyglotExecutor {
                 shell: needsShell,
                 // On Unix, create a new process group so killTree can kill all children
                 detached: !isWin,
+                // Hide the spawned-process console window on Windows. Without this,
+                // child_process.spawn creates a visible window that intercepts stdout,
+                // leaving the MCP response empty and popping a Git Bash terminal over
+                // the user's IDE. Issue #384.
+                ...buildSpawnOptions(process.platform),
             });
             let timedOut = false;
             let resolved = false;
-            const timer = setTimeout(() => {
+            // Issue #406 — if the caller didn't pass a timeout we don't fire one.
+            // Timeout policy belongs to the MCP host/client (Claude Code, VSCode,
+            // JetBrains all enforce their own RPC timeouts); imposing a second
+            // policy here turned 30-minute Gradle/Maven/SBT builds into spurious
+            // false negatives whenever the caller forgot the explicit value.
+            const timer = timeout === undefined ? undefined : setTimeout(() => {
                 timedOut = true;
                 if (background) {
                     // Background mode: detach process, return partial output, keep running

package/build/fetch-cache.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Cache-key / storage-label composition for ctx_fetch_and_index.
+ *
+ * Two distinct URLs that share a user-supplied `source` label MUST NOT collide
+ * in the cache (or in FTS5 storage, since indexing dedups by label). Compose
+ * `${source}::${url}` whenever a `source` is explicitly provided so cache
+ * lookup, dedup, and re-indexing are all per-(source,url). When no `source`
+ * is provided the URL itself is the unique key — no composition needed.
+ *
+ * `ctx_search(source: "Docs")` continues to work because LIKE-mode source
+ * filtering matches on the substring "Docs" inside "Docs::https://…".
+ */
+export declare function composeFetchCacheKey(source: string | undefined, url: string): string;

package/build/fetch-cache.js

@@ -0,0 +1,15 @@
+/**
+ * Cache-key / storage-label composition for ctx_fetch_and_index.
+ *
+ * Two distinct URLs that share a user-supplied `source` label MUST NOT collide
+ * in the cache (or in FTS5 storage, since indexing dedups by label). Compose
+ * `${source}::${url}` whenever a `source` is explicitly provided so cache
+ * lookup, dedup, and re-indexing are all per-(source,url). When no `source`
+ * is provided the URL itself is the unique key — no composition needed.
+ *
+ * `ctx_search(source: "Docs")` continues to work because LIKE-mode source
+ * filtering matches on the substring "Docs" inside "Docs::https://…".
+ */
+export function composeFetchCacheKey(source, url) {
+    return source === undefined ? url : `${source}::${url}`;
+}

package/build/lifecycle.d.ts

@@ -4,8 +4,12 @@
  * Detects parent process death (ppid polling) and OS signals to prevent
  * orphaned MCP server processes consuming 100% CPU (issue #103).
  *
- * Stdin close is NOT used as a shutdown signal — the MCP stdio transport
- * owns stdin and transient pipe events cause spurious -32000 errors (#236).
+ * Stdin close is NOT used as a *standalone* shutdown signal — the MCP stdio
+ * transport owns stdin and transient pipe events cause spurious -32000
+ * errors (#236). We do, however, treat stdin EOF as a hint to re-run the
+ * parent-liveness probe immediately (instead of waiting up to 30 s for the
+ * next poll tick), which closes the multi-day CPU-spin window seen in
+ * #311/#388 without reintroducing the false-positive shutdowns of #236.
  *
  * Cross-platform: macOS, Linux, Windows.
  */

package/build/lifecycle.js

@@ -4,8 +4,12 @@
  * Detects parent process death (ppid polling) and OS signals to prevent
  * orphaned MCP server processes consuming 100% CPU (issue #103).
  *
- * Stdin close is NOT used as a shutdown signal — the MCP stdio transport
- * owns stdin and transient pipe events cause spurious -32000 errors (#236).
+ * Stdin close is NOT used as a *standalone* shutdown signal — the MCP stdio
+ * transport owns stdin and transient pipe events cause spurious -32000
+ * errors (#236). We do, however, treat stdin EOF as a hint to re-run the
+ * parent-liveness probe immediately (instead of waiting up to 30 s for the
+ * next poll tick), which closes the multi-day CPU-spin window seen in
+ * #311/#388 without reintroducing the false-positive shutdowns of #236.
  *
  * Cross-platform: macOS, Linux, Windows.
  */
@@ -93,10 +97,33 @@ export function startLifecycleGuard(opts) {
         signals.push("SIGHUP");
     for (const sig of signals)
         process.on(sig, shutdown);
+    // P0: Stdin-EOF assist (#311/#388). The vendored MCP SDK's
+    // StdioServerTransport only registers 'data' / 'error' listeners — not
+    // 'end' — so when the parent (e.g. Claude Code) dies abruptly without
+    // sending SIGTERM, the server keeps reading from a half-closed pipe and
+    // CPU-spins until the 30 s ppid poll catches up. Observed in #388 with
+    // single processes accumulating ~80 h of CPU time before SIGKILL.
+    //
+    // We deliberately DO NOT call shutdown() unconditionally on 'end' — that
+    // is exactly the false-positive behavior #236 tore out. Instead we run
+    // the same isParentAlive() check the periodic timer uses, just earlier.
+    // If the parent is alive, this is a no-op and the existing #236
+    // regression test still passes; if the parent is gone, we collapse the
+    // 30 s detection window to ~0.
+    //
+    // Skipped on TTY (OpenCode ts-plugin) where stdin is not the MCP channel.
+    const onStdinEnd = () => {
+        if (!check())
+            shutdown();
+    };
+    if (!process.stdin.isTTY) {
+        process.stdin.on("end", onStdinEnd);
+    }
     return () => {
         stopped = true;
         clearInterval(timer);
         for (const sig of signals)
             process.removeListener(sig, shutdown);
+        process.stdin.removeListener("end", onStdinEnd);
     };
 }

package/build/opencode-plugin.d.ts

@@ -55,6 +55,28 @@ interface CompactingHookOutput {
     context: string[];
     prompt?: string;
 }
+/**
+ * OpenCode experimental.chat.system.transform — first parameter.
+ * Verified against sst/opencode/dev/packages/plugin/src/index.ts:
+ *   input: { sessionID?: string; model: Model }
+ * `sessionID` is optional in the SDK type but is in practice always set
+ * (the transform runs *for* a session). We treat it as required and
+ * skip injection when absent rather than fall back to a fabricated ID.
+ *
+ * NOTE: We deliberately do NOT use `experimental.chat.messages.transform`.
+ * Its SDK input shape is `{}` (no sessionID) and its output is
+ * `{ messages: { info: Message; parts: Part[] }[] }` — the prior code
+ * (`output.messages.unshift({ role, content })`) wrote a value of the
+ * wrong shape and was silently dropped (Mickey / PR #376 root cause).
+ */
+interface SystemTransformHookInput {
+    sessionID?: string;
+    model: unknown;
+}
+/** OpenCode experimental.chat.system.transform — second parameter */
+interface SystemTransformHookOutput {
+    system: string[];
+}
 /**
  * Plugin factory. Called once when KiloCode/OpenCode loads the plugin.
  * Returns an object mapping hook event names to async handler functions.
@@ -66,6 +88,7 @@ declare function createContextModePlugin(ctx: PluginContext): Promise<{
     "tool.execute.before": (input: BeforeHookInput, output: BeforeHookOutput) => Promise<void>;
     "tool.execute.after": (input: AfterHookInput, output: AfterHookOutput) => Promise<void>;
     "experimental.session.compacting": (input: CompactingHookInput, output: CompactingHookOutput) => Promise<string>;
+    "experimental.chat.system.transform": (input: SystemTransformHookInput, output: SystemTransformHookOutput) => Promise<void>;
 }>;
 declare const _default: {
     server: typeof createContextModePlugin;

package/build/opencode-plugin.js

@@ -18,16 +18,40 @@
  *   - No routing file auto-write (avoid dirtying project trees)
  *   - Session cleanup happens at plugin init (no SessionStart)
  */
-import { randomUUID } from "node:crypto";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { SessionDB } from "./session/db.js";
 import { extractEvents } from "./session/extract.js";
 import { buildResumeSnapshot } from "./session/snapshot.js";
 import { OpenCodeAdapter } from "./adapters/opencode/index.js";
+import { PLATFORM_ENV_VARS } from "./adapters/detect.js";
 // ── Helpers ───────────────────────────────────────────────
+/**
+ * Detect whether the plugin is running under KiloCode or OpenCode.
+ *
+ * Reuses the canonical PLATFORM_ENV_VARS list (src/adapters/detect.ts) instead
+ * of hardcoding env var names — single source of truth, future-proof if Kilo
+ * or OpenCode add/rename env vars upstream.
+ *
+ * Order matters: KiloCode is an OpenCode fork and sets `OPENCODE=1` in
+ * addition to `KILO_PID`. PLATFORM_ENV_VARS lists `kilo` BEFORE `opencode`
+ * so KILO_PID wins the iteration.
+ *
+ * Pre-fix version was `return process.env.KILO_PID ? "kilo" : "opencode";` —
+ * surfaced by github.com/mksglu/context-mode/pull/376 (mikij). Full symmetric
+ * fix: also actively check opencode env vars instead of blind fallback.
+ */
 function getPlatform() {
-    return process.env.KILO_PID ? "kilo" : "opencode";
+    for (const [platform, vars] of PLATFORM_ENV_VARS) {
+        if (platform !== "kilo" && platform !== "opencode")
+            continue;
+        if (vars.some((v) => process.env[v])) {
+            return platform;
+        }
+    }
+    // Plugin host should always set one of the env vars. Fallback to opencode
+    // (the wider ecosystem) when neither is set, for predictable behavior.
+    return "opencode";
 }
 // ── Plugin Factory ────────────────────────────────────────
 /**
@@ -45,13 +69,18 @@ async function createContextModePlugin(ctx) {
     const routingPath = resolve(buildDir, "..", "hooks", "core", "routing.mjs");
     const routing = await import(pathToFileURL(routingPath).href);
     await routing.initSecurity(buildDir);
-    // Initialize session
+    // Initialize per-process state. We do NOT fabricate a sessionId here —
+    // OpenCode/Kilo provide the real `input.sessionID` on every hook, and a
+    // process-global UUID would (a) never match prior-session resume rows and
+    // (b) collide across multi-session reuse (Mickey / PR #376 root cause).
     const projectDir = ctx.directory;
     const db = new SessionDB({ dbPath: adapter.getSessionDBPath(projectDir) });
-    const sessionId = randomUUID();
-    db.ensureSession(sessionId, projectDir);
-    // Clean up old sessions on startup (replaces SessionStart hook)
+    // Clean up old sessions on startup (no SessionStart hook to do this).
     db.cleanupOldSessions(7);
+    // Track per-session resume injection: persistent plugin process can host
+    // many sessions, so the gate must be keyed by sessionID — NOT a single
+    // boolean closure flag (Mickey #2 root cause).
+    const resumeInjected = new Set();
     return {
         // ── PreToolUse: Routing enforcement ─────────────────
         "tool.execute.before": async (input, output) => {
@@ -78,7 +107,11 @@ async function createContextModePlugin(ctx) {
         },
         // ── PostToolUse: Session event capture ──────────────
         "tool.execute.after": async (input, output) => {
+            const sessionId = input.sessionID;
+            if (!sessionId)
+                return;
             try {
+                db.ensureSession(sessionId, projectDir);
                 const hookInput = {
                     tool_name: input.tool ?? "",
                     tool_input: input.args ?? {},
@@ -97,7 +130,11 @@ async function createContextModePlugin(ctx) {
         },
         // ── PreCompact: Snapshot generation ─────────────────
         "experimental.session.compacting": async (input, output) => {
+            const sessionId = input.sessionID;
+            if (!sessionId)
+                return "";
             try {
+                db.ensureSession(sessionId, projectDir);
                 const events = db.getEvents(sessionId);
                 if (events.length === 0)
                     return "";
@@ -115,6 +152,43 @@ async function createContextModePlugin(ctx) {
                 return "";
             }
         },
+        // ── SessionStart equivalent (PR #376) ───────────────
+        // OpenCode lacks a real SessionStart hook (#14808, #5409). The closest
+        // surrogate is `experimental.chat.system.transform` — verified shape:
+        //   input:  { sessionID?: string; model: Model }
+        //   output: { system: string[] }
+        // We claim the most-recent unconsumed resume snapshot atomically (race-
+        // safe across concurrent processes) and prepend it to the system prompt.
+        // First-injection-per-session is enforced by `resumeInjected` Set.
+        "experimental.chat.system.transform": async (input, output) => {
+            const sessionId = input?.sessionID;
+            if (!sessionId)
+                return;
+            if (resumeInjected.has(sessionId))
+                return;
+            resumeInjected.add(sessionId);
+            try {
+                const row = db.claimLatestUnconsumedResume();
+                if (!row || !row.snapshot)
+                    return;
+                if (Array.isArray(output?.system)) {
+                    // Insert at index 1 (after the header) — NOT unshift.
+                    // OpenCode's llm.ts:117-128 saves `header = system[0]` BEFORE this
+                    // hook runs and then folds the rest into a 2-part structure
+                    // `[header, body]` only if `system[0] === header` after the hook.
+                    // Prepending via unshift replaces system[0] with the snapshot,
+                    // making the equality check fail → cache-fold is skipped → every
+                    // system block is sent as a separate `role: "system"` message →
+                    // provider prompt cache is invalidated on every resume injection.
+                    // Inserting at index 1 keeps the header invariant and lets the
+                    // snapshot ride along inside the cached body block.
+                    output.system.splice(1, 0, row.snapshot);
+                }
+            }
+            catch {
+                // Silent — never break the chat turn
+            }
+        },
     };
 }
 // ── Exports ──────────────────────────────────────────────