open-agents-ai 0.42.1 → 0.43.0

package/dist/index.js

@@ -1285,7 +1285,7 @@ ${stdinInput ?? ""}`);
       }
       runCommand(command, timeout, stdinInput) {
         const start = performance.now();
-        return new Promise((resolve26) => {
+        return new Promise((resolve27) => {
           const child = spawn("bash", ["-c", command], {
             cwd: this.workingDir,
             env: {
@@ -1313,7 +1313,7 @@ ${stdinInput ?? ""}`);
             clearTimeout(timer);
             if (exitFlushTimer)
               clearTimeout(exitFlushTimer);
-            resolve26(result);
+            resolve27(result);
           };
           const timer = setTimeout(() => {
             killed = true;
@@ -2317,7 +2317,7 @@ Meta: ${metaKeys.map((k) => `${k}="${meta[k]?.slice(0, 80)}"`).join(", ")}`);
         return null;
       }
       runProcess(cmd, args, timeoutMs) {
-        return new Promise((resolve26, reject) => {
+        return new Promise((resolve27, reject) => {
           const proc = execFile3(cmd, args, {
             timeout: timeoutMs,
             maxBuffer: 10 * 1024 * 1024,
@@ -2327,7 +2327,7 @@ Meta: ${metaKeys.map((k) => `${k}="${meta[k]?.slice(0, 80)}"`).join(", ")}`);
               reject(new Error(`Process timeout after ${timeoutMs}ms`));
               return;
             }
-            resolve26({
+            resolve27({
               stdout: String(stdout),
               stderr: String(stderr),
               exitCode: error ? error.code ?? 1 : 0
@@ -5361,7 +5361,7 @@ var init_custom_tool = __esm({
       }
       /** Execute a single shell command and return output */
       runCommand(command) {
-        return new Promise((resolve26) => {
+        return new Promise((resolve27) => {
           const child = spawn3("bash", ["-c", command], {
             cwd: this.workingDir,
             env: { ...process.env, CI: "true", NO_COLOR: "1" },
@@ -5386,11 +5386,11 @@ var init_custom_tool = __esm({
               child.kill("SIGTERM");
             } catch {
             }
-            resolve26({ success: false, output: stdout, error: "Command timed out after 60s" });
+            resolve27({ success: false, output: stdout, error: "Command timed out after 60s" });
           }, 6e4);
           child.on("close", (code) => {
             clearTimeout(timer);
-            resolve26({
+            resolve27({
               success: code === 0,
               output: stdout + (stderr && code === 0 ? `
 STDERR:
@@ -5400,7 +5400,7 @@ ${stderr}` : ""),
           });
           child.on("error", (err) => {
             clearTimeout(timer);
-            resolve26({ success: false, output: stdout, error: err.message });
+            resolve27({ success: false, output: stdout, error: err.message });
           });
         });
       }
@@ -6582,7 +6582,7 @@ import { writeFile as writeFile7, mkdtemp, rm, readdir as readdir2, stat } from
 import { join as join16 } from "node:path";
 import { tmpdir as tmpdir2 } from "node:os";
 function runProcess(cmd, args, options) {
-  return new Promise((resolve26) => {
+  return new Promise((resolve27) => {
     const proc = spawn5(cmd, args, {
       cwd: options.cwd,
       timeout: options.timeout,
@@ -6612,7 +6612,7 @@ function runProcess(cmd, args, options) {
       }
     });
     proc.on("error", (err) => {
-      resolve26({
+      resolve27({
         stdout,
         stderr: stderr || err.message,
         exitCode: 1,
@@ -6624,7 +6624,7 @@ function runProcess(cmd, args, options) {
       if (signal === "SIGTERM" || signal === "SIGKILL") {
         timedOut = true;
       }
-      resolve26({
+      resolve27({
         stdout,
         stderr,
         exitCode: code ?? (timedOut ? 124 : 1),
@@ -8907,10 +8907,524 @@ var init_browser_action = __esm({
   }
 });
 
+// packages/execution/dist/tools/autoresearch.js
+import { execSync as execSync16, spawn as spawn8 } from "node:child_process";
+import { existsSync as existsSync19, readFileSync as readFileSync14, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, appendFileSync, copyFileSync } from "node:fs";
+import { join as join22, resolve as resolve20, dirname as dirname9 } from "node:path";
+import { fileURLToPath as fileURLToPath6 } from "node:url";
+function findAutoresearchScript(scriptName) {
+  const thisDir = dirname9(fileURLToPath6(import.meta.url));
+  const devPath = resolve20(thisDir, "../../scripts", scriptName);
+  if (existsSync19(devPath))
+    return devPath;
+  const bundledPath = resolve20(thisDir, "../scripts", scriptName);
+  if (existsSync19(bundledPath))
+    return bundledPath;
+  const sameDirPath = resolve20(thisDir, scriptName);
+  if (existsSync19(sameDirPath))
+    return sameDirPath;
+  return null;
+}
+function parseRunLog(logContent) {
+  const lines = logContent.split("\n");
+  const result = {};
+  for (const line of lines) {
+    const match = line.match(/^(\w+):\s+([\d.]+)/);
+    if (match) {
+      result[match[1]] = parseFloat(match[2]);
+    }
+  }
+  if (!result["val_bpb"])
+    return null;
+  return {
+    val_bpb: result["val_bpb"],
+    training_seconds: result["training_seconds"] ?? 0,
+    total_seconds: result["total_seconds"] ?? 0,
+    peak_vram_mb: result["peak_vram_mb"] ?? 0,
+    mfu_percent: result["mfu_percent"] ?? 0,
+    total_tokens_M: result["total_tokens_M"] ?? 0,
+    num_steps: result["num_steps"] ?? 0,
+    num_params_M: result["num_params_M"] ?? 0,
+    depth: result["depth"] ?? 0
+  };
+}
+var AutoresearchTool;
+var init_autoresearch = __esm({
+  "packages/execution/dist/tools/autoresearch.js"() {
+    "use strict";
+    AutoresearchTool = class {
+      repoRoot;
+      name = "autoresearch";
+      description = `Autonomous ML research experimentation (based on Karpathy's autoresearch).
+
+Actions:
+- setup: Initialize workspace with training scripts, install deps, download data
+- run: Execute a single 5-minute training experiment, return parsed metrics
+- results: Show experiment history from results.tsv
+- status: Check workspace state (GPU, branch, last result)
+- keep: Record current experiment as keeper in results.tsv and commit
+- discard: Revert train.py to last committed state
+
+The agent modifies train.py between experiments using file_edit. This tool handles infrastructure.
+Requires: NVIDIA GPU, Python 3.10+, uv (astral.sh package manager).`;
+      parameters = {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["setup", "run", "results", "status", "keep", "discard"],
+            description: "Action to perform"
+          },
+          workspace: {
+            type: "string",
+            description: "Path to autoresearch workspace (default: .oa/autoresearch)"
+          },
+          tag: {
+            type: "string",
+            description: "Experiment tag for git branch (setup action, e.g. 'mar14')"
+          },
+          description: {
+            type: "string",
+            description: "Short description of the experiment (keep/discard actions)"
+          },
+          val_bpb: {
+            type: "number",
+            description: "val_bpb result to record (keep/discard actions \u2014 auto-detected from last run if omitted)"
+          },
+          memory_gb: {
+            type: "number",
+            description: "Peak memory in GB (keep/discard actions \u2014 auto-detected from last run if omitted)"
+          },
+          num_shards: {
+            type: "number",
+            description: "Number of data shards to download (setup action, default: 10)"
+          },
+          timeout_minutes: {
+            type: "number",
+            description: "Max wall-clock minutes for a run (default: 10, kills if exceeded)"
+          }
+        },
+        required: ["action"]
+      };
+      constructor(repoRoot) {
+        this.repoRoot = repoRoot;
+      }
+      async execute(args) {
+        const start = Date.now();
+        const action = String(args["action"] ?? "status");
+        const workspacePath = String(args["workspace"] ?? join22(this.repoRoot, ".oa", "autoresearch"));
+        try {
+          switch (action) {
+            case "setup":
+              return await this.setup(workspacePath, args, start);
+            case "run":
+              return await this.run(workspacePath, args, start);
+            case "results":
+              return this.getResults(workspacePath, start);
+            case "status":
+              return this.getStatus(workspacePath, start);
+            case "keep":
+              return this.keepExperiment(workspacePath, args, start);
+            case "discard":
+              return this.discardExperiment(workspacePath, args, start);
+            default:
+              return { success: false, output: "", error: `Unknown action: ${action}. Use: setup, run, results, status, keep, discard`, durationMs: Date.now() - start };
+          }
+        } catch (err) {
+          return { success: false, output: "", error: String(err), durationMs: Date.now() - start };
+        }
+      }
+      // ── Setup ──────────────────────────────────────────────────────────────
+      async setup(workspace, args, start) {
+        const output = [];
+        try {
+          execSync16("which uv", { encoding: "utf-8", timeout: 5e3 });
+          output.push("uv: found");
+        } catch {
+          return { success: false, output: "", error: "uv not found. Install with: curl -LsSf https://astral.sh/uv/install.sh | sh", durationMs: Date.now() - start };
+        }
+        try {
+          const gpuInfo = execSync16("nvidia-smi --query-gpu=name,memory.total --format=csv,noheader 2>/dev/null || echo 'no GPU'", { encoding: "utf-8", timeout: 1e4 }).trim();
+          output.push(`GPU: ${gpuInfo}`);
+        } catch {
+          output.push("GPU: detection failed (nvidia-smi not available)");
+        }
+        mkdirSync5(workspace, { recursive: true });
+        const prepareScript = findAutoresearchScript("autoresearch-prepare.py");
+        const trainScript = findAutoresearchScript("autoresearch-train.py");
+        if (prepareScript) {
+          copyFileSync(prepareScript, join22(workspace, "prepare.py"));
+          output.push("Copied prepare.py template");
+        } else {
+          return { success: false, output: output.join("\n"), error: "autoresearch-prepare.py template not found in distribution", durationMs: Date.now() - start };
+        }
+        if (trainScript) {
+          copyFileSync(trainScript, join22(workspace, "train.py"));
+          output.push("Copied train.py template");
+        } else {
+          return { success: false, output: output.join("\n"), error: "autoresearch-train.py template not found in distribution", durationMs: Date.now() - start };
+        }
+        const pyprojectContent = `[project]
+name = "autoresearch"
+version = "0.1.0"
+description = "Autonomous pretraining research"
+requires-python = ">=3.10"
+dependencies = [
+    "kernels>=0.11.7",
+    "matplotlib>=3.10.8",
+    "numpy>=2.2.6",
+    "pandas>=2.3.3",
+    "pyarrow>=21.0.0",
+    "requests>=2.32.0",
+    "rustbpe>=0.1.0",
+    "tiktoken>=0.11.0",
+    "torch==2.9.1",
+]
+
+[tool.uv.sources]
+torch = [
+    { index = "pytorch-cu128" },
+]
+
+[[tool.uv.index]]
+name = "pytorch-cu128"
+url = "https://download.pytorch.org/whl/cu128"
+explicit = true
+`;
+        writeFileSync5(join22(workspace, "pyproject.toml"), pyprojectContent, "utf-8");
+        output.push("Created pyproject.toml");
+        try {
+          execSync16("git rev-parse --git-dir", { cwd: workspace, encoding: "utf-8", timeout: 5e3 });
+          output.push("Git: already initialized");
+        } catch {
+          execSync16("git init && git add -A && git commit -m 'autoresearch: initial setup'", {
+            cwd: workspace,
+            encoding: "utf-8",
+            timeout: 1e4
+          });
+          output.push("Git: initialized with initial commit");
+        }
+        const tag = String(args["tag"] ?? (/* @__PURE__ */ new Date()).toISOString().slice(5, 10).replace("-", ""));
+        const branchName = `autoresearch/${tag}`;
+        try {
+          execSync16(`git checkout -b ${branchName}`, { cwd: workspace, encoding: "utf-8", timeout: 5e3 });
+          output.push(`Branch: created ${branchName}`);
+        } catch {
+          output.push(`Branch: ${branchName} may already exist, staying on current branch`);
+        }
+        output.push("Installing dependencies with uv sync (this may take a while)...");
+        try {
+          const uvOut = execSync16("uv sync 2>&1", { cwd: workspace, encoding: "utf-8", timeout: 3e5 });
+          output.push(`uv sync: ${uvOut.trim().split("\n").slice(-3).join(" | ")}`);
+        } catch (err) {
+          const e = err;
+          output.push(`uv sync warning: ${(e.stderr ?? e.stdout ?? "failed").slice(0, 500)}`);
+        }
+        const numShards = Number(args["num_shards"] ?? 10);
+        output.push(`Preparing data (${numShards} shards)...`);
+        try {
+          const prepOut = execSync16(`uv run prepare.py --num-shards ${numShards} 2>&1`, {
+            cwd: workspace,
+            encoding: "utf-8",
+            timeout: 6e5
+          });
+          output.push(`Data prep: ${prepOut.trim().split("\n").slice(-3).join(" | ")}`);
+        } catch (err) {
+          const e = err;
+          output.push(`Data prep warning: ${(e.stderr ?? e.stdout ?? "failed").slice(0, 500)}`);
+        }
+        const tsvPath = join22(workspace, "results.tsv");
+        if (!existsSync19(tsvPath)) {
+          writeFileSync5(tsvPath, "commit	val_bpb	memory_gb	status	description\n", "utf-8");
+          output.push("Created results.tsv");
+        }
+        return {
+          success: true,
+          output: `Autoresearch workspace ready at ${workspace}
+
+${output.join("\n")}
+
+Next steps:
+1. Run baseline: autoresearch(action="run") \u2014 establishes starting val_bpb
+2. Record baseline: autoresearch(action="keep", description="baseline")
+3. Modify train.py with file_edit, then run again
+4. Keep or discard based on val_bpb improvement
+5. Repeat \u2014 iteration beats perfection!`,
+          durationMs: Date.now() - start
+        };
+      }
+      // ── Run experiment ─────────────────────────────────────────────────────
+      async run(workspace, args, start) {
+        if (!existsSync19(join22(workspace, "train.py"))) {
+          return { success: false, output: "", error: `No train.py found in ${workspace}. Run autoresearch(action="setup") first.`, durationMs: Date.now() - start };
+        }
+        const timeoutMin = Number(args["timeout_minutes"] ?? 10);
+        const timeoutMs = timeoutMin * 60 * 1e3;
+        const logPath = join22(workspace, "run.log");
+        return new Promise((resolveResult) => {
+          const proc = spawn8("uv", ["run", "train.py"], {
+            cwd: workspace,
+            timeout: timeoutMs,
+            stdio: ["pipe", "pipe", "pipe"],
+            env: { ...process.env, PYTORCH_ALLOC_CONF: "expandable_segments:True" }
+          });
+          let stdout = "";
+          let stderr = "";
+          let timedOut = false;
+          proc.stdout.on("data", (d) => {
+            stdout += d.toString();
+            if (stdout.length > 5e5) {
+              stdout = stdout.slice(-2e5);
+            }
+          });
+          proc.stderr.on("data", (d) => {
+            stderr += d.toString();
+            if (stderr.length > 1e5) {
+              stderr = stderr.slice(-5e4);
+            }
+          });
+          const timer = setTimeout(() => {
+            timedOut = true;
+            proc.kill("SIGKILL");
+          }, timeoutMs);
+          proc.on("close", (code) => {
+            clearTimeout(timer);
+            const fullLog = stdout + "\n" + stderr;
+            try {
+              writeFileSync5(logPath, fullLog, "utf-8");
+            } catch {
+            }
+            if (timedOut) {
+              resolveResult({
+                success: false,
+                output: `Experiment timed out after ${timeoutMin} minutes.
+Last output:
+${fullLog.slice(-2e3)}`,
+                error: "Training exceeded timeout \u2014 treat as failed experiment",
+                durationMs: Date.now() - start
+              });
+              return;
+            }
+            if (code !== 0) {
+              const tail = fullLog.split("\n").slice(-50).join("\n");
+              resolveResult({
+                success: false,
+                output: `Experiment crashed (exit code ${code}).
+
+Last 50 lines:
+${tail}`,
+                error: "Training crashed \u2014 check the error above, fix train.py, and re-run",
+                durationMs: Date.now() - start
+              });
+              return;
+            }
+            const result = parseRunLog(fullLog);
+            if (!result) {
+              resolveResult({
+                success: false,
+                output: `Experiment completed but no val_bpb found in output.
+Log tail:
+${fullLog.slice(-2e3)}`,
+                error: "Could not parse experiment results",
+                durationMs: Date.now() - start
+              });
+              return;
+            }
+            try {
+              writeFileSync5(join22(workspace, ".last-result.json"), JSON.stringify(result, null, 2), "utf-8");
+            } catch {
+            }
+            const memGB = (result.peak_vram_mb / 1024).toFixed(1);
+            const output = [
+              `Experiment complete!`,
+              ``,
+              `val_bpb:          ${result.val_bpb.toFixed(6)}`,
+              `training_seconds: ${result.training_seconds.toFixed(1)}`,
+              `total_seconds:    ${result.total_seconds.toFixed(1)}`,
+              `peak_vram_mb:     ${result.peak_vram_mb.toFixed(1)} (${memGB} GB)`,
+              `mfu_percent:      ${result.mfu_percent.toFixed(2)}`,
+              `total_tokens_M:   ${result.total_tokens_M.toFixed(1)}`,
+              `num_steps:        ${result.num_steps}`,
+              `num_params_M:     ${result.num_params_M.toFixed(1)}`,
+              `depth:            ${result.depth}`,
+              ``,
+              `Next: Compare val_bpb to previous best.`,
+              `  If improved: autoresearch(action="keep", description="what you changed")`,
+              `  If worse:    autoresearch(action="discard", description="what you tried")`
+            ].join("\n");
+            resolveResult({ success: true, output, durationMs: Date.now() - start });
+          });
+          proc.on("error", (err) => {
+            clearTimeout(timer);
+            resolveResult({
+              success: false,
+              output: "",
+              error: `Failed to start training: ${err.message}. Is uv installed and GPU available?`,
+              durationMs: Date.now() - start
+            });
+          });
+        });
+      }
+      // ── Results ────────────────────────────────────────────────────────────
+      getResults(workspace, start) {
+        const tsvPath = join22(workspace, "results.tsv");
+        if (!existsSync19(tsvPath)) {
+          return { success: false, output: "", error: `No results.tsv found. Run autoresearch(action="setup") first.`, durationMs: Date.now() - start };
+        }
+        const content = readFileSync14(tsvPath, "utf-8");
+        const lines = content.trim().split("\n");
+        if (lines.length <= 1) {
+          return { success: true, output: 'No experiments recorded yet. Run autoresearch(action="run") to start.', durationMs: Date.now() - start };
+        }
+        const experiments = lines.slice(1).map((line) => {
+          const [commit, bpb, mem, status, desc] = line.split("	");
+          return { commit, val_bpb: parseFloat(bpb ?? "0"), memory_gb: parseFloat(mem ?? "0"), status, description: desc };
+        });
+        const kept = experiments.filter((e) => e.status === "keep");
+        const best = kept.reduce((a, b) => a.val_bpb < b.val_bpb && a.val_bpb > 0 ? a : b, kept[0]);
+        const summary = [
+          `Experiments: ${experiments.length} total, ${kept.length} kept, ${experiments.filter((e) => e.status === "discard").length} discarded, ${experiments.filter((e) => e.status === "crash").length} crashed`,
+          `Best val_bpb: ${best?.val_bpb?.toFixed(6) ?? "N/A"} (${best?.description ?? "N/A"})`,
+          ``,
+          `Full history:`,
+          content
+        ].join("\n");
+        return { success: true, output: summary, durationMs: Date.now() - start };
+      }
+      // ── Status ─────────────────────────────────────────────────────────────
+      getStatus(workspace, start) {
+        const output = [];
+        if (!existsSync19(join22(workspace, "train.py"))) {
+          return {
+            success: true,
+            output: `Autoresearch workspace not initialized at ${workspace}.
+Run autoresearch(action="setup") to begin.`,
+            durationMs: Date.now() - start
+          };
+        }
+        output.push(`Workspace: ${workspace}`);
+        try {
+          const branch = execSync16("git branch --show-current", { cwd: workspace, encoding: "utf-8", timeout: 5e3 }).trim();
+          output.push(`Branch: ${branch}`);
+          const lastCommit = execSync16("git log --oneline -1", { cwd: workspace, encoding: "utf-8", timeout: 5e3 }).trim();
+          output.push(`Last commit: ${lastCommit}`);
+        } catch {
+          output.push("Git: not initialized");
+        }
+        try {
+          const gpuInfo = execSync16("nvidia-smi --query-gpu=name,memory.total,memory.used --format=csv,noheader 2>/dev/null", { encoding: "utf-8", timeout: 1e4 }).trim();
+          output.push(`GPU: ${gpuInfo}`);
+        } catch {
+          output.push("GPU: not detected");
+        }
+        const lastResultPath = join22(workspace, ".last-result.json");
+        if (existsSync19(lastResultPath)) {
+          try {
+            const last = JSON.parse(readFileSync14(lastResultPath, "utf-8"));
+            output.push(`Last experiment: val_bpb=${last.val_bpb.toFixed(6)}, ${(last.peak_vram_mb / 1024).toFixed(1)}GB VRAM, ${last.num_params_M.toFixed(1)}M params`);
+          } catch {
+          }
+        }
+        const tsvPath = join22(workspace, "results.tsv");
+        if (existsSync19(tsvPath)) {
+          const lines = readFileSync14(tsvPath, "utf-8").trim().split("\n");
+          output.push(`Experiments recorded: ${lines.length - 1}`);
+        }
+        const cacheDir = join22(process.env["HOME"] ?? "~", ".cache", "autoresearch");
+        output.push(`Data cache: ${existsSync19(cacheDir) ? "present" : "not found"} (${cacheDir})`);
+        return { success: true, output: output.join("\n"), durationMs: Date.now() - start };
+      }
+      // ── Keep / Discard ─────────────────────────────────────────────────────
+      keepExperiment(workspace, args, start) {
+        const desc = String(args["description"] ?? "experiment");
+        const tsvPath = join22(workspace, "results.tsv");
+        const lastResultPath = join22(workspace, ".last-result.json");
+        let valBpb = args["val_bpb"];
+        let memGb = args["memory_gb"];
+        if ((valBpb === void 0 || memGb === void 0) && existsSync19(lastResultPath)) {
+          try {
+            const last = JSON.parse(readFileSync14(lastResultPath, "utf-8"));
+            if (valBpb === void 0)
+              valBpb = last.val_bpb;
+            if (memGb === void 0)
+              memGb = parseFloat((last.peak_vram_mb / 1024).toFixed(1));
+          } catch {
+          }
+        }
+        valBpb = valBpb ?? 0;
+        memGb = memGb ?? 0;
+        let commitHash = "0000000";
+        try {
+          execSync16("git add train.py", { cwd: workspace, encoding: "utf-8", timeout: 5e3 });
+          execSync16(`git commit -m "autoresearch: ${desc}"`, { cwd: workspace, encoding: "utf-8", timeout: 1e4 });
+          commitHash = execSync16("git rev-parse --short HEAD", { cwd: workspace, encoding: "utf-8", timeout: 5e3 }).trim();
+        } catch {
+          try {
+            commitHash = execSync16("git rev-parse --short HEAD", { cwd: workspace, encoding: "utf-8", timeout: 5e3 }).trim();
+          } catch {
+          }
+        }
+        const row = `${commitHash}	${valBpb.toFixed(6)}	${memGb.toFixed(1)}	keep	${desc}
+`;
+        appendFileSync(tsvPath, row, "utf-8");
+        return {
+          success: true,
+          output: `Kept: ${commitHash} | val_bpb=${valBpb.toFixed(6)} | ${memGb.toFixed(1)}GB | ${desc}
+Branch advanced. Ready for next experiment.`,
+          durationMs: Date.now() - start
+        };
+      }
+      discardExperiment(workspace, args, start) {
+        const desc = String(args["description"] ?? "experiment");
+        const tsvPath = join22(workspace, "results.tsv");
+        const lastResultPath = join22(workspace, ".last-result.json");
+        let valBpb = args["val_bpb"];
+        let memGb = args["memory_gb"];
+        if ((valBpb === void 0 || memGb === void 0) && existsSync19(lastResultPath)) {
+          try {
+            const last = JSON.parse(readFileSync14(lastResultPath, "utf-8"));
+            if (valBpb === void 0)
+              valBpb = last.val_bpb;
+            if (memGb === void 0)
+              memGb = parseFloat((last.peak_vram_mb / 1024).toFixed(1));
+          } catch {
+          }
+        }
+        valBpb = valBpb ?? 0;
+        memGb = memGb ?? 0;
+        let commitHash = "0000000";
+        try {
+          commitHash = execSync16("git rev-parse --short HEAD", { cwd: workspace, encoding: "utf-8", timeout: 5e3 }).trim();
+        } catch {
+        }
+        const row = `${commitHash}	${valBpb.toFixed(6)}	${memGb.toFixed(1)}	discard	${desc}
+`;
+        appendFileSync(tsvPath, row, "utf-8");
+        try {
+          execSync16("git checkout -- train.py", { cwd: workspace, encoding: "utf-8", timeout: 5e3 });
+        } catch {
+          return {
+            success: false,
+            output: `Recorded discard but failed to revert train.py`,
+            error: "git checkout -- train.py failed",
+            durationMs: Date.now() - start
+          };
+        }
+        return {
+          success: true,
+          output: `Discarded: val_bpb=${valBpb.toFixed(6)} | ${memGb.toFixed(1)}GB | ${desc}
+train.py reverted to last kept state. Ready for next experiment.`,
+          durationMs: Date.now() - start
+        };
+      }
+    };
+  }
+});
+
 // packages/execution/dist/tools/scheduler.js
-import { execSync as execSync16, exec as execCb } from "node:child_process";
+import { execSync as execSync17, exec as execCb } from "node:child_process";
 import { readFile as readFile9, writeFile as writeFile8, mkdir as mkdir4 } from "node:fs/promises";
-import { resolve as resolve20, join as join22 } from "node:path";
+import { resolve as resolve21, join as join23 } from "node:path";
 import { randomBytes as randomBytes2 } from "node:crypto";
 function isValidCron(expr) {
   const parts = expr.trim().split(/\s+/);
@@ -8970,19 +9484,19 @@ function describeCron(expr) {
 }
 function getCurrentCrontab() {
   try {
-    return execSync16("crontab -l 2>/dev/null", { stdio: "pipe" }).toString().split("\n");
+    return execSync17("crontab -l 2>/dev/null", { stdio: "pipe" }).toString().split("\n");
   } catch {
     return [];
   }
 }
 function writeCrontab(lines) {
   const content = lines.join("\n") + "\n";
-  execSync16(`echo ${JSON.stringify(content)} | crontab -`, { stdio: "pipe" });
+  execSync17(`echo ${JSON.stringify(content)} | crontab -`, { stdio: "pipe" });
 }
 function findOaBinary() {
   for (const cmd of ["oa", "open-agents"]) {
     try {
-      const path = execSync16(`which ${cmd} 2>/dev/null`, { stdio: "pipe" }).toString().trim();
+      const path = execSync17(`which ${cmd} 2>/dev/null`, { stdio: "pipe" }).toString().trim();
       if (path)
         return path;
     } catch {
@@ -8993,8 +9507,8 @@ function findOaBinary() {
 function installCronJob(task, workingDir) {
   const lines = getCurrentCrontab();
   const oaBin = findOaBinary();
-  const logDir = resolve20(workingDir, ".oa", "scheduled", "logs");
-  const logFile = join22(logDir, `${task.id}.log`);
+  const logDir = resolve21(workingDir, ".oa", "scheduled", "logs");
+  const logFile = join23(logDir, `${task.id}.log`);
   const cronLine = `${task.schedule} cd ${JSON.stringify(workingDir)} && ${oaBin} ${JSON.stringify(task.task)} >> ${JSON.stringify(logFile)} 2>&1 ${CRON_MARKER}${task.id}`;
   const filtered = lines.filter((l) => !l.includes(`${CRON_MARKER}${task.id}`));
   filtered.push(cronLine);
@@ -9014,7 +9528,7 @@ function listCronJobs() {
   });
 }
 async function loadStore(workingDir) {
-  const storePath = resolve20(workingDir, ".oa", "scheduled", "tasks.json");
+  const storePath = resolve21(workingDir, ".oa", "scheduled", "tasks.json");
   try {
     const raw = await readFile9(storePath, "utf-8");
     return JSON.parse(raw);
@@ -9023,11 +9537,11 @@ async function loadStore(workingDir) {
   }
 }
 async function saveStore(workingDir, store) {
-  const dir = resolve20(workingDir, ".oa", "scheduled");
+  const dir = resolve21(workingDir, ".oa", "scheduled");
   await mkdir4(dir, { recursive: true });
-  await mkdir4(join22(dir, "logs"), { recursive: true });
+  await mkdir4(join23(dir, "logs"), { recursive: true });
   store.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await writeFile8(join22(dir, "tasks.json"), JSON.stringify(store, null, 2), "utf-8");
+  await writeFile8(join23(dir, "tasks.json"), JSON.stringify(store, null, 2), "utf-8");
 }
 var SCHEDULE_PRESETS, CRON_MARKER, SchedulerTool;
 var init_scheduler = __esm({
@@ -9245,7 +9759,7 @@ var init_scheduler = __esm({
         const id = String(args["id"] ?? "");
         if (!id)
           return { success: false, output: "", error: "id is required for logs action", durationMs: performance.now() - start };
-        const logFile = resolve20(this.workingDir, ".oa", "scheduled", "logs", `${id}.log`);
+        const logFile = resolve21(this.workingDir, ".oa", "scheduled", "logs", `${id}.log`);
         try {
           const raw = await readFile9(logFile, "utf-8");
           const truncated = raw.length > 1e4 ? "...(truncated)\n" + raw.slice(-1e4) : raw;
@@ -9261,7 +9775,7 @@ ${truncated}`, durationMs: performance.now() - start };
 
 // packages/execution/dist/tools/reminder.js
 import { readFile as readFile10, writeFile as writeFile9, mkdir as mkdir5 } from "node:fs/promises";
-import { resolve as resolve21, join as join23 } from "node:path";
+import { resolve as resolve22, join as join24 } from "node:path";
 import { randomBytes as randomBytes3 } from "node:crypto";
 function parseDueTime(due) {
   const lower = due.toLowerCase().trim();
@@ -9311,9 +9825,9 @@ function parseDueTime(due) {
   return null;
 }
 async function getStorePath(workingDir) {
-  const dir = resolve21(workingDir, ".oa", "scheduled");
+  const dir = resolve22(workingDir, ".oa", "scheduled");
   await mkdir5(dir, { recursive: true });
-  return join23(dir, STORE_FILE);
+  return join24(dir, STORE_FILE);
 }
 async function loadReminderStore(workingDir) {
   const storePath = await getStorePath(workingDir);
@@ -9574,10 +10088,10 @@ var init_reminder = __esm({
 
 // packages/execution/dist/tools/agenda.js
 import { readFile as readFile11, writeFile as writeFile10, mkdir as mkdir6 } from "node:fs/promises";
-import { resolve as resolve22, join as join24 } from "node:path";
+import { resolve as resolve23, join as join25 } from "node:path";
 import { randomBytes as randomBytes4 } from "node:crypto";
 async function loadAttentionStore(workingDir) {
-  const storePath = resolve22(workingDir, ".oa", "scheduled", "attention.json");
+  const storePath = resolve23(workingDir, ".oa", "scheduled", "attention.json");
   try {
     const raw = await readFile11(storePath, "utf-8");
     return JSON.parse(raw);
@@ -9586,10 +10100,10 @@ async function loadAttentionStore(workingDir) {
   }
 }
 async function saveAttentionStore(workingDir, store) {
-  const dir = resolve22(workingDir, ".oa", "scheduled");
+  const dir = resolve23(workingDir, ".oa", "scheduled");
   await mkdir6(dir, { recursive: true });
   store.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await writeFile10(join24(dir, "attention.json"), JSON.stringify(store, null, 2), "utf-8");
+  await writeFile10(join25(dir, "attention.json"), JSON.stringify(store, null, 2), "utf-8");
 }
 async function getActiveAttentionItems(workingDir) {
   const store = await loadAttentionStore(workingDir);
@@ -9884,7 +10398,7 @@ ${sections.join("\n")}`,
       }
       async loadScheduleStore() {
         try {
-          const storePath = resolve22(this.workingDir, ".oa", "scheduled", "tasks.json");
+          const storePath = resolve23(this.workingDir, ".oa", "scheduled", "tasks.json");
           const raw = await readFile11(storePath, "utf-8");
           const store = JSON.parse(raw);
           return store.tasks ?? [];
@@ -10012,6 +10526,7 @@ var init_dist2 = __esm({
     init_pdf_to_text();
     init_ocr_image_advanced();
     init_browser_action();
+    init_autoresearch();
     init_scheduler();
     init_reminder();
     init_agenda();
@@ -11147,7 +11662,7 @@ var init_code_retriever = __esm({
 import { execFile as execFile5 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
 import { readFile as readFile12, readdir as readdir3, stat as stat3 } from "node:fs/promises";
-import { join as join25, extname as extname7 } from "node:path";
+import { join as join26, extname as extname7 } 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;
@@ -11289,7 +11804,7 @@ async function walkForFiles(rootDir, dir, excludeGlobs, results) {
       continue;
     if (excludeGlobs.some((g) => entry.name === g || matchesGlob(entry.name, g)))
       continue;
-    const absPath = join25(dir, entry.name);
+    const absPath = join26(dir, entry.name);
     if (entry.isDirectory()) {
       await walkForFiles(rootDir, absPath, excludeGlobs, results);
     } else if (entry.isFile()) {
@@ -11596,7 +12111,7 @@ var init_graphExpand = __esm({
 
 // packages/retrieval/dist/snippetPacker.js
 import { readFile as readFile13 } from "node:fs/promises";
-import { join as join26 } from "node:path";
+import { join as join27 } from "node:path";
 async function packSnippets(requests, opts = {}) {
   const maxTokens = opts.maxTokens ?? DEFAULT_MAX_TOKENS;
   const contextLines = opts.contextLines ?? DEFAULT_CONTEXT_LINES;
@@ -11622,7 +12137,7 @@ 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 : join26(repoRoot, req.filePath);
+  const absPath = req.filePath.startsWith("/") ? req.filePath : join27(repoRoot, req.filePath);
   let content;
   try {
     content = await readFile13(absPath, "utf-8");
@@ -13358,8 +13873,8 @@ Rules:
       async waitIfPaused() {
         if (!this._paused)
           return true;
-        await new Promise((resolve26) => {
-          this._pauseResolve = resolve26;
+        await new Promise((resolve27) => {
+          this._pauseResolve = resolve27;
         });
         return !this.aborted;
       }
@@ -13939,14 +14454,14 @@ ${result.output}`;
       waitForSudoPassword(timeoutMs = 12e4) {
         if (this._sudoPassword)
           return Promise.resolve(this._sudoPassword);
-        return new Promise((resolve26) => {
+        return new Promise((resolve27) => {
           const timer = setTimeout(() => {
             this._sudoResolve = null;
-            resolve26(null);
+            resolve27(null);
           }, timeoutMs);
           this._sudoResolve = (pw) => {
             clearTimeout(timer);
-            resolve26(pw);
+            resolve27(pw);
           };
         });
       }
@@ -14068,10 +14583,10 @@ ${marker}` : marker);
         if (!this._workingDirectory)
           return;
         try {
-          const { mkdirSync: mkdirSync14, writeFileSync: writeFileSync13 } = __require("node:fs");
-          const { join: join43 } = __require("node:path");
-          const sessionDir = join43(this._workingDirectory, ".oa", "session", this._sessionId);
-          mkdirSync14(sessionDir, { recursive: true });
+          const { mkdirSync: mkdirSync15, writeFileSync: writeFileSync14 } = __require("node:fs");
+          const { join: join44 } = __require("node:path");
+          const sessionDir = join44(this._workingDirectory, ".oa", "session", this._sessionId);
+          mkdirSync15(sessionDir, { recursive: true });
           const checkpoint = {
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
             sessionId: this._sessionId,
@@ -14083,7 +14598,7 @@ ${marker}` : marker);
             memexEntryCount: this._memexArchive.size,
             fileRegistrySize: this._fileRegistry.size
           };
-          writeFileSync13(join43(sessionDir, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
+          writeFileSync14(join44(sessionDir, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
         } catch {
         }
       }
@@ -15621,11 +16136,11 @@ var init_dist5 = __esm({
 });
 
 // packages/cli/dist/tui/listen.js
-import { spawn as spawn8, execSync as execSync17 } from "node:child_process";
-import { existsSync as existsSync19, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5, readdirSync as readdirSync6 } from "node:fs";
-import { join as join27, dirname as dirname9 } from "node:path";
+import { spawn as spawn9, execSync as execSync18 } from "node:child_process";
+import { existsSync as existsSync20, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6, readdirSync as readdirSync6 } from "node:fs";
+import { join as join28, dirname as dirname10 } from "node:path";
 import { homedir as homedir8 } from "node:os";
-import { fileURLToPath as fileURLToPath6 } from "node:url";
+import { fileURLToPath as fileURLToPath7 } from "node:url";
 import { EventEmitter } from "node:events";
 import { createInterface as createInterface2 } from "node:readline";
 function isAudioPath(path) {
@@ -15643,7 +16158,7 @@ function findMicCaptureCommand() {
   const platform4 = process.platform;
   if (platform4 === "linux") {
     try {
-      execSync17("which arecord", { stdio: "pipe" });
+      execSync18("which arecord", { stdio: "pipe" });
       return {
         cmd: "arecord",
         args: ["-f", "S16_LE", "-r", "16000", "-c", "1", "-t", "raw", "-q", "-"]
@@ -15653,7 +16168,7 @@ function findMicCaptureCommand() {
   }
   if (platform4 === "darwin") {
     try {
-      execSync17("which sox", { stdio: "pipe" });
+      execSync18("which sox", { stdio: "pipe" });
       return {
         cmd: "sox",
         args: ["-d", "-t", "raw", "-r", "16000", "-c", "1", "-b", "16", "-e", "signed-integer", "-"]
@@ -15662,7 +16177,7 @@ function findMicCaptureCommand() {
     }
   }
   try {
-    execSync17("which ffmpeg", { stdio: "pipe" });
+    execSync18("which ffmpeg", { stdio: "pipe" });
     if (platform4 === "linux") {
       return {
         cmd: "ffmpeg",
@@ -15707,41 +16222,41 @@ function findMicCaptureCommand() {
   return null;
 }
 function findLiveWhisperScript() {
-  const thisDir = dirname9(fileURLToPath6(import.meta.url));
+  const thisDir = dirname10(fileURLToPath7(import.meta.url));
   const candidates = [
-    join27(thisDir, "../../../../packages/execution/scripts/live-whisper.py"),
-    join27(thisDir, "../../../packages/execution/scripts/live-whisper.py"),
-    join27(thisDir, "../../execution/scripts/live-whisper.py"),
+    join28(thisDir, "../../../../packages/execution/scripts/live-whisper.py"),
+    join28(thisDir, "../../../packages/execution/scripts/live-whisper.py"),
+    join28(thisDir, "../../execution/scripts/live-whisper.py"),
     // npm install layout — scripts bundled alongside dist
-    join27(thisDir, "../scripts/live-whisper.py"),
-    join27(thisDir, "../../scripts/live-whisper.py")
+    join28(thisDir, "../scripts/live-whisper.py"),
+    join28(thisDir, "../../scripts/live-whisper.py")
   ];
   for (const p of candidates) {
-    if (existsSync19(p))
+    if (existsSync20(p))
       return p;
   }
   try {
-    const globalRoot = execSync17("npm root -g", {
+    const globalRoot = execSync18("npm root -g", {
       encoding: "utf-8",
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     const candidates2 = [
-      join27(globalRoot, "open-agents-ai", "dist", "scripts", "live-whisper.py"),
-      join27(globalRoot, "open-agents-ai", "scripts", "live-whisper.py")
+      join28(globalRoot, "open-agents-ai", "dist", "scripts", "live-whisper.py"),
+      join28(globalRoot, "open-agents-ai", "scripts", "live-whisper.py")
     ];
     for (const p of candidates2) {
-      if (existsSync19(p))
+      if (existsSync20(p))
         return p;
     }
   } catch {
   }
-  const nvmBase = join27(homedir8(), ".nvm", "versions", "node");
-  if (existsSync19(nvmBase)) {
+  const nvmBase = join28(homedir8(), ".nvm", "versions", "node");
+  if (existsSync20(nvmBase)) {
     try {
       for (const ver of readdirSync6(nvmBase)) {
-        const p = join27(nvmBase, ver, "lib", "node_modules", "open-agents-ai", "dist", "scripts", "live-whisper.py");
-        if (existsSync19(p))
+        const p = join28(nvmBase, ver, "lib", "node_modules", "open-agents-ai", "dist", "scripts", "live-whisper.py");
+        if (existsSync20(p))
           return p;
       }
     } catch {
@@ -15754,21 +16269,21 @@ function ensureTranscribeCliBackground() {
     return;
   _bgInstallPromise = (async () => {
     try {
-      const globalRoot = execSync17("npm root -g", {
+      const globalRoot = execSync18("npm root -g", {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      if (existsSync19(join27(globalRoot, "transcribe-cli", "dist", "index.js"))) {
+      if (existsSync20(join28(globalRoot, "transcribe-cli", "dist", "index.js"))) {
         return true;
       }
     } catch {
     }
     try {
       const { exec } = await import("node:child_process");
-      return new Promise((resolve26) => {
+      return new Promise((resolve27) => {
         exec("npm i -g transcribe-cli", { timeout: 18e4 }, (err) => {
-          resolve26(!err);
+          resolve27(!err);
         });
       });
     } catch {
@@ -15821,11 +16336,11 @@ var init_listen = __esm({
         return this._ready;
       }
       async start() {
-        return new Promise((resolve26, reject) => {
+        return new Promise((resolve27, reject) => {
           const timeout = setTimeout(() => {
             reject(new Error("Whisper fallback: model load timeout (5 min). First run downloads the model."));
           }, 3e5);
-          this.process = spawn8("python3", [
+          this.process = spawn9("python3", [
             this.scriptPath,
             "--model",
             this.model,
@@ -15849,7 +16364,7 @@ var init_listen = __esm({
                   this._ready = true;
                   clearTimeout(timeout);
                   this.emit("ready");
-                  resolve26();
+                  resolve27();
                   break;
                 case "transcript":
                   this.emit("transcript", {
@@ -15954,7 +16469,7 @@ var init_listen = __esm({
         }
         if (!this.transcribeCliAvailable) {
           try {
-            execSync17("which transcribe-cli", { stdio: "pipe" });
+            execSync18("which transcribe-cli", { stdio: "pipe" });
             this.transcribeCliAvailable = true;
           } catch {
             this.transcribeCliAvailable = false;
@@ -15971,29 +16486,29 @@ var init_listen = __esm({
         } catch {
         }
         try {
-          const globalRoot = execSync17("npm root -g", {
+          const globalRoot = execSync18("npm root -g", {
             encoding: "utf-8",
             timeout: 5e3,
             stdio: ["pipe", "pipe", "pipe"]
           }).trim();
-          const tcPath = join27(globalRoot, "transcribe-cli");
-          if (existsSync19(join27(tcPath, "dist", "index.js"))) {
+          const tcPath = join28(globalRoot, "transcribe-cli");
+          if (existsSync20(join28(tcPath, "dist", "index.js"))) {
             const { createRequire: createRequire4 } = await import("node:module");
             const req = createRequire4(import.meta.url);
-            return req(join27(tcPath, "dist", "index.js"));
+            return req(join28(tcPath, "dist", "index.js"));
           }
         } catch {
         }
-        const nvmBase = join27(homedir8(), ".nvm", "versions", "node");
-        if (existsSync19(nvmBase)) {
+        const nvmBase = join28(homedir8(), ".nvm", "versions", "node");
+        if (existsSync20(nvmBase)) {
           try {
             const { readdirSync: readdirSync14 } = await import("node:fs");
             for (const ver of readdirSync14(nvmBase)) {
-              const tcPath = join27(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
-              if (existsSync19(join27(tcPath, "dist", "index.js"))) {
+              const tcPath = join28(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
+              if (existsSync20(join28(tcPath, "dist", "index.js"))) {
                 const { createRequire: createRequire4 } = await import("node:module");
                 const req = createRequire4(import.meta.url);
-                return req(join27(tcPath, "dist", "index.js"));
+                return req(join28(tcPath, "dist", "index.js"));
               }
             }
           } catch {
@@ -16021,7 +16536,7 @@ var init_listen = __esm({
           }
           if (!tc) {
             try {
-              execSync17("npm i -g transcribe-cli", { stdio: "pipe", timeout: 18e4 });
+              execSync18("npm i -g transcribe-cli", { stdio: "pipe", timeout: 18e4 });
               this.transcribeCliAvailable = null;
               tc = await this.loadTranscribeCli();
             } catch {
@@ -16053,11 +16568,11 @@ var init_listen = __esm({
               this.liveTranscriber.on("error", (err) => {
                 this.emit("error", err);
               });
-              await new Promise((resolve26, reject) => {
+              await new Promise((resolve27, reject) => {
                 const timeout = setTimeout(() => reject(new Error("Model load timeout (60s)")), 6e4);
                 this.liveTranscriber.on("ready", () => {
                   clearTimeout(timeout);
-                  resolve26();
+                  resolve27();
                 });
                 this.liveTranscriber.on("error", (err) => {
                   clearTimeout(timeout);
@@ -16107,7 +16622,7 @@ transcribe-cli error: ${transcribeCliError}` : "";
             return `Failed to start live transcription: ${msg}${tcHint}`;
           }
         }
-        this.micProcess = spawn8(micCmd.cmd, micCmd.args, {
+        this.micProcess = spawn9(micCmd.cmd, micCmd.args, {
           stdio: ["pipe", "pipe", "pipe"],
           env: { ...process.env }
         });
@@ -16202,7 +16717,7 @@ transcribe-cli error: ${transcribeCliError}` : "";
         }
         if (!tc) {
           try {
-            execSync17("npm i -g transcribe-cli", { stdio: "pipe", timeout: 18e4 });
+            execSync18("npm i -g transcribe-cli", { stdio: "pipe", timeout: 18e4 });
             this.transcribeCliAvailable = null;
             tc = await this.loadTranscribeCli();
           } catch {
@@ -16219,10 +16734,10 @@ transcribe-cli error: ${transcribeCliError}` : "";
           });
           if (outputDir) {
             const { basename: basename16 } = await import("node:path");
-            const transcriptDir = join27(outputDir, ".oa", "transcripts");
-            mkdirSync5(transcriptDir, { recursive: true });
-            const outFile = join27(transcriptDir, `${basename16(filePath)}.txt`);
-            writeFileSync5(outFile, result.text, "utf-8");
+            const transcriptDir = join28(outputDir, ".oa", "transcripts");
+            mkdirSync6(transcriptDir, { recursive: true });
+            const outFile = join28(transcriptDir, `${basename16(filePath)}.txt`);
+            writeFileSync6(outFile, result.text, "utf-8");
           }
           return {
             text: result.text,
@@ -17538,8 +18053,8 @@ Approach this task thoughtfully:
 });
 
 // packages/prompts/dist/index.js
-import { join as join28, dirname as dirname10 } from "node:path";
-import { fileURLToPath as fileURLToPath7 } from "node:url";
+import { join as join29, dirname as dirname11 } from "node:path";
+import { fileURLToPath as fileURLToPath8 } from "node:url";
 var _dir, _packageRoot;
 var init_dist6 = __esm({
   "packages/prompts/dist/index.js"() {
@@ -17548,27 +18063,27 @@ var init_dist6 = __esm({
     init_render2();
     init_task_templates();
     init_render2();
-    _dir = dirname10(fileURLToPath7(import.meta.url));
-    _packageRoot = join28(_dir, "..");
+    _dir = dirname11(fileURLToPath8(import.meta.url));
+    _packageRoot = join29(_dir, "..");
   }
 });
 
 // packages/cli/dist/tui/oa-directory.js
-import { existsSync as existsSync20, mkdirSync as mkdirSync6, readFileSync as readFileSync14, writeFileSync as writeFileSync6, readdirSync as readdirSync7, statSync as statSync9, unlinkSync as unlinkSync3 } from "node:fs";
-import { join as join29, relative as relative2, basename as basename9, extname as extname8 } from "node:path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync7, readFileSync as readFileSync15, writeFileSync as writeFileSync7, readdirSync as readdirSync7, statSync as statSync9, unlinkSync as unlinkSync3 } from "node:fs";
+import { join as join30, relative as relative2, basename as basename9, extname as extname8 } from "node:path";
 import { homedir as homedir9 } from "node:os";
 function initOaDirectory(repoRoot) {
-  const oaPath = join29(repoRoot, OA_DIR);
+  const oaPath = join30(repoRoot, OA_DIR);
   for (const sub of SUBDIRS) {
-    mkdirSync6(join29(oaPath, sub), { recursive: true });
+    mkdirSync7(join30(oaPath, sub), { recursive: true });
   }
   try {
-    const gitignorePath = join29(repoRoot, ".gitignore");
+    const gitignorePath = join30(repoRoot, ".gitignore");
     const settingsPattern = ".oa/settings.json";
-    if (existsSync20(gitignorePath)) {
-      const content = readFileSync14(gitignorePath, "utf-8");
+    if (existsSync21(gitignorePath)) {
+      const content = readFileSync15(gitignorePath, "utf-8");
       if (!content.includes(settingsPattern)) {
-        writeFileSync6(gitignorePath, content.trimEnd() + "\n" + settingsPattern + "\n", "utf-8");
+        writeFileSync7(gitignorePath, content.trimEnd() + "\n" + settingsPattern + "\n", "utf-8");
       }
     }
   } catch {
@@ -17576,41 +18091,41 @@ function initOaDirectory(repoRoot) {
   return oaPath;
 }
 function hasOaDirectory(repoRoot) {
-  return existsSync20(join29(repoRoot, OA_DIR, "index"));
+  return existsSync21(join30(repoRoot, OA_DIR, "index"));
 }
 function loadProjectSettings(repoRoot) {
-  const settingsPath = join29(repoRoot, OA_DIR, "settings.json");
+  const settingsPath = join30(repoRoot, OA_DIR, "settings.json");
   try {
-    if (existsSync20(settingsPath)) {
-      return JSON.parse(readFileSync14(settingsPath, "utf-8"));
+    if (existsSync21(settingsPath)) {
+      return JSON.parse(readFileSync15(settingsPath, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function saveProjectSettings(repoRoot, settings) {
-  const oaPath = join29(repoRoot, OA_DIR);
-  mkdirSync6(oaPath, { recursive: true });
+  const oaPath = join30(repoRoot, OA_DIR);
+  mkdirSync7(oaPath, { recursive: true });
   const existing = loadProjectSettings(repoRoot);
   const merged = { ...existing, ...settings };
-  writeFileSync6(join29(oaPath, "settings.json"), JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  writeFileSync7(join30(oaPath, "settings.json"), JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
 }
 function loadGlobalSettings() {
-  const settingsPath = join29(homedir9(), ".open-agents", "settings.json");
+  const settingsPath = join30(homedir9(), ".open-agents", "settings.json");
   try {
-    if (existsSync20(settingsPath)) {
-      return JSON.parse(readFileSync14(settingsPath, "utf-8"));
+    if (existsSync21(settingsPath)) {
+      return JSON.parse(readFileSync15(settingsPath, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function saveGlobalSettings(settings) {
-  const dir = join29(homedir9(), ".open-agents");
-  mkdirSync6(dir, { recursive: true });
+  const dir = join30(homedir9(), ".open-agents");
+  mkdirSync7(dir, { recursive: true });
   const existing = loadGlobalSettings();
   const merged = { ...existing, ...settings };
-  writeFileSync6(join29(dir, "settings.json"), JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  writeFileSync7(join30(dir, "settings.json"), JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
 }
 function resolveSettings(repoRoot) {
   const global = loadGlobalSettings();
@@ -17625,12 +18140,12 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
   while (dir && !visited.has(dir)) {
     visited.add(dir);
     for (const name of CONTEXT_FILES) {
-      const filePath = join29(dir, name);
+      const filePath = join30(dir, name);
       const normalizedName = name.toLowerCase();
-      if (existsSync20(filePath) && !seen.has(filePath)) {
+      if (existsSync21(filePath) && !seen.has(filePath)) {
         seen.add(filePath);
         try {
-          let content = readFileSync14(filePath, "utf-8");
+          let content = readFileSync15(filePath, "utf-8");
           if (content.length > maxContentLen) {
             content = content.slice(0, maxContentLen) + "\n\n...(truncated)";
           }
@@ -17644,11 +18159,11 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
         }
       }
     }
-    const projectMap = join29(dir, OA_DIR, "context", "project-map.md");
-    if (existsSync20(projectMap) && !seen.has(projectMap)) {
+    const projectMap = join30(dir, OA_DIR, "context", "project-map.md");
+    if (existsSync21(projectMap) && !seen.has(projectMap)) {
       seen.add(projectMap);
       try {
-        let content = readFileSync14(projectMap, "utf-8");
+        let content = readFileSync15(projectMap, "utf-8");
         if (content.length > maxContentLen) {
           content = content.slice(0, maxContentLen) + "\n\n...(truncated)";
         }
@@ -17660,7 +18175,7 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
       } catch {
       }
     }
-    const parent = join29(dir, "..");
+    const parent = join30(dir, "..");
     if (parent === dir)
       break;
     dir = parent;
@@ -17678,9 +18193,9 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
   return found;
 }
 function readIndexMeta(repoRoot) {
-  const metaPath = join29(repoRoot, OA_DIR, "index", "meta.json");
+  const metaPath = join30(repoRoot, OA_DIR, "index", "meta.json");
   try {
-    return JSON.parse(readFileSync14(metaPath, "utf-8"));
+    return JSON.parse(readFileSync15(metaPath, "utf-8"));
   } catch {
     return null;
   }
@@ -17731,28 +18246,28 @@ ${tree}\`\`\`
     sections.push("");
   }
   const content = sections.join("\n");
-  const contextDir = join29(repoRoot, OA_DIR, "context");
-  mkdirSync6(contextDir, { recursive: true });
-  writeFileSync6(join29(contextDir, "project-map.md"), content, "utf-8");
+  const contextDir = join30(repoRoot, OA_DIR, "context");
+  mkdirSync7(contextDir, { recursive: true });
+  writeFileSync7(join30(contextDir, "project-map.md"), content, "utf-8");
   return content;
 }
 function saveSession(repoRoot, session) {
-  const historyDir = join29(repoRoot, OA_DIR, "history");
-  mkdirSync6(historyDir, { recursive: true });
-  writeFileSync6(join29(historyDir, `${session.id}.json`), JSON.stringify(session, null, 2), "utf-8");
+  const historyDir = join30(repoRoot, OA_DIR, "history");
+  mkdirSync7(historyDir, { recursive: true });
+  writeFileSync7(join30(historyDir, `${session.id}.json`), JSON.stringify(session, null, 2), "utf-8");
 }
 function loadRecentSessions(repoRoot, limit = 5) {
-  const historyDir = join29(repoRoot, OA_DIR, "history");
-  if (!existsSync20(historyDir))
+  const historyDir = join30(repoRoot, OA_DIR, "history");
+  if (!existsSync21(historyDir))
     return [];
   try {
     const files = readdirSync7(historyDir).filter((f) => f.endsWith(".json") && f !== "pending-task.json").map((f) => {
-      const stat5 = statSync9(join29(historyDir, f));
+      const stat5 = statSync9(join30(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(readFileSync14(join29(historyDir, f.file), "utf-8"));
+        return JSON.parse(readFileSync15(join30(historyDir, f.file), "utf-8"));
       } catch {
         return null;
       }
@@ -17762,16 +18277,16 @@ function loadRecentSessions(repoRoot, limit = 5) {
   }
 }
 function savePendingTask(repoRoot, task) {
-  const historyDir = join29(repoRoot, OA_DIR, "history");
-  mkdirSync6(historyDir, { recursive: true });
-  writeFileSync6(join29(historyDir, PENDING_TASK_FILE), JSON.stringify(task, null, 2) + "\n", "utf-8");
+  const historyDir = join30(repoRoot, OA_DIR, "history");
+  mkdirSync7(historyDir, { recursive: true });
+  writeFileSync7(join30(historyDir, PENDING_TASK_FILE), JSON.stringify(task, null, 2) + "\n", "utf-8");
 }
 function loadPendingTask(repoRoot) {
-  const filePath = join29(repoRoot, OA_DIR, "history", PENDING_TASK_FILE);
+  const filePath = join30(repoRoot, OA_DIR, "history", PENDING_TASK_FILE);
   try {
-    if (!existsSync20(filePath))
+    if (!existsSync21(filePath))
       return null;
-    const data = JSON.parse(readFileSync14(filePath, "utf-8"));
+    const data = JSON.parse(readFileSync15(filePath, "utf-8"));
     try {
       unlinkSync3(filePath);
     } catch {
@@ -17782,13 +18297,13 @@ function loadPendingTask(repoRoot) {
   }
 }
 function saveSessionContext(repoRoot, entry) {
-  const contextDir = join29(repoRoot, OA_DIR, "context");
-  mkdirSync6(contextDir, { recursive: true });
-  const filePath = join29(contextDir, CONTEXT_SAVE_FILE);
+  const contextDir = join30(repoRoot, OA_DIR, "context");
+  mkdirSync7(contextDir, { recursive: true });
+  const filePath = join30(contextDir, CONTEXT_SAVE_FILE);
   let ctx;
   try {
-    if (existsSync20(filePath)) {
-      ctx = JSON.parse(readFileSync14(filePath, "utf-8"));
+    if (existsSync21(filePath)) {
+      ctx = JSON.parse(readFileSync15(filePath, "utf-8"));
     } else {
       ctx = { entries: [], maxEntries: MAX_CONTEXT_ENTRIES, updatedAt: "" };
     }
@@ -17800,14 +18315,14 @@ function saveSessionContext(repoRoot, entry) {
     ctx.entries = ctx.entries.slice(-ctx.maxEntries);
   }
   ctx.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  writeFileSync6(filePath, JSON.stringify(ctx, null, 2) + "\n", "utf-8");
+  writeFileSync7(filePath, JSON.stringify(ctx, null, 2) + "\n", "utf-8");
 }
 function loadSessionContext(repoRoot) {
-  const filePath = join29(repoRoot, OA_DIR, "context", CONTEXT_SAVE_FILE);
+  const filePath = join30(repoRoot, OA_DIR, "context", CONTEXT_SAVE_FILE);
   try {
-    if (!existsSync20(filePath))
+    if (!existsSync21(filePath))
       return null;
-    return JSON.parse(readFileSync14(filePath, "utf-8"));
+    return JSON.parse(readFileSync15(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -17854,12 +18369,12 @@ function detectManifests(repoRoot) {
     { file: "docker-compose.yaml", type: "Docker Compose" }
   ];
   for (const check of checks) {
-    const filePath = join29(repoRoot, check.file);
-    if (existsSync20(filePath)) {
+    const filePath = join30(repoRoot, check.file);
+    if (existsSync21(filePath)) {
       let name;
       if (check.nameField) {
         try {
-          const data = JSON.parse(readFileSync14(filePath, "utf-8"));
+          const data = JSON.parse(readFileSync15(filePath, "utf-8"));
           name = data[check.nameField];
         } catch {
         }
@@ -17888,7 +18403,7 @@ function findKeyFiles(repoRoot) {
     { pattern: "CLAUDE.md", description: "Claude Code context" }
   ];
   for (const check of checks) {
-    if (existsSync20(join29(repoRoot, check.pattern))) {
+    if (existsSync21(join30(repoRoot, check.pattern))) {
       keyFiles.push({ path: check.pattern, description: check.description });
     }
   }
@@ -17914,12 +18429,12 @@ function buildDirTree(root, maxDepth, prefix = "", depth = 0) {
       if (entry.isDirectory()) {
         let fileCount = 0;
         try {
-          fileCount = readdirSync7(join29(root, entry.name)).filter((f) => !f.startsWith(".")).length;
+          fileCount = readdirSync7(join30(root, entry.name)).filter((f) => !f.startsWith(".")).length;
         } catch {
         }
         result += `${prefix}${connector}${entry.name}/ (${fileCount})
 `;
-        result += buildDirTree(join29(root, entry.name), maxDepth, childPrefix, depth + 1);
+        result += buildDirTree(join30(root, entry.name), maxDepth, childPrefix, depth + 1);
       } else if (depth < maxDepth) {
         result += `${prefix}${connector}${entry.name}
 `;
@@ -17972,9 +18487,9 @@ var init_oa_directory = __esm({
 
 // packages/cli/dist/tui/setup.js
 import * as readline from "node:readline";
-import { execSync as execSync18, spawn as spawn9 } from "node:child_process";
-import { existsSync as existsSync21, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "node:fs";
-import { join as join30 } from "node:path";
+import { execSync as execSync19, spawn as spawn10 } from "node:child_process";
+import { existsSync as existsSync22, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8 } from "node:fs";
+import { join as join31 } from "node:path";
 import { homedir as homedir10, platform } from "node:os";
 function detectSystemSpecs() {
   let totalRamGB = 0;
@@ -17982,7 +18497,7 @@ function detectSystemSpecs() {
   let gpuVramGB = 0;
   let gpuName = "";
   try {
-    const memInfo = execSync18("free -b 2>/dev/null || sysctl -n hw.memsize 2>/dev/null", {
+    const memInfo = execSync19("free -b 2>/dev/null || sysctl -n hw.memsize 2>/dev/null", {
       encoding: "utf8",
       timeout: 5e3
     });
@@ -18002,7 +18517,7 @@ function detectSystemSpecs() {
   } catch {
   }
   try {
-    const nvidiaSmi = execSync18("nvidia-smi --query-gpu=memory.total,name --format=csv,noheader,nounits 2>/dev/null", { encoding: "utf8", timeout: 5e3 });
+    const nvidiaSmi = execSync19("nvidia-smi --query-gpu=memory.total,name --format=csv,noheader,nounits 2>/dev/null", { encoding: "utf8", timeout: 5e3 });
     const lines = nvidiaSmi.trim().split("\n");
     if (lines.length > 0) {
       for (const line of lines) {
@@ -18058,12 +18573,12 @@ function modelSupportsToolCalling(modelName) {
   return false;
 }
 function ask(rl, question) {
-  return new Promise((resolve26) => {
-    rl.question(question, (answer) => resolve26(answer.trim()));
+  return new Promise((resolve27) => {
+    rl.question(question, (answer) => resolve27(answer.trim()));
   });
 }
 function askSecret(rl, question) {
-  return new Promise((resolve26) => {
+  return new Promise((resolve27) => {
     process.stdout.write(question);
     let secret = "";
     const stdin = process.stdin;
@@ -18081,7 +18596,7 @@ function askSecret(rl, question) {
             stdin.setRawMode(hadRawMode ?? false);
           }
           process.stdout.write("\n");
-          resolve26(secret.trim());
+          resolve27(secret.trim());
           return;
         } else if (c3 === "") {
           stdin.removeListener("data", onData);
@@ -18089,7 +18604,7 @@ function askSecret(rl, question) {
             stdin.setRawMode(hadRawMode ?? false);
           }
           process.stdout.write("\n");
-          resolve26("");
+          resolve27("");
           return;
         } else if (c3 === "\x7F" || c3 === "\b") {
           if (secret.length > 0) {
@@ -18127,7 +18642,7 @@ function installOllamaLinux() {
 
 `);
   try {
-    execSync18("curl -fsSL https://ollama.com/install.sh | sh", {
+    execSync19("curl -fsSL https://ollama.com/install.sh | sh", {
       stdio: "inherit",
       timeout: 3e5
     });
@@ -18166,10 +18681,10 @@ async function installOllamaMac(rl) {
 
 `);
     try {
-      execSync18('/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"', { stdio: "inherit", timeout: 6e5 });
+      execSync19('/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"', { stdio: "inherit", timeout: 6e5 });
       if (!hasCmd("brew")) {
         try {
-          const brewPrefix = existsSync21("/opt/homebrew/bin/brew") ? "/opt/homebrew" : "/usr/local";
+          const brewPrefix = existsSync22("/opt/homebrew/bin/brew") ? "/opt/homebrew" : "/usr/local";
           process.env["PATH"] = `${brewPrefix}/bin:${process.env["PATH"]}`;
         } catch {
         }
@@ -18199,7 +18714,7 @@ async function installOllamaMac(rl) {
 
 `);
   try {
-    execSync18("brew install ollama", {
+    execSync19("brew install ollama", {
       stdio: "inherit",
       timeout: 3e5
     });
@@ -18226,7 +18741,7 @@ function installOllamaWindows() {
 
 `);
   try {
-    execSync18('powershell -Command "irm https://ollama.com/install.ps1 | iex"', {
+    execSync19('powershell -Command "irm https://ollama.com/install.ps1 | iex"', {
       stdio: "inherit",
       timeout: 3e5
     });
@@ -18249,7 +18764,7 @@ function installOllamaWindows() {
 }
 function pullModelWithAutoUpdate(tag) {
   try {
-    execSync18(`ollama pull ${tag}`, {
+    execSync19(`ollama pull ${tag}`, {
       stdio: "inherit",
       timeout: 36e5
       // 1 hour max
@@ -18266,7 +18781,7 @@ function pullModelWithAutoUpdate(tag) {
 
 `);
       try {
-        execSync18("curl -fsSL https://ollama.com/install.sh | sh", {
+        execSync19("curl -fsSL https://ollama.com/install.sh | sh", {
           stdio: "inherit",
           timeout: 3e5
           // 5 min max for install
@@ -18277,7 +18792,7 @@ function pullModelWithAutoUpdate(tag) {
         process.stdout.write(`  ${c2.cyan("\u25CF")} Retrying pull of ${c2.bold(tag)}...
 
 `);
-        execSync18(`ollama pull ${tag}`, {
+        execSync19(`ollama pull ${tag}`, {
           stdio: "inherit",
           timeout: 36e5
         });
@@ -18458,9 +18973,9 @@ async function doSetup(config, rl) {
   ${c2.cyan("\u25CF")} Starting ollama serve in background...
 `);
         try {
-          const child = spawn9("ollama", ["serve"], { stdio: "ignore", detached: true });
+          const child = spawn10("ollama", ["serve"], { stdio: "ignore", detached: true });
           child.unref();
-          await new Promise((resolve26) => setTimeout(resolve26, 3e3));
+          await new Promise((resolve27) => setTimeout(resolve27, 3e3));
           try {
             models = await fetchOllamaModels(config.backendUrl);
             process.stdout.write(`  ${c2.green("\u2714")} Ollama is running.
@@ -18486,9 +19001,9 @@ async function doSetup(config, rl) {
   ${c2.cyan("\u25CF")} Starting ollama serve...
 `);
           try {
-            const child = spawn9("ollama", ["serve"], { stdio: "ignore", detached: true });
+            const child = spawn10("ollama", ["serve"], { stdio: "ignore", detached: true });
             child.unref();
-            await new Promise((resolve26) => setTimeout(resolve26, 3e3));
+            await new Promise((resolve27) => setTimeout(resolve27, 3e3));
             try {
               models = await fetchOllamaModels(config.backendUrl);
               process.stdout.write(`  ${c2.green("\u2714")} Ollama is running.
@@ -18643,12 +19158,12 @@ async function doSetup(config, rl) {
           `PARAMETER num_predict ${numPredict}`,
           `PARAMETER stop "<|endoftext|>"`
         ].join("\n");
-        const modelDir2 = join30(homedir10(), ".open-agents", "models");
-        mkdirSync7(modelDir2, { recursive: true });
-        const modelfilePath = join30(modelDir2, `Modelfile.${customName}`);
-        writeFileSync7(modelfilePath, modelfileContent + "\n", "utf8");
+        const modelDir2 = join31(homedir10(), ".open-agents", "models");
+        mkdirSync8(modelDir2, { recursive: true });
+        const modelfilePath = join31(modelDir2, `Modelfile.${customName}`);
+        writeFileSync8(modelfilePath, modelfileContent + "\n", "utf8");
         process.stdout.write(`  ${c2.dim("Creating model...")} `);
-        execSync18(`ollama create ${customName} -f ${modelfilePath}`, {
+        execSync19(`ollama create ${customName} -f ${modelfilePath}`, {
           stdio: "pipe",
           timeout: 12e4
         });
@@ -18691,7 +19206,7 @@ async function isModelAvailable(config) {
 }
 function isFirstRun() {
   try {
-    return !existsSync21(join30(homedir10(), ".open-agents", "config.json"));
+    return !existsSync22(join31(homedir10(), ".open-agents", "config.json"));
   } catch {
     return true;
   }
@@ -18699,7 +19214,7 @@ function isFirstRun() {
 function hasCmd(cmd) {
   try {
     const whichCmd = process.platform === "win32" ? `where ${cmd}` : `which ${cmd}`;
-    execSync18(whichCmd, { stdio: "pipe", timeout: 3e3 });
+    execSync19(whichCmd, { stdio: "pipe", timeout: 3e3 });
     return true;
   } catch {
     return false;
@@ -18728,11 +19243,11 @@ function detectPkgManager() {
   return null;
 }
 function getVenvDir() {
-  return join30(homedir10(), ".open-agents", "venv");
+  return join31(homedir10(), ".open-agents", "venv");
 }
 function hasVenvModule() {
   try {
-    execSync18("python3 -m venv --help", { stdio: "pipe", timeout: 5e3 });
+    execSync19("python3 -m venv --help", { stdio: "pipe", timeout: 5e3 });
     return true;
   } catch {
     return false;
@@ -18740,8 +19255,8 @@ function hasVenvModule() {
 }
 function ensureVenv(log) {
   const venvDir = getVenvDir();
-  const venvPip = join30(venvDir, "bin", "pip");
-  if (existsSync21(venvPip))
+  const venvPip = join31(venvDir, "bin", "pip");
+  if (existsSync22(venvPip))
     return venvDir;
   log("Creating Python venv for vision deps...");
   if (!hasCmd("python3")) {
@@ -18753,9 +19268,9 @@ function ensureVenv(log) {
     return null;
   }
   try {
-    mkdirSync7(join30(homedir10(), ".open-agents"), { recursive: true });
-    execSync18(`python3 -m venv "${venvDir}"`, { stdio: "pipe", timeout: 3e4 });
-    execSync18(`"${join30(venvDir, "bin", "pip")}" install --upgrade pip`, {
+    mkdirSync8(join31(homedir10(), ".open-agents"), { recursive: true });
+    execSync19(`python3 -m venv "${venvDir}"`, { stdio: "pipe", timeout: 3e4 });
+    execSync19(`"${join31(venvDir, "bin", "pip")}" install --upgrade pip`, {
       stdio: "pipe",
       timeout: 6e4
     });
@@ -18768,7 +19283,7 @@ function ensureVenv(log) {
 }
 function trySudoPasswordless(cmd, timeoutMs = 12e4) {
   try {
-    execSync18(`sudo -n ${cmd}`, {
+    execSync19(`sudo -n ${cmd}`, {
       stdio: "pipe",
       timeout: timeoutMs,
       env: { ...process.env, DEBIAN_FRONTEND: "noninteractive" }
@@ -18780,7 +19295,7 @@ function trySudoPasswordless(cmd, timeoutMs = 12e4) {
 }
 function runWithSudo(cmd, password, timeoutMs = 12e4) {
   try {
-    execSync18(`sudo -S ${cmd}`, {
+    execSync19(`sudo -S ${cmd}`, {
       input: password + "\n",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: timeoutMs,
@@ -18840,7 +19355,7 @@ async function ensureVisionDeps(onInfo, getSudoPassword) {
       } else {
         log("Installing tesseract-ocr...");
         try {
-          execSync18(pkg.cmd, { stdio: "pipe", timeout: 12e4 });
+          execSync19(pkg.cmd, { stdio: "pipe", timeout: 12e4 });
           if (hasCmd("tesseract")) {
             log("tesseract-ocr installed successfully.");
           } else {
@@ -18912,7 +19427,7 @@ async function ensureVisionDeps(onInfo, getSudoPassword) {
       } else {
         log(`Installing ${dep.label}...`);
         try {
-          execSync18(pkg.cmd, { stdio: "pipe", timeout: 12e4 });
+          execSync19(pkg.cmd, { stdio: "pipe", timeout: 12e4 });
           if (hasCmd(dep.binary)) {
             log(`${dep.label} installed successfully.`);
           } else {
@@ -18943,7 +19458,7 @@ async function ensureVisionDeps(onInfo, getSudoPassword) {
     const venvCmds = {
       apt: () => {
         try {
-          const pyVer = execSync18(`python3 -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')"`, { encoding: "utf8", stdio: "pipe", timeout: 5e3 }).trim();
+          const pyVer = execSync19(`python3 -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')"`, { encoding: "utf8", stdio: "pipe", timeout: 5e3 }).trim();
           return `apt-get install -y python3-venv python${pyVer}-venv`;
         } catch {
           return "apt-get install -y python3-venv";
@@ -18964,19 +19479,19 @@ async function ensureVisionDeps(onInfo, getSudoPassword) {
     }
   }
   const venvDir = getVenvDir();
-  const venvBin = join30(venvDir, "bin");
-  const venvMoondream = join30(venvBin, "moondream-station");
+  const venvBin = join31(venvDir, "bin");
+  const venvMoondream = join31(venvBin, "moondream-station");
   const venv = ensureVenv(log);
-  if (venv && !hasCmd("moondream-station") && !existsSync21(venvMoondream)) {
-    const venvPip = join30(venvBin, "pip");
+  if (venv && !hasCmd("moondream-station") && !existsSync22(venvMoondream)) {
+    const venvPip = join31(venvBin, "pip");
     log("Installing moondream-station in ~/.open-agents/venv...");
     try {
-      execSync18(`"${venvPip}" install moondream-station`, { stdio: "pipe", timeout: 3e5 });
-      if (existsSync21(venvMoondream)) {
+      execSync19(`"${venvPip}" install moondream-station`, { stdio: "pipe", timeout: 3e5 });
+      if (existsSync22(venvMoondream)) {
         log("moondream-station installed successfully.");
       } else {
         try {
-          const check = execSync18(`"${venvPip}" show moondream-station`, { encoding: "utf8", stdio: "pipe", timeout: 5e3 });
+          const check = execSync19(`"${venvPip}" show moondream-station`, { encoding: "utf8", stdio: "pipe", timeout: 5e3 });
           if (check.includes("moondream")) {
             log("moondream-station package installed.");
           }
@@ -18989,11 +19504,11 @@ async function ensureVisionDeps(onInfo, getSudoPassword) {
     }
   }
   if (venv) {
-    const venvPython = join30(venvBin, "python");
-    const venvPip2 = join30(venvBin, "pip");
+    const venvPython = join31(venvBin, "python");
+    const venvPip2 = join31(venvBin, "pip");
     let ocrStackInstalled = false;
     try {
-      execSync18(`"${venvPython}" -c "import cv2, pytesseract, numpy, PIL"`, { stdio: "pipe", timeout: 1e4 });
+      execSync19(`"${venvPython}" -c "import cv2, pytesseract, numpy, PIL"`, { stdio: "pipe", timeout: 1e4 });
       ocrStackInstalled = true;
     } catch {
     }
@@ -19001,9 +19516,9 @@ async function ensureVisionDeps(onInfo, getSudoPassword) {
       const ocrPackages = "pytesseract Pillow opencv-python-headless numpy";
       log("Installing OCR Python stack (pytesseract, OpenCV, Pillow, numpy)...");
       try {
-        execSync18(`"${venvPip2}" install ${ocrPackages}`, { stdio: "pipe", timeout: 3e5 });
+        execSync19(`"${venvPip2}" install ${ocrPackages}`, { stdio: "pipe", timeout: 3e5 });
         try {
-          execSync18(`"${venvPython}" -c "import cv2, pytesseract, numpy, PIL"`, { stdio: "pipe", timeout: 1e4 });
+          execSync19(`"${venvPython}" -c "import cv2, pytesseract, numpy, PIL"`, { stdio: "pipe", timeout: 1e4 });
           log("OCR Python stack installed successfully.");
         } catch {
           log("OCR Python stack install completed but import verification failed.");
@@ -19050,11 +19565,11 @@ function createExpandedVariant(baseModel, specs, sizeGB) {
       `PARAMETER num_predict ${numPredict}`,
       `PARAMETER stop "<|endoftext|>"`
     ].join("\n");
-    const modelDir2 = join30(homedir10(), ".open-agents", "models");
-    mkdirSync7(modelDir2, { recursive: true });
-    const modelfilePath = join30(modelDir2, `Modelfile.${customName}`);
-    writeFileSync7(modelfilePath, modelfileContent + "\n", "utf8");
-    execSync18(`ollama create ${customName} -f ${modelfilePath}`, {
+    const modelDir2 = join31(homedir10(), ".open-agents", "models");
+    mkdirSync8(modelDir2, { recursive: true });
+    const modelfilePath = join31(modelDir2, `Modelfile.${customName}`);
+    writeFileSync8(modelfilePath, modelfileContent + "\n", "utf8");
+    execSync19(`ollama create ${customName} -f ${modelfilePath}`, {
       stdio: "pipe",
       timeout: 12e4
     });
@@ -19941,18 +20456,18 @@ async function handleUpdate(subcommand, ctx) {
   let currentVersion = "0.0.0";
   try {
     const { createRequire: createRequire4 } = await import("node:module");
-    const { fileURLToPath: fileURLToPath10 } = await import("node:url");
-    const { dirname: dirname13, join: join43 } = await import("node:path");
-    const { existsSync: existsSync30 } = await import("node:fs");
+    const { fileURLToPath: fileURLToPath11 } = await import("node:url");
+    const { dirname: dirname14, join: join44 } = await import("node:path");
+    const { existsSync: existsSync31 } = await import("node:fs");
     const req = createRequire4(import.meta.url);
-    const thisDir = dirname13(fileURLToPath10(import.meta.url));
+    const thisDir = dirname14(fileURLToPath11(import.meta.url));
     const candidates = [
-      join43(thisDir, "..", "package.json"),
-      join43(thisDir, "..", "..", "package.json"),
-      join43(thisDir, "..", "..", "..", "package.json")
+      join44(thisDir, "..", "package.json"),
+      join44(thisDir, "..", "..", "package.json"),
+      join44(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync30(pkgPath)) {
+      if (existsSync31(pkgPath)) {
         const pkg = req(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           currentVersion = pkg.version ?? "0.0.0";
@@ -19990,8 +20505,8 @@ async function handleUpdate(subcommand, ctx) {
   checkSpinner.stop(`Update available: v${info.currentVersion} \u2192 v${c2.bold(c2.green(info.latestVersion))}`);
   const installSpinner = startInlineSpinner("Installing update");
   const { exec } = await import("node:child_process");
-  const installOk = await new Promise((resolve26) => {
-    const child = exec(`npm cache clean --force open-agents-ai 2>/dev/null; npm install -g open-agents-ai@latest --force`, { timeout: 18e4 }, (err) => resolve26(!err));
+  const installOk = await new Promise((resolve27) => {
+    const child = exec(`npm cache clean --force open-agents-ai 2>/dev/null; npm install -g open-agents-ai@latest --force`, { timeout: 18e4 }, (err) => resolve27(!err));
     child.stdout?.resume();
     child.stderr?.resume();
   });
@@ -20084,9 +20599,9 @@ var init_commands = __esm({
 });
 
 // packages/cli/dist/tui/project-context.js
-import { existsSync as existsSync22, readFileSync as readFileSync15, readdirSync as readdirSync8 } from "node:fs";
-import { join as join31, basename as basename10 } from "node:path";
-import { execSync as execSync19 } from "node:child_process";
+import { existsSync as existsSync23, readFileSync as readFileSync16, readdirSync as readdirSync8 } from "node:fs";
+import { join as join32, basename as basename10 } from "node:path";
+import { execSync as execSync20 } from "node:child_process";
 import { homedir as homedir11, platform as platform2, release } from "node:os";
 function getModelTier(modelName) {
   const m = modelName.toLowerCase();
@@ -20120,10 +20635,10 @@ function loadProjectMap(repoRoot) {
   if (!hasOaDirectory(repoRoot)) {
     initOaDirectory(repoRoot);
   }
-  const mapPath = join31(repoRoot, OA_DIR, "context", "project-map.md");
-  if (existsSync22(mapPath)) {
+  const mapPath = join32(repoRoot, OA_DIR, "context", "project-map.md");
+  if (existsSync23(mapPath)) {
     try {
-      const content = readFileSync15(mapPath, "utf-8");
+      const content = readFileSync16(mapPath, "utf-8");
       return content;
     } catch {
     }
@@ -20132,19 +20647,19 @@ function loadProjectMap(repoRoot) {
 }
 function getGitInfo(repoRoot) {
   try {
-    execSync19("git rev-parse --is-inside-work-tree", { cwd: repoRoot, stdio: "pipe" });
+    execSync20("git rev-parse --is-inside-work-tree", { cwd: repoRoot, stdio: "pipe" });
   } catch {
     return "";
   }
   const lines = [];
   try {
-    const branch = execSync19("git branch --show-current", { cwd: repoRoot, encoding: "utf-8", stdio: "pipe" }).trim();
+    const branch = execSync20("git branch --show-current", { cwd: repoRoot, encoding: "utf-8", stdio: "pipe" }).trim();
     if (branch)
       lines.push(`Branch: ${branch}`);
   } catch {
   }
   try {
-    const status = execSync19("git status --porcelain", { cwd: repoRoot, encoding: "utf-8", stdio: "pipe" }).trim();
+    const status = execSync20("git status --porcelain", { cwd: repoRoot, encoding: "utf-8", stdio: "pipe" }).trim();
     if (status) {
       const changed = status.split("\n").length;
       lines.push(`Working tree: ${changed} changed file(s)`);
@@ -20154,7 +20669,7 @@ function getGitInfo(repoRoot) {
   } catch {
   }
   try {
-    const log = execSync19("git log --oneline -5 --no-decorate", { cwd: repoRoot, encoding: "utf-8", stdio: "pipe" }).trim();
+    const log = execSync20("git log --oneline -5 --no-decorate", { cwd: repoRoot, encoding: "utf-8", stdio: "pipe" }).trim();
     if (log)
       lines.push(`Recent commits:
 ${log}`);
@@ -20164,31 +20679,31 @@ ${log}`);
 }
 function loadMemoryContext(repoRoot) {
   const sections = [];
-  const oaMemDir = join31(repoRoot, OA_DIR, "memory");
+  const oaMemDir = join32(repoRoot, OA_DIR, "memory");
   const oaEntries = loadMemoryDir(oaMemDir, "project");
   if (oaEntries)
     sections.push(oaEntries);
-  const legacyMemDir = join31(repoRoot, ".open-agents", "memory");
-  if (legacyMemDir !== oaMemDir && existsSync22(legacyMemDir)) {
+  const legacyMemDir = join32(repoRoot, ".open-agents", "memory");
+  if (legacyMemDir !== oaMemDir && existsSync23(legacyMemDir)) {
     const legacyEntries = loadMemoryDir(legacyMemDir, "project/legacy");
     if (legacyEntries)
       sections.push(legacyEntries);
   }
-  const globalMemDir = join31(homedir11(), ".open-agents", "memory");
+  const globalMemDir = join32(homedir11(), ".open-agents", "memory");
   const globalEntries = loadMemoryDir(globalMemDir, "global");
   if (globalEntries)
     sections.push(globalEntries);
   return sections.join("\n\n");
 }
 function loadMemoryDir(memDir, scope) {
-  if (!existsSync22(memDir))
+  if (!existsSync23(memDir))
     return "";
   const lines = [];
   try {
     const files = readdirSync8(memDir).filter((f) => f.endsWith(".json"));
     for (const file of files.slice(0, 10)) {
       try {
-        const raw = readFileSync15(join31(memDir, file), "utf-8");
+        const raw = readFileSync16(join32(memDir, file), "utf-8");
         const entries = JSON.parse(raw);
         const topic = basename10(file, ".json");
         const keys = Object.keys(entries);
@@ -21215,22 +21730,22 @@ var init_carousel = __esm({
 });
 
 // packages/cli/dist/tui/carousel-descriptors.js
-import { existsSync as existsSync23, readFileSync as readFileSync16, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8, readdirSync as readdirSync9 } from "node:fs";
-import { join as join32, basename as basename11 } from "node:path";
+import { existsSync as existsSync24, readFileSync as readFileSync17, writeFileSync as writeFileSync9, mkdirSync as mkdirSync9, readdirSync as readdirSync9 } from "node:fs";
+import { join as join33, basename as basename11 } from "node:path";
 function loadToolProfile(repoRoot) {
-  const filePath = join32(repoRoot, OA_DIR, "context", TOOL_PROFILE_FILE);
+  const filePath = join33(repoRoot, OA_DIR, "context", TOOL_PROFILE_FILE);
   try {
-    if (!existsSync23(filePath))
+    if (!existsSync24(filePath))
       return null;
-    return JSON.parse(readFileSync16(filePath, "utf-8"));
+    return JSON.parse(readFileSync17(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveToolProfile(repoRoot, profile) {
-  const contextDir = join32(repoRoot, OA_DIR, "context");
-  mkdirSync8(contextDir, { recursive: true });
-  writeFileSync8(join32(contextDir, TOOL_PROFILE_FILE), JSON.stringify(profile, null, 2), "utf-8");
+  const contextDir = join33(repoRoot, OA_DIR, "context");
+  mkdirSync9(contextDir, { recursive: true });
+  writeFileSync9(join33(contextDir, TOOL_PROFILE_FILE), JSON.stringify(profile, null, 2), "utf-8");
 }
 function categorizeToolCall(toolName) {
   for (const cat of TOOL_CATEGORIES) {
@@ -21288,25 +21803,25 @@ function weightedColor(profile) {
   return selectedCat.colors[Math.floor(Math.random() * selectedCat.colors.length)];
 }
 function loadCachedDescriptors(repoRoot) {
-  const filePath = join32(repoRoot, OA_DIR, "context", DESCRIPTOR_FILE);
+  const filePath = join33(repoRoot, OA_DIR, "context", DESCRIPTOR_FILE);
   try {
-    if (!existsSync23(filePath))
+    if (!existsSync24(filePath))
       return null;
-    const cached = JSON.parse(readFileSync16(filePath, "utf-8"));
+    const cached = JSON.parse(readFileSync17(filePath, "utf-8"));
     return cached.phrases.length > 0 ? cached.phrases : null;
   } catch {
     return null;
   }
 }
 function saveCachedDescriptors(repoRoot, phrases, sourceHash) {
-  const contextDir = join32(repoRoot, OA_DIR, "context");
-  mkdirSync8(contextDir, { recursive: true });
+  const contextDir = join33(repoRoot, OA_DIR, "context");
+  mkdirSync9(contextDir, { recursive: true });
   const cached = {
     phrases,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     sourceHash
   };
-  writeFileSync8(join32(contextDir, DESCRIPTOR_FILE), JSON.stringify(cached, null, 2), "utf-8");
+  writeFileSync9(join33(contextDir, DESCRIPTOR_FILE), JSON.stringify(cached, null, 2), "utf-8");
 }
 function generateDescriptors(repoRoot) {
   const profile = loadToolProfile(repoRoot);
@@ -21354,11 +21869,11 @@ function generateDescriptors(repoRoot) {
   return phrases;
 }
 function extractFromPackageJson(repoRoot, tags) {
-  const pkgPath = join32(repoRoot, "package.json");
+  const pkgPath = join33(repoRoot, "package.json");
   try {
-    if (!existsSync23(pkgPath))
+    if (!existsSync24(pkgPath))
       return;
-    const pkg = JSON.parse(readFileSync16(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync17(pkgPath, "utf-8"));
     if (pkg.name && typeof pkg.name === "string") {
       const parts = pkg.name.replace(/^@/, "").split("/");
       for (const p of parts)
@@ -21402,7 +21917,7 @@ function extractFromManifests(repoRoot, tags) {
     { file: ".github/workflows", tag: "ci/cd" }
   ];
   for (const check of manifestChecks) {
-    if (existsSync23(join32(repoRoot, check.file))) {
+    if (existsSync24(join33(repoRoot, check.file))) {
       tags.push(check.tag);
     }
   }
@@ -21424,16 +21939,16 @@ function extractFromSessions(repoRoot, tags) {
   }
 }
 function extractFromMemory(repoRoot, tags) {
-  const memoryDir = join32(repoRoot, OA_DIR, "memory");
+  const memoryDir = join33(repoRoot, OA_DIR, "memory");
   try {
-    if (!existsSync23(memoryDir))
+    if (!existsSync24(memoryDir))
       return;
     const files = readdirSync9(memoryDir).filter((f) => f.endsWith(".json"));
     for (const file of files) {
       const topic = file.replace(/\.json$/, "").replace(/[-_]/g, " ");
       tags.push(topic);
       try {
-        const data = JSON.parse(readFileSync16(join32(memoryDir, file), "utf-8"));
+        const data = JSON.parse(readFileSync17(join33(memoryDir, file), "utf-8"));
         if (data && typeof data === "object") {
           const keys = Object.keys(data).slice(0, 3);
           for (const key of keys) {
@@ -21568,25 +22083,25 @@ var init_carousel_descriptors = __esm({
 });
 
 // packages/cli/dist/tui/voice.js
-import { existsSync as existsSync24, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9, readFileSync as readFileSync17, unlinkSync as unlinkSync4 } from "node:fs";
-import { join as join33 } from "node:path";
+import { existsSync as existsSync25, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10, readFileSync as readFileSync18, unlinkSync as unlinkSync4 } from "node:fs";
+import { join as join34 } from "node:path";
 import { homedir as homedir12, tmpdir as tmpdir6, platform as platform3 } from "node:os";
-import { execSync as execSync20, spawn as nodeSpawn } from "node:child_process";
+import { execSync as execSync21, spawn as nodeSpawn } from "node:child_process";
 import { createRequire } from "node:module";
 function voiceDir() {
-  return join33(homedir12(), ".open-agents", "voice");
+  return join34(homedir12(), ".open-agents", "voice");
 }
 function modelsDir() {
-  return join33(voiceDir(), "models");
+  return join34(voiceDir(), "models");
 }
 function modelDir(id) {
-  return join33(modelsDir(), id);
+  return join34(modelsDir(), id);
 }
 function modelOnnxPath(id) {
-  return join33(modelDir(id), "model.onnx");
+  return join34(modelDir(id), "model.onnx");
 }
 function modelConfigPath(id) {
-  return join33(modelDir(id), "config.json");
+  return join34(modelDir(id), "config.json");
 }
 function describeToolCall(toolName, args, personality = 2) {
   const path = args["path"];
@@ -22032,7 +22547,7 @@ var init_voice = __esm({
         const audioData = result["output"].data;
         if (audioData.length === 0)
           return;
-        const wavPath = join33(tmpdir6(), `oa-voice-${Date.now()}.wav`);
+        const wavPath = join34(tmpdir6(), `oa-voice-${Date.now()}.wav`);
         this.writeWav(audioData, this.config.audio.sample_rate, wavPath);
         await this.playWav(wavPath);
         try {
@@ -22112,7 +22627,7 @@ var init_voice = __esm({
         buffer.write("data", 36);
         buffer.writeUInt32LE(dataSize, 40);
         Buffer.from(int16.buffer, int16.byteOffset, int16.byteLength).copy(buffer, 44);
-        writeFileSync9(path, buffer);
+        writeFileSync10(path, buffer);
       }
       // -------------------------------------------------------------------------
       // Audio playback (system default speakers)
@@ -22121,7 +22636,7 @@ var init_voice = __esm({
         const cmd = this.getPlayCommand(path);
         if (!cmd)
           return;
-        return new Promise((resolve26) => {
+        return new Promise((resolve27) => {
           const child = nodeSpawn(cmd[0], cmd.slice(1), {
             stdio: "ignore",
             detached: false
@@ -22130,12 +22645,12 @@ var init_voice = __esm({
           child.on("close", () => {
             if (this.currentPlayback === child)
               this.currentPlayback = null;
-            resolve26();
+            resolve27();
           });
           child.on("error", () => {
             if (this.currentPlayback === child)
               this.currentPlayback = null;
-            resolve26();
+            resolve27();
           });
           setTimeout(() => {
             if (this.currentPlayback === child) {
@@ -22145,7 +22660,7 @@ var init_voice = __esm({
               }
               this.currentPlayback = null;
             }
-            resolve26();
+            resolve27();
           }, 15e3);
         });
       }
@@ -22162,7 +22677,7 @@ var init_voice = __esm({
         }
         for (const player of ["paplay", "pw-play", "aplay"]) {
           try {
-            execSync20(`which ${player}`, { stdio: "pipe" });
+            execSync21(`which ${player}`, { stdio: "pipe" });
             return [player, path];
           } catch {
           }
@@ -22186,30 +22701,30 @@ var init_voice = __esm({
           return;
         const arch = process.arch;
         const isArmLinux = (arch === "arm64" || arch === "arm") && process.platform === "linux";
-        mkdirSync9(voiceDir(), { recursive: true });
-        const pkgPath = join33(voiceDir(), "package.json");
+        mkdirSync10(voiceDir(), { recursive: true });
+        const pkgPath = join34(voiceDir(), "package.json");
         const expectedDeps = {
           "onnxruntime-node": "^1.21.0",
           "phonemizer": "^1.2.1"
         };
-        if (existsSync24(pkgPath)) {
+        if (existsSync25(pkgPath)) {
           try {
-            const existing = JSON.parse(readFileSync17(pkgPath, "utf8"));
+            const existing = JSON.parse(readFileSync18(pkgPath, "utf8"));
             if (!existing.dependencies?.["phonemizer"]) {
               existing.dependencies = { ...existing.dependencies, ...expectedDeps };
-              writeFileSync9(pkgPath, JSON.stringify(existing, null, 2));
+              writeFileSync10(pkgPath, JSON.stringify(existing, null, 2));
             }
           } catch {
           }
         }
-        if (!existsSync24(pkgPath)) {
-          writeFileSync9(pkgPath, JSON.stringify({
+        if (!existsSync25(pkgPath)) {
+          writeFileSync10(pkgPath, JSON.stringify({
             name: "open-agents-voice",
             private: true,
             dependencies: expectedDeps
           }, null, 2));
         }
-        const voiceRequire = createRequire(join33(voiceDir(), "index.js"));
+        const voiceRequire = createRequire(join34(voiceDir(), "index.js"));
         try {
           this.ort = voiceRequire("onnxruntime-node");
         } catch {
@@ -22218,7 +22733,7 @@ var init_voice = __esm({
           }
           renderInfo("Installing ONNX runtime for voice synthesis...");
           try {
-            execSync20("npm install --no-audit --no-fund", {
+            execSync21("npm install --no-audit --no-fund", {
               cwd: voiceDir(),
               stdio: "pipe",
               timeout: 12e4
@@ -22239,7 +22754,7 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
           }
           renderInfo("Installing phonemizer for voice synthesis...");
           try {
-            execSync20("npm install --no-audit --no-fund", {
+            execSync21("npm install --no-audit --no-fund", {
               cwd: voiceDir(),
               stdio: "pipe",
               timeout: 12e4
@@ -22263,18 +22778,18 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
         const dir = modelDir(id);
         const onnxPath = modelOnnxPath(id);
         const configPath = modelConfigPath(id);
-        if (existsSync24(onnxPath) && existsSync24(configPath))
+        if (existsSync25(onnxPath) && existsSync25(configPath))
           return;
-        mkdirSync9(dir, { recursive: true });
-        if (!existsSync24(configPath)) {
+        mkdirSync10(dir, { recursive: true });
+        if (!existsSync25(configPath)) {
           renderInfo(`Downloading ${model.label} voice config...`);
           const configResp = await fetch(model.configUrl);
           if (!configResp.ok)
             throw new Error(`Failed to download config: HTTP ${configResp.status}`);
           const configText = await configResp.text();
-          writeFileSync9(configPath, configText);
+          writeFileSync10(configPath, configText);
         }
-        if (!existsSync24(onnxPath)) {
+        if (!existsSync25(onnxPath)) {
           renderInfo(`Downloading ${model.label} voice model (this may take a minute)...`);
           const onnxResp = await fetch(model.onnxUrl);
           if (!onnxResp.ok)
@@ -22298,7 +22813,7 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
           }
           process.stdout.write("\r" + " ".repeat(60) + "\r");
           const fullBuffer = Buffer.concat(chunks);
-          writeFileSync9(onnxPath, fullBuffer);
+          writeFileSync10(onnxPath, fullBuffer);
           renderInfo(`${model.label} model downloaded (${formatBytes2(fullBuffer.length)}).`);
         }
       }
@@ -22310,10 +22825,10 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
           throw new Error("ONNX runtime not loaded");
         const onnxPath = modelOnnxPath(this.modelId);
         const configPath = modelConfigPath(this.modelId);
-        if (!existsSync24(onnxPath) || !existsSync24(configPath)) {
+        if (!existsSync25(onnxPath) || !existsSync25(configPath)) {
           throw new Error(`Model files not found for ${this.modelId}`);
         }
-        this.config = JSON.parse(readFileSync17(configPath, "utf8"));
+        this.config = JSON.parse(readFileSync18(configPath, "utf8"));
         renderInfo("Loading voice model...");
         this.session = await this.ort.InferenceSession.create(onnxPath, {
           executionProviders: ["cpu"],
@@ -22813,13 +23328,13 @@ var init_stream_renderer = __esm({
 });
 
 // packages/cli/dist/tui/edit-history.js
-import { appendFileSync, mkdirSync as mkdirSync10 } from "node:fs";
-import { join as join34 } from "node:path";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync11 } from "node:fs";
+import { join as join35 } from "node:path";
 function createEditHistoryLogger(repoRoot, sessionId) {
-  const historyDir = join34(repoRoot, ".oa", "history");
-  const logPath = join34(historyDir, "edits.jsonl");
+  const historyDir = join35(repoRoot, ".oa", "history");
+  const logPath = join35(historyDir, "edits.jsonl");
   try {
-    mkdirSync10(historyDir, { recursive: true });
+    mkdirSync11(historyDir, { recursive: true });
   } catch {
   }
   function logToolCall(toolName, toolArgs, success) {
@@ -22835,7 +23350,7 @@ function createEditHistoryLogger(repoRoot, sessionId) {
       args: sanitizeArgs(toolName, toolArgs)
     };
     try {
-      appendFileSync(logPath, JSON.stringify(entry) + "\n", "utf-8");
+      appendFileSync2(logPath, JSON.stringify(entry) + "\n", "utf-8");
     } catch {
     }
   }
@@ -22928,9 +23443,9 @@ var init_edit_history = __esm({
 });
 
 // packages/cli/dist/tui/dream-engine.js
-import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync10, readFileSync as readFileSync18, existsSync as existsSync25, cpSync, rmSync, readdirSync as readdirSync10 } from "node:fs";
-import { join as join35, basename as basename12 } from "node:path";
-import { execSync as execSync21 } from "node:child_process";
+import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync11, readFileSync as readFileSync19, existsSync as existsSync26, cpSync, rmSync, readdirSync as readdirSync10 } from "node:fs";
+import { join as join36, basename as basename12 } from "node:path";
+import { execSync as execSync22 } from "node:child_process";
 function adaptTool(tool) {
   return {
     name: tool.name,
@@ -23104,14 +23619,14 @@ 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") ? join35(this.dreamsDir, basename12(rawPath)) : join35(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join36(this.dreamsDir, basename12(rawPath)) : join36(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 = join35(targetPath, "..");
-          mkdirSync11(dir, { recursive: true });
-          writeFileSync10(targetPath, content, "utf-8");
+          const dir = join36(targetPath, "..");
+          mkdirSync12(dir, { recursive: true });
+          writeFileSync11(targetPath, content, "utf-8");
           return { success: true, output: `Wrote ${content.length} bytes to ${rawPath}`, durationMs: Date.now() - start };
         } catch (err) {
           return { success: false, output: "", error: String(err), durationMs: Date.now() - start };
@@ -23139,20 +23654,20 @@ 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") ? join35(this.dreamsDir, basename12(rawPath)) : join35(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join36(this.dreamsDir, basename12(rawPath)) : join36(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 };
         }
         try {
-          if (!existsSync25(targetPath)) {
+          if (!existsSync26(targetPath)) {
             return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: Date.now() - start };
           }
-          let content = readFileSync18(targetPath, "utf-8");
+          let content = readFileSync19(targetPath, "utf-8");
           if (!content.includes(oldStr)) {
             return { success: false, output: "", error: "old_string not found in file", durationMs: Date.now() - start };
           }
           content = content.replace(oldStr, newStr);
-          writeFileSync10(targetPath, content, "utf-8");
+          writeFileSync11(targetPath, content, "utf-8");
           return { success: true, output: `Edited ${rawPath}`, durationMs: Date.now() - start };
         } catch (err) {
           return { success: false, output: "", error: String(err), durationMs: Date.now() - start };
@@ -23183,7 +23698,7 @@ var init_dream_engine = __esm({
           }
         }
         try {
-          const output = execSync21(cmd, {
+          const output = execSync22(cmd, {
             cwd: this.repoRoot,
             timeout: 3e4,
             encoding: "utf-8",
@@ -23206,7 +23721,7 @@ var init_dream_engine = __esm({
       constructor(config, repoRoot) {
         this.config = config;
         this.repoRoot = repoRoot;
-        this.dreamsDir = join35(repoRoot, ".oa", "dreams");
+        this.dreamsDir = join36(repoRoot, ".oa", "dreams");
         this.state = {
           mode: "default",
           active: false,
@@ -23237,7 +23752,7 @@ var init_dream_engine = __esm({
           startedAt: (/* @__PURE__ */ new Date()).toISOString(),
           results: []
         };
-        mkdirSync11(this.dreamsDir, { recursive: true });
+        mkdirSync12(this.dreamsDir, { recursive: true });
         this.saveDreamState();
         try {
           for (let cycle = 1; cycle <= totalCycles; cycle++) {
@@ -23286,8 +23801,8 @@ ${result.summary}`;
             if (mode !== "default" || cycle === totalCycles) {
               renderDreamContraction(cycle);
               const cycleSummary = this.buildCycleSummary(cycle, previousFindings);
-              const summaryPath = join35(this.dreamsDir, `cycle-${cycle}-summary.md`);
-              writeFileSync10(summaryPath, cycleSummary, "utf-8");
+              const summaryPath = join36(this.dreamsDir, `cycle-${cycle}-summary.md`);
+              writeFileSync11(summaryPath, cycleSummary, "utf-8");
             }
             if (mode === "lucid" && !this.abortController.signal.aborted) {
               this.saveVersionCheckpoint(cycle);
@@ -23525,29 +24040,29 @@ After synthesis, call task_complete with the final prioritized summary.`, toolMo
       }
       /** Save workspace backup for lucid mode */
       saveVersionCheckpoint(cycle) {
-        const checkpointDir = join35(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
+        const checkpointDir = join36(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
         try {
-          mkdirSync11(checkpointDir, { recursive: true });
+          mkdirSync12(checkpointDir, { recursive: true });
           try {
-            const gitStatus = execSync21("git status --porcelain", {
+            const gitStatus = execSync22("git status --porcelain", {
               cwd: this.repoRoot,
               encoding: "utf-8",
               timeout: 1e4
             });
-            const gitDiff = execSync21("git diff", {
+            const gitDiff = execSync22("git diff", {
               cwd: this.repoRoot,
               encoding: "utf-8",
               timeout: 1e4
             });
-            const gitHash = execSync21("git rev-parse HEAD 2>/dev/null || echo 'no-git'", {
+            const gitHash = execSync22("git rev-parse HEAD 2>/dev/null || echo 'no-git'", {
               cwd: this.repoRoot,
               encoding: "utf-8",
               timeout: 5e3
             }).trim();
-            writeFileSync10(join35(checkpointDir, "git-status.txt"), gitStatus, "utf-8");
-            writeFileSync10(join35(checkpointDir, "git-diff.patch"), gitDiff, "utf-8");
-            writeFileSync10(join35(checkpointDir, "git-hash.txt"), gitHash, "utf-8");
-            writeFileSync10(join35(checkpointDir, "checkpoint.json"), JSON.stringify({
+            writeFileSync11(join36(checkpointDir, "git-status.txt"), gitStatus, "utf-8");
+            writeFileSync11(join36(checkpointDir, "git-diff.patch"), gitDiff, "utf-8");
+            writeFileSync11(join36(checkpointDir, "git-hash.txt"), gitHash, "utf-8");
+            writeFileSync11(join36(checkpointDir, "checkpoint.json"), JSON.stringify({
               cycle,
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
               gitHash,
@@ -23555,7 +24070,7 @@ After synthesis, call task_complete with the final prioritized summary.`, toolMo
             }, null, 2), "utf-8");
             renderInfo(`Checkpoint saved: cycle ${cycle} (${gitHash.slice(0, 8)})`);
           } catch {
-            writeFileSync10(join35(checkpointDir, "checkpoint.json"), JSON.stringify({ cycle, timestamp: (/* @__PURE__ */ new Date()).toISOString(), mode: this.state.mode }, null, 2), "utf-8");
+            writeFileSync11(join36(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) {
@@ -23613,14 +24128,14 @@ ${files.map((f) => `- [\`${f}\`](./${f})`).join("\n")}
 ---
 *Auto-generated by open-agents dream engine*
 `;
-          writeFileSync10(join35(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
+          writeFileSync11(join36(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
         } catch {
         }
       }
       /** Save dream state for resume/inspection */
       saveDreamState() {
         try {
-          writeFileSync10(join35(this.dreamsDir, "dream-state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
+          writeFileSync11(join36(this.dreamsDir, "dream-state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
         } catch {
         }
       }
@@ -23773,8 +24288,8 @@ var init_bless_engine = __esm({
 });
 
 // packages/cli/dist/tui/dmn-engine.js
-import { existsSync as existsSync26, readFileSync as readFileSync19, writeFileSync as writeFileSync11, mkdirSync as mkdirSync12, readdirSync as readdirSync11, unlinkSync as unlinkSync5 } from "node:fs";
-import { join as join36, basename as basename13 } from "node:path";
+import { existsSync as existsSync27, readFileSync as readFileSync20, writeFileSync as writeFileSync12, mkdirSync as mkdirSync13, readdirSync as readdirSync11, unlinkSync as unlinkSync5 } from "node:fs";
+import { join as join37, basename as basename13 } from "node:path";
 function buildDMNGatherPrompt(recentTaskSummaries, dueReminders, attentionItems, memoryTopics, capabilities, competence, reflectionBuffer) {
   const competenceReport = competence.length > 0 ? competence.map((c3) => {
     const rate = c3.attempts > 0 ? Math.round(c3.successes / c3.attempts * 100) : 0;
@@ -24006,9 +24521,9 @@ var init_dmn_engine = __esm({
       constructor(config, repoRoot) {
         this.config = config;
         this.repoRoot = repoRoot;
-        this.stateDir = join36(repoRoot, ".oa", "dmn");
-        this.historyDir = join36(repoRoot, ".oa", "dmn", "cycles");
-        mkdirSync12(this.historyDir, { recursive: true });
+        this.stateDir = join37(repoRoot, ".oa", "dmn");
+        this.historyDir = join37(repoRoot, ".oa", "dmn", "cycles");
+        mkdirSync13(this.historyDir, { recursive: true });
         this.loadState();
       }
       get stats() {
@@ -24596,11 +25111,11 @@ OUTPUT: Call task_complete with JSON:
       async gatherMemoryTopics() {
         const topics = [];
         const dirs = [
-          join36(this.repoRoot, ".oa", "memory"),
-          join36(this.repoRoot, ".open-agents", "memory")
+          join37(this.repoRoot, ".oa", "memory"),
+          join37(this.repoRoot, ".open-agents", "memory")
         ];
         for (const dir of dirs) {
-          if (!existsSync26(dir))
+          if (!existsSync27(dir))
             continue;
           try {
             const files = readdirSync11(dir).filter((f) => f.endsWith(".json"));
@@ -24616,29 +25131,29 @@ OUTPUT: Call task_complete with JSON:
       }
       // ── State persistence ─────────────────────────────────────────────────
       loadState() {
-        const path = join36(this.stateDir, "state.json");
-        if (existsSync26(path)) {
+        const path = join37(this.stateDir, "state.json");
+        if (existsSync27(path)) {
           try {
-            this.state = JSON.parse(readFileSync19(path, "utf-8"));
+            this.state = JSON.parse(readFileSync20(path, "utf-8"));
           } catch {
           }
         }
       }
       saveState() {
         try {
-          writeFileSync11(join36(this.stateDir, "state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
+          writeFileSync12(join37(this.stateDir, "state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
         } catch {
         }
       }
       saveCycleResult(result) {
         try {
           const filename = `cycle-${result.cycleNumber}-${Date.now()}.json`;
-          writeFileSync11(join36(this.historyDir, filename), JSON.stringify(result, null, 2) + "\n", "utf-8");
+          writeFileSync12(join37(this.historyDir, filename), JSON.stringify(result, null, 2) + "\n", "utf-8");
           const files = readdirSync11(this.historyDir).filter((f) => f.startsWith("cycle-") && f.endsWith(".json")).sort();
           if (files.length > 50) {
             for (const old of files.slice(0, files.length - 50)) {
               try {
-                unlinkSync5(join36(this.historyDir, old));
+                unlinkSync5(join37(this.historyDir, old));
               } catch {
               }
             }
@@ -24651,8 +25166,8 @@ OUTPUT: Call task_complete with JSON:
 });
 
 // packages/cli/dist/tui/snr-engine.js
-import { existsSync as existsSync27, readdirSync as readdirSync12, readFileSync as readFileSync20 } from "node:fs";
-import { join as join37, basename as basename14 } from "node:path";
+import { existsSync as existsSync28, readdirSync as readdirSync12, readFileSync as readFileSync21 } from "node:fs";
+import { join as join38, basename as basename14 } from "node:path";
 function computeDPrime(signalScores, noiseScores) {
   if (signalScores.length === 0 || noiseScores.length === 0)
     return 0;
@@ -24899,11 +25414,11 @@ Call task_complete with the JSON array when done.`, onEvent)
       loadMemoryEntries(topics) {
         const entries = [];
         const dirs = [
-          join37(this.repoRoot, ".oa", "memory"),
-          join37(this.repoRoot, ".open-agents", "memory")
+          join38(this.repoRoot, ".oa", "memory"),
+          join38(this.repoRoot, ".open-agents", "memory")
         ];
         for (const dir of dirs) {
-          if (!existsSync27(dir))
+          if (!existsSync28(dir))
             continue;
           try {
             const files = readdirSync12(dir).filter((f) => f.endsWith(".json"));
@@ -24912,7 +25427,7 @@ Call task_complete with the JSON array when done.`, onEvent)
               if (topics.length > 0 && !topics.includes(topic))
                 continue;
               try {
-                const data = JSON.parse(readFileSync20(join37(dir, f), "utf-8"));
+                const data = JSON.parse(readFileSync21(join38(dir, f), "utf-8"));
                 for (const [key, val] of Object.entries(data)) {
                   const value = typeof val === "object" && val !== null && "value" in val ? String(val.value) : String(val);
                   entries.push({ topic, key, value });
@@ -26309,11 +26824,11 @@ var init_status_bar = __esm({
 import * as readline2 from "node:readline";
 import { Writable } from "node:stream";
 import { cwd } from "node:process";
-import { resolve as resolve23, join as join38, dirname as dirname11, extname as extname9 } from "node:path";
+import { resolve as resolve24, join as join39, dirname as dirname12, extname as extname9 } from "node:path";
 import { createRequire as createRequire2 } from "node:module";
-import { fileURLToPath as fileURLToPath8 } from "node:url";
-import { readFileSync as readFileSync21, rmSync as rmSync2, readdirSync as readdirSync13 } from "node:fs";
-import { existsSync as existsSync28 } from "node:fs";
+import { fileURLToPath as fileURLToPath9 } from "node:url";
+import { readFileSync as readFileSync22, rmSync as rmSync2, readdirSync as readdirSync13 } from "node:fs";
+import { existsSync as existsSync29 } from "node:fs";
 function formatTimeAgo(date) {
   const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
   if (seconds < 60)
@@ -26330,14 +26845,14 @@ function formatTimeAgo(date) {
 function getVersion() {
   try {
     const require2 = createRequire2(import.meta.url);
-    const thisDir = dirname11(fileURLToPath8(import.meta.url));
+    const thisDir = dirname12(fileURLToPath9(import.meta.url));
     const candidates = [
-      join38(thisDir, "..", "package.json"),
-      join38(thisDir, "..", "..", "package.json"),
-      join38(thisDir, "..", "..", "..", "package.json")
+      join39(thisDir, "..", "package.json"),
+      join39(thisDir, "..", "..", "package.json"),
+      join39(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync28(pkgPath)) {
+      if (existsSync29(pkgPath)) {
         const pkg = require2(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           return pkg.version ?? "0.0.0";
@@ -26438,6 +26953,8 @@ function buildTools(repoRoot, config, contextWindowSize) {
     new OcrImageAdvancedTool(repoRoot),
     // Browser automation (headless Chrome via Hydra scrape service)
     new BrowserActionTool(),
+    // Autoresearch (autonomous ML experiment loop)
+    new AutoresearchTool(repoRoot),
     // Temporal agency (scheduling, reminders, attention steering)
     new SchedulerTool(repoRoot),
     new ReminderTool(repoRoot),
@@ -26529,15 +27046,15 @@ Use task_status("${taskId}") or task_output("${taskId}") to check progress.`
 function gatherMemorySnippets(root) {
   const snippets = [];
   const dirs = [
-    join38(root, ".oa", "memory"),
-    join38(root, ".open-agents", "memory")
+    join39(root, ".oa", "memory"),
+    join39(root, ".open-agents", "memory")
   ];
   for (const dir of dirs) {
-    if (!existsSync28(dir))
+    if (!existsSync29(dir))
       continue;
     try {
       for (const f of readdirSync13(dir).filter((f2) => f2.endsWith(".json"))) {
-        const data = JSON.parse(readFileSync21(join38(dir, f), "utf-8"));
+        const data = JSON.parse(readFileSync22(join39(dir, f), "utf-8"));
         for (const val of Object.values(data)) {
           const v = typeof val === "object" && val !== null && "value" in val ? String(val.value) : String(val);
           if (v.length > 10)
@@ -26937,7 +27454,7 @@ ${entry.fullContent}`
   } };
 }
 async function startInteractive(config, repoPath) {
-  const repoRoot = resolve23(repoPath ?? cwd());
+  const repoRoot = resolve24(repoPath ?? cwd());
   const resumeFlag = process.env.__OA_RESUMED ?? "";
   const isResumed = resumeFlag !== "";
   const hasTaskToResume = resumeFlag === "1";
@@ -27091,14 +27608,14 @@ async function startInteractive(config, repoPath) {
       renderInfo(msg);
       statusBar.endContentWrite();
     }
-  }, () => new Promise((resolve26) => {
+  }, () => new Promise((resolve27) => {
     depSudoPromptPending = true;
     depSudoResolver = (pw) => {
       depSudoPromptPending = false;
       depSudoResolver = null;
       if (pw)
         sessionSudoPassword = pw;
-      resolve26(pw);
+      resolve27(pw);
     };
     if (statusBar?.isActive) {
       statusBar.beginContentWrite();
@@ -27723,8 +28240,8 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       return true;
     },
     destroyProject() {
-      const oaPath = join38(repoRoot, OA_DIR);
-      if (existsSync28(oaPath)) {
+      const oaPath = join39(repoRoot, OA_DIR);
+      if (existsSync29(oaPath)) {
         try {
           rmSync2(oaPath, { recursive: true, force: true });
           writeContent(() => renderInfo(`Removed ${OA_DIR}/ directory.`));
@@ -27998,13 +28515,13 @@ Execute this skill now. Follow the behavioral guidance above.`;
       }
     }
     const cleanPath = input.replace(/^['"]|['"]$/g, "").trim();
-    const isImage = isImagePath(cleanPath) && existsSync28(resolve23(repoRoot, cleanPath));
-    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync28(resolve23(repoRoot, cleanPath));
+    const isImage = isImagePath(cleanPath) && existsSync29(resolve24(repoRoot, cleanPath));
+    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync29(resolve24(repoRoot, cleanPath));
     if (activeTask) {
       if (isImage) {
         try {
-          const imgPath = resolve23(repoRoot, cleanPath);
-          const imgBuffer = readFileSync21(imgPath);
+          const imgPath = resolve24(repoRoot, cleanPath);
+          const imgBuffer = readFileSync22(imgPath);
           const base64 = imgBuffer.toString("base64");
           const ext = extname9(cleanPath).toLowerCase();
           const mime = ext === ".png" ? "image/png" : ext === ".gif" ? "image/gif" : ext === ".webp" ? "image/webp" : "image/jpeg";
@@ -28017,7 +28534,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(resolve23(repoRoot, cleanPath), repoRoot);
+        const result = await engine.transcribeFile(resolve24(repoRoot, cleanPath), repoRoot);
         if (result) {
           const transcript = `[Transcription of ${cleanPath}]
 ${result.text}`;
@@ -28050,7 +28567,7 @@ ${result.text}`;
     if (isMedia && fullInput === input) {
       writeContent(() => renderInfo(`Transcribing: ${cleanPath}...`));
       const engine = getListenEngine();
-      const result = await engine.transcribeFile(resolve23(repoRoot, cleanPath), repoRoot);
+      const result = await engine.transcribeFile(resolve24(repoRoot, cleanPath), repoRoot);
       if (result) {
         fullInput = `The user has provided an audio/video file: ${cleanPath}.
 
@@ -28268,7 +28785,7 @@ ${c2.dim("(Use /quit to exit)")}
   });
 }
 async function runWithTUI(task, config, repoPath) {
-  const repoRoot = resolve23(repoPath ?? cwd());
+  const repoRoot = resolve24(repoPath ?? cwd());
   const needsSetup = isFirstRun() || !await isModelAvailable(config);
   if (needsSetup && config.backendType === "ollama") {
     const setupModel = await runSetupWizard(config);
@@ -28378,7 +28895,7 @@ import { glob } from "glob";
 import ignore from "ignore";
 import { readFile as readFile14, stat as stat4 } from "node:fs/promises";
 import { createHash } from "node:crypto";
-import { join as join39, relative as relative3, extname as extname10, basename as basename15 } from "node:path";
+import { join as join40, relative as relative3, extname as extname10, basename as basename15 } from "node:path";
 var DEFAULT_EXCLUDE, LANGUAGE_MAP, CodebaseIndexer;
 var init_codebase_indexer = __esm({
   "packages/indexer/dist/codebase-indexer.js"() {
@@ -28422,7 +28939,7 @@ var init_codebase_indexer = __esm({
         const ig = ignore.default();
         if (this.config.respectGitignore) {
           try {
-            const gitignoreContent = await readFile14(join39(this.config.rootDir, ".gitignore"), "utf-8");
+            const gitignoreContent = await readFile14(join40(this.config.rootDir, ".gitignore"), "utf-8");
             ig.add(gitignoreContent);
           } catch {
           }
@@ -28437,7 +28954,7 @@ var init_codebase_indexer = __esm({
         for (const relativePath of files) {
           if (ig.ignores(relativePath))
             continue;
-          const fullPath = join39(this.config.rootDir, relativePath);
+          const fullPath = join40(this.config.rootDir, relativePath);
           try {
             const fileStat = await stat4(fullPath);
             if (fileStat.size > this.config.maxFileSize)
@@ -28483,7 +29000,7 @@ var init_codebase_indexer = __esm({
               if (!child) {
                 child = {
                   name: part,
-                  path: join39(current.path, part),
+                  path: join40(current.path, part),
                   type: "directory",
                   children: []
                 };
@@ -28565,14 +29082,14 @@ var index_repo_exports = {};
 __export(index_repo_exports, {
   indexRepoCommand: () => indexRepoCommand
 });
-import { resolve as resolve24 } from "node:path";
-import { existsSync as existsSync29, statSync as statSync10 } from "node:fs";
+import { resolve as resolve25 } from "node:path";
+import { existsSync as existsSync30, statSync as statSync10 } from "node:fs";
 import { cwd as cwd2 } from "node:process";
 async function indexRepoCommand(opts, _config) {
-  const repoRoot = resolve24(opts.repoPath ?? cwd2());
+  const repoRoot = resolve25(opts.repoPath ?? cwd2());
   printHeader("Index Repository");
   printInfo(`Indexing: ${repoRoot}`);
-  if (!existsSync29(repoRoot)) {
+  if (!existsSync30(repoRoot)) {
     printError(`Path does not exist: ${repoRoot}`);
     process.exit(1);
   }
@@ -28824,7 +29341,7 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { join as join40, resolve as resolve25 } from "node:path";
+import { join as join41, resolve as resolve26 } from "node:path";
 import { homedir as homedir13 } from "node:os";
 import { cwd as cwd3 } from "node:process";
 function redactIfSensitive(key, value) {
@@ -28851,7 +29368,7 @@ async function configCommand(opts, config) {
   return handleShow(opts, config);
 }
 function handleShow(opts, config) {
-  const repoRoot = resolve25(opts.repoPath ?? cwd3());
+  const repoRoot = resolve26(opts.repoPath ?? cwd3());
   printHeader("Configuration");
   printSection("Active Settings (merged)");
   printKeyValue("backendUrl", config.backendUrl, 2);
@@ -28883,7 +29400,7 @@ function handleShow(opts, config) {
     }
   }
   printSection("Config File");
-  printInfo(`~/.open-agents/config.json (${join40(homedir13(), ".open-agents", "config.json")})`);
+  printInfo(`~/.open-agents/config.json (${join41(homedir13(), ".open-agents", "config.json")})`);
   printSection("Priority Chain");
   printInfo("  1. CLI flags (--model, --backend-url, etc.)");
   printInfo("  2. Project .oa/settings.json (--local)");
@@ -28916,13 +29433,13 @@ function handleSet(opts, _config) {
     process.exit(1);
   }
   if (opts.local) {
-    const repoRoot = resolve25(opts.repoPath ?? cwd3());
+    const repoRoot = resolve26(opts.repoPath ?? cwd3());
     try {
       initOaDirectory(repoRoot);
       const coerced = coerceForSettings(key, value);
       saveProjectSettings(repoRoot, { [key]: coerced });
       printSuccess(`Project override set: ${key} = ${redactIfSensitive(key, value)}`);
-      printInfo(`Saved to ${join40(repoRoot, ".oa", "settings.json")}`);
+      printInfo(`Saved to ${join41(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)}`);
@@ -28983,7 +29500,7 @@ var serve_exports = {};
 __export(serve_exports, {
   serveCommand: () => serveCommand
 });
-import { spawn as spawn10 } from "node:child_process";
+import { spawn as spawn11 } from "node:child_process";
 async function serveCommand(opts, config) {
   const backendType = config.backendType;
   if (backendType === "ollama") {
@@ -29075,8 +29592,8 @@ async function serveVllm(opts, config) {
   await runVllmServer(args, opts.verbose ?? false);
 }
 async function runVllmServer(args, verbose) {
-  return new Promise((resolve26, reject) => {
-    const child = spawn10("python", args, {
+  return new Promise((resolve27, reject) => {
+    const child = spawn11("python", args, {
       stdio: verbose ? "inherit" : ["ignore", "pipe", "pipe"],
       env: { ...process.env }
     });
@@ -29110,10 +29627,10 @@ async function runVllmServer(args, verbose) {
     child.once("exit", (code, signal) => {
       if (signal) {
         printInfo(`vLLM server stopped by signal ${signal}`);
-        resolve26();
+        resolve27();
       } else if (code === 0) {
         printSuccess("vLLM server exited cleanly");
-        resolve26();
+        resolve27();
       } else {
         printError(`vLLM server exited with code ${code}`);
         reject(new Error(`vLLM exited with code ${code}`));
@@ -29141,8 +29658,8 @@ __export(eval_exports, {
   evalCommand: () => evalCommand
 });
 import { tmpdir as tmpdir7 } from "node:os";
-import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync12 } from "node:fs";
-import { join as join41 } from "node:path";
+import { mkdirSync as mkdirSync14, writeFileSync as writeFileSync13 } from "node:fs";
+import { join as join42 } from "node:path";
 async function evalCommand(opts, config) {
   const suiteName = opts.suite ?? "basic";
   const suite = SUITES[suiteName];
@@ -29263,9 +29780,9 @@ async function evalCommand(opts, config) {
   process.exit(failed > 0 ? 1 : 0);
 }
 function createTempEvalRepo() {
-  const dir = join41(tmpdir7(), `open-agents-eval-${Date.now()}`);
-  mkdirSync13(dir, { recursive: true });
-  writeFileSync12(join41(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
+  const dir = join42(tmpdir7(), `open-agents-eval-${Date.now()}`);
+  mkdirSync14(dir, { recursive: true });
+  writeFileSync13(join42(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
   return dir;
 }
 var BASIC_SUITE, FULL_SUITE, SUITES;
@@ -29324,8 +29841,8 @@ init_output();
 init_updater();
 import { parseArgs as nodeParseArgs2 } from "node:util";
 import { createRequire as createRequire3 } from "node:module";
-import { fileURLToPath as fileURLToPath9 } from "node:url";
-import { dirname as dirname12, join as join42 } from "node:path";
+import { fileURLToPath as fileURLToPath10 } from "node:url";
+import { dirname as dirname13, join as join43 } from "node:path";
 
 // packages/cli/dist/cli.js
 import { createInterface } from "node:readline";
@@ -29432,7 +29949,7 @@ init_output();
 function getVersion2() {
   try {
     const require2 = createRequire3(import.meta.url);
-    const pkgPath = join42(dirname12(fileURLToPath9(import.meta.url)), "..", "package.json");
+    const pkgPath = join43(dirname13(fileURLToPath10(import.meta.url)), "..", "package.json");
     const pkg = require2(pkgPath);
     return pkg.version;
   } catch {