context-mode 1.0.53 → 1.0.56

package/build/server.js

@@ -321,6 +321,33 @@ export function extractSnippet(content, query, maxLen = 1500, highlighted) {
     }
     return parts.join("\n\n");
 }
+export function formatBatchQueryResults(store, queries, source, maxOutput = 80 * 1024) {
+    const sections = [];
+    let outputSize = 0;
+    for (const query of queries) {
+        if (outputSize > maxOutput) {
+            sections.push(`## ${query}\n(output cap reached — use search(queries: ["${query}"]) for details)\n`);
+            continue;
+        }
+        const results = store.searchWithFallback(query, 3, source, undefined, "exact");
+        sections.push(`## ${query}`);
+        sections.push("");
+        if (results.length > 0) {
+            for (const result of results) {
+                const snippet = extractSnippet(result.content, query, 3000, result.highlighted);
+                sections.push(`### ${result.title}`);
+                sections.push(snippet);
+                sections.push("");
+                outputSize += snippet.length + result.title.length;
+            }
+            continue;
+        }
+        sections.push("No matching sections found.");
+        sections.push("");
+    }
+    sections.push(`\n> **Tip:** Results are scoped to this batch only. To search across all indexed sources, use \`ctx_search(queries: [...])\`.`);
+    return sections;
+}
 // ─────────────────────────────────────────────────────────
 // Tool: execute
 // ─────────────────────────────────────────────────────────
@@ -486,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 },
@@ -503,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 },
@@ -539,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);
@@ -666,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 },
@@ -682,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 },
@@ -1091,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();
@@ -1209,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;
@@ -1272,45 +1327,9 @@ server.registerTool("ctx_batch_execute", {
             inventory.push(`- ${s.title} (${(bytes / 1024).toFixed(1)}KB)`);
             sectionTitles.push(s.title);
         }
-        // Run all search queries — 3 results each, smart snippets
-        // Three-tier fallback: scoped → boosted → global
-        const MAX_OUTPUT = 80 * 1024; // 80KB total output cap
-        const queryResults = [];
-        let outputSize = 0;
-        for (const query of queries) {
-            if (outputSize > MAX_OUTPUT) {
-                queryResults.push(`## ${query}\n(output cap reached — use search(queries: ["${query}"]) for details)\n`);
-                continue;
-            }
-            // Tier 1: scoped search with fallback (porter → trigram → fuzzy)
-            let results = store.searchWithFallback(query, 3, source);
-            let crossSource = false;
-            // Tier 2: global fallback (no source filter) — warn about cross-source (Issue #61)
-            if (results.length === 0) {
-                results = store.searchWithFallback(query, 3);
-                crossSource = results.length > 0;
-            }
-            queryResults.push(`## ${query}`);
-            if (crossSource) {
-                queryResults.push(`> **Note:** No results in current batch output. Showing results from previously indexed content.`);
-            }
-            queryResults.push("");
-            if (results.length > 0) {
-                for (const r of results) {
-                    // Use larger snippet (3KB) for batch_execute to reduce tiny-fragment issue (Issue #61)
-                    const snippet = extractSnippet(r.content, query, 3000, r.highlighted);
-                    const sourceTag = crossSource ? ` _(source: ${r.source})_` : "";
-                    queryResults.push(`### ${r.title}${sourceTag}`);
-                    queryResults.push(snippet);
-                    queryResults.push("");
-                    outputSize += snippet.length + r.title.length;
-                }
-            }
-            else {
-                queryResults.push("No matching sections found.");
-                queryResults.push("");
-            }
-        }
+        // Run all search queries — source scoped only.
+        // Cross-source search remains available via explicit search().
+        const queryResults = formatBatchQueryResults(store, queries, source);
         // Get searchable terms for edge cases where follow-up is needed
         const distinctiveTerms = store.getDistinctiveTerms
             ? store.getDistinctiveTerms(indexed.sourceId)
@@ -1608,7 +1627,7 @@ server.registerTool("ctx_upgrade", {
         // Write inline script to a temp .mjs file — avoids quote-escaping issues
         // across cmd.exe, PowerShell, and bash (node -e '...' breaks on Windows).
         const scriptLines = [
-            `import{execSync}from"node:child_process";`,
+            `import{execFileSync}from"node:child_process";`,
             `import{cpSync,rmSync,existsSync,mkdtempSync}from"node:fs";`,
             `import{join}from"node:path";`,
             `import{tmpdir}from"node:os";`,
@@ -1616,15 +1635,15 @@ server.registerTool("ctx_upgrade", {
             `const T=mkdtempSync(join(tmpdir(),"ctx-upgrade-"));`,
             `try{`,
             `console.log("- [x] Starting inline upgrade (no CLI found)");`,
-            `execSync("git clone --depth 1 ${repoUrl} \\""+T+"\\"",{stdio:"inherit"});`,
+            `execFileSync("git",["clone","--depth","1","${repoUrl}",T],{stdio:"inherit"});`,
             `console.log("- [x] Cloned latest source");`,
-            `execSync("npm install",{cwd:T,stdio:"inherit"});`,
-            `execSync("npm run build",{cwd:T,stdio:"inherit"});`,
+            `execFileSync("npm",["install"],{cwd:T,stdio:"inherit"});`,
+            `execFileSync("npm",["run","build"],{cwd:T,stdio:"inherit"});`,
             `console.log("- [x] Built from source");`,
             ...copyDirs.map((d) => `if(existsSync(join(T,${JSON.stringify(d)})))cpSync(join(T,${JSON.stringify(d)}),join(P,${JSON.stringify(d)}),{recursive:true,force:true});`),
             ...copyFiles.map((f) => `if(existsSync(join(T,${JSON.stringify(f)})))cpSync(join(T,${JSON.stringify(f)}),join(P,${JSON.stringify(f)}),{force:true});`),
             `console.log("- [x] Copied build artifacts");`,
-            `execSync("npm install --production",{cwd:P,stdio:"inherit"});`,
+            `execFileSync("npm",["install","--production"],{cwd:P,stdio:"inherit"});`,
             `console.log("- [x] Installed production dependencies");`,
             `console.log("## context-mode upgrade complete");`,
             `}catch(e){`,
@@ -1692,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/store.d.ts

@@ -7,6 +7,7 @@
  * Use for documentation, API references, and any content where
  * you need EXACT text later — not summaries.
  */
+type SourceMatchMode = "like" | "exact";
 import type { IndexResult, SearchResult, StoreStats } from "./types.js";
 export type { IndexResult, SearchResult, StoreStats } from "./types.js";
 /**
@@ -42,10 +43,10 @@ export declare class ContentStore {
      * Falls back to `indexPlainText` if the content is not valid JSON.
      */
     indexJSON(content: string, source: string, maxChunkBytes?: number): IndexResult;
-    search(query: string, limit?: number, source?: string, mode?: "AND" | "OR", contentType?: "code" | "prose"): SearchResult[];
-    searchTrigram(query: string, limit?: number, source?: string, mode?: "AND" | "OR", contentType?: "code" | "prose"): SearchResult[];
+    search(query: string, limit?: number, source?: string, mode?: "AND" | "OR", contentType?: "code" | "prose", sourceMatchMode?: SourceMatchMode): SearchResult[];
+    searchTrigram(query: string, limit?: number, source?: string, mode?: "AND" | "OR", contentType?: "code" | "prose", sourceMatchMode?: SourceMatchMode): SearchResult[];
     fuzzyCorrect(query: string): string | null;
-    searchWithFallback(query: string, limit?: number, source?: string, contentType?: "code" | "prose"): SearchResult[];
+    searchWithFallback(query: string, limit?: number, source?: string, contentType?: "code" | "prose", sourceMatchMode?: SourceMatchMode): SearchResult[];
     getSourceMeta(label: string): {
         label: string;
         chunkCount: number;

package/build/store.js

@@ -212,13 +212,17 @@ export class ContentStore {
     // Search path (hot)
     #stmtSearchPorter;
     #stmtSearchPorterFiltered;
+    #stmtSearchPorterExact;
     #stmtSearchTrigram;
     #stmtSearchTrigramFiltered;
+    #stmtSearchTrigramExact;
     #stmtFuzzyVocab;
     #stmtSearchPorterContentType;
     #stmtSearchPorterFilteredContentType;
+    #stmtSearchPorterExactContentType;
     #stmtSearchTrigramContentType;
     #stmtSearchTrigramFilteredContentType;
+    #stmtSearchTrigramExactContentType;
     // Read path
     #stmtListSources;
     #stmtChunksBySource;
@@ -278,6 +282,8 @@ export class ContentStore {
       CREATE TABLE IF NOT EXISTS vocabulary (
         word TEXT PRIMARY KEY
       );
+
+      CREATE INDEX IF NOT EXISTS idx_sources_label ON sources(label);
     `);
     }
     #prepareStatements() {
@@ -320,6 +326,20 @@ export class ContentStore {
       WHERE chunks MATCH ? AND sources.label LIKE ?
       ORDER BY rank
       LIMIT ?
+    `);
+        this.#stmtSearchPorterExact = this.#db.prepare(`
+      SELECT
+        chunks.title,
+        chunks.content,
+        chunks.content_type,
+        sources.label,
+        bm25(chunks, 5.0, 1.0) AS rank,
+        highlight(chunks, 1, char(2), char(3)) AS highlighted
+      FROM chunks
+      JOIN sources ON sources.id = chunks.source_id
+      WHERE chunks MATCH ? AND sources.label = ?
+      ORDER BY rank
+      LIMIT ?
     `);
         this.#stmtSearchTrigram = this.#db.prepare(`
       SELECT
@@ -348,6 +368,20 @@ export class ContentStore {
       WHERE chunks_trigram MATCH ? AND sources.label LIKE ?
       ORDER BY rank
       LIMIT ?
+    `);
+        this.#stmtSearchTrigramExact = this.#db.prepare(`
+      SELECT
+        chunks_trigram.title,
+        chunks_trigram.content,
+        chunks_trigram.content_type,
+        sources.label,
+        bm25(chunks_trigram, 5.0, 1.0) AS rank,
+        highlight(chunks_trigram, 1, char(2), char(3)) AS highlighted
+      FROM chunks_trigram
+      JOIN sources ON sources.id = chunks_trigram.source_id
+      WHERE chunks_trigram MATCH ? AND sources.label = ?
+      ORDER BY rank
+      LIMIT ?
     `);
         // Content-type filtered variants
         this.#stmtSearchPorterContentType = this.#db.prepare(`
@@ -377,6 +411,20 @@ export class ContentStore {
       WHERE chunks MATCH ? AND sources.label LIKE ? AND chunks.content_type = ?
       ORDER BY rank
       LIMIT ?
+    `);
+        this.#stmtSearchPorterExactContentType = this.#db.prepare(`
+      SELECT
+        chunks.title,
+        chunks.content,
+        chunks.content_type,
+        sources.label,
+        bm25(chunks, 5.0, 1.0) AS rank,
+        highlight(chunks, 1, char(2), char(3)) AS highlighted
+      FROM chunks
+      JOIN sources ON sources.id = chunks.source_id
+      WHERE chunks MATCH ? AND sources.label = ? AND chunks.content_type = ?
+      ORDER BY rank
+      LIMIT ?
     `);
         this.#stmtSearchTrigramContentType = this.#db.prepare(`
       SELECT
@@ -405,6 +453,20 @@ export class ContentStore {
       WHERE chunks_trigram MATCH ? AND sources.label LIKE ? AND chunks_trigram.content_type = ?
       ORDER BY rank
       LIMIT ?
+    `);
+        this.#stmtSearchTrigramExactContentType = this.#db.prepare(`
+      SELECT
+        chunks_trigram.title,
+        chunks_trigram.content,
+        chunks_trigram.content_type,
+        sources.label,
+        bm25(chunks_trigram, 5.0, 1.0) AS rank,
+        highlight(chunks_trigram, 1, char(2), char(3)) AS highlighted
+      FROM chunks_trigram
+      JOIN sources ON sources.id = chunks_trigram.source_id
+      WHERE chunks_trigram MATCH ? AND sources.label = ? AND chunks_trigram.content_type = ?
+      ORDER BY rank
+      LIMIT ?
     `);
         // Fuzzy path
         this.#stmtFuzzyVocab = this.#db.prepare("SELECT word FROM vocabulary WHERE length(word) BETWEEN ? AND ?");
@@ -514,17 +576,34 @@ export class ContentStore {
         };
     }
     // ── Search ──
-    search(query, limit = 3, source, mode = "AND", contentType) {
+    #mapSearchRows(rows) {
+        return rows.map((r) => ({
+            title: r.title,
+            content: r.content,
+            source: r.label,
+            rank: r.rank,
+            contentType: r.content_type,
+            highlighted: r.highlighted,
+        }));
+    }
+    #sourceFilterParam(source, sourceMatchMode) {
+        return sourceMatchMode === "exact" ? source : `%${source}%`;
+    }
+    search(query, limit = 3, source, mode = "AND", contentType, sourceMatchMode = "like") {
         const sanitized = sanitizeQuery(query, mode);
         let stmt;
         let params;
         if (source && contentType) {
-            stmt = this.#stmtSearchPorterFilteredContentType;
-            params = [sanitized, `%${source}%`, contentType, limit];
+            stmt = sourceMatchMode === "exact"
+                ? this.#stmtSearchPorterExactContentType
+                : this.#stmtSearchPorterFilteredContentType;
+            params = [sanitized, this.#sourceFilterParam(source, sourceMatchMode), contentType, limit];
         }
         else if (source) {
-            stmt = this.#stmtSearchPorterFiltered;
-            params = [sanitized, `%${source}%`, limit];
+            stmt = sourceMatchMode === "exact"
+                ? this.#stmtSearchPorterExact
+                : this.#stmtSearchPorterFiltered;
+            params = [sanitized, this.#sourceFilterParam(source, sourceMatchMode), limit];
         }
         else if (contentType) {
             stmt = this.#stmtSearchPorterContentType;
@@ -534,30 +613,26 @@ export class ContentStore {
             stmt = this.#stmtSearchPorter;
             params = [sanitized, limit];
         }
-        const rows = stmt.all(...params);
-        return rows.map((r) => ({
-            title: r.title,
-            content: r.content,
-            source: r.label,
-            rank: r.rank,
-            contentType: r.content_type,
-            highlighted: r.highlighted,
-        }));
+        return this.#mapSearchRows(stmt.all(...params));
     }
     // ── Trigram Search (Layer 2) ──
-    searchTrigram(query, limit = 3, source, mode = "AND", contentType) {
+    searchTrigram(query, limit = 3, source, mode = "AND", contentType, sourceMatchMode = "like") {
         const sanitized = sanitizeTrigramQuery(query, mode);
         if (!sanitized)
             return [];
         let stmt;
         let params;
         if (source && contentType) {
-            stmt = this.#stmtSearchTrigramFilteredContentType;
-            params = [sanitized, `%${source}%`, contentType, limit];
+            stmt = sourceMatchMode === "exact"
+                ? this.#stmtSearchTrigramExactContentType
+                : this.#stmtSearchTrigramFilteredContentType;
+            params = [sanitized, this.#sourceFilterParam(source, sourceMatchMode), contentType, limit];
         }
         else if (source) {
-            stmt = this.#stmtSearchTrigramFiltered;
-            params = [sanitized, `%${source}%`, limit];
+            stmt = sourceMatchMode === "exact"
+                ? this.#stmtSearchTrigramExact
+                : this.#stmtSearchTrigramFiltered;
+            params = [sanitized, this.#sourceFilterParam(source, sourceMatchMode), limit];
         }
         else if (contentType) {
             stmt = this.#stmtSearchTrigramContentType;
@@ -567,15 +642,7 @@ export class ContentStore {
             stmt = this.#stmtSearchTrigram;
             params = [sanitized, limit];
         }
-        const rows = stmt.all(...params);
-        return rows.map((r) => ({
-            title: r.title,
-            content: r.content,
-            source: r.label,
-            rank: r.rank,
-            contentType: r.content_type,
-            highlighted: r.highlighted,
-        }));
+        return this.#mapSearchRows(stmt.all(...params));
     }
     // ── Fuzzy Correction (Layer 3) ──
     fuzzyCorrect(query) {
@@ -598,11 +665,11 @@ export class ContentStore {
         return bestDist <= maxDist ? bestWord : null;
     }
     // ── Reciprocal Rank Fusion (Cormack et al. 2009) ──
-    #rrfSearch(query, limit, source, contentType) {
+    #rrfSearch(query, limit, source, contentType, sourceMatchMode = "like") {
         const K = 60; // Standard RRF constant
         const fetchLimit = Math.max(limit * 2, 10);
-        const porterResults = this.search(query, fetchLimit, source, "OR", contentType);
-        const trigramResults = this.searchTrigram(query, fetchLimit, source, "OR", contentType);
+        const porterResults = this.search(query, fetchLimit, source, "OR", contentType, sourceMatchMode);
+        const trigramResults = this.searchTrigram(query, fetchLimit, source, "OR", contentType, sourceMatchMode);
         const scoreMap = new Map();
         const key = (r) => `${r.source}::${r.title}`;
         for (const [i, r] of porterResults.entries()) {
@@ -655,9 +722,9 @@ export class ContentStore {
             .map(({ result }) => result);
     }
     // ── Unified Fallback Search ──
-    searchWithFallback(query, limit = 3, source, contentType) {
+    searchWithFallback(query, limit = 3, source, contentType, sourceMatchMode = "like") {
         // Step 1: RRF fusion (porter OR + trigram OR → merge)
-        const rrfResults = this.#rrfSearch(query, limit, source, contentType);
+        const rrfResults = this.#rrfSearch(query, limit, source, contentType, sourceMatchMode);
         if (rrfResults.length > 0) {
             const reranked = this.#applyProximityReranking(rrfResults, query);
             return reranked.map((r) => ({ ...r, matchLayer: "rrf" }));
@@ -672,7 +739,7 @@ export class ContentStore {
         const correctedWords = words.map((w) => this.fuzzyCorrect(w) ?? w);
         const correctedQuery = correctedWords.join(" ");
         if (correctedQuery !== original) {
-            const fuzzyResults = this.#rrfSearch(correctedQuery, limit, source, contentType);
+            const fuzzyResults = this.#rrfSearch(correctedQuery, limit, source, contentType, sourceMatchMode);
             if (fuzzyResults.length > 0) {
                 const reranked = this.#applyProximityReranking(fuzzyResults, correctedQuery);
                 return reranked.map((r) => ({ ...r, matchLayer: "rrf-fuzzy" }));

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
 // ─────────────────────────────────────────────────────────
 /**