open-agents-ai 0.32.2 → 0.34.0

package/dist/index.js

@@ -1285,7 +1285,7 @@ ${stdinInput ?? ""}`);
       }
       runCommand(command, timeout, stdinInput) {
         const start = performance.now();
-        return new Promise((resolve22) => {
+        return new Promise((resolve23) => {
           const child = spawn("bash", ["-c", command], {
             cwd: this.workingDir,
             env: {
@@ -1313,7 +1313,7 @@ ${stdinInput ?? ""}`);
             clearTimeout(timer);
             if (exitFlushTimer)
               clearTimeout(exitFlushTimer);
-            resolve22(result);
+            resolve23(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((resolve22, reject) => {
+        return new Promise((resolve23, 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;
             }
-            resolve22({
+            resolve23({
               stdout: String(stdout),
               stderr: String(stderr),
               exitCode: error ? error.code ?? 1 : 0
@@ -2639,9 +2639,402 @@ var init_memory_write = __esm({
   }
 });
 
+// packages/execution/dist/tools/memory-search.js
+import { readFile as readFile5, readdir } from "node:fs/promises";
+import { resolve as resolve8, join as join6, basename } from "node:path";
+import { existsSync as existsSync4 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+function termMatchScore(query, document) {
+  const queryTerms = tokenize(query);
+  const docTerms = tokenize(document);
+  if (queryTerms.length === 0 || docTerms.length === 0)
+    return 0;
+  const docSet = new Set(docTerms);
+  const docBigrams = /* @__PURE__ */ new Set();
+  for (let i = 0; i < docTerms.length - 1; i++) {
+    docBigrams.add(`${docTerms[i]} ${docTerms[i + 1]}`);
+  }
+  let matchedTerms = 0;
+  let matchedBigrams = 0;
+  let totalWeight = 0;
+  for (const term of queryTerms) {
+    totalWeight += 1;
+    if (docSet.has(term)) {
+      matchedTerms += 1;
+    } else if ([...docSet].some((d) => d.startsWith(term) || term.startsWith(d))) {
+      matchedTerms += 0.5;
+    }
+  }
+  for (let i = 0; i < queryTerms.length - 1; i++) {
+    const bigram = `${queryTerms[i]} ${queryTerms[i + 1]}`;
+    totalWeight += 1;
+    if (docBigrams.has(bigram)) {
+      matchedBigrams += 1;
+    }
+  }
+  return totalWeight > 0 ? (matchedTerms + matchedBigrams * 2) / (totalWeight * 2) : 0;
+}
+function tokenize(text) {
+  const STOP_WORDS2 = /* @__PURE__ */ new Set([
+    "a",
+    "an",
+    "the",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "can",
+    "shall",
+    "to",
+    "of",
+    "in",
+    "for",
+    "on",
+    "with",
+    "at",
+    "by",
+    "from",
+    "as",
+    "into",
+    "through",
+    "during",
+    "before",
+    "after",
+    "above",
+    "below",
+    "and",
+    "but",
+    "or",
+    "not",
+    "no",
+    "if",
+    "then",
+    "else",
+    "when",
+    "up",
+    "out",
+    "so",
+    "than",
+    "too",
+    "very",
+    "just",
+    "about",
+    "this",
+    "that",
+    "these",
+    "those",
+    "it",
+    "its"
+  ]);
+  return text.toLowerCase().replace(/[^a-z0-9_\-\.]+/g, " ").split(/\s+/).filter((t) => t.length > 1 && !STOP_WORDS2.has(t));
+}
+var MemorySearchTool;
+var init_memory_search = __esm({
+  "packages/execution/dist/tools/memory-search.js"() {
+    "use strict";
+    MemorySearchTool = class {
+      name = "memory_search";
+      description = "Search across all memory entries by relevance. Unlike memory_read (exact topic+key), this finds relevant memories using text matching. Use when you don't know the exact topic or key, or want to find all memories related to a concept.";
+      parameters = {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Natural language search query (e.g. 'authentication bug fix', 'React patterns')"
+          },
+          max_results: {
+            type: "number",
+            description: "Maximum number of results to return (default: 10)"
+          }
+        },
+        required: ["query"]
+      };
+      workingDir;
+      constructor(workingDir) {
+        this.workingDir = workingDir;
+      }
+      async execute(args) {
+        const query = args["query"];
+        const maxResults = args["max_results"] ?? 10;
+        const start = performance.now();
+        try {
+          const allEntries = await this.loadAllMemories();
+          if (allEntries.length === 0) {
+            return {
+              success: true,
+              output: "No memory entries found. Use memory_write to store insights.",
+              durationMs: performance.now() - start
+            };
+          }
+          const scored = allEntries.map((entry) => ({
+            ...entry,
+            score: termMatchScore(query, `${entry.topic} ${entry.key} ${entry.value}`)
+          }));
+          const results = scored.filter((e) => e.score > 0).sort((a, b) => b.score - a.score).slice(0, maxResults);
+          if (results.length === 0) {
+            return {
+              success: true,
+              output: `No memories matched query: "${query}"
+
+Try broader terms or use memory_read with a specific topic.`,
+              durationMs: performance.now() - start
+            };
+          }
+          const lines = [
+            `Found ${results.length} relevant memories for: "${query}"
+`
+          ];
+          for (const r of results) {
+            const score = Math.round(r.score * 100);
+            lines.push(`[${r.topic}/${r.key}] (relevance: ${score}%)`);
+            lines.push(`  ${r.value.slice(0, 300)}${r.value.length > 300 ? "..." : ""}`);
+            if (r.timestamp)
+              lines.push(`  (saved: ${r.timestamp.split("T")[0]})`);
+            lines.push("");
+          }
+          return {
+            success: true,
+            output: lines.join("\n"),
+            durationMs: performance.now() - start
+          };
+        } catch (error) {
+          return {
+            success: false,
+            output: "",
+            error: error instanceof Error ? error.message : String(error),
+            durationMs: performance.now() - start
+          };
+        }
+      }
+      /**
+       * Load all memory entries from all memory directories.
+       */
+      async loadAllMemories() {
+        const entries = [];
+        const dirs = [
+          resolve8(this.workingDir, ".oa", "memory"),
+          resolve8(this.workingDir, ".open-agents", "memory"),
+          resolve8(homedir3(), ".open-agents", "memory")
+        ];
+        const seen = /* @__PURE__ */ new Set();
+        for (const dir of dirs) {
+          if (!existsSync4(dir))
+            continue;
+          try {
+            const files = await readdir(dir);
+            for (const file of files.filter((f) => f.endsWith(".json"))) {
+              try {
+                const raw = await readFile5(join6(dir, file), "utf-8");
+                const data = JSON.parse(raw);
+                const topic = basename(file, ".json");
+                for (const [key, entry] of Object.entries(data)) {
+                  const dedup = `${topic}:${key}`;
+                  if (seen.has(dedup))
+                    continue;
+                  seen.add(dedup);
+                  if (entry?.value) {
+                    entries.push({
+                      topic,
+                      key,
+                      value: String(entry.value),
+                      timestamp: entry.timestamp,
+                      score: 0
+                    });
+                  }
+                }
+              } catch {
+              }
+            }
+          } catch {
+          }
+        }
+        return entries;
+      }
+    };
+  }
+});
+
+// packages/execution/dist/tools/explore-tools.js
+var TOOL_CATALOG, ExploreToolsTool;
+var init_explore_tools = __esm({
+  "packages/execution/dist/tools/explore-tools.js"() {
+    "use strict";
+    TOOL_CATALOG = {
+      grep_search: "Search file contents with regex patterns",
+      find_files: "Find files by glob pattern (e.g. **/*.ts)",
+      list_directory: "List contents of a directory",
+      web_search: "Search the web via DuckDuckGo",
+      web_fetch: "Fetch and read a web page URL",
+      web_crawl: "Crawl a website following links",
+      memory_read: "Read from persistent memory (exact topic+key)",
+      memory_write: "Store a fact in persistent memory",
+      memory_search: "Search all memories by relevance",
+      batch_edit: "Apply multiple file edits atomically",
+      file_patch: "Apply unified diff patches to files",
+      git_info: "Get git status, branch, recent commits",
+      codebase_map: "Generate overview of project structure",
+      diagnostic: "Run project diagnostics (build, test, lint)",
+      image_read: "Read and describe image contents",
+      screenshot: "Capture a screenshot of the desktop",
+      ocr_image: "Extract text from images via OCR",
+      ocr_pdf: "Extract text from PDF pages via OCR",
+      pdf_to_text: "Convert PDF to plain text",
+      vision: "Describe what's on screen using Moondream",
+      desktop_click: "Click at coordinates on the desktop",
+      desktop_describe: "Describe a region of the desktop",
+      transcribe_file: "Transcribe audio/video files to text",
+      create_tool: "Create a new custom tool from a workflow",
+      manage_tools: "List, inspect, or remove custom tools",
+      skill_list: "List available AIWG skills",
+      skill_execute: "Execute an AIWG skill",
+      structured_file: "Generate structured files (CSV, JSON, MD)",
+      code_sandbox: "Run code in an isolated sandbox",
+      structured_read: "Read structured data files (CSV, JSON)",
+      sub_agent: "Delegate a subtask to a new agent instance",
+      background_run: "Run a shell command in the background",
+      task_status: "Check status of background tasks",
+      task_output: "Read output from a background task",
+      task_stop: "Stop a running background task"
+    };
+    ExploreToolsTool = class {
+      name = "explore_tools";
+      description = "Discover and enable additional tools. Call with no arguments to see all available tools. Call with enable='tool_name' to unlock a tool for this session. Call with search='query' to find tools matching your need.";
+      parameters = {
+        type: "object",
+        properties: {
+          enable: {
+            type: "string",
+            description: "Tool name to unlock for this session (omit to list available)"
+          },
+          search: {
+            type: "string",
+            description: "Search query to find relevant tools (e.g. 'search files', 'web')"
+          }
+        },
+        required: []
+      };
+      /** Set of currently unlocked tool names (managed by the runner) */
+      unlockedTools = /* @__PURE__ */ new Set();
+      /** Callback to signal tool unlock to the runner */
+      onUnlock;
+      /**
+       * Set the unlock callback. The runner calls this to wire up the unlock mechanism.
+       * The callback should return true if the tool was successfully unlocked.
+       */
+      setUnlockCallback(cb) {
+        this.onUnlock = cb;
+      }
+      /** Mark a tool as already unlocked (called by runner during init) */
+      markUnlocked(name) {
+        this.unlockedTools.add(name);
+      }
+      async execute(args) {
+        const start = performance.now();
+        const enableName = args["enable"]?.trim();
+        const searchQuery = args["search"]?.trim();
+        if (enableName) {
+          if (!(enableName in TOOL_CATALOG)) {
+            return {
+              success: false,
+              output: "",
+              error: `Unknown tool '${enableName}'. Call explore_tools() to see available tools.`,
+              durationMs: performance.now() - start
+            };
+          }
+          if (this.unlockedTools.has(enableName)) {
+            return {
+              success: true,
+              output: `Tool '${enableName}' is already unlocked. You can use it now.`,
+              durationMs: performance.now() - start
+            };
+          }
+          if (this.onUnlock) {
+            const success = this.onUnlock(enableName);
+            if (success) {
+              this.unlockedTools.add(enableName);
+              return {
+                success: true,
+                output: `Tool '${enableName}' is now unlocked and available. You can use it in your next response.`,
+                durationMs: performance.now() - start
+              };
+            }
+          }
+          return {
+            success: true,
+            output: `UNLOCK_TOOL:${enableName}`,
+            durationMs: performance.now() - start
+          };
+        }
+        if (searchQuery) {
+          const terms = searchQuery.toLowerCase().split(/\s+/);
+          const matches = [];
+          for (const [name, desc] of Object.entries(TOOL_CATALOG)) {
+            const text = `${name} ${desc}`.toLowerCase();
+            const score = terms.reduce((s, t) => s + (text.includes(t) ? 1 : 0), 0);
+            if (score > 0)
+              matches.push([name, desc, score]);
+          }
+          matches.sort((a, b) => b[2] - a[2]);
+          if (matches.length === 0) {
+            return {
+              success: true,
+              output: `No tools match "${searchQuery}". Try broader terms or call explore_tools() to list all.`,
+              durationMs: performance.now() - start
+            };
+          }
+          const lines2 = [`Tools matching "${searchQuery}":
+`];
+          for (const [name, desc] of matches.slice(0, 8)) {
+            const status = this.unlockedTools.has(name) ? " [unlocked]" : "";
+            lines2.push(`  ${name}: ${desc}${status}`);
+          }
+          lines2.push(`
+Use explore_tools(enable='name') to unlock a tool.`);
+          return {
+            success: true,
+            output: lines2.join("\n"),
+            durationMs: performance.now() - start
+          };
+        }
+        const lines = ["Available tools (call explore_tools with enable='name' to unlock):\n"];
+        for (const [name, desc] of Object.entries(TOOL_CATALOG)) {
+          const status = this.unlockedTools.has(name) ? " [unlocked]" : "";
+          lines.push(`  ${name}: ${desc}${status}`);
+        }
+        lines.push(`
+${this.unlockedTools.size} of ${Object.keys(TOOL_CATALOG).length} tools currently unlocked.`);
+        lines.push(`
+Examples:`);
+        lines.push(`  explore_tools({enable: 'grep_search'})`);
+        lines.push(`  explore_tools({search: 'search files'})`);
+        return {
+          success: true,
+          output: lines.join("\n"),
+          durationMs: performance.now() - start
+        };
+      }
+    };
+  }
+});
+
 // packages/execution/dist/tools/list-directory.js
 import { readdirSync, statSync } from "node:fs";
-import { resolve as resolve8, join as join6 } from "node:path";
+import { resolve as resolve9, join as join7 } from "node:path";
 var EXCLUDED, MAX_ENTRIES, ListDirectoryTool;
 var init_list_directory = __esm({
   "packages/execution/dist/tools/list-directory.js"() {
@@ -2669,7 +3062,7 @@ var init_list_directory = __esm({
         const dirPath = args["path"] ?? ".";
         const start = performance.now();
         try {
-          const fullPath = resolve8(this.workingDir, dirPath);
+          const fullPath = resolve9(this.workingDir, dirPath);
           const entries = readdirSync(fullPath, { withFileTypes: true });
           const visible = entries.filter((e) => !EXCLUDED.has(e.name));
           const limited = visible.slice(0, MAX_ENTRIES);
@@ -2680,7 +3073,7 @@ var init_list_directory = __esm({
             }
             let size = 0;
             try {
-              size = statSync(join6(fullPath, entry.name)).size;
+              size = statSync(join7(fullPath, entry.name)).size;
             } catch {
             }
             return `${prefix}  ${entry.name}  ${size}`;
@@ -2783,8 +3176,8 @@ ${output}`,
 
 // packages/execution/dist/tools/aiwg-health.js
 import { execSync as execSync2 } from "node:child_process";
-import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
+import { join as join8 } from "node:path";
 var AiwgHealthTool;
 var init_aiwg_health = __esm({
   "packages/execution/dist/tools/aiwg-health.js"() {
@@ -2816,8 +3209,8 @@ var init_aiwg_health = __esm({
         const detailed = args["detailed"] ?? false;
         const report = [];
         report.push("# SDLC Health Report\n");
-        const aiwgDir = join7(projectDir, ".aiwg");
-        const hasAiwg = existsSync4(aiwgDir);
+        const aiwgDir = join8(projectDir, ".aiwg");
+        const hasAiwg = existsSync5(aiwgDir);
         report.push(`## AIWG Framework: ${hasAiwg ? "DEPLOYED" : "NOT DEPLOYED"}`);
         if (hasAiwg) {
           const aiwgArtifacts = this.scanAiwgArtifacts(aiwgDir);
@@ -2885,7 +3278,7 @@ var init_aiwg_health = __esm({
           const entries = readdirSync2(aiwgDir, { withFileTypes: true });
           for (const entry of entries) {
             if (entry.isDirectory()) {
-              const subDir = join7(aiwgDir, entry.name);
+              const subDir = join8(aiwgDir, entry.name);
               try {
                 const files = readdirSync2(subDir).filter((f) => !f.startsWith("."));
                 categories[entry.name] = files.length;
@@ -2899,7 +3292,7 @@ var init_aiwg_health = __esm({
         return { total, categories };
       }
       analyzeStructure(dir) {
-        const has = (p) => existsSync4(join7(dir, p));
+        const has = (p) => existsSync5(join8(dir, p));
         return {
           packageManager: has("pnpm-lock.yaml") ? "pnpm" : has("yarn.lock") ? "yarn" : has("package-lock.json") ? "npm" : has("Cargo.toml") ? "cargo" : has("go.mod") ? "go" : "unknown",
           language: has("tsconfig.json") ? "TypeScript" : has("package.json") ? "JavaScript" : has("Cargo.toml") ? "Rust" : has("go.mod") ? "Go" : has("pyproject.toml") || has("setup.py") ? "Python" : "unknown",
@@ -2912,8 +3305,8 @@ var init_aiwg_health = __esm({
       }
       analyzeDocumentation(dir) {
         let readmeQuality = "missing";
-        const readmePath = join7(dir, "README.md");
-        if (existsSync4(readmePath)) {
+        const readmePath = join8(dir, "README.md");
+        if (existsSync5(readmePath)) {
           try {
             const content = readFileSync3(readmePath, "utf8");
             const len = content.length;
@@ -2922,12 +3315,12 @@ var init_aiwg_health = __esm({
             readmeQuality = "unreadable";
           }
         }
-        const has = (p) => existsSync4(join7(dir, p));
+        const has = (p) => existsSync5(join8(dir, p));
         const hasApiDocs = has("docs/api") || has("api-docs") || has("swagger.json") || has("openapi.yaml");
         const hasArchDocs = has("docs/architecture") || has(".aiwg/architecture") || has("ARCHITECTURE.md");
         let docFileCount = 0;
-        const docsDir = join7(dir, "docs");
-        if (existsSync4(docsDir)) {
+        const docsDir = join8(dir, "docs");
+        if (existsSync5(docsDir)) {
           try {
             docFileCount = this.countFiles(docsDir);
           } catch {
@@ -2943,7 +3336,7 @@ var init_aiwg_health = __esm({
             if (entry.isFile())
               count++;
             else if (entry.isDirectory() && entry.name !== "node_modules") {
-              count += this.countFiles(join7(dir, entry.name));
+              count += this.countFiles(join8(dir, entry.name));
             }
           }
         } catch {
@@ -3079,8 +3472,8 @@ var init_aiwg_workflow = __esm({
 });
 
 // packages/execution/dist/tools/batch-edit.js
-import { readFile as readFile5, writeFile as writeFile4 } from "node:fs/promises";
-import { resolve as resolve9 } from "node:path";
+import { readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
+import { resolve as resolve10 } from "node:path";
 function countOccurrences2(haystack, needle) {
   let count = 0;
   let pos = 0;
@@ -3146,7 +3539,7 @@ var init_batch_edit = __esm({
         }
         const byFile = /* @__PURE__ */ new Map();
         for (const edit of edits) {
-          const fullPath = resolve9(this.workingDir, edit.path);
+          const fullPath = resolve10(this.workingDir, edit.path);
           if (!byFile.has(fullPath))
             byFile.set(fullPath, []);
           byFile.get(fullPath).push({
@@ -3161,7 +3554,7 @@ var init_batch_edit = __esm({
         let failCount = 0;
         for (const [fullPath, fileEdits] of byFile) {
           try {
-            let content = await readFile5(fullPath, "utf-8");
+            let content = await readFile6(fullPath, "utf-8");
             for (const edit of fileEdits) {
               const occurrences = countOccurrences2(content, edit.old_string);
               if (occurrences === 0) {
@@ -3205,8 +3598,8 @@ ${results.join("\n")}`,
 });
 
 // packages/execution/dist/tools/file-patch.js
-import { readFile as readFile6, writeFile as writeFile5, copyFile } from "node:fs/promises";
-import { resolve as resolve10 } from "node:path";
+import { readFile as readFile7, writeFile as writeFile5, copyFile } from "node:fs/promises";
+import { resolve as resolve11 } from "node:path";
 var FilePatchTool;
 var init_file_patch = __esm({
   "packages/execution/dist/tools/file-patch.js"() {
@@ -3274,8 +3667,8 @@ var init_file_patch = __esm({
               durationMs: performance.now() - start
             };
           }
-          const fullPath = resolve10(this.workingDir, filePath);
-          const content = await readFile6(fullPath, "utf-8");
+          const fullPath = resolve11(this.workingDir, filePath);
+          const content = await readFile7(fullPath, "utf-8");
           const lines = content.split("\n");
           const totalLines = lines.length;
           if (startLine > totalLines) {
@@ -3377,8 +3770,8 @@ ${diff}`,
 });
 
 // packages/execution/dist/tools/codebase-map.js
-import { readdirSync as readdirSync3, statSync as statSync3, readFileSync as readFileSync4, existsSync as existsSync5 } from "node:fs";
-import { join as join8, relative, extname } from "node:path";
+import { readdirSync as readdirSync3, statSync as statSync3, readFileSync as readFileSync4, existsSync as existsSync6 } from "node:fs";
+import { join as join9, relative, extname } from "node:path";
 var CodebaseMapTool;
 var init_codebase_map = __esm({
   "packages/execution/dist/tools/codebase-map.js"() {
@@ -3462,8 +3855,8 @@ var init_codebase_map = __esm({
       }
       detectProjectInfo(dir) {
         const info = {};
-        const pkgPath = join8(dir, "package.json");
-        if (existsSync5(pkgPath)) {
+        const pkgPath = join9(dir, "package.json");
+        if (existsSync6(pkgPath)) {
           try {
             const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
             info.name = pkg.name;
@@ -3471,15 +3864,15 @@ var init_codebase_map = __esm({
           } catch {
           }
         }
-        if (existsSync5(join8(dir, "tsconfig.json")))
+        if (existsSync6(join9(dir, "tsconfig.json")))
           info.language = "TypeScript";
-        else if (existsSync5(join8(dir, "package.json")))
+        else if (existsSync6(join9(dir, "package.json")))
           info.language = "JavaScript";
-        else if (existsSync5(join8(dir, "Cargo.toml")))
+        else if (existsSync6(join9(dir, "Cargo.toml")))
           info.language = "Rust";
-        else if (existsSync5(join8(dir, "go.mod")))
+        else if (existsSync6(join9(dir, "go.mod")))
           info.language = "Go";
-        else if (existsSync5(join8(dir, "pyproject.toml")))
+        else if (existsSync6(join9(dir, "pyproject.toml")))
           info.language = "Python";
         return info;
       }
@@ -3507,7 +3900,7 @@ var init_codebase_map = __esm({
         ];
         const found = [];
         for (const kf of KEY_FILES) {
-          if (existsSync5(join8(dir, kf))) {
+          if (existsSync6(join9(dir, kf))) {
             found.push(kf);
           }
         }
@@ -3545,7 +3938,7 @@ var init_codebase_map = __esm({
           const dirs = entries.filter((e) => e.isDirectory() && !this.SKIP_DIRS.has(e.name));
           const files = entries.filter((e) => e.isFile());
           for (const d of dirs) {
-            const subPath = join8(dir, d.name);
+            const subPath = join9(dir, d.name);
             const fileCount = this.countFilesShallow(subPath);
             lines.push(`${indent}${d.name}/ (${fileCount} files)`);
             const subtree = this.buildTree(subPath, rootDir, depth + 1, maxDepth, showFiles);
@@ -3586,7 +3979,7 @@ var init_codebase_map = __esm({
               if (lang)
                 counts.set(lang, (counts.get(lang) ?? 0) + 1);
             } else if (entry.isDirectory() && !this.SKIP_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
-              const sub = this.countLanguages(join8(dir, entry.name), depth + 1, maxDepth);
+              const sub = this.countLanguages(join9(dir, entry.name), depth + 1, maxDepth);
               for (const [lang, count] of sub) {
                 counts.set(lang, (counts.get(lang) ?? 0) + count);
               }
@@ -3644,13 +4037,13 @@ var init_codebase_map = __esm({
             if (entry.isFile()) {
               files++;
               try {
-                const size = statSync3(join8(dir, entry.name)).size;
+                const size = statSync3(join9(dir, entry.name)).size;
                 estimatedLines += Math.ceil(size / 40);
               } catch {
               }
             } else if (entry.isDirectory() && !this.SKIP_DIRS.has(entry.name)) {
               dirs++;
-              const sub = this.countStats(join8(dir, entry.name), depth + 1, maxDepth);
+              const sub = this.countStats(join9(dir, entry.name), depth + 1, maxDepth);
               files += sub.files;
               dirs += sub.dirs;
               estimatedLines += sub.estimatedLines;
@@ -3666,8 +4059,8 @@ var init_codebase_map = __esm({
 
 // packages/execution/dist/tools/diagnostic.js
 import { execSync as execSync4 } from "node:child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "node:fs";
-import { join as join9 } from "node:path";
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "node:fs";
+import { join as join10 } from "node:path";
 var DiagnosticTool;
 var init_diagnostic = __esm({
   "packages/execution/dist/tools/diagnostic.js"() {
@@ -3746,7 +4139,7 @@ var init_diagnostic = __esm({
       }
       detectSteps(dir) {
         const steps = /* @__PURE__ */ new Map();
-        const has = (p) => existsSync6(join9(dir, p));
+        const has = (p) => existsSync7(join10(dir, p));
         if (has(".eslintrc.json") || has(".eslintrc.js") || has(".eslintrc.yml") || has("eslint.config.js") || has("eslint.config.mjs")) {
           steps.set("lint", "npx eslint . --max-warnings 0");
         } else if (has("biome.json") || has("biome.jsonc")) {
@@ -3761,7 +4154,7 @@ var init_diagnostic = __esm({
           steps.set("test", "npx jest --passWithNoTests");
         } else {
           try {
-            const pkg = JSON.parse(readFileSync5(join9(dir, "package.json"), "utf8"));
+            const pkg = JSON.parse(readFileSync5(join10(dir, "package.json"), "utf8"));
             if (pkg.scripts?.test && pkg.scripts.test !== 'echo "Error: no test specified" && exit 1') {
               steps.set("test", "npm test");
             }
@@ -3769,7 +4162,7 @@ var init_diagnostic = __esm({
           }
         }
         try {
-          const pkg = JSON.parse(readFileSync5(join9(dir, "package.json"), "utf8"));
+          const pkg = JSON.parse(readFileSync5(join10(dir, "package.json"), "utf8"));
           if (pkg.scripts?.build) {
             steps.set("build", "npm run build");
           }
@@ -3811,8 +4204,8 @@ ${err.stderr ?? ""}`.trim(),
 
 // packages/execution/dist/tools/git-info.js
 import { execSync as execSync5 } from "node:child_process";
-import { existsSync as existsSync7 } from "node:fs";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join11 } from "node:path";
 var GitInfoTool;
 var init_git_info = __esm({
   "packages/execution/dist/tools/git-info.js"() {
@@ -3847,7 +4240,7 @@ var init_git_info = __esm({
         const repoDir = args["path"] || this.workingDir;
         const showDiff = args["show_diff"] ?? false;
         const logCount = args["log_count"] ?? 5;
-        if (!existsSync7(join10(repoDir, ".git"))) {
+        if (!existsSync8(join11(repoDir, ".git"))) {
           return {
             success: false,
             output: "",
@@ -4421,11 +4814,11 @@ var init_system_deps = __esm({
 });
 
 // packages/execution/dist/tools/image.js
-import { existsSync as existsSync8, readFileSync as readFileSync6, statSync as statSync4 } from "node:fs";
-import { resolve as resolve11, extname as extname2, basename } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync6, statSync as statSync4 } from "node:fs";
+import { resolve as resolve12, extname as extname2, basename as basename2 } from "node:path";
 import { execSync as execSync7 } from "node:child_process";
 import { tmpdir } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 function isImagePath(path) {
   return IMAGE_EXTENSIONS.has(extname2(path).toLowerCase());
 }
@@ -4547,8 +4940,8 @@ var init_image = __esm({
         if (!rawPath) {
           return { success: false, output: "", error: "path is required", durationMs: 0 };
         }
-        const fullPath = resolve11(this.workingDir, rawPath);
-        if (!existsSync8(fullPath)) {
+        const fullPath = resolve12(this.workingDir, rawPath);
+        if (!existsSync9(fullPath)) {
           return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: Date.now() - start };
         }
         const stat5 = statSync4(fullPath);
@@ -4568,7 +4961,7 @@ var init_image = __esm({
         const dims = getImageDimensions(fullPath);
         const sizeKb = (stat5.size / 1024).toFixed(1);
         const parts = [
-          `File: ${basename(fullPath)}`,
+          `File: ${basename2(fullPath)}`,
           `Size: ${sizeKb}KB`,
           `Format: ${mime}`
         ];
@@ -4616,7 +5009,7 @@ ${ocrText}`);
       }
       async execute(args) {
         const start = Date.now();
-        const outputPath = args["output_path"] ? resolve11(this.workingDir, String(args["output_path"])) : join11(tmpdir(), `oa-screenshot-${Date.now()}.png`);
+        const outputPath = args["output_path"] ? resolve12(this.workingDir, String(args["output_path"])) : join12(tmpdir(), `oa-screenshot-${Date.now()}.png`);
         const delayMs = typeof args["delay_ms"] === "number" ? args["delay_ms"] : 0;
         const region = String(args["region"] ?? "full");
         if (delayMs > 0) {
@@ -4641,7 +5034,7 @@ ${ocrText}`);
             durationMs: Date.now() - start
           };
         }
-        if (!existsSync8(outputPath)) {
+        if (!existsSync9(outputPath)) {
           return { success: false, output: "", error: "Screenshot file not created", durationMs: Date.now() - start };
         }
         const stat5 = statSync4(outputPath);
@@ -4749,8 +5142,8 @@ ${ocrText}`);
         if (!rawPath) {
           return { success: false, output: "", error: "path is required", durationMs: 0 };
         }
-        const fullPath = resolve11(this.workingDir, rawPath);
-        if (!existsSync8(fullPath)) {
+        const fullPath = resolve12(this.workingDir, rawPath);
+        if (!existsSync9(fullPath)) {
           return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: Date.now() - start };
         }
         if (!hasTesseract()) {
@@ -4765,7 +5158,7 @@ ${ocrText}`);
         if (region) {
           const [x, y, w, h] = region.split(",").map(Number);
           if (x != null && y != null && w != null && h != null) {
-            const croppedPath = join11(tmpdir(), `oa-ocr-crop-${Date.now()}.png`);
+            const croppedPath = join12(tmpdir(), `oa-ocr-crop-${Date.now()}.png`);
             try {
               execSync7(`convert ${JSON.stringify(fullPath)} -crop ${w}x${h}+${x}+${y} +repage ${JSON.stringify(croppedPath)}`, { stdio: "pipe", timeout: 1e4 });
               inputPath = croppedPath;
@@ -4781,7 +5174,7 @@ ${ocrText}`);
           const lineCount = text.split("\n").length;
           return {
             success: true,
-            output: `OCR extracted ${lineCount} lines from ${basename(fullPath)}${region ? ` (region: ${region})` : ""}:
+            output: `OCR extracted ${lineCount} lines from ${basename2(fullPath)}${region ? ` (region: ${region})` : ""}:
 
 ${text}`,
             durationMs: Date.now() - start
@@ -4809,15 +5202,15 @@ __export(custom_tool_exports, {
   loadCustomTools: () => loadCustomTools,
   saveCustomToolDefinition: () => saveCustomToolDefinition
 });
-import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync7, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join12 } from "node:path";
-import { homedir as homedir3 } from "node:os";
+import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync7, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join13 } from "node:path";
+import { homedir as homedir4 } from "node:os";
 import { spawn as spawn3 } from "node:child_process";
 function globalToolsDir() {
-  return join12(homedir3(), ".open-agents", "tools");
+  return join13(homedir4(), ".open-agents", "tools");
 }
 function projectToolsDir(repoRoot) {
-  return join12(repoRoot, ".oa", "tools");
+  return join13(repoRoot, ".oa", "tools");
 }
 function loadCustomTools(repoRoot) {
   const definitions = /* @__PURE__ */ new Map();
@@ -4837,14 +5230,14 @@ function buildCustomTools(repoRoot) {
 function saveCustomToolDefinition(definition, scope, repoRoot) {
   const dir = scope === "project" && repoRoot ? projectToolsDir(repoRoot) : globalToolsDir();
   mkdirSync3(dir, { recursive: true });
-  const filePath = join12(dir, `${definition.name}.json`);
+  const filePath = join13(dir, `${definition.name}.json`);
   writeFileSync3(filePath, JSON.stringify(definition, null, 2), "utf-8");
   return filePath;
 }
 function deleteCustomToolDefinition(name, scope, repoRoot) {
   const dir = scope === "project" && repoRoot ? projectToolsDir(repoRoot) : globalToolsDir();
-  const filePath = join12(dir, `${name}.json`);
-  if (existsSync9(filePath)) {
+  const filePath = join13(dir, `${name}.json`);
+  if (existsSync10(filePath)) {
     const { unlinkSync: unlinkSync5 } = __require("node:fs");
     unlinkSync5(filePath);
     return true;
@@ -4878,14 +5271,14 @@ function listCustomToolFiles(repoRoot) {
   return result;
 }
 function loadFromDirectory(dir) {
-  if (!existsSync9(dir))
+  if (!existsSync10(dir))
     return [];
   const definitions = [];
   try {
     const files = readdirSync4(dir).filter((f) => f.endsWith(".json"));
     for (const file of files) {
       try {
-        const content = readFileSync7(join12(dir, file), "utf-8");
+        const content = readFileSync7(join13(dir, file), "utf-8");
         const def = JSON.parse(content);
         if (def.name && def.description && Array.isArray(def.steps) && def.steps.length > 0) {
           if (!def.parameters || typeof def.parameters !== "object") {
@@ -4964,7 +5357,7 @@ var init_custom_tool = __esm({
       }
       /** Execute a single shell command and return output */
       runCommand(command) {
-        return new Promise((resolve22) => {
+        return new Promise((resolve23) => {
           const child = spawn3("bash", ["-c", command], {
             cwd: this.workingDir,
             env: { ...process.env, CI: "true", NO_COLOR: "1" },
@@ -4989,11 +5382,11 @@ var init_custom_tool = __esm({
               child.kill("SIGTERM");
             } catch {
             }
-            resolve22({ success: false, output: stdout, error: "Command timed out after 60s" });
+            resolve23({ success: false, output: stdout, error: "Command timed out after 60s" });
           }, 6e4);
           child.on("close", (code) => {
             clearTimeout(timer);
-            resolve22({
+            resolve23({
               success: code === 0,
               output: stdout + (stderr && code === 0 ? `
 STDERR:
@@ -5003,7 +5396,7 @@ ${stderr}` : ""),
           });
           child.on("error", (err) => {
             clearTimeout(timer);
-            resolve22({ success: false, output: stdout, error: err.message });
+            resolve23({ success: false, output: stdout, error: err.message });
           });
         });
       }
@@ -5306,16 +5699,16 @@ var init_tool_creator = __esm({
 });
 
 // packages/execution/dist/tools/skill-tools.js
-import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync8 } from "node:fs";
-import { join as join13, basename as basename2, dirname as dirname3 } from "node:path";
-import { homedir as homedir4 } from "node:os";
+import { existsSync as existsSync11, readdirSync as readdirSync5, readFileSync as readFileSync8 } from "node:fs";
+import { join as join14, basename as basename3, dirname as dirname3 } from "node:path";
+import { homedir as homedir5 } from "node:os";
 import { execSync as execSync8 } from "node:child_process";
 function getAiwgPaths() {
-  const dataDir = join13(homedir4(), ".local", "share", "ai-writing-guide");
+  const dataDir = join14(homedir5(), ".local", "share", "ai-writing-guide");
   return {
-    frameworksDir: join13(dataDir, "agentic", "code", "frameworks"),
-    addonsDir: join13(dataDir, "agentic", "code", "addons"),
-    pluginsDir: join13(dataDir, "plugins")
+    frameworksDir: join14(dataDir, "agentic", "code", "frameworks"),
+    addonsDir: join14(dataDir, "agentic", "code", "addons"),
+    pluginsDir: join14(dataDir, "plugins")
   };
 }
 function findAiwgPackageRoot() {
@@ -5327,8 +5720,8 @@ function findAiwgPackageRoot() {
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    const candidate = join13(globalRoot, "aiwg");
-    if (existsSync10(join13(candidate, "package.json"))) {
+    const candidate = join14(globalRoot, "aiwg");
+    if (existsSync11(join14(candidate, "package.json"))) {
       _cachedAiwgPkgRoot = candidate;
       return candidate;
     }
@@ -5337,18 +5730,18 @@ function findAiwgPackageRoot() {
   const candidates = [
     "/usr/local/lib/node_modules/aiwg",
     "/usr/lib/node_modules/aiwg",
-    join13(homedir4(), ".nvm", "versions")
+    join14(homedir5(), ".nvm", "versions")
     // nvm — need to search deeper
   ];
   for (const c3 of candidates) {
     if (c3.includes(".nvm")) {
-      if (existsSync10(c3)) {
+      if (existsSync11(c3)) {
         try {
-          for (const ver of readdirSync5(join13(c3, "node"), { withFileTypes: true })) {
+          for (const ver of readdirSync5(join14(c3, "node"), { withFileTypes: true })) {
             if (!ver.isDirectory())
               continue;
-            const nvmPath = join13(c3, "node", ver.name, "lib", "node_modules", "aiwg");
-            if (existsSync10(join13(nvmPath, "package.json"))) {
+            const nvmPath = join14(c3, "node", ver.name, "lib", "node_modules", "aiwg");
+            if (existsSync11(join14(nvmPath, "package.json"))) {
               _cachedAiwgPkgRoot = nvmPath;
               return nvmPath;
             }
@@ -5356,7 +5749,7 @@ function findAiwgPackageRoot() {
         } catch {
         }
       }
-    } else if (existsSync10(join13(c3, "package.json"))) {
+    } else if (existsSync11(join14(c3, "package.json"))) {
       _cachedAiwgPkgRoot = c3;
       return c3;
     }
@@ -5368,49 +5761,49 @@ function discoverSkills(repoRoot) {
   const skills = /* @__PURE__ */ new Map();
   const { frameworksDir, addonsDir, pluginsDir } = getAiwgPaths();
   const loadComponent = (componentDir, source) => {
-    loadSkillsFromDir(join13(componentDir, "skills"), source, skills);
-    loadCommandsFromDir(join13(componentDir, "commands"), source, skills);
+    loadSkillsFromDir(join14(componentDir, "skills"), source, skills);
+    loadCommandsFromDir(join14(componentDir, "commands"), source, skills);
   };
   const pkgRoot = findAiwgPackageRoot();
   if (pkgRoot) {
-    const pkgFrameworks = join13(pkgRoot, "agentic", "code", "frameworks");
-    if (existsSync10(pkgFrameworks)) {
+    const pkgFrameworks = join14(pkgRoot, "agentic", "code", "frameworks");
+    if (existsSync11(pkgFrameworks)) {
       for (const fw of safeReaddir(pkgFrameworks)) {
-        loadComponent(join13(pkgFrameworks, fw), `framework:${fw}`);
+        loadComponent(join14(pkgFrameworks, fw), `framework:${fw}`);
       }
     }
-    const pkgAddons = join13(pkgRoot, "agentic", "code", "addons");
-    if (existsSync10(pkgAddons)) {
+    const pkgAddons = join14(pkgRoot, "agentic", "code", "addons");
+    if (existsSync11(pkgAddons)) {
       for (const addon of safeReaddir(pkgAddons)) {
-        loadComponent(join13(pkgAddons, addon), `addon:${addon}`);
+        loadComponent(join14(pkgAddons, addon), `addon:${addon}`);
       }
     }
-    const pkgPlugins = join13(pkgRoot, "plugins");
-    if (existsSync10(pkgPlugins)) {
+    const pkgPlugins = join14(pkgRoot, "plugins");
+    if (existsSync11(pkgPlugins)) {
       for (const plugin of safeReaddir(pkgPlugins)) {
-        loadComponent(join13(pkgPlugins, plugin), `plugin:${plugin}`);
+        loadComponent(join14(pkgPlugins, plugin), `plugin:${plugin}`);
       }
     }
   }
-  if (existsSync10(frameworksDir)) {
+  if (existsSync11(frameworksDir)) {
     for (const framework of safeReaddir(frameworksDir)) {
-      loadComponent(join13(frameworksDir, framework), `framework:${framework}`);
+      loadComponent(join14(frameworksDir, framework), `framework:${framework}`);
     }
   }
-  if (existsSync10(addonsDir)) {
+  if (existsSync11(addonsDir)) {
     for (const addon of safeReaddir(addonsDir)) {
-      loadComponent(join13(addonsDir, addon), `addon:${addon}`);
+      loadComponent(join14(addonsDir, addon), `addon:${addon}`);
     }
   }
-  if (existsSync10(pluginsDir)) {
+  if (existsSync11(pluginsDir)) {
     for (const plugin of safeReaddir(pluginsDir)) {
-      loadComponent(join13(pluginsDir, plugin), `plugin:${plugin}`);
+      loadComponent(join14(pluginsDir, plugin), `plugin:${plugin}`);
     }
   }
-  const projectAiwg = join13(repoRoot, ".aiwg");
-  loadSkillsFromDir(join13(projectAiwg, "skills"), "project", skills);
-  loadCommandsFromDir(join13(projectAiwg, "commands"), "project", skills);
-  const projectOaSkills = join13(repoRoot, ".oa", "skills");
+  const projectAiwg = join14(repoRoot, ".aiwg");
+  loadSkillsFromDir(join14(projectAiwg, "skills"), "project", skills);
+  loadCommandsFromDir(join14(projectAiwg, "commands"), "project", skills);
+  const projectOaSkills = join14(repoRoot, ".oa", "skills");
   loadSkillsFromDir(projectOaSkills, "local", skills);
   return Array.from(skills.values());
 }
@@ -5456,13 +5849,13 @@ function safeReaddir(dir) {
   }
 }
 function loadSkillsFromDir(dir, source, out) {
-  if (!existsSync10(dir))
+  if (!existsSync11(dir))
     return;
   const manifest = loadManifest(dir);
   const entries = safeReaddir(dir);
   for (const entry of entries) {
-    const skillMd = join13(dir, entry, "SKILL.md");
-    if (!existsSync10(skillMd))
+    const skillMd = join14(dir, entry, "SKILL.md");
+    if (!existsSync11(skillMd))
       continue;
     const manifestEntry = manifest.get(entry);
     const info = {
@@ -5476,7 +5869,7 @@ function loadSkillsFromDir(dir, source, out) {
   }
 }
 function loadCommandsFromDir(dir, source, out) {
-  if (!existsSync10(dir))
+  if (!existsSync11(dir))
     return;
   let entries;
   try {
@@ -5486,7 +5879,7 @@ function loadCommandsFromDir(dir, source, out) {
   }
   for (const file of entries) {
     const name = file.replace(/\.md$/, "");
-    const filePath = join13(dir, file);
+    const filePath = join14(dir, file);
     if (out.has(name))
       continue;
     const info = {
@@ -5522,8 +5915,8 @@ function parseCommandTriggers(name) {
 }
 function loadManifest(dir) {
   const result = /* @__PURE__ */ new Map();
-  const manifestPath = join13(dir, "manifest.json");
-  if (!existsSync10(manifestPath))
+  const manifestPath = join14(dir, "manifest.json");
+  if (!existsSync11(manifestPath))
     return result;
   try {
     const content = readFileSync8(manifestPath, "utf-8");
@@ -5706,9 +6099,9 @@ ${content}`,
 });
 
 // packages/execution/dist/tools/transcribe-tool.js
-import { existsSync as existsSync11, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4, readFileSync as readFileSync9, unlinkSync } from "node:fs";
-import { join as join14, basename as basename3, extname as extname3, resolve as resolve12 } from "node:path";
-import { homedir as homedir5 } from "node:os";
+import { existsSync as existsSync12, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4, readFileSync as readFileSync9, unlinkSync } from "node:fs";
+import { join as join15, basename as basename4, extname as extname3, resolve as resolve13 } from "node:path";
+import { homedir as homedir6 } from "node:os";
 import { execSync as execSync9, spawn as spawn4 } from "node:child_process";
 function isTranscribable(path) {
   const ext = extname3(path).toLowerCase();
@@ -5724,25 +6117,25 @@ async function loadTranscribeCli() {
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    const tcPath = join14(globalRoot, "transcribe-cli");
-    if (existsSync11(join14(tcPath, "dist", "index.js"))) {
+    const tcPath = join15(globalRoot, "transcribe-cli");
+    if (existsSync12(join15(tcPath, "dist", "index.js"))) {
       const { createRequire: createRequire4 } = await import("node:module");
       const req = createRequire4(import.meta.url);
-      _tcModule = req(join14(tcPath, "dist", "index.js"));
+      _tcModule = req(join15(tcPath, "dist", "index.js"));
       return _tcModule;
     }
   } catch {
   }
-  const nvmBase = join14(homedir5(), ".nvm", "versions", "node");
-  if (existsSync11(nvmBase)) {
+  const nvmBase = join15(homedir6(), ".nvm", "versions", "node");
+  if (existsSync12(nvmBase)) {
     try {
       const { readdirSync: readdirSync11 } = await import("node:fs");
       for (const ver of readdirSync11(nvmBase)) {
-        const tcPath = join14(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
-        if (existsSync11(join14(tcPath, "dist", "index.js"))) {
+        const tcPath = join15(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
+        if (existsSync12(join15(tcPath, "dist", "index.js"))) {
           const { createRequire: createRequire4 } = await import("node:module");
           const req = createRequire4(import.meta.url);
-          _tcModule = req(join14(tcPath, "dist", "index.js"));
+          _tcModule = req(join15(tcPath, "dist", "index.js"));
           return _tcModule;
         }
       }
@@ -5811,10 +6204,10 @@ var init_transcribe_tool = __esm({
       }
       async execute(args) {
         const start = performance.now();
-        const filePath = resolve12(this.workingDir, String(args["path"] ?? ""));
+        const filePath = resolve13(this.workingDir, String(args["path"] ?? ""));
         const model = String(args["model"] ?? "base");
         const diarize = Boolean(args["diarize"] ?? false);
-        if (!existsSync11(filePath)) {
+        if (!existsSync12(filePath)) {
           return {
             success: false,
             output: "",
@@ -5841,12 +6234,12 @@ var init_transcribe_tool = __esm({
             diarize,
             wordTimestamps: false
           });
-          const transcriptDir = join14(this.workingDir, ".oa", "transcripts");
+          const transcriptDir = join15(this.workingDir, ".oa", "transcripts");
           mkdirSync4(transcriptDir, { recursive: true });
-          const outFile = join14(transcriptDir, `${basename3(filePath)}.txt`);
+          const outFile = join15(transcriptDir, `${basename4(filePath)}.txt`);
           writeFileSync4(outFile, result.text, "utf-8");
           const lines = [
-            `Transcription of: ${basename3(filePath)}`,
+            `Transcription of: ${basename4(filePath)}`,
             `Model: ${model} | Language: ${result.language} | Duration: ${result.duration ? `${result.duration.toFixed(1)}s` : "unknown"}`,
             `Words: ${result.wordCount} | Saved to: ${outFile}`,
             ""
@@ -5941,14 +6334,14 @@ var init_transcribe_tool = __esm({
             durationMs: performance.now() - start
           };
         }
-        const tmpDir = join14(this.workingDir, ".oa", "tmp");
+        const tmpDir = join15(this.workingDir, ".oa", "tmp");
         mkdirSync4(tmpDir, { recursive: true });
         const urlPath = new URL(url).pathname;
         let ext = extname3(urlPath).toLowerCase();
         if (!ext || !AUDIO_EXTS.has(ext) && !VIDEO_EXTS.has(ext)) {
           ext = ".mp3";
         }
-        const tmpFile = join14(tmpDir, `download-${Date.now()}${ext}`);
+        const tmpFile = join15(tmpDir, `download-${Date.now()}${ext}`);
         try {
           try {
             execSync9(`curl -sL -o "${tmpFile}" "${url}"`, {
@@ -5961,7 +6354,7 @@ var init_transcribe_tool = __esm({
               stdio: ["pipe", "pipe", "pipe"]
             });
           }
-          if (!existsSync11(tmpFile)) {
+          if (!existsSync12(tmpFile)) {
             return {
               success: false,
               output: "",
@@ -6001,7 +6394,7 @@ ${result.output}`,
 
 // packages/execution/dist/tools/structured-file.js
 import { writeFile as writeFile6, mkdir as mkdir3 } from "node:fs/promises";
-import { resolve as resolve13, dirname as dirname4, extname as extname4 } from "node:path";
+import { resolve as resolve14, dirname as dirname4, extname as extname4 } from "node:path";
 function jsonToCSV(data, separator = ",") {
   if (!Array.isArray(data) || data.length === 0)
     return "";
@@ -6115,7 +6508,7 @@ var init_structured_file = __esm({
           }
         }
         try {
-          const fullPath = resolve13(this.workingDir, filePath);
+          const fullPath = resolve14(this.workingDir, filePath);
           await mkdir3(dirname4(fullPath), { recursive: true });
           let content;
           let byteInfo = "";
@@ -6181,11 +6574,11 @@ var init_structured_file = __esm({
 
 // packages/execution/dist/tools/code-sandbox.js
 import { spawn as spawn5 } from "node:child_process";
-import { writeFile as writeFile7, mkdtemp, rm, readdir, stat } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { writeFile as writeFile7, mkdtemp, rm, readdir as readdir2, stat } from "node:fs/promises";
+import { join as join16 } from "node:path";
 import { tmpdir as tmpdir2 } from "node:os";
 function runProcess(cmd, args, options) {
-  return new Promise((resolve22) => {
+  return new Promise((resolve23) => {
     const proc = spawn5(cmd, args, {
       cwd: options.cwd,
       timeout: options.timeout,
@@ -6215,7 +6608,7 @@ function runProcess(cmd, args, options) {
       }
     });
     proc.on("error", (err) => {
-      resolve22({
+      resolve23({
         stdout,
         stderr: stderr || err.message,
         exitCode: 1,
@@ -6227,7 +6620,7 @@ function runProcess(cmd, args, options) {
       if (signal === "SIGTERM" || signal === "SIGKILL") {
         timedOut = true;
       }
-      resolve22({
+      resolve23({
         stdout,
         stderr,
         exitCode: code ?? (timedOut ? 124 : 1),
@@ -6244,11 +6637,11 @@ function runProcess(cmd, args, options) {
 async function listCreatedFiles(dir) {
   const files = [];
   try {
-    const entries = await readdir(dir);
+    const entries = await readdir2(dir);
     for (const entry of entries) {
       if (entry.startsWith("_sandbox_script"))
         continue;
-      const fullPath = join15(dir, entry);
+      const fullPath = join16(dir, entry);
       const s = await stat(fullPath);
       if (s.isFile()) {
         files.push(entry);
@@ -6368,9 +6761,9 @@ ${result.filesCreated.join("\n")}`);
       // Subprocess mode — temp directory + separate process
       // -------------------------------------------------------------------------
       async #runSubprocess(code, langConfig, timeoutMs, stdin) {
-        const sandboxDir = await mkdtemp(join15(tmpdir2(), "oa-sandbox-"));
+        const sandboxDir = await mkdtemp(join16(tmpdir2(), "oa-sandbox-"));
         try {
-          const scriptFile = join15(sandboxDir, `_sandbox_script${langConfig.ext}`);
+          const scriptFile = join16(sandboxDir, `_sandbox_script${langConfig.ext}`);
           await writeFile7(scriptFile, code, "utf-8");
           const result = await runProcess(langConfig.cmd, langConfig.args(scriptFile), {
             cwd: sandboxDir,
@@ -6395,10 +6788,10 @@ ${result.filesCreated.join("\n")}`);
           bash: "bash:5"
         };
         const image = images[language] ?? "node:22-slim";
-        const sandboxDir = await mkdtemp(join15(tmpdir2(), "oa-docker-sandbox-"));
+        const sandboxDir = await mkdtemp(join16(tmpdir2(), "oa-docker-sandbox-"));
         try {
           const scriptFile = `_sandbox_script${langConfig.ext}`;
-          await writeFile7(join15(sandboxDir, scriptFile), code, "utf-8");
+          await writeFile7(join16(sandboxDir, scriptFile), code, "utf-8");
           const dockerArgs = [
             "run",
             "--rm",
@@ -6433,8 +6826,8 @@ ${result.filesCreated.join("\n")}`);
 });
 
 // packages/execution/dist/tools/structured-read.js
-import { readFile as readFile7, stat as stat2 } from "node:fs/promises";
-import { resolve as resolve14, extname as extname5 } from "node:path";
+import { readFile as readFile8, stat as stat2 } from "node:fs/promises";
+import { resolve as resolve15, extname as extname5 } from "node:path";
 function parseCSV(text, separator = ",") {
   const lines = text.split("\n").filter((l) => l.trim() !== "");
   if (lines.length < 2)
@@ -6575,7 +6968,7 @@ var init_structured_read = __esm({
         if (!filePath) {
           return { success: false, output: "", error: "path is required", durationMs: 0 };
         }
-        const fullPath = resolve14(this.workingDir, filePath);
+        const fullPath = resolve15(this.workingDir, filePath);
         try {
           const fileStat = await stat2(fullPath);
           if (!fileStat.isFile()) {
@@ -6628,7 +7021,7 @@ var init_structured_read = __esm({
             }
           }
           if (format === "xlsx" || format === "pdf" || format === "docx" || format === "auto") {
-            const buffer = await readFile7(fullPath);
+            const buffer = await readFile8(fullPath);
             const detected = detectBinaryFormat(buffer);
             if (detected === "xlsx") {
               return {
@@ -6673,7 +7066,7 @@ Or install mammoth for programmatic access.`,
               }
             }
           }
-          const text = await readFile7(fullPath, "utf-8");
+          const text = await readFile8(fullPath, "utf-8");
           switch (format) {
             case "csv": {
               const rows = parseCSV(text, ",");
@@ -6768,9 +7161,9 @@ ${parts.join("\n\n")}`,
 });
 
 // packages/execution/dist/tools/vision.js
-import { readFileSync as readFileSync10, existsSync as existsSync12, statSync as statSync5 } from "node:fs";
+import { readFileSync as readFileSync10, existsSync as existsSync13, statSync as statSync5 } from "node:fs";
 import { execSync as execSync10, spawn as spawn6 } from "node:child_process";
-import { resolve as resolve15, extname as extname6, basename as basename4, dirname as dirname5, join as join16 } from "node:path";
+import { resolve as resolve16, extname as extname6, basename as basename5, dirname as dirname5, join as join17 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 async function probeStation(endpoint) {
   try {
@@ -6785,24 +7178,24 @@ async function probeStation(endpoint) {
   }
 }
 function findStationBinary() {
-  const oaVenvPython = join16(process.env["HOME"] || "/root", ".open-agents", "venv", "bin", "python");
-  if (existsSync12(oaVenvPython)) {
+  const oaVenvPython = join17(process.env["HOME"] || "/root", ".open-agents", "venv", "bin", "python");
+  if (existsSync13(oaVenvPython)) {
     try {
       execSync10(`${JSON.stringify(oaVenvPython)} -c "import moondream_station"`, { stdio: "pipe", timeout: 5e3 });
       return oaVenvPython;
     } catch {
     }
   }
-  const oaVenvBin = join16(process.env["HOME"] || "/root", ".open-agents", "venv", "bin", "moondream-station");
-  if (existsSync12(oaVenvBin))
+  const oaVenvBin = join17(process.env["HOME"] || "/root", ".open-agents", "venv", "bin", "moondream-station");
+  if (existsSync13(oaVenvBin))
     return oaVenvBin;
   const thisDir = dirname5(fileURLToPath2(import.meta.url));
   const localVenvPaths = [
-    resolve15(thisDir, "../../../../.moondream-venv/bin/python"),
-    resolve15(thisDir, "../../../.moondream-venv/bin/python")
+    resolve16(thisDir, "../../../../.moondream-venv/bin/python"),
+    resolve16(thisDir, "../../../.moondream-venv/bin/python")
   ];
   for (const p of localVenvPaths) {
-    if (existsSync12(p)) {
+    if (existsSync13(p)) {
       try {
         execSync10(`${JSON.stringify(p)} -c "import moondream_station"`, { stdio: "pipe", timeout: 5e3 });
         return p;
@@ -6823,8 +7216,8 @@ async function autoLaunchStation(port = 2020) {
   if (!pythonBin)
     return false;
   const thisDir = dirname5(fileURLToPath2(import.meta.url));
-  const launcherScript = resolve15(thisDir, "../../scripts/start-moondream.py");
-  if (!existsSync12(launcherScript))
+  const launcherScript = resolve16(thisDir, "../../scripts/start-moondream.py");
+  if (!existsSync13(launcherScript))
     return false;
   return new Promise((resolvePromise) => {
     const child = spawn6(pythonBin, [launcherScript, "--port", String(port)], {
@@ -6898,8 +7291,8 @@ Details: ${err.message}` : "");
   }
 }
 function loadImageBuffer(workingDir, rawPath) {
-  const fullPath = resolve15(workingDir, rawPath);
-  if (!existsSync12(fullPath)) {
+  const fullPath = resolve16(workingDir, rawPath);
+  if (!existsSync13(fullPath)) {
     throw new Error(`File not found: ${rawPath}`);
   }
   const stat5 = statSync5(fullPath);
@@ -6988,7 +7381,7 @@ var init_vision = __esm({
         }
         try {
           const { buffer, fullPath } = loadImageBuffer(this.workingDir, rawPath);
-          const filename = basename4(fullPath);
+          const filename = basename5(fullPath);
           let client = null;
           try {
             client = await getMoondreamClient();
@@ -7138,10 +7531,10 @@ ${response}`, durationMs: performance.now() - start };
 });
 
 // packages/execution/dist/tools/desktop-click.js
-import { readFileSync as readFileSync11, existsSync as existsSync13 } from "node:fs";
+import { readFileSync as readFileSync11, existsSync as existsSync14 } from "node:fs";
 import { execSync as execSync11 } from "node:child_process";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join17, dirname as dirname6 } from "node:path";
+import { join as join18, dirname as dirname6 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function hasCommand2(cmd) {
   try {
@@ -7203,7 +7596,7 @@ function captureScreenshot(outputPath) {
       } else {
         try {
           execSync11(`DISPLAY=:0 python3 -c "from PIL import ImageGrab; ImageGrab.grab().save(${JSON.stringify(outputPath)})"`, { stdio: "pipe", timeout: 1e4 });
-          if (existsSync13(outputPath))
+          if (existsSync14(outputPath))
             return;
         } catch {
         }
@@ -7214,7 +7607,7 @@ function captureScreenshot(outputPath) {
     throw new Error("No screenshot tool found. Auto-install failed. Try manually: sudo apt install scrot");
   }
   execSync11(cmd, { stdio: "pipe", timeout: 1e4 });
-  if (!existsSync13(outputPath)) {
+  if (!existsSync14(outputPath)) {
     throw new Error("Screenshot file was not created");
   }
 }
@@ -7265,7 +7658,7 @@ for i in range(${clicks}):
     } catch {
     }
     try {
-      const venvPy = join17(__dirname, "../../../../.moondream-venv/bin/python");
+      const venvPy = join18(__dirname, "../../../../.moondream-venv/bin/python");
       execSync11(`DISPLAY=:0 ${JSON.stringify(venvPy)} -c "${pyScript}"`, { stdio: "pipe", timeout: 5e3 });
       return;
     } catch {
@@ -7357,7 +7750,7 @@ var init_desktop_click = __esm({
           if (delayMs > 0) {
             await new Promise((r) => setTimeout(r, delayMs));
           }
-          const screenshotPath = join17(tmpdir3(), `oa-desktop-click-${Date.now()}.png`);
+          const screenshotPath = join18(tmpdir3(), `oa-desktop-click-${Date.now()}.png`);
           captureScreenshot(screenshotPath);
           const dims = getImageDimensions2(screenshotPath);
           if (!dims) {
@@ -7532,7 +7925,7 @@ Screenshot: ${screenshotPath}`,
           if (delayMs > 0) {
             await new Promise((r) => setTimeout(r, delayMs));
           }
-          const screenshotPath = join17(tmpdir3(), `oa-desktop-describe-${Date.now()}.png`);
+          const screenshotPath = join18(tmpdir3(), `oa-desktop-describe-${Date.now()}.png`);
           captureScreenshot(screenshotPath);
           const dims = getImageDimensions2(screenshotPath);
           const imageBuffer = readFileSync11(screenshotPath);
@@ -7647,8 +8040,8 @@ Screen: ${dims.width}x${dims.height}`);
 });
 
 // packages/execution/dist/tools/ocr-pdf.js
-import { existsSync as existsSync14, statSync as statSync6 } from "node:fs";
-import { resolve as resolve16, basename as basename5 } from "node:path";
+import { existsSync as existsSync15, statSync as statSync6 } from "node:fs";
+import { resolve as resolve17, basename as basename6 } from "node:path";
 import { execSync as execSync12 } from "node:child_process";
 var OcrPdfTool;
 var init_ocr_pdf = __esm({
@@ -7698,8 +8091,8 @@ var init_ocr_pdf = __esm({
         if (!rawInput) {
           return { success: false, output: "", error: "input path is required", durationMs: 0 };
         }
-        const inputPath = resolve16(this.workingDir, rawInput);
-        if (!existsSync14(inputPath)) {
+        const inputPath = resolve17(this.workingDir, rawInput);
+        if (!existsSync15(inputPath)) {
           return { success: false, output: "", error: `File not found: ${rawInput}`, durationMs: performance.now() - start };
         }
         const stat5 = statSync6(inputPath);
@@ -7722,7 +8115,7 @@ var init_ocr_pdf = __esm({
             durationMs: performance.now() - start
           };
         }
-        const outputPath = rawOutput ? resolve16(this.workingDir, rawOutput) : inputPath;
+        const outputPath = rawOutput ? resolve17(this.workingDir, rawOutput) : inputPath;
         const cmdParts = ["ocrmypdf"];
         cmdParts.push("-l", language);
         if (deskew)
@@ -7747,7 +8140,7 @@ var init_ocr_pdf = __esm({
           const sizeMB = (outputStat.size / 1024 / 1024).toFixed(1);
           return {
             success: true,
-            output: `OCR completed for ${basename5(inputPath)}
+            output: `OCR completed for ${basename6(inputPath)}
 Output: ${outputPath === inputPath ? "(in-place)" : outputPath}
 Size: ${sizeMB}MB
 Language: ${language}
@@ -7770,8 +8163,8 @@ Language: ${language}
 });
 
 // packages/execution/dist/tools/pdf-to-text.js
-import { existsSync as existsSync15, statSync as statSync7, readFileSync as readFileSync12, unlinkSync as unlinkSync2 } from "node:fs";
-import { resolve as resolve17, basename as basename6, join as join18 } from "node:path";
+import { existsSync as existsSync16, statSync as statSync7, readFileSync as readFileSync12, unlinkSync as unlinkSync2 } from "node:fs";
+import { resolve as resolve18, basename as basename7, join as join19 } from "node:path";
 import { execSync as execSync13 } from "node:child_process";
 import { tmpdir as tmpdir4 } from "node:os";
 var PdfToTextTool;
@@ -7822,8 +8215,8 @@ var init_pdf_to_text = __esm({
         if (!rawPath) {
           return { success: false, output: "", error: "path is required", durationMs: 0 };
         }
-        const fullPath = resolve17(this.workingDir, rawPath);
-        if (!existsSync15(fullPath)) {
+        const fullPath = resolve18(this.workingDir, rawPath);
+        if (!existsSync16(fullPath)) {
           return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: performance.now() - start };
         }
         const fileStat = statSync7(fullPath);
@@ -7881,7 +8274,7 @@ var init_pdf_to_text = __esm({
               const pageInfo2 = pages ? ` (pages: ${pages})` : "";
               return {
                 success: true,
-                output: `Extracted ${lineCount2} lines from ${basename6(fullPath)}${pageInfo2} (via OCR):
+                output: `Extracted ${lineCount2} lines from ${basename7(fullPath)}${pageInfo2} (via OCR):
 
 ${text}`,
                 durationMs: performance.now() - start
@@ -7889,14 +8282,14 @@ ${text}`,
             }
             return {
               success: true,
-              output: `No text found in ${basename6(fullPath)} \u2014 appears to be a scanned/image PDF with no extractable text. OCR also returned no results.`,
+              output: `No text found in ${basename7(fullPath)} \u2014 appears to be a scanned/image PDF with no extractable text. OCR also returned no results.`,
               durationMs: performance.now() - start
             };
           }
           if (!text) {
             return {
               success: true,
-              output: `No text found in ${basename6(fullPath)} \u2014 may be a scanned/image PDF. Use ocr_pdf tool to add a text layer first.`,
+              output: `No text found in ${basename7(fullPath)} \u2014 may be a scanned/image PDF. Use ocr_pdf tool to add a text layer first.`,
               durationMs: performance.now() - start
             };
           }
@@ -7904,7 +8297,7 @@ ${text}`,
           const pageInfo = pages ? ` (pages: ${pages})` : "";
           return {
             success: true,
-            output: `Extracted ${lineCount} lines from ${basename6(fullPath)}${pageInfo}:
+            output: `Extracted ${lineCount} lines from ${basename7(fullPath)}${pageInfo}:
 
 ${text}`,
             durationMs: performance.now() - start
@@ -7925,7 +8318,7 @@ ${text}`,
         if (!ocrCheck.available || !tesCheck.available || !gsCheck.available) {
           return null;
         }
-        const tmpPdf = join18(tmpdir4(), `oa-ocr-${Date.now()}.pdf`);
+        const tmpPdf = join19(tmpdir4(), `oa-ocr-${Date.now()}.pdf`);
         try {
           const ocrCmd = `ocrmypdf -l ${language} --skip-text ${JSON.stringify(inputPath)} ${JSON.stringify(tmpPdf)}`;
           execSync13(ocrCmd, { stdio: "pipe", timeout: 6e5 });
@@ -7955,27 +8348,27 @@ ${text}`,
 });
 
 // packages/execution/dist/tools/ocr-image-advanced.js
-import { existsSync as existsSync16, statSync as statSync8 } from "node:fs";
-import { resolve as resolve18, basename as basename7, dirname as dirname7, join as join19 } from "node:path";
+import { existsSync as existsSync17, statSync as statSync8 } from "node:fs";
+import { resolve as resolve19, basename as basename8, dirname as dirname7, join as join20 } from "node:path";
 import { execSync as execSync14 } from "node:child_process";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
-import { homedir as homedir6, tmpdir as tmpdir5 } from "node:os";
+import { homedir as homedir7, tmpdir as tmpdir5 } from "node:os";
 function findOcrScript() {
   const thisDir = dirname7(fileURLToPath4(import.meta.url));
-  const devPath = resolve18(thisDir, "../../scripts/ocr-advanced.py");
-  if (existsSync16(devPath))
+  const devPath = resolve19(thisDir, "../../scripts/ocr-advanced.py");
+  if (existsSync17(devPath))
     return devPath;
-  const bundledPath = resolve18(thisDir, "../scripts/ocr-advanced.py");
-  if (existsSync16(bundledPath))
+  const bundledPath = resolve19(thisDir, "../scripts/ocr-advanced.py");
+  if (existsSync17(bundledPath))
     return bundledPath;
-  const sameDirPath = resolve18(thisDir, "ocr-advanced.py");
-  if (existsSync16(sameDirPath))
+  const sameDirPath = resolve19(thisDir, "ocr-advanced.py");
+  if (existsSync17(sameDirPath))
     return sameDirPath;
   return null;
 }
 function findPython() {
-  const venvPython = join19(homedir6(), ".open-agents", "venv", "bin", "python");
-  if (existsSync16(venvPython)) {
+  const venvPython = join20(homedir7(), ".open-agents", "venv", "bin", "python");
+  if (existsSync17(venvPython)) {
     try {
       execSync14(`${JSON.stringify(venvPython)} -c "import cv2, pytesseract, numpy, PIL"`, {
         stdio: "pipe",
@@ -8058,8 +8451,8 @@ var init_ocr_image_advanced = __esm({
         if (!rawPath) {
           return { success: false, output: "", error: "image path is required", durationMs: 0 };
         }
-        const fullPath = resolve18(this.workingDir, rawPath);
-        if (!existsSync16(fullPath)) {
+        const fullPath = resolve19(this.workingDir, rawPath);
+        if (!existsSync17(fullPath)) {
           return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: performance.now() - start };
         }
         if (!batch) {
@@ -8117,10 +8510,10 @@ var init_ocr_image_advanced = __esm({
         if (batch)
           cmdParts.push("--batch");
         if (outputDir)
-          cmdParts.push("--output-dir", JSON.stringify(resolve18(this.workingDir, outputDir)));
+          cmdParts.push("--output-dir", JSON.stringify(resolve19(this.workingDir, outputDir)));
         let debugDir;
         if (debug) {
-          debugDir = join19(tmpdir5(), `oa-ocr-debug-${Date.now()}`);
+          debugDir = join20(tmpdir5(), `oa-ocr-debug-${Date.now()}`);
           cmdParts.push("--debug-dir", debugDir);
         }
         try {
@@ -8160,7 +8553,7 @@ var init_ocr_image_advanced = __esm({
             };
           }
           const parts = [];
-          parts.push(`OCR extracted from ${basename7(imagePath)} (${result.image_size})`);
+          parts.push(`OCR extracted from ${basename8(imagePath)} (${result.image_size})`);
           parts.push(`Best variant: ${result.variant} (confidence: ${result.confidence}%, ${result.chars} chars, ${result.lines} lines, score: ${result.score})`);
           parts.push(`Variants tested: ${result.variants_tested}`);
           if (result.output_files) {
@@ -8219,7 +8612,7 @@ var init_ocr_image_advanced = __esm({
         if (region) {
           try {
             const [x, y, w, h] = region.split(",").map(Number);
-            const croppedPath = join19(tmpdir5(), `oa-ocr-crop-${Date.now()}.png`);
+            const croppedPath = join20(tmpdir5(), `oa-ocr-crop-${Date.now()}.png`);
             execSync14(`convert ${JSON.stringify(imagePath)} -crop ${w}x${h}+${x}+${y} +repage ${JSON.stringify(croppedPath)}`, { stdio: "pipe", timeout: 1e4 });
             inputPath = croppedPath;
           } catch {
@@ -8231,14 +8624,14 @@ var init_ocr_image_advanced = __esm({
           if (!text) {
             return {
               success: true,
-              output: `(no text detected in ${basename7(imagePath)} \u2014 try the advanced Python OCR pipeline for better results)`,
+              output: `(no text detected in ${basename8(imagePath)} \u2014 try the advanced Python OCR pipeline for better results)`,
               durationMs: performance.now() - start
             };
           }
           const lineCount = text.split("\n").length;
           return {
             success: true,
-            output: `OCR extracted ${lineCount} lines from ${basename7(imagePath)} (basic tesseract, PSM ${psmArg}):
+            output: `OCR extracted ${lineCount} lines from ${basename8(imagePath)} (basic tesseract, PSM ${psmArg}):
 Note: Advanced Python pipeline not available \u2014 install pytesseract, opencv-python-headless, Pillow, numpy for better results.
 
 ` + text,
@@ -8347,6 +8740,8 @@ var init_dist2 = __esm({
     init_file_edit();
     init_memory_read();
     init_memory_write();
+    init_memory_search();
+    init_explore_tools();
     init_list_directory();
     init_aiwg_setup();
     init_aiwg_health();
@@ -9485,8 +9880,8 @@ var init_code_retriever = __esm({
         });
       }
       async getFileContent(filePath, startLine, endLine) {
-        const { readFile: readFile11 } = await import("node:fs/promises");
-        const content = await readFile11(filePath, "utf-8");
+        const { readFile: readFile12 } = await import("node:fs/promises");
+        const content = await readFile12(filePath, "utf-8");
         if (startLine === void 0)
           return content;
         const lines = content.split("\n");
@@ -9501,8 +9896,8 @@ var init_code_retriever = __esm({
 // packages/retrieval/dist/lexicalSearch.js
 import { execFile as execFile5 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
-import { readFile as readFile8, readdir as readdir2, stat as stat3 } from "node:fs/promises";
-import { join as join20, extname as extname7 } from "node:path";
+import { readFile as readFile9, readdir as readdir3, stat as stat3 } from "node:fs/promises";
+import { join as join21, 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;
@@ -9607,7 +10002,7 @@ async function searchWithNodeFallback(pattern, kind, options) {
     if (results.length >= maxMatches)
       break;
     try {
-      const content = await readFile8(filePath, "utf-8");
+      const content = await readFile9(filePath, "utf-8");
       const contentLines = content.split("\n");
       for (let i = 0; i < contentLines.length; i++) {
         if (results.length >= maxMatches)
@@ -9635,7 +10030,7 @@ async function collectFiles(rootDir, includeGlobs, excludeGlobs) {
 async function walkForFiles(rootDir, dir, excludeGlobs, results) {
   let entries;
   try {
-    entries = await readdir2(dir, { withFileTypes: true, encoding: "utf-8" });
+    entries = await readdir3(dir, { withFileTypes: true, encoding: "utf-8" });
   } catch {
     return;
   }
@@ -9644,7 +10039,7 @@ async function walkForFiles(rootDir, dir, excludeGlobs, results) {
       continue;
     if (excludeGlobs.some((g) => entry.name === g || matchesGlob(entry.name, g)))
       continue;
-    const absPath = join20(dir, entry.name);
+    const absPath = join21(dir, entry.name);
     if (entry.isDirectory()) {
       await walkForFiles(rootDir, absPath, excludeGlobs, results);
     } else if (entry.isFile()) {
@@ -9688,6 +10083,55 @@ var init_lexicalSearch = __esm({
 });
 
 // packages/retrieval/dist/semanticSearch.js
+function parseTagFilter(query) {
+  const required = [];
+  const anyOf = [];
+  const excluded = [];
+  const cleanParts = [];
+  for (const token of query.split(/\s+/)) {
+    if (token.startsWith("+") && token.length > 1) {
+      required.push(token.slice(1).toLowerCase());
+    } else if (token.startsWith("~") && token.length > 1) {
+      anyOf.push(token.slice(1).toLowerCase());
+    } else if (token.startsWith("-") && token.length > 1 && !/^\d/.test(token.slice(1))) {
+      excluded.push(token.slice(1).toLowerCase());
+    } else {
+      cleanParts.push(token);
+    }
+  }
+  const hasFilter = required.length > 0 || anyOf.length > 0 || excluded.length > 0;
+  return {
+    cleanQuery: cleanParts.join(" "),
+    tagFilter: hasFilter ? { required, anyOf, excluded } : null
+  };
+}
+function matchesTagFilter(text, filter) {
+  const lowerText = text.toLowerCase();
+  const clusteringTags = /* @__PURE__ */ new Set();
+  for (const match of lowerText.matchAll(/clustering:(\S+)/g)) {
+    clusteringTags.add(match[1]);
+  }
+  const domainMatch = lowerText.match(/domain:\s*(\S+)/);
+  if (domainMatch)
+    clusteringTags.add(domainMatch[1]);
+  const riskMatch = lowerText.match(/risk:\s*(\S+)/);
+  if (riskMatch)
+    clusteringTags.add(riskMatch[1]);
+  for (const tag of filter.required) {
+    if (!clusteringTags.has(tag) && !lowerText.includes(tag))
+      return false;
+  }
+  if (filter.anyOf.length > 0) {
+    const hasAny = filter.anyOf.some((tag) => clusteringTags.has(tag) || lowerText.includes(tag));
+    if (!hasAny)
+      return false;
+  }
+  for (const tag of filter.excluded) {
+    if (clusteringTags.has(tag))
+      return false;
+  }
+  return true;
+}
 function cosineSimilarity(a, b) {
   if (a.length !== b.length || a.length === 0)
     return 0;
@@ -9713,7 +10157,7 @@ function makePlaceholderSummary(filePath) {
     lastIndexed: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-var StubSemanticSearchEngine, IndexBackedSemanticSearchEngine;
+var StubSemanticSearchEngine, IndexBackedSemanticSearchEngine, LazySemanticSearchEngine;
 var init_semanticSearch = __esm({
   "packages/retrieval/dist/semanticSearch.js"() {
     "use strict";
@@ -9734,11 +10178,26 @@ var init_semanticSearch = __esm({
         if (!this.isAvailable)
           return [];
         const queryVector = await this.options.embedQuery(query);
+        const { cleanQuery, tagFilter } = parseTagFilter(query);
+        const searchVector = cleanQuery !== query ? await this.options.embedQuery(cleanQuery) : queryVector;
         const scored = this.options.index.map((item) => ({
           filePath: item.filePath,
-          score: cosineSimilarity(queryVector, item.vector)
+          score: cosineSimilarity(searchVector, item.vector),
+          text: item.text
         }));
-        return scored.sort((a, b) => b.score - a.score).slice(0, topK).map(({ filePath, score }) => {
+        let filtered = scored;
+        if (tagFilter) {
+          filtered = scored.filter((item) => matchesTagFilter(item.text, tagFilter));
+        }
+        const byFile = /* @__PURE__ */ new Map();
+        for (const item of filtered) {
+          const existing = byFile.get(item.filePath);
+          if (!existing || item.score > existing.score) {
+            byFile.set(item.filePath, item);
+          }
+        }
+        const deduped = Array.from(byFile.values());
+        return deduped.sort((a, b) => b.score - a.score).slice(0, topK).map(({ filePath, score }) => {
           const summary = this.options.summaryMap.get(filePath);
           return {
             filePath,
@@ -9748,6 +10207,74 @@ var init_semanticSearch = __esm({
           };
         });
       }
+      /**
+       * Pattern 7: Find semantically related items in the index.
+       * Returns pairs of items with >threshold similarity.
+       * Useful for auto-linking related memories/files.
+       */
+      findRelated(filePath, threshold = 0.7, maxResults = 5) {
+        const sourceItem = this.options.index.find((i) => i.filePath === filePath);
+        if (!sourceItem)
+          return [];
+        const scored = this.options.index.filter((i) => i.filePath !== filePath).map((item) => ({
+          filePath: item.filePath,
+          score: cosineSimilarity(sourceItem.vector, item.vector)
+        })).filter((r) => r.score >= threshold).sort((a, b) => b.score - a.score).slice(0, maxResults);
+        return scored;
+      }
+    };
+    LazySemanticSearchEngine = class {
+      inner = null;
+      buildPromise = null;
+      buildFailed = false;
+      opts;
+      constructor(opts) {
+        this.opts = opts;
+      }
+      get isAvailable() {
+        return this.inner?.isAvailable ?? false;
+      }
+      /**
+       * Trigger index building in the background.
+       * Call this during idle time to pre-warm the index.
+       */
+      warmUp() {
+        if (!this.buildPromise && !this.inner && !this.buildFailed) {
+          this.buildPromise = this.build();
+        }
+      }
+      async search(query, topK = 10) {
+        if (this.inner)
+          return this.inner.search(query, topK);
+        if (this.buildFailed)
+          return [];
+        if (!this.buildPromise) {
+          this.buildPromise = this.build();
+        }
+        const timeoutMs = this.opts.timeoutMs ?? 6e4;
+        try {
+          await Promise.race([
+            this.buildPromise,
+            new Promise((_, reject) => setTimeout(() => reject(new Error("Index build timeout")), timeoutMs))
+          ]);
+        } catch {
+          return [];
+        }
+        return this.searchInner(query, topK);
+      }
+      searchInner(query, topK) {
+        if (this.inner)
+          return this.inner.search(query, topK);
+        return Promise.resolve([]);
+      }
+      async build() {
+        try {
+          const options = await this.opts.buildIndex();
+          this.inner = new IndexBackedSemanticSearchEngine(options);
+        } catch {
+          this.buildFailed = true;
+        }
+      }
     };
   }
 });
@@ -9818,8 +10345,8 @@ var init_graphExpand = __esm({
 });
 
 // packages/retrieval/dist/snippetPacker.js
-import { readFile as readFile9 } from "node:fs/promises";
-import { join as join21 } from "node:path";
+import { readFile as readFile10 } from "node:fs/promises";
+import { join as join22 } from "node:path";
 async function packSnippets(requests, opts = {}) {
   const maxTokens = opts.maxTokens ?? DEFAULT_MAX_TOKENS;
   const contextLines = opts.contextLines ?? DEFAULT_CONTEXT_LINES;
@@ -9845,10 +10372,10 @@ async function packSnippets(requests, opts = {}) {
   return { packed, dropped, totalTokens };
 }
 async function extractSnippet(req, repoRoot, contextLines = DEFAULT_CONTEXT_LINES) {
-  const absPath = req.filePath.startsWith("/") ? req.filePath : join21(repoRoot, req.filePath);
+  const absPath = req.filePath.startsWith("/") ? req.filePath : join22(repoRoot, req.filePath);
   let content;
   try {
-    content = await readFile9(absPath, "utf-8");
+    content = await readFile10(absPath, "utf-8");
   } catch {
     return null;
   }
@@ -9904,24 +10431,41 @@ async function assembleContext(request, opts) {
     Promise.all(request.errorHint.slice(0, maxLogs).map((e) => searchByError(e, { rootDir: repoRoot, maxMatches: 5 }))).then((res) => res.flat()),
     semanticEngine?.isAvailable ? semanticEngine.search(request.query, maxFiles) : Promise.resolve([])
   ]);
-  const seenFiles = /* @__PURE__ */ new Set();
-  const candidateFiles = [];
-  function addCandidate(relativePath, priority) {
-    if (seenFiles.has(relativePath))
-      return;
-    seenFiles.add(relativePath);
-    candidateFiles.push({ relativePath, priority });
-  }
+  const queryType = classifyQuery(request.query);
+  const rrfK = adaptiveK(queryType, opts.rrfConfig?.k);
+  const wFts = opts.rrfConfig?.weightFts ?? 1;
+  const wSem = opts.rrfConfig?.weightSemantic ?? 1;
+  const lexicalCandidates = [];
   for (const m of pathMatches)
-    addCandidate(m.relativePath, 100);
+    lexicalCandidates.push({ relativePath: m.relativePath, basePriority: 100 });
   for (const m of symbolMatches)
-    addCandidate(m.relativePath, 80);
-  for (const r of semanticResults) {
-    addCandidate(r.filePath, Math.round(50 + r.score * 30));
-  }
+    lexicalCandidates.push({ relativePath: m.relativePath, basePriority: 80 });
   for (const m of errorMatches)
-    addCandidate(m.relativePath, 40);
-  const topFiles = candidateFiles.sort((a, b) => b.priority - a.priority).slice(0, maxFiles);
+    lexicalCandidates.push({ relativePath: m.relativePath, basePriority: 40 });
+  const lexDedup = /* @__PURE__ */ new Map();
+  for (const c3 of lexicalCandidates) {
+    const existing = lexDedup.get(c3.relativePath) ?? 0;
+    lexDedup.set(c3.relativePath, Math.max(existing, c3.basePriority));
+  }
+  const lexRanked = Array.from(lexDedup.entries()).sort((a, b) => b[1] - a[1]).map(([path], idx) => ({ path, rank: idx + 1 }));
+  const semRanked = semanticResults.sort((a, b) => b.score - a.score).map((r, idx) => ({ path: r.filePath, rank: idx + 1, score: r.score }));
+  const rrfScores = /* @__PURE__ */ new Map();
+  const lexRankMap = new Map(lexRanked.map((l) => [l.path, l.rank]));
+  const semRankMap = new Map(semRanked.map((s) => [s.path, s.rank]));
+  const allPaths = /* @__PURE__ */ new Set([...lexRankMap.keys(), ...semRankMap.keys()]);
+  for (const p of allPaths) {
+    const lexRank = lexRankMap.get(p);
+    const semRank = semRankMap.get(p);
+    let score = 0;
+    if (lexRank !== void 0)
+      score += wFts / (rrfK + lexRank);
+    if (semRank !== void 0)
+      score += wSem / (rrfK + semRank);
+    rrfScores.set(p, score);
+  }
+  const candidateFiles = Array.from(rrfScores.entries()).sort((a, b) => b[1] - a[1]).map(([relativePath, priority]) => ({ relativePath, priority: Math.round(priority * 1e3) }));
+  const seenFiles = new Set(candidateFiles.map((c3) => c3.relativePath));
+  const topFiles = candidateFiles.slice(0, maxFiles);
   const neighborFiles = [];
   if (expandNeighbors && graph) {
     const seedPaths = topFiles.map((f) => f.relativePath);
@@ -9966,6 +10510,39 @@ async function assembleContext(request, opts) {
     assembledAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
+function classifyQuery(query) {
+  const trimmed = query.trim();
+  if (/^["'].*["']$/.test(trimmed) || /"[^"]+"/.test(trimmed))
+    return "quoted";
+  if (/(?:error|exception|stack|traceback|ENOENT|EPERM|TypeError|SyntaxError)/i.test(trimmed))
+    return "error";
+  if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(trimmed))
+    return "symbol";
+  const wordCount = trimmed.split(/\s+/).length;
+  if (wordCount <= 3)
+    return "short";
+  return "long";
+}
+function adaptiveK(queryType, overrideK) {
+  if (overrideK !== void 0)
+    return overrideK;
+  switch (queryType) {
+    case "short":
+      return 30;
+    // tight — top results matter more
+    case "quoted":
+      return 20;
+    // very tight — exact match should win
+    case "symbol":
+      return 25;
+    // tight — symbol search is precise
+    case "error":
+      return 40;
+    // moderate — errors need breadth
+    case "long":
+      return 60;
+  }
+}
 function buildSymbolSnippets(symbolMatches, maxSnippets) {
   const byFile = /* @__PURE__ */ new Map();
   for (const m of symbolMatches) {
@@ -10008,8 +10585,10 @@ __export(dist_exports, {
   CodeRetriever: () => CodeRetriever,
   GrepSearch: () => GrepSearch,
   IndexBackedSemanticSearchEngine: () => IndexBackedSemanticSearchEngine,
+  LazySemanticSearchEngine: () => LazySemanticSearchEngine,
   StubSemanticSearchEngine: () => StubSemanticSearchEngine,
   assembleContext: () => assembleContext,
+  classifyQuery: () => classifyQuery,
   estimatePacketTokens: () => estimatePacketTokens,
   estimateTokens: () => estimateTokens,
   expandGraph: () => expandGraph,
@@ -10017,6 +10596,7 @@ __export(dist_exports, {
   oneHopNeighbors: () => oneHopNeighbors,
   packFiles: () => packFiles,
   packSnippets: () => packSnippets,
+  parseTagFilter: () => parseTagFilter,
   searchByError: () => searchByError,
   searchByPath: () => searchByPath,
   searchByQuery: () => searchByQuery,
@@ -11451,8 +12031,8 @@ Rules:
       async waitIfPaused() {
         if (!this._paused)
           return true;
-        await new Promise((resolve22) => {
-          this._pauseResolve = resolve22;
+        await new Promise((resolve23) => {
+          this._pauseResolve = resolve23;
         });
         return !this.aborted;
       }
@@ -11709,6 +12289,15 @@ Integrate this guidance into your current approach. Continue working on the task
                   }
                 }
               }
+              if (tc.name === "explore_tools" && result.success && result.output.startsWith("UNLOCK_TOOL:")) {
+                const unlockName = result.output.slice("UNLOCK_TOOL:".length).trim();
+                const existingTool = this.tools.get(unlockName);
+                if (existingTool) {
+                  result = { success: true, output: `Tool '${unlockName}' is now unlocked and available. You can use it in your next response.` };
+                } else {
+                  result = { success: false, output: "", error: `Unknown tool '${unlockName}'. Call explore_tools() with no args to see available tools.` };
+                }
+              }
               const { toolOutputMaxChars: maxLen } = this.contextLimits();
               const output = result.success ? result.output.length > maxLen ? this.foldOutput(result.output, maxLen) : result.output : `Error: ${result.error || "unknown error"}
 ${result.output.length > maxLen ? this.foldOutput(result.output, maxLen) : result.output}`;
@@ -12020,14 +12609,14 @@ ${result.output}`;
       waitForSudoPassword(timeoutMs = 12e4) {
         if (this._sudoPassword)
           return Promise.resolve(this._sudoPassword);
-        return new Promise((resolve22) => {
+        return new Promise((resolve23) => {
           const timer = setTimeout(() => {
             this._sudoResolve = null;
-            resolve22(null);
+            resolve23(null);
           }, timeoutMs);
           this._sudoResolve = (pw) => {
             clearTimeout(timer);
-            resolve22(pw);
+            resolve23(pw);
           };
         });
       }
@@ -12150,8 +12739,8 @@ ${marker}` : marker);
           return;
         try {
           const { mkdirSync: mkdirSync13, writeFileSync: writeFileSync12 } = __require("node:fs");
-          const { join: join36 } = __require("node:path");
-          const sessionDir = join36(this._workingDirectory, ".oa", "session", this._sessionId);
+          const { join: join37 } = __require("node:path");
+          const sessionDir = join37(this._workingDirectory, ".oa", "session", this._sessionId);
           mkdirSync13(sessionDir, { recursive: true });
           const checkpoint = {
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -12164,7 +12753,7 @@ ${marker}` : marker);
             memexEntryCount: this._memexArchive.size,
             fileRegistrySize: this._fileRegistry.size
           };
-          writeFileSync12(join36(sessionDir, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
+          writeFileSync12(join37(sessionDir, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
         } catch {
         }
       }
@@ -13697,9 +14286,9 @@ var init_dist5 = __esm({
 
 // packages/cli/dist/tui/listen.js
 import { spawn as spawn7, execSync as execSync15 } from "node:child_process";
-import { existsSync as existsSync17, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5, readdirSync as readdirSync6 } from "node:fs";
-import { join as join22, dirname as dirname8 } from "node:path";
-import { homedir as homedir7 } from "node:os";
+import { existsSync as existsSync18, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5, readdirSync as readdirSync6 } from "node:fs";
+import { join as join23, dirname as dirname8 } from "node:path";
+import { homedir as homedir8 } from "node:os";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { EventEmitter } from "node:events";
 import { createInterface as createInterface2 } from "node:readline";
@@ -13784,15 +14373,15 @@ function findMicCaptureCommand() {
 function findLiveWhisperScript() {
   const thisDir = dirname8(fileURLToPath5(import.meta.url));
   const candidates = [
-    join22(thisDir, "../../../../packages/execution/scripts/live-whisper.py"),
-    join22(thisDir, "../../../packages/execution/scripts/live-whisper.py"),
-    join22(thisDir, "../../execution/scripts/live-whisper.py"),
+    join23(thisDir, "../../../../packages/execution/scripts/live-whisper.py"),
+    join23(thisDir, "../../../packages/execution/scripts/live-whisper.py"),
+    join23(thisDir, "../../execution/scripts/live-whisper.py"),
     // npm install layout — scripts bundled alongside dist
-    join22(thisDir, "../scripts/live-whisper.py"),
-    join22(thisDir, "../../scripts/live-whisper.py")
+    join23(thisDir, "../scripts/live-whisper.py"),
+    join23(thisDir, "../../scripts/live-whisper.py")
   ];
   for (const p of candidates) {
-    if (existsSync17(p))
+    if (existsSync18(p))
       return p;
   }
   try {
@@ -13802,21 +14391,21 @@ function findLiveWhisperScript() {
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     const candidates2 = [
-      join22(globalRoot, "open-agents-ai", "dist", "scripts", "live-whisper.py"),
-      join22(globalRoot, "open-agents-ai", "scripts", "live-whisper.py")
+      join23(globalRoot, "open-agents-ai", "dist", "scripts", "live-whisper.py"),
+      join23(globalRoot, "open-agents-ai", "scripts", "live-whisper.py")
     ];
     for (const p of candidates2) {
-      if (existsSync17(p))
+      if (existsSync18(p))
         return p;
     }
   } catch {
   }
-  const nvmBase = join22(homedir7(), ".nvm", "versions", "node");
-  if (existsSync17(nvmBase)) {
+  const nvmBase = join23(homedir8(), ".nvm", "versions", "node");
+  if (existsSync18(nvmBase)) {
     try {
       for (const ver of readdirSync6(nvmBase)) {
-        const p = join22(nvmBase, ver, "lib", "node_modules", "open-agents-ai", "dist", "scripts", "live-whisper.py");
-        if (existsSync17(p))
+        const p = join23(nvmBase, ver, "lib", "node_modules", "open-agents-ai", "dist", "scripts", "live-whisper.py");
+        if (existsSync18(p))
           return p;
       }
     } catch {
@@ -13834,16 +14423,16 @@ function ensureTranscribeCliBackground() {
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      if (existsSync17(join22(globalRoot, "transcribe-cli", "dist", "index.js"))) {
+      if (existsSync18(join23(globalRoot, "transcribe-cli", "dist", "index.js"))) {
         return true;
       }
     } catch {
     }
     try {
       const { exec } = await import("node:child_process");
-      return new Promise((resolve22) => {
+      return new Promise((resolve23) => {
         exec("npm i -g transcribe-cli", { timeout: 18e4 }, (err) => {
-          resolve22(!err);
+          resolve23(!err);
         });
       });
     } catch {
@@ -13896,7 +14485,7 @@ var init_listen = __esm({
         return this._ready;
       }
       async start() {
-        return new Promise((resolve22, reject) => {
+        return new Promise((resolve23, reject) => {
           const timeout = setTimeout(() => {
             reject(new Error("Whisper fallback: model load timeout (5 min). First run downloads the model."));
           }, 3e5);
@@ -13924,7 +14513,7 @@ var init_listen = __esm({
                   this._ready = true;
                   clearTimeout(timeout);
                   this.emit("ready");
-                  resolve22();
+                  resolve23();
                   break;
                 case "transcript":
                   this.emit("transcript", {
@@ -14051,24 +14640,24 @@ var init_listen = __esm({
             timeout: 5e3,
             stdio: ["pipe", "pipe", "pipe"]
           }).trim();
-          const tcPath = join22(globalRoot, "transcribe-cli");
-          if (existsSync17(join22(tcPath, "dist", "index.js"))) {
+          const tcPath = join23(globalRoot, "transcribe-cli");
+          if (existsSync18(join23(tcPath, "dist", "index.js"))) {
             const { createRequire: createRequire4 } = await import("node:module");
             const req = createRequire4(import.meta.url);
-            return req(join22(tcPath, "dist", "index.js"));
+            return req(join23(tcPath, "dist", "index.js"));
           }
         } catch {
         }
-        const nvmBase = join22(homedir7(), ".nvm", "versions", "node");
-        if (existsSync17(nvmBase)) {
+        const nvmBase = join23(homedir8(), ".nvm", "versions", "node");
+        if (existsSync18(nvmBase)) {
           try {
             const { readdirSync: readdirSync11 } = await import("node:fs");
             for (const ver of readdirSync11(nvmBase)) {
-              const tcPath = join22(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
-              if (existsSync17(join22(tcPath, "dist", "index.js"))) {
+              const tcPath = join23(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
+              if (existsSync18(join23(tcPath, "dist", "index.js"))) {
                 const { createRequire: createRequire4 } = await import("node:module");
                 const req = createRequire4(import.meta.url);
-                return req(join22(tcPath, "dist", "index.js"));
+                return req(join23(tcPath, "dist", "index.js"));
               }
             }
           } catch {
@@ -14128,11 +14717,11 @@ var init_listen = __esm({
               this.liveTranscriber.on("error", (err) => {
                 this.emit("error", err);
               });
-              await new Promise((resolve22, reject) => {
+              await new Promise((resolve23, reject) => {
                 const timeout = setTimeout(() => reject(new Error("Model load timeout (60s)")), 6e4);
                 this.liveTranscriber.on("ready", () => {
                   clearTimeout(timeout);
-                  resolve22();
+                  resolve23();
                 });
                 this.liveTranscriber.on("error", (err) => {
                   clearTimeout(timeout);
@@ -14293,10 +14882,10 @@ transcribe-cli error: ${transcribeCliError}` : "";
             wordTimestamps: false
           });
           if (outputDir) {
-            const { basename: basename13 } = await import("node:path");
-            const transcriptDir = join22(outputDir, ".oa", "transcripts");
+            const { basename: basename14 } = await import("node:path");
+            const transcriptDir = join23(outputDir, ".oa", "transcripts");
             mkdirSync5(transcriptDir, { recursive: true });
-            const outFile = join22(transcriptDir, `${basename13(filePath)}.txt`);
+            const outFile = join23(transcriptDir, `${basename14(filePath)}.txt`);
             writeFileSync5(outFile, result.text, "utf-8");
           }
           return {
@@ -15568,7 +16157,7 @@ Approach this task thoughtfully:
 });
 
 // packages/prompts/dist/index.js
-import { join as join23, dirname as dirname9 } from "node:path";
+import { join as join24, dirname as dirname9 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 var _dir, _packageRoot;
 var init_dist6 = __esm({
@@ -15579,28 +16168,28 @@ var init_dist6 = __esm({
     init_task_templates();
     init_render2();
     _dir = dirname9(fileURLToPath6(import.meta.url));
-    _packageRoot = join23(_dir, "..");
+    _packageRoot = join24(_dir, "..");
   }
 });
 
 // packages/cli/dist/tui/oa-directory.js
-import { existsSync as existsSync18, mkdirSync as mkdirSync6, readFileSync as readFileSync13, writeFileSync as writeFileSync6, readdirSync as readdirSync7, statSync as statSync9, unlinkSync as unlinkSync3 } from "node:fs";
-import { join as join24, relative as relative2, basename as basename8, extname as extname8 } from "node:path";
-import { homedir as homedir8 } from "node:os";
+import { existsSync as existsSync19, mkdirSync as mkdirSync6, readFileSync as readFileSync13, writeFileSync as writeFileSync6, readdirSync as readdirSync7, statSync as statSync9, unlinkSync as unlinkSync3 } from "node:fs";
+import { join as join25, relative as relative2, basename as basename9, extname as extname8 } from "node:path";
+import { homedir as homedir9 } from "node:os";
 function initOaDirectory(repoRoot) {
-  const oaPath = join24(repoRoot, OA_DIR);
+  const oaPath = join25(repoRoot, OA_DIR);
   for (const sub of SUBDIRS) {
-    mkdirSync6(join24(oaPath, sub), { recursive: true });
+    mkdirSync6(join25(oaPath, sub), { recursive: true });
   }
   return oaPath;
 }
 function hasOaDirectory(repoRoot) {
-  return existsSync18(join24(repoRoot, OA_DIR, "index"));
+  return existsSync19(join25(repoRoot, OA_DIR, "index"));
 }
 function loadProjectSettings(repoRoot) {
-  const settingsPath = join24(repoRoot, OA_DIR, "settings.json");
+  const settingsPath = join25(repoRoot, OA_DIR, "settings.json");
   try {
-    if (existsSync18(settingsPath)) {
+    if (existsSync19(settingsPath)) {
       return JSON.parse(readFileSync13(settingsPath, "utf-8"));
     }
   } catch {
@@ -15608,16 +16197,16 @@ function loadProjectSettings(repoRoot) {
   return {};
 }
 function saveProjectSettings(repoRoot, settings) {
-  const oaPath = join24(repoRoot, OA_DIR);
+  const oaPath = join25(repoRoot, OA_DIR);
   mkdirSync6(oaPath, { recursive: true });
   const existing = loadProjectSettings(repoRoot);
   const merged = { ...existing, ...settings };
-  writeFileSync6(join24(oaPath, "settings.json"), JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  writeFileSync6(join25(oaPath, "settings.json"), JSON.stringify(merged, null, 2) + "\n", "utf-8");
 }
 function loadGlobalSettings() {
-  const settingsPath = join24(homedir8(), ".open-agents", "settings.json");
+  const settingsPath = join25(homedir9(), ".open-agents", "settings.json");
   try {
-    if (existsSync18(settingsPath)) {
+    if (existsSync19(settingsPath)) {
       return JSON.parse(readFileSync13(settingsPath, "utf-8"));
     }
   } catch {
@@ -15625,11 +16214,11 @@ function loadGlobalSettings() {
   return {};
 }
 function saveGlobalSettings(settings) {
-  const dir = join24(homedir8(), ".open-agents");
+  const dir = join25(homedir9(), ".open-agents");
   mkdirSync6(dir, { recursive: true });
   const existing = loadGlobalSettings();
   const merged = { ...existing, ...settings };
-  writeFileSync6(join24(dir, "settings.json"), JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  writeFileSync6(join25(dir, "settings.json"), JSON.stringify(merged, null, 2) + "\n", "utf-8");
 }
 function resolveSettings(repoRoot) {
   const global = loadGlobalSettings();
@@ -15644,9 +16233,9 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
   while (dir && !visited.has(dir)) {
     visited.add(dir);
     for (const name of CONTEXT_FILES) {
-      const filePath = join24(dir, name);
+      const filePath = join25(dir, name);
       const normalizedName = name.toLowerCase();
-      if (existsSync18(filePath) && !seen.has(filePath)) {
+      if (existsSync19(filePath) && !seen.has(filePath)) {
         seen.add(filePath);
         try {
           let content = readFileSync13(filePath, "utf-8");
@@ -15663,8 +16252,8 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
         }
       }
     }
-    const projectMap = join24(dir, OA_DIR, "context", "project-map.md");
-    if (existsSync18(projectMap) && !seen.has(projectMap)) {
+    const projectMap = join25(dir, OA_DIR, "context", "project-map.md");
+    if (existsSync19(projectMap) && !seen.has(projectMap)) {
       seen.add(projectMap);
       try {
         let content = readFileSync13(projectMap, "utf-8");
@@ -15679,7 +16268,7 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
       } catch {
       }
     }
-    const parent = join24(dir, "..");
+    const parent = join25(dir, "..");
     if (parent === dir)
       break;
     dir = parent;
@@ -15697,7 +16286,7 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
   return found;
 }
 function readIndexMeta(repoRoot) {
-  const metaPath = join24(repoRoot, OA_DIR, "index", "meta.json");
+  const metaPath = join25(repoRoot, OA_DIR, "index", "meta.json");
   try {
     return JSON.parse(readFileSync13(metaPath, "utf-8"));
   } catch {
@@ -15706,7 +16295,7 @@ function readIndexMeta(repoRoot) {
 }
 function generateProjectMap(repoRoot) {
   const sections = [];
-  const repoName2 = basename8(repoRoot);
+  const repoName2 = basename9(repoRoot);
   sections.push(`# Project Map: ${repoName2}
 `);
   sections.push(`> Auto-generated by open-agents. Updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
@@ -15750,28 +16339,28 @@ ${tree}\`\`\`
     sections.push("");
   }
   const content = sections.join("\n");
-  const contextDir = join24(repoRoot, OA_DIR, "context");
+  const contextDir = join25(repoRoot, OA_DIR, "context");
   mkdirSync6(contextDir, { recursive: true });
-  writeFileSync6(join24(contextDir, "project-map.md"), content, "utf-8");
+  writeFileSync6(join25(contextDir, "project-map.md"), content, "utf-8");
   return content;
 }
 function saveSession(repoRoot, session) {
-  const historyDir = join24(repoRoot, OA_DIR, "history");
+  const historyDir = join25(repoRoot, OA_DIR, "history");
   mkdirSync6(historyDir, { recursive: true });
-  writeFileSync6(join24(historyDir, `${session.id}.json`), JSON.stringify(session, null, 2), "utf-8");
+  writeFileSync6(join25(historyDir, `${session.id}.json`), JSON.stringify(session, null, 2), "utf-8");
 }
 function loadRecentSessions(repoRoot, limit = 5) {
-  const historyDir = join24(repoRoot, OA_DIR, "history");
-  if (!existsSync18(historyDir))
+  const historyDir = join25(repoRoot, OA_DIR, "history");
+  if (!existsSync19(historyDir))
     return [];
   try {
     const files = readdirSync7(historyDir).filter((f) => f.endsWith(".json") && f !== "pending-task.json").map((f) => {
-      const stat5 = statSync9(join24(historyDir, f));
+      const stat5 = statSync9(join25(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(readFileSync13(join24(historyDir, f.file), "utf-8"));
+        return JSON.parse(readFileSync13(join25(historyDir, f.file), "utf-8"));
       } catch {
         return null;
       }
@@ -15781,14 +16370,14 @@ function loadRecentSessions(repoRoot, limit = 5) {
   }
 }
 function savePendingTask(repoRoot, task) {
-  const historyDir = join24(repoRoot, OA_DIR, "history");
+  const historyDir = join25(repoRoot, OA_DIR, "history");
   mkdirSync6(historyDir, { recursive: true });
-  writeFileSync6(join24(historyDir, PENDING_TASK_FILE), JSON.stringify(task, null, 2) + "\n", "utf-8");
+  writeFileSync6(join25(historyDir, PENDING_TASK_FILE), JSON.stringify(task, null, 2) + "\n", "utf-8");
 }
 function loadPendingTask(repoRoot) {
-  const filePath = join24(repoRoot, OA_DIR, "history", PENDING_TASK_FILE);
+  const filePath = join25(repoRoot, OA_DIR, "history", PENDING_TASK_FILE);
   try {
-    if (!existsSync18(filePath))
+    if (!existsSync19(filePath))
       return null;
     const data = JSON.parse(readFileSync13(filePath, "utf-8"));
     try {
@@ -15801,12 +16390,12 @@ function loadPendingTask(repoRoot) {
   }
 }
 function saveSessionContext(repoRoot, entry) {
-  const contextDir = join24(repoRoot, OA_DIR, "context");
+  const contextDir = join25(repoRoot, OA_DIR, "context");
   mkdirSync6(contextDir, { recursive: true });
-  const filePath = join24(contextDir, CONTEXT_SAVE_FILE);
+  const filePath = join25(contextDir, CONTEXT_SAVE_FILE);
   let ctx;
   try {
-    if (existsSync18(filePath)) {
+    if (existsSync19(filePath)) {
       ctx = JSON.parse(readFileSync13(filePath, "utf-8"));
     } else {
       ctx = { entries: [], maxEntries: MAX_CONTEXT_ENTRIES, updatedAt: "" };
@@ -15822,9 +16411,9 @@ function saveSessionContext(repoRoot, entry) {
   writeFileSync6(filePath, JSON.stringify(ctx, null, 2) + "\n", "utf-8");
 }
 function loadSessionContext(repoRoot) {
-  const filePath = join24(repoRoot, OA_DIR, "context", CONTEXT_SAVE_FILE);
+  const filePath = join25(repoRoot, OA_DIR, "context", CONTEXT_SAVE_FILE);
   try {
-    if (!existsSync18(filePath))
+    if (!existsSync19(filePath))
       return null;
     return JSON.parse(readFileSync13(filePath, "utf-8"));
   } catch {
@@ -15873,8 +16462,8 @@ function detectManifests(repoRoot) {
     { file: "docker-compose.yaml", type: "Docker Compose" }
   ];
   for (const check of checks) {
-    const filePath = join24(repoRoot, check.file);
-    if (existsSync18(filePath)) {
+    const filePath = join25(repoRoot, check.file);
+    if (existsSync19(filePath)) {
       let name;
       if (check.nameField) {
         try {
@@ -15907,7 +16496,7 @@ function findKeyFiles(repoRoot) {
     { pattern: "CLAUDE.md", description: "Claude Code context" }
   ];
   for (const check of checks) {
-    if (existsSync18(join24(repoRoot, check.pattern))) {
+    if (existsSync19(join25(repoRoot, check.pattern))) {
       keyFiles.push({ path: check.pattern, description: check.description });
     }
   }
@@ -15933,12 +16522,12 @@ function buildDirTree(root, maxDepth, prefix = "", depth = 0) {
       if (entry.isDirectory()) {
         let fileCount = 0;
         try {
-          fileCount = readdirSync7(join24(root, entry.name)).filter((f) => !f.startsWith(".")).length;
+          fileCount = readdirSync7(join25(root, entry.name)).filter((f) => !f.startsWith(".")).length;
         } catch {
         }
         result += `${prefix}${connector}${entry.name}/ (${fileCount})
 `;
-        result += buildDirTree(join24(root, entry.name), maxDepth, childPrefix, depth + 1);
+        result += buildDirTree(join25(root, entry.name), maxDepth, childPrefix, depth + 1);
       } else if (depth < maxDepth) {
         result += `${prefix}${connector}${entry.name}
 `;
@@ -15992,9 +16581,9 @@ var init_oa_directory = __esm({
 // packages/cli/dist/tui/setup.js
 import * as readline from "node:readline";
 import { execSync as execSync16, spawn as spawn8 } from "node:child_process";
-import { existsSync as existsSync19, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "node:fs";
-import { join as join25 } from "node:path";
-import { homedir as homedir9, platform } from "node:os";
+import { existsSync as existsSync20, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "node:fs";
+import { join as join26 } from "node:path";
+import { homedir as homedir10, platform } from "node:os";
 function detectSystemSpecs() {
   let totalRamGB = 0;
   let availableRamGB = 0;
@@ -16077,8 +16666,8 @@ function modelSupportsToolCalling(modelName) {
   return false;
 }
 function ask(rl, question) {
-  return new Promise((resolve22) => {
-    rl.question(question, (answer) => resolve22(answer.trim()));
+  return new Promise((resolve23) => {
+    rl.question(question, (answer) => resolve23(answer.trim()));
   });
 }
 async function autoInstallOllama(rl) {
@@ -16145,7 +16734,7 @@ async function installOllamaMac(rl) {
       execSync16('/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"', { stdio: "inherit", timeout: 6e5 });
       if (!hasCmd("brew")) {
         try {
-          const brewPrefix = existsSync19("/opt/homebrew/bin/brew") ? "/opt/homebrew" : "/usr/local";
+          const brewPrefix = existsSync20("/opt/homebrew/bin/brew") ? "/opt/homebrew" : "/usr/local";
           process.env["PATH"] = `${brewPrefix}/bin:${process.env["PATH"]}`;
         } catch {
         }
@@ -16436,7 +17025,7 @@ async function doSetup(config, rl) {
         try {
           const child = spawn8("ollama", ["serve"], { stdio: "ignore", detached: true });
           child.unref();
-          await new Promise((resolve22) => setTimeout(resolve22, 3e3));
+          await new Promise((resolve23) => setTimeout(resolve23, 3e3));
           try {
             models = await fetchOllamaModels(config.backendUrl);
             process.stdout.write(`  ${c2.green("\u2714")} Ollama is running.
@@ -16464,7 +17053,7 @@ async function doSetup(config, rl) {
           try {
             const child = spawn8("ollama", ["serve"], { stdio: "ignore", detached: true });
             child.unref();
-            await new Promise((resolve22) => setTimeout(resolve22, 3e3));
+            await new Promise((resolve23) => setTimeout(resolve23, 3e3));
             try {
               models = await fetchOllamaModels(config.backendUrl);
               process.stdout.write(`  ${c2.green("\u2714")} Ollama is running.
@@ -16619,9 +17208,9 @@ async function doSetup(config, rl) {
           `PARAMETER num_predict ${numPredict}`,
           `PARAMETER stop "<|endoftext|>"`
         ].join("\n");
-        const modelDir2 = join25(homedir9(), ".open-agents", "models");
+        const modelDir2 = join26(homedir10(), ".open-agents", "models");
         mkdirSync7(modelDir2, { recursive: true });
-        const modelfilePath = join25(modelDir2, `Modelfile.${customName}`);
+        const modelfilePath = join26(modelDir2, `Modelfile.${customName}`);
         writeFileSync7(modelfilePath, modelfileContent + "\n", "utf8");
         process.stdout.write(`  ${c2.dim("Creating model...")} `);
         execSync16(`ollama create ${customName} -f ${modelfilePath}`, {
@@ -16667,7 +17256,7 @@ async function isModelAvailable(config) {
 }
 function isFirstRun() {
   try {
-    return !existsSync19(join25(homedir9(), ".open-agents", "config.json"));
+    return !existsSync20(join26(homedir10(), ".open-agents", "config.json"));
   } catch {
     return true;
   }
@@ -16704,7 +17293,7 @@ function detectPkgManager() {
   return null;
 }
 function getVenvDir() {
-  return join25(homedir9(), ".open-agents", "venv");
+  return join26(homedir10(), ".open-agents", "venv");
 }
 function hasVenvModule() {
   try {
@@ -16716,8 +17305,8 @@ function hasVenvModule() {
 }
 function ensureVenv(log) {
   const venvDir = getVenvDir();
-  const venvPip = join25(venvDir, "bin", "pip");
-  if (existsSync19(venvPip))
+  const venvPip = join26(venvDir, "bin", "pip");
+  if (existsSync20(venvPip))
     return venvDir;
   log("Creating Python venv for vision deps...");
   if (!hasCmd("python3")) {
@@ -16729,9 +17318,9 @@ function ensureVenv(log) {
     return null;
   }
   try {
-    mkdirSync7(join25(homedir9(), ".open-agents"), { recursive: true });
+    mkdirSync7(join26(homedir10(), ".open-agents"), { recursive: true });
     execSync16(`python3 -m venv "${venvDir}"`, { stdio: "pipe", timeout: 3e4 });
-    execSync16(`"${join25(venvDir, "bin", "pip")}" install --upgrade pip`, {
+    execSync16(`"${join26(venvDir, "bin", "pip")}" install --upgrade pip`, {
       stdio: "pipe",
       timeout: 6e4
     });
@@ -16940,15 +17529,15 @@ async function ensureVisionDeps(onInfo, getSudoPassword) {
     }
   }
   const venvDir = getVenvDir();
-  const venvBin = join25(venvDir, "bin");
-  const venvMoondream = join25(venvBin, "moondream-station");
+  const venvBin = join26(venvDir, "bin");
+  const venvMoondream = join26(venvBin, "moondream-station");
   const venv = ensureVenv(log);
-  if (venv && !hasCmd("moondream-station") && !existsSync19(venvMoondream)) {
-    const venvPip = join25(venvBin, "pip");
+  if (venv && !hasCmd("moondream-station") && !existsSync20(venvMoondream)) {
+    const venvPip = join26(venvBin, "pip");
     log("Installing moondream-station in ~/.open-agents/venv...");
     try {
       execSync16(`"${venvPip}" install moondream-station`, { stdio: "pipe", timeout: 3e5 });
-      if (existsSync19(venvMoondream)) {
+      if (existsSync20(venvMoondream)) {
         log("moondream-station installed successfully.");
       } else {
         try {
@@ -16965,8 +17554,8 @@ async function ensureVisionDeps(onInfo, getSudoPassword) {
     }
   }
   if (venv) {
-    const venvPython = join25(venvBin, "python");
-    const venvPip2 = join25(venvBin, "pip");
+    const venvPython = join26(venvBin, "python");
+    const venvPip2 = join26(venvBin, "pip");
     let ocrStackInstalled = false;
     try {
       execSync16(`"${venvPython}" -c "import cv2, pytesseract, numpy, PIL"`, { stdio: "pipe", timeout: 1e4 });
@@ -17026,9 +17615,9 @@ function createExpandedVariant(baseModel, specs, sizeGB) {
       `PARAMETER num_predict ${numPredict}`,
       `PARAMETER stop "<|endoftext|>"`
     ].join("\n");
-    const modelDir2 = join25(homedir9(), ".open-agents", "models");
+    const modelDir2 = join26(homedir10(), ".open-agents", "models");
     mkdirSync7(modelDir2, { recursive: true });
-    const modelfilePath = join25(modelDir2, `Modelfile.${customName}`);
+    const modelfilePath = join26(modelDir2, `Modelfile.${customName}`);
     writeFileSync7(modelfilePath, modelfileContent + "\n", "utf8");
     execSync16(`ollama create ${customName} -f ${modelfilePath}`, {
       stdio: "pipe",
@@ -17792,17 +18381,17 @@ async function handleUpdate(subcommand, ctx) {
   try {
     const { createRequire: createRequire4 } = await import("node:module");
     const { fileURLToPath: fileURLToPath9 } = await import("node:url");
-    const { dirname: dirname12, join: join36 } = await import("node:path");
-    const { existsSync: existsSync26 } = await import("node:fs");
+    const { dirname: dirname12, join: join37 } = await import("node:path");
+    const { existsSync: existsSync27 } = await import("node:fs");
     const req = createRequire4(import.meta.url);
     const thisDir = dirname12(fileURLToPath9(import.meta.url));
     const candidates = [
-      join36(thisDir, "..", "package.json"),
-      join36(thisDir, "..", "..", "package.json"),
-      join36(thisDir, "..", "..", "..", "package.json")
+      join37(thisDir, "..", "package.json"),
+      join37(thisDir, "..", "..", "package.json"),
+      join37(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync26(pkgPath)) {
+      if (existsSync27(pkgPath)) {
         const pkg = req(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           currentVersion = pkg.version ?? "0.0.0";
@@ -17917,10 +18506,10 @@ var init_commands = __esm({
 });
 
 // packages/cli/dist/tui/project-context.js
-import { existsSync as existsSync20, readFileSync as readFileSync14, readdirSync as readdirSync8 } from "node:fs";
-import { join as join26, basename as basename9 } from "node:path";
+import { existsSync as existsSync21, readFileSync as readFileSync14, readdirSync as readdirSync8 } from "node:fs";
+import { join as join27, basename as basename10 } from "node:path";
 import { execSync as execSync17 } from "node:child_process";
-import { homedir as homedir10, platform as platform2, release } from "node:os";
+import { homedir as homedir11, platform as platform2, release } from "node:os";
 function getModelTier(modelName) {
   const m = modelName.toLowerCase();
   const sizeMatch = m.match(/\b(\d+)b\b/);
@@ -17953,8 +18542,8 @@ function loadProjectMap(repoRoot) {
   if (!hasOaDirectory(repoRoot)) {
     initOaDirectory(repoRoot);
   }
-  const mapPath = join26(repoRoot, OA_DIR, "context", "project-map.md");
-  if (existsSync20(mapPath)) {
+  const mapPath = join27(repoRoot, OA_DIR, "context", "project-map.md");
+  if (existsSync21(mapPath)) {
     try {
       const content = readFileSync14(mapPath, "utf-8");
       return content;
@@ -17997,33 +18586,33 @@ ${log}`);
 }
 function loadMemoryContext(repoRoot) {
   const sections = [];
-  const oaMemDir = join26(repoRoot, OA_DIR, "memory");
+  const oaMemDir = join27(repoRoot, OA_DIR, "memory");
   const oaEntries = loadMemoryDir(oaMemDir, "project");
   if (oaEntries)
     sections.push(oaEntries);
-  const legacyMemDir = join26(repoRoot, ".open-agents", "memory");
-  if (legacyMemDir !== oaMemDir && existsSync20(legacyMemDir)) {
+  const legacyMemDir = join27(repoRoot, ".open-agents", "memory");
+  if (legacyMemDir !== oaMemDir && existsSync21(legacyMemDir)) {
     const legacyEntries = loadMemoryDir(legacyMemDir, "project/legacy");
     if (legacyEntries)
       sections.push(legacyEntries);
   }
-  const globalMemDir = join26(homedir10(), ".open-agents", "memory");
+  const globalMemDir = join27(homedir11(), ".open-agents", "memory");
   const globalEntries = loadMemoryDir(globalMemDir, "global");
   if (globalEntries)
     sections.push(globalEntries);
   return sections.join("\n\n");
 }
 function loadMemoryDir(memDir, scope) {
-  if (!existsSync20(memDir))
+  if (!existsSync21(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 = readFileSync14(join26(memDir, file), "utf-8");
+        const raw = readFileSync14(join27(memDir, file), "utf-8");
         const entries = JSON.parse(raw);
-        const topic = basename9(file, ".json");
+        const topic = basename10(file, ".json");
         const keys = Object.keys(entries);
         if (keys.length === 0)
           continue;
@@ -19048,12 +19637,12 @@ var init_carousel = __esm({
 });
 
 // packages/cli/dist/tui/carousel-descriptors.js
-import { existsSync as existsSync21, readFileSync as readFileSync15, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8, readdirSync as readdirSync9 } from "node:fs";
-import { join as join27, basename as basename10 } from "node:path";
+import { existsSync as existsSync22, readFileSync as readFileSync15, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8, readdirSync as readdirSync9 } from "node:fs";
+import { join as join28, basename as basename11 } from "node:path";
 function loadToolProfile(repoRoot) {
-  const filePath = join27(repoRoot, OA_DIR, "context", TOOL_PROFILE_FILE);
+  const filePath = join28(repoRoot, OA_DIR, "context", TOOL_PROFILE_FILE);
   try {
-    if (!existsSync21(filePath))
+    if (!existsSync22(filePath))
       return null;
     return JSON.parse(readFileSync15(filePath, "utf-8"));
   } catch {
@@ -19061,9 +19650,9 @@ function loadToolProfile(repoRoot) {
   }
 }
 function saveToolProfile(repoRoot, profile) {
-  const contextDir = join27(repoRoot, OA_DIR, "context");
+  const contextDir = join28(repoRoot, OA_DIR, "context");
   mkdirSync8(contextDir, { recursive: true });
-  writeFileSync8(join27(contextDir, TOOL_PROFILE_FILE), JSON.stringify(profile, null, 2), "utf-8");
+  writeFileSync8(join28(contextDir, TOOL_PROFILE_FILE), JSON.stringify(profile, null, 2), "utf-8");
 }
 function categorizeToolCall(toolName) {
   for (const cat of TOOL_CATEGORIES) {
@@ -19121,9 +19710,9 @@ function weightedColor(profile) {
   return selectedCat.colors[Math.floor(Math.random() * selectedCat.colors.length)];
 }
 function loadCachedDescriptors(repoRoot) {
-  const filePath = join27(repoRoot, OA_DIR, "context", DESCRIPTOR_FILE);
+  const filePath = join28(repoRoot, OA_DIR, "context", DESCRIPTOR_FILE);
   try {
-    if (!existsSync21(filePath))
+    if (!existsSync22(filePath))
       return null;
     const cached = JSON.parse(readFileSync15(filePath, "utf-8"));
     return cached.phrases.length > 0 ? cached.phrases : null;
@@ -19132,14 +19721,14 @@ function loadCachedDescriptors(repoRoot) {
   }
 }
 function saveCachedDescriptors(repoRoot, phrases, sourceHash) {
-  const contextDir = join27(repoRoot, OA_DIR, "context");
+  const contextDir = join28(repoRoot, OA_DIR, "context");
   mkdirSync8(contextDir, { recursive: true });
   const cached = {
     phrases,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     sourceHash
   };
-  writeFileSync8(join27(contextDir, DESCRIPTOR_FILE), JSON.stringify(cached, null, 2), "utf-8");
+  writeFileSync8(join28(contextDir, DESCRIPTOR_FILE), JSON.stringify(cached, null, 2), "utf-8");
 }
 function generateDescriptors(repoRoot) {
   const profile = loadToolProfile(repoRoot);
@@ -19150,7 +19739,7 @@ function generateDescriptors(repoRoot) {
   extractFromSessions(repoRoot, tags);
   extractFromMemory(repoRoot, tags);
   extractFromToolProfile(profile, tags);
-  const repoName2 = basename10(repoRoot);
+  const repoName2 = basename11(repoRoot);
   if (repoName2 && !tags.includes(repoName2)) {
     tags.push(repoName2);
   }
@@ -19187,9 +19776,9 @@ function generateDescriptors(repoRoot) {
   return phrases;
 }
 function extractFromPackageJson(repoRoot, tags) {
-  const pkgPath = join27(repoRoot, "package.json");
+  const pkgPath = join28(repoRoot, "package.json");
   try {
-    if (!existsSync21(pkgPath))
+    if (!existsSync22(pkgPath))
       return;
     const pkg = JSON.parse(readFileSync15(pkgPath, "utf-8"));
     if (pkg.name && typeof pkg.name === "string") {
@@ -19235,7 +19824,7 @@ function extractFromManifests(repoRoot, tags) {
     { file: ".github/workflows", tag: "ci/cd" }
   ];
   for (const check of manifestChecks) {
-    if (existsSync21(join27(repoRoot, check.file))) {
+    if (existsSync22(join28(repoRoot, check.file))) {
       tags.push(check.tag);
     }
   }
@@ -19257,16 +19846,16 @@ function extractFromSessions(repoRoot, tags) {
   }
 }
 function extractFromMemory(repoRoot, tags) {
-  const memoryDir = join27(repoRoot, OA_DIR, "memory");
+  const memoryDir = join28(repoRoot, OA_DIR, "memory");
   try {
-    if (!existsSync21(memoryDir))
+    if (!existsSync22(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(readFileSync15(join27(memoryDir, file), "utf-8"));
+        const data = JSON.parse(readFileSync15(join28(memoryDir, file), "utf-8"));
         if (data && typeof data === "object") {
           const keys = Object.keys(data).slice(0, 3);
           for (const key of keys) {
@@ -19401,25 +19990,25 @@ var init_carousel_descriptors = __esm({
 });
 
 // packages/cli/dist/tui/voice.js
-import { existsSync as existsSync22, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9, readFileSync as readFileSync16, unlinkSync as unlinkSync4 } from "node:fs";
-import { join as join28 } from "node:path";
-import { homedir as homedir11, tmpdir as tmpdir6, platform as platform3 } from "node:os";
+import { existsSync as existsSync23, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9, readFileSync as readFileSync16, unlinkSync as unlinkSync4 } from "node:fs";
+import { join as join29 } from "node:path";
+import { homedir as homedir12, tmpdir as tmpdir6, platform as platform3 } from "node:os";
 import { execSync as execSync18, spawn as nodeSpawn } from "node:child_process";
 import { createRequire } from "node:module";
 function voiceDir() {
-  return join28(homedir11(), ".open-agents", "voice");
+  return join29(homedir12(), ".open-agents", "voice");
 }
 function modelsDir() {
-  return join28(voiceDir(), "models");
+  return join29(voiceDir(), "models");
 }
 function modelDir(id) {
-  return join28(modelsDir(), id);
+  return join29(modelsDir(), id);
 }
 function modelOnnxPath(id) {
-  return join28(modelDir(id), "model.onnx");
+  return join29(modelDir(id), "model.onnx");
 }
 function modelConfigPath(id) {
-  return join28(modelDir(id), "config.json");
+  return join29(modelDir(id), "config.json");
 }
 function describeToolCall(toolName, args) {
   const path = args["path"];
@@ -19692,7 +20281,7 @@ var init_voice = __esm({
         const audioData = result["output"].data;
         if (audioData.length === 0)
           return;
-        const wavPath = join28(tmpdir6(), `oa-voice-${Date.now()}.wav`);
+        const wavPath = join29(tmpdir6(), `oa-voice-${Date.now()}.wav`);
         this.writeWav(audioData, this.config.audio.sample_rate, wavPath);
         await this.playWav(wavPath);
         try {
@@ -19781,7 +20370,7 @@ var init_voice = __esm({
         const cmd = this.getPlayCommand(path);
         if (!cmd)
           return;
-        return new Promise((resolve22) => {
+        return new Promise((resolve23) => {
           const child = nodeSpawn(cmd[0], cmd.slice(1), {
             stdio: "ignore",
             detached: false
@@ -19790,12 +20379,12 @@ var init_voice = __esm({
           child.on("close", () => {
             if (this.currentPlayback === child)
               this.currentPlayback = null;
-            resolve22();
+            resolve23();
           });
           child.on("error", () => {
             if (this.currentPlayback === child)
               this.currentPlayback = null;
-            resolve22();
+            resolve23();
           });
           setTimeout(() => {
             if (this.currentPlayback === child) {
@@ -19805,7 +20394,7 @@ var init_voice = __esm({
               }
               this.currentPlayback = null;
             }
-            resolve22();
+            resolve23();
           }, 15e3);
         });
       }
@@ -19847,12 +20436,12 @@ var init_voice = __esm({
         const arch = process.arch;
         const isArmLinux = (arch === "arm64" || arch === "arm") && process.platform === "linux";
         mkdirSync9(voiceDir(), { recursive: true });
-        const pkgPath = join28(voiceDir(), "package.json");
+        const pkgPath = join29(voiceDir(), "package.json");
         const expectedDeps = {
           "onnxruntime-node": "^1.21.0",
           "phonemizer": "^1.2.1"
         };
-        if (existsSync22(pkgPath)) {
+        if (existsSync23(pkgPath)) {
           try {
             const existing = JSON.parse(readFileSync16(pkgPath, "utf8"));
             if (!existing.dependencies?.["phonemizer"]) {
@@ -19862,14 +20451,14 @@ var init_voice = __esm({
           } catch {
           }
         }
-        if (!existsSync22(pkgPath)) {
+        if (!existsSync23(pkgPath)) {
           writeFileSync9(pkgPath, JSON.stringify({
             name: "open-agents-voice",
             private: true,
             dependencies: expectedDeps
           }, null, 2));
         }
-        const voiceRequire = createRequire(join28(voiceDir(), "index.js"));
+        const voiceRequire = createRequire(join29(voiceDir(), "index.js"));
         try {
           this.ort = voiceRequire("onnxruntime-node");
         } catch {
@@ -19923,10 +20512,10 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
         const dir = modelDir(id);
         const onnxPath = modelOnnxPath(id);
         const configPath = modelConfigPath(id);
-        if (existsSync22(onnxPath) && existsSync22(configPath))
+        if (existsSync23(onnxPath) && existsSync23(configPath))
           return;
         mkdirSync9(dir, { recursive: true });
-        if (!existsSync22(configPath)) {
+        if (!existsSync23(configPath)) {
           renderInfo(`Downloading ${model.label} voice config...`);
           const configResp = await fetch(model.configUrl);
           if (!configResp.ok)
@@ -19934,7 +20523,7 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
           const configText = await configResp.text();
           writeFileSync9(configPath, configText);
         }
-        if (!existsSync22(onnxPath)) {
+        if (!existsSync23(onnxPath)) {
           renderInfo(`Downloading ${model.label} voice model (this may take a minute)...`);
           const onnxResp = await fetch(model.onnxUrl);
           if (!onnxResp.ok)
@@ -19970,7 +20559,7 @@ 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 (!existsSync22(onnxPath) || !existsSync22(configPath)) {
+        if (!existsSync23(onnxPath) || !existsSync23(configPath)) {
           throw new Error(`Model files not found for ${this.modelId}`);
         }
         this.config = JSON.parse(readFileSync16(configPath, "utf8"));
@@ -20474,10 +21063,10 @@ var init_stream_renderer = __esm({
 
 // packages/cli/dist/tui/edit-history.js
 import { appendFileSync, mkdirSync as mkdirSync10 } from "node:fs";
-import { join as join29 } from "node:path";
+import { join as join30 } from "node:path";
 function createEditHistoryLogger(repoRoot, sessionId) {
-  const historyDir = join29(repoRoot, ".oa", "history");
-  const logPath = join29(historyDir, "edits.jsonl");
+  const historyDir = join30(repoRoot, ".oa", "history");
+  const logPath = join30(historyDir, "edits.jsonl");
   try {
     mkdirSync10(historyDir, { recursive: true });
   } catch {
@@ -20588,8 +21177,8 @@ var init_edit_history = __esm({
 });
 
 // packages/cli/dist/tui/dream-engine.js
-import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync10, readFileSync as readFileSync17, existsSync as existsSync23, cpSync, rmSync, readdirSync as readdirSync10 } from "node:fs";
-import { join as join30, basename as basename11 } from "node:path";
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync10, readFileSync as readFileSync17, existsSync as existsSync24, cpSync, rmSync, readdirSync as readdirSync10 } from "node:fs";
+import { join as join31, basename as basename12 } from "node:path";
 import { execSync as execSync19 } from "node:child_process";
 function adaptTool(tool) {
   return {
@@ -20764,12 +21353,12 @@ var init_dream_engine = __esm({
         const content = String(args["content"] ?? "");
         if (!rawPath)
           return { success: false, output: "", error: "path is required", durationMs: Date.now() - start };
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join30(this.dreamsDir, basename11(rawPath)) : join30(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join31(this.dreamsDir, basename12(rawPath)) : join31(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 = join30(targetPath, "..");
+          const dir = join31(targetPath, "..");
           mkdirSync11(dir, { recursive: true });
           writeFileSync10(targetPath, content, "utf-8");
           return { success: true, output: `Wrote ${content.length} bytes to ${rawPath}`, durationMs: Date.now() - start };
@@ -20799,12 +21388,12 @@ 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") ? join30(this.dreamsDir, basename11(rawPath)) : join30(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join31(this.dreamsDir, basename12(rawPath)) : join31(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 (!existsSync23(targetPath)) {
+          if (!existsSync24(targetPath)) {
             return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: Date.now() - start };
           }
           let content = readFileSync17(targetPath, "utf-8");
@@ -20866,7 +21455,7 @@ var init_dream_engine = __esm({
       constructor(config, repoRoot) {
         this.config = config;
         this.repoRoot = repoRoot;
-        this.dreamsDir = join30(repoRoot, ".oa", "dreams");
+        this.dreamsDir = join31(repoRoot, ".oa", "dreams");
         this.state = {
           mode: "default",
           active: false,
@@ -20938,7 +21527,7 @@ ${result.summary}`;
             if (mode !== "default" || cycle === totalCycles) {
               renderDreamContraction(cycle);
               const cycleSummary = this.buildCycleSummary(cycle, previousFindings);
-              const summaryPath = join30(this.dreamsDir, `cycle-${cycle}-summary.md`);
+              const summaryPath = join31(this.dreamsDir, `cycle-${cycle}-summary.md`);
               writeFileSync10(summaryPath, cycleSummary, "utf-8");
             }
             if (mode === "lucid" && !this.abortController.signal.aborted) {
@@ -21061,7 +21650,7 @@ Dreams directory: ${this.dreamsDir}`);
       }
       /** Save workspace backup for lucid mode */
       saveVersionCheckpoint(cycle) {
-        const checkpointDir = join30(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
+        const checkpointDir = join31(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
         try {
           mkdirSync11(checkpointDir, { recursive: true });
           try {
@@ -21080,10 +21669,10 @@ Dreams directory: ${this.dreamsDir}`);
               encoding: "utf-8",
               timeout: 5e3
             }).trim();
-            writeFileSync10(join30(checkpointDir, "git-status.txt"), gitStatus, "utf-8");
-            writeFileSync10(join30(checkpointDir, "git-diff.patch"), gitDiff, "utf-8");
-            writeFileSync10(join30(checkpointDir, "git-hash.txt"), gitHash, "utf-8");
-            writeFileSync10(join30(checkpointDir, "checkpoint.json"), JSON.stringify({
+            writeFileSync10(join31(checkpointDir, "git-status.txt"), gitStatus, "utf-8");
+            writeFileSync10(join31(checkpointDir, "git-diff.patch"), gitDiff, "utf-8");
+            writeFileSync10(join31(checkpointDir, "git-hash.txt"), gitHash, "utf-8");
+            writeFileSync10(join31(checkpointDir, "checkpoint.json"), JSON.stringify({
               cycle,
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
               gitHash,
@@ -21091,7 +21680,7 @@ Dreams directory: ${this.dreamsDir}`);
             }, null, 2), "utf-8");
             renderInfo(`Checkpoint saved: cycle ${cycle} (${gitHash.slice(0, 8)})`);
           } catch {
-            writeFileSync10(join30(checkpointDir, "checkpoint.json"), JSON.stringify({ cycle, timestamp: (/* @__PURE__ */ new Date()).toISOString(), mode: this.state.mode }, null, 2), "utf-8");
+            writeFileSync10(join31(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) {
@@ -21149,14 +21738,14 @@ ${files.map((f) => `- [\`${f}\`](./${f})`).join("\n")}
 ---
 *Auto-generated by open-agents dream engine*
 `;
-          writeFileSync10(join30(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
+          writeFileSync10(join31(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
         } catch {
         }
       }
       /** Save dream state for resume/inspection */
       saveDreamState() {
         try {
-          writeFileSync10(join30(this.dreamsDir, "dream-state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
+          writeFileSync10(join31(this.dreamsDir, "dream-state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
         } catch {
         }
       }
@@ -22024,11 +22613,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 resolve19, join as join31, dirname as dirname10, extname as extname9 } from "node:path";
+import { resolve as resolve20, join as join32, dirname as dirname10, extname as extname9 } from "node:path";
 import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 import { readFileSync as readFileSync18, rmSync as rmSync2 } from "node:fs";
-import { existsSync as existsSync24 } from "node:fs";
+import { existsSync as existsSync25 } from "node:fs";
 function formatTimeAgo(date) {
   const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
   if (seconds < 60)
@@ -22047,12 +22636,12 @@ function getVersion() {
     const require2 = createRequire2(import.meta.url);
     const thisDir = dirname10(fileURLToPath7(import.meta.url));
     const candidates = [
-      join31(thisDir, "..", "package.json"),
-      join31(thisDir, "..", "..", "package.json"),
-      join31(thisDir, "..", "..", "..", "package.json")
+      join32(thisDir, "..", "package.json"),
+      join32(thisDir, "..", "..", "package.json"),
+      join32(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync24(pkgPath)) {
+      if (existsSync25(pkgPath)) {
         const pkg = require2(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           return pkg.version ?? "0.0.0";
@@ -22104,6 +22693,8 @@ function buildTools(repoRoot, config, contextWindowSize) {
     new WebCrawlTool(repoRoot),
     new MemoryReadTool(repoRoot),
     new MemoryWriteTool(repoRoot),
+    new MemorySearchTool(repoRoot),
+    new ExploreToolsTool(),
     // AIWG SDLC tools (auto-detect if aiwg is installed)
     new AiwgSetupTool(repoRoot),
     new AiwgHealthTool(repoRoot),
@@ -22519,7 +23110,7 @@ ${entry.fullContent}`
   } };
 }
 async function startInteractive(config, repoPath) {
-  const repoRoot = resolve19(repoPath ?? cwd());
+  const repoRoot = resolve20(repoPath ?? cwd());
   const resumeFlag = process.env.__OA_RESUMED ?? "";
   const isResumed = resumeFlag !== "";
   const hasTaskToResume = resumeFlag === "1";
@@ -22671,14 +23262,14 @@ async function startInteractive(config, repoPath) {
       renderInfo(msg);
       statusBar.endContentWrite();
     }
-  }, () => new Promise((resolve22) => {
+  }, () => new Promise((resolve23) => {
     depSudoPromptPending = true;
     depSudoResolver = (pw) => {
       depSudoPromptPending = false;
       depSudoResolver = null;
       if (pw)
         sessionSudoPassword = pw;
-      resolve22(pw);
+      resolve23(pw);
     };
     if (statusBar?.isActive) {
       statusBar.beginContentWrite();
@@ -23092,8 +23683,8 @@ async function startInteractive(config, repoPath) {
       return true;
     },
     destroyProject() {
-      const oaPath = join31(repoRoot, OA_DIR);
-      if (existsSync24(oaPath)) {
+      const oaPath = join32(repoRoot, OA_DIR);
+      if (existsSync25(oaPath)) {
         try {
           rmSync2(oaPath, { recursive: true, force: true });
           writeContent(() => renderInfo(`Removed ${OA_DIR}/ directory.`));
@@ -23325,12 +23916,12 @@ Execute this skill now. Follow the behavioral guidance above.`;
       }
     }
     const cleanPath = input.replace(/^['"]|['"]$/g, "").trim();
-    const isImage = isImagePath(cleanPath) && existsSync24(resolve19(repoRoot, cleanPath));
-    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync24(resolve19(repoRoot, cleanPath));
+    const isImage = isImagePath(cleanPath) && existsSync25(resolve20(repoRoot, cleanPath));
+    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync25(resolve20(repoRoot, cleanPath));
     if (activeTask) {
       if (isImage) {
         try {
-          const imgPath = resolve19(repoRoot, cleanPath);
+          const imgPath = resolve20(repoRoot, cleanPath);
           const imgBuffer = readFileSync18(imgPath);
           const base64 = imgBuffer.toString("base64");
           const ext = extname9(cleanPath).toLowerCase();
@@ -23344,7 +23935,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(resolve19(repoRoot, cleanPath), repoRoot);
+        const result = await engine.transcribeFile(resolve20(repoRoot, cleanPath), repoRoot);
         if (result) {
           const transcript = `[Transcription of ${cleanPath}]
 ${result.text}`;
@@ -23377,7 +23968,7 @@ ${result.text}`;
     if (isMedia && fullInput === input) {
       writeContent(() => renderInfo(`Transcribing: ${cleanPath}...`));
       const engine = getListenEngine();
-      const result = await engine.transcribeFile(resolve19(repoRoot, cleanPath), repoRoot);
+      const result = await engine.transcribeFile(resolve20(repoRoot, cleanPath), repoRoot);
       if (result) {
         fullInput = `The user has provided an audio/video file: ${cleanPath}.
 
@@ -23506,7 +24097,7 @@ ${c2.dim("(Use /quit to exit)")}
   });
 }
 async function runWithTUI(task, config, repoPath) {
-  const repoRoot = resolve19(repoPath ?? cwd());
+  const repoRoot = resolve20(repoPath ?? cwd());
   const needsSetup = isFirstRun() || !await isModelAvailable(config);
   if (needsSetup && config.backendType === "ollama") {
     const setupModel = await runSetupWizard(config);
@@ -23609,9 +24200,9 @@ var init_run = __esm({
 // packages/indexer/dist/codebase-indexer.js
 import { glob } from "glob";
 import ignore from "ignore";
-import { readFile as readFile10, stat as stat4 } from "node:fs/promises";
+import { readFile as readFile11, stat as stat4 } from "node:fs/promises";
 import { createHash } from "node:crypto";
-import { join as join32, relative as relative3, extname as extname10, basename as basename12 } from "node:path";
+import { join as join33, relative as relative3, extname as extname10, basename as basename13 } from "node:path";
 var DEFAULT_EXCLUDE, LANGUAGE_MAP, CodebaseIndexer;
 var init_codebase_indexer = __esm({
   "packages/indexer/dist/codebase-indexer.js"() {
@@ -23655,7 +24246,7 @@ var init_codebase_indexer = __esm({
         const ig = ignore.default();
         if (this.config.respectGitignore) {
           try {
-            const gitignoreContent = await readFile10(join32(this.config.rootDir, ".gitignore"), "utf-8");
+            const gitignoreContent = await readFile11(join33(this.config.rootDir, ".gitignore"), "utf-8");
             ig.add(gitignoreContent);
           } catch {
           }
@@ -23670,12 +24261,12 @@ var init_codebase_indexer = __esm({
         for (const relativePath of files) {
           if (ig.ignores(relativePath))
             continue;
-          const fullPath = join32(this.config.rootDir, relativePath);
+          const fullPath = join33(this.config.rootDir, relativePath);
           try {
             const fileStat = await stat4(fullPath);
             if (fileStat.size > this.config.maxFileSize)
               continue;
-            const content = await readFile10(fullPath);
+            const content = await readFile11(fullPath);
             const hash = createHash("sha256").update(content).digest("hex");
             const ext = extname10(relativePath);
             indexed.push({
@@ -23693,7 +24284,7 @@ var init_codebase_indexer = __esm({
       }
       buildTree(files) {
         const root = {
-          name: basename12(this.config.rootDir),
+          name: basename13(this.config.rootDir),
           path: this.config.rootDir,
           type: "directory",
           children: []
@@ -23716,7 +24307,7 @@ var init_codebase_indexer = __esm({
               if (!child) {
                 child = {
                   name: part,
-                  path: join32(current.path, part),
+                  path: join33(current.path, part),
                   type: "directory",
                   children: []
                 };
@@ -23772,6 +24363,13 @@ var init_embeddings = __esm({
   }
 });
 
+// packages/indexer/dist/ollamaEmbeddings.js
+var init_ollamaEmbeddings = __esm({
+  "packages/indexer/dist/ollamaEmbeddings.js"() {
+    "use strict";
+  }
+});
+
 // packages/indexer/dist/index.js
 var init_dist8 = __esm({
   "packages/indexer/dist/index.js"() {
@@ -23782,6 +24380,7 @@ var init_dist8 = __esm({
     init_graphBuilder();
     init_fileSummarizer();
     init_embeddings();
+    init_ollamaEmbeddings();
   }
 });
 
@@ -23790,14 +24389,14 @@ var index_repo_exports = {};
 __export(index_repo_exports, {
   indexRepoCommand: () => indexRepoCommand
 });
-import { resolve as resolve20 } from "node:path";
-import { existsSync as existsSync25, statSync as statSync10 } from "node:fs";
+import { resolve as resolve21 } from "node:path";
+import { existsSync as existsSync26, statSync as statSync10 } from "node:fs";
 import { cwd as cwd2 } from "node:process";
 async function indexRepoCommand(opts, _config) {
-  const repoRoot = resolve20(opts.repoPath ?? cwd2());
+  const repoRoot = resolve21(opts.repoPath ?? cwd2());
   printHeader("Index Repository");
   printInfo(`Indexing: ${repoRoot}`);
-  if (!existsSync25(repoRoot)) {
+  if (!existsSync26(repoRoot)) {
     printError(`Path does not exist: ${repoRoot}`);
     process.exit(1);
   }
@@ -24043,8 +24642,8 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { join as join33, resolve as resolve21 } from "node:path";
-import { homedir as homedir12 } from "node:os";
+import { join as join34, resolve as resolve22 } from "node:path";
+import { homedir as homedir13 } from "node:os";
 import { cwd as cwd3 } from "node:process";
 function coerceForSettings(key, value) {
   if (INT_KEYS.has(key))
@@ -24064,7 +24663,7 @@ async function configCommand(opts, config) {
   return handleShow(opts, config);
 }
 function handleShow(opts, config) {
-  const repoRoot = resolve21(opts.repoPath ?? cwd3());
+  const repoRoot = resolve22(opts.repoPath ?? cwd3());
   printHeader("Configuration");
   printSection("Active Settings (merged)");
   printKeyValue("backendUrl", config.backendUrl, 2);
@@ -24096,7 +24695,7 @@ function handleShow(opts, config) {
     }
   }
   printSection("Config File");
-  printInfo(`~/.open-agents/config.json (${join33(homedir12(), ".open-agents", "config.json")})`);
+  printInfo(`~/.open-agents/config.json (${join34(homedir13(), ".open-agents", "config.json")})`);
   printSection("Priority Chain");
   printInfo("  1. CLI flags (--model, --backend-url, etc.)");
   printInfo("  2. Project .oa/settings.json (--local)");
@@ -24129,13 +24728,13 @@ function handleSet(opts, _config) {
     process.exit(1);
   }
   if (opts.local) {
-    const repoRoot = resolve21(opts.repoPath ?? cwd3());
+    const repoRoot = resolve22(opts.repoPath ?? cwd3());
     try {
       initOaDirectory(repoRoot);
       const coerced = coerceForSettings(key, value);
       saveProjectSettings(repoRoot, { [key]: coerced });
       printSuccess(`Project override set: ${key} = ${value}`);
-      printInfo(`Saved to ${join33(repoRoot, ".oa", "settings.json")}`);
+      printInfo(`Saved to ${join34(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)}`);
@@ -24287,7 +24886,7 @@ async function serveVllm(opts, config) {
   await runVllmServer(args, opts.verbose ?? false);
 }
 async function runVllmServer(args, verbose) {
-  return new Promise((resolve22, reject) => {
+  return new Promise((resolve23, reject) => {
     const child = spawn9("python", args, {
       stdio: verbose ? "inherit" : ["ignore", "pipe", "pipe"],
       env: { ...process.env }
@@ -24322,10 +24921,10 @@ async function runVllmServer(args, verbose) {
     child.once("exit", (code, signal) => {
       if (signal) {
         printInfo(`vLLM server stopped by signal ${signal}`);
-        resolve22();
+        resolve23();
       } else if (code === 0) {
         printSuccess("vLLM server exited cleanly");
-        resolve22();
+        resolve23();
       } else {
         printError(`vLLM server exited with code ${code}`);
         reject(new Error(`vLLM exited with code ${code}`));
@@ -24354,7 +24953,7 @@ __export(eval_exports, {
 });
 import { tmpdir as tmpdir7 } from "node:os";
 import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync11 } from "node:fs";
-import { join as join34 } from "node:path";
+import { join as join35 } from "node:path";
 async function evalCommand(opts, config) {
   const suiteName = opts.suite ?? "basic";
   const suite = SUITES[suiteName];
@@ -24475,9 +25074,9 @@ async function evalCommand(opts, config) {
   process.exit(failed > 0 ? 1 : 0);
 }
 function createTempEvalRepo() {
-  const dir = join34(tmpdir7(), `open-agents-eval-${Date.now()}`);
+  const dir = join35(tmpdir7(), `open-agents-eval-${Date.now()}`);
   mkdirSync12(dir, { recursive: true });
-  writeFileSync11(join34(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
+  writeFileSync11(join35(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
   return dir;
 }
 var BASIC_SUITE, FULL_SUITE, SUITES;
@@ -24537,7 +25136,7 @@ init_updater();
 import { parseArgs as nodeParseArgs2 } from "node:util";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
-import { dirname as dirname11, join as join35 } from "node:path";
+import { dirname as dirname11, join as join36 } from "node:path";
 
 // packages/cli/dist/cli.js
 import { createInterface } from "node:readline";
@@ -24644,7 +25243,7 @@ init_output();
 function getVersion2() {
   try {
     const require2 = createRequire3(import.meta.url);
-    const pkgPath = join35(dirname11(fileURLToPath8(import.meta.url)), "..", "package.json");
+    const pkgPath = join36(dirname11(fileURLToPath8(import.meta.url)), "..", "package.json");
     const pkg = require2(pkgPath);
     return pkg.version;
   } catch {