open-agents-ai 0.13.5 → 0.14.1

package/dist/index.js

@@ -1170,7 +1170,7 @@ var init_shell = __esm({
         const timeout = args["timeout"] ?? this.defaultTimeout;
         const stdinInput = args["stdin"];
         const start = performance.now();
-        return new Promise((resolve15) => {
+        return new Promise((resolve16) => {
           const child = spawn("bash", ["-c", command], {
             cwd: this.workingDir,
             env: {
@@ -1223,7 +1223,7 @@ var init_shell = __esm({
               const combined = stdout + stderr;
               const looksInteractive = /\? .+[›>]|y\/n|yes\/no|\(Y\/n\)|\[y\/N\]/i.test(combined);
               const hint = looksInteractive ? " The command appears to be waiting for interactive input. Use non-interactive flags (e.g., --yes, --no-input) or provide input via the stdin parameter." : "";
-              resolve15({
+              resolve16({
                 success: false,
                 output: stdout,
                 error: `Command timed out after ${timeout}ms.${hint}`,
@@ -1232,7 +1232,7 @@ var init_shell = __esm({
               return;
             }
             const success = code === 0;
-            resolve15({
+            resolve16({
               success,
               output: stdout + (stderr && success ? `
 STDERR:
@@ -1243,7 +1243,7 @@ ${stderr}` : ""),
           });
           child.on("error", (err) => {
             clearTimeout(timer);
-            resolve15({
+            resolve16({
               success: false,
               output: stdout,
               error: err.message,
@@ -4031,8 +4031,8 @@ function deleteCustomToolDefinition(name, scope, repoRoot) {
   const dir = scope === "project" && repoRoot ? projectToolsDir(repoRoot) : globalToolsDir();
   const filePath = join11(dir, `${name}.json`);
   if (existsSync8(filePath)) {
-    const { unlinkSync: unlinkSync3 } = __require("node:fs");
-    unlinkSync3(filePath);
+    const { unlinkSync: unlinkSync4 } = __require("node:fs");
+    unlinkSync4(filePath);
     return true;
   }
   return false;
@@ -4150,7 +4150,7 @@ var init_custom_tool = __esm({
       }
       /** Execute a single shell command and return output */
       runCommand(command) {
-        return new Promise((resolve15) => {
+        return new Promise((resolve16) => {
           const child = spawn3("bash", ["-c", command], {
             cwd: this.workingDir,
             env: { ...process.env, CI: "true", NO_COLOR: "1" },
@@ -4175,11 +4175,11 @@ var init_custom_tool = __esm({
               child.kill("SIGTERM");
             } catch {
             }
-            resolve15({ success: false, output: stdout, error: "Command timed out after 60s" });
+            resolve16({ success: false, output: stdout, error: "Command timed out after 60s" });
           }, 6e4);
           child.on("close", (code) => {
             clearTimeout(timer);
-            resolve15({
+            resolve16({
               success: code === 0,
               output: stdout + (stderr && code === 0 ? `
 STDERR:
@@ -4189,7 +4189,7 @@ ${stderr}` : ""),
           });
           child.on("error", (err) => {
             clearTimeout(timer);
-            resolve15({ success: false, output: stdout, error: err.message });
+            resolve16({ success: false, output: stdout, error: err.message });
           });
         });
       }
@@ -4840,6 +4840,300 @@ ${content}`,
   }
 });
 
+// packages/execution/dist/tools/transcribe-tool.js
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4, readFileSync as readFileSync9, unlinkSync } from "node:fs";
+import { join as join13, basename as basename3, extname as extname3, resolve as resolve12 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { execSync as execSync9, spawn as spawn4 } from "node:child_process";
+function isTranscribable(path) {
+  const ext = extname3(path).toLowerCase();
+  return AUDIO_EXTS.has(ext) || VIDEO_EXTS.has(ext);
+}
+async function loadTranscribeCli() {
+  if (_tcChecked)
+    return _tcModule;
+  _tcChecked = true;
+  try {
+    const globalRoot = execSync9("npm root -g", {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const tcPath = join13(globalRoot, "transcribe-cli");
+    if (existsSync10(join13(tcPath, "dist", "index.js"))) {
+      const { createRequire: createRequire4 } = await import("node:module");
+      const req = createRequire4(import.meta.url);
+      _tcModule = req(join13(tcPath, "dist", "index.js"));
+      return _tcModule;
+    }
+  } catch {
+  }
+  const nvmBase = join13(homedir5(), ".nvm", "versions", "node");
+  if (existsSync10(nvmBase)) {
+    try {
+      const { readdirSync: readdirSync9 } = await import("node:fs");
+      for (const ver of readdirSync9(nvmBase)) {
+        const tcPath = join13(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
+        if (existsSync10(join13(tcPath, "dist", "index.js"))) {
+          const { createRequire: createRequire4 } = await import("node:module");
+          const req = createRequire4(import.meta.url);
+          _tcModule = req(join13(tcPath, "dist", "index.js"));
+          return _tcModule;
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function formatTime(seconds) {
+  const m = Math.floor(seconds / 60);
+  const s = Math.floor(seconds % 60);
+  return `${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
+}
+var AUDIO_EXTS, VIDEO_EXTS, _tcModule, _tcChecked, TranscribeFileTool, TranscribeUrlTool;
+var init_transcribe_tool = __esm({
+  "packages/execution/dist/tools/transcribe-tool.js"() {
+    "use strict";
+    AUDIO_EXTS = /* @__PURE__ */ new Set([
+      ".mp3",
+      ".wav",
+      ".flac",
+      ".aac",
+      ".m4a",
+      ".ogg",
+      ".wma",
+      ".opus"
+    ]);
+    VIDEO_EXTS = /* @__PURE__ */ new Set([
+      ".mp4",
+      ".mkv",
+      ".avi",
+      ".mov",
+      ".webm",
+      ".flv",
+      ".wmv",
+      ".m4v",
+      ".ts"
+    ]);
+    _tcModule = null;
+    _tcChecked = false;
+    TranscribeFileTool = class {
+      name = "transcribe_file";
+      description = "Transcribe a local audio or video file to text using Whisper (faster-whisper). Supports MP3, WAV, FLAC, AAC, M4A, OGG, MP4, MKV, AVI, MOV, WebM. Returns the full transcription text with optional speaker diarization. Transcription is 100% local \u2014 no API keys needed.";
+      parameters = {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Path to the audio or video file to transcribe"
+          },
+          model: {
+            type: "string",
+            description: "Whisper model size: tiny, base, small, medium, large-v3 (default: base)",
+            enum: ["tiny", "base", "small", "medium", "large-v3"]
+          },
+          diarize: {
+            type: "boolean",
+            description: "Enable speaker diarization (identify who said what). Default: false"
+          }
+        },
+        required: ["path"]
+      };
+      workingDir;
+      constructor(workingDir) {
+        this.workingDir = workingDir;
+      }
+      async execute(args) {
+        const start = performance.now();
+        const filePath = resolve12(this.workingDir, String(args["path"] ?? ""));
+        const model = String(args["model"] ?? "base");
+        const diarize = Boolean(args["diarize"] ?? false);
+        if (!existsSync10(filePath)) {
+          return {
+            success: false,
+            output: "",
+            error: `File not found: ${filePath}`,
+            durationMs: performance.now() - start
+          };
+        }
+        if (!isTranscribable(filePath)) {
+          return {
+            success: false,
+            output: "",
+            error: `Unsupported file type: ${extname3(filePath)}. Supported: ${[...AUDIO_EXTS, ...VIDEO_EXTS].join(", ")}`,
+            durationMs: performance.now() - start
+          };
+        }
+        const tc = await loadTranscribeCli();
+        if (!tc) {
+          return this.execViaCli(filePath, model, diarize, start);
+        }
+        try {
+          const result = await tc.transcribe(filePath, {
+            model,
+            format: "json",
+            diarize,
+            wordTimestamps: false
+          });
+          const transcriptDir = join13(this.workingDir, ".oa", "transcripts");
+          mkdirSync4(transcriptDir, { recursive: true });
+          const outFile = join13(transcriptDir, `${basename3(filePath)}.txt`);
+          writeFileSync4(outFile, result.text, "utf-8");
+          const lines = [
+            `Transcription of: ${basename3(filePath)}`,
+            `Model: ${model} | Language: ${result.language} | Duration: ${result.duration ? `${result.duration.toFixed(1)}s` : "unknown"}`,
+            `Words: ${result.wordCount} | Saved to: ${outFile}`,
+            ""
+          ];
+          if (result.speakers.length > 1) {
+            lines.push(`Speakers: ${result.speakers.join(", ")}`);
+            lines.push("");
+          }
+          if (diarize && result.segments.length > 0) {
+            for (const seg of result.segments) {
+              const ts = `[${formatTime(seg.start)} \u2192 ${formatTime(seg.end)}]`;
+              const speaker = seg.speaker ? `${seg.speaker}: ` : "";
+              lines.push(`${ts} ${speaker}${seg.text}`);
+            }
+          } else {
+            lines.push(result.text);
+          }
+          return {
+            success: true,
+            output: lines.join("\n"),
+            durationMs: performance.now() - start
+          };
+        } catch (err) {
+          return {
+            success: false,
+            output: "",
+            error: `Transcription failed: ${err instanceof Error ? err.message : String(err)}`,
+            durationMs: performance.now() - start
+          };
+        }
+      }
+      /** Fallback: invoke transcribe-cli as a subprocess. */
+      async execViaCli(filePath, model, diarize, start) {
+        try {
+          const args = [filePath, "-m", model, "-f", "txt"];
+          if (diarize)
+            args.push("--diarize");
+          const output = execSync9(`transcribe-cli ${args.join(" ")}`, {
+            encoding: "utf-8",
+            timeout: 3e5,
+            // 5 min max
+            cwd: this.workingDir,
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+          return {
+            success: true,
+            output: output.trim() || "(empty transcription)",
+            durationMs: performance.now() - start
+          };
+        } catch (err) {
+          const stderr = err.stderr || "";
+          return {
+            success: false,
+            output: err.stdout || "",
+            error: `transcribe-cli failed: ${stderr || err.message}`,
+            durationMs: performance.now() - start
+          };
+        }
+      }
+    };
+    TranscribeUrlTool = class {
+      name = "transcribe_url";
+      description = "Download an audio or video file from a URL and transcribe it to text. Supports direct links to MP3, WAV, MP4, and other media files. The file is downloaded to a temp location, transcribed locally, then cleaned up.";
+      parameters = {
+        type: "object",
+        properties: {
+          url: {
+            type: "string",
+            description: "URL of the audio or video file to download and transcribe"
+          },
+          model: {
+            type: "string",
+            description: "Whisper model size: tiny, base, small, medium, large-v3 (default: base)",
+            enum: ["tiny", "base", "small", "medium", "large-v3"]
+          }
+        },
+        required: ["url"]
+      };
+      workingDir;
+      constructor(workingDir) {
+        this.workingDir = workingDir;
+      }
+      async execute(args) {
+        const start = performance.now();
+        const url = String(args["url"] ?? "");
+        const model = String(args["model"] ?? "base");
+        if (!url) {
+          return {
+            success: false,
+            output: "",
+            error: "URL is required.",
+            durationMs: performance.now() - start
+          };
+        }
+        const tmpDir = join13(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 = join13(tmpDir, `download-${Date.now()}${ext}`);
+        try {
+          try {
+            execSync9(`curl -sL -o "${tmpFile}" "${url}"`, {
+              timeout: 12e4,
+              stdio: ["pipe", "pipe", "pipe"]
+            });
+          } catch {
+            execSync9(`wget -q -O "${tmpFile}" "${url}"`, {
+              timeout: 12e4,
+              stdio: ["pipe", "pipe", "pipe"]
+            });
+          }
+          if (!existsSync10(tmpFile)) {
+            return {
+              success: false,
+              output: "",
+              error: "Download failed \u2014 file not created.",
+              durationMs: performance.now() - start
+            };
+          }
+          const fileTool = new TranscribeFileTool(this.workingDir);
+          const result = await fileTool.execute({ path: tmpFile, model });
+          try {
+            unlinkSync(tmpFile);
+          } catch {
+          }
+          return {
+            success: result.success,
+            output: `Source: ${url}
+${result.output}`,
+            error: result.error,
+            durationMs: performance.now() - start
+          };
+        } catch (err) {
+          try {
+            unlinkSync(tmpFile);
+          } catch {
+          }
+          return {
+            success: false,
+            output: "",
+            error: `Failed to download/transcribe: ${err instanceof Error ? err.message : String(err)}`,
+            durationMs: performance.now() - start
+          };
+        }
+      }
+    };
+  }
+});
+
 // packages/execution/dist/shellRunner.js
 var init_shellRunner = __esm({
   "packages/execution/dist/shellRunner.js"() {
@@ -4943,6 +5237,7 @@ var init_dist2 = __esm({
     init_custom_tool();
     init_tool_creator();
     init_skill_tools();
+    init_transcribe_tool();
     init_shellRunner();
     init_gitWorktree();
     init_patchApplier();
@@ -6074,7 +6369,7 @@ var init_code_retriever = __esm({
 import { execFile as execFile4 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
 import { readFile as readFile7, readdir, stat } from "node:fs/promises";
-import { join as join13, extname as extname3 } from "node:path";
+import { join as join14, extname as extname4 } 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;
@@ -6216,11 +6511,11 @@ async function walkForFiles(rootDir, dir, excludeGlobs, results) {
       continue;
     if (excludeGlobs.some((g) => entry.name === g || matchesGlob(entry.name, g)))
       continue;
-    const absPath = join13(dir, entry.name);
+    const absPath = join14(dir, entry.name);
     if (entry.isDirectory()) {
       await walkForFiles(rootDir, absPath, excludeGlobs, results);
     } else if (entry.isFile()) {
-      const ext = extname3(entry.name);
+      const ext = extname4(entry.name);
       if (!ALL_CODE_EXTS.has(ext))
         continue;
       const relativePath = absPath.startsWith(rootDir) ? absPath.slice(rootDir.length).replace(/^\//, "") : absPath;
@@ -6391,7 +6686,7 @@ var init_graphExpand = __esm({
 
 // packages/retrieval/dist/snippetPacker.js
 import { readFile as readFile8 } from "node:fs/promises";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 async function packSnippets(requests, opts = {}) {
   const maxTokens = opts.maxTokens ?? DEFAULT_MAX_TOKENS;
   const contextLines = opts.contextLines ?? DEFAULT_CONTEXT_LINES;
@@ -6417,7 +6712,7 @@ async function packSnippets(requests, opts = {}) {
   return { packed, dropped, totalTokens };
 }
 async function extractSnippet(req, repoRoot, contextLines = DEFAULT_CONTEXT_LINES) {
-  const absPath = req.filePath.startsWith("/") ? req.filePath : join14(repoRoot, req.filePath);
+  const absPath = req.filePath.startsWith("/") ? req.filePath : join15(repoRoot, req.filePath);
   let content;
   try {
     content = await readFile8(absPath, "utf-8");
@@ -8726,6 +9021,425 @@ var init_dist5 = __esm({
   }
 });
 
+// packages/cli/dist/tui/listen.js
+import { spawn as spawn5, execSync as execSync10 } from "node:child_process";
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join16 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+import { EventEmitter } from "node:events";
+function isAudioPath(path) {
+  const ext = path.toLowerCase().split(".").pop();
+  return ext ? AUDIO_EXTENSIONS.has(`.${ext}`) : false;
+}
+function isVideoPath(path) {
+  const ext = path.toLowerCase().split(".").pop();
+  return ext ? VIDEO_EXTENSIONS.has(`.${ext}`) : false;
+}
+function isTranscribablePath(path) {
+  return isAudioPath(path) || isVideoPath(path);
+}
+function findMicCaptureCommand() {
+  const platform3 = process.platform;
+  if (platform3 === "linux") {
+    try {
+      execSync10("which arecord", { stdio: "pipe" });
+      return {
+        cmd: "arecord",
+        args: ["-f", "S16_LE", "-r", "16000", "-c", "1", "-t", "raw", "-q", "-"]
+      };
+    } catch {
+    }
+  }
+  if (platform3 === "darwin") {
+    try {
+      execSync10("which sox", { stdio: "pipe" });
+      return {
+        cmd: "sox",
+        args: ["-d", "-t", "raw", "-r", "16000", "-c", "1", "-b", "16", "-e", "signed-integer", "-"]
+      };
+    } catch {
+    }
+  }
+  try {
+    execSync10("which ffmpeg", { stdio: "pipe" });
+    if (platform3 === "linux") {
+      return {
+        cmd: "ffmpeg",
+        args: [
+          "-f",
+          "pulse",
+          "-i",
+          "default",
+          "-ar",
+          "16000",
+          "-ac",
+          "1",
+          "-f",
+          "s16le",
+          "-loglevel",
+          "quiet",
+          "pipe:1"
+        ]
+      };
+    } else if (platform3 === "darwin") {
+      return {
+        cmd: "ffmpeg",
+        args: [
+          "-f",
+          "avfoundation",
+          "-i",
+          ":0",
+          "-ar",
+          "16000",
+          "-ac",
+          "1",
+          "-f",
+          "s16le",
+          "-loglevel",
+          "quiet",
+          "pipe:1"
+        ]
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+function getListenEngine(config) {
+  if (!_engine) {
+    _engine = new ListenEngine(config);
+  }
+  return _engine;
+}
+var AUDIO_EXTENSIONS, VIDEO_EXTENSIONS, ListenEngine, _engine;
+var init_listen = __esm({
+  "packages/cli/dist/tui/listen.js"() {
+    "use strict";
+    AUDIO_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".mp3",
+      ".wav",
+      ".flac",
+      ".aac",
+      ".m4a",
+      ".ogg",
+      ".wma",
+      ".opus"
+    ]);
+    VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".mp4",
+      ".mkv",
+      ".avi",
+      ".mov",
+      ".webm",
+      ".flv",
+      ".wmv",
+      ".m4v",
+      ".ts"
+    ]);
+    ListenEngine = class extends EventEmitter {
+      config;
+      micProcess = null;
+      liveTranscriber = null;
+      // TranscribeLive from transcribe-cli
+      active = false;
+      silenceTimer = null;
+      countdownInterval = null;
+      lastTranscriptTime = 0;
+      pendingText = "";
+      blinkTimer = null;
+      blinkState = false;
+      transcribeCliAvailable = null;
+      constructor(config) {
+        super();
+        this.config = {
+          model: config?.model ?? "base",
+          mode: config?.mode ?? "confirm",
+          silenceTimeoutMs: config?.silenceTimeoutMs ?? 3e3
+        };
+      }
+      get isActive() {
+        return this.active;
+      }
+      get isBlinking() {
+        return this.active && this.blinkState;
+      }
+      get currentModel() {
+        return this.config.model;
+      }
+      get currentMode() {
+        return this.config.mode;
+      }
+      get pendingTranscript() {
+        return this.pendingText;
+      }
+      setModel(model) {
+        this.config.model = model;
+      }
+      setMode(mode) {
+        this.config.mode = mode;
+      }
+      /** Check if transcribe-cli is available. */
+      async isAvailable() {
+        if (this.transcribeCliAvailable !== null)
+          return this.transcribeCliAvailable;
+        try {
+          const mod = await this.loadTranscribeCli();
+          this.transcribeCliAvailable = mod !== null;
+        } catch {
+          this.transcribeCliAvailable = false;
+        }
+        if (!this.transcribeCliAvailable) {
+          try {
+            execSync10("which transcribe-cli", { stdio: "pipe" });
+            this.transcribeCliAvailable = true;
+          } catch {
+            this.transcribeCliAvailable = false;
+          }
+        }
+        return this.transcribeCliAvailable;
+      }
+      /** Load transcribe-cli dynamically (it may not be installed). */
+      async loadTranscribeCli() {
+        try {
+          const globalRoot = execSync10("npm root -g", {
+            encoding: "utf-8",
+            timeout: 5e3,
+            stdio: ["pipe", "pipe", "pipe"]
+          }).trim();
+          const tcPath = join16(globalRoot, "transcribe-cli");
+          if (existsSync11(join16(tcPath, "dist", "index.js"))) {
+            const { createRequire: createRequire4 } = await import("node:module");
+            const req = createRequire4(import.meta.url);
+            return req(join16(tcPath, "dist", "index.js"));
+          }
+        } catch {
+        }
+        const nvmBase = join16(homedir6(), ".nvm", "versions", "node");
+        if (existsSync11(nvmBase)) {
+          try {
+            const { readdirSync: readdirSync9 } = await import("node:fs");
+            for (const ver of readdirSync9(nvmBase)) {
+              const tcPath = join16(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
+              if (existsSync11(join16(tcPath, "dist", "index.js"))) {
+                const { createRequire: createRequire4 } = await import("node:module");
+                const req = createRequire4(import.meta.url);
+                return req(join16(tcPath, "dist", "index.js"));
+              }
+            }
+          } catch {
+          }
+        }
+        return null;
+      }
+      /**
+       * Start listening — captures microphone audio and feeds to TranscribeLive.
+       */
+      async start() {
+        if (this.active)
+          return "Already listening.";
+        const micCmd = findMicCaptureCommand();
+        if (!micCmd) {
+          return "No microphone capture tool found. Install arecord (Linux), sox (macOS), or ffmpeg.";
+        }
+        let tc = await this.loadTranscribeCli();
+        if (!tc) {
+          this.emit("info", "transcribe-cli not found. Installing globally...");
+          try {
+            execSync10("npm i -g transcribe-cli", { stdio: "pipe", timeout: 12e4 });
+            this.transcribeCliAvailable = null;
+            tc = await this.loadTranscribeCli();
+          } catch {
+          }
+          if (!tc) {
+            return "Failed to install transcribe-cli. Try manually: npm i -g transcribe-cli";
+          }
+        }
+        const TranscribeLive = tc.TranscribeLive;
+        this.liveTranscriber = new TranscribeLive({
+          model: this.config.model,
+          sampleRate: 16e3,
+          channels: 1,
+          sampleWidth: 2,
+          chunkDuration: 3
+          // 3s chunks for responsive transcription
+        });
+        this.liveTranscriber.on("transcript", (evt) => {
+          if (!evt.text.trim())
+            return;
+          this.lastTranscriptTime = Date.now();
+          this.pendingText = evt.text.trim();
+          this.emit("transcript", this.pendingText, evt.isFinal);
+          if (this.config.mode === "auto") {
+            this.resetSilenceTimer();
+          }
+        });
+        this.liveTranscriber.on("error", (err) => {
+          this.emit("error", err);
+        });
+        await new Promise((resolve16, reject) => {
+          const timeout = setTimeout(() => reject(new Error("Model load timeout (60s)")), 6e4);
+          this.liveTranscriber.on("ready", () => {
+            clearTimeout(timeout);
+            resolve16();
+          });
+          this.liveTranscriber.on("error", (err) => {
+            clearTimeout(timeout);
+            reject(err);
+          });
+        });
+        this.micProcess = spawn5(micCmd.cmd, micCmd.args, {
+          stdio: ["pipe", "pipe", "pipe"],
+          env: { ...process.env }
+        });
+        this.micProcess.stdout?.on("data", (chunk) => {
+          if (this.active && this.liveTranscriber) {
+            this.liveTranscriber.write(chunk);
+          }
+        });
+        this.micProcess.stderr?.on("data", () => {
+        });
+        this.micProcess.on("error", (err) => {
+          this.emit("error", new Error(`Mic capture failed: ${err.message}`));
+          this.stop();
+        });
+        this.micProcess.on("close", () => {
+          if (this.active) {
+            this.stop();
+          }
+        });
+        this.active = true;
+        this.blinkState = true;
+        this.blinkTimer = setInterval(() => {
+          this.blinkState = !this.blinkState;
+          this.emit("recording", this.blinkState);
+        }, 500);
+        this.lastTranscriptTime = Date.now();
+        this.emit("started");
+        this.emit("recording", true);
+        const modeDesc = this.config.mode === "auto" ? `auto (${this.config.silenceTimeoutMs / 1e3}s timeout)` : "confirm (press Enter to submit)";
+        return `Listening with ${this.config.model} model (${modeDesc})`;
+      }
+      /**
+       * Stop listening — cleanup mic, transcriber, timers.
+       */
+      async stop() {
+        if (!this.active)
+          return "Not listening.";
+        this.active = false;
+        this.blinkState = false;
+        if (this.blinkTimer) {
+          clearInterval(this.blinkTimer);
+          this.blinkTimer = null;
+        }
+        if (this.silenceTimer) {
+          clearTimeout(this.silenceTimer);
+          this.silenceTimer = null;
+        }
+        if (this.countdownInterval) {
+          clearInterval(this.countdownInterval);
+          this.countdownInterval = null;
+        }
+        if (this.micProcess) {
+          try {
+            this.micProcess.kill("SIGTERM");
+          } catch {
+          }
+          this.micProcess = null;
+        }
+        if (this.liveTranscriber) {
+          try {
+            this.liveTranscriber.stop();
+          } catch {
+          }
+          this.liveTranscriber = null;
+        }
+        this.emit("recording", false);
+        this.emit("stopped");
+        const result = this.pendingText;
+        this.pendingText = "";
+        return result || "Stopped listening.";
+      }
+      /**
+       * Accept the current pending transcript (for confirm mode).
+       * Returns the text to inject into the input line.
+       */
+      acceptTranscript() {
+        const text = this.pendingText;
+        this.pendingText = "";
+        return text;
+      }
+      /**
+       * Transcribe a file (audio or video) using transcribe-cli.
+       * Returns the transcription result.
+       */
+      async transcribeFile(filePath, outputDir) {
+        let tc = await this.loadTranscribeCli();
+        if (!tc) {
+          try {
+            execSync10("npm i -g transcribe-cli", { stdio: "pipe", timeout: 12e4 });
+            this.transcribeCliAvailable = null;
+            tc = await this.loadTranscribeCli();
+          } catch {
+          }
+        }
+        if (!tc)
+          return null;
+        try {
+          const result = await tc.transcribe(filePath, {
+            model: this.config.model,
+            format: "json",
+            diarize: false,
+            wordTimestamps: false
+          });
+          if (outputDir) {
+            const { basename: basename8 } = await import("node:path");
+            const transcriptDir = join16(outputDir, ".oa", "transcripts");
+            mkdirSync5(transcriptDir, { recursive: true });
+            const outFile = join16(transcriptDir, `${basename8(filePath)}.txt`);
+            writeFileSync5(outFile, result.text, "utf-8");
+          }
+          return {
+            text: result.text,
+            duration: result.duration,
+            speakers: result.speakers,
+            segments: result.segments
+          };
+        } catch (err) {
+          this.emit("error", err instanceof Error ? err : new Error(String(err)));
+          return null;
+        }
+      }
+      // -------------------------------------------------------------------------
+      // Auto-mode silence detection
+      // -------------------------------------------------------------------------
+      resetSilenceTimer() {
+        if (this.silenceTimer)
+          clearTimeout(this.silenceTimer);
+        if (this.countdownInterval)
+          clearInterval(this.countdownInterval);
+        const timeoutMs = this.config.silenceTimeoutMs;
+        const startTime = Date.now();
+        this.countdownInterval = setInterval(() => {
+          const elapsed = Date.now() - startTime;
+          const remaining = Math.max(0, Math.ceil((timeoutMs - elapsed) / 1e3));
+          this.emit("countdown", remaining);
+          if (remaining <= 0 && this.countdownInterval) {
+            clearInterval(this.countdownInterval);
+            this.countdownInterval = null;
+          }
+        }, 1e3);
+        this.silenceTimer = setTimeout(() => {
+          if (this.active && this.pendingText) {
+            this.emit("countdown", 0);
+            this.emit("transcript", this.pendingText, true);
+          }
+        }, timeoutMs);
+      }
+    };
+    _engine = null;
+  }
+});
+
 // packages/cli/dist/tui/model-picker.js
 async function fetchOllamaModels(baseUrl) {
   const url = `${baseUrl.replace(/\/$/, "")}/api/tags`;
@@ -9016,10 +9730,16 @@ function renderSlashHelp() {
     ["/dream deep", "Deep dream \u2014 multi-cycle exploration with sleep architecture"],
     ["/dream lucid", "Lucid dream \u2014 implements proposals, tests, evaluates in cycles"],
     ["/dream stop", "Wake up \u2014 stop dreaming"],
+    ["/listen", "Toggle live microphone transcription (Whisper)"],
+    ["/listen <model>", "Set model: tiny, base, small, medium, large"],
+    ["/listen confirm", "Require Enter to submit transcription"],
+    ["/listen auto", "Auto-submit after 3s silence (blinking \u25CF indicator)"],
+    ["/listen stop", "Stop listening"],
     ["/bruteforce", "Toggle brute-force mode (auto re-engage on turn limit)"],
     ["/tools", "List agent-created custom tools"],
     ["/skills", "List available AIWG skills"],
     ["/skills <keyword>", "Filter skills by name or trigger"],
+    ["/<skill-name> [args]", "Invoke an AIWG skill directly"],
     ["/verbose", "Toggle verbose mode"],
     ["/clear", "Clear the screen"],
     ["/help", "Show this help"],
@@ -9149,6 +9869,10 @@ function formatToolArgs(toolName, args) {
       return String(args["region"] ?? "full screen");
     case "ocr":
       return `${args["path"] ?? ""}${args["region"] ? ` (${args["region"]})` : ""}`;
+    case "transcribe_file":
+      return `${args["path"] ?? ""}${args["model"] ? ` (${args["model"]})` : ""}`;
+    case "transcribe_url":
+      return truncStr(String(args["url"] ?? ""), 60);
     default:
       return Object.entries(args).map(([k, v]) => `${k}=${truncStr(String(v), 30)}`).join(", ");
   }
@@ -9214,7 +9938,10 @@ var init_render = __esm({
       // Image tools
       image_read: "\u{1F5BC}\uFE0F",
       screenshot: "\u{1F4F8}",
-      ocr: "\u{1F441}\uFE0F"
+      ocr: "\u{1F441}\uFE0F",
+      // Transcription tools
+      transcribe_file: "\u{1F399}\uFE0F",
+      transcribe_url: "\u{1F399}\uFE0F"
     };
     TOOL_LABELS = {
       file_read: "Read",
@@ -9245,7 +9972,10 @@ var init_render = __esm({
       // Image tools
       image_read: "Image read",
       screenshot: "Screenshot",
-      ocr: "OCR"
+      ocr: "OCR",
+      // Transcription tools
+      transcribe_file: "Transcribe",
+      transcribe_url: "Transcribe URL"
     };
     _contentWriteHook = null;
     HINTS = [
@@ -9287,6 +10017,8 @@ var init_render = __esm({
       "image_read",
       "screenshot",
       "ocr",
+      "transcribe_file",
+      "transcribe_url",
       "aiwg_setup",
       "aiwg_health",
       "aiwg_workflow",
@@ -9301,11 +10033,13 @@ var init_render = __esm({
       "/config",
       "/update",
       "/voice",
+      "/listen",
       "/stream",
       "/verbose",
       "/dream",
       "/bruteforce",
       "/tools",
+      "/skills",
       "/clear",
       "/help",
       "/quit"
@@ -9314,52 +10048,52 @@ var init_render = __esm({
 });
 
 // packages/cli/dist/tui/oa-directory.js
-import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync4, readdirSync as readdirSync6, statSync as statSync5, unlinkSync } from "node:fs";
-import { join as join15, relative as relative2, basename as basename3, extname as extname4 } from "node:path";
-import { homedir as homedir5 } from "node:os";
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync6, readdirSync as readdirSync6, statSync as statSync5, unlinkSync as unlinkSync2 } from "node:fs";
+import { join as join17, relative as relative2, basename as basename4, extname as extname5 } from "node:path";
+import { homedir as homedir7 } from "node:os";
 function initOaDirectory(repoRoot) {
-  const oaPath = join15(repoRoot, OA_DIR);
+  const oaPath = join17(repoRoot, OA_DIR);
   for (const sub of SUBDIRS) {
-    mkdirSync4(join15(oaPath, sub), { recursive: true });
+    mkdirSync6(join17(oaPath, sub), { recursive: true });
   }
   return oaPath;
 }
 function hasOaDirectory(repoRoot) {
-  return existsSync10(join15(repoRoot, OA_DIR, "index"));
+  return existsSync12(join17(repoRoot, OA_DIR, "index"));
 }
 function loadProjectSettings(repoRoot) {
-  const settingsPath = join15(repoRoot, OA_DIR, "settings.json");
+  const settingsPath = join17(repoRoot, OA_DIR, "settings.json");
   try {
-    if (existsSync10(settingsPath)) {
-      return JSON.parse(readFileSync9(settingsPath, "utf-8"));
+    if (existsSync12(settingsPath)) {
+      return JSON.parse(readFileSync10(settingsPath, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function saveProjectSettings(repoRoot, settings) {
-  const oaPath = join15(repoRoot, OA_DIR);
-  mkdirSync4(oaPath, { recursive: true });
+  const oaPath = join17(repoRoot, OA_DIR);
+  mkdirSync6(oaPath, { recursive: true });
   const existing = loadProjectSettings(repoRoot);
   const merged = { ...existing, ...settings };
-  writeFileSync4(join15(oaPath, "settings.json"), JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  writeFileSync6(join17(oaPath, "settings.json"), JSON.stringify(merged, null, 2) + "\n", "utf-8");
 }
 function loadGlobalSettings() {
-  const settingsPath = join15(homedir5(), ".open-agents", "settings.json");
+  const settingsPath = join17(homedir7(), ".open-agents", "settings.json");
   try {
-    if (existsSync10(settingsPath)) {
-      return JSON.parse(readFileSync9(settingsPath, "utf-8"));
+    if (existsSync12(settingsPath)) {
+      return JSON.parse(readFileSync10(settingsPath, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function saveGlobalSettings(settings) {
-  const dir = join15(homedir5(), ".open-agents");
-  mkdirSync4(dir, { recursive: true });
+  const dir = join17(homedir7(), ".open-agents");
+  mkdirSync6(dir, { recursive: true });
   const existing = loadGlobalSettings();
   const merged = { ...existing, ...settings };
-  writeFileSync4(join15(dir, "settings.json"), JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  writeFileSync6(join17(dir, "settings.json"), JSON.stringify(merged, null, 2) + "\n", "utf-8");
 }
 function resolveSettings(repoRoot) {
   const global = loadGlobalSettings();
@@ -9374,12 +10108,12 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
   while (dir && !visited.has(dir)) {
     visited.add(dir);
     for (const name of CONTEXT_FILES) {
-      const filePath = join15(dir, name);
+      const filePath = join17(dir, name);
       const normalizedName = name.toLowerCase();
-      if (existsSync10(filePath) && !seen.has(filePath)) {
+      if (existsSync12(filePath) && !seen.has(filePath)) {
         seen.add(filePath);
         try {
-          let content = readFileSync9(filePath, "utf-8");
+          let content = readFileSync10(filePath, "utf-8");
           if (content.length > maxContentLen) {
             content = content.slice(0, maxContentLen) + "\n\n...(truncated)";
           }
@@ -9393,11 +10127,11 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
         }
       }
     }
-    const projectMap = join15(dir, OA_DIR, "context", "project-map.md");
-    if (existsSync10(projectMap) && !seen.has(projectMap)) {
+    const projectMap = join17(dir, OA_DIR, "context", "project-map.md");
+    if (existsSync12(projectMap) && !seen.has(projectMap)) {
       seen.add(projectMap);
       try {
-        let content = readFileSync9(projectMap, "utf-8");
+        let content = readFileSync10(projectMap, "utf-8");
         if (content.length > maxContentLen) {
           content = content.slice(0, maxContentLen) + "\n\n...(truncated)";
         }
@@ -9409,7 +10143,7 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
       } catch {
       }
     }
-    const parent = join15(dir, "..");
+    const parent = join17(dir, "..");
     if (parent === dir)
       break;
     dir = parent;
@@ -9427,16 +10161,16 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
   return found;
 }
 function readIndexMeta(repoRoot) {
-  const metaPath = join15(repoRoot, OA_DIR, "index", "meta.json");
+  const metaPath = join17(repoRoot, OA_DIR, "index", "meta.json");
   try {
-    return JSON.parse(readFileSync9(metaPath, "utf-8"));
+    return JSON.parse(readFileSync10(metaPath, "utf-8"));
   } catch {
     return null;
   }
 }
 function generateProjectMap(repoRoot) {
   const sections = [];
-  const repoName2 = basename3(repoRoot);
+  const repoName2 = basename4(repoRoot);
   sections.push(`# Project Map: ${repoName2}
 `);
   sections.push(`> Auto-generated by open-agents. Updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
@@ -9480,28 +10214,28 @@ ${tree}\`\`\`
     sections.push("");
   }
   const content = sections.join("\n");
-  const contextDir = join15(repoRoot, OA_DIR, "context");
-  mkdirSync4(contextDir, { recursive: true });
-  writeFileSync4(join15(contextDir, "project-map.md"), content, "utf-8");
+  const contextDir = join17(repoRoot, OA_DIR, "context");
+  mkdirSync6(contextDir, { recursive: true });
+  writeFileSync6(join17(contextDir, "project-map.md"), content, "utf-8");
   return content;
 }
 function saveSession(repoRoot, session) {
-  const historyDir = join15(repoRoot, OA_DIR, "history");
-  mkdirSync4(historyDir, { recursive: true });
-  writeFileSync4(join15(historyDir, `${session.id}.json`), JSON.stringify(session, null, 2), "utf-8");
+  const historyDir = join17(repoRoot, OA_DIR, "history");
+  mkdirSync6(historyDir, { recursive: true });
+  writeFileSync6(join17(historyDir, `${session.id}.json`), JSON.stringify(session, null, 2), "utf-8");
 }
 function loadRecentSessions(repoRoot, limit = 5) {
-  const historyDir = join15(repoRoot, OA_DIR, "history");
-  if (!existsSync10(historyDir))
+  const historyDir = join17(repoRoot, OA_DIR, "history");
+  if (!existsSync12(historyDir))
     return [];
   try {
     const files = readdirSync6(historyDir).filter((f) => f.endsWith(".json")).map((f) => {
-      const stat3 = statSync5(join15(historyDir, f));
+      const stat3 = statSync5(join17(historyDir, f));
       return { file: f, mtime: stat3.mtimeMs };
     }).sort((a, b) => b.mtime - a.mtime).slice(0, limit);
     return files.map((f) => {
       try {
-        return JSON.parse(readFileSync9(join15(historyDir, f.file), "utf-8"));
+        return JSON.parse(readFileSync10(join17(historyDir, f.file), "utf-8"));
       } catch {
         return null;
       }
@@ -9511,18 +10245,18 @@ function loadRecentSessions(repoRoot, limit = 5) {
   }
 }
 function savePendingTask(repoRoot, task) {
-  const historyDir = join15(repoRoot, OA_DIR, "history");
-  mkdirSync4(historyDir, { recursive: true });
-  writeFileSync4(join15(historyDir, PENDING_TASK_FILE), JSON.stringify(task, null, 2) + "\n", "utf-8");
+  const historyDir = join17(repoRoot, OA_DIR, "history");
+  mkdirSync6(historyDir, { recursive: true });
+  writeFileSync6(join17(historyDir, PENDING_TASK_FILE), JSON.stringify(task, null, 2) + "\n", "utf-8");
 }
 function loadPendingTask(repoRoot) {
-  const filePath = join15(repoRoot, OA_DIR, "history", PENDING_TASK_FILE);
+  const filePath = join17(repoRoot, OA_DIR, "history", PENDING_TASK_FILE);
   try {
-    if (!existsSync10(filePath))
+    if (!existsSync12(filePath))
       return null;
-    const data = JSON.parse(readFileSync9(filePath, "utf-8"));
+    const data = JSON.parse(readFileSync10(filePath, "utf-8"));
     try {
-      unlinkSync(filePath);
+      unlinkSync2(filePath);
     } catch {
     }
     return data;
@@ -9548,12 +10282,12 @@ function detectManifests(repoRoot) {
     { file: "docker-compose.yaml", type: "Docker Compose" }
   ];
   for (const check of checks) {
-    const filePath = join15(repoRoot, check.file);
-    if (existsSync10(filePath)) {
+    const filePath = join17(repoRoot, check.file);
+    if (existsSync12(filePath)) {
       let name;
       if (check.nameField) {
         try {
-          const data = JSON.parse(readFileSync9(filePath, "utf-8"));
+          const data = JSON.parse(readFileSync10(filePath, "utf-8"));
           name = data[check.nameField];
         } catch {
         }
@@ -9582,7 +10316,7 @@ function findKeyFiles(repoRoot) {
     { pattern: "CLAUDE.md", description: "Claude Code context" }
   ];
   for (const check of checks) {
-    if (existsSync10(join15(repoRoot, check.pattern))) {
+    if (existsSync12(join17(repoRoot, check.pattern))) {
       keyFiles.push({ path: check.pattern, description: check.description });
     }
   }
@@ -9608,12 +10342,12 @@ function buildDirTree(root, maxDepth, prefix = "", depth = 0) {
       if (entry.isDirectory()) {
         let fileCount = 0;
         try {
-          fileCount = readdirSync6(join15(root, entry.name)).filter((f) => !f.startsWith(".")).length;
+          fileCount = readdirSync6(join17(root, entry.name)).filter((f) => !f.startsWith(".")).length;
         } catch {
         }
         result += `${prefix}${connector}${entry.name}/ (${fileCount})
 `;
-        result += buildDirTree(join15(root, entry.name), maxDepth, childPrefix, depth + 1);
+        result += buildDirTree(join17(root, entry.name), maxDepth, childPrefix, depth + 1);
       } else if (depth < maxDepth) {
         result += `${prefix}${connector}${entry.name}
 `;
@@ -9808,7 +10542,7 @@ async function handleSlashCommand(input, ctx) {
           }
         }
         process.stdout.write("\n");
-        renderInfo("The agent can use these via the skill_execute tool.");
+        renderInfo('Invoke directly: /<skill-name> [args]  (e.g. /ralph "fix tests" --completion "npm test passes")');
         renderInfo("Filter with: /skills <keyword>");
       }
       return "handled";
@@ -9829,6 +10563,38 @@ async function handleSlashCommand(input, ctx) {
       }
       return "handled";
     }
+    case "listen":
+    case "mic": {
+      if (!ctx.listenToggle) {
+        renderWarning("Listen mode not available in this context.");
+        return "handled";
+      }
+      if (arg === "stop" || arg === "off") {
+        const msg2 = await (ctx.listenStop?.() ?? Promise.resolve("Not listening."));
+        renderInfo(msg2);
+        return "handled";
+      }
+      if (arg === "confirm") {
+        const msg2 = ctx.listenSetMode?.("confirm") ?? "Confirm mode set.";
+        renderInfo(msg2);
+        return "handled";
+      }
+      if (arg === "auto") {
+        const msg2 = ctx.listenSetMode?.("auto") ?? "Auto mode set.";
+        renderInfo(msg2);
+        return "handled";
+      }
+      const modelSizes = ["tiny", "base", "small", "medium", "large", "large-v3"];
+      if (arg && modelSizes.includes(arg.toLowerCase())) {
+        const model = arg.toLowerCase() === "large" ? "large-v3" : arg.toLowerCase();
+        const msg2 = await (ctx.listenSetModel?.(model) ?? Promise.resolve(`Model set to ${model}.`));
+        renderInfo(msg2);
+        return "handled";
+      }
+      const msg = await ctx.listenToggle();
+      renderInfo(msg);
+      return "handled";
+    }
     case "bruteforce":
     case "brute": {
       const isOn = ctx.bruteForceToggle();
@@ -9837,9 +10603,19 @@ async function handleSlashCommand(input, ctx) {
       renderInfo(`Brute-force mode: ${isOn ? "on" : "off"}${hasLocal ? " (project-local)" : ""}` + (isOn ? " \u2014 agent will auto re-engage when turn limit is hit, reassess and try creative strategies" : ""));
       return "handled";
     }
-    default:
+    default: {
+      const skills = discoverSkills(ctx.repoRoot);
+      const skill = skills.find((s) => s.name === cmd || s.name === cmd.replace(/_/g, "-"));
+      if (skill) {
+        const content = loadSkillContent(skill.filePath);
+        if (content) {
+          renderInfo(`Loading skill: ${c2.bold(skill.name)} (${skill.source})`);
+          return { type: "skill", name: skill.name, content, args: arg };
+        }
+      }
       renderWarning(`Unknown command: /${cmd}. Type /help for available commands.`);
       return "handled";
+    }
   }
 }
 async function listModels(ctx) {
@@ -9971,17 +10747,17 @@ async function handleUpdate(subcommand, repoRoot, savePendingTaskState) {
   try {
     const { createRequire: createRequire4 } = await import("node:module");
     const { fileURLToPath: fileURLToPath3 } = await import("node:url");
-    const { dirname: dirname5, join: join26 } = await import("node:path");
-    const { existsSync: existsSync17 } = await import("node:fs");
+    const { dirname: dirname5, join: join28 } = await import("node:path");
+    const { existsSync: existsSync19 } = await import("node:fs");
     const req = createRequire4(import.meta.url);
     const thisDir = dirname5(fileURLToPath3(import.meta.url));
     const candidates = [
-      join26(thisDir, "..", "package.json"),
-      join26(thisDir, "..", "..", "package.json"),
-      join26(thisDir, "..", "..", "..", "package.json")
+      join28(thisDir, "..", "package.json"),
+      join28(thisDir, "..", "..", "package.json"),
+      join28(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync17(pkgPath)) {
+      if (existsSync19(pkgPath)) {
         const pkg = req(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           currentVersion = pkg.version ?? "0.0.0";
@@ -10065,17 +10841,17 @@ var init_commands = __esm({
 
 // packages/cli/dist/tui/setup.js
 import * as readline from "node:readline";
-import { execSync as execSync9 } from "node:child_process";
-import { existsSync as existsSync11, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "node:fs";
-import { join as join16 } from "node:path";
-import { homedir as homedir6 } from "node:os";
+import { execSync as execSync11 } from "node:child_process";
+import { existsSync as existsSync13, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "node:fs";
+import { join as join18 } from "node:path";
+import { homedir as homedir8 } from "node:os";
 function detectSystemSpecs() {
   let totalRamGB = 0;
   let availableRamGB = 0;
   let gpuVramGB = 0;
   let gpuName = "";
   try {
-    const memInfo = execSync9("free -b 2>/dev/null || sysctl -n hw.memsize 2>/dev/null", {
+    const memInfo = execSync11("free -b 2>/dev/null || sysctl -n hw.memsize 2>/dev/null", {
       encoding: "utf8",
       timeout: 5e3
     });
@@ -10095,7 +10871,7 @@ function detectSystemSpecs() {
   } catch {
   }
   try {
-    const nvidiaSmi = execSync9("nvidia-smi --query-gpu=memory.total,name --format=csv,noheader,nounits 2>/dev/null", { encoding: "utf8", timeout: 5e3 });
+    const nvidiaSmi = execSync11("nvidia-smi --query-gpu=memory.total,name --format=csv,noheader,nounits 2>/dev/null", { encoding: "utf8", timeout: 5e3 });
     const lines = nvidiaSmi.trim().split("\n");
     if (lines.length > 0) {
       for (const line of lines) {
@@ -10151,13 +10927,13 @@ function modelSupportsToolCalling(modelName) {
   return false;
 }
 function ask(rl, question) {
-  return new Promise((resolve15) => {
-    rl.question(question, (answer) => resolve15(answer.trim()));
+  return new Promise((resolve16) => {
+    rl.question(question, (answer) => resolve16(answer.trim()));
   });
 }
 function pullModelWithAutoUpdate(tag) {
   try {
-    execSync9(`ollama pull ${tag}`, {
+    execSync11(`ollama pull ${tag}`, {
       stdio: "inherit",
       timeout: 36e5
       // 1 hour max
@@ -10174,7 +10950,7 @@ function pullModelWithAutoUpdate(tag) {
 
 `);
       try {
-        execSync9("curl -fsSL https://ollama.com/install.sh | sh", {
+        execSync11("curl -fsSL https://ollama.com/install.sh | sh", {
           stdio: "inherit",
           timeout: 3e5
           // 5 min max for install
@@ -10185,7 +10961,7 @@ function pullModelWithAutoUpdate(tag) {
         process.stdout.write(`  ${c2.cyan("\u25CF")} Retrying pull of ${c2.bold(tag)}...
 
 `);
-        execSync9(`ollama pull ${tag}`, {
+        execSync11(`ollama pull ${tag}`, {
           stdio: "inherit",
           timeout: 36e5
         });
@@ -10363,12 +11139,12 @@ async function doSetup(config, rl) {
           `PARAMETER num_predict 16384`,
           `PARAMETER stop "<|endoftext|>"`
         ].join("\n");
-        const modelDir2 = join16(homedir6(), ".open-agents", "models");
-        mkdirSync5(modelDir2, { recursive: true });
-        const modelfilePath = join16(modelDir2, `Modelfile.${customName}`);
-        writeFileSync5(modelfilePath, modelfileContent + "\n", "utf8");
+        const modelDir2 = join18(homedir8(), ".open-agents", "models");
+        mkdirSync7(modelDir2, { recursive: true });
+        const modelfilePath = join18(modelDir2, `Modelfile.${customName}`);
+        writeFileSync7(modelfilePath, modelfileContent + "\n", "utf8");
         process.stdout.write(`  ${c2.dim("Creating model...")} `);
-        execSync9(`ollama create ${customName} -f ${modelfilePath}`, {
+        execSync11(`ollama create ${customName} -f ${modelfilePath}`, {
           stdio: "pipe",
           timeout: 12e4
         });
@@ -10411,7 +11187,7 @@ async function isModelAvailable(config) {
 }
 function isFirstRun() {
   try {
-    return !existsSync11(join16(homedir6(), ".open-agents", "config.json"));
+    return !existsSync13(join18(homedir8(), ".open-agents", "config.json"));
   } catch {
     return true;
   }
@@ -10451,10 +11227,10 @@ var init_setup = __esm({
 });
 
 // packages/cli/dist/tui/project-context.js
-import { existsSync as existsSync12, readFileSync as readFileSync10, readdirSync as readdirSync7 } from "node:fs";
-import { join as join17, basename as basename4 } from "node:path";
-import { execSync as execSync10 } from "node:child_process";
-import { homedir as homedir7, platform, release } from "node:os";
+import { existsSync as existsSync14, readFileSync as readFileSync11, readdirSync as readdirSync7 } from "node:fs";
+import { join as join19, basename as basename5 } from "node:path";
+import { execSync as execSync12 } from "node:child_process";
+import { homedir as homedir9, platform, release } from "node:os";
 function loadProjectFiles(repoRoot) {
   const discovered = discoverContextFiles(repoRoot);
   if (discovered.length === 0)
@@ -10472,10 +11248,10 @@ function loadProjectMap(repoRoot) {
   if (!hasOaDirectory(repoRoot)) {
     initOaDirectory(repoRoot);
   }
-  const mapPath = join17(repoRoot, OA_DIR, "context", "project-map.md");
-  if (existsSync12(mapPath)) {
+  const mapPath = join19(repoRoot, OA_DIR, "context", "project-map.md");
+  if (existsSync14(mapPath)) {
     try {
-      const content = readFileSync10(mapPath, "utf-8");
+      const content = readFileSync11(mapPath, "utf-8");
       return content;
     } catch {
     }
@@ -10484,19 +11260,19 @@ function loadProjectMap(repoRoot) {
 }
 function getGitInfo(repoRoot) {
   try {
-    execSync10("git rev-parse --is-inside-work-tree", { cwd: repoRoot, stdio: "pipe" });
+    execSync12("git rev-parse --is-inside-work-tree", { cwd: repoRoot, stdio: "pipe" });
   } catch {
     return "";
   }
   const lines = [];
   try {
-    const branch = execSync10("git branch --show-current", { cwd: repoRoot, encoding: "utf-8", stdio: "pipe" }).trim();
+    const branch = execSync12("git branch --show-current", { cwd: repoRoot, encoding: "utf-8", stdio: "pipe" }).trim();
     if (branch)
       lines.push(`Branch: ${branch}`);
   } catch {
   }
   try {
-    const status = execSync10("git status --porcelain", { cwd: repoRoot, encoding: "utf-8", stdio: "pipe" }).trim();
+    const status = execSync12("git status --porcelain", { cwd: repoRoot, encoding: "utf-8", stdio: "pipe" }).trim();
     if (status) {
       const changed = status.split("\n").length;
       lines.push(`Working tree: ${changed} changed file(s)`);
@@ -10506,7 +11282,7 @@ function getGitInfo(repoRoot) {
   } catch {
   }
   try {
-    const log = execSync10("git log --oneline -5 --no-decorate", { cwd: repoRoot, encoding: "utf-8", stdio: "pipe" }).trim();
+    const log = execSync12("git log --oneline -5 --no-decorate", { cwd: repoRoot, encoding: "utf-8", stdio: "pipe" }).trim();
     if (log)
       lines.push(`Recent commits:
 ${log}`);
@@ -10516,33 +11292,33 @@ ${log}`);
 }
 function loadMemoryContext(repoRoot) {
   const sections = [];
-  const oaMemDir = join17(repoRoot, OA_DIR, "memory");
+  const oaMemDir = join19(repoRoot, OA_DIR, "memory");
   const oaEntries = loadMemoryDir(oaMemDir, "project");
   if (oaEntries)
     sections.push(oaEntries);
-  const legacyMemDir = join17(repoRoot, ".open-agents", "memory");
-  if (legacyMemDir !== oaMemDir && existsSync12(legacyMemDir)) {
+  const legacyMemDir = join19(repoRoot, ".open-agents", "memory");
+  if (legacyMemDir !== oaMemDir && existsSync14(legacyMemDir)) {
     const legacyEntries = loadMemoryDir(legacyMemDir, "project/legacy");
     if (legacyEntries)
       sections.push(legacyEntries);
   }
-  const globalMemDir = join17(homedir7(), ".open-agents", "memory");
+  const globalMemDir = join19(homedir9(), ".open-agents", "memory");
   const globalEntries = loadMemoryDir(globalMemDir, "global");
   if (globalEntries)
     sections.push(globalEntries);
   return sections.join("\n\n");
 }
 function loadMemoryDir(memDir, scope) {
-  if (!existsSync12(memDir))
+  if (!existsSync14(memDir))
     return "";
   const lines = [];
   try {
     const files = readdirSync7(memDir).filter((f) => f.endsWith(".json"));
     for (const file of files.slice(0, 10)) {
       try {
-        const raw = readFileSync10(join17(memDir, file), "utf-8");
+        const raw = readFileSync11(join19(memDir, file), "utf-8");
         const entries = JSON.parse(raw);
-        const topic = basename4(file, ".json");
+        const topic = basename5(file, ".json");
         const keys = Object.keys(entries);
         if (keys.length === 0)
           continue;
@@ -11551,25 +12327,25 @@ var init_carousel = __esm({
 });
 
 // packages/cli/dist/tui/voice.js
-import { existsSync as existsSync13, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6, readFileSync as readFileSync11, unlinkSync as unlinkSync2 } from "node:fs";
-import { join as join18 } from "node:path";
-import { homedir as homedir8, tmpdir as tmpdir2, platform as platform2 } from "node:os";
-import { execSync as execSync11, spawn as nodeSpawn } from "node:child_process";
+import { existsSync as existsSync15, mkdirSync as mkdirSync8, writeFileSync as writeFileSync8, readFileSync as readFileSync12, unlinkSync as unlinkSync3 } from "node:fs";
+import { join as join20 } from "node:path";
+import { homedir as homedir10, tmpdir as tmpdir2, platform as platform2 } from "node:os";
+import { execSync as execSync13, spawn as nodeSpawn } from "node:child_process";
 import { createRequire } from "node:module";
 function voiceDir() {
-  return join18(homedir8(), ".open-agents", "voice");
+  return join20(homedir10(), ".open-agents", "voice");
 }
 function modelsDir() {
-  return join18(voiceDir(), "models");
+  return join20(voiceDir(), "models");
 }
 function modelDir(id) {
-  return join18(modelsDir(), id);
+  return join20(modelsDir(), id);
 }
 function modelOnnxPath(id) {
-  return join18(modelDir(id), "model.onnx");
+  return join20(modelDir(id), "model.onnx");
 }
 function modelConfigPath(id) {
-  return join18(modelDir(id), "config.json");
+  return join20(modelDir(id), "config.json");
 }
 function describeToolCall(toolName, args) {
   const path = args["path"];
@@ -11842,11 +12618,11 @@ var init_voice = __esm({
         const audioData = result["output"].data;
         if (audioData.length === 0)
           return;
-        const wavPath = join18(tmpdir2(), `oa-voice-${Date.now()}.wav`);
+        const wavPath = join20(tmpdir2(), `oa-voice-${Date.now()}.wav`);
         this.writeWav(audioData, this.config.audio.sample_rate, wavPath);
         await this.playWav(wavPath);
         try {
-          unlinkSync2(wavPath);
+          unlinkSync3(wavPath);
         } catch {
         }
       }
@@ -11922,7 +12698,7 @@ var init_voice = __esm({
         buffer.write("data", 36);
         buffer.writeUInt32LE(dataSize, 40);
         Buffer.from(int16.buffer, int16.byteOffset, int16.byteLength).copy(buffer, 44);
-        writeFileSync6(path, buffer);
+        writeFileSync8(path, buffer);
       }
       // -------------------------------------------------------------------------
       // Audio playback (system default speakers)
@@ -11931,7 +12707,7 @@ var init_voice = __esm({
         const cmd = this.getPlayCommand(path);
         if (!cmd)
           return;
-        return new Promise((resolve15) => {
+        return new Promise((resolve16) => {
           const child = nodeSpawn(cmd[0], cmd.slice(1), {
             stdio: "ignore",
             detached: false
@@ -11940,12 +12716,12 @@ var init_voice = __esm({
           child.on("close", () => {
             if (this.currentPlayback === child)
               this.currentPlayback = null;
-            resolve15();
+            resolve16();
           });
           child.on("error", () => {
             if (this.currentPlayback === child)
               this.currentPlayback = null;
-            resolve15();
+            resolve16();
           });
           setTimeout(() => {
             if (this.currentPlayback === child) {
@@ -11955,7 +12731,7 @@ var init_voice = __esm({
               }
               this.currentPlayback = null;
             }
-            resolve15();
+            resolve16();
           }, 15e3);
         });
       }
@@ -11972,7 +12748,7 @@ var init_voice = __esm({
         }
         for (const player of ["paplay", "pw-play", "aplay"]) {
           try {
-            execSync11(`which ${player}`, { stdio: "pipe" });
+            execSync13(`which ${player}`, { stdio: "pipe" });
             return [player, path];
           } catch {
           }
@@ -11994,36 +12770,36 @@ var init_voice = __esm({
       async ensureRuntime() {
         if (this.ort)
           return;
-        mkdirSync6(voiceDir(), { recursive: true });
-        const pkgPath = join18(voiceDir(), "package.json");
+        mkdirSync8(voiceDir(), { recursive: true });
+        const pkgPath = join20(voiceDir(), "package.json");
         const expectedDeps = {
           "onnxruntime-node": "^1.21.0",
           "phonemizer": "^1.2.1"
         };
-        if (existsSync13(pkgPath)) {
+        if (existsSync15(pkgPath)) {
           try {
-            const existing = JSON.parse(readFileSync11(pkgPath, "utf8"));
+            const existing = JSON.parse(readFileSync12(pkgPath, "utf8"));
             if (!existing.dependencies?.["phonemizer"]) {
               existing.dependencies = { ...existing.dependencies, ...expectedDeps };
-              writeFileSync6(pkgPath, JSON.stringify(existing, null, 2));
+              writeFileSync8(pkgPath, JSON.stringify(existing, null, 2));
             }
           } catch {
           }
         }
-        if (!existsSync13(pkgPath)) {
-          writeFileSync6(pkgPath, JSON.stringify({
+        if (!existsSync15(pkgPath)) {
+          writeFileSync8(pkgPath, JSON.stringify({
             name: "open-agents-voice",
             private: true,
             dependencies: expectedDeps
           }, null, 2));
         }
-        const voiceRequire = createRequire(join18(voiceDir(), "index.js"));
+        const voiceRequire = createRequire(join20(voiceDir(), "index.js"));
         try {
           this.ort = voiceRequire("onnxruntime-node");
         } catch {
           renderInfo("Installing ONNX runtime for voice synthesis...");
           try {
-            execSync11("npm install --no-audit --no-fund", {
+            execSync13("npm install --no-audit --no-fund", {
               cwd: voiceDir(),
               stdio: "pipe",
               timeout: 12e4
@@ -12040,7 +12816,7 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
         } catch {
           renderInfo("Installing phonemizer for voice synthesis...");
           try {
-            execSync11("npm install --no-audit --no-fund", {
+            execSync13("npm install --no-audit --no-fund", {
               cwd: voiceDir(),
               stdio: "pipe",
               timeout: 12e4
@@ -12063,18 +12839,18 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
         const dir = modelDir(id);
         const onnxPath = modelOnnxPath(id);
         const configPath = modelConfigPath(id);
-        if (existsSync13(onnxPath) && existsSync13(configPath))
+        if (existsSync15(onnxPath) && existsSync15(configPath))
           return;
-        mkdirSync6(dir, { recursive: true });
-        if (!existsSync13(configPath)) {
+        mkdirSync8(dir, { recursive: true });
+        if (!existsSync15(configPath)) {
           renderInfo(`Downloading ${model.label} voice config...`);
           const configResp = await fetch(model.configUrl);
           if (!configResp.ok)
             throw new Error(`Failed to download config: HTTP ${configResp.status}`);
           const configText = await configResp.text();
-          writeFileSync6(configPath, configText);
+          writeFileSync8(configPath, configText);
         }
-        if (!existsSync13(onnxPath)) {
+        if (!existsSync15(onnxPath)) {
           renderInfo(`Downloading ${model.label} voice model (this may take a minute)...`);
           const onnxResp = await fetch(model.onnxUrl);
           if (!onnxResp.ok)
@@ -12098,7 +12874,7 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
           }
           process.stdout.write("\r" + " ".repeat(60) + "\r");
           const fullBuffer = Buffer.concat(chunks);
-          writeFileSync6(onnxPath, fullBuffer);
+          writeFileSync8(onnxPath, fullBuffer);
           renderInfo(`${model.label} model downloaded (${formatBytes2(fullBuffer.length)}).`);
         }
       }
@@ -12110,10 +12886,10 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
           throw new Error("ONNX runtime not loaded");
         const onnxPath = modelOnnxPath(this.modelId);
         const configPath = modelConfigPath(this.modelId);
-        if (!existsSync13(onnxPath) || !existsSync13(configPath)) {
+        if (!existsSync15(onnxPath) || !existsSync15(configPath)) {
           throw new Error(`Model files not found for ${this.modelId}`);
         }
-        this.config = JSON.parse(readFileSync11(configPath, "utf8"));
+        this.config = JSON.parse(readFileSync12(configPath, "utf8"));
         renderInfo("Loading voice model...");
         this.session = await this.ort.InferenceSession.create(onnxPath, {
           executionProviders: ["cpu"],
@@ -12570,13 +13346,13 @@ var init_stream_renderer = __esm({
 });
 
 // packages/cli/dist/tui/edit-history.js
-import { appendFileSync, mkdirSync as mkdirSync7 } from "node:fs";
-import { join as join19 } from "node:path";
+import { appendFileSync, mkdirSync as mkdirSync9 } from "node:fs";
+import { join as join21 } from "node:path";
 function createEditHistoryLogger(repoRoot, sessionId) {
-  const historyDir = join19(repoRoot, ".oa", "history");
-  const logPath = join19(historyDir, "edits.jsonl");
+  const historyDir = join21(repoRoot, ".oa", "history");
+  const logPath = join21(historyDir, "edits.jsonl");
   try {
-    mkdirSync7(historyDir, { recursive: true });
+    mkdirSync9(historyDir, { recursive: true });
   } catch {
   }
   function logToolCall(toolName, toolArgs, success) {
@@ -12685,9 +13461,9 @@ var init_edit_history = __esm({
 });
 
 // packages/cli/dist/tui/dream-engine.js
-import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync7, readFileSync as readFileSync12, existsSync as existsSync14, cpSync, rmSync, readdirSync as readdirSync8 } from "node:fs";
-import { join as join20, basename as basename5 } from "node:path";
-import { execSync as execSync12 } from "node:child_process";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync9, readFileSync as readFileSync13, existsSync as existsSync16, cpSync, rmSync, readdirSync as readdirSync8 } from "node:fs";
+import { join as join22, basename as basename6 } from "node:path";
+import { execSync as execSync14 } from "node:child_process";
 function adaptTool(tool) {
   return {
     name: tool.name,
@@ -12861,14 +13637,14 @@ var init_dream_engine = __esm({
         const content = String(args["content"] ?? "");
         if (!rawPath)
           return { success: false, output: "", error: "path is required", durationMs: Date.now() - start };
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join20(this.dreamsDir, basename5(rawPath)) : join20(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join22(this.dreamsDir, basename6(rawPath)) : join22(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 = join20(targetPath, "..");
-          mkdirSync8(dir, { recursive: true });
-          writeFileSync7(targetPath, content, "utf-8");
+          const dir = join22(targetPath, "..");
+          mkdirSync10(dir, { recursive: true });
+          writeFileSync9(targetPath, content, "utf-8");
           return { success: true, output: `Wrote ${content.length} bytes to ${rawPath}`, durationMs: Date.now() - start };
         } catch (err) {
           return { success: false, output: "", error: String(err), durationMs: Date.now() - start };
@@ -12896,20 +13672,20 @@ var init_dream_engine = __esm({
         const rawPath = String(args["path"] ?? "");
         const oldStr = String(args["old_string"] ?? "");
         const newStr = String(args["new_string"] ?? "");
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join20(this.dreamsDir, basename5(rawPath)) : join20(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join22(this.dreamsDir, basename6(rawPath)) : join22(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 (!existsSync14(targetPath)) {
+          if (!existsSync16(targetPath)) {
             return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: Date.now() - start };
           }
-          let content = readFileSync12(targetPath, "utf-8");
+          let content = readFileSync13(targetPath, "utf-8");
           if (!content.includes(oldStr)) {
             return { success: false, output: "", error: "old_string not found in file", durationMs: Date.now() - start };
           }
           content = content.replace(oldStr, newStr);
-          writeFileSync7(targetPath, content, "utf-8");
+          writeFileSync9(targetPath, content, "utf-8");
           return { success: true, output: `Edited ${rawPath}`, durationMs: Date.now() - start };
         } catch (err) {
           return { success: false, output: "", error: String(err), durationMs: Date.now() - start };
@@ -12940,7 +13716,7 @@ var init_dream_engine = __esm({
           }
         }
         try {
-          const output = execSync12(cmd, {
+          const output = execSync14(cmd, {
             cwd: this.repoRoot,
             timeout: 3e4,
             encoding: "utf-8",
@@ -12963,7 +13739,7 @@ var init_dream_engine = __esm({
       constructor(config, repoRoot) {
         this.config = config;
         this.repoRoot = repoRoot;
-        this.dreamsDir = join20(repoRoot, ".oa", "dreams");
+        this.dreamsDir = join22(repoRoot, ".oa", "dreams");
         this.state = {
           mode: "default",
           active: false,
@@ -12994,7 +13770,7 @@ var init_dream_engine = __esm({
           startedAt: (/* @__PURE__ */ new Date()).toISOString(),
           results: []
         };
-        mkdirSync8(this.dreamsDir, { recursive: true });
+        mkdirSync10(this.dreamsDir, { recursive: true });
         this.saveDreamState();
         try {
           for (let cycle = 1; cycle <= totalCycles; cycle++) {
@@ -13035,8 +13811,8 @@ ${result.summary}`;
             if (mode !== "default" || cycle === totalCycles) {
               renderDreamContraction(cycle);
               const cycleSummary = this.buildCycleSummary(cycle, previousFindings);
-              const summaryPath = join20(this.dreamsDir, `cycle-${cycle}-summary.md`);
-              writeFileSync7(summaryPath, cycleSummary, "utf-8");
+              const summaryPath = join22(this.dreamsDir, `cycle-${cycle}-summary.md`);
+              writeFileSync9(summaryPath, cycleSummary, "utf-8");
             }
             if (mode === "lucid" && !this.abortController.signal.aborted) {
               this.saveVersionCheckpoint(cycle);
@@ -13156,29 +13932,29 @@ Dreams directory: ${this.dreamsDir}`);
       }
       /** Save workspace backup for lucid mode */
       saveVersionCheckpoint(cycle) {
-        const checkpointDir = join20(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
+        const checkpointDir = join22(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
         try {
-          mkdirSync8(checkpointDir, { recursive: true });
+          mkdirSync10(checkpointDir, { recursive: true });
           try {
-            const gitStatus = execSync12("git status --porcelain", {
+            const gitStatus = execSync14("git status --porcelain", {
               cwd: this.repoRoot,
               encoding: "utf-8",
               timeout: 1e4
             });
-            const gitDiff = execSync12("git diff", {
+            const gitDiff = execSync14("git diff", {
               cwd: this.repoRoot,
               encoding: "utf-8",
               timeout: 1e4
             });
-            const gitHash = execSync12("git rev-parse HEAD 2>/dev/null || echo 'no-git'", {
+            const gitHash = execSync14("git rev-parse HEAD 2>/dev/null || echo 'no-git'", {
               cwd: this.repoRoot,
               encoding: "utf-8",
               timeout: 5e3
             }).trim();
-            writeFileSync7(join20(checkpointDir, "git-status.txt"), gitStatus, "utf-8");
-            writeFileSync7(join20(checkpointDir, "git-diff.patch"), gitDiff, "utf-8");
-            writeFileSync7(join20(checkpointDir, "git-hash.txt"), gitHash, "utf-8");
-            writeFileSync7(join20(checkpointDir, "checkpoint.json"), JSON.stringify({
+            writeFileSync9(join22(checkpointDir, "git-status.txt"), gitStatus, "utf-8");
+            writeFileSync9(join22(checkpointDir, "git-diff.patch"), gitDiff, "utf-8");
+            writeFileSync9(join22(checkpointDir, "git-hash.txt"), gitHash, "utf-8");
+            writeFileSync9(join22(checkpointDir, "checkpoint.json"), JSON.stringify({
               cycle,
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
               gitHash,
@@ -13186,7 +13962,7 @@ Dreams directory: ${this.dreamsDir}`);
             }, null, 2), "utf-8");
             renderInfo(`Checkpoint saved: cycle ${cycle} (${gitHash.slice(0, 8)})`);
           } catch {
-            writeFileSync7(join20(checkpointDir, "checkpoint.json"), JSON.stringify({ cycle, timestamp: (/* @__PURE__ */ new Date()).toISOString(), mode: this.state.mode }, null, 2), "utf-8");
+            writeFileSync9(join22(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) {
@@ -13244,14 +14020,14 @@ ${files.map((f) => `- [\`${f}\`](./${f})`).join("\n")}
 ---
 *Auto-generated by open-agents dream engine*
 `;
-          writeFileSync7(join20(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
+          writeFileSync9(join22(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
         } catch {
         }
       }
       /** Save dream state for resume/inspection */
       saveDreamState() {
         try {
-          writeFileSync7(join20(this.dreamsDir, "dream-state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
+          writeFileSync9(join22(this.dreamsDir, "dream-state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
         } catch {
         }
       }
@@ -13297,6 +14073,10 @@ var init_status_bar = __esm({
        * own output is suppressed.
        */
       inputStateProvider = null;
+      /** Whether microphone is recording (blinking indicator) */
+      _recording = false;
+      /** Countdown seconds for auto-mode silence timeout (0 = not counting down) */
+      _countdown = 0;
       /**
        * Provide a callback that returns readline's current input state.
        * StatusBar uses this to render typed text and position the cursor
@@ -13305,6 +14085,20 @@ var init_status_bar = __esm({
       setInputStateProvider(provider) {
         this.inputStateProvider = provider;
       }
+      /** Set recording indicator state (blinking red ●) */
+      setRecording(active) {
+        this._recording = active;
+        if (!active)
+          this._countdown = 0;
+        if (this.active)
+          this.renderFooterPreserveCursor();
+      }
+      /** Set countdown seconds for auto-mode silence timeout */
+      setCountdown(seconds) {
+        this._countdown = seconds;
+        if (this.active)
+          this.renderFooterPreserveCursor();
+      }
       /** Context window size to display. Can be updated if model changes. */
       setContextWindowSize(size) {
         this.metrics.contextWindowSize = size;
@@ -13453,7 +14247,13 @@ var init_status_bar = __esm({
         const ctxPct = ctxTotal > 0 ? Math.max(0, Math.min(100, Math.round((1 - ctxUsed / ctxTotal) * 100))) : 100;
         const ctxColor = ctxPct > 50 ? c2.green : ctxPct > 20 ? c2.yellow : c2.red;
         const ctxLabel = c2.blue("Ctx: ") + c2.bold(`${ctxUsed.toLocaleString()}/${ctxTotal.toLocaleString()}`) + ` ${ctxColor(`${ctxPct}%`)}`;
-        return ` ${tokInLabel}${pipe}${tokOutLabel}${pipe}${ctxLabel}`;
+        let recordingLabel = "";
+        if (this._recording) {
+          const dot = c2.red("\u25CF");
+          const countdown = this._countdown > 0 ? c2.dim(` ${this._countdown}s`) : "";
+          recordingLabel = pipe + dot + c2.red(" REC") + countdown;
+        }
+        return ` ${tokInLabel}${pipe}${tokOutLabel}${pipe}${ctxLabel}${recordingLabel}`;
       }
       // -------------------------------------------------------------------------
       // Private
@@ -13580,23 +14380,22 @@ var init_status_bar = __esm({
 import * as readline2 from "node:readline";
 import { Writable } from "node:stream";
 import { cwd } from "node:process";
-import { resolve as resolve12, join as join21, dirname as dirname3 } from "node:path";
+import { resolve as resolve13, join as join23, dirname as dirname3, extname as extname6 } from "node:path";
 import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath } from "node:url";
-import { readFileSync as readFileSync13 } from "node:fs";
-import { existsSync as existsSync15 } from "node:fs";
-import { extname as extname5 } from "node:path";
+import { readFileSync as readFileSync14 } from "node:fs";
+import { existsSync as existsSync17 } from "node:fs";
 function getVersion() {
   try {
     const require2 = createRequire2(import.meta.url);
     const thisDir = dirname3(fileURLToPath(import.meta.url));
     const candidates = [
-      join21(thisDir, "..", "package.json"),
-      join21(thisDir, "..", "..", "package.json"),
-      join21(thisDir, "..", "..", "..", "package.json")
+      join23(thisDir, "..", "package.json"),
+      join23(thisDir, "..", "..", "package.json"),
+      join23(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync15(pkgPath)) {
+      if (existsSync17(pkgPath)) {
         const pkg = require2(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           return pkg.version ?? "0.0.0";
@@ -13673,7 +14472,10 @@ function buildTools(repoRoot, config) {
     ...buildCustomTools(repoRoot),
     // Skill system (AIWG skills — discovery and execution)
     new SkillListTool(repoRoot),
-    new SkillExecuteTool(repoRoot)
+    new SkillExecuteTool(repoRoot),
+    // Transcription tools (transcribe-cli / faster-whisper)
+    new TranscribeFileTool(repoRoot),
+    new TranscribeUrlTool(repoRoot)
   ];
   return [
     ...executionTools.map(adaptTool2),
@@ -13926,7 +14728,7 @@ function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce
   } };
 }
 async function startInteractive(config, repoPath) {
-  const repoRoot = resolve12(repoPath ?? cwd());
+  const repoRoot = resolve13(repoPath ?? cwd());
   const isResumed = !!process.env.__OA_RESUMED;
   if (isResumed) {
     delete process.env.__OA_RESUMED;
@@ -14153,7 +14955,7 @@ async function startInteractive(config, repoPath) {
       }
     },
     savePendingTaskState() {
-      if (lastSubmittedPrompt) {
+      if (lastSubmittedPrompt && activeTask) {
         savePendingTask(repoRoot, {
           prompt: lastSubmittedPrompt,
           progressSummary: `Manual /update triggered. ${sessionToolCallCount} tool calls completed in last task.`,
@@ -14195,6 +14997,59 @@ async function startInteractive(config, repoPath) {
     },
     isDreaming() {
       return dreamEngine?.isActive ?? false;
+    },
+    // Listen mode (transcribe-cli integration)
+    async listenToggle() {
+      const engine = getListenEngine();
+      if (engine.isActive) {
+        const text = await engine.stop();
+        statusBar.setRecording(false);
+        return text ? `Stopped. Last transcript: "${text}"` : "Stopped listening.";
+      }
+      const available = await engine.isAvailable();
+      if (!available) {
+        return "transcribe-cli not installed. Run: npm i -g transcribe-cli";
+      }
+      engine.on("transcript", (text, isFinal) => {
+        if (engine.currentMode === "confirm") {
+          writeContent(() => renderInfo(`Heard: "${text}" ${c2.dim("(press Enter to submit)")}`));
+        } else if (isFinal) {
+          writeContent(() => renderInfo(`Auto-submitting: "${text}"`));
+          rl.write(text + "\n");
+        } else {
+          writeContent(() => renderInfo(`Hearing: "${text}"`));
+        }
+      });
+      engine.on("recording", (active) => {
+        statusBar.setRecording(active);
+      });
+      engine.on("countdown", (seconds) => {
+        statusBar.setCountdown(seconds);
+      });
+      engine.on("error", (err) => {
+        writeContent(() => renderWarning(`Listen error: ${err.message}`));
+      });
+      engine.on("info", (msg2) => {
+        writeContent(() => renderInfo(msg2));
+      });
+      const msg = await engine.start();
+      return msg;
+    },
+    async listenSetModel(model) {
+      const engine = getListenEngine();
+      engine.setModel(model);
+      return `Whisper model set to: ${model}`;
+    },
+    listenSetMode(mode) {
+      const engine = getListenEngine();
+      engine.setMode(mode);
+      return mode === "auto" ? "Auto mode: transcriptions auto-submit after 3s silence" : "Confirm mode: press Enter to submit transcriptions";
+    },
+    async listenStop() {
+      const engine = getListenEngine();
+      const text = await engine.stop();
+      statusBar.setRecording(false);
+      return text ? `Stopped. Last transcript: "${text}"` : "Stopped listening.";
     }
   };
   showPrompt();
@@ -14242,16 +15097,56 @@ ${c2.dim("Goodbye!")}
         showPrompt();
         return;
       }
+      if (typeof cmdResult === "object" && cmdResult.type === "skill") {
+        const skillPrompt = cmdResult.args ? `<skill-context name="${cmdResult.name}">
+${cmdResult.content}
+</skill-context>
+
+ARGUMENTS: ${cmdResult.args}` : `<skill-context name="${cmdResult.name}">
+${cmdResult.content}
+</skill-context>
+
+Execute this skill now. Follow the behavioral guidance above.`;
+        if (!carouselRetired && carousel.isRunning) {
+          carousel.stop();
+          carouselRetired = true;
+          if (statusBar.isActive)
+            statusBar.setScrollRegionTop(1);
+        }
+        writeContent(() => renderUserMessage(`/${cmdResult.name}${cmdResult.args ? " " + cmdResult.args : ""}`));
+        lastSubmittedPrompt = skillPrompt;
+        try {
+          const task = startTask(skillPrompt, currentConfig, repoRoot, voiceEngine, {
+            enabled: streamEnabled,
+            renderer: streamRenderer
+          }, {
+            contextStores,
+            taskMemoryStore: taskMemoryStore ?? void 0,
+            failureStore: failureStore ?? void 0,
+            toolPatternStore: toolPatternStore ?? void 0
+          }, bruteForceEnabled, statusBar);
+          activeTask = task;
+          showPrompt();
+          await task.promise;
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          writeContent(() => renderError(errMsg));
+        }
+        activeTask = null;
+        showPrompt();
+        return;
+      }
     }
     const cleanPath = input.replace(/^['"]|['"]$/g, "").trim();
-    const isImage = isImagePath(cleanPath) && existsSync15(resolve12(repoRoot, cleanPath));
+    const isImage = isImagePath(cleanPath) && existsSync17(resolve13(repoRoot, cleanPath));
+    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync17(resolve13(repoRoot, cleanPath));
     if (activeTask) {
       if (isImage) {
         try {
-          const imgPath = resolve12(repoRoot, cleanPath);
-          const imgBuffer = readFileSync13(imgPath);
+          const imgPath = resolve13(repoRoot, cleanPath);
+          const imgBuffer = readFileSync14(imgPath);
           const base64 = imgBuffer.toString("base64");
-          const ext = extname5(cleanPath).toLowerCase();
+          const ext = extname6(cleanPath).toLowerCase();
           const mime = ext === ".png" ? "image/png" : ext === ".gif" ? "image/gif" : ext === ".webp" ? "image/webp" : "image/jpeg";
           activeTask.runner.injectImage(base64, mime, `User shared image: ${cleanPath}`);
           writeContent(() => renderUserInterrupt(`[Image: ${cleanPath}]`));
@@ -14259,6 +15154,19 @@ ${c2.dim("Goodbye!")}
           activeTask.runner.injectUserMessage(input);
           writeContent(() => renderUserInterrupt(input));
         }
+      } else if (isMedia) {
+        writeContent(() => renderInfo(`Transcribing: ${cleanPath}...`));
+        const engine = getListenEngine();
+        const result = await engine.transcribeFile(resolve13(repoRoot, cleanPath), repoRoot);
+        if (result) {
+          const transcript = `[Transcription of ${cleanPath}]
+${result.text}`;
+          activeTask.runner.injectUserMessage(transcript);
+          writeContent(() => renderUserInterrupt(`[Audio: ${cleanPath}] (${result.text.split(" ").length} words)`));
+        } else {
+          activeTask.runner.injectUserMessage(`User dropped audio/video file: ${cleanPath}. Use transcribe_file tool to transcribe it.`);
+          writeContent(() => renderUserInterrupt(`[Media: ${cleanPath}]`));
+        }
       } else {
         activeTask.runner.injectUserMessage(input);
         writeContent(() => renderUserInterrupt(input));
@@ -14274,6 +15182,22 @@ ${c2.dim("Goodbye!")}
     if (isImage && fullInput === input) {
       fullInput = `The user has provided an image file: ${cleanPath}. Read it with image_read and describe what you see. Extract any text with OCR if relevant.`;
     }
+    if (isMedia && fullInput === input) {
+      writeContent(() => renderInfo(`Transcribing: ${cleanPath}...`));
+      const engine = getListenEngine();
+      const result = await engine.transcribeFile(resolve13(repoRoot, cleanPath), repoRoot);
+      if (result) {
+        fullInput = `The user has provided an audio/video file: ${cleanPath}.
+
+Transcription (${result.text.split(" ").length} words, ${result.duration ? result.duration.toFixed(1) + "s" : "unknown duration"}):
+
+${result.text}
+
+Summarize or analyze this transcription as appropriate.`;
+      } else {
+        fullInput = `The user has provided an audio/video file: ${cleanPath}. Use the transcribe_file tool to transcribe it and then summarize the content.`;
+      }
+    }
     if (!carouselRetired && carousel.isRunning) {
       carousel.stop();
       carouselRetired = true;
@@ -14332,19 +15256,6 @@ ${c2.dim("Goodbye!")}
           writeContent(() => renderInfo(`Update available: v${version} \u2192 v${updateInfo.latestVersion}. Installing...`));
           const ok = performSilentUpdate();
           if (ok) {
-            if (lastSubmittedPrompt) {
-              try {
-                savePendingTask(repoRoot, {
-                  prompt: lastSubmittedPrompt,
-                  progressSummary: `Task completed ${sessionToolCallCount} tool calls before update. Last task finished normally.`,
-                  filesModified: sessionFilesTouched,
-                  bruteForce: bruteForceEnabled,
-                  savedAt: (/* @__PURE__ */ new Date()).toISOString(),
-                  toolCallCount: sessionToolCallCount
-                });
-              } catch {
-              }
-            }
             writeContent(() => renderInfo(`Updated to v${updateInfo.latestVersion}. Reloading...
 `));
             process.env.__OA_RESUMED = "1";
@@ -14384,7 +15295,7 @@ ${c2.dim("(Use /quit to exit)")}
   });
 }
 async function runWithTUI(task, config, repoPath) {
-  const repoRoot = resolve12(repoPath ?? cwd());
+  const repoRoot = resolve13(repoPath ?? cwd());
   const needsSetup = isFirstRun() || !await isModelAvailable(config);
   if (needsSetup && config.backendType === "ollama") {
     const setupModel = await runSetupWizard(config);
@@ -14421,6 +15332,7 @@ var init_interactive = __esm({
     "use strict";
     init_dist5();
     init_dist2();
+    init_listen();
     init_updater();
     init_commands();
     init_setup();
@@ -14469,7 +15381,7 @@ import { glob } from "glob";
 import ignore from "ignore";
 import { readFile as readFile9, stat as stat2 } from "node:fs/promises";
 import { createHash } from "node:crypto";
-import { join as join22, relative as relative3, extname as extname6, basename as basename6 } from "node:path";
+import { join as join24, relative as relative3, extname as extname7, basename as basename7 } from "node:path";
 var DEFAULT_EXCLUDE, LANGUAGE_MAP, CodebaseIndexer;
 var init_codebase_indexer = __esm({
   "packages/indexer/dist/codebase-indexer.js"() {
@@ -14513,7 +15425,7 @@ var init_codebase_indexer = __esm({
         const ig = ignore.default();
         if (this.config.respectGitignore) {
           try {
-            const gitignoreContent = await readFile9(join22(this.config.rootDir, ".gitignore"), "utf-8");
+            const gitignoreContent = await readFile9(join24(this.config.rootDir, ".gitignore"), "utf-8");
             ig.add(gitignoreContent);
           } catch {
           }
@@ -14528,14 +15440,14 @@ var init_codebase_indexer = __esm({
         for (const relativePath of files) {
           if (ig.ignores(relativePath))
             continue;
-          const fullPath = join22(this.config.rootDir, relativePath);
+          const fullPath = join24(this.config.rootDir, relativePath);
           try {
             const fileStat = await stat2(fullPath);
             if (fileStat.size > this.config.maxFileSize)
               continue;
             const content = await readFile9(fullPath);
             const hash = createHash("sha256").update(content).digest("hex");
-            const ext = extname6(relativePath);
+            const ext = extname7(relativePath);
             indexed.push({
               path: fullPath,
               relativePath,
@@ -14551,7 +15463,7 @@ var init_codebase_indexer = __esm({
       }
       buildTree(files) {
         const root = {
-          name: basename6(this.config.rootDir),
+          name: basename7(this.config.rootDir),
           path: this.config.rootDir,
           type: "directory",
           children: []
@@ -14574,7 +15486,7 @@ var init_codebase_indexer = __esm({
               if (!child) {
                 child = {
                   name: part,
-                  path: join22(current.path, part),
+                  path: join24(current.path, part),
                   type: "directory",
                   children: []
                 };
@@ -14648,14 +15560,14 @@ var index_repo_exports = {};
 __export(index_repo_exports, {
   indexRepoCommand: () => indexRepoCommand
 });
-import { resolve as resolve13 } from "node:path";
-import { existsSync as existsSync16, statSync as statSync6 } from "node:fs";
+import { resolve as resolve14 } from "node:path";
+import { existsSync as existsSync18, statSync as statSync6 } from "node:fs";
 import { cwd as cwd2 } from "node:process";
 async function indexRepoCommand(opts, _config) {
-  const repoRoot = resolve13(opts.repoPath ?? cwd2());
+  const repoRoot = resolve14(opts.repoPath ?? cwd2());
   printHeader("Index Repository");
   printInfo(`Indexing: ${repoRoot}`);
-  if (!existsSync16(repoRoot)) {
+  if (!existsSync18(repoRoot)) {
     printError(`Path does not exist: ${repoRoot}`);
     process.exit(1);
   }
@@ -14901,8 +15813,8 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { join as join23, resolve as resolve14 } from "node:path";
-import { homedir as homedir9 } from "node:os";
+import { join as join25, resolve as resolve15 } from "node:path";
+import { homedir as homedir11 } from "node:os";
 import { cwd as cwd3 } from "node:process";
 function coerceForSettings(key, value) {
   if (INT_KEYS.has(key))
@@ -14922,7 +15834,7 @@ async function configCommand(opts, config) {
   return handleShow(opts, config);
 }
 function handleShow(opts, config) {
-  const repoRoot = resolve14(opts.repoPath ?? cwd3());
+  const repoRoot = resolve15(opts.repoPath ?? cwd3());
   printHeader("Configuration");
   printSection("Active Settings (merged)");
   printKeyValue("backendUrl", config.backendUrl, 2);
@@ -14954,7 +15866,7 @@ function handleShow(opts, config) {
     }
   }
   printSection("Config File");
-  printInfo(`~/.open-agents/config.json (${join23(homedir9(), ".open-agents", "config.json")})`);
+  printInfo(`~/.open-agents/config.json (${join25(homedir11(), ".open-agents", "config.json")})`);
   printSection("Priority Chain");
   printInfo("  1. CLI flags (--model, --backend-url, etc.)");
   printInfo("  2. Project .oa/settings.json (--local)");
@@ -14987,13 +15899,13 @@ function handleSet(opts, _config) {
     process.exit(1);
   }
   if (opts.local) {
-    const repoRoot = resolve14(opts.repoPath ?? cwd3());
+    const repoRoot = resolve15(opts.repoPath ?? cwd3());
     try {
       initOaDirectory(repoRoot);
       const coerced = coerceForSettings(key, value);
       saveProjectSettings(repoRoot, { [key]: coerced });
       printSuccess(`Project override set: ${key} = ${value}`);
-      printInfo(`Saved to ${join23(repoRoot, ".oa", "settings.json")}`);
+      printInfo(`Saved to ${join25(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)}`);
@@ -15053,7 +15965,7 @@ var serve_exports = {};
 __export(serve_exports, {
   serveCommand: () => serveCommand
 });
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 async function serveCommand(opts, config) {
   const backendType = config.backendType;
   if (backendType === "ollama") {
@@ -15145,8 +16057,8 @@ async function serveVllm(opts, config) {
   await runVllmServer(args, opts.verbose ?? false);
 }
 async function runVllmServer(args, verbose) {
-  return new Promise((resolve15, reject) => {
-    const child = spawn4("python", args, {
+  return new Promise((resolve16, reject) => {
+    const child = spawn6("python", args, {
       stdio: verbose ? "inherit" : ["ignore", "pipe", "pipe"],
       env: { ...process.env }
     });
@@ -15180,10 +16092,10 @@ async function runVllmServer(args, verbose) {
     child.once("exit", (code, signal) => {
       if (signal) {
         printInfo(`vLLM server stopped by signal ${signal}`);
-        resolve15();
+        resolve16();
       } else if (code === 0) {
         printSuccess("vLLM server exited cleanly");
-        resolve15();
+        resolve16();
       } else {
         printError(`vLLM server exited with code ${code}`);
         reject(new Error(`vLLM exited with code ${code}`));
@@ -15211,8 +16123,8 @@ __export(eval_exports, {
   evalCommand: () => evalCommand
 });
 import { tmpdir as tmpdir3 } from "node:os";
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join24 } from "node:path";
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join26 } from "node:path";
 async function evalCommand(opts, config) {
   const suiteName = opts.suite ?? "basic";
   const suite = SUITES[suiteName];
@@ -15333,9 +16245,9 @@ async function evalCommand(opts, config) {
   process.exit(failed > 0 ? 1 : 0);
 }
 function createTempEvalRepo() {
-  const dir = join24(tmpdir3(), `open-agents-eval-${Date.now()}`);
-  mkdirSync9(dir, { recursive: true });
-  writeFileSync8(join24(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
+  const dir = join26(tmpdir3(), `open-agents-eval-${Date.now()}`);
+  mkdirSync11(dir, { recursive: true });
+  writeFileSync10(join26(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
   return dir;
 }
 var BASIC_SUITE, FULL_SUITE, SUITES;
@@ -15395,7 +16307,7 @@ init_updater();
 import { parseArgs as nodeParseArgs2 } from "node:util";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { dirname as dirname4, join as join25 } from "node:path";
+import { dirname as dirname4, join as join27 } from "node:path";
 
 // packages/cli/dist/cli.js
 import { createInterface } from "node:readline";
@@ -15502,7 +16414,7 @@ init_output();
 function getVersion2() {
   try {
     const require2 = createRequire3(import.meta.url);
-    const pkgPath = join25(dirname4(fileURLToPath2(import.meta.url)), "..", "package.json");
+    const pkgPath = join27(dirname4(fileURLToPath2(import.meta.url)), "..", "package.json");
     const pkg = require2(pkgPath);
     return pkg.version;
   } catch {