open-agents-ai 0.184.1 → 0.184.3

package/dist/index.js

@@ -61,11 +61,11 @@ function parseBackendType(value) {
   return VALID_BACKEND_TYPES.has(value) ? value : void 0;
 }
 function loadConfigFile() {
-  const configPath = join(homedir(), ".open-agents", "config.json");
-  if (!existsSync(configPath))
+  const configPath2 = join(homedir(), ".open-agents", "config.json");
+  if (!existsSync(configPath2))
     return {};
   try {
-    const raw = readFileSync(configPath, "utf8");
+    const raw = readFileSync(configPath2, "utf8");
     const parsed = JSON.parse(raw);
     const result = {};
     if (typeof parsed.backendUrl === "string")
@@ -111,10 +111,10 @@ function mergeConfig(base, overrides) {
 function setConfigValue(key, value) {
   const dir = join(homedir(), ".open-agents");
   mkdirSync(dir, { recursive: true });
-  const configPath = join(dir, "config.json");
+  const configPath2 = join(dir, "config.json");
   const existing = loadConfigFile();
   existing[key] = coerceConfigValue(key, value);
-  writeFileSync(configPath, JSON.stringify(existing, null, 2) + "\n", { encoding: "utf8", mode: 384 });
+  writeFileSync(configPath2, JSON.stringify(existing, null, 2) + "\n", { encoding: "utf8", mode: 384 });
 }
 function coerceConfigValue(key, value) {
   const intKeys = /* @__PURE__ */ new Set(["maxRetries", "timeoutMs"]);
@@ -13402,9 +13402,9 @@ print("${sentinel}")
         if (!this.proc || this.proc.killed) {
           return { success: false, path: "" };
         }
-        const { mkdirSync: mkdirSync26, writeFileSync: writeFileSync25 } = await import("node:fs");
+        const { mkdirSync: mkdirSync27, writeFileSync: writeFileSync26 } = await import("node:fs");
         const sessionDir = join22(this.cwd, ".oa", "rlm");
-        mkdirSync26(sessionDir, { recursive: true });
+        mkdirSync27(sessionDir, { recursive: true });
         const sessionPath = join22(sessionDir, "session.json");
         try {
           const inspectCode = `
@@ -13428,7 +13428,7 @@ print("__SESSION__" + json.dumps(_session) + "__SESSION__")
               trajectoryCount: this.trajectory.length,
               subCallCount: this.subCallCount
             };
-            writeFileSync25(sessionPath, JSON.stringify(sessionData, null, 2), "utf8");
+            writeFileSync26(sessionPath, JSON.stringify(sessionData, null, 2), "utf8");
             return { success: true, path: sessionPath };
           }
         } catch {
@@ -13440,11 +13440,11 @@ print("__SESSION__" + json.dumps(_session) + "__SESSION__")
        *  what was previously computed. */
       async loadSessionInfo() {
         try {
-          const { readFileSync: readFileSync40, existsSync: existsSync52 } = await import("node:fs");
+          const { readFileSync: readFileSync41, existsSync: existsSync53 } = await import("node:fs");
           const sessionPath = join22(this.cwd, ".oa", "rlm", "session.json");
-          if (!existsSync52(sessionPath))
+          if (!existsSync53(sessionPath))
             return null;
-          return JSON.parse(readFileSync40(sessionPath, "utf8"));
+          return JSON.parse(readFileSync41(sessionPath, "utf8"));
         } catch {
           return null;
         }
@@ -13621,10 +13621,10 @@ var init_memory_metabolism = __esm({
         const trajDir = join23(this.cwd, ".oa", "rlm-trajectories");
         let lessons = [];
         try {
-          const { readdirSync: readdirSync21, readFileSync: readFileSync40 } = await import("node:fs");
+          const { readdirSync: readdirSync21, readFileSync: readFileSync41 } = await import("node:fs");
           const files = readdirSync21(trajDir).filter((f) => f.endsWith(".jsonl")).sort().reverse().slice(0, 3);
           for (const file of files) {
-            const lines = readFileSync40(join23(trajDir, file), "utf8").split("\n").filter((l) => l.trim());
+            const lines = readFileSync41(join23(trajDir, file), "utf8").split("\n").filter((l) => l.trim());
             for (const line of lines) {
               try {
                 const entry = JSON.parse(line);
@@ -14008,14 +14008,14 @@ ${issues.map((i) => `  - ${i}`).join("\n")}` : "  No issues found."),
        * Optionally filter by task type for phase-aware context (FSM paper insight).
        */
       getTopMemoriesSync(k = 5, taskType) {
-        const { readFileSync: readFileSync40, existsSync: existsSync52 } = __require("node:fs");
+        const { readFileSync: readFileSync41, existsSync: existsSync53 } = __require("node:fs");
         const metaDir = join23(this.cwd, ".oa", "memory", "metabolism");
         const storeFile = join23(metaDir, "store.json");
-        if (!existsSync52(storeFile))
+        if (!existsSync53(storeFile))
           return "";
         let store = [];
         try {
-          store = JSON.parse(readFileSync40(storeFile, "utf8"));
+          store = JSON.parse(readFileSync41(storeFile, "utf8"));
         } catch {
           return "";
         }
@@ -14037,14 +14037,14 @@ ${issues.map((i) => `  - ${i}`).join("\n")}` : "  No issues found."),
       /** Update memory scores based on task outcome. Called after task completion.
        *  Memories used in successful tasks get boosted. Memories present during failures get decayed. */
       updateFromOutcomeSync(surfacedMemoryText, succeeded) {
-        const { readFileSync: readFileSync40, writeFileSync: writeFileSync25, existsSync: existsSync52, mkdirSync: mkdirSync26 } = __require("node:fs");
+        const { readFileSync: readFileSync41, writeFileSync: writeFileSync26, existsSync: existsSync53, mkdirSync: mkdirSync27 } = __require("node:fs");
         const metaDir = join23(this.cwd, ".oa", "memory", "metabolism");
         const storeFile = join23(metaDir, "store.json");
-        if (!existsSync52(storeFile))
+        if (!existsSync53(storeFile))
           return;
         let store = [];
         try {
-          store = JSON.parse(readFileSync40(storeFile, "utf8"));
+          store = JSON.parse(readFileSync41(storeFile, "utf8"));
         } catch {
           return;
         }
@@ -14068,8 +14068,8 @@ ${issues.map((i) => `  - ${i}`).join("\n")}` : "  No issues found."),
           updated = true;
         }
         if (updated) {
-          mkdirSync26(metaDir, { recursive: true });
-          writeFileSync25(storeFile, JSON.stringify(store, null, 2));
+          mkdirSync27(metaDir, { recursive: true });
+          writeFileSync26(storeFile, JSON.stringify(store, null, 2));
         }
       }
       // ── Storage ──────────────────────────────────────────────────────────
@@ -14491,13 +14491,13 @@ Recommendation: Strategy ${scored[0].index + 1} scores highest.`;
       // Per EvoSkill (arXiv:2603.02766): retrieve relevant strategies from archive.
       /** Retrieve top-K strategies for context injection. Returns "" if none. */
       getRelevantStrategiesSync(k = 3, taskType) {
-        const { readFileSync: readFileSync40, existsSync: existsSync52 } = __require("node:fs");
+        const { readFileSync: readFileSync41, existsSync: existsSync53 } = __require("node:fs");
         const archiveFile = join25(this.cwd, ".oa", "arche", "variants.json");
-        if (!existsSync52(archiveFile))
+        if (!existsSync53(archiveFile))
           return "";
         let variants = [];
         try {
-          variants = JSON.parse(readFileSync40(archiveFile, "utf8"));
+          variants = JSON.parse(readFileSync41(archiveFile, "utf8"));
         } catch {
           return "";
         }
@@ -14515,13 +14515,13 @@ Recommendation: Strategy ${scored[0].index + 1} scores highest.`;
       }
       /** Archive a strategy variant synchronously (for task completion path) */
       archiveVariantSync(strategy, outcome, tags = []) {
-        const { readFileSync: readFileSync40, writeFileSync: writeFileSync25, existsSync: existsSync52, mkdirSync: mkdirSync26 } = __require("node:fs");
+        const { readFileSync: readFileSync41, writeFileSync: writeFileSync26, existsSync: existsSync53, mkdirSync: mkdirSync27 } = __require("node:fs");
         const dir = join25(this.cwd, ".oa", "arche");
         const archiveFile = join25(dir, "variants.json");
         let variants = [];
         try {
-          if (existsSync52(archiveFile))
-            variants = JSON.parse(readFileSync40(archiveFile, "utf8"));
+          if (existsSync53(archiveFile))
+            variants = JSON.parse(readFileSync41(archiveFile, "utf8"));
         } catch {
         }
         variants.push({
@@ -14536,8 +14536,8 @@ Recommendation: Strategy ${scored[0].index + 1} scores highest.`;
         });
         if (variants.length > 50)
           variants = variants.slice(-50);
-        mkdirSync26(dir, { recursive: true });
-        writeFileSync25(archiveFile, JSON.stringify(variants, null, 2));
+        mkdirSync27(dir, { recursive: true });
+        writeFileSync26(archiveFile, JSON.stringify(variants, null, 2));
       }
       async saveArchive(variants) {
         const dir = join25(this.cwd, ".oa", "arche");
@@ -26895,10 +26895,10 @@ ${marker}` : marker);
         if (!this._workingDirectory)
           return;
         try {
-          const { mkdirSync: mkdirSync26, writeFileSync: writeFileSync25 } = __require("node:fs");
-          const { join: join72 } = __require("node:path");
-          const sessionDir = join72(this._workingDirectory, ".oa", "session", this._sessionId);
-          mkdirSync26(sessionDir, { recursive: true });
+          const { mkdirSync: mkdirSync27, writeFileSync: writeFileSync26 } = __require("node:fs");
+          const { join: join73 } = __require("node:path");
+          const sessionDir = join73(this._workingDirectory, ".oa", "session", this._sessionId);
+          mkdirSync27(sessionDir, { recursive: true });
           const checkpoint = {
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
             sessionId: this._sessionId,
@@ -26910,7 +26910,7 @@ ${marker}` : marker);
             memexEntryCount: this._memexArchive.size,
             fileRegistrySize: this._fileRegistry.size
           };
-          writeFileSync25(join72(sessionDir, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
+          writeFileSync26(join73(sessionDir, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
         } catch {
         }
       }
@@ -34617,6 +34617,10 @@ var init_render = __esm({
       ["/nexus restart --clean", "Restart + clear metering data for fresh stats"],
       ["/nexus disconnect", "Kill daemon without reconnecting"],
       ["/nexus wallet", "Show wallet address and x402 payment status"],
+      ["/sponsor", "Sponsor inference \u2014 onboarding wizard or dashboard"],
+      ["/sponsor status", "Show sponsor dashboard with usage metrics"],
+      ["/sponsor pause", "Pause active sponsorship"],
+      ["/sponsor remove", "Remove sponsorship entirely"],
       ["/expose <backend>", "Expose local inference via libp2p (default)"],
       ["/expose <backend> --tunnel", "Expose via cloudflared tunnel"],
       ["/expose passthrough", "Forward configured /endpoint through libp2p P2P"],
@@ -35573,6 +35577,9 @@ var init_expose = __esm({
       /** Periodic PID watchdog for reconnect mode (no ChildProcess close event) */
       _pidWatchdog = null;
       _tunnelUrl = null;
+      /** Debounce tracking for tunnel restarts */
+      _lastRestartAttempt = 0;
+      _consecutiveFailures = 0;
       _authKey;
       _targetUrl;
       _kind;
@@ -35634,16 +35641,19 @@ var init_expose = __esm({
           this.server.on("error", reject);
         });
         let lastStartErr;
+        this._consecutiveFailures = 0;
         for (let attempt = 0; attempt < 3; attempt++) {
           try {
+            this._lastRestartAttempt = Date.now();
             this._tunnelUrl = await this.startCloudflared(port);
+            this._consecutiveFailures = 0;
             break;
           } catch (err) {
             lastStartErr = err instanceof Error ? err : new Error(String(err));
-            const is429 = lastStartErr.message.includes("429") || lastStartErr.message.includes("Too Many Requests");
-            if (is429 && attempt < 2) {
-              const delaySec = (attempt + 1) * 15;
-              this.options.onInfo?.(`Cloudflare rate limited \u2014 retrying in ${delaySec}s (attempt ${attempt + 2}/3)...`);
+            this._consecutiveFailures++;
+            if (attempt < 2) {
+              const delaySec = Math.min(15 * Math.pow(2, attempt), 60);
+              this.options.onInfo?.(`Tunnel start failed \u2014 retrying in ${delaySec}s (attempt ${attempt + 2}/3)...`);
               await new Promise((r) => setTimeout(r, delaySec * 1e3));
               continue;
             }
@@ -36052,9 +36062,19 @@ var init_expose = __esm({
       startCloudflared(port) {
         this._proxyPort = port;
         return new Promise((resolve35, reject) => {
+          const TUNNEL_TIMEOUT_MS = 6e4;
           const timeout = setTimeout(() => {
-            reject(new Error("Cloudflared tunnel start timeout (30s)"));
-          }, 3e4);
+            reject(new Error("Cloudflared tunnel start timeout (60s). Slow network? Try again."));
+          }, TUNNEL_TIMEOUT_MS);
+          let elapsed = 0;
+          const progressInterval = setInterval(() => {
+            elapsed += 5;
+            this.options.onInfo?.(`Starting cloudflared tunnel... (${elapsed}s)`);
+          }, 5e3);
+          const cleanTimers = () => {
+            clearTimeout(timeout);
+            clearInterval(progressInterval);
+          };
           this.cloudflaredProcess = spawn18("cloudflared", [
             "tunnel",
             "--url",
@@ -36074,9 +36094,14 @@ var init_expose = __esm({
             if (stderrOutput.length > 4096)
               stderrOutput = stderrOutput.slice(-4096);
             const urlMatch = text.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/);
+            const statusMatch = text.match(/INF\s+(.*)/);
+            if (statusMatch && !urlFound) {
+              this.options.onInfo?.(`cloudflared: ${statusMatch[1].slice(0, 80)}`);
+            }
             if (urlMatch && !urlFound) {
               urlFound = true;
-              clearTimeout(timeout);
+              cleanTimers();
+              this._consecutiveFailures = 0;
               this.cloudflaredProcess?.unref();
               this.cloudflaredProcess?.stdout?.destroy();
               this.cloudflaredProcess?.stderr?.destroy();
@@ -36086,59 +36111,80 @@ var init_expose = __esm({
           this.cloudflaredProcess.stdout?.on("data", handleOutput);
           this.cloudflaredProcess.stderr?.on("data", handleOutput);
           this.cloudflaredProcess.on("error", (err) => {
-            clearTimeout(timeout);
-            reject(new Error(`Failed to start cloudflared: ${err.message}`));
+            cleanTimers();
+            const msg = err.message;
+            if (msg.includes("ENOENT")) {
+              reject(new Error("cloudflared not installed. Install: brew install cloudflared (macOS) or download from https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/"));
+            } else {
+              reject(new Error(`Failed to start cloudflared: ${msg}`));
+            }
           });
           this.cloudflaredProcess.on("close", (code) => {
             if (!urlFound) {
-              clearTimeout(timeout);
+              cleanTimers();
               const hint = stderrOutput.trim().split("\n").slice(-3).join(" | ");
-              reject(new Error(`Cloudflared exited with code ${code}. ${hint ? "Output: " + hint : ""}`));
+              if (hint.includes("address already in use")) {
+                reject(new Error(`Port ${port} already in use. Another expose gateway may be running. Try: /expose stop first.`));
+              } else if (hint.includes("429") || hint.includes("Too Many")) {
+                reject(new Error(`Cloudflare rate limited (429). Wait 60s or use /expose libp2p instead.`));
+              } else {
+                reject(new Error(`Cloudflared exited with code ${code}. ${hint ? "Output: " + hint : ""}`));
+              }
             }
             if (this._stats.status === "active") {
-              this.options.onInfo?.("Cloudflared tunnel died \u2014 restarting...");
               this._stats.status = "error";
               this.emitStats();
-              this.restartCloudflared();
+              this.debouncedRestart();
             }
           });
         });
       }
-      /** Auto-restart cloudflared after unexpected exit (new URL assigned) */
-      async restartCloudflared() {
+      /**
+       * Debounced auto-restart: ensures minimum 10s between attempts,
+       * exponential cooldown on consecutive failures, stops after 3 failures
+       * and waits for manual `/expose tunnel` retry.
+       */
+      async debouncedRestart() {
         if (!this.server || this._proxyPort === 0)
           return;
-        for (let attempt = 0; attempt < 3; attempt++) {
-          try {
-            this._tunnelUrl = await this.startCloudflared(this._proxyPort);
-            this._stats.status = "active";
-            this.emitStats();
-            this.options.onInfo?.(`Tunnel restarted with new URL \u2014 share with consumers:
+        this._consecutiveFailures++;
+        if (this._consecutiveFailures >= 3) {
+          this._stats.status = "standby";
+          this.emitStats();
+          this.options.onError?.(`Tunnel failed to start after ${this._consecutiveFailures} attempts.
+Type /expose tunnel to retry manually, or /expose libp2p as alternative.`);
+          return;
+        }
+        const cooldownSec = Math.min(10 * Math.pow(2, this._consecutiveFailures - 1), 300);
+        const sinceLast = (Date.now() - this._lastRestartAttempt) / 1e3;
+        const waitSec = Math.max(cooldownSec - sinceLast, 0);
+        if (waitSec > 0) {
+          this.options.onInfo?.(`Tunnel died \u2014 will retry in ${Math.ceil(waitSec)}s (attempt ${this._consecutiveFailures + 1}/3)...`);
+          await new Promise((r) => setTimeout(r, waitSec * 1e3));
+        }
+        this._lastRestartAttempt = Date.now();
+        try {
+          this._tunnelUrl = await this.startCloudflared(this._proxyPort);
+          this._stats.status = "active";
+          this._consecutiveFailures = 0;
+          this.emitStats();
+          this.options.onInfo?.(`Tunnel restarted with new URL \u2014 share with consumers:
 ${this.formatConnectionInfo()}`);
-            if (this._stateDir) {
-              writeExposeState(this._stateDir, {
-                pid: this._cloudflaredPid,
-                tunnelUrl: this._tunnelUrl,
-                authKey: this._authKey,
-                proxyPort: this._proxyPort,
-                targetUrl: this._targetUrl,
-                kind: this._kind,
-                startedAt: (/* @__PURE__ */ new Date()).toISOString()
-              });
-            }
-            return;
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            const is429 = msg.includes("429") || msg.includes("Too Many Requests");
-            if (is429 && attempt < 2) {
-              const delaySec = (attempt + 1) * 15;
-              this.options.onInfo?.(`Cloudflare rate limited \u2014 retrying in ${delaySec}s...`);
-              await new Promise((r) => setTimeout(r, delaySec * 1e3));
-              continue;
-            }
-            this.options.onError?.(`Tunnel restart failed: ${msg}`);
-            return;
+          if (this._stateDir) {
+            writeExposeState(this._stateDir, {
+              pid: this._cloudflaredPid,
+              tunnelUrl: this._tunnelUrl,
+              authKey: this._authKey,
+              proxyPort: this._proxyPort,
+              targetUrl: this._targetUrl,
+              kind: this._kind,
+              startedAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
           }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          this.options.onError?.(`Tunnel restart failed (attempt ${this._consecutiveFailures}/3): ${msg}`);
+          this.debouncedRestart();
         }
       }
       /**
@@ -36155,7 +36201,7 @@ ${this.formatConnectionInfo()}`);
               this.options.onInfo?.("Cloudflared tunnel died (detected by watchdog) \u2014 restarting...");
               this._stats.status = "error";
               this.emitStats();
-              this.restartCloudflared();
+              this.debouncedRestart();
             }
           }
         }, 1e4);
@@ -38138,26 +38184,26 @@ async function fetchOpenAIModels(baseUrl, apiKey) {
 async function fetchPeerModels(peerId, authKey) {
   try {
     const { NexusTool: NexusTool2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
-    const { existsSync: existsSync52, readFileSync: readFileSync40 } = await import("node:fs");
-    const { join: join72 } = await import("node:path");
+    const { existsSync: existsSync53, readFileSync: readFileSync41 } = await import("node:fs");
+    const { join: join73 } = await import("node:path");
     const cwd4 = process.cwd();
     const nexusTool = new NexusTool2(cwd4);
     const nexusDir = nexusTool.getNexusDir();
     let isLocalPeer = false;
     try {
-      const statusPath = join72(nexusDir, "status.json");
-      if (existsSync52(statusPath)) {
-        const status = JSON.parse(readFileSync40(statusPath, "utf8"));
+      const statusPath = join73(nexusDir, "status.json");
+      if (existsSync53(statusPath)) {
+        const status = JSON.parse(readFileSync41(statusPath, "utf8"));
         if (status.peerId === peerId)
           isLocalPeer = true;
       }
     } catch {
     }
     if (isLocalPeer) {
-      const pricingPath = join72(nexusDir, "pricing.json");
-      if (existsSync52(pricingPath)) {
+      const pricingPath = join73(nexusDir, "pricing.json");
+      if (existsSync53(pricingPath)) {
         try {
-          const pricing = JSON.parse(readFileSync40(pricingPath, "utf8"));
+          const pricing = JSON.parse(readFileSync41(pricingPath, "utf8"));
           const localModels = (pricing.models || []).map((m) => ({
             name: m.model || "unknown",
             size: m.parameterSize || "",
@@ -38171,10 +38217,10 @@ async function fetchPeerModels(peerId, authKey) {
         }
       }
     }
-    const cachePath = join72(nexusDir, "peer-models-cache.json");
-    if (existsSync52(cachePath)) {
+    const cachePath = join73(nexusDir, "peer-models-cache.json");
+    if (existsSync53(cachePath)) {
       try {
-        const cache4 = JSON.parse(readFileSync40(cachePath, "utf8"));
+        const cache4 = JSON.parse(readFileSync41(cachePath, "utf8"));
         if (cache4.peerId === peerId && cache4.models?.length > 0) {
           const age = Date.now() - new Date(cache4.cachedAt).getTime();
           if (age < 5 * 60 * 1e3) {
@@ -38289,10 +38335,10 @@ async function fetchPeerModels(peerId, authKey) {
     } catch {
     }
     if (isLocalPeer) {
-      const pricingPath = join72(nexusDir, "pricing.json");
-      if (existsSync52(pricingPath)) {
+      const pricingPath = join73(nexusDir, "pricing.json");
+      if (existsSync53(pricingPath)) {
         try {
-          const pricing = JSON.parse(readFileSync40(pricingPath, "utf8"));
+          const pricing = JSON.parse(readFileSync41(pricingPath, "utf8"));
           return (pricing.models || []).map((m) => ({
             name: m.model || "unknown",
             size: m.parameterSize || "",
@@ -42325,6 +42371,471 @@ var init_neovim_mode = __esm({
   }
 });
 
+// packages/cli/dist/tui/sponsor-wizard.js
+var sponsor_wizard_exports = {};
+__export(sponsor_wizard_exports, {
+  loadSponsorConfig: () => loadSponsorConfig,
+  runSponsorWizard: () => runSponsorWizard,
+  saveSponsorConfig: () => saveSponsorConfig,
+  showSponsorDashboard: () => showSponsorDashboard
+});
+import { existsSync as existsSync40, readFileSync as readFileSync29, writeFileSync as writeFileSync17, mkdirSync as mkdirSync16 } from "node:fs";
+import { join as join56 } from "node:path";
+function sponsorDir(projectDir) {
+  return join56(projectDir, ".oa", "sponsor");
+}
+function configPath(projectDir) {
+  return join56(sponsorDir(projectDir), "config.json");
+}
+function loadSponsorConfig(projectDir) {
+  const p = configPath(projectDir);
+  if (!existsSync40(p))
+    return null;
+  try {
+    return JSON.parse(readFileSync29(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function saveSponsorConfig(projectDir, config) {
+  const dir = sponsorDir(projectDir);
+  mkdirSync16(dir, { recursive: true });
+  config.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync17(configPath(projectDir), JSON.stringify(config, null, 2), "utf8");
+}
+function defaultConfig() {
+  return {
+    endpoints: [],
+    banner: { preset: "wave" },
+    header: {
+      messageEnabled: false,
+      message: "",
+      linkEnabled: false,
+      linkUrl: "",
+      linkText: ""
+    },
+    transport: { cloudflared: true, libp2p: false },
+    rateLimits: {
+      maxRequestsPerMinute: 60,
+      maxTokensPerDay: 1e5,
+      maxConcurrent: 5,
+      allowedModels: "all"
+    },
+    status: "inactive",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function discoverEndpoints(ollamaUrl) {
+  const endpoints = [];
+  try {
+    const resp = await fetch(`${ollamaUrl}/api/tags`, { signal: AbortSignal.timeout(5e3) });
+    if (resp.ok) {
+      const data = await resp.json();
+      const models = (data.models || []).map((m) => m.name);
+      endpoints.push({
+        kind: "ollama",
+        url: ollamaUrl,
+        models,
+        label: `Local Ollama (${new URL(ollamaUrl).host})`,
+        enabled: true
+      });
+    }
+  } catch {
+  }
+  return endpoints;
+}
+async function stepEndpoints(config, ollamaUrl, rl, availableRows) {
+  const discovered = await discoverEndpoints(ollamaUrl);
+  for (const disc of discovered) {
+    const existing = config.endpoints.find((e) => e.url === disc.url);
+    if (!existing) {
+      config.endpoints.push(disc);
+    } else {
+      existing.models = disc.models;
+    }
+  }
+  const items = [
+    { key: "hdr", label: "Select Endpoints to Sponsor", isToggleable: false }
+  ];
+  for (const ep of config.endpoints) {
+    const modelList = ep.models.length > 0 ? ep.models.slice(0, 3).join(", ") + (ep.models.length > 3 ? ` +${ep.models.length - 3} more` : "") : "all models";
+    items.push({
+      key: ep.url,
+      label: `${ep.enabled ? "[x]" : "[ ]"} ${ep.label}`,
+      detail: `Models: ${modelList}`,
+      endpoint: ep,
+      isToggleable: true
+    });
+  }
+  items.push({
+    key: "add_custom",
+    label: "  + Add custom endpoint URL...",
+    isToggleable: false
+  });
+  items.push({ key: "sep", label: "", isToggleable: false });
+  items.push({
+    key: "next",
+    label: selectColors.green("  Next Step  \u2192"),
+    isToggleable: false
+  });
+  const result = await tuiSelect({
+    items,
+    title: "Step 1/5 \u2014 Endpoint Selection",
+    rl,
+    skipKeys: ["hdr", "sep"],
+    availableRows,
+    onAction: (item, action) => {
+      if (action === "space" && item.isToggleable && item.endpoint) {
+        item.endpoint.enabled = !item.endpoint.enabled;
+        item.label = `${item.endpoint.enabled ? "[x]" : "[ ]"} ${item.endpoint.label}`;
+        return true;
+      }
+      return false;
+    },
+    renderRow: (item, focused, _isActive) => {
+      const prefix = focused ? selectColors.orange("\u276F ") : "  ";
+      if (item.key === "hdr") {
+        return selectColors.bold(item.label);
+      }
+      if (item.detail) {
+        return `${prefix}${item.label}
+     ${selectColors.dim(item.detail)}`;
+      }
+      return `${prefix}${item.label}`;
+    }
+  });
+  if (!result.confirmed)
+    return false;
+  if (result.key === "next") {
+    const anyEnabled = config.endpoints.some((e) => e.enabled);
+    if (!anyEnabled) {
+      renderWarning("Select at least one endpoint before continuing.");
+      return stepEndpoints(config, ollamaUrl, rl, availableRows);
+    }
+    return true;
+  }
+  if (result.key && result.key !== "add_custom") {
+    const ep = config.endpoints.find((e) => e.url === result.key);
+    if (ep) {
+      ep.enabled = !ep.enabled;
+      return stepEndpoints(config, ollamaUrl, rl, availableRows);
+    }
+  }
+  if (result.key === "add_custom") {
+    renderInfo("Custom endpoint support coming soon. Use /endpoint to configure external APIs.");
+    return stepEndpoints(config, ollamaUrl, rl, availableRows);
+  }
+  return false;
+}
+async function stepBanner(config, rl, availableRows) {
+  const items = [
+    { key: "hdr", label: "Select Banner Animation" }
+  ];
+  for (const preset of ANIM_PRESETS) {
+    items.push({
+      key: preset.id,
+      label: `${config.banner.preset === preset.id ? "(\u25CF)" : "( )"} ${preset.name}`,
+      detail: preset.desc
+    });
+  }
+  items.push({ key: "sep", label: "" });
+  items.push({ key: "next", label: selectColors.green("  Next Step  \u2192") });
+  const result = await tuiSelect({
+    items,
+    title: "Step 2/5 \u2014 Banner Animation",
+    rl,
+    skipKeys: ["hdr", "sep"],
+    availableRows,
+    onAction: (item, action) => {
+      if (action === "space" && ANIM_PRESETS.some((p) => p.id === item.key)) {
+        config.banner.preset = item.key;
+        for (const it of items) {
+          const p = ANIM_PRESETS.find((pr) => pr.id === it.key);
+          if (p) {
+            it.label = `${config.banner.preset === p.id ? "(\u25CF)" : "( )"} ${p.name}`;
+          }
+        }
+        return true;
+      }
+      return false;
+    }
+  });
+  if (!result.confirmed)
+    return false;
+  if (result.key === "next")
+    return true;
+  if (ANIM_PRESETS.some((p) => p.id === result.key)) {
+    config.banner.preset = result.key;
+    return true;
+  }
+  return false;
+}
+async function stepHeader(config, rl, availableRows) {
+  const items = [
+    { key: "hdr", label: "Header Content" },
+    {
+      key: "message_toggle",
+      label: `${config.header.messageEnabled ? "[x]" : "[ ]"} Header Message`,
+      detail: config.header.message || "(none set)"
+    },
+    {
+      key: "link_toggle",
+      label: `${config.header.linkEnabled ? "[x]" : "[ ]"} Link`,
+      detail: config.header.linkUrl ? `${config.header.linkUrl}  [${config.header.linkText || "link"}]` : "(none set)"
+    },
+    { key: "sep", label: "" },
+    { key: "next", label: selectColors.green("  Next Step  \u2192") }
+  ];
+  const result = await tuiSelect({
+    items,
+    title: "Step 3/5 \u2014 Header Text & Links",
+    rl,
+    skipKeys: ["hdr", "sep"],
+    availableRows,
+    onAction: (item, action) => {
+      if (action === "space") {
+        if (item.key === "message_toggle") {
+          config.header.messageEnabled = !config.header.messageEnabled;
+          item.label = `${config.header.messageEnabled ? "[x]" : "[ ]"} Header Message`;
+          return true;
+        }
+        if (item.key === "link_toggle") {
+          config.header.linkEnabled = !config.header.linkEnabled;
+          item.label = `${config.header.linkEnabled ? "[x]" : "[ ]"} Link`;
+          return true;
+        }
+      }
+      return false;
+    }
+  });
+  if (!result.confirmed)
+    return false;
+  if (result.key === "next")
+    return true;
+  if (result.key === "message_toggle") {
+    config.header.messageEnabled = true;
+    const msg = await promptLine(rl, "Header message: ");
+    if (msg)
+      config.header.message = msg.slice(0, 80);
+    return stepHeader(config, rl, availableRows);
+  }
+  if (result.key === "link_toggle") {
+    config.header.linkEnabled = true;
+    const url = await promptLine(rl, "Link URL: ");
+    if (url) {
+      config.header.linkUrl = url;
+      const text = await promptLine(rl, "Link text: ");
+      if (text)
+        config.header.linkText = text;
+    }
+    return stepHeader(config, rl, availableRows);
+  }
+  return false;
+}
+async function stepTransport(config, rl, availableRows) {
+  const items = [
+    { key: "hdr_transport", label: "Network Transport" },
+    {
+      key: "cf_toggle",
+      label: `${config.transport.cloudflared ? "[x]" : "[ ]"} Cloudflared Tunnel (HTTPS)`,
+      detail: "Public URL via trycloudflare.com"
+    },
+    {
+      key: "p2p_toggle",
+      label: `${config.transport.libp2p ? "[x]" : "[ ]"} libp2p P2P Mesh`,
+      detail: "Decentralized, no central relay"
+    },
+    { key: "hdr_limits", label: "Rate Limits" },
+    {
+      key: "rpm",
+      label: `  Max requests/min:     ${config.rateLimits.maxRequestsPerMinute}`
+    },
+    {
+      key: "tpd",
+      label: `  Max tokens/day:       ${config.rateLimits.maxTokensPerDay.toLocaleString()}`
+    },
+    {
+      key: "conc",
+      label: `  Max concurrent:       ${config.rateLimits.maxConcurrent}`
+    },
+    { key: "sep", label: "" },
+    { key: "next", label: selectColors.green("  Next Step  \u2192") }
+  ];
+  const result = await tuiSelect({
+    items,
+    title: "Step 4/5 \u2014 Transport & Rate Limits",
+    rl,
+    skipKeys: ["hdr_transport", "hdr_limits", "sep"],
+    availableRows,
+    onAction: (item, action) => {
+      if (action === "space") {
+        if (item.key === "cf_toggle") {
+          config.transport.cloudflared = !config.transport.cloudflared;
+          item.label = `${config.transport.cloudflared ? "[x]" : "[ ]"} Cloudflared Tunnel (HTTPS)`;
+          return true;
+        }
+        if (item.key === "p2p_toggle") {
+          config.transport.libp2p = !config.transport.libp2p;
+          item.label = `${config.transport.libp2p ? "[x]" : "[ ]"} libp2p P2P Mesh`;
+          return true;
+        }
+      }
+      return false;
+    }
+  });
+  if (!result.confirmed)
+    return false;
+  if (result.key === "next") {
+    if (!config.transport.cloudflared && !config.transport.libp2p) {
+      renderWarning("At least one transport must be enabled.");
+      return stepTransport(config, rl, availableRows);
+    }
+    return true;
+  }
+  if (result.key === "rpm") {
+    const val = await promptLine(rl, "Max requests per minute: ");
+    const n = parseInt(val, 10);
+    if (!isNaN(n) && n > 0)
+      config.rateLimits.maxRequestsPerMinute = n;
+    return stepTransport(config, rl, availableRows);
+  }
+  if (result.key === "tpd") {
+    const val = await promptLine(rl, "Max tokens per day: ");
+    const n = parseInt(val, 10);
+    if (!isNaN(n) && n > 0)
+      config.rateLimits.maxTokensPerDay = n;
+    return stepTransport(config, rl, availableRows);
+  }
+  if (result.key === "conc") {
+    const val = await promptLine(rl, "Max concurrent requests: ");
+    const n = parseInt(val, 10);
+    if (!isNaN(n) && n > 0)
+      config.rateLimits.maxConcurrent = n;
+    return stepTransport(config, rl, availableRows);
+  }
+  return false;
+}
+async function stepReview(config, rl, availableRows) {
+  const enabledEps = config.endpoints.filter((e) => e.enabled);
+  const epList = enabledEps.map((e) => e.label).join(", ") || "none";
+  const transports = [];
+  if (config.transport.cloudflared)
+    transports.push("Cloudflared Tunnel");
+  if (config.transport.libp2p)
+    transports.push("libp2p P2P");
+  const items = [
+    { key: "hdr", label: "Review Sponsorship Configuration" },
+    { key: "info_ep", label: `  Endpoints: ${epList}` },
+    { key: "info_anim", label: `  Banner:    ${config.banner.preset}` },
+    { key: "info_msg", label: `  Message:   ${config.header.messageEnabled ? config.header.message || "(empty)" : "(disabled)"}` },
+    { key: "info_link", label: `  Link:      ${config.header.linkEnabled ? `${config.header.linkUrl} [${config.header.linkText}]` : "(disabled)"}` },
+    { key: "info_transport", label: `  Transport: ${transports.join(" + ")}` },
+    { key: "info_limits", label: `  Limits:    ${config.rateLimits.maxRequestsPerMinute} req/min, ${config.rateLimits.maxTokensPerDay.toLocaleString()} tokens/day` },
+    { key: "sep", label: "" },
+    { key: "go_live", label: selectColors.green("  \u2726 Go Live & Sponsor Inference  ") },
+    { key: "cancel", label: selectColors.dim("  Cancel") }
+  ];
+  const result = await tuiSelect({
+    items,
+    title: "Step 5/5 \u2014 Review & Go Live",
+    rl,
+    skipKeys: ["hdr", "sep", "info_ep", "info_anim", "info_msg", "info_link", "info_transport", "info_limits"],
+    availableRows
+  });
+  if (!result.confirmed || result.key === "cancel")
+    return false;
+  return result.key === "go_live";
+}
+async function showSponsorDashboard(config, projectDir, rl, availableRows) {
+  const isPaused = config.status === "paused";
+  const enabledEps = config.endpoints.filter((e) => e.enabled);
+  const items = [
+    { key: "hdr", label: "Sponsor Dashboard" },
+    { key: "info_status", label: `  Status: ${isPaused ? "\u25CF PAUSED" : "\u25CF ACTIVE"}` },
+    { key: "info_ep", label: `  Endpoints: ${enabledEps.map((e) => e.label).join(", ")}` },
+    { key: "info_transport", label: `  Transport: ${[config.transport.cloudflared ? "Cloudflared" : "", config.transport.libp2p ? "libp2p" : ""].filter(Boolean).join(" + ")}` },
+    { key: "info_limits", label: `  Limits: ${config.rateLimits.maxRequestsPerMinute} req/min, ${config.rateLimits.maxTokensPerDay.toLocaleString()} tokens/day` },
+    { key: "sep", label: "" },
+    { key: "modify", label: "  [Modify Settings]" },
+    { key: isPaused ? "resume" : "pause", label: isPaused ? "  [Resume Sponsorship]" : "  [Pause Sponsorship]" },
+    { key: "remove", label: selectColors.dim("  [Remove Sponsorship]") }
+  ];
+  const result = await tuiSelect({
+    items,
+    title: "Sponsor Dashboard",
+    rl,
+    skipKeys: ["hdr", "sep", "info_status", "info_ep", "info_transport", "info_limits"],
+    availableRows
+  });
+  if (!result.confirmed)
+    return "close";
+  return result.key || "close";
+}
+async function runSponsorWizard(ctx) {
+  let config = loadSponsorConfig(ctx.projectDir) || defaultConfig();
+  renderInfo("Starting sponsor onboarding wizard...\n");
+  if (!await stepEndpoints(config, ctx.ollamaUrl, ctx.rl, ctx.availableRows)) {
+    renderInfo("Sponsor wizard cancelled.");
+    return null;
+  }
+  saveSponsorConfig(ctx.projectDir, config);
+  if (!await stepBanner(config, ctx.rl, ctx.availableRows)) {
+    renderInfo("Sponsor wizard cancelled.");
+    return null;
+  }
+  saveSponsorConfig(ctx.projectDir, config);
+  if (!await stepHeader(config, ctx.rl, ctx.availableRows)) {
+    renderInfo("Sponsor wizard cancelled.");
+    return null;
+  }
+  saveSponsorConfig(ctx.projectDir, config);
+  if (!await stepTransport(config, ctx.rl, ctx.availableRows)) {
+    renderInfo("Sponsor wizard cancelled.");
+    return null;
+  }
+  saveSponsorConfig(ctx.projectDir, config);
+  if (!await stepReview(config, ctx.rl, ctx.availableRows)) {
+    renderInfo("Sponsor wizard cancelled.");
+    return null;
+  }
+  config.status = "active";
+  saveSponsorConfig(ctx.projectDir, config);
+  if (ctx.onGoLive) {
+    await ctx.onGoLive(config);
+  }
+  renderInfo("\u2726 Sponsorship active!");
+  renderInfo("Toggle: /sponsor status | Pause: /sponsor pause | Remove: /sponsor remove");
+  return config;
+}
+function promptLine(rl, prompt) {
+  return new Promise((resolve35) => {
+    process.stdout.write(prompt);
+    const handler = (line) => {
+      rl.removeListener("line", handler);
+      resolve35(line.trim());
+    };
+    rl.on("line", handler);
+  });
+}
+var ANIM_PRESETS;
+var init_sponsor_wizard = __esm({
+  "packages/cli/dist/tui/sponsor-wizard.js"() {
+    "use strict";
+    init_tui_select();
+    init_render();
+    ANIM_PRESETS = [
+      { id: "wave", name: "Wave", desc: "Flowing wave pattern" },
+      { id: "pulse", name: "Pulse", desc: "Pulsing dots" },
+      { id: "matrix", name: "Matrix", desc: "Falling characters" },
+      { id: "sparkle", name: "Sparkle", desc: "Random sparkle effect" },
+      { id: "radar", name: "Radar", desc: "Rotating radar sweep" },
+      { id: "circuit", name: "Circuit", desc: "Circuit board traces" },
+      { id: "none", name: "No Animation", desc: "Static banner only" }
+    ];
+  }
+});
+
 // packages/cli/dist/tui/voice.js
 var voice_exports = {};
 __export(voice_exports, {
@@ -42337,8 +42848,8 @@ __export(voice_exports, {
   registerCustomOnnxModel: () => registerCustomOnnxModel,
   resetNarrationContext: () => resetNarrationContext
 });
-import { existsSync as existsSync40, mkdirSync as mkdirSync16, writeFileSync as writeFileSync17, readFileSync as readFileSync29, unlinkSync as unlinkSync9, readdirSync as readdirSync11, renameSync, statSync as statSync13 } from "node:fs";
-import { join as join56, dirname as dirname18 } from "node:path";
+import { existsSync as existsSync41, mkdirSync as mkdirSync17, writeFileSync as writeFileSync18, readFileSync as readFileSync30, unlinkSync as unlinkSync9, readdirSync as readdirSync11, renameSync, statSync as statSync13 } from "node:fs";
+import { join as join57, dirname as dirname18 } from "node:path";
 import { homedir as homedir13, tmpdir as tmpdir9, platform as platform3 } from "node:os";
 import { execSync as execSync29, spawn as nodeSpawn } from "node:child_process";
 import { createRequire } from "node:module";
@@ -42363,40 +42874,40 @@ function listVoiceModels() {
   }));
 }
 function voiceDir() {
-  return join56(homedir13(), ".open-agents", "voice");
+  return join57(homedir13(), ".open-agents", "voice");
 }
 function modelsDir() {
-  return join56(voiceDir(), "models");
+  return join57(voiceDir(), "models");
 }
 function modelDir(id) {
-  return join56(modelsDir(), id);
+  return join57(modelsDir(), id);
 }
 function modelOnnxPath(id) {
-  return join56(modelDir(id), "model.onnx");
+  return join57(modelDir(id), "model.onnx");
 }
 function modelConfigPath(id) {
-  return join56(modelDir(id), "config.json");
+  return join57(modelDir(id), "config.json");
 }
 function luxttsVenvDir() {
-  return join56(voiceDir(), "luxtts-venv");
+  return join57(voiceDir(), "luxtts-venv");
 }
 function luxttsVenvPy() {
-  return platform3() === "win32" ? join56(luxttsVenvDir(), "Scripts", "python.exe") : join56(luxttsVenvDir(), "bin", "python3");
+  return platform3() === "win32" ? join57(luxttsVenvDir(), "Scripts", "python.exe") : join57(luxttsVenvDir(), "bin", "python3");
 }
 function luxttsRepoDir() {
-  return join56(voiceDir(), "LuxTTS");
+  return join57(voiceDir(), "LuxTTS");
 }
 function luxttsCloneRefsDir() {
-  return join56(voiceDir(), "clone-refs");
+  return join57(voiceDir(), "clone-refs");
 }
 function luxttsInferScript() {
-  return join56(voiceDir(), "luxtts-infer.py");
+  return join57(voiceDir(), "luxtts-infer.py");
 }
 function writeDetectTorchScript(targetPath) {
-  if (existsSync40(targetPath))
+  if (existsSync41(targetPath))
     return;
   try {
-    mkdirSync16(dirname18(targetPath), { recursive: true });
+    mkdirSync17(dirname18(targetPath), { recursive: true });
   } catch {
   }
   const script = `#!/usr/bin/env python3
@@ -42469,7 +42980,7 @@ def main():
 if __name__ == "__main__": main()
 `;
   try {
-    writeFileSync17(targetPath, script, { mode: 493 });
+    writeFileSync18(targetPath, script, { mode: 493 });
   } catch {
   }
 }
@@ -43279,8 +43790,8 @@ var init_voice = __esm({
         const refsDir = luxttsCloneRefsDir();
         const targets = ["glados", "overwatch"];
         for (const modelId of targets) {
-          const refFile = join56(refsDir, `${modelId}-ref.wav`);
-          if (existsSync40(refFile))
+          const refFile = join57(refsDir, `${modelId}-ref.wav`);
+          if (existsSync41(refFile))
             continue;
           try {
             await this.generateCloneRef(modelId);
@@ -43359,24 +43870,24 @@ var init_voice = __esm({
         }
         p = p.replace(/\\ /g, " ");
         if (p.startsWith("~/") || p === "~") {
-          p = join56(homedir13(), p.slice(1));
+          p = join57(homedir13(), p.slice(1));
         }
-        if (!existsSync40(p)) {
+        if (!existsSync41(p)) {
           return `File not found: ${p}
   (original input: ${audioPath})`;
         }
         audioPath = p;
         const refsDir = luxttsCloneRefsDir();
-        if (!existsSync40(refsDir))
-          mkdirSync16(refsDir, { recursive: true });
+        if (!existsSync41(refsDir))
+          mkdirSync17(refsDir, { recursive: true });
         const ext = audioPath.split(".").pop() || "wav";
         const srcName = (audioPath.split("/").pop() ?? "clone").replace(/\.[^.]+$/, "").replace(/[^a-zA-Z0-9_-]/g, "-");
         const ts = Date.now().toString(36);
         const destFilename = `clone-${srcName}-${ts}.${ext}`;
-        const destPath = join56(refsDir, destFilename);
+        const destPath = join57(refsDir, destFilename);
         try {
-          const data = readFileSync29(audioPath);
-          writeFileSync17(destPath, data);
+          const data = readFileSync30(audioPath);
+          writeFileSync18(destPath, data);
         } catch (err) {
           return `Failed to copy audio file: ${err instanceof Error ? err.message : String(err)}`;
         }
@@ -43416,9 +43927,9 @@ var init_voice = __esm({
             return `Failed to synthesize reference audio from ${source.label}.`;
           }
           const refsDir = luxttsCloneRefsDir();
-          if (!existsSync40(refsDir))
-            mkdirSync16(refsDir, { recursive: true });
-          const destPath = join56(refsDir, `${sourceModelId}-ref.wav`);
+          if (!existsSync41(refsDir))
+            mkdirSync17(refsDir, { recursive: true });
+          const destPath = join57(refsDir, `${sourceModelId}-ref.wav`);
           const sampleRate = this.config?.audio?.sample_rate ?? 22050;
           this.writeWav(audioData, sampleRate, destPath);
           this.luxttsCloneRef = destPath;
@@ -43434,23 +43945,23 @@ var init_voice = __esm({
       // -------------------------------------------------------------------------
       /** Metadata file for friendly names of clone refs */
       static cloneMetaFile() {
-        return join56(luxttsCloneRefsDir(), "meta.json");
+        return join57(luxttsCloneRefsDir(), "meta.json");
       }
       loadCloneMeta() {
         const p = _VoiceEngine.cloneMetaFile();
-        if (!existsSync40(p))
+        if (!existsSync41(p))
           return {};
         try {
-          return JSON.parse(readFileSync29(p, "utf8"));
+          return JSON.parse(readFileSync30(p, "utf8"));
         } catch {
           return {};
         }
       }
       saveCloneMeta(meta) {
         const dir = luxttsCloneRefsDir();
-        if (!existsSync40(dir))
-          mkdirSync16(dir, { recursive: true });
-        writeFileSync17(_VoiceEngine.cloneMetaFile(), JSON.stringify(meta, null, 2));
+        if (!existsSync41(dir))
+          mkdirSync17(dir, { recursive: true });
+        writeFileSync18(_VoiceEngine.cloneMetaFile(), JSON.stringify(meta, null, 2));
       }
       /** Audio file extensions recognized as clone references */
       static AUDIO_EXTS = /* @__PURE__ */ new Set(["wav", "mp3", "ogg", "flac", "m4a", "opus", "aac"]);
@@ -43460,7 +43971,7 @@ var init_voice = __esm({
        */
       listCloneRefs() {
         const dir = luxttsCloneRefsDir();
-        if (!existsSync40(dir))
+        if (!existsSync41(dir))
           return [];
         const meta = this.loadCloneMeta();
         const files = readdirSync11(dir).filter((f) => {
@@ -43468,7 +43979,7 @@ var init_voice = __esm({
           return _VoiceEngine.AUDIO_EXTS.has(ext);
         });
         return files.map((f) => {
-          const p = join56(dir, f);
+          const p = join57(dir, f);
           let size = 0;
           try {
             size = statSync13(p).size;
@@ -43485,8 +43996,8 @@ var init_voice = __esm({
       }
       /** Delete a clone reference file by filename. Returns true if deleted. */
       deleteCloneRef(filename) {
-        const p = join56(luxttsCloneRefsDir(), filename);
-        if (!existsSync40(p))
+        const p = join57(luxttsCloneRefsDir(), filename);
+        if (!existsSync41(p))
           return false;
         try {
           unlinkSync9(p);
@@ -43510,8 +44021,8 @@ var init_voice = __esm({
       }
       /** Set the active clone reference by filename. */
       setActiveCloneRef(filename) {
-        const p = join56(luxttsCloneRefsDir(), filename);
-        if (!existsSync40(p))
+        const p = join57(luxttsCloneRefsDir(), filename);
+        if (!existsSync41(p))
           return `File not found: ${filename}`;
         this.luxttsCloneRef = p;
         return `Active clone voice set to: ${filename}`;
@@ -43836,7 +44347,7 @@ var init_voice = __esm({
           }
           this.onPCMOutput(Buffer.from(int16.buffer), sampleRate);
         }
-        const wavPath = join56(tmpdir9(), `oa-voice-${Date.now()}.wav`);
+        const wavPath = join57(tmpdir9(), `oa-voice-${Date.now()}.wav`);
         this.writeStereoWav(stereo.left, stereo.right, sampleRate, wavPath);
         await this.playWav(wavPath);
         try {
@@ -43953,7 +44464,7 @@ var init_voice = __esm({
           buffer.writeInt16LE(rSample < 0 ? rSample * 32768 : rSample * 32767, pos);
           pos += 2;
         }
-        writeFileSync17(path, buffer);
+        writeFileSync18(path, buffer);
       }
       // -------------------------------------------------------------------------
       // Phonemization
@@ -44031,7 +44542,7 @@ var init_voice = __esm({
         return buffer;
       }
       writeWav(samples, sampleRate, path) {
-        writeFileSync17(path, this.buildWavBuffer(samples, sampleRate));
+        writeFileSync18(path, this.buildWavBuffer(samples, sampleRate));
       }
       // -------------------------------------------------------------------------
       // Audio playback (system default speakers)
@@ -44229,7 +44740,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
         const mlxModelId = model.mlxModelId ?? "mlx-community/Kokoro-82M-bf16";
         const mlxVoice = model.mlxVoice ?? "af_heart";
         const mlxLangCode = model.mlxLangCode ?? "a";
-        const wavPath = join56(tmpdir9(), `oa-mlx-${Date.now()}.wav`);
+        const wavPath = join57(tmpdir9(), `oa-mlx-${Date.now()}.wav`);
         const pyScript = [
           "import sys, json",
           "from mlx_audio.tts import generate as tts_gen",
@@ -44246,11 +44757,11 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
             return;
           }
         }
-        if (!existsSync40(wavPath))
+        if (!existsSync41(wavPath))
           return;
         if (volume !== 1) {
           try {
-            const wavData = readFileSync29(wavPath);
+            const wavData = readFileSync30(wavPath);
             if (wavData.length > 44) {
               const header = wavData.subarray(0, 44);
               const samples = new Int16Array(wavData.buffer, wavData.byteOffset + 44, (wavData.length - 44) / 2);
@@ -44258,14 +44769,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)]);
-              writeFileSync17(wavPath, scaled);
+              writeFileSync18(wavPath, scaled);
             }
           } catch {
           }
         }
         if (this.onPCMOutput) {
           try {
-            const wavData = readFileSync29(wavPath);
+            const wavData = readFileSync30(wavPath);
             if (wavData.length > 44) {
               const pcm = Buffer.from(wavData.buffer, wavData.byteOffset + 44, wavData.length - 44);
               const sampleRate = wavData.readUInt32LE(24);
@@ -44297,7 +44808,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
         const mlxModelId = model.mlxModelId ?? "mlx-community/Kokoro-82M-bf16";
         const mlxVoice = model.mlxVoice ?? "af_heart";
         const mlxLangCode = model.mlxLangCode ?? "a";
-        const wavPath = join56(tmpdir9(), `oa-mlx-buf-${Date.now()}.wav`);
+        const wavPath = join57(tmpdir9(), `oa-mlx-buf-${Date.now()}.wav`);
         const pyScript = [
           "import sys, json",
           "from mlx_audio.tts import generate as tts_gen",
@@ -44314,10 +44825,10 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
             return null;
           }
         }
-        if (!existsSync40(wavPath))
+        if (!existsSync41(wavPath))
           return null;
         try {
-          const data = readFileSync29(wavPath);
+          const data = readFileSync30(wavPath);
           unlinkSync9(wavPath);
           return data;
         } catch {
@@ -44340,7 +44851,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
         }
         const venvDir = luxttsVenvDir();
         const venvPy = luxttsVenvPy();
-        if (existsSync40(venvPy)) {
+        if (existsSync41(venvPy)) {
           try {
             await this.asyncShell(`${venvPy} -c "import sys; sys.path.insert(0, '${luxttsRepoDir()}'); from zipvoice.luxvoice import LuxTTS; print('ok')"`, 3e4);
             let hasCudaSys = false;
@@ -44354,7 +44865,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
                 if (torchCheck === "cpu") {
                   renderWarning("GPU detected but PyTorch is CPU-only. Reinstalling with CUDA support in background...");
                   try {
-                    const detectScript = join56(voiceDir(), "detect-torch.py");
+                    const detectScript = join57(voiceDir(), "detect-torch.py");
                     writeDetectTorchScript(detectScript);
                     let pipArgs = `torch torchaudio --index-url https://download.pytorch.org/whl/cu124`;
                     try {
@@ -44379,7 +44890,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
           }
         }
         renderInfo("Setting up LuxTTS voice cloning (first-time setup, this takes several minutes)...");
-        if (!existsSync40(venvDir)) {
+        if (!existsSync41(venvDir)) {
           renderInfo("  Creating Python virtual environment...");
           try {
             await this.asyncShell(`${py} -m venv ${JSON.stringify(venvDir)}`, 6e4);
@@ -44388,7 +44899,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
           }
         }
         {
-          const detectScript = join56(voiceDir(), "detect-torch.py");
+          const detectScript = join57(voiceDir(), "detect-torch.py");
           writeDetectTorchScript(detectScript);
           let pipArgsStr = "torch torchaudio";
           let torchDesc = "unknown platform";
@@ -44425,10 +44936,10 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
           }
         }
         const repoDir = luxttsRepoDir();
-        if (!existsSync40(join56(repoDir, "zipvoice", "luxvoice.py"))) {
+        if (!existsSync41(join57(repoDir, "zipvoice", "luxvoice.py"))) {
           renderInfo("  Cloning LuxTTS repository...");
           try {
-            if (existsSync40(repoDir)) {
+            if (existsSync41(repoDir)) {
               const rmCmd = process.platform === "win32" ? `rmdir /s /q ${JSON.stringify(repoDir)}` : `rm -rf ${JSON.stringify(repoDir)}`;
               await this.asyncShell(rmCmd, 3e4);
             }
@@ -44467,7 +44978,7 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
             renderWarning(`  Could not install system build deps: ${err instanceof Error ? err.message : String(err)}`);
           }
         }
-        const isJetson = isArm && (existsSync40("/etc/nv_tegra_release") || existsSync40("/usr/local/cuda/targets/aarch64-linux") || (process.env.JETSON_L4T_VERSION ?? "") !== "");
+        const isJetson = isArm && (existsSync41("/etc/nv_tegra_release") || existsSync41("/usr/local/cuda/targets/aarch64-linux") || (process.env.JETSON_L4T_VERSION ?? "") !== "");
         const installSteps = isArm ? [
           // ARM: install individually so we get clear error messages per package.
           // ALL are fatal because LuxTTS hard-imports them (no lazy/optional imports).
@@ -44535,14 +45046,14 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
       }
       /** Auto-detect an existing clone reference in the refs directory */
       autoDetectCloneRef() {
-        if (this.luxttsCloneRef && existsSync40(this.luxttsCloneRef))
+        if (this.luxttsCloneRef && existsSync41(this.luxttsCloneRef))
           return;
         const refsDir = luxttsCloneRefsDir();
-        if (!existsSync40(refsDir))
+        if (!existsSync41(refsDir))
           return;
         for (const name of ["custom-clone.wav", "custom-clone.mp3", "glados-ref.wav", "overwatch-ref.wav"]) {
-          const p = join56(refsDir, name);
-          if (existsSync40(p)) {
+          const p = join57(refsDir, name);
+          if (existsSync41(p)) {
             this.luxttsCloneRef = p;
             return;
           }
@@ -44642,15 +45153,15 @@ if __name__ == '__main__':
     main()
 `;
         const scriptPath2 = luxttsInferScript();
-        mkdirSync16(voiceDir(), { recursive: true });
-        writeFileSync17(scriptPath2, script);
+        mkdirSync17(voiceDir(), { recursive: true });
+        writeFileSync18(scriptPath2, script);
       }
       /** Ensure the LuxTTS daemon is running, spawn if needed */
       async ensureLuxttsDaemon() {
         if (this._luxttsDaemon && !this._luxttsDaemon.killed)
           return true;
         const venvPy = luxttsVenvPy();
-        if (!existsSync40(venvPy))
+        if (!existsSync41(venvPy))
           return false;
         return new Promise((resolve35) => {
           const env = { ...process.env, LUXTTS_REPO_PATH: luxttsRepoDir() };
@@ -44734,7 +45245,7 @@ if __name__ == '__main__':
        * Used by drainQueue's pre-fetch pipeline for gapless back-to-back playback.
        */
       async synthesizeLuxttsWav(text, speedFactor = 1) {
-        if (!this.luxttsCloneRef || !existsSync40(this.luxttsCloneRef))
+        if (!this.luxttsCloneRef || !existsSync41(this.luxttsCloneRef))
           return null;
         const cleaned = text.replace(/\*/g, "").trim();
         if (!cleaned)
@@ -44742,7 +45253,7 @@ if __name__ == '__main__':
         const ready = await this.ensureLuxttsDaemon();
         if (!ready)
           return null;
-        const wavPath = join56(tmpdir9(), `oa-luxtts-${Date.now()}-${Math.random().toString(36).slice(2, 6)}.wav`);
+        const wavPath = join57(tmpdir9(), `oa-luxtts-${Date.now()}-${Math.random().toString(36).slice(2, 6)}.wav`);
         try {
           await this.luxttsRequest({
             action: "synthesize",
@@ -44754,17 +45265,17 @@ if __name__ == '__main__':
         } catch {
           return null;
         }
-        return existsSync40(wavPath) ? wavPath : null;
+        return existsSync41(wavPath) ? wavPath : null;
       }
       /**
        * Post-process (fade-in, volume, pitch, stereo) and play a LuxTTS WAV file.
        * Cleans up the WAV file after playback.
        */
       async postProcessAndPlayLuxtts(wavPath, volume = 1, pitchFactor = 1, stereoDelayMs = 0.6) {
-        if (!existsSync40(wavPath))
+        if (!existsSync41(wavPath))
           return;
         try {
-          const wavData = readFileSync29(wavPath);
+          const wavData = readFileSync30(wavPath);
           if (wavData.length > 44) {
             const sampleRate = wavData.readUInt32LE(24);
             const samples = new Int16Array(wavData.buffer, wavData.byteOffset + 44, (wavData.length - 44) / 2);
@@ -44779,13 +45290,13 @@ if __name__ == '__main__':
             }
             const header = wavData.subarray(0, 44);
             const scaled = Buffer.concat([header, Buffer.from(samples.buffer, samples.byteOffset, samples.byteLength)]);
-            writeFileSync17(wavPath, scaled);
+            writeFileSync18(wavPath, scaled);
           }
         } catch {
         }
         if (pitchFactor !== 1) {
           try {
-            const wavData = readFileSync29(wavPath);
+            const wavData = readFileSync30(wavPath);
             if (wavData.length > 44) {
               const int16 = new Int16Array(wavData.buffer, wavData.byteOffset + 44, (wavData.length - 44) / 2);
               const float32 = new Float32Array(int16.length);
@@ -44800,7 +45311,7 @@ if __name__ == '__main__':
         }
         if (this.onPCMOutput) {
           try {
-            const wavData = readFileSync29(wavPath);
+            const wavData = readFileSync30(wavPath);
             if (wavData.length > 44) {
               const pcm = Buffer.from(wavData.buffer, wavData.byteOffset + 44, wavData.length - 44);
               const sampleRate = wavData.readUInt32LE(24);
@@ -44811,7 +45322,7 @@ if __name__ == '__main__':
         }
         if (stereoDelayMs > 0) {
           try {
-            const wavData = readFileSync29(wavPath);
+            const wavData = readFileSync30(wavPath);
             if (wavData.length > 44) {
               const sampleRate = wavData.readUInt32LE(24);
               const numChannels = wavData.readUInt16LE(22);
@@ -44847,7 +45358,7 @@ if __name__ == '__main__':
        * Used for Telegram voice messages and WebSocket streaming.
        */
       async synthesizeLuxttsToBuffer(text) {
-        if (!this.luxttsCloneRef || !existsSync40(this.luxttsCloneRef))
+        if (!this.luxttsCloneRef || !existsSync41(this.luxttsCloneRef))
           return null;
         const cleaned = text.replace(/\*/g, "").trim();
         if (!cleaned)
@@ -44855,7 +45366,7 @@ if __name__ == '__main__':
         const ready = await this.ensureLuxttsDaemon();
         if (!ready)
           return null;
-        const wavPath = join56(tmpdir9(), `oa-luxtts-buf-${Date.now()}.wav`);
+        const wavPath = join57(tmpdir9(), `oa-luxtts-buf-${Date.now()}.wav`);
         try {
           await this.luxttsRequest({
             action: "synthesize",
@@ -44867,10 +45378,10 @@ if __name__ == '__main__':
         } catch {
           return null;
         }
-        if (!existsSync40(wavPath))
+        if (!existsSync41(wavPath))
           return null;
         try {
-          const data = readFileSync29(wavPath);
+          const data = readFileSync30(wavPath);
           unlinkSync9(wavPath);
           return data;
         } catch {
@@ -44884,40 +45395,40 @@ if __name__ == '__main__':
         if (this.ort)
           return;
         const arch2 = process.arch;
-        mkdirSync16(voiceDir(), { recursive: true });
-        const pkgPath = join56(voiceDir(), "package.json");
+        mkdirSync17(voiceDir(), { recursive: true });
+        const pkgPath = join57(voiceDir(), "package.json");
         const expectedDeps = {
           "onnxruntime-node": "^1.21.0",
           "phonemizer": "^1.2.1"
         };
-        if (existsSync40(pkgPath)) {
+        if (existsSync41(pkgPath)) {
           try {
-            const existing = JSON.parse(readFileSync29(pkgPath, "utf8"));
+            const existing = JSON.parse(readFileSync30(pkgPath, "utf8"));
             if (!existing.dependencies?.["phonemizer"]) {
               existing.dependencies = { ...existing.dependencies, ...expectedDeps };
-              writeFileSync17(pkgPath, JSON.stringify(existing, null, 2));
+              writeFileSync18(pkgPath, JSON.stringify(existing, null, 2));
             }
           } catch {
           }
         }
-        if (!existsSync40(pkgPath)) {
-          writeFileSync17(pkgPath, JSON.stringify({
+        if (!existsSync41(pkgPath)) {
+          writeFileSync18(pkgPath, JSON.stringify({
             name: "open-agents-voice",
             private: true,
             dependencies: expectedDeps
           }, null, 2));
         }
-        const voiceRequire = createRequire(join56(voiceDir(), "index.js"));
+        const voiceRequire = createRequire(join57(voiceDir(), "index.js"));
         const probeOnnx = async () => {
           try {
-            const output = await this.asyncShell(`NODE_PATH="${join56(voiceDir(), "node_modules")}" node -e "try { require('onnxruntime-node'); console.log('OK'); } catch(e) { console.log('FAIL:' + e.message); }"`, 15e3);
+            const output = await this.asyncShell(`NODE_PATH="${join57(voiceDir(), "node_modules")}" node -e "try { require('onnxruntime-node'); console.log('OK'); } catch(e) { console.log('FAIL:' + e.message); }"`, 15e3);
             return output.trim() === "OK";
           } catch {
             return false;
           }
         };
-        const onnxNodeModules = join56(voiceDir(), "node_modules", "onnxruntime-node");
-        const onnxInstalled = existsSync40(onnxNodeModules);
+        const onnxNodeModules = join57(voiceDir(), "node_modules", "onnxruntime-node");
+        const onnxInstalled = existsSync41(onnxNodeModules);
         if (onnxInstalled && !await probeOnnx()) {
           throw new Error(`Voice synthesis unavailable: ONNX runtime crashes on this CPU (${process.platform}-${arch2}). 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.`);
         }
@@ -44966,19 +45477,19 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
           throw new Error(`Unknown model: ${id}`);
         const dir = modelDir(id);
         const onnxPath = modelOnnxPath(id);
-        const configPath = modelConfigPath(id);
-        if (existsSync40(onnxPath) && existsSync40(configPath))
+        const configPath2 = modelConfigPath(id);
+        if (existsSync41(onnxPath) && existsSync41(configPath2))
           return;
-        mkdirSync16(dir, { recursive: true });
-        if (!existsSync40(configPath)) {
+        mkdirSync17(dir, { recursive: true });
+        if (!existsSync41(configPath2)) {
           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();
-          writeFileSync17(configPath, configText);
+          writeFileSync18(configPath2, configText);
         }
-        if (!existsSync40(onnxPath)) {
+        if (!existsSync41(onnxPath)) {
           renderInfo(`Downloading ${model.label} voice model (this may take a minute)...`);
           const onnxResp = await fetch(model.onnxUrl);
           if (!onnxResp.ok)
@@ -45003,7 +45514,7 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
             }
           }
           const fullBuffer = Buffer.concat(chunks);
-          writeFileSync17(onnxPath, fullBuffer);
+          writeFileSync18(onnxPath, fullBuffer);
           renderInfo(`${model.label} model downloaded (${formatBytes2(fullBuffer.length)}).`);
         }
       }
@@ -45014,11 +45525,11 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
         if (!this.ort)
           throw new Error("ONNX runtime not loaded");
         const onnxPath = modelOnnxPath(this.modelId);
-        const configPath = modelConfigPath(this.modelId);
-        if (!existsSync40(onnxPath) || !existsSync40(configPath)) {
+        const configPath2 = modelConfigPath(this.modelId);
+        if (!existsSync41(onnxPath) || !existsSync41(configPath2)) {
           throw new Error(`Model files not found for ${this.modelId}`);
         }
-        this.config = JSON.parse(readFileSync29(configPath, "utf8"));
+        this.config = JSON.parse(readFileSync30(configPath2, "utf8"));
         this.session = await this.ort.InferenceSession.create(onnxPath, {
           executionProviders: ["cpu"],
           graphOptimizationLevel: "all"
@@ -45045,8 +45556,8 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
 // packages/cli/dist/tui/commands.js
 import * as nodeOs from "node:os";
 import { execSync as nodeExecSync } from "node:child_process";
-import { existsSync as existsSync41, readFileSync as readFileSync30, writeFileSync as writeFileSync18, mkdirSync as mkdirSync17, readdirSync as readdirSync12, statSync as statSync14, rmSync } from "node:fs";
-import { join as join57 } from "node:path";
+import { existsSync as existsSync42, readFileSync as readFileSync31, writeFileSync as writeFileSync19, mkdirSync as mkdirSync18, readdirSync as readdirSync12, statSync as statSync14, rmSync } from "node:fs";
+import { join as join58 } from "node:path";
 function safeLog(text) {
   if (isNeovimActive()) {
     writeToNeovimOutput(text + "\n");
@@ -45655,22 +46166,22 @@ async function handleSlashCommand(input, ctx) {
         let content = "";
         let metadata = {};
         if (shareType === "tool") {
-          const toolDir = join57(ctx.repoRoot, ".oa", "tools");
-          const toolFile = join57(toolDir, shareName.endsWith(".json") ? shareName : `${shareName}.json`);
-          if (!existsSync41(toolFile)) {
+          const toolDir = join58(ctx.repoRoot, ".oa", "tools");
+          const toolFile = join58(toolDir, shareName.endsWith(".json") ? shareName : `${shareName}.json`);
+          if (!existsSync42(toolFile)) {
             renderWarning(`Tool not found: ${toolFile}`);
             return "handled";
           }
-          content = readFileSync30(toolFile, "utf8");
+          content = readFileSync31(toolFile, "utf8");
           metadata = { type: "tool", name: shareName };
         } else if (shareType === "skill") {
-          const skillDir = join57(ctx.repoRoot, ".oa", "skills", shareName);
-          const skillFile = join57(skillDir, "SKILL.md");
-          if (!existsSync41(skillFile)) {
+          const skillDir = join58(ctx.repoRoot, ".oa", "skills", shareName);
+          const skillFile = join58(skillDir, "SKILL.md");
+          if (!existsSync42(skillFile)) {
             renderWarning(`Skill not found: ${skillFile}`);
             return "handled";
           }
-          content = readFileSync30(skillFile, "utf8");
+          content = readFileSync31(skillFile, "utf8");
           metadata = { type: "skill", name: shareName };
         } else {
           renderWarning(`Unknown share type: ${shareType}. Use 'tool' or 'skill'.`);
@@ -45709,9 +46220,9 @@ async function handleSlashCommand(input, ctx) {
           const { NexusTool: NexusTool2 } = __require("@open-agents/execution");
           const nexus = new NexusTool2(ctx.repoRoot);
           await nexus.execute({ action: "ipfs_pin", cid: importCid, source: "import" });
-          const regFile = join57(ctx.repoRoot, ".oa", "nexus", "ipfs", "cid-registry", "learning-cids.json");
-          if (existsSync41(regFile)) {
-            const reg = JSON.parse(readFileSync30(regFile, "utf8"));
+          const regFile = join58(ctx.repoRoot, ".oa", "nexus", "ipfs", "cid-registry", "learning-cids.json");
+          if (existsSync42(regFile)) {
+            const reg = JSON.parse(readFileSync31(regFile, "utf8"));
             const pinned = Object.values(reg).some((e) => e.cid === importCid && e.pinned);
             if (pinned) {
               renderInfo(`CID ${importCid.slice(0, 20)}... pinned successfully.`);
@@ -45764,33 +46275,33 @@ async function handleSlashCommand(input, ctx) {
       lines.push(`
   ${c2.bold("IPFS / Helia Status")}
 `);
-      const ipfsDir = join57(ctx.repoRoot, ".oa", "ipfs");
-      const ipfsLocalDir = join57(ipfsDir, "local");
+      const ipfsDir = join58(ctx.repoRoot, ".oa", "ipfs");
+      const ipfsLocalDir = join58(ipfsDir, "local");
       let ipfsFiles = 0;
       let ipfsBytes = 0;
       let heliaBlocks = 0;
       let heliaBytes = 0;
       try {
-        if (existsSync41(ipfsLocalDir)) {
+        if (existsSync42(ipfsLocalDir)) {
           const files = readdirSync12(ipfsLocalDir).filter((f) => f.endsWith(".json"));
           ipfsFiles = files.length;
           for (const f of files) {
             try {
-              ipfsBytes += statSync14(join57(ipfsLocalDir, f)).size;
+              ipfsBytes += statSync14(join58(ipfsLocalDir, f)).size;
             } catch {
             }
           }
         }
-        const heliaBlockDir = join57(ipfsDir, "blocks");
-        if (existsSync41(heliaBlockDir)) {
+        const heliaBlockDir = join58(ipfsDir, "blocks");
+        if (existsSync42(heliaBlockDir)) {
           const walkDir = (dir) => {
             for (const entry of readdirSync12(dir, { withFileTypes: true })) {
               if (entry.isDirectory())
-                walkDir(join57(dir, entry.name));
+                walkDir(join58(dir, entry.name));
               else {
                 heliaBlocks++;
                 try {
-                  heliaBytes += statSync14(join57(dir, entry.name)).size;
+                  heliaBytes += statSync14(join58(dir, entry.name)).size;
                 } catch {
                 }
               }
@@ -45806,9 +46317,9 @@ async function handleSlashCommand(input, ctx) {
       lines.push(`    Blocks: ${c2.bold(String(heliaBlocks))}   Size: ${c2.bold(formatFileSize(heliaBytes))}`);
       lines.push(`    Backend: ${heliaBlocks > 0 ? c2.green("helia-ipfs") : c2.yellow("sha256-local (Helia not initialized)")}`);
       try {
-        const statusFile = join57(ctx.repoRoot, ".oa", "nexus", "status.json");
-        if (existsSync41(statusFile)) {
-          const status = JSON.parse(readFileSync30(statusFile, "utf8"));
+        const statusFile = join58(ctx.repoRoot, ".oa", "nexus", "status.json");
+        if (existsSync42(statusFile)) {
+          const status = JSON.parse(readFileSync31(statusFile, "utf8"));
           if (status.peerId) {
             lines.push(`
   ${c2.bold("Peer Info")}`);
@@ -45827,11 +46338,11 @@ async function handleSlashCommand(input, ctx) {
   ${c2.dim("Commands: /ipfs pin <CID>  /ipfs publish  /ipfs cids")}`);
       lines.push(`
   ${c2.bold("Identity Kernel")}`);
-      const idDir = join57(ctx.repoRoot, ".oa", "identity");
+      const idDir = join58(ctx.repoRoot, ".oa", "identity");
       try {
-        const stateFile = join57(idDir, "self-state.json");
-        if (existsSync41(stateFile)) {
-          const state = JSON.parse(readFileSync30(stateFile, "utf8"));
+        const stateFile = join58(idDir, "self-state.json");
+        if (existsSync42(stateFile)) {
+          const state = JSON.parse(readFileSync31(stateFile, "utf8"));
           lines.push(`    Version: ${c2.bold("v" + (state.version ?? "?"))}   Sessions: ${c2.bold(String(state.session_count ?? 0))}`);
           if (state.narrative_summary) {
             lines.push(`    Narrative: ${c2.dim(state.narrative_summary.slice(0, 60))}${state.narrative_summary.length > 60 ? "..." : ""}`);
@@ -45840,9 +46351,9 @@ async function handleSlashCommand(input, ctx) {
             const traits = typeof state.personality_traits === "object" ? Object.entries(state.personality_traits).map(([k, v]) => `${k}:${v}`).join(", ") : String(state.personality_traits);
             lines.push(`    Traits: ${c2.dim(traits.slice(0, 60))}`);
           }
-          const cidFile = join57(idDir, "cids.json");
-          if (existsSync41(cidFile)) {
-            const cids = JSON.parse(readFileSync30(cidFile, "utf8"));
+          const cidFile = join58(idDir, "cids.json");
+          if (existsSync42(cidFile)) {
+            const cids = JSON.parse(readFileSync31(cidFile, "utf8"));
             const lastCid = Array.isArray(cids) ? cids[cids.length - 1] : cids.latest;
             if (lastCid)
               lines.push(`    Last CID: ${c2.dim(String(lastCid).slice(0, 50))}`);
@@ -45855,9 +46366,9 @@ async function handleSlashCommand(input, ctx) {
       lines.push(`
   ${c2.bold("Memory Sentiment")}`);
       try {
-        const metaFile = join57(ctx.repoRoot, ".oa", "memory", "metabolism", "store.json");
-        if (existsSync41(metaFile)) {
-          const store = JSON.parse(readFileSync30(metaFile, "utf8"));
+        const metaFile = join58(ctx.repoRoot, ".oa", "memory", "metabolism", "store.json");
+        if (existsSync42(metaFile)) {
+          const store = JSON.parse(readFileSync31(metaFile, "utf8"));
           const active = store.filter((m) => m.type !== "quarantine");
           const recoveries = active.filter((m) => m.content?.startsWith("[recovery]")).length;
           const strategies = active.filter((m) => m.content?.startsWith("[strategy]")).length;
@@ -45875,8 +46386,8 @@ async function handleSlashCommand(input, ctx) {
       } catch {
       }
       try {
-        const dbPath = join57(ctx.repoRoot, ".oa", "memory", "structured.db");
-        if (existsSync41(dbPath)) {
+        const dbPath = join58(ctx.repoRoot, ".oa", "memory", "structured.db");
+        if (existsSync42(dbPath)) {
           const { initDb: initDb2, closeDb: cDb, ProceduralMemoryStore: ProceduralMemoryStore2 } = __require("@open-agents/memory");
           const db = initDb2(dbPath);
           const memStore = new ProceduralMemoryStore2(db);
@@ -45897,8 +46408,8 @@ async function handleSlashCommand(input, ctx) {
       lines.push(`
   ${c2.bold("Storage Overview")}
 `);
-      const oaDir = join57(ctx.repoRoot, ".oa");
-      if (!existsSync41(oaDir)) {
+      const oaDir = join58(ctx.repoRoot, ".oa");
+      if (!existsSync42(oaDir)) {
         lines.push(`  ${c2.dim("No .oa/ directory found.")}`);
         safeLog(lines.join("\n") + "\n");
         return "handled";
@@ -45908,7 +46419,7 @@ async function handleSlashCommand(input, ctx) {
       const walkStorage = (dir, category) => {
         try {
           for (const entry of readdirSync12(dir, { withFileTypes: true })) {
-            const full = join57(dir, entry.name);
+            const full = join58(dir, entry.name);
             if (entry.isDirectory()) {
               const subCat = category || entry.name;
               walkStorage(full, subCat);
@@ -45944,10 +46455,10 @@ async function handleSlashCommand(input, ctx) {
           for (const entry of readdirSync12(dir, { withFileTypes: true })) {
             const name = entry.name.toLowerCase();
             if (sensitivePatterns.some((p) => name.includes(p))) {
-              sensitiveFound.push(join57(dir, entry.name).replace(oaDir + "/", ""));
+              sensitiveFound.push(join58(dir, entry.name).replace(oaDir + "/", ""));
             }
             if (entry.isDirectory())
-              checkSensitive(join57(dir, entry.name));
+              checkSensitive(join58(dir, entry.name));
           }
         } catch {
         }
@@ -45975,8 +46486,8 @@ async function handleSlashCommand(input, ctx) {
         renderInfo("Supported: .wav .mp3 .flac .ogg (audio\u2192transcribe) | .pdf .txt .md (text\u2192chunk)");
         return "handled";
       }
-      const resolvedPath = join57(ctx.repoRoot, filePath);
-      if (!existsSync41(resolvedPath)) {
+      const resolvedPath = join58(ctx.repoRoot, filePath);
+      if (!existsSync42(resolvedPath)) {
         renderWarning(`File not found: ${resolvedPath}`);
         return "handled";
       }
@@ -45992,9 +46503,9 @@ async function handleSlashCommand(input, ctx) {
       }
       try {
         const { initDb: initDb2, closeDb: cDb, ProceduralMemoryStore: ProceduralMemoryStore2 } = __require("@open-agents/memory");
-        const dbDir = join57(ctx.repoRoot, ".oa", "memory");
-        mkdirSync17(dbDir, { recursive: true });
-        const db = initDb2(join57(dbDir, "structured.db"));
+        const dbDir = join58(ctx.repoRoot, ".oa", "memory");
+        mkdirSync18(dbDir, { recursive: true });
+        const db = initDb2(join58(dbDir, "structured.db"));
         const memStore = new ProceduralMemoryStore2(db);
         if (isAudio) {
           renderInfo(`Transcribing: ${filePath}...`);
@@ -46035,7 +46546,7 @@ async function handleSlashCommand(input, ctx) {
               return "handled";
             }
           } else {
-            content = readFileSync30(resolvedPath, "utf8");
+            content = readFileSync31(resolvedPath, "utf8");
           }
           if (!content.trim()) {
             renderWarning("No content extracted.");
@@ -46074,9 +46585,9 @@ async function handleSlashCommand(input, ctx) {
     }
     case "fortemi": {
       const fortemiSubCmd = (arg || "").trim().toLowerCase();
-      const fortemiDir = join57(ctx.repoRoot, "..", "fortemi-react");
-      const altFortemiDir = join57(nodeOs.homedir(), "fortemi-react");
-      const fDir = existsSync41(fortemiDir) ? fortemiDir : existsSync41(altFortemiDir) ? altFortemiDir : null;
+      const fortemiDir = join58(ctx.repoRoot, "..", "fortemi-react");
+      const altFortemiDir = join58(nodeOs.homedir(), "fortemi-react");
+      const fDir = existsSync42(fortemiDir) ? fortemiDir : existsSync42(altFortemiDir) ? altFortemiDir : null;
       if (fortemiSubCmd === "start" || fortemiSubCmd === "") {
         if (!fDir) {
           renderWarning("fortemi-react not found adjacent or in home directory.");
@@ -46091,14 +46602,14 @@ async function handleSlashCommand(input, ctx) {
           // 24h
           nonce: Math.random().toString(36).slice(2, 10)
         };
-        const jwtFile = join57(ctx.repoRoot, ".oa", "fortemi-jwt.json");
-        mkdirSync17(join57(ctx.repoRoot, ".oa"), { recursive: true });
-        writeFileSync18(jwtFile, JSON.stringify(jwtPayload, null, 2));
+        const jwtFile = join58(ctx.repoRoot, ".oa", "fortemi-jwt.json");
+        mkdirSync18(join58(ctx.repoRoot, ".oa"), { recursive: true });
+        writeFileSync19(jwtFile, JSON.stringify(jwtPayload, null, 2));
         renderInfo(`Launching fortemi-react from ${fDir}...`);
         try {
           const { spawn: spawn22 } = __require("node:child_process");
           const child = spawn22("npx", ["vite", "dev", "--host", "0.0.0.0", "--port", "3000"], {
-            cwd: join57(fDir, "apps", "standalone"),
+            cwd: join58(fDir, "apps", "standalone"),
             stdio: "ignore",
             detached: true,
             env: { ...process.env, OA_JWT: JSON.stringify(jwtPayload) }
@@ -46107,8 +46618,8 @@ async function handleSlashCommand(input, ctx) {
           renderInfo("Fortemi-React starting on http://localhost:3000");
           renderInfo(`JWT saved to ${jwtFile}`);
           renderInfo("Memory operations will proxy to fortemi when available.");
-          const bridgeFile = join57(ctx.repoRoot, ".oa", "fortemi-bridge.json");
-          writeFileSync18(bridgeFile, JSON.stringify({
+          const bridgeFile = join58(ctx.repoRoot, ".oa", "fortemi-bridge.json");
+          writeFileSync19(bridgeFile, JSON.stringify({
             url: "http://localhost:3000",
             pid: child.pid,
             startedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -46120,12 +46631,12 @@ async function handleSlashCommand(input, ctx) {
         return "handled";
       }
       if (fortemiSubCmd === "status") {
-        const bridgeFile = join57(ctx.repoRoot, ".oa", "fortemi-bridge.json");
-        if (!existsSync41(bridgeFile)) {
+        const bridgeFile = join58(ctx.repoRoot, ".oa", "fortemi-bridge.json");
+        if (!existsSync42(bridgeFile)) {
           renderInfo("Fortemi bridge: not connected. Run /fortemi start");
           return "handled";
         }
-        const bridge = JSON.parse(readFileSync30(bridgeFile, "utf8"));
+        const bridge = JSON.parse(readFileSync31(bridgeFile, "utf8"));
         let alive = false;
         try {
           process.kill(bridge.pid, 0);
@@ -46145,15 +46656,15 @@ async function handleSlashCommand(input, ctx) {
         lines.push(`  Process:  ${alive ? c2.green("running") : c2.yellow("not running")} (PID ${bridge.pid})`);
         lines.push(`  HTTP:     ${httpOk ? c2.green("connected") : c2.yellow("unreachable")}`);
         lines.push(`  Started:  ${bridge.startedAt}`);
-        lines.push(`  JWT:      ${existsSync41(bridge.jwtFile) ? c2.green("valid") : c2.yellow("missing")}`);
+        lines.push(`  JWT:      ${existsSync42(bridge.jwtFile) ? c2.green("valid") : c2.yellow("missing")}`);
         lines.push("");
         safeLog(lines.join("\n"));
         return "handled";
       }
       if (fortemiSubCmd === "stop") {
-        const bridgeFile = join57(ctx.repoRoot, ".oa", "fortemi-bridge.json");
-        if (existsSync41(bridgeFile)) {
-          const bridge = JSON.parse(readFileSync30(bridgeFile, "utf8"));
+        const bridgeFile = join58(ctx.repoRoot, ".oa", "fortemi-bridge.json");
+        if (existsSync42(bridgeFile)) {
+          const bridge = JSON.parse(readFileSync31(bridgeFile, "utf8"));
           try {
             process.kill(bridge.pid, "SIGTERM");
           } catch {
@@ -46531,6 +47042,86 @@ async function handleSlashCommand(input, ctx) {
       }
       return "handled";
     }
+    case "sponsor": {
+      if (!ctx.rl) {
+        renderWarning("Sponsor wizard requires interactive mode.");
+        return "handled";
+      }
+      const { loadSponsorConfig: loadSponsorConfig2, saveSponsorConfig: saveSponsorConfig2, runSponsorWizard: runSponsorWizard2, showSponsorDashboard: showSponsorDashboard2 } = await Promise.resolve().then(() => (init_sponsor_wizard(), sponsor_wizard_exports));
+      const projectDir = process.cwd();
+      const existingConfig = loadSponsorConfig2(projectDir);
+      const sponsorRl = ctx.rl;
+      if (arg === "pause" && existingConfig?.status === "active") {
+        existingConfig.status = "paused";
+        saveSponsorConfig2(projectDir, existingConfig);
+        renderInfo("Sponsorship paused. /sponsor to resume.");
+        return "handled";
+      }
+      if (arg === "remove" && existingConfig) {
+        existingConfig.status = "inactive";
+        saveSponsorConfig2(projectDir, existingConfig);
+        renderInfo("Sponsorship removed.");
+        return "handled";
+      }
+      if (arg === "status" || existingConfig && existingConfig.status !== "inactive") {
+        if (!existingConfig || existingConfig.status === "inactive") {
+          renderInfo("No active sponsorship. Run /sponsor to start.");
+          return "handled";
+        }
+        const action = await showSponsorDashboard2(existingConfig, projectDir, sponsorRl, ctx.availableContentRows?.());
+        switch (action) {
+          case "modify":
+            break;
+          case "pause":
+            existingConfig.status = "paused";
+            saveSponsorConfig2(projectDir, existingConfig);
+            renderInfo("Sponsorship paused. /sponsor to resume.");
+            return "handled";
+          case "resume":
+            existingConfig.status = "active";
+            saveSponsorConfig2(projectDir, existingConfig);
+            renderInfo("Sponsorship resumed.");
+            return "handled";
+          case "remove":
+            existingConfig.status = "inactive";
+            saveSponsorConfig2(projectDir, existingConfig);
+            renderInfo("Sponsorship removed.");
+            return "handled";
+          default:
+            return "handled";
+        }
+      }
+      const result = await runSponsorWizard2({
+        rl: sponsorRl,
+        projectDir,
+        ollamaUrl: "http://localhost:11434",
+        availableRows: ctx.availableContentRows?.(),
+        onGoLive: async (config) => {
+          if (config.transport.cloudflared && ctx.exposeStart) {
+            try {
+              const url = await ctx.exposeStart("ollama", void 0, "tunnel");
+              if (url)
+                renderInfo(`Tunnel: ${url}`);
+            } catch (err) {
+              renderError(`Tunnel start failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+          }
+          if (config.transport.libp2p && ctx.exposeStart) {
+            try {
+              const url = await ctx.exposeStart("ollama", void 0, "libp2p");
+              if (url)
+                renderInfo(`P2P: ${url}`);
+            } catch (err) {
+              renderError(`P2P start failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+          }
+        }
+      });
+      if (result) {
+        renderInfo("Sponsor wizard completed.");
+      }
+      return "handled";
+    }
     case "expose": {
       if (!ctx.exposeStart) {
         renderWarning("Expose gateway not available in this context.");
@@ -47532,13 +48123,13 @@ async function showCohereDashboard(ctx) {
             } else if (idResult.key === "view") {
               await ik.execute({ operation: "hydrate" });
             } else if (idResult.key === "history") {
-              const snapDir = join57(ctx.repoRoot, ".oa", "identity", "snapshots");
-              if (existsSync41(snapDir)) {
+              const snapDir = join58(ctx.repoRoot, ".oa", "identity", "snapshots");
+              if (existsSync42(snapDir)) {
                 const snaps = readdirSync12(snapDir).filter((f) => f.endsWith(".json")).sort().reverse();
                 const snapItems = snaps.slice(0, 20).map((f) => ({
                   key: f,
                   label: f.replace(".json", ""),
-                  detail: `${formatFileSize(statSync14(join57(snapDir, f)).size)}`
+                  detail: `${formatFileSize(statSync14(join58(snapDir, f)).size)}`
                 }));
                 if (snapItems.length > 0) {
                   await tuiSelect({
@@ -47854,12 +48445,12 @@ async function handleVoiceMenu(ctx, save, hasLocal) {
               continue;
             }
             const { basename: basename18, join: pathJoin } = await import("node:path");
-            const { copyFileSync: copyFileSync2, mkdirSync: mkdirSync26, existsSync: exists } = await import("node:fs");
+            const { copyFileSync: copyFileSync2, mkdirSync: mkdirSync27, existsSync: exists } = await import("node:fs");
             const { homedir: homedir18 } = await import("node:os");
             const modelName = basename18(onnxDrop.path, ".onnx").replace(/[^a-zA-Z0-9_-]/g, "-");
             const destDir = pathJoin(homedir18(), ".open-agents", "voice", "models", modelName);
             if (!exists(destDir))
-              mkdirSync26(destDir, { recursive: true });
+              mkdirSync27(destDir, { recursive: true });
             copyFileSync2(onnxDrop.path, pathJoin(destDir, "model.onnx"));
             copyFileSync2(jsonDrop.path, pathJoin(destDir, "config.json"));
             const { registerCustomOnnxModel: registerCustomOnnxModel2 } = await Promise.resolve().then(() => (init_voice(), voice_exports));
@@ -48351,11 +48942,11 @@ async function handlePeerEndpoint(peerId, authKey, ctx, local) {
     const models = await fetchModels(peerUrl, authKey);
     if (models.length > 0) {
       try {
-        const { writeFileSync: writeFileSync25, mkdirSync: mkdirSync26 } = await import("node:fs");
-        const { join: join72, dirname: dirname22 } = await import("node:path");
-        const cachePath = join72(ctx.repoRoot || process.cwd(), ".oa", "nexus", "peer-models-cache.json");
-        mkdirSync26(dirname22(cachePath), { recursive: true });
-        writeFileSync25(cachePath, JSON.stringify({
+        const { writeFileSync: writeFileSync26, mkdirSync: mkdirSync27 } = await import("node:fs");
+        const { join: join73, dirname: dirname22 } = await import("node:path");
+        const cachePath = join73(ctx.repoRoot || process.cwd(), ".oa", "nexus", "peer-models-cache.json");
+        mkdirSync27(dirname22(cachePath), { recursive: true });
+        writeFileSync26(cachePath, JSON.stringify({
           peerId,
           cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
           models: models.map((m) => ({ name: m.name, size: m.size, parameterSize: m.parameterSize }))
@@ -48554,17 +49145,17 @@ async function handleUpdate(subcommand, ctx) {
   try {
     const { createRequire: createRequire4 } = await import("node:module");
     const { fileURLToPath: fileURLToPath14 } = await import("node:url");
-    const { dirname: dirname22, join: join72 } = await import("node:path");
-    const { existsSync: existsSync52 } = await import("node:fs");
+    const { dirname: dirname22, join: join73 } = await import("node:path");
+    const { existsSync: existsSync53 } = await import("node:fs");
     const req = createRequire4(import.meta.url);
     const thisDir = dirname22(fileURLToPath14(import.meta.url));
     const candidates = [
-      join72(thisDir, "..", "package.json"),
-      join72(thisDir, "..", "..", "package.json"),
-      join72(thisDir, "..", "..", "..", "package.json")
+      join73(thisDir, "..", "package.json"),
+      join73(thisDir, "..", "..", "package.json"),
+      join73(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync52(pkgPath)) {
+      if (existsSync53(pkgPath)) {
         const pkg = req(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           currentVersion = pkg.version ?? "0.0.0";
@@ -49402,8 +49993,8 @@ var init_commands = __esm({
 });
 
 // packages/cli/dist/tui/project-context.js
-import { existsSync as existsSync42, readFileSync as readFileSync31, readdirSync as readdirSync13 } from "node:fs";
-import { join as join58, basename as basename12 } from "node:path";
+import { existsSync as existsSync43, readFileSync as readFileSync32, readdirSync as readdirSync13 } from "node:fs";
+import { join as join59, basename as basename12 } from "node:path";
 import { execSync as execSync30 } from "node:child_process";
 import { homedir as homedir15, platform as platform4, release } from "node:os";
 function getModelTier(modelName) {
@@ -49438,10 +50029,10 @@ function loadProjectMap(repoRoot) {
   if (!hasOaDirectory(repoRoot)) {
     initOaDirectory(repoRoot);
   }
-  const mapPath2 = join58(repoRoot, OA_DIR, "context", "project-map.md");
-  if (existsSync42(mapPath2)) {
+  const mapPath2 = join59(repoRoot, OA_DIR, "context", "project-map.md");
+  if (existsSync43(mapPath2)) {
     try {
-      const content = readFileSync31(mapPath2, "utf-8");
+      const content = readFileSync32(mapPath2, "utf-8");
       return content;
     } catch {
     }
@@ -49482,31 +50073,31 @@ ${log}`);
 }
 function loadMemoryContext(repoRoot) {
   const sections = [];
-  const oaMemDir = join58(repoRoot, OA_DIR, "memory");
+  const oaMemDir = join59(repoRoot, OA_DIR, "memory");
   const oaEntries = loadMemoryDir(oaMemDir, "project");
   if (oaEntries)
     sections.push(oaEntries);
-  const legacyMemDir = join58(repoRoot, ".open-agents", "memory");
-  if (legacyMemDir !== oaMemDir && existsSync42(legacyMemDir)) {
+  const legacyMemDir = join59(repoRoot, ".open-agents", "memory");
+  if (legacyMemDir !== oaMemDir && existsSync43(legacyMemDir)) {
     const legacyEntries = loadMemoryDir(legacyMemDir, "project/legacy");
     if (legacyEntries)
       sections.push(legacyEntries);
   }
-  const globalMemDir = join58(homedir15(), ".open-agents", "memory");
+  const globalMemDir = join59(homedir15(), ".open-agents", "memory");
   const globalEntries = loadMemoryDir(globalMemDir, "global");
   if (globalEntries)
     sections.push(globalEntries);
   return sections.join("\n\n");
 }
 function loadMemoryDir(memDir, scope) {
-  if (!existsSync42(memDir))
+  if (!existsSync43(memDir))
     return "";
   const lines = [];
   try {
     const files = readdirSync13(memDir).filter((f) => f.endsWith(".json"));
     for (const file of files.slice(0, 10)) {
       try {
-        const raw = readFileSync31(join58(memDir, file), "utf-8");
+        const raw = readFileSync32(join59(memDir, file), "utf-8");
         const entries = JSON.parse(raw);
         const topic = basename12(file, ".json");
         const keys = Object.keys(entries);
@@ -51025,22 +51616,22 @@ var init_banner = __esm({
 });
 
 // packages/cli/dist/tui/carousel-descriptors.js
-import { existsSync as existsSync43, readFileSync as readFileSync32, writeFileSync as writeFileSync19, mkdirSync as mkdirSync18, readdirSync as readdirSync14 } from "node:fs";
-import { join as join59, basename as basename13 } from "node:path";
+import { existsSync as existsSync44, readFileSync as readFileSync33, writeFileSync as writeFileSync20, mkdirSync as mkdirSync19, readdirSync as readdirSync14 } from "node:fs";
+import { join as join60, basename as basename13 } from "node:path";
 function loadToolProfile(repoRoot) {
-  const filePath = join59(repoRoot, OA_DIR, "context", TOOL_PROFILE_FILE);
+  const filePath = join60(repoRoot, OA_DIR, "context", TOOL_PROFILE_FILE);
   try {
-    if (!existsSync43(filePath))
+    if (!existsSync44(filePath))
       return null;
-    return JSON.parse(readFileSync32(filePath, "utf-8"));
+    return JSON.parse(readFileSync33(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveToolProfile(repoRoot, profile) {
-  const contextDir = join59(repoRoot, OA_DIR, "context");
-  mkdirSync18(contextDir, { recursive: true });
-  writeFileSync19(join59(contextDir, TOOL_PROFILE_FILE), JSON.stringify(profile, null, 2), "utf-8");
+  const contextDir = join60(repoRoot, OA_DIR, "context");
+  mkdirSync19(contextDir, { recursive: true });
+  writeFileSync20(join60(contextDir, TOOL_PROFILE_FILE), JSON.stringify(profile, null, 2), "utf-8");
 }
 function categorizeToolCall(toolName) {
   for (const cat of TOOL_CATEGORIES) {
@@ -51098,25 +51689,25 @@ function weightedColor(profile) {
   return selectedCat.colors[Math.floor(Math.random() * selectedCat.colors.length)];
 }
 function loadCachedDescriptors(repoRoot) {
-  const filePath = join59(repoRoot, OA_DIR, "context", DESCRIPTOR_FILE);
+  const filePath = join60(repoRoot, OA_DIR, "context", DESCRIPTOR_FILE);
   try {
-    if (!existsSync43(filePath))
+    if (!existsSync44(filePath))
       return null;
-    const cached = JSON.parse(readFileSync32(filePath, "utf-8"));
+    const cached = JSON.parse(readFileSync33(filePath, "utf-8"));
     return cached.phrases.length > 0 ? cached.phrases : null;
   } catch {
     return null;
   }
 }
 function saveCachedDescriptors(repoRoot, phrases, sourceHash) {
-  const contextDir = join59(repoRoot, OA_DIR, "context");
-  mkdirSync18(contextDir, { recursive: true });
+  const contextDir = join60(repoRoot, OA_DIR, "context");
+  mkdirSync19(contextDir, { recursive: true });
   const cached = {
     phrases,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     sourceHash
   };
-  writeFileSync19(join59(contextDir, DESCRIPTOR_FILE), JSON.stringify(cached, null, 2), "utf-8");
+  writeFileSync20(join60(contextDir, DESCRIPTOR_FILE), JSON.stringify(cached, null, 2), "utf-8");
 }
 function generateDescriptors(repoRoot) {
   const profile = loadToolProfile(repoRoot);
@@ -51164,11 +51755,11 @@ function generateDescriptors(repoRoot) {
   return phrases;
 }
 function extractFromPackageJson(repoRoot, tags) {
-  const pkgPath = join59(repoRoot, "package.json");
+  const pkgPath = join60(repoRoot, "package.json");
   try {
-    if (!existsSync43(pkgPath))
+    if (!existsSync44(pkgPath))
       return;
-    const pkg = JSON.parse(readFileSync32(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync33(pkgPath, "utf-8"));
     if (pkg.name && typeof pkg.name === "string") {
       const parts = pkg.name.replace(/^@/, "").split("/");
       for (const p of parts)
@@ -51212,7 +51803,7 @@ function extractFromManifests(repoRoot, tags) {
     { file: ".github/workflows", tag: "ci/cd" }
   ];
   for (const check of manifestChecks) {
-    if (existsSync43(join59(repoRoot, check.file))) {
+    if (existsSync44(join60(repoRoot, check.file))) {
       tags.push(check.tag);
     }
   }
@@ -51234,16 +51825,16 @@ function extractFromSessions(repoRoot, tags) {
   }
 }
 function extractFromMemory(repoRoot, tags) {
-  const memoryDir = join59(repoRoot, OA_DIR, "memory");
+  const memoryDir = join60(repoRoot, OA_DIR, "memory");
   try {
-    if (!existsSync43(memoryDir))
+    if (!existsSync44(memoryDir))
       return;
     const files = readdirSync14(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(readFileSync32(join59(memoryDir, file), "utf-8"));
+        const data = JSON.parse(readFileSync33(join60(memoryDir, file), "utf-8"));
         if (data && typeof data === "object") {
           const keys = Object.keys(data).slice(0, 3);
           for (const key of keys) {
@@ -51898,13 +52489,13 @@ var init_stream_renderer = __esm({
 });
 
 // packages/cli/dist/tui/edit-history.js
-import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync19 } from "node:fs";
-import { join as join60 } from "node:path";
+import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync20 } from "node:fs";
+import { join as join61 } from "node:path";
 function createEditHistoryLogger(repoRoot, sessionId) {
-  const historyDir = join60(repoRoot, ".oa", "history");
-  const logPath2 = join60(historyDir, "edits.jsonl");
+  const historyDir = join61(repoRoot, ".oa", "history");
+  const logPath2 = join61(historyDir, "edits.jsonl");
   try {
-    mkdirSync19(historyDir, { recursive: true });
+    mkdirSync20(historyDir, { recursive: true });
   } catch {
   }
   function logToolCall(toolName, toolArgs, success) {
@@ -52013,17 +52604,17 @@ var init_edit_history = __esm({
 });
 
 // packages/cli/dist/tui/promptLoader.js
-import { readFileSync as readFileSync33, existsSync as existsSync44 } from "node:fs";
-import { join as join61, dirname as dirname19 } from "node:path";
+import { readFileSync as readFileSync34, existsSync as existsSync45 } from "node:fs";
+import { join as join62, dirname as dirname19 } 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 = join61(PROMPTS_DIR3, promptPath);
-    if (!existsSync44(fullPath)) {
+    const fullPath = join62(PROMPTS_DIR3, promptPath);
+    if (!existsSync45(fullPath)) {
       throw new Error(`Prompt file not found: ${fullPath}`);
     }
-    content = readFileSync33(fullPath, "utf-8");
+    content = readFileSync34(fullPath, "utf-8");
     cache3.set(promptPath, content);
   }
   if (!vars)
@@ -52036,23 +52627,23 @@ var init_promptLoader3 = __esm({
     "use strict";
     __filename3 = fileURLToPath11(import.meta.url);
     __dirname6 = dirname19(__filename3);
-    devPath2 = join61(__dirname6, "..", "..", "prompts");
-    publishedPath2 = join61(__dirname6, "..", "prompts");
-    PROMPTS_DIR3 = existsSync44(devPath2) ? devPath2 : publishedPath2;
+    devPath2 = join62(__dirname6, "..", "..", "prompts");
+    publishedPath2 = join62(__dirname6, "..", "prompts");
+    PROMPTS_DIR3 = existsSync45(devPath2) ? devPath2 : publishedPath2;
     cache3 = /* @__PURE__ */ new Map();
   }
 });
 
 // packages/cli/dist/tui/dream-engine.js
-import { mkdirSync as mkdirSync20, writeFileSync as writeFileSync20, readFileSync as readFileSync34, existsSync as existsSync45, cpSync, rmSync as rmSync2, readdirSync as readdirSync15 } from "node:fs";
-import { join as join62, basename as basename14 } from "node:path";
+import { mkdirSync as mkdirSync21, writeFileSync as writeFileSync21, readFileSync as readFileSync35, existsSync as existsSync46, cpSync, rmSync as rmSync2, readdirSync as readdirSync15 } from "node:fs";
+import { join as join63, basename as basename14 } from "node:path";
 import { execSync as execSync31 } from "node:child_process";
 function loadAutoresearchMemory(repoRoot) {
-  const memoryPath = join62(repoRoot, ".oa", "memory", "autoresearch.json");
-  if (!existsSync45(memoryPath))
+  const memoryPath = join63(repoRoot, ".oa", "memory", "autoresearch.json");
+  if (!existsSync46(memoryPath))
     return "";
   try {
-    const raw = readFileSync34(memoryPath, "utf-8");
+    const raw = readFileSync35(memoryPath, "utf-8");
     const data = JSON.parse(raw);
     const sections = [];
     for (const key of AUTORESEARCH_MEMORY_KEYS) {
@@ -52242,14 +52833,14 @@ var init_dream_engine = __esm({
         const content = String(args["content"] ?? "");
         if (!rawPath)
           return { success: false, output: "", error: "path is required", durationMs: Date.now() - start };
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/autoresearch") ? join62(this.autoresearchDir, basename14(rawPath)) : join62(this.autoresearchDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/autoresearch") ? join63(this.autoresearchDir, basename14(rawPath)) : join63(this.autoresearchDir, rawPath);
         if (!targetPath.startsWith(this.autoresearchDir)) {
           return { success: false, output: "", error: "Autoresearch mode: writes are confined to .oa/autoresearch/", durationMs: Date.now() - start };
         }
         try {
-          const dir = join62(targetPath, "..");
-          mkdirSync20(dir, { recursive: true });
-          writeFileSync20(targetPath, content, "utf-8");
+          const dir = join63(targetPath, "..");
+          mkdirSync21(dir, { recursive: true });
+          writeFileSync21(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 };
@@ -52277,20 +52868,20 @@ var init_dream_engine = __esm({
         const rawPath = String(args["path"] ?? "");
         const oldStr = String(args["old_string"] ?? "");
         const newStr = String(args["new_string"] ?? "");
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/autoresearch") ? join62(this.autoresearchDir, basename14(rawPath)) : join62(this.autoresearchDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/autoresearch") ? join63(this.autoresearchDir, basename14(rawPath)) : join63(this.autoresearchDir, rawPath);
         if (!targetPath.startsWith(this.autoresearchDir)) {
           return { success: false, output: "", error: "Autoresearch mode: edits are confined to .oa/autoresearch/", durationMs: Date.now() - start };
         }
         try {
-          if (!existsSync45(targetPath)) {
+          if (!existsSync46(targetPath)) {
             return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: Date.now() - start };
           }
-          let content = readFileSync34(targetPath, "utf-8");
+          let content = readFileSync35(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);
-          writeFileSync20(targetPath, content, "utf-8");
+          writeFileSync21(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 };
@@ -52331,14 +52922,14 @@ var init_dream_engine = __esm({
         const content = String(args["content"] ?? "");
         if (!rawPath)
           return { success: false, output: "", error: "path is required", durationMs: Date.now() - start };
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join62(this.dreamsDir, basename14(rawPath)) : join62(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join63(this.dreamsDir, basename14(rawPath)) : join63(this.dreamsDir, rawPath);
         if (!targetPath.startsWith(this.dreamsDir)) {
           return { success: false, output: "", error: "Dream mode: writes are confined to .oa/dreams/", durationMs: Date.now() - start };
         }
         try {
-          const dir = join62(targetPath, "..");
-          mkdirSync20(dir, { recursive: true });
-          writeFileSync20(targetPath, content, "utf-8");
+          const dir = join63(targetPath, "..");
+          mkdirSync21(dir, { recursive: true });
+          writeFileSync21(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 };
@@ -52366,20 +52957,20 @@ var init_dream_engine = __esm({
         const rawPath = String(args["path"] ?? "");
         const oldStr = String(args["old_string"] ?? "");
         const newStr = String(args["new_string"] ?? "");
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join62(this.dreamsDir, basename14(rawPath)) : join62(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join63(this.dreamsDir, basename14(rawPath)) : join63(this.dreamsDir, rawPath);
         if (!targetPath.startsWith(this.dreamsDir)) {
           return { success: false, output: "", error: "Dream mode: edits are confined to .oa/dreams/", durationMs: Date.now() - start };
         }
         try {
-          if (!existsSync45(targetPath)) {
+          if (!existsSync46(targetPath)) {
             return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: Date.now() - start };
           }
-          let content = readFileSync34(targetPath, "utf-8");
+          let content = readFileSync35(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);
-          writeFileSync20(targetPath, content, "utf-8");
+          writeFileSync21(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 };
@@ -52433,7 +53024,7 @@ var init_dream_engine = __esm({
       constructor(config, repoRoot) {
         this.config = config;
         this.repoRoot = repoRoot;
-        this.dreamsDir = join62(repoRoot, ".oa", "dreams");
+        this.dreamsDir = join63(repoRoot, ".oa", "dreams");
         this.state = {
           mode: "default",
           active: false,
@@ -52464,7 +53055,7 @@ var init_dream_engine = __esm({
           startedAt: (/* @__PURE__ */ new Date()).toISOString(),
           results: []
         };
-        mkdirSync20(this.dreamsDir, { recursive: true });
+        mkdirSync21(this.dreamsDir, { recursive: true });
         this.saveDreamState();
         try {
           for (let cycle = 1; cycle <= totalCycles; cycle++) {
@@ -52517,8 +53108,8 @@ ${result.summary}`;
             if (mode !== "default" || cycle === totalCycles) {
               renderDreamContraction(cycle);
               const cycleSummary = this.buildCycleSummary(cycle, previousFindings);
-              const summaryPath = join62(this.dreamsDir, `cycle-${cycle}-summary.md`);
-              writeFileSync20(summaryPath, cycleSummary, "utf-8");
+              const summaryPath = join63(this.dreamsDir, `cycle-${cycle}-summary.md`);
+              writeFileSync21(summaryPath, cycleSummary, "utf-8");
             }
             if (mode === "lucid" && !this.abortController.signal.aborted) {
               this.saveVersionCheckpoint(cycle);
@@ -52730,7 +53321,7 @@ After synthesis, call task_complete with the final prioritized summary.`, toolMo
       }
       /** Build role-specific tool sets for swarm agents */
       buildSwarmTools(role, _workspace) {
-        const autoresearchDir = join62(this.repoRoot, ".oa", "autoresearch");
+        const autoresearchDir = join63(this.repoRoot, ".oa", "autoresearch");
         const taskComplete = this.createSwarmTaskCompleteTool(role);
         switch (role) {
           case "researcher": {
@@ -53094,7 +53685,7 @@ INSTRUCTIONS:
 2. Summarize the key learnings and next steps
 
 Call task_complete with a human-readable summary of the autoresearch session.`, workspace, onEvent);
-        const reportPath = join62(this.dreamsDir, `cycle-${cycleNum}-autoresearch-report.md`);
+        const reportPath = join63(this.dreamsDir, `cycle-${cycleNum}-autoresearch-report.md`);
         const report = `# Autoresearch Swarm Report \u2014 Cycle ${cycleNum}
 
 **Date**: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
@@ -53116,8 +53707,8 @@ ${summaryResult}
 *Generated by open-agents autoresearch swarm*
 `;
         try {
-          mkdirSync20(this.dreamsDir, { recursive: true });
-          writeFileSync20(reportPath, report, "utf-8");
+          mkdirSync21(this.dreamsDir, { recursive: true });
+          writeFileSync21(reportPath, report, "utf-8");
         } catch {
         }
         renderSwarmComplete(workspace);
@@ -53183,9 +53774,9 @@ ${summaryResult}
       }
       /** Save workspace backup for lucid mode */
       saveVersionCheckpoint(cycle) {
-        const checkpointDir = join62(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
+        const checkpointDir = join63(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
         try {
-          mkdirSync20(checkpointDir, { recursive: true });
+          mkdirSync21(checkpointDir, { recursive: true });
           try {
             const gitStatus = execSync31("git status --porcelain", {
               cwd: this.repoRoot,
@@ -53202,10 +53793,10 @@ ${summaryResult}
               encoding: "utf-8",
               timeout: 5e3
             }).trim();
-            writeFileSync20(join62(checkpointDir, "git-status.txt"), gitStatus, "utf-8");
-            writeFileSync20(join62(checkpointDir, "git-diff.patch"), gitDiff, "utf-8");
-            writeFileSync20(join62(checkpointDir, "git-hash.txt"), gitHash, "utf-8");
-            writeFileSync20(join62(checkpointDir, "checkpoint.json"), JSON.stringify({
+            writeFileSync21(join63(checkpointDir, "git-status.txt"), gitStatus, "utf-8");
+            writeFileSync21(join63(checkpointDir, "git-diff.patch"), gitDiff, "utf-8");
+            writeFileSync21(join63(checkpointDir, "git-hash.txt"), gitHash, "utf-8");
+            writeFileSync21(join63(checkpointDir, "checkpoint.json"), JSON.stringify({
               cycle,
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
               gitHash,
@@ -53213,7 +53804,7 @@ ${summaryResult}
             }, null, 2), "utf-8");
             renderInfo(`Checkpoint saved: cycle ${cycle} (${gitHash.slice(0, 8)})`);
           } catch {
-            writeFileSync20(join62(checkpointDir, "checkpoint.json"), JSON.stringify({ cycle, timestamp: (/* @__PURE__ */ new Date()).toISOString(), mode: this.state.mode }, null, 2), "utf-8");
+            writeFileSync21(join63(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) {
@@ -53271,14 +53862,14 @@ ${files.map((f) => `- [\`${f}\`](./${f})`).join("\n")}
 ---
 *Auto-generated by open-agents dream engine*
 `;
-          writeFileSync20(join62(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
+          writeFileSync21(join63(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
         } catch {
         }
       }
       /** Save dream state for resume/inspection */
       saveDreamState() {
         try {
-          writeFileSync20(join62(this.dreamsDir, "dream-state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
+          writeFileSync21(join63(this.dreamsDir, "dream-state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
         } catch {
         }
       }
@@ -53652,8 +54243,8 @@ var init_bless_engine = __esm({
 });
 
 // packages/cli/dist/tui/dmn-engine.js
-import { existsSync as existsSync46, readFileSync as readFileSync35, writeFileSync as writeFileSync21, mkdirSync as mkdirSync21, readdirSync as readdirSync16, unlinkSync as unlinkSync10 } from "node:fs";
-import { join as join63, basename as basename15 } from "node:path";
+import { existsSync as existsSync47, readFileSync as readFileSync36, writeFileSync as writeFileSync22, mkdirSync as mkdirSync22, readdirSync as readdirSync16, unlinkSync as unlinkSync10 } from "node:fs";
+import { join as join64, basename as basename15 } from "node:path";
 function buildDMNGatherPrompt(recentTaskSummaries, dueReminders, attentionItems, memoryTopics, capabilities, competence, reflectionBuffer) {
   const competenceReport = competence.length > 0 ? competence.map((c3) => {
     const rate = c3.attempts > 0 ? Math.round(c3.successes / c3.attempts * 100) : 0;
@@ -53773,9 +54364,9 @@ var init_dmn_engine = __esm({
       constructor(config, repoRoot) {
         this.config = config;
         this.repoRoot = repoRoot;
-        this.stateDir = join63(repoRoot, ".oa", "dmn");
-        this.historyDir = join63(repoRoot, ".oa", "dmn", "cycles");
-        mkdirSync21(this.historyDir, { recursive: true });
+        this.stateDir = join64(repoRoot, ".oa", "dmn");
+        this.historyDir = join64(repoRoot, ".oa", "dmn", "cycles");
+        mkdirSync22(this.historyDir, { recursive: true });
         this.loadState();
       }
       get stats() {
@@ -54364,11 +54955,11 @@ OUTPUT: Call task_complete with JSON:
       async gatherMemoryTopics() {
         const topics = [];
         const dirs = [
-          join63(this.repoRoot, ".oa", "memory"),
-          join63(this.repoRoot, ".open-agents", "memory")
+          join64(this.repoRoot, ".oa", "memory"),
+          join64(this.repoRoot, ".open-agents", "memory")
         ];
         for (const dir of dirs) {
-          if (!existsSync46(dir))
+          if (!existsSync47(dir))
             continue;
           try {
             const files = readdirSync16(dir).filter((f) => f.endsWith(".json"));
@@ -54384,29 +54975,29 @@ OUTPUT: Call task_complete with JSON:
       }
       // ── State persistence ─────────────────────────────────────────────────
       loadState() {
-        const path = join63(this.stateDir, "state.json");
-        if (existsSync46(path)) {
+        const path = join64(this.stateDir, "state.json");
+        if (existsSync47(path)) {
           try {
-            this.state = JSON.parse(readFileSync35(path, "utf-8"));
+            this.state = JSON.parse(readFileSync36(path, "utf-8"));
           } catch {
           }
         }
       }
       saveState() {
         try {
-          writeFileSync21(join63(this.stateDir, "state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
+          writeFileSync22(join64(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`;
-          writeFileSync21(join63(this.historyDir, filename), JSON.stringify(result, null, 2) + "\n", "utf-8");
+          writeFileSync22(join64(this.historyDir, filename), JSON.stringify(result, null, 2) + "\n", "utf-8");
           const files = readdirSync16(this.historyDir).filter((f) => f.startsWith("cycle-") && f.endsWith(".json")).sort();
           if (files.length > 50) {
             for (const old of files.slice(0, files.length - 50)) {
               try {
-                unlinkSync10(join63(this.historyDir, old));
+                unlinkSync10(join64(this.historyDir, old));
               } catch {
               }
             }
@@ -54419,8 +55010,8 @@ OUTPUT: Call task_complete with JSON:
 });
 
 // packages/cli/dist/tui/snr-engine.js
-import { existsSync as existsSync47, readdirSync as readdirSync17, readFileSync as readFileSync36 } from "node:fs";
-import { join as join64, basename as basename16 } from "node:path";
+import { existsSync as existsSync48, readdirSync as readdirSync17, readFileSync as readFileSync37 } from "node:fs";
+import { join as join65, basename as basename16 } from "node:path";
 function computeDPrime(signalScores, noiseScores) {
   if (signalScores.length === 0 || noiseScores.length === 0)
     return 0;
@@ -54660,11 +55251,11 @@ Call task_complete with the JSON array when done.`, onEvent)
       loadMemoryEntries(topics) {
         const entries = [];
         const dirs = [
-          join64(this.repoRoot, ".oa", "memory"),
-          join64(this.repoRoot, ".open-agents", "memory")
+          join65(this.repoRoot, ".oa", "memory"),
+          join65(this.repoRoot, ".open-agents", "memory")
         ];
         for (const dir of dirs) {
-          if (!existsSync47(dir))
+          if (!existsSync48(dir))
             continue;
           try {
             const files = readdirSync17(dir).filter((f) => f.endsWith(".json"));
@@ -54673,7 +55264,7 @@ Call task_complete with the JSON array when done.`, onEvent)
               if (topics.length > 0 && !topics.includes(topic))
                 continue;
               try {
-                const data = JSON.parse(readFileSync36(join64(dir, f), "utf-8"));
+                const data = JSON.parse(readFileSync37(join65(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 });
@@ -55240,8 +55831,8 @@ var init_tool_policy = __esm({
 });
 
 // packages/cli/dist/tui/telegram-bridge.js
-import { mkdirSync as mkdirSync22, existsSync as existsSync48, unlinkSync as unlinkSync11, readdirSync as readdirSync18, statSync as statSync15 } from "node:fs";
-import { join as join65, resolve as resolve30 } from "node:path";
+import { mkdirSync as mkdirSync23, existsSync as existsSync49, unlinkSync as unlinkSync11, readdirSync as readdirSync18, statSync as statSync15 } from "node:fs";
+import { join as join66, resolve as resolve30 } from "node:path";
 import { writeFile as writeFileAsync } from "node:fs/promises";
 function convertMarkdownToTelegramHTML(md) {
   let html = md;
@@ -55569,7 +56160,7 @@ with summary "no_reply" to silently skip without responding.
         this.polling = true;
         this.abortController = new AbortController();
         try {
-          mkdirSync22(this.mediaCacheDir, { recursive: true });
+          mkdirSync23(this.mediaCacheDir, { recursive: true });
         } catch {
         }
         this.mediaCacheCleanupTimer = setInterval(() => this.cleanupMediaCache(), 5 * 60 * 1e3);
@@ -56006,7 +56597,7 @@ Telegram admin: @${msg.username}` : `Telegram ${isGroup ? "group" : "public"} ch
             return null;
           const buffer = Buffer.from(await res.arrayBuffer());
           const fileName = `${Date.now()}-${fileId.slice(0, 8)}${extension}`;
-          const localPath = join65(this.mediaCacheDir, fileName);
+          const localPath = join66(this.mediaCacheDir, fileName);
           await writeFileAsync(localPath, buffer);
           return localPath;
         } catch {
@@ -57362,7 +57953,7 @@ var init_text_selection = __esm({
 });
 
 // packages/cli/dist/tui/status-bar.js
-import { readFileSync as readFileSync37 } from "node:fs";
+import { readFileSync as readFileSync38 } from "node:fs";
 function setTerminalTitle(task, version) {
   if (!process.stdout.isTTY)
     return;
@@ -58044,7 +58635,7 @@ var init_status_bar = __esm({
             if (nexusDir) {
               try {
                 const metricsPath = nexusDir + "/remote-metrics.json";
-                const raw = readFileSync37(metricsPath, "utf8");
+                const raw = readFileSync38(metricsPath, "utf8");
                 const cached = JSON.parse(raw);
                 if (cached && cached.ts && Date.now() - cached.ts < 6e4) {
                   const m = cached.data;
@@ -59643,11 +60234,11 @@ var init_mouse_filter = __esm({
 import * as readline2 from "node:readline";
 import { Writable } from "node:stream";
 import { cwd } from "node:process";
-import { resolve as resolve31, join as join66, dirname as dirname20, extname as extname11 } from "node:path";
+import { resolve as resolve31, join as join67, dirname as dirname20, extname as extname11 } from "node:path";
 import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath as fileURLToPath12 } from "node:url";
-import { readFileSync as readFileSync38, writeFileSync as writeFileSync22, appendFileSync as appendFileSync4, rmSync as rmSync3, readdirSync as readdirSync19, mkdirSync as mkdirSync23 } from "node:fs";
-import { existsSync as existsSync49 } from "node:fs";
+import { readFileSync as readFileSync39, writeFileSync as writeFileSync23, appendFileSync as appendFileSync4, rmSync as rmSync3, readdirSync as readdirSync19, mkdirSync as mkdirSync24 } from "node:fs";
+import { existsSync as existsSync50 } from "node:fs";
 import { execSync as execSync33 } from "node:child_process";
 import { homedir as homedir16 } from "node:os";
 function formatTimeAgo(date) {
@@ -59668,12 +60259,12 @@ function getVersion3() {
     const require2 = createRequire2(import.meta.url);
     const thisDir = dirname20(fileURLToPath12(import.meta.url));
     const candidates = [
-      join66(thisDir, "..", "package.json"),
-      join66(thisDir, "..", "..", "package.json"),
-      join66(thisDir, "..", "..", "..", "package.json")
+      join67(thisDir, "..", "package.json"),
+      join67(thisDir, "..", "..", "package.json"),
+      join67(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync49(pkgPath)) {
+      if (existsSync50(pkgPath)) {
         const pkg = require2(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           return pkg.version ?? "0.0.0";
@@ -59908,15 +60499,15 @@ Use task_status("${taskId}") or task_output("${taskId}") to check progress.`
 function gatherMemorySnippets(root) {
   const snippets = [];
   const dirs = [
-    join66(root, ".oa", "memory"),
-    join66(root, ".open-agents", "memory")
+    join67(root, ".oa", "memory"),
+    join67(root, ".open-agents", "memory")
   ];
   for (const dir of dirs) {
-    if (!existsSync49(dir))
+    if (!existsSync50(dir))
       continue;
     try {
       for (const f of readdirSync19(dir).filter((f2) => f2.endsWith(".json"))) {
-        const data = JSON.parse(readFileSync38(join66(dir, f), "utf-8"));
+        const data = JSON.parse(readFileSync39(join67(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)
@@ -60073,9 +60664,9 @@ ${metabolismMemories}
   } catch {
   }
   try {
-    const archeFile = join66(repoRoot, ".oa", "arche", "variants.json");
-    if (existsSync49(archeFile)) {
-      const variants = JSON.parse(readFileSync38(archeFile, "utf8"));
+    const archeFile = join67(repoRoot, ".oa", "arche", "variants.json");
+    if (existsSync50(archeFile)) {
+      const variants = JSON.parse(readFileSync39(archeFile, "utf8"));
       if (variants.length > 0) {
         let filtered = variants;
         if (taskType) {
@@ -60212,9 +60803,9 @@ ${lines.join("\n")}
   const compactionThreshold = modelTier === "small" ? 12e3 : modelTier === "medium" ? 24e3 : 4e4;
   let identityInjection = "";
   try {
-    const ikStateFile = join66(repoRoot, ".oa", "identity", "self-state.json");
-    if (existsSync49(ikStateFile)) {
-      const selfState = JSON.parse(readFileSync38(ikStateFile, "utf8"));
+    const ikStateFile = join67(repoRoot, ".oa", "identity", "self-state.json");
+    if (existsSync50(ikStateFile)) {
+      const selfState = JSON.parse(readFileSync39(ikStateFile, "utf8"));
       const lines = [
         `[Identity State v${selfState.version}]`,
         `Self: ${selfState.narrative_summary}`,
@@ -60855,13 +61446,13 @@ When done, either call task_complete with your answer, or use FINAL_VAR(variable
           });
         }
         try {
-          const ikDir = join66(repoRoot, ".oa", "identity");
-          const ikFile = join66(ikDir, "self-state.json");
+          const ikDir = join67(repoRoot, ".oa", "identity");
+          const ikFile = join67(ikDir, "self-state.json");
           let ikState;
-          if (existsSync49(ikFile)) {
-            ikState = JSON.parse(readFileSync38(ikFile, "utf8"));
+          if (existsSync50(ikFile)) {
+            ikState = JSON.parse(readFileSync39(ikFile, "utf8"));
           } else {
-            mkdirSync23(ikDir, { recursive: true });
+            mkdirSync24(ikDir, { recursive: true });
             const machineId = Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
             ikState = {
               self_id: `oa-${machineId}`,
@@ -60887,7 +61478,7 @@ When done, either call task_complete with your answer, or use FINAL_VAR(variable
           }
           ikState.session_count = (ikState.session_count || 0) + 1;
           ikState.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-          writeFileSync22(ikFile, JSON.stringify(ikState, null, 2));
+          writeFileSync23(ikFile, JSON.stringify(ikState, null, 2));
         } catch (ikErr) {
           try {
             console.error("[IK-OBSERVE]", ikErr);
@@ -60902,14 +61493,14 @@ When done, either call task_complete with your answer, or use FINAL_VAR(variable
       } else {
         renderTaskIncomplete(result.turns, result.toolCalls, result.durationMs, tokens);
         try {
-          const ikFile = join66(repoRoot, ".oa", "identity", "self-state.json");
-          if (existsSync49(ikFile)) {
-            const ikState = JSON.parse(readFileSync38(ikFile, "utf8"));
+          const ikFile = join67(repoRoot, ".oa", "identity", "self-state.json");
+          if (existsSync50(ikFile)) {
+            const ikState = JSON.parse(readFileSync39(ikFile, "utf8"));
             ikState.homeostasis.uncertainty = Math.min(1, ikState.homeostasis.uncertainty + 0.1);
             ikState.homeostasis.coherence = Math.max(0, ikState.homeostasis.coherence - 0.05);
             ikState.session_count = (ikState.session_count || 0) + 1;
             ikState.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-            writeFileSync22(ikFile, JSON.stringify(ikState, null, 2));
+            writeFileSync23(ikFile, JSON.stringify(ikState, null, 2));
           }
         } catch {
         }
@@ -61252,7 +61843,7 @@ Review its full output in the [${id}] tab or via full_sub_agent(action='output',
   let p2pGateway = null;
   let peerMesh = null;
   let inferenceRouter = null;
-  const secretVault = new SecretVault(join66(repoRoot, ".oa", "vault.enc"));
+  const secretVault = new SecretVault(join67(repoRoot, ".oa", "vault.enc"));
   let adminSessionKey = null;
   const callSubAgents = /* @__PURE__ */ new Map();
   const streamRenderer = new StreamRenderer();
@@ -61437,6 +62028,7 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     "/p2p",
     "/secrets",
     "/vault",
+    "/sponsor",
     "/full-send-bless",
     "/bless",
     "/telegram",
@@ -61472,13 +62064,13 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     const hits = allCompletions.filter((c3) => c3.toLowerCase().startsWith(lower));
     return [hits, line];
   }
-  const HISTORY_DIR = join66(homedir16(), ".open-agents");
-  const HISTORY_FILE = join66(HISTORY_DIR, "repl-history");
+  const HISTORY_DIR = join67(homedir16(), ".open-agents");
+  const HISTORY_FILE = join67(HISTORY_DIR, "repl-history");
   const MAX_HISTORY_LINES = 500;
   let savedHistory = [];
   try {
-    if (existsSync49(HISTORY_FILE)) {
-      const raw = readFileSync38(HISTORY_FILE, "utf8").trim();
+    if (existsSync50(HISTORY_FILE)) {
+      const raw = readFileSync39(HISTORY_FILE, "utf8").trim();
       if (raw)
         savedHistory = raw.split("\n").reverse();
     }
@@ -61558,12 +62150,12 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     if (!line.trim())
       return;
     try {
-      mkdirSync23(HISTORY_DIR, { recursive: true });
+      mkdirSync24(HISTORY_DIR, { recursive: true });
       appendFileSync4(HISTORY_FILE, line + "\n", "utf8");
       if (Math.random() < 0.02) {
-        const all = readFileSync38(HISTORY_FILE, "utf8").trim().split("\n");
+        const all = readFileSync39(HISTORY_FILE, "utf8").trim().split("\n");
         if (all.length > MAX_HISTORY_LINES) {
-          writeFileSync22(HISTORY_FILE, all.slice(-MAX_HISTORY_LINES).join("\n") + "\n", "utf8");
+          writeFileSync23(HISTORY_FILE, all.slice(-MAX_HISTORY_LINES).join("\n") + "\n", "utf8");
         }
       }
     } catch {
@@ -61739,7 +62331,7 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     } catch {
     }
     try {
-      const oaDir = join66(repoRoot, ".oa");
+      const oaDir = join67(repoRoot, ".oa");
       const reconnected = await ExposeGateway.checkAndReconnect(oaDir, {
         onInfo: (msg) => writeContent(() => renderInfo(msg)),
         onError: (msg) => writeContent(() => renderWarning(msg))
@@ -61762,7 +62354,7 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     } catch {
     }
     try {
-      const oaDir = join66(repoRoot, ".oa");
+      const oaDir = join67(repoRoot, ".oa");
       const reconnectedP2P = await ExposeP2PGateway.checkAndReconnect(oaDir, new NexusTool(repoRoot), {
         onInfo: (msg) => writeContent(() => renderInfo(msg)),
         onError: (msg) => writeContent(() => renderWarning(msg))
@@ -62646,7 +63238,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
           kind,
           targetUrl,
           authKey,
-          stateDir: join66(repoRoot, ".oa"),
+          stateDir: join67(repoRoot, ".oa"),
           passthrough: passthrough ?? false,
           loadbalance: loadbalance ?? false,
           endpointAuth: passthrough ? currentConfig.apiKey : void 0,
@@ -62694,7 +63286,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         await tunnelGateway.stop();
         tunnelGateway = null;
       }
-      const newTunnel = new ExposeGateway({ kind, targetUrl, authKey, fullAccess, stateDir: join66(repoRoot, ".oa") });
+      const newTunnel = new ExposeGateway({ kind, targetUrl, authKey, fullAccess, stateDir: join67(repoRoot, ".oa") });
       newTunnel.on("stats", (stats) => {
         statusBar.setExposeStatus({
           status: stats.status,
@@ -62963,10 +63555,10 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         writeContent(() => renderInfo(`Killed ${bgKilled} background task(s).`));
       }
       try {
-        const nexusDir = join66(repoRoot, OA_DIR, "nexus");
-        const pidFile = join66(nexusDir, "daemon.pid");
-        if (existsSync49(pidFile)) {
-          const pid = parseInt(readFileSync38(pidFile, "utf8").trim(), 10);
+        const nexusDir = join67(repoRoot, OA_DIR, "nexus");
+        const pidFile = join67(nexusDir, "daemon.pid");
+        if (existsSync50(pidFile)) {
+          const pid = parseInt(readFileSync39(pidFile, "utf8").trim(), 10);
           if (pid > 0) {
             try {
               if (process.platform === "win32") {
@@ -62988,13 +63580,13 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       } catch {
       }
       try {
-        const voiceDir2 = join66(homedir16(), ".open-agents", "voice");
+        const voiceDir2 = join67(homedir16(), ".open-agents", "voice");
         const voicePidFiles = ["luxtts-daemon.pid", "piper-daemon.pid"];
         for (const pf of voicePidFiles) {
-          const pidPath = join66(voiceDir2, pf);
-          if (existsSync49(pidPath)) {
+          const pidPath = join67(voiceDir2, pf);
+          if (existsSync50(pidPath)) {
             try {
-              const pid = parseInt(readFileSync38(pidPath, "utf8").trim(), 10);
+              const pid = parseInt(readFileSync39(pidPath, "utf8").trim(), 10);
               if (pid > 0) {
                 if (process.platform === "win32") {
                   try {
@@ -63018,8 +63610,8 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         execSync33(process.platform === "win32" ? "timeout /t 1 /nobreak >nul" : "sleep 0.5", { timeout: 3e3, stdio: "ignore" });
       } catch {
       }
-      const oaPath = join66(repoRoot, OA_DIR);
-      if (existsSync49(oaPath)) {
+      const oaPath = join67(repoRoot, OA_DIR);
+      if (existsSync50(oaPath)) {
         let deleted = false;
         for (let attempt = 0; attempt < 3; attempt++) {
           try {
@@ -63391,8 +63983,8 @@ Execute this skill now. Follow the behavioral guidance above.`;
       }
     }
     const cleanPath = input.replace(/^['"]|['"]$/g, "").trim();
-    const isImage = isImagePath(cleanPath) && existsSync49(resolve31(repoRoot, cleanPath));
-    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync49(resolve31(repoRoot, cleanPath));
+    const isImage = isImagePath(cleanPath) && existsSync50(resolve31(repoRoot, cleanPath));
+    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync50(resolve31(repoRoot, cleanPath));
     if (activeTask) {
       if (activeTask.runner.isPaused) {
         activeTask.runner.resume();
@@ -63401,7 +63993,7 @@ Execute this skill now. Follow the behavioral guidance above.`;
       if (isImage) {
         try {
           const imgPath = resolve31(repoRoot, cleanPath);
-          const imgBuffer = readFileSync38(imgPath);
+          const imgBuffer = readFileSync39(imgPath);
           const base64 = imgBuffer.toString("base64");
           const ext = extname11(cleanPath).toLowerCase();
           const mime = ext === ".png" ? "image/png" : ext === ".gif" ? "image/gif" : ext === ".webp" ? "image/webp" : "image/jpeg";
@@ -63900,13 +64492,13 @@ async function runWithTUI(task, config, repoPath) {
     const handle = startTask(task, config, repoRoot);
     await handle.promise;
     try {
-      const ikDir = join66(repoRoot, ".oa", "identity");
-      const ikFile = join66(ikDir, "self-state.json");
+      const ikDir = join67(repoRoot, ".oa", "identity");
+      const ikFile = join67(ikDir, "self-state.json");
       let ikState;
-      if (existsSync49(ikFile)) {
-        ikState = JSON.parse(readFileSync38(ikFile, "utf8"));
+      if (existsSync50(ikFile)) {
+        ikState = JSON.parse(readFileSync39(ikFile, "utf8"));
       } else {
-        mkdirSync23(ikDir, { recursive: true });
+        mkdirSync24(ikDir, { recursive: true });
         ikState = {
           self_id: `oa-${Date.now().toString(36)}`,
           version: 1,
@@ -63928,7 +64520,7 @@ async function runWithTUI(task, config, repoPath) {
       ikState.homeostasis.coherence = Math.min(1, ikState.homeostasis.coherence + 0.05);
       ikState.session_count = (ikState.session_count || 0) + 1;
       ikState.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-      writeFileSync22(ikFile, JSON.stringify(ikState, null, 2));
+      writeFileSync23(ikFile, JSON.stringify(ikState, null, 2));
     } catch (ikErr) {
     }
     try {
@@ -63937,12 +64529,12 @@ async function runWithTUI(task, config, repoPath) {
       ec.archiveVariantSync(`Task: ${task.slice(0, 200)}`, "success \u2014 completed", ["general"]);
     } catch {
       try {
-        const archeDir = join66(repoRoot, ".oa", "arche");
-        const archeFile = join66(archeDir, "variants.json");
+        const archeDir = join67(repoRoot, ".oa", "arche");
+        const archeFile = join67(archeDir, "variants.json");
         let variants = [];
         try {
-          if (existsSync49(archeFile))
-            variants = JSON.parse(readFileSync38(archeFile, "utf8"));
+          if (existsSync50(archeFile))
+            variants = JSON.parse(readFileSync39(archeFile, "utf8"));
         } catch {
         }
         variants.push({
@@ -63957,15 +64549,15 @@ async function runWithTUI(task, config, repoPath) {
         });
         if (variants.length > 50)
           variants = variants.slice(-50);
-        mkdirSync23(archeDir, { recursive: true });
-        writeFileSync22(archeFile, JSON.stringify(variants, null, 2));
+        mkdirSync24(archeDir, { recursive: true });
+        writeFileSync23(archeFile, JSON.stringify(variants, null, 2));
       } catch {
       }
     }
     try {
-      const metaFile = join66(repoRoot, ".oa", "memory", "metabolism", "store.json");
-      if (existsSync49(metaFile)) {
-        const store = JSON.parse(readFileSync38(metaFile, "utf8"));
+      const metaFile = join67(repoRoot, ".oa", "memory", "metabolism", "store.json");
+      if (existsSync50(metaFile)) {
+        const store = JSON.parse(readFileSync39(metaFile, "utf8"));
         const surfaced = store.filter((m) => m.type !== "quarantine" && m.scores?.confidence > 0.15).sort((a, b) => b.scores.utility * b.scores.confidence - a.scores.utility * a.scores.confidence).slice(0, 5);
         let updated = false;
         for (const item of surfaced) {
@@ -63976,7 +64568,7 @@ async function runWithTUI(task, config, repoPath) {
           updated = true;
         }
         if (updated) {
-          writeFileSync22(metaFile, JSON.stringify(store, null, 2));
+          writeFileSync23(metaFile, JSON.stringify(store, null, 2));
         }
       }
     } catch {
@@ -64029,9 +64621,9 @@ Rules:
           try {
             const { initDb: initDb2 } = __require("@open-agents/memory");
             const { ProceduralMemoryStore: ProceduralMemoryStore2 } = __require("@open-agents/memory");
-            const dbDir = join66(repoRoot, ".oa", "memory");
-            mkdirSync23(dbDir, { recursive: true });
-            const db = initDb2(join66(dbDir, "structured.db"));
+            const dbDir = join67(repoRoot, ".oa", "memory");
+            mkdirSync24(dbDir, { recursive: true });
+            const db = initDb2(join67(dbDir, "structured.db"));
             const memStore = new ProceduralMemoryStore2(db);
             memStore.createWithEmbedding({
               content: content.slice(0, 600),
@@ -64046,12 +64638,12 @@ Rules:
             db.close();
           } catch {
           }
-          const metaDir = join66(repoRoot, ".oa", "memory", "metabolism");
-          const storeFile = join66(metaDir, "store.json");
+          const metaDir = join67(repoRoot, ".oa", "memory", "metabolism");
+          const storeFile = join67(metaDir, "store.json");
           let store = [];
           try {
-            if (existsSync49(storeFile))
-              store = JSON.parse(readFileSync38(storeFile, "utf8"));
+            if (existsSync50(storeFile))
+              store = JSON.parse(readFileSync39(storeFile, "utf8"));
           } catch {
           }
           store.push({
@@ -64067,26 +64659,26 @@ Rules:
           });
           if (store.length > 100)
             store = store.slice(-100);
-          mkdirSync23(metaDir, { recursive: true });
-          writeFileSync22(storeFile, JSON.stringify(store, null, 2));
+          mkdirSync24(metaDir, { recursive: true });
+          writeFileSync23(storeFile, JSON.stringify(store, null, 2));
         }
       }
     } catch {
     }
     try {
-      const cohereSettingsFile = join66(repoRoot, ".oa", "settings.json");
+      const cohereSettingsFile = join67(repoRoot, ".oa", "settings.json");
       let cohereActive = false;
       try {
-        if (existsSync49(cohereSettingsFile)) {
-          const settings = JSON.parse(readFileSync38(cohereSettingsFile, "utf8"));
+        if (existsSync50(cohereSettingsFile)) {
+          const settings = JSON.parse(readFileSync39(cohereSettingsFile, "utf8"));
           cohereActive = settings.cohere === true;
         }
       } catch {
       }
       if (cohereActive) {
-        const metaFile = join66(repoRoot, ".oa", "memory", "metabolism", "store.json");
-        if (existsSync49(metaFile)) {
-          const store = JSON.parse(readFileSync38(metaFile, "utf8"));
+        const metaFile = join67(repoRoot, ".oa", "memory", "metabolism", "store.json");
+        if (existsSync50(metaFile)) {
+          const store = JSON.parse(readFileSync39(metaFile, "utf8"));
           const latest = store.filter((m) => m.sourceTrace === "trajectory-extraction" || m.sourceTrace === "llm-trajectory-extraction").slice(-1)[0];
           if (latest && latest.scores?.confidence >= 0.6) {
             try {
@@ -64111,18 +64703,18 @@ Rules:
     }
   } catch (err) {
     try {
-      const ikFile = join66(repoRoot, ".oa", "identity", "self-state.json");
-      if (existsSync49(ikFile)) {
-        const ikState = JSON.parse(readFileSync38(ikFile, "utf8"));
+      const ikFile = join67(repoRoot, ".oa", "identity", "self-state.json");
+      if (existsSync50(ikFile)) {
+        const ikState = JSON.parse(readFileSync39(ikFile, "utf8"));
         ikState.homeostasis.uncertainty = Math.min(1, ikState.homeostasis.uncertainty + 0.1);
         ikState.homeostasis.coherence = Math.max(0, ikState.homeostasis.coherence - 0.05);
         ikState.session_count = (ikState.session_count || 0) + 1;
         ikState.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-        writeFileSync22(ikFile, JSON.stringify(ikState, null, 2));
+        writeFileSync23(ikFile, JSON.stringify(ikState, null, 2));
       }
-      const metaFile = join66(repoRoot, ".oa", "memory", "metabolism", "store.json");
-      if (existsSync49(metaFile)) {
-        const store = JSON.parse(readFileSync38(metaFile, "utf8"));
+      const metaFile = join67(repoRoot, ".oa", "memory", "metabolism", "store.json");
+      if (existsSync50(metaFile)) {
+        const store = JSON.parse(readFileSync39(metaFile, "utf8"));
         const surfaced = store.filter((m) => m.type !== "quarantine" && m.scores?.confidence > 0.15).sort((a, b) => b.scores.utility * b.scores.confidence - a.scores.utility * a.scores.confidence).slice(0, 5);
         for (const item of surfaced) {
           item.accessCount = (item.accessCount || 0) + 1;
@@ -64130,15 +64722,15 @@ Rules:
           item.scores.utility = Math.max(0, (item.scores.utility || 0.5) - 0.05);
           item.scores.confidence = Math.max(0, (item.scores.confidence || 0.5) - 0.02);
         }
-        writeFileSync22(metaFile, JSON.stringify(store, null, 2));
+        writeFileSync23(metaFile, JSON.stringify(store, null, 2));
       }
       try {
-        const archeDir = join66(repoRoot, ".oa", "arche");
-        const archeFile = join66(archeDir, "variants.json");
+        const archeDir = join67(repoRoot, ".oa", "arche");
+        const archeFile = join67(archeDir, "variants.json");
         let variants = [];
         try {
-          if (existsSync49(archeFile))
-            variants = JSON.parse(readFileSync38(archeFile, "utf8"));
+          if (existsSync50(archeFile))
+            variants = JSON.parse(readFileSync39(archeFile, "utf8"));
         } catch {
         }
         variants.push({
@@ -64153,8 +64745,8 @@ Rules:
         });
         if (variants.length > 50)
           variants = variants.slice(-50);
-        mkdirSync23(archeDir, { recursive: true });
-        writeFileSync22(archeFile, JSON.stringify(variants, null, 2));
+        mkdirSync24(archeDir, { recursive: true });
+        writeFileSync23(archeFile, JSON.stringify(variants, null, 2));
       } catch {
       }
     } catch {
@@ -64221,13 +64813,13 @@ __export(run_exports, {
 });
 import { resolve as resolve32 } from "node:path";
 import { spawn as spawn20 } from "node:child_process";
-import { mkdirSync as mkdirSync24, writeFileSync as writeFileSync23, readFileSync as readFileSync39, readdirSync as readdirSync20, existsSync as existsSync50 } from "node:fs";
+import { mkdirSync as mkdirSync25, writeFileSync as writeFileSync24, readFileSync as readFileSync40, readdirSync as readdirSync20, existsSync as existsSync51 } from "node:fs";
 import { randomBytes as randomBytes15 } from "node:crypto";
-import { join as join67 } from "node:path";
+import { join as join68 } from "node:path";
 function jobsDir(repoPath) {
   const root = resolve32(repoPath ?? process.cwd());
-  const dir = join67(root, ".oa", "jobs");
-  mkdirSync24(dir, { recursive: true });
+  const dir = join68(root, ".oa", "jobs");
+  mkdirSync25(dir, { recursive: true });
   return dir;
 }
 async function runCommand(opts, config) {
@@ -64312,7 +64904,7 @@ async function runBackground(task, config, opts) {
   });
   child.unref();
   job.pid = child.pid ?? 0;
-  writeFileSync23(join67(dir, `${id}.json`), JSON.stringify(job, null, 2));
+  writeFileSync24(join68(dir, `${id}.json`), JSON.stringify(job, null, 2));
   let output = "";
   child.stdout?.on("data", (chunk) => {
     output += chunk.toString();
@@ -64328,7 +64920,7 @@ async function runBackground(task, config, opts) {
       job.summary = result.summary;
       job.durationMs = result.durationMs;
       job.error = result.error;
-      writeFileSync23(join67(dir, `${id}.json`), JSON.stringify(job, null, 2));
+      writeFileSync24(join68(dir, `${id}.json`), JSON.stringify(job, null, 2));
     } catch {
     }
   });
@@ -64344,13 +64936,13 @@ async function runBackground(task, config, opts) {
 }
 function statusCommand(jobId, repoPath) {
   const dir = jobsDir(repoPath);
-  const file = join67(dir, `${jobId}.json`);
-  if (!existsSync50(file)) {
+  const file = join68(dir, `${jobId}.json`);
+  if (!existsSync51(file)) {
     console.error(`Job not found: ${jobId}`);
     console.log(`Available jobs: oa jobs`);
     process.exit(1);
   }
-  const job = JSON.parse(readFileSync39(file, "utf-8"));
+  const job = JSON.parse(readFileSync40(file, "utf-8"));
   const runtime = job.completedAt ? `${((new Date(job.completedAt).getTime() - new Date(job.startedAt).getTime()) / 1e3).toFixed(0)}s` : `${((Date.now() - new Date(job.startedAt).getTime()) / 1e3).toFixed(0)}s`;
   const icon = job.status === "completed" ? "\u2713" : job.status === "failed" ? "\u2717" : "\u25CF";
   console.log(`${icon} ${job.id} [${job.status}] ${runtime}`);
@@ -64373,7 +64965,7 @@ function jobsCommand(repoPath) {
   console.log("Jobs:");
   for (const file of files) {
     try {
-      const job = JSON.parse(readFileSync39(join67(dir, file), "utf-8"));
+      const job = JSON.parse(readFileSync40(join68(dir, file), "utf-8"));
       const icon = job.status === "completed" ? "\u2713" : job.status === "failed" ? "\u2717" : "\u25CF";
       const runtime = job.completedAt ? `${((new Date(job.completedAt).getTime() - new Date(job.startedAt).getTime()) / 1e3).toFixed(0)}s` : `${((Date.now() - new Date(job.startedAt).getTime()) / 1e3).toFixed(0)}s`;
       console.log(`  ${icon} ${job.id} [${job.status}] ${runtime} \u2014 ${job.task.slice(0, 60)}`);
@@ -64393,7 +64985,7 @@ import { glob } from "glob";
 import ignore from "ignore";
 import { readFile as readFile23, stat as stat4 } from "node:fs/promises";
 import { createHash as createHash5 } from "node:crypto";
-import { join as join68, relative as relative4, extname as extname12, basename as basename17 } from "node:path";
+import { join as join69, relative as relative4, extname as extname12, basename as basename17 } from "node:path";
 var DEFAULT_EXCLUDE, LANGUAGE_MAP, CodebaseIndexer;
 var init_codebase_indexer = __esm({
   "packages/indexer/dist/codebase-indexer.js"() {
@@ -64437,7 +65029,7 @@ var init_codebase_indexer = __esm({
         const ig = ignore.default();
         if (this.config.respectGitignore) {
           try {
-            const gitignoreContent = await readFile23(join68(this.config.rootDir, ".gitignore"), "utf-8");
+            const gitignoreContent = await readFile23(join69(this.config.rootDir, ".gitignore"), "utf-8");
             ig.add(gitignoreContent);
           } catch {
           }
@@ -64452,7 +65044,7 @@ var init_codebase_indexer = __esm({
         for (const relativePath of files) {
           if (ig.ignores(relativePath))
             continue;
-          const fullPath = join68(this.config.rootDir, relativePath);
+          const fullPath = join69(this.config.rootDir, relativePath);
           try {
             const fileStat = await stat4(fullPath);
             if (fileStat.size > this.config.maxFileSize)
@@ -64498,7 +65090,7 @@ var init_codebase_indexer = __esm({
               if (!child) {
                 child = {
                   name: part,
-                  path: join68(current.path, part),
+                  path: join69(current.path, part),
                   type: "directory",
                   children: []
                 };
@@ -64581,13 +65173,13 @@ __export(index_repo_exports, {
   indexRepoCommand: () => indexRepoCommand
 });
 import { resolve as resolve33 } from "node:path";
-import { existsSync as existsSync51, statSync as statSync16 } from "node:fs";
+import { existsSync as existsSync52, statSync as statSync16 } from "node:fs";
 import { cwd as cwd2 } from "node:process";
 async function indexRepoCommand(opts, _config) {
   const repoRoot = resolve33(opts.repoPath ?? cwd2());
   printHeader("Index Repository");
   printInfo(`Indexing: ${repoRoot}`);
-  if (!existsSync51(repoRoot)) {
+  if (!existsSync52(repoRoot)) {
     printError(`Path does not exist: ${repoRoot}`);
     process.exit(1);
   }
@@ -64839,7 +65431,7 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { join as join69, resolve as resolve34 } from "node:path";
+import { join as join70, resolve as resolve34 } from "node:path";
 import { homedir as homedir17 } from "node:os";
 import { cwd as cwd3 } from "node:process";
 function redactIfSensitive(key, value) {
@@ -64922,7 +65514,7 @@ function handleShow(opts, config) {
     }
   }
   printSection("Config File");
-  printInfo(`~/.open-agents/config.json (${join69(homedir17(), ".open-agents", "config.json")})`);
+  printInfo(`~/.open-agents/config.json (${join70(homedir17(), ".open-agents", "config.json")})`);
   printSection("Priority Chain");
   printInfo("  1. CLI flags (--model, --backend-url, etc.)");
   printInfo("  2. Project .oa/settings.json (--local)");
@@ -64961,7 +65553,7 @@ function handleSet(opts, _config) {
       const coerced = coerceForSettings(key, value);
       saveProjectSettings(repoRoot, { [key]: coerced });
       printSuccess(`Project override set: ${key} = ${redactIfSensitive(key, value)}`);
-      printInfo(`Saved to ${join69(repoRoot, ".oa", "settings.json")}`);
+      printInfo(`Saved to ${join70(repoRoot, ".oa", "settings.json")}`);
       printInfo("This override applies only when running in this workspace.");
     } catch (err) {
       printError(`Failed to save: ${err instanceof Error ? err.message : String(err)}`);
@@ -65219,8 +65811,8 @@ __export(eval_exports, {
   evalCommand: () => evalCommand
 });
 import { tmpdir as tmpdir10 } from "node:os";
-import { mkdirSync as mkdirSync25, writeFileSync as writeFileSync24 } from "node:fs";
-import { join as join70 } from "node:path";
+import { mkdirSync as mkdirSync26, writeFileSync as writeFileSync25 } from "node:fs";
+import { join as join71 } from "node:path";
 async function evalCommand(opts, config) {
   const suiteName = opts.suite ?? "basic";
   const suite = SUITES[suiteName];
@@ -65345,9 +65937,9 @@ async function evalCommand(opts, config) {
   process.exit(failed > 0 ? 1 : 0);
 }
 function createTempEvalRepo() {
-  const dir = join70(tmpdir10(), `open-agents-eval-${Date.now()}`);
-  mkdirSync25(dir, { recursive: true });
-  writeFileSync24(join70(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
+  const dir = join71(tmpdir10(), `open-agents-eval-${Date.now()}`);
+  mkdirSync26(dir, { recursive: true });
+  writeFileSync25(join71(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
   return dir;
 }
 var BASIC_SUITE, FULL_SUITE, SUITES;
@@ -65407,7 +65999,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 dirname21, join as join71 } from "node:path";
+import { dirname as dirname21, join as join72 } from "node:path";
 
 // packages/cli/dist/cli.js
 import { createInterface } from "node:readline";
@@ -65514,7 +66106,7 @@ init_output();
 function getVersion4() {
   try {
     const require2 = createRequire3(import.meta.url);
-    const pkgPath = join71(dirname21(fileURLToPath13(import.meta.url)), "..", "package.json");
+    const pkgPath = join72(dirname21(fileURLToPath13(import.meta.url)), "..", "package.json");
     const pkg = require2(pkgPath);
     return pkg.version;
   } catch {