open-agents-ai 0.86.0 → 0.88.0

package/dist/index.js

@@ -139,7 +139,7 @@ var init_config = __esm({
       verbose: false,
       dbPath: join(homedir(), ".open-agents", "memory.db")
     });
-    VALID_BACKEND_TYPES = /* @__PURE__ */ new Set(["ollama", "vllm", "fake"]);
+    VALID_BACKEND_TYPES = /* @__PURE__ */ new Set(["ollama", "vllm", "fake", "nexus"]);
   }
 });
 
@@ -11202,7 +11202,7 @@ ${truncated}`, durationMs: performance.now() - start };
 });
 
 // packages/execution/dist/tools/nexus.js
-import { readFile as readFile13, writeFile as writeFile12, mkdir as mkdir8, chmod, unlink, readdir as readdir3 } from "node:fs/promises";
+import { readFile as readFile13, writeFile as writeFile12, mkdir as mkdir8, chmod, unlink, readdir as readdir3, open as fsOpen } from "node:fs/promises";
 import { existsSync as existsSync21, readFileSync as readFileSync15 } from "node:fs";
 import { resolve as resolve26, join as join28 } from "node:path";
 import { randomBytes as randomBytes6, createCipheriv, createDecipheriv, scryptSync, createHash } from "node:crypto";
@@ -11244,6 +11244,8 @@ function dlog(msg) { try { appendFileSync(logFile, new Date().toISOString() + '
 const pidFile = join(nexusDir, 'daemon.pid');
 const invocationsDir = join(nexusDir, 'invocations');
 const meteringFile = join(nexusDir, 'metering.jsonl');
+const x402KeyPath = join(nexusDir, 'x402-wallet.key');
+const hasX402Key = existsSync(x402KeyPath);
 
 mkdirSync(inboxDir, { recursive: true });
 mkdirSync(invocationsDir, { recursive: true });
@@ -11252,7 +11254,7 @@ mkdirSync(invocationsDir, { recursive: true });
 writeFileSync(pidFile, String(process.pid));
 
 const keyPath = join(nexusDir, 'identity.key');
-const nexus = new NexusClient({
+var nexusOpts = {
   keyStorePath: keyPath,
   agentName,
   agentType,
@@ -11264,7 +11266,18 @@ const nexus = new NexusClient({
   enableCircuitRelay: true,
   usePublicBootstrap: true,
   trustPolicy: { denylist: [], allowlist: [] },
-});
+};
+if (hasX402Key) {
+  nexusOpts.x402 = {
+    enabled: true,
+    walletKeyPath: x402KeyPath,
+    maxPaymentPerRequest: '5000000',
+  };
+  if (process.env.ALCHEMY_API_KEY) {
+    nexusOpts.x402.alchemyApiKey = process.env.ALCHEMY_API_KEY;
+  }
+}
+const nexus = new NexusClient(nexusOpts);
 
 const rooms = new Map();
 let connected = false;
@@ -11392,6 +11405,101 @@ async function handleCmd(cmd) {
         }
         break;
       }
+      case 'remote_infer': {
+        var riModel = args.model;
+        var riPrompt = args.prompt || args.input || '';
+        var riMessages = args.messages || null;
+        var riTools = args.tools || null;
+        var riTargetPeer = args.target_peer || '';
+        if (!riModel) { writeResp(id, { ok: false, output: 'model is required' }); return; }
+        if (!riPrompt && !riMessages) { writeResp(id, { ok: false, output: 'prompt or messages is required' }); return; }
+
+        // Build invoke data \u2014 structured (messages+tools) or flat (prompt)
+        var riData;
+        if (riMessages) {
+          var riParsedMsgs = typeof riMessages === 'string' ? JSON.parse(riMessages) : riMessages;
+          riData = { messages: riParsedMsgs };
+          if (riTools) {
+            riData.tools = typeof riTools === 'string' ? JSON.parse(riTools) : riTools;
+          }
+          if (args.temperature !== undefined) riData.temperature = Number(args.temperature);
+          if (args.max_tokens) riData.max_tokens = Number(args.max_tokens);
+        } else {
+          riData = { prompt: riPrompt };
+        }
+
+        // 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);
+
+        // If target_peer specified, invoke directly. Otherwise auto-discover.
+        if (riTargetPeer) {
+          // Direct invoke on specified peer
+          dlog('remote_infer: invoking ' + riCapName + ' on explicit peer ' + riTargetPeer.slice(0, 20));
+          try {
+            var RI_TIMEOUT = 120000;
+            var riInvokeP = nexus.invokeCapability(riTargetPeer, riCapName, riData, { stream: false, maxDurationMs: 90000 });
+            var riTimeoutP = new Promise(function(_, reject) { setTimeout(function() { reject(new Error('remote_infer timed out after ' + (RI_TIMEOUT / 1000) + 's')); }, RI_TIMEOUT); });
+            var riResult = await Promise.race([riInvokeP, riTimeoutP]);
+            dlog('remote_infer: SUCCESS (explicit peer)');
+          } catch (riErr) {
+            dlog('remote_infer: ERROR (explicit peer) ' + (riErr.message || String(riErr)));
+            writeResp(id, { ok: false, output: 'Remote inference failed: ' + (riErr.message || String(riErr)) });
+            return;
+          }
+        } else {
+          // Auto-discover: try speculative invoke on each 12D3KooW peer
+          // Skip Qm-prefixed bootstrap/relay nodes \u2014 they never host inference
+          var discStart = Date.now();
+          var riResult = null;
+          try {
+            var riNode = nexus.network ? nexus.network.node : null;
+            var riPeers = riNode && typeof riNode.getPeers === 'function' ? riNode.getPeers() : [];
+            var riCandidates = [];
+            for (var rfi = 0; rfi < riPeers.length; rfi++) {
+              var rpStr = riPeers[rfi].toString ? riPeers[rfi].toString() : String(riPeers[rfi]);
+              if (rpStr.startsWith('12D3KooW')) riCandidates.push(rpStr);
+            }
+            dlog('remote_infer: auto-discover across ' + riCandidates.length + ' peers (of ' + riPeers.length + ' total) for ' + riCapName);
+
+            for (var ri = 0; ri < riCandidates.length && !riResult; ri++) {
+              var rPid = riCandidates[ri];
+              dlog('remote_infer: trying peer ' + rPid.slice(0, 20) + '...');
+              try {
+                var PEER_INVOKE_TIMEOUT = 30000; // 30s per peer attempt
+                var specInvoke = nexus.invokeCapability(rPid, riCapName, riData, { stream: false, maxDurationMs: 25000 });
+                var specTimeout = new Promise(function(_, reject) {
+                  setTimeout(function() { reject(new Error('peer invoke timeout')); }, PEER_INVOKE_TIMEOUT);
+                });
+                riResult = await Promise.race([specInvoke, specTimeout]);
+                riTargetPeer = rPid;
+                dlog('remote_infer: SUCCESS via peer ' + rPid.slice(0, 20) + ' (' + (Date.now() - discStart) + 'ms)');
+              } catch (specErr) {
+                dlog('remote_infer: peer ' + rPid.slice(0, 20) + ' failed: ' + (specErr.message || specErr));
+              }
+            }
+          } catch (discErr) {
+            dlog('remote_infer: discovery error: ' + (discErr.message || discErr));
+          }
+          dlog('remote_infer: auto-discover took ' + (Date.now() - discStart) + 'ms');
+
+          if (!riResult) {
+            writeResp(id, { ok: false, output: 'No peer found with capability: ' + riCapName + '. Ensure a provider is running expose with model ' + riModel });
+            return;
+          }
+        }
+
+        // riResult and riTargetPeer are available from either path above
+        var riOutput = {
+          success: true,
+          model: riModel,
+          peer: riTargetPeer,
+          capability: riCapName,
+          result: riResult,
+        };
+        writeResp(id, { ok: true, output: JSON.stringify(riOutput, null, 2) });
+        break;
+      }
       case 'store_content': {
         const data = args.data;
         if (!data) { writeResp(id, { ok: false, output: 'data is required' }); return; }
@@ -11643,6 +11751,18 @@ async function handleCmd(cmd) {
           // Register as nexus capability
           const capName = 'inference:' + model.name.replace(/[^a-zA-Z0-9._-]/g, '_');
           if (typeof nexus.registerCapability === 'function') {
+            var capOpts = {};
+            if (margin > 0 && entry.pricing.input_per_1m_tokens > 0) {
+              var tokensPerReq = 1000;
+              var amountPerReq = Math.round(entry.pricing.input_per_1m_tokens * tokensPerReq);
+              if (amountPerReq > 0) {
+                capOpts.pricing = {
+                  amount: String(amountPerReq),
+                  currency: 'USDC',
+                  description: 'Inference: ' + model.name,
+                };
+              }
+            }
             nexus.registerCapability(capName, async (request, stream) => {
               const logEntry = {
                 ts: Date.now(),
@@ -11654,11 +11774,17 @@ async function handleCmd(cmd) {
               const logFile = join(invocationsDir, Date.now() + '-' + capName + '.json');
               try { writeFileSync(logFile, JSON.stringify(logEntry, null, 2)); } catch {}
 
-              // Collect input
+              // Collect input via stream data events
               let prompt = '';
+              var dataChunks = [];
+              var inputDone = false;
               stream.onData((msg) => {
                 if (msg.type === 'invoke.chunk') {
-                  prompt += (typeof msg.data === 'string' ? msg.data : JSON.stringify(msg.data));
+                  var chunk = typeof msg.data === 'string' ? msg.data : JSON.stringify(msg.data);
+                  dataChunks.push(chunk);
+                }
+                if (msg.type === 'invoke.done' || msg.type === 'invoke.end' || msg.type === 'invoke.close') {
+                  inputDone = true;
                 }
               });
 
@@ -11668,33 +11794,100 @@ async function handleCmd(cmd) {
                 requestId: request.requestId, accepted: true,
               });
 
-              // Forward to Ollama
+              // Wait for input data to arrive (invoke protocol sends data after accept)
+              var waitMs = 0;
+              while (!inputDone && dataChunks.length === 0 && waitMs < 5000) {
+                await new Promise(function(r) { setTimeout(r, 100); });
+                waitMs += 100;
+              }
+              prompt = dataChunks.join('');
+              dlog('expose: received ' + dataChunks.length + ' chunks, prompt_len=' + prompt.length + ' inputDone=' + inputDone);
+
+              // Forward to Ollama \u2014 supports both flat prompt and structured messages
               try {
-                const genResp = await fetch(ollamaUrl + '/api/generate', {
-                  method: 'POST',
-                  headers: { 'Content-Type': 'application/json' },
-                  body: JSON.stringify({
+                var parsedReq = null;
+                try { parsedReq = JSON.parse(prompt); } catch (pe) { dlog('expose: JSON parse error: ' + (pe.message || pe)); }
+
+                var genResp, genData, output, inputTokens, outputTokens, responsePayload;
+
+                if (parsedReq && parsedReq.messages && Array.isArray(parsedReq.messages)) {
+                  // Structured request \u2014 use /v1/chat/completions (supports tools + multi-turn)
+                  var chatBody = {
                     model: model.name,
-                    prompt: prompt || 'Hello',
+                    messages: parsedReq.messages,
                     stream: false,
-                  }),
-                });
-                const genData = await genResp.json();
-                const output = genData.response || '';
-                const inputTokens = genData.prompt_eval_count || 0;
-                const outputTokens = genData.eval_count || 0;
+                  };
+                  if (parsedReq.tools && parsedReq.tools.length > 0) {
+                    chatBody.tools = parsedReq.tools;
+                  }
+                  if (parsedReq.temperature !== undefined) chatBody.temperature = parsedReq.temperature;
+                  if (parsedReq.max_tokens) chatBody.max_tokens = parsedReq.max_tokens;
+
+                  dlog('expose: calling /v1/chat/completions with ' + chatBody.messages.length + ' messages, tools=' + (chatBody.tools ? chatBody.tools.length : 0));
+                  genResp = await fetch(ollamaUrl + '/v1/chat/completions', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(chatBody),
+                  });
+                  genData = await genResp.json();
+                  dlog('expose: ollama response keys=' + Object.keys(genData).join(',') + ' choices=' + (genData.choices ? genData.choices.length : 0));
+
+                  var chatChoices = genData.choices || [];
+                  var firstMsg = (chatChoices[0] || {}).message || {};
+                  // Strip <think>...</think> tags from content (thinking models)
+                  var rawContent = firstMsg.content || '';
+                  output = rawContent.replace(/<think>[\\s\\S]*?<\\/think>/g, '').trim();
+                  // Fallback: if content is empty but reasoning exists, use reasoning
+                  // (happens when max_tokens is too small for thinking models at temp=0)
+                  if (!output && firstMsg.reasoning) {
+                    output = firstMsg.reasoning;
+                  }
+                  // Update the choices to reflect final content
+                  if (chatChoices[0] && chatChoices[0].message) {
+                    chatChoices[0].message.content = output;
+                  }
+                  dlog('expose: rawContent_len=' + rawContent.length + ' output_len=' + output.length + ' reasoning=' + (firstMsg.reasoning ? firstMsg.reasoning.length : 0) + ' tool_calls=' + (firstMsg.tool_calls ? firstMsg.tool_calls.length : 0));
+                  inputTokens = (genData.usage || {}).prompt_tokens || 0;
+                  outputTokens = (genData.usage || {}).completion_tokens || 0;
+
+                  responsePayload = {
+                    model: model.name,
+                    response: output,
+                    choices: chatChoices,
+                    usage: { input_tokens: inputTokens, output_tokens: outputTokens },
+                    pricing: entry.pricing,
+                  };
+                } else {
+                  // Flat prompt \u2014 use /api/generate (original behavior)
+                  var flatPrompt = parsedReq && parsedReq.prompt ? parsedReq.prompt : (prompt || 'Hello');
+                  genResp = await fetch(ollamaUrl + '/api/generate', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                      model: model.name,
+                      prompt: flatPrompt,
+                      stream: false,
+                    }),
+                  });
+                  genData = await genResp.json();
+                  output = genData.response || '';
+                  inputTokens = genData.prompt_eval_count || 0;
+                  outputTokens = genData.eval_count || 0;
+
+                  responsePayload = {
+                    model: model.name,
+                    response: output,
+                    usage: { input_tokens: inputTokens, output_tokens: outputTokens },
+                    pricing: entry.pricing,
+                  };
+                }
 
                 // Stream result back
                 await stream.write({
                   type: 'invoke.event', version: 1,
                   requestId: request.requestId, seq: 0,
                   event: 'result',
-                  data: JSON.stringify({
-                    model: model.name,
-                    response: output,
-                    usage: { input_tokens: inputTokens, output_tokens: outputTokens },
-                    pricing: entry.pricing,
-                  }),
+                  data: JSON.stringify(responsePayload),
                 });
 
                 await stream.write({
@@ -11702,7 +11895,7 @@ async function handleCmd(cmd) {
                   requestId: request.requestId,
                   usage: {
                     inputBytes: prompt.length,
-                    outputBytes: output.length,
+                    outputBytes: (output || '').length,
                     tokens: inputTokens + outputTokens,
                   },
                 });
@@ -11719,7 +11912,7 @@ async function handleCmd(cmd) {
                 });
               }
               stream.close();
-            });
+            }, capOpts);
           }
         }
 
@@ -11822,6 +12015,37 @@ process.on('unhandledRejection', (reason) => {
       }
     } catch {}
 
+    // Write payment events to ledger.jsonl
+    try {
+      if (nexus.metering && typeof nexus.metering.addHook === 'function') {
+        nexus.metering.addHook(function(record) {
+          if (!record.payment) return;
+          var ledgerFile = join(nexusDir, 'ledger.jsonl');
+          var entry = {
+            timestamp: new Date().toISOString(),
+            type: record.direction === 'inbound' ? 'earned' : 'spent',
+            amount: String(record.payment.amount || 0),
+            amountUsd: (Number(record.payment.amount || 0) / 1000000).toFixed(6),
+            peer: record.peerId || 'unknown',
+            capability: record.service || record.capability || 'unknown',
+            txHash: record.payment.txHash || '',
+            note: 'auto:metering',
+          };
+          try { appendFileSync(ledgerFile, JSON.stringify(entry) + '\\n'); } catch {}
+        });
+      }
+    } catch {}
+
+    // Init x402 wallet if key file exists
+    if (hasX402Key && nexus.x402 && typeof nexus.x402.initWallet === 'function') {
+      try {
+        var addr = nexus.x402.initWallet(x402KeyPath);
+        dlog('x402 wallet initialized: ' + addr);
+      } catch (e) {
+        dlog('x402 wallet init failed: ' + (e.message || e));
+      }
+    }
+
     // v1.5.0: Client-level events for global message/DM/invoke routing
     try {
       if (typeof nexus.on === 'function') {
@@ -11876,7 +12100,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
     ];
     NexusTool = class {
       name = "nexus";
-      description = "Decentralized agent-to-agent communication via open-agents-nexus v1.5.0. Spawns a background Node.js process with real network sockets for libp2p + NATS P2P mesh. Simple flow: connect \u2192 join room \u2192 send messages. Auto-installs/updates nexus if needed. EXPOSE: expose action queries Ollama models, fetches OpenRouter market rates, registers metered inference capabilities so peers can invoke your models. pricing_menu shows rates. v1.5.0: register_capability, block_peer/unblock_peer, metering_status, room_members. Also supports direct peer invoke, IPFS storage, DMs, discovery, x402, inference proofs.";
+      description = "Decentralized agent-to-agent communication via open-agents-nexus v1.5.0. Spawns a background Node.js process with real network sockets for libp2p + NATS P2P mesh. Simple flow: connect \u2192 join room \u2192 send messages. Auto-installs/updates nexus if needed. EXPOSE: expose action queries Ollama models, fetches OpenRouter market rates, registers metered inference capabilities so peers can invoke your models. pricing_menu shows rates. v1.5.0: register_capability, block_peer/unblock_peer, metering_status, room_members. Also supports direct peer invoke, IPFS storage, DMs, discovery, x402, inference proofs. WALLET: wallet_create generates EVM wallet (secp256k1, Base mainnet USDC). wallet_status shows address, USDC balance, and ledger summary. PAYMENTS: ledger_status tracks earnings/spending. budget_status/budget_set configure spending limits. spend: sign EIP-3009 USDC transfer (target_address + amount_usdc). x402 native payment via daemon. REMOTE INFERENCE: remote_infer routes a prompt to a remote peer's model on the mesh. Auto-discovers peers with the requested model capability, budget-checks, invokes, and returns the result. Use: nexus(action='remote_infer', model='qwen3.5:70b', prompt='...'). Optional: target_peer, temperature, max_tokens.";
       parameters = {
         type: "object",
         properties: {
@@ -11908,7 +12132,12 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
               "metering_status",
               "room_members",
               "expose",
-              "pricing_menu"
+              "pricing_menu",
+              "ledger_status",
+              "budget_status",
+              "budget_set",
+              "spend",
+              "remote_infer"
             ],
             description: "The nexus action to perform"
           },
@@ -11963,6 +12192,42 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           margin: {
             type: "string",
             description: "Price margin multiplier for expose (0.5 = 50% of market rate, 0 = free). Default: 0.5"
+          },
+          daily_limit: {
+            type: "string",
+            description: "For budget_set: max daily USDC spend (e.g. '1.00')"
+          },
+          per_invoke_max: {
+            type: "string",
+            description: "For budget_set: max per-invoke USDC spend (e.g. '0.10')"
+          },
+          auto_approve_below: {
+            type: "string",
+            description: "For budget_set: auto-approve payments below this USD amount (e.g. '0.01')"
+          },
+          target_address: {
+            type: "string",
+            description: "For spend: target EVM address (0x + 40 hex chars)"
+          },
+          amount_usdc: {
+            type: "string",
+            description: "For spend: USDC amount to transfer (e.g. '0.10')"
+          },
+          model: {
+            type: "string",
+            description: "For remote_infer: model to request (e.g. 'qwen3.5:70b', 'nemotron-3-nano:30b')"
+          },
+          prompt: {
+            type: "string",
+            description: "For remote_infer: the prompt text to send to the remote model"
+          },
+          temperature: {
+            type: "string",
+            description: "For remote_infer: sampling temperature (e.g. '0.7'). Default: 0.7"
+          },
+          max_tokens: {
+            type: "string",
+            description: "For remote_infer: maximum tokens to generate (e.g. '4096'). Default: 4096"
           }
         },
         required: ["action"],
@@ -12063,6 +12328,21 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
             case "pricing_menu":
               result = await this.sendDaemonCmd("pricing_menu", args);
               break;
+            case "ledger_status":
+              result = await this.doLedgerStatus();
+              break;
+            case "budget_status":
+              result = await this.doBudgetStatus();
+              break;
+            case "budget_set":
+              result = await this.doBudgetSet(args);
+              break;
+            case "spend":
+              result = await this.doSpend(args);
+              break;
+            case "remote_infer":
+              result = await this.doRemoteInfer(args);
+              break;
             default:
               return { success: false, output: "", error: `Unknown nexus action: ${action}`, durationMs: Date.now() - start };
           }
@@ -12112,6 +12392,14 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         }
         return `Daemon did not respond within ${Math.round(timeoutMs / 1e3)}s. It may still be processing.`;
       }
+      /** Public interface for daemon commands — used by NexusAgenticBackend */
+      async sendCommand(action, args, timeoutMs) {
+        return this.sendDaemonCmd(action, args, timeoutMs);
+      }
+      /** Get the nexus data directory path */
+      getNexusDir() {
+        return this.nexusDir;
+      }
       // =========================================================================
       // Actions
       // =========================================================================
@@ -12396,6 +12684,9 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         }
         return lines.join("\n");
       }
+      // ---------------------------------------------------------------------------
+      // Step 1: Wallet v2 — secp256k1 via viem for proper EVM addresses
+      // ---------------------------------------------------------------------------
       async doWalletStatus() {
         await this.ensureDir();
         const walletPath = join28(this.nexusDir, "wallet.enc");
@@ -12404,13 +12695,33 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         }
         try {
           const w = JSON.parse(await readFile13(walletPath, "utf8"));
-          return [
+          const lines = [
             `Wallet Status:`,
             `  Address: ${w.address}`,
+            `  Version: ${w.version} (${w.version === 2 ? "secp256k1/EVM" : "legacy SHA256"})`,
+            `  Network: ${w.network || "none"} (chain ${w.chainId || "N/A"})`,
             `  Created: ${w.createdAt}`,
             `  Encryption: AES-256-GCM + scrypt`,
             `  NOTE: Private key is encrypted and NEVER accessible to the agent.`
-          ].join("\n");
+          ];
+          if (w.version === 2 && w.address) {
+            const balance = await this.queryUsdcBalance(w.address, w.chainId || 8453);
+            if (balance !== null) {
+              const usdcHuman = (Number(balance) / 1e6).toFixed(6);
+              lines.push(`  USDC Balance: $${usdcHuman}`);
+              const budget = await this.loadBudget();
+              if (budget && Number(balance) < budget.circuitBreakerUsdc) {
+                lines.push(`  \u26A0 CIRCUIT BREAKER: Balance below $${(budget.circuitBreakerUsdc / 1e6).toFixed(2)} \u2014 all payments BLOCKED`);
+              } else if (budget && Number(balance) < budget.lowBalanceAlertUsdc) {
+                lines.push(`  \u26A0 LOW BALANCE: Below $${(budget.lowBalanceAlertUsdc / 1e6).toFixed(2)} threshold`);
+              }
+            }
+          }
+          const ledgerSummary = await this.getLedgerSummary();
+          if (ledgerSummary) {
+            lines.push(`  Earned: $${ledgerSummary.totalEarned}  Spent: $${ledgerSummary.totalSpent}  Net: $${ledgerSummary.net}`);
+          }
+          return lines.join("\n");
         } catch {
           return "Wallet file exists but could not be read.";
         }
@@ -12419,51 +12730,550 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         await this.ensureDir();
         const walletPath = join28(this.nexusDir, "wallet.enc");
         if (existsSync21(walletPath))
-          return "Wallet already exists.";
+          return "Wallet already exists. Delete wallet.enc to create a new one.";
         const userAddress = args.wallet_address;
         if (userAddress) {
           if (!/^0x[0-9a-fA-F]{40}$/.test(userAddress)) {
             return "Invalid address format. Expected 0x + 40 hex chars.";
           }
           const w2 = {
-            version: 1,
+            version: 2,
             address: userAddress,
             encryptedKey: "",
             iv: "",
             authTag: "",
             salt: "",
-            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            network: "base",
+            chainId: 8453
           };
-          await writeFile12(walletPath, JSON.stringify(w2, null, 2));
-          await chmod(walletPath, 384);
-          return `Wallet configured: ${userAddress} (user-managed)`;
+          const walletFh = await fsOpen(walletPath, "w", 384);
+          await walletFh.writeFile(JSON.stringify(w2, null, 2));
+          await walletFh.close();
+          await this.ensureDefaultBudget();
+          return `Wallet configured: ${userAddress} (user-managed, Base mainnet, no x402 key \u2014 spend/sign requires self-hosted wallet)`;
+        }
+        let address;
+        let privKeyHex;
+        try {
+          const { privateKeyToAccount } = await import("viem/accounts");
+          const privKey = randomBytes6(32);
+          privKeyHex = privKey.toString("hex");
+          const account = privateKeyToAccount(`0x${privKeyHex}`);
+          address = account.address;
+          privKey.fill(0);
+        } catch {
+          const privKey = randomBytes6(32);
+          privKeyHex = privKey.toString("hex");
+          address = "0x" + createHash("sha256").update(privKey).digest("hex").slice(0, 40);
+          privKey.fill(0);
         }
-        const privKey = randomBytes6(32);
-        const address = "0x" + createHash("sha256").update(privKey).digest("hex").slice(0, 40);
         const salt = randomBytes6(32);
         const key = scryptSync(`${hostname()}:${userInfo().username}:nexus-wallet`, salt, 32, { N: 16384, r: 8, p: 1 });
         const iv = randomBytes6(16);
         const cipher = createCipheriv("aes-256-gcm", key, iv);
-        let enc = cipher.update(privKey.toString("hex"), "utf8", "hex");
+        let enc = cipher.update(privKeyHex, "utf8", "hex");
         enc += cipher.final("hex");
-        privKey.fill(0);
+        const x402KeyPath = join28(this.nexusDir, "x402-wallet.key");
+        const x402Fh = await fsOpen(x402KeyPath, "w", 384);
+        await x402Fh.writeFile("0x" + privKeyHex);
+        await x402Fh.close();
+        privKeyHex = "0".repeat(64);
         const w = {
-          version: 1,
+          version: 2,
           address,
           encryptedKey: enc,
           iv: iv.toString("hex"),
           authTag: cipher.getAuthTag().toString("hex"),
           salt: salt.toString("hex"),
-          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          network: "base",
+          chainId: 8453
         };
-        await writeFile12(walletPath, JSON.stringify(w, null, 2));
-        await chmod(walletPath, 384);
+        const walletFh2 = await fsOpen(walletPath, "w", 384);
+        await walletFh2.writeFile(JSON.stringify(w, null, 2));
+        await walletFh2.close();
+        await this.ensureDefaultBudget();
         return [
-          `Wallet created: ${address}`,
+          `Wallet created (v2, secp256k1/EVM):`,
+          `  Address: ${address}`,
+          `  Network: Base mainnet (chain 8453)`,
+          `  Token: USDC`,
           `  Encrypted with AES-256-GCM (key NEVER visible to agent)`,
-          `  File: ${walletPath} (0600)`
+          `  File: ${walletPath} (0600)`,
+          ``,
+          `Fund this address with USDC on Base to enable paid inference.`,
+          `Free inference (margin=0) works without funding.`
         ].join("\n");
       }
+      // ---------------------------------------------------------------------------
+      // Step 2: USDC Balance Query via Base RPC
+      // ---------------------------------------------------------------------------
+      balanceCache = null;
+      async queryUsdcBalance(address, chainId) {
+        if (this.balanceCache && Date.now() - this.balanceCache.fetchedAt < 6e4) {
+          return this.balanceCache.value;
+        }
+        const rpcUrl = chainId === 84532 ? "https://sepolia.base.org" : "https://mainnet.base.org";
+        const usdcContract = chainId === 84532 ? "0x036CbD53842c5426634e7929541eC2318f3dCF7e" : "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+        const paddedAddress = address.slice(2).toLowerCase().padStart(64, "0");
+        const data = `0x70a08231${paddedAddress}`;
+        try {
+          const resp = await fetch(rpcUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              jsonrpc: "2.0",
+              id: 1,
+              method: "eth_call",
+              params: [{ to: usdcContract, data }, "latest"]
+            }),
+            signal: AbortSignal.timeout(5e3)
+          });
+          const json = await resp.json();
+          if (json.result) {
+            const balance = BigInt(json.result).toString();
+            this.balanceCache = { value: balance, fetchedAt: Date.now() };
+            return balance;
+          }
+        } catch {
+        }
+        return null;
+      }
+      // ---------------------------------------------------------------------------
+      // Step 3: Ledger — Track earnings and expenditures
+      // ---------------------------------------------------------------------------
+      async doLedgerStatus() {
+        await this.ensureDir();
+        const ledgerPath = join28(this.nexusDir, "ledger.jsonl");
+        if (!existsSync21(ledgerPath)) {
+          return "No ledger entries. Earnings and spending will be tracked here after x402 transactions.";
+        }
+        try {
+          const raw = await readFile13(ledgerPath, "utf8");
+          const entries = raw.trim().split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
+          if (entries.length === 0) {
+            return "Ledger is empty. No transactions recorded.";
+          }
+          let totalEarned = 0n, totalSpent = 0n, pending = 0n;
+          for (const e of entries) {
+            const amt = BigInt(e.amount);
+            if (e.type === "earned")
+              totalEarned += amt;
+            else if (e.type === "spent")
+              totalSpent += amt;
+            else if (e.type === "pending")
+              pending += amt;
+          }
+          const lines = [
+            `Ledger Status (${entries.length} entries):`,
+            `  Total Earned: $${(Number(totalEarned) / 1e6).toFixed(6)} USDC`,
+            `  Total Spent:  $${(Number(totalSpent) / 1e6).toFixed(6)} USDC`,
+            `  Net:          $${(Number(totalEarned - totalSpent) / 1e6).toFixed(6)} USDC`
+          ];
+          if (pending > 0n) {
+            lines.push(`  Pending:      $${(Number(pending) / 1e6).toFixed(6)} USDC`);
+          }
+          const recent = entries.slice(-5);
+          lines.push(``, `Recent transactions:`);
+          for (const e of recent) {
+            const sign = e.type === "earned" ? "+" : e.type === "spent" ? "-" : "~";
+            const peerShort = (e.peer || "?").slice(0, 16) + "...";
+            lines.push(`  ${e.timestamp.slice(0, 19)} ${sign}$${e.amountUsd} ${e.capability} (${peerShort})`);
+          }
+          return lines.join("\n");
+        } catch {
+          return "Error reading ledger file.";
+        }
+      }
+      async getLedgerSummary() {
+        const ledgerPath = join28(this.nexusDir, "ledger.jsonl");
+        if (!existsSync21(ledgerPath))
+          return null;
+        try {
+          const raw = await readFile13(ledgerPath, "utf8");
+          const entries = raw.trim().split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
+          let totalEarned = 0n, totalSpent = 0n;
+          for (const e of entries) {
+            const amt = BigInt(e.amount);
+            if (e.type === "earned")
+              totalEarned += amt;
+            else if (e.type === "spent")
+              totalSpent += amt;
+          }
+          return {
+            totalEarned: (Number(totalEarned) / 1e6).toFixed(6),
+            totalSpent: (Number(totalSpent) / 1e6).toFixed(6),
+            net: (Number(totalEarned - totalSpent) / 1e6).toFixed(6)
+          };
+        } catch {
+          return null;
+        }
+      }
+      async appendLedger(entry) {
+        await this.ensureDir();
+        const ledgerPath = join28(this.nexusDir, "ledger.jsonl");
+        const line = JSON.stringify(entry) + "\n";
+        await writeFile12(ledgerPath, existsSync21(ledgerPath) ? await readFile13(ledgerPath, "utf8") + line : line);
+      }
+      // ---------------------------------------------------------------------------
+      // Step 4: Budget Policy — Spending limits and auto-approve thresholds
+      // ---------------------------------------------------------------------------
+      async loadBudget() {
+        const budgetPath = join28(this.nexusDir, "budget.json");
+        if (!existsSync21(budgetPath))
+          return null;
+        try {
+          return JSON.parse(await readFile13(budgetPath, "utf8"));
+        } catch {
+          return null;
+        }
+      }
+      async ensureDefaultBudget() {
+        const budgetPath = join28(this.nexusDir, "budget.json");
+        if (existsSync21(budgetPath))
+          return;
+        const defaultBudget = {
+          version: 1,
+          autoApproveBelow: 1e3,
+          // $0.001 — auto-approve micropayments
+          dailyLimitUsdc: 1e6,
+          // $1.00/day default
+          perInvokeMaxUsdc: 1e5,
+          // $0.10 per invoke max
+          requireConfirmationAbove: 5e5,
+          // $0.50 — ask human above this
+          lowBalanceAlertUsdc: 5e5,
+          // $0.50 — warn when low
+          circuitBreakerUsdc: 1e5,
+          // $0.10 — refuse payments below this balance
+          allowedCapabilities: ["inference:*", "transfer:direct", "remote_infer"],
+          deniedPeers: []
+        };
+        await this.ensureDir();
+        await writeFile12(budgetPath, JSON.stringify(defaultBudget, null, 2));
+      }
+      async doBudgetStatus() {
+        await this.ensureDir();
+        const budget = await this.loadBudget();
+        if (!budget) {
+          return "No budget policy configured. Use wallet_create to initialize defaults, or budget_set to configure.";
+        }
+        const todaySpent = await this.getTodaySpending();
+        const lines = [
+          `Budget Policy:`,
+          `  Auto-approve below: $${(budget.autoApproveBelow / 1e6).toFixed(6)}`,
+          `  Per-invoke max:     $${(budget.perInvokeMaxUsdc / 1e6).toFixed(6)}`,
+          `  Daily limit:        $${(budget.dailyLimitUsdc / 1e6).toFixed(6)}`,
+          `  Today's spending:   $${(todaySpent / 1e6).toFixed(6)} / $${(budget.dailyLimitUsdc / 1e6).toFixed(6)}`,
+          `  Confirm above:      $${(budget.requireConfirmationAbove / 1e6).toFixed(6)}`,
+          `  Low balance alert:  $${(budget.lowBalanceAlertUsdc / 1e6).toFixed(6)}`,
+          `  Circuit breaker:    $${(budget.circuitBreakerUsdc / 1e6).toFixed(6)}`,
+          `  Allowed caps:       ${budget.allowedCapabilities.join(", ")}`
+        ];
+        if (budget.deniedPeers.length > 0) {
+          lines.push(`  Denied peers:       ${budget.deniedPeers.length} blocked`);
+        }
+        return lines.join("\n");
+      }
+      async doBudgetSet(args) {
+        await this.ensureDir();
+        let budget = await this.loadBudget();
+        if (!budget) {
+          await this.ensureDefaultBudget();
+          budget = await this.loadBudget();
+        }
+        const parseUsdc = (s) => Math.round(parseFloat(s) * 1e6);
+        const changes = [];
+        if (args.daily_limit) {
+          budget.dailyLimitUsdc = parseUsdc(args.daily_limit);
+          changes.push(`daily_limit=$${args.daily_limit}`);
+        }
+        if (args.per_invoke_max) {
+          budget.perInvokeMaxUsdc = parseUsdc(args.per_invoke_max);
+          changes.push(`per_invoke_max=$${args.per_invoke_max}`);
+        }
+        if (args.auto_approve_below) {
+          budget.autoApproveBelow = parseUsdc(args.auto_approve_below);
+          changes.push(`auto_approve_below=$${args.auto_approve_below}`);
+        }
+        if (changes.length === 0) {
+          return "No budget parameters provided. Use daily_limit, per_invoke_max, or auto_approve_below.";
+        }
+        const budgetPath = join28(this.nexusDir, "budget.json");
+        await writeFile12(budgetPath, JSON.stringify(budget, null, 2));
+        return `Budget updated: ${changes.join(", ")}`;
+      }
+      async getTodaySpending() {
+        const ledgerPath = join28(this.nexusDir, "ledger.jsonl");
+        if (!existsSync21(ledgerPath))
+          return 0;
+        try {
+          const todayPrefix = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+          const raw = await readFile13(ledgerPath, "utf8");
+          let total = 0;
+          for (const line of raw.trim().split("\n")) {
+            if (!line.trim())
+              continue;
+            const entry = JSON.parse(line);
+            if (entry.type === "spent" && entry.timestamp.startsWith(todayPrefix)) {
+              total += Number(BigInt(entry.amount));
+            }
+          }
+          return total;
+        } catch {
+          return 0;
+        }
+      }
+      async checkBudget(amountUsdc, capability, peerId) {
+        const budget = await this.loadBudget();
+        if (!budget)
+          return { allowed: true };
+        if (budget.deniedPeers.includes(peerId)) {
+          return { allowed: false, reason: `Peer ${peerId.slice(0, 16)}... is denied by budget policy` };
+        }
+        const capAllowed = budget.allowedCapabilities.some((pattern) => {
+          if (pattern === "*")
+            return true;
+          if (pattern.endsWith(":*"))
+            return capability.startsWith(pattern.slice(0, -1));
+          return capability === pattern;
+        });
+        if (!capAllowed) {
+          return { allowed: false, reason: `Capability "${capability}" not in allowed list` };
+        }
+        if (amountUsdc > budget.perInvokeMaxUsdc) {
+          return { allowed: false, reason: `Amount $${(amountUsdc / 1e6).toFixed(6)} exceeds per-invoke max $${(budget.perInvokeMaxUsdc / 1e6).toFixed(6)}` };
+        }
+        const todaySpent = await this.getTodaySpending();
+        if (todaySpent + amountUsdc > budget.dailyLimitUsdc) {
+          return { allowed: false, reason: `Would exceed daily limit ($${((todaySpent + amountUsdc) / 1e6).toFixed(6)} > $${(budget.dailyLimitUsdc / 1e6).toFixed(6)})` };
+        }
+        const walletPath = join28(this.nexusDir, "wallet.enc");
+        if (existsSync21(walletPath)) {
+          try {
+            const w = JSON.parse(await readFile13(walletPath, "utf8"));
+            if (w.version === 2 && w.address) {
+              const balance = await this.queryUsdcBalance(w.address, w.chainId || 8453);
+              if (balance !== null && Number(balance) < budget.circuitBreakerUsdc) {
+                return { allowed: false, reason: `Balance $${(Number(balance) / 1e6).toFixed(6)} below circuit breaker threshold $${(budget.circuitBreakerUsdc / 1e6).toFixed(6)}` };
+              }
+            }
+          } catch {
+          }
+        }
+        return { allowed: true };
+      }
+      // ---------------------------------------------------------------------------
+      // Step 5: Spend — Agent-initiated USDC transfer (EIP-3009)
+      // ---------------------------------------------------------------------------
+      async doSpend(args) {
+        const targetAddress = args.target_address;
+        const amountUsd = args.amount_usdc;
+        if (!targetAddress || !/^0x[0-9a-fA-F]{40}$/.test(targetAddress))
+          throw new Error("Valid target_address (0x + 40 hex) is required");
+        if (!amountUsd || isNaN(parseFloat(amountUsd)))
+          throw new Error("amount_usdc is required (e.g. '0.10')");
+        const amountSmallest = Math.round(parseFloat(amountUsd) * 1e6);
+        if (amountSmallest <= 0)
+          throw new Error("amount must be positive");
+        const budgetResult = await this.checkBudget(amountSmallest, "transfer:direct", targetAddress);
+        if (!budgetResult.allowed)
+          return `BLOCKED by budget policy: ${budgetResult.reason}`;
+        const walletPath = join28(this.nexusDir, "wallet.enc");
+        if (!existsSync21(walletPath))
+          throw new Error("No wallet. Use wallet_create first.");
+        const w = JSON.parse(await readFile13(walletPath, "utf8"));
+        if (!w.encryptedKey)
+          throw new Error("User-managed wallet cannot spend (no private key)");
+        const salt = Buffer.from(w.salt, "hex");
+        const key = scryptSync(`${hostname()}:${userInfo().username}:nexus-wallet`, salt, 32, { N: 16384, r: 8, p: 1 });
+        const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(w.iv, "hex"));
+        decipher.setAuthTag(Buffer.from(w.authTag, "hex"));
+        let privKeyHex = decipher.update(w.encryptedKey, "hex", "utf8");
+        privKeyHex += decipher.final("utf8");
+        try {
+          const { privateKeyToAccount } = await import("viem/accounts");
+          const account = privateKeyToAccount(`0x${privKeyHex}`);
+          const nonce = "0x" + randomBytes6(32).toString("hex");
+          const now = Math.floor(Date.now() / 1e3);
+          const validAfter = now - 60;
+          const validBefore = now + 3600;
+          const USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+          const domain = {
+            name: "USD Coin",
+            version: "2",
+            chainId: 8453,
+            verifyingContract: USDC_ADDRESS
+          };
+          const types = {
+            TransferWithAuthorization: [
+              { name: "from", type: "address" },
+              { name: "to", type: "address" },
+              { name: "value", type: "uint256" },
+              { name: "validAfter", type: "uint256" },
+              { name: "validBefore", type: "uint256" },
+              { name: "nonce", type: "bytes32" }
+            ]
+          };
+          const message = {
+            from: account.address,
+            to: targetAddress,
+            value: BigInt(amountSmallest),
+            validAfter: BigInt(validAfter),
+            validBefore: BigInt(validBefore),
+            nonce
+          };
+          const { signTypedData } = await import("viem/accounts");
+          const signature = await signTypedData({
+            privateKey: `0x${privKeyHex}`,
+            domain,
+            types,
+            primaryType: "TransferWithAuthorization",
+            message
+          });
+          await this.appendLedger({
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            type: "spent",
+            amount: String(amountSmallest),
+            amountUsd: (amountSmallest / 1e6).toFixed(6),
+            peer: targetAddress,
+            capability: "transfer:direct",
+            note: "signed, awaiting submission"
+          });
+          const proofFile = join28(this.nexusDir, "pending-transfer.json");
+          const proof = {
+            from: account.address,
+            to: targetAddress,
+            value: String(amountSmallest),
+            validAfter: String(validAfter),
+            validBefore: String(validBefore),
+            nonce,
+            signature,
+            chainId: 8453,
+            usdcContract: USDC_ADDRESS,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          await writeFile12(proofFile, JSON.stringify(proof, null, 2));
+          return [
+            `Transfer signed (EIP-3009 TransferWithAuthorization):`,
+            `  From: ${account.address}`,
+            `  To: ${targetAddress}`,
+            `  Amount: $${(amountSmallest / 1e6).toFixed(6)} USDC`,
+            `  Valid: ${new Date(validAfter * 1e3).toISOString()} to ${new Date(validBefore * 1e3).toISOString()}`,
+            `  Signature: ${signature.slice(0, 20)}...`,
+            `  Proof saved: ${proofFile}`,
+            ``,
+            `To submit on-chain: anyone can call USDC.transferWithAuthorization() with this proof.`,
+            `The recipient or a facilitator can submit it \u2014 no gas needed from the payer.`
+          ].join("\n");
+        } finally {
+          privKeyHex = "0".repeat(64);
+        }
+      }
+      // ---------------------------------------------------------------------------
+      // Step 6: Remote Inference — Route inference to remote peers on the mesh
+      // ---------------------------------------------------------------------------
+      async doRemoteInfer(args) {
+        const model = args.model;
+        const prompt = args.prompt || args.input;
+        if (!model)
+          throw new Error("model is required (e.g., 'qwen3.5:70b', 'nemotron-3-nano:30b')");
+        if (!prompt)
+          throw new Error("prompt is required");
+        const estimatedTokens = Math.ceil(prompt.length / 4) + 1e3;
+        let estimatedCostSmallest = 0;
+        const pricingPath = join28(this.nexusDir, "pricing.json");
+        if (existsSync21(pricingPath)) {
+          try {
+            const pricing = JSON.parse(await readFile13(pricingPath, "utf8"));
+            const modelPricing = (pricing.models || []).find((m) => m.model === model || m.model.startsWith(model.split(":")[0]));
+            if (modelPricing?.pricing?.input_per_1m_tokens > 0) {
+              estimatedCostSmallest = Math.ceil(estimatedTokens / 1e6 * modelPricing.pricing.input_per_1m_tokens * 1e6);
+            }
+          } catch {
+          }
+        }
+        if (estimatedCostSmallest > 0) {
+          const budgetResult = await this.checkBudget(estimatedCostSmallest, "remote_infer", args.target_peer || "");
+          if (!budgetResult.allowed) {
+            return `BLOCKED by budget policy: ${budgetResult.reason}`;
+          }
+        }
+        const budget = await this.loadBudget();
+        if (budget && !budget.allowedCapabilities.some((c3) => c3 === "remote_infer" || c3 === "inference:*" || c3 === "*")) {
+          return "BLOCKED: remote_infer not in budget allowedCapabilities. Use budget_set to allow it.";
+        }
+        const daemonArgs = {
+          model,
+          target_peer: args.target_peer,
+          temperature: args.temperature,
+          max_tokens: args.max_tokens
+        };
+        if (args.messages) {
+          daemonArgs.messages = args.messages;
+          if (args.tools)
+            daemonArgs.tools = args.tools;
+        } else {
+          daemonArgs.prompt = prompt;
+        }
+        const result = await this.sendDaemonCmd("remote_infer", daemonArgs, 12e4);
+        let peerUsed = args.target_peer || "auto-selected";
+        try {
+          const parsed = JSON.parse(result);
+          if (parsed.peer)
+            peerUsed = parsed.peer;
+          if (estimatedCostSmallest > 0) {
+            await this.appendLedger({
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              type: "spent",
+              amount: String(estimatedCostSmallest),
+              amountUsd: (estimatedCostSmallest / 1e6).toFixed(6),
+              peer: peerUsed,
+              capability: "remote_infer:" + model,
+              note: "remote inference"
+            });
+          }
+          const inferResult = parsed.result;
+          let responseText = "";
+          if (typeof inferResult === "string") {
+            responseText = inferResult;
+          } else if (inferResult) {
+            const events = Array.isArray(inferResult) ? inferResult : [inferResult];
+            for (const evt of events) {
+              if (evt.event === "result" && evt.data) {
+                try {
+                  const data = typeof evt.data === "string" ? JSON.parse(evt.data) : evt.data;
+                  responseText = data.response || data.content || JSON.stringify(data);
+                } catch {
+                  responseText = String(evt.data);
+                }
+              }
+            }
+            if (!responseText) {
+              responseText = JSON.stringify(inferResult, null, 2);
+            }
+          }
+          const lines = [
+            `Remote inference result (${model} via ${peerUsed.slice(0, 20)}...):`,
+            ``,
+            responseText,
+            ``,
+            `--- Metadata ---`,
+            `Model: ${parsed.model || model}`,
+            `Peer: ${peerUsed}`,
+            `Capability: ${parsed.capability || "inference:" + model}`
+          ];
+          if (estimatedCostSmallest > 0) {
+            lines.push(`Estimated cost: $${(estimatedCostSmallest / 1e6).toFixed(6)} USDC`);
+          } else {
+            lines.push(`Cost: FREE (provider margin = 0)`);
+          }
+          return lines.join("\n");
+        } catch {
+          return result;
+        }
+      }
       async doInferenceProof() {
         try {
           const psRaw = execSync21("ollama ps 2>/dev/null", { timeout: 1e4, encoding: "utf8" });
@@ -17416,6 +18226,121 @@ ${transcript}`
   }
 });
 
+// packages/orchestrator/dist/nexusBackend.js
+var NexusAgenticBackend;
+var init_nexusBackend = __esm({
+  "packages/orchestrator/dist/nexusBackend.js"() {
+    "use strict";
+    NexusAgenticBackend = class {
+      sendFn;
+      model;
+      targetPeer;
+      constructor(sendFn, model, targetPeer) {
+        this.sendFn = sendFn;
+        this.model = model;
+        this.targetPeer = targetPeer || "";
+      }
+      async chatCompletion(request) {
+        const daemonArgs = {
+          model: this.model,
+          messages: JSON.stringify(request.messages),
+          tools: JSON.stringify(request.tools),
+          temperature: String(request.temperature),
+          max_tokens: String(request.maxTokens)
+        };
+        if (this.targetPeer) {
+          daemonArgs.target_peer = this.targetPeer;
+        }
+        const rawResult = await this.sendFn("remote_infer", daemonArgs, request.timeoutMs || 12e4);
+        let parsed;
+        try {
+          parsed = JSON.parse(rawResult);
+        } catch {
+          throw new Error(`Invalid response from nexus daemon: ${rawResult.slice(0, 200)}`);
+        }
+        if (parsed.success === false) {
+          throw new Error(`Remote inference failed: ${parsed.output || rawResult}`);
+        }
+        const invokeResult = parsed.result;
+        let responseData = null;
+        if (typeof invokeResult === "string") {
+          try {
+            responseData = JSON.parse(invokeResult);
+          } catch {
+            responseData = { response: invokeResult };
+          }
+        } else if (invokeResult) {
+          const events = Array.isArray(invokeResult) ? invokeResult : [invokeResult];
+          for (const evt of events) {
+            if (evt.event === "result" && evt.data) {
+              const evtData = evt.data;
+              try {
+                responseData = typeof evtData === "string" ? JSON.parse(evtData) : evtData;
+              } catch {
+                responseData = { response: String(evtData) };
+              }
+            }
+          }
+        }
+        if (!responseData) {
+          throw new Error("No response data from remote inference");
+        }
+        const choices = responseData.choices;
+        if (choices && Array.isArray(choices)) {
+          return {
+            choices: choices.map((c3) => {
+              const msg = c3.message || {};
+              const toolCalls = msg.tool_calls || [];
+              return {
+                message: {
+                  content: typeof msg.content === "string" ? msg.content : msg.content ?? null,
+                  toolCalls: toolCalls.length > 0 ? toolCalls.map((tc) => {
+                    const fn = tc.function || {};
+                    let args;
+                    try {
+                      args = typeof fn.arguments === "string" ? JSON.parse(fn.arguments) : fn.arguments ?? {};
+                    } catch {
+                      args = { _raw: fn.arguments };
+                    }
+                    return {
+                      id: tc.id || crypto.randomUUID(),
+                      name: fn.name,
+                      arguments: args
+                    };
+                  }) : void 0
+                }
+              };
+            }),
+            usage: this.extractUsage(responseData)
+          };
+        }
+        const content = responseData.response || JSON.stringify(responseData);
+        return {
+          choices: [{
+            message: {
+              content,
+              toolCalls: void 0
+            }
+          }],
+          usage: this.extractUsage(responseData)
+        };
+      }
+      extractUsage(data) {
+        const usage = data.usage;
+        if (!usage)
+          return void 0;
+        const inputTokens = usage.input_tokens || usage.prompt_tokens || 0;
+        const outputTokens = usage.output_tokens || usage.completion_tokens || 0;
+        return {
+          totalTokens: inputTokens + outputTokens,
+          promptTokens: inputTokens,
+          completionTokens: outputTokens
+        };
+      }
+    };
+  }
+});
+
 // packages/orchestrator/dist/costTracker.js
 var DEFAULT_PRICING, CostTracker;
 var init_costTracker = __esm({
@@ -17895,6 +18820,7 @@ var init_dist5 = __esm({
     init_mergeRunner();
     init_retryController();
     init_agenticRunner();
+    init_nexusBackend();
     init_costTracker();
     init_workEvaluator();
     init_sessionMetrics();
@@ -38561,7 +39487,13 @@ function createSubAgentTool(config, repoRoot, ctxWindowSize) {
       if (!task) {
         return { success: false, output: "", error: "task is required" };
       }
-      const backend = new OllamaAgenticBackend(config.backendUrl, config.model, config.apiKey);
+      let backend;
+      if (config.backendType === "nexus") {
+        const nexusTool = new NexusTool(repoRoot);
+        backend = new NexusAgenticBackend(nexusTool.sendCommand.bind(nexusTool), config.model);
+      } else {
+        backend = new OllamaAgenticBackend(config.backendUrl, config.model, config.apiKey);
+      }
       const subCtxWindow = ctxWindowSize ?? 0;
       const subTier = getModelTier(config.model);
       const subCompaction = subTier === "small" ? 12e3 : subTier === "medium" ? 24e3 : 4e4;
@@ -38712,7 +39644,14 @@ function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce
   if (taskType && modelTier !== "small") {
     dynamicContext += "\n\n" + buildTaskContext(taskType);
   }
-  const backend = new OllamaAgenticBackend(config.backendUrl, config.model, config.apiKey);
+  let backend;
+  if (config.backendType === "nexus") {
+    const nexusTool = new NexusTool(repoRoot);
+    const sendFn = nexusTool.sendCommand.bind(nexusTool);
+    backend = new NexusAgenticBackend(sendFn, config.model);
+  } else {
+    backend = new OllamaAgenticBackend(config.backendUrl, config.model, config.apiKey);
+  }
   const compactionThreshold = modelTier === "small" ? 12e3 : modelTier === "medium" ? 24e3 : 4e4;
   const runner = new AgenticRunner(backend, {
     maxTurns: 60,
@@ -41924,6 +42863,10 @@ async function evalCommand(opts, config) {
   const evalRepoRoot = opts.repoPath ?? createTempEvalRepo();
   let rawBackend;
   if (useLive) {
+    if (config.backendType === "nexus") {
+      printError("Nexus backend is not supported for eval. Use --backend ollama or --backend vllm.");
+      process.exit(1);
+    }
     rawBackend = createBackend({
       type: config.backendType,
       model: config.model,