@hasna/terminal 2.0.5 → 2.3.0

package/src/command-validator.ts

@@ -78,6 +78,17 @@ export function validateCommand(command: string, cwd: string): ValidationResult
     issues.push(`GNU flag on macOS: ${gnuFlags.join(", ")}`);
   }
 
+  // Complexity guard — extreme pipe chains are fragile
+  const pipeCount = (command.match(/\|/g) || []).length;
+  if (pipeCount > 7) {
+    issues.push(`too complex: ${pipeCount} pipes — simplify`);
+  }
+
+  // grep -P (PCRE) doesn't exist on macOS
+  if (/grep\s+.*-[a-zA-Z]*P/.test(command)) {
+    issues.push("grep -P (PCRE) not available on macOS — use grep -E");
+  }
+
   return {
     valid: issues.length === 0,
     issues,

package/src/context-hints.ts

@@ -0,0 +1,291 @@
+// Context hints — discover context via lightweight checks, inject into AI prompt
+// Regex DISCOVERS, AI DECIDES. No hardcoded logic that makes decisions.
+
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+
+export interface ContextHints {
+  project: string[];    // project metadata
+  output: string[];     // observations about command output
+  safety: string[];     // safety-relevant observations
+  environment: string[]; // system/env observations
+}
+
+/** Discover project context from the filesystem */
+export function discoverProjectHints(cwd: string): string[] {
+  const hints: string[] = [];
+
+  // Package managers and project files
+  const projectFiles: [string, string][] = [
+    ["package.json", "Node.js/TypeScript"],
+    ["pyproject.toml", "Python"],
+    ["requirements.txt", "Python"],
+    ["go.mod", "Go"],
+    ["Cargo.toml", "Rust"],
+    ["pom.xml", "Java/Maven"],
+    ["build.gradle", "Java/Gradle"],
+    ["build.gradle.kts", "Java/Gradle (Kotlin DSL)"],
+    ["Makefile", "Has Makefile"],
+    ["Dockerfile", "Has Docker"],
+    ["docker-compose.yml", "Has Docker Compose"],
+    ["docker-compose.yaml", "Has Docker Compose"],
+    [".github/workflows", "Has GitHub Actions CI"],
+    ["Gemfile", "Ruby"],
+    ["composer.json", "PHP"],
+    ["mix.exs", "Elixir"],
+    ["build.zig", "Zig"],
+    ["CMakeLists.txt", "C/C++ (CMake)"],
+  ];
+
+  for (const [file, lang] of projectFiles) {
+    if (existsSync(join(cwd, file))) {
+      hints.push(`Project type: ${lang} (${file} found)`);
+    }
+  }
+
+  // Extract rich metadata from package.json
+  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"}`);
+      if (pkg.scripts) {
+        hints.push(`Available scripts: ${Object.entries(pkg.scripts).map(([k, v]) => `${k}: ${v}`).slice(0, 10).join(", ")}`);
+      }
+      if (pkg.dependencies) hints.push(`Dependencies: ${Object.keys(pkg.dependencies).join(", ")}`);
+    } catch {}
+  }
+
+  // Extract from pyproject.toml
+  const pyPath = join(cwd, "pyproject.toml");
+  if (existsSync(pyPath)) {
+    try {
+      const py = readFileSync(pyPath, "utf8");
+      const name = py.match(/name\s*=\s*"([^"]+)"/)?.[1];
+      if (name) hints.push(`Python package: ${name}`);
+    } catch {}
+  }
+
+  // Extract from go.mod
+  const goPath = join(cwd, "go.mod");
+  if (existsSync(goPath)) {
+    try {
+      const go = readFileSync(goPath, "utf8");
+      const mod = go.match(/module\s+(\S+)/)?.[1];
+      if (mod) hints.push(`Go module: ${mod}`);
+    } catch {}
+  }
+
+  // Extract from Cargo.toml
+  const cargoPath = join(cwd, "Cargo.toml");
+  if (existsSync(cargoPath)) {
+    try {
+      const cargo = readFileSync(cargoPath, "utf8");
+      const name = cargo.match(/name\s*=\s*"([^"]+)"/)?.[1];
+      if (name) hints.push(`Rust crate: ${name}`);
+    } catch {}
+  }
+
+  // Monorepo detection
+  if (existsSync(join(cwd, "packages"))) {
+    try {
+      const pkgs = readdirSync(join(cwd, "packages")).filter(d => !d.startsWith("."));
+      hints.push(`MONOREPO: ${pkgs.length} packages in packages/ — search packages/ not src/`);
+      hints.push(`Packages: ${pkgs.slice(0, 10).join(", ")}`);
+    } catch {}
+  }
+  if (existsSync(join(cwd, "apps"))) {
+    hints.push("MONOREPO: apps/ directory detected");
+  }
+
+  // Makefile targets
+  if (existsSync(join(cwd, "Makefile"))) {
+    try {
+      const { execSync } = require("child_process");
+      const targets = execSync("grep -E '^[a-zA-Z_-]+:' Makefile | head -10 | cut -d: -f1", { cwd, encoding: "utf8", timeout: 1000 }).trim();
+      if (targets) hints.push(`Makefile targets: ${targets.split("\n").join(", ")}`);
+    } catch {}
+  }
+
+  // Source directory structure
+  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();
+        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;
+}
+
+/** Discover output-specific hints (observations about command output) */
+export function discoverOutputHints(output: string, command: string): string[] {
+  const hints: string[] = [];
+
+  const lines = output.split("\n");
+  hints.push(`Output: ${lines.length} lines, ${output.length} chars`);
+
+  // Only detect test results from actual test runners (not grep output containing "pass"/"fail" in code)
+  const isGrepOutput = /^\s*(src\/|\.\/|packages\/).*:\d+:/.test(output);
+  if (!isGrepOutput) {
+    const passMatch = output.match(/(\d+)\s+pass(?:ed|ing)?\b/i);
+    const failMatch = output.match(/(\d+)\s+fail(?:ed|ing|ure)?\b/i);
+    if (passMatch) hints.push(`Test results detected: ${passMatch[0]}`);
+    if (failMatch) hints.push(`Test results detected: ${failMatch[0]}`);
+
+    // Error patterns (only from actual command output, not code search)
+    if (output.match(/error\s*TS\d+/i)) hints.push("TypeScript errors detected in output");
+    if (output.match(/ENOENT|EACCES|EADDRINUSE/)) hints.push("System error code detected in output");
+  }
+
+  // Coverage patterns
+  if (output.match(/%\s*Funcs|%\s*Lines|coverage/i)) hints.push("Code coverage data detected in output");
+
+  // Large/repetitive output
+  if (lines.length > 100) hints.push(`Large output (${lines.length} lines) — consider summarizing`);
+  const uniqueLines = new Set(lines.map(l => l.trim())).size;
+  if (uniqueLines < lines.length * 0.5) hints.push("Output has many duplicate/similar lines");
+
+  // Sensitive data (only env var assignments, not code containing the word KEY/TOKEN)
+  if (output.match(/^[A-Z_]+(KEY|TOKEN|SECRET|PASSWORD)\s*=\s*\S+/m)) hints.push("Output may contain sensitive data — redact credentials");
+
+  // Error block extraction — state machine that captures multi-line errors
+  if (!isGrepOutput) {
+    const errorBlocks = extractErrorBlocks(output);
+    if (errorBlocks.length > 0) {
+      const summary = errorBlocks.slice(0, 3).map(b => b.trim().split("\n").slice(0, 5).join("\n")).join("\n---\n");
+      hints.push(`ERROR BLOCKS FOUND (${errorBlocks.length}):\n${summary}`);
+    }
+  }
+
+  return hints;
+}
+
+/** Extract multi-line error blocks using a state machine */
+function extractErrorBlocks(output: string): string[] {
+  const lines = output.split("\n");
+  const blocks: string[] = [];
+  let currentBlock: string[] = [];
+  let inErrorBlock = false;
+  let blankCount = 0;
+
+  // Patterns that START an error block
+  const errorStarters = [
+    /^error/i, /^Error:/i, /^ERROR/,
+    /^Traceback/i, /^panic:/i, /^fatal:/i,
+    /^FAIL/i, /^✗/, /^✘/,
+    /error\s*TS\d+/i, /error\[E\d+\]/,
+    /^SyntaxError/i, /^TypeError/i, /^ReferenceError/i,
+    /^Unhandled/i, /^Exception/i,
+    /ENOENT|EACCES|EADDRINUSE|ECONNREFUSED/,
+  ];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    if (!trimmed) {
+      blankCount++;
+      if (inErrorBlock) {
+        currentBlock.push(line);
+        // 2+ blank lines = end of error block
+        if (blankCount >= 2) {
+          blocks.push(currentBlock.join("\n").trim());
+          currentBlock = [];
+          inErrorBlock = false;
+        }
+      }
+      continue;
+    }
+    blankCount = 0;
+
+    // Check if this line starts a new error block
+    if (!inErrorBlock && errorStarters.some(p => p.test(trimmed))) {
+      inErrorBlock = true;
+      currentBlock = [line];
+      continue;
+    }
+
+    if (inErrorBlock) {
+      // Continuation: indented lines, "at ..." stack frames, "--->" pointers, "File ..." python traces
+      const isContinuation =
+        /^\s+/.test(line) ||
+        /^\s*at\s/.test(trimmed) ||
+        /^\s*-+>/.test(trimmed) ||
+        /^\s*\|/.test(trimmed) ||
+        /^\s*File "/.test(trimmed) ||
+        /^\s*\d+\s*\|/.test(trimmed) || // rust/compiler line numbers
+        /^Caused by:/i.test(trimmed);
+
+      if (isContinuation) {
+        currentBlock.push(line);
+      } else {
+        // Non-continuation, non-blank = end of error block
+        blocks.push(currentBlock.join("\n").trim());
+        currentBlock = [];
+        inErrorBlock = false;
+
+        // Check if THIS line starts a new error block
+        if (errorStarters.some(p => p.test(trimmed))) {
+          inErrorBlock = true;
+          currentBlock = [line];
+        }
+      }
+    }
+  }
+
+  // Flush remaining block
+  if (currentBlock.length > 0) {
+    blocks.push(currentBlock.join("\n").trim());
+  }
+
+  return blocks;
+}
+
+/** Discover safety hints about a command */
+export function discoverSafetyHints(command: string): string[] {
+  const hints: string[] = [];
+
+  // Observations about the command (AI decides if it's safe)
+  if (command.match(/\brm\b|\brmdir\b|\btruncate\b/)) hints.push("SAFETY: command contains file deletion (rm/rmdir/truncate)");
+  if (command.match(/\bkill\b|\bkillall\b|\bpkill\b/)) hints.push("SAFETY: command kills processes");
+  if (command.match(/\bgit\s+push\b|\bgit\s+reset\s+--hard\b/)) hints.push("SAFETY: command pushes/resets git");
+  if (command.match(/\bnpx\b|\bnpm\s+install\b|\bpip\s+install\b/)) hints.push("SAFETY: command installs packages");
+  if (command.match(/\bsed\s+-i\b|\bcodemod\b/)) hints.push("SAFETY: command modifies files in-place");
+  if (command.match(/\btouch\b|\bmkdir\b/)) hints.push("SAFETY: command creates files/directories");
+  if (command.match(/>\s*\S+\.\w+/)) hints.push("SAFETY: command writes to a file via redirect");
+  if (command.match(/\b(bun|npm|pnpm)\s+run\s+dev\b|\bstart\b/)) hints.push("SAFETY: command starts a server/process");
+
+  // Read-only observations
+  if (command.match(/^\s*git\s+(log|show|diff|status|branch|blame|tag)\b/)) hints.push("This is a read-only git command");
+  if (command.match(/^\s*(ls|cat|head|tail|grep|find|wc|du|df|uptime|whoami|pwd)\b/)) hints.push("This is a read-only command");
+
+  return hints;
+}
+
+/** Format all hints for system prompt injection */
+export function formatHints(project: string[], output?: string[], safety?: string[]): string {
+  const sections: string[] = [];
+
+  if (project.length > 0) {
+    sections.push("PROJECT CONTEXT:\n" + project.join("\n"));
+  }
+  if (output && output.length > 0) {
+    sections.push("OUTPUT OBSERVATIONS:\n" + output.join("\n"));
+  }
+  if (safety && safety.length > 0) {
+    sections.push("SAFETY OBSERVATIONS:\n" + safety.join("\n"));
+  }
+
+  return sections.join("\n\n");
+}

package/src/discover.ts

@@ -0,0 +1,238 @@
+// Discover — scan Claude Code session history to find token savings opportunities
+// Reads ~/.claude/projects/*/sessions/*.jsonl, extracts Bash commands + output sizes,
+// estimates how much terminal would have saved.
+
+import { readdirSync, readFileSync, statSync, existsSync } from "fs";
+import { join } from "path";
+import { estimateTokens } from "./parsers/index.js";
+
+export interface DiscoveredCommand {
+  command: string;
+  outputTokens: number;
+  outputChars: number;
+  sessionFile: string;
+  timestamp?: string;
+}
+
+export interface DiscoverReport {
+  totalSessions: number;
+  totalCommands: number;
+  totalOutputTokens: number;
+  estimatedSavings: number; // tokens saved at 70% compression
+  estimatedSavingsUsd: number; // at Opus rates ($5/M input)
+  topCommands: { command: string; count: number; totalTokens: number; avgTokens: number }[];
+  commandsByCategory: Record<string, { count: number; tokens: number }>;
+}
+
+/** Find all Claude session JSONL files */
+function findSessionFiles(claudeDir: string, maxAge?: number): string[] {
+  const files: string[] = [];
+  const projectsDir = join(claudeDir, "projects");
+  if (!existsSync(projectsDir)) return files;
+
+  const now = Date.now();
+  const cutoff = maxAge ? now - maxAge : 0;
+
+  try {
+    for (const project of readdirSync(projectsDir)) {
+      const projectPath = join(projectsDir, project);
+      // Look for session JSONL files (not subagents)
+      try {
+        for (const entry of readdirSync(projectPath)) {
+          if (entry.endsWith(".jsonl")) {
+            const filePath = join(projectPath, entry);
+            try {
+              const stat = statSync(filePath);
+              if (stat.mtimeMs > cutoff) files.push(filePath);
+            } catch {}
+          }
+        }
+      } catch {}
+    }
+  } catch {}
+
+  return files;
+}
+
+/** Extract Bash commands and their output sizes from a session file */
+function extractCommands(sessionFile: string): DiscoveredCommand[] {
+  const commands: DiscoveredCommand[] = [];
+
+  try {
+    const content = readFileSync(sessionFile, "utf8");
+    const lines = content.split("\n").filter(l => l.trim());
+
+    // Track tool_use IDs to match with tool_results
+    const pendingToolUses: Map<string, string> = new Map(); // id -> command
+
+    for (const line of lines) {
+      try {
+        const obj = JSON.parse(line);
+        const msg = obj.message;
+        if (!msg?.content || !Array.isArray(msg.content)) continue;
+
+        for (const block of msg.content) {
+          // Capture Bash tool_use commands
+          if (block.type === "tool_use" && block.name === "Bash" && block.input?.command) {
+            pendingToolUses.set(block.id, block.input.command);
+          }
+
+          // Capture tool_result outputs and match to commands
+          if (block.type === "tool_result" && block.tool_use_id) {
+            const command = pendingToolUses.get(block.tool_use_id);
+            if (command) {
+              let outputText = "";
+              if (typeof block.content === "string") {
+                outputText = block.content;
+              } else if (Array.isArray(block.content)) {
+                outputText = block.content
+                  .filter((c: any) => c.type === "text")
+                  .map((c: any) => c.text)
+                  .join("\n");
+              }
+
+              if (outputText.length > 0) {
+                commands.push({
+                  command,
+                  outputTokens: estimateTokens(outputText),
+                  outputChars: outputText.length,
+                  sessionFile,
+                });
+              }
+              pendingToolUses.delete(block.tool_use_id);
+            }
+          }
+        }
+      } catch {} // skip malformed lines
+    }
+  } catch {} // skip unreadable files
+
+  return commands;
+}
+
+/** Categorize a command into a bucket */
+function categorizeCommand(cmd: string): string {
+  const trimmed = cmd.trim();
+  if (/^git\b/.test(trimmed)) return "git";
+  if (/\b(bun|npm|yarn|pnpm)\s+(test|run\s+test)/.test(trimmed)) return "test";
+  if (/\b(bun|npm|yarn|pnpm)\s+run\s+(build|typecheck|lint)/.test(trimmed)) return "build";
+  if (/^(grep|rg)\b/.test(trimmed)) return "grep";
+  if (/^find\b/.test(trimmed)) return "find";
+  if (/^(cat|head|tail|less)\b/.test(trimmed)) return "read";
+  if (/^(ls|tree|du|wc)\b/.test(trimmed)) return "list";
+  if (/^(curl|wget|fetch)\b/.test(trimmed)) return "network";
+  if (/^(docker|kubectl|helm)\b/.test(trimmed)) return "infra";
+  if (/^(python|pip|pytest)\b/.test(trimmed)) return "python";
+  if (/^(cargo|rustc)\b/.test(trimmed)) return "rust";
+  if (/^(go\s|golangci)\b/.test(trimmed)) return "go";
+  return "other";
+}
+
+/** Normalize command for grouping (strip variable parts like paths, hashes) */
+function normalizeCommand(cmd: string): string {
+  return cmd
+    .replace(/[0-9a-f]{7,40}/g, "{hash}") // git hashes
+    .replace(/\/[\w./-]+\.(ts|tsx|js|json|py|rs|go)\b/g, "{file}") // file paths
+    .replace(/\d{4}-\d{2}-\d{2}/g, "{date}") // dates
+    .replace(/:\d+/g, ":{line}") // line numbers
+    .trim();
+}
+
+/** Run discover across all Claude sessions */
+export function discover(options: { maxAgeDays?: number; minTokens?: number } = {}): DiscoverReport {
+  const claudeDir = join(process.env.HOME ?? "~", ".claude");
+  const maxAge = (options.maxAgeDays ?? 30) * 24 * 60 * 60 * 1000;
+  const minTokens = options.minTokens ?? 50;
+
+  const sessionFiles = findSessionFiles(claudeDir, maxAge);
+  const allCommands: DiscoveredCommand[] = [];
+
+  for (const file of sessionFiles) {
+    allCommands.push(...extractCommands(file));
+  }
+
+  // Filter to commands with meaningful output
+  const significant = allCommands.filter(c => c.outputTokens >= minTokens);
+
+  // Group by normalized command
+  const groups = new Map<string, { count: number; totalTokens: number; example: string }>();
+  for (const cmd of significant) {
+    const key = normalizeCommand(cmd.command);
+    const existing = groups.get(key) ?? { count: 0, totalTokens: 0, example: cmd.command };
+    existing.count++;
+    existing.totalTokens += cmd.outputTokens;
+    groups.set(key, existing);
+  }
+
+  // Top commands by total tokens
+  const topCommands = [...groups.entries()]
+    .map(([cmd, data]) => ({
+      command: data.example,
+      count: data.count,
+      totalTokens: data.totalTokens,
+      avgTokens: Math.round(data.totalTokens / data.count),
+    }))
+    .sort((a, b) => b.totalTokens - a.totalTokens)
+    .slice(0, 20);
+
+  // Category breakdown
+  const commandsByCategory: Record<string, { count: number; tokens: number }> = {};
+  for (const cmd of significant) {
+    const cat = categorizeCommand(cmd.command);
+    if (!commandsByCategory[cat]) commandsByCategory[cat] = { count: 0, tokens: 0 };
+    commandsByCategory[cat].count++;
+    commandsByCategory[cat].tokens += cmd.outputTokens;
+  }
+
+  const totalOutputTokens = significant.reduce((sum, c) => sum + c.outputTokens, 0);
+  // Conservative 70% compression estimate (RTK claims 60-90%)
+  const estimatedSavings = Math.round(totalOutputTokens * 0.7);
+  // Each saved input token is repeated across ~5 turns on average before compaction
+  const multipliedSavings = estimatedSavings * 5;
+  // At Opus rates ($5/M input tokens)
+  const estimatedSavingsUsd = (multipliedSavings * 5) / 1_000_000;
+
+  return {
+    totalSessions: sessionFiles.length,
+    totalCommands: significant.length,
+    totalOutputTokens,
+    estimatedSavings,
+    estimatedSavingsUsd,
+    topCommands,
+    commandsByCategory,
+  };
+}
+
+/** Format discover report for CLI display */
+export function formatDiscoverReport(report: DiscoverReport): string {
+  const lines: string[] = [];
+
+  lines.push(`📊 Terminal Discover — Token Savings Analysis`);
+  lines.push(`   Scanned ${report.totalSessions} sessions, ${report.totalCommands} commands with >50 token output\n`);
+
+  lines.push(`💰 Estimated savings with open-terminal:`);
+  lines.push(`   Output tokens: ${report.totalOutputTokens.toLocaleString()}`);
+  lines.push(`   Compressible:  ${report.estimatedSavings.toLocaleString()} tokens (70% avg)`);
+  lines.push(`   Repeated ~5x before compaction = ${(report.estimatedSavings * 5).toLocaleString()} billable tokens`);
+  lines.push(`   At Opus rates: $${report.estimatedSavingsUsd.toFixed(2)} saved\n`);
+
+  if (report.topCommands.length > 0) {
+    lines.push(`🔝 Top commands by token cost:`);
+    for (const cmd of report.topCommands.slice(0, 15)) {
+      const avg = cmd.avgTokens.toLocaleString().padStart(6);
+      const total = cmd.totalTokens.toLocaleString().padStart(8);
+      lines.push(`   ${String(cmd.count).padStart(4)}× ${avg} avg → ${total} total  ${cmd.command.slice(0, 60)}`);
+    }
+    lines.push("");
+  }
+
+  if (Object.keys(report.commandsByCategory).length > 0) {
+    lines.push(`📁 By category:`);
+    const sorted = Object.entries(report.commandsByCategory).sort((a, b) => b[1].tokens - a[1].tokens);
+    for (const [cat, data] of sorted) {
+      lines.push(`   ${cat.padEnd(10)} ${String(data.count).padStart(5)} cmds  ${data.tokens.toLocaleString().padStart(10)} tokens`);
+    }
+  }
+
+  return lines.join("\n");
+}

package/src/economy.ts

@@ -97,3 +97,56 @@ export function formatTokens(n: number): string {
   if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`;
   return `${n}`;
 }
+
+// ── Weighted economics ──────────────────────────────────────────────────────
+// Saved input tokens are repeated across multiple turns before compaction.
+// Weighted pricing accounts for the actual billing impact.
+
+/** Provider pricing per million tokens */
+const PROVIDER_PRICING: Record<string, { input: number; output: number }> = {
+  cerebras:  { input: 0.60, output: 1.20 },
+  groq:      { input: 0.15, output: 0.60 },
+  xai:       { input: 0.20, output: 1.50 },
+  anthropic: { input: 0.80, output: 4.00 }, // Haiku
+  "anthropic-sonnet": { input: 3.00, output: 15.00 },
+  "anthropic-opus":   { input: 5.00, output: 25.00 },
+};
+
+/** Estimate USD savings from compressed tokens */
+export function estimateSavingsUsd(
+  tokensSaved: number,
+  consumerModel: string = "anthropic-opus",
+  avgTurnsBeforeCompaction: number = 5,
+): { savingsUsd: number; multipliedTokens: number; ratePerMillion: number } {
+  const pricing = PROVIDER_PRICING[consumerModel] ?? PROVIDER_PRICING["anthropic-opus"];
+  const multipliedTokens = tokensSaved * avgTurnsBeforeCompaction;
+  const savingsUsd = (multipliedTokens * pricing.input) / 1_000_000;
+  return { savingsUsd, multipliedTokens, ratePerMillion: pricing.input };
+}
+
+/** Format a full economics summary */
+export function formatEconomicsSummary(): string {
+  const s = loadStats();
+  const opus = estimateSavingsUsd(s.totalTokensSaved, "anthropic-opus");
+  const sonnet = estimateSavingsUsd(s.totalTokensSaved, "anthropic-sonnet");
+  const haiku = estimateSavingsUsd(s.totalTokensSaved, "anthropic");
+
+  return [
+    `Token Economy:`,
+    `  Tokens saved:  ${formatTokens(s.totalTokensSaved)}`,
+    `  Tokens used:   ${formatTokens(s.totalTokensUsed)}`,
+    `  Ratio:         ${s.totalTokensUsed > 0 ? (s.totalTokensSaved / s.totalTokensUsed).toFixed(1) : "∞"}x return`,
+    ``,
+    `  Estimated USD savings (×5 turns before compaction):`,
+    `    Opus ($5/M):   $${opus.savingsUsd.toFixed(2)} (${formatTokens(opus.multipliedTokens)} billable tokens)`,
+    `    Sonnet ($3/M): $${sonnet.savingsUsd.toFixed(2)}`,
+    `    Haiku ($0.8/M): $${haiku.savingsUsd.toFixed(2)}`,
+    ``,
+    `  By feature:`,
+    `    Compressed: ${formatTokens(s.savingsByFeature.compressed)}`,
+    `    Structured: ${formatTokens(s.savingsByFeature.structured)}`,
+    `    Diff cache: ${formatTokens(s.savingsByFeature.diff)}`,
+    `    NL cache:   ${formatTokens(s.savingsByFeature.cache)}`,
+    `    Search:     ${formatTokens(s.savingsByFeature.search)}`,
+  ].join("\n");
+}

package/src/output-processor.ts

@@ -4,6 +4,7 @@
 import { getProvider } from "./providers/index.js";
 import { estimateTokens } from "./parsers/index.js";
 import { recordSaving } from "./economy.js";
+import { discoverOutputHints } from "./context-hints.js";
 
 export interface ProcessedOutput {
   /** AI-generated summary (concise, structured) */
@@ -79,27 +80,15 @@ export async function processOutput(
   }
 
   try {
-    // Pre-parse: if output contains clear pass/fail counts, extract and return directly
-    // No hardcoded test runner list — works for ANY tool that outputs "X pass, Y fail"
-    const passMatch = output.match(/(\d+)\s+pass/i);
-    const failMatch = output.match(/(\d+)\s+fail/i);
-    // Pre-parse fires when output has BOTH pass+fail counts AND the user asked about tests
-    if (passMatch && failMatch && originalPrompt && /test|pass|fail/i.test(originalPrompt)) {
-      const passed = parseInt(passMatch[1]);
-      const failed = parseInt(failMatch[1]);
-      const answer = failed === 0
-        ? `✓ Yes, all ${passed} tests pass.`
-        : `✗ ${failed} of ${passed + failed} tests failed.`;
-      const savedTokens = estimateTokens(output) - estimateTokens(answer);
-      return {
-        summary: answer, full: output, tokensSaved: Math.max(0, savedTokens),
-        aiTokensUsed: 0, aiProcessed: true, aiCostUsd: 0, savingsValueUsd: 0, netSavingsUsd: 0,
-      };
-    }
+    // Discover output hints — regex discovers patterns, AI decides what matters
+    const outputHints = discoverOutputHints(output, command);
+    const hintsBlock = outputHints.length > 0
+      ? `\n\nOUTPUT OBSERVATIONS:\n${outputHints.join("\n")}`
+      : "";
 
     const provider = getProvider();
     const summary = await provider.complete(
-      `${originalPrompt ? `User asked: ${originalPrompt}\n` : ""}Command: ${command}\nOutput (${lines.length} lines):\n${toSummarize}`,
+      `${originalPrompt ? `User asked: ${originalPrompt}\n` : ""}Command: ${command}\nOutput (${lines.length} lines):\n${toSummarize}${hintsBlock}`,
       {
         system: SUMMARIZE_PROMPT,
         maxTokens: 300,