@hasna/terminal 2.2.0 → 2.3.1

package/dist/cli.js

@@ -28,6 +28,7 @@ SUBCOMMANDS:
   collection create|list       Recipe collections
   mcp serve                    Start MCP server for AI agents
   mcp install --claude|--codex Install MCP server
+  discover [--days=N] [--json]  Scan Claude sessions, show token savings potential
   snapshot                     Terminal state as JSON
   --help                       Show this help
   --version                    Show version
@@ -253,17 +254,8 @@ else if (args[0] === "collection") {
 }
 // ── Stats command ────────────────────────────────────────────────────────────
 else if (args[0] === "stats") {
-    const { getEconomyStats, formatTokens } = await import("./economy.js");
-    const s = getEconomyStats();
-    console.log("Token Economy:");
-    console.log(`  Total saved:  ${formatTokens(s.totalTokensSaved)}`);
-    console.log(`  Total used:   ${formatTokens(s.totalTokensUsed)}`);
-    console.log(`  By feature:`);
-    console.log(`    Structured: ${formatTokens(s.savingsByFeature.structured)}`);
-    console.log(`    Compressed: ${formatTokens(s.savingsByFeature.compressed)}`);
-    console.log(`    Diff cache: ${formatTokens(s.savingsByFeature.diff)}`);
-    console.log(`    NL cache:   ${formatTokens(s.savingsByFeature.cache)}`);
-    console.log(`    Search:     ${formatTokens(s.savingsByFeature.search)}`);
+    const { formatEconomicsSummary } = await import("./economy.js");
+    console.log(formatEconomicsSummary());
 }
 // ── Sessions command ─────────────────────────────────────────────────────────
 else if (args[0] === "sessions") {
@@ -369,17 +361,52 @@ else if (args[0] === "repo") {
 else if (args[0] === "symbols" && args[1]) {
     const { extractSymbolsFromFile } = await import("./search/semantic.js");
     const { resolve } = await import("path");
-    const filePath = resolve(args[1]);
-    const symbols = extractSymbolsFromFile(filePath);
-    if (symbols.length === 0) {
-        console.log("No symbols found.");
+    const { statSync, readdirSync } = await import("fs");
+    const target = resolve(args[1]);
+    const filter = args[2]; // optional: grep-like filter on symbol name
+    // Support directories — recurse and extract symbols from all source files
+    const files = [];
+    try {
+        if (statSync(target).isDirectory()) {
+            const walk = (dir) => {
+                for (const entry of readdirSync(dir, { withFileTypes: true })) {
+                    if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist")
+                        continue;
+                    const full = resolve(dir, entry.name);
+                    if (entry.isDirectory())
+                        walk(full);
+                    else if (/\.(ts|tsx|py|go|rs)$/.test(entry.name) && !/\.(test|spec)\.\w+$/.test(entry.name))
+                        files.push(full);
+                }
+            };
+            walk(target);
+        }
+        else {
+            files.push(target);
+        }
     }
-    else {
-        for (const s of symbols) {
+    catch {
+        files.push(target);
+    }
+    let totalSymbols = 0;
+    for (const file of files) {
+        const symbols = extractSymbolsFromFile(file);
+        const filtered = filter ? symbols.filter(s => s.name.toLowerCase().includes(filter.toLowerCase()) || s.kind.toLowerCase().includes(filter.toLowerCase())) : symbols;
+        if (filtered.length === 0)
+            continue;
+        const relPath = file.replace(process.cwd() + "/", "");
+        if (files.length > 1)
+            console.log(`\n${relPath}:`);
+        for (const s of filtered) {
             const exp = s.exported ? "⬡" : "·";
             console.log(`  ${exp} ${s.kind.padEnd(10)} L${String(s.line).padStart(4)}  ${s.name}`);
         }
+        totalSymbols += filtered.length;
     }
+    if (totalSymbols === 0)
+        console.log("No symbols found.");
+    else if (files.length > 1)
+        console.log(`\n${totalSymbols} symbols across ${files.length} files`);
 }
 // ── History command ──────────────────────────────────────────────────────────
 else if (args[0] === "history") {
@@ -407,6 +434,19 @@ else if (args[0] === "explain" && args[1]) {
     const explanation = await explainCommand(command);
     console.log(explanation);
 }
+// ── Discover command ─────────────────────────────────────────────────────────
+else if (args[0] === "discover") {
+    const { discover, formatDiscoverReport } = await import("./discover.js");
+    const days = parseInt(args.find(a => a.startsWith("--days="))?.split("=")[1] ?? "30");
+    const json = args.includes("--json");
+    const report = discover({ maxAgeDays: days });
+    if (json) {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        console.log(formatDiscoverReport(report));
+    }
+}
 // ── Snapshot command ─────────────────────────────────────────────────────────
 else if (args[0] === "snapshot") {
     const { captureSnapshot } = await import("./snapshots.js");
@@ -430,6 +470,7 @@ else if (args.length > 0) {
     const { processOutput, shouldProcess } = await import("./output-processor.js");
     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 { recordSaving, recordUsage } = await import("./economy.js");
     const { isTestOutput, trackTests, formatWatchResult } = await import("./test-watchlist.js");
@@ -437,6 +478,7 @@ else if (args.length > 0) {
     const { loadConfig } = await import("./history.js");
     const { loadContext, saveContext, formatContext } = await import("./session-context.js");
     const { getLearned, recordMapping } = await import("./usage-cache.js");
+    const { recordCorrection, findSimilarCorrections, recordOutput } = await import("./sessions-db.js");
     const config = loadConfig();
     const perms = config.permissions;
     const sessionCtx = formatContext();
@@ -580,7 +622,15 @@ else if (args.length > 0) {
             if (processed.aiProcessed) {
                 if (processed.tokensSaved > 0)
                     recordSaving("compressed", processed.tokensSaved);
-                console.log(processed.summary);
+                // Save full output for lazy recovery — agents can read the file
+                if (processed.tokensSaved > 50) {
+                    const outputPath = saveOutput(actualCmd, clean);
+                    console.log(processed.summary);
+                    console.log(formatOutputHint(outputPath));
+                }
+                else {
+                    console.log(processed.summary);
+                }
                 if (processed.tokensSaved > 10)
                     console.error(`[open-terminal] ${rawTokens} → ${rawTokens - processed.tokensSaved} tokens (saved ${processed.tokensSaved})`);
                 process.exit(0);
@@ -606,7 +656,7 @@ else if (args.length > 0) {
     catch (e) {
         // Empty result (grep exit 1 = no matches) — not a real error
         const errStdout = e.stdout?.toString() ?? "";
-        const errStderr = e.stderr?.toString() ?? "";
+        let errStderr = e.stderr?.toString() ?? "";
         if (e.status === 1 && !errStdout.trim() && !errStderr.trim()) {
             // Empty result — retry with broader scope before giving up
             if (!actualCmd.includes("#(broadened)")) {
@@ -628,22 +678,37 @@ else if (args.length > 0) {
             console.log(`No results found for: ${prompt}`);
             process.exit(0);
         }
-        // Auto-retry: if command failed (exit 2+), ask AI for a simpler alternative
-        if (e.status >= 2 && !actualCmd.includes("(retry)")) {
-            try {
-                const retryCmd = await translateToCommand(`${prompt} (The previous command failed with: ${errStderr.slice(0, 200)}. Try a SIMPLER approach. Use basic commands only.)`, perms, []);
-                if (retryCmd && !isIrreversible(retryCmd) && !checkPermissions(retryCmd, perms)) {
-                    console.error(`[open-terminal] retrying: $ ${retryCmd}`);
-                    const retryResult = execSync(retryCmd + " #(retry)", { encoding: "utf8", maxBuffer: 10 * 1024 * 1024, cwd: process.cwd() });
+        // 3-retry learning loop: each attempt learns from the previous failure
+        if (e.status >= 2) {
+            const retryStrategies = [
+                // Attempt 2: inject error context
+                `${prompt} (Command "${actualCmd}" failed with: ${errStderr.slice(0, 300)}. Fix this specific error. Keep the approach but correct the issue.)`,
+                // Attempt 3: inject corrections + force simplicity
+                `${prompt} (TWO commands already failed for this query. Use the ABSOLUTE SIMPLEST approach: basic grep -rn, find, wc -l, cat. No awk, no xargs, no subshells. Must work on macOS BSD.)`,
+            ];
+            for (let attempt = 0; attempt < retryStrategies.length; attempt++) {
+                try {
+                    const retryCmd = await translateToCommand(retryStrategies[attempt], perms, []);
+                    if (!retryCmd || retryCmd === actualCmd || isIrreversible(retryCmd) || checkPermissions(retryCmd, perms))
+                        continue;
+                    console.error(`[open-terminal] retry ${attempt + 2}/3: $ ${retryCmd}`);
+                    const retryResult = execSync(retryCmd + ` #(retry${attempt + 2})`, { encoding: "utf8", maxBuffer: 10 * 1024 * 1024, cwd: process.cwd() });
                     const retryClean = stripNoise(stripAnsi(retryResult)).cleaned;
                     if (retryClean.length > 5) {
+                        // Record correction — AI learns for next time
+                        recordCorrection(prompt, actualCmd, errStderr.slice(0, 500), retryCmd, true);
                         const processed = await processOutput(retryCmd, retryClean, prompt);
                         console.log(processed.aiProcessed ? processed.summary : retryClean);
                         process.exit(0);
                     }
                 }
+                catch (retryErr) {
+                    // This attempt also failed — record it and try next strategy
+                    const retryStderr = retryErr.stderr?.toString() ?? "";
+                    errStderr = retryStderr; // update for next attempt's context
+                    continue;
+                }
             }
-            catch { /* retry also failed, fall through */ }
         }
         // Combine stdout+stderr and try AI answer framing (for audit/lint/test commands)
         const combined = errStderr && errStdout.includes(errStderr.trim()) ? errStdout : errStdout + errStderr;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/terminal",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "description": "Smart terminal wrapper for AI agents and humans — structured output, token compression, MCP server, natural language",
   "type": "module",
   "bin": {

package/src/ai.ts

@@ -6,51 +6,48 @@ import { join } from "path";
 import { discoverProjectHints, discoverSafetyHints, formatHints } from "./context-hints.js";
 
 // ── model routing ─────────────────────────────────────────────────────────────
-// Simple queries → fast model. Complex/ambiguous → smart model.
+// Config-driven model selection. Defaults per provider, user can override in ~/.terminal/config.json
 
 const COMPLEX_SIGNALS = [
   /\b(undo|revert|rollback|previous|last)\b/i,
   /\b(all files?|recursively|bulk|batch)\b/i,
   /\b(pipeline|chain|then|and then|after)\b/i,
   /\b(if|when|unless|only if)\b/i,
-  /\b(go into|go to|navigate|cd into|enter)\b.*\b(and|then)\b/i, // multi-step navigation
-  /\b(inside|within|under)\b/i,  // relative references need context awareness
-  /[|&;]{2}/,           // pipes / &&  in NL (unusual = complex intent)
+  /\b(go into|go to|navigate|cd into|enter)\b.*\b(and|then)\b/i,
+  /\b(inside|within|under)\b/i,
+  /[|&;]{2}/,
 ];
 
-/** Model routing per provider */
+/** Default models per provider — user can override in ~/.terminal/config.json under "models" */
+const MODEL_DEFAULTS: Record<string, { fast: string; smart: string }> = {
+  cerebras:  { fast: "qwen-3-235b-a22b-instruct-2507", smart: "qwen-3-235b-a22b-instruct-2507" },
+  groq:      { fast: "openai/gpt-oss-120b",             smart: "moonshotai/kimi-k2-instruct" },
+  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 */
+function loadModelOverrides(): Record<string, { fast?: string; smart?: string }> {
+  try {
+    const configPath = join(process.env.HOME ?? "~", ".terminal", "config.json");
+    if (existsSync(configPath)) {
+      const config = JSON.parse(readFileSync(configPath, "utf8"));
+      return config.models ?? {};
+    }
+  } catch {}
+  return {};
+}
+
+/** Model routing per provider — config-driven with defaults */
 function pickModel(nl: string): { fast: string; smart: string; pick: "fast" | "smart" } {
   const isComplex = COMPLEX_SIGNALS.some((r) => r.test(nl)) || nl.split(" ").length > 10;
   const provider = getProvider();
+  const defaults = MODEL_DEFAULTS[provider.name] ?? MODEL_DEFAULTS.cerebras;
+  const overrides = loadModelOverrides()[provider.name] ?? {};
 
-  if (provider.name === "anthropic") {
-    return {
-      fast: "claude-haiku-4-5-20251001",
-      smart: "claude-sonnet-4-6",
-      pick: isComplex ? "smart" : "fast",
-    };
-  }
-
-  if (provider.name === "groq") {
-    return {
-      fast: "openai/gpt-oss-120b",
-      smart: "moonshotai/kimi-k2-instruct",
-      pick: isComplex ? "smart" : "fast",
-    };
-  }
-
-  if (provider.name === "xai") {
-    return {
-      fast: "grok-code-fast-1",
-      smart: "grok-4-fast-non-reasoning",
-      pick: isComplex ? "smart" : "fast",
-    };
-  }
-
-  // Cerebras — qwen for everything (llama3.1-8b too unreliable)
   return {
-    fast: "qwen-3-235b-a22b-instruct-2507",
-    smart: "qwen-3-235b-a22b-instruct-2507",
+    fast: overrides.fast ?? defaults.fast,
+    smart: overrides.smart ?? defaults.smart,
     pick: isComplex ? "smart" : "fast",
   };
 }
@@ -124,6 +121,23 @@ export interface SessionEntry {
   error?: boolean;
 }
 
+// ── correction memory ───────────────────────────────────────────────────────
+
+/** Load past corrections relevant to a prompt — injected as negative examples */
+function loadCorrectionHints(prompt: string): string {
+  try {
+    // Dynamic import to avoid circular deps
+    const { findSimilarCorrections } = require("./sessions-db.js");
+    const corrections = findSimilarCorrections(prompt, 3);
+    if (corrections.length === 0) return "";
+
+    const lines = corrections.map((c: any) =>
+      `AVOID: "${c.failed_command}" (failed: ${c.error_type}). USE: "${c.corrected_command}" instead.`
+    );
+    return `\n\nLEARNED CORRECTIONS (from past failures):\n${lines.join("\n")}`;
+  } catch { return ""; }
+}
+
 // ── project context (powered by context-hints) ──────────────────────────────
 
 function detectProjectContext(): string {
@@ -133,7 +147,7 @@ function detectProjectContext(): string {
 
 // ── system prompt ─────────────────────────────────────────────────────────────
 
-function buildSystemPrompt(perms: Permissions, sessionEntries: SessionEntry[]): string {
+function buildSystemPrompt(perms: Permissions, sessionEntries: SessionEntry[], currentPrompt?: string): string {
   const restrictions: string[] = [];
   if (!perms.destructive)
     restrictions.push("- NEVER generate commands that delete, remove, or overwrite files/data");
@@ -202,6 +216,14 @@ RULES:
 - 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)
@@ -233,7 +255,7 @@ EXISTENCE CHECKS: If the prompt starts with "is there", "does this have", "do we
 
 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/.
 cwd: ${process.cwd()}
-shell: zsh / macOS${projectContext}${safetyBlock}${restrictionBlock}${contextBlock}`;
+shell: zsh / macOS${projectContext}${safetyBlock}${restrictionBlock}${contextBlock}${currentPrompt ? loadCorrectionHints(currentPrompt) : ""}`;
 }
 
 // ── streaming translate ───────────────────────────────────────────────────────
@@ -253,7 +275,7 @@ export async function translateToCommand(
   const provider = getProvider();
   const routing = pickModel(nl);
   const model = routing.pick === "smart" ? routing.smart : routing.fast;
-  const system = buildSystemPrompt(perms, sessionEntries);
+  const system = buildSystemPrompt(perms, sessionEntries, nl);
 
   let text: string;
 
@@ -332,7 +354,7 @@ export async function fixCommand(
     {
       model: routing.smart, // always use smart model for fixes
       maxTokens: 256,
-      system: buildSystemPrompt(perms, sessionEntries),
+      system: buildSystemPrompt(perms, sessionEntries, originalNl),
     }
   );
   if (text.startsWith("BLOCKED:")) throw new Error(text);

package/src/cli.tsx

@@ -31,6 +31,7 @@ SUBCOMMANDS:
   collection create|list       Recipe collections
   mcp serve                    Start MCP server for AI agents
   mcp install --claude|--codex Install MCP server
+  discover [--days=N] [--json]  Scan Claude sessions, show token savings potential
   snapshot                     Terminal state as JSON
   --help                       Show this help
   --version                    Show version
@@ -243,17 +244,8 @@ else if (args[0] === "collection") {
 // ── Stats command ────────────────────────────────────────────────────────────
 
 else if (args[0] === "stats") {
-  const { getEconomyStats, formatTokens } = await import("./economy.js");
-  const s = getEconomyStats();
-  console.log("Token Economy:");
-  console.log(`  Total saved:  ${formatTokens(s.totalTokensSaved)}`);
-  console.log(`  Total used:   ${formatTokens(s.totalTokensUsed)}`);
-  console.log(`  By feature:`);
-  console.log(`    Structured: ${formatTokens(s.savingsByFeature.structured)}`);
-  console.log(`    Compressed: ${formatTokens(s.savingsByFeature.compressed)}`);
-  console.log(`    Diff cache: ${formatTokens(s.savingsByFeature.diff)}`);
-  console.log(`    NL cache:   ${formatTokens(s.savingsByFeature.cache)}`);
-  console.log(`    Search:     ${formatTokens(s.savingsByFeature.search)}`);
+  const { formatEconomicsSummary } = await import("./economy.js");
+  console.log(formatEconomicsSummary());
 }
 
 // ── Sessions command ─────────────────────────────────────────────────────────
@@ -343,15 +335,43 @@ else if (args[0] === "repo") {
 else if (args[0] === "symbols" && args[1]) {
   const { extractSymbolsFromFile } = await import("./search/semantic.js");
   const { resolve } = await import("path");
-  const filePath = resolve(args[1]);
-  const symbols = extractSymbolsFromFile(filePath);
-  if (symbols.length === 0) { console.log("No symbols found."); }
-  else {
-    for (const s of symbols) {
+  const { statSync, readdirSync } = await import("fs");
+  const target = resolve(args[1]);
+  const filter = args[2]; // optional: grep-like filter on symbol name
+
+  // Support directories — recurse and extract symbols from all source files
+  const files: string[] = [];
+  try {
+    if (statSync(target).isDirectory()) {
+      const walk = (dir: string) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+          if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist") continue;
+          const full = resolve(dir, entry.name);
+          if (entry.isDirectory()) walk(full);
+          else if (/\.(ts|tsx|py|go|rs)$/.test(entry.name) && !/\.(test|spec)\.\w+$/.test(entry.name)) files.push(full);
+        }
+      };
+      walk(target);
+    } else {
+      files.push(target);
+    }
+  } catch { files.push(target); }
+
+  let totalSymbols = 0;
+  for (const file of files) {
+    const symbols = extractSymbolsFromFile(file);
+    const filtered = filter ? symbols.filter(s => s.name.toLowerCase().includes(filter.toLowerCase()) || s.kind.toLowerCase().includes(filter.toLowerCase())) : symbols;
+    if (filtered.length === 0) continue;
+    const relPath = file.replace(process.cwd() + "/", "");
+    if (files.length > 1) console.log(`\n${relPath}:`);
+    for (const s of filtered) {
       const exp = s.exported ? "⬡" : "·";
       console.log(`  ${exp} ${s.kind.padEnd(10)} L${String(s.line).padStart(4)}  ${s.name}`);
     }
+    totalSymbols += filtered.length;
   }
+  if (totalSymbols === 0) console.log("No symbols found.");
+  else if (files.length > 1) console.log(`\n${totalSymbols} symbols across ${files.length} files`);
 }
 
 // ── History command ──────────────────────────────────────────────────────────
@@ -381,6 +401,20 @@ else if (args[0] === "explain" && args[1]) {
   console.log(explanation);
 }
 
+// ── Discover command ─────────────────────────────────────────────────────────
+
+else if (args[0] === "discover") {
+  const { discover, formatDiscoverReport } = await import("./discover.js");
+  const days = parseInt(args.find(a => a.startsWith("--days="))?.split("=")[1] ?? "30");
+  const json = args.includes("--json");
+  const report = discover({ maxAgeDays: days });
+  if (json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    console.log(formatDiscoverReport(report));
+  }
+}
+
 // ── Snapshot command ─────────────────────────────────────────────────────────
 
 else if (args[0] === "snapshot") {
@@ -411,6 +445,7 @@ else if (args.length > 0) {
   const { processOutput, shouldProcess } = await import("./output-processor.js");
   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 { recordSaving, recordUsage } = await import("./economy.js");
   const { isTestOutput, trackTests, formatWatchResult } = await import("./test-watchlist.js");
@@ -418,6 +453,7 @@ else if (args.length > 0) {
   const { loadConfig } = await import("./history.js");
   const { loadContext, saveContext, formatContext } = await import("./session-context.js");
   const { getLearned, recordMapping } = await import("./usage-cache.js");
+  const { recordCorrection, findSimilarCorrections, recordOutput } = await import("./sessions-db.js");
 
   const config = loadConfig();
   const perms = config.permissions;
@@ -566,7 +602,14 @@ else if (args.length > 0) {
       const processed = await processOutput(actualCmd, clean, prompt);
       if (processed.aiProcessed) {
         if (processed.tokensSaved > 0) recordSaving("compressed", processed.tokensSaved);
-        console.log(processed.summary);
+        // Save full output for lazy recovery — agents can read the file
+        if (processed.tokensSaved > 50) {
+          const outputPath = saveOutput(actualCmd, clean);
+          console.log(processed.summary);
+          console.log(formatOutputHint(outputPath));
+        } else {
+          console.log(processed.summary);
+        }
         if (processed.tokensSaved > 10) console.error(`[open-terminal] ${rawTokens} → ${rawTokens - processed.tokensSaved} tokens (saved ${processed.tokensSaved})`);
         process.exit(0);
       }
@@ -588,7 +631,7 @@ else if (args.length > 0) {
   } catch (e: any) {
     // Empty result (grep exit 1 = no matches) — not a real error
     const errStdout = e.stdout?.toString() ?? "";
-    const errStderr = e.stderr?.toString() ?? "";
+    let errStderr = e.stderr?.toString() ?? "";
     if (e.status === 1 && !errStdout.trim() && !errStderr.trim()) {
       // Empty result — retry with broader scope before giving up
       if (!actualCmd.includes("#(broadened)")) {
@@ -613,24 +656,37 @@ else if (args.length > 0) {
       process.exit(0);
     }
 
-    // Auto-retry: if command failed (exit 2+), ask AI for a simpler alternative
-    if (e.status >= 2 && !actualCmd.includes("(retry)")) {
-      try {
-        const retryCmd = await translateToCommand(
-          `${prompt} (The previous command failed with: ${errStderr.slice(0, 200)}. Try a SIMPLER approach. Use basic commands only.)`,
-          perms, []
-        );
-        if (retryCmd && !isIrreversible(retryCmd) && !checkPermissions(retryCmd, perms)) {
-          console.error(`[open-terminal] retrying: $ ${retryCmd}`);
-          const retryResult = execSync(retryCmd + " #(retry)", { encoding: "utf8", maxBuffer: 10 * 1024 * 1024, cwd: process.cwd() });
+    // 3-retry learning loop: each attempt learns from the previous failure
+    if (e.status >= 2) {
+      const retryStrategies = [
+        // Attempt 2: inject error context
+        `${prompt} (Command "${actualCmd}" failed with: ${errStderr.slice(0, 300)}. Fix this specific error. Keep the approach but correct the issue.)`,
+        // Attempt 3: inject corrections + force simplicity
+        `${prompt} (TWO commands already failed for this query. Use the ABSOLUTE SIMPLEST approach: basic grep -rn, find, wc -l, cat. No awk, no xargs, no subshells. Must work on macOS BSD.)`,
+      ];
+
+      for (let attempt = 0; attempt < retryStrategies.length; attempt++) {
+        try {
+          const retryCmd = await translateToCommand(retryStrategies[attempt], perms, []);
+          if (!retryCmd || retryCmd === actualCmd || isIrreversible(retryCmd) || checkPermissions(retryCmd, perms)) continue;
+
+          console.error(`[open-terminal] retry ${attempt + 2}/3: $ ${retryCmd}`);
+          const retryResult = execSync(retryCmd + ` #(retry${attempt + 2})`, { encoding: "utf8", maxBuffer: 10 * 1024 * 1024, cwd: process.cwd() });
           const retryClean = stripNoise(stripAnsi(retryResult)).cleaned;
           if (retryClean.length > 5) {
+            // Record correction — AI learns for next time
+            recordCorrection(prompt, actualCmd, errStderr.slice(0, 500), retryCmd, true);
             const processed = await processOutput(retryCmd, retryClean, prompt);
             console.log(processed.aiProcessed ? processed.summary : retryClean);
             process.exit(0);
           }
+        } catch (retryErr: any) {
+          // This attempt also failed — record it and try next strategy
+          const retryStderr = retryErr.stderr?.toString() ?? "";
+          errStderr = retryStderr; // update for next attempt's context
+          continue;
         }
-      } catch { /* retry also failed, fall through */ }
+      }
     }
 
     // Combine stdout+stderr and try AI answer framing (for audit/lint/test commands)

package/src/context-hints.ts

@@ -160,9 +160,98 @@ export function discoverOutputHints(output: string, command: string): string[] {
   // 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[] = [];

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

@@ -5,6 +5,7 @@ import { getProvider } from "./providers/index.js";
 import { estimateTokens } from "./parsers/index.js";
 import { recordSaving } from "./economy.js";
 import { discoverOutputHints } from "./context-hints.js";
+import { formatProfileHints } from "./tool-profiles.js";
 
 export interface ProcessedOutput {
   /** AI-generated summary (concise, structured) */
@@ -86,9 +87,13 @@ export async function processOutput(
       ? `\n\nOUTPUT OBSERVATIONS:\n${outputHints.join("\n")}`
       : "";
 
+    // Inject tool-specific profile hints
+    const profileBlock = formatProfileHints(command);
+    const profileHints = profileBlock ? `\n\n${profileBlock}` : "";
+
     const provider = getProvider();
     const summary = await provider.complete(
-      `${originalPrompt ? `User asked: ${originalPrompt}\n` : ""}Command: ${command}\nOutput (${lines.length} lines):\n${toSummarize}${hintsBlock}`,
+      `${originalPrompt ? `User asked: ${originalPrompt}\n` : ""}Command: ${command}\nOutput (${lines.length} lines):\n${toSummarize}${hintsBlock}${profileHints}`,
       {
         system: SUMMARIZE_PROMPT,
         maxTokens: 300,

package/src/output-store.ts

@@ -0,0 +1,111 @@
+// Output store — saves full raw output to disk when AI compresses it
+// Agents can read the file for full detail. Tiered retention strategy.
+
+import { existsSync, mkdirSync, writeFileSync, readdirSync, statSync, unlinkSync } from "fs";
+import { join } from "path";
+import { createHash } from "crypto";
+
+const OUTPUTS_DIR = join(process.env.HOME ?? "~", ".terminal", "outputs");
+
+/** Ensure outputs directory exists */
+function ensureDir() {
+  if (!existsSync(OUTPUTS_DIR)) mkdirSync(OUTPUTS_DIR, { recursive: true });
+}
+
+/** Generate a short hash for an output */
+function hashOutput(command: string, output: string): string {
+  return createHash("md5").update(command + output.slice(0, 1000)).digest("hex").slice(0, 12);
+}
+
+/** Tiered retention: recent = keep all, older = keep only high-value */
+function rotate() {
+  try {
+    const now = Date.now();
+    const ONE_HOUR = 60 * 60 * 1000;
+    const ONE_DAY = 24 * ONE_HOUR;
+
+    const files = readdirSync(OUTPUTS_DIR)
+      .filter(f => f.endsWith(".txt"))
+      .map(f => {
+        const path = join(OUTPUTS_DIR, f);
+        const stat = statSync(path);
+        return { name: f, path, mtime: stat.mtimeMs, size: stat.size };
+      })
+      .sort((a, b) => b.mtime - a.mtime); // newest first
+
+    for (const file of files) {
+      const age = now - file.mtime;
+
+      // Last 1 hour: keep everything
+      if (age < ONE_HOUR) continue;
+
+      // Last 24 hours: keep outputs >2KB (meaningful compression)
+      if (age < ONE_DAY) {
+        if (file.size < 2000) {
+          try { unlinkSync(file.path); } catch {}
+        }
+        continue;
+      }
+
+      // Older than 24h: keep only >10KB (high-value saves)
+      if (file.size < 10000) {
+        try { unlinkSync(file.path); } catch {}
+        continue;
+      }
+
+      // Older than 7 days: remove everything
+      if (age > 7 * ONE_DAY) {
+        try { unlinkSync(file.path); } catch {}
+      }
+    }
+
+    // Hard cap: never exceed 100 files or 10MB total
+    const remaining = readdirSync(OUTPUTS_DIR)
+      .filter(f => f.endsWith(".txt"))
+      .map(f => ({ path: join(OUTPUTS_DIR, f), mtime: statSync(join(OUTPUTS_DIR, f)).mtimeMs, size: statSync(join(OUTPUTS_DIR, f)).size }))
+      .sort((a, b) => b.mtime - a.mtime);
+
+    let totalSize = 0;
+    for (let i = 0; i < remaining.length; i++) {
+      totalSize += remaining[i].size;
+      if (i >= 100 || totalSize > 10 * 1024 * 1024) {
+        try { unlinkSync(remaining[i].path); } catch {}
+      }
+    }
+  } catch {}
+}
+
+/** Save full output to disk, return the file path */
+export function saveOutput(command: string, rawOutput: string): string {
+  ensureDir();
+
+  const hash = hashOutput(command, rawOutput);
+  const filename = `${hash}.txt`;
+  const filepath = join(OUTPUTS_DIR, filename);
+
+  const content = `$ ${command}\n${"─".repeat(60)}\n${rawOutput}`;
+  writeFileSync(filepath, content, "utf8");
+
+  rotate();
+  return filepath;
+}
+
+/** Format the hint line that tells agents where to find full output */
+export function formatOutputHint(filepath: string): string {
+  return `[full output: ${filepath}]`;
+}
+
+/** Get the outputs directory path */
+export function getOutputsDir(): string {
+  return OUTPUTS_DIR;
+}
+
+/** Manually purge all outputs */
+export function purgeOutputs(): number {
+  if (!existsSync(OUTPUTS_DIR)) return 0;
+  let count = 0;
+  for (const f of readdirSync(OUTPUTS_DIR)) {
+    try { unlinkSync(join(OUTPUTS_DIR, f)); count++; } catch {}
+  }
+  return count;
+}

package/src/providers/index.ts

@@ -51,13 +51,13 @@ function resolveProvider(config: ProviderConfig): LLMProvider {
     return p;
   }
 
-  // auto: prefer xAI (code-optimized), then Cerebras, then Groq, then Anthropic
-  const xai = new XaiProvider();
-  if (xai.isAvailable()) return xai;
-
+  // auto: prefer Cerebras (qwen-235b, fast + accurate), then xAI, then Groq, then Anthropic
   const cerebras = new CerebrasProvider();
   if (cerebras.isAvailable()) return cerebras;
 
+  const xai = new XaiProvider();
+  if (xai.isAvailable()) return xai;
+
   const groq = new GroqProvider();
   if (groq.isAvailable()) return groq;
 

package/src/sessions-db.ts

@@ -45,6 +45,32 @@ function getDb(): Database {
 
     CREATE INDEX IF NOT EXISTS idx_interactions_session ON interactions(session_id);
     CREATE INDEX IF NOT EXISTS idx_sessions_started ON sessions(started_at);
+
+    CREATE TABLE IF NOT EXISTS corrections (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      prompt TEXT NOT NULL,
+      failed_command TEXT NOT NULL,
+      error_output TEXT,
+      corrected_command TEXT NOT NULL,
+      worked INTEGER DEFAULT 1,
+      error_type TEXT,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS outputs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT,
+      command TEXT NOT NULL,
+      raw_output_path TEXT,
+      compressed_summary TEXT,
+      tokens_raw INTEGER DEFAULT 0,
+      tokens_compressed INTEGER DEFAULT 0,
+      provider TEXT,
+      model TEXT,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_corrections_prompt ON corrections(prompt);
   `);
 
   return db;
@@ -186,6 +212,61 @@ export function getSessionStats(): SessionStats {
   };
 }
 
+// ── Corrections ─────────────────────────────────────────────────────────────
+
+/** Record a correction: command failed, then AI retried with a better one */
+export function recordCorrection(
+  prompt: string,
+  failedCommand: string,
+  errorOutput: string,
+  correctedCommand: string,
+  worked: boolean,
+  errorType?: string,
+): void {
+  getDb().prepare(
+    "INSERT INTO corrections (prompt, failed_command, error_output, corrected_command, worked, error_type, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)"
+  ).run(prompt, failedCommand, errorOutput?.slice(0, 2000) ?? "", correctedCommand, worked ? 1 : 0, errorType ?? null, Date.now());
+}
+
+/** Find similar corrections for a prompt — used to inject as negative examples */
+export function findSimilarCorrections(prompt: string, limit: number = 5): { failed_command: string; corrected_command: string; error_type: string }[] {
+  // Simple keyword matching — extract significant words from prompt
+  const words = prompt.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+  if (words.length === 0) return [];
+
+  // Search corrections where the prompt shares keywords
+  const all = getDb().prepare(
+    "SELECT prompt, failed_command, corrected_command, error_type FROM corrections WHERE worked = 1 ORDER BY created_at DESC LIMIT 100"
+  ).all() as any[];
+
+  return all
+    .filter(c => {
+      const cWords = c.prompt.toLowerCase().split(/\s+/);
+      const overlap = words.filter((w: string) => cWords.some((cw: string) => cw.includes(w) || w.includes(cw)));
+      return overlap.length >= Math.min(2, words.length);
+    })
+    .slice(0, limit)
+    .map(c => ({ failed_command: c.failed_command, corrected_command: c.corrected_command, error_type: c.error_type ?? "unknown" }));
+}
+
+// ── Output tracking ─────────────────────────────────────────────────────────
+
+/** Record a compressed output for audit trail */
+export function recordOutput(
+  command: string,
+  rawOutputPath: string | null,
+  compressedSummary: string,
+  tokensRaw: number,
+  tokensCompressed: number,
+  provider?: string,
+  model?: string,
+  sessionId?: string,
+): void {
+  getDb().prepare(
+    "INSERT INTO outputs (session_id, command, raw_output_path, compressed_summary, tokens_raw, tokens_compressed, provider, model, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+  ).run(sessionId ?? null, command, rawOutputPath ?? null, compressedSummary?.slice(0, 5000) ?? "", tokensRaw, tokensCompressed, provider ?? null, model ?? null, Date.now());
+}
+
 /** Close the database connection */
 export function closeDb(): void {
   if (db) { db.close(); db = null; }

package/src/tool-profiles.ts

@@ -0,0 +1,139 @@
+// Tool profiles — config-driven AI enhancement for specific command categories
+// Profiles are loaded from ~/.terminal/profiles/ (user-customizable)
+// Each profile tells the AI how to handle a specific tool's output
+
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+
+export interface ToolProfile {
+  name: string;
+  /** Regex pattern to detect this tool in a command */
+  detect: string;
+  /** Hints injected into the AI output processor prompt */
+  hints: {
+    compress?: string;   // How to compress this tool's output
+    errors?: string;     // How to extract errors from this tool
+    success?: string;    // What success looks like
+  };
+  /** Output handling */
+  output?: {
+    maxLines?: number;        // Cap output before AI processing
+    preservePatterns?: string[]; // Regex patterns to always keep
+    stripPatterns?: string[];    // Regex patterns to always remove
+  };
+}
+
+const PROFILES_DIR = join(process.env.HOME ?? "~", ".terminal", "profiles");
+
+/** Built-in profiles — sensible defaults, user can override */
+const BUILTIN_PROFILES: ToolProfile[] = [
+  {
+    name: "git",
+    detect: "^git\\b",
+    hints: {
+      compress: "For git output: show branch, file counts, insertions/deletions summary. Collapse individual diffs to file-level stats.",
+      errors: "Git errors often include a suggested fix (e.g., 'did you mean X?'). Extract the suggestion.",
+      success: "Clean working tree, successful push/pull, merge complete.",
+    },
+    output: { preservePatterns: ["conflict", "CONFLICT", "fatal", "error", "diverged"] },
+  },
+  {
+    name: "test",
+    detect: "\\b(bun|npm|yarn|pnpm)\\s+(test|run\\s+test)|\\bpytest\\b|\\bcargo\\s+test\\b|\\bgo\\s+test\\b",
+    hints: {
+      compress: "For test output: show pass/fail counts FIRST, then list ONLY failing test names with error snippets. Skip passing tests entirely.",
+      errors: "Test failures have: test name, expected vs actual, stack trace. Extract all three.",
+      success: "All tests passing = one line: '✓ N tests pass, 0 fail'",
+    },
+    output: { preservePatterns: ["FAIL", "fail", "Error", "✗", "expected", "received"] },
+  },
+  {
+    name: "build",
+    detect: "\\b(tsc|bun\\s+run\\s+build|npm\\s+run\\s+build|cargo\\s+build|go\\s+build|make)\\b",
+    hints: {
+      compress: "For build output: if success with no errors, say '✓ Build succeeded'. If errors, list each error with file:line and message.",
+      errors: "Build errors have file:line:column format. Group by file.",
+      success: "Empty output or exit 0 = build succeeded.",
+    },
+  },
+  {
+    name: "lint",
+    detect: "\\b(eslint|biome|ruff|clippy|golangci-lint|prettier|tsc\\s+--noEmit)\\b",
+    hints: {
+      compress: "For lint output: group violations by rule name, show count per rule, one example per rule. Skip clean files.",
+      errors: "Lint violations: file:line rule-name message. Group by rule.",
+    },
+    output: { maxLines: 100 },
+  },
+  {
+    name: "install",
+    detect: "\\b(npm\\s+install|bun\\s+install|yarn|pip\\s+install|cargo\\s+build|go\\s+mod)\\b",
+    hints: {
+      compress: "For install output: show only errors and final summary (packages added/removed/updated). Strip progress bars, funding notices, deprecation warnings.",
+    },
+    output: { stripPatterns: ["npm warn", "packages are looking for funding", "run `npm fund`"] },
+  },
+  {
+    name: "find",
+    detect: "^find\\b",
+    hints: {
+      compress: "For find output: if >50 results, group by top-level directory with counts. Show first 10 results as examples.",
+    },
+  },
+  {
+    name: "docker",
+    detect: "\\b(docker|kubectl|helm)\\b",
+    hints: {
+      compress: "For container output: show container status, image, ports. Strip pull progress and layer hashes.",
+      errors: "Docker errors: extract the error message after 'Error response from daemon:'",
+    },
+  },
+];
+
+/** Load user profiles from ~/.terminal/profiles/ */
+function loadUserProfiles(): ToolProfile[] {
+  if (!existsSync(PROFILES_DIR)) return [];
+
+  const profiles: ToolProfile[] = [];
+  try {
+    for (const file of readdirSync(PROFILES_DIR)) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        const content = JSON.parse(readFileSync(join(PROFILES_DIR, file), "utf8"));
+        if (content.name && content.detect) profiles.push(content as ToolProfile);
+      } catch {}
+    }
+  } catch {}
+  return profiles;
+}
+
+/** Get all profiles — user profiles override builtins by name */
+export function getProfiles(): ToolProfile[] {
+  const user = loadUserProfiles();
+  const userNames = new Set(user.map(p => p.name));
+  const builtins = BUILTIN_PROFILES.filter(p => !userNames.has(p.name));
+  return [...user, ...builtins];
+}
+
+/** Find the matching profile for a command */
+export function matchProfile(command: string): ToolProfile | null {
+  for (const profile of getProfiles()) {
+    try {
+      if (new RegExp(profile.detect).test(command)) return profile;
+    } catch {}
+  }
+  return null;
+}
+
+/** Format profile hints for injection into AI prompt */
+export function formatProfileHints(command: string): string {
+  const profile = matchProfile(command);
+  if (!profile) return "";
+
+  const lines: string[] = [`TOOL PROFILE (${profile.name}):`];
+  if (profile.hints.compress) lines.push(`  Compression: ${profile.hints.compress}`);
+  if (profile.hints.errors) lines.push(`  Errors: ${profile.hints.errors}`);
+  if (profile.hints.success) lines.push(`  Success: ${profile.hints.success}`);
+
+  return lines.join("\n");
+}