context-mode 1.0.54 → 1.0.56

package/build/adapters/opencode/index.js

@@ -16,6 +16,13 @@
  *   - Session dir: ~/.config/opencode/context-mode/sessions/
  */
 import { createHash } from "node:crypto";
+/** Strip JSONC comments (// and /* *​/) and trailing commas for JSON.parse. */
+function stripJsonComments(str) {
+    return str
+        .replace(/\/\/.*$/gm, "")
+        .replace(/\/\*[\s\S]*?\*\//g, "")
+        .replace(/,(\s*[}\]])/g, "$1");
+}
 import { readFileSync, writeFileSync, mkdirSync, copyFileSync, accessSync, constants, } from "node:fs";
 import { resolve, join } from "node:path";
 import { homedir } from "node:os";
@@ -33,7 +40,7 @@ export class OpenCodeAdapter {
         preToolUse: true,
         postToolUse: true,
         preCompact: true, // experimental
-        sessionStart: true,
+        sessionStart: false,
         canModifyArgs: true,
         canModifyOutput: true, // with TUI bug caveat for bash (#13575)
         canInjectSessionContext: false,
@@ -150,8 +157,11 @@ export class OpenCodeAdapter {
         }
         return [
             resolve("opencode.json"),
+            resolve("opencode.jsonc"),
             resolve(".opencode", "opencode.json"),
+            resolve(".opencode", "opencode.jsonc"),
             join(homedir(), ".config", "opencode", "opencode.json"),
+            join(homedir(), ".config", "opencode", "opencode.jsonc"),
         ];
     }
     getSessionDir() {
@@ -222,7 +232,8 @@ export class OpenCodeAdapter {
             try {
                 const raw = readFileSync(configPath, "utf-8");
                 this.settingsPath = configPath;
-                return JSON.parse(raw);
+                const text = configPath.endsWith(".jsonc") ? stripJsonComments(raw) : raw;
+                return JSON.parse(text);
             }
             catch {
                 continue;
@@ -242,7 +253,7 @@ export class OpenCodeAdapter {
             results.push({
                 check: "Plugin configuration",
                 status: "fail",
-                message: "Could not read opencode.json",
+                message: `Could not read ${this.platform}.json or ${this.platform}.jsonc`,
                 fix: "context-mode upgrade",
             });
             return results;
@@ -284,7 +295,7 @@ export class OpenCodeAdapter {
             return {
                 check: "Plugin registration",
                 status: "warn",
-                message: "Could not read opencode.json",
+                message: `Could not read ${this.platform}.json or ${this.platform}.jsonc`,
             };
         }
         const plugins = settings.plugin;
@@ -358,36 +369,6 @@ export class OpenCodeAdapter {
     updatePluginRegistry(_pluginRoot, _version) {
         // OpenCode manages plugins through npm/opencode.json — no separate registry
     }
-    // ── Routing Instructions (soft enforcement) ────────────
-    getRoutingInstructionsConfig() {
-        return {
-            fileName: "AGENTS.md",
-            globalPath: resolve(homedir(), ".config", this.platform, "AGENTS.md"),
-            projectRelativePath: "AGENTS.md",
-        };
-    }
-    writeRoutingInstructions(projectDir, pluginRoot) {
-        const config = this.getRoutingInstructionsConfig();
-        const targetPath = resolve(projectDir, config.projectRelativePath);
-        const sourcePath = resolve(pluginRoot, "configs", this.platform, config.fileName);
-        try {
-            const content = readFileSync(sourcePath, "utf-8");
-            try {
-                const existing = readFileSync(targetPath, "utf-8");
-                if (existing.includes("context-mode"))
-                    return null;
-                writeFileSync(targetPath, existing.trimEnd() + "\n\n" + content, "utf-8");
-                return targetPath;
-            }
-            catch {
-                writeFileSync(targetPath, content, "utf-8");
-                return targetPath;
-            }
-        }
-        catch {
-            return null;
-        }
-    }
     // ── Internal helpers ───────────────────────────────────
     /**
      * Extract session ID from OpenCode hook input.

package/build/adapters/types.d.ts

@@ -180,19 +180,6 @@ export interface HookAdapter {
     setHookPermissions(pluginRoot: string): string[];
     /** Update platform's plugin registry to point to given path and version. */
     updatePluginRegistry(pluginRoot: string, version: string): void;
-    /** Get the routing instructions file config for this platform. */
-    getRoutingInstructionsConfig(): RoutingInstructionsConfig;
-    /** Write routing instructions file to project directory if not present. Returns path written or null if already exists. */
-    writeRoutingInstructions(projectDir: string, pluginRoot: string): string | null;
-}
-/** Configuration for platform-specific routing instruction files. */
-export interface RoutingInstructionsConfig {
-    /** File name the platform reads (e.g., "CLAUDE.md", "GEMINI.md", "AGENTS.md"). */
-    fileName: string;
-    /** Global path for this platform (e.g., "~/.claude/CLAUDE.md"). */
-    globalPath: string;
-    /** Project-level path relative to project root (e.g., "GEMINI.md", ".github/copilot-instructions.md"). */
-    projectRelativePath: string;
 }
 /** Result from a platform-specific diagnostic check. */
 export interface DiagnosticResult {

package/build/adapters/vscode-copilot/index.d.ts

@@ -21,7 +21,7 @@
  *   - Session dir: ~/.vscode/context-mode/sessions/ (fallback)
  *   - Preview status — API may change
  */
-import type { HookAdapter, HookParadigm, PlatformCapabilities, DiagnosticResult, PreToolUseEvent, PostToolUseEvent, PreCompactEvent, SessionStartEvent, PreToolUseResponse, PostToolUseResponse, PreCompactResponse, SessionStartResponse, HookRegistration, RoutingInstructionsConfig } from "../types.js";
+import type { HookAdapter, HookParadigm, PlatformCapabilities, DiagnosticResult, PreToolUseEvent, PostToolUseEvent, PreCompactEvent, SessionStartEvent, PreToolUseResponse, PostToolUseResponse, PreCompactResponse, SessionStartResponse, HookRegistration } from "../types.js";
 export declare class VSCodeCopilotAdapter implements HookAdapter {
     readonly name = "VS Code Copilot";
     readonly paradigm: HookParadigm;
@@ -48,8 +48,6 @@ export declare class VSCodeCopilotAdapter implements HookAdapter {
     backupSettings(): string | null;
     setHookPermissions(pluginRoot: string): string[];
     updatePluginRegistry(_pluginRoot: string, _version: string): void;
-    getRoutingInstructionsConfig(): RoutingInstructionsConfig;
-    writeRoutingInstructions(projectDir: string, pluginRoot: string): string | null;
     /**
      * Extract session ID from VS Code Copilot hook input.
      * VS Code Copilot uses camelCase sessionId (NOT session_id).

package/build/adapters/vscode-copilot/index.js

@@ -465,38 +465,6 @@ export class VSCodeCopilotAdapter {
         // VS Code manages extensions through its own marketplace/extension system.
         // No manual registry update needed.
     }
-    // ── Routing Instructions (soft enforcement) ────────────
-    getRoutingInstructionsConfig() {
-        return {
-            fileName: "copilot-instructions.md",
-            globalPath: "", // VS Code Copilot uses org-level, not global file
-            projectRelativePath: join(".github", "copilot-instructions.md"),
-        };
-    }
-    writeRoutingInstructions(projectDir, pluginRoot) {
-        const config = this.getRoutingInstructionsConfig();
-        const targetPath = resolve(projectDir, config.projectRelativePath);
-        const sourcePath = resolve(pluginRoot, "configs", "vscode-copilot", config.fileName);
-        try {
-            const content = readFileSync(sourcePath, "utf-8");
-            // Ensure .github directory exists
-            mkdirSync(resolve(projectDir, ".github"), { recursive: true });
-            try {
-                const existing = readFileSync(targetPath, "utf-8");
-                if (existing.includes("context-mode"))
-                    return null;
-                writeFileSync(targetPath, existing.trimEnd() + "\n\n" + content, "utf-8");
-                return targetPath;
-            }
-            catch {
-                writeFileSync(targetPath, content, "utf-8");
-                return targetPath;
-            }
-        }
-        catch {
-            return null;
-        }
-    }
     // ── Internal helpers ───────────────────────────────────
     /**
      * Extract session ID from VS Code Copilot hook input.

package/build/adapters/zed/index.d.ts

@@ -10,7 +10,7 @@
  *   - All capabilities are false — MCP is the only integration path
  *   - Session dir: ~/.config/zed/context-mode/sessions/
  */
-import type { HookAdapter, HookParadigm, PlatformCapabilities, DiagnosticResult, PreToolUseEvent, PostToolUseEvent, PreCompactEvent, SessionStartEvent, PreToolUseResponse, PostToolUseResponse, PreCompactResponse, SessionStartResponse, HookRegistration, RoutingInstructionsConfig } from "../types.js";
+import type { HookAdapter, HookParadigm, PlatformCapabilities, DiagnosticResult, PreToolUseEvent, PostToolUseEvent, PreCompactEvent, SessionStartEvent, PreToolUseResponse, PostToolUseResponse, PreCompactResponse, SessionStartResponse, HookRegistration } from "../types.js";
 export declare class ZedAdapter implements HookAdapter {
     readonly name = "Zed";
     readonly paradigm: HookParadigm;
@@ -37,7 +37,5 @@ export declare class ZedAdapter implements HookAdapter {
     backupSettings(): string | null;
     setHookPermissions(_pluginRoot: string): string[];
     updatePluginRegistry(_pluginRoot: string, _version: string): void;
-    getRoutingInstructionsConfig(): RoutingInstructionsConfig;
-    writeRoutingInstructions(projectDir: string, pluginRoot: string): string | null;
     getRoutingInstructions(): string;
 }

package/build/adapters/zed/index.js

@@ -175,36 +175,6 @@ export class ZedAdapter {
     updatePluginRegistry(_pluginRoot, _version) {
         // Zed has no plugin registry
     }
-    // ── Routing Instructions (soft enforcement) ────────────
-    getRoutingInstructionsConfig() {
-        return {
-            fileName: "AGENTS.md",
-            globalPath: resolve(homedir(), ".config", "zed", "AGENTS.md"),
-            projectRelativePath: "AGENTS.md",
-        };
-    }
-    writeRoutingInstructions(projectDir, pluginRoot) {
-        const config = this.getRoutingInstructionsConfig();
-        const targetPath = resolve(projectDir, config.projectRelativePath);
-        const sourcePath = resolve(pluginRoot, "configs", "zed", config.fileName);
-        try {
-            const content = readFileSync(sourcePath, "utf-8");
-            try {
-                const existing = readFileSync(targetPath, "utf-8");
-                if (existing.includes("context-mode"))
-                    return null;
-                writeFileSync(targetPath, existing.trimEnd() + "\n\n" + content, "utf-8");
-                return targetPath;
-            }
-            catch {
-                writeFileSync(targetPath, content, "utf-8");
-                return targetPath;
-            }
-        }
-        catch {
-            return null;
-        }
-    }
     getRoutingInstructions() {
         const instructionsPath = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "configs", "zed", "AGENTS.md");
         try {

package/build/executor.d.ts

@@ -14,7 +14,6 @@ interface ExecuteFileOptions extends ExecuteOptions {
 export declare class PolyglotExecutor {
     #private;
     constructor(opts?: {
-        maxOutputBytes?: number;
         hardCapBytes?: number;
         projectRoot?: string;
         runtimes?: RuntimeMap;

package/build/executor.js

@@ -3,8 +3,24 @@ import { mkdtempSync, writeFileSync, rmSync, existsSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 import { detectRuntimes, buildCommand, } from "./runtime.js";
-import { smartTruncate } from "./truncate.js";
 const isWin = process.platform === "win32";
+/**
+ * Resolve the real OS temp directory, bypassing any TMPDIR env override.
+ * os.tmpdir() reads TMPDIR from the environment, which some shells/tools
+ * set to the project root — causing temp files to pollute the working tree.
+ */
+const OS_TMPDIR = (() => {
+    if (isWin)
+        return process.env.TEMP ?? process.env.TMP ?? tmpdir();
+    try {
+        const result = execFileSync(process.platform === "darwin" ? "getconf" : "mktemp", process.platform === "darwin" ? ["DARWIN_USER_TEMP_DIR"] : ["-u", "-d"], { env: { ...process.env, TMPDIR: undefined }, encoding: "utf-8" }).trim();
+        const dir = process.platform === "darwin" ? result : resolve(result, "..");
+        if (dir && dir !== process.cwd())
+            return dir;
+    }
+    catch { /* fall through */ }
+    return "/tmp";
+})();
 /** Kill process tree — on Windows uses taskkill /T; on Unix kills the process group. */
 function killTree(proc) {
     if (isWin && proc.pid) {
@@ -22,14 +38,12 @@ function killTree(proc) {
     }
 }
 export class PolyglotExecutor {
-    #maxOutputBytes;
     #hardCapBytes;
     #projectRoot;
     #runtimes;
     /** PIDs of backgrounded processes — killed on cleanup to prevent zombies. */
     #backgroundedPids = new Set();
     constructor(opts) {
-        this.#maxOutputBytes = opts?.maxOutputBytes ?? 102_400;
         this.#hardCapBytes = opts?.hardCapBytes ?? 100 * 1024 * 1024; // 100MB
         this.#projectRoot = opts?.projectRoot ?? process.cwd();
         this.#runtimes = opts?.runtimes ?? detectRuntimes();
@@ -50,7 +64,7 @@ export class PolyglotExecutor {
     }
     async execute(opts) {
         const { language, code, timeout = 30_000, background = false } = opts;
-        const tmpDir = mkdtempSync(join(tmpdir(), ".ctx-mode-"));
+        const tmpDir = mkdtempSync(join(OS_TMPDIR, ".ctx-mode-"));
         try {
             const filePath = this.#writeScript(tmpDir, code, language);
             const cmd = buildCommand(this.#runtimes, language, filePath);
@@ -62,7 +76,7 @@ export class PolyglotExecutor {
             // and other project-aware tools work naturally. Non-shell languages
             // run in the temp directory where their script file is written.
             const cwd = language === "shell" ? this.#projectRoot : tmpDir;
-            const result = await this.#spawn(cmd, cwd, timeout, background);
+            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 {
@@ -144,9 +158,9 @@ export class PolyglotExecutor {
             };
         }
         // Run
-        return this.#spawn([binPath], cwd, timeout);
+        return this.#spawn([binPath], cwd, cwd, timeout);
     }
-    async #spawn(cmd, cwd, timeout, background = false) {
+    async #spawn(cmd, cwd, sandboxTmpDir, timeout, background = false) {
         return new Promise((res) => {
             // Only .cmd/.bat shims need shell on Windows; real executables don't.
             // Using shell: true globally causes process-tree kill issues with MSYS2/Git Bash.
@@ -168,7 +182,7 @@ export class PolyglotExecutor {
             const proc = spawn(spawnCmd, spawnArgs, {
                 cwd,
                 stdio: ["ignore", "pipe", "pipe"],
-                env: this.#buildSafeEnv(cwd),
+                env: this.#buildSafeEnv(sandboxTmpDir),
                 shell: needsShell,
                 // On Unix, create a new process group so killTree can kill all children
                 detached: !isWin,
@@ -187,10 +201,9 @@ export class PolyglotExecutor {
                     proc.stderr.destroy();
                     const rawStdout = Buffer.concat(stdoutChunks).toString("utf-8");
                     const rawStderr = Buffer.concat(stderrChunks).toString("utf-8");
-                    const max = this.#maxOutputBytes;
                     res({
-                        stdout: smartTruncate(rawStdout, max),
-                        stderr: smartTruncate(rawStderr, max),
+                        stdout: rawStdout,
+                        stderr: rawStderr,
                         exitCode: 0,
                         timedOut: true,
                         backgrounded: true,
@@ -237,9 +250,8 @@ export class PolyglotExecutor {
                 if (capExceeded) {
                     rawStderr += `\n[output capped at ${(this.#hardCapBytes / 1024 / 1024).toFixed(0)}MB — process killed]`;
                 }
-                const max = this.#maxOutputBytes;
-                const stdout = smartTruncate(rawStdout, max);
-                const stderr = smartTruncate(rawStderr, max);
+                const stdout = rawStdout;
+                const stderr = rawStderr;
                 res({
                     stdout,
                     stderr,

package/build/openclaw-plugin.js

@@ -36,7 +36,6 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { OpenClawSessionDB } from "./adapters/openclaw/session-db.js";
 import { extractEvents, extractUserEvents } from "./session/extract.js";
 import { buildResumeSnapshot } from "./session/snapshot.js";
-import { OpenClawAdapter } from "./adapters/openclaw/index.js";
 import { WorkspaceRouter } from "./openclaw/workspace-router.js";
 /** Plugin config schema for OpenClaw validation. */
 const configSchema = {
@@ -131,12 +130,6 @@ export default {
             // best effort
         }
         // Async init: load routing module. Hooks await this.
-        // NOTE: writeRoutingInstructions is intentionally NOT called here.
-        // process.cwd() at plugin load time is the gateway's working directory, not
-        // the agent's workspace. Writing AGENTS.md to cwd() caused the file to be
-        // created in arbitrary directories (repo roots, config dirs, $HOME, etc.).
-        // The write is now deferred to session_start where the real workspace path
-        // is known via the sessionKey → workspace mapping.
         const initPromise = (async () => {
             const routingPath = resolve(buildDir, "..", "hooks", "core", "routing.mjs");
             const routing = await import(pathToFileURL(routingPath).href);
@@ -319,29 +312,6 @@ export default {
                 // workspace. Derive the workspace directory from the sessionKey so we
                 // only write into recognised /.openclaw/workspace* paths, never into
                 // the gateway's cwd or any other arbitrary directory.
-                if (key) {
-                    try {
-                        const adapter = new OpenClawAdapter();
-                        const openclawBase = resolve(homedir(), ".openclaw");
-                        // Resolve workspace dir from sessionKey (pattern: agent:<name>:*)
-                        // Restrict agent name to safe characters to prevent path traversal (#183)
-                        const wsMatch = key.match(/^agent:([a-zA-Z0-9_-]+):/);
-                        let wsDir;
-                        if (wsMatch) {
-                            wsDir = resolve(openclawBase, `workspace-${wsMatch[1]}`);
-                        }
-                        else {
-                            wsDir = resolve(openclawBase, "workspace");
-                        }
-                        // Containment check: never write outside ~/.openclaw/
-                        if (wsDir.startsWith(openclawBase)) {
-                            adapter.writeRoutingInstructions(wsDir, pluginRoot);
-                        }
-                    }
-                    catch {
-                        // best effort — never break session start
-                    }
-                }
             }
             catch {
                 // best effort — never break session start

package/build/opencode-plugin.d.ts

@@ -11,6 +11,7 @@
  * Constraints:
  *   - No SessionStart hook (OpenCode doesn't support it — #14808, #5409)
  *   - No context injection (canInjectSessionContext: false)
+ *   - No routing file auto-write (avoid dirtying project trees)
  *   - Session cleanup happens at plugin init (no SessionStart)
  */
 /** OpenCode plugin context passed to the factory function. */

package/build/opencode-plugin.js

@@ -11,6 +11,7 @@
  * Constraints:
  *   - No SessionStart hook (OpenCode doesn't support it — #14808, #5409)
  *   - No context injection (canInjectSessionContext: false)
+ *   - No routing file auto-write (avoid dirtying project trees)
  *   - Session cleanup happens at plugin init (no SessionStart)
  */
 import { createHash, randomUUID } from "node:crypto";
@@ -21,7 +22,6 @@ 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";
 // ── Helpers ───────────────────────────────────────────────
 function getPlatform() {
     return process.env.KILO ? "kilo" : "opencode";
@@ -55,13 +55,6 @@ export const ContextModePlugin = async (ctx) => {
     const db = new SessionDB({ dbPath: getDBPath(projectDir) });
     const sessionId = randomUUID();
     db.ensureSession(sessionId, projectDir);
-    // Auto-write AGENTS.md on startup for OpenCode projects
-    try {
-        new OpenCodeAdapter(getPlatform()).writeRoutingInstructions(projectDir, resolve(buildDir, ".."));
-    }
-    catch {
-        // best effort — never break plugin init
-    }
     // Clean up old sessions on startup (replaces SessionStart hook)
     db.cleanupOldSessions(0);
     return {

package/build/server.js

@@ -513,6 +513,16 @@ __cm_main().catch(e=>{console.error(e);process.exitCode=1});${background ? '\nse
                     isError,
                 });
             }
+            // Auto-index large error output into FTS5 — no data loss
+            if (Buffer.byteLength(output) > LARGE_OUTPUT_THRESHOLD) {
+                trackIndexed(Buffer.byteLength(output));
+                return trackResponse("ctx_execute", {
+                    content: [
+                        { type: "text", text: intentSearch(output, "errors failures exceptions", isError ? `execute:${language}:error` : `execute:${language}`) },
+                    ],
+                    isError,
+                });
+            }
             return trackResponse("ctx_execute", {
                 content: [
                     { type: "text", text: output },
@@ -530,6 +540,10 @@ __cm_main().catch(e=>{console.error(e);process.exitCode=1});${background ? '\nse
                 ],
             });
         }
+        // Auto-index large stdout into FTS5 — return pointer, not raw content
+        if (Buffer.byteLength(stdout) > LARGE_OUTPUT_THRESHOLD) {
+            return trackResponse("ctx_execute", indexStdout(stdout, `execute:${language}`));
+        }
         return trackResponse("ctx_execute", {
             content: [
                 { type: "text", text: stdout },
@@ -566,6 +580,7 @@ function indexStdout(stdout, source) {
 // Helper: intent-driven search on execution output
 // ─────────────────────────────────────────────────────────
 const INTENT_SEARCH_THRESHOLD = 5_000; // bytes — ~80-100 lines
+const LARGE_OUTPUT_THRESHOLD = 102_400; // 100KB — auto-index into FTS5, return pointer
 function intentSearch(stdout, intent, source, maxResults = 5) {
     const totalLines = stdout.split("\n").length;
     const totalBytes = Buffer.byteLength(stdout);
@@ -693,6 +708,16 @@ server.registerTool("ctx_execute_file", {
                     isError,
                 });
             }
+            // Auto-index large error output into FTS5 — no data loss
+            if (Buffer.byteLength(output) > LARGE_OUTPUT_THRESHOLD) {
+                trackIndexed(Buffer.byteLength(output));
+                return trackResponse("ctx_execute_file", {
+                    content: [
+                        { type: "text", text: intentSearch(output, "errors failures exceptions", isError ? `file:${path}:error` : `file:${path}`) },
+                    ],
+                    isError,
+                });
+            }
             return trackResponse("ctx_execute_file", {
                 content: [
                     { type: "text", text: output },
@@ -709,6 +734,10 @@ server.registerTool("ctx_execute_file", {
                 ],
             });
         }
+        // Auto-index large stdout into FTS5 — return pointer, not raw content
+        if (Buffer.byteLength(stdout) > LARGE_OUTPUT_THRESHOLD) {
+            return trackResponse("ctx_execute_file", indexStdout(stdout, `file:${path}`));
+        }
         return trackResponse("ctx_execute_file", {
             content: [
                 { type: "text", text: stdout },
@@ -1118,7 +1147,7 @@ server.registerTool("ctx_fetch_and_index", {
         // Parse content-type marker from stdout (content is in the temp file)
         const store = getStore();
         const header = (result.stdout || "").trim();
-        // Read full content from temp file (bypasses smartTruncate)
+        // Read full content from temp file
         let markdown;
         try {
             markdown = readFileSync(outputPath, "utf-8").trim();
@@ -1236,9 +1265,8 @@ server.registerTool("ctx_batch_execute", {
     }
     try {
         // Execute each command individually so every command gets its own
-        // smartTruncate budget (~100KB). Previously, all commands were
-        // concatenated into a single script where smartTruncate (60% head +
-        // 40% tail) could silently drop middle commands. (Issue #61)
+        // output capture. Full stdout is preserved and indexed into FTS5.
+        // (Issue #61, #197)
         const perCommandOutputs = [];
         const startTime = Date.now();
         let timedOut = false;
@@ -1683,26 +1711,15 @@ async function main() {
     startLifecycleGuard({ onShutdown: () => gracefulShutdown() });
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    // Write routing instructions for hookless platforms (e.g. Codex CLI, Antigravity)
+    // Log detected MCP client for diagnostics
     try {
         const { detectPlatform, getAdapter } = await import("./adapters/detect.js");
         const clientInfo = server.server.getClientVersion();
         const signal = detectPlatform(clientInfo ?? undefined);
-        const adapter = await getAdapter(signal.platform);
+        await getAdapter(signal.platform);
         if (clientInfo) {
             console.error(`MCP client: ${clientInfo.name} v${clientInfo.version} → ${signal.platform}`);
         }
-        // Routing file auto-write DISABLED for all platforms (#158, #164).
-        // Writing to project dirs dirties git trees and env var detection at
-        // MCP startup is unreliable. Routing is injected via SessionStart hooks
-        // for hook-capable platforms. Non-hook platforms rely on manual setup
-        // until `context-mode init` command is implemented.
-        // if (!adapter.capabilities.sessionStart) {
-        //   const pluginRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-        //   const projectDir = process.env.CLAUDE_PROJECT_DIR ?? process.env.CODEX_HOME ?? process.cwd();
-        //   const written = adapter.writeRoutingInstructions(projectDir, pluginRoot);
-        //   if (written) console.error(`Wrote routing instructions: ${written}`);
-        // }
     }
     catch { /* best effort — don't block server startup */ }
     console.error(`Context Mode MCP server v${VERSION} running on stdio`);

package/build/truncate.d.ts

@@ -1,10 +1,9 @@
 /**
- * truncate — Pure string and output truncation utilities for context-mode.
+ * truncate — Pure string truncation and escaping utilities for context-mode.
  *
- * These helpers are used by both the core ContentStore (chunking) and the
- * PolyglotExecutor (smart output truncation). They are extracted here so
- * SessionDB and any other future consumer can import them without pulling
- * in the full store or executor.
+ * These helpers are used by the core ContentStore (chunking) and
+ * SessionDB (snapshot building). They are extracted here so any
+ * consumer can import them without pulling in the full store or executor.
  */
 /**
  * Truncate a string to at most `maxChars` characters, appending an ellipsis
@@ -16,18 +15,6 @@
  *          ending with "...".
  */
 export declare function truncateString(str: string, maxChars: number): string;
-/**
- * Smart truncation that keeps the head (60%) and tail (40%) of output,
- * preserving both initial context and final error messages.
- * Snaps to line boundaries and handles UTF-8 safely via `Buffer.byteLength`.
- *
- * Used by PolyglotExecutor to cap stdout/stderr before returning to context.
- *
- * @param raw - Raw output string.
- * @param maxBytes - Soft cap in bytes. Output below this threshold is returned as-is.
- * @returns The original string if within budget, otherwise head + separator + tail.
- */
-export declare function smartTruncate(raw: string, maxBytes: number): string;
 /**
  * Serialize a value to JSON, then truncate the result to `maxBytes` bytes.
  * If truncation occurs, the string is cut at a UTF-8-safe boundary and

package/build/truncate.js

@@ -1,10 +1,9 @@
 /**
- * truncate — Pure string and output truncation utilities for context-mode.
+ * truncate — Pure string truncation and escaping utilities for context-mode.
  *
- * These helpers are used by both the core ContentStore (chunking) and the
- * PolyglotExecutor (smart output truncation). They are extracted here so
- * SessionDB and any other future consumer can import them without pulling
- * in the full store or executor.
+ * These helpers are used by the core ContentStore (chunking) and
+ * SessionDB (snapshot building). They are extracted here so any
+ * consumer can import them without pulling in the full store or executor.
  */
 // ─────────────────────────────────────────────────────────
 // String truncation
@@ -24,53 +23,6 @@ export function truncateString(str, maxChars) {
     return str.slice(0, Math.max(0, maxChars - 3)) + "...";
 }
 // ─────────────────────────────────────────────────────────
-// Byte-aware smart truncation (head + tail)
-// ─────────────────────────────────────────────────────────
-/**
- * Smart truncation that keeps the head (60%) and tail (40%) of output,
- * preserving both initial context and final error messages.
- * Snaps to line boundaries and handles UTF-8 safely via `Buffer.byteLength`.
- *
- * Used by PolyglotExecutor to cap stdout/stderr before returning to context.
- *
- * @param raw - Raw output string.
- * @param maxBytes - Soft cap in bytes. Output below this threshold is returned as-is.
- * @returns The original string if within budget, otherwise head + separator + tail.
- */
-export function smartTruncate(raw, maxBytes) {
-    if (Buffer.byteLength(raw) <= maxBytes)
-        return raw;
-    const lines = raw.split("\n");
-    // Budget: 60% head, 40% tail (errors/results are usually at the end)
-    const headBudget = Math.floor(maxBytes * 0.6);
-    const tailBudget = maxBytes - headBudget;
-    // Collect head lines
-    const headLines = [];
-    let headBytes = 0;
-    for (const line of lines) {
-        const lineBytes = Buffer.byteLength(line) + 1; // +1 for \n
-        if (headBytes + lineBytes > headBudget)
-            break;
-        headLines.push(line);
-        headBytes += lineBytes;
-    }
-    // Collect tail lines (from end)
-    const tailLines = [];
-    let tailBytes = 0;
-    for (let i = lines.length - 1; i >= headLines.length; i--) {
-        const lineBytes = Buffer.byteLength(lines[i]) + 1;
-        if (tailBytes + lineBytes > tailBudget)
-            break;
-        tailLines.unshift(lines[i]);
-        tailBytes += lineBytes;
-    }
-    const skippedLines = lines.length - headLines.length - tailLines.length;
-    const skippedBytes = Buffer.byteLength(raw) - headBytes - tailBytes;
-    const separator = `\n\n... [${skippedLines} lines / ${(skippedBytes / 1024).toFixed(1)}KB truncated` +
-        ` — showing first ${headLines.length} + last ${tailLines.length} lines] ...\n\n`;
-    return headLines.join("\n") + separator + tailLines.join("\n");
-}
-// ─────────────────────────────────────────────────────────
 // JSON truncation
 // ─────────────────────────────────────────────────────────
 /**