open-agents-ai 0.16.4 → 0.17.0

package/dist/index.js

@@ -1285,7 +1285,7 @@ ${stdinInput ?? ""}`);
       }
       runCommand(command, timeout, stdinInput) {
         const start = performance.now();
-        return new Promise((resolve16) => {
+        return new Promise((resolve18) => {
           const child = spawn("bash", ["-c", command], {
             cwd: this.workingDir,
             env: {
@@ -1338,7 +1338,7 @@ ${stdinInput ?? ""}`);
               const combined = stdout + stderr;
               const looksInteractive = /\? .+[›>]|y\/n|yes\/no|\(Y\/n\)|\[y\/N\]/i.test(combined);
               const hint = looksInteractive ? " The command appears to be waiting for interactive input. Use non-interactive flags (e.g., --yes, --no-input) or provide input via the stdin parameter." : "";
-              resolve16({
+              resolve18({
                 success: false,
                 output: stdout,
                 error: `Command timed out after ${timeout}ms.${hint}`,
@@ -1347,7 +1347,7 @@ ${stdinInput ?? ""}`);
               return;
             }
             const success = code === 0;
-            resolve16({
+            resolve18({
               success,
               output: stdout + (stderr && success ? `
 STDERR:
@@ -1358,7 +1358,7 @@ ${stderr}` : ""),
           });
           child.on("error", (err) => {
             clearTimeout(timer);
-            resolve16({
+            resolve18({
               success: false,
               output: stdout,
               error: err.message,
@@ -1732,15 +1732,24 @@ var init_web_fetch = __esm({
 });
 
 // packages/execution/dist/tools/web-search.js
-var DEFAULT_NUM_RESULTS, DUCKDUCKGO_HTML_URL, WebSearchTool;
+function detectSearchProvider() {
+  if (process.env["TAVILY_API_KEY"])
+    return "tavily";
+  if (process.env["JINA_API_KEY"])
+    return "jina";
+  return "duckduckgo";
+}
+var DEFAULT_NUM_RESULTS, DUCKDUCKGO_HTML_URL, TAVILY_API_URL, JINA_SEARCH_URL, WebSearchTool;
 var init_web_search = __esm({
   "packages/execution/dist/tools/web-search.js"() {
     "use strict";
     DEFAULT_NUM_RESULTS = 5;
     DUCKDUCKGO_HTML_URL = "https://html.duckduckgo.com/html/";
+    TAVILY_API_URL = "https://api.tavily.com/search";
+    JINA_SEARCH_URL = "https://s.jina.ai/";
     WebSearchTool = class {
       name = "web_search";
-      description = "Search the web for information. Returns a list of search results with titles, URLs, and snippets.";
+      description = "Search the web for information. Returns search results with titles, URLs, and snippets. Supports DuckDuckGo (free), Tavily (structured, set TAVILY_API_KEY), and Jina AI (markdown, set JINA_API_KEY).";
       parameters = {
         type: "object",
         properties: {
@@ -1751,6 +1760,11 @@ var init_web_search = __esm({
           num_results: {
             type: "number",
             description: `Number of results to return (default: ${DEFAULT_NUM_RESULTS})`
+          },
+          provider: {
+            type: "string",
+            enum: ["duckduckgo", "tavily", "jina"],
+            description: "Search provider (auto-detected from API keys if omitted). tavily: structured JSON results with AI answer. jina: markdown-formatted results. duckduckgo: free HTML scraping fallback."
           }
         },
         required: ["query"]
@@ -1758,43 +1772,73 @@ var init_web_search = __esm({
       async execute(args) {
         const query = args["query"];
         const numResults = args["num_results"] ?? DEFAULT_NUM_RESULTS;
+        const requestedProvider = args["provider"];
         const start = performance.now();
+        const provider = requestedProvider ?? detectSearchProvider();
         try {
-          const searchUrl = `${DUCKDUCKGO_HTML_URL}?q=${encodeURIComponent(query)}`;
-          const response = await fetch(searchUrl, {
-            method: "GET",
-            headers: {
-              "User-Agent": "Mozilla/5.0 (compatible; open-coding-agent/1.0; +https://github.com/open-agents)",
-              Accept: "text/html"
-            },
-            signal: AbortSignal.timeout(15e3)
-          });
-          if (!response.ok) {
-            return {
-              success: false,
-              output: "",
-              error: `HTTP ${response.status} ${response.statusText} from DuckDuckGo`,
-              durationMs: performance.now() - start
-            };
+          let response;
+          switch (provider) {
+            case "tavily":
+              response = await this.#searchTavily(query, numResults);
+              break;
+            case "jina":
+              response = await this.#searchJina(query, numResults);
+              break;
+            default:
+              response = await this.#searchDuckDuckGo(query, numResults);
+              break;
           }
-          const html = await response.text();
-          const results = this.#parseResults(html, numResults);
-          if (results.length === 0) {
+          if (response.results.length === 0) {
             return {
               success: true,
               output: "No results found.",
               durationMs: performance.now() - start
             };
           }
-          const formatted = results.map((r, i) => `${i + 1}. ${r.title}
-   URL: ${r.url}
-   ${r.snippet}`).join("\n\n");
+          const parts = [];
+          if (response.aiAnswer) {
+            parts.push(`AI Answer: ${response.aiAnswer}
+`);
+          }
+          for (let i = 0; i < response.results.length; i++) {
+            const r = response.results[i];
+            let line = `${i + 1}. ${r.title}
+   URL: ${r.url}`;
+            if (r.score !== void 0) {
+              line += `
+   Relevance: ${(r.score * 100).toFixed(0)}%`;
+            }
+            if (r.snippet) {
+              line += `
+   ${r.snippet}`;
+            }
+            parts.push(line);
+          }
+          const providerTag = provider !== "duckduckgo" ? ` [${provider}]` : "";
           return {
             success: true,
-            output: formatted,
+            output: parts.join("\n\n") + providerTag,
             durationMs: performance.now() - start
           };
         } catch (error) {
+          if (provider !== "duckduckgo") {
+            try {
+              const fallback = await this.#searchDuckDuckGo(query, numResults);
+              if (fallback.results.length > 0) {
+                const formatted = fallback.results.map((r, i) => `${i + 1}. ${r.title}
+   URL: ${r.url}
+   ${r.snippet}`).join("\n\n");
+                return {
+                  success: true,
+                  output: `[${provider} failed, fell back to DuckDuckGo]
+
+${formatted}`,
+                  durationMs: performance.now() - start
+                };
+              }
+            } catch {
+            }
+          }
           return {
             success: false,
             output: "",
@@ -1803,7 +1847,109 @@ var init_web_search = __esm({
           };
         }
       }
-      #parseResults(html, limit) {
+      // -------------------------------------------------------------------------
+      // Tavily provider — structured JSON search API
+      // -------------------------------------------------------------------------
+      async #searchTavily(query, numResults) {
+        const apiKey = process.env["TAVILY_API_KEY"];
+        if (!apiKey) {
+          throw new Error("TAVILY_API_KEY not set. Set the env var or use provider=duckduckgo.");
+        }
+        const body = {
+          query,
+          max_results: numResults,
+          include_answer: true,
+          search_depth: "basic"
+        };
+        const resp = await fetch(TAVILY_API_URL, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`
+          },
+          body: JSON.stringify(body),
+          signal: AbortSignal.timeout(2e4)
+        });
+        if (!resp.ok) {
+          throw new Error(`Tavily HTTP ${resp.status} ${resp.statusText}`);
+        }
+        const data = await resp.json();
+        const results = (data.results ?? []).map((r) => ({
+          title: r.title ?? "",
+          url: r.url ?? "",
+          snippet: r.content ?? "",
+          score: r.score
+        }));
+        return {
+          provider: "tavily",
+          query,
+          results,
+          aiAnswer: data.answer
+        };
+      }
+      // -------------------------------------------------------------------------
+      // Jina AI provider — markdown-formatted search
+      // -------------------------------------------------------------------------
+      async #searchJina(query, numResults) {
+        const apiKey = process.env["JINA_API_KEY"];
+        if (!apiKey) {
+          throw new Error("JINA_API_KEY not set. Set the env var or use provider=duckduckgo.");
+        }
+        const searchUrl = `${JINA_SEARCH_URL}${encodeURIComponent(query)}`;
+        const headers = {
+          Accept: "application/json",
+          Authorization: `Bearer ${apiKey}`,
+          "X-Retain-Images": "none"
+        };
+        const resp = await fetch(searchUrl, {
+          method: "GET",
+          headers,
+          signal: AbortSignal.timeout(2e4)
+        });
+        if (!resp.ok) {
+          throw new Error(`Jina HTTP ${resp.status} ${resp.statusText}`);
+        }
+        const data = await resp.json();
+        const items = data.data ?? [];
+        const results = items.slice(0, numResults).map((r) => ({
+          title: r.title ?? "",
+          url: r.url ?? "",
+          snippet: r.description ?? r.content ?? ""
+        }));
+        return {
+          provider: "jina",
+          query,
+          results
+        };
+      }
+      // -------------------------------------------------------------------------
+      // DuckDuckGo provider — free HTML scraping fallback
+      // -------------------------------------------------------------------------
+      async #searchDuckDuckGo(query, numResults) {
+        const searchUrl = `${DUCKDUCKGO_HTML_URL}?q=${encodeURIComponent(query)}`;
+        const response = await fetch(searchUrl, {
+          method: "GET",
+          headers: {
+            "User-Agent": "Mozilla/5.0 (compatible; open-coding-agent/1.0; +https://github.com/open-agents)",
+            Accept: "text/html"
+          },
+          signal: AbortSignal.timeout(15e3)
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status} ${response.statusText} from DuckDuckGo`);
+        }
+        const html = await response.text();
+        const results = this.#parseDDGResults(html, numResults);
+        return {
+          provider: "duckduckgo",
+          query,
+          results
+        };
+      }
+      // -------------------------------------------------------------------------
+      // DuckDuckGo HTML parsing (unchanged from original)
+      // -------------------------------------------------------------------------
+      #parseDDGResults(html, limit) {
         const results = [];
         const resultBlockRegex = /<div[^>]+class="[^"]*result[^"]*"[^>]*>([\s\S]*?)<\/div>\s*<\/div>/gi;
         let blockMatch;
@@ -3862,12 +4008,12 @@ var init_image = __esm({
         if (!existsSync7(fullPath)) {
           return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: Date.now() - start };
         }
-        const stat3 = statSync4(fullPath);
-        if (stat3.size > maxSizeKb * 1024) {
+        const stat5 = statSync4(fullPath);
+        if (stat5.size > maxSizeKb * 1024) {
           return {
             success: false,
             output: "",
-            error: `File too large: ${(stat3.size / 1024).toFixed(0)}KB (max: ${maxSizeKb}KB)`,
+            error: `File too large: ${(stat5.size / 1024).toFixed(0)}KB (max: ${maxSizeKb}KB)`,
             durationMs: Date.now() - start
           };
         }
@@ -3877,7 +4023,7 @@ var init_image = __esm({
         const base64 = imageToBase64(fullPath);
         const mime = getMimeType(fullPath);
         const dims = getImageDimensions(fullPath);
-        const sizeKb = (stat3.size / 1024).toFixed(1);
+        const sizeKb = (stat5.size / 1024).toFixed(1);
         const parts = [
           `File: ${basename(fullPath)}`,
           `Size: ${sizeKb}KB`,
@@ -3955,12 +4101,12 @@ ${ocrText}`);
         if (!existsSync7(outputPath)) {
           return { success: false, output: "", error: "Screenshot file not created", durationMs: Date.now() - start };
         }
-        const stat3 = statSync4(outputPath);
+        const stat5 = statSync4(outputPath);
         const base64 = imageToBase64(outputPath);
         const dims = getImageDimensions(outputPath);
         const parts = [
           `Screenshot saved: ${outputPath}`,
-          `Size: ${(stat3.size / 1024).toFixed(1)}KB`
+          `Size: ${(stat5.size / 1024).toFixed(1)}KB`
         ];
         if (dims)
           parts.push(`Dimensions: ${dims.width}x${dims.height}`);
@@ -4265,7 +4411,7 @@ var init_custom_tool = __esm({
       }
       /** Execute a single shell command and return output */
       runCommand(command) {
-        return new Promise((resolve16) => {
+        return new Promise((resolve18) => {
           const child = spawn3("bash", ["-c", command], {
             cwd: this.workingDir,
             env: { ...process.env, CI: "true", NO_COLOR: "1" },
@@ -4290,11 +4436,11 @@ var init_custom_tool = __esm({
               child.kill("SIGTERM");
             } catch {
             }
-            resolve16({ success: false, output: stdout, error: "Command timed out after 60s" });
+            resolve18({ success: false, output: stdout, error: "Command timed out after 60s" });
           }, 6e4);
           child.on("close", (code) => {
             clearTimeout(timer);
-            resolve16({
+            resolve18({
               success: code === 0,
               output: stdout + (stderr && code === 0 ? `
 STDERR:
@@ -4304,7 +4450,7 @@ ${stderr}` : ""),
           });
           child.on("error", (err) => {
             clearTimeout(timer);
-            resolve16({ success: false, output: stdout, error: err.message });
+            resolve18({ success: false, output: stdout, error: err.message });
           });
         });
       }
@@ -5240,7 +5386,775 @@ ${result.output}`,
           return {
             success: false,
             output: "",
-            error: `Failed to download/transcribe: ${err instanceof Error ? err.message : String(err)}`,
+            error: `Failed to download/transcribe: ${err instanceof Error ? err.message : String(err)}`,
+            durationMs: performance.now() - start
+          };
+        }
+      }
+    };
+  }
+});
+
+// packages/execution/dist/tools/structured-file.js
+import { writeFile as writeFile6, mkdir as mkdir3 } from "node:fs/promises";
+import { resolve as resolve13, dirname as dirname3, extname as extname4 } from "node:path";
+function jsonToCSV(data, separator = ",") {
+  if (!Array.isArray(data) || data.length === 0)
+    return "";
+  const headers = Object.keys(data[0]);
+  const esc = (val) => {
+    const str = val === null || val === void 0 ? "" : String(val);
+    if (str.includes(separator) || str.includes('"') || str.includes("\n")) {
+      return `"${str.replace(/"/g, '""')}"`;
+    }
+    return str;
+  };
+  const lines = [
+    headers.map((h) => esc(h)).join(separator),
+    ...data.map((row) => {
+      const obj = row;
+      return headers.map((h) => esc(obj[h])).join(separator);
+    })
+  ];
+  return lines.join("\n") + "\n";
+}
+function jsonToMarkdownTable(data) {
+  if (!Array.isArray(data) || data.length === 0)
+    return "";
+  const headers = Object.keys(data[0]);
+  const headerRow = `| ${headers.join(" | ")} |`;
+  const sepRow = `| ${headers.map(() => "---").join(" | ")} |`;
+  const dataRows = data.map((row) => {
+    const obj = row;
+    return `| ${headers.map((h) => String(obj[h] ?? "")).join(" | ")} |`;
+  });
+  return [headerRow, sepRow, ...dataRows].join("\n") + "\n";
+}
+var StructuredFileTool;
+var init_structured_file = __esm({
+  "packages/execution/dist/tools/structured-file.js"() {
+    "use strict";
+    StructuredFileTool = class {
+      name = "create_structured_file";
+      description = "Create a structured file (CSV, JSON, Markdown table, or Excel-compatible) from data. Provide data as a JSON array of objects. Each object becomes a row, keys become columns.";
+      parameters = {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Output file path (extension determines format: .csv, .json, .md, .tsv, .xlsx)"
+          },
+          data: {
+            type: "array",
+            description: "Array of objects \u2014 each object is a row, keys are column headers",
+            items: { type: "object" }
+          },
+          format: {
+            type: "string",
+            enum: ["csv", "json", "markdown", "tsv", "xlsx"],
+            description: "Output format (auto-detected from file extension if omitted)"
+          },
+          title: {
+            type: "string",
+            description: "Optional title/heading for markdown output"
+          },
+          sheets: {
+            type: "array",
+            description: "For multi-sheet xlsx: array of {name, data} objects",
+            items: {
+              type: "object",
+              properties: {
+                name: { type: "string" },
+                data: { type: "array", items: { type: "object" } }
+              }
+            }
+          }
+        },
+        required: ["path"]
+      };
+      workingDir;
+      constructor(workingDir) {
+        this.workingDir = workingDir;
+      }
+      async execute(args) {
+        const filePath = args["path"];
+        const data = args["data"] ?? [];
+        const title = args["title"];
+        const sheets = args["sheets"];
+        const start = performance.now();
+        if (!filePath) {
+          return { success: false, output: "", error: "path is required", durationMs: 0 };
+        }
+        const ext = extname4(filePath).toLowerCase();
+        let format = args["format"] ?? "";
+        if (!format) {
+          switch (ext) {
+            case ".csv":
+              format = "csv";
+              break;
+            case ".tsv":
+              format = "tsv";
+              break;
+            case ".json":
+              format = "json";
+              break;
+            case ".md":
+            case ".markdown":
+              format = "markdown";
+              break;
+            case ".xlsx":
+            case ".xls":
+              format = "xlsx";
+              break;
+            default:
+              format = "csv";
+          }
+        }
+        try {
+          const fullPath = resolve13(this.workingDir, filePath);
+          await mkdir3(dirname3(fullPath), { recursive: true });
+          let content;
+          let byteInfo = "";
+          switch (format) {
+            case "csv":
+              content = jsonToCSV(data, ",");
+              byteInfo = `${data.length} rows`;
+              break;
+            case "tsv":
+            case "xlsx":
+              content = jsonToCSV(data, "	");
+              byteInfo = `${data.length} rows (tab-separated)`;
+              break;
+            case "json":
+              content = JSON.stringify(data, null, 2) + "\n";
+              byteInfo = `${data.length} items`;
+              break;
+            case "markdown": {
+              const parts = [];
+              if (title)
+                parts.push(`# ${title}
+`);
+              if (sheets && sheets.length > 0) {
+                for (const sheet of sheets) {
+                  parts.push(`## ${sheet.name}
+`);
+                  parts.push(jsonToMarkdownTable(sheet.data));
+                  parts.push("");
+                }
+              } else if (data.length > 0) {
+                parts.push(jsonToMarkdownTable(data));
+              }
+              content = parts.join("\n");
+              byteInfo = sheets ? `${sheets.length} sections, ${sheets.reduce((s, sh) => s + sh.data.length, 0)} total rows` : `${data.length} rows`;
+              break;
+            }
+            default:
+              return {
+                success: false,
+                output: "",
+                error: `Unknown format: ${format}. Use csv, json, markdown, tsv, or xlsx.`,
+                durationMs: performance.now() - start
+              };
+          }
+          await writeFile6(fullPath, content, "utf-8");
+          return {
+            success: true,
+            output: `Created ${format.toUpperCase()} file: ${fullPath} (${byteInfo}, ${content.length} bytes)`,
+            durationMs: performance.now() - start
+          };
+        } catch (error) {
+          return {
+            success: false,
+            output: "",
+            error: error instanceof Error ? error.message : String(error),
+            durationMs: performance.now() - start
+          };
+        }
+      }
+    };
+  }
+});
+
+// packages/execution/dist/tools/code-sandbox.js
+import { spawn as spawn5 } from "node:child_process";
+import { writeFile as writeFile7, mkdtemp, rm, readdir, stat } from "node:fs/promises";
+import { join as join14 } from "node:path";
+import { tmpdir as tmpdir2 } from "node:os";
+function runProcess(cmd, args, options) {
+  return new Promise((resolve18) => {
+    const proc = spawn5(cmd, args, {
+      cwd: options.cwd,
+      timeout: options.timeout,
+      env: {
+        PATH: process.env["PATH"] ?? "/usr/bin:/bin",
+        HOME: options.cwd,
+        TMPDIR: options.cwd,
+        NODE_ENV: "sandbox",
+        ...options.env ?? {}
+      },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    proc.stdout.on("data", (d) => {
+      stdout += d.toString();
+      if (stdout.length > 1e5) {
+        stdout = stdout.slice(0, 1e5) + "\n[output truncated at 100KB]";
+        proc.kill("SIGKILL");
+      }
+    });
+    proc.stderr.on("data", (d) => {
+      stderr += d.toString();
+      if (stderr.length > 5e4) {
+        stderr = stderr.slice(0, 5e4) + "\n[stderr truncated at 50KB]";
+      }
+    });
+    proc.on("error", (err) => {
+      resolve18({
+        stdout,
+        stderr: stderr || err.message,
+        exitCode: 1,
+        filesCreated: [],
+        timedOut: false
+      });
+    });
+    proc.on("close", (code, signal) => {
+      if (signal === "SIGTERM" || signal === "SIGKILL") {
+        timedOut = true;
+      }
+      resolve18({
+        stdout,
+        stderr,
+        exitCode: code ?? (timedOut ? 124 : 1),
+        filesCreated: [],
+        timedOut
+      });
+    });
+    if (options.stdin) {
+      proc.stdin.write(options.stdin);
+    }
+    proc.stdin.end();
+  });
+}
+async function listCreatedFiles(dir) {
+  const files = [];
+  try {
+    const entries = await readdir(dir);
+    for (const entry of entries) {
+      if (entry.startsWith("_sandbox_script"))
+        continue;
+      const fullPath = join14(dir, entry);
+      const s = await stat(fullPath);
+      if (s.isFile()) {
+        files.push(entry);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+var LANGUAGE_CONFIG, CodeSandboxTool;
+var init_code_sandbox = __esm({
+  "packages/execution/dist/tools/code-sandbox.js"() {
+    "use strict";
+    LANGUAGE_CONFIG = {
+      javascript: { ext: ".js", cmd: "node", args: (f) => [f] },
+      python: { ext: ".py", cmd: "python3", args: (f) => [f] },
+      bash: { ext: ".sh", cmd: "bash", args: (f) => [f] },
+      typescript: { ext: ".ts", cmd: "npx", args: (f) => ["tsx", f] }
+    };
+    CodeSandboxTool = class {
+      name = "code_sandbox";
+      description = "Execute code in an isolated sandbox environment. Safer than shell for running generated or untrusted code. Supports JavaScript, Python, Bash, and TypeScript. Returns stdout, stderr, exit code, and any files created.";
+      parameters = {
+        type: "object",
+        properties: {
+          code: {
+            type: "string",
+            description: "The code to execute"
+          },
+          language: {
+            type: "string",
+            enum: ["javascript", "python", "bash", "typescript"],
+            description: "Programming language (default: javascript)"
+          },
+          timeout_ms: {
+            type: "number",
+            description: "Execution timeout in milliseconds (default: 30000, max: 120000)"
+          },
+          stdin: {
+            type: "string",
+            description: "Optional input to pass to stdin"
+          },
+          mode: {
+            type: "string",
+            enum: ["subprocess", "docker"],
+            description: "Execution mode. subprocess (default): isolated process. docker: Docker container (requires Docker installed)."
+          }
+        },
+        required: ["code"]
+      };
+      workingDir;
+      constructor(workingDir) {
+        this.workingDir = workingDir;
+      }
+      async execute(args) {
+        const code = args["code"];
+        const language = args["language"] ?? "javascript";
+        const timeoutMs = Math.min(args["timeout_ms"] ?? 3e4, 12e4);
+        const stdin = args["stdin"];
+        const mode = args["mode"] ?? "subprocess";
+        const start = performance.now();
+        if (!code) {
+          return { success: false, output: "", error: "code is required", durationMs: 0 };
+        }
+        const langConfig = LANGUAGE_CONFIG[language];
+        if (!langConfig) {
+          return {
+            success: false,
+            output: "",
+            error: `Unsupported language: ${language}. Use javascript, python, bash, or typescript.`,
+            durationMs: performance.now() - start
+          };
+        }
+        try {
+          let result;
+          if (mode === "docker") {
+            result = await this.#runDocker(code, language, langConfig, timeoutMs, stdin);
+          } else {
+            result = await this.#runSubprocess(code, langConfig, timeoutMs, stdin);
+          }
+          const parts = [];
+          if (result.stdout) {
+            parts.push(result.stdout.trimEnd());
+          }
+          if (result.stderr) {
+            parts.push(`
+--- stderr ---
+${result.stderr.trimEnd()}`);
+          }
+          if (result.timedOut) {
+            parts.push(`
+[Execution timed out after ${timeoutMs}ms]`);
+          }
+          if (result.filesCreated.length > 0) {
+            parts.push(`
+--- files created ---
+${result.filesCreated.join("\n")}`);
+          }
+          parts.push(`
+[exit code: ${result.exitCode}]`);
+          return {
+            success: result.exitCode === 0,
+            output: parts.join(""),
+            error: result.exitCode !== 0 ? `Process exited with code ${result.exitCode}${result.timedOut ? " (timeout)" : ""}` : void 0,
+            durationMs: performance.now() - start
+          };
+        } catch (error) {
+          return {
+            success: false,
+            output: "",
+            error: error instanceof Error ? error.message : String(error),
+            durationMs: performance.now() - start
+          };
+        }
+      }
+      // -------------------------------------------------------------------------
+      // Subprocess mode — temp directory + separate process
+      // -------------------------------------------------------------------------
+      async #runSubprocess(code, langConfig, timeoutMs, stdin) {
+        const sandboxDir = await mkdtemp(join14(tmpdir2(), "oa-sandbox-"));
+        try {
+          const scriptFile = join14(sandboxDir, `_sandbox_script${langConfig.ext}`);
+          await writeFile7(scriptFile, code, "utf-8");
+          const result = await runProcess(langConfig.cmd, langConfig.args(scriptFile), {
+            cwd: sandboxDir,
+            timeout: timeoutMs,
+            stdin
+          });
+          result.filesCreated = await listCreatedFiles(sandboxDir);
+          return result;
+        } finally {
+          await rm(sandboxDir, { recursive: true, force: true }).catch(() => {
+          });
+        }
+      }
+      // -------------------------------------------------------------------------
+      // Docker mode — run in container
+      // -------------------------------------------------------------------------
+      async #runDocker(code, language, langConfig, timeoutMs, stdin) {
+        const images = {
+          javascript: "node:22-slim",
+          typescript: "node:22-slim",
+          python: "python:3.12-slim",
+          bash: "bash:5"
+        };
+        const image = images[language] ?? "node:22-slim";
+        const sandboxDir = await mkdtemp(join14(tmpdir2(), "oa-docker-sandbox-"));
+        try {
+          const scriptFile = `_sandbox_script${langConfig.ext}`;
+          await writeFile7(join14(sandboxDir, scriptFile), code, "utf-8");
+          const dockerArgs = [
+            "run",
+            "--rm",
+            "--network=none",
+            // No network access
+            "--memory=256m",
+            // Memory limit
+            "--cpus=1",
+            // CPU limit
+            "-v",
+            `${sandboxDir}:/sandbox:rw`,
+            "-w",
+            "/sandbox",
+            image,
+            langConfig.cmd,
+            ...langConfig.args(`/sandbox/${scriptFile}`)
+          ];
+          const result = await runProcess("docker", dockerArgs, {
+            cwd: sandboxDir,
+            timeout: timeoutMs,
+            stdin
+          });
+          result.filesCreated = await listCreatedFiles(sandboxDir);
+          return result;
+        } finally {
+          await rm(sandboxDir, { recursive: true, force: true }).catch(() => {
+          });
+        }
+      }
+    };
+  }
+});
+
+// packages/execution/dist/tools/structured-read.js
+import { readFile as readFile7, stat as stat2 } from "node:fs/promises";
+import { resolve as resolve14, extname as extname5 } from "node:path";
+function parseCSV(text, separator = ",") {
+  const lines = text.split("\n").filter((l) => l.trim() !== "");
+  if (lines.length < 2)
+    return [];
+  const parseLine = (line) => {
+    const fields = [];
+    let current = "";
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+      const ch = line[i];
+      if (inQuotes) {
+        if (ch === '"' && line[i + 1] === '"') {
+          current += '"';
+          i++;
+        } else if (ch === '"') {
+          inQuotes = false;
+        } else {
+          current += ch;
+        }
+      } else {
+        if (ch === '"') {
+          inQuotes = true;
+        } else if (ch === separator) {
+          fields.push(current);
+          current = "";
+        } else {
+          current += ch;
+        }
+      }
+    }
+    fields.push(current);
+    return fields;
+  };
+  const headers = parseLine(lines[0]).map((h) => h.trim());
+  const rows = [];
+  for (let i = 1; i < lines.length; i++) {
+    const values = parseLine(lines[i]);
+    const row = {};
+    for (let j = 0; j < headers.length; j++) {
+      row[headers[j]] = (values[j] ?? "").trim();
+    }
+    rows.push(row);
+  }
+  return rows;
+}
+function parseMarkdownTables(text) {
+  const tables = [];
+  const lines = text.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i].trim();
+    if (line.startsWith("|") && line.endsWith("|")) {
+      const nextLine = (lines[i + 1] ?? "").trim();
+      if (nextLine.startsWith("|") && /^\|[\s-:|]+\|$/.test(nextLine)) {
+        let heading;
+        for (let h = i - 1; h >= 0; h--) {
+          const prev = lines[h].trim();
+          if (prev === "")
+            continue;
+          if (prev.startsWith("#")) {
+            heading = prev.replace(/^#+\s*/, "").trim();
+          }
+          break;
+        }
+        const headers = line.split("|").filter((c3) => c3.trim() !== "").map((c3) => c3.trim());
+        const rows = [];
+        i += 2;
+        while (i < lines.length) {
+          const dataLine = lines[i].trim();
+          if (!dataLine.startsWith("|") || !dataLine.endsWith("|"))
+            break;
+          const values = dataLine.split("|").filter((c3) => c3.trim() !== "").map((c3) => c3.trim());
+          const row = {};
+          for (let j = 0; j < headers.length; j++) {
+            row[headers[j]] = values[j] ?? "";
+          }
+          rows.push(row);
+          i++;
+        }
+        if (rows.length > 0) {
+          tables.push({ heading, rows });
+        }
+        continue;
+      }
+    }
+    i++;
+  }
+  return tables;
+}
+function detectBinaryFormat(buffer) {
+  if (buffer[0] === 80 && buffer[1] === 75) {
+    const str = buffer.toString("utf-8", 0, Math.min(buffer.length, 2e3));
+    if (str.includes("xl/") || str.includes("spreadsheetml"))
+      return "xlsx";
+    if (str.includes("word/") || str.includes("wordprocessingml"))
+      return "docx";
+    return "zip";
+  }
+  if (buffer[0] === 37 && buffer[1] === 80 && buffer[2] === 68 && buffer[3] === 70) {
+    return "pdf";
+  }
+  return null;
+}
+var StructuredReadTool;
+var init_structured_read = __esm({
+  "packages/execution/dist/tools/structured-read.js"() {
+    "use strict";
+    StructuredReadTool = class {
+      name = "read_structured_file";
+      description = "Read and parse a structured file (CSV, TSV, JSON, Markdown tables). Returns the file content as structured data the agent can work with. For binary formats (XLSX, PDF), detects the format and suggests tools.";
+      parameters = {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "File path to read"
+          },
+          format: {
+            type: "string",
+            enum: ["csv", "tsv", "json", "markdown", "auto"],
+            description: "File format (auto-detected from extension if omitted)"
+          },
+          max_rows: {
+            type: "number",
+            description: "Maximum rows to return (default: 100)"
+          }
+        },
+        required: ["path"]
+      };
+      workingDir;
+      constructor(workingDir) {
+        this.workingDir = workingDir;
+      }
+      async execute(args) {
+        const filePath = args["path"];
+        const maxRows = args["max_rows"] ?? 100;
+        const start = performance.now();
+        if (!filePath) {
+          return { success: false, output: "", error: "path is required", durationMs: 0 };
+        }
+        const fullPath = resolve14(this.workingDir, filePath);
+        try {
+          const fileStat = await stat2(fullPath);
+          if (!fileStat.isFile()) {
+            return {
+              success: false,
+              output: "",
+              error: `Not a file: ${filePath}`,
+              durationMs: performance.now() - start
+            };
+          }
+          if (fileStat.size > 10 * 1024 * 1024) {
+            return {
+              success: false,
+              output: "",
+              error: `File too large (${(fileStat.size / 1024 / 1024).toFixed(1)}MB). Maximum is 10MB.`,
+              durationMs: performance.now() - start
+            };
+          }
+          const ext = extname5(filePath).toLowerCase();
+          let format = args["format"] ?? "auto";
+          if (format === "auto") {
+            switch (ext) {
+              case ".csv":
+                format = "csv";
+                break;
+              case ".tsv":
+                format = "tsv";
+                break;
+              case ".json":
+                format = "json";
+                break;
+              case ".md":
+              case ".markdown":
+                format = "markdown";
+                break;
+              case ".xlsx":
+              case ".xls":
+                format = "xlsx";
+                break;
+              case ".pdf":
+                format = "pdf";
+                break;
+              case ".docx":
+              case ".doc":
+                format = "docx";
+                break;
+              default:
+                format = "auto";
+                break;
+            }
+          }
+          if (format === "xlsx" || format === "pdf" || format === "docx" || format === "auto") {
+            const buffer = await readFile7(fullPath);
+            const detected = detectBinaryFormat(buffer);
+            if (detected === "xlsx") {
+              return {
+                success: true,
+                output: `Detected Excel file (.xlsx), ${(fileStat.size / 1024).toFixed(1)}KB.
+To parse this file, use the shell tool to run:
+  npx xlsx-cli "${filePath}" --json
+Or install exceljs for programmatic access.`,
+                durationMs: performance.now() - start
+              };
+            }
+            if (detected === "pdf") {
+              return {
+                success: true,
+                output: `Detected PDF file, ${(fileStat.size / 1024).toFixed(1)}KB.
+To extract text, use the shell tool to run:
+  pdftotext "${filePath}" -
+Or install pdf-parse for programmatic access.`,
+                durationMs: performance.now() - start
+              };
+            }
+            if (detected === "docx") {
+              return {
+                success: true,
+                output: `Detected Word document (.docx), ${(fileStat.size / 1024).toFixed(1)}KB.
+To extract text, use the shell tool to run:
+  pandoc "${filePath}" -t plain
+Or install mammoth for programmatic access.`,
+                durationMs: performance.now() - start
+              };
+            }
+            if (format === "auto") {
+              const text2 = buffer.toString("utf-8");
+              if (text2.trimStart().startsWith("{") || text2.trimStart().startsWith("[")) {
+                format = "json";
+              } else if (text2.includes("	") && !text2.includes(",")) {
+                format = "tsv";
+              } else if (text2.includes("|") && /^\|[\s-:|]+\|$/m.test(text2)) {
+                format = "markdown";
+              } else {
+                format = "csv";
+              }
+            }
+          }
+          const text = await readFile7(fullPath, "utf-8");
+          switch (format) {
+            case "csv": {
+              const rows = parseCSV(text, ",");
+              const limited = rows.slice(0, maxRows);
+              const truncated = rows.length > maxRows ? `
+[showing ${maxRows} of ${rows.length} rows]` : "";
+              return {
+                success: true,
+                output: `CSV: ${rows.length} rows, ${Object.keys(rows[0] ?? {}).length} columns
+${JSON.stringify(limited, null, 2)}${truncated}`,
+                durationMs: performance.now() - start
+              };
+            }
+            case "tsv": {
+              const rows = parseCSV(text, "	");
+              const limited = rows.slice(0, maxRows);
+              const truncated = rows.length > maxRows ? `
+[showing ${maxRows} of ${rows.length} rows]` : "";
+              return {
+                success: true,
+                output: `TSV: ${rows.length} rows, ${Object.keys(rows[0] ?? {}).length} columns
+${JSON.stringify(limited, null, 2)}${truncated}`,
+                durationMs: performance.now() - start
+              };
+            }
+            case "json": {
+              const parsed = JSON.parse(text);
+              const isArray = Array.isArray(parsed);
+              const count = isArray ? parsed.length : Object.keys(parsed).length;
+              let display;
+              if (isArray && parsed.length > maxRows) {
+                display = parsed.slice(0, maxRows);
+                return {
+                  success: true,
+                  output: `JSON array: ${parsed.length} items
+${JSON.stringify(display, null, 2)}
+[showing ${maxRows} of ${parsed.length} items]`,
+                  durationMs: performance.now() - start
+                };
+              }
+              return {
+                success: true,
+                output: `JSON ${isArray ? "array" : "object"}: ${count} ${isArray ? "items" : "keys"}
+${JSON.stringify(parsed, null, 2)}`,
+                durationMs: performance.now() - start
+              };
+            }
+            case "markdown": {
+              const tables = parseMarkdownTables(text);
+              if (tables.length === 0) {
+                return {
+                  success: true,
+                  output: `Markdown file (no tables found). Content:
+${text.slice(0, 5e3)}${text.length > 5e3 ? "\n[truncated]" : ""}`,
+                  durationMs: performance.now() - start
+                };
+              }
+              const parts = [];
+              for (const table of tables) {
+                const heading = table.heading ? `Table: ${table.heading}` : "Table";
+                const limited = table.rows.slice(0, maxRows);
+                parts.push(`${heading} (${table.rows.length} rows)
+${JSON.stringify(limited, null, 2)}`);
+              }
+              return {
+                success: true,
+                output: `Markdown: ${tables.length} table(s)
+
+${parts.join("\n\n")}`,
+                durationMs: performance.now() - start
+              };
+            }
+            default:
+              return {
+                success: false,
+                output: "",
+                error: `Unsupported format: ${format}`,
+                durationMs: performance.now() - start
+              };
+          }
+        } catch (error) {
+          return {
+            success: false,
+            output: "",
+            error: error instanceof Error ? error.message : String(error),
             durationMs: performance.now() - start
           };
         }
@@ -5353,6 +6267,9 @@ var init_dist2 = __esm({
     init_tool_creator();
     init_skill_tools();
     init_transcribe_tool();
+    init_structured_file();
+    init_code_sandbox();
+    init_structured_read();
     init_shellRunner();
     init_gitWorktree();
     init_patchApplier();
@@ -6467,8 +7384,8 @@ var init_code_retriever = __esm({
         });
       }
       async getFileContent(filePath, startLine, endLine) {
-        const { readFile: readFile10 } = await import("node:fs/promises");
-        const content = await readFile10(filePath, "utf-8");
+        const { readFile: readFile11 } = await import("node:fs/promises");
+        const content = await readFile11(filePath, "utf-8");
         if (startLine === void 0)
           return content;
         const lines = content.split("\n");
@@ -6483,8 +7400,8 @@ var init_code_retriever = __esm({
 // packages/retrieval/dist/lexicalSearch.js
 import { execFile as execFile4 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
-import { readFile as readFile7, readdir, stat } from "node:fs/promises";
-import { join as join14, extname as extname4 } from "node:path";
+import { readFile as readFile8, readdir as readdir2, stat as stat3 } from "node:fs/promises";
+import { join as join15, extname as extname6 } from "node:path";
 async function searchByPath(pathPattern, options) {
   const allFiles = await collectFiles(options.rootDir, options.includeGlobs ?? DEFAULT_INCLUDE_GLOBS, options.excludeGlobs ?? DEFAULT_EXCLUDE_GLOBS);
   const pattern = options.caseInsensitive ? pathPattern.toLowerCase() : pathPattern;
@@ -6589,7 +7506,7 @@ async function searchWithNodeFallback(pattern, kind, options) {
     if (results.length >= maxMatches)
       break;
     try {
-      const content = await readFile7(filePath, "utf-8");
+      const content = await readFile8(filePath, "utf-8");
       const contentLines = content.split("\n");
       for (let i = 0; i < contentLines.length; i++) {
         if (results.length >= maxMatches)
@@ -6617,7 +7534,7 @@ async function collectFiles(rootDir, includeGlobs, excludeGlobs) {
 async function walkForFiles(rootDir, dir, excludeGlobs, results) {
   let entries;
   try {
-    entries = await readdir(dir, { withFileTypes: true, encoding: "utf-8" });
+    entries = await readdir2(dir, { withFileTypes: true, encoding: "utf-8" });
   } catch {
     return;
   }
@@ -6626,16 +7543,16 @@ async function walkForFiles(rootDir, dir, excludeGlobs, results) {
       continue;
     if (excludeGlobs.some((g) => entry.name === g || matchesGlob(entry.name, g)))
       continue;
-    const absPath = join14(dir, entry.name);
+    const absPath = join15(dir, entry.name);
     if (entry.isDirectory()) {
       await walkForFiles(rootDir, absPath, excludeGlobs, results);
     } else if (entry.isFile()) {
-      const ext = extname4(entry.name);
+      const ext = extname6(entry.name);
       if (!ALL_CODE_EXTS.has(ext))
         continue;
       const relativePath = absPath.startsWith(rootDir) ? absPath.slice(rootDir.length).replace(/^\//, "") : absPath;
       try {
-        const s = await stat(absPath);
+        const s = await stat3(absPath);
         if (s.size > 2e6)
           continue;
       } catch {
@@ -6800,8 +7717,8 @@ var init_graphExpand = __esm({
 });
 
 // packages/retrieval/dist/snippetPacker.js
-import { readFile as readFile8 } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { readFile as readFile9 } from "node:fs/promises";
+import { join as join16 } from "node:path";
 async function packSnippets(requests, opts = {}) {
   const maxTokens = opts.maxTokens ?? DEFAULT_MAX_TOKENS;
   const contextLines = opts.contextLines ?? DEFAULT_CONTEXT_LINES;
@@ -6827,10 +7744,10 @@ async function packSnippets(requests, opts = {}) {
   return { packed, dropped, totalTokens };
 }
 async function extractSnippet(req, repoRoot, contextLines = DEFAULT_CONTEXT_LINES) {
-  const absPath = req.filePath.startsWith("/") ? req.filePath : join15(repoRoot, req.filePath);
+  const absPath = req.filePath.startsWith("/") ? req.filePath : join16(repoRoot, req.filePath);
   let content;
   try {
-    content = await readFile8(absPath, "utf-8");
+    content = await readFile9(absPath, "utf-8");
   } catch {
     return null;
   }
@@ -8697,14 +9614,14 @@ ${result.output}`;
       waitForSudoPassword(timeoutMs = 12e4) {
         if (this._sudoPassword)
           return Promise.resolve(this._sudoPassword);
-        return new Promise((resolve16) => {
+        return new Promise((resolve18) => {
           const timer = setTimeout(() => {
             this._sudoResolve = null;
-            resolve16(null);
+            resolve18(null);
           }, timeoutMs);
           this._sudoResolve = (pw) => {
             clearTimeout(timer);
-            resolve16(pw);
+            resolve18(pw);
           };
         });
       }
@@ -9332,6 +10249,489 @@ ${newerSummary}` : newerSummary;
   }
 });
 
+// packages/orchestrator/dist/costTracker.js
+var DEFAULT_PRICING, CostTracker;
+var init_costTracker = __esm({
+  "packages/orchestrator/dist/costTracker.js"() {
+    "use strict";
+    DEFAULT_PRICING = [
+      // Cloud providers — typical pricing tiers
+      { providerId: "openai", label: "OpenAI", inputPer1M: 2.5, outputPer1M: 10 },
+      { providerId: "together", label: "Together AI", inputPer1M: 0.8, outputPer1M: 0.8 },
+      { providerId: "groq", label: "Groq", inputPer1M: 0.05, outputPer1M: 0.1 },
+      { providerId: "openrouter", label: "OpenRouter", inputPer1M: 1, outputPer1M: 2 },
+      { providerId: "fireworks", label: "Fireworks AI", inputPer1M: 0.2, outputPer1M: 0.8 },
+      { providerId: "deepinfra", label: "DeepInfra", inputPer1M: 0.1, outputPer1M: 0.4 },
+      { providerId: "mistral", label: "Mistral AI", inputPer1M: 0.5, outputPer1M: 1.5 },
+      { providerId: "chutes", label: "Chutes AI", inputPer1M: 0.2, outputPer1M: 0.8 },
+      { providerId: "cerebras", label: "Cerebras", inputPer1M: 0.1, outputPer1M: 0.1 },
+      { providerId: "sambanova", label: "SambaNova", inputPer1M: 0.1, outputPer1M: 0.4 },
+      { providerId: "nvidia", label: "NVIDIA NIM", inputPer1M: 0.3, outputPer1M: 1.2 },
+      { providerId: "hyperbolic", label: "Hyperbolic", inputPer1M: 0.1, outputPer1M: 0.3 },
+      // Local providers — free (no token cost)
+      { providerId: "ollama", label: "Ollama (local)", inputPer1M: 0, outputPer1M: 0 },
+      { providerId: "lmstudio", label: "LM Studio (local)", inputPer1M: 0, outputPer1M: 0 },
+      { providerId: "vllm", label: "vLLM (local)", inputPer1M: 0, outputPer1M: 0 }
+    ];
+    CostTracker = class {
+      pricing;
+      tasks = [];
+      sessionStartedAt;
+      // Running totals
+      _totalInputTokens = 0;
+      _totalOutputTokens = 0;
+      _totalEstimatedCost = 0;
+      // Current task accumulator
+      _currentTask = null;
+      _currentInputTokens = 0;
+      _currentOutputTokens = 0;
+      _currentStartedAt = "";
+      _currentStartMs = 0;
+      constructor(providerId, customPricing) {
+        this.sessionStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+        this.pricing = customPricing ?? DEFAULT_PRICING.find((p) => p.providerId === providerId) ?? { providerId: providerId ?? "unknown", label: "Unknown", inputPer1M: 0, outputPer1M: 0 };
+      }
+      /** Get the current provider pricing */
+      get provider() {
+        return this.pricing;
+      }
+      /** Update provider (e.g., when user switches endpoint) */
+      setProvider(providerId, customPricing) {
+        this.pricing = customPricing ?? DEFAULT_PRICING.find((p) => p.providerId === providerId) ?? { providerId, label: "Unknown", inputPer1M: 0, outputPer1M: 0 };
+      }
+      /** Start tracking a new task */
+      startTask(taskDescription) {
+        if (this._currentTask) {
+          this.endTask();
+        }
+        this._currentTask = taskDescription;
+        this._currentInputTokens = 0;
+        this._currentOutputTokens = 0;
+        this._currentStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+        this._currentStartMs = Date.now();
+      }
+      /** Record token usage from an API response */
+      trackTokens(inputTokens, outputTokens) {
+        this._currentInputTokens += inputTokens;
+        this._currentOutputTokens += outputTokens;
+        this._totalInputTokens += inputTokens;
+        this._totalOutputTokens += outputTokens;
+        const cost = this.calculateCost(inputTokens, outputTokens);
+        this._totalEstimatedCost += cost;
+      }
+      /** End current task and record it */
+      endTask() {
+        if (!this._currentTask)
+          return null;
+        const cost = this.calculateCost(this._currentInputTokens, this._currentOutputTokens);
+        const record = {
+          task: this._currentTask,
+          inputTokens: this._currentInputTokens,
+          outputTokens: this._currentOutputTokens,
+          estimatedCost: cost,
+          durationMs: Date.now() - this._currentStartMs,
+          startedAt: this._currentStartedAt
+        };
+        this.tasks.push(record);
+        this._currentTask = null;
+        return record;
+      }
+      /** Calculate cost for a given token usage */
+      calculateCost(inputTokens, outputTokens) {
+        return inputTokens / 1e6 * this.pricing.inputPer1M + outputTokens / 1e6 * this.pricing.outputPer1M;
+      }
+      /** Get current running cost estimate */
+      get currentCost() {
+        return this._totalEstimatedCost;
+      }
+      /** Get total input tokens */
+      get totalInputTokens() {
+        return this._totalInputTokens;
+      }
+      /** Get total output tokens */
+      get totalOutputTokens() {
+        return this._totalOutputTokens;
+      }
+      /** Whether this provider has non-zero pricing */
+      get hasPricing() {
+        return this.pricing.inputPer1M > 0 || this.pricing.outputPer1M > 0;
+      }
+      /** Format cost as a readable string */
+      formatCost(cost) {
+        const c3 = cost ?? this._totalEstimatedCost;
+        if (c3 < 0.01)
+          return `$${c3.toFixed(4)}`;
+        if (c3 < 1)
+          return `$${c3.toFixed(3)}`;
+        return `$${c3.toFixed(2)}`;
+      }
+      /** Get full session summary */
+      getSummary() {
+        const pendingRecord = this._currentTask ? {
+          task: this._currentTask,
+          inputTokens: this._currentInputTokens,
+          outputTokens: this._currentOutputTokens,
+          estimatedCost: this.calculateCost(this._currentInputTokens, this._currentOutputTokens),
+          durationMs: Date.now() - this._currentStartMs,
+          startedAt: this._currentStartedAt
+        } : null;
+        const allTasks = pendingRecord ? [...this.tasks, pendingRecord] : [...this.tasks];
+        return {
+          totalInputTokens: this._totalInputTokens,
+          totalOutputTokens: this._totalOutputTokens,
+          totalEstimatedCost: this._totalEstimatedCost,
+          taskCount: allTasks.length,
+          tasks: allTasks,
+          provider: this.pricing.label,
+          sessionStartedAt: this.sessionStartedAt,
+          sessionDurationMs: Date.now() - new Date(this.sessionStartedAt).getTime()
+        };
+      }
+      /** Reset all tracking (e.g., new session) */
+      reset() {
+        this.tasks = [];
+        this._totalInputTokens = 0;
+        this._totalOutputTokens = 0;
+        this._totalEstimatedCost = 0;
+        this._currentTask = null;
+        this.sessionStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+    };
+  }
+});
+
+// packages/orchestrator/dist/workEvaluator.js
+function detectTaskType(taskDescription) {
+  let bestType = "general";
+  let bestScore = 0;
+  for (const { type, patterns } of TASK_TYPE_PATTERNS) {
+    let score = 0;
+    for (const p of patterns) {
+      if (p.test(taskDescription))
+        score++;
+    }
+    if (score > bestScore) {
+      bestScore = score;
+      bestType = type;
+    }
+  }
+  return bestType;
+}
+function getRubric(taskType) {
+  return RUBRICS[taskType];
+}
+function buildEvaluationPrompt(task, summary, rubric) {
+  const dimensionList = rubric.dimensions.map((d, i) => `${i + 1}. **${d.name}** (${Math.round(d.weight * 100)}%): ${d.criteria}`).join("\n");
+  return `You are a quality evaluator. Score the following completed work on these dimensions.
+
+## Task
+${task}
+
+## Completed Work Summary
+${summary}
+
+## Scoring Dimensions (${rubric.label} task)
+${dimensionList}
+
+## Instructions
+For each dimension, provide:
+1. A score from 0-10 (0 = completely missing, 5 = adequate, 10 = exceptional)
+2. A brief explanation (1-2 sentences)
+
+Then provide an overall summary of the work quality.
+
+Respond in EXACTLY this JSON format:
+{
+  "dimensions": [
+    {"name": "${rubric.dimensions[0].name}", "score": <0-10>, "feedback": "<explanation>"},
+    {"name": "${rubric.dimensions[1].name}", "score": <0-10>, "feedback": "<explanation>"},
+    {"name": "${rubric.dimensions[2].name}", "score": <0-10>, "feedback": "<explanation>"},
+    {"name": "${rubric.dimensions[3].name}", "score": <0-10>, "feedback": "<explanation>"}
+  ],
+  "summary": "<2-3 sentence overall assessment>"
+}
+
+Respond with ONLY the JSON object, no other text.`;
+}
+var RUBRICS, TASK_TYPE_PATTERNS, WorkEvaluator;
+var init_workEvaluator = __esm({
+  "packages/orchestrator/dist/workEvaluator.js"() {
+    "use strict";
+    RUBRICS = {
+      code: {
+        type: "code",
+        label: "Code",
+        dimensions: [
+          { name: "Completeness", weight: 0.4, criteria: "All requested features implemented. Tests written if applicable. No missing edge cases." },
+          { name: "Correctness", weight: 0.3, criteria: "Code compiles/runs without errors. Tests pass. Logic is sound. No bugs or regressions." },
+          { name: "Quality", weight: 0.2, criteria: "Clean, readable code. Follows existing conventions. Appropriate naming. No unnecessary complexity." },
+          { name: "Domain", weight: 0.1, criteria: "Follows language/framework best practices. Proper error handling. Security considerations." }
+        ]
+      },
+      document: {
+        type: "document",
+        label: "Document",
+        dimensions: [
+          { name: "Completeness", weight: 0.4, criteria: "All required sections present. Covers the full scope. No gaps in coverage." },
+          { name: "Correctness", weight: 0.3, criteria: "Factually accurate. No fabrications. Sources cited where applicable." },
+          { name: "Quality", weight: 0.2, criteria: "Well-structured. Clear writing. Professional formatting. Good flow." },
+          { name: "Domain", weight: 0.1, criteria: "Follows document type conventions. Appropriate tone and terminology." }
+        ]
+      },
+      analysis: {
+        type: "analysis",
+        label: "Analysis",
+        dimensions: [
+          { name: "Completeness", weight: 0.4, criteria: "All data considered. Methodology explained. Conclusions cover key findings." },
+          { name: "Correctness", weight: 0.3, criteria: "Calculations accurate. Logic sound. No errors in reasoning or data interpretation." },
+          { name: "Quality", weight: 0.2, criteria: "Clear presentation. Data visualized where helpful. Executive summary included." },
+          { name: "Domain", weight: 0.1, criteria: "Follows analytical best practices. Appropriate statistical methods. Caveats noted." }
+        ]
+      },
+      plan: {
+        type: "plan",
+        label: "Plan",
+        dimensions: [
+          { name: "Completeness", weight: 0.4, criteria: "All phases covered. Timeline realistic. Resources identified. Risks addressed." },
+          { name: "Correctness", weight: 0.3, criteria: "Dependencies accurate. Estimates reasonable. Constraints respected." },
+          { name: "Quality", weight: 0.2, criteria: "Actionable steps. Clear ownership. Measurable milestones. Well-organized." },
+          { name: "Domain", weight: 0.1, criteria: "Follows project management best practices. Appropriate methodology for scope." }
+        ]
+      },
+      general: {
+        type: "general",
+        label: "General",
+        dimensions: [
+          { name: "Completeness", weight: 0.4, criteria: "All aspects of the request addressed. Nothing missing or incomplete." },
+          { name: "Correctness", weight: 0.3, criteria: "Accurate and factual. No errors or inconsistencies." },
+          { name: "Quality", weight: 0.2, criteria: "Well-structured. Clear communication. Professional output." },
+          { name: "Domain", weight: 0.1, criteria: "Appropriate for the context. Follows relevant conventions." }
+        ]
+      }
+    };
+    TASK_TYPE_PATTERNS = [
+      {
+        type: "code",
+        patterns: [
+          /\b(fix|implement|refactor|debug|test|code|function|class|module|api|bug|feature|PR|commit|build|compile|lint)\b/i,
+          /\.(ts|js|py|rs|go|java|cpp|rb|php|swift)\b/i
+        ]
+      },
+      {
+        type: "document",
+        patterns: [
+          /\b(write|draft|document|report|article|blog|readme|guide|manual|specification|proposal|email|letter)\b/i,
+          /\.(md|doc|docx|pdf|txt)\b/i
+        ]
+      },
+      {
+        type: "analysis",
+        patterns: [
+          /\b(analyze|research|evaluate|compare|assess|review|audit|benchmark|metric|data|statistic|trend)\b/i
+        ]
+      },
+      {
+        type: "plan",
+        patterns: [
+          /\b(plan|schedule|roadmap|strategy|design|architect|timeline|milestone|sprint|backlog|estimate)\b/i
+        ]
+      }
+    ];
+    WorkEvaluator = class {
+      backend;
+      constructor(backend) {
+        this.backend = backend ?? null;
+      }
+      /** Set or update the evaluation backend */
+      setBackend(backend) {
+        this.backend = backend;
+      }
+      /** Evaluate completed work */
+      async evaluate(task, summary, taskType) {
+        if (!this.backend) {
+          return {
+            overallScore: 0,
+            dimensions: [],
+            feedback: "No evaluation backend configured.",
+            taskType: taskType ?? "general",
+            success: false,
+            error: "No evaluation backend configured"
+          };
+        }
+        const detectedType = taskType ?? detectTaskType(task);
+        const rubric = getRubric(detectedType);
+        const prompt = buildEvaluationPrompt(task, summary, rubric);
+        try {
+          const response = await this.backend.evaluate(prompt);
+          return this.parseResponse(response, rubric, detectedType);
+        } catch (err) {
+          return {
+            overallScore: 0,
+            dimensions: [],
+            feedback: `Evaluation failed: ${err instanceof Error ? err.message : String(err)}`,
+            taskType: detectedType,
+            success: false,
+            error: err instanceof Error ? err.message : String(err)
+          };
+        }
+      }
+      /** Parse the LLM's JSON response into an EvaluationResult */
+      parseResponse(response, rubric, taskType) {
+        try {
+          let jsonStr = response.trim();
+          const jsonMatch = jsonStr.match(/```(?:json)?\s*([\s\S]*?)```/);
+          if (jsonMatch) {
+            jsonStr = jsonMatch[1].trim();
+          }
+          if (!jsonStr.startsWith("{")) {
+            const braceMatch = jsonStr.match(/\{[\s\S]*\}/);
+            if (braceMatch)
+              jsonStr = braceMatch[0];
+          }
+          const parsed = JSON.parse(jsonStr);
+          if (!parsed.dimensions || !Array.isArray(parsed.dimensions)) {
+            throw new Error("Missing dimensions array in response");
+          }
+          const dimensions = rubric.dimensions.map((rd, i) => {
+            const pd = parsed.dimensions[i];
+            const score = Math.max(0, Math.min(10, pd?.score ?? 0));
+            return {
+              name: rd.name,
+              weight: rd.weight,
+              score,
+              feedback: pd?.feedback ?? ""
+            };
+          });
+          const overallScore = dimensions.reduce((sum, d) => sum + d.score / 10 * d.weight, 0);
+          return {
+            overallScore,
+            dimensions,
+            feedback: parsed.summary ?? "",
+            taskType,
+            success: true
+          };
+        } catch (err) {
+          return {
+            overallScore: 0,
+            dimensions: [],
+            feedback: `Failed to parse evaluation response: ${err instanceof Error ? err.message : String(err)}`,
+            taskType,
+            success: false,
+            error: `Parse error: ${err instanceof Error ? err.message : String(err)}`
+          };
+        }
+      }
+    };
+  }
+});
+
+// packages/orchestrator/dist/sessionMetrics.js
+var SessionMetrics;
+var init_sessionMetrics = __esm({
+  "packages/orchestrator/dist/sessionMetrics.js"() {
+    "use strict";
+    SessionMetrics = class {
+      sessionStart;
+      turns = 0;
+      toolCalls = 0;
+      toolCallsByName = {};
+      inputTokens = 0;
+      outputTokens = 0;
+      filesModified = /* @__PURE__ */ new Set();
+      tasks = [];
+      currentTask = null;
+      constructor() {
+        this.sessionStart = Date.now();
+      }
+      /** Record a new turn (assistant response). */
+      recordTurn() {
+        this.turns++;
+      }
+      /** Record a tool call. */
+      recordToolCall(toolName) {
+        this.toolCalls++;
+        this.toolCallsByName[toolName] = (this.toolCallsByName[toolName] ?? 0) + 1;
+        if (this.currentTask) {
+          this.currentTask.toolCalls++;
+        }
+      }
+      /** Record token usage. */
+      recordTokenUsage(inputTokens, outputTokens) {
+        this.inputTokens += inputTokens;
+        this.outputTokens += outputTokens;
+      }
+      /** Record a file modification. */
+      recordFileModified(filePath) {
+        this.filesModified.add(filePath);
+      }
+      /** Start tracking a new task. */
+      startTask(description) {
+        this.currentTask = {
+          description,
+          startTime: Date.now(),
+          toolCalls: 0
+        };
+      }
+      /** End the current task with optional evaluation score. */
+      endTask(evaluationScore) {
+        if (this.currentTask) {
+          this.currentTask.endTime = Date.now();
+          this.currentTask.durationMs = this.currentTask.endTime - this.currentTask.startTime;
+          if (evaluationScore !== void 0) {
+            this.currentTask.evaluationScore = evaluationScore;
+          }
+          this.tasks.push(this.currentTask);
+          this.currentTask = null;
+        }
+      }
+      /** Get current session summary. */
+      getSummary() {
+        const now = Date.now();
+        const evalScores = this.tasks.filter((t) => t.evaluationScore !== void 0).map((t) => t.evaluationScore);
+        return {
+          sessionStartTime: this.sessionStart,
+          sessionDurationMs: now - this.sessionStart,
+          totalTurns: this.turns,
+          totalToolCalls: this.toolCalls,
+          toolCallsByName: { ...this.toolCallsByName },
+          totalInputTokens: this.inputTokens,
+          totalOutputTokens: this.outputTokens,
+          filesModified: [...this.filesModified],
+          tasksCompleted: this.tasks.length,
+          tasks: [...this.tasks],
+          averageEvalScore: evalScores.length > 0 ? evalScores.reduce((a, b) => a + b, 0) / evalScores.length : void 0
+        };
+      }
+      /** Get the most-used tools (sorted by count). */
+      getTopTools(limit = 5) {
+        return Object.entries(this.toolCallsByName).sort((a, b) => b[1] - a[1]).slice(0, limit).map(([name, count]) => ({ name, count }));
+      }
+      /** Format duration in human-readable form. */
+      static formatDuration(ms) {
+        if (ms < 1e3)
+          return `${ms}ms`;
+        const seconds = Math.floor(ms / 1e3);
+        if (seconds < 60)
+          return `${seconds}s`;
+        const minutes = Math.floor(seconds / 60);
+        const remainingSecs = seconds % 60;
+        if (minutes < 60)
+          return `${minutes}m ${remainingSecs}s`;
+        const hours = Math.floor(minutes / 60);
+        const remainingMins = minutes % 60;
+        return `${hours}h ${remainingMins}m`;
+      }
+    };
+  }
+});
+
+// packages/orchestrator/dist/taskLearning.js
+var init_taskLearning = __esm({
+  "packages/orchestrator/dist/taskLearning.js"() {
+    "use strict";
+  }
+});
+
 // packages/orchestrator/dist/index.js
 var init_dist5 = __esm({
   "packages/orchestrator/dist/index.js"() {
@@ -9347,13 +10747,17 @@ var init_dist5 = __esm({
     init_mergeRunner();
     init_retryController();
     init_agenticRunner();
+    init_costTracker();
+    init_workEvaluator();
+    init_sessionMetrics();
+    init_taskLearning();
   }
 });
 
 // packages/cli/dist/tui/listen.js
-import { spawn as spawn5, execSync as execSync9 } from "node:child_process";
+import { spawn as spawn6, execSync as execSync9 } from "node:child_process";
 import { existsSync as existsSync11, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 import { homedir as homedir6 } from "node:os";
 import { EventEmitter } from "node:events";
 function isAudioPath(path) {
@@ -9444,16 +10848,16 @@ function ensureTranscribeCliBackground() {
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      if (existsSync11(join16(globalRoot, "transcribe-cli", "dist", "index.js"))) {
+      if (existsSync11(join17(globalRoot, "transcribe-cli", "dist", "index.js"))) {
         return true;
       }
     } catch {
     }
     try {
       const { exec } = await import("node:child_process");
-      return new Promise((resolve16) => {
+      return new Promise((resolve18) => {
         exec("npm i -g transcribe-cli", { timeout: 18e4 }, (err) => {
-          resolve16(!err);
+          resolve18(!err);
         });
       });
     } catch {
@@ -9568,24 +10972,24 @@ var init_listen = __esm({
             timeout: 5e3,
             stdio: ["pipe", "pipe", "pipe"]
           }).trim();
-          const tcPath = join16(globalRoot, "transcribe-cli");
-          if (existsSync11(join16(tcPath, "dist", "index.js"))) {
+          const tcPath = join17(globalRoot, "transcribe-cli");
+          if (existsSync11(join17(tcPath, "dist", "index.js"))) {
             const { createRequire: createRequire4 } = await import("node:module");
             const req = createRequire4(import.meta.url);
-            return req(join16(tcPath, "dist", "index.js"));
+            return req(join17(tcPath, "dist", "index.js"));
           }
         } catch {
         }
-        const nvmBase = join16(homedir6(), ".nvm", "versions", "node");
+        const nvmBase = join17(homedir6(), ".nvm", "versions", "node");
         if (existsSync11(nvmBase)) {
           try {
             const { readdirSync: readdirSync9 } = await import("node:fs");
             for (const ver of readdirSync9(nvmBase)) {
-              const tcPath = join16(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
-              if (existsSync11(join16(tcPath, "dist", "index.js"))) {
+              const tcPath = join17(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
+              if (existsSync11(join17(tcPath, "dist", "index.js"))) {
                 const { createRequire: createRequire4 } = await import("node:module");
                 const req = createRequire4(import.meta.url);
-                return req(join16(tcPath, "dist", "index.js"));
+                return req(join17(tcPath, "dist", "index.js"));
               }
             }
           } catch {
@@ -9646,18 +11050,18 @@ var init_listen = __esm({
         this.liveTranscriber.on("error", (err) => {
           this.emit("error", err);
         });
-        await new Promise((resolve16, reject) => {
+        await new Promise((resolve18, reject) => {
           const timeout = setTimeout(() => reject(new Error("Model load timeout (60s)")), 6e4);
           this.liveTranscriber.on("ready", () => {
             clearTimeout(timeout);
-            resolve16();
+            resolve18();
           });
           this.liveTranscriber.on("error", (err) => {
             clearTimeout(timeout);
             reject(err);
           });
         });
-        this.micProcess = spawn5(micCmd.cmd, micCmd.args, {
+        this.micProcess = spawn6(micCmd.cmd, micCmd.args, {
           stdio: ["pipe", "pipe", "pipe"],
           env: { ...process.env }
         });
@@ -9768,9 +11172,9 @@ var init_listen = __esm({
           });
           if (outputDir) {
             const { basename: basename8 } = await import("node:path");
-            const transcriptDir = join16(outputDir, ".oa", "transcripts");
+            const transcriptDir = join17(outputDir, ".oa", "transcripts");
             mkdirSync5(transcriptDir, { recursive: true });
-            const outFile = join16(transcriptDir, `${basename8(filePath)}.txt`);
+            const outFile = join17(transcriptDir, `${basename8(filePath)}.txt`);
             writeFileSync5(outFile, result.text, "utf-8");
           }
           return {
@@ -9835,6 +11239,53 @@ async function fetchOllamaModels(baseUrl) {
     parameterSize: m.details?.parameter_size
   })).sort((a, b) => b.sizeBytes - a.sizeBytes);
 }
+async function fetchOpenAIModels(baseUrl, apiKey) {
+  const normalized = normalizeBaseUrl(baseUrl);
+  const url = `${normalized}/v1/models`;
+  const headers = {};
+  if (apiKey) {
+    headers["Authorization"] = `Bearer ${apiKey}`;
+  }
+  const resp = await fetch(url, {
+    headers,
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!resp.ok) {
+    throw new Error(`Failed to fetch models: HTTP ${resp.status}`);
+  }
+  const data = await resp.json();
+  const models = data.data ?? [];
+  return models.map((m) => ({
+    name: m.id,
+    size: m.context_length ? `${Math.round(m.context_length / 1024)}K ctx` : m.max_model_len ? `${Math.round(m.max_model_len / 1024)}K ctx` : "",
+    sizeBytes: 0,
+    modified: m.created ? formatRelativeTime(new Date(m.created * 1e3).toISOString()) : "",
+    parameterSize: m.owned_by ?? void 0
+  })).sort((a, b) => a.name.localeCompare(b.name));
+}
+async function fetchModels(baseUrl, apiKey) {
+  const provider = detectProvider(baseUrl);
+  if (provider.id === "ollama") {
+    try {
+      return await fetchOllamaModels(baseUrl);
+    } catch {
+      try {
+        return await fetchOpenAIModels(baseUrl, apiKey);
+      } catch {
+        throw new Error("Cannot reach Ollama at " + baseUrl);
+      }
+    }
+  }
+  try {
+    return await fetchOpenAIModels(baseUrl, apiKey);
+  } catch {
+    try {
+      return await fetchOllamaModels(baseUrl);
+    } catch {
+      throw new Error(`Cannot fetch models from ${provider.label} at ${baseUrl}`);
+    }
+  }
+}
 function findModel(models, query) {
   const exact = models.find((m) => m.name === query);
   if (exact)
@@ -10330,6 +11781,10 @@ function renderSlashHelp() {
     ["/listen confirm", "Require Enter to submit transcription"],
     ["/listen auto", "Auto-submit after 3s silence (blinking \u25CF indicator)"],
     ["/listen stop", "Stop listening"],
+    ["/cost", "Show session token cost breakdown"],
+    ["/evaluate", "Evaluate last completed task (LLM quality scoring)"],
+    ["/task-type", "Set task type (code, document, analysis, plan, general, auto)"],
+    ["/stats", "Show session dashboard (metrics, tool usage, task history)"],
     ["/bruteforce", "Toggle brute-force mode (auto re-engage on turn limit)"],
     ["/tools", "List agent-created custom tools"],
     ["/skills", "List available AIWG skills"],
@@ -10708,22 +12163,215 @@ var init_render = __esm({
   }
 });
 
+// packages/prompts/dist/loader.js
+var init_loader = __esm({
+  "packages/prompts/dist/loader.js"() {
+    "use strict";
+  }
+});
+
+// packages/prompts/dist/render.js
+var init_render2 = __esm({
+  "packages/prompts/dist/render.js"() {
+    "use strict";
+  }
+});
+
+// packages/prompts/dist/task-templates.js
+function getTaskTemplate(type) {
+  return TEMPLATES[type];
+}
+function getTaskTypes() {
+  return Object.keys(TEMPLATES);
+}
+function buildTaskContext(type) {
+  const template = TEMPLATES[type];
+  return `${template.systemPromptAddition}
+
+### Output Guidance
+${template.outputGuidance}`;
+}
+var TEMPLATES;
+var init_task_templates = __esm({
+  "packages/prompts/dist/task-templates.js"() {
+    "use strict";
+    TEMPLATES = {
+      code: {
+        type: "code",
+        label: "Software Development",
+        description: "Writing, debugging, refactoring, or reviewing code.",
+        systemPromptAddition: `
+## Task Context: Software Development
+
+You are working on a software development task. Follow these principles:
+
+- **Read before writing**: Always read the existing code and understand the context before making changes.
+- **Test-driven approach**: Run existing tests first, make changes, then verify tests still pass.
+- **Minimal changes**: Make the smallest change that solves the problem. Avoid refactoring unrelated code.
+- **Convention adherence**: Match the existing code style, naming conventions, and patterns in the project.
+- **Error handling**: Ensure proper error handling and edge case coverage.
+- **File organization**: Follow the existing project structure when adding new files.
+
+When the task is complete, verify by running tests and/or type-checking where available.`,
+        recommendedTools: [
+          "file_read",
+          "file_write",
+          "file_edit",
+          "shell",
+          "grep_search",
+          "glob_find",
+          "git_info",
+          "codebase_map"
+        ],
+        outputGuidance: "Deliver working code with tests passing. Summarize what was changed and why."
+      },
+      document: {
+        type: "document",
+        label: "Document Drafting",
+        description: "Creating reports, specifications, guides, proposals, or other professional documents.",
+        systemPromptAddition: `
+## Task Context: Document Drafting
+
+You are working on a professional document. Follow these principles:
+
+- **Audience awareness**: Tailor language, depth, and terminology to the intended audience.
+- **Structure first**: Create a clear outline before filling in content. Use headings, sections, and lists.
+- **Completeness**: Cover all aspects the user requested. Flag any areas where you need clarification.
+- **Clarity**: Use clear, concise language. Avoid jargon unless appropriate for the audience.
+- **Formatting**: Use appropriate markdown formatting \u2014 tables for data, code blocks for technical content, lists for enumerations.
+- **Citations**: When referencing external information, note sources or indicate where citations are needed.
+
+Use the create_structured_file tool for spreadsheets, CSV, or formatted output. Use file_write for documents.`,
+        recommendedTools: [
+          "file_read",
+          "file_write",
+          "web_search",
+          "web_fetch",
+          "create_structured_file",
+          "memory_read"
+        ],
+        outputGuidance: "Deliver a complete, well-structured document. Specify the output format (Markdown, PDF, etc.)."
+      },
+      analysis: {
+        type: "analysis",
+        label: "Analysis & Research",
+        description: "Analyzing data, evaluating options, conducting research, or producing insights.",
+        systemPromptAddition: `
+## Task Context: Analysis & Research
+
+You are working on an analytical task. Follow these principles:
+
+- **Evidence-based**: Ground conclusions in data, code, or verifiable sources. Avoid speculation.
+- **Methodology**: State your analytical approach clearly. When comparing options, define criteria upfront.
+- **Quantify**: Use numbers, metrics, and measurements wherever possible. Avoid vague qualifiers.
+- **Visualization**: Present data in tables or structured formats for clarity.
+- **Limitations**: Acknowledge limitations in your analysis \u2014 data gaps, assumptions, scope boundaries.
+- **Actionable conclusions**: End with clear recommendations or next steps.
+
+Use web_search for external research. Use grep_search and codebase_map for codebase analysis.
+Use create_structured_file to output data as CSV, JSON, or markdown tables.`,
+        recommendedTools: [
+          "file_read",
+          "grep_search",
+          "glob_find",
+          "web_search",
+          "web_fetch",
+          "codebase_map",
+          "create_structured_file",
+          "shell"
+        ],
+        outputGuidance: "Deliver a structured analysis with findings, data tables, and actionable recommendations."
+      },
+      plan: {
+        type: "plan",
+        label: "Planning & Design",
+        description: "Creating project plans, system designs, architecture proposals, or roadmaps.",
+        systemPromptAddition: `
+## Task Context: Planning & Design
+
+You are working on a planning or design task. Follow these principles:
+
+- **Scope clarity**: Define what is in-scope and out-of-scope explicitly.
+- **Phased approach**: Break work into phases or milestones with clear dependencies.
+- **Risk identification**: Identify key risks, assumptions, and dependencies for each phase.
+- **Resource awareness**: Consider team size, skill requirements, and tool/infrastructure needs.
+- **Alternatives**: When making design decisions, briefly note alternatives considered and why the chosen approach is preferred.
+- **Actionable items**: Every section should include concrete next steps or action items.
+- **Traceability**: Link plan items to requirements or goals where applicable.
+
+Use codebase_map and grep_search to understand existing architecture.
+Use create_structured_file for timeline/schedule output.`,
+        recommendedTools: [
+          "file_read",
+          "grep_search",
+          "glob_find",
+          "codebase_map",
+          "web_search",
+          "create_structured_file",
+          "file_write",
+          "git_info"
+        ],
+        outputGuidance: "Deliver a structured plan with phases, milestones, risks, and action items."
+      },
+      general: {
+        type: "general",
+        label: "General Task",
+        description: "Tasks that don't clearly fit another category.",
+        systemPromptAddition: `
+## Task Context: General
+
+Approach this task thoughtfully:
+
+- **Clarify intent**: If the task is ambiguous, use available tools to gather context before proceeding.
+- **Appropriate tools**: Select the right tools for the job \u2014 file tools for file work, search for research, shell for commands.
+- **Quality output**: Regardless of task type, produce clear, complete, and well-organized output.
+- **Verify results**: After completing work, verify the results are correct and complete.`,
+        recommendedTools: [
+          "file_read",
+          "file_write",
+          "shell",
+          "grep_search",
+          "web_search",
+          "memory_read"
+        ],
+        outputGuidance: "Deliver complete results with a clear summary of what was done."
+      }
+    };
+  }
+});
+
+// packages/prompts/dist/index.js
+import { join as join18, dirname as dirname4 } from "node:path";
+import { fileURLToPath } from "node:url";
+var _dir, _packageRoot;
+var init_dist6 = __esm({
+  "packages/prompts/dist/index.js"() {
+    "use strict";
+    init_loader();
+    init_render2();
+    init_task_templates();
+    init_render2();
+    _dir = dirname4(fileURLToPath(import.meta.url));
+    _packageRoot = join18(_dir, "..");
+  }
+});
+
 // packages/cli/dist/tui/oa-directory.js
 import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync6, readdirSync as readdirSync6, statSync as statSync5, unlinkSync as unlinkSync2 } from "node:fs";
-import { join as join17, relative as relative2, basename as basename4, extname as extname5 } from "node:path";
+import { join as join19, relative as relative2, basename as basename4, extname as extname7 } from "node:path";
 import { homedir as homedir7 } from "node:os";
 function initOaDirectory(repoRoot) {
-  const oaPath = join17(repoRoot, OA_DIR);
+  const oaPath = join19(repoRoot, OA_DIR);
   for (const sub of SUBDIRS) {
-    mkdirSync6(join17(oaPath, sub), { recursive: true });
+    mkdirSync6(join19(oaPath, sub), { recursive: true });
   }
   return oaPath;
 }
 function hasOaDirectory(repoRoot) {
-  return existsSync12(join17(repoRoot, OA_DIR, "index"));
+  return existsSync12(join19(repoRoot, OA_DIR, "index"));
 }
 function loadProjectSettings(repoRoot) {
-  const settingsPath = join17(repoRoot, OA_DIR, "settings.json");
+  const settingsPath = join19(repoRoot, OA_DIR, "settings.json");
   try {
     if (existsSync12(settingsPath)) {
       return JSON.parse(readFileSync10(settingsPath, "utf-8"));
@@ -10733,14 +12381,14 @@ function loadProjectSettings(repoRoot) {
   return {};
 }
 function saveProjectSettings(repoRoot, settings) {
-  const oaPath = join17(repoRoot, OA_DIR);
+  const oaPath = join19(repoRoot, OA_DIR);
   mkdirSync6(oaPath, { recursive: true });
   const existing = loadProjectSettings(repoRoot);
   const merged = { ...existing, ...settings };
-  writeFileSync6(join17(oaPath, "settings.json"), JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  writeFileSync6(join19(oaPath, "settings.json"), JSON.stringify(merged, null, 2) + "\n", "utf-8");
 }
 function loadGlobalSettings() {
-  const settingsPath = join17(homedir7(), ".open-agents", "settings.json");
+  const settingsPath = join19(homedir7(), ".open-agents", "settings.json");
   try {
     if (existsSync12(settingsPath)) {
       return JSON.parse(readFileSync10(settingsPath, "utf-8"));
@@ -10750,11 +12398,11 @@ function loadGlobalSettings() {
   return {};
 }
 function saveGlobalSettings(settings) {
-  const dir = join17(homedir7(), ".open-agents");
+  const dir = join19(homedir7(), ".open-agents");
   mkdirSync6(dir, { recursive: true });
   const existing = loadGlobalSettings();
   const merged = { ...existing, ...settings };
-  writeFileSync6(join17(dir, "settings.json"), JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  writeFileSync6(join19(dir, "settings.json"), JSON.stringify(merged, null, 2) + "\n", "utf-8");
 }
 function resolveSettings(repoRoot) {
   const global = loadGlobalSettings();
@@ -10769,7 +12417,7 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
   while (dir && !visited.has(dir)) {
     visited.add(dir);
     for (const name of CONTEXT_FILES) {
-      const filePath = join17(dir, name);
+      const filePath = join19(dir, name);
       const normalizedName = name.toLowerCase();
       if (existsSync12(filePath) && !seen.has(filePath)) {
         seen.add(filePath);
@@ -10788,7 +12436,7 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
         }
       }
     }
-    const projectMap = join17(dir, OA_DIR, "context", "project-map.md");
+    const projectMap = join19(dir, OA_DIR, "context", "project-map.md");
     if (existsSync12(projectMap) && !seen.has(projectMap)) {
       seen.add(projectMap);
       try {
@@ -10804,7 +12452,7 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
       } catch {
       }
     }
-    const parent = join17(dir, "..");
+    const parent = join19(dir, "..");
     if (parent === dir)
       break;
     dir = parent;
@@ -10822,7 +12470,7 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
   return found;
 }
 function readIndexMeta(repoRoot) {
-  const metaPath = join17(repoRoot, OA_DIR, "index", "meta.json");
+  const metaPath = join19(repoRoot, OA_DIR, "index", "meta.json");
   try {
     return JSON.parse(readFileSync10(metaPath, "utf-8"));
   } catch {
@@ -10875,28 +12523,28 @@ ${tree}\`\`\`
     sections.push("");
   }
   const content = sections.join("\n");
-  const contextDir = join17(repoRoot, OA_DIR, "context");
+  const contextDir = join19(repoRoot, OA_DIR, "context");
   mkdirSync6(contextDir, { recursive: true });
-  writeFileSync6(join17(contextDir, "project-map.md"), content, "utf-8");
+  writeFileSync6(join19(contextDir, "project-map.md"), content, "utf-8");
   return content;
 }
 function saveSession(repoRoot, session) {
-  const historyDir = join17(repoRoot, OA_DIR, "history");
+  const historyDir = join19(repoRoot, OA_DIR, "history");
   mkdirSync6(historyDir, { recursive: true });
-  writeFileSync6(join17(historyDir, `${session.id}.json`), JSON.stringify(session, null, 2), "utf-8");
+  writeFileSync6(join19(historyDir, `${session.id}.json`), JSON.stringify(session, null, 2), "utf-8");
 }
 function loadRecentSessions(repoRoot, limit = 5) {
-  const historyDir = join17(repoRoot, OA_DIR, "history");
+  const historyDir = join19(repoRoot, OA_DIR, "history");
   if (!existsSync12(historyDir))
     return [];
   try {
     const files = readdirSync6(historyDir).filter((f) => f.endsWith(".json")).map((f) => {
-      const stat3 = statSync5(join17(historyDir, f));
-      return { file: f, mtime: stat3.mtimeMs };
+      const stat5 = statSync5(join19(historyDir, f));
+      return { file: f, mtime: stat5.mtimeMs };
     }).sort((a, b) => b.mtime - a.mtime).slice(0, limit);
     return files.map((f) => {
       try {
-        return JSON.parse(readFileSync10(join17(historyDir, f.file), "utf-8"));
+        return JSON.parse(readFileSync10(join19(historyDir, f.file), "utf-8"));
       } catch {
         return null;
       }
@@ -10906,12 +12554,12 @@ function loadRecentSessions(repoRoot, limit = 5) {
   }
 }
 function savePendingTask(repoRoot, task) {
-  const historyDir = join17(repoRoot, OA_DIR, "history");
+  const historyDir = join19(repoRoot, OA_DIR, "history");
   mkdirSync6(historyDir, { recursive: true });
-  writeFileSync6(join17(historyDir, PENDING_TASK_FILE), JSON.stringify(task, null, 2) + "\n", "utf-8");
+  writeFileSync6(join19(historyDir, PENDING_TASK_FILE), JSON.stringify(task, null, 2) + "\n", "utf-8");
 }
 function loadPendingTask(repoRoot) {
-  const filePath = join17(repoRoot, OA_DIR, "history", PENDING_TASK_FILE);
+  const filePath = join19(repoRoot, OA_DIR, "history", PENDING_TASK_FILE);
   try {
     if (!existsSync12(filePath))
       return null;
@@ -10943,7 +12591,7 @@ function detectManifests(repoRoot) {
     { file: "docker-compose.yaml", type: "Docker Compose" }
   ];
   for (const check of checks) {
-    const filePath = join17(repoRoot, check.file);
+    const filePath = join19(repoRoot, check.file);
     if (existsSync12(filePath)) {
       let name;
       if (check.nameField) {
@@ -10977,7 +12625,7 @@ function findKeyFiles(repoRoot) {
     { pattern: "CLAUDE.md", description: "Claude Code context" }
   ];
   for (const check of checks) {
-    if (existsSync12(join17(repoRoot, check.pattern))) {
+    if (existsSync12(join19(repoRoot, check.pattern))) {
       keyFiles.push({ path: check.pattern, description: check.description });
     }
   }
@@ -11003,12 +12651,12 @@ function buildDirTree(root, maxDepth, prefix = "", depth = 0) {
       if (entry.isDirectory()) {
         let fileCount = 0;
         try {
-          fileCount = readdirSync6(join17(root, entry.name)).filter((f) => !f.startsWith(".")).length;
+          fileCount = readdirSync6(join19(root, entry.name)).filter((f) => !f.startsWith(".")).length;
         } catch {
         }
         result += `${prefix}${connector}${entry.name}/ (${fileCount})
 `;
-        result += buildDirTree(join17(root, entry.name), maxDepth, childPrefix, depth + 1);
+        result += buildDirTree(join19(root, entry.name), maxDepth, childPrefix, depth + 1);
       } else if (depth < maxDepth) {
         result += `${prefix}${connector}${entry.name}
 `;
@@ -11061,7 +12709,7 @@ var init_oa_directory = __esm({
 import * as readline from "node:readline";
 import { execSync as execSync10 } from "node:child_process";
 import { existsSync as existsSync13, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "node:fs";
-import { join as join18 } from "node:path";
+import { join as join20 } from "node:path";
 import { homedir as homedir8 } from "node:os";
 function detectSystemSpecs() {
   let totalRamGB = 0;
@@ -11145,8 +12793,8 @@ function modelSupportsToolCalling(modelName) {
   return false;
 }
 function ask(rl, question) {
-  return new Promise((resolve16) => {
-    rl.question(question, (answer) => resolve16(answer.trim()));
+  return new Promise((resolve18) => {
+    rl.question(question, (answer) => resolve18(answer.trim()));
   });
 }
 function pullModelWithAutoUpdate(tag) {
@@ -11495,9 +13143,9 @@ async function doSetup(config, rl) {
           `PARAMETER num_predict 16384`,
           `PARAMETER stop "<|endoftext|>"`
         ].join("\n");
-        const modelDir2 = join18(homedir8(), ".open-agents", "models");
+        const modelDir2 = join20(homedir8(), ".open-agents", "models");
         mkdirSync7(modelDir2, { recursive: true });
-        const modelfilePath = join18(modelDir2, `Modelfile.${customName}`);
+        const modelfilePath = join20(modelDir2, `Modelfile.${customName}`);
         writeFileSync7(modelfilePath, modelfileContent + "\n", "utf8");
         process.stdout.write(`  ${c2.dim("Creating model...")} `);
         execSync10(`ollama create ${customName} -f ${modelfilePath}`, {
@@ -11535,7 +13183,7 @@ async function doSetup(config, rl) {
 }
 async function isModelAvailable(config) {
   try {
-    const models = await fetchOllamaModels(config.backendUrl);
+    const models = await fetchModels(config.backendUrl, config.apiKey);
     return !!findModel(models, config.model);
   } catch {
     return false;
@@ -11543,7 +13191,7 @@ async function isModelAvailable(config) {
 }
 function isFirstRun() {
   try {
-    return !existsSync13(join18(homedir8(), ".open-agents", "config.json"));
+    return !existsSync13(join20(homedir8(), ".open-agents", "config.json"));
   } catch {
     return true;
   }
@@ -11581,9 +13229,9 @@ function createExpandedVariant(baseModel, specs, sizeGB) {
       `PARAMETER num_predict 16384`,
       `PARAMETER stop "<|endoftext|>"`
     ].join("\n");
-    const modelDir2 = join18(homedir8(), ".open-agents", "models");
+    const modelDir2 = join20(homedir8(), ".open-agents", "models");
     mkdirSync7(modelDir2, { recursive: true });
-    const modelfilePath = join18(modelDir2, `Modelfile.${customName}`);
+    const modelfilePath = join20(modelDir2, `Modelfile.${customName}`);
     writeFileSync7(modelfilePath, modelfileContent + "\n", "utf8");
     execSync10(`ollama create ${customName} -f ${modelfilePath}`, {
       stdio: "pipe",
@@ -11712,6 +13360,174 @@ async function handleSlashCommand(input, ctx) {
         dryRun: String(ctx.config.dryRun)
       });
       return "handled";
+    case "cost":
+    case "costs":
+      if (ctx.costTracker) {
+        const summary = ctx.costTracker.getSummary();
+        const lines = [];
+        lines.push(c2.bold(`  Session Cost Summary (${summary.provider})`));
+        lines.push("");
+        lines.push(`  Input tokens:  ${c2.bold(summary.totalInputTokens.toLocaleString())}`);
+        lines.push(`  Output tokens: ${c2.bold(summary.totalOutputTokens.toLocaleString())}`);
+        if (ctx.costTracker.hasPricing) {
+          lines.push(`  Estimated cost: ${c2.bold(c2.yellow(ctx.costTracker.formatCost()))}`);
+          lines.push(`  Pricing: $${ctx.costTracker.provider.inputPer1M}/1M in, $${ctx.costTracker.provider.outputPer1M}/1M out`);
+        } else {
+          lines.push(`  Cost: ${c2.dim("free (local provider)")}`);
+        }
+        if (summary.taskCount > 0) {
+          lines.push("");
+          lines.push(`  Tasks: ${summary.taskCount}`);
+          for (const t of summary.tasks.slice(-5)) {
+            const costStr = ctx.costTracker.hasPricing ? ` ${ctx.costTracker.formatCost(t.estimatedCost)}` : "";
+            const dur = (t.durationMs / 1e3).toFixed(1);
+            lines.push(`    ${c2.dim("\u2022")} ${t.task.slice(0, 50)}${t.task.length > 50 ? "..." : ""} \u2014 ${dur}s${costStr}`);
+          }
+          if (summary.taskCount > 5) {
+            lines.push(`    ${c2.dim(`... and ${summary.taskCount - 5} more`)}`);
+          }
+        }
+        lines.push("");
+        console.log(lines.join("\n"));
+      } else {
+        renderInfo("Cost tracking not available.");
+      }
+      return "handled";
+    case "evaluate":
+    case "eval":
+      if (ctx.workEvaluator && ctx.lastTask && ctx.lastSummary) {
+        renderInfo("Evaluating last completed task...");
+        try {
+          const evalResult = await ctx.workEvaluator.evaluate(ctx.lastTask, ctx.lastSummary);
+          if (evalResult.success) {
+            const lines = [];
+            const pct = Math.round(evalResult.overallScore * 100);
+            const scoreColor = pct >= 80 ? c2.green : pct >= 60 ? c2.yellow : c2.red;
+            lines.push(`
+  ${c2.bold("Task Evaluation")} (${evalResult.taskType})`);
+            lines.push(`  Overall: ${scoreColor(c2.bold(`${pct}%`))}`);
+            lines.push("");
+            for (const d of evalResult.dimensions) {
+              const bar = "\u2588".repeat(d.score) + "\u2591".repeat(10 - d.score);
+              const dPct = Math.round(d.score / 10 * 100);
+              const dColor = dPct >= 80 ? c2.green : dPct >= 60 ? c2.yellow : c2.red;
+              lines.push(`  ${d.name.padEnd(14)} ${dColor(bar)} ${dColor(`${d.score}/10`)} ${c2.dim(`(${Math.round(d.weight * 100)}%)`)}`);
+              if (d.feedback)
+                lines.push(`  ${c2.dim("  " + d.feedback)}`);
+            }
+            if (evalResult.feedback) {
+              lines.push("");
+              lines.push(`  ${c2.dim(evalResult.feedback)}`);
+            }
+            lines.push("");
+            console.log(lines.join("\n"));
+          } else {
+            renderError(`Evaluation failed: ${evalResult.error}`);
+          }
+        } catch (err) {
+          renderError(`Evaluation error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      } else if (!ctx.lastTask) {
+        renderWarning("No completed task to evaluate. Complete a task first.");
+      } else {
+        renderWarning("Evaluation backend not configured.");
+      }
+      return "handled";
+    case "task-type":
+    case "tasktype":
+    case "tt": {
+      const validTypes = getTaskTypes();
+      if (arg === "auto" || arg === "clear" || arg === "reset") {
+        ctx.setTaskType?.(void 0);
+        renderInfo("Task type set to auto-detect.");
+      } else if (arg && validTypes.includes(arg)) {
+        const type = arg;
+        const template = getTaskTemplate(type);
+        ctx.setTaskType?.(type);
+        renderInfo(`Task type: ${c2.bold(template.label)} (${type})`);
+        console.log(`  ${c2.dim(template.description)}`);
+        console.log(`  ${c2.dim("Recommended tools:")} ${template.recommendedTools.slice(0, 5).join(", ")}`);
+        console.log("");
+      } else {
+        const lines = [];
+        lines.push(`
+  ${c2.bold("Available Task Types")}
+`);
+        for (const t of validTypes) {
+          const tmpl = getTaskTemplate(t);
+          const active = ctx.taskType === t ? c2.green(" \u2190 active") : "";
+          lines.push(`  ${c2.bold(t.padEnd(10))} ${tmpl.label}${active}`);
+          lines.push(`  ${c2.dim("           " + tmpl.description)}`);
+        }
+        if (!ctx.taskType) {
+          lines.push(`
+  ${c2.dim("Current: auto-detect")}`);
+        }
+        lines.push(`
+  ${c2.dim("Usage: /task-type <type> or /task-type auto")}`);
+        lines.push("");
+        console.log(lines.join("\n"));
+      }
+      return "handled";
+    }
+    case "stats":
+    case "metrics":
+    case "dashboard": {
+      if (!ctx.sessionMetrics) {
+        renderInfo("Session metrics not available.");
+        return "handled";
+      }
+      const summary = ctx.sessionMetrics.getSummary();
+      const dur = SessionMetrics.formatDuration(summary.sessionDurationMs);
+      const lines = [];
+      lines.push(`
+  ${c2.bold("Session Dashboard")}
+`);
+      lines.push(`  Duration:       ${c2.bold(dur)}`);
+      lines.push(`  Tasks completed: ${c2.bold(String(summary.tasksCompleted))}`);
+      lines.push(`  Turns:          ${c2.bold(String(summary.totalTurns))}`);
+      lines.push(`  Tool calls:     ${c2.bold(String(summary.totalToolCalls))}`);
+      lines.push(`  Input tokens:   ${c2.bold(summary.totalInputTokens.toLocaleString())}`);
+      lines.push(`  Output tokens:  ${c2.bold(summary.totalOutputTokens.toLocaleString())}`);
+      if (ctx.costTracker?.hasPricing) {
+        lines.push(`  Estimated cost: ${c2.bold(c2.yellow(ctx.costTracker.formatCost()))}`);
+      }
+      const topTools = ctx.sessionMetrics.getTopTools(5);
+      if (topTools.length > 0) {
+        lines.push(`
+  ${c2.bold("Top Tools")}`);
+        for (const t of topTools) {
+          const bar = "\u2588".repeat(Math.min(t.count, 30));
+          lines.push(`  ${t.name.padEnd(20)} ${c2.dim(bar)} ${t.count}`);
+        }
+      }
+      if (summary.filesModified.length > 0) {
+        lines.push(`
+  ${c2.bold("Files Modified")} (${summary.filesModified.length})`);
+        for (const f of summary.filesModified.slice(0, 10)) {
+          lines.push(`  ${c2.dim("\u2022")} ${f}`);
+        }
+        if (summary.filesModified.length > 10) {
+          lines.push(`  ${c2.dim(`... and ${summary.filesModified.length - 10} more`)}`);
+        }
+      }
+      if (summary.tasks.length > 0) {
+        lines.push(`
+  ${c2.bold("Task History")}`);
+        for (const task of summary.tasks.slice(-5)) {
+          const taskDur = task.durationMs ? SessionMetrics.formatDuration(task.durationMs) : "?";
+          const score = task.evaluationScore !== void 0 ? ` ${c2.dim(`(${Math.round(task.evaluationScore * 100)}%)`)}` : "";
+          lines.push(`  ${c2.dim("\u2022")} ${task.description.slice(0, 50)}${task.description.length > 50 ? "..." : ""} \u2014 ${taskDur}${score}`);
+        }
+      }
+      if (summary.averageEvalScore !== void 0) {
+        lines.push(`
+  Avg eval score: ${c2.bold(`${Math.round(summary.averageEvalScore * 100)}%`)}`);
+      }
+      lines.push("");
+      console.log(lines.join("\n"));
+      return "handled";
+    }
     case "model":
       if (arg) {
         await switchModel(arg, ctx, hasLocal);
@@ -11910,7 +13726,7 @@ async function handleSlashCommand(input, ctx) {
 }
 async function listModels(ctx) {
   try {
-    const models = await fetchOllamaModels(ctx.config.backendUrl);
+    const models = await fetchModels(ctx.config.backendUrl, ctx.config.apiKey);
     renderModelList(models.map((m) => ({ name: m.name, size: m.size, modified: m.modified })), ctx.config.model);
   } catch (err) {
     renderError(`Failed to fetch models: ${err instanceof Error ? err.message : String(err)}`);
@@ -11918,9 +13734,9 @@ async function listModels(ctx) {
 }
 async function showModelPicker(ctx) {
   try {
-    const models = await fetchOllamaModels(ctx.config.backendUrl);
+    const models = await fetchModels(ctx.config.backendUrl, ctx.config.apiKey);
     if (models.length === 0) {
-      renderWarning("No models found. Pull a model with: ollama pull <model>");
+      renderWarning("No models found.");
       return;
     }
     renderModelList(models.map((m) => ({ name: m.name, size: m.size, modified: m.modified })), ctx.config.model);
@@ -12051,15 +13867,15 @@ async function handleUpdate(subcommand, ctx) {
   let currentVersion = "0.0.0";
   try {
     const { createRequire: createRequire4 } = await import("node:module");
-    const { fileURLToPath: fileURLToPath3 } = await import("node:url");
-    const { dirname: dirname5, join: join28 } = await import("node:path");
+    const { fileURLToPath: fileURLToPath4 } = await import("node:url");
+    const { dirname: dirname7, join: join30 } = await import("node:path");
     const { existsSync: existsSync19 } = await import("node:fs");
     const req = createRequire4(import.meta.url);
-    const thisDir = dirname5(fileURLToPath3(import.meta.url));
+    const thisDir = dirname7(fileURLToPath4(import.meta.url));
     const candidates = [
-      join28(thisDir, "..", "package.json"),
-      join28(thisDir, "..", "..", "package.json"),
-      join28(thisDir, "..", "..", "..", "package.json")
+      join30(thisDir, "..", "package.json"),
+      join30(thisDir, "..", "..", "package.json"),
+      join30(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
       if (existsSync19(pkgPath)) {
@@ -12114,7 +13930,7 @@ async function handleUpdate(subcommand, ctx) {
 }
 async function switchModel(query, ctx, local = false) {
   try {
-    const models = await fetchOllamaModels(ctx.config.backendUrl);
+    const models = await fetchModels(ctx.config.backendUrl, ctx.config.apiKey);
     const match = findModel(models, query);
     if (!match) {
       renderError(`Model not found: "${query}"`);
@@ -12157,6 +13973,8 @@ var init_commands = __esm({
     init_render();
     init_dist2();
     init_config();
+    init_dist5();
+    init_dist6();
     init_updater();
     init_oa_directory();
     init_setup();
@@ -12166,7 +13984,7 @@ var init_commands = __esm({
 
 // packages/cli/dist/tui/project-context.js
 import { existsSync as existsSync14, readFileSync as readFileSync11, readdirSync as readdirSync7 } from "node:fs";
-import { join as join19, basename as basename5 } from "node:path";
+import { join as join21, basename as basename5 } from "node:path";
 import { execSync as execSync11 } from "node:child_process";
 import { homedir as homedir9, platform, release } from "node:os";
 function loadProjectFiles(repoRoot) {
@@ -12186,7 +14004,7 @@ function loadProjectMap(repoRoot) {
   if (!hasOaDirectory(repoRoot)) {
     initOaDirectory(repoRoot);
   }
-  const mapPath = join19(repoRoot, OA_DIR, "context", "project-map.md");
+  const mapPath = join21(repoRoot, OA_DIR, "context", "project-map.md");
   if (existsSync14(mapPath)) {
     try {
       const content = readFileSync11(mapPath, "utf-8");
@@ -12230,17 +14048,17 @@ ${log}`);
 }
 function loadMemoryContext(repoRoot) {
   const sections = [];
-  const oaMemDir = join19(repoRoot, OA_DIR, "memory");
+  const oaMemDir = join21(repoRoot, OA_DIR, "memory");
   const oaEntries = loadMemoryDir(oaMemDir, "project");
   if (oaEntries)
     sections.push(oaEntries);
-  const legacyMemDir = join19(repoRoot, ".open-agents", "memory");
+  const legacyMemDir = join21(repoRoot, ".open-agents", "memory");
   if (legacyMemDir !== oaMemDir && existsSync14(legacyMemDir)) {
     const legacyEntries = loadMemoryDir(legacyMemDir, "project/legacy");
     if (legacyEntries)
       sections.push(legacyEntries);
   }
-  const globalMemDir = join19(homedir9(), ".open-agents", "memory");
+  const globalMemDir = join21(homedir9(), ".open-agents", "memory");
   const globalEntries = loadMemoryDir(globalMemDir, "global");
   if (globalEntries)
     sections.push(globalEntries);
@@ -12254,7 +14072,7 @@ function loadMemoryDir(memDir, scope) {
     const files = readdirSync7(memDir).filter((f) => f.endsWith(".json"));
     for (const file of files.slice(0, 10)) {
       try {
-        const raw = readFileSync11(join19(memDir, file), "utf-8");
+        const raw = readFileSync11(join21(memDir, file), "utf-8");
         const entries = JSON.parse(raw);
         const topic = basename5(file, ".json");
         const keys = Object.keys(entries);
@@ -12967,7 +14785,7 @@ var init_toolPatternStore = __esm({
 });
 
 // packages/memory/dist/index.js
-var init_dist6 = __esm({
+var init_dist7 = __esm({
   "packages/memory/dist/index.js"() {
     "use strict";
     init_db();
@@ -13266,24 +15084,24 @@ var init_carousel = __esm({
 
 // packages/cli/dist/tui/voice.js
 import { existsSync as existsSync15, mkdirSync as mkdirSync8, writeFileSync as writeFileSync8, readFileSync as readFileSync12, unlinkSync as unlinkSync3 } from "node:fs";
-import { join as join20 } from "node:path";
-import { homedir as homedir10, tmpdir as tmpdir2, platform as platform2 } from "node:os";
+import { join as join22 } from "node:path";
+import { homedir as homedir10, tmpdir as tmpdir3, platform as platform2 } from "node:os";
 import { execSync as execSync12, spawn as nodeSpawn } from "node:child_process";
 import { createRequire } from "node:module";
 function voiceDir() {
-  return join20(homedir10(), ".open-agents", "voice");
+  return join22(homedir10(), ".open-agents", "voice");
 }
 function modelsDir() {
-  return join20(voiceDir(), "models");
+  return join22(voiceDir(), "models");
 }
 function modelDir(id) {
-  return join20(modelsDir(), id);
+  return join22(modelsDir(), id);
 }
 function modelOnnxPath(id) {
-  return join20(modelDir(id), "model.onnx");
+  return join22(modelDir(id), "model.onnx");
 }
 function modelConfigPath(id) {
-  return join20(modelDir(id), "config.json");
+  return join22(modelDir(id), "config.json");
 }
 function describeToolCall(toolName, args) {
   const path = args["path"];
@@ -13556,7 +15374,7 @@ var init_voice = __esm({
         const audioData = result["output"].data;
         if (audioData.length === 0)
           return;
-        const wavPath = join20(tmpdir2(), `oa-voice-${Date.now()}.wav`);
+        const wavPath = join22(tmpdir3(), `oa-voice-${Date.now()}.wav`);
         this.writeWav(audioData, this.config.audio.sample_rate, wavPath);
         await this.playWav(wavPath);
         try {
@@ -13645,7 +15463,7 @@ var init_voice = __esm({
         const cmd = this.getPlayCommand(path);
         if (!cmd)
           return;
-        return new Promise((resolve16) => {
+        return new Promise((resolve18) => {
           const child = nodeSpawn(cmd[0], cmd.slice(1), {
             stdio: "ignore",
             detached: false
@@ -13654,12 +15472,12 @@ var init_voice = __esm({
           child.on("close", () => {
             if (this.currentPlayback === child)
               this.currentPlayback = null;
-            resolve16();
+            resolve18();
           });
           child.on("error", () => {
             if (this.currentPlayback === child)
               this.currentPlayback = null;
-            resolve16();
+            resolve18();
           });
           setTimeout(() => {
             if (this.currentPlayback === child) {
@@ -13669,7 +15487,7 @@ var init_voice = __esm({
               }
               this.currentPlayback = null;
             }
-            resolve16();
+            resolve18();
           }, 15e3);
         });
       }
@@ -13709,7 +15527,7 @@ var init_voice = __esm({
         if (this.ort)
           return;
         mkdirSync8(voiceDir(), { recursive: true });
-        const pkgPath = join20(voiceDir(), "package.json");
+        const pkgPath = join22(voiceDir(), "package.json");
         const expectedDeps = {
           "onnxruntime-node": "^1.21.0",
           "phonemizer": "^1.2.1"
@@ -13731,7 +15549,7 @@ var init_voice = __esm({
             dependencies: expectedDeps
           }, null, 2));
         }
-        const voiceRequire = createRequire(join20(voiceDir(), "index.js"));
+        const voiceRequire = createRequire(join22(voiceDir(), "index.js"));
         try {
           this.ort = voiceRequire("onnxruntime-node");
         } catch {
@@ -14328,10 +16146,10 @@ var init_stream_renderer = __esm({
 
 // packages/cli/dist/tui/edit-history.js
 import { appendFileSync, mkdirSync as mkdirSync9 } from "node:fs";
-import { join as join21 } from "node:path";
+import { join as join23 } from "node:path";
 function createEditHistoryLogger(repoRoot, sessionId) {
-  const historyDir = join21(repoRoot, ".oa", "history");
-  const logPath = join21(historyDir, "edits.jsonl");
+  const historyDir = join23(repoRoot, ".oa", "history");
+  const logPath = join23(historyDir, "edits.jsonl");
   try {
     mkdirSync9(historyDir, { recursive: true });
   } catch {
@@ -14443,7 +16261,7 @@ var init_edit_history = __esm({
 
 // packages/cli/dist/tui/dream-engine.js
 import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync9, readFileSync as readFileSync13, existsSync as existsSync16, cpSync, rmSync, readdirSync as readdirSync8 } from "node:fs";
-import { join as join22, basename as basename6 } from "node:path";
+import { join as join24, basename as basename6 } from "node:path";
 import { execSync as execSync13 } from "node:child_process";
 function adaptTool(tool) {
   return {
@@ -14618,12 +16436,12 @@ var init_dream_engine = __esm({
         const content = String(args["content"] ?? "");
         if (!rawPath)
           return { success: false, output: "", error: "path is required", durationMs: Date.now() - start };
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join22(this.dreamsDir, basename6(rawPath)) : join22(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join24(this.dreamsDir, basename6(rawPath)) : join24(this.dreamsDir, rawPath);
         if (!targetPath.startsWith(this.dreamsDir)) {
           return { success: false, output: "", error: "Dream mode: writes are confined to .oa/dreams/", durationMs: Date.now() - start };
         }
         try {
-          const dir = join22(targetPath, "..");
+          const dir = join24(targetPath, "..");
           mkdirSync10(dir, { recursive: true });
           writeFileSync9(targetPath, content, "utf-8");
           return { success: true, output: `Wrote ${content.length} bytes to ${rawPath}`, durationMs: Date.now() - start };
@@ -14653,7 +16471,7 @@ var init_dream_engine = __esm({
         const rawPath = String(args["path"] ?? "");
         const oldStr = String(args["old_string"] ?? "");
         const newStr = String(args["new_string"] ?? "");
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join22(this.dreamsDir, basename6(rawPath)) : join22(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join24(this.dreamsDir, basename6(rawPath)) : join24(this.dreamsDir, rawPath);
         if (!targetPath.startsWith(this.dreamsDir)) {
           return { success: false, output: "", error: "Dream mode: edits are confined to .oa/dreams/", durationMs: Date.now() - start };
         }
@@ -14720,7 +16538,7 @@ var init_dream_engine = __esm({
       constructor(config, repoRoot) {
         this.config = config;
         this.repoRoot = repoRoot;
-        this.dreamsDir = join22(repoRoot, ".oa", "dreams");
+        this.dreamsDir = join24(repoRoot, ".oa", "dreams");
         this.state = {
           mode: "default",
           active: false,
@@ -14792,7 +16610,7 @@ ${result.summary}`;
             if (mode !== "default" || cycle === totalCycles) {
               renderDreamContraction(cycle);
               const cycleSummary = this.buildCycleSummary(cycle, previousFindings);
-              const summaryPath = join22(this.dreamsDir, `cycle-${cycle}-summary.md`);
+              const summaryPath = join24(this.dreamsDir, `cycle-${cycle}-summary.md`);
               writeFileSync9(summaryPath, cycleSummary, "utf-8");
             }
             if (mode === "lucid" && !this.abortController.signal.aborted) {
@@ -14913,7 +16731,7 @@ Dreams directory: ${this.dreamsDir}`);
       }
       /** Save workspace backup for lucid mode */
       saveVersionCheckpoint(cycle) {
-        const checkpointDir = join22(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
+        const checkpointDir = join24(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
         try {
           mkdirSync10(checkpointDir, { recursive: true });
           try {
@@ -14932,10 +16750,10 @@ Dreams directory: ${this.dreamsDir}`);
               encoding: "utf-8",
               timeout: 5e3
             }).trim();
-            writeFileSync9(join22(checkpointDir, "git-status.txt"), gitStatus, "utf-8");
-            writeFileSync9(join22(checkpointDir, "git-diff.patch"), gitDiff, "utf-8");
-            writeFileSync9(join22(checkpointDir, "git-hash.txt"), gitHash, "utf-8");
-            writeFileSync9(join22(checkpointDir, "checkpoint.json"), JSON.stringify({
+            writeFileSync9(join24(checkpointDir, "git-status.txt"), gitStatus, "utf-8");
+            writeFileSync9(join24(checkpointDir, "git-diff.patch"), gitDiff, "utf-8");
+            writeFileSync9(join24(checkpointDir, "git-hash.txt"), gitHash, "utf-8");
+            writeFileSync9(join24(checkpointDir, "checkpoint.json"), JSON.stringify({
               cycle,
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
               gitHash,
@@ -14943,7 +16761,7 @@ Dreams directory: ${this.dreamsDir}`);
             }, null, 2), "utf-8");
             renderInfo(`Checkpoint saved: cycle ${cycle} (${gitHash.slice(0, 8)})`);
           } catch {
-            writeFileSync9(join22(checkpointDir, "checkpoint.json"), JSON.stringify({ cycle, timestamp: (/* @__PURE__ */ new Date()).toISOString(), mode: this.state.mode }, null, 2), "utf-8");
+            writeFileSync9(join24(checkpointDir, "checkpoint.json"), JSON.stringify({ cycle, timestamp: (/* @__PURE__ */ new Date()).toISOString(), mode: this.state.mode }, null, 2), "utf-8");
             renderInfo(`Checkpoint saved: cycle ${cycle} (no git)`);
           }
         } catch (err) {
@@ -15001,14 +16819,14 @@ ${files.map((f) => `- [\`${f}\`](./${f})`).join("\n")}
 ---
 *Auto-generated by open-agents dream engine*
 `;
-          writeFileSync9(join22(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
+          writeFileSync9(join24(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
         } catch {
         }
       }
       /** Save dream state for resume/inspection */
       saveDreamState() {
         try {
-          writeFileSync9(join22(this.dreamsDir, "dream-state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
+          writeFileSync9(join24(this.dreamsDir, "dream-state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
         } catch {
         }
       }
@@ -15244,13 +17062,18 @@ var init_status_bar = __esm({
         const ctxPct = ctxTotal > 0 ? Math.max(0, Math.min(100, Math.round((1 - ctxUsed / ctxTotal) * 100))) : 100;
         const ctxColor = ctxPct > 50 ? c2.green : ctxPct > 20 ? c2.yellow : c2.red;
         const ctxLabel = pastel2(153, "Ctx: ") + c2.bold(`${ctxUsed.toLocaleString()}/${ctxTotal.toLocaleString()}`) + ` ${ctxColor(`${ctxPct}%`)}`;
+        let costLabel = "";
+        if (m.hasPricing && m.estimatedCost !== void 0) {
+          const costStr = m.estimatedCost < 0.01 ? `$${m.estimatedCost.toFixed(4)}` : m.estimatedCost < 1 ? `$${m.estimatedCost.toFixed(3)}` : `$${m.estimatedCost.toFixed(2)}`;
+          costLabel = pipe + pastel2(222, "Cost: ") + c2.bold(costStr);
+        }
         let recordingLabel = "";
         if (this._recording) {
           const dot = this._recBlink ? pastel2(210, "\u25CF") : " ";
           const countdown = this._countdown > 0 ? c2.dim(` ${this._countdown}s`) : "";
           recordingLabel = pipe + dot + pastel2(210, " REC") + countdown;
         }
-        return ` ${tokInLabel}${pipe}${tokOutLabel}${pipe}${ctxLabel}${recordingLabel}`;
+        return ` ${tokInLabel}${pipe}${tokOutLabel}${pipe}${ctxLabel}${costLabel}${recordingLabel}`;
       }
       // -------------------------------------------------------------------------
       // Private
@@ -15377,19 +17200,19 @@ var init_status_bar = __esm({
 import * as readline2 from "node:readline";
 import { Writable } from "node:stream";
 import { cwd } from "node:process";
-import { resolve as resolve13, join as join23, dirname as dirname3, extname as extname6 } from "node:path";
+import { resolve as resolve15, join as join25, dirname as dirname5, extname as extname8 } from "node:path";
 import { createRequire as createRequire2 } from "node:module";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { readFileSync as readFileSync14 } from "node:fs";
 import { existsSync as existsSync17 } from "node:fs";
 function getVersion() {
   try {
     const require2 = createRequire2(import.meta.url);
-    const thisDir = dirname3(fileURLToPath(import.meta.url));
+    const thisDir = dirname5(fileURLToPath2(import.meta.url));
     const candidates = [
-      join23(thisDir, "..", "package.json"),
-      join23(thisDir, "..", "..", "package.json"),
-      join23(thisDir, "..", "..", "..", "package.json")
+      join25(thisDir, "..", "package.json"),
+      join25(thisDir, "..", "..", "package.json"),
+      join25(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
       if (existsSync17(pkgPath)) {
@@ -15472,7 +17295,13 @@ function buildTools(repoRoot, config) {
     new SkillExecuteTool(repoRoot),
     // Transcription tools (transcribe-cli / faster-whisper)
     new TranscribeFileTool(repoRoot),
-    new TranscribeUrlTool(repoRoot)
+    new TranscribeUrlTool(repoRoot),
+    // Structured file generation (CSV, JSON, Markdown, Excel-compatible)
+    new StructuredFileTool(repoRoot),
+    // Code sandbox (isolated code execution)
+    new CodeSandboxTool(repoRoot),
+    // Structured file reading (CSV, JSON, Markdown, binary detection)
+    new StructuredReadTool(repoRoot)
   ];
   return [
     ...executionTools.map(adaptTool2),
@@ -15552,9 +17381,12 @@ Use task_status("${taskId}") or task_output("${taskId}") to check progress.`
     }
   };
 }
-function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce, statusBar, sudoCallback) {
+function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce, statusBar, sudoCallback, costTracker, onComplete, taskType) {
   const projectCtx = buildProjectContext(repoRoot, taskStores?.contextStores);
-  const dynamicContext = formatContextForPrompt(projectCtx);
+  let dynamicContext = formatContextForPrompt(projectCtx);
+  if (taskType) {
+    dynamicContext += "\n\n" + buildTaskContext(taskType);
+  }
   const backend = new OllamaAgenticBackend(config.backendUrl, config.model, config.apiKey);
   const runner = new AgenticRunner(backend, {
     maxTurns: 60,
@@ -15658,7 +17490,14 @@ function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce
         break;
       case "token_usage":
         if (statusBar && event.tokenUsage) {
-          statusBar.updateMetrics(event.tokenUsage);
+          if (costTracker && event.tokenUsage.promptTokens > 0) {
+            costTracker.trackTokens(event.tokenUsage.promptTokens, event.tokenUsage.completionTokens);
+          }
+          statusBar.updateMetrics({
+            ...event.tokenUsage,
+            estimatedCost: costTracker?.currentCost,
+            hasPricing: costTracker?.hasPricing
+          });
         }
         break;
       case "sudo_request":
@@ -15677,6 +17516,8 @@ function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce
     contentWrite(() => {
       if (result.completed) {
         renderTaskComplete(result.summary, result.turns, result.toolCalls, result.durationMs, tokens);
+        if (onComplete)
+          onComplete(result.summary);
         if (voice?.enabled && result.summary) {
           const ttsText = result.summary.length > 300 ? result.summary.slice(0, 300) + "..." : result.summary;
           voice.speak(`Task complete. ${ttsText}`);
@@ -15734,7 +17575,7 @@ function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce
   } };
 }
 async function startInteractive(config, repoPath) {
-  const repoRoot = resolve13(repoPath ?? cwd());
+  const repoRoot = resolve15(repoPath ?? cwd());
   const isResumed = !!process.env.__OA_RESUMED;
   if (isResumed) {
     delete process.env.__OA_RESUMED;
@@ -15803,8 +17644,8 @@ async function startInteractive(config, repoPath) {
   if (!isResumed) {
     try {
       const baseUrl = normalizeBaseUrl(config.backendUrl);
-      const provider = detectProvider(config.backendUrl);
-      const healthUrl = `${baseUrl}${provider.modelsPath}`;
+      const provider2 = detectProvider(config.backendUrl);
+      const healthUrl = `${baseUrl}${provider2.modelsPath}`;
       const headers = {};
       if (config.apiKey) {
         headers["Authorization"] = `Bearer ${config.apiKey}`;
@@ -15813,9 +17654,9 @@ async function startInteractive(config, repoPath) {
       if (!resp.ok)
         throw new Error(`HTTP ${resp.status}`);
     } catch {
-      const provider = detectProvider(config.backendUrl);
-      renderWarning(`Cannot reach ${provider.label} at ${config.backendUrl}`);
-      if (provider.id === "ollama") {
+      const provider2 = detectProvider(config.backendUrl);
+      renderWarning(`Cannot reach ${provider2.label} at ${config.backendUrl}`);
+      if (provider2.id === "ollama") {
         renderInfo("Start Ollama with: ollama serve");
       }
       renderInfo("Use /endpoint to configure a different backend. Starting anyway...");
@@ -15846,6 +17687,10 @@ async function startInteractive(config, repoPath) {
       end: () => statusBar.endContentWrite()
     });
   }
+  const provider = detectProvider(config.backendUrl);
+  const costTracker = new CostTracker(provider.id);
+  const sessionMetrics = new SessionMetrics();
+  const workEvaluator = new WorkEvaluator();
   ensureTranscribeCliBackground();
   const voiceEngine = new VoiceEngine();
   const streamRenderer = new StreamRenderer();
@@ -15863,6 +17708,8 @@ async function startInteractive(config, repoPath) {
   let messageQueue = [];
   let carouselRetired = isResumed;
   let lastSubmittedPrompt = "";
+  let lastCompletedSummary = "";
+  let currentTaskType;
   let sessionFilesTouched = [];
   let sessionToolCallCount = 0;
   let sessionSudoPassword = null;
@@ -15930,11 +17777,43 @@ async function startInteractive(config, repoPath) {
     const sudoPromptStr = `  ${c2.bold(c2.yellow("\u{1F511} Password:"))} `;
     process.stdout.write(sudoPromptStr);
   }
+  const evalBackend = {
+    async evaluate(prompt) {
+      const backend = new OllamaAgenticBackend(currentConfig.backendUrl, currentConfig.model, currentConfig.apiKey);
+      const result = await backend.chatCompletion({
+        messages: [
+          { role: "system", content: "You are a quality evaluator. Respond with JSON only." },
+          { role: "user", content: prompt }
+        ],
+        tools: [],
+        temperature: 0,
+        maxTokens: 2048,
+        timeoutMs: currentConfig.timeoutMs
+      });
+      return result.choices[0]?.message?.content ?? "";
+    }
+  };
+  workEvaluator.setBackend(evalBackend);
   const commandCtx = {
     get config() {
       return currentConfig;
     },
     repoRoot,
+    costTracker,
+    workEvaluator,
+    get lastTask() {
+      return lastSubmittedPrompt;
+    },
+    get lastSummary() {
+      return lastCompletedSummary;
+    },
+    get taskType() {
+      return currentTaskType;
+    },
+    setTaskType(type) {
+      currentTaskType = type;
+    },
+    sessionMetrics,
     setModel(model) {
       currentConfig = { ...currentConfig, model };
     },
@@ -15948,6 +17827,8 @@ async function startInteractive(config, repoPath) {
         backendType,
         ...apiKey !== void 0 ? { apiKey } : {}
       };
+      const newProvider = detectProvider(url);
+      costTracker.setProvider(newProvider.id);
     },
     clearScreen() {
       process.stdout.write("\x1B[2J\x1B[H");
@@ -16223,7 +18104,9 @@ Execute this skill now. Follow the behavioral guidance above.`;
             taskMemoryStore: taskMemoryStore ?? void 0,
             failureStore: failureStore ?? void 0,
             toolPatternStore: toolPatternStore ?? void 0
-          }, bruteForceEnabled, statusBar, handleSudoRequest);
+          }, bruteForceEnabled, statusBar, handleSudoRequest, costTracker, (summary) => {
+            lastCompletedSummary = summary;
+          }, currentTaskType);
           activeTask = task;
           showPrompt();
           await task.promise;
@@ -16237,15 +18120,15 @@ Execute this skill now. Follow the behavioral guidance above.`;
       }
     }
     const cleanPath = input.replace(/^['"]|['"]$/g, "").trim();
-    const isImage = isImagePath(cleanPath) && existsSync17(resolve13(repoRoot, cleanPath));
-    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync17(resolve13(repoRoot, cleanPath));
+    const isImage = isImagePath(cleanPath) && existsSync17(resolve15(repoRoot, cleanPath));
+    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync17(resolve15(repoRoot, cleanPath));
     if (activeTask) {
       if (isImage) {
         try {
-          const imgPath = resolve13(repoRoot, cleanPath);
+          const imgPath = resolve15(repoRoot, cleanPath);
           const imgBuffer = readFileSync14(imgPath);
           const base64 = imgBuffer.toString("base64");
-          const ext = extname6(cleanPath).toLowerCase();
+          const ext = extname8(cleanPath).toLowerCase();
           const mime = ext === ".png" ? "image/png" : ext === ".gif" ? "image/gif" : ext === ".webp" ? "image/webp" : "image/jpeg";
           activeTask.runner.injectImage(base64, mime, `User shared image: ${cleanPath}`);
           writeContent(() => renderUserInterrupt(`[Image: ${cleanPath}]`));
@@ -16256,7 +18139,7 @@ Execute this skill now. Follow the behavioral guidance above.`;
       } else if (isMedia) {
         writeContent(() => renderInfo(`Transcribing: ${cleanPath}...`));
         const engine = getListenEngine();
-        const result = await engine.transcribeFile(resolve13(repoRoot, cleanPath), repoRoot);
+        const result = await engine.transcribeFile(resolve15(repoRoot, cleanPath), repoRoot);
         if (result) {
           const transcript = `[Transcription of ${cleanPath}]
 ${result.text}`;
@@ -16289,7 +18172,7 @@ ${result.text}`;
     if (isMedia && fullInput === input) {
       writeContent(() => renderInfo(`Transcribing: ${cleanPath}...`));
       const engine = getListenEngine();
-      const result = await engine.transcribeFile(resolve13(repoRoot, cleanPath), repoRoot);
+      const result = await engine.transcribeFile(resolve15(repoRoot, cleanPath), repoRoot);
       if (result) {
         fullInput = `The user has provided an audio/video file: ${cleanPath}.
 
@@ -16321,7 +18204,9 @@ Summarize or analyze this transcription as appropriate.`;
         taskMemoryStore: taskMemoryStore ?? void 0,
         failureStore: failureStore ?? void 0,
         toolPatternStore: toolPatternStore ?? void 0
-      }, bruteForceEnabled, statusBar, handleSudoRequest);
+      }, bruteForceEnabled, statusBar, handleSudoRequest, costTracker, (summary) => {
+        lastCompletedSummary = summary;
+      }, currentTaskType);
       activeTask = task;
       showPrompt();
       await task.promise;
@@ -16405,7 +18290,7 @@ ${c2.dim("(Use /quit to exit)")}
   });
 }
 async function runWithTUI(task, config, repoPath) {
-  const repoRoot = resolve13(repoPath ?? cwd());
+  const repoRoot = resolve15(repoPath ?? cwd());
   const needsSetup = isFirstRun() || !await isModelAvailable(config);
   if (needsSetup && config.backendType === "ollama") {
     const setupModel = await runSetupWizard(config);
@@ -16463,7 +18348,7 @@ var init_interactive = __esm({
     init_commands();
     init_setup();
     init_project_context();
-    init_dist6();
+    init_dist7();
     init_oa_directory();
     init_render();
     init_carousel();
@@ -16472,6 +18357,7 @@ var init_interactive = __esm({
     init_edit_history();
     init_dream_engine();
     init_status_bar();
+    init_dist6();
     taskManager = new BackgroundTaskManager();
   }
 });
@@ -16505,9 +18391,9 @@ var init_run = __esm({
 // packages/indexer/dist/codebase-indexer.js
 import { glob } from "glob";
 import ignore from "ignore";
-import { readFile as readFile9, stat as stat2 } from "node:fs/promises";
+import { readFile as readFile10, stat as stat4 } from "node:fs/promises";
 import { createHash } from "node:crypto";
-import { join as join24, relative as relative3, extname as extname7, basename as basename7 } from "node:path";
+import { join as join26, relative as relative3, extname as extname9, basename as basename7 } from "node:path";
 var DEFAULT_EXCLUDE, LANGUAGE_MAP, CodebaseIndexer;
 var init_codebase_indexer = __esm({
   "packages/indexer/dist/codebase-indexer.js"() {
@@ -16551,7 +18437,7 @@ var init_codebase_indexer = __esm({
         const ig = ignore.default();
         if (this.config.respectGitignore) {
           try {
-            const gitignoreContent = await readFile9(join24(this.config.rootDir, ".gitignore"), "utf-8");
+            const gitignoreContent = await readFile10(join26(this.config.rootDir, ".gitignore"), "utf-8");
             ig.add(gitignoreContent);
           } catch {
           }
@@ -16566,14 +18452,14 @@ var init_codebase_indexer = __esm({
         for (const relativePath of files) {
           if (ig.ignores(relativePath))
             continue;
-          const fullPath = join24(this.config.rootDir, relativePath);
+          const fullPath = join26(this.config.rootDir, relativePath);
           try {
-            const fileStat = await stat2(fullPath);
+            const fileStat = await stat4(fullPath);
             if (fileStat.size > this.config.maxFileSize)
               continue;
-            const content = await readFile9(fullPath);
+            const content = await readFile10(fullPath);
             const hash = createHash("sha256").update(content).digest("hex");
-            const ext = extname7(relativePath);
+            const ext = extname9(relativePath);
             indexed.push({
               path: fullPath,
               relativePath,
@@ -16612,7 +18498,7 @@ var init_codebase_indexer = __esm({
               if (!child) {
                 child = {
                   name: part,
-                  path: join24(current.path, part),
+                  path: join26(current.path, part),
                   type: "directory",
                   children: []
                 };
@@ -16669,7 +18555,7 @@ var init_embeddings = __esm({
 });
 
 // packages/indexer/dist/index.js
-var init_dist7 = __esm({
+var init_dist8 = __esm({
   "packages/indexer/dist/index.js"() {
     "use strict";
     init_codebase_indexer();
@@ -16686,19 +18572,19 @@ var index_repo_exports = {};
 __export(index_repo_exports, {
   indexRepoCommand: () => indexRepoCommand
 });
-import { resolve as resolve14 } from "node:path";
+import { resolve as resolve16 } from "node:path";
 import { existsSync as existsSync18, statSync as statSync6 } from "node:fs";
 import { cwd as cwd2 } from "node:process";
 async function indexRepoCommand(opts, _config) {
-  const repoRoot = resolve14(opts.repoPath ?? cwd2());
+  const repoRoot = resolve16(opts.repoPath ?? cwd2());
   printHeader("Index Repository");
   printInfo(`Indexing: ${repoRoot}`);
   if (!existsSync18(repoRoot)) {
     printError(`Path does not exist: ${repoRoot}`);
     process.exit(1);
   }
-  const stat3 = statSync6(repoRoot);
-  if (!stat3.isDirectory()) {
+  const stat5 = statSync6(repoRoot);
+  if (!stat5.isDirectory()) {
     printError(`Path is not a directory: ${repoRoot}`);
     process.exit(1);
   }
@@ -16776,7 +18662,7 @@ async function indexRepoCommand(opts, _config) {
 var init_index_repo = __esm({
   "packages/cli/dist/commands/index-repo.js"() {
     "use strict";
-    init_dist7();
+    init_dist8();
     init_spinner();
     init_output();
   }
@@ -16939,7 +18825,7 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { join as join25, resolve as resolve15 } from "node:path";
+import { join as join27, resolve as resolve17 } from "node:path";
 import { homedir as homedir11 } from "node:os";
 import { cwd as cwd3 } from "node:process";
 function coerceForSettings(key, value) {
@@ -16960,7 +18846,7 @@ async function configCommand(opts, config) {
   return handleShow(opts, config);
 }
 function handleShow(opts, config) {
-  const repoRoot = resolve15(opts.repoPath ?? cwd3());
+  const repoRoot = resolve17(opts.repoPath ?? cwd3());
   printHeader("Configuration");
   printSection("Active Settings (merged)");
   printKeyValue("backendUrl", config.backendUrl, 2);
@@ -16992,7 +18878,7 @@ function handleShow(opts, config) {
     }
   }
   printSection("Config File");
-  printInfo(`~/.open-agents/config.json (${join25(homedir11(), ".open-agents", "config.json")})`);
+  printInfo(`~/.open-agents/config.json (${join27(homedir11(), ".open-agents", "config.json")})`);
   printSection("Priority Chain");
   printInfo("  1. CLI flags (--model, --backend-url, etc.)");
   printInfo("  2. Project .oa/settings.json (--local)");
@@ -17025,13 +18911,13 @@ function handleSet(opts, _config) {
     process.exit(1);
   }
   if (opts.local) {
-    const repoRoot = resolve15(opts.repoPath ?? cwd3());
+    const repoRoot = resolve17(opts.repoPath ?? cwd3());
     try {
       initOaDirectory(repoRoot);
       const coerced = coerceForSettings(key, value);
       saveProjectSettings(repoRoot, { [key]: coerced });
       printSuccess(`Project override set: ${key} = ${value}`);
-      printInfo(`Saved to ${join25(repoRoot, ".oa", "settings.json")}`);
+      printInfo(`Saved to ${join27(repoRoot, ".oa", "settings.json")}`);
       printInfo("This override applies only when running in this workspace.");
     } catch (err) {
       printError(`Failed to save: ${err instanceof Error ? err.message : String(err)}`);
@@ -17091,7 +18977,7 @@ var serve_exports = {};
 __export(serve_exports, {
   serveCommand: () => serveCommand
 });
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 async function serveCommand(opts, config) {
   const backendType = config.backendType;
   if (backendType === "ollama") {
@@ -17183,8 +19069,8 @@ async function serveVllm(opts, config) {
   await runVllmServer(args, opts.verbose ?? false);
 }
 async function runVllmServer(args, verbose) {
-  return new Promise((resolve16, reject) => {
-    const child = spawn6("python", args, {
+  return new Promise((resolve18, reject) => {
+    const child = spawn7("python", args, {
       stdio: verbose ? "inherit" : ["ignore", "pipe", "pipe"],
       env: { ...process.env }
     });
@@ -17218,10 +19104,10 @@ async function runVllmServer(args, verbose) {
     child.once("exit", (code, signal) => {
       if (signal) {
         printInfo(`vLLM server stopped by signal ${signal}`);
-        resolve16();
+        resolve18();
       } else if (code === 0) {
         printSuccess("vLLM server exited cleanly");
-        resolve16();
+        resolve18();
       } else {
         printError(`vLLM server exited with code ${code}`);
         reject(new Error(`vLLM exited with code ${code}`));
@@ -17248,9 +19134,9 @@ var eval_exports = {};
 __export(eval_exports, {
   evalCommand: () => evalCommand
 });
-import { tmpdir as tmpdir3 } from "node:os";
+import { tmpdir as tmpdir4 } from "node:os";
 import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join26 } from "node:path";
+import { join as join28 } from "node:path";
 async function evalCommand(opts, config) {
   const suiteName = opts.suite ?? "basic";
   const suite = SUITES[suiteName];
@@ -17371,9 +19257,9 @@ async function evalCommand(opts, config) {
   process.exit(failed > 0 ? 1 : 0);
 }
 function createTempEvalRepo() {
-  const dir = join26(tmpdir3(), `open-agents-eval-${Date.now()}`);
+  const dir = join28(tmpdir4(), `open-agents-eval-${Date.now()}`);
   mkdirSync11(dir, { recursive: true });
-  writeFileSync10(join26(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
+  writeFileSync10(join28(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
   return dir;
 }
 var BASIC_SUITE, FULL_SUITE, SUITES;
@@ -17432,8 +19318,8 @@ init_output();
 init_updater();
 import { parseArgs as nodeParseArgs2 } from "node:util";
 import { createRequire as createRequire3 } from "node:module";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { dirname as dirname4, join as join27 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { dirname as dirname6, join as join29 } from "node:path";
 
 // packages/cli/dist/cli.js
 import { createInterface } from "node:readline";
@@ -17540,7 +19426,7 @@ init_output();
 function getVersion2() {
   try {
     const require2 = createRequire3(import.meta.url);
-    const pkgPath = join27(dirname4(fileURLToPath2(import.meta.url)), "..", "package.json");
+    const pkgPath = join29(dirname6(fileURLToPath3(import.meta.url)), "..", "package.json");
     const pkg = require2(pkgPath);
     return pkg.version;
   } catch {