omnius 1.0.200 → 1.0.201

package/dist/index.js

@@ -258385,9 +258385,9 @@ print("${sentinel}")
         if (!this.proc || this.proc.killed) {
           return { success: false, path: "" };
         }
-        const { mkdirSync: mkdirSync88, writeFileSync: writeFileSync79 } = await import("node:fs");
+        const { mkdirSync: mkdirSync89, writeFileSync: writeFileSync80 } = await import("node:fs");
         const sessionDir2 = join36(this.cwd, ".omnius", "rlm");
-        mkdirSync88(sessionDir2, { recursive: true });
+        mkdirSync89(sessionDir2, { recursive: true });
         const sessionPath2 = join36(sessionDir2, "session.json");
         try {
           const inspectCode = `
@@ -258411,7 +258411,7 @@ print("__SESSION__" + json.dumps(_session) + "__SESSION__")
               trajectoryCount: this.trajectory.length,
               subCallCount: this.subCallCount
             };
-            writeFileSync79(sessionPath2, JSON.stringify(sessionData, null, 2), "utf8");
+            writeFileSync80(sessionPath2, JSON.stringify(sessionData, null, 2), "utf8");
             return { success: true, path: sessionPath2 };
           }
         } catch {
@@ -259020,7 +259020,7 @@ ${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: readFileSync117, writeFileSync: writeFileSync79, existsSync: existsSync144, mkdirSync: mkdirSync88 } = __require("node:fs");
+        const { readFileSync: readFileSync117, writeFileSync: writeFileSync80, existsSync: existsSync144, mkdirSync: mkdirSync89 } = __require("node:fs");
         const metaDir = join37(this.cwd, ".omnius", "memory", "metabolism");
         const storeFile = join37(metaDir, "store.json");
         if (!existsSync144(storeFile))
@@ -259051,8 +259051,8 @@ ${issues.map((i2) => `  - ${i2}`).join("\n")}` : "  No issues found."),
           updated = true;
         }
         if (updated) {
-          mkdirSync88(metaDir, { recursive: true });
-          writeFileSync79(storeFile, JSON.stringify(store2, null, 2));
+          mkdirSync89(metaDir, { recursive: true });
+          writeFileSync80(storeFile, JSON.stringify(store2, null, 2));
         }
       }
       // ── Storage ──────────────────────────────────────────────────────────
@@ -259498,7 +259498,7 @@ Recommendation: Strategy ${scored[0].index + 1} scores highest.`;
       }
       /** Archive a strategy variant synchronously (for task completion path) */
       archiveVariantSync(strategy, outcome, tags = []) {
-        const { readFileSync: readFileSync117, writeFileSync: writeFileSync79, existsSync: existsSync144, mkdirSync: mkdirSync88 } = __require("node:fs");
+        const { readFileSync: readFileSync117, writeFileSync: writeFileSync80, existsSync: existsSync144, mkdirSync: mkdirSync89 } = __require("node:fs");
         const dir = join39(this.cwd, ".omnius", "arche");
         const archiveFile = join39(dir, "variants.json");
         let variants = [];
@@ -259519,8 +259519,8 @@ Recommendation: Strategy ${scored[0].index + 1} scores highest.`;
         });
         if (variants.length > 50)
           variants = variants.slice(-50);
-        mkdirSync88(dir, { recursive: true });
-        writeFileSync79(archiveFile, JSON.stringify(variants, null, 2));
+        mkdirSync89(dir, { recursive: true });
+        writeFileSync80(archiveFile, JSON.stringify(variants, null, 2));
       }
       async saveArchive(variants) {
         const dir = join39(this.cwd, ".omnius", "arche");
@@ -550166,12 +550166,12 @@ var init_reflectionBuffer = __esm({
         if (!this.persistPath)
           return;
         try {
-          const { writeFileSync: writeFileSync79, mkdirSync: mkdirSync88, existsSync: existsSync144 } = __require("node:fs");
+          const { writeFileSync: writeFileSync80, mkdirSync: mkdirSync89, existsSync: existsSync144 } = __require("node:fs");
           const { join: join160 } = __require("node:path");
           const dir = join160(this.persistPath, "..");
           if (!existsSync144(dir))
-            mkdirSync88(dir, { recursive: true });
-          writeFileSync79(this.persistPath, JSON.stringify(this.state, null, 2));
+            mkdirSync89(dir, { recursive: true });
+          writeFileSync80(this.persistPath, JSON.stringify(this.state, null, 2));
         } catch {
         }
       }
@@ -550385,15 +550385,17 @@ function loadMessagePairsFromLog(omniusDir, opts) {
   const now = Date.now();
   const norm = (s2) => s2.toLowerCase().replace(/\s+/g, " ").replace(/[.!?,;:]+$/g, "").trim();
   const taskNorm = norm(opts.currentTask.slice(0, 500));
+  const eligible = records.filter((rec) => now - rec.recordedAt <= ttl && norm(rec.handoff.priorGoal) !== taskNorm);
+  const signature = (rec) => `${norm(rec.handoff.priorGoal)}|${[...rec.handoff.filesTouched].sort().join(",")}`;
+  const lastIndexBySig = /* @__PURE__ */ new Map();
+  eligible.forEach((rec, i2) => lastIndexBySig.set(signature(rec), i2));
   const out = [];
-  for (const rec of records) {
-    if (now - rec.recordedAt > ttl)
-      continue;
-    if (norm(rec.handoff.priorGoal) === taskNorm)
-      continue;
+  eligible.forEach((rec, i2) => {
+    if (lastIndexBySig.get(signature(rec)) !== i2)
+      return;
     const pair = buildHandoffMessagePair(rec.handoff);
     out.push(pair[0], pair[1]);
-  }
+  });
   return out;
 }
 function trimLog(omniusDir) {
@@ -554703,7 +554705,8 @@ var init_agenticRunner = __esm({
           // Phase 4 — sub-agent isolation flag (defaults false). When true, this
           // runner skips cross-task handoff inheritance from the parent's
           // session.
-          subAgent: options2?.subAgent ?? false
+          subAgent: options2?.subAgent ?? false,
+          skipCrossTaskHandoff: options2?.skipCrossTaskHandoff ?? false
         };
         this._observerMode = this.options.observerMode;
       }
@@ -558459,6 +558462,10 @@ TASK: ${scrubbedTask}` : scrubbedTask;
         try {
           if (this.options.subAgent)
             throw "skip-handoff-subagent";
+          if (this.options.skipCrossTaskHandoff)
+            throw "skip-handoff-caller-optout";
+          if (/<task-handoff>|<session-recap>/.test(task))
+            throw "skip-handoff-restore-supplied";
           if (process.env["OMNIUS_FRESH_SESSION"] === "1")
             throw "skip-handoff-fresh";
           const omniusDir = this._workingDirectory ? _pathJoin(this._workingDirectory, ".omnius") : _pathJoin(process.cwd(), ".omnius");
@@ -563807,10 +563814,10 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
                 try {
-                  const { mkdirSync: mkdirSync88, readdirSync: readdirSync53, statSync: statSync53, unlinkSync: unlinkSync31, writeFileSync: writeFileSync79 } = __require("node:fs");
+                  const { mkdirSync: mkdirSync89, readdirSync: readdirSync53, statSync: statSync53, unlinkSync: unlinkSync31, writeFileSync: writeFileSync80 } = __require("node:fs");
                   const { join: join160 } = __require("node:path");
                   const contextDir = join160(this._workingDirectory || process.cwd(), ".omnius", "context");
-                  mkdirSync88(contextDir, { recursive: true });
+                  mkdirSync89(contextDir, { recursive: true });
                   const topEntities = this._temporalGraph.nodesByType("entity", 3);
                   const topFiles = this._temporalGraph.nodesByType("file", 3);
                   const topConcepts = this._temporalGraph.nodesByType("concept", 3);
@@ -563851,17 +563858,17 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                   section("Top Concepts", topConcepts);
                   lines.push("(Use file_read on this file for quick recall. See provenance JSON for full edge detail.)");
                   const kgSummaryDir = join160(contextDir, "kg-summary");
-                  mkdirSync88(kgSummaryDir, { recursive: true });
+                  mkdirSync89(kgSummaryDir, { recursive: true });
                   const summaryFilename = `kg-summary-${this._sessionId}.md`;
                   const outPath = join160(kgSummaryDir, summaryFilename);
-                  writeFileSync79(outPath, lines.join("\n"), "utf-8");
-                  writeFileSync79(join160(kgSummaryDir, "latest.md"), lines.join("\n"), "utf-8");
-                  writeFileSync79(join160(contextDir, `kg-summary-latest.md`), [
+                  writeFileSync80(outPath, lines.join("\n"), "utf-8");
+                  writeFileSync80(join160(kgSummaryDir, "latest.md"), lines.join("\n"), "utf-8");
+                  writeFileSync80(join160(contextDir, `kg-summary-latest.md`), [
                     "Latest KG summary moved to `.omnius/context/kg-summary/latest.md`.",
                     "",
                     lines.join("\n")
                   ].join("\n"), "utf-8");
-                  writeFileSync79(join160(kgSummaryDir, "index.json"), JSON.stringify({
+                  writeFileSync80(join160(kgSummaryDir, "index.json"), JSON.stringify({
                     schema: "omnius.kg-summary-index.v1",
                     latest: "latest.md",
                     latestSessionFile: summaryFilename,
@@ -564151,11 +564158,11 @@ ${errOutput}`);
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
         try {
-          const { mkdirSync: mkdirSync88, writeFileSync: writeFileSync79 } = __require("node:fs");
+          const { mkdirSync: mkdirSync89, writeFileSync: writeFileSync80 } = __require("node:fs");
           const { join: join160 } = __require("node:path");
           const resultsDir = join160(this.omniusStateDir(), "tool-results");
-          mkdirSync88(resultsDir, { recursive: true });
-          writeFileSync79(join160(resultsDir, `${handleId}.txt`), `# Tool: ${toolName}
+          mkdirSync89(resultsDir, { recursive: true });
+          writeFileSync80(join160(resultsDir, `${handleId}.txt`), `# Tool: ${toolName}
 # Turn: ${turn}
 # Timestamp: ${(/* @__PURE__ */ new Date()).toISOString()}
 # Size: ${result.output.length} chars, ${lineCount} lines
@@ -564548,10 +564555,10 @@ Actions: (1) list_directory on the parent directory to see what's there, (2) Che
         if (!this._workingDirectory)
           return;
         try {
-          const { mkdirSync: mkdirSync88, writeFileSync: writeFileSync79 } = __require("node:fs");
+          const { mkdirSync: mkdirSync89, writeFileSync: writeFileSync80 } = __require("node:fs");
           const { join: join160 } = __require("node:path");
           const sessionDir2 = this.options.stateDir ? join160(this.omniusStateDir(), "session", this._sessionId) : join160(this._workingDirectory, ".omnius", "session", this._sessionId);
-          mkdirSync88(sessionDir2, { recursive: true });
+          mkdirSync89(sessionDir2, { recursive: true });
           const checkpoint = {
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
             sessionId: this._sessionId,
@@ -564563,7 +564570,7 @@ Actions: (1) list_directory on the parent directory to see what's there, (2) Che
             memexEntryCount: this._memexArchive.size,
             fileRegistrySize: this._fileRegistry.size
           };
-          writeFileSync79(join160(sessionDir2, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
+          writeFileSync80(join160(sessionDir2, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
         } catch {
         }
       }
@@ -566976,12 +566983,12 @@ ${result}`
             let resizedBase64 = null;
             try {
               const { execSync: execSync62 } = await import("node:child_process");
-              const { writeFileSync: writeFileSync79, readFileSync: readFileSync117, unlinkSync: unlinkSync31 } = await import("node:fs");
+              const { writeFileSync: writeFileSync80, readFileSync: readFileSync117, unlinkSync: unlinkSync31 } = await import("node:fs");
               const { join: join160 } = await import("node:path");
               const { tmpdir: tmpdir23 } = await import("node:os");
               const tmpIn = join160(tmpdir23(), `omnius_img_in_${Date.now()}.png`);
               const tmpOut = join160(tmpdir23(), `omnius_img_out_${Date.now()}.jpg`);
-              writeFileSync79(tmpIn, buffer2);
+              writeFileSync80(tmpIn, buffer2);
               const pyBin = process.platform === "win32" ? "python" : "python3";
               const escapedIn = tmpIn.replace(/\\/g, "\\\\");
               const escapedOut = tmpOut.replace(/\\/g, "\\\\");
@@ -609736,13 +609743,13 @@ async function handleSlashCommand(input, ctx3) {
           try {
             const { randomBytes: randomBytes29 } = await import("node:crypto");
             const { homedir: homedir56 } = await import("node:os");
-            const { mkdirSync: mkdirSync88, writeFileSync: writeFileSync79 } = await import("node:fs");
+            const { mkdirSync: mkdirSync89, writeFileSync: writeFileSync80 } = await import("node:fs");
             const { join: join160 } = await import("node:path");
             const newKey = randomBytes29(16).toString("hex");
             process.env["OMNIUS_API_KEY"] = newKey;
             const dir = join160(homedir56(), ".omnius");
-            mkdirSync88(dir, { recursive: true });
-            writeFileSync79(join160(dir, "api.key"), newKey + "\n", "utf8");
+            mkdirSync89(dir, { recursive: true });
+            writeFileSync80(join160(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."
@@ -610007,11 +610014,11 @@ async function handleSlashCommand(input, ctx3) {
             );
             try {
               const { homedir: homedir57 } = await import("node:os");
-              const { mkdirSync: mkdirSync89, writeFileSync: writeFileSync80 } = await import("node:fs");
+              const { mkdirSync: mkdirSync90, writeFileSync: writeFileSync81 } = await import("node:fs");
               const { join: join161 } = await import("node:path");
               const dir = join161(homedir57(), ".omnius");
-              mkdirSync89(dir, { recursive: true });
-              writeFileSync80(join161(dir, "api.key"), apiKey + "\n", "utf8");
+              mkdirSync90(dir, { recursive: true });
+              writeFileSync81(join161(dir, "api.key"), apiKey + "\n", "utf8");
             } catch {
             }
           }
@@ -610023,11 +610030,11 @@ async function handleSlashCommand(input, ctx3) {
           const port2 = parseInt(process.env["OMNIUS_PORT"] || "11435", 10);
           try {
             const { homedir: homedir57 } = await import("node:os");
-            const { mkdirSync: mkdirSync89, writeFileSync: writeFileSync80 } = await import("node:fs");
+            const { mkdirSync: mkdirSync90, writeFileSync: writeFileSync81 } = await import("node:fs");
             const { join: join161 } = await import("node:path");
             const dir = join161(homedir57(), ".omnius");
-            mkdirSync89(dir, { recursive: true });
-            writeFileSync80(join161(dir, "access"), `${val2}
+            mkdirSync90(dir, { recursive: true });
+            writeFileSync81(join161(dir, "access"), `${val2}
 `, "utf8");
           } catch {
           }
@@ -610127,11 +610134,11 @@ async function handleSlashCommand(input, ctx3) {
         );
         try {
           const { homedir: homedir57 } = await import("node:os");
-          const { mkdirSync: mkdirSync89, writeFileSync: writeFileSync80 } = await import("node:fs");
+          const { mkdirSync: mkdirSync90, writeFileSync: writeFileSync81 } = await import("node:fs");
           const { join: join161 } = await import("node:path");
           const dir = join161(homedir57(), ".omnius");
-          mkdirSync89(dir, { recursive: true });
-          writeFileSync80(join161(dir, "api.key"), apiKey + "\n", "utf8");
+          mkdirSync90(dir, { recursive: true });
+          writeFileSync81(join161(dir, "api.key"), apiKey + "\n", "utf8");
         } catch {
         }
       }
@@ -610142,12 +610149,12 @@ async function handleSlashCommand(input, ctx3) {
       }
       const port = parseInt(process.env["OMNIUS_PORT"] || "11435", 10);
       const { homedir: homedir56 } = await import("node:os");
-      const { mkdirSync: mkdirSync88, writeFileSync: writeFileSync79 } = await import("node:fs");
+      const { mkdirSync: mkdirSync89, writeFileSync: writeFileSync80 } = await import("node:fs");
       const { join: join160 } = await import("node:path");
       try {
         const dir = join160(homedir56(), ".omnius");
-        mkdirSync88(dir, { recursive: true });
-        writeFileSync79(join160(dir, "access"), `${val}
+        mkdirSync89(dir, { recursive: true });
+        writeFileSync80(join160(dir, "access"), `${val}
 `, "utf8");
       } catch (e2) {
         renderWarning(
@@ -618111,7 +618118,7 @@ async function handleVoiceMenu(ctx3, save2, hasLocal) {
             const { basename: basename38, join: pathJoin } = await import("node:path");
             const {
               copyFileSync: copyFileSync5,
-              mkdirSync: mkdirSync88,
+              mkdirSync: mkdirSync89,
               existsSync: exists2
             } = await import("node:fs");
             const { homedir: homedir56 } = await import("node:os");
@@ -618126,7 +618133,7 @@ async function handleVoiceMenu(ctx3, save2, hasLocal) {
               "models",
               modelName
             );
-            if (!exists2(destDir)) mkdirSync88(destDir, { recursive: true });
+            if (!exists2(destDir)) mkdirSync89(destDir, { recursive: true });
             copyFileSync5(onnxDrop.path, pathJoin(destDir, "model.onnx"));
             copyFileSync5(jsonDrop.path, pathJoin(destDir, "config.json"));
             const { registerCustomOnnxModel: registerCustomOnnxModel2 } = await Promise.resolve().then(() => (init_voice(), voice_exports));
@@ -619597,13 +619604,13 @@ async function handleSponsoredEndpoint(ctx3, local) {
     sponsors.push(...verified);
     if (verified.length > 0) {
       try {
-        const { mkdirSync: mkdirSync88, writeFileSync: writeFileSync79 } = __require("node:fs");
-        mkdirSync88(sponsorDir2, { recursive: true });
+        const { mkdirSync: mkdirSync89, writeFileSync: writeFileSync80 } = __require("node:fs");
+        mkdirSync89(sponsorDir2, { recursive: true });
         const cached = verified.map((s2) => ({
           ...s2,
           lastVerified: Date.now()
         }));
-        writeFileSync79(knownFile, JSON.stringify(cached, null, 2));
+        writeFileSync80(knownFile, JSON.stringify(cached, null, 2));
       } catch {
       }
     }
@@ -619807,7 +619814,7 @@ async function handlePeerEndpoint(peerId, authKey, ctx3, local, advertisedModels
     }
     if (models.length > 0) {
       try {
-        const { writeFileSync: writeFileSync79, mkdirSync: mkdirSync88 } = await import("node:fs");
+        const { writeFileSync: writeFileSync80, mkdirSync: mkdirSync89 } = await import("node:fs");
         const { join: join160, dirname: dirname46 } = await import("node:path");
         const cachePath = join160(
           ctx3.repoRoot || process.cwd(),
@@ -619815,8 +619822,8 @@ async function handlePeerEndpoint(peerId, authKey, ctx3, local, advertisedModels
           "nexus",
           "peer-models-cache.json"
         );
-        mkdirSync88(dirname46(cachePath), { recursive: true });
-        writeFileSync79(
+        mkdirSync89(dirname46(cachePath), { recursive: true });
+        writeFileSync80(
           cachePath,
           JSON.stringify(
             {
@@ -619888,7 +619895,7 @@ async function handlePeerEndpoint(peerId, authKey, ctx3, local, advertisedModels
       }));
       renderWarning("Live model probe failed; using sponsor directory model advertisement.");
       try {
-        const { writeFileSync: writeFileSync79, mkdirSync: mkdirSync88 } = await import("node:fs");
+        const { writeFileSync: writeFileSync80, mkdirSync: mkdirSync89 } = await import("node:fs");
         const { join: join160, dirname: dirname46 } = await import("node:path");
         const cachePath = join160(
           ctx3.repoRoot || process.cwd(),
@@ -619896,8 +619903,8 @@ async function handlePeerEndpoint(peerId, authKey, ctx3, local, advertisedModels
           "nexus",
           "peer-models-cache.json"
         );
-        mkdirSync88(dirname46(cachePath), { recursive: true });
-        writeFileSync79(
+        mkdirSync89(dirname46(cachePath), { recursive: true });
+        writeFileSync80(
           cachePath,
           JSON.stringify({
             peerId,
@@ -622499,13 +622506,13 @@ var init_commands = __esm({
             try {
               const { randomBytes: randomBytes29 } = await import("node:crypto");
               const { homedir: homedir56 } = await import("node:os");
-              const { mkdirSync: mkdirSync88, writeFileSync: writeFileSync79 } = await import("node:fs");
+              const { mkdirSync: mkdirSync89, writeFileSync: writeFileSync80 } = await import("node:fs");
               const { join: join160 } = await import("node:path");
               const apiKey = randomBytes29(16).toString("hex");
               process.env["OMNIUS_API_KEY"] = apiKey;
               const dir = join160(homedir56(), ".omnius");
-              mkdirSync88(dir, { recursive: true });
-              writeFileSync79(join160(dir, "api.key"), apiKey + "\n", "utf8");
+              mkdirSync89(dir, { recursive: true });
+              writeFileSync80(join160(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."
@@ -622524,11 +622531,11 @@ var init_commands = __esm({
           const port = parseInt(process.env["OMNIUS_PORT"] || "11435", 10);
           try {
             const { homedir: homedir56 } = await import("node:os");
-            const { mkdirSync: mkdirSync88, writeFileSync: writeFileSync79 } = await import("node:fs");
+            const { mkdirSync: mkdirSync89, writeFileSync: writeFileSync80 } = await import("node:fs");
             const { join: join160 } = await import("node:path");
             const dir = join160(homedir56(), ".omnius");
-            mkdirSync88(dir, { recursive: true });
-            writeFileSync79(join160(dir, "access"), `${val}
+            mkdirSync89(dir, { recursive: true });
+            writeFileSync80(join160(dir, "access"), `${val}
 `, "utf8");
           } catch {
           }
@@ -622819,22 +622826,47 @@ function loadMemoryContext(repoRoot) {
   }
   const buckets = /* @__PURE__ */ new Map();
   for (const e2 of deduped) {
-    const key = `${e2.scope}/${e2.topic}`;
-    const arr = buckets.get(key) ?? [];
-    arr.push(e2);
-    buckets.set(key, arr);
+    const family = topicFamily(e2.topic);
+    const bucketKey = `${e2.scope}/${family}`;
+    const bucket = buckets.get(bucketKey) ?? { family, multiTopic: false, entries: [] };
+    if (bucket.entries.length > 0 && bucket.entries[0].topic !== e2.topic) bucket.multiTopic = true;
+    bucket.entries.push(e2);
+    buckets.set(bucketKey, bucket);
   }
   const lines = [];
-  for (const [bucketKey, entries] of buckets) {
-    const sorted = entries.sort((a2, b) => b.ts.localeCompare(a2.ts)).slice(0, 5);
-    if (sorted.length === 0) continue;
-    lines.push(`[${bucketKey}]`);
+  for (const [bucketKey, bucket] of buckets) {
+    const sorted = bucket.entries.sort((a2, b) => b.ts.localeCompare(a2.ts));
+    const seenValues = /* @__PURE__ */ new Set();
+    const kept = [];
     for (const e2 of sorted) {
-      lines.push(`  ${e2.key}: ${truncateProjectContextText(e2.value, 200, "")}`);
+      const sig = normalizeValueSignature(e2.value);
+      if (seenValues.has(sig)) continue;
+      seenValues.add(sig);
+      kept.push(e2);
+      if (kept.length >= 5) break;
+    }
+    if (kept.length === 0) continue;
+    const dropped = bucket.entries.length - kept.length;
+    const header = bucket.multiTopic ? `[${bucketKey}* (${bucket.entries.length} entries in series${dropped > 0 ? `, ${dropped} redundant collapsed` : ""})]` : `[${bucketKey}]`;
+    lines.push(header);
+    for (const e2 of kept) {
+      const label = bucket.multiTopic ? `${e2.topic}.${e2.key}` : e2.key;
+      lines.push(`  ${label}: ${truncateProjectContextText(trimMemoryValueMetadata(e2.value), 200, "")}`);
     }
   }
   return lines.join("\n");
 }
+function topicFamily(topic) {
+  const m2 = topic.match(/^(.*?)[_-]?\d+$/);
+  if (!m2 || !m2[1]) return topic;
+  return m2[1].length >= 3 ? m2[1] : topic;
+}
+function normalizeValueSignature(value2) {
+  return value2.toLowerCase().replace(/\d+(\.\d+)?/g, "#").replace(/\s+/g, " ").trim().slice(0, 160);
+}
+function trimMemoryValueMetadata(value2) {
+  return value2.replace(/\b(?:confidence|weight|salience|score|noise_score|relevance)\s*[=:]\s*\d*\.?\d+\b/gi, "").replace(/\b(?:evidence|sources?|refs?)\s*[=:]\s*[\d,\s]+\b/gi, "").replace(/\bvalue_?hash\s*[=:]\s*[0-9a-f]{8,}\b/gi, "").replace(/[ \t]{2,}/g, " ").replace(/\s+([,.;])/g, "$1").trim();
+}
 function loadSessionHistory2(repoRoot) {
   const sessions3 = loadRecentSessions(repoRoot, 5);
   const lines = ["Recent tasks in this project:"];
@@ -626234,18 +626266,471 @@ var init_edit_history = __esm({
   }
 });
 
+// packages/cli/src/tui/snr-engine.ts
+import { existsSync as existsSync120, readdirSync as readdirSync42, readFileSync as readFileSync96, writeFileSync as writeFileSync61, mkdirSync as mkdirSync69, rmSync as rmSync7 } from "node:fs";
+import { join as join133, basename as basename31 } from "node:path";
+function computeDPrime(signalScores, noiseScores) {
+  if (signalScores.length === 0 || noiseScores.length === 0) return 0;
+  const mean = (arr) => arr.reduce((s2, v) => s2 + v, 0) / arr.length;
+  const variance = (arr, mu) => arr.reduce((s2, v) => s2 + (v - mu) ** 2, 0) / Math.max(1, arr.length - 1);
+  const muSignal = mean(signalScores);
+  const muNoise = mean(noiseScores);
+  const varSignal = variance(signalScores, muSignal);
+  const varNoise = variance(noiseScores, muNoise);
+  const pooledStd = Math.sqrt((varSignal + varNoise) / 2);
+  if (pooledStd === 0) return muSignal > muNoise ? 3 : 0;
+  return (muSignal - muNoise) / pooledStd;
+}
+function computeSparsity(entries) {
+  if (entries.length <= 1) return 1;
+  const ngramSets = entries.map((e2) => {
+    const words = e2.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+    const ngrams = /* @__PURE__ */ new Set();
+    for (let i2 = 0; i2 < words.length - 1; i2++) {
+      ngrams.add(`${words[i2]} ${words[i2 + 1]}`);
+    }
+    return ngrams;
+  });
+  let totalPairs = 0;
+  let totalJaccard = 0;
+  for (let i2 = 0; i2 < ngramSets.length; i2++) {
+    for (let j = i2 + 1; j < ngramSets.length; j++) {
+      const a2 = ngramSets[i2];
+      const b = ngramSets[j];
+      if (a2.size === 0 && b.size === 0) continue;
+      const intersection = new Set([...a2].filter((x) => b.has(x)));
+      const union = /* @__PURE__ */ new Set([...a2, ...b]);
+      totalJaccard += union.size > 0 ? intersection.size / union.size : 0;
+      totalPairs++;
+    }
+  }
+  if (totalPairs === 0) return 1;
+  const avgOverlap = totalJaccard / totalPairs;
+  return Math.max(0, Math.min(1, 1 - avgOverlap));
+}
+function adaptTool2(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters,
+    async execute(args) {
+      const result = await tool.execute(args);
+      return { success: result.success, output: result.output, error: result.error };
+    }
+  };
+}
+var SNREngine;
+var init_snr_engine = __esm({
+  "packages/cli/src/tui/snr-engine.ts"() {
+    "use strict";
+    init_dist8();
+    init_dist5();
+    init_project_context();
+    init_render();
+    SNREngine = class {
+      constructor(config, repoRoot) {
+        this.config = config;
+        this.repoRoot = repoRoot;
+      }
+      config;
+      repoRoot;
+      lastScore = null;
+      evaluationCount = 0;
+      get score() {
+        return this.lastScore;
+      }
+      /**
+       * Quick local-only SNR estimation (no LLM calls, fast).
+       * @param contextSlots — total context window tokens (for Hopfield capacity warning)
+       */
+      computeLocalSNR(currentTask, contextEntries, contextSlots) {
+        if (contextEntries.length === 0) {
+          return this.makeScore(1, 3, 0, 0, 0, 1, ["local-empty"]);
+        }
+        const taskTerms = new Set(
+          currentTask.toLowerCase().split(/\s+/).filter((w) => w.length > 3).map((w) => w.replace(/[^a-z0-9]/g, ""))
+        );
+        const scores = contextEntries.map((entry) => {
+          const entryTerms = entry.toLowerCase().split(/\s+/).filter((w) => w.length > 3).map((w) => w.replace(/[^a-z0-9]/g, ""));
+          const matchCount = entryTerms.filter((t2) => taskTerms.has(t2)).length;
+          const score2 = entryTerms.length > 0 ? matchCount / Math.sqrt(entryTerms.length) : 0;
+          return { entry, score: score2 };
+        });
+        const allScores = scores.map((s2) => s2.score);
+        const mean = allScores.reduce((a2, b) => a2 + b, 0) / allScores.length;
+        const std = Math.sqrt(allScores.reduce((a2, v) => a2 + (v - mean) ** 2, 0) / allScores.length);
+        const threshold = mean + 0.5 * std;
+        const signalScores = allScores.filter((s2) => s2 >= threshold);
+        const noiseScores = allScores.filter((s2) => s2 < threshold);
+        const dPrime = computeDPrime(
+          signalScores.length > 0 ? signalScores : [mean],
+          noiseScores.length > 0 ? noiseScores : [0]
+        );
+        const sparsity = computeSparsity(contextEntries);
+        const signalProportion = signalScores.length / allScores.length;
+        const dPrimeNorm = Math.min(1, Math.max(0, dPrime / 3));
+        const ratio = 0.5 * signalProportion + 0.3 * dPrimeNorm + 0.2 * sparsity;
+        const capacityWarning = contextSlots ? contextEntries.length > Math.floor(contextSlots * 0.138) : false;
+        const score = this.makeScore(
+          ratio,
+          dPrime,
+          contextEntries.length,
+          signalScores.length,
+          noiseScores.length,
+          sparsity,
+          ["local-keyword"],
+          capacityWarning
+        );
+        this.lastScore = score;
+        this.evaluationCount++;
+        return score;
+      }
+      /**
+       * Full SNR evaluation using parallel LLM evaluator agents.
+       * Mirrors PFC gating + multi-agent debate (Du et al. 2023).
+       *
+       * Spawns 2 lightweight agents with different evaluation perspectives:
+       * - "Relevance Evaluator" — scores entries by task relevance (PFC role)
+       * - "Noise Detector" — identifies redundant/stale/irrelevant entries (DG role)
+       *
+       * Their consensus determines the final SNR.
+       */
+      async evaluateWithAgents(currentTask, memoryTopics, onEvent) {
+        const entries = this.loadMemoryEntries(memoryTopics);
+        if (entries.length === 0) {
+          const score2 = this.makeScore(1, 3, 0, 0, 0, 1, ["agents-empty"]);
+          this.lastScore = score2;
+          return score2;
+        }
+        const entrySummaries = entries.map(
+          (e2, i2) => `[${i2}] topic=${e2.topic} key=${e2.key}: ${e2.value.slice(0, 200)}${e2.value.length > 200 ? "..." : ""}`
+        );
+        const entriesBlock = entrySummaries.join("\n");
+        const [relevanceResult, noiseResult] = await Promise.allSettled([
+          this.runEvaluatorAgent(
+            "relevance",
+            `You are a Prefrontal Cortex Gating Evaluator. Your role is to assess which
+memory entries are RELEVANT to the current task.
+
+CURRENT TASK: ${currentTask}
+
+MEMORY ENTRIES TO EVALUATE:
+${entriesBlock}
+
+For each entry, output a JSON array of objects:
+[{"index": 0, "score": 0.8, "reason": "directly related to task"}, ...]
+
+Score 0-1 where:
+- 1.0 = directly relevant to the current task
+- 0.7 = supporting context (useful background)
+- 0.4 = marginally relevant
+- 0.1 = not relevant to current task
+
+Call task_complete with the JSON array when done.`,
+            onEvent
+          ),
+          this.runEvaluatorAgent(
+            "noise",
+            `You are a Dentate Gyrus Pattern Separation Evaluator. Your role is to identify
+NOISE in the memory context — entries that are redundant, stale, or interfering.
+
+CURRENT TASK: ${currentTask}
+
+MEMORY ENTRIES TO EVALUATE:
+${entriesBlock}
+
+For each entry, output a JSON array of objects:
+[{"index": 0, "noise_score": 0.2, "reason": "unique, not redundant"}, ...]
+
+Noise score 0-1 where:
+- 1.0 = pure noise (completely redundant, stale, or interfering with task)
+- 0.7 = mostly noise (outdated or largely redundant with another entry)
+- 0.4 = moderate noise (some overlap with other entries)
+- 0.1 = clean signal (unique, fresh, non-interfering)
+
+Look for: duplicate information, outdated facts, entries that contradict
+newer entries, entries about completely unrelated topics.
+
+Call task_complete with the JSON array when done.`,
+            onEvent
+          )
+        ]);
+        const relevanceScores = this.parseEvaluatorResult(
+          relevanceResult.status === "fulfilled" ? relevanceResult.value : "",
+          entries.length,
+          0.5
+          // default relevance
+        );
+        const noiseScores = this.parseEvaluatorResult(
+          noiseResult.status === "fulfilled" ? noiseResult.value : "",
+          entries.length,
+          0.5
+          // default noise
+        );
+        const combinedScores = entries.map((_, i2) => {
+          const rel = relevanceScores[i2] ?? 0.5;
+          const noise2 = noiseScores[i2] ?? 0.5;
+          const votes = [rel, 1 - noise2].sort((a2, b) => a2 - b);
+          return (votes[0] + votes[1]) / 2;
+        });
+        const mean = combinedScores.reduce((a2, b) => a2 + b, 0) / combinedScores.length;
+        const std = Math.sqrt(combinedScores.reduce((a2, v) => a2 + (v - mean) ** 2, 0) / combinedScores.length);
+        const threshold = Math.max(0.3, mean);
+        const signalEntries = combinedScores.filter((s2) => s2 >= threshold);
+        const noiseEntries = combinedScores.filter((s2) => s2 < threshold);
+        const dPrime = computeDPrime(
+          signalEntries.length > 0 ? signalEntries : [mean],
+          noiseEntries.length > 0 ? noiseEntries : [0.1]
+        );
+        const sparsity = computeSparsity(entries.map((e2) => e2.value));
+        const signalProportion = signalEntries.length / combinedScores.length;
+        const dPrimeNorm = Math.min(1, Math.max(0, dPrime / 3));
+        const ratio = 0.5 * signalProportion + 0.3 * dPrimeNorm + 0.2 * sparsity;
+        const evaluators = [
+          relevanceResult.status === "fulfilled" ? "relevance-agent" : "relevance-failed",
+          noiseResult.status === "fulfilled" ? "noise-agent" : "noise-failed"
+        ];
+        const score = this.makeScore(
+          ratio,
+          dPrime,
+          entries.length,
+          signalEntries.length,
+          noiseEntries.length,
+          sparsity,
+          evaluators
+        );
+        this.lastScore = score;
+        this.evaluationCount++;
+        return score;
+      }
+      // ── Evaluator agent ──────────────────────────────────────────────────
+      async runEvaluatorAgent(name10, prompt, onEvent) {
+        const backend = new OllamaAgenticBackend(
+          this.config.backendUrl,
+          this.config.model,
+          this.config.apiKey
+        );
+        const modelTier = getModelTier(this.config.model);
+        const runner = new AgenticRunner(backend, {
+          maxTurns: 5,
+          // Evaluators are very focused — 5 turns max
+          maxTokens: 4096,
+          temperature: 0,
+          // Deterministic scoring
+          requestTimeoutMs: this.config.timeoutMs,
+          taskTimeoutMs: this.config.timeoutMs,
+          compactionThreshold: modelTier === "small" ? 8e3 : 16e3,
+          modelTier
+        });
+        const tools = [
+          new MemoryReadTool(this.repoRoot),
+          new MemorySearchTool(this.repoRoot)
+        ];
+        runner.registerTools([
+          ...tools.map(adaptTool2),
+          {
+            name: "task_complete",
+            description: "Signal evaluation is complete with your scored results.",
+            parameters: {
+              type: "object",
+              properties: {
+                summary: { type: "string", description: "JSON array of scored entries" }
+              },
+              required: ["summary"]
+            },
+            async execute(args) {
+              return { success: true, output: args["summary"] || "[]" };
+            }
+          }
+        ]);
+        if (onEvent) runner.onEvent(onEvent);
+        const result = await runner.run(
+          prompt,
+          `SNR Evaluator (${name10}). Working directory: ${this.repoRoot}`
+        );
+        return result.summary || "[]";
+      }
+      // ── Memory loading ───────────────────────────────────────────────────
+      loadMemoryEntries(topics) {
+        const entries = [];
+        const dirs = [.../* @__PURE__ */ new Set([
+          join133(this.repoRoot, ".omnius", "memory")
+        ])];
+        for (const dir of dirs) {
+          if (!existsSync120(dir)) continue;
+          try {
+            const files = readdirSync42(dir).filter((f2) => f2.endsWith(".json"));
+            for (const f2 of files) {
+              const topic = basename31(f2, ".json");
+              if (topics.length > 0 && !topics.includes(topic)) continue;
+              try {
+                const data = JSON.parse(readFileSync96(join133(dir, f2), "utf-8"));
+                for (const [key, val] of Object.entries(data)) {
+                  const value2 = typeof val === "object" && val !== null && "value" in val ? String(val.value) : String(val);
+                  entries.push({ topic, key, value: value2 });
+                }
+              } catch {
+              }
+            }
+          } catch {
+          }
+        }
+        return entries;
+      }
+      // ── Result parsing ───────────────────────────────────────────────────
+      parseEvaluatorResult(summary, entryCount, defaultScore) {
+        const scores = new Array(entryCount).fill(defaultScore);
+        try {
+          const jsonMatch = summary.match(/\[[\s\S]*\]/);
+          if (!jsonMatch) return scores;
+          const parsed = JSON.parse(jsonMatch[0]);
+          for (const item of parsed) {
+            const idx = typeof item.index === "number" ? item.index : -1;
+            const score = typeof item.score === "number" ? item.score : typeof item.noise_score === "number" ? item.noise_score : defaultScore;
+            if (idx >= 0 && idx < entryCount) {
+              scores[idx] = Math.max(0, Math.min(1, score));
+            }
+          }
+        } catch {
+        }
+        return scores;
+      }
+      // ── Memory pruning recommendations ──────────────────────────────────
+      /**
+       * Identify low-SNR memory entries that should be pruned.
+       * Mirrors synaptic downscaling during slow-wave sleep — weak connections
+       * (low-relevance, high-redundancy entries) are depotentiated.
+       *
+       * Returns topics+keys of entries scoring below the noise threshold.
+       * Does NOT delete anything — the caller decides what to do with the list.
+       */
+      getPruningCandidates(currentTask, noiseThreshold = 0.3) {
+        const entries = this.loadMemoryEntries([]);
+        if (entries.length === 0) return [];
+        const taskTerms = new Set(
+          currentTask.toLowerCase().split(/\s+/).filter((w) => w.length > 3).map((w) => w.replace(/[^a-z0-9]/g, ""))
+        );
+        const candidates = [];
+        for (const entry of entries) {
+          const entryTerms = entry.value.toLowerCase().split(/\s+/).filter((w) => w.length > 3).map((w) => w.replace(/[^a-z0-9]/g, ""));
+          const matchCount = entryTerms.filter((t2) => taskTerms.has(t2)).length;
+          const relevance = entryTerms.length > 0 ? matchCount / Math.sqrt(entryTerms.length) : 0;
+          if (relevance < noiseThreshold) {
+            candidates.push({
+              topic: entry.topic,
+              key: entry.key,
+              score: relevance,
+              reason: relevance === 0 ? "no keyword overlap with current task" : `low relevance (${(relevance * 100).toFixed(0)}% < ${(noiseThreshold * 100).toFixed(0)}% threshold)`
+            });
+          }
+        }
+        return candidates.sort((a2, b) => a2.score - b.score);
+      }
+      /**
+       * Act on the pruning recommendations: move low-SNR entries OUT of the active
+       * memory topic files and into `.omnius/memory/.archive/<topic>.json`.
+       *
+       * This is the missing half of the Dentate Gyrus loop — `getPruningCandidates`
+       * only ever produced a list that nothing consumed, so flagged-noise entries
+       * kept loading into every context window (agent self-audit 2026-05-28).
+       *
+       * Safety properties:
+       *   - Reversible: entries are moved to an archive file, never deleted.
+       *   - Bounded: at most `maxArchive` entries removed per call.
+       *   - Guarded: refuses to run against a trivial focus string (which would
+       *     score every entry as irrelevant and archive the whole store).
+       *   - Conservative threshold (0.15) — only entries with near-zero relevance
+       *     to the focus are eligible.
+       *
+       * Intended caller: the deliberate slow-wave consolidation cycle, passing the
+       * consolidation summary as `focus` (what the agent just decided matters).
+       */
+      archiveNoiseEntries(focus, opts = {}) {
+        const noiseThreshold = opts.noiseThreshold ?? 0.15;
+        const maxArchive = opts.maxArchive ?? 25;
+        const focusTerms = focus.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+        if (focusTerms.length < 3) return { archived: 0, topics: [] };
+        const candidates = this.getPruningCandidates(focus, noiseThreshold).slice(0, maxArchive);
+        if (candidates.length === 0) return { archived: 0, topics: [] };
+        const byTopic = /* @__PURE__ */ new Map();
+        for (const cand of candidates) {
+          const set = byTopic.get(cand.topic) ?? /* @__PURE__ */ new Set();
+          set.add(cand.key);
+          byTopic.set(cand.topic, set);
+        }
+        const memDir = join133(this.repoRoot, ".omnius", "memory");
+        const archiveDir = join133(memDir, ".archive");
+        let archived = 0;
+        const touchedTopics = [];
+        for (const [topic, keys] of byTopic) {
+          const file = join133(memDir, `${topic}.json`);
+          if (!existsSync120(file)) continue;
+          try {
+            const data = JSON.parse(readFileSync96(file, "utf-8"));
+            const moved = {};
+            for (const key of keys) {
+              if (key in data) {
+                moved[key] = data[key];
+                delete data[key];
+                archived++;
+              }
+            }
+            if (Object.keys(moved).length === 0) continue;
+            mkdirSync69(archiveDir, { recursive: true });
+            const archiveFile = join133(archiveDir, `${topic}.json`);
+            let archiveData = {};
+            if (existsSync120(archiveFile)) {
+              try {
+                archiveData = JSON.parse(readFileSync96(archiveFile, "utf-8"));
+              } catch {
+              }
+            }
+            Object.assign(archiveData, moved);
+            writeFileSync61(archiveFile, JSON.stringify(archiveData, null, 2));
+            if (Object.keys(data).length === 0) {
+              try {
+                rmSync7(file);
+              } catch {
+              }
+            } else {
+              writeFileSync61(file, JSON.stringify(data, null, 2));
+            }
+            touchedTopics.push(topic);
+          } catch {
+          }
+        }
+        return { archived, topics: touchedTopics };
+      }
+      // ── Helpers ──────────────────────────────────────────────────────────
+      makeScore(ratio, dPrime, total, signal, noise2, sparsity, evaluators, capacityWarning = false) {
+        return {
+          ratio: Math.max(0, Math.min(1, ratio)),
+          dPrime: Math.max(0, dPrime),
+          entriesEvaluated: total,
+          signalCount: signal,
+          noiseCount: noise2,
+          sparsity: Math.max(0, Math.min(1, sparsity)),
+          evaluatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          evaluators,
+          capacityWarning
+        };
+      }
+    };
+  }
+});
+
 // packages/cli/src/tui/promptLoader.ts
-import { readFileSync as readFileSync96, existsSync as existsSync120 } from "node:fs";
-import { join as join133, dirname as dirname38 } from "node:path";
+import { readFileSync as readFileSync97, existsSync as existsSync121 } from "node:fs";
+import { join as join134, dirname as dirname38 } from "node:path";
 import { fileURLToPath as fileURLToPath17 } from "node:url";
 function loadPrompt3(promptPath, vars) {
   let content = cache7.get(promptPath);
   if (content === void 0) {
-    const fullPath = join133(PROMPTS_DIR3, promptPath);
-    if (!existsSync120(fullPath)) {
+    const fullPath = join134(PROMPTS_DIR3, promptPath);
+    if (!existsSync121(fullPath)) {
       throw new Error(`Prompt file not found: ${fullPath}`);
     }
-    content = readFileSync96(fullPath, "utf-8");
+    content = readFileSync97(fullPath, "utf-8");
     cache7.set(promptPath, content);
   }
   if (!vars) return content;
@@ -626257,16 +626742,16 @@ var init_promptLoader3 = __esm({
     "use strict";
     __filename5 = fileURLToPath17(import.meta.url);
     __dirname6 = dirname38(__filename5);
-    devPath2 = join133(__dirname6, "..", "..", "prompts");
-    publishedPath2 = join133(__dirname6, "..", "prompts");
-    PROMPTS_DIR3 = existsSync120(devPath2) ? devPath2 : publishedPath2;
+    devPath2 = join134(__dirname6, "..", "..", "prompts");
+    publishedPath2 = join134(__dirname6, "..", "prompts");
+    PROMPTS_DIR3 = existsSync121(devPath2) ? devPath2 : publishedPath2;
     cache7 = /* @__PURE__ */ new Map();
   }
 });
 
 // packages/cli/src/tui/dream-engine.ts
-import { mkdirSync as mkdirSync69, writeFileSync as writeFileSync61, readFileSync as readFileSync97, existsSync as existsSync121, readdirSync as readdirSync42 } from "node:fs";
-import { join as join134, basename as basename31 } from "node:path";
+import { mkdirSync as mkdirSync70, writeFileSync as writeFileSync62, readFileSync as readFileSync98, existsSync as existsSync122, readdirSync as readdirSync43 } from "node:fs";
+import { join as join135, basename as basename32 } from "node:path";
 import { execSync as execSync56 } from "node:child_process";
 function setDreamWriteContent(fn) {
   _dreamWriteContent = fn;
@@ -626279,10 +626764,10 @@ function dreamWrite(fn) {
   }
 }
 function loadAutoresearchMemory(repoRoot) {
-  const memoryPath = join134(repoRoot, ".omnius", "memory", "autoresearch.json");
-  if (!existsSync121(memoryPath)) return "";
+  const memoryPath = join135(repoRoot, ".omnius", "memory", "autoresearch.json");
+  if (!existsSync122(memoryPath)) return "";
   try {
-    const raw = readFileSync97(memoryPath, "utf-8");
+    const raw = readFileSync98(memoryPath, "utf-8");
     const data = JSON.parse(raw);
     const sections = [];
     for (const key of AUTORESEARCH_MEMORY_KEYS) {
@@ -626301,7 +626786,7 @@ ${sections.join("\n\n")}`;
     return "";
   }
 }
-function adaptTool2(tool) {
+function adaptTool3(tool) {
   return {
     name: tool.name,
     description: tool.description,
@@ -626448,6 +626933,7 @@ var init_dream_engine = __esm({
     init_dist8();
     init_dist5();
     init_project_context();
+    init_snr_engine();
     init_setup();
     init_render();
     init_promptLoader3();
@@ -626479,14 +626965,14 @@ var init_dream_engine = __esm({
         const rawPath = String(args["path"] ?? "");
         const content = String(args["content"] ?? "");
         if (!rawPath) return { success: false, output: "", error: "path is required", durationMs: Date.now() - start2 };
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".omnius/autoresearch") ? join134(this.autoresearchDir, basename31(rawPath)) : join134(this.autoresearchDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".omnius/autoresearch") ? join135(this.autoresearchDir, basename32(rawPath)) : join135(this.autoresearchDir, rawPath);
         if (!targetPath.startsWith(this.autoresearchDir)) {
           return { success: false, output: "", error: "Autoresearch mode: writes are confined to .omnius/autoresearch/", durationMs: Date.now() - start2 };
         }
         try {
-          const dir = join134(targetPath, "..");
-          mkdirSync69(dir, { recursive: true });
-          writeFileSync61(targetPath, content, "utf-8");
+          const dir = join135(targetPath, "..");
+          mkdirSync70(dir, { recursive: true });
+          writeFileSync62(targetPath, content, "utf-8");
           return { success: true, output: `Wrote ${content.length} bytes to ${rawPath}`, durationMs: Date.now() - start2 };
         } catch (err) {
           return { success: false, output: "", error: String(err), durationMs: Date.now() - start2 };
@@ -626514,20 +627000,20 @@ var init_dream_engine = __esm({
         const rawPath = String(args["path"] ?? "");
         const oldStr = String(args["old_string"] ?? "");
         const newStr = String(args["new_string"] ?? "");
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".omnius/autoresearch") ? join134(this.autoresearchDir, basename31(rawPath)) : join134(this.autoresearchDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".omnius/autoresearch") ? join135(this.autoresearchDir, basename32(rawPath)) : join135(this.autoresearchDir, rawPath);
         if (!targetPath.startsWith(this.autoresearchDir)) {
           return { success: false, output: "", error: "Autoresearch mode: edits are confined to .omnius/autoresearch/", durationMs: Date.now() - start2 };
         }
         try {
-          if (!existsSync121(targetPath)) {
+          if (!existsSync122(targetPath)) {
             return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: Date.now() - start2 };
           }
-          let content = readFileSync97(targetPath, "utf-8");
+          let content = readFileSync98(targetPath, "utf-8");
           if (!content.includes(oldStr)) {
             return { success: false, output: "", error: "old_string not found in file", durationMs: Date.now() - start2 };
           }
           content = content.replace(oldStr, newStr);
-          writeFileSync61(targetPath, content, "utf-8");
+          writeFileSync62(targetPath, content, "utf-8");
           return { success: true, output: `Edited ${rawPath}`, durationMs: Date.now() - start2 };
         } catch (err) {
           return { success: false, output: "", error: String(err), durationMs: Date.now() - start2 };
@@ -626567,14 +627053,14 @@ var init_dream_engine = __esm({
         const rawPath = String(args["path"] ?? "");
         const content = String(args["content"] ?? "");
         if (!rawPath) return { success: false, output: "", error: "path is required", durationMs: Date.now() - start2 };
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".omnius/dreams") ? join134(this.dreamsDir, basename31(rawPath)) : join134(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".omnius/dreams") ? join135(this.dreamsDir, basename32(rawPath)) : join135(this.dreamsDir, rawPath);
         if (!targetPath.startsWith(this.dreamsDir)) {
           return { success: false, output: "", error: "Dream mode: writes are confined to .omnius/dreams/", durationMs: Date.now() - start2 };
         }
         try {
-          const dir = join134(targetPath, "..");
-          mkdirSync69(dir, { recursive: true });
-          writeFileSync61(targetPath, content, "utf-8");
+          const dir = join135(targetPath, "..");
+          mkdirSync70(dir, { recursive: true });
+          writeFileSync62(targetPath, content, "utf-8");
           return { success: true, output: `Wrote ${content.length} bytes to ${rawPath}`, durationMs: Date.now() - start2 };
         } catch (err) {
           return { success: false, output: "", error: String(err), durationMs: Date.now() - start2 };
@@ -626602,20 +627088,20 @@ var init_dream_engine = __esm({
         const rawPath = String(args["path"] ?? "");
         const oldStr = String(args["old_string"] ?? "");
         const newStr = String(args["new_string"] ?? "");
-        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".omnius/dreams") ? join134(this.dreamsDir, basename31(rawPath)) : join134(this.dreamsDir, rawPath);
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".omnius/dreams") ? join135(this.dreamsDir, basename32(rawPath)) : join135(this.dreamsDir, rawPath);
         if (!targetPath.startsWith(this.dreamsDir)) {
           return { success: false, output: "", error: "Dream mode: edits are confined to .omnius/dreams/", durationMs: Date.now() - start2 };
         }
         try {
-          if (!existsSync121(targetPath)) {
+          if (!existsSync122(targetPath)) {
             return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: Date.now() - start2 };
           }
-          let content = readFileSync97(targetPath, "utf-8");
+          let content = readFileSync98(targetPath, "utf-8");
           if (!content.includes(oldStr)) {
             return { success: false, output: "", error: "old_string not found in file", durationMs: Date.now() - start2 };
           }
           content = content.replace(oldStr, newStr);
-          writeFileSync61(targetPath, content, "utf-8");
+          writeFileSync62(targetPath, content, "utf-8");
           return { success: true, output: `Edited ${rawPath}`, durationMs: Date.now() - start2 };
         } catch (err) {
           return { success: false, output: "", error: String(err), durationMs: Date.now() - start2 };
@@ -626664,7 +627150,7 @@ var init_dream_engine = __esm({
       constructor(config, repoRoot) {
         this.config = config;
         this.repoRoot = repoRoot;
-        this.dreamsDir = join134(repoRoot, ".omnius", "dreams");
+        this.dreamsDir = join135(repoRoot, ".omnius", "dreams");
         this.state = {
           mode: "default",
           active: false,
@@ -626703,7 +627189,7 @@ var init_dream_engine = __esm({
           startedAt: (/* @__PURE__ */ new Date()).toISOString(),
           results: []
         };
-        mkdirSync69(this.dreamsDir, { recursive: true });
+        mkdirSync70(this.dreamsDir, { recursive: true });
         this.saveDreamState();
         try {
           for (let cycle = 1; cycle <= totalCycles; cycle++) {
@@ -626775,8 +627261,8 @@ ${result.summary}`;
             if (mode !== "default" || cycle === totalCycles) {
               renderDreamContraction(cycle);
               const cycleSummary = this.buildCycleSummary(cycle, previousFindings);
-              const summaryPath = join134(this.dreamsDir, `cycle-${cycle}-summary.md`);
-              writeFileSync61(summaryPath, cycleSummary, "utf-8");
+              const summaryPath = join135(this.dreamsDir, `cycle-${cycle}-summary.md`);
+              writeFileSync62(summaryPath, cycleSummary, "utf-8");
             }
             if (mode === "lucid" && !this.abortController.signal.aborted) {
               this.saveVersionCheckpoint(cycle);
@@ -627015,7 +627501,7 @@ After synthesis, call task_complete with the final prioritized summary.`,
       }
       /** Build role-specific tool sets for swarm agents */
       buildSwarmTools(role, _workspace) {
-        const autoresearchDir = join134(this.repoRoot, ".omnius", "autoresearch");
+        const autoresearchDir = join135(this.repoRoot, ".omnius", "autoresearch");
         const taskComplete = this.createSwarmTaskCompleteTool(role);
         switch (role) {
           case "researcher": {
@@ -627030,7 +627516,7 @@ After synthesis, call task_complete with the final prioritized summary.`,
               new MemorySearchTool(this.repoRoot),
               new MemoryWriteTool(this.repoRoot)
             ];
-            return [...tools.map(adaptTool2), this.createDreamTodoWriteTool(), this.createDreamWorkingNotesTool(), taskComplete];
+            return [...tools.map(adaptTool3), this.createDreamTodoWriteTool(), this.createDreamWorkingNotesTool(), taskComplete];
           }
           case "monitor": {
             const tools = [
@@ -627041,7 +627527,7 @@ After synthesis, call task_complete with the final prioritized summary.`,
               // status-only in prompt
               new MemoryReadTool(this.repoRoot)
             ];
-            return [...tools.map(adaptTool2), this.createDreamTodoWriteTool(), taskComplete];
+            return [...tools.map(adaptTool3), this.createDreamTodoWriteTool(), taskComplete];
           }
           case "evaluator": {
             const tools = [
@@ -627053,7 +627539,7 @@ After synthesis, call task_complete with the final prioritized summary.`,
               new MemoryWriteTool(this.repoRoot),
               new GrepSearchTool(this.repoRoot)
             ];
-            return [...tools.map(adaptTool2), this.createDreamTodoWriteTool(), this.createDreamWorkingNotesTool(), taskComplete];
+            return [...tools.map(adaptTool3), this.createDreamTodoWriteTool(), this.createDreamWorkingNotesTool(), taskComplete];
           }
           case "critic": {
             const tools = [
@@ -627062,7 +627548,7 @@ After synthesis, call task_complete with the final prioritized summary.`,
               new MemorySearchTool(this.repoRoot),
               new GrepSearchTool(this.repoRoot)
             ];
-            return [...tools.map(adaptTool2), this.createDreamTodoWriteTool(), taskComplete];
+            return [...tools.map(adaptTool3), this.createDreamTodoWriteTool(), taskComplete];
           }
           case "flow_maintainer": {
             const tools = [
@@ -627070,7 +627556,7 @@ After synthesis, call task_complete with the final prioritized summary.`,
               new MemoryWriteTool(this.repoRoot),
               new MemorySearchTool(this.repoRoot)
             ];
-            return [...tools.map(adaptTool2), this.createDreamTodoWriteTool(), this.createDreamWorkingNotesTool(), taskComplete];
+            return [...tools.map(adaptTool3), this.createDreamTodoWriteTool(), this.createDreamWorkingNotesTool(), taskComplete];
           }
         }
       }
@@ -627416,7 +627902,7 @@ Call task_complete with a human-readable summary of the autoresearch session.`,
           workspace,
           onEvent
         );
-        const reportPath = join134(this.dreamsDir, `cycle-${cycleNum}-autoresearch-report.md`);
+        const reportPath = join135(this.dreamsDir, `cycle-${cycleNum}-autoresearch-report.md`);
         const report2 = `# Autoresearch Swarm Report — Cycle ${cycleNum}
 
 **Date**: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
@@ -627438,8 +627924,8 @@ ${summaryResult}
 *Generated by omnius autoresearch swarm*
 `;
         try {
-          mkdirSync69(this.dreamsDir, { recursive: true });
-          writeFileSync61(reportPath, report2, "utf-8");
+          mkdirSync70(this.dreamsDir, { recursive: true });
+          writeFileSync62(reportPath, report2, "utf-8");
         } catch {
         }
         renderSwarmComplete(workspace);
@@ -627451,7 +627937,7 @@ ${summaryResult}
           new MemoryReadTool(this.repoRoot),
           new MemoryWriteTool(this.repoRoot),
           new MemorySearchTool(this.repoRoot)
-        ].map(adaptTool2);
+        ].map(adaptTool3);
         const todoWriteTool = this.createDreamTodoWriteTool();
         const workingNotesTool = this.createDreamWorkingNotesTool();
         if (toolMode === "full") {
@@ -627470,7 +627956,7 @@ ${summaryResult}
             new WebSearchTool()
           ];
           return [
-            ...tools.map(adaptTool2),
+            ...tools.map(adaptTool3),
             ...memoryAndPlanTools,
             todoWriteTool,
             workingNotesTool,
@@ -627492,8 +627978,8 @@ ${summaryResult}
           new DreamShellTool(this.repoRoot)
         ];
         return [
-          ...readTools.map(adaptTool2),
-          ...dreamWriteTools.map(adaptTool2),
+          ...readTools.map(adaptTool3),
+          ...dreamWriteTools.map(adaptTool3),
           ...memoryAndPlanTools,
           todoWriteTool,
           workingNotesTool,
@@ -627502,7 +627988,7 @@ ${summaryResult}
       }
       /** Dream-scoped todo_write — persists to .omnius/dreams/todo-state.json */
       createDreamTodoWriteTool() {
-        const todoPath3 = join134(this.dreamsDir, "todo-state.json");
+        const todoPath3 = join135(this.dreamsDir, "todo-state.json");
         return {
           name: "todo_write",
           description: "Update the task checklist for this dream session. Mark items in_progress/completed/pending as you work through stages.",
@@ -627531,7 +628017,7 @@ ${summaryResult}
               return { success: false, output: "", error: "todos must be an array" };
             }
             try {
-              writeFileSync61(todoPath3, JSON.stringify({ todos, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2), "utf-8");
+              writeFileSync62(todoPath3, JSON.stringify({ todos, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2), "utf-8");
               const summary = todos.map(
                 (t2, i2) => `  ${t2.status === "completed" ? "✓" : t2.status === "in_progress" ? "▶" : "◯"} ${i2 + 1}: ${t2.content || "(untitled)"}`
               ).join("\n");
@@ -627545,7 +628031,7 @@ ${summary}` };
       }
       /** Dream-scoped working_notes — persists to .omnius/dreams/working-notes.json */
       createDreamWorkingNotesTool() {
-        const notesPath = join134(this.dreamsDir, "working-notes.json");
+        const notesPath = join135(this.dreamsDir, "working-notes.json");
         return {
           name: "working_notes",
           description: "Track discoveries, decisions, and findings across dream stages. Notes persist within this dream session.",
@@ -627569,8 +628055,8 @@ ${summary}` };
             const action = args["action"] || "list";
             try {
               let notes = [];
-              if (existsSync121(notesPath)) {
-                notes = JSON.parse(readFileSync97(notesPath, "utf-8"));
+              if (existsSync122(notesPath)) {
+                notes = JSON.parse(readFileSync98(notesPath, "utf-8"));
               }
               if (action === "add") {
                 const note = {
@@ -627579,11 +628065,11 @@ ${summary}` };
                   addedAt: (/* @__PURE__ */ new Date()).toISOString()
                 };
                 notes.push(note);
-                writeFileSync61(notesPath, JSON.stringify(notes, null, 2), "utf-8");
+                writeFileSync62(notesPath, JSON.stringify(notes, null, 2), "utf-8");
                 return { success: true, output: `Note added: [${note.category}] ${note.content.slice(0, 80)}` };
               }
               if (action === "clear") {
-                writeFileSync61(notesPath, "[]", "utf-8");
+                writeFileSync62(notesPath, "[]", "utf-8");
                 return { success: true, output: "All notes cleared." };
               }
               if (action === "search") {
@@ -627619,9 +628105,9 @@ ${summary}` };
       }
       /** Save workspace backup for lucid mode */
       saveVersionCheckpoint(cycle) {
-        const checkpointDir3 = join134(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
+        const checkpointDir3 = join135(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
         try {
-          mkdirSync69(checkpointDir3, { recursive: true });
+          mkdirSync70(checkpointDir3, { recursive: true });
           try {
             const gitStatus = execSync56("git status --porcelain", {
               cwd: this.repoRoot,
@@ -627638,11 +628124,11 @@ ${summary}` };
               encoding: "utf-8",
               timeout: 5e3
             }).trim();
-            writeFileSync61(join134(checkpointDir3, "git-status.txt"), gitStatus, "utf-8");
-            writeFileSync61(join134(checkpointDir3, "git-diff.patch"), gitDiff, "utf-8");
-            writeFileSync61(join134(checkpointDir3, "git-hash.txt"), gitHash, "utf-8");
-            writeFileSync61(
-              join134(checkpointDir3, "checkpoint.json"),
+            writeFileSync62(join135(checkpointDir3, "git-status.txt"), gitStatus, "utf-8");
+            writeFileSync62(join135(checkpointDir3, "git-diff.patch"), gitDiff, "utf-8");
+            writeFileSync62(join135(checkpointDir3, "git-hash.txt"), gitHash, "utf-8");
+            writeFileSync62(
+              join135(checkpointDir3, "checkpoint.json"),
               JSON.stringify({
                 cycle,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -627653,8 +628139,8 @@ ${summary}` };
             );
             renderInfo(`Checkpoint saved: cycle ${cycle} (${gitHash.slice(0, 8)})`);
           } catch {
-            writeFileSync61(
-              join134(checkpointDir3, "checkpoint.json"),
+            writeFileSync62(
+              join135(checkpointDir3, "checkpoint.json"),
               JSON.stringify({ cycle, timestamp: (/* @__PURE__ */ new Date()).toISOString(), mode: this.state.mode }, null, 2),
               "utf-8"
             );
@@ -627694,7 +628180,7 @@ Each proposal includes implementation entrypoints and estimated effort.
       /** Update the master proposal index */
       updateProposalIndex() {
         try {
-          const files = readdirSync42(this.dreamsDir).filter((f2) => f2.endsWith(".md") && f2 !== "PROPOSAL-INDEX.md" && f2 !== "dream-state.json").sort();
+          const files = readdirSync43(this.dreamsDir).filter((f2) => f2.endsWith(".md") && f2 !== "PROPOSAL-INDEX.md" && f2 !== "dream-state.json").sort();
           const index = `# Dream Proposals Index
 
 **Last updated**: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
@@ -627715,7 +628201,7 @@ ${files.map((f2) => `- [\`${f2}\`](./${f2})`).join("\n")}
 ---
 *Auto-generated by omnius dream engine*
 `;
-          writeFileSync61(join134(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
+          writeFileSync62(join135(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
         } catch {
         }
       }
@@ -627736,8 +628222,8 @@ ${files.map((f2) => `- [\`${f2}\`](./${f2})`).join("\n")}
           results: []
         };
         renderInfo("Memory consolidation starting — Phase 1: Orient → Phase 2: Gather → Phase 3: Consolidate → Phase 4: Prune");
-        const memoryDir = join134(this.repoRoot, ".omnius", "memory");
-        mkdirSync69(memoryDir, { recursive: true });
+        const memoryDir = join135(this.repoRoot, ".omnius", "memory");
+        mkdirSync70(memoryDir, { recursive: true });
         let prompt;
         try {
           prompt = loadPrompt3("tui/dream-consolidate.md", {
@@ -627803,14 +628289,25 @@ ${files.map((f2) => `- [\`${f2}\`](./${f2})`).join("\n")}
             durationMs
           });
           try {
-            writeFileSync61(
-              join134(memoryDir, ".last-consolidation"),
+            writeFileSync62(
+              join135(memoryDir, ".last-consolidation"),
               JSON.stringify({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), summary: result.summary?.slice(0, 500) }) + "\n"
             );
           } catch {
           }
           renderInfo(`Consolidation complete: ${result.turns} turns, ${result.toolCalls} tool calls, ${(durationMs / 1e3).toFixed(1)}s`);
           if (result.summary) renderInfo(`Summary: ${result.summary.slice(0, 200)}`);
+          if (result.summary && result.summary.trim().length > 40) {
+            try {
+              const snr = new SNREngine(this.config, this.repoRoot);
+              const { archived, topics } = snr.archiveNoiseEntries(result.summary);
+              if (archived > 0) {
+                renderInfo(`Pruned ${archived} low-SNR memory entr${archived === 1 ? "y" : "ies"} to .archive (topics: ${topics.join(", ")})`);
+              }
+            } catch (pruneErr) {
+              renderWarning(`Noise pruning skipped: ${pruneErr instanceof Error ? pruneErr.message : String(pruneErr)}`);
+            }
+          }
         } catch (err) {
           renderWarning(`Consolidation failed: ${err instanceof Error ? err.message : String(err)}`);
         }
@@ -627821,8 +628318,8 @@ ${files.map((f2) => `- [\`${f2}\`](./${f2})`).join("\n")}
       /** Save dream state for resume/inspection */
       saveDreamState() {
         try {
-          writeFileSync61(
-            join134(this.dreamsDir, "dream-state.json"),
+          writeFileSync62(
+            join135(this.dreamsDir, "dream-state.json"),
             JSON.stringify(this.state, null, 2) + "\n",
             "utf-8"
           );
@@ -628202,8 +628699,8 @@ var init_bless_engine = __esm({
 });
 
 // packages/cli/src/tui/dmn-engine.ts
-import { existsSync as existsSync122, readFileSync as readFileSync98, writeFileSync as writeFileSync62, mkdirSync as mkdirSync70, readdirSync as readdirSync43, unlinkSync as unlinkSync24 } from "node:fs";
-import { join as join135, basename as basename32 } from "node:path";
+import { existsSync as existsSync123, readFileSync as readFileSync99, writeFileSync as writeFileSync63, mkdirSync as mkdirSync71, readdirSync as readdirSync44, unlinkSync as unlinkSync24 } from "node:fs";
+import { join as join136, basename as basename33 } from "node:path";
 function buildDMNGatherPrompt(recentTaskSummaries, dueReminders, attentionItems, memoryTopics, capabilities, competence, reflectionBuffer) {
   const competenceReport = competence.length > 0 ? competence.map((c8) => {
     const rate = c8.attempts > 0 ? Math.round(c8.successes / c8.attempts * 100) : 0;
@@ -628227,7 +628724,7 @@ ${competenceReport}
 Reflect on what went well and what could improve.`;
   }
 }
-function adaptTool3(tool) {
+function adaptTool4(tool) {
   return {
     name: tool.name,
     description: tool.description,
@@ -628308,9 +628805,9 @@ var init_dmn_engine = __esm({
       constructor(config, repoRoot) {
         this.config = config;
         this.repoRoot = repoRoot;
-        this.stateDir = join135(repoRoot, ".omnius", "dmn");
-        this.historyDir = join135(repoRoot, ".omnius", "dmn", "cycles");
-        mkdirSync70(this.historyDir, { recursive: true });
+        this.stateDir = join136(repoRoot, ".omnius", "dmn");
+        this.historyDir = join136(repoRoot, ".omnius", "dmn", "cycles");
+        mkdirSync71(this.historyDir, { recursive: true });
         this.loadState();
       }
       config;
@@ -628525,7 +629022,7 @@ DMN state directory: ${this.stateDir}`
           new ShellTool(this.repoRoot)
         ];
         return [
-          ...tools.map(adaptTool3),
+          ...tools.map(adaptTool4),
           this.createTaskCompleteTool()
         ];
       }
@@ -628802,7 +629299,7 @@ OUTPUT: Call task_complete with JSON:
         ];
         tools.push(new MemoryWriteTool(this.repoRoot));
         runner.registerTools([
-          ...tools.map(adaptTool3),
+          ...tools.map(adaptTool4),
           {
             name: "task_complete",
             description: `Signal that the ${role} analysis is complete.`,
@@ -628946,15 +629443,15 @@ OUTPUT: Call task_complete with JSON:
       async gatherMemoryTopics() {
         const topics = [];
         const dirs = [
-          join135(this.repoRoot, ".omnius", "memory"),
-          join135(this.repoRoot, ".omnius", "memory")
+          join136(this.repoRoot, ".omnius", "memory"),
+          join136(this.repoRoot, ".omnius", "memory")
         ];
         for (const dir of dirs) {
-          if (!existsSync122(dir)) continue;
+          if (!existsSync123(dir)) continue;
           try {
-            const files = readdirSync43(dir).filter((f2) => f2.endsWith(".json"));
+            const files = readdirSync44(dir).filter((f2) => f2.endsWith(".json"));
             for (const f2 of files) {
-              const topic = basename32(f2, ".json");
+              const topic = basename33(f2, ".json");
               if (!topics.includes(topic)) topics.push(topic);
             }
           } catch {
@@ -628964,18 +629461,18 @@ OUTPUT: Call task_complete with JSON:
       }
       // ── State persistence ─────────────────────────────────────────────────
       loadState() {
-        const path12 = join135(this.stateDir, "state.json");
-        if (existsSync122(path12)) {
+        const path12 = join136(this.stateDir, "state.json");
+        if (existsSync123(path12)) {
           try {
-            this.state = JSON.parse(readFileSync98(path12, "utf-8"));
+            this.state = JSON.parse(readFileSync99(path12, "utf-8"));
           } catch {
           }
         }
       }
       saveState() {
         try {
-          writeFileSync62(
-            join135(this.stateDir, "state.json"),
+          writeFileSync63(
+            join136(this.stateDir, "state.json"),
             JSON.stringify(this.state, null, 2) + "\n",
             "utf-8"
           );
@@ -628985,8 +629482,8 @@ OUTPUT: Call task_complete with JSON:
       saveCycleResult(result) {
         try {
           const filename = `cycle-${result.cycleNumber}-${Date.now()}.json`;
-          writeFileSync62(
-            join135(this.historyDir, filename),
+          writeFileSync63(
+            join136(this.historyDir, filename),
             JSON.stringify(result, null, 2) + "\n",
             "utf-8"
           );
@@ -628995,13 +629492,13 @@ OUTPUT: Call task_complete with JSON:
         }
       }
       pruneCycleHistory() {
-        const files = readdirSync43(this.historyDir).filter((f2) => f2.startsWith("cycle-") && f2.endsWith(".json")).sort();
+        const files = readdirSync44(this.historyDir).filter((f2) => f2.startsWith("cycle-") && f2.endsWith(".json")).sort();
         if (files.length <= 2) return;
         const keep = /* @__PURE__ */ new Set([files[0], files[files.length - 1]]);
         const latestByFingerprint = /* @__PURE__ */ new Map();
         for (const file of files) {
           try {
-            const parsed = JSON.parse(readFileSync98(join135(this.historyDir, file), "utf-8"));
+            const parsed = JSON.parse(readFileSync99(join136(this.historyDir, file), "utf-8"));
             latestByFingerprint.set(this.fingerprintCycle(parsed), file);
           } catch {
             keep.add(file);
@@ -629019,7 +629516,7 @@ OUTPUT: Call task_complete with JSON:
         for (const file of files) {
           if (!keep.has(file)) {
             try {
-              unlinkSync24(join135(this.historyDir, file));
+              unlinkSync24(join136(this.historyDir, file));
             } catch {
             }
           }
@@ -629045,385 +629542,6 @@ ${result.reasoning}`).toLowerCase().replace(/\d+/g, "#").replace(/\s+/g, " ").tr
   }
 });
 
-// packages/cli/src/tui/snr-engine.ts
-import { existsSync as existsSync123, readdirSync as readdirSync44, readFileSync as readFileSync99 } from "node:fs";
-import { join as join136, basename as basename33 } from "node:path";
-function computeDPrime(signalScores, noiseScores) {
-  if (signalScores.length === 0 || noiseScores.length === 0) return 0;
-  const mean = (arr) => arr.reduce((s2, v) => s2 + v, 0) / arr.length;
-  const variance = (arr, mu) => arr.reduce((s2, v) => s2 + (v - mu) ** 2, 0) / Math.max(1, arr.length - 1);
-  const muSignal = mean(signalScores);
-  const muNoise = mean(noiseScores);
-  const varSignal = variance(signalScores, muSignal);
-  const varNoise = variance(noiseScores, muNoise);
-  const pooledStd = Math.sqrt((varSignal + varNoise) / 2);
-  if (pooledStd === 0) return muSignal > muNoise ? 3 : 0;
-  return (muSignal - muNoise) / pooledStd;
-}
-function computeSparsity(entries) {
-  if (entries.length <= 1) return 1;
-  const ngramSets = entries.map((e2) => {
-    const words = e2.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
-    const ngrams = /* @__PURE__ */ new Set();
-    for (let i2 = 0; i2 < words.length - 1; i2++) {
-      ngrams.add(`${words[i2]} ${words[i2 + 1]}`);
-    }
-    return ngrams;
-  });
-  let totalPairs = 0;
-  let totalJaccard = 0;
-  for (let i2 = 0; i2 < ngramSets.length; i2++) {
-    for (let j = i2 + 1; j < ngramSets.length; j++) {
-      const a2 = ngramSets[i2];
-      const b = ngramSets[j];
-      if (a2.size === 0 && b.size === 0) continue;
-      const intersection = new Set([...a2].filter((x) => b.has(x)));
-      const union = /* @__PURE__ */ new Set([...a2, ...b]);
-      totalJaccard += union.size > 0 ? intersection.size / union.size : 0;
-      totalPairs++;
-    }
-  }
-  if (totalPairs === 0) return 1;
-  const avgOverlap = totalJaccard / totalPairs;
-  return Math.max(0, Math.min(1, 1 - avgOverlap));
-}
-function adaptTool4(tool) {
-  return {
-    name: tool.name,
-    description: tool.description,
-    parameters: tool.parameters,
-    async execute(args) {
-      const result = await tool.execute(args);
-      return { success: result.success, output: result.output, error: result.error };
-    }
-  };
-}
-var SNREngine;
-var init_snr_engine = __esm({
-  "packages/cli/src/tui/snr-engine.ts"() {
-    "use strict";
-    init_dist8();
-    init_dist5();
-    init_project_context();
-    init_render();
-    SNREngine = class {
-      constructor(config, repoRoot) {
-        this.config = config;
-        this.repoRoot = repoRoot;
-      }
-      config;
-      repoRoot;
-      lastScore = null;
-      evaluationCount = 0;
-      get score() {
-        return this.lastScore;
-      }
-      /**
-       * Quick local-only SNR estimation (no LLM calls, fast).
-       * @param contextSlots — total context window tokens (for Hopfield capacity warning)
-       */
-      computeLocalSNR(currentTask, contextEntries, contextSlots) {
-        if (contextEntries.length === 0) {
-          return this.makeScore(1, 3, 0, 0, 0, 1, ["local-empty"]);
-        }
-        const taskTerms = new Set(
-          currentTask.toLowerCase().split(/\s+/).filter((w) => w.length > 3).map((w) => w.replace(/[^a-z0-9]/g, ""))
-        );
-        const scores = contextEntries.map((entry) => {
-          const entryTerms = entry.toLowerCase().split(/\s+/).filter((w) => w.length > 3).map((w) => w.replace(/[^a-z0-9]/g, ""));
-          const matchCount = entryTerms.filter((t2) => taskTerms.has(t2)).length;
-          const score2 = entryTerms.length > 0 ? matchCount / Math.sqrt(entryTerms.length) : 0;
-          return { entry, score: score2 };
-        });
-        const allScores = scores.map((s2) => s2.score);
-        const mean = allScores.reduce((a2, b) => a2 + b, 0) / allScores.length;
-        const std = Math.sqrt(allScores.reduce((a2, v) => a2 + (v - mean) ** 2, 0) / allScores.length);
-        const threshold = mean + 0.5 * std;
-        const signalScores = allScores.filter((s2) => s2 >= threshold);
-        const noiseScores = allScores.filter((s2) => s2 < threshold);
-        const dPrime = computeDPrime(
-          signalScores.length > 0 ? signalScores : [mean],
-          noiseScores.length > 0 ? noiseScores : [0]
-        );
-        const sparsity = computeSparsity(contextEntries);
-        const signalProportion = signalScores.length / allScores.length;
-        const dPrimeNorm = Math.min(1, Math.max(0, dPrime / 3));
-        const ratio = 0.5 * signalProportion + 0.3 * dPrimeNorm + 0.2 * sparsity;
-        const capacityWarning = contextSlots ? contextEntries.length > Math.floor(contextSlots * 0.138) : false;
-        const score = this.makeScore(
-          ratio,
-          dPrime,
-          contextEntries.length,
-          signalScores.length,
-          noiseScores.length,
-          sparsity,
-          ["local-keyword"],
-          capacityWarning
-        );
-        this.lastScore = score;
-        this.evaluationCount++;
-        return score;
-      }
-      /**
-       * Full SNR evaluation using parallel LLM evaluator agents.
-       * Mirrors PFC gating + multi-agent debate (Du et al. 2023).
-       *
-       * Spawns 2 lightweight agents with different evaluation perspectives:
-       * - "Relevance Evaluator" — scores entries by task relevance (PFC role)
-       * - "Noise Detector" — identifies redundant/stale/irrelevant entries (DG role)
-       *
-       * Their consensus determines the final SNR.
-       */
-      async evaluateWithAgents(currentTask, memoryTopics, onEvent) {
-        const entries = this.loadMemoryEntries(memoryTopics);
-        if (entries.length === 0) {
-          const score2 = this.makeScore(1, 3, 0, 0, 0, 1, ["agents-empty"]);
-          this.lastScore = score2;
-          return score2;
-        }
-        const entrySummaries = entries.map(
-          (e2, i2) => `[${i2}] topic=${e2.topic} key=${e2.key}: ${e2.value.slice(0, 200)}${e2.value.length > 200 ? "..." : ""}`
-        );
-        const entriesBlock = entrySummaries.join("\n");
-        const [relevanceResult, noiseResult] = await Promise.allSettled([
-          this.runEvaluatorAgent(
-            "relevance",
-            `You are a Prefrontal Cortex Gating Evaluator. Your role is to assess which
-memory entries are RELEVANT to the current task.
-
-CURRENT TASK: ${currentTask}
-
-MEMORY ENTRIES TO EVALUATE:
-${entriesBlock}
-
-For each entry, output a JSON array of objects:
-[{"index": 0, "score": 0.8, "reason": "directly related to task"}, ...]
-
-Score 0-1 where:
-- 1.0 = directly relevant to the current task
-- 0.7 = supporting context (useful background)
-- 0.4 = marginally relevant
-- 0.1 = not relevant to current task
-
-Call task_complete with the JSON array when done.`,
-            onEvent
-          ),
-          this.runEvaluatorAgent(
-            "noise",
-            `You are a Dentate Gyrus Pattern Separation Evaluator. Your role is to identify
-NOISE in the memory context — entries that are redundant, stale, or interfering.
-
-CURRENT TASK: ${currentTask}
-
-MEMORY ENTRIES TO EVALUATE:
-${entriesBlock}
-
-For each entry, output a JSON array of objects:
-[{"index": 0, "noise_score": 0.2, "reason": "unique, not redundant"}, ...]
-
-Noise score 0-1 where:
-- 1.0 = pure noise (completely redundant, stale, or interfering with task)
-- 0.7 = mostly noise (outdated or largely redundant with another entry)
-- 0.4 = moderate noise (some overlap with other entries)
-- 0.1 = clean signal (unique, fresh, non-interfering)
-
-Look for: duplicate information, outdated facts, entries that contradict
-newer entries, entries about completely unrelated topics.
-
-Call task_complete with the JSON array when done.`,
-            onEvent
-          )
-        ]);
-        const relevanceScores = this.parseEvaluatorResult(
-          relevanceResult.status === "fulfilled" ? relevanceResult.value : "",
-          entries.length,
-          0.5
-          // default relevance
-        );
-        const noiseScores = this.parseEvaluatorResult(
-          noiseResult.status === "fulfilled" ? noiseResult.value : "",
-          entries.length,
-          0.5
-          // default noise
-        );
-        const combinedScores = entries.map((_, i2) => {
-          const rel = relevanceScores[i2] ?? 0.5;
-          const noise2 = noiseScores[i2] ?? 0.5;
-          const votes = [rel, 1 - noise2].sort((a2, b) => a2 - b);
-          return (votes[0] + votes[1]) / 2;
-        });
-        const mean = combinedScores.reduce((a2, b) => a2 + b, 0) / combinedScores.length;
-        const std = Math.sqrt(combinedScores.reduce((a2, v) => a2 + (v - mean) ** 2, 0) / combinedScores.length);
-        const threshold = Math.max(0.3, mean);
-        const signalEntries = combinedScores.filter((s2) => s2 >= threshold);
-        const noiseEntries = combinedScores.filter((s2) => s2 < threshold);
-        const dPrime = computeDPrime(
-          signalEntries.length > 0 ? signalEntries : [mean],
-          noiseEntries.length > 0 ? noiseEntries : [0.1]
-        );
-        const sparsity = computeSparsity(entries.map((e2) => e2.value));
-        const signalProportion = signalEntries.length / combinedScores.length;
-        const dPrimeNorm = Math.min(1, Math.max(0, dPrime / 3));
-        const ratio = 0.5 * signalProportion + 0.3 * dPrimeNorm + 0.2 * sparsity;
-        const evaluators = [
-          relevanceResult.status === "fulfilled" ? "relevance-agent" : "relevance-failed",
-          noiseResult.status === "fulfilled" ? "noise-agent" : "noise-failed"
-        ];
-        const score = this.makeScore(
-          ratio,
-          dPrime,
-          entries.length,
-          signalEntries.length,
-          noiseEntries.length,
-          sparsity,
-          evaluators
-        );
-        this.lastScore = score;
-        this.evaluationCount++;
-        return score;
-      }
-      // ── Evaluator agent ──────────────────────────────────────────────────
-      async runEvaluatorAgent(name10, prompt, onEvent) {
-        const backend = new OllamaAgenticBackend(
-          this.config.backendUrl,
-          this.config.model,
-          this.config.apiKey
-        );
-        const modelTier = getModelTier(this.config.model);
-        const runner = new AgenticRunner(backend, {
-          maxTurns: 5,
-          // Evaluators are very focused — 5 turns max
-          maxTokens: 4096,
-          temperature: 0,
-          // Deterministic scoring
-          requestTimeoutMs: this.config.timeoutMs,
-          taskTimeoutMs: this.config.timeoutMs,
-          compactionThreshold: modelTier === "small" ? 8e3 : 16e3,
-          modelTier
-        });
-        const tools = [
-          new MemoryReadTool(this.repoRoot),
-          new MemorySearchTool(this.repoRoot)
-        ];
-        runner.registerTools([
-          ...tools.map(adaptTool4),
-          {
-            name: "task_complete",
-            description: "Signal evaluation is complete with your scored results.",
-            parameters: {
-              type: "object",
-              properties: {
-                summary: { type: "string", description: "JSON array of scored entries" }
-              },
-              required: ["summary"]
-            },
-            async execute(args) {
-              return { success: true, output: args["summary"] || "[]" };
-            }
-          }
-        ]);
-        if (onEvent) runner.onEvent(onEvent);
-        const result = await runner.run(
-          prompt,
-          `SNR Evaluator (${name10}). Working directory: ${this.repoRoot}`
-        );
-        return result.summary || "[]";
-      }
-      // ── Memory loading ───────────────────────────────────────────────────
-      loadMemoryEntries(topics) {
-        const entries = [];
-        const dirs = [
-          join136(this.repoRoot, ".omnius", "memory"),
-          join136(this.repoRoot, ".omnius", "memory")
-        ];
-        for (const dir of dirs) {
-          if (!existsSync123(dir)) continue;
-          try {
-            const files = readdirSync44(dir).filter((f2) => f2.endsWith(".json"));
-            for (const f2 of files) {
-              const topic = basename33(f2, ".json");
-              if (topics.length > 0 && !topics.includes(topic)) continue;
-              try {
-                const data = JSON.parse(readFileSync99(join136(dir, f2), "utf-8"));
-                for (const [key, val] of Object.entries(data)) {
-                  const value2 = typeof val === "object" && val !== null && "value" in val ? String(val.value) : String(val);
-                  entries.push({ topic, key, value: value2 });
-                }
-              } catch {
-              }
-            }
-          } catch {
-          }
-        }
-        return entries;
-      }
-      // ── Result parsing ───────────────────────────────────────────────────
-      parseEvaluatorResult(summary, entryCount, defaultScore) {
-        const scores = new Array(entryCount).fill(defaultScore);
-        try {
-          const jsonMatch = summary.match(/\[[\s\S]*\]/);
-          if (!jsonMatch) return scores;
-          const parsed = JSON.parse(jsonMatch[0]);
-          for (const item of parsed) {
-            const idx = typeof item.index === "number" ? item.index : -1;
-            const score = typeof item.score === "number" ? item.score : typeof item.noise_score === "number" ? item.noise_score : defaultScore;
-            if (idx >= 0 && idx < entryCount) {
-              scores[idx] = Math.max(0, Math.min(1, score));
-            }
-          }
-        } catch {
-        }
-        return scores;
-      }
-      // ── Memory pruning recommendations ──────────────────────────────────
-      /**
-       * Identify low-SNR memory entries that should be pruned.
-       * Mirrors synaptic downscaling during slow-wave sleep — weak connections
-       * (low-relevance, high-redundancy entries) are depotentiated.
-       *
-       * Returns topics+keys of entries scoring below the noise threshold.
-       * Does NOT delete anything — the caller decides what to do with the list.
-       */
-      getPruningCandidates(currentTask, noiseThreshold = 0.3) {
-        const entries = this.loadMemoryEntries([]);
-        if (entries.length === 0) return [];
-        const taskTerms = new Set(
-          currentTask.toLowerCase().split(/\s+/).filter((w) => w.length > 3).map((w) => w.replace(/[^a-z0-9]/g, ""))
-        );
-        const candidates = [];
-        for (const entry of entries) {
-          const entryTerms = entry.value.toLowerCase().split(/\s+/).filter((w) => w.length > 3).map((w) => w.replace(/[^a-z0-9]/g, ""));
-          const matchCount = entryTerms.filter((t2) => taskTerms.has(t2)).length;
-          const relevance = entryTerms.length > 0 ? matchCount / Math.sqrt(entryTerms.length) : 0;
-          if (relevance < noiseThreshold) {
-            candidates.push({
-              topic: entry.topic,
-              key: entry.key,
-              score: relevance,
-              reason: relevance === 0 ? "no keyword overlap with current task" : `low relevance (${(relevance * 100).toFixed(0)}% < ${(noiseThreshold * 100).toFixed(0)}% threshold)`
-            });
-          }
-        }
-        return candidates.sort((a2, b) => a2.score - b.score);
-      }
-      // ── Helpers ──────────────────────────────────────────────────────────
-      makeScore(ratio, dPrime, total, signal, noise2, sparsity, evaluators, capacityWarning = false) {
-        return {
-          ratio: Math.max(0, Math.min(1, ratio)),
-          dPrime: Math.max(0, dPrime),
-          entriesEvaluated: total,
-          signalCount: signal,
-          noiseCount: noise2,
-          sparsity: Math.max(0, Math.min(1, sparsity)),
-          evaluatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          evaluators,
-          capacityWarning
-        };
-      }
-    };
-  }
-});
-
 // packages/cli/src/tui/emotion-engine.ts
 function labelFromCoordinates(valence, arousal) {
   if (valence > 0.6 && arousal > 0.6) return { label: "exhilarated", emoji: "🤩" };
@@ -631022,11 +631140,11 @@ var init_telegram_command_menu = __esm({
 import { createCipheriv as createCipheriv5, createDecipheriv as createDecipheriv5, randomBytes as randomBytes24 } from "node:crypto";
 import {
   existsSync as existsSync124,
-  mkdirSync as mkdirSync71,
+  mkdirSync as mkdirSync72,
   readFileSync as readFileSync100,
   statSync as statSync45,
   unlinkSync as unlinkSync25,
-  writeFileSync as writeFileSync63
+  writeFileSync as writeFileSync64
 } from "node:fs";
 import { mkdir as mkdir20 } from "node:fs/promises";
 import {
@@ -631043,7 +631161,7 @@ function telegramCreativeWorkspaceRoot(repoRoot, chatId) {
   const raw = chatId === void 0 ? "unknown" : String(chatId);
   const key = raw.replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 96) || "unknown";
   const root = join137(repoRoot, ".omnius", "telegram-creative", key);
-  mkdirSync71(root, { recursive: true });
+  mkdirSync72(root, { recursive: true });
   return root;
 }
 function formatTelegramCreativeWorkspacePrompt(root) {
@@ -631216,8 +631334,8 @@ function scopedTool(base3, root, mode) {
         if (mode === "edit" && !existsSync124(guarded.path.abs)) {
           const materialized = materializeTelegramCreativeArtifactForSend(rootAbs, guarded.path.rel);
           if (!materialized.ok) return denied(materialized.error);
-          mkdirSync71(dirname39(guarded.path.abs), { recursive: true });
-          writeFileSync63(guarded.path.abs, readFileSync100(materialized.path));
+          mkdirSync72(dirname39(guarded.path.abs), { recursive: true });
+          writeFileSync64(guarded.path.abs, readFileSync100(materialized.path));
           materialized.cleanup?.();
           restoredEditPath = guarded.path.abs;
         }
@@ -631309,10 +631427,10 @@ function manifestPath(root) {
   return join137(root, MANIFEST_FILE);
 }
 function ensureManifest(root) {
-  mkdirSync71(root, { recursive: true });
+  mkdirSync72(root, { recursive: true });
   const path12 = manifestPath(root);
   if (!existsSync124(path12)) {
-    writeFileSync63(path12, JSON.stringify({ files: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n", "utf8");
+    writeFileSync64(path12, JSON.stringify({ files: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n", "utf8");
   }
 }
 function readManifest(root) {
@@ -631338,7 +631456,7 @@ function readManifest(root) {
 }
 function writeManifest(root, manifest) {
   ensureManifest(root);
-  writeFileSync63(manifestPath(root), JSON.stringify(manifest, null, 2) + "\n", "utf8");
+  writeFileSync64(manifestPath(root), JSON.stringify(manifest, null, 2) + "\n", "utf8");
 }
 function manifestHas(root, relPath) {
   const rel = relPath.replace(/\\/g, "/");
@@ -631362,7 +631480,7 @@ function rememberCreated(root, absPath) {
         }
       }
     }
-    mkdirSync71(join137(root, OBJECTS_DIR), { recursive: true });
+    mkdirSync72(join137(root, OBJECTS_DIR), { recursive: true });
     const data = readFileSync100(guarded.path.abs);
     const prefix = randomBytes24(48);
     const key = randomBytes24(32);
@@ -631372,7 +631490,7 @@ function rememberCreated(root, absPath) {
     const tag = cipher.getAuthTag();
     const storedRel = join137(OBJECTS_DIR, `${Date.now()}-${randomBytes24(12).toString("hex")}.blob`).replace(/\\/g, "/");
     const storedAbs = join137(root, storedRel);
-    writeFileSync63(storedAbs, Buffer.concat([prefix, encrypted]));
+    writeFileSync64(storedAbs, Buffer.concat([prefix, encrypted]));
     try {
       unlinkSync25(guarded.path.abs);
     } catch {
@@ -631431,9 +631549,9 @@ function materializeTelegramCreativeArtifactForSend(root, rawPath) {
       payload = Buffer.concat([decipher.update(payload), decipher.final()]);
     }
     const stageDir = join137(rootAbs, SEND_DIR, `${Date.now()}-${randomBytes24(8).toString("hex")}`);
-    mkdirSync71(stageDir, { recursive: true });
+    mkdirSync72(stageDir, { recursive: true });
     const staged = join137(stageDir, object.originalName || basename34(rel));
-    writeFileSync63(staged, payload);
+    writeFileSync64(staged, payload);
     return {
       ok: true,
       path: staged,
@@ -632114,7 +632232,7 @@ var init_soul_observations = __esm({
 });
 
 // packages/cli/src/tui/telegram-channel-dmn.ts
-import { existsSync as existsSync125, mkdirSync as mkdirSync72, readdirSync as readdirSync45, readFileSync as readFileSync101, writeFileSync as writeFileSync64 } from "node:fs";
+import { existsSync as existsSync125, mkdirSync as mkdirSync73, readdirSync as readdirSync45, readFileSync as readFileSync101, writeFileSync as writeFileSync65 } from "node:fs";
 import { join as join138 } from "node:path";
 import { createHash as createHash30 } from "node:crypto";
 function safeFilePart(value2) {
@@ -632674,12 +632792,12 @@ ${artifact.personaContext}
 }
 function writeTelegramChannelDaydream(repoRoot, artifact) {
   const dir = sessionDir(repoRoot, artifact.sessionKey);
-  mkdirSync72(dir, { recursive: true });
+  mkdirSync73(dir, { recursive: true });
   const base3 = `${artifact.generatedAt.replace(/[:.]/g, "-")}-${artifact.id}`;
   const jsonPath = join138(dir, `${base3}.json`);
   const markdownPath = join138(dir, `${base3}.md`);
-  writeFileSync64(jsonPath, JSON.stringify(artifact, null, 2) + "\n", "utf8");
-  writeFileSync64(markdownPath, formatTelegramChannelDaydreamMarkdown(artifact), "utf8");
+  writeFileSync65(jsonPath, JSON.stringify(artifact, null, 2) + "\n", "utf8");
+  writeFileSync65(markdownPath, formatTelegramChannelDaydreamMarkdown(artifact), "utf8");
   return { dir, jsonPath, markdownPath };
 }
 function latestTelegramChannelDaydream(repoRoot, sessionKey) {
@@ -634433,7 +634551,7 @@ var init_vision_ingress = __esm({
 });
 
 // packages/cli/src/tui/telegram-bridge.ts
-import { mkdirSync as mkdirSync73, existsSync as existsSync127, unlinkSync as unlinkSync27, readdirSync as readdirSync46, statSync as statSync46, statfsSync as statfsSync5, readFileSync as readFileSync103, writeFileSync as writeFileSync66, appendFileSync as appendFileSync10 } from "node:fs";
+import { mkdirSync as mkdirSync74, existsSync as existsSync127, unlinkSync as unlinkSync27, readdirSync as readdirSync46, statSync as statSync46, statfsSync as statfsSync5, readFileSync as readFileSync103, writeFileSync as writeFileSync67, appendFileSync as appendFileSync10 } from "node:fs";
 import { join as join140, resolve as resolve53, basename as basename35, relative as relative14, isAbsolute as isAbsolute9, extname as extname19 } from "node:path";
 import { homedir as homedir44 } from "node:os";
 import { writeFile as writeFileAsync } from "node:fs/promises";
@@ -638824,7 +638942,7 @@ Model: <code>${escapeTelegramHTML(model.id)}</code>`
       appendTelegramConversationLedger(sessionKey, entry) {
         if (!this.repoRoot) return;
         try {
-          mkdirSync73(this.telegramConversationDir, { recursive: true });
+          mkdirSync74(this.telegramConversationDir, { recursive: true });
           appendFileSync10(
             this.telegramConversationLedgerPath(sessionKey),
             JSON.stringify({ sessionKey, ...entry }) + "\n",
@@ -639073,7 +639191,7 @@ ${mediaContext}` : ""
           return null;
         }
         try {
-          mkdirSync73(resolve53(this.repoRoot, ".omnius"), { recursive: true });
+          mkdirSync74(resolve53(this.repoRoot, ".omnius"), { recursive: true });
           const db = initDb(this.telegramSqlitePath);
           db.exec(`
         CREATE TABLE IF NOT EXISTS telegram_messages (
@@ -639840,7 +639958,7 @@ ${mediaContext}` : ""
       saveTelegramConversationState(sessionKey) {
         if (!this.repoRoot) return;
         try {
-          mkdirSync73(this.telegramConversationDir, { recursive: true });
+          mkdirSync74(this.telegramConversationDir, { recursive: true });
           const participants = [...this.chatParticipants.get(sessionKey)?.values() ?? []].map((profile) => ({
             ...profile,
             toneTags: [...profile.toneTags]
@@ -639857,7 +639975,7 @@ ${mediaContext}` : ""
             stimulation: this.stimulation.getState(sessionKey),
             reflection: this.channelReflectionState.get(sessionKey) ?? { autoFollowup: false }
           };
-          writeFileSync66(this.telegramConversationPath(sessionKey), JSON.stringify(payload, null, 2) + "\n", "utf8");
+          writeFileSync67(this.telegramConversationPath(sessionKey), JSON.stringify(payload, null, 2) + "\n", "utf8");
         } catch {
         }
       }
@@ -643482,7 +643600,7 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
           this.startTelegramSubAgentWatchdog();
           await this.prepareTelegramLongPolling();
           try {
-            mkdirSync73(this.mediaCacheDir, { recursive: true });
+            mkdirSync74(this.mediaCacheDir, { recursive: true });
           } catch {
           }
           try {
@@ -643599,7 +643717,7 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
         this.refreshActiveTelegramInteractionCount();
       }
       claimTelegramOwnerLock(lockDir, botUserId, botUsername) {
-        mkdirSync73(lockDir, { recursive: true });
+        mkdirSync74(lockDir, { recursive: true });
         const lockFile = join140(lockDir, `bot-${botUserId}.owner.lock`);
         if (existsSync127(lockFile)) {
           try {
@@ -643614,7 +643732,7 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
             if (e2 instanceof Error && e2.message.startsWith("Telegram bot @")) throw e2;
           }
         }
-        writeFileSync66(
+        writeFileSync67(
           lockFile,
           JSON.stringify({
             pid: process.pid,
@@ -647090,8 +647208,8 @@ Scoped workspace: ${scopedRoot}`,
         return join140(this.telegramToolButtonDir, `${safe}.json`);
       }
       writeTelegramToolButtonState(state) {
-        mkdirSync73(this.telegramToolButtonDir, { recursive: true });
-        writeFileSync66(this.telegramToolButtonPath(state.nonce), JSON.stringify(state, null, 2) + "\n", "utf-8");
+        mkdirSync74(this.telegramToolButtonDir, { recursive: true });
+        writeFileSync67(this.telegramToolButtonPath(state.nonce), JSON.stringify(state, null, 2) + "\n", "utf-8");
       }
       readTelegramToolButtonState(nonce) {
         try {
@@ -649214,9 +649332,9 @@ import {
   existsSync as existsSync128,
   readFileSync as readFileSync104,
   readdirSync as readdirSync47,
-  writeFileSync as writeFileSync67,
+  writeFileSync as writeFileSync68,
   renameSync as renameSync8,
-  mkdirSync as mkdirSync74,
+  mkdirSync as mkdirSync75,
   unlinkSync as unlinkSync28,
   appendFileSync as appendFileSync11
 } from "node:fs";
@@ -649235,20 +649353,20 @@ function inFlightPath(id) {
 }
 function persistSession(s2) {
   try {
-    mkdirSync74(sessionsDir(), { recursive: true });
+    mkdirSync75(sessionsDir(), { recursive: true });
     const final2 = sessionPath(s2.id);
     const tmp = `${final2}.tmp.${process.pid}.${Date.now()}`;
-    writeFileSync67(tmp, JSON.stringify(s2, null, 2), "utf-8");
+    writeFileSync68(tmp, JSON.stringify(s2, null, 2), "utf-8");
     renameSync8(tmp, final2);
   } catch {
   }
 }
 function persistInFlight(j) {
   try {
-    mkdirSync74(sessionsDir(), { recursive: true });
+    mkdirSync75(sessionsDir(), { recursive: true });
     const final2 = inFlightPath(j.sessionId);
     const tmp = `${final2}.tmp.${process.pid}.${Date.now()}`;
-    writeFileSync67(tmp, JSON.stringify(j, null, 2), "utf-8");
+    writeFileSync68(tmp, JSON.stringify(j, null, 2), "utf-8");
     renameSync8(tmp, final2);
   } catch {
   }
@@ -649280,7 +649398,7 @@ function loadPersistedSessions() {
               parsed.error = "Daemon restart while subprocess was running";
               parsed.completedAt = Date.now();
               try {
-                writeFileSync67(fp, JSON.stringify(parsed, null, 2), "utf-8");
+                writeFileSync68(fp, JSON.stringify(parsed, null, 2), "utf-8");
               } catch {
               }
               report2.staleInFlight++;
@@ -649463,7 +649581,7 @@ function checkinPath(sessionId) {
 }
 function appendCheckin(sessionId, steering) {
   try {
-    mkdirSync74(sessionsDir(), { recursive: true });
+    mkdirSync75(sessionsDir(), { recursive: true });
     const fp = checkinPath(sessionId);
     const entry = JSON.stringify({ ts: Date.now(), steering }) + "\n";
     appendFileSync11(fp, entry, "utf-8");
@@ -649861,7 +649979,7 @@ __export(projects_exports, {
   setCurrentProject: () => setCurrentProject,
   unregisterProject: () => unregisterProject
 });
-import { readFileSync as readFileSync105, writeFileSync as writeFileSync68, mkdirSync as mkdirSync75, existsSync as existsSync129, statSync as statSync47, renameSync as renameSync9 } from "node:fs";
+import { readFileSync as readFileSync105, writeFileSync as writeFileSync69, mkdirSync as mkdirSync76, existsSync as existsSync129, statSync as statSync47, renameSync as renameSync9 } from "node:fs";
 import { homedir as homedir46 } from "node:os";
 import { basename as basename36, join as join142, resolve as resolve54 } from "node:path";
 import { randomUUID as randomUUID15 } from "node:crypto";
@@ -649877,9 +649995,9 @@ function readAll2() {
   }
 }
 function writeAll(file) {
-  mkdirSync75(OMNIUS_DIR3, { recursive: true });
+  mkdirSync76(OMNIUS_DIR3, { recursive: true });
   const tmp = `${PROJECTS_FILE}.${randomUUID15().slice(0, 8)}.tmp`;
-  writeFileSync68(tmp, JSON.stringify(file, null, 2), "utf8");
+  writeFileSync69(tmp, JSON.stringify(file, null, 2), "utf8");
   renameSync9(tmp, PROJECTS_FILE);
 }
 function listProjects() {
@@ -649961,8 +650079,8 @@ function setCurrentProject(root) {
   if (!entry) return null;
   currentRoot = canonical;
   try {
-    mkdirSync75(OMNIUS_DIR3, { recursive: true });
-    writeFileSync68(CURRENT_FILE, `${canonical}
+    mkdirSync76(OMNIUS_DIR3, { recursive: true });
+    writeFileSync69(CURRENT_FILE, `${canonical}
 `, "utf8");
   } catch {
   }
@@ -650855,7 +650973,7 @@ var init_access_policy = __esm({
 
 // packages/cli/src/api/project-preferences.ts
 import { createHash as createHash34 } from "node:crypto";
-import { existsSync as existsSync130, mkdirSync as mkdirSync76, readFileSync as readFileSync106, renameSync as renameSync10, writeFileSync as writeFileSync69, unlinkSync as unlinkSync29 } from "node:fs";
+import { existsSync as existsSync130, mkdirSync as mkdirSync77, readFileSync as readFileSync106, renameSync as renameSync10, writeFileSync as writeFileSync70, unlinkSync as unlinkSync29 } from "node:fs";
 import { homedir as homedir47 } from "node:os";
 import { join as join143, resolve as resolve55 } from "node:path";
 import { randomUUID as randomUUID16 } from "node:crypto";
@@ -650874,11 +650992,11 @@ function rootSentinelPath(root) {
 }
 function ensureDir(root) {
   const dir = projectDir(root);
-  mkdirSync76(dir, { recursive: true });
+  mkdirSync77(dir, { recursive: true });
   const sentinel = rootSentinelPath(root);
   try {
     if (!existsSync130(sentinel)) {
-      writeFileSync69(sentinel, `${resolve55(root)}
+      writeFileSync70(sentinel, `${resolve55(root)}
 `, "utf8");
     }
   } catch {
@@ -650907,12 +651025,12 @@ function writeProjectPreferences(root, partial) {
   };
   const file = prefsPath(root);
   const tmp = `${file}.${randomUUID16().slice(0, 8)}.tmp`;
-  writeFileSync69(tmp, JSON.stringify(merged, null, 2), "utf8");
+  writeFileSync70(tmp, JSON.stringify(merged, null, 2), "utf8");
   try {
     renameSync10(tmp, file);
   } catch (err) {
     try {
-      writeFileSync69(file, JSON.stringify(merged, null, 2), "utf8");
+      writeFileSync70(file, JSON.stringify(merged, null, 2), "utf8");
     } catch {
     }
     try {
@@ -651839,13 +651957,13 @@ __export(audit_log_exports, {
   recordAudit: () => recordAudit,
   sanitizeBody: () => sanitizeBody
 });
-import { mkdirSync as mkdirSync77, appendFileSync as appendFileSync12, readFileSync as readFileSync107, existsSync as existsSync131 } from "node:fs";
+import { mkdirSync as mkdirSync78, appendFileSync as appendFileSync12, readFileSync as readFileSync107, existsSync as existsSync131 } from "node:fs";
 import { join as join144 } from "node:path";
 function initAuditLog(omniusDir) {
   auditDir = join144(omniusDir, "audit");
   auditFile = join144(auditDir, "audit.jsonl");
   try {
-    mkdirSync77(auditDir, { recursive: true });
+    mkdirSync78(auditDir, { recursive: true });
     initialized = true;
   } catch {
   }
@@ -651913,7 +652031,7 @@ var init_audit_log = __esm({
 
 // packages/cli/src/api/disk-task-output.ts
 import { open } from "node:fs/promises";
-import { existsSync as existsSync132, mkdirSync as mkdirSync78, statSync as statSync48 } from "node:fs";
+import { existsSync as existsSync132, mkdirSync as mkdirSync79, statSync as statSync48 } from "node:fs";
 import { dirname as dirname41 } from "node:path";
 import * as fsConstants from "node:constants";
 var O_NOFOLLOW2, O_APPEND2, O_CREAT2, O_WRONLY2, OPEN_FLAGS_WRITE, OPEN_MODE, DiskTaskOutput;
@@ -651933,7 +652051,7 @@ var init_disk_task_output = __esm({
       fileSize = 0;
       constructor(outputPath3) {
         this.path = outputPath3;
-        mkdirSync78(dirname41(outputPath3), { recursive: true });
+        mkdirSync79(dirname41(outputPath3), { recursive: true });
       }
       /** Queue content for async append. Non-blocking. */
       append(chunk) {
@@ -653103,13 +653221,13 @@ __export(runtime_keys_exports, {
   mintKey: () => mintKey,
   revokeByPrefix: () => revokeByPrefix
 });
-import { existsSync as existsSync134, readFileSync as readFileSync109, writeFileSync as writeFileSync70, mkdirSync as mkdirSync79, chmodSync as chmodSync3 } from "node:fs";
+import { existsSync as existsSync134, readFileSync as readFileSync109, writeFileSync as writeFileSync71, mkdirSync as mkdirSync80, chmodSync as chmodSync3 } from "node:fs";
 import { join as join146 } from "node:path";
 import { homedir as homedir49 } from "node:os";
 import { randomBytes as randomBytes26 } from "node:crypto";
 function ensureDir2() {
   const dir = join146(homedir49(), ".omnius");
-  if (!existsSync134(dir)) mkdirSync79(dir, { recursive: true });
+  if (!existsSync134(dir)) mkdirSync80(dir, { recursive: true });
 }
 function loadAll() {
   if (!existsSync134(KEYS_FILE)) return [];
@@ -653124,7 +653242,7 @@ function loadAll() {
 }
 function persistAll(records) {
   ensureDir2();
-  writeFileSync70(KEYS_FILE, JSON.stringify(records, null, 2), "utf-8");
+  writeFileSync71(KEYS_FILE, JSON.stringify(records, null, 2), "utf-8");
   try {
     chmodSync3(KEYS_FILE, 384);
   } catch {
@@ -653358,7 +653476,7 @@ __export(graphical_sudo_exports, {
   runGraphicalSudo: () => runGraphicalSudo
 });
 import { spawn as spawn29 } from "node:child_process";
-import { existsSync as existsSync136, mkdirSync as mkdirSync80, writeFileSync as writeFileSync71, chmodSync as chmodSync4 } from "node:fs";
+import { existsSync as existsSync136, mkdirSync as mkdirSync81, writeFileSync as writeFileSync72, chmodSync as chmodSync4 } from "node:fs";
 import { join as join148 } from "node:path";
 import { tmpdir as tmpdir21 } from "node:os";
 function detectSudoHelper() {
@@ -653382,7 +653500,7 @@ function which2(cmd) {
 }
 function ensureAskpassShim(helper, description) {
   const shimDir = join148(tmpdir21(), "omnius-askpass");
-  mkdirSync80(shimDir, { recursive: true });
+  mkdirSync81(shimDir, { recursive: true });
   const shim = join148(shimDir, `${helper}.sh`);
   let body;
   if (helper === "zenity") {
@@ -653394,7 +653512,7 @@ exec zenity --password --title="Omnius needs sudo" --text="${description.replace
 exec kdialog --password "${description.replace(/"/g, '\\"')}" 2>/dev/null
 `;
   }
-  writeFileSync71(shim, body, "utf-8");
+  writeFileSync72(shim, body, "utf-8");
   chmodSync4(shim, 493);
   return shim;
 }
@@ -656090,8 +656208,8 @@ function readAimsFile(name10, fallback) {
 }
 function writeAimsFile(name10, data) {
   const dir = aimsDir();
-  const { mkdirSync: mkdirSync88, writeFileSync: wf, renameSync: rn } = __require("node:fs");
-  mkdirSync88(dir, { recursive: true });
+  const { mkdirSync: mkdirSync89, writeFileSync: wf, renameSync: rn } = __require("node:fs");
+  mkdirSync89(dir, { recursive: true });
   const finalPath = join149(dir, name10);
   const tmpPath = `${finalPath}.tmp.${process.pid}.${Date.now()}`;
   try {
@@ -665931,11 +666049,11 @@ var init_auth_oidc = __esm({
 });
 
 // packages/cli/src/api/usage-tracker.ts
-import { mkdirSync as mkdirSync81, readFileSync as readFileSync112, writeFileSync as writeFileSync72, existsSync as existsSync138 } from "node:fs";
+import { mkdirSync as mkdirSync82, readFileSync as readFileSync112, writeFileSync as writeFileSync73, existsSync as existsSync138 } from "node:fs";
 import { join as join150 } from "node:path";
 function initUsageTracker(omniusDir) {
   const dir = join150(omniusDir, "usage");
-  mkdirSync81(dir, { recursive: true });
+  mkdirSync82(dir, { recursive: true });
   usageFile = join150(dir, "token-usage.json");
   try {
     if (existsSync138(usageFile)) {
@@ -665975,7 +666093,7 @@ function flush2() {
   if (!initialized2 || !dirty) return;
   try {
     store.lastSaved = (/* @__PURE__ */ new Date()).toISOString();
-    writeFileSync72(usageFile, JSON.stringify(store, null, 2), "utf-8");
+    writeFileSync73(usageFile, JSON.stringify(store, null, 2), "utf-8");
     dirty = false;
   } catch {
   }
@@ -666004,7 +666122,7 @@ var init_usage_tracker = __esm({
 
 // packages/cli/src/docker.ts
 import { execSync as execSync58, spawn as spawn30 } from "node:child_process";
-import { existsSync as existsSync139, mkdirSync as mkdirSync82, writeFileSync as writeFileSync73 } from "node:fs";
+import { existsSync as existsSync139, mkdirSync as mkdirSync83, writeFileSync as writeFileSync74 } from "node:fs";
 import { join as join151, resolve as resolve56, dirname as dirname42 } from "node:path";
 import { homedir as homedir52 } from "node:os";
 import { fileURLToPath as fileURLToPath18 } from "node:url";
@@ -666155,7 +666273,7 @@ async function ensureOmniusImage(force = false) {
     buildContext = dockerDir;
   } else {
     buildContext = join151(homedir52(), ".omnius", "docker-build");
-    mkdirSync82(buildContext, { recursive: true });
+    mkdirSync83(buildContext, { recursive: true });
     writeDockerfiles(buildContext);
   }
   try {
@@ -666229,8 +666347,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 "$@"
 `;
-  writeFileSync73(join151(dir, "Dockerfile"), dockerfile);
-  writeFileSync73(join151(dir, "docker-entrypoint.sh"), entrypoint, { mode: 493 });
+  writeFileSync74(join151(dir, "Dockerfile"), dockerfile);
+  writeFileSync74(join151(dir, "docker-entrypoint.sh"), entrypoint, { mode: 493 });
 }
 function hasNvidiaGpu() {
   try {
@@ -666488,7 +666606,7 @@ import { fileURLToPath as fileURLToPath19 } from "node:url";
 import { dirname as dirname43, join as join153, resolve as resolve57 } from "node:path";
 import { homedir as homedir53 } from "node:os";
 import { spawn as spawn31, execSync as execSync59 } from "node:child_process";
-import { mkdirSync as mkdirSync83, writeFileSync as writeFileSync74, readFileSync as readFileSync113, readdirSync as readdirSync50, existsSync as existsSync140, watch as fsWatch4, renameSync as renameSync11, unlinkSync as unlinkSync30, statSync as statSync51, openSync as openSync4, readSync as readSync2, closeSync as closeSync4 } from "node:fs";
+import { mkdirSync as mkdirSync84, writeFileSync as writeFileSync75, readFileSync as readFileSync113, readdirSync as readdirSync50, existsSync as existsSync140, watch as fsWatch4, renameSync as renameSync11, unlinkSync as unlinkSync30, statSync as statSync51, openSync as openSync4, readSync as readSync2, closeSync as closeSync4 } from "node:fs";
 import { randomBytes as randomBytes27, randomUUID as randomUUID17 } from "node:crypto";
 import { createHash as createHash36 } from "node:crypto";
 function memoryDbPaths3(baseDir = process.cwd()) {
@@ -667468,7 +667586,7 @@ function ollamaStream(ollamaUrl, path12, method, body, onData, onEnd, onError, t
 function jobsDir() {
   const root = resolve57(process.cwd());
   const dir = join153(root, ".omnius", "jobs");
-  mkdirSync83(dir, { recursive: true });
+  mkdirSync84(dir, { recursive: true });
   return dir;
 }
 function loadJob(id) {
@@ -667813,11 +667931,11 @@ function atomicJobWrite(dir, id, job) {
   const finalPath = join153(dir, `${id}.json`);
   const tmpPath = `${finalPath}.tmp.${process.pid}.${Date.now()}`;
   try {
-    writeFileSync74(tmpPath, JSON.stringify(job, null, 2), "utf-8");
+    writeFileSync75(tmpPath, JSON.stringify(job, null, 2), "utf-8");
     renameSync11(tmpPath, finalPath);
   } catch {
     try {
-      writeFileSync74(finalPath, JSON.stringify(job, null, 2), "utf-8");
+      writeFileSync75(finalPath, JSON.stringify(job, null, 2), "utf-8");
     } catch {
     }
     try {
@@ -669353,10 +669471,10 @@ function readUpdateState() {
 function writeUpdateState(state) {
   try {
     const dir = join153(homedir53(), ".omnius");
-    mkdirSync83(dir, { recursive: true });
+    mkdirSync84(dir, { recursive: true });
     const finalPath = updateStateFile();
     const tmpPath = `${finalPath}.tmp.${process.pid}`;
-    writeFileSync74(tmpPath, JSON.stringify(state, null, 2), "utf-8");
+    writeFileSync75(tmpPath, JSON.stringify(state, null, 2), "utf-8");
     renameSync11(tmpPath, finalPath);
   } catch {
   }
@@ -669665,7 +669783,7 @@ async function handleV1Run(req2, res) {
     cwd4 = resolve57(workingDir);
   } else if (isolate) {
     const wsDir = join153(dir, "..", "workspaces", id);
-    mkdirSync83(wsDir, { recursive: true });
+    mkdirSync84(wsDir, { recursive: true });
     cwd4 = wsDir;
   } else {
     cwd4 = resolve57(process.cwd());
@@ -671137,10 +671255,10 @@ async function handleRequest(req2, res, ollamaUrl, verbose, runtimeDefaults = {}
           return;
         }
         const { tmpdir: tmpdir23 } = await import("node:os");
-        const { writeFileSync: writeFileSync79, unlinkSync: unlinkSync31 } = await import("node:fs");
+        const { writeFileSync: writeFileSync80, unlinkSync: unlinkSync31 } = await import("node:fs");
         const { join: pjoin } = await import("node:path");
         const tmpPath = pjoin(tmpdir23(), `omnius-clone-upload-${Date.now()}-${safeName3}`);
-        writeFileSync79(tmpPath, buf);
+        writeFileSync80(tmpPath, buf);
         try {
           const ve = getVoiceEngine();
           const msg = await ve.setCloneVoice(tmpPath);
@@ -671732,7 +671850,7 @@ data: ${JSON.stringify(data)}
         }
         for (const f2 of seenFiles) {
           try {
-            writeFileSync74(f2, JSON.stringify({ tasks: [] }, null, 2));
+            writeFileSync75(f2, JSON.stringify({ tasks: [] }, null, 2));
             deleted++;
           } catch {
           }
@@ -672952,11 +673070,11 @@ function setScheduledEnabled(id, enabled2) {
     arr[target.index].enabled = enabled2;
     if (Array.isArray(json?.tasks)) {
       json.tasks = arr;
-      writeFileSync74(target.file, JSON.stringify(json, null, 2));
+      writeFileSync75(target.file, JSON.stringify(json, null, 2));
     } else if (Array.isArray(json)) {
-      writeFileSync74(target.file, JSON.stringify(arr, null, 2));
+      writeFileSync75(target.file, JSON.stringify(arr, null, 2));
     } else {
-      writeFileSync74(target.file, JSON.stringify({ tasks: arr }, null, 2));
+      writeFileSync75(target.file, JSON.stringify({ tasks: arr }, null, 2));
     }
     if (!enabled2) {
       try {
@@ -672986,11 +673104,11 @@ function deleteScheduledById(id) {
     arr.splice(target.index, 1);
     if (Array.isArray(json?.tasks)) {
       json.tasks = arr;
-      writeFileSync74(target.file, JSON.stringify(json, null, 2));
+      writeFileSync75(target.file, JSON.stringify(json, null, 2));
     } else if (Array.isArray(json)) {
-      writeFileSync74(target.file, JSON.stringify(arr, null, 2));
+      writeFileSync75(target.file, JSON.stringify(arr, null, 2));
     } else {
-      writeFileSync74(target.file, JSON.stringify({ tasks: arr }, null, 2));
+      writeFileSync75(target.file, JSON.stringify({ tasks: arr }, null, 2));
     }
     const candidates = [];
     if (id) candidates.push(id);
@@ -673258,9 +673376,9 @@ function reconcileScheduledTasks(apply) {
           const entry = { task: f2.task || `legacy ${f2.id}`, schedule: f2.cron, enabled: true };
           arr.push(entry);
           const toWrite = Array.isArray(json?.tasks) ? { ...json, tasks: arr } : Array.isArray(json) ? arr : { tasks: arr };
-          mkdirSync83(join153(wdir, ".omnius", "scheduled"), { recursive: true });
-          mkdirSync83(join153(wdir, ".omnius", "scheduled", "logs"), { recursive: true });
-          writeFileSync74(file, JSON.stringify(toWrite, null, 2));
+          mkdirSync84(join153(wdir, ".omnius", "scheduled"), { recursive: true });
+          mkdirSync84(join153(wdir, ".omnius", "scheduled", "logs"), { recursive: true });
+          writeFileSync75(file, JSON.stringify(toWrite, null, 2));
           adopted.push({ file, index: arr.length - 1 });
         }
       } else {
@@ -673393,9 +673511,9 @@ Persistent=true
 WantedBy=timers.target
 `;
         if (!dryRun) {
-          mkdirSync83(unitDir, { recursive: true });
-          writeFileSync74(svc, svcText);
-          writeFileSync74(tim, timText);
+          mkdirSync84(unitDir, { recursive: true });
+          writeFileSync75(svc, svcText);
+          writeFileSync75(tim, timText);
           try {
             const { execSync: es } = require4("node:child_process");
             es("systemctl --user daemon-reload", { stdio: "pipe" });
@@ -673539,7 +673657,7 @@ function startApiServer(options2 = {}) {
   if (!apiTestMode) try {
     const dir = todoDir();
     try {
-      mkdirSync83(dir, { recursive: true });
+      mkdirSync84(dir, { recursive: true });
     } catch {
     }
     const cache8 = /* @__PURE__ */ new Map();
@@ -673717,8 +673835,8 @@ function startApiServer(options2 = {}) {
             runtimeAccessMode = requested;
             try {
               const dir = join153(homedir53(), ".omnius");
-              mkdirSync83(dir, { recursive: true });
-              writeFileSync74(join153(dir, "access"), `${runtimeAccessMode}
+              mkdirSync84(dir, { recursive: true });
+              writeFileSync75(join153(dir, "access"), `${runtimeAccessMode}
 `, "utf8");
             } catch {
             }
@@ -674023,7 +674141,7 @@ function startApiServer(options2 = {}) {
       return;
     }
     try {
-      const { writeFileSync: writeFileSync79, mkdirSync: mkdirSync88, existsSync: _exists, readFileSync: _rfs } = require4("node:fs");
+      const { writeFileSync: writeFileSync80, mkdirSync: mkdirSync89, existsSync: _exists, readFileSync: _rfs } = require4("node:fs");
       const { join: _join } = require4("node:path");
       const { homedir: _homedir } = require4("node:os");
       const apiHint = JSON.stringify({
@@ -674052,8 +674170,8 @@ function startApiServer(options2 = {}) {
       let written = 0;
       for (const dir of dirSet) {
         try {
-          if (!_exists(dir)) mkdirSync88(dir, { recursive: true });
-          writeFileSync79(_join(dir, "api-port.json"), apiHint);
+          if (!_exists(dir)) mkdirSync89(dir, { recursive: true });
+          writeFileSync80(_join(dir, "api-port.json"), apiHint);
           written++;
         } catch {
         }
@@ -674338,9 +674456,9 @@ async function handleChatAttachmentUpload(req2, res) {
     }
     const safeName3 = filename.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 180) || `attachment-${Date.now()}.bin`;
     const dir = join153(process.cwd(), ".omnius", "gui-attachments");
-    mkdirSync83(dir, { recursive: true });
+    mkdirSync84(dir, { recursive: true });
     const localPath = join153(dir, `${Date.now()}-${randomUUID17().slice(0, 8)}-${safeName3}`);
-    writeFileSync74(localPath, Buffer.from(base642, "base64"));
+    writeFileSync75(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;
@@ -674711,15 +674829,15 @@ __export(clipboard_media_exports, {
   pasteClipboardImageToFile: () => pasteClipboardImageToFile
 });
 import { execFileSync as execFileSync9, execSync as execSync60 } from "node:child_process";
-import { mkdirSync as mkdirSync84, readFileSync as readFileSync114, rmSync as rmSync8, writeFileSync as writeFileSync75 } from "node:fs";
+import { mkdirSync as mkdirSync85, readFileSync as readFileSync114, rmSync as rmSync9, writeFileSync as writeFileSync76 } from "node:fs";
 import { join as join154 } from "node:path";
 function pasteClipboardImageToFile(repoRoot) {
   const image = readClipboardImage();
   if (!image) return null;
   const dir = join154(repoRoot, ".omnius", "clipboard");
-  mkdirSync84(dir, { recursive: true });
+  mkdirSync85(dir, { recursive: true });
   const path12 = join154(dir, `clipboard-${Date.now()}${image.ext}`);
-  writeFileSync75(path12, image.buffer);
+  writeFileSync76(path12, image.buffer);
   return { path: path12, buffer: image.buffer, mime: image.mime };
 }
 function readClipboardImage() {
@@ -674730,7 +674848,7 @@ function readClipboardImage() {
       execFileSync9("pngpaste", [tmp], { timeout: 3e3 });
       const buffer2 = readFileSync114(tmp);
       try {
-        rmSync8(tmp);
+        rmSync9(tmp);
       } catch {
       }
       if (buffer2.length > 0) return { buffer: buffer2, mime: "image/png", ext: ".png" };
@@ -674788,11 +674906,11 @@ import { createRequire as createRequire8 } from "node:module";
 import { fileURLToPath as fileURLToPath20 } from "node:url";
 import {
   readFileSync as readFileSync115,
-  writeFileSync as writeFileSync76,
+  writeFileSync as writeFileSync77,
   appendFileSync as appendFileSync13,
-  rmSync as rmSync9,
+  rmSync as rmSync10,
   readdirSync as readdirSync51,
-  mkdirSync as mkdirSync85
+  mkdirSync as mkdirSync86
 } from "node:fs";
 import { existsSync as existsSync141 } from "node:fs";
 import { execSync as execSync61 } from "node:child_process";
@@ -677826,7 +677944,7 @@ When done, either call task_complete with your answer, or use FINAL_VAR(variable
           if (existsSync141(ikFile)) {
             ikState = JSON.parse(readFileSync115(ikFile, "utf8"));
           } else {
-            mkdirSync85(ikDir, { recursive: true });
+            mkdirSync86(ikDir, { recursive: true });
             const machineId = Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
             ikState = {
               self_id: `omnius-${machineId}`,
@@ -677936,7 +678054,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();
-          writeFileSync76(ikFile, JSON.stringify(ikState, null, 2));
+          writeFileSync77(ikFile, JSON.stringify(ikState, null, 2));
         } catch (ikErr) {
           try {
             console.error("[IK-OBSERVE]", ikErr);
@@ -677992,7 +678110,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();
-            writeFileSync76(ikFile, JSON.stringify(ikState, null, 2));
+            writeFileSync77(ikFile, JSON.stringify(ikState, null, 2));
           }
         } catch {
         }
@@ -679566,12 +679684,12 @@ This is an independent background session started from /background.`
   function persistHistoryLine(line) {
     if (!line.trim()) return;
     try {
-      mkdirSync85(HISTORY_DIR, { recursive: true });
+      mkdirSync86(HISTORY_DIR, { recursive: true });
       appendFileSync13(HISTORY_FILE, line + "\n", "utf8");
       if (Math.random() < 0.02) {
         const all2 = readFileSync115(HISTORY_FILE, "utf8").trim().split("\n");
         if (all2.length > MAX_HISTORY_LINES) {
-          writeFileSync76(
+          writeFileSync77(
             HISTORY_FILE,
             all2.slice(-MAX_HISTORY_LINES).join("\n") + "\n",
             "utf8"
@@ -680474,8 +680592,8 @@ Log: ${nexusLogPath}`)
     setSessionTitle(title) {
       sessionTitle = title.trim() || null;
       try {
-        mkdirSync85(join155(repoRoot, ".omnius"), { recursive: true });
-        writeFileSync76(join155(repoRoot, ".omnius", "session-title"), `${sessionTitle ?? ""}
+        mkdirSync86(join155(repoRoot, ".omnius"), { recursive: true });
+        writeFileSync77(join155(repoRoot, ".omnius", "session-title"), `${sessionTitle ?? ""}
 `, "utf8");
       } catch {
       }
@@ -682265,7 +682383,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         let deleted = false;
         for (let attempt = 0; attempt < 3; attempt++) {
           try {
-            rmSync9(omniusPath, { recursive: true, force: true });
+            rmSync10(omniusPath, { recursive: true, force: true });
             deleted = true;
             break;
           } catch (err) {
@@ -683676,7 +683794,7 @@ async function runWithTUI(task, config, repoPath2, callbacks) {
       if (existsSync141(ikFile)) {
         ikState = JSON.parse(readFileSync115(ikFile, "utf8"));
       } else {
-        mkdirSync85(ikDir, { recursive: true });
+        mkdirSync86(ikDir, { recursive: true });
         ikState = {
           self_id: `omnius-${Date.now().toString(36)}`,
           version: 1,
@@ -683729,7 +683847,7 @@ async function runWithTUI(task, config, repoPath2, callbacks) {
       );
       ikState.session_count = (ikState.session_count || 0) + 1;
       ikState.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-      writeFileSync76(ikFile, JSON.stringify(ikState, null, 2));
+      writeFileSync77(ikFile, JSON.stringify(ikState, null, 2));
     } catch (ikErr) {
     }
     try {
@@ -683761,8 +683879,8 @@ async function runWithTUI(task, config, repoPath2, callbacks) {
           tags: ["general"]
         });
         if (variants.length > 50) variants = variants.slice(-50);
-        mkdirSync85(archeDir, { recursive: true });
-        writeFileSync76(archeFile, JSON.stringify(variants, null, 2));
+        mkdirSync86(archeDir, { recursive: true });
+        writeFileSync77(archeFile, JSON.stringify(variants, null, 2));
       } catch {
       }
     }
@@ -683793,7 +683911,7 @@ async function runWithTUI(task, config, repoPath2, callbacks) {
           updated = true;
         }
         if (updated) {
-          writeFileSync76(metaFile2, JSON.stringify(store2, null, 2));
+          writeFileSync77(metaFile2, JSON.stringify(store2, null, 2));
         }
       }
     } catch {
@@ -683852,7 +683970,7 @@ Rules:
             const { initDb: initDb2 } = __require("@omnius/memory");
             const { ProceduralMemoryStore: ProceduralMemoryStore2 } = __require("@omnius/memory");
             const dbDir = join155(repoRoot, ".omnius", "memory");
-            mkdirSync85(dbDir, { recursive: true });
+            mkdirSync86(dbDir, { recursive: true });
             const db = initDb2(join155(dbDir, "structured.db"));
             const memStore = new ProceduralMemoryStore2(db);
             memStore.createWithEmbedding(
@@ -683901,8 +684019,8 @@ Rules:
             accessCount: 0
           });
           if (store2.length > 100) store2 = store2.slice(-100);
-          mkdirSync85(metaDir, { recursive: true });
-          writeFileSync76(storeFile, JSON.stringify(store2, null, 2));
+          mkdirSync86(metaDir, { recursive: true });
+          writeFileSync77(storeFile, JSON.stringify(store2, null, 2));
         }
       }
     } catch {
@@ -683966,7 +684084,7 @@ Rules:
         );
         ikState.session_count = (ikState.session_count || 0) + 1;
         ikState.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-        writeFileSync76(ikFile, JSON.stringify(ikState, null, 2));
+        writeFileSync77(ikFile, JSON.stringify(ikState, null, 2));
       }
       const metaFile2 = join155(
         repoRoot,
@@ -683994,7 +684112,7 @@ Rules:
             (item.scores.confidence || 0.5) - 0.02
           );
         }
-        writeFileSync76(metaFile2, JSON.stringify(store2, null, 2));
+        writeFileSync77(metaFile2, JSON.stringify(store2, null, 2));
       }
       try {
         const archeDir = join155(repoRoot, ".omnius", "arche");
@@ -684016,8 +684134,8 @@ Rules:
           tags: ["general"]
         });
         if (variants.length > 50) variants = variants.slice(-50);
-        mkdirSync85(archeDir, { recursive: true });
-        writeFileSync76(archeFile, JSON.stringify(variants, null, 2));
+        mkdirSync86(archeDir, { recursive: true });
+        writeFileSync77(archeFile, JSON.stringify(variants, null, 2));
       } catch {
       }
     } catch {
@@ -684123,13 +684241,13 @@ __export(run_exports, {
 });
 import { resolve as resolve59 } from "node:path";
 import { spawn as spawn32 } from "node:child_process";
-import { mkdirSync as mkdirSync86, writeFileSync as writeFileSync77, readFileSync as readFileSync116, readdirSync as readdirSync52, existsSync as existsSync142 } from "node:fs";
+import { mkdirSync as mkdirSync87, writeFileSync as writeFileSync78, readFileSync as readFileSync116, readdirSync as readdirSync52, existsSync as existsSync142 } from "node:fs";
 import { randomBytes as randomBytes28 } from "node:crypto";
 import { join as join156 } from "node:path";
 function jobsDir2(repoPath2) {
   const root = resolve59(repoPath2 ?? process.cwd());
   const dir = join156(root, ".omnius", "jobs");
-  mkdirSync86(dir, { recursive: true });
+  mkdirSync87(dir, { recursive: true });
   return dir;
 }
 async function runCommand2(opts, config) {
@@ -684251,7 +684369,7 @@ async function runBackground(task, config, opts) {
     }
   });
   job.pid = child.pid ?? 0;
-  writeFileSync77(join156(dir, `${id}.json`), JSON.stringify(job, null, 2));
+  writeFileSync78(join156(dir, `${id}.json`), JSON.stringify(job, null, 2));
   let output = "";
   child.stdout?.on("data", (chunk) => {
     output += chunk.toString();
@@ -684267,7 +684385,7 @@ async function runBackground(task, config, opts) {
       job.summary = result.summary;
       job.durationMs = result.durationMs;
       job.error = result.error;
-      writeFileSync77(join156(dir, `${id}.json`), JSON.stringify(job, null, 2));
+      writeFileSync78(join156(dir, `${id}.json`), JSON.stringify(job, null, 2));
     } catch {
     }
   });
@@ -684902,7 +685020,7 @@ __export(eval_exports, {
   evalCommand: () => evalCommand
 });
 import { tmpdir as tmpdir22 } from "node:os";
-import { mkdirSync as mkdirSync87, writeFileSync as writeFileSync78 } from "node:fs";
+import { mkdirSync as mkdirSync88, writeFileSync as writeFileSync79 } from "node:fs";
 import { join as join158 } from "node:path";
 async function evalCommand(opts, config) {
   const suiteName = opts.suite ?? "basic";
@@ -685033,8 +685151,8 @@ async function evalCommand(opts, config) {
 }
 function createTempEvalRepo() {
   const dir = join158(tmpdir22(), `omnius-eval-${Date.now()}`);
-  mkdirSync87(dir, { recursive: true });
-  writeFileSync78(
+  mkdirSync88(dir, { recursive: true });
+  writeFileSync79(
     join158(dir, "package.json"),
     JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n",
     "utf8"
@@ -685561,11 +685679,11 @@ function crashLog(label, err) {
   const logLine = `[${timestamp}] ${label}: ${msg}
 `;
   try {
-    const { appendFileSync: appendFileSync14, mkdirSync: mkdirSync88 } = __require("node:fs");
+    const { appendFileSync: appendFileSync14, mkdirSync: mkdirSync89 } = __require("node:fs");
     const { join: join160 } = __require("node:path");
     const { homedir: homedir56 } = __require("node:os");
     const logDir = join160(homedir56(), ".omnius");
-    mkdirSync88(logDir, { recursive: true });
+    mkdirSync89(logDir, { recursive: true });
     appendFileSync14(join160(logDir, "crash.log"), logLine);
   } catch {
   }