@aexol/spectral 0.9.20 → 0.9.21

package/dist/memory/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/memory/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAcjE,MAAM,CAAC,OAAO,UAAU,mBAAmB,CAAC,GAAG,EAAE,YAAY,QAmB5D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/memory/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAejE,MAAM,CAAC,OAAO,UAAU,mBAAmB,CAAC,GAAG,EAAE,YAAY,QAoB5D"}

package/dist/memory/index.js

@@ -5,6 +5,7 @@ import { registerCompactionTrigger } from "./hooks/compaction-trigger.js";
 import { registerInterAgentReceiver } from "./hooks/inter-agent-receiver.js";
 import { registerObserverTrigger } from "./hooks/observer-trigger.js";
 import { Runtime } from "./runtime.js";
+import { registerToolOutputCompressor } from "./tool-output-compressor.js";
 import { registerRecallTool } from "./tools/recall-observation.js";
 import { registerReadProjectObservationsTool } from "./tools/read-project-observations.js";
 import { registerReceiveAgentObservationsTool } from "./tools/receive-agent-observations.js";
@@ -17,6 +18,7 @@ export default function observationalMemory(ext) {
     registerObserverTrigger(ext, runtime);
     registerCompactionTrigger(ext, runtime);
     registerCompactionHook(ext, runtime);
+    registerToolOutputCompressor(ext, runtime);
     registerStatusCommand(ext, runtime);
     registerViewCommand(ext, runtime);
     registerRecallTool(ext);

package/dist/memory/tool-output-compressor.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Tool Output Compressor — RTK-inspired pre-processing that intercepts
+ * tool results and compresses raw output before it enters the LLM context.
+ *
+ * This is complementary to the conversation-level compaction pipeline:
+ * - Compressor: compresses raw tool output (pre-context)
+ * - Compaction: summarizes + prunes conversation history (post-context)
+ * - Unified compaction: narrative summary + observation extraction (at compaction boundary)
+ *
+ * Strategies (mirroring RTK's four-pronged approach):
+ *
+ * 1. SMART FILTERING — strip noise from structured outputs
+ *    - Code: remove comments, collapse whitespace, skip blank lines
+ *    - Git: strip progress meters, hints, verbose enumerations
+ *    - Shell: remove ANSI escape codes, carriage returns
+ *
+ * 2. GROUPING — aggregate similar items
+ *    - ls/find: group files by directory
+ *    - grep/rg: group matches by file, collapse repeated patterns
+ *    - Lint errors: group by rule + file
+ *
+ * 3. TRUNCATION — keep relevant context, cut redundancy
+ *    - Read: keep N lines with line-number markers
+ *    - Bash: keep first + last N lines of long output
+ *    - Test runners: keep only failures + summary
+ *
+ * 4. DEDUPLICATION — collapse repeated lines with counts
+ *    - Log output: deduplicate repeated lines
+ *    - Docker/build output: collapse progress lines
+ */
+import type { ExtensionAPI } from "../sdk/coding-agent/index.js";
+import type { Runtime } from "./runtime.js";
+export interface CompressorConfig {
+    /** Enable compression (default: true) */
+    enabled: boolean;
+    /** Maximum characters for any single tool result before truncation */
+    maxResultChars: number;
+    /** Maximum lines for read results before truncation */
+    maxReadLines: number;
+    /** Maximum lines for directory listings */
+    maxLsLines: number;
+    /** Maximum lines for grep/find results before grouping */
+    maxSearchLines: number;
+    /** Enable ANSI escape code stripping */
+    stripAnsi: boolean;
+    /** Enable comment stripping for code files */
+    stripComments: boolean;
+    /** Enable test-runner failure-only filtering */
+    testFailuresOnly: boolean;
+    /** Enable git output compacting */
+    compactGit: boolean;
+}
+export declare const DEFAULT_COMPRESSOR_CONFIG: CompressorConfig;
+export interface CompressionStats {
+    originalChars: number;
+    compressedChars: number;
+    savingsPercent: number;
+    toolName: string;
+}
+export declare function registerToolOutputCompressor(ext: ExtensionAPI, runtime: Runtime): void;
+//# sourceMappingURL=tool-output-compressor.d.ts.map

package/dist/memory/tool-output-compressor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-output-compressor.d.ts","sourceRoot":"","sources":["../../src/memory/tool-output-compressor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAUjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAO5C,MAAM,WAAW,gBAAgB;IAChC,yCAAyC;IACzC,OAAO,EAAE,OAAO,CAAC;IACjB,sEAAsE;IACtE,cAAc,EAAE,MAAM,CAAC;IACvB,uDAAuD;IACvD,YAAY,EAAE,MAAM,CAAC;IACrB,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,0DAA0D;IAC1D,cAAc,EAAE,MAAM,CAAC;IACvB,wCAAwC;IACxC,SAAS,EAAE,OAAO,CAAC;IACnB,8CAA8C;IAC9C,aAAa,EAAE,OAAO,CAAC;IACvB,gDAAgD;IAChD,gBAAgB,EAAE,OAAO,CAAC;IAC1B,mCAAmC;IACnC,UAAU,EAAE,OAAO,CAAC;CACpB;AAED,eAAO,MAAM,yBAAyB,EAAE,gBAUvC,CAAC;AAghBF,MAAM,WAAW,gBAAgB;IAChC,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,4BAA4B,CAC3C,GAAG,EAAE,YAAY,EACjB,OAAO,EAAE,OAAO,GACd,IAAI,CA4HN"}

package/dist/memory/tool-output-compressor.js

@@ -0,0 +1,569 @@
+/**
+ * Tool Output Compressor — RTK-inspired pre-processing that intercepts
+ * tool results and compresses raw output before it enters the LLM context.
+ *
+ * This is complementary to the conversation-level compaction pipeline:
+ * - Compressor: compresses raw tool output (pre-context)
+ * - Compaction: summarizes + prunes conversation history (post-context)
+ * - Unified compaction: narrative summary + observation extraction (at compaction boundary)
+ *
+ * Strategies (mirroring RTK's four-pronged approach):
+ *
+ * 1. SMART FILTERING — strip noise from structured outputs
+ *    - Code: remove comments, collapse whitespace, skip blank lines
+ *    - Git: strip progress meters, hints, verbose enumerations
+ *    - Shell: remove ANSI escape codes, carriage returns
+ *
+ * 2. GROUPING — aggregate similar items
+ *    - ls/find: group files by directory
+ *    - grep/rg: group matches by file, collapse repeated patterns
+ *    - Lint errors: group by rule + file
+ *
+ * 3. TRUNCATION — keep relevant context, cut redundancy
+ *    - Read: keep N lines with line-number markers
+ *    - Bash: keep first + last N lines of long output
+ *    - Test runners: keep only failures + summary
+ *
+ * 4. DEDUPLICATION — collapse repeated lines with counts
+ *    - Log output: deduplicate repeated lines
+ *    - Docker/build output: collapse progress lines
+ */
+import { debugLog } from "./debug-log.js";
+export const DEFAULT_COMPRESSOR_CONFIG = {
+    enabled: true,
+    maxResultChars: 8000,
+    maxReadLines: 500,
+    maxLsLines: 100,
+    maxSearchLines: 200,
+    stripAnsi: true,
+    stripComments: true,
+    testFailuresOnly: true,
+    compactGit: true,
+};
+// ============================================================================
+// ANSI Stripping
+// ============================================================================
+const ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]/g;
+const CARRIAGE_RETURN_RE = /\r/g;
+function stripAnsi(input) {
+    return input.replace(ANSI_RE, "").replace(CARRIAGE_RETURN_RE, "");
+}
+const COMMENT_PATTERNS = {
+    ts: { line: "//", blockStart: "/*", blockEnd: "*/" },
+    tsx: { line: "//", blockStart: "/*", blockEnd: "*/" },
+    js: { line: "//", blockStart: "/*", blockEnd: "*/" },
+    jsx: { line: "//", blockStart: "/*", blockEnd: "*/" },
+    mjs: { line: "//", blockStart: "/*", blockEnd: "*/" },
+    cjs: { line: "//", blockStart: "/*", blockEnd: "*/" },
+    py: { line: "#", blockStart: '"""', blockEnd: '"""' },
+    pyw: { line: "#", blockStart: '"""', blockEnd: '"""' },
+    rs: { line: "//", blockStart: "/*", blockEnd: "*/" },
+    go: { line: "//", blockStart: "/*", blockEnd: "*/" },
+    java: { line: "//", blockStart: "/*", blockEnd: "*/" },
+    rb: { line: "#", blockStart: "=begin", blockEnd: "=end" },
+    sh: { line: "#", blockStart: null, blockEnd: null },
+    bash: { line: "#", blockStart: null, blockEnd: null },
+    zsh: { line: "#", blockStart: null, blockEnd: null },
+    c: { line: "//", blockStart: "/*", blockEnd: "*/" },
+    h: { line: "//", blockStart: "/*", blockEnd: "*/" },
+    cpp: { line: "//", blockStart: "/*", blockEnd: "*/" },
+    hpp: { line: "//", blockStart: "/*", blockEnd: "*/" },
+};
+/** Data formats that must never have comment stripping applied */
+const DATA_EXTENSIONS = new Set([
+    "json", "jsonc", "json5", "yaml", "yml", "toml", "xml", "csv",
+    "tsv", "graphql", "gql", "sql", "md", "markdown", "txt",
+    "env", "lock", "css", "scss", "less", "html", "htm",
+]);
+function getExtension(filePath) {
+    const dot = filePath.lastIndexOf(".");
+    if (dot < 0)
+        return "";
+    return filePath.slice(dot + 1).toLowerCase();
+}
+function stripComments(content, ext) {
+    if (!ext || DATA_EXTENSIONS.has(ext))
+        return content;
+    const patterns = COMMENT_PATTERNS[ext];
+    if (!patterns)
+        return content;
+    const lines = content.split("\n");
+    const result = [];
+    let inBlockComment = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Handle block comments
+        if (patterns.blockStart && patterns.blockEnd) {
+            if (!inBlockComment && trimmed.includes(patterns.blockStart)) {
+                inBlockComment = true;
+            }
+            if (inBlockComment) {
+                if (trimmed.includes(patterns.blockEnd)) {
+                    inBlockComment = false;
+                }
+                continue;
+            }
+        }
+        // Skip line comments
+        if (patterns.line && trimmed.startsWith(patterns.line)) {
+            continue;
+        }
+        // Skip blank lines
+        if (!trimmed)
+            continue;
+        // Remove trailing whitespace
+        result.push(line.replace(/\s+$/, ""));
+    }
+    return result.join("\n");
+}
+// ============================================================================
+// Smart Truncation
+// ============================================================================
+function smartTruncate(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    const half = Math.floor(maxChars / 2);
+    const head = text.slice(0, half);
+    const tail = text.slice(text.length - half);
+    const omitted = text.length - head.length - tail.length;
+    return `${head}\n\n[... ${omitted} characters truncated ...]\n\n${tail}`;
+}
+function smartTruncateLines(text, maxLines) {
+    const lines = text.split("\n");
+    if (lines.length <= maxLines)
+        return text;
+    const keepFirst = Math.floor(maxLines / 3);
+    const keepLast = Math.floor(maxLines / 3);
+    const middle = maxLines - keepFirst - keepLast - 1;
+    const head = lines.slice(0, keepFirst);
+    const tail = lines.slice(lines.length - keepLast);
+    const omitted = lines.length - keepFirst - keepLast;
+    return [
+        ...head,
+        `[... ${omitted} lines omitted ...]`,
+        ...tail,
+    ].join("\n");
+}
+function deduplicateRepeatedLines(text) {
+    const lines = text.split("\n");
+    const stats = { totalLines: 0, uniqueLines: 0, collapsedRuns: 0 };
+    if (lines.length === 0)
+        return { result: text, stats };
+    const result = [];
+    let runCount = 0;
+    let lastLine = "";
+    for (const line of lines) {
+        stats.totalLines++;
+        if (line === lastLine) {
+            runCount++;
+        }
+        else {
+            if (runCount > 2) {
+                // Collapse: replace the repeated run with a count marker
+                result.pop(); // Remove the last duplicate
+                result.push(`${lastLine}  [repeated ${runCount - 1} more times]`);
+                stats.collapsedRuns++;
+            }
+            result.push(line);
+            stats.uniqueLines++;
+            runCount = 1;
+            lastLine = line;
+        }
+    }
+    // Handle trailing run
+    if (runCount > 2) {
+        result.pop();
+        result.push(`${lastLine}  [repeated ${runCount - 1} more times]`);
+        stats.collapsedRuns++;
+    }
+    return {
+        result: result.join("\n"),
+        stats,
+    };
+}
+// ============================================================================
+// Read Compressor
+// ============================================================================
+function compressReadOutput(event, config) {
+    let content = event.content
+        .filter((c) => c.type === "text")
+        .map((c) => c.text)
+        .join("\n");
+    if (!content)
+        return "";
+    // Strip ANSI
+    if (config.stripAnsi) {
+        content = stripAnsi(content);
+    }
+    // Strip comments for code files
+    if (config.stripComments) {
+        const filePath = event.input?.path ?? "";
+        const ext = getExtension(filePath);
+        if (ext && !DATA_EXTENSIONS.has(ext)) {
+            content = stripComments(content, ext);
+        }
+    }
+    // Truncate long reads
+    const lines = content.split("\n");
+    if (lines.length > config.maxReadLines) {
+        content = smartTruncateLines(content, config.maxReadLines);
+    }
+    // Truncate by char count
+    if (content.length > config.maxResultChars) {
+        content = smartTruncate(content, config.maxResultChars);
+    }
+    return content;
+}
+// ============================================================================
+// Bash Compressor
+// ============================================================================
+/** Commands whose output should be filtered to failures only */
+const TEST_COMMANDS = [
+    "jest", "vitest", "pytest", "go test", "cargo test",
+    "rspec", "rake test", "playwright test", "npx playwright",
+    "npm test", "npm run test", "yarn test", "pnpm test",
+    "bun test",
+];
+/** Commands where git-like compacting should apply */
+const GIT_COMMANDS = [
+    "git status", "git diff", "git log", "git show",
+    "git push", "git pull", "git fetch", "git add",
+    "git commit", "git branch", "git stash",
+];
+/** Patterns to strip from git output */
+const GIT_NOISE_PATTERNS = [
+    /^Enumerating objects:/,
+    /^Counting objects:/,
+    /^Compressing objects:/,
+    /^Writing objects:/,
+    /^Delta compression using/,
+    /^Total \d+/,
+    /^\(use "git/,
+    /^\(create\/copy files/,
+];
+function detectCommandType(command) {
+    const base = command.split(/\s+/).slice(0, 3).join(" ").toLowerCase();
+    for (const testCmd of TEST_COMMANDS) {
+        if (base.startsWith(testCmd))
+            return "test";
+    }
+    for (const gitCmd of GIT_COMMANDS) {
+        if (base.startsWith(gitCmd))
+            return "git";
+    }
+    if (/\b(build|compile|tsc|esbuild|webpack|vite build|next build)\b/.test(base)) {
+        return "build";
+    }
+    return "other";
+}
+function filterGitOutput(content) {
+    const lines = content.split("\n");
+    const filtered = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        // Skip noise lines
+        if (GIT_NOISE_PATTERNS.some((p) => p.test(trimmed)))
+            continue;
+        filtered.push(line);
+    }
+    if (filtered.length === 0)
+        return "ok";
+    return filtered.join("\n");
+}
+function filterTestOutput(content) {
+    const lines = content.split("\n");
+    const result = [];
+    let failureSection = false;
+    let summarySection = false;
+    for (const line of lines) {
+        // Start of failure section
+        if (/^FAIL|^\s*●|^\s*\d+\)|^\s*FAILED|^AssertionError|^Error:/i.test(line)) {
+            failureSection = true;
+        }
+        // Start of summary section
+        if (/^(Test Suites|Tests|Snapshots|Time|Ran all):/i.test(line)) {
+            summarySection = true;
+            failureSection = false;
+        }
+        // Keep lines in failure or summary sections
+        if (failureSection || summarySection) {
+            result.push(line);
+        }
+    }
+    // If no failures found, just return a summary
+    if (result.length === 0) {
+        const summaryLines = lines.filter((l) => /^(Tests|Test Suites|Snapshots|Time|Ran):/i.test(l.trim()));
+        if (summaryLines.length > 0) {
+            return summaryLines.join("\n");
+        }
+        return "All tests passed.";
+    }
+    return result.join("\n");
+}
+function compressBashOutput(event, config) {
+    let content = event.content
+        .filter((c) => c.type === "text")
+        .map((c) => c.text)
+        .join("\n");
+    if (!content)
+        return "";
+    // Strip ANSI
+    if (config.stripAnsi) {
+        content = stripAnsi(content);
+    }
+    // Detect command type and apply specialized filters
+    const command = event.input?.command ?? "";
+    const cmdType = detectCommandType(command);
+    switch (cmdType) {
+        case "git":
+            if (config.compactGit) {
+                content = filterGitOutput(content);
+            }
+            break;
+        case "test":
+            if (config.testFailuresOnly) {
+                content = filterTestOutput(content);
+            }
+            break;
+        case "build":
+            // For build output, deduplicate repeated progress lines
+            {
+                const deduped = deduplicateRepeatedLines(content);
+                content = deduped.result;
+            }
+            break;
+    }
+    // Deduplicate repeated lines for all outputs
+    {
+        const deduped = deduplicateRepeatedLines(content);
+        if (deduped.stats.collapsedRuns > 0) {
+            content = deduped.result;
+        }
+    }
+    // Truncate by char count
+    if (content.length > config.maxResultChars) {
+        content = smartTruncate(content, config.maxResultChars);
+    }
+    return content;
+}
+// ============================================================================
+// Ls Compressor
+// ============================================================================
+function compressLsOutput(event, config) {
+    let content = event.content
+        .filter((c) => c.type === "text")
+        .map((c) => c.text)
+        .join("\n");
+    if (!content)
+        return "";
+    if (config.stripAnsi) {
+        content = stripAnsi(content);
+    }
+    const lines = content.split("\n");
+    if (lines.length > config.maxLsLines) {
+        // Group by directory when listing many files
+        const groups = new Map();
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const slashIdx = trimmed.lastIndexOf("/");
+            const dir = slashIdx >= 0 ? trimmed.slice(0, slashIdx) : ".";
+            groups.set(dir, (groups.get(dir) ?? 0) + 1);
+        }
+        const grouped = [];
+        for (const [dir, count] of [...groups.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+            grouped.push(`${dir}/  (${count} files)`);
+        }
+        return grouped.join("\n");
+    }
+    return content;
+}
+// ============================================================================
+// Grep Compressor
+// ============================================================================
+function compressGrepOutput(event, config) {
+    let content = event.content
+        .filter((c) => c.type === "text")
+        .map((c) => c.text)
+        .join("\n");
+    if (!content)
+        return "";
+    if (config.stripAnsi) {
+        content = stripAnsi(content);
+    }
+    // Group matches by file
+    const lines = content.split("\n");
+    const byFile = new Map();
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        // Standard grep format: "file:line:text"
+        const colonIdx = trimmed.indexOf(":");
+        if (colonIdx > 0) {
+            const file = trimmed.slice(0, colonIdx);
+            byFile.set(file, (byFile.get(file) ?? 0) + 1);
+        }
+    }
+    if (byFile.size > 1 && lines.length > config.maxSearchLines) {
+        // Group by file with count, show first few matches per file
+        const grouped = [];
+        for (const [file, count] of [...byFile.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+            const fileMatches = lines.filter((l) => l.startsWith(file));
+            const preview = fileMatches.slice(0, 3).join("\n  ");
+            grouped.push(`${file} (${count} matches):\n  ${preview}${count > 3 ? `\n  ... +${count - 3} more` : ""}`);
+        }
+        return grouped.join("\n\n");
+    }
+    return content;
+}
+// ============================================================================
+// Find Compressor
+// ============================================================================
+function compressFindOutput(event, config) {
+    let content = event.content
+        .filter((c) => c.type === "text")
+        .map((c) => c.text)
+        .join("\n");
+    if (!content)
+        return "";
+    if (config.stripAnsi) {
+        content = stripAnsi(content);
+    }
+    // Group by directory
+    const lines = content.split("\n").filter((l) => l.trim());
+    if (lines.length > config.maxSearchLines) {
+        const groups = new Map();
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const slashIdx = trimmed.lastIndexOf("/");
+            const dir = slashIdx >= 0 ? trimmed.slice(0, slashIdx) : ".";
+            if (!groups.has(dir))
+                groups.set(dir, []);
+            groups.get(dir).push(slashIdx >= 0 ? trimmed.slice(slashIdx + 1) : trimmed);
+        }
+        const grouped = [];
+        for (const [dir, files] of [...groups.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+            if (files.length === 1) {
+                grouped.push(`${dir}/${files[0]}`);
+            }
+            else if (files.length <= 5) {
+                grouped.push(`${dir}/  (${files.length} files: ${files.join(", ")})`);
+            }
+            else {
+                grouped.push(`${dir}/  (${files.length} files: ${files.slice(0, 3).join(", ")}... +${files.length - 3} more)`);
+            }
+        }
+        return grouped.join("\n");
+    }
+    return content;
+}
+export function registerToolOutputCompressor(ext, runtime) {
+    const config = { ...DEFAULT_COMPRESSOR_CONFIG };
+    ext.on("tool_result", (_event, _ctx) => {
+        if (!config.enabled)
+            return;
+        // Only apply compression for known tool types
+        if (_event.toolName === "read") {
+            const event = _event;
+            const original = event.content
+                .filter((c) => c.type === "text")
+                .map((c) => c.text)
+                .join("\n");
+            const compressed = compressReadOutput(event, config);
+            if (compressed && compressed !== original) {
+                debugLog("compressor.read", {
+                    originalLen: original.length,
+                    compressedLen: compressed.length,
+                    savings: ((1 - compressed.length / Math.max(1, original.length)) * 100).toFixed(1) + "%",
+                });
+                return {
+                    content: [...event.content.filter((c) => c.type !== "text"), { type: "text", text: compressed }],
+                };
+            }
+            return;
+        }
+        if (_event.toolName === "bash") {
+            const event = _event;
+            const original = event.content
+                .filter((c) => c.type === "text")
+                .map((c) => c.text)
+                .join("\n");
+            const compressed = compressBashOutput(event, config);
+            if (compressed && compressed !== original) {
+                const command = event.input?.command ?? "";
+                debugLog("compressor.bash", {
+                    command: command.slice(0, 80),
+                    originalLen: original.length,
+                    compressedLen: compressed.length,
+                    savings: ((1 - compressed.length / Math.max(1, original.length)) * 100).toFixed(1) + "%",
+                });
+                return {
+                    content: [...event.content.filter((c) => c.type !== "text"), { type: "text", text: compressed }],
+                };
+            }
+            return;
+        }
+        if (_event.toolName === "ls") {
+            const event = _event;
+            const original = event.content
+                .filter((c) => c.type === "text")
+                .map((c) => c.text)
+                .join("\n");
+            const compressed = compressLsOutput(event, config);
+            if (compressed && compressed !== original) {
+                debugLog("compressor.ls", {
+                    originalLen: original.length,
+                    compressedLen: compressed.length,
+                });
+                return {
+                    content: [...event.content.filter((c) => c.type !== "text"), { type: "text", text: compressed }],
+                };
+            }
+            return;
+        }
+        if (_event.toolName === "grep") {
+            const event = _event;
+            const original = event.content
+                .filter((c) => c.type === "text")
+                .map((c) => c.text)
+                .join("\n");
+            const compressed = compressGrepOutput(event, config);
+            if (compressed && compressed !== original) {
+                debugLog("compressor.grep", {
+                    originalLen: original.length,
+                    compressedLen: compressed.length,
+                });
+                return {
+                    content: [...event.content.filter((c) => c.type !== "text"), { type: "text", text: compressed }],
+                };
+            }
+            return;
+        }
+        if (_event.toolName === "find") {
+            const event = _event;
+            const original = event.content
+                .filter((c) => c.type === "text")
+                .map((c) => c.text)
+                .join("\n");
+            const compressed = compressFindOutput(event, config);
+            if (compressed && compressed !== original) {
+                debugLog("compressor.find", {
+                    originalLen: original.length,
+                    compressedLen: compressed.length,
+                });
+                return {
+                    content: [...event.content.filter((c) => c.type !== "text"), { type: "text", text: compressed }],
+                };
+            }
+            return;
+        }
+        // Unknown tool types: do nothing
+        return;
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aexol/spectral",
-  "version": "0.9.20",
+  "version": "0.9.21",
   "description": "AI coding agent for Aexol with relay-based browser access.",
   "type": "module",
   "private": false,