@hasna/terminal 2.3.2 → 3.0.1

package/dist/ai.js

@@ -21,17 +21,26 @@ const MODEL_DEFAULTS = {
     xai: { fast: "grok-code-fast-1", smart: "grok-4-fast-non-reasoning" },
     anthropic: { fast: "claude-haiku-4-5-20251001", smart: "claude-sonnet-4-6" },
 };
-/** Load user model overrides from ~/.terminal/config.json */
+/** Load user model overrides from ~/.terminal/config.json (cached 30s) */
+let _modelOverrides = null;
+let _modelOverridesAt = 0;
 function loadModelOverrides() {
+    const now = Date.now();
+    if (_modelOverrides && now - _modelOverridesAt < 30_000)
+        return _modelOverrides;
     try {
         const configPath = join(process.env.HOME ?? "~", ".terminal", "config.json");
         if (existsSync(configPath)) {
             const config = JSON.parse(readFileSync(configPath, "utf8"));
-            return config.models ?? {};
+            _modelOverrides = config.models ?? {};
+            _modelOverridesAt = now;
+            return _modelOverrides;
         }
     }
     catch { }
-    return {};
+    _modelOverrides = {};
+    _modelOverridesAt = now;
+    return _modelOverrides;
 }
 /** Model routing per provider — config-driven with defaults */
 function pickModel(nl) {
@@ -122,6 +131,7 @@ function detectProjectContext() {
 }
 // ── system prompt ─────────────────────────────────────────────────────────────
 function buildSystemPrompt(perms, sessionEntries, currentPrompt) {
+    const nl = currentPrompt?.toLowerCase() ?? "";
     const restrictions = [];
     if (!perms.destructive)
         restrictions.push("- NEVER generate commands that delete, remove, or overwrite files/data");
@@ -150,7 +160,6 @@ function buildSystemPrompt(perms, sessionEntries, currentPrompt) {
         contextBlock = `\n\nSESSION HISTORY (user intent > command $ output):\n${lines.join("\n")}`;
     }
     const projectContext = detectProjectContext();
-    // Inject safety hints for the command being generated (AI sees what's risky)
     const safetyBlock = sessionEntries.length > 0
         ? (() => {
             const lastCmd = sessionEntries[sessionEntries.length - 1]?.cmd;
@@ -161,70 +170,29 @@ function buildSystemPrompt(perms, sessionEntries, currentPrompt) {
             return "";
         })()
         : "";
+    // ── Conditional sections (only included when relevant) ──
+    const wantsStructure = /\b(function|class|interface|export|symbol|structure|hierarchy|outline)\b/i.test(nl);
+    const astBlock = wantsStructure ? `\nAST-POWERED QUERIES: For code STRUCTURE questions, use "terminal symbols" instead of grep. It uses AST parsing for TypeScript, Python, Go, Rust.` : "";
+    const wantsMultiple = /\b(and|both|also|plus|as well)\b/i.test(nl);
+    const compoundBlock = wantsMultiple ? `\nCOMPOUND QUESTIONS: Prefer ONE command that captures all info. NEVER split into separate expensive commands.` : "";
+    const wantsAnalysis = /\b(quality|lint|coverage|complexity|unused|dead code|security|audit|scan|dependency)\b/i.test(nl);
+    const blockedAltBlock = wantsAnalysis ? `\nBLOCKED ALTERNATIVES: If your preferred command needs installing packages, try READ-ONLY alternatives (grep, cat, wc, awk). NEVER give up on analysis questions.` : "";
     return `You are a terminal assistant. Output ONLY the exact shell command — no explanation, no markdown, no backticks.
-The user describes what they want in plain English. You translate to the exact shell command.
 
 RULES:
-- SIMPLICITY FIRST: Use the simplest command that works. Prefer grep | sort | head over 10-pipe chains. Complex pipelines are OK when needed, but NEVER pass file:line output to wc or xargs without cleaning it first.
-- ALWAYS use grep -rn (with -r) when searching directories. NEVER use grep without -r on src/ or any directory.
-- When user refers to items from previous output, use the EXACT names shown (e.g., "feature/auth" not "auth", "open-skills" not "open_skills")
-- When user says "the largest/smallest/first/second", look at the previous output to identify the correct item
-- When user says "them all" or "combine them", refer to items from the most recent command output
-- For "show who changed each line" use git blame, for "show remote urls" use git remote -v
-- For text search in code, use grep -rn, NOT nm or objdump (those are for compiled binaries)
-- On macOS: for memory use vm_stat or top -l 1, for disk use df -h, for processes use ps aux
-- macOS uses BSD tools, NOT GNU. Use: du -d 1 (not --max-depth), ls (not ls --color), sort -r (not sort --reverse), ps aux (not ps --sort)
-- NEVER use grep -P (PCRE). macOS grep has NO -P flag. Use grep -E for extended regex, or sed/awk for complex extraction.
-- NEVER invent commands that don't exist. Stick to standard Unix/macOS commands.
-- NEVER install packages (npx, npm install, pip install, brew install). This is a READ-ONLY terminal.
-- NEVER modify source code (sed -i, codemod, awk with redirect). Only observe, never change.
-- Search src/ directory, NOT dist/ or node_modules/ for code queries.
-- Use exact file paths from the project context below. Do NOT guess paths.
-- For "what would break if I deleted X": use grep -rn "from.*X\\|import.*X\\|require.*X" src/ to find all importers.
-- For "find where X is defined": use grep -rn "export.*function X\\|export.*class X\\|export.*const X" src/
-- For "show me the code of function X": if you know the file, use grep -A 30 "function X" src/file.ts. If not, use grep -rn -A 30 "function X" src/ --include="*.ts"
-- ALWAYS use grep -rn (recursive) when searching directories. NEVER use grep without -r on a directory — it will fail.
-- For conceptual questions about what code does: use cat on the relevant file, the AI summary will explain it.
-- For DESTRUCTIVE requests (delete, remove, install, push): output BLOCKED: <reason>. NEVER try to execute destructive commands.
-
-AST-POWERED QUERIES: For code STRUCTURE questions, use the built-in AST tool instead of grep:
-- "find all exported functions" → terminal symbols src/ (lists all functions, classes, interfaces with line numbers)
-- "show all interfaces" → terminal symbols src/ | grep interface
-- "what does file X export" → terminal symbols src/file.ts
-- "show me the class hierarchy" → terminal symbols src/
-The "terminal symbols" command uses AST parsing (not regex) — it understands TypeScript, Python, Go, Rust code structure.
-For TEXT search (TODO, string matches, imports) → use grep as normal.
-
-COMPOUND QUESTIONS: For questions asking multiple things, prefer ONE command that captures all info. Extract multiple answers from a single output.
-- "how many tests and do they pass" → bun test (extract count AND pass/fail from output)
-- "what files changed and how many lines" → git log --stat -3 (shows files AND line counts)
-- "what version of node and bun" → node -v && bun -v (only use && for trivial non-failing commands)
-NEVER split into separate test runs or expensive commands chained with &&.
-
-BLOCKED ALTERNATIVES: If your preferred command would require installing packages (npx, npm install), ALWAYS try a READ-ONLY alternative:
-- Code quality analysis → grep -rn "TODO\\|FIXME\\|HACK\\|XXX" src/
-- Linting → check if "lint" or "typecheck" exists in package.json scripts, run that
-- Security scan → grep -rn "eval\\|exec\\|spawn\\|password\\|secret" src/
-- Dependency audit → cat package.json | grep -A 50 dependencies
-- Test coverage → bun test --coverage (or npm run test:coverage if available)
-NEVER give up. NEVER output BLOCKED for analysis questions. Always try a grep/find/cat/wc/awk read-only alternative.
-- Cyclomatic complexity → grep -rn "if\\|else\\|for\\|while\\|switch\\|case\\|catch\\|&&\\|||" src/ --include="*.ts" | wc -l
-- Unused exports → grep -rn "export function\|export const\|export class" src/ --include="*.ts" | sed 's/.*export [a-z]* //' | sed 's/[(<:].*//' | sort -u
-- Dead code → for each exported name, grep -rn "name" src/ --include="*.ts" | wc -l (if only 1 match = unused)
-- Dependency graph → grep -rn "from " src/ --include="*.ts" | sed 's/:.*from "/→/' | sed 's/".*//' | sort -u
-- Most parameters → grep -rn "function " src/ --include="*.ts" | awk -F'[()]' '{print gsub(/,/,",",$2)+1, $0}' | sort -nr | head -10
-ALWAYS try a heuristic shell approach before giving up. NEVER say BLOCKED for analysis questions.
-
-SEMANTIC MAPPING: When the user references a concept, search the file tree for RELATED terms:
-- Look at directory names: src/agent/ likely contains "agentic" code
-- Look at file names: lazy-executor.ts likely handles "lazy mode"
-- When uncertain: grep -rn "keyword" src/ --include="*.ts" -l (list matching files)
-
-ACTION vs CONCEPTUAL: If the prompt starts with "run", "execute", "check", "test", "build", "show output of" — ALWAYS generate an executable command. NEVER read README for action requests. Only read docs for "explain why", "what does X mean", "how was X designed".
-
-EXISTENCE CHECKS: If the prompt starts with "is there", "does this have", "do we have", "does X exist" — NEVER run/start/launch anything. Use ls, find, or test -d to CHECK existence. These are READ-ONLY questions.
-
-MONOREPO: If the project context says "MONOREPO", search packages/ or apps/ NOT src/. Use: grep -rn "pattern" packages/ --include="*.ts". For specific packages, use packages/PKGNAME/src/.
+- SIMPLICITY FIRST: Use the simplest command. Prefer grep | sort | head over 10-pipe chains.
+- ALWAYS use grep -rn when searching directories. NEVER grep without -r on a directory.
+- When user refers to items from previous output, use EXACT names shown.
+- For text search use grep -rn, NOT nm or objdump.
+- macOS/BSD tools: du -d 1 (not --max-depth), NEVER grep -P, use grep -E for extended regex.
+- NEVER invent commands. Stick to standard Unix/macOS.
+- NEVER install packages. READ-ONLY terminal.
+- NEVER modify source code. Only observe.
+- Search src/ not dist/ or node_modules/.
+- Use exact file paths from project context. Do NOT guess paths.
+- For DESTRUCTIVE requests: output BLOCKED: <reason>.
+- ACTION vs CONCEPTUAL: "run/test/build/check" → executable command. "explain/what does X mean" → read docs.
+- EXISTENCE CHECKS: "is there/does X exist" → use ls/find/test, NEVER run/launch.${astBlock}${compoundBlock}${blockedAltBlock}
 cwd: ${process.cwd()}
 shell: zsh / macOS${projectContext}${safetyBlock}${restrictionBlock}${contextBlock}${currentPrompt ? loadCorrectionHints(currentPrompt) : ""}`;
 }
@@ -244,12 +212,12 @@ export async function translateToCommand(nl, perms, sessionEntries, onToken) {
     const system = buildSystemPrompt(perms, sessionEntries, nl);
     let text;
     if (onToken) {
-        text = await provider.stream(nl, { model, maxTokens: 256, system }, {
+        text = await provider.stream(nl, { model, maxTokens: 256, temperature: 0, stop: ["\n"], system }, {
             onToken: (partial) => onToken(partial),
         });
     }
     else {
-        text = await provider.complete(nl, { model, maxTokens: 256, system });
+        text = await provider.complete(nl, { model, maxTokens: 256, temperature: 0, stop: ["\n"], system });
     }
     if (text.startsWith("BLOCKED:"))
         throw new Error(text);
@@ -294,29 +262,35 @@ export async function explainCommand(command) {
     return provider.complete(command, {
         model: routing.fast,
         maxTokens: 128,
+        temperature: 0,
         system: "Explain what this shell command does in one plain English sentence. No markdown, no code blocks.",
     });
 }
 // ── auto-fix ──────────────────────────────────────────────────────────────────
-export async function fixCommand(originalNl, failedCommand, errorOutput, perms, sessionEntries) {
+export async function fixCommand(originalNl, failedCommand, errorOutput, perms, _sessionEntries) {
     const provider = getProvider();
     const routing = pickModel(originalNl);
-    const text = await provider.complete(`I wanted to: ${originalNl}\nI ran: ${failedCommand}\nError:\n${errorOutput}\n\nGive me the corrected command only.`, {
-        model: routing.smart, // always use smart model for fixes
+    // Lightweight fix prompt — no full project context, just rules + restrictions
+    const restrictions = [];
+    if (!perms.destructive)
+        restrictions.push("- NEVER delete/remove/overwrite files");
+    if (!perms.network)
+        restrictions.push("- NEVER make network requests");
+    if (!perms.install)
+        restrictions.push("- NEVER install packages");
+    const fixSystem = `You are a terminal assistant. Output ONLY the corrected shell command — no explanation.
+macOS/BSD tools. NEVER use grep -P. Use grep -E for extended regex.
+NEVER install packages. READ-ONLY terminal.
+cwd: ${process.cwd()}${restrictions.length > 0 ? `\nRESTRICTIONS:\n${restrictions.join("\n")}` : ""}`;
+    const text = await provider.complete(`I wanted to: ${originalNl}\nI ran: ${failedCommand}\nError:\n${errorOutput.slice(0, 2000)}\n\nGive me the corrected command only.`, {
+        model: routing.smart,
         maxTokens: 256,
-        system: buildSystemPrompt(perms, sessionEntries, originalNl),
+        temperature: 0,
+        stop: ["\n"],
+        system: fixSystem,
     });
     if (text.startsWith("BLOCKED:"))
         throw new Error(text);
-    return text;
-}
-// ── summarize output (for MCP/agent use) ──────────────────────────────────────
-export async function summarizeOutput(command, output, maxTokens = 200) {
-    const provider = getProvider();
-    const routing = pickModel("summarize");
-    return provider.complete(`Command: ${command}\nOutput:\n${output}\n\nSummarize this output concisely for an AI agent. Focus on: status, key results, errors. Be terse.`, {
-        model: routing.fast,
-        maxTokens,
-        system: "You summarize command output for AI agents. Be extremely concise. Return structured info. No prose.",
-    });
+    return text.trim();
 }
+// summarizeOutput() removed — all output processing goes through processOutput() in output-processor.ts

package/dist/cache.js

@@ -19,12 +19,13 @@ function persistCache() {
     }
     catch { }
 }
-/** Normalize a natural language query for cache lookup */
+/** Normalize a natural language query for cache lookup.
+ *  Keeps . / - _ which are meaningful in file paths and shell context. */
 export function normalizeNl(nl) {
     return nl
         .toLowerCase()
         .trim()
-        .replace(/[^a-z0-9\s]/g, "") // strip punctuation
+        .replace(/[^a-z0-9\s.\/_-]/g, "") // keep meaningful shell chars
         .replace(/\s+/g, " ");
 }
 export function cacheGet(nl) {

package/dist/cli.js

@@ -471,7 +471,7 @@ else if (args.length > 0) {
     const { rewriteCommand } = await import("./command-rewriter.js");
     const { shouldBeLazy, toLazy } = await import("./lazy-executor.js");
     const { saveOutput, formatOutputHint } = await import("./output-store.js");
-    const { parseOutput, estimateTokens } = await import("./parsers/index.js");
+    const { estimateTokens } = await import("./tokens.js");
     const { recordSaving, recordUsage } = await import("./economy.js");
     const { isTestOutput, trackTests, formatWatchResult } = await import("./test-watchlist.js");
     const { detectLoop } = await import("./loop-detector.js");

package/dist/compression.js

@@ -1,5 +1,7 @@
 // Token compression engine — reduces CLI output to fit within token budgets
-import { parseOutput, estimateTokens, tokenSavings } from "./parsers/index.js";
+// No regex parsing — just ANSI stripping, deduplication, and smart truncation.
+// All intelligent output processing goes through AI via processOutput().
+import { estimateTokens } from "./tokens.js";
 /** Strip ANSI escape codes from text */
 export function stripAnsi(text) {
     // eslint-disable-next-line no-control-regex
@@ -14,7 +16,6 @@ function deduplicateLines(lines) {
     let repeatPattern = "";
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
-        // Extract a "pattern" — the line without numbers, paths, specific identifiers
         const pattern = line.replace(/[0-9]+/g, "N").replace(/\/\S+/g, "/PATH").replace(/\s+/g, " ").trim();
         if (pattern === repeatPattern) {
             repeatCount++;
@@ -24,7 +25,6 @@ function deduplicateLines(lines) {
                 result.push(`  ... (${repeatCount} similar lines)`);
             }
             else if (repeatCount > 0) {
-                // Push the skipped lines back
                 for (let j = i - repeatCount; j < i; j++) {
                     result.push(lines[j]);
                 }
@@ -44,13 +44,12 @@ function deduplicateLines(lines) {
     }
     return result;
 }
-/** Smart truncation: keep first N + last M lines */
+/** Smart truncation: keep first 60% + last 40% of lines */
 function smartTruncate(text, maxTokens) {
     const lines = text.split("\n");
     const currentTokens = estimateTokens(text);
     if (currentTokens <= maxTokens)
         return text;
-    // Keep proportional first/last, with first getting more
     const targetLines = Math.floor((maxTokens * lines.length) / currentTokens);
     const firstCount = Math.ceil(targetLines * 0.6);
     const lastCount = Math.floor(targetLines * 0.4);
@@ -61,44 +60,23 @@ function smartTruncate(text, maxTokens) {
     const hiddenCount = lines.length - firstCount - lastCount;
     return [...first, `\n--- ${hiddenCount} lines hidden ---\n`, ...last].join("\n");
 }
-/** Compress command output to fit within a token budget */
+/** Compress command output — ANSI strip, dedup, truncate. No parsing. */
 export function compress(command, output, options = {}) {
-    const { maxTokens, format = "text", stripAnsi: doStrip = true } = options;
+    const { maxTokens, stripAnsi: doStrip = true } = options;
     const originalTokens = estimateTokens(output);
     // Step 1: Strip ANSI codes
     let text = doStrip ? stripAnsi(output) : output;
-    // Step 2: Try structured parsing (format=json or when it saves tokens)
-    if (format === "json" || format === "summary") {
-        const parsed = parseOutput(command, text);
-        if (parsed) {
-            const json = JSON.stringify(parsed.data, null, format === "summary" ? 0 : 2);
-            const savings = tokenSavings(output, parsed.data);
-            const compressedTokens = estimateTokens(json);
-            // ONLY use JSON if it actually saves tokens (never return larger output)
-            if (savings.saved > 0 && (!maxTokens || compressedTokens <= maxTokens)) {
-                return {
-                    content: json,
-                    format: "json",
-                    originalTokens,
-                    compressedTokens,
-                    tokensSaved: savings.saved,
-                    savingsPercent: savings.percent,
-                };
-            }
-        }
-    }
-    // Step 3: Deduplicate similar lines
+    // Step 2: Deduplicate similar lines
     const lines = text.split("\n");
     const deduped = deduplicateLines(lines);
     text = deduped.join("\n");
-    // Step 4: Smart truncation if over budget
+    // Step 3: Smart truncation if over budget
     if (maxTokens) {
         text = smartTruncate(text, maxTokens);
     }
     const compressedTokens = estimateTokens(text);
     return {
         content: text,
-        format: "text",
         originalTokens,
         compressedTokens,
         tokensSaved: Math.max(0, originalTokens - compressedTokens),

package/dist/context-hints.js

@@ -31,18 +31,31 @@ export function discoverProjectHints(cwd) {
             hints.push(`Project type: ${lang} (${file} found)`);
         }
     }
-    // Extract rich metadata from package.json
+    // Extract metadata from package.json — trimmed to save tokens
     const pkgPath = join(cwd, "package.json");
     if (existsSync(pkgPath)) {
         try {
             const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
             if (pkg.name)
-                hints.push(`Package name: ${pkg.name}@${pkg.version ?? "unknown"}`);
+                hints.push(`Package: ${pkg.name}@${pkg.version ?? "?"}`);
             if (pkg.scripts) {
-                hints.push(`Available scripts: ${Object.entries(pkg.scripts).map(([k, v]) => `${k}: ${v}`).slice(0, 10).join(", ")}`);
+                // Only top-5 most useful scripts
+                const priority = ["dev", "build", "test", "lint", "start", "typecheck", "check"];
+                const scripts = Object.keys(pkg.scripts);
+                const top = priority.filter(s => scripts.includes(s));
+                const rest = scripts.filter(s => !priority.includes(s)).slice(0, Math.max(0, 5 - top.length));
+                hints.push(`Scripts: ${[...top, ...rest].join(", ")}`);
+            }
+            if (pkg.dependencies) {
+                // Only framework/major deps — skip utility libs
+                const major = ["react", "next", "express", "fastify", "hono", "vue", "angular", "svelte",
+                    "prisma", "drizzle", "mongoose", "typeorm", "zod", "trpc", "graphql", "tailwindcss",
+                    "electron", "bun", "elysia", "nest", "nuxt", "remix", "astro", "vite"];
+                const deps = Object.keys(pkg.dependencies);
+                const found = deps.filter(d => major.some(m => d.includes(m)));
+                if (found.length > 0)
+                    hints.push(`Key deps: ${found.slice(0, 10).join(", ")}`);
             }
-            if (pkg.dependencies)
-                hints.push(`Dependencies: ${Object.keys(pkg.dependencies).join(", ")}`);
         }
         catch { }
     }
@@ -101,21 +114,18 @@ export function discoverProjectHints(cwd) {
         }
         catch { }
     }
-    // Source directory structure
+    // Source directory structure — max 20 files to save tokens
     try {
         const { execSync } = require("child_process");
         const srcDirs = ["src", "lib", "app", "packages"];
         for (const dir of srcDirs) {
             if (existsSync(join(cwd, dir))) {
-                const tree = execSync(`find ${dir} -maxdepth 3 -not -path '*/node_modules/*' -not -path '*/dist/*' -not -name '*.test.*' 2>/dev/null | sort | head -60`, { cwd, encoding: "utf8", timeout: 3000 }).trim();
+                const tree = execSync(`find ${dir} -maxdepth 2 -not -path '*/node_modules/*' -not -path '*/dist/*' -not -name '*.test.*' -not -name '*.spec.*' 2>/dev/null | sort | head -20`, { cwd, encoding: "utf8", timeout: 2000 }).trim();
                 if (tree)
                     hints.push(`Files in ${dir}/:\n${tree}`);
                 break;
             }
         }
-        // Top-level files
-        const topLevel = execSync("ls -1", { cwd, encoding: "utf8", timeout: 1000 }).trim();
-        hints.push(`Top-level: ${topLevel.split("\n").join(", ")}`);
     }
     catch { }
     return hints;

package/dist/diff-cache.js

@@ -1,5 +1,5 @@
 // Diff-aware output caching — when same command runs again, return only what changed
-import { estimateTokens } from "./parsers/index.js";
+import { estimateTokens } from "./tokens.js";
 const cache = new Map();
 function cacheKey(command, cwd) {
     return `${cwd}:${command}`;

package/dist/discover.js

@@ -3,7 +3,7 @@
 // estimates how much terminal would have saved.
 import { readdirSync, readFileSync, statSync, existsSync } from "fs";
 import { join } from "path";
-import { estimateTokens } from "./parsers/index.js";
+import { estimateTokens } from "./tokens.js";
 /** Find all Claude session JSONL files */
 function findSessionFiles(claudeDir, maxAge) {
     const files = [];

package/dist/economy.js

@@ -44,12 +44,29 @@ function loadStats() {
     };
     return stats;
 }
+let _saveTimer = null;
 function saveStats() {
-    ensureDir();
-    if (stats) {
-        writeFileSync(ECONOMY_FILE, JSON.stringify(stats, null, 2));
-    }
+    // Debounce: coalesce multiple writes within 1 second
+    if (_saveTimer)
+        return;
+    _saveTimer = setTimeout(() => {
+        _saveTimer = null;
+        ensureDir();
+        if (stats) {
+            writeFileSync(ECONOMY_FILE, JSON.stringify(stats, null, 2));
+        }
+    }, 1000);
 }
+// Flush on exit
+process.on("exit", () => {
+    if (_saveTimer) {
+        clearTimeout(_saveTimer);
+        _saveTimer = null;
+        ensureDir();
+        if (stats)
+            writeFileSync(ECONOMY_FILE, JSON.stringify(stats, null, 2));
+    }
+});
 /** Record token savings from a feature */
 export function recordSaving(feature, tokensSaved) {
     const s = loadStats();
@@ -89,8 +106,23 @@ const PROVIDER_PRICING = {
     "anthropic-sonnet": { input: 3.00, output: 15.00 },
     "anthropic-opus": { input: 5.00, output: 25.00 },
 };
+/** Load configurable turns-before-compaction from ~/.terminal/config.json */
+function loadTurnsMultiplier() {
+    try {
+        const configPath = join(DIR, "config.json");
+        if (existsSync(configPath)) {
+            const config = JSON.parse(readFileSync(configPath, "utf8"));
+            return config.economy?.turnsBeforeCompaction ?? 5;
+        }
+    }
+    catch { }
+    return 5; // Default: tokens saved are repeated ~5 turns before agent compacts context
+}
 /** Estimate USD savings from compressed tokens */
-export function estimateSavingsUsd(tokensSaved, consumerModel = "anthropic-opus", avgTurnsBeforeCompaction = 5) {
+export function estimateSavingsUsd(tokensSaved, consumerModel = "anthropic-opus", avgTurnsBeforeCompaction) {
+    if (avgTurnsBeforeCompaction === undefined) {
+        avgTurnsBeforeCompaction = loadTurnsMultiplier();
+    }
     const pricing = PROVIDER_PRICING[consumerModel] ?? PROVIDER_PRICING["anthropic-opus"];
     const multipliedTokens = tokensSaved * avgTurnsBeforeCompaction;
     const savingsUsd = (multipliedTokens * pricing.input) / 1_000_000;

package/dist/expand-store.js

@@ -15,6 +15,10 @@ export function storeOutput(command, output) {
     store.set(key, { command, output, timestamp: Date.now() });
     return key;
 }
+/** Escape regex special characters for safe use in new RegExp() */
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 /** Retrieve full output by key, optionally filtered */
 export function expandOutput(key, grep) {
     const entry = store.get(key);
@@ -22,7 +26,9 @@ export function expandOutput(key, grep) {
         return { found: false };
     let output = entry.output;
     if (grep) {
-        const pattern = new RegExp(grep, "i");
+        // Escape metacharacters so user input like "[error" or "func()" doesn't crash
+        const safe = escapeRegex(grep);
+        const pattern = new RegExp(safe, "i");
         output = output.split("\n").filter(l => pattern.test(l)).join("\n");
     }
     return { found: true, output, lines: output.split("\n").length };