context-mode 1.0.54 → 1.0.57

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

@@ -127,7 +127,43 @@ const sessionStats = {
     cacheBytesSaved: 0, // bytes avoided by TTL cache hits
     sessionStart: Date.now(),
 };
+/**
+ * Reset session stats to zero. Called when /clear flag is detected.
+ * The SessionStart hook writes a .clear-stats flag file on /clear,
+ * and the server checks for it before each tool call.
+ */
+function resetSessionStats() {
+    sessionStats.calls = {};
+    sessionStats.bytesReturned = {};
+    sessionStats.bytesIndexed = 0;
+    sessionStats.bytesSandboxed = 0;
+    sessionStats.cacheHits = 0;
+    sessionStats.cacheBytesSaved = 0;
+    sessionStats.sessionStart = Date.now();
+    // Also reset FTS5 content store — drop and recreate on next getStore() call
+    if (_store) {
+        try {
+            _store.cleanup();
+        }
+        catch { /* best effort */ }
+        _store = null;
+    }
+}
+/** Check for .clear-stats flag and reset stats if found. */
+function checkClearStatsFlag() {
+    const sessDir = join(homedir(), ".claude", "context-mode", "sessions");
+    try {
+        const flags = readdirSync(sessDir).filter((f) => f.endsWith(".clear-stats"));
+        for (const f of flags) {
+            unlinkSync(join(sessDir, f));
+        }
+        if (flags.length > 0)
+            resetSessionStats();
+    }
+    catch { /* best effort */ }
+}
 function trackResponse(toolName, response) {
+    checkClearStatsFlag();
     const bytes = response.content.reduce((sum, c) => sum + Buffer.byteLength(c.text), 0);
     sessionStats.calls[toolName] = (sessionStats.calls[toolName] || 0) + 1;
     sessionStats.bytesReturned[toolName] =
@@ -513,6 +549,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 +576,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 +616,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 +744,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 +770,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 +1183,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 +1301,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;
@@ -1342,8 +1406,18 @@ server.registerTool("ctx_stats", {
     description: "Returns context consumption statistics for the current session. " +
         "Shows total bytes returned to context, breakdown by tool, call counts, " +
         "estimated token usage, and context savings ratio.",
-    inputSchema: z.object({}),
-}, async () => {
+    inputSchema: z.object({
+        reset: z.boolean().optional().describe("Reset all stats and FTS5 store to zero. Use after /clear."),
+    }),
+}, async ({ reset }) => {
+    // Check for clear flag BEFORE reading stats
+    checkClearStatsFlag();
+    if (reset) {
+        resetSessionStats();
+        return trackResponse("ctx_stats", {
+            content: [{ type: "text", text: "Session stats and search index reset." }],
+        });
+    }
     const totalBytesReturned = Object.values(sessionStats.bytesReturned).reduce((sum, b) => sum + b, 0);
     const totalCalls = Object.values(sessionStats.calls).reduce((sum, c) => sum + c, 0);
     const uptimeMs = Date.now() - sessionStats.sessionStart;
@@ -1683,26 +1757,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