open-agents-ai 0.104.31 → 0.105.0

package/dist/index.js

@@ -5639,8 +5639,8 @@ function deleteCustomToolDefinition(name, scope, repoRoot) {
   const dir = scope === "project" && repoRoot ? projectToolsDir(repoRoot) : globalToolsDir();
   const filePath = join13(dir, `${name}.json`);
   if (existsSync10(filePath)) {
-    const { unlinkSync: unlinkSync9 } = __require("node:fs");
-    unlinkSync9(filePath);
+    const { unlinkSync: unlinkSync10 } = __require("node:fs");
+    unlinkSync10(filePath);
     return true;
   }
   return false;
@@ -12555,15 +12555,16 @@ async function handleCmd(cmd) {
           riData.auth_key = riAuthKey;
         }
 
+        // Streaming mode: if stream_file is provided, use stream:true and write tokens to file
+        var riStreamFile = args.stream_file || '';
+        var riUseStream = !!riStreamFile;
+
         // If target_peer specified, invoke directly. Otherwise auto-discover.
         if (riTargetPeer) {
-          // Race libp2p direct dial and NATS relay IN PARALLEL.
-          // For cross-NAT peers, libp2p dial can take 10-60s to fail while NATS
-          // succeeds in <1s. Racing them eliminates the wait.
-          dlog('remote_infer: invoking ' + riCapName + ' on peer ' + riTargetPeer.slice(0, 20) + ' (libp2p' + (_natsConn ? ' + NATS parallel' : '') + ')');
+          dlog('remote_infer: invoking ' + riCapName + ' on peer ' + riTargetPeer.slice(0, 20) + ' stream=' + riUseStream + ' (libp2p' + (_natsConn ? ' + NATS parallel' : '') + ')');
           try {
-            var RI_TIMEOUT = 60000;  // 60s outer timeout \u2014 fail fast for interactive use
-            var riInvokeP = nexus.invokeCapability(riTargetPeer, riCapName, riData, { stream: false, maxDurationMs: 45000 });
+            var RI_TIMEOUT = 120000;
+            var riInvokeP = nexus.invokeCapability(riTargetPeer, riCapName, riData, { stream: riUseStream, maxDurationMs: 90000 });
             var riTimeoutP = new Promise(function(_, reject) { setTimeout(function() { reject(new Error('remote_infer timed out after ' + (RI_TIMEOUT / 1000) + 's')); }, RI_TIMEOUT); });
 
             // Build race candidates \u2014 libp2p + timeout always present
@@ -12667,22 +12668,67 @@ async function handleCmd(cmd) {
         }
 
         // riResult and riTargetPeer are available from either path above
-        // Check if the invoke returned an error message instead of real data.
-        // IMPORTANT: Only flag short non-JSON strings as errors. Valid inference
-        // responses are JSON with model/response/choices \u2014 the model's natural
-        // language output often contains words like "error" or "not found" which
-        // would cause false positives if we checked the entire JSON string.
+        // \u2500\u2500 Streaming mode: iterate AsyncGenerator, write tokens to file \u2500\u2500
+        if (riUseStream && riResult && typeof riResult[Symbol.asyncIterator] === 'function') {
+          // Signal OA process that streaming has started
+          writeResp(id, { ok: true, output: JSON.stringify({ streaming: true, stream_file: riStreamFile }) });
+
+          var riTokenContent = '';
+          var riToolCalls = [];
+          var riInputTokens = 0;
+          var riOutputTokens = 0;
+          try {
+            for await (var riEvt of riResult) {
+              if (riEvt.event === 'token' && riEvt.data) {
+                var tkn = typeof riEvt.data === 'string' ? riEvt.data : String(riEvt.data);
+                riTokenContent += tkn;
+                appendFileSync(riStreamFile, JSON.stringify({ type: 'token', content: tkn }) + '
+');
+              } else if (riEvt.event === 'result' && riEvt.data) {
+                // Final metadata event \u2014 parse for usage/tool_calls
+                try {
+                  var riMeta = typeof riEvt.data === 'string' ? JSON.parse(riEvt.data) : riEvt.data;
+                  if (riMeta.usage) {
+                    riInputTokens = riMeta.usage.input_tokens || riMeta.usage.prompt_tokens || 0;
+                    riOutputTokens = riMeta.usage.output_tokens || riMeta.usage.completion_tokens || 0;
+                  }
+                  if (riMeta.choices && riMeta.choices[0] && riMeta.choices[0].message && riMeta.choices[0].message.tool_calls) {
+                    riToolCalls = riMeta.choices[0].message.tool_calls;
+                  }
+                } catch {}
+              }
+            }
+          } catch (riStreamErr) {
+            dlog('remote_infer: stream error: ' + (riStreamErr.message || riStreamErr));
+          }
+
+          // Write done sentinel with final response
+          var riFinalPayload = {
+            model: riModel,
+            response: riTokenContent,
+            choices: [{
+              message: {
+                content: riTokenContent,
+                tool_calls: riToolCalls.length > 0 ? riToolCalls : undefined,
+              },
+            }],
+            usage: { input_tokens: riInputTokens, output_tokens: riOutputTokens },
+          };
+          appendFileSync(riStreamFile, JSON.stringify({ type: 'done', result: JSON.stringify(riFinalPayload) }) + '
+');
+          dlog('remote_infer: stream complete, tokens=' + riTokenContent.length + ' in=' + riInputTokens + ' out=' + riOutputTokens);
+          break;
+        }
+
+        // \u2500\u2500 Unary mode: check for errors and write response \u2500\u2500
         var riIsError = false;
         if (typeof riResult === 'string') {
-          // Try to parse as JSON \u2014 if it has model+response or choices, it's valid
           var riParsedCheck = null;
           try { riParsedCheck = JSON.parse(riResult); } catch {}
           if (riParsedCheck && typeof riParsedCheck === 'object' &&
               (riParsedCheck.model || riParsedCheck.choices || riParsedCheck.response !== undefined)) {
-            // Valid inference response \u2014 NOT an error
             riIsError = false;
           } else {
-            // Non-JSON or unstructured response \u2014 check for error keywords
             var riLower = riResult.toLowerCase();
             if (riLower.includes('unauthorized') || riLower.includes('forbidden') ||
                 riLower.includes('not found') || riLower.includes('error') ||
@@ -13118,12 +13164,15 @@ async function handleCmd(cmd) {
 
                 var genResp, genData, output, inputTokens, outputTokens, responsePayload;
 
+                // Detect if requester wants streaming (outputMode from invoke.open)
+                var wantsStream = request.outputMode === 'stream';
+
                 if (parsedReq && parsedReq.messages && Array.isArray(parsedReq.messages)) {
                   // Structured request \u2014 use /v1/chat/completions (supports tools + multi-turn)
                   var chatBody = {
                     model: model.name,
                     messages: parsedReq.messages,
-                    stream: false,
+                    stream: wantsStream,
                   };
                   if (parsedReq.tools && parsedReq.tools.length > 0) {
                     chatBody.tools = parsedReq.tools;
@@ -13134,41 +13183,117 @@ async function handleCmd(cmd) {
 
                   var chatHeaders = { 'Content-Type': 'application/json' };
                   if (isPassthrough && endpointAuth) chatHeaders['Authorization'] = 'Bearer ' + endpointAuth;
-                  dlog('expose: calling /v1/chat/completions with ' + chatBody.messages.length + ' messages, tools=' + (chatBody.tools ? chatBody.tools.length : 0) + (isPassthrough ? ' (passthrough)' : ''));
+                  dlog('expose: calling /v1/chat/completions with ' + chatBody.messages.length + ' messages, tools=' + (chatBody.tools ? chatBody.tools.length : 0) + ' stream=' + wantsStream + (isPassthrough ? ' (passthrough)' : ''));
                   genResp = await fetch(ollamaUrl + '/v1/chat/completions', {
                     method: 'POST',
                     headers: chatHeaders,
                     body: JSON.stringify(chatBody),
-                    signal: AbortSignal.timeout(210000), // 3.5 min \u2014 upstream API may be slow
+                    signal: AbortSignal.timeout(210000),
                   });
-                  genData = await genResp.json();
-                  dlog('expose: ollama response keys=' + Object.keys(genData).join(',') + ' choices=' + (genData.choices ? genData.choices.length : 0));
-
-                  var chatChoices = genData.choices || [];
-                  var firstMsg = (chatChoices[0] || {}).message || {};
-                  // Strip <think>...</think> tags from content (thinking models)
-                  var rawContent = firstMsg.content || '';
-                  output = rawContent.replace(/<think>[\\s\\S]*?<\\/think>/g, '').trim();
-                  // Fallback: if content is empty but reasoning exists, use reasoning
-                  // (happens when max_tokens is too small for thinking models at temp=0)
-                  if (!output && firstMsg.reasoning) {
-                    output = firstMsg.reasoning;
-                  }
-                  // Update the choices to reflect final content
-                  if (chatChoices[0] && chatChoices[0].message) {
-                    chatChoices[0].message.content = output;
-                  }
-                  dlog('expose: rawContent_len=' + rawContent.length + ' output_len=' + output.length + ' reasoning=' + (firstMsg.reasoning ? firstMsg.reasoning.length : 0) + ' tool_calls=' + (firstMsg.tool_calls ? firstMsg.tool_calls.length : 0));
-                  inputTokens = (genData.usage || {}).prompt_tokens || 0;
-                  outputTokens = (genData.usage || {}).completion_tokens || 0;
 
-                  responsePayload = {
-                    model: model.name,
-                    response: output,
-                    choices: chatChoices,
-                    usage: { input_tokens: inputTokens, output_tokens: outputTokens },
-                    pricing: entry.pricing,
-                  };
+                  if (wantsStream && genResp.ok && genResp.body) {
+                    // \u2500\u2500 SSE streaming path \u2014 read tokens and send as invoke.event \u2500\u2500
+                    var sseReader = genResp.body.getReader();
+                    var sseDecoder = new TextDecoder();
+                    var sseBuf = '';
+                    var sseSeq = 0;
+                    var sseContent = '';
+                    var sseToolCalls = [];
+                    inputTokens = 0;
+                    outputTokens = 0;
+
+                    while (true) {
+                      var sseChunk = await sseReader.read();
+                      if (sseChunk.done) break;
+                      sseBuf += sseDecoder.decode(sseChunk.value, { stream: true });
+                      var sseLines = sseBuf.split('
+');
+                      sseBuf = sseLines.pop();
+
+                      for (var sli = 0; sli < sseLines.length; sli++) {
+                        var sseLine = sseLines[sli];
+                        if (!sseLine.startsWith('data: ')) continue;
+                        var sseData = sseLine.slice(6).trim();
+                        if (sseData === '[DONE]') continue;
+
+                        try {
+                          var sseObj = JSON.parse(sseData);
+                          var sseDelta = (sseObj.choices && sseObj.choices[0] && sseObj.choices[0].delta) || {};
+                          var sseToken = sseDelta.content || '';
+                          if (sseToken) {
+                            sseContent += sseToken;
+                            await swrite({
+                              type: 'invoke.event', version: 1,
+                              requestId: request.requestId, seq: sseSeq++,
+                              event: 'token', data: sseToken,
+                            });
+                          }
+                          // Collect tool calls from streaming deltas
+                          if (sseDelta.tool_calls) {
+                            for (var stci = 0; stci < sseDelta.tool_calls.length; stci++) {
+                              var stc = sseDelta.tool_calls[stci];
+                              if (stc.index !== undefined) {
+                                while (sseToolCalls.length <= stc.index) sseToolCalls.push({ id: '', function: { name: '', arguments: '' } });
+                                if (stc.id) sseToolCalls[stc.index].id = stc.id;
+                                if (stc.function) {
+                                  if (stc.function.name) sseToolCalls[stc.index].function.name = stc.function.name;
+                                  if (stc.function.arguments) sseToolCalls[stc.index].function.arguments += stc.function.arguments;
+                                }
+                              }
+                            }
+                          }
+                          // Capture usage from final chunk
+                          if (sseObj.usage) {
+                            inputTokens = sseObj.usage.prompt_tokens || 0;
+                            outputTokens = sseObj.usage.completion_tokens || 0;
+                          }
+                        } catch (sseParseErr) { /* skip bad SSE lines */ }
+                      }
+                    }
+
+                    // Strip thinking tags from accumulated content
+                    output = sseContent.replace(/<think>[\\s\\S]*?<\\/think>/g, '').trim();
+                    // Build final response payload for the result event
+                    var sseChoices = [{
+                      message: {
+                        content: output,
+                        tool_calls: sseToolCalls.length > 0 ? sseToolCalls : undefined,
+                      },
+                    }];
+                    responsePayload = {
+                      model: model.name,
+                      response: output,
+                      choices: sseChoices,
+                      usage: { input_tokens: inputTokens, output_tokens: outputTokens },
+                      pricing: entry.pricing,
+                    };
+                  } else {
+                    // \u2500\u2500 Unary path (stream: false or streaming not available) \u2500\u2500
+                    genData = await genResp.json();
+                    dlog('expose: ollama response keys=' + Object.keys(genData).join(',') + ' choices=' + (genData.choices ? genData.choices.length : 0));
+
+                    var chatChoices = genData.choices || [];
+                    var firstMsg = (chatChoices[0] || {}).message || {};
+                    var rawContent = firstMsg.content || '';
+                    output = rawContent.replace(/<think>[\\s\\S]*?<\\/think>/g, '').trim();
+                    if (!output && firstMsg.reasoning) {
+                      output = firstMsg.reasoning;
+                    }
+                    if (chatChoices[0] && chatChoices[0].message) {
+                      chatChoices[0].message.content = output;
+                    }
+                    dlog('expose: rawContent_len=' + rawContent.length + ' output_len=' + output.length);
+                    inputTokens = (genData.usage || {}).prompt_tokens || 0;
+                    outputTokens = (genData.usage || {}).completion_tokens || 0;
+
+                    responsePayload = {
+                      model: model.name,
+                      response: output,
+                      choices: chatChoices,
+                      usage: { input_tokens: inputTokens, output_tokens: outputTokens },
+                      pricing: entry.pricing,
+                    };
+                  }
                 } else if (isPassthrough) {
                   // Passthrough flat prompt \u2014 convert to /v1/chat/completions (upstream has no /api/generate)
                   var flatPrompt = parsedReq && parsedReq.prompt ? parsedReq.prompt : (prompt || 'Hello');
@@ -14321,11 +14446,11 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           nodePaths.push(globalDir);
         } catch {
         }
-        const { openSync, closeSync } = await import("node:fs");
+        const { openSync: openSync2, closeSync: closeSync2 } = await import("node:fs");
         const daemonLogPath = join30(this.nexusDir, "daemon.log");
         const daemonErrPath = join30(this.nexusDir, "daemon.err");
-        const outFd = openSync(daemonLogPath, "w");
-        const errFd = openSync(daemonErrPath, "w");
+        const outFd = openSync2(daemonLogPath, "w");
+        const errFd = openSync2(daemonErrPath, "w");
         const child = spawn11("node", [daemonPath, this.nexusDir, agentName, agentType], {
           detached: true,
           stdio: ["ignore", outFd, errFd],
@@ -14334,11 +14459,11 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         });
         child.unref();
         try {
-          closeSync(outFd);
+          closeSync2(outFd);
         } catch {
         }
         try {
-          closeSync(errFd);
+          closeSync2(errFd);
         } catch {
         }
         const statusFile = join30(this.nexusDir, "status.json");
@@ -20059,9 +20184,9 @@ ${marker}` : marker);
         if (!this._workingDirectory)
           return;
         try {
-          const { mkdirSync: mkdirSync21, writeFileSync: writeFileSync19 } = __require("node:fs");
-          const { join: join56 } = __require("node:path");
-          const sessionDir = join56(this._workingDirectory, ".oa", "session", this._sessionId);
+          const { mkdirSync: mkdirSync21, writeFileSync: writeFileSync20 } = __require("node:fs");
+          const { join: join57 } = __require("node:path");
+          const sessionDir = join57(this._workingDirectory, ".oa", "session", this._sessionId);
           mkdirSync21(sessionDir, { recursive: true });
           const checkpoint = {
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -20074,7 +20199,7 @@ ${marker}` : marker);
             memexEntryCount: this._memexArchive.size,
             fileRegistrySize: this._fileRegistry.size
           };
-          writeFileSync19(join56(sessionDir, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
+          writeFileSync20(join57(sessionDir, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
         } catch {
         }
       }
@@ -21340,6 +21465,11 @@ ${transcript}`
 });
 
 // packages/orchestrator/dist/nexusBackend.js
+import { existsSync as existsSync26, statSync as statSync9, openSync, readSync, closeSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync8 } from "node:fs";
+import { watch as fsWatch } from "node:fs";
+import { join as join34 } from "node:path";
+import { tmpdir as tmpdir6 } from "node:os";
+import { randomBytes as randomBytes7 } from "node:crypto";
 var NexusAgenticBackend;
 var init_nexusBackend = __esm({
   "packages/orchestrator/dist/nexusBackend.js"() {
@@ -21475,47 +21605,199 @@ var init_nexusBackend = __esm({
         };
       }
       /**
-       * Simulated streaming: calls chatCompletion() for the full response,
-       * then yields it as word-level StreamChunk objects.
-       * Gives API compatibility with the streaming path in AgenticRunner.
+       * Real streaming: sends remote_infer with a stream_file, then tails
+       * the file for token-by-token delivery from the remote peer.
+       * Falls back to unary + word-split if streaming setup fails.
        */
       async *chatCompletionStream(request) {
-        const response = await this.chatCompletion(request);
-        const choice = response.choices[0];
-        if (!choice)
-          return;
-        const msg = choice.message;
-        if (msg.content) {
-          const words = msg.content.split(/(\s+)/);
-          for (const word of words) {
-            if (word) {
-              yield { type: "content", content: word };
-            }
+        const streamFile = join34(tmpdir6(), `nexus-stream-${randomBytes7(6).toString("hex")}.jsonl`);
+        writeFileSync8(streamFile, "", "utf8");
+        const daemonArgs = {
+          model: this.model,
+          messages: JSON.stringify(request.messages),
+          tools: JSON.stringify(request.tools),
+          temperature: String(request.temperature),
+          max_tokens: String(request.maxTokens),
+          stream_file: streamFile
+        };
+        if (this.targetPeer)
+          daemonArgs.target_peer = this.targetPeer;
+        if (this.authKey)
+          daemonArgs.auth_key = this.authKey;
+        daemonArgs.think = String(this.thinking);
+        let rawResult;
+        try {
+          rawResult = await this.sendFn("remote_infer", daemonArgs, request.timeoutMs || 12e4);
+        } catch (sendErr) {
+          this.consecutiveFailures++;
+          try {
+            unlinkSync3(streamFile);
+          } catch {
           }
+          throw sendErr;
         }
-        if (msg.toolCalls) {
-          for (let i = 0; i < msg.toolCalls.length; i++) {
-            const tc = msg.toolCalls[i];
-            yield {
-              type: "tool_call_delta",
-              toolCallIndex: i,
-              toolCallId: tc.id,
-              toolCallName: tc.name,
-              toolCallArgs: JSON.stringify(tc.arguments)
-            };
+        let isStreaming = false;
+        try {
+          const parsed = JSON.parse(rawResult);
+          if (parsed.streaming === true) {
+            isStreaming = true;
           }
+        } catch {
         }
-        if (response.usage) {
-          yield {
-            type: "usage",
-            usage: {
-              promptTokens: response.usage.promptTokens ?? 0,
-              completionTokens: response.usage.completionTokens ?? 0,
-              totalTokens: response.usage.totalTokens
+        if (!isStreaming) {
+          try {
+            unlinkSync3(streamFile);
+          } catch {
+          }
+          let parsed;
+          try {
+            parsed = JSON.parse(rawResult);
+          } catch {
+            this.consecutiveFailures++;
+            throw new Error(rawResult.slice(0, 500));
+          }
+          if (parsed.success === false) {
+            this.consecutiveFailures++;
+            throw new Error(`Remote inference failed: ${String(parsed.output || rawResult)}`);
+          }
+          this.consecutiveFailures = 0;
+          const invokeResult = parsed.result;
+          let responseData = null;
+          if (typeof invokeResult === "string") {
+            try {
+              responseData = JSON.parse(invokeResult);
+            } catch {
+              responseData = { response: invokeResult };
             }
-          };
+          } else if (invokeResult) {
+            const events = Array.isArray(invokeResult) ? invokeResult : [invokeResult];
+            for (const evt of events) {
+              if (evt.event === "result" && evt.data) {
+                const evtData = evt.data;
+                try {
+                  responseData = typeof evtData === "string" ? JSON.parse(evtData) : evtData;
+                } catch {
+                  responseData = { response: String(evtData) };
+                }
+              }
+            }
+          }
+          const content = responseData ? responseData.response || "" : "";
+          if (content) {
+            const words = content.split(/(\s+)/);
+            for (const word of words) {
+              if (word)
+                yield { type: "content", content: word };
+            }
+          }
+          yield { type: "finish", finishReason: "stop" };
+          return;
+        }
+        this.consecutiveFailures = 0;
+        let position = 0;
+        let done = false;
+        const deadline = Date.now() + (request.timeoutMs ?? 12e4);
+        try {
+          while (!done && Date.now() < deadline) {
+            await new Promise((resolve32) => {
+              let resolved = false;
+              const finish = () => {
+                if (!resolved) {
+                  resolved = true;
+                  resolve32();
+                }
+              };
+              let watcher = null;
+              try {
+                watcher = fsWatch(streamFile, { persistent: false }, () => {
+                  try {
+                    watcher?.close();
+                  } catch {
+                  }
+                  finish();
+                });
+              } catch {
+              }
+              setTimeout(() => {
+                try {
+                  watcher?.close();
+                } catch {
+                }
+                finish();
+              }, 50);
+            });
+            const stat5 = statSync9(streamFile, { throwIfNoEntry: false });
+            if (!stat5 || stat5.size <= position)
+              continue;
+            const fd = openSync(streamFile, "r");
+            const buf = Buffer.allocUnsafe(stat5.size - position);
+            readSync(fd, buf, 0, buf.length, position);
+            closeSync(fd);
+            position = stat5.size;
+            for (const line of buf.toString("utf8").split("\n")) {
+              if (!line.trim())
+                continue;
+              let event;
+              try {
+                event = JSON.parse(line);
+              } catch {
+                continue;
+              }
+              if (event.type === "token" && event.content) {
+                yield { type: "content", content: event.content };
+              } else if (event.type === "done") {
+                done = true;
+                if (event.result) {
+                  try {
+                    const r = JSON.parse(event.result);
+                    const choices = r.choices;
+                    if (choices?.[0]) {
+                      const msg = choices[0].message || {};
+                      const toolCalls = msg.tool_calls || [];
+                      if (toolCalls.length > 0) {
+                        for (let i = 0; i < toolCalls.length; i++) {
+                          const tc = toolCalls[i];
+                          const fn = tc.function || {};
+                          let args;
+                          try {
+                            args = typeof fn.arguments === "string" ? JSON.parse(fn.arguments) : fn.arguments ?? {};
+                          } catch {
+                            args = { _raw: fn.arguments };
+                          }
+                          yield {
+                            type: "tool_call_delta",
+                            toolCallIndex: i,
+                            toolCallId: tc.id || crypto.randomUUID(),
+                            toolCallName: fn.name,
+                            toolCallArgs: JSON.stringify(args)
+                          };
+                        }
+                      }
+                    }
+                    if (r.usage) {
+                      yield {
+                        type: "usage",
+                        usage: {
+                          promptTokens: r.usage.input_tokens ?? r.usage.prompt_tokens ?? 0,
+                          completionTokens: r.usage.output_tokens ?? r.usage.completion_tokens ?? 0,
+                          totalTokens: (r.usage.input_tokens ?? 0) + (r.usage.output_tokens ?? 0)
+                        }
+                      };
+                    }
+                  } catch {
+                  }
+                }
+                yield { type: "finish", finishReason: "stop" };
+                break;
+              }
+            }
+          }
+        } finally {
+          try {
+            unlinkSync3(streamFile);
+          } catch {
+          }
         }
-        yield { type: "finish", finishReason: "stop" };
       }
       extractUsage(data) {
         const usage = data.usage;
@@ -22356,8 +22638,8 @@ __export(listen_exports, {
   waitForTranscribeCli: () => waitForTranscribeCli
 });
 import { spawn as spawn14, execSync as execSync23 } from "node:child_process";
-import { existsSync as existsSync26, mkdirSync as mkdirSync8, writeFileSync as writeFileSync8, readdirSync as readdirSync6 } from "node:fs";
-import { join as join34, dirname as dirname13 } from "node:path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync8, writeFileSync as writeFileSync9, readdirSync as readdirSync6 } from "node:fs";
+import { join as join35, dirname as dirname13 } from "node:path";
 import { homedir as homedir8 } from "node:os";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 import { EventEmitter } from "node:events";
@@ -22443,15 +22725,15 @@ function findMicCaptureCommand() {
 function findLiveWhisperScript() {
   const thisDir = dirname13(fileURLToPath8(import.meta.url));
   const candidates = [
-    join34(thisDir, "../../../../packages/execution/scripts/live-whisper.py"),
-    join34(thisDir, "../../../packages/execution/scripts/live-whisper.py"),
-    join34(thisDir, "../../execution/scripts/live-whisper.py"),
+    join35(thisDir, "../../../../packages/execution/scripts/live-whisper.py"),
+    join35(thisDir, "../../../packages/execution/scripts/live-whisper.py"),
+    join35(thisDir, "../../execution/scripts/live-whisper.py"),
     // npm install layout — scripts bundled alongside dist
-    join34(thisDir, "../scripts/live-whisper.py"),
-    join34(thisDir, "../../scripts/live-whisper.py")
+    join35(thisDir, "../scripts/live-whisper.py"),
+    join35(thisDir, "../../scripts/live-whisper.py")
   ];
   for (const p of candidates) {
-    if (existsSync26(p))
+    if (existsSync27(p))
       return p;
   }
   try {
@@ -22461,21 +22743,21 @@ function findLiveWhisperScript() {
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     const candidates2 = [
-      join34(globalRoot, "open-agents-ai", "dist", "scripts", "live-whisper.py"),
-      join34(globalRoot, "open-agents-ai", "scripts", "live-whisper.py")
+      join35(globalRoot, "open-agents-ai", "dist", "scripts", "live-whisper.py"),
+      join35(globalRoot, "open-agents-ai", "scripts", "live-whisper.py")
     ];
     for (const p of candidates2) {
-      if (existsSync26(p))
+      if (existsSync27(p))
         return p;
     }
   } catch {
   }
-  const nvmBase = join34(homedir8(), ".nvm", "versions", "node");
-  if (existsSync26(nvmBase)) {
+  const nvmBase = join35(homedir8(), ".nvm", "versions", "node");
+  if (existsSync27(nvmBase)) {
     try {
       for (const ver of readdirSync6(nvmBase)) {
-        const p = join34(nvmBase, ver, "lib", "node_modules", "open-agents-ai", "dist", "scripts", "live-whisper.py");
-        if (existsSync26(p))
+        const p = join35(nvmBase, ver, "lib", "node_modules", "open-agents-ai", "dist", "scripts", "live-whisper.py");
+        if (existsSync27(p))
           return p;
       }
     } catch {
@@ -22493,7 +22775,7 @@ function ensureTranscribeCliBackground() {
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      if (existsSync26(join34(globalRoot, "transcribe-cli", "dist", "index.js"))) {
+      if (existsSync27(join35(globalRoot, "transcribe-cli", "dist", "index.js"))) {
         return true;
       }
     } catch {
@@ -22716,24 +22998,24 @@ var init_listen = __esm({
             timeout: 5e3,
             stdio: ["pipe", "pipe", "pipe"]
           }).trim();
-          const tcPath = join34(globalRoot, "transcribe-cli");
-          if (existsSync26(join34(tcPath, "dist", "index.js"))) {
+          const tcPath = join35(globalRoot, "transcribe-cli");
+          if (existsSync27(join35(tcPath, "dist", "index.js"))) {
             const { createRequire: createRequire4 } = await import("node:module");
             const req = createRequire4(import.meta.url);
-            return req(join34(tcPath, "dist", "index.js"));
+            return req(join35(tcPath, "dist", "index.js"));
           }
         } catch {
         }
-        const nvmBase = join34(homedir8(), ".nvm", "versions", "node");
-        if (existsSync26(nvmBase)) {
+        const nvmBase = join35(homedir8(), ".nvm", "versions", "node");
+        if (existsSync27(nvmBase)) {
           try {
             const { readdirSync: readdirSync17 } = await import("node:fs");
             for (const ver of readdirSync17(nvmBase)) {
-              const tcPath = join34(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
-              if (existsSync26(join34(tcPath, "dist", "index.js"))) {
+              const tcPath = join35(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
+              if (existsSync27(join35(tcPath, "dist", "index.js"))) {
                 const { createRequire: createRequire4 } = await import("node:module");
                 const req = createRequire4(import.meta.url);
-                return req(join34(tcPath, "dist", "index.js"));
+                return req(join35(tcPath, "dist", "index.js"));
               }
             }
           } catch {
@@ -23015,10 +23297,10 @@ transcribe-cli error: ${transcribeCliError}` : "";
           });
           if (outputDir) {
             const { basename: basename16 } = await import("node:path");
-            const transcriptDir = join34(outputDir, ".oa", "transcripts");
+            const transcriptDir = join35(outputDir, ".oa", "transcripts");
             mkdirSync8(transcriptDir, { recursive: true });
-            const outFile = join34(transcriptDir, `${basename16(filePath)}.txt`);
-            writeFileSync8(outFile, result.text, "utf-8");
+            const outFile = join35(transcriptDir, `${basename16(filePath)}.txt`);
+            writeFileSync9(outFile, result.text, "utf-8");
           }
           return {
             text: result.text,
@@ -25266,7 +25548,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes10, createHash: createHash5 } = __require("crypto");
+    var { randomBytes: randomBytes11, createHash: createHash5 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate = require_permessage_deflate();
@@ -25796,7 +26078,7 @@ var require_websocket = __commonJS({
         }
       }
       const defaultPort = isSecure ? 443 : 80;
-      const key = randomBytes10(16).toString("base64");
+      const key = randomBytes11(16).toString("base64");
       const request = isSecure ? https.request : http.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
@@ -28371,11 +28653,11 @@ var init_voice_session = __esm({
 import { createServer as createServer2, request as httpRequest } from "node:http";
 import { spawn as spawn16, exec } from "node:child_process";
 import { EventEmitter as EventEmitter3 } from "node:events";
-import { randomBytes as randomBytes7 } from "node:crypto";
+import { randomBytes as randomBytes8 } from "node:crypto";
 import { URL as URL2 } from "node:url";
 import { loadavg, cpus, totalmem, freemem } from "node:os";
-import { existsSync as existsSync27, readFileSync as readFileSync19, writeFileSync as writeFileSync9, unlinkSync as unlinkSync3, mkdirSync as mkdirSync9, readdirSync as readdirSync7, statSync as statSync9 } from "node:fs";
-import { join as join35 } from "node:path";
+import { existsSync as existsSync28, readFileSync as readFileSync19, writeFileSync as writeFileSync10, unlinkSync as unlinkSync4, mkdirSync as mkdirSync9, readdirSync as readdirSync7, statSync as statSync10 } from "node:fs";
+import { join as join36 } from "node:path";
 function cleanForwardHeaders(raw, targetHost) {
   const out = {};
   for (const [key, value] of Object.entries(raw)) {
@@ -28403,8 +28685,8 @@ function fmtTokens(n) {
 }
 function readExposeState(stateDir) {
   try {
-    const path = join35(stateDir, STATE_FILE_NAME);
-    if (!existsSync27(path))
+    const path = join36(stateDir, STATE_FILE_NAME);
+    if (!existsSync28(path))
       return null;
     const raw = readFileSync19(path, "utf8");
     const data = JSON.parse(raw);
@@ -28418,13 +28700,13 @@ function readExposeState(stateDir) {
 function writeExposeState(stateDir, state) {
   try {
     mkdirSync9(stateDir, { recursive: true });
-    writeFileSync9(join35(stateDir, STATE_FILE_NAME), JSON.stringify(state, null, 2));
+    writeFileSync10(join36(stateDir, STATE_FILE_NAME), JSON.stringify(state, null, 2));
   } catch {
   }
 }
 function removeExposeState(stateDir) {
   try {
-    unlinkSync3(join35(stateDir, STATE_FILE_NAME));
+    unlinkSync4(join36(stateDir, STATE_FILE_NAME));
   } catch {
   }
 }
@@ -28513,8 +28795,8 @@ async function collectSystemMetricsAsync() {
 }
 function readP2PExposeState(stateDir) {
   try {
-    const path = join35(stateDir, P2P_STATE_FILE_NAME);
-    if (!existsSync27(path))
+    const path = join36(stateDir, P2P_STATE_FILE_NAME);
+    if (!existsSync28(path))
       return null;
     const raw = readFileSync19(path, "utf8");
     const data = JSON.parse(raw);
@@ -28528,13 +28810,13 @@ function readP2PExposeState(stateDir) {
 function writeP2PExposeState(stateDir, state) {
   try {
     mkdirSync9(stateDir, { recursive: true });
-    writeFileSync9(join35(stateDir, P2P_STATE_FILE_NAME), JSON.stringify(state, null, 2));
+    writeFileSync10(join36(stateDir, P2P_STATE_FILE_NAME), JSON.stringify(state, null, 2));
   } catch {
   }
 }
 function removeP2PExposeState(stateDir) {
   try {
-    unlinkSync3(join35(stateDir, P2P_STATE_FILE_NAME));
+    unlinkSync4(join36(stateDir, P2P_STATE_FILE_NAME));
   } catch {
   }
 }
@@ -28616,7 +28898,7 @@ var init_expose = __esm({
         this._stateDir = options.stateDir ?? null;
         this._fullAccess = options.fullAccess ?? false;
         if (options.authKey === void 0 || options.authKey === "") {
-          this._authKey = randomBytes7(24).toString("base64url");
+          this._authKey = randomBytes8(24).toString("base64url");
         } else {
           this._authKey = options.authKey;
         }
@@ -29324,7 +29606,7 @@ ${this.formatConnectionInfo()}`);
         this._onInfo = options.onInfo;
         this._onError = options.onError;
         if (options.authKey === void 0 || options.authKey === "") {
-          this._authKey = randomBytes7(24).toString("base64url");
+          this._authKey = randomBytes8(24).toString("base64url");
         } else {
           this._authKey = options.authKey;
         }
@@ -29362,7 +29644,7 @@ ${this.formatConnectionInfo()}`);
           throw new Error(`Expose failed: ${exposeResult.error}`);
         }
         const nexusDir = this._nexusTool.getNexusDir();
-        const statusPath = join35(nexusDir, "status.json");
+        const statusPath = join36(nexusDir, "status.json");
         for (let i = 0; i < 80; i++) {
           try {
             const raw = readFileSync19(statusPath, "utf8");
@@ -29396,8 +29678,8 @@ ${this.formatConnectionInfo()}`);
           });
         }
         try {
-          const invocDir = join35(nexusDir, "invocations");
-          if (existsSync27(invocDir)) {
+          const invocDir = join36(nexusDir, "invocations");
+          if (existsSync28(invocDir)) {
             this._prevInvocCount = readdirSync7(invocDir).filter((f) => f.endsWith(".json")).length;
             this._stats.totalRequests = this._prevInvocCount;
           }
@@ -29426,9 +29708,9 @@ ${this.formatConnectionInfo()}`);
         if (!state)
           return null;
         const nexusDir = nexusTool.getNexusDir();
-        const statusPath = join35(nexusDir, "status.json");
+        const statusPath = join36(nexusDir, "status.json");
         try {
-          if (!existsSync27(statusPath)) {
+          if (!existsSync28(statusPath)) {
             removeP2PExposeState(stateDir);
             return null;
           }
@@ -29485,8 +29767,8 @@ ${this.formatConnectionInfo()}`);
         let lastMeteringLineCount = 0;
         this._activityPollTimer = setInterval(() => {
           try {
-            const invocDir = join35(nexusDir, "invocations");
-            if (!existsSync27(invocDir))
+            const invocDir = join36(nexusDir, "invocations");
+            if (!existsSync28(invocDir))
               return;
             const files = readdirSync7(invocDir).filter((f) => f.endsWith(".json"));
             const invocCount = files.length;
@@ -29501,16 +29783,16 @@ ${this.formatConnectionInfo()}`);
             let recentActive = 0;
             for (const f of files.slice(-10)) {
               try {
-                const st = statSync9(join35(invocDir, f));
+                const st = statSync10(join36(invocDir, f));
                 if (now - st.mtimeMs < 1e4)
                   recentActive++;
               } catch {
               }
             }
-            const meteringFile = join35(nexusDir, "metering.jsonl");
+            const meteringFile = join36(nexusDir, "metering.jsonl");
             let meteringLines = lastMeteringLineCount;
             try {
-              if (existsSync27(meteringFile)) {
+              if (existsSync28(meteringFile)) {
                 const content = readFileSync19(meteringFile, "utf8");
                 meteringLines = content.split("\n").filter((l) => l.trim()).length;
               }
@@ -29537,8 +29819,8 @@ ${this.formatConnectionInfo()}`);
         this._activityPollTimer.unref();
         this._pollTimer = setInterval(() => {
           try {
-            const statusPath = join35(nexusDir, "status.json");
-            if (existsSync27(statusPath)) {
+            const statusPath = join36(nexusDir, "status.json");
+            if (existsSync28(statusPath)) {
               const status = JSON.parse(readFileSync19(statusPath, "utf8"));
               if (status.peerId && !this._peerId) {
                 this._peerId = status.peerId;
@@ -29548,8 +29830,8 @@ ${this.formatConnectionInfo()}`);
           } catch {
           }
           try {
-            const invocDir = join35(nexusDir, "invocations");
-            if (existsSync27(invocDir)) {
+            const invocDir = join36(nexusDir, "invocations");
+            if (existsSync28(invocDir)) {
               const files = readdirSync7(invocDir);
               const invocCount = files.filter((f) => f.endsWith(".json")).length;
               if (invocCount > this._stats.totalRequests) {
@@ -29560,8 +29842,8 @@ ${this.formatConnectionInfo()}`);
           } catch {
           }
           try {
-            const meteringFile = join35(nexusDir, "metering.jsonl");
-            if (existsSync27(meteringFile)) {
+            const meteringFile = join36(nexusDir, "metering.jsonl");
+            if (existsSync28(meteringFile)) {
               const content = readFileSync19(meteringFile, "utf8");
               if (content.length > lastMeteringSize) {
                 const newContent = content.slice(lastMeteringSize);
@@ -29778,9 +30060,9 @@ var init_types = __esm({
 });
 
 // packages/cli/dist/tui/p2p/secret-vault.js
-import { createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2, randomBytes as randomBytes8, scryptSync as scryptSync2, createHash as createHash2 } from "node:crypto";
-import { readFileSync as readFileSync20, writeFileSync as writeFileSync10, existsSync as existsSync28, mkdirSync as mkdirSync10 } from "node:fs";
-import { join as join36, dirname as dirname14 } from "node:path";
+import { createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2, randomBytes as randomBytes9, scryptSync as scryptSync2, createHash as createHash2 } from "node:crypto";
+import { readFileSync as readFileSync20, writeFileSync as writeFileSync11, existsSync as existsSync29, mkdirSync as mkdirSync10 } from "node:fs";
+import { join as join37, dirname as dirname14 } from "node:path";
 var PLACEHOLDER_PREFIX, PLACEHOLDER_SUFFIX, CIPHER_ALGO, SALT_LEN, IV_LEN, KEY_LEN, SecretVault;
 var init_secret_vault = __esm({
   "packages/cli/dist/tui/p2p/secret-vault.js"() {
@@ -29984,24 +30266,24 @@ var init_secret_vault = __esm({
           minTrust: s.minTrust,
           createdAt: s.createdAt
         })));
-        const salt = randomBytes8(SALT_LEN);
+        const salt = randomBytes9(SALT_LEN);
         const key = scryptSync2(passphrase, salt, KEY_LEN);
-        const iv = randomBytes8(IV_LEN);
+        const iv = randomBytes9(IV_LEN);
         const cipher = createCipheriv2(CIPHER_ALGO, key, iv);
         const encrypted = Buffer.concat([cipher.update(data, "utf8"), cipher.final()]);
         const tag = cipher.getAuthTag();
         const blob = Buffer.concat([salt, iv, tag, encrypted]);
         const dir = dirname14(this.storePath);
-        if (!existsSync28(dir))
+        if (!existsSync29(dir))
           mkdirSync10(dir, { recursive: true });
-        writeFileSync10(this.storePath, blob, { mode: 384 });
+        writeFileSync11(this.storePath, blob, { mode: 384 });
       }
       /**
        * Load vault from disk, decrypting with the given passphrase.
        * Returns the number of secrets loaded.
        */
       load(passphrase) {
-        if (!this.storePath || !existsSync28(this.storePath))
+        if (!this.storePath || !existsSync29(this.storePath))
           return 0;
         const blob = readFileSync20(this.storePath);
         if (blob.length < SALT_LEN + IV_LEN + 16) {
@@ -30044,7 +30326,7 @@ var init_secret_vault = __esm({
 // packages/cli/dist/tui/p2p/peer-mesh.js
 import { EventEmitter as EventEmitter4 } from "node:events";
 import { createServer as createServer3 } from "node:http";
-import { randomBytes as randomBytes9, createHash as createHash3, generateKeyPairSync } from "node:crypto";
+import { randomBytes as randomBytes10, createHash as createHash3, generateKeyPairSync } from "node:crypto";
 var PING_INTERVAL_MS, PEER_TIMEOUT_MS, GOSSIP_INTERVAL_MS, MAX_PEERS, PeerMesh;
 var init_peer_mesh = __esm({
   "packages/cli/dist/tui/p2p/peer-mesh.js"() {
@@ -30096,7 +30378,7 @@ var init_peer_mesh = __esm({
         this.peerId = createHash3("sha256").update(this.publicKey).digest("base64url").slice(0, 22);
         this.capabilities = options.capabilities;
         this.displayName = options.displayName;
-        this._authKey = options.authKey ?? randomBytes9(24).toString("base64url");
+        this._authKey = options.authKey ?? randomBytes10(24).toString("base64url");
       }
       // ── Lifecycle ───────────────────────────────────────────────────────────
       /** Start the mesh node — creates WS server and connects to bootstrap peers */
@@ -30260,7 +30542,7 @@ var init_peer_mesh = __esm({
         if (!ws || ws.readyState !== import_websocket.default.OPEN) {
           throw new Error(`Peer ${peerId} not connected`);
         }
-        const msgId = randomBytes9(8).toString("hex");
+        const msgId = randomBytes10(8).toString("hex");
         return new Promise((resolve32, reject) => {
           const timeout = setTimeout(() => {
             this.pendingRequests.delete(msgId);
@@ -30481,7 +30763,7 @@ var init_peer_mesh = __esm({
         const msg = {
           type,
           from: this.peerId,
-          msgId: msgId ?? randomBytes9(8).toString("hex"),
+          msgId: msgId ?? randomBytes10(8).toString("hex"),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           payload
         };
@@ -31116,15 +31398,15 @@ async function fetchOpenAIModels(baseUrl, apiKey) {
 async function fetchPeerModels(peerId, authKey) {
   try {
     const { NexusTool: NexusTool2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
-    const { existsSync: existsSync44, readFileSync: readFileSync32 } = await import("node:fs");
-    const { join: join56 } = await import("node:path");
+    const { existsSync: existsSync45, readFileSync: readFileSync32 } = await import("node:fs");
+    const { join: join57 } = await import("node:path");
     const cwd4 = process.cwd();
     const nexusTool = new NexusTool2(cwd4);
     const nexusDir = nexusTool.getNexusDir();
     let isLocalPeer = false;
     try {
-      const statusPath = join56(nexusDir, "status.json");
-      if (existsSync44(statusPath)) {
+      const statusPath = join57(nexusDir, "status.json");
+      if (existsSync45(statusPath)) {
         const status = JSON.parse(readFileSync32(statusPath, "utf8"));
         if (status.peerId === peerId)
           isLocalPeer = true;
@@ -31132,8 +31414,8 @@ async function fetchPeerModels(peerId, authKey) {
     } catch {
     }
     if (isLocalPeer) {
-      const pricingPath = join56(nexusDir, "pricing.json");
-      if (existsSync44(pricingPath)) {
+      const pricingPath = join57(nexusDir, "pricing.json");
+      if (existsSync45(pricingPath)) {
         try {
           const pricing = JSON.parse(readFileSync32(pricingPath, "utf8"));
           const localModels = (pricing.models || []).map((m) => ({
@@ -31149,8 +31431,8 @@ async function fetchPeerModels(peerId, authKey) {
         }
       }
     }
-    const cachePath = join56(nexusDir, "peer-models-cache.json");
-    if (existsSync44(cachePath)) {
+    const cachePath = join57(nexusDir, "peer-models-cache.json");
+    if (existsSync45(cachePath)) {
       try {
         const cache4 = JSON.parse(readFileSync32(cachePath, "utf8"));
         if (cache4.peerId === peerId && cache4.models?.length > 0) {
@@ -31267,8 +31549,8 @@ async function fetchPeerModels(peerId, authKey) {
     } catch {
     }
     if (isLocalPeer) {
-      const pricingPath = join56(nexusDir, "pricing.json");
-      if (existsSync44(pricingPath)) {
+      const pricingPath = join57(nexusDir, "pricing.json");
+      if (existsSync45(pricingPath)) {
         try {
           const pricing = JSON.parse(readFileSync32(pricingPath, "utf8"));
           return (pricing.models || []).map((m) => ({
@@ -31539,14 +31821,14 @@ var init_render2 = __esm({
 });
 
 // packages/prompts/dist/promptLoader.js
-import { readFileSync as readFileSync21, existsSync as existsSync29 } from "node:fs";
-import { join as join37, dirname as dirname15 } from "node:path";
+import { readFileSync as readFileSync21, existsSync as existsSync30 } from "node:fs";
+import { join as join38, dirname as dirname15 } from "node:path";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
 function loadPrompt2(promptPath, vars) {
   let content = cache2.get(promptPath);
   if (content === void 0) {
-    const fullPath = join37(PROMPTS_DIR2, promptPath);
-    if (!existsSync29(fullPath)) {
+    const fullPath = join38(PROMPTS_DIR2, promptPath);
+    if (!existsSync30(fullPath)) {
       throw new Error(`Prompt file not found: ${fullPath}`);
     }
     content = readFileSync21(fullPath, "utf-8");
@@ -31562,9 +31844,9 @@ var init_promptLoader2 = __esm({
     "use strict";
     __filename2 = fileURLToPath9(import.meta.url);
     __dirname5 = dirname15(__filename2);
-    devPath = join37(__dirname5, "..", "templates");
-    publishedPath = join37(__dirname5, "..", "prompts", "templates");
-    PROMPTS_DIR2 = existsSync29(devPath) ? devPath : publishedPath;
+    devPath = join38(__dirname5, "..", "templates");
+    publishedPath = join38(__dirname5, "..", "prompts", "templates");
+    PROMPTS_DIR2 = existsSync30(devPath) ? devPath : publishedPath;
     cache2 = /* @__PURE__ */ new Map();
   }
 });
@@ -31675,7 +31957,7 @@ var init_task_templates = __esm({
 });
 
 // packages/prompts/dist/index.js
-import { join as join38, dirname as dirname16 } from "node:path";
+import { join as join39, dirname as dirname16 } from "node:path";
 import { fileURLToPath as fileURLToPath10 } from "node:url";
 var _dir, _packageRoot;
 var init_dist6 = __esm({
@@ -31686,26 +31968,26 @@ var init_dist6 = __esm({
     init_task_templates();
     init_render2();
     _dir = dirname16(fileURLToPath10(import.meta.url));
-    _packageRoot = join38(_dir, "..");
+    _packageRoot = join39(_dir, "..");
   }
 });
 
 // packages/cli/dist/tui/oa-directory.js
-import { existsSync as existsSync30, mkdirSync as mkdirSync11, readFileSync as readFileSync22, writeFileSync as writeFileSync11, readdirSync as readdirSync8, statSync as statSync10, unlinkSync as unlinkSync4 } from "node:fs";
-import { join as join39, relative as relative2, basename as basename9, extname as extname8 } from "node:path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync11, readFileSync as readFileSync22, writeFileSync as writeFileSync12, readdirSync as readdirSync8, statSync as statSync11, unlinkSync as unlinkSync5 } from "node:fs";
+import { join as join40, relative as relative2, basename as basename9, extname as extname8 } from "node:path";
 import { homedir as homedir9 } from "node:os";
 function initOaDirectory(repoRoot) {
-  const oaPath = join39(repoRoot, OA_DIR);
+  const oaPath = join40(repoRoot, OA_DIR);
   for (const sub of SUBDIRS) {
-    mkdirSync11(join39(oaPath, sub), { recursive: true });
+    mkdirSync11(join40(oaPath, sub), { recursive: true });
   }
   try {
-    const gitignorePath = join39(repoRoot, ".gitignore");
+    const gitignorePath = join40(repoRoot, ".gitignore");
     const settingsPattern = ".oa/settings.json";
-    if (existsSync30(gitignorePath)) {
+    if (existsSync31(gitignorePath)) {
       const content = readFileSync22(gitignorePath, "utf-8");
       if (!content.includes(settingsPattern)) {
-        writeFileSync11(gitignorePath, content.trimEnd() + "\n" + settingsPattern + "\n", "utf-8");
+        writeFileSync12(gitignorePath, content.trimEnd() + "\n" + settingsPattern + "\n", "utf-8");
       }
     }
   } catch {
@@ -31713,12 +31995,12 @@ function initOaDirectory(repoRoot) {
   return oaPath;
 }
 function hasOaDirectory(repoRoot) {
-  return existsSync30(join39(repoRoot, OA_DIR, "index"));
+  return existsSync31(join40(repoRoot, OA_DIR, "index"));
 }
 function loadProjectSettings(repoRoot) {
-  const settingsPath = join39(repoRoot, OA_DIR, "settings.json");
+  const settingsPath = join40(repoRoot, OA_DIR, "settings.json");
   try {
-    if (existsSync30(settingsPath)) {
+    if (existsSync31(settingsPath)) {
       return JSON.parse(readFileSync22(settingsPath, "utf-8"));
     }
   } catch {
@@ -31726,16 +32008,16 @@ function loadProjectSettings(repoRoot) {
   return {};
 }
 function saveProjectSettings(repoRoot, settings) {
-  const oaPath = join39(repoRoot, OA_DIR);
+  const oaPath = join40(repoRoot, OA_DIR);
   mkdirSync11(oaPath, { recursive: true });
   const existing = loadProjectSettings(repoRoot);
   const merged = { ...existing, ...settings };
-  writeFileSync11(join39(oaPath, "settings.json"), JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  writeFileSync12(join40(oaPath, "settings.json"), JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
 }
 function loadGlobalSettings() {
-  const settingsPath = join39(homedir9(), ".open-agents", "settings.json");
+  const settingsPath = join40(homedir9(), ".open-agents", "settings.json");
   try {
-    if (existsSync30(settingsPath)) {
+    if (existsSync31(settingsPath)) {
       return JSON.parse(readFileSync22(settingsPath, "utf-8"));
     }
   } catch {
@@ -31743,11 +32025,11 @@ function loadGlobalSettings() {
   return {};
 }
 function saveGlobalSettings(settings) {
-  const dir = join39(homedir9(), ".open-agents");
+  const dir = join40(homedir9(), ".open-agents");
   mkdirSync11(dir, { recursive: true });
   const existing = loadGlobalSettings();
   const merged = { ...existing, ...settings };
-  writeFileSync11(join39(dir, "settings.json"), JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  writeFileSync12(join40(dir, "settings.json"), JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
 }
 function resolveSettings(repoRoot) {
   const global = loadGlobalSettings();
@@ -31762,9 +32044,9 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
   while (dir && !visited.has(dir)) {
     visited.add(dir);
     for (const name of CONTEXT_FILES) {
-      const filePath = join39(dir, name);
+      const filePath = join40(dir, name);
       const normalizedName = name.toLowerCase();
-      if (existsSync30(filePath) && !seen.has(filePath)) {
+      if (existsSync31(filePath) && !seen.has(filePath)) {
         seen.add(filePath);
         try {
           let content = readFileSync22(filePath, "utf-8");
@@ -31781,8 +32063,8 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
         }
       }
     }
-    const projectMap = join39(dir, OA_DIR, "context", "project-map.md");
-    if (existsSync30(projectMap) && !seen.has(projectMap)) {
+    const projectMap = join40(dir, OA_DIR, "context", "project-map.md");
+    if (existsSync31(projectMap) && !seen.has(projectMap)) {
       seen.add(projectMap);
       try {
         let content = readFileSync22(projectMap, "utf-8");
@@ -31797,7 +32079,7 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
       } catch {
       }
     }
-    const parent = join39(dir, "..");
+    const parent = join40(dir, "..");
     if (parent === dir)
       break;
     dir = parent;
@@ -31815,7 +32097,7 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
   return found;
 }
 function readIndexMeta(repoRoot) {
-  const metaPath = join39(repoRoot, OA_DIR, "index", "meta.json");
+  const metaPath = join40(repoRoot, OA_DIR, "index", "meta.json");
   try {
     return JSON.parse(readFileSync22(metaPath, "utf-8"));
   } catch {
@@ -31868,28 +32150,28 @@ ${tree}\`\`\`
     sections.push("");
   }
   const content = sections.join("\n");
-  const contextDir = join39(repoRoot, OA_DIR, "context");
+  const contextDir = join40(repoRoot, OA_DIR, "context");
   mkdirSync11(contextDir, { recursive: true });
-  writeFileSync11(join39(contextDir, "project-map.md"), content, "utf-8");
+  writeFileSync12(join40(contextDir, "project-map.md"), content, "utf-8");
   return content;
 }
 function saveSession(repoRoot, session) {
-  const historyDir = join39(repoRoot, OA_DIR, "history");
+  const historyDir = join40(repoRoot, OA_DIR, "history");
   mkdirSync11(historyDir, { recursive: true });
-  writeFileSync11(join39(historyDir, `${session.id}.json`), JSON.stringify(session, null, 2), "utf-8");
+  writeFileSync12(join40(historyDir, `${session.id}.json`), JSON.stringify(session, null, 2), "utf-8");
 }
 function loadRecentSessions(repoRoot, limit = 5) {
-  const historyDir = join39(repoRoot, OA_DIR, "history");
-  if (!existsSync30(historyDir))
+  const historyDir = join40(repoRoot, OA_DIR, "history");
+  if (!existsSync31(historyDir))
     return [];
   try {
     const files = readdirSync8(historyDir).filter((f) => f.endsWith(".json") && f !== "pending-task.json").map((f) => {
-      const stat5 = statSync10(join39(historyDir, f));
+      const stat5 = statSync11(join40(historyDir, f));
       return { file: f, mtime: stat5.mtimeMs };
     }).sort((a, b) => b.mtime - a.mtime).slice(0, limit);
     return files.map((f) => {
       try {
-        return JSON.parse(readFileSync22(join39(historyDir, f.file), "utf-8"));
+        return JSON.parse(readFileSync22(join40(historyDir, f.file), "utf-8"));
       } catch {
         return null;
       }
@@ -31899,18 +32181,18 @@ function loadRecentSessions(repoRoot, limit = 5) {
   }
 }
 function savePendingTask(repoRoot, task) {
-  const historyDir = join39(repoRoot, OA_DIR, "history");
+  const historyDir = join40(repoRoot, OA_DIR, "history");
   mkdirSync11(historyDir, { recursive: true });
-  writeFileSync11(join39(historyDir, PENDING_TASK_FILE), JSON.stringify(task, null, 2) + "\n", "utf-8");
+  writeFileSync12(join40(historyDir, PENDING_TASK_FILE), JSON.stringify(task, null, 2) + "\n", "utf-8");
 }
 function loadPendingTask(repoRoot) {
-  const filePath = join39(repoRoot, OA_DIR, "history", PENDING_TASK_FILE);
+  const filePath = join40(repoRoot, OA_DIR, "history", PENDING_TASK_FILE);
   try {
-    if (!existsSync30(filePath))
+    if (!existsSync31(filePath))
       return null;
     const data = JSON.parse(readFileSync22(filePath, "utf-8"));
     try {
-      unlinkSync4(filePath);
+      unlinkSync5(filePath);
     } catch {
     }
     return data;
@@ -31919,12 +32201,12 @@ function loadPendingTask(repoRoot) {
   }
 }
 function saveSessionContext(repoRoot, entry) {
-  const contextDir = join39(repoRoot, OA_DIR, "context");
+  const contextDir = join40(repoRoot, OA_DIR, "context");
   mkdirSync11(contextDir, { recursive: true });
-  const filePath = join39(contextDir, CONTEXT_SAVE_FILE);
+  const filePath = join40(contextDir, CONTEXT_SAVE_FILE);
   let ctx;
   try {
-    if (existsSync30(filePath)) {
+    if (existsSync31(filePath)) {
       ctx = JSON.parse(readFileSync22(filePath, "utf-8"));
     } else {
       ctx = { entries: [], maxEntries: MAX_CONTEXT_ENTRIES, updatedAt: "" };
@@ -31937,12 +32219,12 @@ function saveSessionContext(repoRoot, entry) {
     ctx.entries = ctx.entries.slice(-ctx.maxEntries);
   }
   ctx.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  writeFileSync11(filePath, JSON.stringify(ctx, null, 2) + "\n", "utf-8");
+  writeFileSync12(filePath, JSON.stringify(ctx, null, 2) + "\n", "utf-8");
 }
 function loadSessionContext(repoRoot) {
-  const filePath = join39(repoRoot, OA_DIR, "context", CONTEXT_SAVE_FILE);
+  const filePath = join40(repoRoot, OA_DIR, "context", CONTEXT_SAVE_FILE);
   try {
-    if (!existsSync30(filePath))
+    if (!existsSync31(filePath))
       return null;
     return JSON.parse(readFileSync22(filePath, "utf-8"));
   } catch {
@@ -31991,8 +32273,8 @@ function detectManifests(repoRoot) {
     { file: "docker-compose.yaml", type: "Docker Compose" }
   ];
   for (const check of checks) {
-    const filePath = join39(repoRoot, check.file);
-    if (existsSync30(filePath)) {
+    const filePath = join40(repoRoot, check.file);
+    if (existsSync31(filePath)) {
       let name;
       if (check.nameField) {
         try {
@@ -32025,7 +32307,7 @@ function findKeyFiles(repoRoot) {
     { pattern: "CLAUDE.md", description: "Claude Code context" }
   ];
   for (const check of checks) {
-    if (existsSync30(join39(repoRoot, check.pattern))) {
+    if (existsSync31(join40(repoRoot, check.pattern))) {
       keyFiles.push({ path: check.pattern, description: check.description });
     }
   }
@@ -32051,12 +32333,12 @@ function buildDirTree(root, maxDepth, prefix = "", depth = 0) {
       if (entry.isDirectory()) {
         let fileCount = 0;
         try {
-          fileCount = readdirSync8(join39(root, entry.name)).filter((f) => !f.startsWith(".")).length;
+          fileCount = readdirSync8(join40(root, entry.name)).filter((f) => !f.startsWith(".")).length;
         } catch {
         }
         result += `${prefix}${connector}${entry.name}/ (${fileCount})
 `;
-        result += buildDirTree(join39(root, entry.name), maxDepth, childPrefix, depth + 1);
+        result += buildDirTree(join40(root, entry.name), maxDepth, childPrefix, depth + 1);
       } else if (depth < maxDepth) {
         result += `${prefix}${connector}${entry.name}
 `;
@@ -32068,7 +32350,7 @@ function buildDirTree(root, maxDepth, prefix = "", depth = 0) {
 }
 function loadUsageFile(filePath) {
   try {
-    if (existsSync30(filePath)) {
+    if (existsSync31(filePath)) {
       return JSON.parse(readFileSync22(filePath, "utf-8"));
     }
   } catch {
@@ -32076,9 +32358,9 @@ function loadUsageFile(filePath) {
   return { records: [] };
 }
 function saveUsageFile(filePath, data) {
-  const dir = join39(filePath, "..");
+  const dir = join40(filePath, "..");
   mkdirSync11(dir, { recursive: true });
-  writeFileSync11(filePath, JSON.stringify(data, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  writeFileSync12(filePath, JSON.stringify(data, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
 }
 function recordUsage(kind, value, opts) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -32106,15 +32388,15 @@ function recordUsage(kind, value, opts) {
     }
     saveUsageFile(filePath, data);
   };
-  update(join39(homedir9(), ".open-agents", USAGE_HISTORY_FILE));
+  update(join40(homedir9(), ".open-agents", USAGE_HISTORY_FILE));
   if (opts?.repoRoot) {
-    update(join39(opts.repoRoot, OA_DIR, USAGE_HISTORY_FILE));
+    update(join40(opts.repoRoot, OA_DIR, USAGE_HISTORY_FILE));
   }
 }
 function loadUsageHistory(kind, repoRoot) {
-  const globalPath = join39(homedir9(), ".open-agents", USAGE_HISTORY_FILE);
+  const globalPath = join40(homedir9(), ".open-agents", USAGE_HISTORY_FILE);
   const globalData = loadUsageFile(globalPath);
-  const localData = repoRoot ? loadUsageFile(join39(repoRoot, OA_DIR, USAGE_HISTORY_FILE)) : { records: [] };
+  const localData = repoRoot ? loadUsageFile(join40(repoRoot, OA_DIR, USAGE_HISTORY_FILE)) : { records: [] };
   const map = /* @__PURE__ */ new Map();
   for (const r of globalData.records) {
     if (r.kind !== kind)
@@ -32145,9 +32427,9 @@ function deleteUsageRecord(kind, value, repoRoot) {
       saveUsageFile(filePath, data);
     }
   };
-  remove(join39(homedir9(), ".open-agents", USAGE_HISTORY_FILE));
+  remove(join40(homedir9(), ".open-agents", USAGE_HISTORY_FILE));
   if (repoRoot) {
-    remove(join39(repoRoot, OA_DIR, USAGE_HISTORY_FILE));
+    remove(join40(repoRoot, OA_DIR, USAGE_HISTORY_FILE));
   }
 }
 var OA_DIR, SUBDIRS, CONTEXT_FILES, PENDING_TASK_FILE, CONTEXT_SAVE_FILE, MAX_CONTEXT_ENTRIES, SKIP_DIRS, USAGE_HISTORY_FILE, MAX_HISTORY_RECORDS;
@@ -32197,8 +32479,8 @@ var init_oa_directory = __esm({
 import * as readline from "node:readline";
 import { execSync as execSync25, spawn as spawn17, exec as exec2 } from "node:child_process";
 import { promisify as promisify5 } from "node:util";
-import { existsSync as existsSync31, writeFileSync as writeFileSync12, readFileSync as readFileSync23, appendFileSync as appendFileSync2, mkdirSync as mkdirSync12 } from "node:fs";
-import { join as join40 } from "node:path";
+import { existsSync as existsSync32, writeFileSync as writeFileSync13, readFileSync as readFileSync23, appendFileSync as appendFileSync2, mkdirSync as mkdirSync12 } from "node:fs";
+import { join as join41 } from "node:path";
 import { homedir as homedir10, platform } from "node:os";
 function detectSystemSpecs() {
   let totalRamGB = 0;
@@ -32485,7 +32767,7 @@ async function installOllamaMac(_rl) {
       execSync25('/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"', { stdio: "inherit", timeout: 6e5 });
       if (!hasCmd("brew")) {
         try {
-          const brewPrefix = existsSync31("/opt/homebrew/bin/brew") ? "/opt/homebrew" : "/usr/local";
+          const brewPrefix = existsSync32("/opt/homebrew/bin/brew") ? "/opt/homebrew" : "/usr/local";
           process.env["PATH"] = `${brewPrefix}/bin:${process.env["PATH"]}`;
         } catch {
         }
@@ -33239,10 +33521,10 @@ async function doSetup(config, rl) {
           `PARAMETER num_predict ${numPredict}`,
           `PARAMETER stop "<|endoftext|>"`
         ].join("\n");
-        const modelDir2 = join40(homedir10(), ".open-agents", "models");
+        const modelDir2 = join41(homedir10(), ".open-agents", "models");
         mkdirSync12(modelDir2, { recursive: true });
-        const modelfilePath = join40(modelDir2, `Modelfile.${customName}`);
-        writeFileSync12(modelfilePath, modelfileContent + "\n", "utf8");
+        const modelfilePath = join41(modelDir2, `Modelfile.${customName}`);
+        writeFileSync13(modelfilePath, modelfileContent + "\n", "utf8");
         process.stdout.write(`  ${c2.dim("Creating model...")} `);
         execSync25(`ollama create ${customName} -f ${modelfilePath}`, {
           stdio: "pipe",
@@ -33287,7 +33569,7 @@ async function isModelAvailable(config) {
 }
 function isFirstRun() {
   try {
-    return !existsSync31(join40(homedir10(), ".open-agents", "config.json"));
+    return !existsSync32(join41(homedir10(), ".open-agents", "config.json"));
   } catch {
     return true;
   }
@@ -33324,7 +33606,7 @@ function detectPkgManager() {
   return null;
 }
 function getVenvDir() {
-  return join40(homedir10(), ".open-agents", "venv");
+  return join41(homedir10(), ".open-agents", "venv");
 }
 function hasVenvModule() {
   try {
@@ -33336,8 +33618,8 @@ function hasVenvModule() {
 }
 function ensureVenv(log) {
   const venvDir = getVenvDir();
-  const venvPip = join40(venvDir, "bin", "pip");
-  if (existsSync31(venvPip))
+  const venvPip = join41(venvDir, "bin", "pip");
+  if (existsSync32(venvPip))
     return venvDir;
   log("Creating Python venv for vision deps...");
   if (!hasCmd("python3")) {
@@ -33349,9 +33631,9 @@ function ensureVenv(log) {
     return null;
   }
   try {
-    mkdirSync12(join40(homedir10(), ".open-agents"), { recursive: true });
+    mkdirSync12(join41(homedir10(), ".open-agents"), { recursive: true });
     execSync25(`python3 -m venv "${venvDir}"`, { stdio: "pipe", timeout: 3e4 });
-    execSync25(`"${join40(venvDir, "bin", "pip")}" install --upgrade pip`, {
+    execSync25(`"${join41(venvDir, "bin", "pip")}" install --upgrade pip`, {
       stdio: "pipe",
       timeout: 6e4
     });
@@ -33542,15 +33824,15 @@ async function ensureVisionDeps(onInfo, getSudoPassword) {
     }
   }
   const venvDir = getVenvDir();
-  const venvBin = join40(venvDir, "bin");
-  const venvMoondream = join40(venvBin, "moondream-station");
+  const venvBin = join41(venvDir, "bin");
+  const venvMoondream = join41(venvBin, "moondream-station");
   const venv = ensureVenv(log);
-  if (venv && !hasCmd("moondream-station") && !existsSync31(venvMoondream)) {
-    const venvPip = join40(venvBin, "pip");
+  if (venv && !hasCmd("moondream-station") && !existsSync32(venvMoondream)) {
+    const venvPip = join41(venvBin, "pip");
     log("Installing moondream-station in ~/.open-agents/venv...");
     try {
       execSync25(`"${venvPip}" install moondream-station`, { stdio: "pipe", timeout: 3e5 });
-      if (existsSync31(venvMoondream)) {
+      if (existsSync32(venvMoondream)) {
         log("moondream-station installed successfully.");
       } else {
         try {
@@ -33567,8 +33849,8 @@ async function ensureVisionDeps(onInfo, getSudoPassword) {
     }
   }
   if (venv) {
-    const venvPython = join40(venvBin, "python");
-    const venvPip2 = join40(venvBin, "pip");
+    const venvPython = join41(venvBin, "python");
+    const venvPip2 = join41(venvBin, "pip");
     let ocrStackInstalled = false;
     try {
       execSync25(`"${venvPython}" -c "import cv2, pytesseract, numpy, PIL"`, { stdio: "pipe", timeout: 1e4 });
@@ -33712,10 +33994,10 @@ async function createExpandedVariantAsync(baseModel, specs, sizeGB, kvBytesPerTo
       `PARAMETER num_predict ${numPredict}`,
       `PARAMETER stop "<|endoftext|>"`
     ].join("\n");
-    const modelDir2 = join40(homedir10(), ".open-agents", "models");
+    const modelDir2 = join41(homedir10(), ".open-agents", "models");
     mkdirSync12(modelDir2, { recursive: true });
-    const modelfilePath = join40(modelDir2, `Modelfile.${customName}`);
-    writeFileSync12(modelfilePath, modelfileContent + "\n", "utf8");
+    const modelfilePath = join41(modelDir2, `Modelfile.${customName}`);
+    writeFileSync13(modelfilePath, modelfileContent + "\n", "utf8");
     await execAsync(`ollama create ${customName} -f ${modelfilePath}`, {
       timeout: 12e4
     });
@@ -33789,8 +34071,8 @@ async function ensureNeovim() {
   const platform5 = process.platform;
   const arch = process.arch;
   if (platform5 === "linux") {
-    const binDir = join40(homedir10(), ".local", "bin");
-    const nvimDest = join40(binDir, "nvim");
+    const binDir = join41(homedir10(), ".local", "bin");
+    const nvimDest = join41(binDir, "nvim");
     try {
       mkdirSync12(binDir, { recursive: true });
     } catch {
@@ -33861,9 +34143,9 @@ async function ensureNeovim() {
 }
 function ensurePathInShellRc(binDir) {
   const shell = process.env.SHELL ?? "";
-  const rcFile = shell.includes("zsh") ? join40(homedir10(), ".zshrc") : join40(homedir10(), ".bashrc");
+  const rcFile = shell.includes("zsh") ? join41(homedir10(), ".zshrc") : join41(homedir10(), ".bashrc");
   try {
-    const rcContent = existsSync31(rcFile) ? readFileSync23(rcFile, "utf8") : "";
+    const rcContent = existsSync32(rcFile) ? readFileSync23(rcFile, "utf8") : "";
     if (rcContent.includes(binDir))
       return;
     const exportLine = `
@@ -34445,7 +34727,7 @@ var init_tui_select = __esm({
 });
 
 // packages/cli/dist/tui/drop-panel.js
-import { existsSync as existsSync32 } from "node:fs";
+import { existsSync as existsSync33 } from "node:fs";
 import { extname as extname9, resolve as resolve27 } from "node:path";
 function ansi4(code, text) {
   return isTTY4 ? `\x1B[${code}m${text}\x1B[0m` : text;
@@ -34560,7 +34842,7 @@ function showDropPanel(opts) {
         filePath = decodeURIComponent(filePath.slice(7));
       }
       filePath = resolve27(filePath);
-      if (!existsSync32(filePath)) {
+      if (!existsSync33(filePath)) {
         errorMsg = `File not found: ${filePath}`;
         render();
         return;
@@ -34631,9 +34913,9 @@ var init_drop_panel = __esm({
 });
 
 // packages/cli/dist/tui/neovim-mode.js
-import { existsSync as existsSync33, unlinkSync as unlinkSync5 } from "node:fs";
-import { tmpdir as tmpdir6 } from "node:os";
-import { join as join41 } from "node:path";
+import { existsSync as existsSync34, unlinkSync as unlinkSync6 } from "node:fs";
+import { tmpdir as tmpdir7 } from "node:os";
+import { join as join42 } from "node:path";
 import { execSync as execSync26 } from "node:child_process";
 function isNeovimActive() {
   return _state !== null && !_state.cleanedUp;
@@ -34681,10 +34963,10 @@ async function startNeovimMode(opts) {
     );
   } catch {
   }
-  const socketPath = join41(tmpdir6(), `oa-nvim-${process.pid}-${Date.now()}.sock`);
+  const socketPath = join42(tmpdir7(), `oa-nvim-${process.pid}-${Date.now()}.sock`);
   try {
-    if (existsSync33(socketPath))
-      unlinkSync5(socketPath);
+    if (existsSync34(socketPath))
+      unlinkSync6(socketPath);
   } catch {
   }
   const ptyCols = opts.cols;
@@ -34834,13 +35116,13 @@ function resizeNeovim(cols, contentRows) {
 }
 async function connectRPC(state, neovimPkg, cols) {
   let attempts = 0;
-  while (!existsSync33(state.socketPath) && attempts < 30) {
+  while (!existsSync34(state.socketPath) && attempts < 30) {
     await new Promise((r) => setTimeout(r, 200));
     attempts++;
     if (state.cleanedUp)
       return;
   }
-  if (!existsSync33(state.socketPath))
+  if (!existsSync34(state.socketPath))
     return;
   const nvim = neovimPkg.attach({ socket: state.socketPath });
   state.nvim = nvim;
@@ -34976,8 +35258,8 @@ function doCleanup(state) {
     state.pty = null;
   }
   try {
-    if (existsSync33(state.socketPath))
-      unlinkSync5(state.socketPath);
+    if (existsSync34(state.socketPath))
+      unlinkSync6(state.socketPath);
   } catch {
   }
   if (state.stdinHandler) {
@@ -35032,9 +35314,9 @@ __export(voice_exports, {
   registerCustomOnnxModel: () => registerCustomOnnxModel,
   resetNarrationContext: () => resetNarrationContext
 });
-import { existsSync as existsSync34, mkdirSync as mkdirSync13, writeFileSync as writeFileSync13, readFileSync as readFileSync24, unlinkSync as unlinkSync6, readdirSync as readdirSync9, renameSync, statSync as statSync11 } from "node:fs";
-import { join as join42 } from "node:path";
-import { homedir as homedir11, tmpdir as tmpdir7, platform as platform2 } from "node:os";
+import { existsSync as existsSync35, mkdirSync as mkdirSync13, writeFileSync as writeFileSync14, readFileSync as readFileSync24, unlinkSync as unlinkSync7, readdirSync as readdirSync9, renameSync, statSync as statSync12 } from "node:fs";
+import { join as join43 } from "node:path";
+import { homedir as homedir11, tmpdir as tmpdir8, platform as platform2 } from "node:os";
 import { execSync as execSync27, spawn as nodeSpawn } from "node:child_process";
 import { createRequire } from "node:module";
 function registerCustomOnnxModel(id, label) {
@@ -35055,34 +35337,34 @@ function listVoiceModels() {
   }));
 }
 function voiceDir() {
-  return join42(homedir11(), ".open-agents", "voice");
+  return join43(homedir11(), ".open-agents", "voice");
 }
 function modelsDir() {
-  return join42(voiceDir(), "models");
+  return join43(voiceDir(), "models");
 }
 function modelDir(id) {
-  return join42(modelsDir(), id);
+  return join43(modelsDir(), id);
 }
 function modelOnnxPath(id) {
-  return join42(modelDir(id), "model.onnx");
+  return join43(modelDir(id), "model.onnx");
 }
 function modelConfigPath(id) {
-  return join42(modelDir(id), "config.json");
+  return join43(modelDir(id), "config.json");
 }
 function luxttsVenvDir() {
-  return join42(voiceDir(), "luxtts-venv");
+  return join43(voiceDir(), "luxtts-venv");
 }
 function luxttsVenvPy() {
-  return platform2() === "win32" ? join42(luxttsVenvDir(), "Scripts", "python.exe") : join42(luxttsVenvDir(), "bin", "python3");
+  return platform2() === "win32" ? join43(luxttsVenvDir(), "Scripts", "python.exe") : join43(luxttsVenvDir(), "bin", "python3");
 }
 function luxttsRepoDir() {
-  return join42(voiceDir(), "LuxTTS");
+  return join43(voiceDir(), "LuxTTS");
 }
 function luxttsCloneRefsDir() {
-  return join42(voiceDir(), "clone-refs");
+  return join43(voiceDir(), "clone-refs");
 }
 function luxttsInferScript() {
-  return join42(voiceDir(), "luxtts-infer.py");
+  return join43(voiceDir(), "luxtts-infer.py");
 }
 function emotionToPitchBias(emotion, stark = false, autist = false) {
   if (autist)
@@ -35890,8 +36172,8 @@ var init_voice = __esm({
         const refsDir = luxttsCloneRefsDir();
         const targets = ["glados", "overwatch"];
         for (const modelId of targets) {
-          const refFile = join42(refsDir, `${modelId}-ref.wav`);
-          if (existsSync34(refFile))
+          const refFile = join43(refsDir, `${modelId}-ref.wav`);
+          if (existsSync35(refFile))
             continue;
           try {
             await this.generateCloneRef(modelId);
@@ -35970,24 +36252,24 @@ var init_voice = __esm({
         }
         p = p.replace(/\\ /g, " ");
         if (p.startsWith("~/") || p === "~") {
-          p = join42(homedir11(), p.slice(1));
+          p = join43(homedir11(), p.slice(1));
         }
-        if (!existsSync34(p)) {
+        if (!existsSync35(p)) {
           return `File not found: ${p}
   (original input: ${audioPath})`;
         }
         audioPath = p;
         const refsDir = luxttsCloneRefsDir();
-        if (!existsSync34(refsDir))
+        if (!existsSync35(refsDir))
           mkdirSync13(refsDir, { recursive: true });
         const ext = audioPath.split(".").pop() || "wav";
         const srcName = (audioPath.split("/").pop() ?? "clone").replace(/\.[^.]+$/, "").replace(/[^a-zA-Z0-9_-]/g, "-");
         const ts = Date.now().toString(36);
         const destFilename = `clone-${srcName}-${ts}.${ext}`;
-        const destPath = join42(refsDir, destFilename);
+        const destPath = join43(refsDir, destFilename);
         try {
           const data = readFileSync24(audioPath);
-          writeFileSync13(destPath, data);
+          writeFileSync14(destPath, data);
         } catch (err) {
           return `Failed to copy audio file: ${err instanceof Error ? err.message : String(err)}`;
         }
@@ -36027,9 +36309,9 @@ var init_voice = __esm({
             return `Failed to synthesize reference audio from ${source.label}.`;
           }
           const refsDir = luxttsCloneRefsDir();
-          if (!existsSync34(refsDir))
+          if (!existsSync35(refsDir))
             mkdirSync13(refsDir, { recursive: true });
-          const destPath = join42(refsDir, `${sourceModelId}-ref.wav`);
+          const destPath = join43(refsDir, `${sourceModelId}-ref.wav`);
           const sampleRate = this.config?.audio?.sample_rate ?? 22050;
           this.writeWav(audioData, sampleRate, destPath);
           this.luxttsCloneRef = destPath;
@@ -36045,11 +36327,11 @@ var init_voice = __esm({
       // -------------------------------------------------------------------------
       /** Metadata file for friendly names of clone refs */
       static cloneMetaFile() {
-        return join42(luxttsCloneRefsDir(), "meta.json");
+        return join43(luxttsCloneRefsDir(), "meta.json");
       }
       loadCloneMeta() {
         const p = _VoiceEngine.cloneMetaFile();
-        if (!existsSync34(p))
+        if (!existsSync35(p))
           return {};
         try {
           return JSON.parse(readFileSync24(p, "utf8"));
@@ -36059,9 +36341,9 @@ var init_voice = __esm({
       }
       saveCloneMeta(meta) {
         const dir = luxttsCloneRefsDir();
-        if (!existsSync34(dir))
+        if (!existsSync35(dir))
           mkdirSync13(dir, { recursive: true });
-        writeFileSync13(_VoiceEngine.cloneMetaFile(), JSON.stringify(meta, null, 2));
+        writeFileSync14(_VoiceEngine.cloneMetaFile(), JSON.stringify(meta, null, 2));
       }
       /** Audio file extensions recognized as clone references */
       static AUDIO_EXTS = /* @__PURE__ */ new Set(["wav", "mp3", "ogg", "flac", "m4a", "opus", "aac"]);
@@ -36071,7 +36353,7 @@ var init_voice = __esm({
        */
       listCloneRefs() {
         const dir = luxttsCloneRefsDir();
-        if (!existsSync34(dir))
+        if (!existsSync35(dir))
           return [];
         const meta = this.loadCloneMeta();
         const files = readdirSync9(dir).filter((f) => {
@@ -36079,10 +36361,10 @@ var init_voice = __esm({
           return _VoiceEngine.AUDIO_EXTS.has(ext);
         });
         return files.map((f) => {
-          const p = join42(dir, f);
+          const p = join43(dir, f);
           let size = 0;
           try {
-            size = statSync11(p).size;
+            size = statSync12(p).size;
           } catch {
           }
           return {
@@ -36096,11 +36378,11 @@ var init_voice = __esm({
       }
       /** Delete a clone reference file by filename. Returns true if deleted. */
       deleteCloneRef(filename) {
-        const p = join42(luxttsCloneRefsDir(), filename);
-        if (!existsSync34(p))
+        const p = join43(luxttsCloneRefsDir(), filename);
+        if (!existsSync35(p))
           return false;
         try {
-          unlinkSync6(p);
+          unlinkSync7(p);
           const meta = this.loadCloneMeta();
           delete meta[filename];
           this.saveCloneMeta(meta);
@@ -36121,8 +36403,8 @@ var init_voice = __esm({
       }
       /** Set the active clone reference by filename. */
       setActiveCloneRef(filename) {
-        const p = join42(luxttsCloneRefsDir(), filename);
-        if (!existsSync34(p))
+        const p = join43(luxttsCloneRefsDir(), filename);
+        if (!existsSync35(p))
           return `File not found: ${filename}`;
         this.luxttsCloneRef = p;
         return `Active clone voice set to: ${filename}`;
@@ -36407,11 +36689,11 @@ var init_voice = __esm({
           }
           this.onPCMOutput(Buffer.from(int16.buffer), sampleRate);
         }
-        const wavPath = join42(tmpdir7(), `oa-voice-${Date.now()}.wav`);
+        const wavPath = join43(tmpdir8(), `oa-voice-${Date.now()}.wav`);
         this.writeWav(audioData, sampleRate, wavPath);
         await this.playWav(wavPath);
         try {
-          unlinkSync6(wavPath);
+          unlinkSync7(wavPath);
         } catch {
         }
       }
@@ -36545,7 +36827,7 @@ var init_voice = __esm({
         return buffer;
       }
       writeWav(samples, sampleRate, path) {
-        writeFileSync13(path, this.buildWavBuffer(samples, sampleRate));
+        writeFileSync14(path, this.buildWavBuffer(samples, sampleRate));
       }
       // -------------------------------------------------------------------------
       // Audio playback (system default speakers)
@@ -36656,7 +36938,7 @@ var init_voice = __esm({
         return new Promise((resolve32, reject) => {
           const proc = nodeSpawn("sh", ["-c", command], {
             stdio: ["ignore", "pipe", "pipe"],
-            cwd: tmpdir7()
+            cwd: tmpdir8()
           });
           let stdout = "";
           let stderr = "";
@@ -36750,7 +37032,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
         const mlxModelId = model.mlxModelId ?? "mlx-community/Kokoro-82M-bf16";
         const mlxVoice = model.mlxVoice ?? "af_heart";
         const mlxLangCode = model.mlxLangCode ?? "a";
-        const wavPath = join42(tmpdir7(), `oa-mlx-${Date.now()}.wav`);
+        const wavPath = join43(tmpdir8(), `oa-mlx-${Date.now()}.wav`);
         const pyScript = [
           "import sys, json",
           "from mlx_audio.tts import generate as tts_gen",
@@ -36758,16 +37040,16 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
           `tts_gen.main(["--model", ${JSON.stringify(mlxModelId)}, "--text", text, "--voice", ${JSON.stringify(mlxVoice)}, "--lang_code", ${JSON.stringify(mlxLangCode)}, "--audio_path", ${JSON.stringify(wavPath)}])`
         ].join("; ");
         try {
-          execSync27(`${py} -c ${JSON.stringify(pyScript)} ${JSON.stringify(JSON.stringify(cleaned))}`, { stdio: "pipe", timeout: 6e4, cwd: tmpdir7() });
+          execSync27(`${py} -c ${JSON.stringify(pyScript)} ${JSON.stringify(JSON.stringify(cleaned))}`, { stdio: "pipe", timeout: 6e4, cwd: tmpdir8() });
         } catch (err) {
           try {
             const safeText = cleaned.replace(/'/g, "'\\''");
-            execSync27(`${py} -m mlx_audio.tts.generate --model ${mlxModelId} --text '${safeText}' --voice ${mlxVoice} --lang_code ${mlxLangCode} --audio_path ${JSON.stringify(wavPath)}`, { stdio: "pipe", timeout: 6e4, cwd: tmpdir7() });
+            execSync27(`${py} -m mlx_audio.tts.generate --model ${mlxModelId} --text '${safeText}' --voice ${mlxVoice} --lang_code ${mlxLangCode} --audio_path ${JSON.stringify(wavPath)}`, { stdio: "pipe", timeout: 6e4, cwd: tmpdir8() });
           } catch (err2) {
             return;
           }
         }
-        if (!existsSync34(wavPath))
+        if (!existsSync35(wavPath))
           return;
         if (volume !== 1) {
           try {
@@ -36779,7 +37061,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
                 samples[i] = Math.round(samples[i] * volume);
               }
               const scaled = Buffer.concat([header, Buffer.from(samples.buffer, samples.byteOffset, samples.byteLength)]);
-              writeFileSync13(wavPath, scaled);
+              writeFileSync14(wavPath, scaled);
             }
           } catch {
           }
@@ -36797,7 +37079,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
         }
         await this.playWav(wavPath);
         try {
-          unlinkSync6(wavPath);
+          unlinkSync7(wavPath);
         } catch {
         }
       }
@@ -36818,7 +37100,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
         const mlxModelId = model.mlxModelId ?? "mlx-community/Kokoro-82M-bf16";
         const mlxVoice = model.mlxVoice ?? "af_heart";
         const mlxLangCode = model.mlxLangCode ?? "a";
-        const wavPath = join42(tmpdir7(), `oa-mlx-buf-${Date.now()}.wav`);
+        const wavPath = join43(tmpdir8(), `oa-mlx-buf-${Date.now()}.wav`);
         const pyScript = [
           "import sys, json",
           "from mlx_audio.tts import generate as tts_gen",
@@ -36826,20 +37108,20 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
           `tts_gen.main(["--model", ${JSON.stringify(mlxModelId)}, "--text", text, "--voice", ${JSON.stringify(mlxVoice)}, "--lang_code", ${JSON.stringify(mlxLangCode)}, "--audio_path", ${JSON.stringify(wavPath)}])`
         ].join("; ");
         try {
-          execSync27(`${py} -c ${JSON.stringify(pyScript)} ${JSON.stringify(JSON.stringify(cleaned))}`, { stdio: "pipe", timeout: 6e4, cwd: tmpdir7() });
+          execSync27(`${py} -c ${JSON.stringify(pyScript)} ${JSON.stringify(JSON.stringify(cleaned))}`, { stdio: "pipe", timeout: 6e4, cwd: tmpdir8() });
         } catch {
           try {
             const safeText = cleaned.replace(/'/g, "'\\''");
-            execSync27(`${py} -m mlx_audio.tts.generate --model ${mlxModelId} --text '${safeText}' --voice ${mlxVoice} --lang_code ${mlxLangCode} --audio_path ${JSON.stringify(wavPath)}`, { stdio: "pipe", timeout: 6e4, cwd: tmpdir7() });
+            execSync27(`${py} -m mlx_audio.tts.generate --model ${mlxModelId} --text '${safeText}' --voice ${mlxVoice} --lang_code ${mlxLangCode} --audio_path ${JSON.stringify(wavPath)}`, { stdio: "pipe", timeout: 6e4, cwd: tmpdir8() });
           } catch {
             return null;
           }
         }
-        if (!existsSync34(wavPath))
+        if (!existsSync35(wavPath))
           return null;
         try {
           const data = readFileSync24(wavPath);
-          unlinkSync6(wavPath);
+          unlinkSync7(wavPath);
           return data;
         } catch {
           return null;
@@ -36861,7 +37143,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
         }
         const venvDir = luxttsVenvDir();
         const venvPy = luxttsVenvPy();
-        if (existsSync34(venvPy)) {
+        if (existsSync35(venvPy)) {
           try {
             await this.asyncShell(`${venvPy} -c "import sys; sys.path.insert(0, '${luxttsRepoDir()}'); from zipvoice.luxvoice import LuxTTS; print('ok')"`, 3e4);
             let hasCudaSys = false;
@@ -36891,7 +37173,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
           }
         }
         renderInfo("Setting up LuxTTS voice cloning (first-time setup, this takes several minutes)...");
-        if (!existsSync34(venvDir)) {
+        if (!existsSync35(venvDir)) {
           renderInfo("  Creating Python virtual environment...");
           try {
             await this.asyncShell(`${py} -m venv ${JSON.stringify(venvDir)}`, 6e4);
@@ -36929,10 +37211,10 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
           }
         }
         const repoDir = luxttsRepoDir();
-        if (!existsSync34(join42(repoDir, "zipvoice", "luxvoice.py"))) {
+        if (!existsSync35(join43(repoDir, "zipvoice", "luxvoice.py"))) {
           renderInfo("  Cloning LuxTTS repository...");
           try {
-            if (existsSync34(repoDir)) {
+            if (existsSync35(repoDir)) {
               await this.asyncShell(`rm -rf ${JSON.stringify(repoDir)}`, 3e4);
             }
             await this.asyncShell(`git clone --depth 1 https://github.com/ysharma3501/LuxTTS.git ${JSON.stringify(repoDir)}`, 12e4);
@@ -36972,14 +37254,14 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
       }
       /** Auto-detect an existing clone reference in the refs directory */
       autoDetectCloneRef() {
-        if (this.luxttsCloneRef && existsSync34(this.luxttsCloneRef))
+        if (this.luxttsCloneRef && existsSync35(this.luxttsCloneRef))
           return;
         const refsDir = luxttsCloneRefsDir();
-        if (!existsSync34(refsDir))
+        if (!existsSync35(refsDir))
           return;
         for (const name of ["custom-clone.wav", "custom-clone.mp3", "glados-ref.wav", "overwatch-ref.wav"]) {
-          const p = join42(refsDir, name);
-          if (existsSync34(p)) {
+          const p = join43(refsDir, name);
+          if (existsSync35(p)) {
             this.luxttsCloneRef = p;
             return;
           }
@@ -37080,20 +37362,20 @@ if __name__ == '__main__':
 `;
         const scriptPath2 = luxttsInferScript();
         mkdirSync13(voiceDir(), { recursive: true });
-        writeFileSync13(scriptPath2, script);
+        writeFileSync14(scriptPath2, script);
       }
       /** Ensure the LuxTTS daemon is running, spawn if needed */
       async ensureLuxttsDaemon() {
         if (this._luxttsDaemon && !this._luxttsDaemon.killed)
           return true;
         const venvPy = luxttsVenvPy();
-        if (!existsSync34(venvPy))
+        if (!existsSync35(venvPy))
           return false;
         return new Promise((resolve32) => {
           const env = { ...process.env, LUXTTS_REPO_PATH: luxttsRepoDir() };
           const daemon = nodeSpawn(venvPy, [luxttsInferScript()], {
             stdio: ["pipe", "pipe", "pipe"],
-            cwd: tmpdir7(),
+            cwd: tmpdir8(),
             env
           });
           this._luxttsDaemon = daemon;
@@ -37166,7 +37448,7 @@ if __name__ == '__main__':
        * Volume is applied via WAV sample scaling.
        */
       async synthesizeWithLuxtts(text, volume = 1, pitchFactor = 1, speedFactor = 1) {
-        if (!this.luxttsCloneRef || !existsSync34(this.luxttsCloneRef)) {
+        if (!this.luxttsCloneRef || !existsSync35(this.luxttsCloneRef)) {
           return;
         }
         const cleaned = text.replace(/\*/g, "").trim();
@@ -37175,7 +37457,7 @@ if __name__ == '__main__':
         const ready = await this.ensureLuxttsDaemon();
         if (!ready)
           return;
-        const wavPath = join42(tmpdir7(), `oa-luxtts-${Date.now()}.wav`);
+        const wavPath = join43(tmpdir8(), `oa-luxtts-${Date.now()}.wav`);
         try {
           await this.luxttsRequest({
             action: "synthesize",
@@ -37187,7 +37469,7 @@ if __name__ == '__main__':
         } catch {
           return;
         }
-        if (!existsSync34(wavPath))
+        if (!existsSync35(wavPath))
           return;
         if (volume !== 1) {
           try {
@@ -37199,7 +37481,7 @@ if __name__ == '__main__':
               }
               const header = wavData.subarray(0, 44);
               const scaled = Buffer.concat([header, Buffer.from(samples.buffer, samples.byteOffset, samples.byteLength)]);
-              writeFileSync13(wavPath, scaled);
+              writeFileSync14(wavPath, scaled);
             }
           } catch {
           }
@@ -37232,7 +37514,7 @@ if __name__ == '__main__':
         }
         await this.playWav(wavPath);
         try {
-          unlinkSync6(wavPath);
+          unlinkSync7(wavPath);
         } catch {
         }
       }
@@ -37241,7 +37523,7 @@ if __name__ == '__main__':
        * Used for Telegram voice messages and WebSocket streaming.
        */
       async synthesizeLuxttsToBuffer(text) {
-        if (!this.luxttsCloneRef || !existsSync34(this.luxttsCloneRef))
+        if (!this.luxttsCloneRef || !existsSync35(this.luxttsCloneRef))
           return null;
         const cleaned = text.replace(/\*/g, "").trim();
         if (!cleaned)
@@ -37249,7 +37531,7 @@ if __name__ == '__main__':
         const ready = await this.ensureLuxttsDaemon();
         if (!ready)
           return null;
-        const wavPath = join42(tmpdir7(), `oa-luxtts-buf-${Date.now()}.wav`);
+        const wavPath = join43(tmpdir8(), `oa-luxtts-buf-${Date.now()}.wav`);
         try {
           await this.luxttsRequest({
             action: "synthesize",
@@ -37261,11 +37543,11 @@ if __name__ == '__main__':
         } catch {
           return null;
         }
-        if (!existsSync34(wavPath))
+        if (!existsSync35(wavPath))
           return null;
         try {
           const data = readFileSync24(wavPath);
-          unlinkSync6(wavPath);
+          unlinkSync7(wavPath);
           return data;
         } catch {
           return null;
@@ -37279,40 +37561,40 @@ if __name__ == '__main__':
           return;
         const arch = process.arch;
         mkdirSync13(voiceDir(), { recursive: true });
-        const pkgPath = join42(voiceDir(), "package.json");
+        const pkgPath = join43(voiceDir(), "package.json");
         const expectedDeps = {
           "onnxruntime-node": "^1.21.0",
           "phonemizer": "^1.2.1"
         };
-        if (existsSync34(pkgPath)) {
+        if (existsSync35(pkgPath)) {
           try {
             const existing = JSON.parse(readFileSync24(pkgPath, "utf8"));
             if (!existing.dependencies?.["phonemizer"]) {
               existing.dependencies = { ...existing.dependencies, ...expectedDeps };
-              writeFileSync13(pkgPath, JSON.stringify(existing, null, 2));
+              writeFileSync14(pkgPath, JSON.stringify(existing, null, 2));
             }
           } catch {
           }
         }
-        if (!existsSync34(pkgPath)) {
-          writeFileSync13(pkgPath, JSON.stringify({
+        if (!existsSync35(pkgPath)) {
+          writeFileSync14(pkgPath, JSON.stringify({
             name: "open-agents-voice",
             private: true,
             dependencies: expectedDeps
           }, null, 2));
         }
-        const voiceRequire = createRequire(join42(voiceDir(), "index.js"));
+        const voiceRequire = createRequire(join43(voiceDir(), "index.js"));
         const probeOnnx = () => {
           try {
-            const result = execSync27(`node -e "try { require('onnxruntime-node'); console.log('OK'); } catch(e) { console.log('FAIL:' + e.message); }"`, { cwd: voiceDir(), stdio: "pipe", timeout: 15e3, env: { ...process.env, NODE_PATH: join42(voiceDir(), "node_modules") } });
+            const result = execSync27(`node -e "try { require('onnxruntime-node'); console.log('OK'); } catch(e) { console.log('FAIL:' + e.message); }"`, { cwd: voiceDir(), stdio: "pipe", timeout: 15e3, env: { ...process.env, NODE_PATH: join43(voiceDir(), "node_modules") } });
             const output = result.toString().trim();
             return output === "OK";
           } catch {
             return false;
           }
         };
-        const onnxNodeModules = join42(voiceDir(), "node_modules", "onnxruntime-node");
-        const onnxInstalled = existsSync34(onnxNodeModules);
+        const onnxNodeModules = join43(voiceDir(), "node_modules", "onnxruntime-node");
+        const onnxInstalled = existsSync35(onnxNodeModules);
         if (onnxInstalled && !probeOnnx()) {
           throw new Error(`Voice synthesis unavailable: ONNX runtime crashes on this CPU (${process.platform}-${arch}). This is a known issue with some ARM SoCs where the CPU vendor is not recognized. Voice feedback will be disabled but all other features work normally.`);
         }
@@ -37370,18 +37652,18 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
         const dir = modelDir(id);
         const onnxPath = modelOnnxPath(id);
         const configPath = modelConfigPath(id);
-        if (existsSync34(onnxPath) && existsSync34(configPath))
+        if (existsSync35(onnxPath) && existsSync35(configPath))
           return;
         mkdirSync13(dir, { recursive: true });
-        if (!existsSync34(configPath)) {
+        if (!existsSync35(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();
-          writeFileSync13(configPath, configText);
+          writeFileSync14(configPath, configText);
         }
-        if (!existsSync34(onnxPath)) {
+        if (!existsSync35(onnxPath)) {
           renderInfo(`Downloading ${model.label} voice model (this may take a minute)...`);
           const onnxResp = await fetch(model.onnxUrl);
           if (!onnxResp.ok)
@@ -37406,7 +37688,7 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
             }
           }
           const fullBuffer = Buffer.concat(chunks);
-          writeFileSync13(onnxPath, fullBuffer);
+          writeFileSync14(onnxPath, fullBuffer);
           renderInfo(`${model.label} model downloaded (${formatBytes2(fullBuffer.length)}).`);
         }
       }
@@ -37418,7 +37700,7 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
           throw new Error("ONNX runtime not loaded");
         const onnxPath = modelOnnxPath(this.modelId);
         const configPath = modelConfigPath(this.modelId);
-        if (!existsSync34(onnxPath) || !existsSync34(configPath)) {
+        if (!existsSync35(onnxPath) || !existsSync35(configPath)) {
           throw new Error(`Model files not found for ${this.modelId}`);
         }
         this.config = JSON.parse(readFileSync24(configPath, "utf8"));
@@ -39654,11 +39936,11 @@ async function handlePeerEndpoint(peerId, authKey, ctx, local) {
     const models = await fetchModels(peerUrl, authKey);
     if (models.length > 0) {
       try {
-        const { writeFileSync: writeFileSync19, mkdirSync: mkdirSync21 } = await import("node:fs");
-        const { join: join56, dirname: dirname20 } = await import("node:path");
-        const cachePath = join56(ctx.repoRoot || process.cwd(), ".oa", "nexus", "peer-models-cache.json");
+        const { writeFileSync: writeFileSync20, mkdirSync: mkdirSync21 } = await import("node:fs");
+        const { join: join57, dirname: dirname20 } = await import("node:path");
+        const cachePath = join57(ctx.repoRoot || process.cwd(), ".oa", "nexus", "peer-models-cache.json");
         mkdirSync21(dirname20(cachePath), { recursive: true });
-        writeFileSync19(cachePath, JSON.stringify({
+        writeFileSync20(cachePath, JSON.stringify({
           peerId,
           cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
           models: models.map((m) => ({ name: m.name, size: m.size, parameterSize: m.parameterSize }))
@@ -39857,17 +40139,17 @@ async function handleUpdate(subcommand, ctx) {
   try {
     const { createRequire: createRequire4 } = await import("node:module");
     const { fileURLToPath: fileURLToPath14 } = await import("node:url");
-    const { dirname: dirname20, join: join56 } = await import("node:path");
-    const { existsSync: existsSync44 } = await import("node:fs");
+    const { dirname: dirname20, join: join57 } = await import("node:path");
+    const { existsSync: existsSync45 } = await import("node:fs");
     const req = createRequire4(import.meta.url);
     const thisDir = dirname20(fileURLToPath14(import.meta.url));
     const candidates = [
-      join56(thisDir, "..", "package.json"),
-      join56(thisDir, "..", "..", "package.json"),
-      join56(thisDir, "..", "..", "..", "package.json")
+      join57(thisDir, "..", "package.json"),
+      join57(thisDir, "..", "..", "package.json"),
+      join57(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync44(pkgPath)) {
+      if (existsSync45(pkgPath)) {
         const pkg = req(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           currentVersion = pkg.version ?? "0.0.0";
@@ -40433,8 +40715,8 @@ var init_commands = __esm({
 });
 
 // packages/cli/dist/tui/project-context.js
-import { existsSync as existsSync35, readFileSync as readFileSync25, readdirSync as readdirSync10 } from "node:fs";
-import { join as join43, basename as basename10 } from "node:path";
+import { existsSync as existsSync36, readFileSync as readFileSync25, readdirSync as readdirSync10 } from "node:fs";
+import { join as join44, basename as basename10 } from "node:path";
 import { execSync as execSync28 } from "node:child_process";
 import { homedir as homedir12, platform as platform3, release } from "node:os";
 function getModelTier(modelName) {
@@ -40469,8 +40751,8 @@ function loadProjectMap(repoRoot) {
   if (!hasOaDirectory(repoRoot)) {
     initOaDirectory(repoRoot);
   }
-  const mapPath = join43(repoRoot, OA_DIR, "context", "project-map.md");
-  if (existsSync35(mapPath)) {
+  const mapPath = join44(repoRoot, OA_DIR, "context", "project-map.md");
+  if (existsSync36(mapPath)) {
     try {
       const content = readFileSync25(mapPath, "utf-8");
       return content;
@@ -40513,31 +40795,31 @@ ${log}`);
 }
 function loadMemoryContext(repoRoot) {
   const sections = [];
-  const oaMemDir = join43(repoRoot, OA_DIR, "memory");
+  const oaMemDir = join44(repoRoot, OA_DIR, "memory");
   const oaEntries = loadMemoryDir(oaMemDir, "project");
   if (oaEntries)
     sections.push(oaEntries);
-  const legacyMemDir = join43(repoRoot, ".open-agents", "memory");
-  if (legacyMemDir !== oaMemDir && existsSync35(legacyMemDir)) {
+  const legacyMemDir = join44(repoRoot, ".open-agents", "memory");
+  if (legacyMemDir !== oaMemDir && existsSync36(legacyMemDir)) {
     const legacyEntries = loadMemoryDir(legacyMemDir, "project/legacy");
     if (legacyEntries)
       sections.push(legacyEntries);
   }
-  const globalMemDir = join43(homedir12(), ".open-agents", "memory");
+  const globalMemDir = join44(homedir12(), ".open-agents", "memory");
   const globalEntries = loadMemoryDir(globalMemDir, "global");
   if (globalEntries)
     sections.push(globalEntries);
   return sections.join("\n\n");
 }
 function loadMemoryDir(memDir, scope) {
-  if (!existsSync35(memDir))
+  if (!existsSync36(memDir))
     return "";
   const lines = [];
   try {
     const files = readdirSync10(memDir).filter((f) => f.endsWith(".json"));
     for (const file of files.slice(0, 10)) {
       try {
-        const raw = readFileSync25(join43(memDir, file), "utf-8");
+        const raw = readFileSync25(join44(memDir, file), "utf-8");
         const entries = JSON.parse(raw);
         const topic = basename10(file, ".json");
         const keys = Object.keys(entries);
@@ -41560,12 +41842,12 @@ var init_carousel = __esm({
 });
 
 // packages/cli/dist/tui/carousel-descriptors.js
-import { existsSync as existsSync36, readFileSync as readFileSync26, writeFileSync as writeFileSync14, mkdirSync as mkdirSync14, readdirSync as readdirSync11 } from "node:fs";
-import { join as join44, basename as basename11 } from "node:path";
+import { existsSync as existsSync37, readFileSync as readFileSync26, writeFileSync as writeFileSync15, mkdirSync as mkdirSync14, readdirSync as readdirSync11 } from "node:fs";
+import { join as join45, basename as basename11 } from "node:path";
 function loadToolProfile(repoRoot) {
-  const filePath = join44(repoRoot, OA_DIR, "context", TOOL_PROFILE_FILE);
+  const filePath = join45(repoRoot, OA_DIR, "context", TOOL_PROFILE_FILE);
   try {
-    if (!existsSync36(filePath))
+    if (!existsSync37(filePath))
       return null;
     return JSON.parse(readFileSync26(filePath, "utf-8"));
   } catch {
@@ -41573,9 +41855,9 @@ function loadToolProfile(repoRoot) {
   }
 }
 function saveToolProfile(repoRoot, profile) {
-  const contextDir = join44(repoRoot, OA_DIR, "context");
+  const contextDir = join45(repoRoot, OA_DIR, "context");
   mkdirSync14(contextDir, { recursive: true });
-  writeFileSync14(join44(contextDir, TOOL_PROFILE_FILE), JSON.stringify(profile, null, 2), "utf-8");
+  writeFileSync15(join45(contextDir, TOOL_PROFILE_FILE), JSON.stringify(profile, null, 2), "utf-8");
 }
 function categorizeToolCall(toolName) {
   for (const cat of TOOL_CATEGORIES) {
@@ -41633,9 +41915,9 @@ function weightedColor(profile) {
   return selectedCat.colors[Math.floor(Math.random() * selectedCat.colors.length)];
 }
 function loadCachedDescriptors(repoRoot) {
-  const filePath = join44(repoRoot, OA_DIR, "context", DESCRIPTOR_FILE);
+  const filePath = join45(repoRoot, OA_DIR, "context", DESCRIPTOR_FILE);
   try {
-    if (!existsSync36(filePath))
+    if (!existsSync37(filePath))
       return null;
     const cached = JSON.parse(readFileSync26(filePath, "utf-8"));
     return cached.phrases.length > 0 ? cached.phrases : null;
@@ -41644,14 +41926,14 @@ function loadCachedDescriptors(repoRoot) {
   }
 }
 function saveCachedDescriptors(repoRoot, phrases, sourceHash) {
-  const contextDir = join44(repoRoot, OA_DIR, "context");
+  const contextDir = join45(repoRoot, OA_DIR, "context");
   mkdirSync14(contextDir, { recursive: true });
   const cached = {
     phrases,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     sourceHash
   };
-  writeFileSync14(join44(contextDir, DESCRIPTOR_FILE), JSON.stringify(cached, null, 2), "utf-8");
+  writeFileSync15(join45(contextDir, DESCRIPTOR_FILE), JSON.stringify(cached, null, 2), "utf-8");
 }
 function generateDescriptors(repoRoot) {
   const profile = loadToolProfile(repoRoot);
@@ -41699,9 +41981,9 @@ function generateDescriptors(repoRoot) {
   return phrases;
 }
 function extractFromPackageJson(repoRoot, tags) {
-  const pkgPath = join44(repoRoot, "package.json");
+  const pkgPath = join45(repoRoot, "package.json");
   try {
-    if (!existsSync36(pkgPath))
+    if (!existsSync37(pkgPath))
       return;
     const pkg = JSON.parse(readFileSync26(pkgPath, "utf-8"));
     if (pkg.name && typeof pkg.name === "string") {
@@ -41747,7 +42029,7 @@ function extractFromManifests(repoRoot, tags) {
     { file: ".github/workflows", tag: "ci/cd" }
   ];
   for (const check of manifestChecks) {
-    if (existsSync36(join44(repoRoot, check.file))) {
+    if (existsSync37(join45(repoRoot, check.file))) {
       tags.push(check.tag);
     }
   }
@@ -41769,16 +42051,16 @@ function extractFromSessions(repoRoot, tags) {
   }
 }
 function extractFromMemory(repoRoot, tags) {
-  const memoryDir = join44(repoRoot, OA_DIR, "memory");
+  const memoryDir = join45(repoRoot, OA_DIR, "memory");
   try {
-    if (!existsSync36(memoryDir))
+    if (!existsSync37(memoryDir))
       return;
     const files = readdirSync11(memoryDir).filter((f) => f.endsWith(".json"));
     for (const file of files) {
       const topic = file.replace(/\.json$/, "").replace(/[-_]/g, " ");
       tags.push(topic);
       try {
-        const data = JSON.parse(readFileSync26(join44(memoryDir, file), "utf-8"));
+        const data = JSON.parse(readFileSync26(join45(memoryDir, file), "utf-8"));
         if (data && typeof data === "object") {
           const keys = Object.keys(data).slice(0, 3);
           for (const key of keys) {
@@ -42401,10 +42683,10 @@ var init_stream_renderer = __esm({
 
 // packages/cli/dist/tui/edit-history.js
 import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync15 } from "node:fs";
-import { join as join45 } from "node:path";
+import { join as join46 } from "node:path";
 function createEditHistoryLogger(repoRoot, sessionId) {
-  const historyDir = join45(repoRoot, ".oa", "history");
-  const logPath = join45(historyDir, "edits.jsonl");
+  const historyDir = join46(repoRoot, ".oa", "history");
+  const logPath = join46(historyDir, "edits.jsonl");
   try {
     mkdirSync15(historyDir, { recursive: true });
   } catch {
@@ -42515,14 +42797,14 @@ var init_edit_history = __esm({
 });
 
 // packages/cli/dist/tui/promptLoader.js
-import { readFileSync as readFileSync27, existsSync as existsSync37 } from "node:fs";
-import { join as join46, dirname as dirname17 } from "node:path";
+import { readFileSync as readFileSync27, existsSync as existsSync38 } from "node:fs";
+import { join as join47, dirname as dirname17 } from "node:path";
 import { fileURLToPath as fileURLToPath11 } from "node:url";
 function loadPrompt3(promptPath, vars) {
   let content = cache3.get(promptPath);
   if (content === void 0) {
-    const fullPath = join46(PROMPTS_DIR3, promptPath);
-    if (!existsSync37(fullPath)) {
+    const fullPath = join47(PROMPTS_DIR3, promptPath);
+    if (!existsSync38(fullPath)) {
       throw new Error(`Prompt file not found: ${fullPath}`);
     }
     content = readFileSync27(fullPath, "utf-8");
@@ -42538,20 +42820,20 @@ var init_promptLoader3 = __esm({
     "use strict";
     __filename3 = fileURLToPath11(import.meta.url);
     __dirname6 = dirname17(__filename3);
-    devPath2 = join46(__dirname6, "..", "..", "prompts");
-    publishedPath2 = join46(__dirname6, "..", "prompts");
-    PROMPTS_DIR3 = existsSync37(devPath2) ? devPath2 : publishedPath2;
+    devPath2 = join47(__dirname6, "..", "..", "prompts");
+    publishedPath2 = join47(__dirname6, "..", "prompts");
+    PROMPTS_DIR3 = existsSync38(devPath2) ? devPath2 : publishedPath2;
     cache3 = /* @__PURE__ */ new Map();
   }
 });
 
 // packages/cli/dist/tui/dream-engine.js
-import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync15, readFileSync as readFileSync28, existsSync as existsSync38, cpSync, rmSync, readdirSync as readdirSync12 } from "node:fs";
-import { join as join47, basename as basename12 } from "node:path";
+import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync16, readFileSync as readFileSync28, existsSync as existsSync39, cpSync, rmSync, readdirSync as readdirSync12 } from "node:fs";
+import { join as join48, basename as basename12 } from "node:path";
 import { execSync as execSync29 } from "node:child_process";
 function loadAutoresearchMemory(repoRoot) {
-  const memoryPath = join47(repoRoot, ".oa", "memory", "autoresearch.json");
-  if (!existsSync38(memoryPath))
+  const memoryPath = join48(repoRoot, ".oa", "memory", "autoresearch.json");
+  if (!existsSync39(memoryPath))
     return "";
   try {
     const raw = readFileSync28(memoryPath, "utf-8");
@@ -42744,14 +43026,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/autoresearch") ? join47(this.autoresearchDir, basename12(rawPath)) : join47(this.autoresearchDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/autoresearch") ? join48(this.autoresearchDir, basename12(rawPath)) : join48(this.autoresearchDir, rawPath);
         if (!targetPath.startsWith(this.autoresearchDir)) {
           return { success: false, output: "", error: "Autoresearch mode: writes are confined to .oa/autoresearch/", durationMs: Date.now() - start };
         }
         try {
-          const dir = join47(targetPath, "..");
+          const dir = join48(targetPath, "..");
           mkdirSync16(dir, { recursive: true });
-          writeFileSync15(targetPath, content, "utf-8");
+          writeFileSync16(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 };
@@ -42779,12 +43061,12 @@ var init_dream_engine = __esm({
         const rawPath = String(args["path"] ?? "");
         const oldStr = String(args["old_string"] ?? "");
         const newStr = String(args["new_string"] ?? "");
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/autoresearch") ? join47(this.autoresearchDir, basename12(rawPath)) : join47(this.autoresearchDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/autoresearch") ? join48(this.autoresearchDir, basename12(rawPath)) : join48(this.autoresearchDir, rawPath);
         if (!targetPath.startsWith(this.autoresearchDir)) {
           return { success: false, output: "", error: "Autoresearch mode: edits are confined to .oa/autoresearch/", durationMs: Date.now() - start };
         }
         try {
-          if (!existsSync38(targetPath)) {
+          if (!existsSync39(targetPath)) {
             return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: Date.now() - start };
           }
           let content = readFileSync28(targetPath, "utf-8");
@@ -42792,7 +43074,7 @@ var init_dream_engine = __esm({
             return { success: false, output: "", error: "old_string not found in file", durationMs: Date.now() - start };
           }
           content = content.replace(oldStr, newStr);
-          writeFileSync15(targetPath, content, "utf-8");
+          writeFileSync16(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 };
@@ -42833,14 +43115,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") ? join47(this.dreamsDir, basename12(rawPath)) : join47(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join48(this.dreamsDir, basename12(rawPath)) : join48(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 = join47(targetPath, "..");
+          const dir = join48(targetPath, "..");
           mkdirSync16(dir, { recursive: true });
-          writeFileSync15(targetPath, content, "utf-8");
+          writeFileSync16(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 };
@@ -42868,12 +43150,12 @@ var init_dream_engine = __esm({
         const rawPath = String(args["path"] ?? "");
         const oldStr = String(args["old_string"] ?? "");
         const newStr = String(args["new_string"] ?? "");
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join47(this.dreamsDir, basename12(rawPath)) : join47(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join48(this.dreamsDir, basename12(rawPath)) : join48(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 (!existsSync38(targetPath)) {
+          if (!existsSync39(targetPath)) {
             return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: Date.now() - start };
           }
           let content = readFileSync28(targetPath, "utf-8");
@@ -42881,7 +43163,7 @@ var init_dream_engine = __esm({
             return { success: false, output: "", error: "old_string not found in file", durationMs: Date.now() - start };
           }
           content = content.replace(oldStr, newStr);
-          writeFileSync15(targetPath, content, "utf-8");
+          writeFileSync16(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 };
@@ -42935,7 +43217,7 @@ var init_dream_engine = __esm({
       constructor(config, repoRoot) {
         this.config = config;
         this.repoRoot = repoRoot;
-        this.dreamsDir = join47(repoRoot, ".oa", "dreams");
+        this.dreamsDir = join48(repoRoot, ".oa", "dreams");
         this.state = {
           mode: "default",
           active: false,
@@ -43019,8 +43301,8 @@ ${result.summary}`;
             if (mode !== "default" || cycle === totalCycles) {
               renderDreamContraction(cycle);
               const cycleSummary = this.buildCycleSummary(cycle, previousFindings);
-              const summaryPath = join47(this.dreamsDir, `cycle-${cycle}-summary.md`);
-              writeFileSync15(summaryPath, cycleSummary, "utf-8");
+              const summaryPath = join48(this.dreamsDir, `cycle-${cycle}-summary.md`);
+              writeFileSync16(summaryPath, cycleSummary, "utf-8");
             }
             if (mode === "lucid" && !this.abortController.signal.aborted) {
               this.saveVersionCheckpoint(cycle);
@@ -43232,7 +43514,7 @@ After synthesis, call task_complete with the final prioritized summary.`, toolMo
       }
       /** Build role-specific tool sets for swarm agents */
       buildSwarmTools(role, _workspace) {
-        const autoresearchDir = join47(this.repoRoot, ".oa", "autoresearch");
+        const autoresearchDir = join48(this.repoRoot, ".oa", "autoresearch");
         const taskComplete = this.createSwarmTaskCompleteTool(role);
         switch (role) {
           case "researcher": {
@@ -43596,7 +43878,7 @@ INSTRUCTIONS:
 2. Summarize the key learnings and next steps
 
 Call task_complete with a human-readable summary of the autoresearch session.`, workspace, onEvent);
-        const reportPath = join47(this.dreamsDir, `cycle-${cycleNum}-autoresearch-report.md`);
+        const reportPath = join48(this.dreamsDir, `cycle-${cycleNum}-autoresearch-report.md`);
         const report = `# Autoresearch Swarm Report \u2014 Cycle ${cycleNum}
 
 **Date**: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
@@ -43619,7 +43901,7 @@ ${summaryResult}
 `;
         try {
           mkdirSync16(this.dreamsDir, { recursive: true });
-          writeFileSync15(reportPath, report, "utf-8");
+          writeFileSync16(reportPath, report, "utf-8");
         } catch {
         }
         renderSwarmComplete(workspace);
@@ -43685,7 +43967,7 @@ ${summaryResult}
       }
       /** Save workspace backup for lucid mode */
       saveVersionCheckpoint(cycle) {
-        const checkpointDir = join47(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
+        const checkpointDir = join48(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
         try {
           mkdirSync16(checkpointDir, { recursive: true });
           try {
@@ -43704,10 +43986,10 @@ ${summaryResult}
               encoding: "utf-8",
               timeout: 5e3
             }).trim();
-            writeFileSync15(join47(checkpointDir, "git-status.txt"), gitStatus, "utf-8");
-            writeFileSync15(join47(checkpointDir, "git-diff.patch"), gitDiff, "utf-8");
-            writeFileSync15(join47(checkpointDir, "git-hash.txt"), gitHash, "utf-8");
-            writeFileSync15(join47(checkpointDir, "checkpoint.json"), JSON.stringify({
+            writeFileSync16(join48(checkpointDir, "git-status.txt"), gitStatus, "utf-8");
+            writeFileSync16(join48(checkpointDir, "git-diff.patch"), gitDiff, "utf-8");
+            writeFileSync16(join48(checkpointDir, "git-hash.txt"), gitHash, "utf-8");
+            writeFileSync16(join48(checkpointDir, "checkpoint.json"), JSON.stringify({
               cycle,
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
               gitHash,
@@ -43715,7 +43997,7 @@ ${summaryResult}
             }, null, 2), "utf-8");
             renderInfo(`Checkpoint saved: cycle ${cycle} (${gitHash.slice(0, 8)})`);
           } catch {
-            writeFileSync15(join47(checkpointDir, "checkpoint.json"), JSON.stringify({ cycle, timestamp: (/* @__PURE__ */ new Date()).toISOString(), mode: this.state.mode }, null, 2), "utf-8");
+            writeFileSync16(join48(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) {
@@ -43773,14 +44055,14 @@ ${files.map((f) => `- [\`${f}\`](./${f})`).join("\n")}
 ---
 *Auto-generated by open-agents dream engine*
 `;
-          writeFileSync15(join47(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
+          writeFileSync16(join48(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
         } catch {
         }
       }
       /** Save dream state for resume/inspection */
       saveDreamState() {
         try {
-          writeFileSync15(join47(this.dreamsDir, "dream-state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
+          writeFileSync16(join48(this.dreamsDir, "dream-state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
         } catch {
         }
       }
@@ -44154,8 +44436,8 @@ var init_bless_engine = __esm({
 });
 
 // packages/cli/dist/tui/dmn-engine.js
-import { existsSync as existsSync39, readFileSync as readFileSync29, writeFileSync as writeFileSync16, mkdirSync as mkdirSync17, readdirSync as readdirSync13, unlinkSync as unlinkSync7 } from "node:fs";
-import { join as join48, basename as basename13 } from "node:path";
+import { existsSync as existsSync40, readFileSync as readFileSync29, writeFileSync as writeFileSync17, mkdirSync as mkdirSync17, readdirSync as readdirSync13, unlinkSync as unlinkSync8 } from "node:fs";
+import { join as join49, basename as basename13 } from "node:path";
 function buildDMNGatherPrompt(recentTaskSummaries, dueReminders, attentionItems, memoryTopics, capabilities, competence, reflectionBuffer) {
   const competenceReport = competence.length > 0 ? competence.map((c3) => {
     const rate = c3.attempts > 0 ? Math.round(c3.successes / c3.attempts * 100) : 0;
@@ -44268,8 +44550,8 @@ var init_dmn_engine = __esm({
       constructor(config, repoRoot) {
         this.config = config;
         this.repoRoot = repoRoot;
-        this.stateDir = join48(repoRoot, ".oa", "dmn");
-        this.historyDir = join48(repoRoot, ".oa", "dmn", "cycles");
+        this.stateDir = join49(repoRoot, ".oa", "dmn");
+        this.historyDir = join49(repoRoot, ".oa", "dmn", "cycles");
         mkdirSync17(this.historyDir, { recursive: true });
         this.loadState();
       }
@@ -44859,11 +45141,11 @@ OUTPUT: Call task_complete with JSON:
       async gatherMemoryTopics() {
         const topics = [];
         const dirs = [
-          join48(this.repoRoot, ".oa", "memory"),
-          join48(this.repoRoot, ".open-agents", "memory")
+          join49(this.repoRoot, ".oa", "memory"),
+          join49(this.repoRoot, ".open-agents", "memory")
         ];
         for (const dir of dirs) {
-          if (!existsSync39(dir))
+          if (!existsSync40(dir))
             continue;
           try {
             const files = readdirSync13(dir).filter((f) => f.endsWith(".json"));
@@ -44879,8 +45161,8 @@ OUTPUT: Call task_complete with JSON:
       }
       // ── State persistence ─────────────────────────────────────────────────
       loadState() {
-        const path = join48(this.stateDir, "state.json");
-        if (existsSync39(path)) {
+        const path = join49(this.stateDir, "state.json");
+        if (existsSync40(path)) {
           try {
             this.state = JSON.parse(readFileSync29(path, "utf-8"));
           } catch {
@@ -44889,19 +45171,19 @@ OUTPUT: Call task_complete with JSON:
       }
       saveState() {
         try {
-          writeFileSync16(join48(this.stateDir, "state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
+          writeFileSync17(join49(this.stateDir, "state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
         } catch {
         }
       }
       saveCycleResult(result) {
         try {
           const filename = `cycle-${result.cycleNumber}-${Date.now()}.json`;
-          writeFileSync16(join48(this.historyDir, filename), JSON.stringify(result, null, 2) + "\n", "utf-8");
+          writeFileSync17(join49(this.historyDir, filename), JSON.stringify(result, null, 2) + "\n", "utf-8");
           const files = readdirSync13(this.historyDir).filter((f) => f.startsWith("cycle-") && f.endsWith(".json")).sort();
           if (files.length > 50) {
             for (const old of files.slice(0, files.length - 50)) {
               try {
-                unlinkSync7(join48(this.historyDir, old));
+                unlinkSync8(join49(this.historyDir, old));
               } catch {
               }
             }
@@ -44914,8 +45196,8 @@ OUTPUT: Call task_complete with JSON:
 });
 
 // packages/cli/dist/tui/snr-engine.js
-import { existsSync as existsSync40, readdirSync as readdirSync14, readFileSync as readFileSync30 } from "node:fs";
-import { join as join49, basename as basename14 } from "node:path";
+import { existsSync as existsSync41, readdirSync as readdirSync14, readFileSync as readFileSync30 } from "node:fs";
+import { join as join50, basename as basename14 } from "node:path";
 function computeDPrime(signalScores, noiseScores) {
   if (signalScores.length === 0 || noiseScores.length === 0)
     return 0;
@@ -45155,11 +45437,11 @@ Call task_complete with the JSON array when done.`, onEvent)
       loadMemoryEntries(topics) {
         const entries = [];
         const dirs = [
-          join49(this.repoRoot, ".oa", "memory"),
-          join49(this.repoRoot, ".open-agents", "memory")
+          join50(this.repoRoot, ".oa", "memory"),
+          join50(this.repoRoot, ".open-agents", "memory")
         ];
         for (const dir of dirs) {
-          if (!existsSync40(dir))
+          if (!existsSync41(dir))
             continue;
           try {
             const files = readdirSync14(dir).filter((f) => f.endsWith(".json"));
@@ -45168,7 +45450,7 @@ Call task_complete with the JSON array when done.`, onEvent)
               if (topics.length > 0 && !topics.includes(topic))
                 continue;
               try {
-                const data = JSON.parse(readFileSync30(join49(dir, f), "utf-8"));
+                const data = JSON.parse(readFileSync30(join50(dir, f), "utf-8"));
                 for (const [key, val] of Object.entries(data)) {
                   const value = typeof val === "object" && val !== null && "value" in val ? String(val.value) : String(val);
                   entries.push({ topic, key, value });
@@ -45735,8 +46017,8 @@ var init_tool_policy = __esm({
 });
 
 // packages/cli/dist/tui/telegram-bridge.js
-import { mkdirSync as mkdirSync18, existsSync as existsSync41, unlinkSync as unlinkSync8, readdirSync as readdirSync15, statSync as statSync12 } from "node:fs";
-import { join as join50, resolve as resolve28 } from "node:path";
+import { mkdirSync as mkdirSync18, existsSync as existsSync42, unlinkSync as unlinkSync9, readdirSync as readdirSync15, statSync as statSync13 } from "node:fs";
+import { join as join51, resolve as resolve28 } from "node:path";
 import { writeFile as writeFileAsync } from "node:fs/promises";
 function convertMarkdownToTelegramHTML(md) {
   let html = md;
@@ -46501,7 +46783,7 @@ Telegram admin: @${msg.username}` : `Telegram ${isGroup ? "group" : "public"} ch
             return null;
           const buffer = Buffer.from(await res.arrayBuffer());
           const fileName = `${Date.now()}-${fileId.slice(0, 8)}${extension}`;
-          const localPath = join50(this.mediaCacheDir, fileName);
+          const localPath = join51(this.mediaCacheDir, fileName);
           await writeFileAsync(localPath, buffer);
           return localPath;
         } catch {
@@ -46589,7 +46871,7 @@ Telegram admin: @${msg.username}` : `Telegram ${isGroup ? "group" : "public"} ch
         for (const [key, entry] of this.mediaCache) {
           if (now - entry.cachedAt > MEDIA_CACHE_TTL_MS) {
             try {
-              unlinkSync8(entry.localPath);
+              unlinkSync9(entry.localPath);
             } catch {
             }
             this.mediaCache.delete(key);
@@ -46665,11 +46947,11 @@ Telegram admin: @${msg.username}` : `Telegram ${isGroup ? "group" : "public"} ch
           let mimeType = "audio/wav";
           try {
             const { execSync: execSyncLocal } = await import("node:child_process");
-            const { tmpdir: tmpdir9 } = await import("node:os");
+            const { tmpdir: tmpdir10 } = await import("node:os");
             const { join: joinPath } = await import("node:path");
             const { writeFileSync: writeFs, readFileSync: readFs, unlinkSync: unlinkFs } = await import("node:fs");
-            const tmpWav = joinPath(tmpdir9(), `oa-tg-voice-${Date.now()}.wav`);
-            const tmpOgg = joinPath(tmpdir9(), `oa-tg-voice-${Date.now()}.ogg`);
+            const tmpWav = joinPath(tmpdir10(), `oa-tg-voice-${Date.now()}.wav`);
+            const tmpOgg = joinPath(tmpdir10(), `oa-tg-voice-${Date.now()}.ogg`);
             writeFs(tmpWav, wavBuffer);
             execSyncLocal(`ffmpeg -i "${tmpWav}" -c:a libopus -b:a 48k -ar 48000 -ac 1 "${tmpOgg}" -y 2>/dev/null`, {
               timeout: 15e3,
@@ -48940,11 +49222,11 @@ var init_status_bar = __esm({
 import * as readline2 from "node:readline";
 import { Writable } from "node:stream";
 import { cwd } from "node:process";
-import { resolve as resolve29, join as join51, dirname as dirname18, extname as extname10 } from "node:path";
+import { resolve as resolve29, join as join52, dirname as dirname18, extname as extname10 } from "node:path";
 import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath as fileURLToPath12 } from "node:url";
-import { readFileSync as readFileSync31, writeFileSync as writeFileSync17, appendFileSync as appendFileSync4, rmSync as rmSync2, readdirSync as readdirSync16, mkdirSync as mkdirSync19 } from "node:fs";
-import { existsSync as existsSync42 } from "node:fs";
+import { readFileSync as readFileSync31, writeFileSync as writeFileSync18, appendFileSync as appendFileSync4, rmSync as rmSync2, readdirSync as readdirSync16, mkdirSync as mkdirSync19 } from "node:fs";
+import { existsSync as existsSync43 } from "node:fs";
 import { homedir as homedir13 } from "node:os";
 function formatTimeAgo(date) {
   const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
@@ -48964,12 +49246,12 @@ function getVersion3() {
     const require2 = createRequire2(import.meta.url);
     const thisDir = dirname18(fileURLToPath12(import.meta.url));
     const candidates = [
-      join51(thisDir, "..", "package.json"),
-      join51(thisDir, "..", "..", "package.json"),
-      join51(thisDir, "..", "..", "..", "package.json")
+      join52(thisDir, "..", "package.json"),
+      join52(thisDir, "..", "..", "package.json"),
+      join52(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync42(pkgPath)) {
+      if (existsSync43(pkgPath)) {
         const pkg = require2(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           return pkg.version ?? "0.0.0";
@@ -49176,15 +49458,15 @@ Use task_status("${taskId}") or task_output("${taskId}") to check progress.`
 function gatherMemorySnippets(root) {
   const snippets = [];
   const dirs = [
-    join51(root, ".oa", "memory"),
-    join51(root, ".open-agents", "memory")
+    join52(root, ".oa", "memory"),
+    join52(root, ".open-agents", "memory")
   ];
   for (const dir of dirs) {
-    if (!existsSync42(dir))
+    if (!existsSync43(dir))
       continue;
     try {
       for (const f of readdirSync16(dir).filter((f2) => f2.endsWith(".json"))) {
-        const data = JSON.parse(readFileSync31(join51(dir, f), "utf-8"));
+        const data = JSON.parse(readFileSync31(join52(dir, f), "utf-8"));
         for (const val of Object.values(data)) {
           const v = typeof val === "object" && val !== null && "value" in val ? String(val.value) : String(val);
           if (v.length > 10)
@@ -50148,7 +50430,7 @@ async function startInteractive(config, repoPath) {
   let p2pGateway = null;
   let peerMesh = null;
   let inferenceRouter = null;
-  const secretVault = new SecretVault(join51(repoRoot, ".oa", "vault.enc"));
+  const secretVault = new SecretVault(join52(repoRoot, ".oa", "vault.enc"));
   let adminSessionKey = null;
   const callSubAgents = /* @__PURE__ */ new Map();
   const streamRenderer = new StreamRenderer();
@@ -50357,12 +50639,12 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     const hits = allCompletions.filter((c3) => c3.toLowerCase().startsWith(lower));
     return [hits, line];
   }
-  const HISTORY_DIR = join51(homedir13(), ".open-agents");
-  const HISTORY_FILE = join51(HISTORY_DIR, "repl-history");
+  const HISTORY_DIR = join52(homedir13(), ".open-agents");
+  const HISTORY_FILE = join52(HISTORY_DIR, "repl-history");
   const MAX_HISTORY_LINES = 500;
   let savedHistory = [];
   try {
-    if (existsSync42(HISTORY_FILE)) {
+    if (existsSync43(HISTORY_FILE)) {
       const raw = readFileSync31(HISTORY_FILE, "utf8").trim();
       if (raw)
         savedHistory = raw.split("\n").reverse();
@@ -50387,7 +50669,7 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
       if (Math.random() < 0.02) {
         const all = readFileSync31(HISTORY_FILE, "utf8").trim().split("\n");
         if (all.length > MAX_HISTORY_LINES) {
-          writeFileSync17(HISTORY_FILE, all.slice(-MAX_HISTORY_LINES).join("\n") + "\n", "utf8");
+          writeFileSync18(HISTORY_FILE, all.slice(-MAX_HISTORY_LINES).join("\n") + "\n", "utf8");
         }
       }
     } catch {
@@ -50568,7 +50850,7 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     } catch {
     }
     try {
-      const oaDir = join51(repoRoot, ".oa");
+      const oaDir = join52(repoRoot, ".oa");
       const reconnected = await ExposeGateway.checkAndReconnect(oaDir, {
         onInfo: (msg) => writeContent(() => renderInfo(msg)),
         onError: (msg) => writeContent(() => renderWarning(msg))
@@ -50591,7 +50873,7 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     } catch {
     }
     try {
-      const oaDir = join51(repoRoot, ".oa");
+      const oaDir = join52(repoRoot, ".oa");
       const reconnectedP2P = await ExposeP2PGateway.checkAndReconnect(oaDir, new NexusTool(repoRoot), {
         onInfo: (msg) => writeContent(() => renderInfo(msg)),
         onError: (msg) => writeContent(() => renderWarning(msg))
@@ -51410,7 +51692,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
           kind,
           targetUrl,
           authKey,
-          stateDir: join51(repoRoot, ".oa"),
+          stateDir: join52(repoRoot, ".oa"),
           passthrough: passthrough ?? false,
           loadbalance: loadbalance ?? false,
           endpointAuth: passthrough ? currentConfig.apiKey : void 0,
@@ -51458,7 +51740,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         await tunnelGateway.stop();
         tunnelGateway = null;
       }
-      const newTunnel = new ExposeGateway({ kind, targetUrl, authKey, fullAccess, stateDir: join51(repoRoot, ".oa") });
+      const newTunnel = new ExposeGateway({ kind, targetUrl, authKey, fullAccess, stateDir: join52(repoRoot, ".oa") });
       newTunnel.on("stats", (stats) => {
         statusBar.setExposeStatus({
           status: stats.status,
@@ -51720,8 +52002,8 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       }
     },
     destroyProject() {
-      const oaPath = join51(repoRoot, OA_DIR);
-      if (existsSync42(oaPath)) {
+      const oaPath = join52(repoRoot, OA_DIR);
+      if (existsSync43(oaPath)) {
         try {
           rmSync2(oaPath, { recursive: true, force: true });
           writeContent(() => renderInfo(`Removed ${OA_DIR}/ directory.`));
@@ -52066,8 +52348,8 @@ Execute this skill now. Follow the behavioral guidance above.`;
       }
     }
     const cleanPath = input.replace(/^['"]|['"]$/g, "").trim();
-    const isImage = isImagePath(cleanPath) && existsSync42(resolve29(repoRoot, cleanPath));
-    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync42(resolve29(repoRoot, cleanPath));
+    const isImage = isImagePath(cleanPath) && existsSync43(resolve29(repoRoot, cleanPath));
+    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync43(resolve29(repoRoot, cleanPath));
     if (activeTask) {
       if (activeTask.runner.isPaused) {
         activeTask.runner.resume();
@@ -52655,7 +52937,7 @@ import { glob } from "glob";
 import ignore from "ignore";
 import { readFile as readFile17, stat as stat4 } from "node:fs/promises";
 import { createHash as createHash4 } from "node:crypto";
-import { join as join52, relative as relative3, extname as extname11, basename as basename15 } from "node:path";
+import { join as join53, relative as relative3, extname as extname11, basename as basename15 } from "node:path";
 var DEFAULT_EXCLUDE, LANGUAGE_MAP, CodebaseIndexer;
 var init_codebase_indexer = __esm({
   "packages/indexer/dist/codebase-indexer.js"() {
@@ -52699,7 +52981,7 @@ var init_codebase_indexer = __esm({
         const ig = ignore.default();
         if (this.config.respectGitignore) {
           try {
-            const gitignoreContent = await readFile17(join52(this.config.rootDir, ".gitignore"), "utf-8");
+            const gitignoreContent = await readFile17(join53(this.config.rootDir, ".gitignore"), "utf-8");
             ig.add(gitignoreContent);
           } catch {
           }
@@ -52714,7 +52996,7 @@ var init_codebase_indexer = __esm({
         for (const relativePath of files) {
           if (ig.ignores(relativePath))
             continue;
-          const fullPath = join52(this.config.rootDir, relativePath);
+          const fullPath = join53(this.config.rootDir, relativePath);
           try {
             const fileStat = await stat4(fullPath);
             if (fileStat.size > this.config.maxFileSize)
@@ -52760,7 +53042,7 @@ var init_codebase_indexer = __esm({
               if (!child) {
                 child = {
                   name: part,
-                  path: join52(current.path, part),
+                  path: join53(current.path, part),
                   type: "directory",
                   children: []
                 };
@@ -52843,17 +53125,17 @@ __export(index_repo_exports, {
   indexRepoCommand: () => indexRepoCommand
 });
 import { resolve as resolve30 } from "node:path";
-import { existsSync as existsSync43, statSync as statSync13 } from "node:fs";
+import { existsSync as existsSync44, statSync as statSync14 } from "node:fs";
 import { cwd as cwd2 } from "node:process";
 async function indexRepoCommand(opts, _config) {
   const repoRoot = resolve30(opts.repoPath ?? cwd2());
   printHeader("Index Repository");
   printInfo(`Indexing: ${repoRoot}`);
-  if (!existsSync43(repoRoot)) {
+  if (!existsSync44(repoRoot)) {
     printError(`Path does not exist: ${repoRoot}`);
     process.exit(1);
   }
-  const stat5 = statSync13(repoRoot);
+  const stat5 = statSync14(repoRoot);
   if (!stat5.isDirectory()) {
     printError(`Path is not a directory: ${repoRoot}`);
     process.exit(1);
@@ -53101,7 +53383,7 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { join as join53, resolve as resolve31 } from "node:path";
+import { join as join54, resolve as resolve31 } from "node:path";
 import { homedir as homedir14 } from "node:os";
 import { cwd as cwd3 } from "node:process";
 function redactIfSensitive(key, value) {
@@ -53184,7 +53466,7 @@ function handleShow(opts, config) {
     }
   }
   printSection("Config File");
-  printInfo(`~/.open-agents/config.json (${join53(homedir14(), ".open-agents", "config.json")})`);
+  printInfo(`~/.open-agents/config.json (${join54(homedir14(), ".open-agents", "config.json")})`);
   printSection("Priority Chain");
   printInfo("  1. CLI flags (--model, --backend-url, etc.)");
   printInfo("  2. Project .oa/settings.json (--local)");
@@ -53223,7 +53505,7 @@ function handleSet(opts, _config) {
       const coerced = coerceForSettings(key, value);
       saveProjectSettings(repoRoot, { [key]: coerced });
       printSuccess(`Project override set: ${key} = ${redactIfSensitive(key, value)}`);
-      printInfo(`Saved to ${join53(repoRoot, ".oa", "settings.json")}`);
+      printInfo(`Saved to ${join54(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)}`);
@@ -53480,9 +53762,9 @@ var eval_exports = {};
 __export(eval_exports, {
   evalCommand: () => evalCommand
 });
-import { tmpdir as tmpdir8 } from "node:os";
-import { mkdirSync as mkdirSync20, writeFileSync as writeFileSync18 } from "node:fs";
-import { join as join54 } from "node:path";
+import { tmpdir as tmpdir9 } from "node:os";
+import { mkdirSync as mkdirSync20, writeFileSync as writeFileSync19 } from "node:fs";
+import { join as join55 } from "node:path";
 async function evalCommand(opts, config) {
   const suiteName = opts.suite ?? "basic";
   const suite = SUITES[suiteName];
@@ -53607,9 +53889,9 @@ async function evalCommand(opts, config) {
   process.exit(failed > 0 ? 1 : 0);
 }
 function createTempEvalRepo() {
-  const dir = join54(tmpdir8(), `open-agents-eval-${Date.now()}`);
+  const dir = join55(tmpdir9(), `open-agents-eval-${Date.now()}`);
   mkdirSync20(dir, { recursive: true });
-  writeFileSync18(join54(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
+  writeFileSync19(join55(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
   return dir;
 }
 var BASIC_SUITE, FULL_SUITE, SUITES;
@@ -53669,7 +53951,7 @@ init_updater();
 import { parseArgs as nodeParseArgs2 } from "node:util";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath13 } from "node:url";
-import { dirname as dirname19, join as join55 } from "node:path";
+import { dirname as dirname19, join as join56 } from "node:path";
 
 // packages/cli/dist/cli.js
 import { createInterface } from "node:readline";
@@ -53776,7 +54058,7 @@ init_output();
 function getVersion4() {
   try {
     const require2 = createRequire3(import.meta.url);
-    const pkgPath = join55(dirname19(fileURLToPath13(import.meta.url)), "..", "package.json");
+    const pkgPath = join56(dirname19(fileURLToPath13(import.meta.url)), "..", "package.json");
     const pkg = require2(pkgPath);
     return pkg.version;
   } catch {