open-agents-ai 0.139.8 → 0.140.0

package/dist/index.js

@@ -10892,8 +10892,8 @@ async function loadTranscribeCli() {
   const nvmBase = join17(homedir6(), ".nvm", "versions", "node");
   if (existsSync14(nvmBase)) {
     try {
-      const { readdirSync: readdirSync17 } = await import("node:fs");
-      for (const ver of readdirSync17(nvmBase)) {
+      const { readdirSync: readdirSync18 } = await import("node:fs");
+      for (const ver of readdirSync18(nvmBase)) {
         const tcPath = join17(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
         if (existsSync14(join17(tcPath, "dist", "index.js"))) {
           const { createRequire: createRequire4 } = await import("node:module");
@@ -12531,9 +12531,9 @@ print("${sentinel}")
         if (!this.proc || this.proc.killed) {
           return { success: false, path: "" };
         }
-        const { mkdirSync: mkdirSync21, writeFileSync: writeFileSync20 } = await import("node:fs");
+        const { mkdirSync: mkdirSync22, writeFileSync: writeFileSync21 } = await import("node:fs");
         const sessionDir = join20(this.cwd, ".oa", "rlm");
-        mkdirSync21(sessionDir, { recursive: true });
+        mkdirSync22(sessionDir, { recursive: true });
         const sessionPath = join20(sessionDir, "session.json");
         try {
           const inspectCode = `
@@ -12557,7 +12557,7 @@ print("__SESSION__" + json.dumps(_session) + "__SESSION__")
               trajectoryCount: this.trajectory.length,
               subCallCount: this.subCallCount
             };
-            writeFileSync20(sessionPath, JSON.stringify(sessionData, null, 2), "utf8");
+            writeFileSync21(sessionPath, JSON.stringify(sessionData, null, 2), "utf8");
             return { success: true, path: sessionPath };
           }
         } catch {
@@ -12569,11 +12569,11 @@ print("__SESSION__" + json.dumps(_session) + "__SESSION__")
        *  what was previously computed. */
       async loadSessionInfo() {
         try {
-          const { readFileSync: readFileSync33, existsSync: existsSync45 } = await import("node:fs");
+          const { readFileSync: readFileSync34, existsSync: existsSync46 } = await import("node:fs");
           const sessionPath = join20(this.cwd, ".oa", "rlm", "session.json");
-          if (!existsSync45(sessionPath))
+          if (!existsSync46(sessionPath))
             return null;
-          return JSON.parse(readFileSync33(sessionPath, "utf8"));
+          return JSON.parse(readFileSync34(sessionPath, "utf8"));
         } catch {
           return null;
         }
@@ -12750,10 +12750,10 @@ var init_memory_metabolism = __esm({
         const trajDir = join21(this.cwd, ".oa", "rlm-trajectories");
         let lessons = [];
         try {
-          const { readdirSync: readdirSync17, readFileSync: readFileSync33 } = await import("node:fs");
-          const files = readdirSync17(trajDir).filter((f) => f.endsWith(".jsonl")).sort().reverse().slice(0, 3);
+          const { readdirSync: readdirSync18, readFileSync: readFileSync34 } = await import("node:fs");
+          const files = readdirSync18(trajDir).filter((f) => f.endsWith(".jsonl")).sort().reverse().slice(0, 3);
           for (const file of files) {
-            const lines = readFileSync33(join21(trajDir, file), "utf8").split("\n").filter((l) => l.trim());
+            const lines = readFileSync34(join21(trajDir, file), "utf8").split("\n").filter((l) => l.trim());
             for (const line of lines) {
               try {
                 const entry = JSON.parse(line);
@@ -13137,14 +13137,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: readFileSync33, existsSync: existsSync45 } = __require("node:fs");
+        const { readFileSync: readFileSync34, existsSync: existsSync46 } = __require("node:fs");
         const metaDir = join21(this.cwd, ".oa", "memory", "metabolism");
         const storeFile = join21(metaDir, "store.json");
-        if (!existsSync45(storeFile))
+        if (!existsSync46(storeFile))
           return "";
         let store = [];
         try {
-          store = JSON.parse(readFileSync33(storeFile, "utf8"));
+          store = JSON.parse(readFileSync34(storeFile, "utf8"));
         } catch {
           return "";
         }
@@ -13166,14 +13166,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: readFileSync33, writeFileSync: writeFileSync20, existsSync: existsSync45, mkdirSync: mkdirSync21 } = __require("node:fs");
+        const { readFileSync: readFileSync34, writeFileSync: writeFileSync21, existsSync: existsSync46, mkdirSync: mkdirSync22 } = __require("node:fs");
         const metaDir = join21(this.cwd, ".oa", "memory", "metabolism");
         const storeFile = join21(metaDir, "store.json");
-        if (!existsSync45(storeFile))
+        if (!existsSync46(storeFile))
           return;
         let store = [];
         try {
-          store = JSON.parse(readFileSync33(storeFile, "utf8"));
+          store = JSON.parse(readFileSync34(storeFile, "utf8"));
         } catch {
           return;
         }
@@ -13197,8 +13197,8 @@ ${issues.map((i) => `  - ${i}`).join("\n")}` : "  No issues found."),
           updated = true;
         }
         if (updated) {
-          mkdirSync21(metaDir, { recursive: true });
-          writeFileSync20(storeFile, JSON.stringify(store, null, 2));
+          mkdirSync22(metaDir, { recursive: true });
+          writeFileSync21(storeFile, JSON.stringify(store, null, 2));
         }
       }
       // ── Storage ──────────────────────────────────────────────────────────
@@ -13620,13 +13620,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: readFileSync33, existsSync: existsSync45 } = __require("node:fs");
+        const { readFileSync: readFileSync34, existsSync: existsSync46 } = __require("node:fs");
         const archiveFile = join23(this.cwd, ".oa", "arche", "variants.json");
-        if (!existsSync45(archiveFile))
+        if (!existsSync46(archiveFile))
           return "";
         let variants = [];
         try {
-          variants = JSON.parse(readFileSync33(archiveFile, "utf8"));
+          variants = JSON.parse(readFileSync34(archiveFile, "utf8"));
         } catch {
           return "";
         }
@@ -13644,13 +13644,13 @@ Recommendation: Strategy ${scored[0].index + 1} scores highest.`;
       }
       /** Archive a strategy variant synchronously (for task completion path) */
       archiveVariantSync(strategy, outcome, tags = []) {
-        const { readFileSync: readFileSync33, writeFileSync: writeFileSync20, existsSync: existsSync45, mkdirSync: mkdirSync21 } = __require("node:fs");
+        const { readFileSync: readFileSync34, writeFileSync: writeFileSync21, existsSync: existsSync46, mkdirSync: mkdirSync22 } = __require("node:fs");
         const dir = join23(this.cwd, ".oa", "arche");
         const archiveFile = join23(dir, "variants.json");
         let variants = [];
         try {
-          if (existsSync45(archiveFile))
-            variants = JSON.parse(readFileSync33(archiveFile, "utf8"));
+          if (existsSync46(archiveFile))
+            variants = JSON.parse(readFileSync34(archiveFile, "utf8"));
         } catch {
         }
         variants.push({
@@ -13665,8 +13665,8 @@ Recommendation: Strategy ${scored[0].index + 1} scores highest.`;
         });
         if (variants.length > 50)
           variants = variants.slice(-50);
-        mkdirSync21(dir, { recursive: true });
-        writeFileSync20(archiveFile, JSON.stringify(variants, null, 2));
+        mkdirSync22(dir, { recursive: true });
+        writeFileSync21(archiveFile, JSON.stringify(variants, null, 2));
       }
       async saveArchive(variants) {
         const dir = join23(this.cwd, ".oa", "arche");
@@ -23755,10 +23755,10 @@ ${marker}` : marker);
         if (!this._workingDirectory)
           return;
         try {
-          const { mkdirSync: mkdirSync21, writeFileSync: writeFileSync20 } = __require("node:fs");
-          const { join: join64 } = __require("node:path");
-          const sessionDir = join64(this._workingDirectory, ".oa", "session", this._sessionId);
-          mkdirSync21(sessionDir, { recursive: true });
+          const { mkdirSync: mkdirSync22, writeFileSync: writeFileSync21 } = __require("node:fs");
+          const { join: join65 } = __require("node:path");
+          const sessionDir = join65(this._workingDirectory, ".oa", "session", this._sessionId);
+          mkdirSync22(sessionDir, { recursive: true });
           const checkpoint = {
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
             sessionId: this._sessionId,
@@ -23770,7 +23770,7 @@ ${marker}` : marker);
             memexEntryCount: this._memexArchive.size,
             fileRegistrySize: this._fileRegistry.size
           };
-          writeFileSync20(join64(sessionDir, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
+          writeFileSync21(join65(sessionDir, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
         } catch {
         }
       }
@@ -26636,8 +26636,8 @@ var init_listen = __esm({
         const nvmBase = join42(homedir8(), ".nvm", "versions", "node");
         if (existsSync27(nvmBase)) {
           try {
-            const { readdirSync: readdirSync17 } = await import("node:fs");
-            for (const ver of readdirSync17(nvmBase)) {
+            const { readdirSync: readdirSync18 } = await import("node:fs");
+            for (const ver of readdirSync18(nvmBase)) {
               const tcPath = join42(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
               if (existsSync27(join42(tcPath, "dist", "index.js"))) {
                 const { createRequire: createRequire4 } = await import("node:module");
@@ -34926,26 +34926,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: existsSync45, readFileSync: readFileSync33 } = await import("node:fs");
-    const { join: join64 } = await import("node:path");
+    const { existsSync: existsSync46, readFileSync: readFileSync34 } = await import("node:fs");
+    const { join: join65 } = await import("node:path");
     const cwd4 = process.cwd();
     const nexusTool = new NexusTool2(cwd4);
     const nexusDir = nexusTool.getNexusDir();
     let isLocalPeer = false;
     try {
-      const statusPath = join64(nexusDir, "status.json");
-      if (existsSync45(statusPath)) {
-        const status = JSON.parse(readFileSync33(statusPath, "utf8"));
+      const statusPath = join65(nexusDir, "status.json");
+      if (existsSync46(statusPath)) {
+        const status = JSON.parse(readFileSync34(statusPath, "utf8"));
         if (status.peerId === peerId)
           isLocalPeer = true;
       }
     } catch {
     }
     if (isLocalPeer) {
-      const pricingPath = join64(nexusDir, "pricing.json");
-      if (existsSync45(pricingPath)) {
+      const pricingPath = join65(nexusDir, "pricing.json");
+      if (existsSync46(pricingPath)) {
         try {
-          const pricing = JSON.parse(readFileSync33(pricingPath, "utf8"));
+          const pricing = JSON.parse(readFileSync34(pricingPath, "utf8"));
           const localModels = (pricing.models || []).map((m) => ({
             name: m.model || "unknown",
             size: m.parameterSize || "",
@@ -34959,10 +34959,10 @@ async function fetchPeerModels(peerId, authKey) {
         }
       }
     }
-    const cachePath = join64(nexusDir, "peer-models-cache.json");
-    if (existsSync45(cachePath)) {
+    const cachePath = join65(nexusDir, "peer-models-cache.json");
+    if (existsSync46(cachePath)) {
       try {
-        const cache4 = JSON.parse(readFileSync33(cachePath, "utf8"));
+        const cache4 = JSON.parse(readFileSync34(cachePath, "utf8"));
         if (cache4.peerId === peerId && cache4.models?.length > 0) {
           const age = Date.now() - new Date(cache4.cachedAt).getTime();
           if (age < 5 * 60 * 1e3) {
@@ -35077,10 +35077,10 @@ async function fetchPeerModels(peerId, authKey) {
     } catch {
     }
     if (isLocalPeer) {
-      const pricingPath = join64(nexusDir, "pricing.json");
-      if (existsSync45(pricingPath)) {
+      const pricingPath = join65(nexusDir, "pricing.json");
+      if (existsSync46(pricingPath)) {
         try {
-          const pricing = JSON.parse(readFileSync33(pricingPath, "utf8"));
+          const pricing = JSON.parse(readFileSync34(pricingPath, "utf8"));
           return (pricing.models || []).map((m) => ({
             name: m.model || "unknown",
             size: m.parameterSize || "",
@@ -41696,6 +41696,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 existsSync36, readFileSync as readFileSync25, writeFileSync as writeFileSync15, mkdirSync as mkdirSync14, readdirSync as readdirSync10, statSync as statSync13, rmSync } from "node:fs";
+import { join as join51 } from "node:path";
 function safeLog(text) {
   if (isNeovimActive()) {
     writeToNeovimOutput(text + "\n");
@@ -42121,6 +42123,194 @@ async function handleSlashCommand(input, ctx) {
       safeLog(lines.join("\n"));
       return "handled";
     }
+    case "ipfs": {
+      const lines = [];
+      lines.push(`
+  ${c2.bold("IPFS / Helia Status")}
+`);
+      const ipfsDir = join51(ctx.repoRoot, ".oa", "ipfs");
+      const ipfsLocalDir = join51(ipfsDir, "local");
+      let ipfsFiles = 0;
+      let ipfsBytes = 0;
+      let heliaBlocks = 0;
+      let heliaBytes = 0;
+      try {
+        if (existsSync36(ipfsLocalDir)) {
+          const files = readdirSync10(ipfsLocalDir).filter((f) => f.endsWith(".json"));
+          ipfsFiles = files.length;
+          for (const f of files) {
+            try {
+              ipfsBytes += statSync13(join51(ipfsLocalDir, f)).size;
+            } catch {
+            }
+          }
+        }
+        const heliaBlockDir = join51(ipfsDir, "blocks");
+        if (existsSync36(heliaBlockDir)) {
+          const walkDir = (dir) => {
+            for (const entry of readdirSync10(dir, { withFileTypes: true })) {
+              if (entry.isDirectory())
+                walkDir(join51(dir, entry.name));
+              else {
+                heliaBlocks++;
+                try {
+                  heliaBytes += statSync13(join51(dir, entry.name)).size;
+                } catch {
+                }
+              }
+            }
+          };
+          walkDir(heliaBlockDir);
+        }
+      } catch {
+      }
+      lines.push(`  ${c2.dim("Local fallback (SHA-256):")}`);
+      lines.push(`    Files: ${c2.bold(String(ipfsFiles))}   Size: ${c2.bold(formatFileSize(ipfsBytes))}`);
+      lines.push(`  ${c2.dim("Helia blocks:")}`);
+      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)")}`);
+      lines.push(`
+  ${c2.bold("Identity Kernel")}`);
+      const idDir = join51(ctx.repoRoot, ".oa", "identity");
+      try {
+        const stateFile = join51(idDir, "self-state.json");
+        if (existsSync36(stateFile)) {
+          const state = JSON.parse(readFileSync25(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 ? "..." : ""}`);
+          }
+          if (state.personality_traits) {
+            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 = join51(idDir, "cids.json");
+          if (existsSync36(cidFile)) {
+            const cids = JSON.parse(readFileSync25(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))}`);
+          }
+        } else {
+          lines.push(`    ${c2.dim("Not initialized (run 5+ tasks to generate)")}`);
+        }
+      } catch {
+      }
+      lines.push(`
+  ${c2.bold("Memory Sentiment")}`);
+      try {
+        const metaFile = join51(ctx.repoRoot, ".oa", "memory", "metabolism", "store.json");
+        if (existsSync36(metaFile)) {
+          const store = JSON.parse(readFileSync25(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;
+          const optimizations = active.filter((m) => m.content?.startsWith("[optimization]")).length;
+          const avgUtil = active.length > 0 ? active.reduce((s, m) => s + (m.scores?.utility ?? 0), 0) / active.length : 0;
+          const avgConf = active.length > 0 ? active.reduce((s, m) => s + (m.scores?.confidence ?? 0), 0) / active.length : 0;
+          lines.push(`    Memories: ${c2.bold(String(active.length))} (${recoveries} recovery, ${strategies} strategy, ${optimizations} optimization)`);
+          lines.push(`    Avg utility: ${c2.bold(avgUtil.toFixed(2))}   Avg confidence: ${c2.bold(avgConf.toFixed(2))}`);
+          const sentiment = strategies + optimizations > recoveries ? "proactive" : recoveries > 0 ? "defensive" : "neutral";
+          const sentimentColor = sentiment === "proactive" ? c2.green : sentiment === "defensive" ? c2.yellow : c2.dim;
+          lines.push(`    Overall: ${sentimentColor(sentiment)} (${strategies + optimizations} proactive / ${recoveries} defensive)`);
+        } else {
+          lines.push(`    ${c2.dim("No memories yet (complete tasks to learn)")}`);
+        }
+      } catch {
+      }
+      try {
+        const dbPath = join51(ctx.repoRoot, ".oa", "memory", "structured.db");
+        if (existsSync36(dbPath)) {
+          const { initDb: initDb2, closeDb: cDb, ProceduralMemoryStore: ProceduralMemoryStore2 } = __require("@open-agents/memory");
+          const db = initDb2(dbPath);
+          const memStore = new ProceduralMemoryStore2(db);
+          const count = memStore.count();
+          lines.push(`
+  ${c2.bold("Structured Memory (SQLite)")}`);
+          lines.push(`    Memories: ${c2.bold(String(count))}   DB: ${c2.dim(formatFileSize(statSync13(dbPath).size))}`);
+          cDb(db);
+        }
+      } catch {
+      }
+      lines.push("");
+      safeLog(lines.join("\n"));
+      return "handled";
+    }
+    case "storage": {
+      const lines = [];
+      lines.push(`
+  ${c2.bold("Storage Overview")}
+`);
+      const oaDir = join51(ctx.repoRoot, ".oa");
+      if (!existsSync36(oaDir)) {
+        lines.push(`  ${c2.dim("No .oa/ directory found.")}`);
+        safeLog(lines.join("\n") + "\n");
+        return "handled";
+      }
+      let totalBytes = 0;
+      const categories = {};
+      const walkStorage = (dir, category) => {
+        try {
+          for (const entry of readdirSync10(dir, { withFileTypes: true })) {
+            const full = join51(dir, entry.name);
+            if (entry.isDirectory()) {
+              const subCat = category || entry.name;
+              walkStorage(full, subCat);
+            } else {
+              try {
+                const sz = statSync13(full).size;
+                totalBytes += sz;
+                if (!categories[category])
+                  categories[category] = { files: 0, bytes: 0 };
+                categories[category].files++;
+                categories[category].bytes += sz;
+              } catch {
+              }
+            }
+          }
+        } catch {
+        }
+      };
+      walkStorage(oaDir, "");
+      const sorted = Object.entries(categories).sort((a, b) => b[1].bytes - a[1].bytes);
+      for (const [cat, info] of sorted) {
+        const name = cat || "root";
+        const pct = totalBytes > 0 ? Math.round(info.bytes / totalBytes * 100) : 0;
+        const bar = "\u2588".repeat(Math.max(1, Math.round(pct / 5))) + "\u2591".repeat(Math.max(0, 20 - Math.round(pct / 5)));
+        lines.push(`  ${c2.bold(name.padEnd(20))} ${bar} ${formatFileSize(info.bytes).padStart(8)}  ${String(info.files).padStart(4)} files  ${String(pct).padStart(2)}%`);
+      }
+      lines.push(`
+  ${c2.bold("Total:")} ${c2.bold(formatFileSize(totalBytes))} across ${sorted.reduce((s, [, v]) => s + v.files, 0)} files`);
+      const sensitivePatterns = [".env", "credentials", "secret", "private_key", "token.json"];
+      const sensitiveFound = [];
+      const checkSensitive = (dir) => {
+        try {
+          for (const entry of readdirSync10(dir, { withFileTypes: true })) {
+            const name = entry.name.toLowerCase();
+            if (sensitivePatterns.some((p) => name.includes(p))) {
+              sensitiveFound.push(join51(dir, entry.name).replace(oaDir + "/", ""));
+            }
+            if (entry.isDirectory())
+              checkSensitive(join51(dir, entry.name));
+          }
+        } catch {
+        }
+      };
+      checkSensitive(oaDir);
+      if (sensitiveFound.length > 0) {
+        lines.push(`
+  ${c2.yellow("\u26A0")} ${c2.bold("Sensitive files detected (excluded from IPFS/COHERE):")}`);
+        for (const f of sensitiveFound.slice(0, 5)) {
+          lines.push(`    ${c2.yellow(f)}`);
+        }
+      } else {
+        lines.push(`
+  ${c2.green("\u2713")} No sensitive files detected in .oa/ storage`);
+      }
+      lines.push("");
+      safeLog(lines.join("\n"));
+      return "handled";
+    }
     case "model":
       if (arg) {
         await switchModel(arg, ctx, hasLocal);
@@ -43574,12 +43764,12 @@ async function handleVoiceMenu(ctx, save, hasLocal) {
               continue;
             }
             const { basename: basename16, join: pathJoin } = await import("node:path");
-            const { copyFileSync: copyFileSync2, mkdirSync: mkdirSync21, existsSync: exists } = await import("node:fs");
+            const { copyFileSync: copyFileSync2, mkdirSync: mkdirSync22, existsSync: exists } = await import("node:fs");
             const { homedir: homedir15 } = await import("node:os");
             const modelName = basename16(onnxDrop.path, ".onnx").replace(/[^a-zA-Z0-9_-]/g, "-");
             const destDir = pathJoin(homedir15(), ".open-agents", "voice", "models", modelName);
             if (!exists(destDir))
-              mkdirSync21(destDir, { recursive: true });
+              mkdirSync22(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));
@@ -44071,11 +44261,11 @@ async function handlePeerEndpoint(peerId, authKey, ctx, local) {
     const models = await fetchModels(peerUrl, authKey);
     if (models.length > 0) {
       try {
-        const { writeFileSync: writeFileSync20, mkdirSync: mkdirSync21 } = await import("node:fs");
-        const { join: join64, dirname: dirname21 } = await import("node:path");
-        const cachePath = join64(ctx.repoRoot || process.cwd(), ".oa", "nexus", "peer-models-cache.json");
-        mkdirSync21(dirname21(cachePath), { recursive: true });
-        writeFileSync20(cachePath, JSON.stringify({
+        const { writeFileSync: writeFileSync21, mkdirSync: mkdirSync22 } = await import("node:fs");
+        const { join: join65, dirname: dirname21 } = await import("node:path");
+        const cachePath = join65(ctx.repoRoot || process.cwd(), ".oa", "nexus", "peer-models-cache.json");
+        mkdirSync22(dirname21(cachePath), { recursive: true });
+        writeFileSync21(cachePath, JSON.stringify({
           peerId,
           cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
           models: models.map((m) => ({ name: m.name, size: m.size, parameterSize: m.parameterSize }))
@@ -44274,17 +44464,17 @@ async function handleUpdate(subcommand, ctx) {
   try {
     const { createRequire: createRequire4 } = await import("node:module");
     const { fileURLToPath: fileURLToPath14 } = await import("node:url");
-    const { dirname: dirname21, join: join64 } = await import("node:path");
-    const { existsSync: existsSync45 } = await import("node:fs");
+    const { dirname: dirname21, join: join65 } = await import("node:path");
+    const { existsSync: existsSync46 } = await import("node:fs");
     const req = createRequire4(import.meta.url);
     const thisDir = dirname21(fileURLToPath14(import.meta.url));
     const candidates = [
-      join64(thisDir, "..", "package.json"),
-      join64(thisDir, "..", "..", "package.json"),
-      join64(thisDir, "..", "..", "..", "package.json")
+      join65(thisDir, "..", "package.json"),
+      join65(thisDir, "..", "..", "package.json"),
+      join65(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync45(pkgPath)) {
+      if (existsSync46(pkgPath)) {
         const pkg = req(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           currentVersion = pkg.version ?? "0.0.0";
@@ -45121,8 +45311,8 @@ var init_commands = __esm({
 });
 
 // packages/cli/dist/tui/project-context.js
-import { existsSync as existsSync36, readFileSync as readFileSync25, readdirSync as readdirSync10 } from "node:fs";
-import { join as join51, basename as basename10 } from "node:path";
+import { existsSync as existsSync37, readFileSync as readFileSync26, readdirSync as readdirSync11 } from "node:fs";
+import { join as join52, basename as basename10 } from "node:path";
 import { execSync as execSync27 } from "node:child_process";
 import { homedir as homedir12, platform as platform3, release } from "node:os";
 function getModelTier(modelName) {
@@ -45157,10 +45347,10 @@ function loadProjectMap(repoRoot) {
   if (!hasOaDirectory(repoRoot)) {
     initOaDirectory(repoRoot);
   }
-  const mapPath = join51(repoRoot, OA_DIR, "context", "project-map.md");
-  if (existsSync36(mapPath)) {
+  const mapPath = join52(repoRoot, OA_DIR, "context", "project-map.md");
+  if (existsSync37(mapPath)) {
     try {
-      const content = readFileSync25(mapPath, "utf-8");
+      const content = readFileSync26(mapPath, "utf-8");
       return content;
     } catch {
     }
@@ -45201,31 +45391,31 @@ ${log}`);
 }
 function loadMemoryContext(repoRoot) {
   const sections = [];
-  const oaMemDir = join51(repoRoot, OA_DIR, "memory");
+  const oaMemDir = join52(repoRoot, OA_DIR, "memory");
   const oaEntries = loadMemoryDir(oaMemDir, "project");
   if (oaEntries)
     sections.push(oaEntries);
-  const legacyMemDir = join51(repoRoot, ".open-agents", "memory");
-  if (legacyMemDir !== oaMemDir && existsSync36(legacyMemDir)) {
+  const legacyMemDir = join52(repoRoot, ".open-agents", "memory");
+  if (legacyMemDir !== oaMemDir && existsSync37(legacyMemDir)) {
     const legacyEntries = loadMemoryDir(legacyMemDir, "project/legacy");
     if (legacyEntries)
       sections.push(legacyEntries);
   }
-  const globalMemDir = join51(homedir12(), ".open-agents", "memory");
+  const globalMemDir = join52(homedir12(), ".open-agents", "memory");
   const globalEntries = loadMemoryDir(globalMemDir, "global");
   if (globalEntries)
     sections.push(globalEntries);
   return sections.join("\n\n");
 }
 function loadMemoryDir(memDir, scope) {
-  if (!existsSync36(memDir))
+  if (!existsSync37(memDir))
     return "";
   const lines = [];
   try {
-    const files = readdirSync10(memDir).filter((f) => f.endsWith(".json"));
+    const files = readdirSync11(memDir).filter((f) => f.endsWith(".json"));
     for (const file of files.slice(0, 10)) {
       try {
-        const raw = readFileSync25(join51(memDir, file), "utf-8");
+        const raw = readFileSync26(join52(memDir, file), "utf-8");
         const entries = JSON.parse(raw);
         const topic = basename10(file, ".json");
         const keys = Object.keys(entries);
@@ -46744,22 +46934,22 @@ var init_banner = __esm({
 });
 
 // packages/cli/dist/tui/carousel-descriptors.js
-import { existsSync as existsSync37, readFileSync as readFileSync26, writeFileSync as writeFileSync15, mkdirSync as mkdirSync14, readdirSync as readdirSync11 } from "node:fs";
-import { join as join52, basename as basename11 } from "node:path";
+import { existsSync as existsSync38, readFileSync as readFileSync27, writeFileSync as writeFileSync16, mkdirSync as mkdirSync15, readdirSync as readdirSync12 } from "node:fs";
+import { join as join53, basename as basename11 } from "node:path";
 function loadToolProfile(repoRoot) {
-  const filePath = join52(repoRoot, OA_DIR, "context", TOOL_PROFILE_FILE);
+  const filePath = join53(repoRoot, OA_DIR, "context", TOOL_PROFILE_FILE);
   try {
-    if (!existsSync37(filePath))
+    if (!existsSync38(filePath))
       return null;
-    return JSON.parse(readFileSync26(filePath, "utf-8"));
+    return JSON.parse(readFileSync27(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveToolProfile(repoRoot, profile) {
-  const contextDir = join52(repoRoot, OA_DIR, "context");
-  mkdirSync14(contextDir, { recursive: true });
-  writeFileSync15(join52(contextDir, TOOL_PROFILE_FILE), JSON.stringify(profile, null, 2), "utf-8");
+  const contextDir = join53(repoRoot, OA_DIR, "context");
+  mkdirSync15(contextDir, { recursive: true });
+  writeFileSync16(join53(contextDir, TOOL_PROFILE_FILE), JSON.stringify(profile, null, 2), "utf-8");
 }
 function categorizeToolCall(toolName) {
   for (const cat of TOOL_CATEGORIES) {
@@ -46817,25 +47007,25 @@ function weightedColor(profile) {
   return selectedCat.colors[Math.floor(Math.random() * selectedCat.colors.length)];
 }
 function loadCachedDescriptors(repoRoot) {
-  const filePath = join52(repoRoot, OA_DIR, "context", DESCRIPTOR_FILE);
+  const filePath = join53(repoRoot, OA_DIR, "context", DESCRIPTOR_FILE);
   try {
-    if (!existsSync37(filePath))
+    if (!existsSync38(filePath))
       return null;
-    const cached = JSON.parse(readFileSync26(filePath, "utf-8"));
+    const cached = JSON.parse(readFileSync27(filePath, "utf-8"));
     return cached.phrases.length > 0 ? cached.phrases : null;
   } catch {
     return null;
   }
 }
 function saveCachedDescriptors(repoRoot, phrases, sourceHash) {
-  const contextDir = join52(repoRoot, OA_DIR, "context");
-  mkdirSync14(contextDir, { recursive: true });
+  const contextDir = join53(repoRoot, OA_DIR, "context");
+  mkdirSync15(contextDir, { recursive: true });
   const cached = {
     phrases,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     sourceHash
   };
-  writeFileSync15(join52(contextDir, DESCRIPTOR_FILE), JSON.stringify(cached, null, 2), "utf-8");
+  writeFileSync16(join53(contextDir, DESCRIPTOR_FILE), JSON.stringify(cached, null, 2), "utf-8");
 }
 function generateDescriptors(repoRoot) {
   const profile = loadToolProfile(repoRoot);
@@ -46883,11 +47073,11 @@ function generateDescriptors(repoRoot) {
   return phrases;
 }
 function extractFromPackageJson(repoRoot, tags) {
-  const pkgPath = join52(repoRoot, "package.json");
+  const pkgPath = join53(repoRoot, "package.json");
   try {
-    if (!existsSync37(pkgPath))
+    if (!existsSync38(pkgPath))
       return;
-    const pkg = JSON.parse(readFileSync26(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync27(pkgPath, "utf-8"));
     if (pkg.name && typeof pkg.name === "string") {
       const parts = pkg.name.replace(/^@/, "").split("/");
       for (const p of parts)
@@ -46931,7 +47121,7 @@ function extractFromManifests(repoRoot, tags) {
     { file: ".github/workflows", tag: "ci/cd" }
   ];
   for (const check of manifestChecks) {
-    if (existsSync37(join52(repoRoot, check.file))) {
+    if (existsSync38(join53(repoRoot, check.file))) {
       tags.push(check.tag);
     }
   }
@@ -46953,16 +47143,16 @@ function extractFromSessions(repoRoot, tags) {
   }
 }
 function extractFromMemory(repoRoot, tags) {
-  const memoryDir = join52(repoRoot, OA_DIR, "memory");
+  const memoryDir = join53(repoRoot, OA_DIR, "memory");
   try {
-    if (!existsSync37(memoryDir))
+    if (!existsSync38(memoryDir))
       return;
-    const files = readdirSync11(memoryDir).filter((f) => f.endsWith(".json"));
+    const files = readdirSync12(memoryDir).filter((f) => f.endsWith(".json"));
     for (const file of files) {
       const topic = file.replace(/\.json$/, "").replace(/[-_]/g, " ");
       tags.push(topic);
       try {
-        const data = JSON.parse(readFileSync26(join52(memoryDir, file), "utf-8"));
+        const data = JSON.parse(readFileSync27(join53(memoryDir, file), "utf-8"));
         if (data && typeof data === "object") {
           const keys = Object.keys(data).slice(0, 3);
           for (const key of keys) {
@@ -47595,13 +47785,13 @@ var init_stream_renderer = __esm({
 });
 
 // packages/cli/dist/tui/edit-history.js
-import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync15 } from "node:fs";
-import { join as join53 } from "node:path";
+import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync16 } from "node:fs";
+import { join as join54 } from "node:path";
 function createEditHistoryLogger(repoRoot, sessionId) {
-  const historyDir = join53(repoRoot, ".oa", "history");
-  const logPath = join53(historyDir, "edits.jsonl");
+  const historyDir = join54(repoRoot, ".oa", "history");
+  const logPath = join54(historyDir, "edits.jsonl");
   try {
-    mkdirSync15(historyDir, { recursive: true });
+    mkdirSync16(historyDir, { recursive: true });
   } catch {
   }
   function logToolCall(toolName, toolArgs, success) {
@@ -47710,17 +47900,17 @@ var init_edit_history = __esm({
 });
 
 // packages/cli/dist/tui/promptLoader.js
-import { readFileSync as readFileSync27, existsSync as existsSync38 } from "node:fs";
-import { join as join54, dirname as dirname18 } from "node:path";
+import { readFileSync as readFileSync28, existsSync as existsSync39 } from "node:fs";
+import { join as join55, dirname as dirname18 } 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 = join54(PROMPTS_DIR3, promptPath);
-    if (!existsSync38(fullPath)) {
+    const fullPath = join55(PROMPTS_DIR3, promptPath);
+    if (!existsSync39(fullPath)) {
       throw new Error(`Prompt file not found: ${fullPath}`);
     }
-    content = readFileSync27(fullPath, "utf-8");
+    content = readFileSync28(fullPath, "utf-8");
     cache3.set(promptPath, content);
   }
   if (!vars)
@@ -47733,23 +47923,23 @@ var init_promptLoader3 = __esm({
     "use strict";
     __filename3 = fileURLToPath11(import.meta.url);
     __dirname6 = dirname18(__filename3);
-    devPath2 = join54(__dirname6, "..", "..", "prompts");
-    publishedPath2 = join54(__dirname6, "..", "prompts");
-    PROMPTS_DIR3 = existsSync38(devPath2) ? devPath2 : publishedPath2;
+    devPath2 = join55(__dirname6, "..", "..", "prompts");
+    publishedPath2 = join55(__dirname6, "..", "prompts");
+    PROMPTS_DIR3 = existsSync39(devPath2) ? devPath2 : publishedPath2;
     cache3 = /* @__PURE__ */ new Map();
   }
 });
 
 // packages/cli/dist/tui/dream-engine.js
-import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync16, readFileSync as readFileSync28, existsSync as existsSync39, cpSync, rmSync, readdirSync as readdirSync12 } from "node:fs";
-import { join as join55, basename as basename12 } from "node:path";
+import { mkdirSync as mkdirSync17, writeFileSync as writeFileSync17, readFileSync as readFileSync29, existsSync as existsSync40, cpSync, rmSync as rmSync2, readdirSync as readdirSync13 } from "node:fs";
+import { join as join56, basename as basename12 } from "node:path";
 import { execSync as execSync28 } from "node:child_process";
 function loadAutoresearchMemory(repoRoot) {
-  const memoryPath = join55(repoRoot, ".oa", "memory", "autoresearch.json");
-  if (!existsSync39(memoryPath))
+  const memoryPath = join56(repoRoot, ".oa", "memory", "autoresearch.json");
+  if (!existsSync40(memoryPath))
     return "";
   try {
-    const raw = readFileSync28(memoryPath, "utf-8");
+    const raw = readFileSync29(memoryPath, "utf-8");
     const data = JSON.parse(raw);
     const sections = [];
     for (const key of AUTORESEARCH_MEMORY_KEYS) {
@@ -47939,14 +48129,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") ? join55(this.autoresearchDir, basename12(rawPath)) : join55(this.autoresearchDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/autoresearch") ? join56(this.autoresearchDir, basename12(rawPath)) : join56(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 = join55(targetPath, "..");
-          mkdirSync16(dir, { recursive: true });
-          writeFileSync16(targetPath, content, "utf-8");
+          const dir = join56(targetPath, "..");
+          mkdirSync17(dir, { recursive: true });
+          writeFileSync17(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 };
@@ -47974,20 +48164,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") ? join55(this.autoresearchDir, basename12(rawPath)) : join55(this.autoresearchDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/autoresearch") ? join56(this.autoresearchDir, basename12(rawPath)) : join56(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 (!existsSync39(targetPath)) {
+          if (!existsSync40(targetPath)) {
             return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: Date.now() - start };
           }
-          let content = readFileSync28(targetPath, "utf-8");
+          let content = readFileSync29(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);
-          writeFileSync16(targetPath, content, "utf-8");
+          writeFileSync17(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 };
@@ -48028,14 +48218,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") ? join55(this.dreamsDir, basename12(rawPath)) : join55(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join56(this.dreamsDir, basename12(rawPath)) : join56(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 = join55(targetPath, "..");
-          mkdirSync16(dir, { recursive: true });
-          writeFileSync16(targetPath, content, "utf-8");
+          const dir = join56(targetPath, "..");
+          mkdirSync17(dir, { recursive: true });
+          writeFileSync17(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 };
@@ -48063,20 +48253,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") ? join55(this.dreamsDir, basename12(rawPath)) : join55(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/dreams") ? join56(this.dreamsDir, basename12(rawPath)) : join56(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 (!existsSync39(targetPath)) {
+          if (!existsSync40(targetPath)) {
             return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: Date.now() - start };
           }
-          let content = readFileSync28(targetPath, "utf-8");
+          let content = readFileSync29(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);
-          writeFileSync16(targetPath, content, "utf-8");
+          writeFileSync17(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 };
@@ -48130,7 +48320,7 @@ var init_dream_engine = __esm({
       constructor(config, repoRoot) {
         this.config = config;
         this.repoRoot = repoRoot;
-        this.dreamsDir = join55(repoRoot, ".oa", "dreams");
+        this.dreamsDir = join56(repoRoot, ".oa", "dreams");
         this.state = {
           mode: "default",
           active: false,
@@ -48161,7 +48351,7 @@ var init_dream_engine = __esm({
           startedAt: (/* @__PURE__ */ new Date()).toISOString(),
           results: []
         };
-        mkdirSync16(this.dreamsDir, { recursive: true });
+        mkdirSync17(this.dreamsDir, { recursive: true });
         this.saveDreamState();
         try {
           for (let cycle = 1; cycle <= totalCycles; cycle++) {
@@ -48214,8 +48404,8 @@ ${result.summary}`;
             if (mode !== "default" || cycle === totalCycles) {
               renderDreamContraction(cycle);
               const cycleSummary = this.buildCycleSummary(cycle, previousFindings);
-              const summaryPath = join55(this.dreamsDir, `cycle-${cycle}-summary.md`);
-              writeFileSync16(summaryPath, cycleSummary, "utf-8");
+              const summaryPath = join56(this.dreamsDir, `cycle-${cycle}-summary.md`);
+              writeFileSync17(summaryPath, cycleSummary, "utf-8");
             }
             if (mode === "lucid" && !this.abortController.signal.aborted) {
               this.saveVersionCheckpoint(cycle);
@@ -48427,7 +48617,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 = join55(this.repoRoot, ".oa", "autoresearch");
+        const autoresearchDir = join56(this.repoRoot, ".oa", "autoresearch");
         const taskComplete = this.createSwarmTaskCompleteTool(role);
         switch (role) {
           case "researcher": {
@@ -48791,7 +48981,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 = join55(this.dreamsDir, `cycle-${cycleNum}-autoresearch-report.md`);
+        const reportPath = join56(this.dreamsDir, `cycle-${cycleNum}-autoresearch-report.md`);
         const report = `# Autoresearch Swarm Report \u2014 Cycle ${cycleNum}
 
 **Date**: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
@@ -48813,8 +49003,8 @@ ${summaryResult}
 *Generated by open-agents autoresearch swarm*
 `;
         try {
-          mkdirSync16(this.dreamsDir, { recursive: true });
-          writeFileSync16(reportPath, report, "utf-8");
+          mkdirSync17(this.dreamsDir, { recursive: true });
+          writeFileSync17(reportPath, report, "utf-8");
         } catch {
         }
         renderSwarmComplete(workspace);
@@ -48880,9 +49070,9 @@ ${summaryResult}
       }
       /** Save workspace backup for lucid mode */
       saveVersionCheckpoint(cycle) {
-        const checkpointDir = join55(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
+        const checkpointDir = join56(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
         try {
-          mkdirSync16(checkpointDir, { recursive: true });
+          mkdirSync17(checkpointDir, { recursive: true });
           try {
             const gitStatus = execSync28("git status --porcelain", {
               cwd: this.repoRoot,
@@ -48899,10 +49089,10 @@ ${summaryResult}
               encoding: "utf-8",
               timeout: 5e3
             }).trim();
-            writeFileSync16(join55(checkpointDir, "git-status.txt"), gitStatus, "utf-8");
-            writeFileSync16(join55(checkpointDir, "git-diff.patch"), gitDiff, "utf-8");
-            writeFileSync16(join55(checkpointDir, "git-hash.txt"), gitHash, "utf-8");
-            writeFileSync16(join55(checkpointDir, "checkpoint.json"), JSON.stringify({
+            writeFileSync17(join56(checkpointDir, "git-status.txt"), gitStatus, "utf-8");
+            writeFileSync17(join56(checkpointDir, "git-diff.patch"), gitDiff, "utf-8");
+            writeFileSync17(join56(checkpointDir, "git-hash.txt"), gitHash, "utf-8");
+            writeFileSync17(join56(checkpointDir, "checkpoint.json"), JSON.stringify({
               cycle,
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
               gitHash,
@@ -48910,7 +49100,7 @@ ${summaryResult}
             }, null, 2), "utf-8");
             renderInfo(`Checkpoint saved: cycle ${cycle} (${gitHash.slice(0, 8)})`);
           } catch {
-            writeFileSync16(join55(checkpointDir, "checkpoint.json"), JSON.stringify({ cycle, timestamp: (/* @__PURE__ */ new Date()).toISOString(), mode: this.state.mode }, null, 2), "utf-8");
+            writeFileSync17(join56(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) {
@@ -48947,7 +49137,7 @@ Each proposal includes implementation entrypoints and estimated effort.
       /** Update the master proposal index */
       updateProposalIndex() {
         try {
-          const files = readdirSync12(this.dreamsDir).filter((f) => f.endsWith(".md") && f !== "PROPOSAL-INDEX.md" && f !== "dream-state.json").sort();
+          const files = readdirSync13(this.dreamsDir).filter((f) => f.endsWith(".md") && f !== "PROPOSAL-INDEX.md" && f !== "dream-state.json").sort();
           const index = `# Dream Proposals Index
 
 **Last updated**: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
@@ -48968,14 +49158,14 @@ ${files.map((f) => `- [\`${f}\`](./${f})`).join("\n")}
 ---
 *Auto-generated by open-agents dream engine*
 `;
-          writeFileSync16(join55(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
+          writeFileSync17(join56(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
         } catch {
         }
       }
       /** Save dream state for resume/inspection */
       saveDreamState() {
         try {
-          writeFileSync16(join55(this.dreamsDir, "dream-state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
+          writeFileSync17(join56(this.dreamsDir, "dream-state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
         } catch {
         }
       }
@@ -49349,8 +49539,8 @@ var init_bless_engine = __esm({
 });
 
 // packages/cli/dist/tui/dmn-engine.js
-import { existsSync as existsSync40, readFileSync as readFileSync29, writeFileSync as writeFileSync17, mkdirSync as mkdirSync17, readdirSync as readdirSync13, unlinkSync as unlinkSync9 } from "node:fs";
-import { join as join56, basename as basename13 } from "node:path";
+import { existsSync as existsSync41, readFileSync as readFileSync30, writeFileSync as writeFileSync18, mkdirSync as mkdirSync18, readdirSync as readdirSync14, unlinkSync as unlinkSync9 } from "node:fs";
+import { join as join57, basename as basename13 } from "node:path";
 function buildDMNGatherPrompt(recentTaskSummaries, dueReminders, attentionItems, memoryTopics, capabilities, competence, reflectionBuffer) {
   const competenceReport = competence.length > 0 ? competence.map((c3) => {
     const rate = c3.attempts > 0 ? Math.round(c3.successes / c3.attempts * 100) : 0;
@@ -49463,9 +49653,9 @@ var init_dmn_engine = __esm({
       constructor(config, repoRoot) {
         this.config = config;
         this.repoRoot = repoRoot;
-        this.stateDir = join56(repoRoot, ".oa", "dmn");
-        this.historyDir = join56(repoRoot, ".oa", "dmn", "cycles");
-        mkdirSync17(this.historyDir, { recursive: true });
+        this.stateDir = join57(repoRoot, ".oa", "dmn");
+        this.historyDir = join57(repoRoot, ".oa", "dmn", "cycles");
+        mkdirSync18(this.historyDir, { recursive: true });
         this.loadState();
       }
       get stats() {
@@ -50054,14 +50244,14 @@ OUTPUT: Call task_complete with JSON:
       async gatherMemoryTopics() {
         const topics = [];
         const dirs = [
-          join56(this.repoRoot, ".oa", "memory"),
-          join56(this.repoRoot, ".open-agents", "memory")
+          join57(this.repoRoot, ".oa", "memory"),
+          join57(this.repoRoot, ".open-agents", "memory")
         ];
         for (const dir of dirs) {
-          if (!existsSync40(dir))
+          if (!existsSync41(dir))
             continue;
           try {
-            const files = readdirSync13(dir).filter((f) => f.endsWith(".json"));
+            const files = readdirSync14(dir).filter((f) => f.endsWith(".json"));
             for (const f of files) {
               const topic = basename13(f, ".json");
               if (!topics.includes(topic))
@@ -50074,29 +50264,29 @@ OUTPUT: Call task_complete with JSON:
       }
       // ── State persistence ─────────────────────────────────────────────────
       loadState() {
-        const path = join56(this.stateDir, "state.json");
-        if (existsSync40(path)) {
+        const path = join57(this.stateDir, "state.json");
+        if (existsSync41(path)) {
           try {
-            this.state = JSON.parse(readFileSync29(path, "utf-8"));
+            this.state = JSON.parse(readFileSync30(path, "utf-8"));
           } catch {
           }
         }
       }
       saveState() {
         try {
-          writeFileSync17(join56(this.stateDir, "state.json"), JSON.stringify(this.state, null, 2) + "\n", "utf-8");
+          writeFileSync18(join57(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`;
-          writeFileSync17(join56(this.historyDir, filename), JSON.stringify(result, null, 2) + "\n", "utf-8");
-          const files = readdirSync13(this.historyDir).filter((f) => f.startsWith("cycle-") && f.endsWith(".json")).sort();
+          writeFileSync18(join57(this.historyDir, filename), JSON.stringify(result, null, 2) + "\n", "utf-8");
+          const files = readdirSync14(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 {
-                unlinkSync9(join56(this.historyDir, old));
+                unlinkSync9(join57(this.historyDir, old));
               } catch {
               }
             }
@@ -50109,8 +50299,8 @@ OUTPUT: Call task_complete with JSON:
 });
 
 // packages/cli/dist/tui/snr-engine.js
-import { existsSync as existsSync41, readdirSync as readdirSync14, readFileSync as readFileSync30 } from "node:fs";
-import { join as join57, basename as basename14 } from "node:path";
+import { existsSync as existsSync42, readdirSync as readdirSync15, readFileSync as readFileSync31 } from "node:fs";
+import { join as join58, basename as basename14 } from "node:path";
 function computeDPrime(signalScores, noiseScores) {
   if (signalScores.length === 0 || noiseScores.length === 0)
     return 0;
@@ -50350,20 +50540,20 @@ Call task_complete with the JSON array when done.`, onEvent)
       loadMemoryEntries(topics) {
         const entries = [];
         const dirs = [
-          join57(this.repoRoot, ".oa", "memory"),
-          join57(this.repoRoot, ".open-agents", "memory")
+          join58(this.repoRoot, ".oa", "memory"),
+          join58(this.repoRoot, ".open-agents", "memory")
         ];
         for (const dir of dirs) {
-          if (!existsSync41(dir))
+          if (!existsSync42(dir))
             continue;
           try {
-            const files = readdirSync14(dir).filter((f) => f.endsWith(".json"));
+            const files = readdirSync15(dir).filter((f) => f.endsWith(".json"));
             for (const f of files) {
               const topic = basename14(f, ".json");
               if (topics.length > 0 && !topics.includes(topic))
                 continue;
               try {
-                const data = JSON.parse(readFileSync30(join57(dir, f), "utf-8"));
+                const data = JSON.parse(readFileSync31(join58(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 });
@@ -50930,8 +51120,8 @@ var init_tool_policy = __esm({
 });
 
 // packages/cli/dist/tui/telegram-bridge.js
-import { mkdirSync as mkdirSync18, existsSync as existsSync42, unlinkSync as unlinkSync10, readdirSync as readdirSync15, statSync as statSync13 } from "node:fs";
-import { join as join58, resolve as resolve28 } from "node:path";
+import { mkdirSync as mkdirSync19, existsSync as existsSync43, unlinkSync as unlinkSync10, readdirSync as readdirSync16, statSync as statSync14 } from "node:fs";
+import { join as join59, resolve as resolve28 } from "node:path";
 import { writeFile as writeFileAsync } from "node:fs/promises";
 function convertMarkdownToTelegramHTML(md) {
   let html = md;
@@ -51259,7 +51449,7 @@ with summary "no_reply" to silently skip without responding.
         this.polling = true;
         this.abortController = new AbortController();
         try {
-          mkdirSync18(this.mediaCacheDir, { recursive: true });
+          mkdirSync19(this.mediaCacheDir, { recursive: true });
         } catch {
         }
         this.mediaCacheCleanupTimer = setInterval(() => this.cleanupMediaCache(), 5 * 60 * 1e3);
@@ -51696,7 +51886,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 = join58(this.mediaCacheDir, fileName);
+          const localPath = join59(this.mediaCacheDir, fileName);
           await writeFileAsync(localPath, buffer);
           return localPath;
         } catch {
@@ -53030,7 +53220,7 @@ var init_text_selection = __esm({
 });
 
 // packages/cli/dist/tui/status-bar.js
-import { readFileSync as readFileSync31 } from "node:fs";
+import { readFileSync as readFileSync32 } from "node:fs";
 function setTerminalTitle(task, version) {
   if (!process.stdout.isTTY)
     return;
@@ -53705,7 +53895,7 @@ var init_status_bar = __esm({
             if (nexusDir) {
               try {
                 const metricsPath = nexusDir + "/remote-metrics.json";
-                const raw = readFileSync31(metricsPath, "utf8");
+                const raw = readFileSync32(metricsPath, "utf8");
                 const cached = JSON.parse(raw);
                 if (cached && cached.ts && Date.now() - cached.ts < 6e4) {
                   const m = cached.data;
@@ -55136,11 +55326,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 resolve29, join as join59, dirname as dirname19, extname as extname10 } from "node:path";
+import { resolve as resolve29, join as join60, dirname as dirname19, extname as extname10 } from "node:path";
 import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath as fileURLToPath12 } from "node:url";
-import { readFileSync as readFileSync32, writeFileSync as writeFileSync18, appendFileSync as appendFileSync4, rmSync as rmSync2, readdirSync as readdirSync16, mkdirSync as mkdirSync19 } from "node:fs";
-import { existsSync as existsSync43 } from "node:fs";
+import { readFileSync as readFileSync33, writeFileSync as writeFileSync19, appendFileSync as appendFileSync4, rmSync as rmSync3, readdirSync as readdirSync17, mkdirSync as mkdirSync20 } from "node:fs";
+import { existsSync as existsSync44 } from "node:fs";
 import { execSync as execSync30 } from "node:child_process";
 import { homedir as homedir13 } from "node:os";
 function formatTimeAgo(date) {
@@ -55161,12 +55351,12 @@ function getVersion3() {
     const require2 = createRequire2(import.meta.url);
     const thisDir = dirname19(fileURLToPath12(import.meta.url));
     const candidates = [
-      join59(thisDir, "..", "package.json"),
-      join59(thisDir, "..", "..", "package.json"),
-      join59(thisDir, "..", "..", "..", "package.json")
+      join60(thisDir, "..", "package.json"),
+      join60(thisDir, "..", "..", "package.json"),
+      join60(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync43(pkgPath)) {
+      if (existsSync44(pkgPath)) {
         const pkg = require2(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           return pkg.version ?? "0.0.0";
@@ -55387,15 +55577,15 @@ Use task_status("${taskId}") or task_output("${taskId}") to check progress.`
 function gatherMemorySnippets(root) {
   const snippets = [];
   const dirs = [
-    join59(root, ".oa", "memory"),
-    join59(root, ".open-agents", "memory")
+    join60(root, ".oa", "memory"),
+    join60(root, ".open-agents", "memory")
   ];
   for (const dir of dirs) {
-    if (!existsSync43(dir))
+    if (!existsSync44(dir))
       continue;
     try {
-      for (const f of readdirSync16(dir).filter((f2) => f2.endsWith(".json"))) {
-        const data = JSON.parse(readFileSync32(join59(dir, f), "utf-8"));
+      for (const f of readdirSync17(dir).filter((f2) => f2.endsWith(".json"))) {
+        const data = JSON.parse(readFileSync33(join60(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)
@@ -55530,9 +55720,9 @@ ${metabolismMemories}
   } catch {
   }
   try {
-    const archeFile = join59(repoRoot, ".oa", "arche", "variants.json");
-    if (existsSync43(archeFile)) {
-      const variants = JSON.parse(readFileSync32(archeFile, "utf8"));
+    const archeFile = join60(repoRoot, ".oa", "arche", "variants.json");
+    if (existsSync44(archeFile)) {
+      const variants = JSON.parse(readFileSync33(archeFile, "utf8"));
       if (variants.length > 0) {
         let filtered = variants;
         if (taskType) {
@@ -55669,9 +55859,9 @@ ${lines.join("\n")}
   const compactionThreshold = modelTier === "small" ? 12e3 : modelTier === "medium" ? 24e3 : 4e4;
   let identityInjection = "";
   try {
-    const ikStateFile = join59(repoRoot, ".oa", "identity", "self-state.json");
-    if (existsSync43(ikStateFile)) {
-      const selfState = JSON.parse(readFileSync32(ikStateFile, "utf8"));
+    const ikStateFile = join60(repoRoot, ".oa", "identity", "self-state.json");
+    if (existsSync44(ikStateFile)) {
+      const selfState = JSON.parse(readFileSync33(ikStateFile, "utf8"));
       const lines = [
         `[Identity State v${selfState.version}]`,
         `Self: ${selfState.narrative_summary}`,
@@ -56309,13 +56499,13 @@ When done, either call task_complete with your answer, or use FINAL_VAR(variable
           });
         }
         try {
-          const ikDir = join59(repoRoot, ".oa", "identity");
-          const ikFile = join59(ikDir, "self-state.json");
+          const ikDir = join60(repoRoot, ".oa", "identity");
+          const ikFile = join60(ikDir, "self-state.json");
           let ikState;
-          if (existsSync43(ikFile)) {
-            ikState = JSON.parse(readFileSync32(ikFile, "utf8"));
+          if (existsSync44(ikFile)) {
+            ikState = JSON.parse(readFileSync33(ikFile, "utf8"));
           } else {
-            mkdirSync19(ikDir, { recursive: true });
+            mkdirSync20(ikDir, { recursive: true });
             const machineId = Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
             ikState = {
               self_id: `oa-${machineId}`,
@@ -56341,7 +56531,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();
-          writeFileSync18(ikFile, JSON.stringify(ikState, null, 2));
+          writeFileSync19(ikFile, JSON.stringify(ikState, null, 2));
         } catch (ikErr) {
           try {
             console.error("[IK-OBSERVE]", ikErr);
@@ -56356,14 +56546,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 = join59(repoRoot, ".oa", "identity", "self-state.json");
-          if (existsSync43(ikFile)) {
-            const ikState = JSON.parse(readFileSync32(ikFile, "utf8"));
+          const ikFile = join60(repoRoot, ".oa", "identity", "self-state.json");
+          if (existsSync44(ikFile)) {
+            const ikState = JSON.parse(readFileSync33(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();
-            writeFileSync18(ikFile, JSON.stringify(ikState, null, 2));
+            writeFileSync19(ikFile, JSON.stringify(ikState, null, 2));
           }
         } catch {
         }
@@ -56686,7 +56876,7 @@ async function startInteractive(config, repoPath) {
   let p2pGateway = null;
   let peerMesh = null;
   let inferenceRouter = null;
-  const secretVault = new SecretVault(join59(repoRoot, ".oa", "vault.enc"));
+  const secretVault = new SecretVault(join60(repoRoot, ".oa", "vault.enc"));
   let adminSessionKey = null;
   const callSubAgents = /* @__PURE__ */ new Map();
   const streamRenderer = new StreamRenderer();
@@ -56906,13 +57096,13 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     const hits = allCompletions.filter((c3) => c3.toLowerCase().startsWith(lower));
     return [hits, line];
   }
-  const HISTORY_DIR = join59(homedir13(), ".open-agents");
-  const HISTORY_FILE = join59(HISTORY_DIR, "repl-history");
+  const HISTORY_DIR = join60(homedir13(), ".open-agents");
+  const HISTORY_FILE = join60(HISTORY_DIR, "repl-history");
   const MAX_HISTORY_LINES = 500;
   let savedHistory = [];
   try {
-    if (existsSync43(HISTORY_FILE)) {
-      const raw = readFileSync32(HISTORY_FILE, "utf8").trim();
+    if (existsSync44(HISTORY_FILE)) {
+      const raw = readFileSync33(HISTORY_FILE, "utf8").trim();
       if (raw)
         savedHistory = raw.split("\n").reverse();
     }
@@ -56998,12 +57188,12 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     if (!line.trim())
       return;
     try {
-      mkdirSync19(HISTORY_DIR, { recursive: true });
+      mkdirSync20(HISTORY_DIR, { recursive: true });
       appendFileSync4(HISTORY_FILE, line + "\n", "utf8");
       if (Math.random() < 0.02) {
-        const all = readFileSync32(HISTORY_FILE, "utf8").trim().split("\n");
+        const all = readFileSync33(HISTORY_FILE, "utf8").trim().split("\n");
         if (all.length > MAX_HISTORY_LINES) {
-          writeFileSync18(HISTORY_FILE, all.slice(-MAX_HISTORY_LINES).join("\n") + "\n", "utf8");
+          writeFileSync19(HISTORY_FILE, all.slice(-MAX_HISTORY_LINES).join("\n") + "\n", "utf8");
         }
       }
     } catch {
@@ -57179,7 +57369,7 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     } catch {
     }
     try {
-      const oaDir = join59(repoRoot, ".oa");
+      const oaDir = join60(repoRoot, ".oa");
       const reconnected = await ExposeGateway.checkAndReconnect(oaDir, {
         onInfo: (msg) => writeContent(() => renderInfo(msg)),
         onError: (msg) => writeContent(() => renderWarning(msg))
@@ -57202,7 +57392,7 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     } catch {
     }
     try {
-      const oaDir = join59(repoRoot, ".oa");
+      const oaDir = join60(repoRoot, ".oa");
       const reconnectedP2P = await ExposeP2PGateway.checkAndReconnect(oaDir, new NexusTool(repoRoot), {
         onInfo: (msg) => writeContent(() => renderInfo(msg)),
         onError: (msg) => writeContent(() => renderWarning(msg))
@@ -58054,7 +58244,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
           kind,
           targetUrl,
           authKey,
-          stateDir: join59(repoRoot, ".oa"),
+          stateDir: join60(repoRoot, ".oa"),
           passthrough: passthrough ?? false,
           loadbalance: loadbalance ?? false,
           endpointAuth: passthrough ? currentConfig.apiKey : void 0,
@@ -58102,7 +58292,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: join59(repoRoot, ".oa") });
+      const newTunnel = new ExposeGateway({ kind, targetUrl, authKey, fullAccess, stateDir: join60(repoRoot, ".oa") });
       newTunnel.on("stats", (stats) => {
         statusBar.setExposeStatus({
           status: stats.status,
@@ -58371,10 +58561,10 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         writeContent(() => renderInfo(`Killed ${bgKilled} background task(s).`));
       }
       try {
-        const nexusDir = join59(repoRoot, OA_DIR, "nexus");
-        const pidFile = join59(nexusDir, "daemon.pid");
-        if (existsSync43(pidFile)) {
-          const pid = parseInt(readFileSync32(pidFile, "utf8").trim(), 10);
+        const nexusDir = join60(repoRoot, OA_DIR, "nexus");
+        const pidFile = join60(nexusDir, "daemon.pid");
+        if (existsSync44(pidFile)) {
+          const pid = parseInt(readFileSync33(pidFile, "utf8").trim(), 10);
           if (pid > 0) {
             try {
               if (process.platform === "win32") {
@@ -58396,13 +58586,13 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       } catch {
       }
       try {
-        const voiceDir2 = join59(homedir13(), ".open-agents", "voice");
+        const voiceDir2 = join60(homedir13(), ".open-agents", "voice");
         const voicePidFiles = ["luxtts-daemon.pid", "piper-daemon.pid"];
         for (const pf of voicePidFiles) {
-          const pidPath = join59(voiceDir2, pf);
-          if (existsSync43(pidPath)) {
+          const pidPath = join60(voiceDir2, pf);
+          if (existsSync44(pidPath)) {
             try {
-              const pid = parseInt(readFileSync32(pidPath, "utf8").trim(), 10);
+              const pid = parseInt(readFileSync33(pidPath, "utf8").trim(), 10);
               if (pid > 0) {
                 if (process.platform === "win32") {
                   try {
@@ -58426,12 +58616,12 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         execSync30(process.platform === "win32" ? "timeout /t 1 /nobreak >nul" : "sleep 0.5", { timeout: 3e3, stdio: "ignore" });
       } catch {
       }
-      const oaPath = join59(repoRoot, OA_DIR);
-      if (existsSync43(oaPath)) {
+      const oaPath = join60(repoRoot, OA_DIR);
+      if (existsSync44(oaPath)) {
         let deleted = false;
         for (let attempt = 0; attempt < 3; attempt++) {
           try {
-            rmSync2(oaPath, { recursive: true, force: true });
+            rmSync3(oaPath, { recursive: true, force: true });
             deleted = true;
             break;
           } catch (err) {
@@ -58799,8 +58989,8 @@ Execute this skill now. Follow the behavioral guidance above.`;
       }
     }
     const cleanPath = input.replace(/^['"]|['"]$/g, "").trim();
-    const isImage = isImagePath(cleanPath) && existsSync43(resolve29(repoRoot, cleanPath));
-    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync43(resolve29(repoRoot, cleanPath));
+    const isImage = isImagePath(cleanPath) && existsSync44(resolve29(repoRoot, cleanPath));
+    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync44(resolve29(repoRoot, cleanPath));
     if (activeTask) {
       if (activeTask.runner.isPaused) {
         activeTask.runner.resume();
@@ -58809,7 +58999,7 @@ Execute this skill now. Follow the behavioral guidance above.`;
       if (isImage) {
         try {
           const imgPath = resolve29(repoRoot, cleanPath);
-          const imgBuffer = readFileSync32(imgPath);
+          const imgBuffer = readFileSync33(imgPath);
           const base64 = imgBuffer.toString("base64");
           const ext = extname10(cleanPath).toLowerCase();
           const mime = ext === ".png" ? "image/png" : ext === ".gif" ? "image/gif" : ext === ".webp" ? "image/webp" : "image/jpeg";
@@ -59307,13 +59497,13 @@ async function runWithTUI(task, config, repoPath) {
     const handle = startTask(task, config, repoRoot);
     await handle.promise;
     try {
-      const ikDir = join59(repoRoot, ".oa", "identity");
-      const ikFile = join59(ikDir, "self-state.json");
+      const ikDir = join60(repoRoot, ".oa", "identity");
+      const ikFile = join60(ikDir, "self-state.json");
       let ikState;
-      if (existsSync43(ikFile)) {
-        ikState = JSON.parse(readFileSync32(ikFile, "utf8"));
+      if (existsSync44(ikFile)) {
+        ikState = JSON.parse(readFileSync33(ikFile, "utf8"));
       } else {
-        mkdirSync19(ikDir, { recursive: true });
+        mkdirSync20(ikDir, { recursive: true });
         ikState = {
           self_id: `oa-${Date.now().toString(36)}`,
           version: 1,
@@ -59335,7 +59525,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();
-      writeFileSync18(ikFile, JSON.stringify(ikState, null, 2));
+      writeFileSync19(ikFile, JSON.stringify(ikState, null, 2));
     } catch (ikErr) {
     }
     try {
@@ -59344,12 +59534,12 @@ async function runWithTUI(task, config, repoPath) {
       ec.archiveVariantSync(`Task: ${task.slice(0, 200)}`, "success \u2014 completed", ["general"]);
     } catch {
       try {
-        const archeDir = join59(repoRoot, ".oa", "arche");
-        const archeFile = join59(archeDir, "variants.json");
+        const archeDir = join60(repoRoot, ".oa", "arche");
+        const archeFile = join60(archeDir, "variants.json");
         let variants = [];
         try {
-          if (existsSync43(archeFile))
-            variants = JSON.parse(readFileSync32(archeFile, "utf8"));
+          if (existsSync44(archeFile))
+            variants = JSON.parse(readFileSync33(archeFile, "utf8"));
         } catch {
         }
         variants.push({
@@ -59364,15 +59554,15 @@ async function runWithTUI(task, config, repoPath) {
         });
         if (variants.length > 50)
           variants = variants.slice(-50);
-        mkdirSync19(archeDir, { recursive: true });
-        writeFileSync18(archeFile, JSON.stringify(variants, null, 2));
+        mkdirSync20(archeDir, { recursive: true });
+        writeFileSync19(archeFile, JSON.stringify(variants, null, 2));
       } catch {
       }
     }
     try {
-      const metaFile = join59(repoRoot, ".oa", "memory", "metabolism", "store.json");
-      if (existsSync43(metaFile)) {
-        const store = JSON.parse(readFileSync32(metaFile, "utf8"));
+      const metaFile = join60(repoRoot, ".oa", "memory", "metabolism", "store.json");
+      if (existsSync44(metaFile)) {
+        const store = JSON.parse(readFileSync33(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) {
@@ -59383,7 +59573,7 @@ async function runWithTUI(task, config, repoPath) {
           updated = true;
         }
         if (updated) {
-          writeFileSync18(metaFile, JSON.stringify(store, null, 2));
+          writeFileSync19(metaFile, JSON.stringify(store, null, 2));
         }
       }
     } catch {
@@ -59436,9 +59626,9 @@ Rules:
           try {
             const { initDb: initDb2 } = __require("@open-agents/memory");
             const { ProceduralMemoryStore: ProceduralMemoryStore2 } = __require("@open-agents/memory");
-            const dbDir = join59(repoRoot, ".oa", "memory");
-            mkdirSync19(dbDir, { recursive: true });
-            const db = initDb2(join59(dbDir, "structured.db"));
+            const dbDir = join60(repoRoot, ".oa", "memory");
+            mkdirSync20(dbDir, { recursive: true });
+            const db = initDb2(join60(dbDir, "structured.db"));
             const memStore = new ProceduralMemoryStore2(db);
             memStore.createWithEmbedding({
               content: content.slice(0, 600),
@@ -59453,12 +59643,12 @@ Rules:
             db.close();
           } catch {
           }
-          const metaDir = join59(repoRoot, ".oa", "memory", "metabolism");
-          const storeFile = join59(metaDir, "store.json");
+          const metaDir = join60(repoRoot, ".oa", "memory", "metabolism");
+          const storeFile = join60(metaDir, "store.json");
           let store = [];
           try {
-            if (existsSync43(storeFile))
-              store = JSON.parse(readFileSync32(storeFile, "utf8"));
+            if (existsSync44(storeFile))
+              store = JSON.parse(readFileSync33(storeFile, "utf8"));
           } catch {
           }
           store.push({
@@ -59474,26 +59664,26 @@ Rules:
           });
           if (store.length > 100)
             store = store.slice(-100);
-          mkdirSync19(metaDir, { recursive: true });
-          writeFileSync18(storeFile, JSON.stringify(store, null, 2));
+          mkdirSync20(metaDir, { recursive: true });
+          writeFileSync19(storeFile, JSON.stringify(store, null, 2));
         }
       }
     } catch {
     }
     try {
-      const cohereSettingsFile = join59(repoRoot, ".oa", "settings.json");
+      const cohereSettingsFile = join60(repoRoot, ".oa", "settings.json");
       let cohereActive = false;
       try {
-        if (existsSync43(cohereSettingsFile)) {
-          const settings = JSON.parse(readFileSync32(cohereSettingsFile, "utf8"));
+        if (existsSync44(cohereSettingsFile)) {
+          const settings = JSON.parse(readFileSync33(cohereSettingsFile, "utf8"));
           cohereActive = settings.cohere === true;
         }
       } catch {
       }
       if (cohereActive) {
-        const metaFile = join59(repoRoot, ".oa", "memory", "metabolism", "store.json");
-        if (existsSync43(metaFile)) {
-          const store = JSON.parse(readFileSync32(metaFile, "utf8"));
+        const metaFile = join60(repoRoot, ".oa", "memory", "metabolism", "store.json");
+        if (existsSync44(metaFile)) {
+          const store = JSON.parse(readFileSync33(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 {
@@ -59518,18 +59708,18 @@ Rules:
     }
   } catch (err) {
     try {
-      const ikFile = join59(repoRoot, ".oa", "identity", "self-state.json");
-      if (existsSync43(ikFile)) {
-        const ikState = JSON.parse(readFileSync32(ikFile, "utf8"));
+      const ikFile = join60(repoRoot, ".oa", "identity", "self-state.json");
+      if (existsSync44(ikFile)) {
+        const ikState = JSON.parse(readFileSync33(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();
-        writeFileSync18(ikFile, JSON.stringify(ikState, null, 2));
+        writeFileSync19(ikFile, JSON.stringify(ikState, null, 2));
       }
-      const metaFile = join59(repoRoot, ".oa", "memory", "metabolism", "store.json");
-      if (existsSync43(metaFile)) {
-        const store = JSON.parse(readFileSync32(metaFile, "utf8"));
+      const metaFile = join60(repoRoot, ".oa", "memory", "metabolism", "store.json");
+      if (existsSync44(metaFile)) {
+        const store = JSON.parse(readFileSync33(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;
@@ -59537,15 +59727,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);
         }
-        writeFileSync18(metaFile, JSON.stringify(store, null, 2));
+        writeFileSync19(metaFile, JSON.stringify(store, null, 2));
       }
       try {
-        const archeDir = join59(repoRoot, ".oa", "arche");
-        const archeFile = join59(archeDir, "variants.json");
+        const archeDir = join60(repoRoot, ".oa", "arche");
+        const archeFile = join60(archeDir, "variants.json");
         let variants = [];
         try {
-          if (existsSync43(archeFile))
-            variants = JSON.parse(readFileSync32(archeFile, "utf8"));
+          if (existsSync44(archeFile))
+            variants = JSON.parse(readFileSync33(archeFile, "utf8"));
         } catch {
         }
         variants.push({
@@ -59560,8 +59750,8 @@ Rules:
         });
         if (variants.length > 50)
           variants = variants.slice(-50);
-        mkdirSync19(archeDir, { recursive: true });
-        writeFileSync18(archeFile, JSON.stringify(variants, null, 2));
+        mkdirSync20(archeDir, { recursive: true });
+        writeFileSync19(archeFile, JSON.stringify(variants, null, 2));
       } catch {
       }
     } catch {
@@ -59646,7 +59836,7 @@ import { glob } from "glob";
 import ignore from "ignore";
 import { readFile as readFile22, stat as stat4 } from "node:fs/promises";
 import { createHash as createHash4 } from "node:crypto";
-import { join as join60, relative as relative3, extname as extname11, basename as basename15 } from "node:path";
+import { join as join61, relative as relative3, extname as extname11, basename as basename15 } from "node:path";
 var DEFAULT_EXCLUDE, LANGUAGE_MAP, CodebaseIndexer;
 var init_codebase_indexer = __esm({
   "packages/indexer/dist/codebase-indexer.js"() {
@@ -59690,7 +59880,7 @@ var init_codebase_indexer = __esm({
         const ig = ignore.default();
         if (this.config.respectGitignore) {
           try {
-            const gitignoreContent = await readFile22(join60(this.config.rootDir, ".gitignore"), "utf-8");
+            const gitignoreContent = await readFile22(join61(this.config.rootDir, ".gitignore"), "utf-8");
             ig.add(gitignoreContent);
           } catch {
           }
@@ -59705,7 +59895,7 @@ var init_codebase_indexer = __esm({
         for (const relativePath of files) {
           if (ig.ignores(relativePath))
             continue;
-          const fullPath = join60(this.config.rootDir, relativePath);
+          const fullPath = join61(this.config.rootDir, relativePath);
           try {
             const fileStat = await stat4(fullPath);
             if (fileStat.size > this.config.maxFileSize)
@@ -59751,7 +59941,7 @@ var init_codebase_indexer = __esm({
               if (!child) {
                 child = {
                   name: part,
-                  path: join60(current.path, part),
+                  path: join61(current.path, part),
                   type: "directory",
                   children: []
                 };
@@ -59834,17 +60024,17 @@ __export(index_repo_exports, {
   indexRepoCommand: () => indexRepoCommand
 });
 import { resolve as resolve30 } from "node:path";
-import { existsSync as existsSync44, statSync as statSync14 } from "node:fs";
+import { existsSync as existsSync45, statSync as statSync15 } from "node:fs";
 import { cwd as cwd2 } from "node:process";
 async function indexRepoCommand(opts, _config) {
   const repoRoot = resolve30(opts.repoPath ?? cwd2());
   printHeader("Index Repository");
   printInfo(`Indexing: ${repoRoot}`);
-  if (!existsSync44(repoRoot)) {
+  if (!existsSync45(repoRoot)) {
     printError(`Path does not exist: ${repoRoot}`);
     process.exit(1);
   }
-  const stat5 = statSync14(repoRoot);
+  const stat5 = statSync15(repoRoot);
   if (!stat5.isDirectory()) {
     printError(`Path is not a directory: ${repoRoot}`);
     process.exit(1);
@@ -60092,7 +60282,7 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { join as join61, resolve as resolve31 } from "node:path";
+import { join as join62, resolve as resolve31 } from "node:path";
 import { homedir as homedir14 } from "node:os";
 import { cwd as cwd3 } from "node:process";
 function redactIfSensitive(key, value) {
@@ -60175,7 +60365,7 @@ function handleShow(opts, config) {
     }
   }
   printSection("Config File");
-  printInfo(`~/.open-agents/config.json (${join61(homedir14(), ".open-agents", "config.json")})`);
+  printInfo(`~/.open-agents/config.json (${join62(homedir14(), ".open-agents", "config.json")})`);
   printSection("Priority Chain");
   printInfo("  1. CLI flags (--model, --backend-url, etc.)");
   printInfo("  2. Project .oa/settings.json (--local)");
@@ -60214,7 +60404,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 ${join61(repoRoot, ".oa", "settings.json")}`);
+      printInfo(`Saved to ${join62(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)}`);
@@ -60472,8 +60662,8 @@ __export(eval_exports, {
   evalCommand: () => evalCommand
 });
 import { tmpdir as tmpdir10 } from "node:os";
-import { mkdirSync as mkdirSync20, writeFileSync as writeFileSync19 } from "node:fs";
-import { join as join62 } from "node:path";
+import { mkdirSync as mkdirSync21, writeFileSync as writeFileSync20 } from "node:fs";
+import { join as join63 } from "node:path";
 async function evalCommand(opts, config) {
   const suiteName = opts.suite ?? "basic";
   const suite = SUITES[suiteName];
@@ -60598,9 +60788,9 @@ async function evalCommand(opts, config) {
   process.exit(failed > 0 ? 1 : 0);
 }
 function createTempEvalRepo() {
-  const dir = join62(tmpdir10(), `open-agents-eval-${Date.now()}`);
-  mkdirSync20(dir, { recursive: true });
-  writeFileSync19(join62(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
+  const dir = join63(tmpdir10(), `open-agents-eval-${Date.now()}`);
+  mkdirSync21(dir, { recursive: true });
+  writeFileSync20(join63(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
   return dir;
 }
 var BASIC_SUITE, FULL_SUITE, SUITES;
@@ -60660,7 +60850,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 dirname20, join as join63 } from "node:path";
+import { dirname as dirname20, join as join64 } from "node:path";
 
 // packages/cli/dist/cli.js
 import { createInterface } from "node:readline";
@@ -60767,7 +60957,7 @@ init_output();
 function getVersion4() {
   try {
     const require2 = createRequire3(import.meta.url);
-    const pkgPath = join63(dirname20(fileURLToPath13(import.meta.url)), "..", "package.json");
+    const pkgPath = join64(dirname20(fileURLToPath13(import.meta.url)), "..", "package.json");
     const pkg = require2(pkgPath);
     return pkg.version;
   } catch {