omnius 1.0.342 → 1.0.343

package/dist/index.js

@@ -150501,9 +150501,9 @@ var require_mock_utils = __commonJS({
       if (mockDispatch2.data.callback) {
         mockDispatch2.data = { ...mockDispatch2.data, ...mockDispatch2.data.callback(opts) };
       }
-      const { data: { statusCode, data, headers, trailers, error }, delay: delay3, persist: persist3 } = mockDispatch2;
+      const { data: { statusCode, data, headers, trailers, error }, delay: delay3, persist: persist4 } = mockDispatch2;
       const { timesInvoked, times } = mockDispatch2;
-      mockDispatch2.consumed = !persist3 && timesInvoked >= times;
+      mockDispatch2.consumed = !persist4 && timesInvoked >= times;
       mockDispatch2.pending = timesInvoked < times;
       if (error !== null) {
         deleteMockDispatch(this[kDispatches], key);
@@ -151150,14 +151150,14 @@ var require_pending_interceptors_formatter = __commonJS({
       }
       format(pendingInterceptors) {
         const withPrettyHeaders = pendingInterceptors.map(
-          ({ method, path: path12, data: { statusCode }, persist: persist3, times, timesInvoked, origin }) => ({
+          ({ method, path: path12, data: { statusCode }, persist: persist4, times, timesInvoked, origin }) => ({
             Method: method,
             Origin: origin,
             Path: path12,
             "Status code": statusCode,
-            Persistent: persist3 ? PERSISTENT : NOT_PERSISTENT,
+            Persistent: persist4 ? PERSISTENT : NOT_PERSISTENT,
             Invocations: timesInvoked,
-            Remaining: persist3 ? Infinity : times - timesInvoked
+            Remaining: persist4 ? Infinity : times - timesInvoked
           })
         );
         this.logger.table(withPrettyHeaders);
@@ -273135,9 +273135,9 @@ print("${sentinel}")
         if (!this.proc || this.proc.killed) {
           return { success: false, path: "" };
         }
-        const { mkdirSync: mkdirSync105, writeFileSync: writeFileSync90 } = await import("node:fs");
+        const { mkdirSync: mkdirSync106, writeFileSync: writeFileSync91 } = await import("node:fs");
         const sessionDir2 = join43(this.cwd, ".omnius", "rlm");
-        mkdirSync105(sessionDir2, { recursive: true });
+        mkdirSync106(sessionDir2, { recursive: true });
         const sessionPath2 = join43(sessionDir2, "session.json");
         try {
           const inspectCode = `
@@ -273161,7 +273161,7 @@ print("__SESSION__" + json.dumps(_session) + "__SESSION__")
               trajectoryCount: this.trajectory.length,
               subCallCount: this.subCallCount
             };
-            writeFileSync90(sessionPath2, JSON.stringify(sessionData, null, 2), "utf8");
+            writeFileSync91(sessionPath2, JSON.stringify(sessionData, null, 2), "utf8");
             return { success: true, path: sessionPath2 };
           }
         } catch {
@@ -273173,11 +273173,11 @@ print("__SESSION__" + json.dumps(_session) + "__SESSION__")
        *  what was previously computed. */
       async loadSessionInfo() {
         try {
-          const { readFileSync: readFileSync133, existsSync: existsSync163 } = await import("node:fs");
+          const { readFileSync: readFileSync134, existsSync: existsSync164 } = await import("node:fs");
           const sessionPath2 = join43(this.cwd, ".omnius", "rlm", "session.json");
-          if (!existsSync163(sessionPath2))
+          if (!existsSync164(sessionPath2))
             return null;
-          return JSON.parse(readFileSync133(sessionPath2, "utf8"));
+          return JSON.parse(readFileSync134(sessionPath2, "utf8"));
         } catch {
           return null;
         }
@@ -273364,10 +273364,10 @@ var init_memory_metabolism = __esm({
         const trajDir = join44(this.cwd, ".omnius", "rlm-trajectories");
         let lessons = [];
         try {
-          const { readdirSync: readdirSync59, readFileSync: readFileSync133 } = await import("node:fs");
+          const { readdirSync: readdirSync59, readFileSync: readFileSync134 } = await import("node:fs");
           const files = readdirSync59(trajDir).filter((f2) => f2.endsWith(".jsonl")).sort().reverse().slice(0, 3);
           for (const file of files) {
-            const lines = readFileSync133(join44(trajDir, file), "utf8").split("\n").filter((l2) => l2.trim());
+            const lines = readFileSync134(join44(trajDir, file), "utf8").split("\n").filter((l2) => l2.trim());
             for (const line of lines) {
               try {
                 const entry = JSON.parse(line);
@@ -273751,14 +273751,14 @@ ${issues.map((i2) => `  - ${i2}`).join("\n")}` : "  No issues found."),
        * Optionally filter by task type for phase-aware context (FSM paper insight).
        */
       getTopMemoriesSync(k = 5, taskType) {
-        const { readFileSync: readFileSync133, existsSync: existsSync163 } = __require("node:fs");
+        const { readFileSync: readFileSync134, existsSync: existsSync164 } = __require("node:fs");
         const metaDir = join44(this.cwd, ".omnius", "memory", "metabolism");
         const storeFile = join44(metaDir, "store.json");
-        if (!existsSync163(storeFile))
+        if (!existsSync164(storeFile))
           return "";
         let store2 = [];
         try {
-          store2 = JSON.parse(readFileSync133(storeFile, "utf8"));
+          store2 = JSON.parse(readFileSync134(storeFile, "utf8"));
         } catch {
           return "";
         }
@@ -273780,14 +273780,14 @@ ${issues.map((i2) => `  - ${i2}`).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: readFileSync133, writeFileSync: writeFileSync90, existsSync: existsSync163, mkdirSync: mkdirSync105 } = __require("node:fs");
+        const { readFileSync: readFileSync134, writeFileSync: writeFileSync91, existsSync: existsSync164, mkdirSync: mkdirSync106 } = __require("node:fs");
         const metaDir = join44(this.cwd, ".omnius", "memory", "metabolism");
         const storeFile = join44(metaDir, "store.json");
-        if (!existsSync163(storeFile))
+        if (!existsSync164(storeFile))
           return;
         let store2 = [];
         try {
-          store2 = JSON.parse(readFileSync133(storeFile, "utf8"));
+          store2 = JSON.parse(readFileSync134(storeFile, "utf8"));
         } catch {
           return;
         }
@@ -273811,8 +273811,8 @@ ${issues.map((i2) => `  - ${i2}`).join("\n")}` : "  No issues found."),
           updated = true;
         }
         if (updated) {
-          mkdirSync105(metaDir, { recursive: true });
-          writeFileSync90(storeFile, JSON.stringify(store2, null, 2));
+          mkdirSync106(metaDir, { recursive: true });
+          writeFileSync91(storeFile, JSON.stringify(store2, null, 2));
         }
       }
       // ── Storage ──────────────────────────────────────────────────────────
@@ -274234,13 +274234,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: readFileSync133, existsSync: existsSync163 } = __require("node:fs");
+        const { readFileSync: readFileSync134, existsSync: existsSync164 } = __require("node:fs");
         const archiveFile = join46(this.cwd, ".omnius", "arche", "variants.json");
-        if (!existsSync163(archiveFile))
+        if (!existsSync164(archiveFile))
           return "";
         let variants = [];
         try {
-          variants = JSON.parse(readFileSync133(archiveFile, "utf8"));
+          variants = JSON.parse(readFileSync134(archiveFile, "utf8"));
         } catch {
           return "";
         }
@@ -274258,13 +274258,13 @@ Recommendation: Strategy ${scored[0].index + 1} scores highest.`;
       }
       /** Archive a strategy variant synchronously (for task completion path) */
       archiveVariantSync(strategy, outcome, tags = []) {
-        const { readFileSync: readFileSync133, writeFileSync: writeFileSync90, existsSync: existsSync163, mkdirSync: mkdirSync105 } = __require("node:fs");
+        const { readFileSync: readFileSync134, writeFileSync: writeFileSync91, existsSync: existsSync164, mkdirSync: mkdirSync106 } = __require("node:fs");
         const dir = join46(this.cwd, ".omnius", "arche");
         const archiveFile = join46(dir, "variants.json");
         let variants = [];
         try {
-          if (existsSync163(archiveFile))
-            variants = JSON.parse(readFileSync133(archiveFile, "utf8"));
+          if (existsSync164(archiveFile))
+            variants = JSON.parse(readFileSync134(archiveFile, "utf8"));
         } catch {
         }
         variants.push({
@@ -274279,8 +274279,8 @@ Recommendation: Strategy ${scored[0].index + 1} scores highest.`;
         });
         if (variants.length > 50)
           variants = variants.slice(-50);
-        mkdirSync105(dir, { recursive: true });
-        writeFileSync90(archiveFile, JSON.stringify(variants, null, 2));
+        mkdirSync106(dir, { recursive: true });
+        writeFileSync91(archiveFile, JSON.stringify(variants, null, 2));
       }
       async saveArchive(variants) {
         const dir = join46(this.cwd, ".omnius", "arche");
@@ -296166,7 +296166,7 @@ var require_util9 = __commonJS({
       return path12;
     }
     exports.normalize = normalize2;
-    function join178(aRoot, aPath) {
+    function join179(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -296198,7 +296198,7 @@ var require_util9 = __commonJS({
       }
       return joined;
     }
-    exports.join = join178;
+    exports.join = join179;
     exports.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
@@ -296371,7 +296371,7 @@ var require_util9 = __commonJS({
             parsed.path = parsed.path.substring(0, index + 1);
           }
         }
-        sourceURL = join178(urlGenerate(parsed), sourceURL);
+        sourceURL = join179(urlGenerate(parsed), sourceURL);
       }
       return normalize2(sourceURL);
     }
@@ -511784,7 +511784,7 @@ var require_path_browserify = __commonJS({
         assertPath(path12);
         return path12.length > 0 && path12.charCodeAt(0) === 47;
       },
-      join: function join178() {
+      join: function join179() {
         if (arguments.length === 0)
           return ".";
         var joined;
@@ -563673,9 +563673,9 @@ var init_reflectionBuffer = __esm({
         this.persistPath = persistPath ?? null;
         if (this.persistPath) {
           try {
-            const { readFileSync: readFileSync133, existsSync: existsSync163 } = __require("node:fs");
-            if (existsSync163(this.persistPath)) {
-              this.state = JSON.parse(readFileSync133(this.persistPath, "utf-8"));
+            const { readFileSync: readFileSync134, existsSync: existsSync164 } = __require("node:fs");
+            if (existsSync164(this.persistPath)) {
+              this.state = JSON.parse(readFileSync134(this.persistPath, "utf-8"));
               return;
             }
           } catch {
@@ -563954,12 +563954,12 @@ var init_reflectionBuffer = __esm({
         if (!this.persistPath)
           return;
         try {
-          const { writeFileSync: writeFileSync90, mkdirSync: mkdirSync105, existsSync: existsSync163 } = __require("node:fs");
-          const { join: join178 } = __require("node:path");
-          const dir = join178(this.persistPath, "..");
-          if (!existsSync163(dir))
-            mkdirSync105(dir, { recursive: true });
-          writeFileSync90(this.persistPath, JSON.stringify(this.state, null, 2));
+          const { writeFileSync: writeFileSync91, mkdirSync: mkdirSync106, existsSync: existsSync164 } = __require("node:fs");
+          const { join: join179 } = __require("node:path");
+          const dir = join179(this.persistPath, "..");
+          if (!existsSync164(dir))
+            mkdirSync106(dir, { recursive: true });
+          writeFileSync91(this.persistPath, JSON.stringify(this.state, null, 2));
         } catch {
         }
       }
@@ -568654,19 +568654,27 @@ function isOllamaModelNotFoundResponse(status, text2, model) {
 function isBackendConnectionError(err) {
   if (err instanceof Error && err.name === "AbortError")
     return false;
+  return /fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EHOSTUNREACH|ENOTFOUND|EPIPE|socket hang up|UND_ERR/i.test(flattenErrorText(err));
+}
+function flattenErrorText(err) {
   const parts = [];
-  if (err instanceof Error) {
-    parts.push(err.message);
-    const cause = err.cause;
-    if (cause instanceof Error)
-      parts.push(cause.message);
-    const code8 = cause?.code;
-    if (typeof code8 === "string")
-      parts.push(code8);
-  } else if (typeof err === "string") {
-    parts.push(err);
-  }
-  return /fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EHOSTUNREACH|ENOTFOUND|EPIPE|socket hang up|UND_ERR/i.test(parts.join(" "));
+  let cur = err;
+  for (let depth = 0; depth < 5 && cur != null; depth++) {
+    if (cur instanceof Error) {
+      if (cur.message)
+        parts.push(cur.message);
+      const code8 = cur.code;
+      if (typeof code8 === "string")
+        parts.push(code8);
+      cur = cur.cause;
+    } else if (typeof cur === "string") {
+      parts.push(cur);
+      break;
+    } else {
+      break;
+    }
+  }
+  return parts.join(" ");
 }
 function computeEffectiveThink(params) {
   if (process.env["OMNIUS_FORCE_NO_THINK"] === "1")
@@ -580166,10 +580174,10 @@ ${this._completionCaveat}` : this._completionCaveat;
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
                 try {
-                  const { mkdirSync: mkdirSync105, readdirSync: readdirSync59, statSync: statSync59, unlinkSync: unlinkSync35, writeFileSync: writeFileSync90 } = __require("node:fs");
-                  const { join: join178 } = __require("node:path");
-                  const contextDir = join178(this._workingDirectory || process.cwd(), ".omnius", "context");
-                  mkdirSync105(contextDir, { recursive: true });
+                  const { mkdirSync: mkdirSync106, readdirSync: readdirSync59, statSync: statSync59, unlinkSync: unlinkSync35, writeFileSync: writeFileSync91 } = __require("node:fs");
+                  const { join: join179 } = __require("node:path");
+                  const contextDir = join179(this._workingDirectory || process.cwd(), ".omnius", "context");
+                  mkdirSync106(contextDir, { recursive: true });
                   const topEntities = this._temporalGraph.nodesByType("entity", 3);
                   const topFiles = this._temporalGraph.nodesByType("file", 3);
                   const topConcepts = this._temporalGraph.nodesByType("concept", 3);
@@ -580209,18 +580217,18 @@ ${this._completionCaveat}` : this._completionCaveat;
                   section("Top Files", topFiles);
                   section("Top Concepts", topConcepts);
                   lines.push("(Use file_read on this file for quick recall. See provenance JSON for full edge detail.)");
-                  const kgSummaryDir = join178(contextDir, "kg-summary");
-                  mkdirSync105(kgSummaryDir, { recursive: true });
+                  const kgSummaryDir = join179(contextDir, "kg-summary");
+                  mkdirSync106(kgSummaryDir, { recursive: true });
                   const summaryFilename = `kg-summary-${this._sessionId}.md`;
-                  const outPath = join178(kgSummaryDir, summaryFilename);
-                  writeFileSync90(outPath, lines.join("\n"), "utf-8");
-                  writeFileSync90(join178(kgSummaryDir, "latest.md"), lines.join("\n"), "utf-8");
-                  writeFileSync90(join178(contextDir, `kg-summary-latest.md`), [
+                  const outPath = join179(kgSummaryDir, summaryFilename);
+                  writeFileSync91(outPath, lines.join("\n"), "utf-8");
+                  writeFileSync91(join179(kgSummaryDir, "latest.md"), lines.join("\n"), "utf-8");
+                  writeFileSync91(join179(contextDir, `kg-summary-latest.md`), [
                     "Latest KG summary moved to `.omnius/context/kg-summary/latest.md`.",
                     "",
                     lines.join("\n")
                   ].join("\n"), "utf-8");
-                  writeFileSync90(join178(kgSummaryDir, "index.json"), JSON.stringify({
+                  writeFileSync91(join179(kgSummaryDir, "index.json"), JSON.stringify({
                     schema: "omnius.kg-summary-index.v1",
                     latest: "latest.md",
                     latestSessionFile: summaryFilename,
@@ -580232,7 +580240,7 @@ ${this._completionCaveat}` : this._completionCaveat;
                       const maxFiles = parseInt(process.env["OMNIUS_KG_SUMMARY_MAX_FILES"] || "60", 10) || 60;
                       const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
                       const summaries = readdirSync59(kgSummaryDir).filter((name10) => name10.startsWith("kg-summary-") && name10.endsWith(".md")).map((name10) => {
-                        const filePath = join178(kgSummaryDir, name10);
+                        const filePath = join179(kgSummaryDir, name10);
                         const stat8 = statSync59(filePath);
                         return { filePath, mtimeMs: stat8.mtimeMs };
                       }).sort((a2, b) => b.mtimeMs - a2.mtimeMs);
@@ -580519,11 +580527,11 @@ ${errOutput}`);
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
         try {
-          const { mkdirSync: mkdirSync105, writeFileSync: writeFileSync90 } = __require("node:fs");
-          const { join: join178 } = __require("node:path");
-          const resultsDir = join178(this.omniusStateDir(), "tool-results");
-          mkdirSync105(resultsDir, { recursive: true });
-          writeFileSync90(join178(resultsDir, `${handleId}.txt`), `# Tool: ${toolName}
+          const { mkdirSync: mkdirSync106, writeFileSync: writeFileSync91 } = __require("node:fs");
+          const { join: join179 } = __require("node:path");
+          const resultsDir = join179(this.omniusStateDir(), "tool-results");
+          mkdirSync106(resultsDir, { recursive: true });
+          writeFileSync91(join179(resultsDir, `${handleId}.txt`), `# Tool: ${toolName}
 # Turn: ${turn}
 # Timestamp: ${(/* @__PURE__ */ new Date()).toISOString()}
 # Size: ${result.output.length} chars, ${lineCount} lines
@@ -580916,10 +580924,10 @@ Actions: (1) list_directory on the parent directory to see what's there, (2) Che
         if (!this._workingDirectory)
           return;
         try {
-          const { mkdirSync: mkdirSync105, writeFileSync: writeFileSync90 } = __require("node:fs");
-          const { join: join178 } = __require("node:path");
-          const sessionDir2 = this.options.stateDir ? join178(this.omniusStateDir(), "session", this._sessionId) : join178(this._workingDirectory, ".omnius", "session", this._sessionId);
-          mkdirSync105(sessionDir2, { recursive: true });
+          const { mkdirSync: mkdirSync106, writeFileSync: writeFileSync91 } = __require("node:fs");
+          const { join: join179 } = __require("node:path");
+          const sessionDir2 = this.options.stateDir ? join179(this.omniusStateDir(), "session", this._sessionId) : join179(this._workingDirectory, ".omnius", "session", this._sessionId);
+          mkdirSync106(sessionDir2, { recursive: true });
           const checkpoint = {
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
             sessionId: this._sessionId,
@@ -580931,7 +580939,7 @@ Actions: (1) list_directory on the parent directory to see what's there, (2) Che
             memexEntryCount: this._memexArchive.size,
             fileRegistrySize: this._fileRegistry.size
           };
-          writeFileSync90(join178(sessionDir2, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
+          writeFileSync91(join179(sessionDir2, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
         } catch {
         }
       }
@@ -581620,8 +581628,8 @@ ${telegramPersonaHead}` : stripped
           let recoveredTokens = 0;
           for (const [filePath, entry] of entries) {
             try {
-              const { readFileSync: readFileSync133 } = await import("node:fs");
-              const content = readFileSync133(filePath, "utf8");
+              const { readFileSync: readFileSync134 } = await import("node:fs");
+              const content = readFileSync134(filePath, "utf8");
               const tokenEst = Math.ceil(content.length / 4);
               if (recoveredTokens + tokenEst > fileRecoveryBudget)
                 break;
@@ -583445,14 +583453,16 @@ ${result}`
       isTransientError(err) {
         if (err instanceof Error && err.fatal)
           return false;
-        const msg = err instanceof Error ? err.message : String(err);
+        const msg = flattenErrorText(err);
+        if (this.isRecoverableAuthError(err))
+          return true;
         if (/HTTP 402|402 Payment|payment required|insufficient (credits|funds|balance)/i.test(msg))
           return true;
         if (/HTTP 429|429 Too Many|rate.?limit|too many requests/i.test(msg))
           return true;
         if (/Backend HTTP (502|503|504)/i.test(msg))
           return true;
-        if (/fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EPIPE|socket hang up/i.test(msg))
+        if (/fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EPIPE|socket hang up|UND_ERR|other side closed/i.test(msg))
           return true;
         if (/received HTML error page/i.test(msg))
           return true;
@@ -583472,6 +583482,16 @@ ${result}`
         const msg = err instanceof Error ? err.message : String(err);
         return /No GPU slot available after 30s\. All slots occupied\./i.test(msg);
       }
+      /**
+       * Recoverable authentication/session error (HTTP 401/403). Distinguished
+       * from a hard config error: this fires when a previously-working backend
+       * loses its session (e.g. "No cookie auth credentials found" after a socket
+       * reset). The fix is to re-authenticate and retry, not to abort the task.
+       */
+      isRecoverableAuthError(err) {
+        const msg = flattenErrorText(err);
+        return /Backend HTTP 401|Backend HTTP 403|HTTP 401|HTTP 403|\b401\b|\b403\b|No cookie auth|cookie auth credentials|unauthor(?:ized|ised)|session (?:expired|invalid|not found)|invalid session|credentials (?:not found|expired|missing)/i.test(msg);
+      }
       /** Detect 402 payment-required errors that should trigger key rotation */
       isPaymentRequiredError(err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -583523,17 +583543,17 @@ ${result}`
             let resizedBase64 = null;
             try {
               const { execSync: execSync63 } = await import("node:child_process");
-              const { writeFileSync: writeFileSync90, readFileSync: readFileSync133, unlinkSync: unlinkSync35 } = await import("node:fs");
-              const { join: join178 } = await import("node:path");
+              const { writeFileSync: writeFileSync91, readFileSync: readFileSync134, unlinkSync: unlinkSync35 } = await import("node:fs");
+              const { join: join179 } = await import("node:path");
               const { tmpdir: tmpdir24 } = await import("node:os");
-              const tmpIn = join178(tmpdir24(), `omnius_img_in_${Date.now()}.png`);
-              const tmpOut = join178(tmpdir24(), `omnius_img_out_${Date.now()}.jpg`);
-              writeFileSync90(tmpIn, buffer2);
+              const tmpIn = join179(tmpdir24(), `omnius_img_in_${Date.now()}.png`);
+              const tmpOut = join179(tmpdir24(), `omnius_img_out_${Date.now()}.jpg`);
+              writeFileSync91(tmpIn, buffer2);
               const pyBin = process.platform === "win32" ? "python" : "python3";
               const escapedIn = tmpIn.replace(/\\/g, "\\\\");
               const escapedOut = tmpOut.replace(/\\/g, "\\\\");
               execSync63(`${pyBin} -c "from PIL import Image; img = Image.open('${escapedIn}'); img.thumbnail((512, 512), Image.LANCZOS); img = img.convert('RGB'); img.save('${escapedOut}', 'JPEG', quality=75)"`, { timeout: 1e4, stdio: "pipe" });
-              const resizedBuf = readFileSync133(tmpOut);
+              const resizedBuf = readFileSync134(tmpOut);
               resizedBase64 = `data:image/jpeg;base64,${resizedBuf.toString("base64")}`;
               try {
                 unlinkSync35(tmpIn);
@@ -583686,10 +583706,11 @@ ${description}`
       async retryOnTransient(initialErr, chatRequest, turn) {
         if (!this.isTransientError(initialErr))
           return null;
-        const errMsg = initialErr instanceof Error ? initialErr.message : String(initialErr);
-        const isNetworkError2 = /fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|socket hang up/i.test(errMsg);
+        const errMsg = flattenErrorText(initialErr);
+        const isNetworkError2 = /fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|socket hang up|UND_ERR|other side closed/i.test(errMsg);
+        const isAuthError = this.isRecoverableAuthError(initialErr);
         const isGpuSlotUnavailable = this.isGpuSlotUnavailableError(initialErr);
-        const maxRetries = isNetworkError2 || isGpuSlotUnavailable ? Infinity : 3;
+        const maxRetries = isNetworkError2 || isGpuSlotUnavailable || isAuthError ? Infinity : 3;
         const baseDelayMs = isGpuSlotUnavailable ? 1e3 : isNetworkError2 ? 5e3 : 3e3;
         const maxDelayMs = 6e4;
         const backend = this.backend;
@@ -583728,6 +583749,22 @@ ${description}`
               return null;
             }
           }
+          if (isAuthError) {
+            try {
+              const reauthed = await backend.reauth?.();
+              this.emit({
+                type: "status",
+                content: reauthed === false ? `Session lost (auth) — retrying (re-auth unavailable, re-presenting credentials)` : `Session lost (auth) — re-authenticating and retrying`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            } catch {
+              this.emit({
+                type: "status",
+                content: `Session lost (auth) — retrying`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            }
+          }
           const delay3 = isGpuSlotUnavailable ? baseDelayMs : Math.min(baseDelayMs * Math.pow(2, attempt - 1), maxDelayMs);
           const attemptLabel = maxRetries === Infinity ? `${attempt}` : `${attempt}/${maxRetries}`;
           if (isGpuSlotUnavailable) {
@@ -598727,25 +598764,25 @@ async function fetchOpenAIModels(baseUrl2, apiKey) {
 async function fetchPeerModels(peerId, authKey) {
   try {
     const { NexusTool: NexusTool2 } = await Promise.resolve().then(() => (init_dist5(), dist_exports2));
-    const { existsSync: existsSync163, readFileSync: readFileSync133 } = await import("node:fs");
-    const { join: join178 } = await import("node:path");
+    const { existsSync: existsSync164, readFileSync: readFileSync134 } = await import("node:fs");
+    const { join: join179 } = await import("node:path");
     const cwd4 = process.cwd();
     const nexusTool = new NexusTool2(cwd4);
     const nexusDir = nexusTool.getNexusDir();
     let isLocalPeer = false;
     try {
-      const statusPath = join178(nexusDir, "status.json");
-      if (existsSync163(statusPath)) {
-        const status = JSON.parse(readFileSync133(statusPath, "utf8"));
+      const statusPath = join179(nexusDir, "status.json");
+      if (existsSync164(statusPath)) {
+        const status = JSON.parse(readFileSync134(statusPath, "utf8"));
         if (status.peerId === peerId) isLocalPeer = true;
       }
     } catch {
     }
     if (isLocalPeer) {
-      const pricingPath = join178(nexusDir, "pricing.json");
-      if (existsSync163(pricingPath)) {
+      const pricingPath = join179(nexusDir, "pricing.json");
+      if (existsSync164(pricingPath)) {
         try {
-          const pricing = JSON.parse(readFileSync133(pricingPath, "utf8"));
+          const pricing = JSON.parse(readFileSync134(pricingPath, "utf8"));
           const localModels = (pricing.models || []).map((m2) => ({
             name: m2.model || "unknown",
             size: m2.parameterSize || "",
@@ -598758,10 +598795,10 @@ async function fetchPeerModels(peerId, authKey) {
         }
       }
     }
-    const cachePath2 = join178(nexusDir, "peer-models-cache.json");
-    if (existsSync163(cachePath2)) {
+    const cachePath2 = join179(nexusDir, "peer-models-cache.json");
+    if (existsSync164(cachePath2)) {
       try {
-        const cache8 = JSON.parse(readFileSync133(cachePath2, "utf8"));
+        const cache8 = JSON.parse(readFileSync134(cachePath2, "utf8"));
         if (cache8.peerId === peerId && cache8.models?.length > 0) {
           const age = Date.now() - new Date(cache8.cachedAt).getTime();
           if (age < 5 * 60 * 1e3) {
@@ -598873,10 +598910,10 @@ async function fetchPeerModels(peerId, authKey) {
     } catch {
     }
     if (isLocalPeer) {
-      const pricingPath = join178(nexusDir, "pricing.json");
-      if (existsSync163(pricingPath)) {
+      const pricingPath = join179(nexusDir, "pricing.json");
+      if (existsSync164(pricingPath)) {
         try {
-          const pricing = JSON.parse(readFileSync133(pricingPath, "utf8"));
+          const pricing = JSON.parse(readFileSync134(pricingPath, "utf8"));
           return (pricing.models || []).map((m2) => ({
             name: m2.model || "unknown",
             size: m2.parameterSize || "",
@@ -632332,9 +632369,9 @@ async function ensureVoiceDeps(ctx3) {
     }
     if (typeof mod3.getVenvPython === "function") {
       const { dirname: dirname54 } = await import("node:path");
-      const { existsSync: existsSync163 } = await import("node:fs");
+      const { existsSync: existsSync164 } = await import("node:fs");
       const venvPy = mod3.getVenvPython();
-      if (existsSync163(venvPy)) {
+      if (existsSync164(venvPy)) {
         process.env.TRANSCRIBE_PYTHON = venvPy;
         const venvBin = dirname54(venvPy);
         const sep6 = process.platform === "win32" ? ";" : ":";
@@ -633220,10 +633257,10 @@ async function handleSlashCommand(input, ctx3) {
         if (!key) {
           try {
             const { homedir: homedir62 } = await import("node:os");
-            const { readFileSync: readFileSync133, existsSync: existsSync163 } = await import("node:fs");
-            const { join: join178 } = await import("node:path");
-            const p2 = join178(homedir62(), ".omnius", "api.key");
-            if (existsSync163(p2)) key = readFileSync133(p2, "utf8").trim();
+            const { readFileSync: readFileSync134, existsSync: existsSync164 } = await import("node:fs");
+            const { join: join179 } = await import("node:path");
+            const p2 = join179(homedir62(), ".omnius", "api.key");
+            if (existsSync164(p2)) key = readFileSync134(p2, "utf8").trim();
           } catch {
           }
         }
@@ -633266,13 +633303,13 @@ async function handleSlashCommand(input, ctx3) {
           try {
             const { randomBytes: randomBytes30 } = await import("node:crypto");
             const { homedir: homedir62 } = await import("node:os");
-            const { mkdirSync: mkdirSync105, writeFileSync: writeFileSync90 } = await import("node:fs");
-            const { join: join178 } = await import("node:path");
+            const { mkdirSync: mkdirSync106, writeFileSync: writeFileSync91 } = await import("node:fs");
+            const { join: join179 } = await import("node:path");
             const newKey = randomBytes30(16).toString("hex");
             process.env["OMNIUS_API_KEY"] = newKey;
-            const dir = join178(homedir62(), ".omnius");
-            mkdirSync105(dir, { recursive: true });
-            writeFileSync90(join178(dir, "api.key"), newKey + "\n", "utf8");
+            const dir = join179(homedir62(), ".omnius");
+            mkdirSync106(dir, { recursive: true });
+            writeFileSync91(join179(dir, "api.key"), newKey + "\n", "utf8");
             renderInfo(`New API key: ${c3.bold(c3.yellow(newKey))}`);
             renderInfo(
               "Restart the daemon to apply if needed. Use /access any to restart quickly."
@@ -633543,11 +633580,11 @@ async function handleSlashCommand(input, ctx3) {
             );
             try {
               const { homedir: homedir63 } = await import("node:os");
-              const { mkdirSync: mkdirSync106, writeFileSync: writeFileSync91 } = await import("node:fs");
-              const { join: join179 } = await import("node:path");
-              const dir = join179(homedir63(), ".omnius");
-              mkdirSync106(dir, { recursive: true });
-              writeFileSync91(join179(dir, "api.key"), apiKey + "\n", "utf8");
+              const { mkdirSync: mkdirSync107, writeFileSync: writeFileSync92 } = await import("node:fs");
+              const { join: join180 } = await import("node:path");
+              const dir = join180(homedir63(), ".omnius");
+              mkdirSync107(dir, { recursive: true });
+              writeFileSync92(join180(dir, "api.key"), apiKey + "\n", "utf8");
             } catch {
             }
           }
@@ -633559,11 +633596,11 @@ async function handleSlashCommand(input, ctx3) {
           const port2 = parseInt(process.env["OMNIUS_PORT"] || "11435", 10);
           try {
             const { homedir: homedir63 } = await import("node:os");
-            const { mkdirSync: mkdirSync106, writeFileSync: writeFileSync91 } = await import("node:fs");
-            const { join: join179 } = await import("node:path");
-            const dir = join179(homedir63(), ".omnius");
-            mkdirSync106(dir, { recursive: true });
-            writeFileSync91(join179(dir, "access"), `${val2}
+            const { mkdirSync: mkdirSync107, writeFileSync: writeFileSync92 } = await import("node:fs");
+            const { join: join180 } = await import("node:path");
+            const dir = join180(homedir63(), ".omnius");
+            mkdirSync107(dir, { recursive: true });
+            writeFileSync92(join180(dir, "access"), `${val2}
 `, "utf8");
           } catch {
           }
@@ -633663,11 +633700,11 @@ async function handleSlashCommand(input, ctx3) {
         );
         try {
           const { homedir: homedir63 } = await import("node:os");
-          const { mkdirSync: mkdirSync106, writeFileSync: writeFileSync91 } = await import("node:fs");
-          const { join: join179 } = await import("node:path");
-          const dir = join179(homedir63(), ".omnius");
-          mkdirSync106(dir, { recursive: true });
-          writeFileSync91(join179(dir, "api.key"), apiKey + "\n", "utf8");
+          const { mkdirSync: mkdirSync107, writeFileSync: writeFileSync92 } = await import("node:fs");
+          const { join: join180 } = await import("node:path");
+          const dir = join180(homedir63(), ".omnius");
+          mkdirSync107(dir, { recursive: true });
+          writeFileSync92(join180(dir, "api.key"), apiKey + "\n", "utf8");
         } catch {
         }
       }
@@ -633678,12 +633715,12 @@ async function handleSlashCommand(input, ctx3) {
       }
       const port = parseInt(process.env["OMNIUS_PORT"] || "11435", 10);
       const { homedir: homedir62 } = await import("node:os");
-      const { mkdirSync: mkdirSync105, writeFileSync: writeFileSync90 } = await import("node:fs");
-      const { join: join178 } = await import("node:path");
+      const { mkdirSync: mkdirSync106, writeFileSync: writeFileSync91 } = await import("node:fs");
+      const { join: join179 } = await import("node:path");
       try {
-        const dir = join178(homedir62(), ".omnius");
-        mkdirSync105(dir, { recursive: true });
-        writeFileSync90(join178(dir, "access"), `${val}
+        const dir = join179(homedir62(), ".omnius");
+        mkdirSync106(dir, { recursive: true });
+        writeFileSync91(join179(dir, "access"), `${val}
 `, "utf8");
       } catch (e2) {
         renderWarning(
@@ -642522,7 +642559,7 @@ async function handleVoiceMenu(ctx3, save3, hasLocal) {
             const { basename: basename39, join: pathJoin } = await import("node:path");
             const {
               copyFileSync: copyFileSync8,
-              mkdirSync: mkdirSync105,
+              mkdirSync: mkdirSync106,
               existsSync: exists2
             } = await import("node:fs");
             const { homedir: homedir62 } = await import("node:os");
@@ -642537,7 +642574,7 @@ async function handleVoiceMenu(ctx3, save3, hasLocal) {
               "models",
               modelName
             );
-            if (!exists2(destDir)) mkdirSync105(destDir, { recursive: true });
+            if (!exists2(destDir)) mkdirSync106(destDir, { recursive: true });
             copyFileSync8(onnxDrop.path, pathJoin(destDir, "model.onnx"));
             copyFileSync8(jsonDrop.path, pathJoin(destDir, "config.json"));
             const { registerCustomOnnxModel: registerCustomOnnxModel2 } = await Promise.resolve().then(() => (init_voice(), voice_exports));
@@ -644316,13 +644353,13 @@ async function handleSponsoredEndpoint(ctx3, local) {
     sponsors.push(...verified);
     if (verified.length > 0) {
       try {
-        const { mkdirSync: mkdirSync105, writeFileSync: writeFileSync90 } = __require("node:fs");
-        mkdirSync105(sponsorDir2, { recursive: true });
+        const { mkdirSync: mkdirSync106, writeFileSync: writeFileSync91 } = __require("node:fs");
+        mkdirSync106(sponsorDir2, { recursive: true });
         const cached = verified.map((s2) => ({
           ...s2,
           lastVerified: Date.now()
         }));
-        writeFileSync90(knownFile, JSON.stringify(cached, null, 2));
+        writeFileSync91(knownFile, JSON.stringify(cached, null, 2));
       } catch {
       }
     }
@@ -644526,16 +644563,16 @@ async function handlePeerEndpoint(peerId, authKey, ctx3, local, advertisedModels
     }
     if (models.length > 0) {
       try {
-        const { writeFileSync: writeFileSync90, mkdirSync: mkdirSync105 } = await import("node:fs");
-        const { join: join178, dirname: dirname54 } = await import("node:path");
-        const cachePath2 = join178(
+        const { writeFileSync: writeFileSync91, mkdirSync: mkdirSync106 } = await import("node:fs");
+        const { join: join179, dirname: dirname54 } = await import("node:path");
+        const cachePath2 = join179(
           ctx3.repoRoot || process.cwd(),
           ".omnius",
           "nexus",
           "peer-models-cache.json"
         );
-        mkdirSync105(dirname54(cachePath2), { recursive: true });
-        writeFileSync90(
+        mkdirSync106(dirname54(cachePath2), { recursive: true });
+        writeFileSync91(
           cachePath2,
           JSON.stringify(
             {
@@ -644609,16 +644646,16 @@ async function handlePeerEndpoint(peerId, authKey, ctx3, local, advertisedModels
         "Live model probe failed; using sponsor directory model advertisement."
       );
       try {
-        const { writeFileSync: writeFileSync90, mkdirSync: mkdirSync105 } = await import("node:fs");
-        const { join: join178, dirname: dirname54 } = await import("node:path");
-        const cachePath2 = join178(
+        const { writeFileSync: writeFileSync91, mkdirSync: mkdirSync106 } = await import("node:fs");
+        const { join: join179, dirname: dirname54 } = await import("node:path");
+        const cachePath2 = join179(
           ctx3.repoRoot || process.cwd(),
           ".omnius",
           "nexus",
           "peer-models-cache.json"
         );
-        mkdirSync105(dirname54(cachePath2), { recursive: true });
-        writeFileSync90(
+        mkdirSync106(dirname54(cachePath2), { recursive: true });
+        writeFileSync91(
           cachePath2,
           JSON.stringify(
             {
@@ -645632,17 +645669,17 @@ async function handleUpdate(subcommand, ctx3) {
   try {
     const { createRequire: createRequire11 } = await import("node:module");
     const { fileURLToPath: fileURLToPath23 } = await import("node:url");
-    const { dirname: dirname54, join: join178 } = await import("node:path");
-    const { existsSync: existsSync163 } = await import("node:fs");
+    const { dirname: dirname54, join: join179 } = await import("node:path");
+    const { existsSync: existsSync164 } = await import("node:fs");
     const req3 = createRequire11(import.meta.url);
     const thisDir = dirname54(fileURLToPath23(import.meta.url));
     const candidates = [
-      join178(thisDir, "..", "package.json"),
-      join178(thisDir, "..", "..", "package.json"),
-      join178(thisDir, "..", "..", "..", "package.json")
+      join179(thisDir, "..", "package.json"),
+      join179(thisDir, "..", "..", "package.json"),
+      join179(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync163(pkgPath)) {
+      if (existsSync164(pkgPath)) {
         const pkg = req3(pkgPath);
         if (pkg.name === "omnius" || pkg.name === "@omnius/cli") {
           currentVersion = pkg.version ?? "0.0.0";
@@ -647316,13 +647353,13 @@ var init_commands = __esm({
             try {
               const { randomBytes: randomBytes30 } = await import("node:crypto");
               const { homedir: homedir62 } = await import("node:os");
-              const { mkdirSync: mkdirSync105, writeFileSync: writeFileSync90 } = await import("node:fs");
-              const { join: join178 } = await import("node:path");
+              const { mkdirSync: mkdirSync106, writeFileSync: writeFileSync91 } = await import("node:fs");
+              const { join: join179 } = await import("node:path");
               const apiKey = randomBytes30(16).toString("hex");
               process.env["OMNIUS_API_KEY"] = apiKey;
-              const dir = join178(homedir62(), ".omnius");
-              mkdirSync105(dir, { recursive: true });
-              writeFileSync90(join178(dir, "api.key"), apiKey + "\n", "utf8");
+              const dir = join179(homedir62(), ".omnius");
+              mkdirSync106(dir, { recursive: true });
+              writeFileSync91(join179(dir, "api.key"), apiKey + "\n", "utf8");
               renderInfo(`Generated API key: ${c3.bold(c3.yellow(apiKey))}`);
               renderInfo(
                 "Use Authorization: Bearer <key> or click 'key' in the Web UI header to paste it."
@@ -647341,11 +647378,11 @@ var init_commands = __esm({
           const port = parseInt(process.env["OMNIUS_PORT"] || "11435", 10);
           try {
             const { homedir: homedir62 } = await import("node:os");
-            const { mkdirSync: mkdirSync105, writeFileSync: writeFileSync90 } = await import("node:fs");
-            const { join: join178 } = await import("node:path");
-            const dir = join178(homedir62(), ".omnius");
-            mkdirSync105(dir, { recursive: true });
-            writeFileSync90(join178(dir, "access"), `${val}
+            const { mkdirSync: mkdirSync106, writeFileSync: writeFileSync91 } = await import("node:fs");
+            const { join: join179 } = await import("node:path");
+            const dir = join179(homedir62(), ".omnius");
+            mkdirSync106(dir, { recursive: true });
+            writeFileSync91(join179(dir, "access"), `${val}
 `, "utf8");
           } catch {
           }
@@ -682548,6 +682585,343 @@ var init_direct_tool_registry = __esm({
   }
 });
 
+// packages/cli/src/api/external-tool-registry.ts
+import { existsSync as existsSync152, mkdirSync as mkdirSync95, readFileSync as readFileSync124, writeFileSync as writeFileSync81, renameSync as renameSync14 } from "node:fs";
+import { join as join163 } from "node:path";
+function externalToolStorePath(workingDir) {
+  return join163(workingDir, ".omnius", "external-tools.json");
+}
+function loadExternalTools(workingDir) {
+  const path12 = externalToolStorePath(workingDir);
+  if (!existsSync152(path12)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync124(path12, "utf-8"));
+    if (!parsed || !Array.isArray(parsed.tools)) return [];
+    return parsed.tools.filter(
+      (t2) => t2 && typeof t2.name === "string" && t2.transport != null
+    );
+  } catch {
+    return [];
+  }
+}
+function persist3(workingDir, tools) {
+  const path12 = externalToolStorePath(workingDir);
+  mkdirSync95(join163(workingDir, ".omnius"), { recursive: true });
+  const file = { version: STORE_VERSION, tools };
+  const tmp = `${path12}.tmp`;
+  writeFileSync81(tmp, JSON.stringify(file, null, 2), { mode: 384 });
+  renameSync14(tmp, path12);
+}
+function validateManifest2(input, existing) {
+  if (!input || typeof input !== "object") {
+    return { ok: false, error: "Body must be a JSON object." };
+  }
+  const m2 = input;
+  const name10 = typeof m2["name"] === "string" ? m2["name"].trim() : "";
+  if (!NAME_RE.test(name10)) {
+    return {
+      ok: false,
+      error: "`name` must match /^[a-zA-Z][a-zA-Z0-9_]{0,63}$/ (letters, digits, underscore; start with a letter)."
+    };
+  }
+  const description = typeof m2["description"] === "string" ? m2["description"].trim() : "";
+  if (!description) {
+    return { ok: false, error: "`description` is required and must be non-empty." };
+  }
+  const parametersRaw = m2["parameters"];
+  let parameters;
+  if (parametersRaw == null) {
+    parameters = { type: "object", properties: {} };
+  } else if (typeof parametersRaw === "object" && !Array.isArray(parametersRaw)) {
+    parameters = parametersRaw;
+    if (parameters["type"] !== "object") {
+      return {
+        ok: false,
+        error: '`parameters` must be a JSON schema object with `type: "object"`.'
+      };
+    }
+  } else {
+    return { ok: false, error: "`parameters` must be a JSON schema object." };
+  }
+  const transportResult = validateTransport(m2["transport"]);
+  if (!transportResult.ok) return { ok: false, error: transportResult.error };
+  const transport = transportResult.transport;
+  const security = normalizeSecurity(m2["security"], transport);
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const record = {
+    name: name10,
+    description,
+    parameters,
+    security,
+    transport,
+    source: "external",
+    created_at: existing?.created_at ?? now2,
+    updated_at: now2
+  };
+  return { ok: true, record };
+}
+function validateTransport(raw) {
+  if (!raw || typeof raw !== "object") {
+    return {
+      ok: false,
+      error: '`transport` is required: {type:"http",callback_url} or {type:"mcp",server,tool}.'
+    };
+  }
+  const t2 = raw;
+  if (t2["type"] === "http") {
+    const url = typeof t2["callback_url"] === "string" ? t2["callback_url"].trim() : "";
+    if (!/^https?:\/\//i.test(url)) {
+      return { ok: false, error: "http transport requires an absolute http(s) `callback_url`." };
+    }
+    const transport = { type: "http", callback_url: url };
+    if (typeof t2["auth_header"] === "string") transport.auth_header = t2["auth_header"];
+    if (t2["headers"] && typeof t2["headers"] === "object") {
+      transport.headers = t2["headers"];
+    }
+    if (typeof t2["timeout_ms"] === "number") transport.timeout_ms = t2["timeout_ms"];
+    if (typeof t2["result_path"] === "string") transport.result_path = t2["result_path"].trim();
+    return { ok: true, transport };
+  }
+  if (t2["type"] === "mcp") {
+    const server2 = typeof t2["server"] === "string" ? t2["server"].trim() : "";
+    const tool = typeof t2["tool"] === "string" ? t2["tool"].trim() : "";
+    if (!server2 || !tool) {
+      return { ok: false, error: "mcp transport requires non-empty `server` and `tool`." };
+    }
+    const transport = { type: "mcp", server: server2, tool };
+    if (t2["connect"] && typeof t2["connect"] === "object") {
+      transport.connect = t2["connect"];
+    }
+    return { ok: true, transport };
+  }
+  return { ok: false, error: '`transport.type` must be "http" or "mcp".' };
+}
+function normalizeSecurity(raw, transport) {
+  const s2 = raw && typeof raw === "object" ? raw : {};
+  const categories = Array.isArray(s2["categories"]) ? s2["categories"].filter((c8) => typeof c8 === "string") : ["network"];
+  const risk = ["low", "medium", "high", "critical"].includes(s2["risk"]) ? s2["risk"] : "medium";
+  const requires_scope = ["read", "run", "admin"].includes(s2["requires_scope"]) ? s2["requires_scope"] : "run";
+  const off_device_allowed = s2["off_device_allowed"] === true;
+  const rationale = typeof s2["rationale"] === "string" && s2["rationale"].trim() ? s2["rationale"].trim() : transport.type === "http" ? `External HTTP tool; Omnius forwards args to ${transport.callback_url}.` : `External MCP tool; proxies to ${transport.server}:${transport.tool}.`;
+  return { categories: categories.length ? categories : ["network"], risk, requires_scope, off_device_allowed, rationale };
+}
+function upsertExternalTool(workingDir, record) {
+  const tools = loadExternalTools(workingDir);
+  const idx = tools.findIndex((t2) => t2.name === record.name);
+  const replaced = idx >= 0;
+  if (replaced) tools[idx] = record;
+  else tools.push(record);
+  tools.sort((a2, b) => a2.name.localeCompare(b.name));
+  persist3(workingDir, tools);
+  return { replaced };
+}
+function removeExternalTool(workingDir, name10) {
+  const tools = loadExternalTools(workingDir);
+  const next = tools.filter((t2) => t2.name !== name10);
+  if (next.length === tools.length) return false;
+  persist3(workingDir, next);
+  return true;
+}
+function getExternalTool(workingDir, name10) {
+  return loadExternalTools(workingDir).find((t2) => t2.name === name10) ?? null;
+}
+var STORE_VERSION, NAME_RE;
+var init_external_tool_registry = __esm({
+  "packages/cli/src/api/external-tool-registry.ts"() {
+    "use strict";
+    STORE_VERSION = 1;
+    NAME_RE = /^[a-zA-Z][a-zA-Z0-9_]{0,63}$/;
+  }
+});
+
+// packages/cli/src/api/external-tool-dispatch.ts
+function clampTimeout(ms, def) {
+  if (typeof ms !== "number" || !Number.isFinite(ms)) return def;
+  return Math.min(Math.max(Math.round(ms), 1e3), 12e4);
+}
+function readPath(obj, path12) {
+  let cur = obj;
+  for (const seg of path12.split(".")) {
+    if (cur == null || typeof cur !== "object") return void 0;
+    cur = cur[seg];
+  }
+  return cur;
+}
+async function dispatchHttp(transport, record, args, sessionId, fetchImpl) {
+  const start2 = performance.now();
+  const controller = new AbortController();
+  const timeout2 = clampTimeout(transport.timeout_ms, 3e4);
+  const timer = setTimeout(() => controller.abort(), timeout2);
+  try {
+    const headers = {
+      "content-type": "application/json",
+      ...transport.headers ?? {}
+    };
+    if (transport.auth_header) headers["authorization"] = transport.auth_header;
+    const resp = await fetchImpl(transport.callback_url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ name: record.name, args, session_id: sessionId }),
+      signal: controller.signal
+    });
+    const text2 = await resp.text();
+    if (!resp.ok) {
+      return {
+        success: false,
+        output: "",
+        error: `External tool HTTP ${resp.status}: ${text2.slice(0, 500)}`,
+        durationMs: performance.now() - start2,
+        transport: "http"
+      };
+    }
+    let output = text2;
+    if (transport.result_path) {
+      try {
+        const json = JSON.parse(text2);
+        const extracted = readPath(json, transport.result_path);
+        output = typeof extracted === "string" ? extracted : JSON.stringify(extracted ?? null);
+      } catch {
+      }
+    }
+    return {
+      success: true,
+      output,
+      durationMs: performance.now() - start2,
+      transport: "http"
+    };
+  } catch (err) {
+    const aborted = err instanceof Error && err.name === "AbortError";
+    return {
+      success: false,
+      output: "",
+      error: aborted ? `External tool call timed out after ${timeout2}ms` : `External tool call failed: ${err instanceof Error ? err.message : String(err)}`,
+      durationMs: performance.now() - start2,
+      transport: "http"
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function dispatchMcp(transport, args, workingDir, deps) {
+  const start2 = performance.now();
+  const mgr = await deps.getMcpManager(workingDir);
+  if (!mgr) {
+    return {
+      success: false,
+      output: "",
+      error: "MCP module unavailable — cannot dispatch mcp transport.",
+      durationMs: performance.now() - start2,
+      transport: "mcp"
+    };
+  }
+  const client = mgr.clients?.get(transport.server);
+  if (!client) {
+    return {
+      success: false,
+      output: "",
+      error: `MCP server '${transport.server}' is not connected.`,
+      durationMs: performance.now() - start2,
+      transport: "mcp"
+    };
+  }
+  try {
+    const result = await client.callTool(transport.tool, args);
+    return {
+      success: true,
+      output: typeof result === "string" ? result : JSON.stringify(result),
+      durationMs: performance.now() - start2,
+      transport: "mcp"
+    };
+  } catch (err) {
+    return {
+      success: false,
+      output: "",
+      error: `MCP tool '${transport.server}:${transport.tool}' failed: ${err instanceof Error ? err.message : String(err)}`,
+      durationMs: performance.now() - start2,
+      transport: "mcp"
+    };
+  }
+}
+async function executeExternalTool(record, args, workingDir, sessionId, deps) {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  if (record.transport.type === "http") {
+    return dispatchHttp(record.transport, record, args, sessionId, fetchImpl);
+  }
+  return dispatchMcp(record.transport, args, workingDir, deps);
+}
+var init_external_tool_dispatch = __esm({
+  "packages/cli/src/api/external-tool-dispatch.ts"() {
+    "use strict";
+  }
+});
+
+// packages/cli/src/api/external-tool-eval.ts
+function scoreCase(expect, result) {
+  const failures = [];
+  if (!expect) {
+    if (!result.success) failures.push(`expected success but tool failed: ${result.error ?? "unknown"}`);
+    return failures;
+  }
+  if (typeof expect.success === "boolean" && result.success !== expect.success) {
+    failures.push(`expected success=${expect.success} but got ${result.success}${result.error ? ` (${result.error})` : ""}`);
+  }
+  if (typeof expect.output_contains === "string" && !result.output.includes(expect.output_contains)) {
+    failures.push(`output did not contain ${JSON.stringify(expect.output_contains)}`);
+  }
+  if (typeof expect.output_equals === "string" && result.output.trim() !== expect.output_equals.trim()) {
+    failures.push(`output did not equal ${JSON.stringify(expect.output_equals)}`);
+  }
+  if (typeof expect.output_matches === "string") {
+    let re = null;
+    try {
+      re = new RegExp(expect.output_matches);
+    } catch {
+      failures.push(`invalid output_matches regex ${JSON.stringify(expect.output_matches)}`);
+    }
+    if (re && !re.test(result.output)) {
+      failures.push(`output did not match /${expect.output_matches}/`);
+    }
+  }
+  return failures;
+}
+async function evaluateExternalTool(record, cases, workingDir, deps) {
+  const start2 = performance.now();
+  const results = [];
+  for (let i2 = 0; i2 < cases.length; i2++) {
+    const c8 = cases[i2];
+    const result = await executeExternalTool(
+      record,
+      c8.args ?? {},
+      workingDir,
+      null,
+      deps
+    );
+    const failures = scoreCase(c8.expect, result);
+    results.push({
+      name: c8.name ?? `case_${i2 + 1}`,
+      passed: failures.length === 0,
+      failures,
+      result
+    });
+  }
+  const passed = results.filter((r2) => r2.passed).length;
+  return {
+    tool: record.name,
+    total: results.length,
+    passed,
+    failed: results.length - passed,
+    pass_rate: results.length ? passed / results.length : 0,
+    duration_ms: performance.now() - start2,
+    cases: results
+  };
+}
+var init_external_tool_eval = __esm({
+  "packages/cli/src/api/external-tool-eval.ts"() {
+    "use strict";
+    init_external_tool_dispatch();
+  }
+});
+
 // packages/cli/src/api/aiwg.ts
 var aiwg_exports = {};
 __export(aiwg_exports, {
@@ -682560,19 +682934,19 @@ __export(aiwg_exports, {
   resolveAiwgRoot: () => resolveAiwgRoot,
   tryRouteAiwg: () => tryRouteAiwg
 });
-import { existsSync as existsSync152, readFileSync as readFileSync124, readdirSync as readdirSync54, statSync as statSync54 } from "node:fs";
-import { join as join163 } from "node:path";
+import { existsSync as existsSync153, readFileSync as readFileSync125, readdirSync as readdirSync54, statSync as statSync54 } from "node:fs";
+import { join as join164 } from "node:path";
 import { homedir as homedir54 } from "node:os";
 import { execSync as execSync58 } from "node:child_process";
 function resolveAiwgRoot() {
   if (_cachedAiwgRoot !== void 0) return _cachedAiwgRoot;
   const envRoot = process.env["OMNIUS_AIWG_ROOT"];
-  if (envRoot && existsSync152(join163(envRoot, "package.json"))) {
+  if (envRoot && existsSync153(join164(envRoot, "package.json"))) {
     _cachedAiwgRoot = envRoot;
     return envRoot;
   }
-  const shareDir = join163(homedir54(), ".local", "share", "ai-writing-guide");
-  if (existsSync152(join163(shareDir, "agentic"))) {
+  const shareDir = join164(homedir54(), ".local", "share", "ai-writing-guide");
+  if (existsSync153(join164(shareDir, "agentic"))) {
     _cachedAiwgRoot = shareDir;
     return shareDir;
   }
@@ -682582,8 +682956,8 @@ function resolveAiwgRoot() {
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    const candidate = join163(globalRoot, "aiwg");
-    if (existsSync152(join163(candidate, "package.json"))) {
+    const candidate = join164(globalRoot, "aiwg");
+    if (existsSync153(join164(candidate, "package.json"))) {
       _cachedAiwgRoot = candidate;
       return candidate;
     }
@@ -682594,22 +682968,22 @@ function resolveAiwgRoot() {
     "/usr/lib/node_modules/aiwg",
     "/opt/homebrew/lib/node_modules/aiwg"
   ]) {
-    if (existsSync152(join163(p2, "package.json"))) {
+    if (existsSync153(join164(p2, "package.json"))) {
       _cachedAiwgRoot = p2;
       return p2;
     }
   }
   const versionDirs = [
-    join163(homedir54(), ".nvm", "versions", "node"),
-    join163(homedir54(), ".local", "share", "fnm", "node-versions")
+    join164(homedir54(), ".nvm", "versions", "node"),
+    join164(homedir54(), ".local", "share", "fnm", "node-versions")
   ];
   for (const vdir of versionDirs) {
-    if (!existsSync152(vdir)) continue;
+    if (!existsSync153(vdir)) continue;
     try {
       for (const ver of readdirSync54(vdir)) {
         for (const prefix of ["lib/node_modules/aiwg", "installation/lib/node_modules/aiwg"]) {
-          const cand = join163(vdir, ver, prefix);
-          if (existsSync152(join163(cand, "package.json"))) {
+          const cand = join164(vdir, ver, prefix);
+          if (existsSync153(join164(cand, "package.json"))) {
             _cachedAiwgRoot = cand;
             return cand;
           }
@@ -682627,11 +683001,11 @@ function resolveAiwgRoot() {
     if (whichAiwg) {
       let cur = whichAiwg;
       for (let i2 = 0; i2 < 8; i2++) {
-        cur = join163(cur, "..");
-        const pj = join163(cur, "package.json");
-        if (existsSync152(pj)) {
+        cur = join164(cur, "..");
+        const pj = join164(cur, "package.json");
+        if (existsSync153(pj)) {
           try {
-            const pkg = JSON.parse(readFileSync124(pj, "utf-8"));
+            const pkg = JSON.parse(readFileSync125(pj, "utf-8"));
             if (pkg.name === "aiwg") {
               _cachedAiwgRoot = cur;
               return cur;
@@ -682653,14 +683027,14 @@ function listAiwgFrameworks() {
     _cachedFrameworks = [];
     return _cachedFrameworks;
   }
-  const frameworksDir = join163(root, "agentic", "code", "frameworks");
-  if (!existsSync152(frameworksDir)) {
+  const frameworksDir = join164(root, "agentic", "code", "frameworks");
+  if (!existsSync153(frameworksDir)) {
     _cachedFrameworks = [];
     return _cachedFrameworks;
   }
   const out = [];
   for (const name10 of readdirSync54(frameworksDir)) {
-    const p2 = join163(frameworksDir, name10);
+    const p2 = join164(frameworksDir, name10);
     try {
       const st = statSync54(p2);
       if (!st.isDirectory()) continue;
@@ -682688,7 +683062,7 @@ function aggregateDir(dir, depth = 0) {
   try {
     for (const e2 of readdirSync54(dir, { withFileTypes: true })) {
       if (e2.name.startsWith(".") || e2.name === "node_modules") continue;
-      const p2 = join163(dir, e2.name);
+      const p2 = join164(dir, e2.name);
       if (e2.isDirectory()) {
         const sub2 = aggregateDir(p2, depth + 1);
         out.files += sub2.files;
@@ -682718,10 +683092,10 @@ function aggregateDir(dir, depth = 0) {
 }
 function readFirstLineDescription(dir) {
   for (const candidate of ["README.md", "SKILL.md", "INDEX.md"]) {
-    const p2 = join163(dir, candidate);
-    if (!existsSync152(p2)) continue;
+    const p2 = join164(dir, candidate);
+    if (!existsSync153(p2)) continue;
     try {
-      const txt = readFileSync124(p2, "utf-8");
+      const txt = readFileSync125(p2, "utf-8");
       const descMatch = txt.match(/^description:\s*(.+)$/m);
       if (descMatch) return descMatch[1].trim().slice(0, 200);
       for (const line of txt.split("\n")) {
@@ -682743,12 +683117,12 @@ function listAiwgItems() {
   }
   const out = [];
   const walkRoots = [
-    join163(root, "agentic", "code", "frameworks"),
-    join163(root, "agentic", "code", "addons"),
-    join163(root, "plugins")
+    join164(root, "agentic", "code", "frameworks"),
+    join164(root, "agentic", "code", "addons"),
+    join164(root, "plugins")
   ];
   for (const wr of walkRoots) {
-    if (!existsSync152(wr)) continue;
+    if (!existsSync153(wr)) continue;
     walkForItems(wr, out, 0);
   }
   _cachedItems = out;
@@ -682759,7 +683133,7 @@ function walkForItems(dir, out, depth) {
   try {
     for (const e2 of readdirSync54(dir, { withFileTypes: true })) {
       if (e2.name.startsWith(".") || e2.name === "node_modules") continue;
-      const p2 = join163(dir, e2.name);
+      const p2 = join164(dir, e2.name);
       if (e2.isDirectory()) {
         walkForItems(p2, out, depth + 1);
       } else if (e2.isFile() && e2.name.endsWith(".md")) {
@@ -682772,7 +683146,7 @@ function walkForItems(dir, out, depth) {
 }
 function parseItem(p2) {
   try {
-    const raw = readFileSync124(p2, "utf-8");
+    const raw = readFileSync125(p2, "utf-8");
     const header = raw.slice(0, 3e3);
     const nameMatch = header.match(/^name:\s*(.+)$/m);
     const descMatch = header.match(/^description:\s*(.+)$/m);
@@ -682810,8 +683184,8 @@ function deriveSource(p2) {
 }
 function loadAiwgItemContent(path12, maxBytes = 2e4) {
   try {
-    if (!existsSync152(path12)) return null;
-    const raw = readFileSync124(path12, "utf-8");
+    if (!existsSync153(path12)) return null;
+    const raw = readFileSync125(path12, "utf-8");
     return raw.length > maxBytes ? raw.slice(0, maxBytes) + "\n\n...(truncated for context budget)" : raw;
   } catch {
     return null;
@@ -682824,14 +683198,14 @@ function listAiwgAddons() {
     _cachedAddons = [];
     return _cachedAddons;
   }
-  const addonsDir = join163(root, "agentic", "code", "addons");
-  if (!existsSync152(addonsDir)) {
+  const addonsDir = join164(root, "agentic", "code", "addons");
+  if (!existsSync153(addonsDir)) {
     _cachedAddons = [];
     return _cachedAddons;
   }
   const out = [];
   for (const name10 of readdirSync54(addonsDir)) {
-    const p2 = join163(addonsDir, name10);
+    const p2 = join164(addonsDir, name10);
     try {
       const st = statSync54(p2);
       if (!st.isDirectory()) continue;
@@ -683347,18 +683721,18 @@ __export(runtime_keys_exports, {
   mintKey: () => mintKey,
   revokeByPrefix: () => revokeByPrefix
 });
-import { existsSync as existsSync153, readFileSync as readFileSync125, writeFileSync as writeFileSync81, mkdirSync as mkdirSync95, chmodSync as chmodSync4 } from "node:fs";
-import { join as join164 } from "node:path";
+import { existsSync as existsSync154, readFileSync as readFileSync126, writeFileSync as writeFileSync82, mkdirSync as mkdirSync96, chmodSync as chmodSync4 } from "node:fs";
+import { join as join165 } from "node:path";
 import { homedir as homedir55 } from "node:os";
 import { randomBytes as randomBytes27 } from "node:crypto";
 function ensureDir2() {
-  const dir = join164(homedir55(), ".omnius");
-  if (!existsSync153(dir)) mkdirSync95(dir, { recursive: true });
+  const dir = join165(homedir55(), ".omnius");
+  if (!existsSync154(dir)) mkdirSync96(dir, { recursive: true });
 }
 function loadAll() {
-  if (!existsSync153(KEYS_FILE)) return [];
+  if (!existsSync154(KEYS_FILE)) return [];
   try {
-    const raw = readFileSync125(KEYS_FILE, "utf-8");
+    const raw = readFileSync126(KEYS_FILE, "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) return [];
     return parsed;
@@ -683368,7 +683742,7 @@ function loadAll() {
 }
 function persistAll(records) {
   ensureDir2();
-  writeFileSync81(KEYS_FILE, JSON.stringify(records, null, 2), "utf-8");
+  writeFileSync82(KEYS_FILE, JSON.stringify(records, null, 2), "utf-8");
   try {
     chmodSync4(KEYS_FILE, 384);
   } catch {
@@ -683433,7 +683807,7 @@ var KEYS_FILE;
 var init_runtime_keys = __esm({
   "packages/cli/src/api/runtime-keys.ts"() {
     "use strict";
-    KEYS_FILE = join164(homedir55(), ".omnius", "keys.json");
+    KEYS_FILE = join165(homedir55(), ".omnius", "keys.json");
   }
 });
 
@@ -683444,20 +683818,20 @@ __export(tor_fallback_exports, {
   torIsReachable: () => torIsReachable,
   tunnelViaTor: () => tunnelViaTor
 });
-import { existsSync as existsSync154, readFileSync as readFileSync126 } from "node:fs";
+import { existsSync as existsSync155, readFileSync as readFileSync127 } from "node:fs";
 import { homedir as homedir56 } from "node:os";
-import { join as join165 } from "node:path";
+import { join as join166 } from "node:path";
 import { createConnection as createConnection3 } from "node:net";
 function getLocalOnion() {
   const candidates = [
-    join165(homedir56(), "hidden_service_hostname"),
-    join165(homedir56(), ".omnius", "tor", "hostname"),
+    join166(homedir56(), "hidden_service_hostname"),
+    join166(homedir56(), ".omnius", "tor", "hostname"),
     "/var/lib/tor/hidden_service/hostname"
   ];
   for (const p2 of candidates) {
     try {
-      if (existsSync154(p2)) {
-        const v = readFileSync126(p2, "utf-8").trim();
+      if (existsSync155(p2)) {
+        const v = readFileSync127(p2, "utf-8").trim();
         if (v && v.endsWith(".onion")) return v;
       }
     } catch {
@@ -683602,8 +683976,8 @@ __export(graphical_sudo_exports, {
   runGraphicalSudo: () => runGraphicalSudo
 });
 import { spawn as spawn31 } from "node:child_process";
-import { existsSync as existsSync155, mkdirSync as mkdirSync96, writeFileSync as writeFileSync82, chmodSync as chmodSync5 } from "node:fs";
-import { join as join166 } from "node:path";
+import { existsSync as existsSync156, mkdirSync as mkdirSync97, writeFileSync as writeFileSync83, chmodSync as chmodSync5 } from "node:fs";
+import { join as join167 } from "node:path";
 import { tmpdir as tmpdir22 } from "node:os";
 function detectSudoHelper() {
   if (process.platform === "win32") return null;
@@ -683619,15 +683993,15 @@ function which2(cmd) {
   const path12 = process.env["PATH"] || "/usr/bin:/bin:/usr/local/bin";
   for (const dir of path12.split(":")) {
     if (!dir) continue;
-    const full = join166(dir, cmd);
-    if (existsSync155(full)) return full;
+    const full = join167(dir, cmd);
+    if (existsSync156(full)) return full;
   }
   return null;
 }
 function ensureAskpassShim(helper, description) {
-  const shimDir = join166(tmpdir22(), "omnius-askpass");
-  mkdirSync96(shimDir, { recursive: true });
-  const shim = join166(shimDir, `${helper}.sh`);
+  const shimDir = join167(tmpdir22(), "omnius-askpass");
+  mkdirSync97(shimDir, { recursive: true });
+  const shim = join167(shimDir, `${helper}.sh`);
   let body;
   if (helper === "zenity") {
     body = `#!/bin/sh
@@ -683638,7 +684012,7 @@ exec zenity --password --title="Omnius needs sudo" --text="${description.replace
 exec kdialog --password "${description.replace(/"/g, '\\"')}" 2>/dev/null
 `;
   }
-  writeFileSync82(shim, body, "utf-8");
+  writeFileSync83(shim, body, "utf-8");
   chmodSync5(shim, 493);
   return shim;
 }
@@ -683718,8 +684092,8 @@ var init_graphical_sudo = __esm({
 });
 
 // packages/cli/src/api/routes-v1.ts
-import { existsSync as existsSync156, mkdirSync as mkdirSync97, readFileSync as readFileSync127, readdirSync as readdirSync55, statSync as statSync55 } from "node:fs";
-import { join as join167, resolve as pathResolve3 } from "node:path";
+import { existsSync as existsSync157, mkdirSync as mkdirSync98, readFileSync as readFileSync128, readdirSync as readdirSync55, statSync as statSync55 } from "node:fs";
+import { join as join168, resolve as pathResolve3 } from "node:path";
 import { homedir as homedir57 } from "node:os";
 async function tryRouteV1(ctx3) {
   const { pathname, method } = ctx3;
@@ -683827,18 +684201,23 @@ async function tryRouteV1(ctx3) {
   if (pathname === "/v1/tools" && method === "GET") {
     return handleListTools(ctx3);
   }
+  if (pathname === "/v1/tools/register" && method === "POST") {
+    return handleRegisterTool(ctx3);
+  }
   {
-    const m2 = /^\/v1\/tools\/([^/]+)(\/call)?$/.exec(pathname);
+    const m2 = /^\/v1\/tools\/([^/]+)(\/call|\/eval)?$/.exec(pathname);
     if (m2) {
       const toolName = decodeURIComponent(m2[1]);
-      const isCall = !!m2[2];
-      if (isCall && method === "POST") return handleCallTool(ctx3, toolName);
-      if (!isCall && method === "GET") return handleGetTool(ctx3, toolName);
+      const suffix = m2[2];
+      if (suffix === "/call" && method === "POST") return handleCallTool(ctx3, toolName);
+      if (suffix === "/eval" && method === "POST") return handleEvalTool(ctx3, toolName);
+      if (!suffix && method === "GET") return handleGetTool(ctx3, toolName);
+      if (!suffix && method === "DELETE") return handleDeleteTool(ctx3, toolName);
       sendProblem(ctx3.res, problemDetails({
         type: P2.methodNotAllowed,
         status: 405,
         title: `Method ${method} not allowed for ${pathname}`,
-        detail: isCall ? "POST /v1/tools/{name}/call to execute the tool." : "GET /v1/tools/{name} to fetch its schema.",
+        detail: suffix === "/call" ? "POST /v1/tools/{name}/call to execute the tool." : suffix === "/eval" ? "POST /v1/tools/{name}/eval to evaluate the tool." : "GET /v1/tools/{name} for schema, DELETE to unregister an external tool.",
         instance: ctx3.requestId
       }));
       return true;
@@ -683970,11 +684349,11 @@ async function handleGetSkill(ctx3, name10) {
 async function fallbackDiscoverSkills() {
   return (_root) => {
     const roots = [
-      join167(homedir57(), ".local", "share", "ai-writing-guide")
+      join168(homedir57(), ".local", "share", "ai-writing-guide")
     ];
     const out = [];
     for (const root of roots) {
-      if (!existsSync156(root)) continue;
+      if (!existsSync157(root)) continue;
       walkForSkills(root, out, 0);
     }
     return out;
@@ -683985,12 +684364,12 @@ function walkForSkills(dir, out, depth) {
   try {
     for (const e2 of readdirSync55(dir, { withFileTypes: true })) {
       if (e2.name.startsWith(".") || e2.name === "node_modules") continue;
-      const p2 = join167(dir, e2.name);
+      const p2 = join168(dir, e2.name);
       if (e2.isDirectory()) {
         walkForSkills(p2, out, depth + 1);
       } else if (e2.isFile() && e2.name === "SKILL.md") {
         try {
-          const content = readFileSync127(p2, "utf-8").slice(0, 2e3);
+          const content = readFileSync128(p2, "utf-8").slice(0, 2e3);
           const nameMatch = content.match(/^name:\s*(.+)$/m);
           const descMatch = content.match(/^description:\s*(.+)$/m);
           out.push({
@@ -684273,19 +684652,19 @@ async function handleOllamaPoolCleanup(ctx3) {
   }
 }
 function memoryDbPaths2(baseDir = process.cwd()) {
-  const dir = join167(baseDir, ".omnius");
+  const dir = join168(baseDir, ".omnius");
   return {
-    episodes: join167(dir, "episodes.db"),
-    knowledge: join167(dir, "knowledge.db")
+    episodes: join168(dir, "episodes.db"),
+    knowledge: join168(dir, "knowledge.db")
   };
 }
 function unifiedMemoryDbPath(baseDir = process.cwd()) {
-  const dir = join167(baseDir, ".omnius");
+  const dir = join168(baseDir, ".omnius");
   try {
-    mkdirSync97(dir, { recursive: true });
+    mkdirSync98(dir, { recursive: true });
   } catch {
   }
-  return join167(dir, "unified-memory.db");
+  return join168(dir, "unified-memory.db");
 }
 function withUnifiedMemory(fn) {
   const db = initDb(unifiedMemoryDbPath());
@@ -684914,7 +685293,7 @@ async function handleFilesRead(ctx3) {
       }));
       return true;
     }
-    if (!existsSync156(resolved)) {
+    if (!existsSync157(resolved)) {
       sendProblem(res, problemDetails({
         type: P2.notFound,
         status: 404,
@@ -684946,7 +685325,7 @@ async function handleFilesRead(ctx3) {
       }));
       return true;
     }
-    const content = readFileSync127(resolved, "utf-8");
+    const content = readFileSync128(resolved, "utf-8");
     const offset = typeof body.offset === "number" && body.offset >= 0 ? body.offset : 0;
     const limit = typeof body.limit === "number" && body.limit > 0 ? body.limit : content.length;
     const slice2 = content.slice(offset, offset + limit);
@@ -685179,14 +685558,14 @@ async function handleNexusStatus(ctx3) {
   const { res, requestId } = ctx3;
   try {
     const statePaths = [
-      join167(process.cwd(), ".omnius", "nexus-peer-state.json"),
-      join167(homedir57(), ".omnius", "nexus-peer-cache.json")
+      join168(process.cwd(), ".omnius", "nexus-peer-state.json"),
+      join168(homedir57(), ".omnius", "nexus-peer-cache.json")
     ];
     const states2 = [];
     for (const p2 of statePaths) {
-      if (!existsSync156(p2)) continue;
+      if (!existsSync157(p2)) continue;
       try {
-        const raw = readFileSync127(p2, "utf-8");
+        const raw = readFileSync128(p2, "utf-8");
         states2.push({ source: p2, data: JSON.parse(raw) });
       } catch (e2) {
         states2.push({ source: p2, error: String(e2) });
@@ -685213,8 +685592,8 @@ async function handleNexusStatus(ctx3) {
 }
 function loadAgentName() {
   try {
-    const p2 = join167(homedir57(), ".omnius", "agent-name");
-    if (existsSync156(p2)) return readFileSync127(p2, "utf-8").trim();
+    const p2 = join168(homedir57(), ".omnius", "agent-name");
+    if (existsSync157(p2)) return readFileSync128(p2, "utf-8").trim();
   } catch {
   }
   return null;
@@ -685223,14 +685602,14 @@ async function handleSponsors(ctx3) {
   const { req: req3, res, url, requestId } = ctx3;
   try {
     const candidates = [
-      join167(homedir57(), ".omnius", "sponsor-cache.json"),
-      join167(homedir57(), ".omnius", "sponsors.json")
+      join168(homedir57(), ".omnius", "sponsor-cache.json"),
+      join168(homedir57(), ".omnius", "sponsors.json")
     ];
     let sponsors = [];
     for (const p2 of candidates) {
-      if (!existsSync156(p2)) continue;
+      if (!existsSync157(p2)) continue;
       try {
-        const raw = JSON.parse(readFileSync127(p2, "utf-8"));
+        const raw = JSON.parse(readFileSync128(p2, "utf-8"));
         if (Array.isArray(raw)) {
           sponsors = raw;
           break;
@@ -685299,8 +685678,8 @@ async function handleEvaluate(ctx3) {
       }));
       return true;
     }
-    const jobPath = join167(process.cwd(), ".omnius", "jobs", `${runId}.json`);
-    if (!existsSync156(jobPath)) {
+    const jobPath = join168(process.cwd(), ".omnius", "jobs", `${runId}.json`);
+    if (!existsSync157(jobPath)) {
       sendProblem(res, problemDetails({
         type: P2.notFound,
         status: 404,
@@ -685310,7 +685689,7 @@ async function handleEvaluate(ctx3) {
       }));
       return true;
     }
-    const job = JSON.parse(readFileSync127(jobPath, "utf-8"));
+    const job = JSON.parse(readFileSync128(jobPath, "utf-8"));
     sendJson2(res, 200, {
       run_id: runId,
       task: job.task,
@@ -685448,9 +685827,9 @@ async function handleMintKey(ctx3) {
   return true;
 }
 function _readStatusFile(p2) {
-  if (!existsSync156(p2)) return null;
+  if (!existsSync157(p2)) return null;
   try {
-    const data = JSON.parse(readFileSync127(p2, "utf-8"));
+    const data = JSON.parse(readFileSync128(p2, "utf-8"));
     if (data?.connected && typeof data.peerId === "string" && data.peerId.length > 10) {
       const pid = Number(data.pid);
       if (pid > 0) {
@@ -685473,32 +685852,32 @@ function _readStatusFile(p2) {
 function resolveLocalPeerId() {
   const override = process.env["OMNIUS_NEXUS_DIR"];
   if (override) {
-    const r2 = _readStatusFile(join167(override, "status.json"));
+    const r2 = _readStatusFile(join168(override, "status.json"));
     if (r2) return r2;
   }
   const scope = (process.env["OMNIUS_NEXUS_SCOPE"] || "").toLowerCase();
   const projectScopeFlag = (process.env["OMNIUS_NEXUS_PROJECT_SCOPE"] || "").toLowerCase();
   const projectScoped = scope === "project" || scope === "local" || projectScopeFlag === "1" || projectScopeFlag === "true" || projectScopeFlag === "yes";
   const candidates = projectScoped ? [
-    join167(process.cwd(), ".omnius", "nexus", "status.json"),
-    join167(homedir57(), ".omnius", "nexus", "status.json")
+    join168(process.cwd(), ".omnius", "nexus", "status.json"),
+    join168(homedir57(), ".omnius", "nexus", "status.json")
   ] : [
-    join167(homedir57(), ".omnius", "nexus", "status.json"),
-    join167(process.cwd(), ".omnius", "nexus", "status.json")
+    join168(homedir57(), ".omnius", "nexus", "status.json"),
+    join168(process.cwd(), ".omnius", "nexus", "status.json")
   ];
   for (const p2 of candidates) {
     const r2 = _readStatusFile(p2);
     if (r2) return r2;
   }
   try {
-    const regPath = join167(homedir57(), ".omnius", "nexus-registry.json");
-    if (existsSync156(regPath)) {
-      const reg = JSON.parse(readFileSync127(regPath, "utf-8"));
+    const regPath = join168(homedir57(), ".omnius", "nexus-registry.json");
+    if (existsSync157(regPath)) {
+      const reg = JSON.parse(readFileSync128(regPath, "utf-8"));
       const entries = Array.isArray(reg?.dirs) ? reg.dirs : [];
       for (const entry of entries) {
         const dir = typeof entry === "string" ? entry : entry?.dir;
         if (typeof dir === "string") {
-          const r2 = _readStatusFile(join167(dir, "status.json"));
+          const r2 = _readStatusFile(join168(dir, "status.json"));
           if (r2) return r2;
         }
       }
@@ -685532,21 +685911,21 @@ function locateTorScript(filename) {
   const candidates = [
     // npm-installed layout: build-publish.mjs copies scripts to
     // publish/dist/scripts/tor/ which lands at <install>/dist/scripts/tor/.
-    join167(__dirname, "scripts", "tor", filename),
-    join167(__dirname, "..", "scripts", "tor", filename),
-    join167(__dirname, "..", "..", "scripts", "tor", filename),
+    join168(__dirname, "scripts", "tor", filename),
+    join168(__dirname, "..", "scripts", "tor", filename),
+    join168(__dirname, "..", "..", "scripts", "tor", filename),
     // Workspace dev: cli package's source tree.
-    join167(process.cwd(), "packages", "cli", "scripts", "tor", filename),
-    join167(process.cwd(), "scripts", "tor", filename)
+    join168(process.cwd(), "packages", "cli", "scripts", "tor", filename),
+    join168(process.cwd(), "scripts", "tor", filename)
   ];
   for (const p2 of candidates) {
-    if (existsSync156(p2)) return p2;
+    if (existsSync157(p2)) return p2;
   }
   try {
     const { execSync: execSync63 } = __require("node:child_process");
     const root = execSync63("npm root -g", { encoding: "utf-8", timeout: 5e3 }).trim();
-    const p2 = join167(root, "omnius", "dist", "scripts", "tor", filename);
-    if (existsSync156(p2)) return p2;
+    const p2 = join168(root, "omnius", "dist", "scripts", "tor", filename);
+    if (existsSync157(p2)) return p2;
   } catch {
   }
   return null;
@@ -685818,15 +686197,15 @@ async function handleRemoteProxy(ctx3) {
   const tunnelScope = (process.env["OMNIUS_NEXUS_SCOPE"] || "").toLowerCase();
   const tunnelProjectScope = tunnelScope === "project" || tunnelScope === "local" || ["1", "true", "yes"].includes((process.env["OMNIUS_NEXUS_PROJECT_SCOPE"] || "").toLowerCase());
   const nexusCandidates = tunnelProjectScope ? [
-    join167(process.cwd(), ".omnius", "nexus"),
-    join167(homedir57(), ".omnius", "nexus")
+    join168(process.cwd(), ".omnius", "nexus"),
+    join168(homedir57(), ".omnius", "nexus")
   ] : [
-    join167(homedir57(), ".omnius", "nexus"),
-    join167(process.cwd(), ".omnius", "nexus")
+    join168(homedir57(), ".omnius", "nexus"),
+    join168(process.cwd(), ".omnius", "nexus")
   ];
   let nexusDirPath = null;
   for (const p2 of nexusCandidates) {
-    if (existsSync156(join167(p2, "status.json"))) {
+    if (existsSync157(join168(p2, "status.json"))) {
       nexusDirPath = p2;
       break;
     }
@@ -685922,7 +686301,7 @@ async function handleRemoteProxy(ctx3) {
     }));
     return true;
   }
-  const streamFile = join167(nexusDirPath, `tunnel-${requestId}-${Date.now()}.jsonl`);
+  const streamFile = join168(nexusDirPath, `tunnel-${requestId}-${Date.now()}.jsonl`);
   try {
     const { writeFileSync: _wfs } = await import("node:fs");
     _wfs(streamFile, "");
@@ -686284,11 +686663,16 @@ async function handleListTools(ctx3) {
       default_exposure: entry.defaultExposure,
       availability: entry.availability,
       direct_callable: entry.directCallable,
+      source: "builtin",
       endpoints: {
         call: `/v1/tools/${encodeURIComponent(entry.name)}/call`,
         schema: `/v1/tools/${encodeURIComponent(entry.name)}`
       }
     }));
+    for (const ext of loadExternalTools(workingDir)) {
+      if (profile.loaded && !isToolAllowed(profile.loaded.profile, ext.name)) continue;
+      tools.push(externalToolToListEntry(ext));
+    }
     tools.sort((a2, b) => a2.name.localeCompare(b.name));
     const filterCat = url.searchParams.get("category");
     const filterScope = url.searchParams.get("scope");
@@ -686352,11 +686736,33 @@ async function handleGetTool(ctx3, name10) {
     }
     const found = registry4.byName.get(name10);
     if (!found) {
+      const ext = getExternalTool(workingDir, name10);
+      if (ext) {
+        if (profile.loaded && !isToolAllowed(profile.loaded.profile, name10)) {
+          sendProblem(res, problemDetails({
+            type: P2.forbidden,
+            status: 403,
+            title: "Tool denied by profile",
+            detail: `Tool '${name10}' is not allowed by profile '${profile.loaded.profile.name}'.`,
+            instance: requestId
+          }));
+          return true;
+        }
+        sendJson2(res, 200, {
+          ...externalToolToListEntry(ext),
+          call_body_shape: {
+            args: "<object matching the `parameters` JSON schema>",
+            session_id: "<optional stable workflow id; also accepted as X-Omnius-Session-Id or env.OMNIUS_SESSION_ID>"
+          },
+          active_profile: profile.loaded ? profileMetadata(profile.loaded, registry4.entries.map((entry) => entry.name)) : null
+        });
+        return true;
+      }
       sendProblem(res, problemDetails({
         type: P2.notFound,
         status: 404,
         title: `Tool '${name10}' not found`,
-        detail: "No direct-callable tool with that name is registered.",
+        detail: "No direct-callable or registered external tool with that name.",
         instance: requestId
       }));
       return true;
@@ -686473,6 +686879,10 @@ async function handleCallTool(ctx3, name10) {
     const registry4 = await buildDirectToolRegistry(workingDir);
     const entry = registry4.byName.get(name10);
     if (!entry) {
+      const ext = getExternalTool(workingDir, name10);
+      if (ext) {
+        return callExternalTool(ctx3, ext, args, workingDir, origin, scope, body);
+      }
       sendProblem(res, problemDetails({
         type: P2.notFound,
         status: 404,
@@ -686570,6 +686980,268 @@ async function handleCallTool(ctx3, name10) {
     return true;
   }
 }
+function externalToolToListEntry(ext) {
+  return {
+    name: ext.name,
+    class: "ExternalTool",
+    description: ext.description,
+    parameters: ext.parameters,
+    security: ext.security,
+    default_exposure: ext.security.off_device_allowed ? "trusted-default" : "local-default",
+    availability: { available: true, cached: false, checkedAt: ext.updated_at },
+    direct_callable: true,
+    source: "external",
+    transport: ext.transport.type,
+    endpoints: {
+      call: `/v1/tools/${encodeURIComponent(ext.name)}/call`,
+      schema: `/v1/tools/${encodeURIComponent(ext.name)}`,
+      eval: `/v1/tools/${encodeURIComponent(ext.name)}/eval`
+    },
+    created_at: ext.created_at,
+    updated_at: ext.updated_at
+  };
+}
+function externalDispatchDeps() {
+  return { getMcpManager: (workingDir) => getMcpManager(workingDir) };
+}
+async function callExternalTool(ctx3, ext, args, workingDir, origin, scope, body) {
+  const { res, requestId, user } = ctx3;
+  const scopeRank = { read: 0, run: 1, admin: 2 };
+  if (scopeRank[scope] < scopeRank[ext.security.requires_scope]) {
+    sendProblem(res, problemDetails({
+      type: P2.forbidden,
+      status: 403,
+      title: "Tool invocation denied",
+      detail: `Tool '${ext.name}' requires '${ext.security.requires_scope}' scope; caller has '${scope}'.`,
+      instance: requestId
+    }));
+    return true;
+  }
+  if (origin === "remote" && !ext.security.off_device_allowed && scope !== "admin") {
+    sendProblem(res, problemDetails({
+      type: P2.forbidden,
+      status: 403,
+      title: "Tool invocation denied",
+      detail: `Tool '${ext.name}' is not off_device_allowed; remote callers need admin scope.`,
+      instance: requestId
+    }));
+    return true;
+  }
+  const sessionId = resolveDirectToolSessionId(ctx3, body, args);
+  const result = await executeExternalTool(ext, args, workingDir, sessionId, externalDispatchDeps());
+  publishEvent("tool.called", { tool: ext.name, transport: ext.transport.type, source: "external" }, {
+    subject: user ?? "anonymous",
+    aimsControl: "A.6.2.6"
+    // ISO 42001 — AI system operation record
+  });
+  sendJson2(res, result.success ? 200 : 502, {
+    tool: ext.name,
+    class: "ExternalTool",
+    result,
+    security: ext.security,
+    session_id: sessionId ?? null,
+    origin,
+    scope
+  });
+  return true;
+}
+async function handleRegisterTool(ctx3) {
+  const { req: req3, res, requestId, user } = ctx3;
+  const scope = requestScope(ctx3);
+  if (scope === "read") {
+    sendProblem(res, problemDetails({
+      type: P2.forbidden,
+      status: 403,
+      title: "run scope required",
+      detail: "Registering a tool requires 'run' or 'admin' scope.",
+      instance: requestId
+    }));
+    return true;
+  }
+  let body;
+  try {
+    body = await parseJsonBodyStrict(req3);
+  } catch {
+    sendProblem(res, problemDetails({
+      type: P2.invalidRequest,
+      status: 400,
+      title: "Body must be JSON",
+      detail: "POST a tool manifest: {name, description, parameters, security?, transport}.",
+      instance: requestId
+    }));
+    return true;
+  }
+  const workingDir = resolveToolWorkingDirFromRequest(ctx3);
+  const origin = requestOrigin(ctx3);
+  if (origin === "remote" && scope !== "admin") {
+    sendProblem(res, problemDetails({
+      type: P2.forbidden,
+      status: 403,
+      title: "Admin scope required",
+      detail: "Remote callers must use admin scope to register tools.",
+      instance: requestId
+    }));
+    return true;
+  }
+  const builtins = await buildDirectToolRegistry(workingDir);
+  const manifestName = typeof body?.name === "string" ? body.name.trim() : "";
+  if (manifestName && builtins.byName.has(manifestName)) {
+    sendProblem(res, problemDetails({
+      type: P2.invalidRequest,
+      status: 409,
+      title: "Name collides with built-in tool",
+      detail: `'${manifestName}' is a built-in tool; choose a different name.`,
+      instance: requestId
+    }));
+    return true;
+  }
+  const existing = getExternalTool(workingDir, manifestName) ?? void 0;
+  const validation = validateManifest2(body, existing);
+  if (!validation.ok || !validation.record) {
+    sendProblem(res, problemDetails({
+      type: P2.invalidRequest,
+      status: 400,
+      title: "Invalid tool manifest",
+      detail: validation.error ?? "Manifest failed validation.",
+      instance: requestId
+    }));
+    return true;
+  }
+  const record = validation.record;
+  if (record.transport.type === "mcp" && record.transport.connect?.url) {
+    try {
+      const mgr = await getMcpManager(workingDir);
+      if (mgr && typeof mgr.addServer === "function") {
+        const c8 = record.transport.connect;
+        await mgr.addServer(record.transport.server, {
+          transport: c8.transport ?? "streamable-http",
+          url: c8.url,
+          headers: c8.headers,
+          command: c8.command,
+          args: c8.args
+        });
+      }
+    } catch (err) {
+      sendProblem(res, problemDetails({
+        type: P2.upstreamFailure,
+        status: 502,
+        title: "MCP server connect failed",
+        detail: `Registered tool but could not connect MCP server '${record.transport.server}': ${err instanceof Error ? err.message : String(err)}`,
+        instance: requestId
+      }));
+      return true;
+    }
+  }
+  const { replaced } = upsertExternalTool(workingDir, record);
+  publishEvent("tool.registered", { tool: record.name, transport: record.transport.type, replaced }, {
+    subject: user ?? "anonymous",
+    aimsControl: "A.6.2.4"
+    // ISO 42001 — AI system change/control record
+  });
+  sendJson2(res, replaced ? 200 : 201, {
+    registered: record.name,
+    replaced,
+    working_directory: workingDir,
+    tool: externalToolToListEntry(record)
+  });
+  return true;
+}
+async function handleDeleteTool(ctx3, name10) {
+  const { res, requestId, user } = ctx3;
+  const scope = requestScope(ctx3);
+  if (scope === "read") {
+    sendProblem(res, problemDetails({
+      type: P2.forbidden,
+      status: 403,
+      title: "run scope required",
+      detail: "Unregistering a tool requires 'run' or 'admin' scope.",
+      instance: requestId
+    }));
+    return true;
+  }
+  const workingDir = resolveToolWorkingDirFromRequest(ctx3);
+  const removed = removeExternalTool(workingDir, name10);
+  if (!removed) {
+    sendProblem(res, problemDetails({
+      type: P2.notFound,
+      status: 404,
+      title: `External tool '${name10}' not found`,
+      detail: "Only externally-registered tools can be deleted; built-ins are immutable.",
+      instance: requestId
+    }));
+    return true;
+  }
+  publishEvent("tool.unregistered", { tool: name10 }, {
+    subject: user ?? "anonymous",
+    aimsControl: "A.6.2.4"
+  });
+  sendJson2(res, 200, { unregistered: name10, working_directory: workingDir });
+  return true;
+}
+async function handleEvalTool(ctx3, name10) {
+  const { req: req3, res, requestId } = ctx3;
+  const scope = requestScope(ctx3);
+  if (scope === "read") {
+    sendProblem(res, problemDetails({
+      type: P2.forbidden,
+      status: 403,
+      title: "run scope required",
+      detail: "Evaluating a tool requires 'run' or 'admin' scope.",
+      instance: requestId
+    }));
+    return true;
+  }
+  let body;
+  try {
+    body = await parseJsonBodyStrict(req3);
+  } catch {
+    sendProblem(res, problemDetails({
+      type: P2.invalidRequest,
+      status: 400,
+      title: "Body must be JSON",
+      detail: "POST {cases: [{name?, args, expect?}]}.",
+      instance: requestId
+    }));
+    return true;
+  }
+  const cases = Array.isArray(body?.cases) ? body.cases : null;
+  if (!cases || cases.length === 0) {
+    sendProblem(res, problemDetails({
+      type: P2.invalidRequest,
+      status: 400,
+      title: "Missing 'cases'",
+      detail: "Provide a non-empty `cases` array: [{args, expect?}].",
+      instance: requestId
+    }));
+    return true;
+  }
+  const workingDir = resolveToolWorkingDirFromRequest(ctx3);
+  const ext = getExternalTool(workingDir, name10);
+  if (!ext) {
+    sendProblem(res, problemDetails({
+      type: P2.notFound,
+      status: 404,
+      title: `External tool '${name10}' not found`,
+      detail: "Tool-level eval is available for externally-registered tools.",
+      instance: requestId
+    }));
+    return true;
+  }
+  try {
+    const report2 = await evaluateExternalTool(ext, cases, workingDir, externalDispatchDeps());
+    sendJson2(res, 200, report2);
+    return true;
+  } catch (err) {
+    sendProblem(res, problemDetails({
+      type: P2.internalError,
+      status: 500,
+      title: "Tool eval failed",
+      detail: err instanceof Error ? err.message : String(err),
+      instance: requestId
+    }));
+    return true;
+  }
+}
 async function handleListHooks(ctx3) {
   const { res } = ctx3;
   sendJson2(res, 200, {
@@ -686617,14 +687289,14 @@ async function handleListEngines(ctx3) {
   const home = homedir57();
   sendJson2(res, 200, {
     engines: [
-      { name: "dream", state_file: join167(process.cwd(), ".omnius", "dreams"), controllable_via: "SSE + slash commands" },
-      { name: "bless", state_file: join167(process.cwd(), ".omnius", "bless-state.json"), controllable_via: "slash commands" },
-      { name: "call", state_file: join167(process.cwd(), ".omnius", "call-state.json"), controllable_via: "slash commands" },
-      { name: "listen", state_file: join167(process.cwd(), ".omnius", "listen-state.json"), controllable_via: "slash commands" },
-      { name: "telegram", state_file: join167(home, ".omnius", "telegram-state.json"), controllable_via: "slash commands" },
-      { name: "expose", state_file: join167(process.cwd(), ".omnius", "expose-state.json"), controllable_via: "/expose commands" },
-      { name: "nexus", state_file: join167(home, ".omnius", "nexus-peer-cache.json"), controllable_via: "/nexus commands" },
-      { name: "ipfs", state_file: join167(process.cwd(), ".omnius", "ipfs"), controllable_via: "slash commands" }
+      { name: "dream", state_file: join168(process.cwd(), ".omnius", "dreams"), controllable_via: "SSE + slash commands" },
+      { name: "bless", state_file: join168(process.cwd(), ".omnius", "bless-state.json"), controllable_via: "slash commands" },
+      { name: "call", state_file: join168(process.cwd(), ".omnius", "call-state.json"), controllable_via: "slash commands" },
+      { name: "listen", state_file: join168(process.cwd(), ".omnius", "listen-state.json"), controllable_via: "slash commands" },
+      { name: "telegram", state_file: join168(home, ".omnius", "telegram-state.json"), controllable_via: "slash commands" },
+      { name: "expose", state_file: join168(process.cwd(), ".omnius", "expose-state.json"), controllable_via: "/expose commands" },
+      { name: "nexus", state_file: join168(home, ".omnius", "nexus-peer-cache.json"), controllable_via: "/nexus commands" },
+      { name: "ipfs", state_file: join168(process.cwd(), ".omnius", "ipfs"), controllable_via: "slash commands" }
     ],
     note: "Engine instrumentation lives in the running TUI process. Full status + control requires the daemon↔TUI bridge (PT-07). See parity audit WO-PARITY-04."
   });
@@ -686707,21 +687379,21 @@ async function tryAimsRoute(ctx3) {
   return false;
 }
 function aimsDir() {
-  return join167(homedir57(), ".omnius", "aims");
+  return join168(homedir57(), ".omnius", "aims");
 }
 function readAimsFile(name10, fallback) {
   try {
-    const p2 = join167(aimsDir(), name10);
-    if (existsSync156(p2)) return JSON.parse(readFileSync127(p2, "utf-8"));
+    const p2 = join168(aimsDir(), name10);
+    if (existsSync157(p2)) return JSON.parse(readFileSync128(p2, "utf-8"));
   } catch {
   }
   return fallback;
 }
 function writeAimsFile(name10, data) {
   const dir = aimsDir();
-  const { mkdirSync: mkdirSync105, writeFileSync: wf, renameSync: rn } = __require("node:fs");
-  mkdirSync105(dir, { recursive: true });
-  const finalPath = join167(dir, name10);
+  const { mkdirSync: mkdirSync106, writeFileSync: wf, renameSync: rn } = __require("node:fs");
+  mkdirSync106(dir, { recursive: true });
+  const finalPath = join168(dir, name10);
   const tmpPath = `${finalPath}.tmp.${process.pid}.${Date.now()}`;
   try {
     wf(tmpPath, JSON.stringify(data, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
@@ -687084,12 +687756,12 @@ async function handleAimsSuppliers(ctx3) {
       }
     ];
     const sponsorPaths = [
-      join167(homedir57(), ".omnius", "sponsor-cache.json")
+      join168(homedir57(), ".omnius", "sponsor-cache.json")
     ];
     for (const p2 of sponsorPaths) {
-      if (!existsSync156(p2)) continue;
+      if (!existsSync157(p2)) continue;
       try {
-        const raw = JSON.parse(readFileSync127(p2, "utf-8"));
+        const raw = JSON.parse(readFileSync128(p2, "utf-8"));
         const list = Array.isArray(raw) ? raw : raw?.sponsors ?? [];
         for (const s2 of list) {
           suppliers.push({
@@ -687242,6 +687914,9 @@ var init_routes_v1 = __esm({
     init_command_registry();
     init_profiles();
     init_direct_tool_registry();
+    init_external_tool_registry();
+    init_external_tool_dispatch();
+    init_external_tool_eval();
     init_dist();
     PROBLEM_BASE2 = "https://omnius.nexus/problems";
     P2 = {
@@ -697850,15 +698525,55 @@ function getOpenApiSpec() {
           responses: { 200: { description: "Paginated tools with security metadata" } }
         }
       },
+      "/v1/tools/register": {
+        post: {
+          summary: "Register an application-specific external tool (run scope)",
+          tags: ["Tools"],
+          description: 'Unified registration contract for agents integrating Omnius into their stack. Body: {name, description, parameters (JSON schema, type:object), security?, transport}. `transport` is discriminated: {type:"http", callback_url, auth_header?, headers?, timeout_ms?, result_path?} — Omnius POSTs {name, args, session_id} to callback_url; OR {type:"mcp", server, tool, connect?:{url, transport, headers}} — proxies to a named tool on an MCP server, auto-connecting when `connect` is supplied. Registered tools are persisted per working directory (.omnius/external-tools.json) and appear in GET /v1/tools alongside built-ins. Names that collide with built-ins are rejected (409). Remote callers require admin scope.',
+          responses: {
+            201: { description: "Registered (new)" },
+            200: { description: "Registered (replaced existing)" },
+            400: { description: "Invalid manifest" },
+            403: { description: "Forbidden — run/admin scope required" },
+            409: { description: "Name collides with a built-in tool" },
+            502: { description: "MCP server connect failed" }
+          }
+        }
+      },
       "/v1/tools/{name}": {
         get: {
           summary: "Single tool schema + security policy",
           tags: ["Tools"],
           parameters: [{ name: "name", in: "path", required: true, schema: { type: "string" }, description: "Tool name (snake_case, e.g. file_read)" }],
           responses: {
-            200: { description: "Tool entry with security info" },
+            200: { description: "Tool entry with security info (built-in or external)" },
             404: { description: "Unknown tool name" }
           }
+        },
+        delete: {
+          summary: "Unregister an external tool (run scope)",
+          tags: ["Tools"],
+          description: "Removes an externally-registered tool from the per-working-directory registry. Built-in tools are immutable and return 404.",
+          parameters: [{ name: "name", in: "path", required: true, schema: { type: "string" } }],
+          responses: {
+            200: { description: "Unregistered" },
+            403: { description: "Forbidden — run/admin scope required" },
+            404: { description: "No external tool with that name" }
+          }
+        }
+      },
+      "/v1/tools/{name}/eval": {
+        post: {
+          summary: "Evaluate an external tool against test cases (dev cycle)",
+          tags: ["Tools"],
+          description: "Runs the registered tool for each case and scores it — the dev-cycle complement to /v1/evaluate (which scores agent runs). Body: {cases: [{name?, args, expect?}]}. `expect` supports {success, output_contains, output_equals, output_matches}. Returns per-case pass/fail plus {total, passed, failed, pass_rate, duration_ms}.",
+          parameters: [{ name: "name", in: "path", required: true, schema: { type: "string" } }],
+          responses: {
+            200: { description: "Eval report" },
+            400: { description: "Missing/empty cases" },
+            403: { description: "Forbidden — run/admin scope required" },
+            404: { description: "No external tool with that name" }
+          }
         }
       },
       "/v1/tools/{name}/call": {
@@ -698333,15 +699048,15 @@ var init_auth_oidc = __esm({
 });
 
 // packages/cli/src/api/usage-tracker.ts
-import { mkdirSync as mkdirSync98, readFileSync as readFileSync128, writeFileSync as writeFileSync83, existsSync as existsSync157 } from "node:fs";
-import { join as join168 } from "node:path";
+import { mkdirSync as mkdirSync99, readFileSync as readFileSync129, writeFileSync as writeFileSync84, existsSync as existsSync158 } from "node:fs";
+import { join as join169 } from "node:path";
 function initUsageTracker(omniusDir) {
-  const dir = join168(omniusDir, "usage");
-  mkdirSync98(dir, { recursive: true });
-  usageFile = join168(dir, "token-usage.json");
+  const dir = join169(omniusDir, "usage");
+  mkdirSync99(dir, { recursive: true });
+  usageFile = join169(dir, "token-usage.json");
   try {
-    if (existsSync157(usageFile)) {
-      store = JSON.parse(readFileSync128(usageFile, "utf-8"));
+    if (existsSync158(usageFile)) {
+      store = JSON.parse(readFileSync129(usageFile, "utf-8"));
     }
   } catch {
     store = { providers: {}, lastSaved: "" };
@@ -698377,7 +699092,7 @@ function flush2() {
   if (!initialized2 || !dirty) return;
   try {
     store.lastSaved = (/* @__PURE__ */ new Date()).toISOString();
-    writeFileSync83(usageFile, JSON.stringify(store, null, 2), "utf-8");
+    writeFileSync84(usageFile, JSON.stringify(store, null, 2), "utf-8");
     dirty = false;
   } catch {
   }
@@ -698552,23 +699267,23 @@ var init_chat_followup = __esm({
 
 // packages/cli/src/docker.ts
 import { execSync as execSync59, spawn as spawn32 } from "node:child_process";
-import { existsSync as existsSync158, mkdirSync as mkdirSync99, writeFileSync as writeFileSync84 } from "node:fs";
-import { join as join169, resolve as resolve65, dirname as dirname50 } from "node:path";
+import { existsSync as existsSync159, mkdirSync as mkdirSync100, writeFileSync as writeFileSync85 } from "node:fs";
+import { join as join170, resolve as resolve65, dirname as dirname50 } from "node:path";
 import { homedir as homedir58 } from "node:os";
 import { fileURLToPath as fileURLToPath19 } from "node:url";
 function getDockerDir() {
   try {
     if (typeof __dirname !== "undefined") {
-      return join169(__dirname, "..", "..", "..", "docker");
+      return join170(__dirname, "..", "..", "..", "docker");
     }
   } catch {
   }
   try {
     const thisDir = dirname50(fileURLToPath19(import.meta.url));
-    return join169(thisDir, "..", "..", "..", "docker");
+    return join170(thisDir, "..", "..", "..", "docker");
   } catch {
   }
-  return join169(process.cwd(), "docker");
+  return join170(process.cwd(), "docker");
 }
 function isDockerAvailable() {
   try {
@@ -698699,11 +699414,11 @@ async function ensureOmniusImage(force = false) {
   }
   let buildContext;
   const dockerDir = getDockerDir();
-  if (existsSync158(join169(dockerDir, "Dockerfile"))) {
+  if (existsSync159(join170(dockerDir, "Dockerfile"))) {
     buildContext = dockerDir;
   } else {
-    buildContext = join169(homedir58(), ".omnius", "docker-build");
-    mkdirSync99(buildContext, { recursive: true });
+    buildContext = join170(homedir58(), ".omnius", "docker-build");
+    mkdirSync100(buildContext, { recursive: true });
     writeDockerfiles(buildContext);
   }
   try {
@@ -698777,8 +699492,8 @@ chown -R node:node /workspace /home/node/.omnius 2>/dev/null || true
 if [ "$1" = "omnius" ]; then shift; exec su - node -c "cd /workspace && omnius $*"; fi
 exec "$@"
 `;
-  writeFileSync84(join169(dir, "Dockerfile"), dockerfile);
-  writeFileSync84(join169(dir, "docker-entrypoint.sh"), entrypoint, { mode: 493 });
+  writeFileSync85(join170(dir, "Dockerfile"), dockerfile);
+  writeFileSync85(join170(dir, "docker-entrypoint.sh"), entrypoint, { mode: 493 });
 }
 function hasNvidiaGpu() {
   try {
@@ -698851,7 +699566,7 @@ __export(embedding_workers_exports, {
   startEmbeddingWorkers: () => startEmbeddingWorkers,
   stopEmbeddingWorkers: () => stopEmbeddingWorkers
 });
-import { basename as basename38, join as join170 } from "node:path";
+import { basename as basename38, join as join171 } from "node:path";
 function startEmbeddingWorkers(opts) {
   if (_running) return;
   _running = true;
@@ -698917,8 +699632,8 @@ async function runEmbeddingTask(modality, episodeId, taskId, opts) {
     try {
       if (!_aligner) {
         const stateRoot = process.env.OMNIUS_DIR || process.cwd();
-        const omniusDir = basename38(stateRoot) === ".omnius" ? stateRoot : join170(stateRoot, ".omnius");
-        const memDir = join170(omniusDir, "memory");
+        const omniusDir = basename38(stateRoot) === ".omnius" ? stateRoot : join171(stateRoot, ".omnius");
+        const memDir = join171(omniusDir, "memory");
         _aligner = new EmbeddingAligner(
           `${modality}-${emb.length}`,
           // e.g. "visual-512"
@@ -699033,18 +699748,18 @@ import * as http5 from "node:http";
 import * as https3 from "node:https";
 import { createRequire as createRequire8 } from "node:module";
 import { fileURLToPath as fileURLToPath20 } from "node:url";
-import { dirname as dirname51, join as join171, resolve as resolve66 } from "node:path";
+import { dirname as dirname51, join as join172, resolve as resolve66 } from "node:path";
 import { homedir as homedir59 } from "node:os";
 import { spawn as spawn33, execSync as execSync60 } from "node:child_process";
 import {
   createReadStream as createReadStream2,
-  mkdirSync as mkdirSync100,
-  writeFileSync as writeFileSync85,
-  readFileSync as readFileSync129,
+  mkdirSync as mkdirSync101,
+  writeFileSync as writeFileSync86,
+  readFileSync as readFileSync130,
   readdirSync as readdirSync56,
-  existsSync as existsSync159,
+  existsSync as existsSync160,
   watch as fsWatch4,
-  renameSync as renameSync14,
+  renameSync as renameSync15,
   unlinkSync as unlinkSync34,
   statSync as statSync56,
   openSync as openSync6,
@@ -699054,25 +699769,25 @@ import {
 import { randomBytes as randomBytes28, randomUUID as randomUUID21, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 import { createHash as createHash43 } from "node:crypto";
 function memoryDbPaths3(baseDir = process.cwd()) {
-  const dir = join171(baseDir, ".omnius");
+  const dir = join172(baseDir, ".omnius");
   return {
     dir,
-    episodes: join171(dir, "episodes.db"),
-    knowledge: join171(dir, "knowledge.db")
+    episodes: join172(dir, "episodes.db"),
+    knowledge: join172(dir, "knowledge.db")
   };
 }
 function getVersion3() {
   try {
     const thisDir = dirname51(fileURLToPath20(import.meta.url));
     const candidates = [
-      join171(thisDir, "..", "package.json"),
-      join171(thisDir, "..", "..", "package.json"),
-      join171(thisDir, "..", "..", "..", "package.json")
+      join172(thisDir, "..", "package.json"),
+      join172(thisDir, "..", "..", "package.json"),
+      join172(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
       try {
-        if (!existsSync159(pkgPath)) continue;
-        const pkg = JSON.parse(readFileSync129(pkgPath, "utf8"));
+        if (!existsSync160(pkgPath)) continue;
+        const pkg = JSON.parse(readFileSync130(pkgPath, "utf8"));
         if (pkg.name === "omnius" || pkg.name === "@omnius/cli" || pkg.name === "@omnius/monorepo") {
           return pkg.version ?? "0.0.0";
         }
@@ -699486,9 +700201,9 @@ function isOriginAllowed(origin) {
   if (!origin) return true;
   let accessMode = (process.env["OMNIUS_ACCESS"] || "").toLowerCase().trim();
   try {
-    const accessFile = join171(homedir59(), ".omnius", "access");
-    if (existsSync159(accessFile)) {
-      const persisted = readFileSync129(accessFile, "utf8").trim().toLowerCase();
+    const accessFile = join172(homedir59(), ".omnius", "access");
+    if (existsSync160(accessFile)) {
+      const persisted = readFileSync130(accessFile, "utf8").trim().toLowerCase();
       if (persisted === "any" || persisted === "lan" || persisted === "loopback") {
         accessMode = persisted;
       }
@@ -700332,28 +701047,28 @@ function ollamaStream(ollamaUrl, path12, method, body, onData, onEnd, onError, t
 }
 function jobsDir() {
   const root = resolve66(process.cwd());
-  const dir = join171(root, ".omnius", "jobs");
-  mkdirSync100(dir, { recursive: true });
+  const dir = join172(root, ".omnius", "jobs");
+  mkdirSync101(dir, { recursive: true });
   return dir;
 }
 function loadJob(id) {
-  const file = join171(jobsDir(), `${id}.json`);
-  if (!existsSync159(file)) return null;
+  const file = join172(jobsDir(), `${id}.json`);
+  if (!existsSync160(file)) return null;
   try {
-    return JSON.parse(readFileSync129(file, "utf-8"));
+    return JSON.parse(readFileSync130(file, "utf-8"));
   } catch {
     return null;
   }
 }
 function listJobs2() {
   const dir = jobsDir();
-  if (!existsSync159(dir)) return [];
+  if (!existsSync160(dir)) return [];
   const files = readdirSync56(dir).filter((f2) => f2.endsWith(".json")).sort();
   const jobs = [];
   for (const file of files) {
     try {
       jobs.push(
-        JSON.parse(readFileSync129(join171(dir, file), "utf-8"))
+        JSON.parse(readFileSync130(join172(dir, file), "utf-8"))
       );
     } catch {
     }
@@ -700364,14 +701079,14 @@ function pruneOldJobs() {
   const retentionH = parseFloat(process.env["OMNIUS_RUN_RETENTION_H"] || "24");
   const cutoffMs = Date.now() - (Number.isFinite(retentionH) && retentionH > 0 ? retentionH : 24) * 36e5;
   const dir = jobsDir();
-  if (!existsSync159(dir)) return { pruned: 0, kept: 0 };
+  if (!existsSync160(dir)) return { pruned: 0, kept: 0 };
   let pruned = 0;
   let kept = 0;
   for (const file of readdirSync56(dir)) {
     if (!file.endsWith(".json")) continue;
-    const path12 = join171(dir, file);
+    const path12 = join172(dir, file);
     try {
-      const job = JSON.parse(readFileSync129(path12, "utf-8"));
+      const job = JSON.parse(readFileSync130(path12, "utf-8"));
       if (job.status === "running") {
         kept++;
         continue;
@@ -700384,7 +701099,7 @@ function pruneOldJobs() {
         } catch {
         }
         const outFile = path12.replace(/\.json$/, ".output");
-        if (existsSync159(outFile)) {
+        if (existsSync160(outFile)) {
           try {
             unlinkSync34(outFile);
           } catch {
@@ -700697,14 +701412,14 @@ function autoSeedTodosFromPrompt(prompt) {
   return [];
 }
 function atomicJobWrite(dir, id, job) {
-  const finalPath = join171(dir, `${id}.json`);
+  const finalPath = join172(dir, `${id}.json`);
   const tmpPath = `${finalPath}.tmp.${process.pid}.${Date.now()}`;
   try {
-    writeFileSync85(tmpPath, JSON.stringify(job, null, 2), "utf-8");
-    renameSync14(tmpPath, finalPath);
+    writeFileSync86(tmpPath, JSON.stringify(job, null, 2), "utf-8");
+    renameSync15(tmpPath, finalPath);
   } catch {
     try {
-      writeFileSync85(finalPath, JSON.stringify(job, null, 2), "utf-8");
+      writeFileSync86(finalPath, JSON.stringify(job, null, 2), "utf-8");
     } catch {
     }
     try {
@@ -702516,28 +703231,28 @@ ${task}` : task;
   });
 }
 function updateStateFile() {
-  return join171(homedir59(), ".omnius", "update-state.json");
+  return join172(homedir59(), ".omnius", "update-state.json");
 }
 function updateLogPath() {
-  return join171(homedir59(), ".omnius", "update.log");
+  return join172(homedir59(), ".omnius", "update.log");
 }
 function readUpdateState() {
   try {
     const p2 = updateStateFile();
-    if (!existsSync159(p2)) return null;
-    return JSON.parse(readFileSync129(p2, "utf-8"));
+    if (!existsSync160(p2)) return null;
+    return JSON.parse(readFileSync130(p2, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeUpdateState(state) {
   try {
-    const dir = join171(homedir59(), ".omnius");
-    mkdirSync100(dir, { recursive: true });
+    const dir = join172(homedir59(), ".omnius");
+    mkdirSync101(dir, { recursive: true });
     const finalPath = updateStateFile();
     const tmpPath = `${finalPath}.tmp.${process.pid}`;
-    writeFileSync85(tmpPath, JSON.stringify(state, null, 2), "utf-8");
-    renameSync14(tmpPath, finalPath);
+    writeFileSync86(tmpPath, JSON.stringify(state, null, 2), "utf-8");
+    renameSync15(tmpPath, finalPath);
   } catch {
   }
 }
@@ -702584,15 +703299,15 @@ async function handleV1Update(req3, res, requestId) {
     const { execSync: es } = require4("node:child_process");
     const isWin2 = process.platform === "win32";
     let npmBin = "";
-    for (const candidate of isWin2 ? [join171(nodeDir, "npm.cmd"), join171(nodeDir, "npm")] : [join171(nodeDir, "npm"), "/usr/local/bin/npm", "/usr/bin/npm"]) {
-      if (existsSync159(candidate)) {
+    for (const candidate of isWin2 ? [join172(nodeDir, "npm.cmd"), join172(nodeDir, "npm")] : [join172(nodeDir, "npm"), "/usr/local/bin/npm", "/usr/bin/npm"]) {
+      if (existsSync160(candidate)) {
         npmBin = candidate;
         break;
       }
     }
     if (!npmBin) npmBin = isWin2 ? "npm.cmd" : "npm";
     const pkgSpec = `omnius@${targetVersion}`;
-    const dir = join171(homedir59(), ".omnius");
+    const dir = join172(homedir59(), ".omnius");
     fs11.mkdirSync(dir, { recursive: true });
     const logFd = fs11.openSync(logPath3, "w");
     const npmPrefix = dirname51(nodeDir);
@@ -702606,7 +703321,7 @@ async function handleV1Update(req3, res, requestId) {
         }).trim();
       } else {
         const npmCliCandidates = [
-          join171(
+          join172(
             nodeDir,
             "..",
             "lib",
@@ -702615,7 +703330,7 @@ async function handleV1Update(req3, res, requestId) {
             "bin",
             "npm-cli.js"
           ),
-          join171(
+          join172(
             npmBin,
             "..",
             "..",
@@ -702629,7 +703344,7 @@ async function handleV1Update(req3, res, requestId) {
         let npmCli = "";
         for (const c8 of npmCliCandidates) {
           try {
-            if (existsSync159(c8)) {
+            if (existsSync160(c8)) {
               npmCli = c8;
               break;
             }
@@ -702674,8 +703389,8 @@ async function handleV1Update(req3, res, requestId) {
       );
     } else {
       const npmCliCandidates = [
-        join171(nodeDir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js"),
-        join171(
+        join172(nodeDir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js"),
+        join172(
           npmBin,
           "..",
           "..",
@@ -702689,7 +703404,7 @@ async function handleV1Update(req3, res, requestId) {
       let npmCli = "";
       for (const c8 of npmCliCandidates) {
         try {
-          if (existsSync159(c8)) {
+          if (existsSync160(c8)) {
             npmCli = c8;
             break;
           }
@@ -702829,8 +703544,8 @@ function handleV1UpdateStatus(res) {
   let logTail = "";
   let exitCode = null;
   try {
-    if (existsSync159(logPath3)) {
-      const raw = readFileSync129(logPath3, "utf-8");
+    if (existsSync160(logPath3)) {
+      const raw = readFileSync130(logPath3, "utf-8");
       const m2 = raw.match(/__EXIT_CODE=(\d+)/);
       if (m2) exitCode = parseInt(m2[1], 10);
       logTail = raw.slice(-2e3);
@@ -702954,8 +703669,8 @@ async function handleV1Run(req3, res) {
   if (workingDir) {
     cwd4 = resolve66(workingDir);
   } else if (isolate) {
-    const wsDir = join171(dir, "..", "workspaces", id);
-    mkdirSync100(wsDir, { recursive: true });
+    const wsDir = join172(dir, "..", "workspaces", id);
+    mkdirSync101(wsDir, { recursive: true });
     cwd4 = wsDir;
   } else {
     cwd4 = resolve66(process.cwd());
@@ -703190,7 +703905,7 @@ async function handleV1Run(req3, res) {
     let output = "";
     let tailBytes = 0;
     const TAIL_BUDGET = 1048576;
-    const outputWriter = new DiskTaskOutput(join171(dir, `${id}.output`));
+    const outputWriter = new DiskTaskOutput(join172(dir, `${id}.output`));
     job.outputFile = outputWriter.path;
     atomicJobWrite(dir, id, job);
     child.stdout?.on("data", (chunk) => {
@@ -703416,7 +704131,7 @@ function handleV1RunsById(res, id) {
   }
   const outputFile = job.outputFile;
   const enriched = { ...job };
-  if (outputFile && existsSync159(outputFile)) {
+  if (outputFile && existsSync160(outputFile)) {
     try {
       const size = statSync56(outputFile).size;
       const tailSize = Math.min(size, 4096);
@@ -704387,7 +705102,7 @@ async function handleRequest(req3, res, ollamaUrl, verbose, runtimeDefaults = {}
       }
       try {
         const target = resolve66(rawPath);
-        if (!existsSync159(target)) {
+        if (!existsSync160(target)) {
           jsonResponse(res, 404, { error: "File not found", path: target });
           return;
         }
@@ -704614,12 +705329,12 @@ async function handleRequest(req3, res, ollamaUrl, verbose, runtimeDefaults = {}
           }
           for (const e2 of entries) {
             if (!e2.isDirectory()) continue;
-            const child = join171(dir, e2.name);
-            const omniusDir = join171(child, ".omnius");
+            const child = join172(dir, e2.name);
+            const omniusDir = join172(child, ".omnius");
             try {
               if (statSync56(omniusDir).isDirectory()) {
                 const name10 = e2.name;
-                const prefsFile = join171(omniusDir, "config.json");
+                const prefsFile = join172(omniusDir, "config.json");
                 let lastSeen = 0;
                 try {
                   lastSeen = statSync56(prefsFile).mtimeMs;
@@ -704673,12 +705388,12 @@ async function handleRequest(req3, res, ollamaUrl, verbose, runtimeDefaults = {}
           }
           for (const e2 of entries) {
             if (!e2.isDirectory()) continue;
-            const child = join171(dir, e2.name);
-            const omniusDir = join171(child, ".omnius");
+            const child = join172(dir, e2.name);
+            const omniusDir = join172(child, ".omnius");
             try {
               if (statSync56(omniusDir).isDirectory()) {
                 const name10 = e2.name;
-                const prefsFile = join171(omniusDir, "config.json");
+                const prefsFile = join172(omniusDir, "config.json");
                 let lastSeen = 0;
                 try {
                   lastSeen = statSync56(prefsFile).mtimeMs;
@@ -704886,13 +705601,13 @@ async function handleRequest(req3, res, ollamaUrl, verbose, runtimeDefaults = {}
           return;
         }
         const { tmpdir: tmpdir24 } = await import("node:os");
-        const { writeFileSync: writeFileSync90, unlinkSync: unlinkSync35 } = await import("node:fs");
+        const { writeFileSync: writeFileSync91, unlinkSync: unlinkSync35 } = await import("node:fs");
         const { join: pjoin } = await import("node:path");
         const tmpPath = pjoin(
           tmpdir24(),
           `omnius-clone-upload-${Date.now()}-${safeName3}`
         );
-        writeFileSync90(tmpPath, buf);
+        writeFileSync91(tmpPath, buf);
         try {
           const ve = getVoiceEngine();
           const msg = await ve.setCloneVoice(tmpPath);
@@ -705616,7 +706331,7 @@ data: ${JSON.stringify(data)}
         }
         for (const f2 of seenFiles) {
           try {
-            writeFileSync85(f2, JSON.stringify({ tasks: [] }, null, 2));
+            writeFileSync86(f2, JSON.stringify({ tasks: [] }, null, 2));
             deleted++;
           } catch {
           }
@@ -707292,7 +708007,7 @@ ${historyLines}
 function getScheduleRoots() {
   const rootsEnv = process.env["OMNIUS_SCHEDULE_ROOTS"] || "";
   const roots = rootsEnv.split(rootsEnv.includes(";") ? ";" : ":").filter(Boolean);
-  const defaults3 = [process.cwd(), join171(homedir59(), "Documents")];
+  const defaults3 = [process.cwd(), join172(homedir59(), "Documents")];
   const set = /* @__PURE__ */ new Set([...defaults3, ...roots]);
   return [...set];
 }
@@ -707307,10 +708022,10 @@ function listScheduledTasks() {
         root,
         0,
         (dir) => {
-          if (dir.endsWith(`${join171(".omnius", "scheduled")}`) || dir.includes(`${join171(".omnius", "scheduled")}`)) {
-            const file = join171(dir, "tasks.json");
+          if (dir.endsWith(`${join172(".omnius", "scheduled")}`) || dir.includes(`${join172(".omnius", "scheduled")}`)) {
+            const file = join172(dir, "tasks.json");
             try {
-              const raw = readFileSync129(file, "utf-8");
+              const raw = readFileSync130(file, "utf-8");
               const json = JSON.parse(raw);
               const tasks = Array.isArray(json?.tasks) ? json.tasks : Array.isArray(json) ? json : [];
               tasks.forEach((t2, i2) => {
@@ -707399,7 +708114,7 @@ function walk(dir, depth, onDir, maxDepth) {
     if (e2.name === "node_modules" || e2.name.startsWith(".")) {
       if (e2.name !== ".omnius") continue;
     }
-    const child = join171(dir, e2.name);
+    const child = join172(dir, e2.name);
     walk(child, depth + 1, onDir, maxDepth);
   }
 }
@@ -707408,18 +708123,18 @@ function setScheduledEnabled(id, enabled2) {
   const target = tasks.find((t2) => t2.id === id);
   if (!target) return false;
   try {
-    const raw = readFileSync129(target.file, "utf-8");
+    const raw = readFileSync130(target.file, "utf-8");
     const json = JSON.parse(raw);
     const arr = Array.isArray(json?.tasks) ? json.tasks : Array.isArray(json) ? json : [];
     if (!arr[target.index]) return false;
     arr[target.index].enabled = enabled2;
     if (Array.isArray(json?.tasks)) {
       json.tasks = arr;
-      writeFileSync85(target.file, JSON.stringify(json, null, 2));
+      writeFileSync86(target.file, JSON.stringify(json, null, 2));
     } else if (Array.isArray(json)) {
-      writeFileSync85(target.file, JSON.stringify(arr, null, 2));
+      writeFileSync86(target.file, JSON.stringify(arr, null, 2));
     } else {
-      writeFileSync85(target.file, JSON.stringify({ tasks: arr }, null, 2));
+      writeFileSync86(target.file, JSON.stringify({ tasks: arr }, null, 2));
     }
     if (!enabled2) {
       try {
@@ -707441,7 +708156,7 @@ function deleteScheduledById(id) {
   const target = tasks.find((t2) => t2.id === id);
   if (!target) return false;
   try {
-    const raw = readFileSync129(target.file, "utf-8");
+    const raw = readFileSync130(target.file, "utf-8");
     const json = JSON.parse(raw);
     const arr = Array.isArray(json?.tasks) ? json.tasks : Array.isArray(json) ? json : [];
     if (!arr[target.index]) return false;
@@ -707449,11 +708164,11 @@ function deleteScheduledById(id) {
     arr.splice(target.index, 1);
     if (Array.isArray(json?.tasks)) {
       json.tasks = arr;
-      writeFileSync85(target.file, JSON.stringify(json, null, 2));
+      writeFileSync86(target.file, JSON.stringify(json, null, 2));
     } else if (Array.isArray(json)) {
-      writeFileSync85(target.file, JSON.stringify(arr, null, 2));
+      writeFileSync86(target.file, JSON.stringify(arr, null, 2));
     } else {
-      writeFileSync85(target.file, JSON.stringify({ tasks: arr }, null, 2));
+      writeFileSync86(target.file, JSON.stringify({ tasks: arr }, null, 2));
     }
     const candidates = [];
     if (id) candidates.push(id);
@@ -707662,11 +708377,11 @@ function reconcileScheduledTasks(apply) {
   const errors = [];
   for (const f2 of found) {
     const wdir = f2.workingDir || process.cwd();
-    const file = join171(wdir, ".omnius", "scheduled", "tasks.json");
+    const file = join172(wdir, ".omnius", "scheduled", "tasks.json");
     try {
       let json = { tasks: [] };
       try {
-        const raw = readFileSync129(file, "utf-8");
+        const raw = readFileSync130(file, "utf-8");
         json = JSON.parse(raw);
       } catch {
       }
@@ -707683,11 +708398,11 @@ function reconcileScheduledTasks(apply) {
           };
           arr.push(entry);
           const toWrite = Array.isArray(json?.tasks) ? { ...json, tasks: arr } : Array.isArray(json) ? arr : { tasks: arr };
-          mkdirSync100(join171(wdir, ".omnius", "scheduled"), { recursive: true });
-          mkdirSync100(join171(wdir, ".omnius", "scheduled", "logs"), {
+          mkdirSync101(join172(wdir, ".omnius", "scheduled"), { recursive: true });
+          mkdirSync101(join172(wdir, ".omnius", "scheduled", "logs"), {
             recursive: true
           });
-          writeFileSync85(file, JSON.stringify(toWrite, null, 2));
+          writeFileSync86(file, JSON.stringify(toWrite, null, 2));
           adopted.push({ file, index: arr.length - 1 });
         }
       } else {
@@ -707760,32 +708475,32 @@ function writeCrontabLines(lines) {
 }
 function canonicalCronLine(rec) {
   const omniusBin = findOmniusBinary4();
-  const logDir = join171(rec.workingDir, ".omnius", "scheduled", "logs");
-  const logFile = join171(logDir, `${rec.id}.log`);
-  const storeFile = join171(rec.workingDir, ".omnius", "scheduled", "tasks.json");
+  const logDir = join172(rec.workingDir, ".omnius", "scheduled", "logs");
+  const logFile = join172(logDir, `${rec.id}.log`);
+  const storeFile = join172(rec.workingDir, ".omnius", "scheduled", "tasks.json");
   const taskEsc = rec.task.replace(/'/g, "'\\''");
-  const lockDir = join171(rec.workingDir, ".omnius", "run");
-  const lockPath = join171(lockDir, `${rec.id}.lock`);
+  const lockDir = join172(rec.workingDir, ".omnius", "run");
+  const lockPath = join172(lockDir, `${rec.id}.lock`);
   const wrapper = [
     `cd ${JSON.stringify(rec.workingDir)}`,
     `mkdir -p ${JSON.stringify(logDir)}`,
     `mkdir -p ${JSON.stringify(lockDir)}`,
     `if mkdir ${JSON.stringify(lockPath)} 2>/dev/null; then`,
-    `  echo $$ > ${JSON.stringify(join171(lockPath, "pid"))}`,
+    `  echo $$ > ${JSON.stringify(join172(lockPath, "pid"))}`,
     `  trap 'rm -rf ${lockPath}' EXIT`,
     `else`,
-    `  if [ -f ${JSON.stringify(join171(lockPath, "pid"))} ]; then`,
-    `    oldpid=$(cat ${JSON.stringify(join171(lockPath, "pid"))} 2>/dev/null || echo)`,
+    `  if [ -f ${JSON.stringify(join172(lockPath, "pid"))} ]; then`,
+    `    oldpid=$(cat ${JSON.stringify(join172(lockPath, "pid"))} 2>/dev/null || echo)`,
     `    if [ -n "$oldpid" ] && kill -0 "$oldpid" 2>/dev/null; then`,
     `      echo "[omnius-scheduler] ${rec.id} already running as PID $oldpid; skipping" >> ${JSON.stringify(logFile)}`,
     `      exit 0`,
     `    else`,
     `      rm -rf ${JSON.stringify(lockPath)} 2>/dev/null || true`,
-    `      mkdir -p ${JSON.stringify(lockPath)} && echo $$ > ${JSON.stringify(join171(lockPath, "pid"))} && trap 'rm -rf ${lockPath}' EXIT`,
+    `      mkdir -p ${JSON.stringify(lockPath)} && echo $$ > ${JSON.stringify(join172(lockPath, "pid"))} && trap 'rm -rf ${lockPath}' EXIT`,
     `    fi`,
     `  else`,
     `    rm -rf ${JSON.stringify(lockPath)} 2>/dev/null || true`,
-    `    mkdir -p ${JSON.stringify(lockPath)} && echo $$ > ${JSON.stringify(join171(lockPath, "pid"))} && trap 'rm -rf ${lockPath}' EXIT`,
+    `    mkdir -p ${JSON.stringify(lockPath)} && echo $$ > ${JSON.stringify(join172(lockPath, "pid"))} && trap 'rm -rf ${lockPath}' EXIT`,
     `  fi`,
     `fi`,
     `lease_id="cron-agent-$(date +%s)-$$"`,
@@ -707827,9 +708542,9 @@ function fixupOrMigrateScheduled(mode, dryRun) {
       try {
         if (!f2.workingDir || !f2.task) continue;
         const unitBase = `omnius-${f2.id}`;
-        const unitDir = join171(homedir59(), ".config", "systemd", "user");
-        const svc = join171(unitDir, `${unitBase}.service`);
-        const tim = join171(unitDir, `${unitBase}.timer`);
+        const unitDir = join172(homedir59(), ".config", "systemd", "user");
+        const svc = join172(unitDir, `${unitBase}.service`);
+        const tim = join172(unitDir, `${unitBase}.timer`);
         const omniusBin = findOmniusBinary4();
         const rec = {
           id: f2.id,
@@ -707864,9 +708579,9 @@ Persistent=true
 WantedBy=timers.target
 `;
         if (!dryRun) {
-          mkdirSync100(unitDir, { recursive: true });
-          writeFileSync85(svc, svcText);
-          writeFileSync85(tim, timText);
+          mkdirSync101(unitDir, { recursive: true });
+          writeFileSync86(svc, svcText);
+          writeFileSync86(tim, timText);
           try {
             const { execSync: es } = require4("node:child_process");
             es("systemctl --user daemon-reload", { stdio: "pipe" });
@@ -707981,8 +708696,8 @@ function startApiServer(options2 = {}) {
   const config = loadConfig();
   const ollamaUrl = options2.ollamaUrl ?? config.backendUrl;
   const cwd4 = process.cwd();
-  initAuditLog(join171(cwd4, ".omnius"));
-  initUsageTracker(join171(cwd4, ".omnius"));
+  initAuditLog(join172(cwd4, ".omnius"));
+  initUsageTracker(join172(cwd4, ".omnius"));
   try {
     const taskMgr = getSharedTaskManager();
     taskMgr.setEventPublisher((type, data, opts) => {
@@ -708035,7 +708750,7 @@ function startApiServer(options2 = {}) {
     try {
       const dir = todoDir();
       try {
-        mkdirSync100(dir, { recursive: true });
+        mkdirSync101(dir, { recursive: true });
       } catch {
       }
       const cache8 = /* @__PURE__ */ new Map();
@@ -708045,7 +708760,7 @@ function startApiServer(options2 = {}) {
           const sid = f2.replace(/\.json$/, "");
           try {
             const items = JSON.parse(
-              readFileSync129(join171(dir, f2), "utf-8")
+              readFileSync130(join172(dir, f2), "utf-8")
             );
             if (Array.isArray(items)) {
               cache8.set(sid, new Map(items.map((t2) => [t2.id, t2])));
@@ -708059,10 +708774,10 @@ function startApiServer(options2 = {}) {
         if (!fname || !fname.endsWith(".json") || fname.includes(".tmp."))
           return;
         const sid = fname.replace(/\.json$/, "");
-        const fp = join171(dir, fname);
+        const fp = join172(dir, fname);
         let next = [];
         try {
-          if (!existsSync159(fp)) {
+          if (!existsSync160(fp)) {
             const old = cache8.get(sid);
             if (old) {
               for (const t2 of old.values()) {
@@ -708079,7 +708794,7 @@ function startApiServer(options2 = {}) {
             }
             return;
           }
-          next = JSON.parse(readFileSync129(fp, "utf-8"));
+          next = JSON.parse(readFileSync130(fp, "utf-8"));
           if (!Array.isArray(next)) return;
         } catch {
           return;
@@ -708135,14 +708850,14 @@ function startApiServer(options2 = {}) {
   );
   if (!apiTestMode && retentionDays > 0) {
     try {
-      const jobsDir3 = join171(cwd4, ".omnius", "jobs");
-      if (existsSync159(jobsDir3)) {
+      const jobsDir3 = join172(cwd4, ".omnius", "jobs");
+      if (existsSync160(jobsDir3)) {
         const cutoff = Date.now() - retentionDays * 864e5;
         for (const f2 of readdirSync56(jobsDir3)) {
           if (!f2.endsWith(".json")) continue;
           try {
-            const jobPath = join171(jobsDir3, f2);
-            const job = JSON.parse(readFileSync129(jobPath, "utf-8"));
+            const jobPath = join172(jobsDir3, f2);
+            const job = JSON.parse(readFileSync130(jobPath, "utf-8"));
             const jobTime = new Date(
               job.startedAt ?? job.completedAt ?? 0
             ).getTime();
@@ -708164,8 +708879,8 @@ function startApiServer(options2 = {}) {
   if (useTls) {
     try {
       tlsOpts = {
-        cert: readFileSync129(resolve66(tlsCert)),
-        key: readFileSync129(resolve66(tlsKey))
+        cert: readFileSync130(resolve66(tlsCert)),
+        key: readFileSync130(resolve66(tlsKey))
       };
     } catch (e2) {
       log22(`
@@ -708176,9 +708891,9 @@ function startApiServer(options2 = {}) {
   }
   let runtimeAccessMode = resolveAccessMode(process.env["OMNIUS_ACCESS"], host);
   try {
-    const accessFile = join171(homedir59(), ".omnius", "access");
-    if (existsSync159(accessFile)) {
-      const persisted = readFileSync129(accessFile, "utf8").trim();
+    const accessFile = join172(homedir59(), ".omnius", "access");
+    if (existsSync160(accessFile)) {
+      const persisted = readFileSync130(accessFile, "utf8").trim();
       const resolved = resolveAccessMode(persisted, host);
       if (resolved) runtimeAccessMode = resolved;
     }
@@ -708248,10 +708963,10 @@ function startApiServer(options2 = {}) {
             const previous = runtimeAccessMode;
             runtimeAccessMode = requested;
             try {
-              const dir = join171(homedir59(), ".omnius");
-              mkdirSync100(dir, { recursive: true });
-              writeFileSync85(
-                join171(dir, "access"),
+              const dir = join172(homedir59(), ".omnius");
+              mkdirSync101(dir, { recursive: true });
+              writeFileSync86(
+                join172(dir, "access"),
                 `${runtimeAccessMode}
 `,
                 "utf8"
@@ -708607,9 +709322,9 @@ function startApiServer(options2 = {}) {
         try {
           const here = dirname51(fileURLToPath20(import.meta.url));
           for (const rel of ["../package.json", "../../package.json", "../../../package.json", "../../../../package.json"]) {
-            const p2 = join171(here, rel);
-            if (existsSync159(p2)) {
-              const pkg = JSON.parse(readFileSync129(p2, "utf8"));
+            const p2 = join172(here, rel);
+            if (existsSync160(p2)) {
+              const pkg = JSON.parse(readFileSync130(p2, "utf8"));
               if (pkg.name === "omnius" || pkg.name === "@omnius/cli" || pkg.name === "@omnius/monorepo") {
                 return pkg.version ?? null;
               }
@@ -708663,8 +709378,8 @@ function startApiServer(options2 = {}) {
     }
     try {
       const {
-        writeFileSync: writeFileSync90,
-        mkdirSync: mkdirSync105,
+        writeFileSync: writeFileSync91,
+        mkdirSync: mkdirSync106,
         existsSync: _exists,
         readFileSync: _rfs
       } = require4("node:fs");
@@ -708701,8 +709416,8 @@ function startApiServer(options2 = {}) {
       let written = 0;
       for (const dir of dirSet) {
         try {
-          if (!_exists(dir)) mkdirSync105(dir, { recursive: true });
-          writeFileSync90(_join(dir, "api-port.json"), apiHint);
+          if (!_exists(dir)) mkdirSync106(dir, { recursive: true });
+          writeFileSync91(_join(dir, "api-port.json"), apiHint);
           written++;
         } catch {
         }
@@ -709065,13 +709780,13 @@ async function handleChatAttachmentUpload(req3, res) {
       return;
     }
     const safeName3 = filename.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 180) || `attachment-${Date.now()}.bin`;
-    const dir = join171(process.cwd(), ".omnius", "gui-attachments");
-    mkdirSync100(dir, { recursive: true });
-    const localPath = join171(
+    const dir = join172(process.cwd(), ".omnius", "gui-attachments");
+    mkdirSync101(dir, { recursive: true });
+    const localPath = join172(
       dir,
       `${Date.now()}-${randomUUID21().slice(0, 8)}-${safeName3}`
     );
-    writeFileSync85(localPath, Buffer.from(base642, "base64"));
+    writeFileSync86(localPath, Buffer.from(base642, "base64"));
     const mimeType = typeof b.mimeType === "string" ? b.mimeType : typeof b.mime_type === "string" ? b.mime_type : "";
     const isImage = mimeType.toLowerCase().startsWith("image/") || /\.(png|jpe?g|gif|webp|bmp|tiff?)$/i.test(safeName3);
     const sessionId = typeof b.sessionId === "string" ? b.sessionId : typeof b.session_id === "string" ? b.session_id : void 0;
@@ -709557,15 +710272,15 @@ __export(clipboard_media_exports, {
   pasteClipboardImageToFile: () => pasteClipboardImageToFile
 });
 import { execFileSync as execFileSync11, execSync as execSync61 } from "node:child_process";
-import { mkdirSync as mkdirSync101, readFileSync as readFileSync130, rmSync as rmSync13, writeFileSync as writeFileSync86 } from "node:fs";
-import { join as join172 } from "node:path";
+import { mkdirSync as mkdirSync102, readFileSync as readFileSync131, rmSync as rmSync13, writeFileSync as writeFileSync87 } from "node:fs";
+import { join as join173 } from "node:path";
 function pasteClipboardImageToFile(repoRoot) {
   const image = readClipboardImage();
   if (!image) return null;
-  const dir = join172(repoRoot, ".omnius", "clipboard");
-  mkdirSync101(dir, { recursive: true });
-  const path12 = join172(dir, `clipboard-${Date.now()}${image.ext}`);
-  writeFileSync86(path12, image.buffer);
+  const dir = join173(repoRoot, ".omnius", "clipboard");
+  mkdirSync102(dir, { recursive: true });
+  const path12 = join173(dir, `clipboard-${Date.now()}${image.ext}`);
+  writeFileSync87(path12, image.buffer);
   return { path: path12, buffer: image.buffer, mime: image.mime };
 }
 function readClipboardImage() {
@@ -709574,7 +710289,7 @@ function readClipboardImage() {
       execSync61("command -v pngpaste", { stdio: "ignore", timeout: 1e3 });
       const tmp = `/tmp/omnius-clipboard-${Date.now()}.png`;
       execFileSync11("pngpaste", [tmp], { timeout: 3e3 });
-      const buffer2 = readFileSync130(tmp);
+      const buffer2 = readFileSync131(tmp);
       try {
         rmSync13(tmp);
       } catch {
@@ -709629,19 +710344,19 @@ var init_clipboard_media = __esm({
 
 // packages/cli/src/tui/interactive.ts
 import { cwd } from "node:process";
-import { resolve as resolve67, join as join173, dirname as dirname52, extname as extname22, relative as relative17, sep as sep5 } from "node:path";
+import { resolve as resolve67, join as join174, dirname as dirname52, extname as extname22, relative as relative17, sep as sep5 } from "node:path";
 import { createRequire as createRequire9 } from "node:module";
 import { fileURLToPath as fileURLToPath21 } from "node:url";
 import {
-  readFileSync as readFileSync131,
-  writeFileSync as writeFileSync87,
+  readFileSync as readFileSync132,
+  writeFileSync as writeFileSync88,
   appendFileSync as appendFileSync17,
   rmSync as rmSync14,
   readdirSync as readdirSync57,
   statSync as statSync57,
-  mkdirSync as mkdirSync102
+  mkdirSync as mkdirSync103
 } from "node:fs";
-import { existsSync as existsSync160 } from "node:fs";
+import { existsSync as existsSync161 } from "node:fs";
 import { execSync as execSync62 } from "node:child_process";
 import { homedir as homedir60 } from "node:os";
 function formatTimeAgo2(date) {
@@ -709659,12 +710374,12 @@ function getVersion4() {
     const require5 = createRequire9(import.meta.url);
     const thisDir = dirname52(fileURLToPath21(import.meta.url));
     const candidates = [
-      join173(thisDir, "..", "package.json"),
-      join173(thisDir, "..", "..", "package.json"),
-      join173(thisDir, "..", "..", "..", "package.json")
+      join174(thisDir, "..", "package.json"),
+      join174(thisDir, "..", "..", "package.json"),
+      join174(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync160(pkgPath)) {
+      if (existsSync161(pkgPath)) {
         const pkg = require5(pkgPath);
         if (pkg.name === "omnius" || pkg.name === "@omnius/cli" || pkg.name === "@omnius/monorepo") {
           return pkg.version ?? "0.0.0";
@@ -710684,7 +711399,7 @@ function createFanoutExploreTool(config, repoRoot, ctxWindowSize) {
       if (regions.length === 0) {
         const listDir = (rel) => {
           try {
-            return readdirSync57(join173(repoRoot, rel), { withFileTypes: true }).map(
+            return readdirSync57(join174(repoRoot, rel), { withFileTypes: true }).map(
               (d2) => ({ name: d2.name, isDir: d2.isDirectory() })
             );
           } catch {
@@ -710755,8 +711470,8 @@ function createFanoutExploreTool(config, repoRoot, ctxWindowSize) {
       );
       if (debug) {
         try {
-          writeFileSync87(
-            join173(repoRoot, ".omnius", "fanout-debug.json"),
+          writeFileSync88(
+            join174(repoRoot, ".omnius", "fanout-debug.json"),
             JSON.stringify({ objective, regions, rawReturns, digests }, null, 2)
           );
         } catch {
@@ -711016,14 +711731,14 @@ Meta-critique: quality ${meta.quality}/5, thorough: ${meta.thorough}`;
 function gatherMemorySnippets(root) {
   const snippets = [];
   const dirs = [
-    join173(root, ".omnius", "memory"),
-    join173(root, ".omnius", "memory")
+    join174(root, ".omnius", "memory"),
+    join174(root, ".omnius", "memory")
   ];
   for (const dir of dirs) {
-    if (!existsSync160(dir)) continue;
+    if (!existsSync161(dir)) continue;
     try {
       for (const f2 of readdirSync57(dir).filter((f3) => f3.endsWith(".json"))) {
-        const data = JSON.parse(readFileSync131(join173(dir, f2), "utf-8"));
+        const data = JSON.parse(readFileSync132(join174(dir, f2), "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) snippets.push(v);
@@ -711279,7 +711994,7 @@ function extractGeneratedAudioPath(output, repoRoot) {
   const match = output.match(/(?:Sound|Music|TTS) generated:\s+([^\n\r]+)/i);
   const raw = match?.[1]?.trim().replace(/^["']|["']$/g, "");
   if (!raw) return null;
-  return raw.startsWith("/") || raw.startsWith("~") ? raw.replace(/^~(?=\/)/, homedir60()) : join173(repoRoot, raw);
+  return raw.startsWith("/") || raw.startsWith("~") ? raw.replace(/^~(?=\/)/, homedir60()) : join174(repoRoot, raw);
 }
 async function playGeneratedAudioForToolResult(toolName, output, repoRoot, writer) {
   if (!toolName || !["generate_audio", "generate_tts", "audio_playback"].includes(toolName) || !output)
@@ -711457,9 +712172,9 @@ ${metabolismMemories}
     }
   if (!realtimeEnabled)
     try {
-      const archeFile = join173(repoRoot, ".omnius", "arche", "variants.json");
-      if (existsSync160(archeFile)) {
-        const variants = JSON.parse(readFileSync131(archeFile, "utf8"));
+      const archeFile = join174(repoRoot, ".omnius", "arche", "variants.json");
+      if (existsSync161(archeFile)) {
+        const variants = JSON.parse(readFileSync132(archeFile, "utf8"));
         if (variants.length > 0) {
           let filtered = variants;
           if (taskType) {
@@ -711709,14 +712424,14 @@ RULES:
   const compactionThreshold = Number.isFinite(envOverride) && envOverride > 0 ? envOverride : modelTier2 === "small" ? 12e3 : modelTier2 === "medium" ? 24e3 : 4e4;
   let identityInjection = "";
   try {
-    const ikStateFile = join173(
+    const ikStateFile = join174(
       repoRoot,
       ".omnius",
       "identity",
       "self-state.json"
     );
-    if (existsSync160(ikStateFile)) {
-      const selfState = JSON.parse(readFileSync131(ikStateFile, "utf8"));
+    if (existsSync161(ikStateFile)) {
+      const selfState = JSON.parse(readFileSync132(ikStateFile, "utf8"));
       const lines = [
         `[Identity State v${selfState.version}]`,
         `Self: ${selfState.narrative_summary}`,
@@ -712054,17 +712769,17 @@ Review its full output via sub_agent(action='output', id='${id}')`
           }
         }
         try {
-          const { readdirSync: readdirSync59, readFileSync: readFileSync133, existsSync: existsSync163 } = await import("node:fs");
+          const { readdirSync: readdirSync59, readFileSync: readFileSync134, existsSync: existsSync164 } = await import("node:fs");
           const { join: pathJoin } = await import("node:path");
           const chunksDir = pathJoin(cwd(), ".omnius", "todo-chunks");
-          if (existsSync163(chunksDir)) {
+          if (existsSync164(chunksDir)) {
             const files = readdirSync59(chunksDir).filter(
               (f2) => f2.endsWith(".json")
             );
             for (const f2 of files) {
               try {
                 const data = JSON.parse(
-                  readFileSync133(pathJoin(chunksDir, f2), "utf-8")
+                  readFileSync134(pathJoin(chunksDir, f2), "utf-8")
                 );
                 if (data._deleted) continue;
                 if ((data.functionalSummary || "").toLowerCase().includes(q) || (data.detailSummary || "").toLowerCase().includes(q) || (data.keyFiles || []).some(
@@ -712130,11 +712845,11 @@ ${lines.join("\n")}`
       const expand2 = args.expand === true;
       if (expand2 && id.startsWith("todo-ctx-")) {
         try {
-          const { readFileSync: readFileSync133, existsSync: existsSync163 } = await import("node:fs");
+          const { readFileSync: readFileSync134, existsSync: existsSync164 } = await import("node:fs");
           const { join: pathJoin } = await import("node:path");
           const chunksDir = pathJoin(cwd(), ".omnius", "todo-chunks");
           const todoIdSuffix = id.replace("todo-ctx-", "");
-          const files = existsSync163(chunksDir) ? (await import("node:fs")).readdirSync(chunksDir).filter((f2) => f2.endsWith(".json")) : [];
+          const files = existsSync164(chunksDir) ? (await import("node:fs")).readdirSync(chunksDir).filter((f2) => f2.endsWith(".json")) : [];
           let chunkData = null;
           for (const f2 of files) {
             try {
@@ -713135,13 +713850,13 @@ When done, either call task_complete with your answer, or use FINAL_VAR(variable
               });
             }
             try {
-              const ikDir = join173(repoRoot, ".omnius", "identity");
-              const ikFile = join173(ikDir, "self-state.json");
+              const ikDir = join174(repoRoot, ".omnius", "identity");
+              const ikFile = join174(ikDir, "self-state.json");
               let ikState;
-              if (existsSync160(ikFile)) {
-                ikState = JSON.parse(readFileSync131(ikFile, "utf8"));
+              if (existsSync161(ikFile)) {
+                ikState = JSON.parse(readFileSync132(ikFile, "utf8"));
               } else {
-                mkdirSync102(ikDir, { recursive: true });
+                mkdirSync103(ikDir, { recursive: true });
                 const machineId = Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
                 ikState = {
                   self_id: `omnius-${machineId}`,
@@ -713257,7 +713972,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();
-              writeFileSync87(ikFile, JSON.stringify(ikState, null, 2));
+              writeFileSync88(ikFile, JSON.stringify(ikState, null, 2));
             } catch (ikErr) {
               try {
                 console.error("[IK-OBSERVE]", ikErr);
@@ -713289,14 +714004,14 @@ When done, either call task_complete with your answer, or use FINAL_VAR(variable
               tokens
             );
             try {
-              const ikFile = join173(
+              const ikFile = join174(
                 repoRoot,
                 ".omnius",
                 "identity",
                 "self-state.json"
               );
-              if (existsSync160(ikFile)) {
-                const ikState = JSON.parse(readFileSync131(ikFile, "utf8"));
+              if (existsSync161(ikFile)) {
+                const ikState = JSON.parse(readFileSync132(ikFile, "utf8"));
                 if (!ikState.stats) ikState.stats = { queries_served: 0 };
                 ikState.stats.queries_served = (ikState.stats.queries_served || 0) + 1;
                 ikState.homeostasis.uncertainty = Math.min(
@@ -713318,7 +714033,7 @@ When done, either call task_complete with your answer, or use FINAL_VAR(variable
                   ikState.version_history = ikState.version_history.slice(-200);
                 ikState.session_count = (ikState.session_count || 0) + 1;
                 ikState.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-                writeFileSync87(ikFile, JSON.stringify(ikState, null, 2));
+                writeFileSync88(ikFile, JSON.stringify(ikState, null, 2));
               }
             } catch {
             }
@@ -713618,10 +714333,10 @@ async function startInteractive(config, repoPath2) {
     process.stdin.pause();
   }
   try {
-    const omniusDir = join173(repoRoot, ".omnius");
-    const nexusPidFile = join173(omniusDir, "nexus", "daemon.pid");
-    if (existsSync160(nexusPidFile)) {
-      const pid = parseInt(readFileSync131(nexusPidFile, "utf8").trim(), 10);
+    const omniusDir = join174(repoRoot, ".omnius");
+    const nexusPidFile = join174(omniusDir, "nexus", "daemon.pid");
+    if (existsSync161(nexusPidFile)) {
+      const pid = parseInt(readFileSync132(nexusPidFile, "utf8").trim(), 10);
       if (pid > 0) {
         try {
           process.kill(pid, 0);
@@ -714340,7 +715055,7 @@ ${result.summary}`
   let p2pGateway = null;
   let peerMesh = null;
   let inferenceRouter = null;
-  const secretVault = new SecretVault(join173(repoRoot, ".omnius", "vault.enc"));
+  const secretVault = new SecretVault(join174(repoRoot, ".omnius", "vault.enc"));
   let adminSessionKey = null;
   const callSubAgents = /* @__PURE__ */ new Map();
   void Promise.resolve().then(() => (init_syntax_highlight(), syntax_highlight_exports)).then((m2) => m2.prewarm()).catch(() => {
@@ -714663,22 +715378,22 @@ Respond to the scoped Telegram target when complete.`
     const out = [];
     const pushJsonFiles = (dir, prefix) => {
       try {
-        if (!existsSync160(dir)) return;
+        if (!existsSync161(dir)) return;
         for (const file of readdirSync57(dir)) {
           if (!file.endsWith(".json")) continue;
           const id = file.replace(/\.json$/, "");
-          out.push({ id: `${prefix}:${id}`, label: id, path: join173(dir, file) });
+          out.push({ id: `${prefix}:${id}`, label: id, path: join174(dir, file) });
         }
       } catch {
       }
     };
-    pushJsonFiles(join173(repoRoot, ".omnius", "checkpoints"), "turn");
+    pushJsonFiles(join174(repoRoot, ".omnius", "checkpoints"), "turn");
     try {
-      const sessionDir2 = join173(repoRoot, ".omnius", "session");
-      if (existsSync160(sessionDir2)) {
+      const sessionDir2 = join174(repoRoot, ".omnius", "session");
+      if (existsSync161(sessionDir2)) {
         for (const entry of readdirSync57(sessionDir2)) {
-          const cp2 = join173(sessionDir2, entry, "checkpoint.json");
-          if (existsSync160(cp2))
+          const cp2 = join174(sessionDir2, entry, "checkpoint.json");
+          if (existsSync161(cp2))
             out.push({ id: `session:${entry}`, label: entry, path: cp2 });
         }
       }
@@ -714768,9 +715483,9 @@ This is an independent background session started from /background.`
     return id;
   };
   try {
-    const titleFile = join173(repoRoot, ".omnius", "session-title");
-    if (existsSync160(titleFile))
-      sessionTitle = readFileSync131(titleFile, "utf8").trim() || null;
+    const titleFile = join174(repoRoot, ".omnius", "session-title");
+    if (existsSync161(titleFile))
+      sessionTitle = readFileSync132(titleFile, "utf8").trim() || null;
   } catch {
   }
   let carouselRetired = isResumed;
@@ -714848,7 +715563,7 @@ This is an independent background session started from /background.`
           const completions = [];
           for (const entry of entries) {
             if (!entry.startsWith(partialName)) continue;
-            const full = join173(searchDir, entry);
+            const full = join174(searchDir, entry);
             try {
               const st = statSync57(full);
               const suffix = st.isDirectory() ? "/" : "";
@@ -714879,13 +715594,13 @@ This is an independent background session started from /background.`
     );
     return [hits, line];
   }
-  const HISTORY_DIR = join173(homedir60(), ".omnius");
-  const HISTORY_FILE = join173(HISTORY_DIR, "repl-history");
+  const HISTORY_DIR = join174(homedir60(), ".omnius");
+  const HISTORY_FILE = join174(HISTORY_DIR, "repl-history");
   const MAX_HISTORY_LINES = 500;
   let savedHistory = [];
   try {
-    if (existsSync160(HISTORY_FILE)) {
-      const raw = readFileSync131(HISTORY_FILE, "utf8").trim();
+    if (existsSync161(HISTORY_FILE)) {
+      const raw = readFileSync132(HISTORY_FILE, "utf8").trim();
       if (raw) savedHistory = raw.split("\n").reverse();
     }
   } catch {
@@ -715037,12 +715752,12 @@ This is an independent background session started from /background.`
   function persistHistoryLine(line) {
     if (!line.trim()) return;
     try {
-      mkdirSync102(HISTORY_DIR, { recursive: true });
+      mkdirSync103(HISTORY_DIR, { recursive: true });
       appendFileSync17(HISTORY_FILE, line + "\n", "utf8");
       if (Math.random() < 0.02) {
-        const all2 = readFileSync131(HISTORY_FILE, "utf8").trim().split("\n");
+        const all2 = readFileSync132(HISTORY_FILE, "utf8").trim().split("\n");
         if (all2.length > MAX_HISTORY_LINES) {
-          writeFileSync87(
+          writeFileSync88(
             HISTORY_FILE,
             all2.slice(-MAX_HISTORY_LINES).join("\n") + "\n",
             "utf8"
@@ -715251,10 +715966,10 @@ This is an independent background session started from /background.`
       const { unlinkSync: _rmStale } = await import("node:fs");
       const { homedir: _hdir } = await import("node:os");
       for (const dp of [
-        join173(repoRoot, ".omnius", "nexus", "nexus-daemon.mjs"),
-        join173(_hdir(), ".omnius", "nexus", "nexus-daemon.mjs")
+        join174(repoRoot, ".omnius", "nexus", "nexus-daemon.mjs"),
+        join174(_hdir(), ".omnius", "nexus", "nexus-daemon.mjs")
       ]) {
-        if (existsSync160(dp))
+        if (existsSync161(dp))
           try {
             _rmStale(dp);
           } catch {
@@ -715266,10 +715981,10 @@ This is an independent background session started from /background.`
       const autoNexus = new NexusTool(repoRoot);
       const _registerNexusDaemon = () => {
         try {
-          const nexusPidFile = join173(autoNexus.getNexusDir(), "daemon.pid");
-          if (existsSync160(nexusPidFile)) {
+          const nexusPidFile = join174(autoNexus.getNexusDir(), "daemon.pid");
+          if (existsSync161(nexusPidFile)) {
             const nPid = parseInt(
-              readFileSync131(nexusPidFile, "utf8").trim(),
+              readFileSync132(nexusPidFile, "utf8").trim(),
               10
             );
             if (nPid > 0 && !registry2.daemons.has("Nexus")) {
@@ -715300,7 +716015,7 @@ This is an independent background session started from /background.`
               await new Promise((r3) => setTimeout(r3, 5e3));
               return _tryNexusConnect(attempt + 1);
             }
-            const nexusLogPath = join173(autoNexus.getNexusDir(), "daemon.err");
+            const nexusLogPath = join174(autoNexus.getNexusDir(), "daemon.err");
             const visibleOut = out.length > 1200 ? `${out.slice(0, 1200)}...` : out;
             writeContent(
               () => renderWarning(
@@ -715343,7 +716058,7 @@ Log: ${nexusLogPath}`
     } catch {
     }
     try {
-      const omniusDir = join173(repoRoot, ".omnius");
+      const omniusDir = join174(repoRoot, ".omnius");
       const reconnected = await ExposeGateway.checkAndReconnect(omniusDir, {
         onInfo: (msg) => writeContent(() => renderInfo(msg)),
         onError: (msg) => writeContent(() => renderWarning(msg))
@@ -715382,7 +716097,7 @@ Log: ${nexusLogPath}`
     } catch {
     }
     try {
-      const omniusDir = join173(repoRoot, ".omnius");
+      const omniusDir = join174(repoRoot, ".omnius");
       const reconnectedP2P = await ExposeP2PGateway.checkAndReconnect(
         omniusDir,
         new NexusTool(repoRoot),
@@ -715447,11 +716162,11 @@ Log: ${nexusLogPath}`
         hostname: _hn,
         userInfo: _ui
       } = await import("node:os");
-      const globalNamePath = join173(_hd(), ".omnius", "agent-name");
+      const globalNamePath = join174(_hd(), ".omnius", "agent-name");
       let agName = "";
       try {
-        if (existsSync160(globalNamePath))
-          agName = readFileSync131(globalNamePath, "utf8").trim();
+        if (existsSync161(globalNamePath))
+          agName = readFileSync132(globalNamePath, "utf8").trim();
       } catch {
       }
       if (!agName) {
@@ -715482,7 +716197,7 @@ Log: ${nexusLogPath}`
         }
         if (!ollamaAlive) {
           try {
-            const savedSponsorsPath = join173(
+            const savedSponsorsPath = join174(
               repoRoot,
               ".omnius",
               "sponsor",
@@ -715490,9 +716205,9 @@ Log: ${nexusLogPath}`
             );
             let savedSponsors = [];
             try {
-              if (existsSync160(savedSponsorsPath)) {
+              if (existsSync161(savedSponsorsPath)) {
                 savedSponsors = JSON.parse(
-                  readFileSync131(savedSponsorsPath, "utf8")
+                  readFileSync132(savedSponsorsPath, "utf8")
                 );
                 const oneHourAgo = Date.now() - 36e5;
                 savedSponsors = savedSponsors.filter(
@@ -715982,9 +716697,9 @@ Log: ${nexusLogPath}`
     setSessionTitle(title) {
       sessionTitle = title.trim() || null;
       try {
-        mkdirSync102(join173(repoRoot, ".omnius"), { recursive: true });
-        writeFileSync87(
-          join173(repoRoot, ".omnius", "session-title"),
+        mkdirSync103(join174(repoRoot, ".omnius"), { recursive: true });
+        writeFileSync88(
+          join174(repoRoot, ".omnius", "session-title"),
           `${sessionTitle ?? ""}
 `,
           "utf8"
@@ -717376,10 +718091,10 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
               if (name10 === "voice_list_files") {
                 const baseDir = String(args?.dir ?? ".");
                 const { readdirSync: readdirSync59, statSync: statSync59 } = __require("node:fs");
-                const { join: join178, resolve: resolve71 } = __require("node:path");
-                const base3 = baseDir.startsWith("/") ? baseDir : resolve71(join178(repoRoot, baseDir));
+                const { join: join179, resolve: resolve71 } = __require("node:path");
+                const base3 = baseDir.startsWith("/") ? baseDir : resolve71(join179(repoRoot, baseDir));
                 const items = readdirSync59(base3).slice(0, 200).map((f2) => {
-                  const s2 = statSync59(join178(base3, f2));
+                  const s2 = statSync59(join179(base3, f2));
                   return { name: f2, dir: s2.isDirectory(), size: s2.size };
                 });
                 return JSON.stringify({ dir: base3, items }, null, 2);
@@ -717482,7 +718197,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
             kind,
             targetUrl,
             authKey,
-            stateDir: join173(repoRoot, ".omnius"),
+            stateDir: join174(repoRoot, ".omnius"),
             passthrough: passthrough ?? false,
             loadbalance: loadbalance ?? false,
             endpointAuth: passthrough ? endpointAuth ?? currentConfig.apiKey : void 0,
@@ -717538,7 +718253,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         targetUrl,
         authKey,
         fullAccess,
-        stateDir: join173(repoRoot, ".omnius"),
+        stateDir: join174(repoRoot, ".omnius"),
         endpointAuth: endpointAuth ?? (passthrough ? currentConfig.apiKey : void 0)
       });
       newTunnel.on("stats", (stats) => {
@@ -717630,9 +718345,9 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       });
       if (!result.success) throw new Error(result.error || "Connect failed");
       try {
-        const nexusPidFile = join173(nexusTool.getNexusDir(), "daemon.pid");
-        if (existsSync160(nexusPidFile)) {
-          const pid = parseInt(readFileSync131(nexusPidFile, "utf8").trim(), 10);
+        const nexusPidFile = join174(nexusTool.getNexusDir(), "daemon.pid");
+        if (existsSync161(nexusPidFile)) {
+          const pid = parseInt(readFileSync132(nexusPidFile, "utf8").trim(), 10);
           if (pid > 0) {
             registry2.register({
               name: "Nexus",
@@ -717842,10 +718557,10 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         );
       }
       try {
-        const nexusDir = join173(repoRoot, OMNIUS_DIR, "nexus");
-        const pidFile = join173(nexusDir, "daemon.pid");
-        if (existsSync160(pidFile)) {
-          const pid = parseInt(readFileSync131(pidFile, "utf8").trim(), 10);
+        const nexusDir = join174(repoRoot, OMNIUS_DIR, "nexus");
+        const pidFile = join174(nexusDir, "daemon.pid");
+        if (existsSync161(pidFile)) {
+          const pid = parseInt(readFileSync132(pidFile, "utf8").trim(), 10);
           if (pid > 0) {
             try {
               if (process.platform === "win32") {
@@ -717872,13 +718587,13 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       } catch {
       }
       try {
-        const voiceDir3 = join173(homedir60(), ".omnius", "voice");
+        const voiceDir3 = join174(homedir60(), ".omnius", "voice");
         const voicePidFiles = ["luxtts-daemon.pid", "piper-daemon.pid"];
         for (const pf of voicePidFiles) {
-          const pidPath = join173(voiceDir3, pf);
-          if (existsSync160(pidPath)) {
+          const pidPath = join174(voiceDir3, pf);
+          if (existsSync161(pidPath)) {
             try {
-              const pid = parseInt(readFileSync131(pidPath, "utf8").trim(), 10);
+              const pid = parseInt(readFileSync132(pidPath, "utf8").trim(), 10);
               if (pid > 0) {
                 if (process.platform === "win32") {
                   try {
@@ -717908,8 +718623,8 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         );
       } catch {
       }
-      const omniusPath = join173(repoRoot, OMNIUS_DIR);
-      if (existsSync160(omniusPath)) {
+      const omniusPath = join174(repoRoot, OMNIUS_DIR);
+      if (existsSync161(omniusPath)) {
         let deleted = false;
         for (let attempt = 0; attempt < 3; attempt++) {
           try {
@@ -718020,23 +718735,23 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
   try {
     const { isPersonaPlexRunning: isPersonaPlexRunning2 } = await Promise.resolve().then(() => (init_personaplex(), personaplex_exports));
     if (isPersonaPlexRunning2()) {
-      const ppPidFile = join173(
+      const ppPidFile = join174(
         homedir60(),
         ".omnius",
         "voice",
         "personaplex",
         "daemon.pid"
       );
-      const ppPortFile = join173(
+      const ppPortFile = join174(
         homedir60(),
         ".omnius",
         "voice",
         "personaplex",
         "daemon.port"
       );
-      if (existsSync160(ppPidFile)) {
-        const ppPid = parseInt(readFileSync131(ppPidFile, "utf8").trim(), 10);
-        const ppPort = existsSync160(ppPortFile) ? parseInt(readFileSync131(ppPortFile, "utf8").trim(), 10) : void 0;
+      if (existsSync161(ppPidFile)) {
+        const ppPid = parseInt(readFileSync132(ppPidFile, "utf8").trim(), 10);
+        const ppPort = existsSync161(ppPortFile) ? parseInt(readFileSync132(ppPortFile, "utf8").trim(), 10) : void 0;
         if (ppPid > 0 && !registry2.daemons.has("PersonaPlex")) {
           registry2.register({
             name: "PersonaPlex",
@@ -718048,12 +718763,12 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         }
       }
     }
-    const nexusPidFile = join173(
+    const nexusPidFile = join174(
       new NexusTool(repoRoot).getNexusDir(),
       "daemon.pid"
     );
-    if (existsSync160(nexusPidFile)) {
-      const nPid = parseInt(readFileSync131(nexusPidFile, "utf8").trim(), 10);
+    if (existsSync161(nexusPidFile)) {
+      const nPid = parseInt(readFileSync132(nexusPidFile, "utf8").trim(), 10);
       if (nPid > 0 && !registry2.daemons.has("Nexus")) {
         try {
           process.kill(nPid, 0);
@@ -718483,9 +719198,9 @@ Execute this skill now. Follow the behavioral guidance above.`;
       }
     }
     const cleanPath = input.replace(/^['"]|['"]$/g, "").trim();
-    const isImage = isImagePath(cleanPath) && existsSync160(resolve67(repoRoot, cleanPath));
-    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync160(resolve67(repoRoot, cleanPath));
-    const isMarkdown = !isImage && !isMedia && /\.(md|markdown)$/i.test(cleanPath) && existsSync160(resolve67(repoRoot, cleanPath));
+    const isImage = isImagePath(cleanPath) && existsSync161(resolve67(repoRoot, cleanPath));
+    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync161(resolve67(repoRoot, cleanPath));
+    const isMarkdown = !isImage && !isMedia && /\.(md|markdown)$/i.test(cleanPath) && existsSync161(resolve67(repoRoot, cleanPath));
     if (activeTask) {
       if ((isImage || isMedia) && activeTask.runner.isPaused) {
         activeTask.runner.resume();
@@ -718494,7 +719209,7 @@ Execute this skill now. Follow the behavioral guidance above.`;
       if (isImage) {
         try {
           const imgPath = resolve67(repoRoot, cleanPath);
-          const imgBuffer = readFileSync131(imgPath);
+          const imgBuffer = readFileSync132(imgPath);
           const base642 = imgBuffer.toString("base64");
           const ext = extname22(cleanPath).toLowerCase();
           const mime = ext === ".png" ? "image/png" : ext === ".gif" ? "image/gif" : ext === ".webp" ? "image/webp" : "image/jpeg";
@@ -718727,7 +719442,7 @@ Read it with image_read or vision if more detail is needed. Describe what you se
     if (isMarkdown && fullInput === input) {
       try {
         const mdPath = resolve67(repoRoot, cleanPath);
-        const mdContent = readFileSync131(mdPath, "utf8");
+        const mdContent = readFileSync132(mdPath, "utf8");
         const { parseMcpMarkdown: parseMcpMarkdown2 } = await Promise.resolve().then(() => (init_dist5(), dist_exports2));
         const result = parseMcpMarkdown2(mdContent);
         if (result.servers.length > 0) {
@@ -719364,13 +720079,13 @@ async function runWithTUI(task, config, repoPath2, callbacks) {
     const handle2 = startTask(task, config, repoRoot);
     await handle2.promise;
     try {
-      const ikDir = join173(repoRoot, ".omnius", "identity");
-      const ikFile = join173(ikDir, "self-state.json");
+      const ikDir = join174(repoRoot, ".omnius", "identity");
+      const ikFile = join174(ikDir, "self-state.json");
       let ikState;
-      if (existsSync160(ikFile)) {
-        ikState = JSON.parse(readFileSync131(ikFile, "utf8"));
+      if (existsSync161(ikFile)) {
+        ikState = JSON.parse(readFileSync132(ikFile, "utf8"));
       } else {
-        mkdirSync102(ikDir, { recursive: true });
+        mkdirSync103(ikDir, { recursive: true });
         ikState = {
           self_id: `omnius-${Date.now().toString(36)}`,
           version: 1,
@@ -719423,7 +720138,7 @@ async function runWithTUI(task, config, repoPath2, callbacks) {
       );
       ikState.session_count = (ikState.session_count || 0) + 1;
       ikState.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-      writeFileSync87(ikFile, JSON.stringify(ikState, null, 2));
+      writeFileSync88(ikFile, JSON.stringify(ikState, null, 2));
     } catch (ikErr) {
     }
     try {
@@ -719436,12 +720151,12 @@ async function runWithTUI(task, config, repoPath2, callbacks) {
       );
     } catch {
       try {
-        const archeDir = join173(repoRoot, ".omnius", "arche");
-        const archeFile = join173(archeDir, "variants.json");
+        const archeDir = join174(repoRoot, ".omnius", "arche");
+        const archeFile = join174(archeDir, "variants.json");
         let variants = [];
         try {
-          if (existsSync160(archeFile))
-            variants = JSON.parse(readFileSync131(archeFile, "utf8"));
+          if (existsSync161(archeFile))
+            variants = JSON.parse(readFileSync132(archeFile, "utf8"));
         } catch {
         }
         variants.push({
@@ -719455,21 +720170,21 @@ async function runWithTUI(task, config, repoPath2, callbacks) {
           tags: ["general"]
         });
         if (variants.length > 50) variants = variants.slice(-50);
-        mkdirSync102(archeDir, { recursive: true });
-        writeFileSync87(archeFile, JSON.stringify(variants, null, 2));
+        mkdirSync103(archeDir, { recursive: true });
+        writeFileSync88(archeFile, JSON.stringify(variants, null, 2));
       } catch {
       }
     }
     try {
-      const metaFile2 = join173(
+      const metaFile2 = join174(
         repoRoot,
         ".omnius",
         "memory",
         "metabolism",
         "store.json"
       );
-      if (existsSync160(metaFile2)) {
-        const store2 = JSON.parse(readFileSync131(metaFile2, "utf8"));
+      if (existsSync161(metaFile2)) {
+        const store2 = JSON.parse(readFileSync132(metaFile2, "utf8"));
         const surfaced = store2.filter(
           (m2) => m2.type !== "quarantine" && m2.scores?.confidence > 0.15
         ).sort(
@@ -719487,7 +720202,7 @@ async function runWithTUI(task, config, repoPath2, callbacks) {
           updated = true;
         }
         if (updated) {
-          writeFileSync87(metaFile2, JSON.stringify(store2, null, 2));
+          writeFileSync88(metaFile2, JSON.stringify(store2, null, 2));
         }
       }
     } catch {
@@ -719545,9 +720260,9 @@ Rules:
           try {
             const { initDb: initDb2 } = __require("@omnius/memory");
             const { ProceduralMemoryStore: ProceduralMemoryStore2 } = __require("@omnius/memory");
-            const dbDir = join173(repoRoot, ".omnius", "memory");
-            mkdirSync102(dbDir, { recursive: true });
-            const db = initDb2(join173(dbDir, "structured.db"));
+            const dbDir = join174(repoRoot, ".omnius", "memory");
+            mkdirSync103(dbDir, { recursive: true });
+            const db = initDb2(join174(dbDir, "structured.db"));
             const memStore = new ProceduralMemoryStore2(db);
             memStore.createWithEmbedding(
               {
@@ -719567,12 +720282,12 @@ Rules:
             db.close();
           } catch {
           }
-          const metaDir = join173(repoRoot, ".omnius", "memory", "metabolism");
-          const storeFile = join173(metaDir, "store.json");
+          const metaDir = join174(repoRoot, ".omnius", "memory", "metabolism");
+          const storeFile = join174(metaDir, "store.json");
           let store2 = [];
           try {
-            if (existsSync160(storeFile))
-              store2 = JSON.parse(readFileSync131(storeFile, "utf8"));
+            if (existsSync161(storeFile))
+              store2 = JSON.parse(readFileSync132(storeFile, "utf8"));
           } catch {
           }
           store2.push({
@@ -719595,32 +720310,32 @@ Rules:
             accessCount: 0
           });
           if (store2.length > 100) store2 = store2.slice(-100);
-          mkdirSync102(metaDir, { recursive: true });
-          writeFileSync87(storeFile, JSON.stringify(store2, null, 2));
+          mkdirSync103(metaDir, { recursive: true });
+          writeFileSync88(storeFile, JSON.stringify(store2, null, 2));
         }
       }
     } catch {
     }
     try {
-      const cohereSettingsFile = join173(repoRoot, ".omnius", "settings.json");
+      const cohereSettingsFile = join174(repoRoot, ".omnius", "settings.json");
       let cohereActive = false;
       try {
-        if (existsSync160(cohereSettingsFile)) {
-          const settings = JSON.parse(readFileSync131(cohereSettingsFile, "utf8"));
+        if (existsSync161(cohereSettingsFile)) {
+          const settings = JSON.parse(readFileSync132(cohereSettingsFile, "utf8"));
           cohereActive = settings.cohere === true;
         }
       } catch {
       }
       if (cohereActive) {
-        const metaFile2 = join173(
+        const metaFile2 = join174(
           repoRoot,
           ".omnius",
           "memory",
           "metabolism",
           "store.json"
         );
-        if (existsSync160(metaFile2)) {
-          const store2 = JSON.parse(readFileSync131(metaFile2, "utf8"));
+        if (existsSync161(metaFile2)) {
+          const store2 = JSON.parse(readFileSync132(metaFile2, "utf8"));
           const latest = store2.filter(
             (m2) => m2.sourceTrace === "trajectory-extraction" || m2.sourceTrace === "llm-trajectory-extraction"
           ).slice(-1)[0];
@@ -719647,9 +720362,9 @@ Rules:
     }
   } catch (err) {
     try {
-      const ikFile = join173(repoRoot, ".omnius", "identity", "self-state.json");
-      if (existsSync160(ikFile)) {
-        const ikState = JSON.parse(readFileSync131(ikFile, "utf8"));
+      const ikFile = join174(repoRoot, ".omnius", "identity", "self-state.json");
+      if (existsSync161(ikFile)) {
+        const ikState = JSON.parse(readFileSync132(ikFile, "utf8"));
         ikState.homeostasis.uncertainty = Math.min(
           1,
           ikState.homeostasis.uncertainty + 0.1
@@ -719660,17 +720375,17 @@ Rules:
         );
         ikState.session_count = (ikState.session_count || 0) + 1;
         ikState.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-        writeFileSync87(ikFile, JSON.stringify(ikState, null, 2));
+        writeFileSync88(ikFile, JSON.stringify(ikState, null, 2));
       }
-      const metaFile2 = join173(
+      const metaFile2 = join174(
         repoRoot,
         ".omnius",
         "memory",
         "metabolism",
         "store.json"
       );
-      if (existsSync160(metaFile2)) {
-        const store2 = JSON.parse(readFileSync131(metaFile2, "utf8"));
+      if (existsSync161(metaFile2)) {
+        const store2 = JSON.parse(readFileSync132(metaFile2, "utf8"));
         const surfaced = store2.filter(
           (m2) => m2.type !== "quarantine" && m2.scores?.confidence > 0.15
         ).sort(
@@ -719688,15 +720403,15 @@ Rules:
             (item.scores.confidence || 0.5) - 0.02
           );
         }
-        writeFileSync87(metaFile2, JSON.stringify(store2, null, 2));
+        writeFileSync88(metaFile2, JSON.stringify(store2, null, 2));
       }
       try {
-        const archeDir = join173(repoRoot, ".omnius", "arche");
-        const archeFile = join173(archeDir, "variants.json");
+        const archeDir = join174(repoRoot, ".omnius", "arche");
+        const archeFile = join174(archeDir, "variants.json");
         let variants = [];
         try {
-          if (existsSync160(archeFile))
-            variants = JSON.parse(readFileSync131(archeFile, "utf8"));
+          if (existsSync161(archeFile))
+            variants = JSON.parse(readFileSync132(archeFile, "utf8"));
         } catch {
         }
         variants.push({
@@ -719710,8 +720425,8 @@ Rules:
           tags: ["general"]
         });
         if (variants.length > 50) variants = variants.slice(-50);
-        mkdirSync102(archeDir, { recursive: true });
-        writeFileSync87(archeFile, JSON.stringify(variants, null, 2));
+        mkdirSync103(archeDir, { recursive: true });
+        writeFileSync88(archeFile, JSON.stringify(variants, null, 2));
       } catch {
       }
     } catch {
@@ -719822,18 +720537,18 @@ __export(run_exports, {
 import { resolve as resolve68 } from "node:path";
 import { spawn as spawn34 } from "node:child_process";
 import {
-  mkdirSync as mkdirSync103,
-  writeFileSync as writeFileSync88,
-  readFileSync as readFileSync132,
+  mkdirSync as mkdirSync104,
+  writeFileSync as writeFileSync89,
+  readFileSync as readFileSync133,
   readdirSync as readdirSync58,
-  existsSync as existsSync161
+  existsSync as existsSync162
 } from "node:fs";
 import { randomBytes as randomBytes29 } from "node:crypto";
-import { join as join174 } from "node:path";
+import { join as join175 } from "node:path";
 function jobsDir2(repoPath2) {
   const root = resolve68(repoPath2 ?? process.cwd());
-  const dir = join174(root, ".omnius", "jobs");
-  mkdirSync103(dir, { recursive: true });
+  const dir = join175(root, ".omnius", "jobs");
+  mkdirSync104(dir, { recursive: true });
   return dir;
 }
 async function runCommand2(opts, config) {
@@ -719963,7 +720678,7 @@ async function runBackground(task, config, opts) {
     }
   });
   job.pid = child.pid ?? 0;
-  writeFileSync88(join174(dir, `${id}.json`), JSON.stringify(job, null, 2));
+  writeFileSync89(join175(dir, `${id}.json`), JSON.stringify(job, null, 2));
   let output = "";
   child.stdout?.on("data", (chunk) => {
     output += chunk.toString();
@@ -719979,7 +720694,7 @@ async function runBackground(task, config, opts) {
       job.summary = result.summary;
       job.durationMs = result.durationMs;
       job.error = result.error;
-      writeFileSync88(join174(dir, `${id}.json`), JSON.stringify(job, null, 2));
+      writeFileSync89(join175(dir, `${id}.json`), JSON.stringify(job, null, 2));
     } catch {
     }
   });
@@ -719995,13 +720710,13 @@ async function runBackground(task, config, opts) {
 }
 function statusCommand(jobId, repoPath2) {
   const dir = jobsDir2(repoPath2);
-  const file = join174(dir, `${jobId}.json`);
-  if (!existsSync161(file)) {
+  const file = join175(dir, `${jobId}.json`);
+  if (!existsSync162(file)) {
     console.error(`Job not found: ${jobId}`);
     console.log(`Available jobs: omnius jobs`);
     process.exit(1);
   }
-  const job = JSON.parse(readFileSync132(file, "utf-8"));
+  const job = JSON.parse(readFileSync133(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" ? "✓" : job.status === "failed" ? "✗" : "●";
   console.log(`${icon} ${job.id} [${job.status}] ${runtime}`);
@@ -720023,7 +720738,7 @@ function jobsCommand(repoPath2) {
   console.log("Jobs:");
   for (const file of files) {
     try {
-      const job = JSON.parse(readFileSync132(join174(dir, file), "utf-8"));
+      const job = JSON.parse(readFileSync133(join175(dir, file), "utf-8"));
       const icon = job.status === "completed" ? "✓" : job.status === "failed" ? "✗" : "●";
       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 cleanListTask = cleanForStorage(job.task) || job.task;
@@ -720050,13 +720765,13 @@ __export(index_repo_exports, {
   indexRepoCommand: () => indexRepoCommand
 });
 import { resolve as resolve69 } from "node:path";
-import { existsSync as existsSync162, statSync as statSync58 } from "node:fs";
+import { existsSync as existsSync163, statSync as statSync58 } from "node:fs";
 import { cwd as cwd2 } from "node:process";
 async function indexRepoCommand(opts, _config3) {
   const repoRoot = resolve69(opts.repoPath ?? cwd2());
   printHeader("Index Repository");
   printInfo(`Indexing: ${repoRoot}`);
-  if (!existsSync162(repoRoot)) {
+  if (!existsSync163(repoRoot)) {
     printError(`Path does not exist: ${repoRoot}`);
     process.exit(1);
   }
@@ -720308,7 +721023,7 @@ var config_exports2 = {};
 __export(config_exports2, {
   configCommand: () => configCommand
 });
-import { join as join175, resolve as resolve70 } from "node:path";
+import { join as join176, resolve as resolve70 } from "node:path";
 import { homedir as homedir61 } from "node:os";
 import { cwd as cwd3 } from "node:process";
 function redactIfSensitive(key, value2) {
@@ -720392,7 +721107,7 @@ function handleShow(opts, config) {
     }
   }
   printSection("Config File");
-  printInfo(`~/.omnius/config.json (${join175(homedir61(), ".omnius", "config.json")})`);
+  printInfo(`~/.omnius/config.json (${join176(homedir61(), ".omnius", "config.json")})`);
   printSection("Priority Chain");
   printInfo("  1. CLI flags (--model, --backend-url, etc.)");
   printInfo("  2. Project .omnius/settings.json (--local)");
@@ -720431,7 +721146,7 @@ function handleSet(opts, _config3) {
       const coerced = coerceForSettings(key, value2);
       saveProjectSettings(repoRoot, { [key]: coerced });
       printSuccess(`Project override set: ${key} = ${redactIfSensitive(key, value2)}`);
-      printInfo(`Saved to ${join175(repoRoot, ".omnius", "settings.json")}`);
+      printInfo(`Saved to ${join176(repoRoot, ".omnius", "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)}`);
@@ -720618,8 +721333,8 @@ __export(eval_exports, {
   evalCommand: () => evalCommand
 });
 import { tmpdir as tmpdir23 } from "node:os";
-import { mkdirSync as mkdirSync104, writeFileSync as writeFileSync89 } from "node:fs";
-import { join as join176 } from "node:path";
+import { mkdirSync as mkdirSync105, writeFileSync as writeFileSync90 } from "node:fs";
+import { join as join177 } from "node:path";
 async function evalCommand(opts, config) {
   const suiteName = opts.suite ?? "basic";
   const suite = SUITES[suiteName];
@@ -720748,10 +721463,10 @@ async function evalCommand(opts, config) {
   process.exit(failed > 0 ? 1 : 0);
 }
 function createTempEvalRepo() {
-  const dir = join176(tmpdir23(), `omnius-eval-${Date.now()}`);
-  mkdirSync104(dir, { recursive: true });
-  writeFileSync89(
-    join176(dir, "package.json"),
+  const dir = join177(tmpdir23(), `omnius-eval-${Date.now()}`);
+  mkdirSync105(dir, { recursive: true });
+  writeFileSync90(
+    join177(dir, "package.json"),
     JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n",
     "utf8"
   );
@@ -720826,7 +721541,7 @@ init_typed_node_events();
 init_dist5();
 import { parseArgs as nodeParseArgs2 } from "node:util";
 import { fileURLToPath as fileURLToPath22 } from "node:url";
-import { dirname as dirname53, join as join177 } from "node:path";
+import { dirname as dirname53, join as join178 } from "node:path";
 import { createRequire as createRequire10 } from "node:module";
 
 // packages/cli/src/cli.ts
@@ -720974,7 +721689,7 @@ init_output();
 function getVersion5() {
   try {
     const require5 = createRequire10(import.meta.url);
-    const pkgPath = join177(dirname53(fileURLToPath22(import.meta.url)), "..", "package.json");
+    const pkgPath = join178(dirname53(fileURLToPath22(import.meta.url)), "..", "package.json");
     const pkg = require5(pkgPath);
     return pkg.version;
   } catch {
@@ -721356,12 +722071,12 @@ function crashLog(label, err) {
   const logLine = `[${timestamp}] ${label}: ${msg}
 `;
   try {
-    const { appendFileSync: appendFileSync18, mkdirSync: mkdirSync105 } = __require("node:fs");
-    const { join: join178 } = __require("node:path");
+    const { appendFileSync: appendFileSync18, mkdirSync: mkdirSync106 } = __require("node:fs");
+    const { join: join179 } = __require("node:path");
     const { homedir: homedir62 } = __require("node:os");
-    const logDir = join178(homedir62(), ".omnius");
-    mkdirSync105(logDir, { recursive: true });
-    appendFileSync18(join178(logDir, "crash.log"), logLine);
+    const logDir = join179(homedir62(), ".omnius");
+    mkdirSync106(logDir, { recursive: true });
+    appendFileSync18(join179(logDir, "crash.log"), logLine);
   } catch {
   }
   try {