open-agents-ai 0.103.17 → 0.103.19

package/dist/index.js

@@ -1257,9 +1257,58 @@ var init_dist = __esm({
 });
 
 // packages/execution/dist/tool-executor.js
+var DEFAULT_CONFIG2, ToolExecutor;
 var init_tool_executor = __esm({
   "packages/execution/dist/tool-executor.js"() {
     "use strict";
+    DEFAULT_CONFIG2 = {
+      workingDir: ".",
+      timeout: 3e4,
+      maxOutputSize: 1e5
+    };
+    ToolExecutor = class {
+      tools = /* @__PURE__ */ new Map();
+      config;
+      constructor(config) {
+        this.config = { ...DEFAULT_CONFIG2, ...config };
+      }
+      register(tool) {
+        this.tools.set(tool.name, tool);
+      }
+      getToolDefinitions() {
+        return Array.from(this.tools.values()).map((tool) => ({
+          type: "function",
+          function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters
+          }
+        }));
+      }
+      async execute(toolName, args) {
+        const tool = this.tools.get(toolName);
+        if (!tool) {
+          return {
+            success: false,
+            output: "",
+            error: `Unknown tool: ${toolName}`,
+            durationMs: 0
+          };
+        }
+        const start = performance.now();
+        try {
+          const result = await tool.execute(args);
+          return result;
+        } catch (error) {
+          return {
+            success: false,
+            output: "",
+            error: error instanceof Error ? error.message : String(error),
+            durationMs: performance.now() - start
+          };
+        }
+      }
+    };
   }
 });
 
@@ -4845,6 +4894,9 @@ function hasCommand(cmd) {
     return false;
   }
 }
+function setSudoPassword(pw) {
+  _sudoPassword = pw;
+}
 function runInstall(installCmd) {
   const plat = process.platform;
   let cmd = installCmd;
@@ -4944,6 +4996,54 @@ function ensureCommand(command) {
   _cache.set(command, result);
   return result;
 }
+function ensureDepsForGroup(group) {
+  const deps = DESKTOP_DEPS.filter((d) => d.group === group);
+  const results = deps.map((d) => ({ command: d.command, result: ensureCommand(d.command) }));
+  const allAvailable = results.every((r) => r.result.available);
+  const installed = results.filter((r) => r.result.installed);
+  const failed = results.filter((r) => !r.result.available);
+  const parts = [];
+  if (installed.length > 0) {
+    parts.push(`Installed: ${installed.map((r) => r.command).join(", ")}`);
+  }
+  if (failed.length > 0) {
+    parts.push(`Missing: ${failed.map((r) => `${r.command} (${r.result.error})`).join(", ")}`);
+  }
+  return { allAvailable, results, summary: parts.join(". ") || "All dependencies available." };
+}
+function ensureAllDesktopDeps() {
+  const results = DESKTOP_DEPS.map((d) => ({
+    dep: d,
+    result: ensureCommand(d.command)
+  }));
+  const installed = results.filter((r) => r.result.installed).map((r) => r.dep.command);
+  const missing = results.filter((r) => !r.result.available).map((r) => r.dep.command);
+  const allAvailable = missing.length === 0;
+  const parts = [];
+  if (installed.length > 0) {
+    parts.push(`Auto-installed: ${installed.join(", ")}`);
+  }
+  if (missing.length > 0) {
+    parts.push(`Could not install: ${missing.join(", ")}`);
+  }
+  return {
+    allAvailable,
+    summary: parts.join(". ") || "All desktop dependencies available.",
+    installed,
+    missing
+  };
+}
+function checkDesktopDeps() {
+  return DESKTOP_DEPS.map((d) => ({
+    dep: d,
+    available: hasCommand(d.command)
+  }));
+}
+function resetDepCache() {
+  _cache.clear();
+  _detectedPkgManager = void 0;
+  _sudoPassword = null;
+}
 var DESKTOP_DEPS, _detectedPkgManager, _cache, _sudoPassword;
 var init_system_deps = __esm({
   "packages/execution/dist/system-deps.js"() {
@@ -7759,6 +7859,10 @@ Details: ${err.message}` : "");
     throw new Error(moondreamError);
   }
 }
+function resetMoondreamClient() {
+  moondreamClient = null;
+  moondreamError = null;
+}
 function loadImageBuffer(workingDir, rawPath) {
   const fullPath = resolve16(workingDir, rawPath);
   if (!existsSync14(fullPath)) {
@@ -12167,9 +12271,16 @@ async function handleCmd(cmd) {
           riData = { prompt: riPrompt };
         }
 
+        var riAuthKey = args.auth_key || '';
+
         // Derive capability name from model
         var riCapName = 'inference:' + riModel.replace(/[^a-zA-Z0-9._-]/g, '_');
-        dlog('remote_infer: model=' + riModel + ' cap=' + riCapName + ' prompt_len=' + riPrompt.length);
+        dlog('remote_infer: model=' + riModel + ' cap=' + riCapName + ' prompt_len=' + riPrompt.length + (riAuthKey ? ' auth=yes' : ''));
+
+        // Include auth key in data if provided
+        if (riAuthKey) {
+          riData.auth_key = riAuthKey;
+        }
 
         // If target_peer specified, invoke directly. Otherwise auto-discover.
         if (riTargetPeer) {
@@ -12414,6 +12525,12 @@ async function handleCmd(cmd) {
 
       // \u2500\u2500 Metered Inference Exposure \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
       case 'expose': {
+        // Auth key for gating inference access (passed from ExposeP2PGateway)
+        var exposeAuthKey = args.auth_key || '';
+        if (exposeAuthKey) {
+          dlog('expose: auth key configured (' + exposeAuthKey.length + ' chars)');
+        }
+
         // Query Ollama for available models
         const ollamaUrl = args.ollama_url || process.env.OLLAMA_URL || 'http://localhost:11434';
         let models = [];
@@ -12513,6 +12630,25 @@ async function handleCmd(cmd) {
               const logFile = join(invocationsDir, Date.now() + '-' + capName + '.json');
               try { writeFileSync(logFile, JSON.stringify(logEntry, null, 2)); } catch {}
 
+              // Auth key validation \u2014 if expose was started with auth_key, require it
+              if (exposeAuthKey) {
+                var reqAuthKey = '';
+                if (request.data && typeof request.data === 'object' && request.data.auth_key) {
+                  reqAuthKey = request.data.auth_key;
+                } else if (request.metadata && request.metadata.auth_key) {
+                  reqAuthKey = request.metadata.auth_key;
+                }
+                if (reqAuthKey !== exposeAuthKey) {
+                  dlog('expose: auth REJECTED for ' + capName + ' from ' + (request.from || 'unknown'));
+                  await stream.write({ type: 'invoke.accept', version: 1, requestId: request.requestId, accepted: false });
+                  await stream.write({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: 0, event: 'error', data: 'Unauthorized \u2014 invalid or missing auth key' });
+                  await stream.write({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: 0, outputBytes: 0 } });
+                  stream.close();
+                  return;
+                }
+                dlog('expose: auth OK for ' + capName);
+              }
+
               // Collect input via stream data events
               let prompt = '';
               var dataChunks = [];
@@ -12655,6 +12791,64 @@ async function handleCmd(cmd) {
           }
         }
 
+        // Register system_metrics capability \u2014 returns CPU/GPU/memory utilization
+        if (typeof nexus.registerCapability === 'function') {
+          nexus.registerCapability('system_metrics', async (request, stream) => {
+            // Auth check for system_metrics too
+            if (exposeAuthKey) {
+              var smAuthKey = '';
+              if (request.data && typeof request.data === 'object' && request.data.auth_key) {
+                smAuthKey = request.data.auth_key;
+              } else if (request.metadata && request.metadata.auth_key) {
+                smAuthKey = request.metadata.auth_key;
+              }
+              if (smAuthKey !== exposeAuthKey) {
+                await stream.write({ type: 'invoke.accept', version: 1, requestId: request.requestId, accepted: false });
+                await stream.write({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: 0, outputBytes: 0 } });
+                stream.close();
+                return;
+              }
+            }
+            await stream.write({ type: 'invoke.accept', version: 1, requestId: request.requestId, accepted: true });
+            try {
+              var os = require('os');
+              var loads = os.loadavg();
+              var cores = os.cpus().length;
+              var totalMem = os.totalmem();
+              var freeMem = os.freemem();
+              var usedMem = totalMem - freeMem;
+              var gpuInfo = { available: false, name: '', utilization: 0, vramUsedMB: 0, vramTotalMB: 0, vramUtilization: 0 };
+              try {
+                var cp = require('child_process');
+                var smiOut = cp.execSync('nvidia-smi --query-gpu=utilization.gpu,memory.used,memory.total,name --format=csv,noheader,nounits 2>/dev/null', { encoding: 'utf8', timeout: 3000 });
+                var smiLine = smiOut.trim().split('\\n')[0];
+                if (smiLine) {
+                  var sp = smiLine.split(',').map(function(s) { return s.trim(); });
+                  gpuInfo.available = true;
+                  gpuInfo.utilization = parseInt(sp[0] || '0', 10) || 0;
+                  gpuInfo.vramUsedMB = parseInt(sp[1] || '0', 10) || 0;
+                  gpuInfo.vramTotalMB = parseInt(sp[2] || '0', 10) || 0;
+                  gpuInfo.name = sp[3] || '';
+                  gpuInfo.vramUtilization = gpuInfo.vramTotalMB > 0 ? Math.round((gpuInfo.vramUsedMB / gpuInfo.vramTotalMB) * 100) : 0;
+                }
+              } catch (ge) { /* no GPU */ }
+              var metricsPayload = {
+                cpu: { utilization: Math.min(100, Math.round((loads[0] / cores) * 100)), cores: cores },
+                memory: { utilization: Math.round((usedMem / totalMem) * 100), totalGB: Math.round((totalMem / (1024*1024*1024)) * 10) / 10 },
+                gpu: gpuInfo,
+                timestamp: new Date().toISOString(),
+              };
+              await stream.write({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: 0, event: 'result', data: JSON.stringify(metricsPayload) });
+              await stream.write({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: 0, outputBytes: JSON.stringify(metricsPayload).length } });
+            } catch (me) {
+              await stream.write({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: 0, event: 'error', data: 'metrics error: ' + me.message });
+              await stream.write({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: 0, outputBytes: 0 } });
+            }
+            stream.close();
+          });
+          dlog('system_metrics capability registered');
+        }
+
         // Write pricing menu to file
         const pricingFile = join(nexusDir, 'pricing.json');
         writeFileSync(pricingFile, JSON.stringify({ updated: new Date().toISOString(), models: pricingMenu }, null, 2));
@@ -14065,21 +14259,185 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
 });
 
 // packages/execution/dist/shellRunner.js
+import { spawn as spawn12 } from "node:child_process";
+async function runShell(options) {
+  const { command, args = [], cwd: cwd4, env, timeoutMs = DEFAULT_TIMEOUT_MS } = options;
+  const mergedEnv = env ? { ...process.env, ...env } : process.env;
+  return new Promise((resolve31) => {
+    const start = Date.now();
+    let timedOut = false;
+    const child = spawn12(command, args, {
+      cwd: cwd4,
+      env: mergedEnv
+      // Do NOT use shell:true — we pass command + args separately
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, timeoutMs);
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      const durationMs = Date.now() - start;
+      const exitCode = timedOut ? -1 : code ?? -1;
+      resolve31({
+        stdout,
+        stderr,
+        exitCode,
+        success: !timedOut && exitCode === 0,
+        timedOut,
+        durationMs
+      });
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      const durationMs = Date.now() - start;
+      resolve31({
+        stdout,
+        stderr: stderr + err.message,
+        exitCode: -1,
+        success: false,
+        timedOut: false,
+        durationMs
+      });
+    });
+  });
+}
+var DEFAULT_TIMEOUT_MS;
 var init_shellRunner = __esm({
   "packages/execution/dist/shellRunner.js"() {
     "use strict";
+    DEFAULT_TIMEOUT_MS = 6e4;
   }
 });
 
 // packages/execution/dist/gitWorktree.js
+async function createWorktree(options) {
+  const { repoPath, worktreePath, branch, timeoutMs = DEFAULT_GIT_TIMEOUT_MS } = options;
+  const result = await runShell({
+    command: "git",
+    args: ["worktree", "add", "-b", branch, worktreePath],
+    cwd: repoPath,
+    timeoutMs
+  });
+  if (!result.success) {
+    throw new Error(`git worktree add failed (exit ${result.exitCode}): ${result.stderr}`);
+  }
+  return { worktreePath, branch };
+}
+async function removeWorktree(options) {
+  const { repoPath, worktreePath, timeoutMs = DEFAULT_GIT_TIMEOUT_MS } = options;
+  const result = await runShell({
+    command: "git",
+    args: ["worktree", "remove", "--force", worktreePath],
+    cwd: repoPath,
+    timeoutMs
+  });
+  if (!result.success) {
+    const isAlreadyGone = result.stderr.includes("not a working tree") || result.stderr.includes("is not a working tree") || result.stderr.includes("No such file");
+    if (!isAlreadyGone) {
+      throw new Error(`git worktree remove failed (exit ${result.exitCode}): ${result.stderr}`);
+    }
+  }
+  await runShell({
+    command: "git",
+    args: ["worktree", "prune"],
+    cwd: repoPath,
+    timeoutMs
+  });
+}
+var DEFAULT_GIT_TIMEOUT_MS;
 var init_gitWorktree = __esm({
   "packages/execution/dist/gitWorktree.js"() {
     "use strict";
     init_shellRunner();
+    DEFAULT_GIT_TIMEOUT_MS = 3e4;
   }
 });
 
 // packages/execution/dist/patchApplier.js
+import { readFileSync as readFileSync17, writeFileSync as writeFileSync7, existsSync as existsSync24, mkdirSync as mkdirSync7 } from "node:fs";
+import { dirname as dirname11 } from "node:path";
+import { spawn as spawn13 } from "node:child_process";
+async function applyPatch(patch) {
+  switch (patch.type) {
+    case "block-replace":
+      return applyBlockReplace(patch);
+    case "rewrite":
+      return applyRewrite(patch);
+    case "new-file":
+      return applyNewFile(patch);
+    case "unified-diff":
+      return applyUnifiedDiff(patch);
+  }
+}
+function applyBlockReplace(patch) {
+  const original = readFileSync17(patch.filePath, "utf-8");
+  if (!original.includes(patch.oldContent)) {
+    throw new Error(`Block not found in "${patch.filePath}": the oldContent string was not found in the file.`);
+  }
+  const updated = original.replace(patch.oldContent, patch.newContent);
+  writeFileSync7(patch.filePath, updated, "utf-8");
+}
+function applyRewrite(patch) {
+  writeFileSync7(patch.filePath, patch.newContent, "utf-8");
+}
+function applyNewFile(patch) {
+  if (existsSync24(patch.filePath)) {
+    throw new Error(`Cannot create new file: "${patch.filePath}" already exists.`);
+  }
+  mkdirSync7(dirname11(patch.filePath), { recursive: true });
+  writeFileSync7(patch.filePath, patch.newContent, "utf-8");
+}
+async function applyUnifiedDiff(patch) {
+  const { filePath, diff } = patch;
+  const result = await runWithStdin({
+    command: "patch",
+    args: [
+      "--no-backup-if-mismatch",
+      "-p1",
+      filePath
+    ],
+    cwd: dirname11(filePath),
+    stdin: diff
+  });
+  if (!result.success) {
+    throw new Error(`patch command failed (exit ${result.exitCode}): ${result.stderr}`);
+  }
+}
+function runWithStdin(options) {
+  const { command, args, cwd: cwd4, stdin } = options;
+  return new Promise((resolve31) => {
+    const child = spawn13(command, args, {
+      cwd: cwd4,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.stdin.write(stdin);
+    child.stdin.end();
+    child.on("close", (code) => {
+      const exitCode = code ?? -1;
+      resolve31({ success: exitCode === 0, exitCode, stdout, stderr });
+    });
+    child.on("error", (err) => {
+      resolve31({ success: false, exitCode: -1, stdout, stderr: err.message });
+    });
+  });
+}
 var init_patchApplier = __esm({
   "packages/execution/dist/patchApplier.js"() {
     "use strict";
@@ -14087,6 +14445,55 @@ var init_patchApplier = __esm({
 });
 
 // packages/execution/dist/formatterRunner.js
+function buildFormatterCommand(formatter, extraArgs) {
+  switch (formatter) {
+    case "prettier":
+      return {
+        command: "npx",
+        args: ["prettier", "--write", ".", ...extraArgs]
+      };
+    case "black":
+      return {
+        command: "black",
+        args: [".", ...extraArgs]
+      };
+    case "rustfmt":
+      return {
+        command: "rustfmt",
+        args: [...extraArgs]
+      };
+    case "gofmt":
+      return {
+        command: "gofmt",
+        args: ["-w", ".", ...extraArgs]
+      };
+  }
+}
+async function runFormatter(options) {
+  const { profile, extraArgs = [] } = options;
+  if (profile.formatter === null) {
+    return {
+      success: true,
+      tool: "none",
+      stdout: "",
+      stderr: "",
+      skipped: true
+    };
+  }
+  const { command, args } = buildFormatterCommand(profile.formatter, extraArgs);
+  const shellResult = await runShell({
+    command,
+    args,
+    cwd: profile.projectRoot
+  });
+  return {
+    success: shellResult.success,
+    tool: profile.formatter,
+    stdout: shellResult.stdout,
+    stderr: shellResult.stderr,
+    skipped: false
+  };
+}
 var init_formatterRunner = __esm({
   "packages/execution/dist/formatterRunner.js"() {
     "use strict";
@@ -14095,6 +14502,60 @@ var init_formatterRunner = __esm({
 });
 
 // packages/execution/dist/linterRunner.js
+function buildLinterCommand(linter, extraArgs) {
+  switch (linter) {
+    case "eslint":
+      return {
+        command: "npx",
+        args: ["eslint", ".", ...extraArgs]
+      };
+    case "ruff":
+      return {
+        command: "ruff",
+        args: ["check", ".", ...extraArgs]
+      };
+    case "flake8":
+      return {
+        command: "flake8",
+        args: [".", ...extraArgs]
+      };
+    case "clippy":
+      return {
+        command: "cargo",
+        args: ["clippy", ...extraArgs]
+      };
+    case "golangci-lint":
+      return {
+        command: "golangci-lint",
+        args: ["run", ...extraArgs]
+      };
+  }
+}
+async function runLinter(options) {
+  const { profile, extraArgs = [] } = options;
+  if (profile.linter === null) {
+    return {
+      success: true,
+      tool: "none",
+      stdout: "",
+      stderr: "",
+      skipped: true
+    };
+  }
+  const { command, args } = buildLinterCommand(profile.linter, extraArgs);
+  const shellResult = await runShell({
+    command,
+    args,
+    cwd: profile.projectRoot
+  });
+  return {
+    success: shellResult.success,
+    tool: profile.linter,
+    stdout: shellResult.stdout,
+    stderr: shellResult.stderr,
+    skipped: false
+  };
+}
 var init_linterRunner = __esm({
   "packages/execution/dist/linterRunner.js"() {
     "use strict";
@@ -14103,6 +14564,50 @@ var init_linterRunner = __esm({
 });
 
 // packages/execution/dist/typecheckRunner.js
+function buildTypecheckerCommand(typechecker, extraArgs) {
+  switch (typechecker) {
+    case "tsc":
+      return {
+        command: "npx",
+        args: ["tsc", "--noEmit", ...extraArgs]
+      };
+    case "mypy":
+      return {
+        command: "mypy",
+        args: [".", ...extraArgs]
+      };
+    case "pyright":
+      return {
+        command: "pyright",
+        args: [...extraArgs]
+      };
+  }
+}
+async function runTypecheck(options) {
+  const { profile, extraArgs = [] } = options;
+  if (profile.typechecker === null) {
+    return {
+      success: true,
+      tool: "none",
+      stdout: "",
+      stderr: "",
+      skipped: true
+    };
+  }
+  const { command, args } = buildTypecheckerCommand(profile.typechecker, extraArgs);
+  const shellResult = await runShell({
+    command,
+    args,
+    cwd: profile.projectRoot
+  });
+  return {
+    success: shellResult.success,
+    tool: profile.typechecker,
+    stdout: shellResult.stdout,
+    stderr: shellResult.stderr,
+    skipped: false
+  };
+}
 var init_typecheckRunner = __esm({
   "packages/execution/dist/typecheckRunner.js"() {
     "use strict";
@@ -14111,6 +14616,60 @@ var init_typecheckRunner = __esm({
 });
 
 // packages/execution/dist/testRunner.js
+function buildTestRunnerCommand(testRunner, extraArgs) {
+  switch (testRunner) {
+    case "jest":
+      return {
+        command: "npx",
+        args: ["jest", ...extraArgs]
+      };
+    case "vitest":
+      return {
+        command: "npx",
+        args: ["vitest", "run", ...extraArgs]
+      };
+    case "pytest":
+      return {
+        command: "pytest",
+        args: [...extraArgs]
+      };
+    case "mocha":
+      return {
+        command: "npx",
+        args: ["mocha", ...extraArgs]
+      };
+    case "go-test":
+      return {
+        command: "go",
+        args: ["test", "./...", ...extraArgs]
+      };
+  }
+}
+async function runTests(options) {
+  const { profile, extraArgs = [] } = options;
+  if (profile.testRunner === null) {
+    return {
+      success: true,
+      tool: "none",
+      stdout: "",
+      stderr: "",
+      skipped: true
+    };
+  }
+  const { command, args } = buildTestRunnerCommand(profile.testRunner, extraArgs);
+  const shellResult = await runShell({
+    command,
+    args,
+    cwd: profile.projectRoot
+  });
+  return {
+    success: shellResult.success,
+    tool: profile.testRunner,
+    stdout: shellResult.stdout,
+    stderr: shellResult.stderr,
+    skipped: false
+  };
+}
 var init_testRunner = __esm({
   "packages/execution/dist/testRunner.js"() {
     "use strict";
@@ -14119,6 +14678,71 @@ var init_testRunner = __esm({
 });
 
 // packages/execution/dist/buildRunner.js
+function buildBuilderCommand(profile, extraArgs) {
+  switch (profile.builder) {
+    case "tsc":
+      return {
+        command: "npx",
+        args: ["tsc", "--build", ...extraArgs]
+      };
+    case "vite":
+      return {
+        command: "npx",
+        args: ["vite", "build", ...extraArgs]
+      };
+    case "webpack":
+      return {
+        command: "npx",
+        args: ["webpack", ...extraArgs]
+      };
+    case "cargo":
+      return {
+        command: "cargo",
+        args: ["build", "--release", ...extraArgs]
+      };
+    case "go-build":
+      return {
+        command: "go",
+        args: ["build", "./...", ...extraArgs]
+      };
+    case "custom": {
+      if (!profile.buildCommand) {
+        throw new Error('buildCommand is required when builder is "custom"');
+      }
+      return {
+        command: "sh",
+        args: ["-c", profile.buildCommand]
+      };
+    }
+    default:
+      throw new Error(`Unsupported builder: ${String(profile.builder)}`);
+  }
+}
+async function runBuild(options) {
+  const { profile, extraArgs = [] } = options;
+  if (profile.builder === null) {
+    return {
+      success: true,
+      tool: "none",
+      stdout: "",
+      stderr: "",
+      skipped: true
+    };
+  }
+  const { command, args } = buildBuilderCommand(profile, extraArgs);
+  const shellResult = await runShell({
+    command,
+    args,
+    cwd: profile.projectRoot
+  });
+  return {
+    success: shellResult.success,
+    tool: profile.builder,
+    stdout: shellResult.stdout,
+    stderr: shellResult.stderr,
+    skipped: false
+  };
+}
 var init_buildRunner = __esm({
   "packages/execution/dist/buildRunner.js"() {
     "use strict";
@@ -14127,6 +14751,100 @@ var init_buildRunner = __esm({
 });
 
 // packages/execution/dist/validationPipeline.js
+async function runValidationPipeline(config) {
+  const { projectRoot, profile, stopOnFirstFailure = true } = config;
+  const formatterProfile = {
+    formatter: profile.formatter,
+    projectRoot
+  };
+  const linterProfile = {
+    linter: profile.linter,
+    projectRoot
+  };
+  const typecheckProfile = {
+    typechecker: profile.typechecker,
+    projectRoot
+  };
+  const testProfile = {
+    testRunner: profile.testRunner,
+    projectRoot
+  };
+  const buildProfile = {
+    builder: profile.builder,
+    projectRoot,
+    buildCommand: profile.buildCommand
+  };
+  const steps = [];
+  const start = Date.now();
+  const formatRaw = await runFormatter({ profile: formatterProfile });
+  const formatStep = {
+    name: "format",
+    success: formatRaw.success,
+    tool: formatRaw.tool,
+    stdout: formatRaw.stdout,
+    stderr: formatRaw.stderr,
+    skipped: formatRaw.skipped
+  };
+  steps.push(formatStep);
+  if (!formatStep.success && stopOnFirstFailure) {
+    return { overall: "fail", steps, totalDurationMs: Date.now() - start };
+  }
+  const lintRaw = await runLinter({ profile: linterProfile });
+  const lintStep = {
+    name: "lint",
+    success: lintRaw.success,
+    tool: lintRaw.tool,
+    stdout: lintRaw.stdout,
+    stderr: lintRaw.stderr,
+    skipped: lintRaw.skipped
+  };
+  steps.push(lintStep);
+  if (!lintStep.success && stopOnFirstFailure) {
+    return { overall: "fail", steps, totalDurationMs: Date.now() - start };
+  }
+  const typecheckRaw = await runTypecheck({ profile: typecheckProfile });
+  const typecheckStep = {
+    name: "typecheck",
+    success: typecheckRaw.success,
+    tool: typecheckRaw.tool,
+    stdout: typecheckRaw.stdout,
+    stderr: typecheckRaw.stderr,
+    skipped: typecheckRaw.skipped
+  };
+  steps.push(typecheckStep);
+  if (!typecheckStep.success && stopOnFirstFailure) {
+    return { overall: "fail", steps, totalDurationMs: Date.now() - start };
+  }
+  const testRaw = await runTests({ profile: testProfile });
+  const testStep = {
+    name: "test",
+    success: testRaw.success,
+    tool: testRaw.tool,
+    stdout: testRaw.stdout,
+    stderr: testRaw.stderr,
+    skipped: testRaw.skipped
+  };
+  steps.push(testStep);
+  if (!testStep.success && stopOnFirstFailure) {
+    return { overall: "fail", steps, totalDurationMs: Date.now() - start };
+  }
+  const buildRaw = await runBuild({ profile: buildProfile });
+  const buildStep = {
+    name: "build",
+    success: buildRaw.success,
+    tool: buildRaw.tool,
+    stdout: buildRaw.stdout,
+    stderr: buildRaw.stderr,
+    skipped: buildRaw.skipped
+  };
+  steps.push(buildStep);
+  const anyFailed = steps.some((s) => !s.success);
+  return {
+    overall: anyFailed ? "fail" : "pass",
+    steps,
+    totalDurationMs: Date.now() - start
+  };
+}
 var init_validationPipeline = __esm({
   "packages/execution/dist/validationPipeline.js"() {
     "use strict";
@@ -14139,6 +14857,97 @@ var init_validationPipeline = __esm({
 });
 
 // packages/execution/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  AgendaTool: () => AgendaTool,
+  AiwgHealthTool: () => AiwgHealthTool,
+  AiwgSetupTool: () => AiwgSetupTool,
+  AiwgWorkflowTool: () => AiwgWorkflowTool,
+  AutoresearchTool: () => AutoresearchTool,
+  BackgroundRunTool: () => BackgroundRunTool,
+  BackgroundTaskManager: () => BackgroundTaskManager,
+  BatchEditTool: () => BatchEditTool,
+  BrowserActionTool: () => BrowserActionTool,
+  CodeSandboxTool: () => CodeSandboxTool,
+  CodebaseMapTool: () => CodebaseMapTool,
+  CreateToolTool: () => CreateToolTool,
+  CronAgentTool: () => CronAgentTool,
+  CustomTool: () => CustomTool,
+  DESKTOP_DEPS: () => DESKTOP_DEPS,
+  DesktopClickTool: () => DesktopClickTool,
+  DesktopDescribeTool: () => DesktopDescribeTool,
+  DiagnosticTool: () => DiagnosticTool,
+  ExploreToolsTool: () => ExploreToolsTool,
+  FactoryTool: () => FactoryTool,
+  FileEditTool: () => FileEditTool,
+  FilePatchTool: () => FilePatchTool,
+  FileReadTool: () => FileReadTool,
+  FileWriteTool: () => FileWriteTool,
+  GitInfoTool: () => GitInfoTool,
+  GlobFindTool: () => GlobFindTool,
+  GrepSearchTool: () => GrepSearchTool,
+  ImageReadTool: () => ImageReadTool,
+  ListDirectoryTool: () => ListDirectoryTool,
+  ManageToolsTool: () => ManageToolsTool,
+  MemoryReadTool: () => MemoryReadTool,
+  MemorySearchTool: () => MemorySearchTool,
+  MemoryWriteTool: () => MemoryWriteTool,
+  NexusTool: () => NexusTool,
+  OCRTool: () => OCRTool,
+  OcrImageAdvancedTool: () => OcrImageAdvancedTool,
+  OcrPdfTool: () => OcrPdfTool,
+  OpenCodeTool: () => OpenCodeTool,
+  PdfToTextTool: () => PdfToTextTool,
+  ReminderTool: () => ReminderTool,
+  SchedulerTool: () => SchedulerTool,
+  ScreenshotTool: () => ScreenshotTool,
+  ShellTool: () => ShellTool,
+  SkillBuildTool: () => SkillBuildTool,
+  SkillExecuteTool: () => SkillExecuteTool,
+  SkillListTool: () => SkillListTool,
+  StructuredFileTool: () => StructuredFileTool,
+  StructuredReadTool: () => StructuredReadTool,
+  TaskOutputTool: () => TaskOutputTool,
+  TaskStatusTool: () => TaskStatusTool,
+  TaskStopTool: () => TaskStopTool,
+  ToolExecutor: () => ToolExecutor,
+  TranscribeFileTool: () => TranscribeFileTool,
+  TranscribeUrlTool: () => TranscribeUrlTool,
+  VisionTool: () => VisionTool,
+  WebCrawlTool: () => WebCrawlTool,
+  WebFetchTool: () => WebFetchTool,
+  WebSearchTool: () => WebSearchTool,
+  applyPatch: () => applyPatch,
+  buildCustomTools: () => buildCustomTools,
+  buildSkillsSummary: () => buildSkillsSummary,
+  checkDesktopDeps: () => checkDesktopDeps,
+  createWorktree: () => createWorktree,
+  detectSearchProvider: () => detectSearchProvider,
+  discoverSkills: () => discoverSkills,
+  ensureAllDesktopDeps: () => ensureAllDesktopDeps,
+  ensureCommand: () => ensureCommand,
+  ensureDepsForGroup: () => ensureDepsForGroup,
+  getActiveAttentionItems: () => getActiveAttentionItems,
+  getDueReminders: () => getDueReminders,
+  isImagePath: () => isImagePath,
+  listCustomToolFiles: () => listCustomToolFiles,
+  loadCustomTools: () => loadCustomTools,
+  loadReminderStore: () => loadReminderStore,
+  loadSkillContent: () => loadSkillContent,
+  markRemindersSeen: () => markRemindersSeen,
+  removeWorktree: () => removeWorktree,
+  resetDepCache: () => resetDepCache,
+  resetMoondreamClient: () => resetMoondreamClient,
+  runBuild: () => runBuild,
+  runFormatter: () => runFormatter,
+  runLinter: () => runLinter,
+  runShell: () => runShell,
+  runTests: () => runTests,
+  runTypecheck: () => runTypecheck,
+  runValidationPipeline: () => runValidationPipeline,
+  saveCustomToolDefinition: () => saveCustomToolDefinition,
+  setSudoPassword: () => setSudoPassword
+});
 var init_dist2 = __esm({
   "packages/execution/dist/index.js"() {
     "use strict";
@@ -14873,17 +15682,17 @@ var init_dist3 = __esm({
 });
 
 // packages/orchestrator/dist/promptLoader.js
-import { readFileSync as readFileSync17, existsSync as existsSync24 } from "node:fs";
-import { join as join31, dirname as dirname11 } from "node:path";
+import { readFileSync as readFileSync18, existsSync as existsSync25 } from "node:fs";
+import { join as join31, dirname as dirname12 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 function loadPrompt(promptPath, vars) {
   let content = cache.get(promptPath);
   if (content === void 0) {
     const fullPath = join31(PROMPTS_DIR, promptPath);
-    if (!existsSync24(fullPath)) {
+    if (!existsSync25(fullPath)) {
       throw new Error(`Prompt file not found: ${fullPath}`);
     }
-    content = readFileSync17(fullPath, "utf-8");
+    content = readFileSync18(fullPath, "utf-8");
     cache.set(promptPath, content);
   }
   if (!vars)
@@ -14895,7 +15704,7 @@ var init_promptLoader = __esm({
   "packages/orchestrator/dist/promptLoader.js"() {
     "use strict";
     __filename = fileURLToPath7(import.meta.url);
-    __dirname4 = dirname11(__filename);
+    __dirname4 = dirname12(__filename);
     PROMPTS_DIR = join31(__dirname4, "..", "prompts");
     cache = /* @__PURE__ */ new Map();
   }
@@ -15232,12 +16041,12 @@ var init_grep_search2 = __esm({
 });
 
 // packages/retrieval/dist/code-retriever.js
-var DEFAULT_CONFIG2, CodeRetriever;
+var DEFAULT_CONFIG3, CodeRetriever;
 var init_code_retriever = __esm({
   "packages/retrieval/dist/code-retriever.js"() {
     "use strict";
     init_grep_search2();
-    DEFAULT_CONFIG2 = {
+    DEFAULT_CONFIG3 = {
       rootDir: ".",
       maxResults: 20,
       maxFileSize: 5e5,
@@ -15248,7 +16057,7 @@ var init_code_retriever = __esm({
       config;
       grepSearch;
       constructor(config) {
-        this.config = { ...DEFAULT_CONFIG2, ...config };
+        this.config = { ...DEFAULT_CONFIG3, ...config };
         this.grepSearch = new GrepSearch(this.config.rootDir);
       }
       async searchByPattern(pattern) {
@@ -15959,8 +16768,8 @@ var init_contextAssembler = __esm({
 });
 
 // packages/retrieval/dist/index.js
-var dist_exports = {};
-__export(dist_exports, {
+var dist_exports2 = {};
+__export(dist_exports2, {
   CodeRetriever: () => CodeRetriever,
   GrepSearch: () => GrepSearch,
   IndexBackedSemanticSearchEngine: () => IndexBackedSemanticSearchEngine,
@@ -15997,7 +16806,7 @@ var init_dist4 = __esm({
 
 // packages/orchestrator/dist/scoutRunner.js
 async function loadCodeRetriever(rootDir) {
-  const mod = await Promise.resolve().then(() => (init_dist4(), dist_exports));
+  const mod = await Promise.resolve().then(() => (init_dist4(), dist_exports2));
   return new mod.CodeRetriever({ rootDir });
 }
 function parseJsonFromContent4(content) {
@@ -18258,10 +19067,10 @@ ${marker}` : marker);
         if (!this._workingDirectory)
           return;
         try {
-          const { mkdirSync: mkdirSync20, writeFileSync: writeFileSync18 } = __require("node:fs");
+          const { mkdirSync: mkdirSync21, writeFileSync: writeFileSync19 } = __require("node:fs");
           const { join: join55 } = __require("node:path");
           const sessionDir = join55(this._workingDirectory, ".oa", "session", this._sessionId);
-          mkdirSync20(sessionDir, { recursive: true });
+          mkdirSync21(sessionDir, { recursive: true });
           const checkpoint = {
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
             sessionId: this._sessionId,
@@ -18273,7 +19082,7 @@ ${marker}` : marker);
             memexEntryCount: this._memexArchive.size,
             fileRegistrySize: this._fileRegistry.size
           };
-          writeFileSync18(join55(sessionDir, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
+          writeFileSync19(join55(sessionDir, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
         } catch {
         }
       }
@@ -19515,10 +20324,12 @@ var init_nexusBackend = __esm({
       sendFn;
       model;
       targetPeer;
-      constructor(sendFn, model, targetPeer) {
+      authKey;
+      constructor(sendFn, model, targetPeer, authKey) {
         this.sendFn = sendFn;
         this.model = model;
         this.targetPeer = targetPeer || "";
+        this.authKey = authKey || "";
       }
       async chatCompletion(request) {
         const daemonArgs = {
@@ -19531,6 +20342,9 @@ var init_nexusBackend = __esm({
         if (this.targetPeer) {
           daemonArgs.target_peer = this.targetPeer;
         }
+        if (this.authKey) {
+          daemonArgs.auth_key = this.authKey;
+        }
         const rawResult = await this.sendFn("remote_infer", daemonArgs, request.timeoutMs || 12e4);
         let parsed;
         try {
@@ -19664,6 +20478,273 @@ var init_nexusBackend = __esm({
   }
 });
 
+// packages/orchestrator/dist/cascadeBackend.js
+var CascadeBackend;
+var init_cascadeBackend = __esm({
+  "packages/orchestrator/dist/cascadeBackend.js"() {
+    "use strict";
+    init_agenticRunner();
+    init_nexusBackend();
+    CascadeBackend = class {
+      model;
+      endpoints;
+      backends = /* @__PURE__ */ new Map();
+      activeIndex = 0;
+      consecutiveFailures = 0;
+      maxFailures;
+      probeTimer = null;
+      onSwitch;
+      onProbeResult;
+      stopped = false;
+      constructor(model, endpoints, options) {
+        if (endpoints.length === 0)
+          throw new Error("CascadeBackend requires at least one endpoint");
+        this.model = model;
+        this.endpoints = [...endpoints];
+        this.maxFailures = options?.maxFailuresBeforeSwitch ?? 2;
+        this.onSwitch = options?.onSwitch;
+        this.onProbeResult = options?.onProbeResult;
+        for (const ep of this.endpoints) {
+          this.backends.set(ep.url, this.createBackend(ep));
+        }
+        if (this.endpoints.length > 1) {
+          const probeInterval = options?.probeIntervalMs ?? 3e4;
+          this.probeTimer = setInterval(() => this.probePrimary(), probeInterval);
+        }
+      }
+      /** Get the currently active endpoint */
+      get activeEndpoint() {
+        return this.endpoints[this.activeIndex];
+      }
+      /** Get all endpoints with their status */
+      get endpointStatus() {
+        return this.endpoints.map((ep, i) => ({
+          ...ep,
+          active: i === this.activeIndex,
+          failures: i === this.activeIndex ? this.consecutiveFailures : 0
+        }));
+      }
+      /** Number of available fallback endpoints */
+      get fallbackCount() {
+        return this.endpoints.filter((ep, i) => i !== this.activeIndex && ep.modelAvailable !== false).length;
+      }
+      async chatCompletion(request) {
+        const backend = this.getActiveBackend();
+        try {
+          const result = await backend.chatCompletion(request);
+          this.consecutiveFailures = 0;
+          return result;
+        } catch (err) {
+          this.consecutiveFailures++;
+          if (this.isTransientError(err) && this.consecutiveFailures >= this.maxFailures) {
+            const nextIdx = this.findNextAvailableEndpoint();
+            if (nextIdx !== null && nextIdx !== this.activeIndex) {
+              const from = this.endpoints[this.activeIndex];
+              const to = this.endpoints[nextIdx];
+              const reason = `${this.consecutiveFailures} consecutive failures: ${err instanceof Error ? err.message : String(err)}`;
+              this.activeIndex = nextIdx;
+              this.consecutiveFailures = 0;
+              this.onSwitch?.(from, to, reason);
+              const newBackend = this.getActiveBackend();
+              try {
+                const result = await newBackend.chatCompletion(request);
+                return result;
+              } catch (cascadeErr) {
+                this.consecutiveFailures++;
+                throw cascadeErr;
+              }
+            }
+          }
+          throw err;
+        }
+      }
+      /**
+       * Streaming support — delegates to active backend's stream method if available.
+       */
+      async *chatCompletionStream(request) {
+        const backend = this.getActiveBackend();
+        const streamable = backend;
+        if (typeof streamable.chatCompletionStream !== "function") {
+          const result = await this.chatCompletion(request);
+          const choice = result.choices[0];
+          if (choice?.message.content) {
+            yield { type: "content", content: choice.message.content };
+          }
+          if (choice?.message.toolCalls) {
+            for (let i = 0; i < choice.message.toolCalls.length; i++) {
+              const tc = choice.message.toolCalls[i];
+              yield {
+                type: "tool_call_delta",
+                toolCallIndex: i,
+                toolCallId: tc.id,
+                toolCallName: tc.name,
+                toolCallArgs: JSON.stringify(tc.arguments)
+              };
+            }
+          }
+          if (result.usage) {
+            yield {
+              type: "usage",
+              usage: {
+                promptTokens: result.usage.promptTokens ?? 0,
+                completionTokens: result.usage.completionTokens ?? 0,
+                totalTokens: result.usage.totalTokens
+              }
+            };
+          }
+          yield { type: "finish", finishReason: "stop" };
+          return;
+        }
+        try {
+          for await (const chunk of streamable.chatCompletionStream(request)) {
+            yield chunk;
+          }
+          this.consecutiveFailures = 0;
+        } catch (err) {
+          this.consecutiveFailures++;
+          if (this.isTransientError(err) && this.consecutiveFailures >= this.maxFailures) {
+            const nextIdx = this.findNextAvailableEndpoint();
+            if (nextIdx !== null && nextIdx !== this.activeIndex) {
+              const from = this.endpoints[this.activeIndex];
+              const to = this.endpoints[nextIdx];
+              this.activeIndex = nextIdx;
+              this.consecutiveFailures = 0;
+              this.onSwitch?.(from, to, err instanceof Error ? err.message : String(err));
+              const result = await this.chatCompletion(request);
+              const choice = result.choices[0];
+              if (choice?.message.content) {
+                yield { type: "content", content: choice.message.content };
+              }
+              if (choice?.message.toolCalls) {
+                for (let i = 0; i < choice.message.toolCalls.length; i++) {
+                  const tc = choice.message.toolCalls[i];
+                  yield {
+                    type: "tool_call_delta",
+                    toolCallIndex: i,
+                    toolCallId: tc.id,
+                    toolCallName: tc.name,
+                    toolCallArgs: JSON.stringify(tc.arguments)
+                  };
+                }
+              }
+              yield { type: "finish", finishReason: "stop" };
+              return;
+            }
+          }
+          throw err;
+        }
+      }
+      /** Add a fallback endpoint at the end of the cascade */
+      addEndpoint(endpoint) {
+        this.endpoints.push(endpoint);
+        this.backends.set(endpoint.url, this.createBackend(endpoint));
+        if (this.endpoints.length === 2 && !this.probeTimer) {
+          this.probeTimer = setInterval(() => this.probePrimary(), 3e4);
+        }
+      }
+      /** Remove an endpoint from the cascade */
+      removeEndpoint(url) {
+        const idx = this.endpoints.findIndex((ep) => ep.url === url);
+        if (idx === -1)
+          return;
+        if (idx === this.activeIndex)
+          return;
+        this.endpoints.splice(idx, 1);
+        this.backends.delete(url);
+        if (this.activeIndex > idx) {
+          this.activeIndex--;
+        }
+      }
+      /** Stop the cascade (clears probe timer) */
+      stop() {
+        this.stopped = true;
+        if (this.probeTimer) {
+          clearInterval(this.probeTimer);
+          this.probeTimer = null;
+        }
+      }
+      /** Update the model (e.g. when user runs /model) */
+      setModel(model) {
+        this.model = model;
+        for (const ep of this.endpoints) {
+          this.backends.set(ep.url, this.createBackend(ep));
+        }
+      }
+      // ── Private helpers ────────────────────────────────────────────────────
+      getActiveBackend() {
+        const ep = this.endpoints[this.activeIndex];
+        return this.backends.get(ep.url);
+      }
+      createBackend(ep) {
+        if (ep.backendType === "nexus" && ep.sendCommandFn) {
+          const targetPeer = ep.url.startsWith("peer://") ? ep.url.slice(7) : void 0;
+          return new NexusAgenticBackend(ep.sendCommandFn, this.model, targetPeer, ep.apiKey);
+        }
+        return new OllamaAgenticBackend(ep.url, this.model, ep.apiKey);
+      }
+      findNextAvailableEndpoint() {
+        for (let offset = 1; offset < this.endpoints.length; offset++) {
+          const idx = (this.activeIndex + offset) % this.endpoints.length;
+          const ep = this.endpoints[idx];
+          if (ep.modelAvailable !== false) {
+            return idx;
+          }
+        }
+        return null;
+      }
+      isTransientError(err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (/Backend HTTP (502|503|504)/i.test(msg))
+          return true;
+        if (/fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EPIPE|socket hang up/i.test(msg))
+          return true;
+        if (/received HTML error page/i.test(msg))
+          return true;
+        if (/model is loading|server busy|overloaded/i.test(msg))
+          return true;
+        if (/remote inference failed|timed out/i.test(msg))
+          return true;
+        return false;
+      }
+      /**
+       * Probe the primary endpoint to check if it's recovered.
+       * If the current active endpoint is NOT the primary, tests the primary
+       * with a lightweight request and switches back if successful.
+       */
+      async probePrimary() {
+        if (this.stopped)
+          return;
+        if (this.activeIndex === 0)
+          return;
+        if (this.endpoints.length === 0)
+          return;
+        const primary = this.endpoints[0];
+        const primaryBackend = this.backends.get(primary.url);
+        if (!primaryBackend)
+          return;
+        try {
+          const result = await primaryBackend.chatCompletion({
+            messages: [{ role: "user", content: "ping" }],
+            tools: [],
+            temperature: 0,
+            maxTokens: 1,
+            timeoutMs: 1e4
+          });
+          if (result.choices.length > 0) {
+            this.onProbeResult?.(primary, true);
+            const from = this.endpoints[this.activeIndex];
+            this.activeIndex = 0;
+            this.consecutiveFailures = 0;
+            this.onSwitch?.(from, primary, "Primary endpoint recovered");
+          }
+        } catch {
+          this.onProbeResult?.(primary, false);
+        }
+      }
+    };
+  }
+});
+
 // packages/orchestrator/dist/flowstatePrompt.js
 var FLOWSTATE_PROMPT;
 var init_flowstatePrompt = __esm({
@@ -20198,6 +21279,7 @@ var init_dist5 = __esm({
     init_retryController();
     init_agenticRunner();
     init_nexusBackend();
+    init_cascadeBackend();
     init_flowstatePrompt();
     init_costTracker();
     init_workEvaluator();
@@ -20218,9 +21300,9 @@ __export(listen_exports, {
   isVideoPath: () => isVideoPath,
   waitForTranscribeCli: () => waitForTranscribeCli
 });
-import { spawn as spawn12, execSync as execSync23 } from "node:child_process";
-import { existsSync as existsSync25, mkdirSync as mkdirSync7, writeFileSync as writeFileSync7, readdirSync as readdirSync6 } from "node:fs";
-import { join as join34, dirname as dirname12 } from "node:path";
+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 { homedir as homedir8 } from "node:os";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 import { EventEmitter } from "node:events";
@@ -20304,7 +21386,7 @@ function findMicCaptureCommand() {
   return null;
 }
 function findLiveWhisperScript() {
-  const thisDir = dirname12(fileURLToPath8(import.meta.url));
+  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"),
@@ -20314,7 +21396,7 @@ function findLiveWhisperScript() {
     join34(thisDir, "../../scripts/live-whisper.py")
   ];
   for (const p of candidates) {
-    if (existsSync25(p))
+    if (existsSync26(p))
       return p;
   }
   try {
@@ -20328,17 +21410,17 @@ function findLiveWhisperScript() {
       join34(globalRoot, "open-agents-ai", "scripts", "live-whisper.py")
     ];
     for (const p of candidates2) {
-      if (existsSync25(p))
+      if (existsSync26(p))
         return p;
     }
   } catch {
   }
   const nvmBase = join34(homedir8(), ".nvm", "versions", "node");
-  if (existsSync25(nvmBase)) {
+  if (existsSync26(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 (existsSync25(p))
+        if (existsSync26(p))
           return p;
       }
     } catch {
@@ -20356,7 +21438,7 @@ function ensureTranscribeCliBackground() {
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      if (existsSync25(join34(globalRoot, "transcribe-cli", "dist", "index.js"))) {
+      if (existsSync26(join34(globalRoot, "transcribe-cli", "dist", "index.js"))) {
         return true;
       }
     } catch {
@@ -20428,7 +21510,7 @@ var init_listen = __esm({
           const timeout = setTimeout(() => {
             reject(new Error("Whisper fallback: model load timeout (5 min). First run downloads the model."));
           }, 3e5);
-          this.process = spawn12("python3", [
+          this.process = spawn14("python3", [
             this.scriptPath,
             "--model",
             this.model,
@@ -20580,7 +21662,7 @@ var init_listen = __esm({
             stdio: ["pipe", "pipe", "pipe"]
           }).trim();
           const tcPath = join34(globalRoot, "transcribe-cli");
-          if (existsSync25(join34(tcPath, "dist", "index.js"))) {
+          if (existsSync26(join34(tcPath, "dist", "index.js"))) {
             const { createRequire: createRequire4 } = await import("node:module");
             const req = createRequire4(import.meta.url);
             return req(join34(tcPath, "dist", "index.js"));
@@ -20588,12 +21670,12 @@ var init_listen = __esm({
         } catch {
         }
         const nvmBase = join34(homedir8(), ".nvm", "versions", "node");
-        if (existsSync25(nvmBase)) {
+        if (existsSync26(nvmBase)) {
           try {
             const { readdirSync: readdirSync16 } = await import("node:fs");
             for (const ver of readdirSync16(nvmBase)) {
               const tcPath = join34(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
-              if (existsSync25(join34(tcPath, "dist", "index.js"))) {
+              if (existsSync26(join34(tcPath, "dist", "index.js"))) {
                 const { createRequire: createRequire4 } = await import("node:module");
                 const req = createRequire4(import.meta.url);
                 return req(join34(tcPath, "dist", "index.js"));
@@ -20710,7 +21792,7 @@ transcribe-cli error: ${transcribeCliError}` : "";
             return `Failed to start live transcription: ${msg}${tcHint}`;
           }
         }
-        this.micProcess = spawn12(micCmd.cmd, micCmd.args, {
+        this.micProcess = spawn14(micCmd.cmd, micCmd.args, {
           stdio: ["pipe", "pipe", "pipe"],
           env: { ...process.env }
         });
@@ -20879,9 +21961,9 @@ transcribe-cli error: ${transcribeCliError}` : "";
           if (outputDir) {
             const { basename: basename16 } = await import("node:path");
             const transcriptDir = join34(outputDir, ".oa", "transcripts");
-            mkdirSync7(transcriptDir, { recursive: true });
+            mkdirSync8(transcriptDir, { recursive: true });
             const outFile = join34(transcriptDir, `${basename16(filePath)}.txt`);
-            writeFileSync7(outFile, result.text, "utf-8");
+            writeFileSync8(outFile, result.text, "utf-8");
           }
           return {
             text: result.text,
@@ -25470,7 +26552,7 @@ var init_render = __esm({
 
 // packages/cli/dist/tui/voice-session.js
 import { createServer } from "node:http";
-import { spawn as spawn13, execSync as execSync24 } from "node:child_process";
+import { spawn as spawn15, execSync as execSync24 } from "node:child_process";
 import { EventEmitter as EventEmitter2 } from "node:events";
 function generateFrontendHTML() {
   return `<!DOCTYPE html>
@@ -26124,7 +27206,7 @@ var init_voice_session = __esm({
           const timeout = setTimeout(() => {
             reject(new Error("Cloudflared tunnel start timeout (30s)"));
           }, 3e4);
-          this.cloudflaredProcess = spawn13("cloudflared", [
+          this.cloudflaredProcess = spawn15("cloudflared", [
             "tunnel",
             "--url",
             `http://127.0.0.1:${port}`
@@ -26198,12 +27280,12 @@ var init_voice_session = __esm({
 
 // packages/cli/dist/tui/expose.js
 import { createServer as createServer2, request as httpRequest } from "node:http";
-import { spawn as spawn14, exec } from "node:child_process";
+import { spawn as spawn16, exec } from "node:child_process";
 import { EventEmitter as EventEmitter3 } from "node:events";
 import { randomBytes as randomBytes7 } from "node:crypto";
 import { URL as URL2 } from "node:url";
 import { loadavg, cpus, totalmem, freemem } from "node:os";
-import { existsSync as existsSync26, readFileSync as readFileSync18, writeFileSync as writeFileSync8, unlinkSync as unlinkSync3, mkdirSync as mkdirSync8, readdirSync as readdirSync7 } from "node:fs";
+import { existsSync as existsSync27, readFileSync as readFileSync19, writeFileSync as writeFileSync9, unlinkSync as unlinkSync3, mkdirSync as mkdirSync9, readdirSync as readdirSync7 } from "node:fs";
 import { join as join35 } from "node:path";
 function cleanForwardHeaders(raw, targetHost) {
   const out = {};
@@ -26233,9 +27315,9 @@ function fmtTokens(n) {
 function readExposeState(stateDir) {
   try {
     const path = join35(stateDir, STATE_FILE_NAME);
-    if (!existsSync26(path))
+    if (!existsSync27(path))
       return null;
-    const raw = readFileSync18(path, "utf8");
+    const raw = readFileSync19(path, "utf8");
     const data = JSON.parse(raw);
     if (!data.pid || !data.tunnelUrl || !data.authKey || !data.proxyPort)
       return null;
@@ -26246,8 +27328,8 @@ function readExposeState(stateDir) {
 }
 function writeExposeState(stateDir, state) {
   try {
-    mkdirSync8(stateDir, { recursive: true });
-    writeFileSync8(join35(stateDir, STATE_FILE_NAME), JSON.stringify(state, null, 2));
+    mkdirSync9(stateDir, { recursive: true });
+    writeFileSync9(join35(stateDir, STATE_FILE_NAME), JSON.stringify(state, null, 2));
   } catch {
   }
 }
@@ -26349,6 +27431,7 @@ var init_expose = __esm({
       _targetUrl;
       _kind;
       _stateDir;
+      _fullAccess;
       _stats = {
         status: "standby",
         totalRequests: 0,
@@ -26381,6 +27464,7 @@ var init_expose = __esm({
         this._kind = options.kind;
         this._targetUrl = options.targetUrl ?? DEFAULT_TARGETS[options.kind];
         this._stateDir = options.stateDir ?? null;
+        this._fullAccess = options.fullAccess ?? false;
         if (options.authKey === void 0 || options.authKey === "") {
           this._authKey = randomBytes7(24).toString("base64url");
         } else {
@@ -26566,6 +27650,18 @@ var init_expose = __esm({
           this.emitStats();
           url.searchParams.delete("key");
           const forwardPath = url.pathname + url.search;
+          if (!this._fullAccess) {
+            const p = url.pathname.toLowerCase();
+            if (p === "/api/pull" || p === "/api/delete" || p === "/api/create" || p === "/api/copy" || p === "/api/push" || p === "/api/blobs") {
+              this._stats.activeConnections--;
+              user.activeRequests--;
+              res.writeHead(403, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({
+                error: "Forbidden \u2014 model management is disabled. Provider must run /expose with --full to allow this."
+              }));
+              return;
+            }
+          }
           const bodyChunks = [];
           req.on("data", (chunk) => bodyChunks.push(chunk));
           req.on("end", () => {
@@ -26755,7 +27851,7 @@ var init_expose = __esm({
           const timeout = setTimeout(() => {
             reject(new Error("Cloudflared tunnel start timeout (30s)"));
           }, 3e4);
-          this.cloudflaredProcess = spawn14("cloudflared", [
+          this.cloudflaredProcess = spawn16("cloudflared", [
             "tunnel",
             "--url",
             `http://127.0.0.1:${port}`,
@@ -26956,6 +28052,7 @@ ${this.formatConnectionInfo()}`);
       // NexusTool instance
       _kind;
       _targetUrl;
+      _authKey;
       _peerId = null;
       _capabilities = [];
       _exposedModels = 0;
@@ -26976,6 +28073,9 @@ ${this.formatConnectionInfo()}`);
       get peerId() {
         return this._peerId;
       }
+      get authKey() {
+        return this._authKey;
+      }
       get stats() {
         return this._stats;
       }
@@ -26999,6 +28099,11 @@ ${this.formatConnectionInfo()}`);
         this._margin = options.margin ?? 0.5;
         this._onInfo = options.onInfo;
         this._onError = options.onError;
+        if (options.authKey === void 0 || options.authKey === "") {
+          this._authKey = randomBytes7(24).toString("base64url");
+        } else {
+          this._authKey = options.authKey;
+        }
       }
       async start() {
         this._onInfo?.("Connecting to nexus P2P network...");
@@ -27015,14 +28120,16 @@ ${this.formatConnectionInfo()}`);
         let exposeResult = await this._nexusTool.execute({
           action: "expose",
           ollama_url: this._targetUrl,
-          margin: String(this._margin)
+          margin: String(this._margin),
+          auth_key: this._authKey
         });
         if (!exposeResult.success && exposeResult.error?.includes("not running")) {
           await new Promise((r) => setTimeout(r, 3e3));
           exposeResult = await this._nexusTool.execute({
             action: "expose",
             ollama_url: this._targetUrl,
-            margin: String(this._margin)
+            margin: String(this._margin),
+            auth_key: this._authKey
           });
         }
         if (!exposeResult.success) {
@@ -27032,7 +28139,7 @@ ${this.formatConnectionInfo()}`);
         const statusPath = join35(nexusDir, "status.json");
         for (let i = 0; i < 60; i++) {
           try {
-            const raw = readFileSync18(statusPath, "utf8");
+            const raw = readFileSync19(statusPath, "utf8");
             if (raw.length > 10) {
               const status = JSON.parse(raw);
               if (status.connected && status.peerId) {
@@ -27065,8 +28172,8 @@ ${this.formatConnectionInfo()}`);
         this._pollTimer = setInterval(() => {
           try {
             const statusPath = join35(nexusDir, "status.json");
-            if (existsSync26(statusPath)) {
-              const status = JSON.parse(readFileSync18(statusPath, "utf8"));
+            if (existsSync27(statusPath)) {
+              const status = JSON.parse(readFileSync19(statusPath, "utf8"));
               if (status.peerId && !this._peerId) {
                 this._peerId = status.peerId;
               }
@@ -27076,7 +28183,7 @@ ${this.formatConnectionInfo()}`);
           }
           try {
             const invocDir = join35(nexusDir, "invocations");
-            if (existsSync26(invocDir)) {
+            if (existsSync27(invocDir)) {
               const files = readdirSync7(invocDir);
               const invocCount = files.filter((f) => f.endsWith(".json")).length;
               if (invocCount > this._stats.totalRequests) {
@@ -27088,8 +28195,8 @@ ${this.formatConnectionInfo()}`);
           }
           try {
             const meteringFile = join35(nexusDir, "metering.jsonl");
-            if (existsSync26(meteringFile)) {
-              const content = readFileSync18(meteringFile, "utf8");
+            if (existsSync27(meteringFile)) {
+              const content = readFileSync19(meteringFile, "utf8");
               if (content.length > lastMeteringSize) {
                 const newContent = content.slice(lastMeteringSize);
                 lastMeteringSize = content.length;
@@ -27165,15 +28272,24 @@ ${this.formatConnectionInfo()}`);
       }
       /** Format connection info for display */
       formatConnectionInfo() {
+        const endpointCmd = `/endpoint ${this._peerId ?? "<peer-id>"} --auth ${this._authKey}`;
         const lines = [];
         lines.push(`  ${c2.green("\u25CF")} Expose gateway active ${c2.dim("(libp2p)")}`);
         lines.push(`  ${c2.cyan("Backend".padEnd(12))} ${this._kind} (${this._targetUrl})`);
         lines.push(`  ${c2.cyan("Transport".padEnd(12))} ${c2.bold("libp2p")} (DHT + mDNS + NATS relay)`);
         lines.push(`  ${c2.cyan("Peer ID".padEnd(12))} ${c2.bold(this._peerId ?? "connecting...")}`);
+        lines.push(`  ${c2.cyan("Auth Key".padEnd(12))} ${c2.bold(this._authKey)}`);
         lines.push(`  ${c2.cyan("Models".padEnd(12))} ${this._exposedModels || this._capabilities.filter((cap) => cap.startsWith("inference:")).length} exposed`);
         lines.push("");
-        lines.push(`  ${c2.dim("Remote peers discover your models via nexus network.")}`);
-        lines.push(`  ${c2.dim("Consumers use: /nexus invoke_capability inference:<model>")}`);
+        lines.push(`  ${c2.dim("Remote consumers connect with:")}`);
+        lines.push(`  ${c2.bold(endpointCmd)}`);
+        lines.push("");
+        lines.push(`  ${c2.yellow("!")} ${c2.dim("Keep this key secure \u2014 it grants full access to your models.")}`);
+        if ((process.stdout.isTTY ?? false) && this._peerId) {
+          const b64 = Buffer.from(endpointCmd).toString("base64");
+          lines.push(`\x1B]52;c;${b64}\x07`);
+          lines.push(`  ${c2.dim("(copied to clipboard)")}`);
+        }
         const infCaps = this._capabilities.filter((cap) => cap.startsWith("inference:"));
         if (infCaps.length > 0) {
           lines.push("");
@@ -27255,8 +28371,8 @@ 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 readFileSync19, writeFileSync as writeFileSync9, existsSync as existsSync27, mkdirSync as mkdirSync9 } from "node:fs";
-import { join as join36, dirname as dirname13 } from "node:path";
+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";
 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"() {
@@ -27467,19 +28583,19 @@ var init_secret_vault = __esm({
         const encrypted = Buffer.concat([cipher.update(data, "utf8"), cipher.final()]);
         const tag = cipher.getAuthTag();
         const blob = Buffer.concat([salt, iv, tag, encrypted]);
-        const dir = dirname13(this.storePath);
-        if (!existsSync27(dir))
-          mkdirSync9(dir, { recursive: true });
-        writeFileSync9(this.storePath, blob, { mode: 384 });
+        const dir = dirname14(this.storePath);
+        if (!existsSync28(dir))
+          mkdirSync10(dir, { recursive: true });
+        writeFileSync10(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 || !existsSync27(this.storePath))
+        if (!this.storePath || !existsSync28(this.storePath))
           return 0;
-        const blob = readFileSync19(this.storePath);
+        const blob = readFileSync20(this.storePath);
         if (blob.length < SALT_LEN + IV_LEN + 16) {
           throw new Error("Vault file is corrupted (too small)");
         }
@@ -28516,7 +29632,54 @@ async function fetchOpenAIModels(baseUrl, apiKey) {
     parameterSize: m.owned_by ?? void 0
   })).sort((a, b) => a.name.localeCompare(b.name));
 }
+async function fetchPeerModels(peerId) {
+  try {
+    const { NexusTool: NexusTool2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
+    const cwd4 = process.cwd();
+    const nexusTool = new NexusTool2(cwd4);
+    const result = await nexusTool.execute({
+      action: "find_agent",
+      peer_id: peerId
+    });
+    if (result.success && result.output) {
+      const models = [];
+      const capMatches = result.output.matchAll(/inference:([^\s,\]]+)/g);
+      for (const m of capMatches) {
+        const capName = m[1];
+        const modelName = capName.replace(/_(\d+[bBmMkK])$/, ":$1").replace(/_latest$/, ":latest");
+        models.push({
+          name: modelName,
+          size: "",
+          modified: "",
+          sizeBytes: 0,
+          parameterSize: "remote"
+        });
+      }
+      if (models.length > 0)
+        return models;
+    }
+    const { existsSync: existsSync42, readFileSync: readFileSync31 } = await import("node:fs");
+    const { join: join55 } = await import("node:path");
+    const pricingPath = join55(nexusTool.getNexusDir(), "pricing.json");
+    if (existsSync42(pricingPath)) {
+      const pricing = JSON.parse(readFileSync31(pricingPath, "utf8"));
+      return (pricing.models || []).map((m) => ({
+        name: m.model || "unknown",
+        size: m.parameterSize || "",
+        modified: "",
+        sizeBytes: 0,
+        parameterSize: m.parameterSize || "remote"
+      }));
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}
 async function fetchModels(baseUrl, apiKey) {
+  if (baseUrl.startsWith("peer://")) {
+    return fetchPeerModels(baseUrl.slice(7));
+  }
   const provider = detectProvider(baseUrl);
   if (provider.id === "ollama") {
     try {
@@ -28593,6 +29756,8 @@ async function queryOpenAIContextSize(baseUrl, modelName, apiKey) {
   }
 }
 async function queryContextSize(baseUrl, modelName, apiKey) {
+  if (baseUrl.startsWith("peer://"))
+    return 32768;
   const ollamaSize = await queryModelContextSize(baseUrl, modelName);
   if (ollamaSize)
     return ollamaSize;
@@ -28600,6 +29765,16 @@ async function queryContextSize(baseUrl, modelName, apiKey) {
 }
 async function queryModelCapabilities(baseUrl, modelName) {
   const caps = { vision: false, toolUse: false, thinking: false };
+  if (baseUrl.startsWith("peer://")) {
+    const nameLower = modelName.toLowerCase();
+    if (/qwen3|qwen2\.5|llama3\.[13]|mistral|mixtral|command-r|gemma3|devstral|deepseek/.test(nameLower)) {
+      caps.toolUse = true;
+    }
+    if (/qwen3|deepseek-r1/.test(nameLower)) {
+      caps.thinking = true;
+    }
+    return caps;
+  }
   try {
     const normalized = normalizeBaseUrl(baseUrl);
     const res = await fetch(`${normalized}/api/show`, {
@@ -28699,17 +29874,17 @@ var init_render2 = __esm({
 });
 
 // packages/prompts/dist/promptLoader.js
-import { readFileSync as readFileSync20, existsSync as existsSync28 } from "node:fs";
-import { join as join37, dirname as dirname14 } from "node:path";
+import { readFileSync as readFileSync21, existsSync as existsSync29 } from "node:fs";
+import { join as join37, 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 (!existsSync28(fullPath)) {
+    if (!existsSync29(fullPath)) {
       throw new Error(`Prompt file not found: ${fullPath}`);
     }
-    content = readFileSync20(fullPath, "utf-8");
+    content = readFileSync21(fullPath, "utf-8");
     cache2.set(promptPath, content);
   }
   if (!vars)
@@ -28721,10 +29896,10 @@ var init_promptLoader2 = __esm({
   "packages/prompts/dist/promptLoader.js"() {
     "use strict";
     __filename2 = fileURLToPath9(import.meta.url);
-    __dirname5 = dirname14(__filename2);
+    __dirname5 = dirname15(__filename2);
     devPath = join37(__dirname5, "..", "templates");
     publishedPath = join37(__dirname5, "..", "prompts", "templates");
-    PROMPTS_DIR2 = existsSync28(devPath) ? devPath : publishedPath;
+    PROMPTS_DIR2 = existsSync29(devPath) ? devPath : publishedPath;
     cache2 = /* @__PURE__ */ new Map();
   }
 });
@@ -28835,7 +30010,7 @@ var init_task_templates = __esm({
 });
 
 // packages/prompts/dist/index.js
-import { join as join38, dirname as dirname15 } from "node:path";
+import { join as join38, dirname as dirname16 } from "node:path";
 import { fileURLToPath as fileURLToPath10 } from "node:url";
 var _dir, _packageRoot;
 var init_dist6 = __esm({
@@ -28845,27 +30020,27 @@ var init_dist6 = __esm({
     init_render2();
     init_task_templates();
     init_render2();
-    _dir = dirname15(fileURLToPath10(import.meta.url));
+    _dir = dirname16(fileURLToPath10(import.meta.url));
     _packageRoot = join38(_dir, "..");
   }
 });
 
 // packages/cli/dist/tui/oa-directory.js
-import { existsSync as existsSync29, mkdirSync as mkdirSync10, readFileSync as readFileSync21, writeFileSync as writeFileSync10, readdirSync as readdirSync8, statSync as statSync9, unlinkSync as unlinkSync4 } from "node:fs";
+import { existsSync as existsSync30, mkdirSync as mkdirSync11, readFileSync as readFileSync22, writeFileSync as writeFileSync11, readdirSync as readdirSync8, statSync as statSync9, unlinkSync as unlinkSync4 } from "node:fs";
 import { join as join39, 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);
   for (const sub of SUBDIRS) {
-    mkdirSync10(join39(oaPath, sub), { recursive: true });
+    mkdirSync11(join39(oaPath, sub), { recursive: true });
   }
   try {
     const gitignorePath = join39(repoRoot, ".gitignore");
     const settingsPattern = ".oa/settings.json";
-    if (existsSync29(gitignorePath)) {
-      const content = readFileSync21(gitignorePath, "utf-8");
+    if (existsSync30(gitignorePath)) {
+      const content = readFileSync22(gitignorePath, "utf-8");
       if (!content.includes(settingsPattern)) {
-        writeFileSync10(gitignorePath, content.trimEnd() + "\n" + settingsPattern + "\n", "utf-8");
+        writeFileSync11(gitignorePath, content.trimEnd() + "\n" + settingsPattern + "\n", "utf-8");
       }
     }
   } catch {
@@ -28873,13 +30048,13 @@ function initOaDirectory(repoRoot) {
   return oaPath;
 }
 function hasOaDirectory(repoRoot) {
-  return existsSync29(join39(repoRoot, OA_DIR, "index"));
+  return existsSync30(join39(repoRoot, OA_DIR, "index"));
 }
 function loadProjectSettings(repoRoot) {
   const settingsPath = join39(repoRoot, OA_DIR, "settings.json");
   try {
-    if (existsSync29(settingsPath)) {
-      return JSON.parse(readFileSync21(settingsPath, "utf-8"));
+    if (existsSync30(settingsPath)) {
+      return JSON.parse(readFileSync22(settingsPath, "utf-8"));
     }
   } catch {
   }
@@ -28887,16 +30062,16 @@ function loadProjectSettings(repoRoot) {
 }
 function saveProjectSettings(repoRoot, settings) {
   const oaPath = join39(repoRoot, OA_DIR);
-  mkdirSync10(oaPath, { recursive: true });
+  mkdirSync11(oaPath, { recursive: true });
   const existing = loadProjectSettings(repoRoot);
   const merged = { ...existing, ...settings };
-  writeFileSync10(join39(oaPath, "settings.json"), JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  writeFileSync11(join39(oaPath, "settings.json"), JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
 }
 function loadGlobalSettings() {
   const settingsPath = join39(homedir9(), ".open-agents", "settings.json");
   try {
-    if (existsSync29(settingsPath)) {
-      return JSON.parse(readFileSync21(settingsPath, "utf-8"));
+    if (existsSync30(settingsPath)) {
+      return JSON.parse(readFileSync22(settingsPath, "utf-8"));
     }
   } catch {
   }
@@ -28904,10 +30079,10 @@ function loadGlobalSettings() {
 }
 function saveGlobalSettings(settings) {
   const dir = join39(homedir9(), ".open-agents");
-  mkdirSync10(dir, { recursive: true });
+  mkdirSync11(dir, { recursive: true });
   const existing = loadGlobalSettings();
   const merged = { ...existing, ...settings };
-  writeFileSync10(join39(dir, "settings.json"), JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  writeFileSync11(join39(dir, "settings.json"), JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
 }
 function resolveSettings(repoRoot) {
   const global = loadGlobalSettings();
@@ -28924,10 +30099,10 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
     for (const name of CONTEXT_FILES) {
       const filePath = join39(dir, name);
       const normalizedName = name.toLowerCase();
-      if (existsSync29(filePath) && !seen.has(filePath)) {
+      if (existsSync30(filePath) && !seen.has(filePath)) {
         seen.add(filePath);
         try {
-          let content = readFileSync21(filePath, "utf-8");
+          let content = readFileSync22(filePath, "utf-8");
           if (content.length > maxContentLen) {
             content = content.slice(0, maxContentLen) + "\n\n...(truncated)";
           }
@@ -28942,10 +30117,10 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
       }
     }
     const projectMap = join39(dir, OA_DIR, "context", "project-map.md");
-    if (existsSync29(projectMap) && !seen.has(projectMap)) {
+    if (existsSync30(projectMap) && !seen.has(projectMap)) {
       seen.add(projectMap);
       try {
-        let content = readFileSync21(projectMap, "utf-8");
+        let content = readFileSync22(projectMap, "utf-8");
         if (content.length > maxContentLen) {
           content = content.slice(0, maxContentLen) + "\n\n...(truncated)";
         }
@@ -28977,7 +30152,7 @@ function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
 function readIndexMeta(repoRoot) {
   const metaPath = join39(repoRoot, OA_DIR, "index", "meta.json");
   try {
-    return JSON.parse(readFileSync21(metaPath, "utf-8"));
+    return JSON.parse(readFileSync22(metaPath, "utf-8"));
   } catch {
     return null;
   }
@@ -29029,18 +30204,18 @@ ${tree}\`\`\`
   }
   const content = sections.join("\n");
   const contextDir = join39(repoRoot, OA_DIR, "context");
-  mkdirSync10(contextDir, { recursive: true });
-  writeFileSync10(join39(contextDir, "project-map.md"), content, "utf-8");
+  mkdirSync11(contextDir, { recursive: true });
+  writeFileSync11(join39(contextDir, "project-map.md"), content, "utf-8");
   return content;
 }
 function saveSession(repoRoot, session) {
   const historyDir = join39(repoRoot, OA_DIR, "history");
-  mkdirSync10(historyDir, { recursive: true });
-  writeFileSync10(join39(historyDir, `${session.id}.json`), JSON.stringify(session, null, 2), "utf-8");
+  mkdirSync11(historyDir, { recursive: true });
+  writeFileSync11(join39(historyDir, `${session.id}.json`), JSON.stringify(session, null, 2), "utf-8");
 }
 function loadRecentSessions(repoRoot, limit = 5) {
   const historyDir = join39(repoRoot, OA_DIR, "history");
-  if (!existsSync29(historyDir))
+  if (!existsSync30(historyDir))
     return [];
   try {
     const files = readdirSync8(historyDir).filter((f) => f.endsWith(".json") && f !== "pending-task.json").map((f) => {
@@ -29049,7 +30224,7 @@ function loadRecentSessions(repoRoot, limit = 5) {
     }).sort((a, b) => b.mtime - a.mtime).slice(0, limit);
     return files.map((f) => {
       try {
-        return JSON.parse(readFileSync21(join39(historyDir, f.file), "utf-8"));
+        return JSON.parse(readFileSync22(join39(historyDir, f.file), "utf-8"));
       } catch {
         return null;
       }
@@ -29060,15 +30235,15 @@ function loadRecentSessions(repoRoot, limit = 5) {
 }
 function savePendingTask(repoRoot, task) {
   const historyDir = join39(repoRoot, OA_DIR, "history");
-  mkdirSync10(historyDir, { recursive: true });
-  writeFileSync10(join39(historyDir, PENDING_TASK_FILE), JSON.stringify(task, null, 2) + "\n", "utf-8");
+  mkdirSync11(historyDir, { recursive: true });
+  writeFileSync11(join39(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);
   try {
-    if (!existsSync29(filePath))
+    if (!existsSync30(filePath))
       return null;
-    const data = JSON.parse(readFileSync21(filePath, "utf-8"));
+    const data = JSON.parse(readFileSync22(filePath, "utf-8"));
     try {
       unlinkSync4(filePath);
     } catch {
@@ -29080,12 +30255,12 @@ function loadPendingTask(repoRoot) {
 }
 function saveSessionContext(repoRoot, entry) {
   const contextDir = join39(repoRoot, OA_DIR, "context");
-  mkdirSync10(contextDir, { recursive: true });
+  mkdirSync11(contextDir, { recursive: true });
   const filePath = join39(contextDir, CONTEXT_SAVE_FILE);
   let ctx;
   try {
-    if (existsSync29(filePath)) {
-      ctx = JSON.parse(readFileSync21(filePath, "utf-8"));
+    if (existsSync30(filePath)) {
+      ctx = JSON.parse(readFileSync22(filePath, "utf-8"));
     } else {
       ctx = { entries: [], maxEntries: MAX_CONTEXT_ENTRIES, updatedAt: "" };
     }
@@ -29097,14 +30272,14 @@ function saveSessionContext(repoRoot, entry) {
     ctx.entries = ctx.entries.slice(-ctx.maxEntries);
   }
   ctx.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  writeFileSync10(filePath, JSON.stringify(ctx, null, 2) + "\n", "utf-8");
+  writeFileSync11(filePath, JSON.stringify(ctx, null, 2) + "\n", "utf-8");
 }
 function loadSessionContext(repoRoot) {
   const filePath = join39(repoRoot, OA_DIR, "context", CONTEXT_SAVE_FILE);
   try {
-    if (!existsSync29(filePath))
+    if (!existsSync30(filePath))
       return null;
-    return JSON.parse(readFileSync21(filePath, "utf-8"));
+    return JSON.parse(readFileSync22(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -29152,11 +30327,11 @@ function detectManifests(repoRoot) {
   ];
   for (const check of checks) {
     const filePath = join39(repoRoot, check.file);
-    if (existsSync29(filePath)) {
+    if (existsSync30(filePath)) {
       let name;
       if (check.nameField) {
         try {
-          const data = JSON.parse(readFileSync21(filePath, "utf-8"));
+          const data = JSON.parse(readFileSync22(filePath, "utf-8"));
           name = data[check.nameField];
         } catch {
         }
@@ -29185,7 +30360,7 @@ function findKeyFiles(repoRoot) {
     { pattern: "CLAUDE.md", description: "Claude Code context" }
   ];
   for (const check of checks) {
-    if (existsSync29(join39(repoRoot, check.pattern))) {
+    if (existsSync30(join39(repoRoot, check.pattern))) {
       keyFiles.push({ path: check.pattern, description: check.description });
     }
   }
@@ -29228,8 +30403,8 @@ function buildDirTree(root, maxDepth, prefix = "", depth = 0) {
 }
 function loadUsageFile(filePath) {
   try {
-    if (existsSync29(filePath)) {
-      return JSON.parse(readFileSync21(filePath, "utf-8"));
+    if (existsSync30(filePath)) {
+      return JSON.parse(readFileSync22(filePath, "utf-8"));
     }
   } catch {
   }
@@ -29237,8 +30412,8 @@ function loadUsageFile(filePath) {
 }
 function saveUsageFile(filePath, data) {
   const dir = join39(filePath, "..");
-  mkdirSync10(dir, { recursive: true });
-  writeFileSync10(filePath, JSON.stringify(data, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  mkdirSync11(dir, { recursive: true });
+  writeFileSync11(filePath, JSON.stringify(data, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
 }
 function recordUsage(kind, value, opts) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -29341,9 +30516,9 @@ var init_oa_directory = __esm({
 
 // packages/cli/dist/tui/setup.js
 import * as readline from "node:readline";
-import { execSync as execSync25, spawn as spawn15, exec as exec2 } from "node:child_process";
+import { execSync as execSync25, spawn as spawn17, exec as exec2 } from "node:child_process";
 import { promisify as promisify5 } from "node:util";
-import { existsSync as existsSync30, writeFileSync as writeFileSync11, mkdirSync as mkdirSync11 } from "node:fs";
+import { existsSync as existsSync31, writeFileSync as writeFileSync12, mkdirSync as mkdirSync12 } from "node:fs";
 import { join as join40 } from "node:path";
 import { homedir as homedir10, platform } from "node:os";
 function detectSystemSpecs() {
@@ -29621,7 +30796,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 = existsSync30("/opt/homebrew/bin/brew") ? "/opt/homebrew" : "/usr/local";
+          const brewPrefix = existsSync31("/opt/homebrew/bin/brew") ? "/opt/homebrew" : "/usr/local";
           process.env["PATH"] = `${brewPrefix}/bin:${process.env["PATH"]}`;
         } catch {
         }
@@ -29729,7 +30904,7 @@ async function ensureOllamaRunning(backendUrl, rl) {
   process.stdout.write(`  ${c2.cyan("\u25CF")} Starting ollama serve...
 `);
   try {
-    const child = spawn15("ollama", ["serve"], { stdio: "ignore", detached: true });
+    const child = spawn17("ollama", ["serve"], { stdio: "ignore", detached: true });
     child.unref();
   } catch {
     process.stdout.write(`  ${c2.yellow("\u26A0")} Could not start ollama serve.
@@ -30197,7 +31372,7 @@ async function doSetup(config, rl) {
   ${c2.cyan("\u25CF")} Ollama is installed but not running. Starting automatically...
 `);
         try {
-          const child = spawn15("ollama", ["serve"], { stdio: "ignore", detached: true });
+          const child = spawn17("ollama", ["serve"], { stdio: "ignore", detached: true });
           child.unref();
           await new Promise((resolve31) => setTimeout(resolve31, 3e3));
           try {
@@ -30225,7 +31400,7 @@ async function doSetup(config, rl) {
   ${c2.cyan("\u25CF")} Starting ollama serve...
 `);
             try {
-              const child = spawn15("ollama", ["serve"], { stdio: "ignore", detached: true });
+              const child = spawn17("ollama", ["serve"], { stdio: "ignore", detached: true });
               child.unref();
               await new Promise((resolve31) => setTimeout(resolve31, 3e3));
               try {
@@ -30376,9 +31551,9 @@ async function doSetup(config, rl) {
           `PARAMETER stop "<|endoftext|>"`
         ].join("\n");
         const modelDir2 = join40(homedir10(), ".open-agents", "models");
-        mkdirSync11(modelDir2, { recursive: true });
+        mkdirSync12(modelDir2, { recursive: true });
         const modelfilePath = join40(modelDir2, `Modelfile.${customName}`);
-        writeFileSync11(modelfilePath, modelfileContent + "\n", "utf8");
+        writeFileSync12(modelfilePath, modelfileContent + "\n", "utf8");
         process.stdout.write(`  ${c2.dim("Creating model...")} `);
         execSync25(`ollama create ${customName} -f ${modelfilePath}`, {
           stdio: "pipe",
@@ -30423,7 +31598,7 @@ async function isModelAvailable(config) {
 }
 function isFirstRun() {
   try {
-    return !existsSync30(join40(homedir10(), ".open-agents", "config.json"));
+    return !existsSync31(join40(homedir10(), ".open-agents", "config.json"));
   } catch {
     return true;
   }
@@ -30473,7 +31648,7 @@ function hasVenvModule() {
 function ensureVenv(log) {
   const venvDir = getVenvDir();
   const venvPip = join40(venvDir, "bin", "pip");
-  if (existsSync30(venvPip))
+  if (existsSync31(venvPip))
     return venvDir;
   log("Creating Python venv for vision deps...");
   if (!hasCmd("python3")) {
@@ -30485,7 +31660,7 @@ function ensureVenv(log) {
     return null;
   }
   try {
-    mkdirSync11(join40(homedir10(), ".open-agents"), { recursive: true });
+    mkdirSync12(join40(homedir10(), ".open-agents"), { recursive: true });
     execSync25(`python3 -m venv "${venvDir}"`, { stdio: "pipe", timeout: 3e4 });
     execSync25(`"${join40(venvDir, "bin", "pip")}" install --upgrade pip`, {
       stdio: "pipe",
@@ -30681,12 +31856,12 @@ async function ensureVisionDeps(onInfo, getSudoPassword) {
   const venvBin = join40(venvDir, "bin");
   const venvMoondream = join40(venvBin, "moondream-station");
   const venv = ensureVenv(log);
-  if (venv && !hasCmd("moondream-station") && !existsSync30(venvMoondream)) {
+  if (venv && !hasCmd("moondream-station") && !existsSync31(venvMoondream)) {
     const venvPip = join40(venvBin, "pip");
     log("Installing moondream-station in ~/.open-agents/venv...");
     try {
       execSync25(`"${venvPip}" install moondream-station`, { stdio: "pipe", timeout: 3e5 });
-      if (existsSync30(venvMoondream)) {
+      if (existsSync31(venvMoondream)) {
         log("moondream-station installed successfully.");
       } else {
         try {
@@ -30818,9 +31993,9 @@ async function createExpandedVariantAsync(baseModel, specs, sizeGB) {
       `PARAMETER stop "<|endoftext|>"`
     ].join("\n");
     const modelDir2 = join40(homedir10(), ".open-agents", "models");
-    mkdirSync11(modelDir2, { recursive: true });
+    mkdirSync12(modelDir2, { recursive: true });
     const modelfilePath = join40(modelDir2, `Modelfile.${customName}`);
-    writeFileSync11(modelfilePath, modelfileContent + "\n", "utf8");
+    writeFileSync12(modelfilePath, modelfileContent + "\n", "utf8");
     await execAsync(`ollama create ${customName} -f ${modelfilePath}`, {
       timeout: 12e4
     });
@@ -31838,6 +33013,7 @@ async function handleSlashCommand(input, ctx) {
           renderInfo("  /expose status           Show usage stats");
           renderInfo("  --key <key>              Use specific auth key (tunnel mode)");
           renderInfo("  --key                    Auto-generate auth key (tunnel mode)");
+          renderInfo("  --full                   Allow full Ollama API access (pull/delete/etc)");
         }
         return "handled";
       }
@@ -31857,8 +33033,9 @@ async function handleSlashCommand(input, ctx) {
       } else if (exposeParts.includes("--libp2p")) {
         exposeTransport = "libp2p";
       }
+      const exposeFullAccess = exposeParts.includes("--full");
       try {
-        const tunnelUrl = await ctx.exposeStart(kindOrUrl, exposeAuthKey, exposeTransport);
+        const tunnelUrl = await ctx.exposeStart(kindOrUrl, exposeAuthKey, exposeTransport, exposeFullAccess);
         if (tunnelUrl) {
           const info = ctx.getExposeInfo?.();
           if (info) {
@@ -32618,6 +33795,10 @@ async function handleEndpoint(arg, ctx, local = false) {
   if (authIdx !== -1 && parts[authIdx + 1]) {
     apiKey = parts[authIdx + 1];
   }
+  if (url.startsWith("12D3KooW") && url.length > 40 && !url.includes("://")) {
+    await handlePeerEndpoint(url, apiKey, ctx, local);
+    return;
+  }
   try {
     new URL(url);
   } catch {
@@ -32741,6 +33922,110 @@ async function handleEndpoint(arg, ctx, local = false) {
     renderWarning(`Could not verify model availability on ${provider.label}. If inference fails, use /model to switch.`);
   }
 }
+async function handlePeerEndpoint(peerId, authKey, ctx, local) {
+  process.stdout.write(`
+  ${c2.dim("Detected:")} ${c2.bold("libp2p peer")}
+`);
+  process.stdout.write(`  ${c2.cyan("Peer ID".padEnd(12))} ${peerId}
+`);
+  if (authKey) {
+    process.stdout.write(`  ${c2.cyan("Auth Key".padEnd(12))} ${authKey.slice(0, 8)}...
+`);
+  }
+  process.stdout.write(`  ${c2.dim("Connecting to nexus network...")} `);
+  try {
+    if (!ctx.nexusConnect) {
+      throw new Error("Nexus not available \u2014 run /nexus connect first");
+    }
+    const connectMsg = await ctx.nexusConnect();
+    process.stdout.write(`${c2.green("\u2714")} Connected
+`);
+  } catch (err) {
+    process.stdout.write(`${c2.yellow("\u26A0")} ${err instanceof Error ? err.message : String(err)}
+`);
+    renderInfo("Setting peer endpoint anyway \u2014 nexus may connect later.");
+  }
+  const peerUrl = `peer://${peerId}`;
+  ctx.setEndpoint(peerUrl, "nexus", authKey);
+  const endpointSettings = { backendUrl: peerUrl, backendType: "nexus", ...authKey ? { apiKey: authKey } : {} };
+  if (local) {
+    ctx.saveLocalSettings(endpointSettings);
+  } else {
+    setConfigValue("backendUrl", peerUrl);
+    setConfigValue("backendType", "nexus");
+    if (authKey)
+      setConfigValue("apiKey", authKey);
+    ctx.saveSettings(endpointSettings);
+  }
+  recordUsage("endpoint", peerUrl, {
+    repoRoot: local ? ctx.repoRoot : void 0,
+    local,
+    meta: {
+      provider: "libp2p-peer",
+      backendType: "nexus",
+      peerId,
+      ...authKey ? { authHint: authKey.slice(0, 4) + "..." } : {}
+    }
+  });
+  process.stdout.write(`
+  ${c2.green("\u2714")} Endpoint set to libp2p peer${local ? " (project-local)" : ""}:
+`);
+  process.stdout.write(`    ${c2.cyan("Transport".padEnd(12))} libp2p (DHT + mDNS + NATS relay)
+`);
+  process.stdout.write(`    ${c2.cyan("Peer ID".padEnd(12))} ${peerId}
+`);
+  if (authKey) {
+    process.stdout.write(`    ${c2.cyan("Auth".padEnd(12))} ${authKey.slice(0, 8)}...
+`);
+  }
+  process.stdout.write(`
+  ${c2.dim("Inference requests will be routed via nexus P2P network.")}
+
+`);
+  try {
+    const models = await fetchModels(peerUrl, authKey);
+    if (models.length > 0) {
+      process.stdout.write(`  ${c2.green("\u2714")} Discovered ${models.length} model(s) on peer:
+`);
+      for (const m of models.slice(0, 10)) {
+        process.stdout.write(`    ${c2.dim("\u2022")} ${m.name}${m.parameterSize ? c2.dim(` (${m.parameterSize})`) : ""}
+`);
+      }
+      if (models.length > 10) {
+        process.stdout.write(`    ${c2.dim(`... and ${models.length - 10} more`)}
+`);
+      }
+      process.stdout.write("\n");
+      const currentModel = ctx.config.model;
+      const found = findModel(models, currentModel);
+      if (!found && models.length > 0) {
+        const autoModel = models[0].name;
+        ctx.setModel(autoModel);
+        if (local) {
+          ctx.saveLocalSettings({ model: autoModel });
+        } else {
+          ctx.saveSettings({ model: autoModel });
+        }
+        renderWarning(`Model "${currentModel}" not found on peer.`);
+        renderModelSwitch(currentModel, autoModel);
+      } else if (found) {
+        process.stdout.write(`  ${c2.green("\u2714")} Model "${currentModel}" available on peer.
+
+`);
+      }
+    } else {
+      renderWarning("No models discovered on peer. The peer may not have exposed yet, or discovery needs time.");
+      renderInfo("Use /models to try again, or just send a prompt \u2014 inference will attempt to reach the peer directly.");
+    }
+  } catch {
+    renderWarning("Could not discover models on peer. Use /models to try again later.");
+  }
+  ctx.refreshModelCache?.();
+  if (ctx.hasActiveTask?.()) {
+    ctx.abortActiveTask?.();
+    renderWarning("Active task aborted \u2014 endpoint changed. Send a new prompt to continue.");
+  }
+}
 async function handleUpdate(subcommand, ctx) {
   const repoRoot = ctx.repoRoot;
   if (subcommand === "auto") {
@@ -32761,17 +34046,17 @@ async function handleUpdate(subcommand, ctx) {
   try {
     const { createRequire: createRequire4 } = await import("node:module");
     const { fileURLToPath: fileURLToPath14 } = await import("node:url");
-    const { dirname: dirname19, join: join55 } = await import("node:path");
-    const { existsSync: existsSync41 } = await import("node:fs");
+    const { dirname: dirname20, join: join55 } = await import("node:path");
+    const { existsSync: existsSync42 } = await import("node:fs");
     const req = createRequire4(import.meta.url);
-    const thisDir = dirname19(fileURLToPath14(import.meta.url));
+    const thisDir = dirname20(fileURLToPath14(import.meta.url));
     const candidates = [
       join55(thisDir, "..", "package.json"),
       join55(thisDir, "..", "..", "package.json"),
       join55(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync41(pkgPath)) {
+      if (existsSync42(pkgPath)) {
         const pkg = req(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           currentVersion = pkg.version ?? "0.0.0";
@@ -33056,7 +34341,7 @@ var init_commands = __esm({
 });
 
 // packages/cli/dist/tui/project-context.js
-import { existsSync as existsSync31, readFileSync as readFileSync22, readdirSync as readdirSync9 } from "node:fs";
+import { existsSync as existsSync32, readFileSync as readFileSync23, readdirSync as readdirSync9 } from "node:fs";
 import { join as join41, basename as basename10 } from "node:path";
 import { execSync as execSync26 } from "node:child_process";
 import { homedir as homedir11, platform as platform2, release } from "node:os";
@@ -33093,9 +34378,9 @@ function loadProjectMap(repoRoot) {
     initOaDirectory(repoRoot);
   }
   const mapPath = join41(repoRoot, OA_DIR, "context", "project-map.md");
-  if (existsSync31(mapPath)) {
+  if (existsSync32(mapPath)) {
     try {
-      const content = readFileSync22(mapPath, "utf-8");
+      const content = readFileSync23(mapPath, "utf-8");
       return content;
     } catch {
     }
@@ -33141,7 +34426,7 @@ function loadMemoryContext(repoRoot) {
   if (oaEntries)
     sections.push(oaEntries);
   const legacyMemDir = join41(repoRoot, ".open-agents", "memory");
-  if (legacyMemDir !== oaMemDir && existsSync31(legacyMemDir)) {
+  if (legacyMemDir !== oaMemDir && existsSync32(legacyMemDir)) {
     const legacyEntries = loadMemoryDir(legacyMemDir, "project/legacy");
     if (legacyEntries)
       sections.push(legacyEntries);
@@ -33153,14 +34438,14 @@ function loadMemoryContext(repoRoot) {
   return sections.join("\n\n");
 }
 function loadMemoryDir(memDir, scope) {
-  if (!existsSync31(memDir))
+  if (!existsSync32(memDir))
     return "";
   const lines = [];
   try {
     const files = readdirSync9(memDir).filter((f) => f.endsWith(".json"));
     for (const file of files.slice(0, 10)) {
       try {
-        const raw = readFileSync22(join41(memDir, file), "utf-8");
+        const raw = readFileSync23(join41(memDir, file), "utf-8");
         const entries = JSON.parse(raw);
         const topic = basename10(file, ".json");
         const keys = Object.keys(entries);
@@ -34183,22 +35468,22 @@ var init_carousel = __esm({
 });
 
 // packages/cli/dist/tui/carousel-descriptors.js
-import { existsSync as existsSync32, readFileSync as readFileSync23, writeFileSync as writeFileSync12, mkdirSync as mkdirSync12, readdirSync as readdirSync10 } from "node:fs";
+import { existsSync as existsSync33, readFileSync as readFileSync24, writeFileSync as writeFileSync13, mkdirSync as mkdirSync13, readdirSync as readdirSync10 } from "node:fs";
 import { join as join42, basename as basename11 } from "node:path";
 function loadToolProfile(repoRoot) {
   const filePath = join42(repoRoot, OA_DIR, "context", TOOL_PROFILE_FILE);
   try {
-    if (!existsSync32(filePath))
+    if (!existsSync33(filePath))
       return null;
-    return JSON.parse(readFileSync23(filePath, "utf-8"));
+    return JSON.parse(readFileSync24(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveToolProfile(repoRoot, profile) {
   const contextDir = join42(repoRoot, OA_DIR, "context");
-  mkdirSync12(contextDir, { recursive: true });
-  writeFileSync12(join42(contextDir, TOOL_PROFILE_FILE), JSON.stringify(profile, null, 2), "utf-8");
+  mkdirSync13(contextDir, { recursive: true });
+  writeFileSync13(join42(contextDir, TOOL_PROFILE_FILE), JSON.stringify(profile, null, 2), "utf-8");
 }
 function categorizeToolCall(toolName) {
   for (const cat of TOOL_CATEGORIES) {
@@ -34258,9 +35543,9 @@ function weightedColor(profile) {
 function loadCachedDescriptors(repoRoot) {
   const filePath = join42(repoRoot, OA_DIR, "context", DESCRIPTOR_FILE);
   try {
-    if (!existsSync32(filePath))
+    if (!existsSync33(filePath))
       return null;
-    const cached = JSON.parse(readFileSync23(filePath, "utf-8"));
+    const cached = JSON.parse(readFileSync24(filePath, "utf-8"));
     return cached.phrases.length > 0 ? cached.phrases : null;
   } catch {
     return null;
@@ -34268,13 +35553,13 @@ function loadCachedDescriptors(repoRoot) {
 }
 function saveCachedDescriptors(repoRoot, phrases, sourceHash) {
   const contextDir = join42(repoRoot, OA_DIR, "context");
-  mkdirSync12(contextDir, { recursive: true });
+  mkdirSync13(contextDir, { recursive: true });
   const cached = {
     phrases,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     sourceHash
   };
-  writeFileSync12(join42(contextDir, DESCRIPTOR_FILE), JSON.stringify(cached, null, 2), "utf-8");
+  writeFileSync13(join42(contextDir, DESCRIPTOR_FILE), JSON.stringify(cached, null, 2), "utf-8");
 }
 function generateDescriptors(repoRoot) {
   const profile = loadToolProfile(repoRoot);
@@ -34324,9 +35609,9 @@ function generateDescriptors(repoRoot) {
 function extractFromPackageJson(repoRoot, tags) {
   const pkgPath = join42(repoRoot, "package.json");
   try {
-    if (!existsSync32(pkgPath))
+    if (!existsSync33(pkgPath))
       return;
-    const pkg = JSON.parse(readFileSync23(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync24(pkgPath, "utf-8"));
     if (pkg.name && typeof pkg.name === "string") {
       const parts = pkg.name.replace(/^@/, "").split("/");
       for (const p of parts)
@@ -34370,7 +35655,7 @@ function extractFromManifests(repoRoot, tags) {
     { file: ".github/workflows", tag: "ci/cd" }
   ];
   for (const check of manifestChecks) {
-    if (existsSync32(join42(repoRoot, check.file))) {
+    if (existsSync33(join42(repoRoot, check.file))) {
       tags.push(check.tag);
     }
   }
@@ -34394,14 +35679,14 @@ function extractFromSessions(repoRoot, tags) {
 function extractFromMemory(repoRoot, tags) {
   const memoryDir = join42(repoRoot, OA_DIR, "memory");
   try {
-    if (!existsSync32(memoryDir))
+    if (!existsSync33(memoryDir))
       return;
     const files = readdirSync10(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(readFileSync23(join42(memoryDir, file), "utf-8"));
+        const data = JSON.parse(readFileSync24(join42(memoryDir, file), "utf-8"));
         if (data && typeof data === "object") {
           const keys = Object.keys(data).slice(0, 3);
           for (const key of keys) {
@@ -34536,7 +35821,7 @@ var init_carousel_descriptors = __esm({
 });
 
 // packages/cli/dist/tui/voice.js
-import { existsSync as existsSync33, mkdirSync as mkdirSync13, writeFileSync as writeFileSync13, readFileSync as readFileSync24, unlinkSync as unlinkSync5 } from "node:fs";
+import { existsSync as existsSync34, mkdirSync as mkdirSync14, writeFileSync as writeFileSync14, readFileSync as readFileSync25, unlinkSync as unlinkSync5 } from "node:fs";
 import { join as join43 } from "node:path";
 import { homedir as homedir12, tmpdir as tmpdir6, platform as platform3 } from "node:os";
 import { execSync as execSync27, spawn as nodeSpawn } from "node:child_process";
@@ -35546,7 +36831,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)
@@ -35722,11 +37007,11 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
             return;
           }
         }
-        if (!existsSync33(wavPath))
+        if (!existsSync34(wavPath))
           return;
         if (volume !== 1) {
           try {
-            const wavData = readFileSync24(wavPath);
+            const wavData = readFileSync25(wavPath);
             if (wavData.length > 44) {
               const header = wavData.subarray(0, 44);
               const samples = new Int16Array(wavData.buffer, wavData.byteOffset + 44, (wavData.length - 44) / 2);
@@ -35734,14 +37019,14 @@ 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 {
           }
         }
         if (this.onPCMOutput) {
           try {
-            const wavData = readFileSync24(wavPath);
+            const wavData = readFileSync25(wavPath);
             if (wavData.length > 44) {
               const pcm = Buffer.from(wavData.buffer, wavData.byteOffset + 44, wavData.length - 44);
               const sampleRate = wavData.readUInt32LE(24);
@@ -35790,10 +37075,10 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
             return null;
           }
         }
-        if (!existsSync33(wavPath))
+        if (!existsSync34(wavPath))
           return null;
         try {
-          const data = readFileSync24(wavPath);
+          const data = readFileSync25(wavPath);
           unlinkSync5(wavPath);
           return data;
         } catch {
@@ -35807,24 +37092,24 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
         if (this.ort)
           return;
         const arch = process.arch;
-        mkdirSync13(voiceDir(), { recursive: true });
+        mkdirSync14(voiceDir(), { recursive: true });
         const pkgPath = join43(voiceDir(), "package.json");
         const expectedDeps = {
           "onnxruntime-node": "^1.21.0",
           "phonemizer": "^1.2.1"
         };
-        if (existsSync33(pkgPath)) {
+        if (existsSync34(pkgPath)) {
           try {
-            const existing = JSON.parse(readFileSync24(pkgPath, "utf8"));
+            const existing = JSON.parse(readFileSync25(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 (!existsSync33(pkgPath)) {
-          writeFileSync13(pkgPath, JSON.stringify({
+        if (!existsSync34(pkgPath)) {
+          writeFileSync14(pkgPath, JSON.stringify({
             name: "open-agents-voice",
             private: true,
             dependencies: expectedDeps
@@ -35841,7 +37126,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
           }
         };
         const onnxNodeModules = join43(voiceDir(), "node_modules", "onnxruntime-node");
-        const onnxInstalled = existsSync33(onnxNodeModules);
+        const onnxInstalled = existsSync34(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.`);
         }
@@ -35899,18 +37184,18 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
         const dir = modelDir(id);
         const onnxPath = modelOnnxPath(id);
         const configPath = modelConfigPath(id);
-        if (existsSync33(onnxPath) && existsSync33(configPath))
+        if (existsSync34(onnxPath) && existsSync34(configPath))
           return;
-        mkdirSync13(dir, { recursive: true });
-        if (!existsSync33(configPath)) {
+        mkdirSync14(dir, { recursive: true });
+        if (!existsSync34(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 (!existsSync33(onnxPath)) {
+        if (!existsSync34(onnxPath)) {
           renderInfo(`Downloading ${model.label} voice model (this may take a minute)...`);
           const onnxResp = await fetch(model.onnxUrl);
           if (!onnxResp.ok)
@@ -35935,7 +37220,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)}).`);
         }
       }
@@ -35947,10 +37232,10 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
           throw new Error("ONNX runtime not loaded");
         const onnxPath = modelOnnxPath(this.modelId);
         const configPath = modelConfigPath(this.modelId);
-        if (!existsSync33(onnxPath) || !existsSync33(configPath)) {
+        if (!existsSync34(onnxPath) || !existsSync34(configPath)) {
           throw new Error(`Model files not found for ${this.modelId}`);
         }
-        this.config = JSON.parse(readFileSync24(configPath, "utf8"));
+        this.config = JSON.parse(readFileSync25(configPath, "utf8"));
         this.session = await this.ort.InferenceSession.create(onnxPath, {
           executionProviders: ["cpu"],
           graphOptimizationLevel: "all"
@@ -36811,13 +38096,13 @@ var init_stream_renderer = __esm({
 });
 
 // packages/cli/dist/tui/edit-history.js
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync14 } from "node:fs";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync15 } from "node:fs";
 import { join as join44 } from "node:path";
 function createEditHistoryLogger(repoRoot, sessionId) {
   const historyDir = join44(repoRoot, ".oa", "history");
   const logPath = join44(historyDir, "edits.jsonl");
   try {
-    mkdirSync14(historyDir, { recursive: true });
+    mkdirSync15(historyDir, { recursive: true });
   } catch {
   }
   function logToolCall(toolName, toolArgs, success) {
@@ -36926,17 +38211,17 @@ var init_edit_history = __esm({
 });
 
 // packages/cli/dist/tui/promptLoader.js
-import { readFileSync as readFileSync25, existsSync as existsSync34 } from "node:fs";
-import { join as join45, dirname as dirname16 } from "node:path";
+import { readFileSync as readFileSync26, existsSync as existsSync35 } from "node:fs";
+import { join as join45, 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 = join45(PROMPTS_DIR3, promptPath);
-    if (!existsSync34(fullPath)) {
+    if (!existsSync35(fullPath)) {
       throw new Error(`Prompt file not found: ${fullPath}`);
     }
-    content = readFileSync25(fullPath, "utf-8");
+    content = readFileSync26(fullPath, "utf-8");
     cache3.set(promptPath, content);
   }
   if (!vars)
@@ -36948,24 +38233,24 @@ var init_promptLoader3 = __esm({
   "packages/cli/dist/tui/promptLoader.js"() {
     "use strict";
     __filename3 = fileURLToPath11(import.meta.url);
-    __dirname6 = dirname16(__filename3);
+    __dirname6 = dirname17(__filename3);
     devPath2 = join45(__dirname6, "..", "..", "prompts");
     publishedPath2 = join45(__dirname6, "..", "prompts");
-    PROMPTS_DIR3 = existsSync34(devPath2) ? devPath2 : publishedPath2;
+    PROMPTS_DIR3 = existsSync35(devPath2) ? devPath2 : publishedPath2;
     cache3 = /* @__PURE__ */ new Map();
   }
 });
 
 // packages/cli/dist/tui/dream-engine.js
-import { mkdirSync as mkdirSync15, writeFileSync as writeFileSync14, readFileSync as readFileSync26, existsSync as existsSync35, cpSync, rmSync, readdirSync as readdirSync11 } from "node:fs";
+import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync15, readFileSync as readFileSync27, existsSync as existsSync36, cpSync, rmSync, readdirSync as readdirSync11 } from "node:fs";
 import { join as join46, basename as basename12 } from "node:path";
 import { execSync as execSync28 } from "node:child_process";
 function loadAutoresearchMemory(repoRoot) {
   const memoryPath = join46(repoRoot, ".oa", "memory", "autoresearch.json");
-  if (!existsSync35(memoryPath))
+  if (!existsSync36(memoryPath))
     return "";
   try {
-    const raw = readFileSync26(memoryPath, "utf-8");
+    const raw = readFileSync27(memoryPath, "utf-8");
     const data = JSON.parse(raw);
     const sections = [];
     for (const key of AUTORESEARCH_MEMORY_KEYS) {
@@ -37161,8 +38446,8 @@ var init_dream_engine = __esm({
         }
         try {
           const dir = join46(targetPath, "..");
-          mkdirSync15(dir, { recursive: true });
-          writeFileSync14(targetPath, content, "utf-8");
+          mkdirSync16(dir, { recursive: true });
+          writeFileSync15(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 };
@@ -37195,15 +38480,15 @@ var init_dream_engine = __esm({
           return { success: false, output: "", error: "Autoresearch mode: edits are confined to .oa/autoresearch/", durationMs: Date.now() - start };
         }
         try {
-          if (!existsSync35(targetPath)) {
+          if (!existsSync36(targetPath)) {
             return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: Date.now() - start };
           }
-          let content = readFileSync26(targetPath, "utf-8");
+          let content = readFileSync27(targetPath, "utf-8");
           if (!content.includes(oldStr)) {
             return { success: false, output: "", error: "old_string not found in file", durationMs: Date.now() - start };
           }
           content = content.replace(oldStr, newStr);
-          writeFileSync14(targetPath, content, "utf-8");
+          writeFileSync15(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 };
@@ -37250,8 +38535,8 @@ var init_dream_engine = __esm({
         }
         try {
           const dir = join46(targetPath, "..");
-          mkdirSync15(dir, { recursive: true });
-          writeFileSync14(targetPath, content, "utf-8");
+          mkdirSync16(dir, { recursive: true });
+          writeFileSync15(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 };
@@ -37284,15 +38569,15 @@ var init_dream_engine = __esm({
           return { success: false, output: "", error: "Dream mode: edits are confined to .oa/dreams/", durationMs: Date.now() - start };
         }
         try {
-          if (!existsSync35(targetPath)) {
+          if (!existsSync36(targetPath)) {
             return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: Date.now() - start };
           }
-          let content = readFileSync26(targetPath, "utf-8");
+          let content = readFileSync27(targetPath, "utf-8");
           if (!content.includes(oldStr)) {
             return { success: false, output: "", error: "old_string not found in file", durationMs: Date.now() - start };
           }
           content = content.replace(oldStr, newStr);
-          writeFileSync14(targetPath, content, "utf-8");
+          writeFileSync15(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 };
@@ -37377,7 +38662,7 @@ var init_dream_engine = __esm({
           startedAt: (/* @__PURE__ */ new Date()).toISOString(),
           results: []
         };
-        mkdirSync15(this.dreamsDir, { recursive: true });
+        mkdirSync16(this.dreamsDir, { recursive: true });
         this.saveDreamState();
         try {
           for (let cycle = 1; cycle <= totalCycles; cycle++) {
@@ -37431,7 +38716,7 @@ ${result.summary}`;
               renderDreamContraction(cycle);
               const cycleSummary = this.buildCycleSummary(cycle, previousFindings);
               const summaryPath = join46(this.dreamsDir, `cycle-${cycle}-summary.md`);
-              writeFileSync14(summaryPath, cycleSummary, "utf-8");
+              writeFileSync15(summaryPath, cycleSummary, "utf-8");
             }
             if (mode === "lucid" && !this.abortController.signal.aborted) {
               this.saveVersionCheckpoint(cycle);
@@ -38029,8 +39314,8 @@ ${summaryResult}
 *Generated by open-agents autoresearch swarm*
 `;
         try {
-          mkdirSync15(this.dreamsDir, { recursive: true });
-          writeFileSync14(reportPath, report, "utf-8");
+          mkdirSync16(this.dreamsDir, { recursive: true });
+          writeFileSync15(reportPath, report, "utf-8");
         } catch {
         }
         renderSwarmComplete(workspace);
@@ -38098,7 +39383,7 @@ ${summaryResult}
       saveVersionCheckpoint(cycle) {
         const checkpointDir = join46(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
         try {
-          mkdirSync15(checkpointDir, { recursive: true });
+          mkdirSync16(checkpointDir, { recursive: true });
           try {
             const gitStatus = execSync28("git status --porcelain", {
               cwd: this.repoRoot,
@@ -38115,10 +39400,10 @@ ${summaryResult}
               encoding: "utf-8",
               timeout: 5e3
             }).trim();
-            writeFileSync14(join46(checkpointDir, "git-status.txt"), gitStatus, "utf-8");
-            writeFileSync14(join46(checkpointDir, "git-diff.patch"), gitDiff, "utf-8");
-            writeFileSync14(join46(checkpointDir, "git-hash.txt"), gitHash, "utf-8");
-            writeFileSync14(join46(checkpointDir, "checkpoint.json"), JSON.stringify({
+            writeFileSync15(join46(checkpointDir, "git-status.txt"), gitStatus, "utf-8");
+            writeFileSync15(join46(checkpointDir, "git-diff.patch"), gitDiff, "utf-8");
+            writeFileSync15(join46(checkpointDir, "git-hash.txt"), gitHash, "utf-8");
+            writeFileSync15(join46(checkpointDir, "checkpoint.json"), JSON.stringify({
               cycle,
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
               gitHash,
@@ -38126,7 +39411,7 @@ ${summaryResult}
             }, null, 2), "utf-8");
             renderInfo(`Checkpoint saved: cycle ${cycle} (${gitHash.slice(0, 8)})`);
           } catch {
-            writeFileSync14(join46(checkpointDir, "checkpoint.json"), JSON.stringify({ cycle, timestamp: (/* @__PURE__ */ new Date()).toISOString(), mode: this.state.mode }, null, 2), "utf-8");
+            writeFileSync15(join46(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) {
@@ -38184,14 +39469,14 @@ ${files.map((f) => `- [\`${f}\`](./${f})`).join("\n")}
 ---
 *Auto-generated by open-agents dream engine*
 `;
-          writeFileSync14(join46(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
+          writeFileSync15(join46(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
         } catch {
         }
       }
       /** Save dream state for resume/inspection */
       saveDreamState() {
         try {
-          writeFileSync14(join46(this.dreamsDir, "dream-state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
+          writeFileSync15(join46(this.dreamsDir, "dream-state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
         } catch {
         }
       }
@@ -38565,7 +39850,7 @@ var init_bless_engine = __esm({
 });
 
 // packages/cli/dist/tui/dmn-engine.js
-import { existsSync as existsSync36, readFileSync as readFileSync27, writeFileSync as writeFileSync15, mkdirSync as mkdirSync16, readdirSync as readdirSync12, unlinkSync as unlinkSync6 } from "node:fs";
+import { existsSync as existsSync37, readFileSync as readFileSync28, writeFileSync as writeFileSync16, mkdirSync as mkdirSync17, readdirSync as readdirSync12, unlinkSync as unlinkSync6 } from "node:fs";
 import { join as join47, basename as basename13 } from "node:path";
 function buildDMNGatherPrompt(recentTaskSummaries, dueReminders, attentionItems, memoryTopics, capabilities, competence, reflectionBuffer) {
   const competenceReport = competence.length > 0 ? competence.map((c3) => {
@@ -38681,7 +39966,7 @@ var init_dmn_engine = __esm({
         this.repoRoot = repoRoot;
         this.stateDir = join47(repoRoot, ".oa", "dmn");
         this.historyDir = join47(repoRoot, ".oa", "dmn", "cycles");
-        mkdirSync16(this.historyDir, { recursive: true });
+        mkdirSync17(this.historyDir, { recursive: true });
         this.loadState();
       }
       get stats() {
@@ -39274,7 +40559,7 @@ OUTPUT: Call task_complete with JSON:
           join47(this.repoRoot, ".open-agents", "memory")
         ];
         for (const dir of dirs) {
-          if (!existsSync36(dir))
+          if (!existsSync37(dir))
             continue;
           try {
             const files = readdirSync12(dir).filter((f) => f.endsWith(".json"));
@@ -39291,23 +40576,23 @@ OUTPUT: Call task_complete with JSON:
       // ── State persistence ─────────────────────────────────────────────────
       loadState() {
         const path = join47(this.stateDir, "state.json");
-        if (existsSync36(path)) {
+        if (existsSync37(path)) {
           try {
-            this.state = JSON.parse(readFileSync27(path, "utf-8"));
+            this.state = JSON.parse(readFileSync28(path, "utf-8"));
           } catch {
           }
         }
       }
       saveState() {
         try {
-          writeFileSync15(join47(this.stateDir, "state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
+          writeFileSync16(join47(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`;
-          writeFileSync15(join47(this.historyDir, filename), JSON.stringify(result, null, 2) + "\n", "utf-8");
+          writeFileSync16(join47(this.historyDir, filename), JSON.stringify(result, null, 2) + "\n", "utf-8");
           const files = readdirSync12(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)) {
@@ -39325,7 +40610,7 @@ OUTPUT: Call task_complete with JSON:
 });
 
 // packages/cli/dist/tui/snr-engine.js
-import { existsSync as existsSync37, readdirSync as readdirSync13, readFileSync as readFileSync28 } from "node:fs";
+import { existsSync as existsSync38, readdirSync as readdirSync13, readFileSync as readFileSync29 } from "node:fs";
 import { join as join48, basename as basename14 } from "node:path";
 function computeDPrime(signalScores, noiseScores) {
   if (signalScores.length === 0 || noiseScores.length === 0)
@@ -39570,7 +40855,7 @@ Call task_complete with the JSON array when done.`, onEvent)
           join48(this.repoRoot, ".open-agents", "memory")
         ];
         for (const dir of dirs) {
-          if (!existsSync37(dir))
+          if (!existsSync38(dir))
             continue;
           try {
             const files = readdirSync13(dir).filter((f) => f.endsWith(".json"));
@@ -39579,7 +40864,7 @@ Call task_complete with the JSON array when done.`, onEvent)
               if (topics.length > 0 && !topics.includes(topic))
                 continue;
               try {
-                const data = JSON.parse(readFileSync28(join48(dir, f), "utf-8"));
+                const data = JSON.parse(readFileSync29(join48(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 });
@@ -40146,7 +41431,7 @@ var init_tool_policy = __esm({
 });
 
 // packages/cli/dist/tui/telegram-bridge.js
-import { mkdirSync as mkdirSync17, existsSync as existsSync38, unlinkSync as unlinkSync7, readdirSync as readdirSync14, statSync as statSync10 } from "node:fs";
+import { mkdirSync as mkdirSync18, existsSync as existsSync39, unlinkSync as unlinkSync7, readdirSync as readdirSync14, statSync as statSync10 } from "node:fs";
 import { join as join49, resolve as resolve27 } from "node:path";
 import { writeFile as writeFileAsync } from "node:fs/promises";
 function convertMarkdownToTelegramHTML(md) {
@@ -40475,7 +41760,7 @@ with summary "no_reply" to silently skip without responding.
         this.polling = true;
         this.abortController = new AbortController();
         try {
-          mkdirSync17(this.mediaCacheDir, { recursive: true });
+          mkdirSync18(this.mediaCacheDir, { recursive: true });
         } catch {
         }
         this.mediaCacheCleanupTimer = setInterval(() => this.cleanupMediaCache(), 5 * 60 * 1e3);
@@ -42012,6 +43297,56 @@ var init_status_bar = __esm({
         poll();
         this._remoteMetricsTimer = setInterval(poll, 1e4);
       }
+      /**
+       * Start polling a peer endpoint for metrics via nexus daemon.
+       * Queries the remote peer's system_metrics capability for CPU/GPU data,
+       * with fallback to local metering data.
+       */
+      startPeerMetricsPolling(sendCommand, peerId, authKey) {
+        this.stopRemoteMetricsPolling();
+        const poll = async () => {
+          try {
+            const queryData = { type: "query" };
+            if (authKey)
+              queryData.auth_key = authKey;
+            const raw = await sendCommand("invoke_capability", {
+              target_peer: peerId,
+              capability: "system_metrics",
+              data: JSON.stringify(queryData)
+            }, 8e3);
+            const result = JSON.parse(raw);
+            if (result.ok !== false && result.result) {
+              const data = typeof result.result === "string" ? JSON.parse(result.result) : result.result;
+              this.setRemoteMetrics({
+                cpuUtil: data.cpu?.utilization ?? 0,
+                gpuUtil: data.gpu?.available ? data.gpu.utilization ?? 0 : -1,
+                gpuName: data.gpu?.name ?? "",
+                vramUtil: data.gpu?.available ? data.gpu.vramUtilization ?? 0 : -1,
+                memUtil: data.memory?.utilization ?? 0
+              });
+              return;
+            }
+          } catch {
+          }
+          try {
+            const raw = await sendCommand("metering_status", { peer_id: peerId }, 5e3);
+            const result = JSON.parse(raw);
+            if (result.ok !== false && result.output) {
+              this.setRemoteMetrics({
+                cpuUtil: -1,
+                // -1 = unavailable (won't render bar)
+                gpuUtil: -1,
+                gpuName: "peer",
+                vramUtil: -1,
+                memUtil: -1
+              });
+            }
+          } catch {
+          }
+        };
+        poll();
+        this._remoteMetricsTimer = setInterval(poll, 1e4);
+      }
       /** Stop polling remote metrics */
       stopRemoteMetricsPolling() {
         if (this._remoteMetricsTimer) {
@@ -42745,11 +44080,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 resolve28, join as join50, dirname as dirname17, extname as extname9 } from "node:path";
+import { resolve as resolve28, join as join50, dirname as dirname18, extname as extname9 } from "node:path";
 import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath as fileURLToPath12 } from "node:url";
-import { readFileSync as readFileSync29, writeFileSync as writeFileSync16, appendFileSync as appendFileSync3, rmSync as rmSync2, readdirSync as readdirSync15, mkdirSync as mkdirSync18 } from "node:fs";
-import { existsSync as existsSync39 } from "node:fs";
+import { readFileSync as readFileSync30, writeFileSync as writeFileSync17, appendFileSync as appendFileSync3, rmSync as rmSync2, readdirSync as readdirSync15, mkdirSync as mkdirSync19 } from "node:fs";
+import { existsSync as existsSync40 } from "node:fs";
 import { homedir as homedir13 } from "node:os";
 function formatTimeAgo(date) {
   const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
@@ -42767,14 +44102,14 @@ function formatTimeAgo(date) {
 function getVersion3() {
   try {
     const require2 = createRequire2(import.meta.url);
-    const thisDir = dirname17(fileURLToPath12(import.meta.url));
+    const thisDir = dirname18(fileURLToPath12(import.meta.url));
     const candidates = [
       join50(thisDir, "..", "package.json"),
       join50(thisDir, "..", "..", "package.json"),
       join50(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync39(pkgPath)) {
+      if (existsSync40(pkgPath)) {
         const pkg = require2(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           return pkg.version ?? "0.0.0";
@@ -42917,7 +44252,8 @@ function createSubAgentTool(config, repoRoot, ctxWindowSize) {
       let backend;
       if (config.backendType === "nexus") {
         const nexusTool = new NexusTool(repoRoot);
-        backend = new NexusAgenticBackend(nexusTool.sendCommand.bind(nexusTool), config.model);
+        const subTargetPeer = config.backendUrl.startsWith("peer://") ? config.backendUrl.slice(7) : void 0;
+        backend = new NexusAgenticBackend(nexusTool.sendCommand.bind(nexusTool), config.model, subTargetPeer, config.apiKey);
       } else {
         backend = new OllamaAgenticBackend(config.backendUrl, config.model, config.apiKey);
       }
@@ -42984,11 +44320,11 @@ function gatherMemorySnippets(root) {
     join50(root, ".open-agents", "memory")
   ];
   for (const dir of dirs) {
-    if (!existsSync39(dir))
+    if (!existsSync40(dir))
       continue;
     try {
       for (const f of readdirSync15(dir).filter((f2) => f2.endsWith(".json"))) {
-        const data = JSON.parse(readFileSync29(join50(dir, f), "utf-8"));
+        const data = JSON.parse(readFileSync30(join50(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)
@@ -43094,10 +44430,58 @@ function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce
   if (config.backendType === "nexus") {
     const nexusTool = new NexusTool(repoRoot);
     const sendFn = nexusTool.sendCommand.bind(nexusTool);
-    backend = new NexusAgenticBackend(sendFn, config.model);
+    const targetPeer = config.backendUrl.startsWith("peer://") ? config.backendUrl.slice(7) : void 0;
+    backend = new NexusAgenticBackend(sendFn, config.model, targetPeer, config.apiKey);
   } else {
     backend = new OllamaAgenticBackend(config.backendUrl, config.model, config.apiKey);
   }
+  try {
+    const endpointHistory = loadUsageHistory("endpoint", repoRoot);
+    const fallbackEndpoints = [];
+    for (const entry of endpointHistory) {
+      if (entry.value === config.backendUrl)
+        continue;
+      const bt = entry.meta?.backendType ?? "ollama";
+      const ep = {
+        url: entry.value,
+        backendType: bt,
+        apiKey: entry.meta?.authHint ? void 0 : void 0,
+        // auth keys not stored in history
+        label: entry.meta?.provider ?? entry.value
+      };
+      if (bt === "nexus" && ep.url.startsWith("peer://")) {
+        const nt = new NexusTool(repoRoot);
+        ep.sendCommandFn = nt.sendCommand.bind(nt);
+      }
+      fallbackEndpoints.push(ep);
+    }
+    if (fallbackEndpoints.length > 0) {
+      const primaryEndpoint = {
+        url: config.backendUrl,
+        backendType: config.backendType,
+        apiKey: config.apiKey,
+        label: "primary"
+      };
+      if (config.backendType === "nexus" && config.backendUrl.startsWith("peer://")) {
+        const nt = new NexusTool(repoRoot);
+        primaryEndpoint.sendCommandFn = nt.sendCommand.bind(nt);
+      }
+      backend = new CascadeBackend(config.model, [primaryEndpoint, ...fallbackEndpoints], {
+        onSwitch: (_from, to, reason) => {
+          process.stderr.write(`
+[cascade] Failover \u2192 ${to.label ?? to.url}: ${reason}
+`);
+        },
+        onProbeResult: (ep, success) => {
+          if (success) {
+            process.stderr.write(`[cascade] Primary recovered: ${ep.label ?? ep.url}
+`);
+          }
+        }
+      });
+    }
+  } catch {
+  }
   const compactionThreshold = modelTier === "small" ? 12e3 : modelTier === "medium" ? 24e3 : 4e4;
   const runner = new AgenticRunner(backend, {
     maxTurns: 60,
@@ -43521,6 +44905,9 @@ ${emotionContext}` : `Working directory: ${repoRoot}`;
       } catch {
       }
     }
+    if (backend && typeof backend.stop === "function") {
+      backend.stop();
+    }
   });
   return { runner, promise, filesTouched, get toolCallCount() {
     return toolSequence.length;
@@ -43930,8 +45317,8 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
   const MAX_HISTORY_LINES = 500;
   let savedHistory = [];
   try {
-    if (existsSync39(HISTORY_FILE)) {
-      const raw = readFileSync29(HISTORY_FILE, "utf8").trim();
+    if (existsSync40(HISTORY_FILE)) {
+      const raw = readFileSync30(HISTORY_FILE, "utf8").trim();
       if (raw)
         savedHistory = raw.split("\n").reverse();
     }
@@ -43950,12 +45337,12 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     if (!line.trim())
       return;
     try {
-      mkdirSync18(HISTORY_DIR, { recursive: true });
+      mkdirSync19(HISTORY_DIR, { recursive: true });
       appendFileSync3(HISTORY_FILE, line + "\n", "utf8");
       if (Math.random() < 0.02) {
-        const all = readFileSync29(HISTORY_FILE, "utf8").trim().split("\n");
+        const all = readFileSync30(HISTORY_FILE, "utf8").trim().split("\n");
         if (all.length > MAX_HISTORY_LINES) {
-          writeFileSync16(HISTORY_FILE, all.slice(-MAX_HISTORY_LINES).join("\n") + "\n", "utf8");
+          writeFileSync17(HISTORY_FILE, all.slice(-MAX_HISTORY_LINES).join("\n") + "\n", "utf8");
         }
       }
     } catch {
@@ -44085,8 +45472,13 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     } catch {
     }
     try {
-      const isRemote = !currentConfig.backendUrl.includes("127.0.0.1") && !currentConfig.backendUrl.includes("localhost");
-      if (isRemote) {
+      const isPeer = currentConfig.backendUrl.startsWith("peer://");
+      const isRemote = !currentConfig.backendUrl.includes("127.0.0.1") && !currentConfig.backendUrl.includes("localhost") && !isPeer;
+      if (isPeer) {
+        const peerId = currentConfig.backendUrl.slice(7);
+        const nexusTool = new NexusTool(repoRoot);
+        statusBar.startPeerMetricsPolling(nexusTool.sendCommand.bind(nexusTool), peerId, currentConfig.apiKey);
+      } else if (isRemote) {
         statusBar.startRemoteMetricsPolling(currentConfig.backendUrl, currentConfig.apiKey);
       }
     } catch {
@@ -44158,8 +45550,13 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
       };
       const newProvider = detectProvider(url);
       costTracker.setProvider(newProvider.id);
-      const isRemote = !url.includes("127.0.0.1") && !url.includes("localhost");
-      if (isRemote) {
+      const isPeer = url.startsWith("peer://");
+      const isRemote = !url.includes("127.0.0.1") && !url.includes("localhost") && !isPeer;
+      if (isPeer) {
+        const peerId = url.slice(7);
+        const nexusTool = new NexusTool(repoRoot);
+        statusBar.startPeerMetricsPolling(nexusTool.sendCommand.bind(nexusTool), peerId, apiKey);
+      } else if (isRemote) {
         statusBar.startRemoteMetricsPolling(url, apiKey);
       } else {
         statusBar.stopRemoteMetricsPolling();
@@ -44714,7 +46111,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
     getCallUrl() {
       return voiceSession?.tunnelUrl ?? null;
     },
-    async exposeStart(kindOrUrl, authKey, transport) {
+    async exposeStart(kindOrUrl, authKey, transport, fullAccess) {
       const knownKinds = ["ollama", "vllm", "llvm"];
       let kind;
       let targetUrl;
@@ -44730,6 +46127,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         const p2pGateway = new ExposeP2PGateway({
           kind,
           targetUrl,
+          authKey,
           stateDir: join50(repoRoot, ".oa")
         }, nexusTool);
         p2pGateway.on("stats", (stats) => {
@@ -44758,7 +46156,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
           }
         }
       }
-      const tunnelGateway = new ExposeGateway({ kind, targetUrl, authKey, stateDir: join50(repoRoot, ".oa") });
+      const tunnelGateway = new ExposeGateway({ kind, targetUrl, authKey, fullAccess, stateDir: join50(repoRoot, ".oa") });
       tunnelGateway.on("stats", (stats) => {
         statusBar.setExposeStatus({
           status: stats.status,
@@ -44795,7 +46193,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       if (exposeGateway instanceof ExposeP2PGateway) {
         return {
           tunnelUrl: exposeGateway.peerId,
-          authKey: "",
+          authKey: exposeGateway.authKey,
           stats: exposeGateway.formatStats()
         };
       }
@@ -44805,6 +46203,18 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         stats: exposeGateway.formatStats()
       };
     },
+    // ── Nexus daemon connect ──────────────────────────────────────────────
+    async nexusConnect() {
+      const nexusTool = new NexusTool(repoRoot);
+      const result = await nexusTool.execute({
+        action: "connect",
+        agent_name: "open-agents-node",
+        agent_type: "general"
+      });
+      if (!result.success)
+        throw new Error(result.error || "Connect failed");
+      return result.output;
+    },
     // ── P2P mesh controls ────────────────────────────────────────────────
     async p2pStart(bootstrapPeers) {
       if (peerMesh)
@@ -44954,7 +46364,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
     },
     destroyProject() {
       const oaPath = join50(repoRoot, OA_DIR);
-      if (existsSync39(oaPath)) {
+      if (existsSync40(oaPath)) {
         try {
           rmSync2(oaPath, { recursive: true, force: true });
           writeContent(() => renderInfo(`Removed ${OA_DIR}/ directory.`));
@@ -45285,13 +46695,13 @@ Execute this skill now. Follow the behavioral guidance above.`;
       }
     }
     const cleanPath = input.replace(/^['"]|['"]$/g, "").trim();
-    const isImage = isImagePath(cleanPath) && existsSync39(resolve28(repoRoot, cleanPath));
-    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync39(resolve28(repoRoot, cleanPath));
+    const isImage = isImagePath(cleanPath) && existsSync40(resolve28(repoRoot, cleanPath));
+    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync40(resolve28(repoRoot, cleanPath));
     if (activeTask) {
       if (isImage) {
         try {
           const imgPath = resolve28(repoRoot, cleanPath);
-          const imgBuffer = readFileSync29(imgPath);
+          const imgBuffer = readFileSync30(imgPath);
           const base64 = imgBuffer.toString("base64");
           const ext = extname9(cleanPath).toLowerCase();
           const mime = ext === ".png" ? "image/png" : ext === ".gif" ? "image/gif" : ext === ".webp" ? "image/webp" : "image/jpeg";
@@ -45989,13 +47399,13 @@ __export(index_repo_exports, {
   indexRepoCommand: () => indexRepoCommand
 });
 import { resolve as resolve29 } from "node:path";
-import { existsSync as existsSync40, statSync as statSync11 } from "node:fs";
+import { existsSync as existsSync41, statSync as statSync11 } from "node:fs";
 import { cwd as cwd2 } from "node:process";
 async function indexRepoCommand(opts, _config) {
   const repoRoot = resolve29(opts.repoPath ?? cwd2());
   printHeader("Index Repository");
   printInfo(`Indexing: ${repoRoot}`);
-  if (!existsSync40(repoRoot)) {
+  if (!existsSync41(repoRoot)) {
     printError(`Path does not exist: ${repoRoot}`);
     process.exit(1);
   }
@@ -46469,7 +47879,7 @@ var serve_exports = {};
 __export(serve_exports, {
   serveCommand: () => serveCommand
 });
-import { spawn as spawn16 } from "node:child_process";
+import { spawn as spawn18 } from "node:child_process";
 async function serveCommand(opts, config) {
   const backendType = config.backendType;
   if (backendType === "ollama") {
@@ -46562,7 +47972,7 @@ async function serveVllm(opts, config) {
 }
 async function runVllmServer(args, verbose) {
   return new Promise((resolve31, reject) => {
-    const child = spawn16("python", args, {
+    const child = spawn18("python", args, {
       stdio: verbose ? "inherit" : ["ignore", "pipe", "pipe"],
       env: { ...process.env }
     });
@@ -46627,7 +48037,7 @@ __export(eval_exports, {
   evalCommand: () => evalCommand
 });
 import { tmpdir as tmpdir7 } from "node:os";
-import { mkdirSync as mkdirSync19, writeFileSync as writeFileSync17 } from "node:fs";
+import { mkdirSync as mkdirSync20, writeFileSync as writeFileSync18 } from "node:fs";
 import { join as join53 } from "node:path";
 async function evalCommand(opts, config) {
   const suiteName = opts.suite ?? "basic";
@@ -46754,8 +48164,8 @@ async function evalCommand(opts, config) {
 }
 function createTempEvalRepo() {
   const dir = join53(tmpdir7(), `open-agents-eval-${Date.now()}`);
-  mkdirSync19(dir, { recursive: true });
-  writeFileSync17(join53(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
+  mkdirSync20(dir, { recursive: true });
+  writeFileSync18(join53(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
   return dir;
 }
 var BASIC_SUITE, FULL_SUITE, SUITES;
@@ -46815,7 +48225,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 dirname18, join as join54 } from "node:path";
+import { dirname as dirname19, join as join54 } from "node:path";
 
 // packages/cli/dist/cli.js
 import { createInterface } from "node:readline";
@@ -46922,7 +48332,7 @@ init_output();
 function getVersion4() {
   try {
     const require2 = createRequire3(import.meta.url);
-    const pkgPath = join54(dirname18(fileURLToPath13(import.meta.url)), "..", "package.json");
+    const pkgPath = join54(dirname19(fileURLToPath13(import.meta.url)), "..", "package.json");
     const pkg = require2(pkgPath);
     return pkg.version;
   } catch {