omnius 1.0.160 → 1.0.161

package/dist/index.js

@@ -9624,14 +9624,17 @@ var init_list_directory = __esm({
           const fullPath = resolve11(this.workingDir, dirPath);
           const entries = readdirSync5(fullPath, { withFileTypes: true });
           const visible = entries.filter((e2) => !EXCLUDED.has(e2.name));
-          const limited = visible.slice(0, MAX_ENTRIES);
+          const collapsed = this.collapseGeneratedContextEntries(visible, fullPath, dirPath);
+          const limited = collapsed.entries.slice(0, MAX_ENTRIES);
           const dirs = [];
           const files = [];
-          const lines = limited.map((entry) => {
+          const lines = [...collapsed.syntheticLines];
+          for (const entry of limited) {
             const relPath = dirPath === "." ? entry.name : join17(dirPath, entry.name);
             if (entry.isDirectory()) {
               dirs.push(relPath);
-              return `d  ${relPath}/`;
+              lines.push(`d  ${relPath}/`);
+              continue;
             }
             let size = 0;
             try {
@@ -9639,8 +9642,8 @@ var init_list_directory = __esm({
             } catch {
             }
             files.push(relPath);
-            return `f  ${relPath}  ${size}`;
-          });
+            lines.push(`f  ${relPath}  ${size}`);
+          }
           if (dirs.length > 0 || files.length > 0) {
             lines.push("");
             lines.push("Next steps — use these exact paths:");
@@ -9673,6 +9676,31 @@ var init_list_directory = __esm({
           };
         }
       }
+      collapseGeneratedContextEntries(entries, fullPath, dirPath) {
+        const normalized = dirPath.replace(/\\/g, "/").replace(/\/+$/, "");
+        if (normalized !== ".omnius/context" && normalized !== ".omnius/context/kg-summary") {
+          return { entries, syntheticLines: [] };
+        }
+        const kgSummaries = entries.filter((entry) => entry.isFile() && entry.name.startsWith("kg-summary-") && entry.name.endsWith(".md"));
+        if (kgSummaries.length <= 8) {
+          return { entries, syntheticLines: [] };
+        }
+        let totalBytes = 0;
+        for (const entry of kgSummaries) {
+          try {
+            totalBytes += statSync6(join17(fullPath, entry.name)).size;
+          } catch {
+          }
+        }
+        const latest = [...kgSummaries].sort((a2, b) => a2.name.localeCompare(b.name)).at(-1)?.name;
+        const latestPath = normalized === ".omnius/context/kg-summary" ? join17(dirPath, "latest.md") : latest ? join17(dirPath, latest) : join17(dirPath, "kg-summary-latest.md");
+        const remaining = entries.filter((entry) => !kgSummaries.includes(entry));
+        const syntheticLines = [
+          `g  ${dirPath}/kg-summary-*.md  ${kgSummaries.length} generated summaries collapsed, ${totalBytes} bytes`,
+          `   latest generated summary: file_read("${latestPath}")`
+        ];
+        return { entries: remaining, syntheticLines };
+      }
     };
   }
 });
@@ -21439,6 +21467,14 @@ var init_skill_tools = __esm({
           source: {
             type: "string",
             description: "Optional source filter (e.g. 'framework:sdlc-complete', 'addon:ralph', 'project', 'local')"
+          },
+          limit: {
+            type: "number",
+            description: "Maximum skills to list. Defaults to 30. Ignored when all=true."
+          },
+          all: {
+            type: "boolean",
+            description: "Return every matching skill instead of the default compressed top 30."
           }
         },
         required: []
@@ -21452,6 +21488,9 @@ var init_skill_tools = __esm({
         const filterRaw = args["filter"] ?? args["pattern"] ?? args["query"] ?? args["search"] ?? "";
         const filter2 = typeof filterRaw === "string" ? filterRaw.toLowerCase() : "";
         const sourceFilter = typeof args["source"] === "string" ? args["source"] : "";
+        const showAll = args["all"] === true;
+        const limitRaw = typeof args["limit"] === "number" ? args["limit"] : 30;
+        const limit = showAll ? Number.POSITIVE_INFINITY : Math.max(1, Math.min(200, Math.floor(limitRaw)));
         let skills = discoverSkills(this.repoRoot);
         if (filter2) {
           skills = skills.filter((s2) => s2.name.toLowerCase().includes(filter2) || s2.description.toLowerCase().includes(filter2) || s2.triggers.some((t2) => t2.toLowerCase().includes(filter2)));
@@ -21466,9 +21505,14 @@ var init_skill_tools = __esm({
             durationMs: performance.now() - start2
           };
         }
-        const lines = [`Found ${skills.length} skills:
-`];
-        for (const s2 of skills) {
+        const total = skills.length;
+        const listed = skills.slice(0, limit);
+        const lines = [
+          showAll || listed.length === total ? `Found ${total} skills:
+` : `Found ${total} skills. Showing ${listed.length}; pass {"all": true} or a narrower filter to expand.
+`
+        ];
+        for (const s2 of listed) {
           lines.push(`  ${s2.name}`);
           lines.push(`    ${s2.description}`);
           if (s2.triggers.length > 0) {
@@ -21480,6 +21524,10 @@ var init_skill_tools = __esm({
           }
           lines.push("");
         }
+        if (!showAll && listed.length < total) {
+          lines.push(`... ${total - listed.length} more skills omitted by default context budget.`);
+          lines.push(`Use skill_list with a filter/source, limit, or all=true when those omitted skills are actually needed.`);
+        }
         return {
           success: true,
           output: lines.join("\n"),
@@ -254257,9 +254305,9 @@ print("${sentinel}")
         if (!this.proc || this.proc.killed) {
           return { success: false, path: "" };
         }
-        const { mkdirSync: mkdirSync84, writeFileSync: writeFileSync76 } = await import("node:fs");
+        const { mkdirSync: mkdirSync85, writeFileSync: writeFileSync77 } = await import("node:fs");
         const sessionDir2 = join33(this.cwd, ".omnius", "rlm");
-        mkdirSync84(sessionDir2, { recursive: true });
+        mkdirSync85(sessionDir2, { recursive: true });
         const sessionPath2 = join33(sessionDir2, "session.json");
         try {
           const inspectCode = `
@@ -254283,7 +254331,7 @@ print("__SESSION__" + json.dumps(_session) + "__SESSION__")
               trajectoryCount: this.trajectory.length,
               subCallCount: this.subCallCount
             };
-            writeFileSync76(sessionPath2, JSON.stringify(sessionData, null, 2), "utf8");
+            writeFileSync77(sessionPath2, JSON.stringify(sessionData, null, 2), "utf8");
             return { success: true, path: sessionPath2 };
           }
         } catch {
@@ -254892,7 +254940,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: readFileSync113, writeFileSync: writeFileSync76, existsSync: existsSync138, mkdirSync: mkdirSync84 } = __require("node:fs");
+        const { readFileSync: readFileSync113, writeFileSync: writeFileSync77, existsSync: existsSync138, mkdirSync: mkdirSync85 } = __require("node:fs");
         const metaDir = join34(this.cwd, ".omnius", "memory", "metabolism");
         const storeFile = join34(metaDir, "store.json");
         if (!existsSync138(storeFile))
@@ -254923,8 +254971,8 @@ ${issues.map((i2) => `  - ${i2}`).join("\n")}` : "  No issues found."),
           updated = true;
         }
         if (updated) {
-          mkdirSync84(metaDir, { recursive: true });
-          writeFileSync76(storeFile, JSON.stringify(store2, null, 2));
+          mkdirSync85(metaDir, { recursive: true });
+          writeFileSync77(storeFile, JSON.stringify(store2, null, 2));
         }
       }
       // ── Storage ──────────────────────────────────────────────────────────
@@ -255370,7 +255418,7 @@ Recommendation: Strategy ${scored[0].index + 1} scores highest.`;
       }
       /** Archive a strategy variant synchronously (for task completion path) */
       archiveVariantSync(strategy, outcome, tags = []) {
-        const { readFileSync: readFileSync113, writeFileSync: writeFileSync76, existsSync: existsSync138, mkdirSync: mkdirSync84 } = __require("node:fs");
+        const { readFileSync: readFileSync113, writeFileSync: writeFileSync77, existsSync: existsSync138, mkdirSync: mkdirSync85 } = __require("node:fs");
         const dir = join36(this.cwd, ".omnius", "arche");
         const archiveFile = join36(dir, "variants.json");
         let variants = [];
@@ -255391,8 +255439,8 @@ Recommendation: Strategy ${scored[0].index + 1} scores highest.`;
         });
         if (variants.length > 50)
           variants = variants.slice(-50);
-        mkdirSync84(dir, { recursive: true });
-        writeFileSync76(archiveFile, JSON.stringify(variants, null, 2));
+        mkdirSync85(dir, { recursive: true });
+        writeFileSync77(archiveFile, JSON.stringify(variants, null, 2));
       }
       async saveArchive(variants) {
         const dir = join36(this.cwd, ".omnius", "arche");
@@ -542581,12 +542629,12 @@ var init_reflectionBuffer = __esm({
         if (!this.persistPath)
           return;
         try {
-          const { writeFileSync: writeFileSync76, mkdirSync: mkdirSync84, existsSync: existsSync138 } = __require("node:fs");
+          const { writeFileSync: writeFileSync77, mkdirSync: mkdirSync85, existsSync: existsSync138 } = __require("node:fs");
           const { join: join155 } = __require("node:path");
           const dir = join155(this.persistPath, "..");
           if (!existsSync138(dir))
-            mkdirSync84(dir, { recursive: true });
-          writeFileSync76(this.persistPath, JSON.stringify(this.state, null, 2));
+            mkdirSync85(dir, { recursive: true });
+          writeFileSync77(this.persistPath, JSON.stringify(this.state, null, 2));
         } catch {
         }
       }
@@ -544754,6 +544802,274 @@ var init_failureHandoff = __esm({
   }
 });
 
+// packages/orchestrator/dist/context-fabric.js
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function normalizeSignalContent(content) {
+  return content.replace(/\r\n/g, "\n").split("\n").map((line) => line.trimEnd()).join("\n").trim();
+}
+function truncateText(text, maxChars) {
+  if (text.length <= maxChars)
+    return { text, truncated: false };
+  if (maxChars <= 40)
+    return { text: text.slice(0, maxChars), truncated: true };
+  return {
+    text: `${text.slice(0, maxChars - 36).trimEnd()}
+... [truncated by context fabric]`,
+    truncated: true
+  };
+}
+function signalFromBlock(kind, source, content, options2 = {}) {
+  const normalized = normalizeSignalContent(content ?? "");
+  if (!normalized)
+    return null;
+  return {
+    id: options2.id ?? source,
+    kind,
+    source,
+    content: normalized,
+    priority: options2.priority,
+    createdTurn: options2.createdTurn,
+    ttlTurns: options2.ttlTurns,
+    dedupeKey: options2.dedupeKey,
+    tags: options2.tags,
+    metadata: options2.metadata
+  };
+}
+var KIND_ORDER, KIND_LABELS, DEFAULT_KIND_CHAR_BUDGET, ContextLedger, ContextFrameBuilder;
+var init_context_fabric = __esm({
+  "packages/orchestrator/dist/context-fabric.js"() {
+    "use strict";
+    KIND_ORDER = [
+      "goal",
+      "user_steering",
+      "task_state",
+      "known_files",
+      "recent_failure",
+      "tool_cache",
+      "skill_manifest",
+      "memory",
+      "session_history",
+      "anchor",
+      "handoff",
+      "environment",
+      "compaction_summary"
+    ];
+    KIND_LABELS = {
+      goal: "Goal",
+      user_steering: "User Steering",
+      task_state: "Task State",
+      known_files: "Known Files",
+      recent_failure: "Recent Failures",
+      tool_cache: "Tool Cache",
+      skill_manifest: "Skill Manifest",
+      memory: "Memory",
+      session_history: "Session History",
+      anchor: "Relevant Anchors",
+      handoff: "Handoff",
+      environment: "Environment",
+      compaction_summary: "Compaction Summary"
+    };
+    DEFAULT_KIND_CHAR_BUDGET = {
+      goal: 900,
+      user_steering: 1400,
+      task_state: 1800,
+      known_files: 2400,
+      recent_failure: 2600,
+      tool_cache: 2200,
+      skill_manifest: 900,
+      memory: 1500,
+      session_history: 1400,
+      anchor: 1100,
+      handoff: 1600,
+      environment: 900,
+      compaction_summary: 1200
+    };
+    ContextLedger = class {
+      signals = /* @__PURE__ */ new Map();
+      sequence = 0;
+      upsert(signal) {
+        const content = normalizeSignalContent(signal.content);
+        if (!content)
+          return;
+        const key = signal.dedupeKey || `${signal.kind}:${signal.id}`;
+        const incoming = {
+          ...signal,
+          content,
+          key,
+          priority: signal.priority ?? 0,
+          createdTurn: signal.createdTurn ?? 0,
+          sequence: ++this.sequence
+        };
+        const existing = this.signals.get(key);
+        if (!existing) {
+          this.signals.set(key, incoming);
+          return;
+        }
+        const shouldReplace = incoming.createdTurn > existing.createdTurn || incoming.createdTurn === existing.createdTurn && incoming.priority >= existing.priority || incoming.priority > existing.priority;
+        if (shouldReplace) {
+          this.signals.set(key, {
+            ...existing,
+            ...incoming,
+            tags: [.../* @__PURE__ */ new Set([...existing.tags ?? [], ...incoming.tags ?? []])],
+            metadata: { ...existing.metadata ?? {}, ...incoming.metadata ?? {} }
+          });
+        }
+      }
+      upsertMany(signals) {
+        for (const signal of signals)
+          this.upsert(signal);
+      }
+      removeWhere(predicate) {
+        let removed = 0;
+        for (const [key, signal] of this.signals.entries()) {
+          if (predicate(signal)) {
+            this.signals.delete(key);
+            removed++;
+          }
+        }
+        return removed;
+      }
+      clearSource(source) {
+        return this.removeWhere((signal) => signal.source === source);
+      }
+      clearSources(prefix) {
+        return this.removeWhere((signal) => signal.source.startsWith(prefix));
+      }
+      prune(turn) {
+        return this.removeWhere((signal) => {
+          if (signal.ttlTurns === void 0)
+            return false;
+          const created = signal.createdTurn ?? 0;
+          return turn - created > signal.ttlTurns;
+        });
+      }
+      values() {
+        return [...this.signals.values()].map(({ key: _key, sequence: _sequence, ...signal }) => ({
+          ...signal
+        }));
+      }
+      size() {
+        return this.signals.size;
+      }
+    };
+    ContextFrameBuilder = class {
+      build(signals, options2 = {}) {
+        const maxChars = Math.max(1200, options2.maxChars ?? 1e4);
+        const budgets = { ...DEFAULT_KIND_CHAR_BUDGET, ...options2.kindCharBudget ?? {} };
+        const sanitized = signals.map((signal) => ({ ...signal, content: normalizeSignalContent(signal.content) })).filter((signal) => signal.content.length > 0);
+        const byKind = /* @__PURE__ */ new Map();
+        for (const signal of sanitized) {
+          const bucket = byKind.get(signal.kind) ?? [];
+          bucket.push(signal);
+          byKind.set(signal.kind, bucket);
+        }
+        const included = [];
+        const dropped = [];
+        const sectionLines = [];
+        const sectionDiagnostics = [];
+        let truncatedSignals = 0;
+        for (const kind of KIND_ORDER) {
+          const bucket = byKind.get(kind);
+          if (!bucket || bucket.length === 0)
+            continue;
+          const sorted = [...bucket].sort((a2, b) => {
+            const pa = a2.priority ?? 0;
+            const pb = b.priority ?? 0;
+            if (pa !== pb)
+              return pb - pa;
+            const ta = a2.createdTurn ?? 0;
+            const tb = b.createdTurn ?? 0;
+            if (ta !== tb)
+              return tb - ta;
+            return a2.source.localeCompare(b.source) || a2.id.localeCompare(b.id);
+          });
+          const budget = Math.max(200, budgets[kind]);
+          const body = [];
+          let chars = 0;
+          let used = 0;
+          for (const signal of sorted) {
+            const prefix = sorted.length > 1 ? `- ${signal.content}` : signal.content;
+            const remaining = budget - chars;
+            if (remaining <= 80) {
+              dropped.push(signal);
+              continue;
+            }
+            const rendered = truncateText(prefix, remaining);
+            if (rendered.truncated)
+              truncatedSignals++;
+            body.push(rendered.text);
+            chars += rendered.text.length + 1;
+            included.push(signal);
+            used++;
+            if (rendered.truncated) {
+              for (const rest of sorted.slice(sorted.indexOf(signal) + 1))
+                dropped.push(rest);
+              break;
+            }
+          }
+          if (body.length === 0)
+            continue;
+          const label = KIND_LABELS[kind];
+          sectionLines.push(`## ${label}`);
+          sectionLines.push(body.join("\n"));
+          sectionDiagnostics.push({ kind, label, signals: used, chars });
+        }
+        const header = [
+          "[ACTIVE CONTEXT FRAME]",
+          options2.turn !== void 0 ? `turn: ${options2.turn}` : null,
+          "Scope: runtime state for the next action. Treat this as the single merged context intake; do not re-read or re-emit it unless state changes."
+        ].filter(Boolean);
+        let content = [...header, "", ...sectionLines].join("\n").trim();
+        if (sectionLines.length === 0) {
+          return {
+            content: null,
+            diagnostics: {
+              includedSignals: 0,
+              droppedSignals: sanitized.length,
+              truncatedSignals: 0,
+              estimatedTokens: 0,
+              totalChars: 0,
+              sections: []
+            },
+            included: [],
+            dropped: sanitized
+          };
+        }
+        if (content.length > maxChars) {
+          const truncated = truncateText(content, maxChars);
+          content = truncated.text;
+          if (truncated.truncated)
+            truncatedSignals++;
+          for (const signal of sanitized) {
+            if (!included.includes(signal) && !dropped.includes(signal))
+              dropped.push(signal);
+          }
+        }
+        if (options2.includeDiagnostics) {
+          content += `
+
+context_fabric: included=${included.length} dropped=${dropped.length} truncated=${truncatedSignals} est_tokens=${estimateTokens(content)}`;
+        }
+        return {
+          content,
+          diagnostics: {
+            includedSignals: included.length,
+            droppedSignals: dropped.length,
+            truncatedSignals,
+            estimatedTokens: estimateTokens(content),
+            totalChars: content.length,
+            sections: sectionDiagnostics
+          },
+          included,
+          dropped
+        };
+      }
+    };
+  }
+});
+
 // packages/orchestrator/dist/preflightSnapshot.js
 var preflightSnapshot_exports = {};
 __export(preflightSnapshot_exports, {
@@ -546103,6 +546419,7 @@ var init_agenticRunner = __esm({
     init_specDecomposer();
     init_modelProfile();
     init_failureHandoff();
+    init_context_fabric();
     TOOL_SUBSETS = {
       web: ["web_search", "web_fetch", "web_crawl"],
       code: [
@@ -546540,6 +546857,10 @@ var init_agenticRunner = __esm({
       // Phase 6 — last-surface guard so we don't re-inject the same anchor on
       // consecutive turns when its keywords still match.
       _lastSurfacedAnchorIds = /* @__PURE__ */ new Set();
+      // Context Fabric — all transient runtime guidance is merged through this
+      // ledger and emitted as one bounded frame before each model call.
+      _contextLedger = new ContextLedger();
+      _contextFrameBuilder = new ContextFrameBuilder();
       /** WO-AM-10: Process pending episode embeddings in background batches */
       async processPendingEmbeddings() {
         if (this._pendingEmbeddings.length === 0 || !this._episodeStore)
@@ -548704,6 +549025,80 @@ ${latest.output || ""}`.trim();
           return null;
         return sections.join("\n");
       }
+      _insertContextFrame(messages2, frame) {
+        if (!frame)
+          return;
+        const insertAt = Math.max(0, messages2.length - 1);
+        messages2.splice(insertAt, 0, { role: "system", content: frame });
+      }
+      _buildTurnContextFrame(turn, messages2, recentToolResults, environmentBlock) {
+        this._contextLedger.clearSources("turn.");
+        this._contextLedger.prune(turn);
+        const signals = [
+          signalFromBlock("goal", "run.goal", this._taskState.goal ? `Active task: ${this._taskState.goal}` : null, {
+            id: "active-task",
+            dedupeKey: "run.goal",
+            priority: 100,
+            createdTurn: turn
+          }),
+          signalFromBlock("known_files", "turn.files", this._renderFilesystemStateBlock(turn), {
+            id: "filesystem-state",
+            dedupeKey: "turn.files",
+            priority: 70,
+            createdTurn: turn,
+            ttlTurns: 1
+          }),
+          signalFromBlock("task_state", "turn.todos", this._renderTodoStateBlock(turn), {
+            id: "todo-state",
+            dedupeKey: "turn.todos",
+            priority: 80,
+            createdTurn: turn,
+            ttlTurns: 1
+          }),
+          signalFromBlock("recent_failure", "turn.failures", this._renderRecentFailuresBlock(turn), {
+            id: "recent-failures",
+            dedupeKey: "turn.failures",
+            priority: 95,
+            createdTurn: turn,
+            ttlTurns: 1
+          }),
+          signalFromBlock("recent_failure", "turn.churn", this._renderWriteChurnBlock(turn), {
+            id: "write-churn",
+            dedupeKey: "turn.churn",
+            priority: 75,
+            createdTurn: turn,
+            ttlTurns: 1
+          }),
+          signalFromBlock("tool_cache", "turn.tool-cache", recentToolResults ? this._renderKnowledgeBlock(recentToolResults) : null, {
+            id: "tool-cache",
+            dedupeKey: "turn.tool-cache",
+            priority: 65,
+            createdTurn: turn,
+            ttlTurns: 1
+          }),
+          signalFromBlock("anchor", "turn.anchors", this.surfaceAnchors(messages2), {
+            id: "anchors",
+            dedupeKey: "turn.anchors",
+            priority: 50,
+            createdTurn: turn,
+            ttlTurns: 1
+          }),
+          signalFromBlock("environment", "turn.environment", environmentBlock, {
+            id: "environment",
+            dedupeKey: "turn.environment",
+            priority: 35,
+            createdTurn: turn,
+            ttlTurns: 1
+          })
+        ];
+        this._contextLedger.upsertMany(signals.filter(Boolean));
+        const frame = this._contextFrameBuilder.build(this._contextLedger.values(), {
+          turn,
+          maxChars: 1e4,
+          includeDiagnostics: process.env["OMNIUS_CONTEXT_FABRIC_DIAGNOSTICS"] === "1"
+        });
+        return frame.content;
+      }
       makePhaseSummarizer() {
         if (process.env["OMNIUS_DISABLE_PHASE_SUMMARIZER"] === "1")
           return null;
@@ -548762,11 +549157,11 @@ ${blob}
        */
       surfaceAnchors(messages2) {
         if (process.env["OMNIUS_DISABLE_ANCHOR_SURFACING"] === "1")
-          return;
+          return null;
         if (!this._contextTree)
-          return;
+          return null;
         if (messages2.length === 0)
-          return;
+          return null;
         const tail = messages2.slice(-6);
         const queryParts = [];
         for (const m2 of tail) {
@@ -548778,7 +549173,7 @@ ${blob}
         }
         const query = queryParts.join(" ").slice(0, 800);
         if (!query)
-          return;
+          return null;
         const anchors = this._contextTree.findAnchorsByKeywords(query, 5);
         const memexMatches = [];
         if (this._memexArchive.size > 0) {
@@ -548801,7 +549196,7 @@ ${blob}
         const newAnchors = anchors.filter((a2) => !this._lastSurfacedAnchorIds.has(a2.id)).slice(0, 3);
         const newMemex = memexMatches.filter((m2) => !this._lastSurfacedAnchorIds.has(m2.id)).slice(0, 2);
         if (newAnchors.length === 0 && newMemex.length === 0)
-          return;
+          return null;
         const lines = [
           `[Anchor surface] Relevant archived context for the current activity:`
         ];
@@ -548812,10 +549207,6 @@ ${blob}
           lines.push(`  - [memex:${m2.id}] ${m2.summary} — call memex_retrieve("${m2.id}") for full body`);
         }
         lines.push(`(Anchors are reminders. Pull only what you actually need; ignore otherwise.)`);
-        messages2.push({
-          role: "system",
-          content: lines.join("\n")
-        });
         for (const a2 of newAnchors)
           this._lastSurfacedAnchorIds.add(a2.id);
         for (const m2 of newMemex)
@@ -548825,6 +549216,7 @@ ${blob}
           content: `Anchor surface: surfaced ${newAnchors.length} anchor(s) + ${newMemex.length} memex entry(ies)`,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
+        return lines.join("\n");
       }
       microcompact(messages2, recentToolResults) {
         const tier = this.options.modelTier ?? "large";
@@ -549545,6 +549937,8 @@ Respond with your assessment, then take action.`;
         this._ephemeralSkillPackContext = "";
         this._contextTree = null;
         this._lastSurfacedAnchorIds.clear();
+        this._contextLedger = new ContextLedger();
+        this._contextFrameBuilder = new ContextFrameBuilder();
         if (!this.options.disablePersistentMemory && !this._memoryInitialized) {
           try {
             const path12 = await import("node:path");
@@ -549890,7 +550284,14 @@ TASK: ${scrubbedTask}` : scrubbedTask;
               maxRecentCalls: 0
             });
             if (failureHandoff) {
-              messages2.push({ role: "system", content: failureHandoff });
+              const signal = signalFromBlock("handoff", "run.failure-handoff", failureHandoff, {
+                id: "failure-mode-handoff",
+                dedupeKey: "run.failure-handoff",
+                priority: 85,
+                createdTurn: 0
+              });
+              if (signal)
+                this._contextLedger.upsert(signal);
             }
           } catch {
           }
@@ -551344,11 +551745,12 @@ ${memoryLines.join("\n")}`
               }
             }
           }
+          let environmentBlock = null;
           if (this.options.environmentProvider) {
             try {
               const envStr = this.options.environmentProvider();
               if (envStr) {
-                compacted.push({ role: "system", content: envStr });
+                environmentBlock = envStr;
               }
             } catch {
             }
@@ -551356,7 +551758,7 @@ ${memoryLines.join("\n")}`
           this._lastAssistantTimestamp = Date.now();
           this.proactivePrune(compacted, turn);
           this.microcompact(compacted, recentToolResults);
-          this.surfaceAnchors(compacted);
+          this._insertContextFrame(compacted, this._buildTurnContextFrame(turn, compacted, recentToolResults, environmentBlock));
           const { maxOutputTokens: effectiveMaxTokens } = this.contextLimits();
           const chatRequest = {
             messages: compacted,
@@ -551428,31 +551830,6 @@ ${memoryLines.join("\n")}`
               }
             }
           }
-          const _injections = [];
-          const fsBlock = this._renderFilesystemStateBlock(turn);
-          if (fsBlock)
-            _injections.push(fsBlock);
-          const todoBlock = this._renderTodoStateBlock(turn);
-          if (todoBlock)
-            _injections.push(todoBlock);
-          const failBlock = this._renderRecentFailuresBlock(turn);
-          if (failBlock)
-            _injections.push(failBlock);
-          const churnBlock = this._renderWriteChurnBlock(turn);
-          if (churnBlock)
-            _injections.push(churnBlock);
-          const knowledgeBlock = this._renderKnowledgeBlock(recentToolResults);
-          if (knowledgeBlock)
-            _injections.push(knowledgeBlock);
-          if (_injections.length > 0) {
-            const reqMsgs = chatRequest.messages;
-            if (Array.isArray(reqMsgs)) {
-              const insertAt = Math.max(0, reqMsgs.length - 1);
-              for (const blk of _injections) {
-                reqMsgs.splice(insertAt, 0, { role: "system", content: blk });
-              }
-            }
-          }
           let response;
           try {
             response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
@@ -553495,7 +553872,15 @@ Then use file_read on individual FILES inside it.`);
                   lastInjectedTurn: lastShellPivotTurn
                 });
                 if (shellPivot.shouldInject && shellPivot.content) {
-                  messages2.push({ role: "system", content: shellPivot.content });
+                  const signal = signalFromBlock("recent_failure", "runtime.shell-pivot", shellPivot.content, {
+                    id: "shell-pivot",
+                    dedupeKey: "runtime.shell-pivot",
+                    priority: 98,
+                    createdTurn: turn,
+                    ttlTurns: 4
+                  });
+                  if (signal)
+                    this._contextLedger.upsert(signal);
                   lastShellPivotTurn = turn;
                   this.emit({
                     type: "status",
@@ -553514,7 +553899,15 @@ Then use file_read on individual FILES inside it.`);
                   maxRecentCalls: 6
                 });
                 if (runtimeHandoff) {
-                  messages2.push({ role: "system", content: runtimeHandoff });
+                  const signal = signalFromBlock("handoff", "runtime.failure-handoff", runtimeHandoff, {
+                    id: "runtime-failure-handoff",
+                    dedupeKey: "runtime.failure-handoff",
+                    priority: 90,
+                    createdTurn: turn,
+                    ttlTurns: 4
+                  });
+                  if (signal)
+                    this._contextLedger.upsert(signal);
                   lastFailureHandoffTurn = turn;
                 }
               }
@@ -554150,7 +554543,14 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
             }
             this.proactivePrune(compactedMsgs, this._taskState.toolCallCount);
             this.microcompact(compactedMsgs);
-            this.surfaceAnchors(compactedMsgs);
+            let bfEnvironmentBlock = null;
+            if (this.options.environmentProvider) {
+              try {
+                bfEnvironmentBlock = this.options.environmentProvider() || null;
+              } catch {
+              }
+            }
+            this._insertContextFrame(compactedMsgs, this._buildTurnContextFrame(turn, compactedMsgs, void 0, bfEnvironmentBlock));
             const chatRequest = {
               messages: compactedMsgs,
               tools: toolDefs,
@@ -555064,10 +555464,10 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
                 try {
-                  const { mkdirSync: mkdirSync84, readdirSync: readdirSync51, statSync: statSync49, unlinkSync: unlinkSync29, writeFileSync: writeFileSync76 } = __require("node:fs");
+                  const { mkdirSync: mkdirSync85, readdirSync: readdirSync51, statSync: statSync49, unlinkSync: unlinkSync29, writeFileSync: writeFileSync77 } = __require("node:fs");
                   const { join: join155 } = __require("node:path");
                   const contextDir = join155(this._workingDirectory || process.cwd(), ".omnius", "context");
-                  mkdirSync84(contextDir, { recursive: true });
+                  mkdirSync85(contextDir, { recursive: true });
                   const topEntities = this._temporalGraph.nodesByType("entity", 3);
                   const topFiles = this._temporalGraph.nodesByType("file", 3);
                   const topConcepts = this._temporalGraph.nodesByType("concept", 3);
@@ -555107,16 +555507,30 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                   section("Top Files", topFiles);
                   section("Top Concepts", topConcepts);
                   lines.push("(Use file_read on this file for quick recall. See provenance JSON for full edge detail.)");
-                  const outPath = join155(contextDir, `kg-summary-${this._sessionId}.md`);
-                  writeFileSync76(outPath, lines.join("\n"), "utf-8");
-                  writeFileSync76(join155(contextDir, `kg-summary-latest.md`), lines.join("\n"), "utf-8");
+                  const kgSummaryDir = join155(contextDir, "kg-summary");
+                  mkdirSync85(kgSummaryDir, { recursive: true });
+                  const summaryFilename = `kg-summary-${this._sessionId}.md`;
+                  const outPath = join155(kgSummaryDir, summaryFilename);
+                  writeFileSync77(outPath, lines.join("\n"), "utf-8");
+                  writeFileSync77(join155(kgSummaryDir, "latest.md"), lines.join("\n"), "utf-8");
+                  writeFileSync77(join155(contextDir, `kg-summary-latest.md`), [
+                    "Latest KG summary moved to `.omnius/context/kg-summary/latest.md`.",
+                    "",
+                    lines.join("\n")
+                  ].join("\n"), "utf-8");
+                  writeFileSync77(join155(kgSummaryDir, "index.json"), JSON.stringify({
+                    schema: "omnius.kg-summary-index.v1",
+                    latest: "latest.md",
+                    latestSessionFile: summaryFilename,
+                    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+                  }, null, 2) + "\n", "utf-8");
                   if (process.env["OMNIUS_DISABLE_KG_SUMMARY_PRUNE"] !== "1") {
                     try {
                       const maxAgeDays = parseInt(process.env["OMNIUS_KG_SUMMARY_MAX_AGE_DAYS"] || "7", 10) || 7;
-                      const maxFiles = parseInt(process.env["OMNIUS_KG_SUMMARY_MAX_FILES"] || "20", 10) || 20;
+                      const maxFiles = parseInt(process.env["OMNIUS_KG_SUMMARY_MAX_FILES"] || "60", 10) || 60;
                       const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
-                      const summaries = readdirSync51(contextDir).filter((name10) => name10.startsWith("kg-summary-") && name10.endsWith(".md") && name10 !== "kg-summary-latest.md").map((name10) => {
-                        const filePath = join155(contextDir, name10);
+                      const summaries = readdirSync51(kgSummaryDir).filter((name10) => name10.startsWith("kg-summary-") && name10.endsWith(".md")).map((name10) => {
+                        const filePath = join155(kgSummaryDir, name10);
                         const stat7 = statSync49(filePath);
                         return { filePath, mtimeMs: stat7.mtimeMs };
                       }).sort((a2, b) => b.mtimeMs - a2.mtimeMs);
@@ -555394,11 +555808,11 @@ ${errOutput}`);
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
         try {
-          const { mkdirSync: mkdirSync84, writeFileSync: writeFileSync76 } = __require("node:fs");
+          const { mkdirSync: mkdirSync85, writeFileSync: writeFileSync77 } = __require("node:fs");
           const { join: join155 } = __require("node:path");
           const resultsDir = join155(this.omniusStateDir(), "tool-results");
-          mkdirSync84(resultsDir, { recursive: true });
-          writeFileSync76(join155(resultsDir, `${handleId}.txt`), `# Tool: ${toolName}
+          mkdirSync85(resultsDir, { recursive: true });
+          writeFileSync77(join155(resultsDir, `${handleId}.txt`), `# Tool: ${toolName}
 # Turn: ${turn}
 # Timestamp: ${(/* @__PURE__ */ new Date()).toISOString()}
 # Size: ${result.output.length} chars, ${lineCount} lines
@@ -555780,10 +556194,10 @@ Actions: (1) list_directory on the parent directory to see what's there, (2) Che
         if (!this._workingDirectory)
           return;
         try {
-          const { mkdirSync: mkdirSync84, writeFileSync: writeFileSync76 } = __require("node:fs");
+          const { mkdirSync: mkdirSync85, writeFileSync: writeFileSync77 } = __require("node:fs");
           const { join: join155 } = __require("node:path");
           const sessionDir2 = this.options.stateDir ? join155(this.omniusStateDir(), "session", this._sessionId) : join155(this._workingDirectory, ".omnius", "session", this._sessionId);
-          mkdirSync84(sessionDir2, { recursive: true });
+          mkdirSync85(sessionDir2, { recursive: true });
           const checkpoint = {
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
             sessionId: this._sessionId,
@@ -555795,7 +556209,7 @@ Actions: (1) list_directory on the parent directory to see what's there, (2) Che
             memexEntryCount: this._memexArchive.size,
             fileRegistrySize: this._fileRegistry.size
           };
-          writeFileSync76(join155(sessionDir2, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
+          writeFileSync77(join155(sessionDir2, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
         } catch {
         }
       }
@@ -555829,10 +556243,17 @@ ${tail}`;
           const textContent = userMsg.replace(imagePattern, "").trim();
           await this.appendOffloadedImageMessage(messages2, mime, base642, textContent, turn);
         } else {
-          messages2.push({
-            role: "user",
-            content: this.formatInjectedUserMessage(userMsg)
-          });
+          const steeringPacket = this.formatInjectedUserMessage(userMsg);
+          const steeringHash = _createHash("sha256").update(steeringPacket).digest("hex").slice(0, 16);
+          const signal = signalFromBlock("user_steering", "user.steering", steeringPacket, {
+            id: `steering-${turn}-${steeringHash}`,
+            dedupeKey: `user.steering:${steeringHash}`,
+            priority: 110,
+            createdTurn: turn,
+            ttlTurns: 20
+          });
+          if (signal)
+            this._contextLedger.upsert(signal);
         }
         this.emit({
           type: "user_interrupt",
@@ -556437,10 +556858,15 @@ ${content.slice(0, 8e3)}
           if (this._taskState.failedApproaches.length > 0) {
             goalParts.push(`**Failed approaches (do NOT repeat):** ${this._taskState.failedApproaches.slice(-3).join("; ")}`);
           }
-          result.push({
-            role: "system",
-            content: goalParts.join("\n")
+          const signal = signalFromBlock("compaction_summary", "runtime.compaction-goal", goalParts.join("\n"), {
+            id: "compaction-goal",
+            dedupeKey: "runtime.compaction-goal",
+            priority: 90,
+            createdTurn: this._taskState.toolCallCount,
+            ttlTurns: 8
           });
+          if (signal)
+            this._contextLedger.upsert(signal);
         }
         if (process.env["OMNIUS_DISABLE_FAILURE_HANDOFF"] !== "1") {
           try {
@@ -556452,10 +556878,15 @@ ${content.slice(0, 8e3)}
               maxRecentCalls: 0
             });
             if (compactFailureHandoff) {
-              result.push({
-                role: "system",
-                content: compactFailureHandoff
+              const signal = signalFromBlock("handoff", "runtime.compaction-failure-handoff", compactFailureHandoff, {
+                id: "compaction-failure-handoff",
+                dedupeKey: "runtime.compaction-failure-handoff",
+                priority: 88,
+                createdTurn: this._taskState.toolCallCount,
+                ttlTurns: 8
               });
+              if (signal)
+                this._contextLedger.upsert(signal);
             }
           } catch {
           }
@@ -558056,12 +558487,12 @@ ${result}`
             let resizedBase64 = null;
             try {
               const { execSync: execSync61 } = await import("node:child_process");
-              const { writeFileSync: writeFileSync76, readFileSync: readFileSync113, unlinkSync: unlinkSync29 } = await import("node:fs");
+              const { writeFileSync: writeFileSync77, readFileSync: readFileSync113, unlinkSync: unlinkSync29 } = await import("node:fs");
               const { join: join155 } = await import("node:path");
               const { tmpdir: tmpdir23 } = await import("node:os");
               const tmpIn = join155(tmpdir23(), `omnius_img_in_${Date.now()}.png`);
               const tmpOut = join155(tmpdir23(), `omnius_img_out_${Date.now()}.jpg`);
-              writeFileSync76(tmpIn, buffer2);
+              writeFileSync77(tmpIn, buffer2);
               const pyBin = process.platform === "win32" ? "python" : "python3";
               const escapedIn = tmpIn.replace(/\\/g, "\\\\");
               const escapedOut = tmpOut.replace(/\\/g, "\\\\");
@@ -578677,7 +579108,7 @@ Assistant: ${assistant}`;
   const prov = last2.provenance ? `
 Provenance: ${last2.provenance} (file_read to expand)` : "";
   const kg = `
-KG summary: .omnius/context/kg-summary-latest.md (file_read to expand)`;
+KG summary: .omnius/context/kg-summary/latest.md (file_read to expand; legacy pointer: .omnius/context/kg-summary-latest.md)`;
   return `<session-recap>
 Project chronology (older to newer):
 ${chronology.join("\n")}
@@ -599464,13 +599895,13 @@ async function handleSlashCommand(input, ctx3) {
           try {
             const { randomBytes: randomBytes29 } = await import("node:crypto");
             const { homedir: homedir56 } = await import("node:os");
-            const { mkdirSync: mkdirSync84, writeFileSync: writeFileSync76 } = await import("node:fs");
+            const { mkdirSync: mkdirSync85, writeFileSync: writeFileSync77 } = await import("node:fs");
             const { join: join155 } = await import("node:path");
             const newKey = randomBytes29(16).toString("hex");
             process.env["OMNIUS_API_KEY"] = newKey;
             const dir = join155(homedir56(), ".omnius");
-            mkdirSync84(dir, { recursive: true });
-            writeFileSync76(join155(dir, "api.key"), newKey + "\n", "utf8");
+            mkdirSync85(dir, { recursive: true });
+            writeFileSync77(join155(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."
@@ -599735,11 +600166,11 @@ async function handleSlashCommand(input, ctx3) {
             );
             try {
               const { homedir: homedir57 } = await import("node:os");
-              const { mkdirSync: mkdirSync85, writeFileSync: writeFileSync77 } = await import("node:fs");
+              const { mkdirSync: mkdirSync86, writeFileSync: writeFileSync78 } = await import("node:fs");
               const { join: join156 } = await import("node:path");
               const dir = join156(homedir57(), ".omnius");
-              mkdirSync85(dir, { recursive: true });
-              writeFileSync77(join156(dir, "api.key"), apiKey + "\n", "utf8");
+              mkdirSync86(dir, { recursive: true });
+              writeFileSync78(join156(dir, "api.key"), apiKey + "\n", "utf8");
             } catch {
             }
           }
@@ -599751,11 +600182,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: mkdirSync85, writeFileSync: writeFileSync77 } = await import("node:fs");
+            const { mkdirSync: mkdirSync86, writeFileSync: writeFileSync78 } = await import("node:fs");
             const { join: join156 } = await import("node:path");
             const dir = join156(homedir57(), ".omnius");
-            mkdirSync85(dir, { recursive: true });
-            writeFileSync77(join156(dir, "access"), `${val2}
+            mkdirSync86(dir, { recursive: true });
+            writeFileSync78(join156(dir, "access"), `${val2}
 `, "utf8");
           } catch {
           }
@@ -599855,11 +600286,11 @@ async function handleSlashCommand(input, ctx3) {
         );
         try {
           const { homedir: homedir57 } = await import("node:os");
-          const { mkdirSync: mkdirSync85, writeFileSync: writeFileSync77 } = await import("node:fs");
+          const { mkdirSync: mkdirSync86, writeFileSync: writeFileSync78 } = await import("node:fs");
           const { join: join156 } = await import("node:path");
           const dir = join156(homedir57(), ".omnius");
-          mkdirSync85(dir, { recursive: true });
-          writeFileSync77(join156(dir, "api.key"), apiKey + "\n", "utf8");
+          mkdirSync86(dir, { recursive: true });
+          writeFileSync78(join156(dir, "api.key"), apiKey + "\n", "utf8");
         } catch {
         }
       }
@@ -599870,12 +600301,12 @@ async function handleSlashCommand(input, ctx3) {
       }
       const port = parseInt(process.env["OMNIUS_PORT"] || "11435", 10);
       const { homedir: homedir56 } = await import("node:os");
-      const { mkdirSync: mkdirSync84, writeFileSync: writeFileSync76 } = await import("node:fs");
+      const { mkdirSync: mkdirSync85, writeFileSync: writeFileSync77 } = await import("node:fs");
       const { join: join155 } = await import("node:path");
       try {
         const dir = join155(homedir56(), ".omnius");
-        mkdirSync84(dir, { recursive: true });
-        writeFileSync76(join155(dir, "access"), `${val}
+        mkdirSync85(dir, { recursive: true });
+        writeFileSync77(join155(dir, "access"), `${val}
 `, "utf8");
       } catch (e2) {
         renderWarning(
@@ -607690,7 +608121,7 @@ async function handleVoiceMenu(ctx3, save2, hasLocal) {
             const { basename: basename36, join: pathJoin } = await import("node:path");
             const {
               copyFileSync: copyFileSync5,
-              mkdirSync: mkdirSync84,
+              mkdirSync: mkdirSync85,
               existsSync: exists2
             } = await import("node:fs");
             const { homedir: homedir56 } = await import("node:os");
@@ -607705,7 +608136,7 @@ async function handleVoiceMenu(ctx3, save2, hasLocal) {
               "models",
               modelName
             );
-            if (!exists2(destDir)) mkdirSync84(destDir, { recursive: true });
+            if (!exists2(destDir)) mkdirSync85(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));
@@ -609176,13 +609607,13 @@ async function handleSponsoredEndpoint(ctx3, local) {
     sponsors.push(...verified);
     if (verified.length > 0) {
       try {
-        const { mkdirSync: mkdirSync84, writeFileSync: writeFileSync76 } = __require("node:fs");
-        mkdirSync84(sponsorDir2, { recursive: true });
+        const { mkdirSync: mkdirSync85, writeFileSync: writeFileSync77 } = __require("node:fs");
+        mkdirSync85(sponsorDir2, { recursive: true });
         const cached = verified.map((s2) => ({
           ...s2,
           lastVerified: Date.now()
         }));
-        writeFileSync76(knownFile, JSON.stringify(cached, null, 2));
+        writeFileSync77(knownFile, JSON.stringify(cached, null, 2));
       } catch {
       }
     }
@@ -609386,7 +609817,7 @@ async function handlePeerEndpoint(peerId, authKey, ctx3, local, advertisedModels
     }
     if (models.length > 0) {
       try {
-        const { writeFileSync: writeFileSync76, mkdirSync: mkdirSync84 } = await import("node:fs");
+        const { writeFileSync: writeFileSync77, mkdirSync: mkdirSync85 } = await import("node:fs");
         const { join: join155, dirname: dirname44 } = await import("node:path");
         const cachePath = join155(
           ctx3.repoRoot || process.cwd(),
@@ -609394,8 +609825,8 @@ async function handlePeerEndpoint(peerId, authKey, ctx3, local, advertisedModels
           "nexus",
           "peer-models-cache.json"
         );
-        mkdirSync84(dirname44(cachePath), { recursive: true });
-        writeFileSync76(
+        mkdirSync85(dirname44(cachePath), { recursive: true });
+        writeFileSync77(
           cachePath,
           JSON.stringify(
             {
@@ -609467,7 +609898,7 @@ async function handlePeerEndpoint(peerId, authKey, ctx3, local, advertisedModels
       }));
       renderWarning("Live model probe failed; using sponsor directory model advertisement.");
       try {
-        const { writeFileSync: writeFileSync76, mkdirSync: mkdirSync84 } = await import("node:fs");
+        const { writeFileSync: writeFileSync77, mkdirSync: mkdirSync85 } = await import("node:fs");
         const { join: join155, dirname: dirname44 } = await import("node:path");
         const cachePath = join155(
           ctx3.repoRoot || process.cwd(),
@@ -609475,8 +609906,8 @@ async function handlePeerEndpoint(peerId, authKey, ctx3, local, advertisedModels
           "nexus",
           "peer-models-cache.json"
         );
-        mkdirSync84(dirname44(cachePath), { recursive: true });
-        writeFileSync76(
+        mkdirSync85(dirname44(cachePath), { recursive: true });
+        writeFileSync77(
           cachePath,
           JSON.stringify({
             peerId,
@@ -612064,13 +612495,13 @@ var init_commands = __esm({
             try {
               const { randomBytes: randomBytes29 } = await import("node:crypto");
               const { homedir: homedir56 } = await import("node:os");
-              const { mkdirSync: mkdirSync84, writeFileSync: writeFileSync76 } = await import("node:fs");
+              const { mkdirSync: mkdirSync85, writeFileSync: writeFileSync77 } = await import("node:fs");
               const { join: join155 } = await import("node:path");
               const apiKey = randomBytes29(16).toString("hex");
               process.env["OMNIUS_API_KEY"] = apiKey;
               const dir = join155(homedir56(), ".omnius");
-              mkdirSync84(dir, { recursive: true });
-              writeFileSync76(join155(dir, "api.key"), apiKey + "\n", "utf8");
+              mkdirSync85(dir, { recursive: true });
+              writeFileSync77(join155(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."
@@ -612089,11 +612520,11 @@ var init_commands = __esm({
           const port = parseInt(process.env["OMNIUS_PORT"] || "11435", 10);
           try {
             const { homedir: homedir56 } = await import("node:os");
-            const { mkdirSync: mkdirSync84, writeFileSync: writeFileSync76 } = await import("node:fs");
+            const { mkdirSync: mkdirSync85, writeFileSync: writeFileSync77 } = await import("node:fs");
             const { join: join155 } = await import("node:path");
             const dir = join155(homedir56(), ".omnius");
-            mkdirSync84(dir, { recursive: true });
-            writeFileSync76(join155(dir, "access"), `${val}
+            mkdirSync85(dir, { recursive: true });
+            writeFileSync77(join155(dir, "access"), `${val}
 `, "utf8");
           } catch {
           }
@@ -612256,7 +612687,7 @@ var init_commands = __esm({
 });
 
 // packages/cli/src/tui/project-context.ts
-import { existsSync as existsSync108, readFileSync as readFileSync87, readdirSync as readdirSync36 } from "node:fs";
+import { existsSync as existsSync108, readFileSync as readFileSync87, readdirSync as readdirSync36, mkdirSync as mkdirSync60, writeFileSync as writeFileSync55 } from "node:fs";
 import { join as join121, basename as basename24 } from "node:path";
 import { execSync as execSync54 } from "node:child_process";
 import { homedir as homedir42 } from "node:os";
@@ -612489,6 +612920,8 @@ function loadPatternSuggestions(repoRoot, store2) {
   }
 }
 function buildProjectContext(repoRoot, stores) {
+  const skills = discoverSkills(repoRoot);
+  writeCompressedSkillsArtifact(repoRoot, skills);
   return {
     projectInstructions: loadProjectFiles(repoRoot),
     projectMap: loadProjectMap(repoRoot),
@@ -612499,9 +612932,40 @@ function buildProjectContext(repoRoot, stores) {
     taskMemories: stores?.taskMemoryStore ? loadTaskMemories(repoRoot, stores.taskMemoryStore) : "",
     failurePatterns: stores?.failureStore ? loadFailurePatterns(stores.failureStore) : "",
     patternSuggestions: stores?.toolPatternStore ? loadPatternSuggestions(repoRoot, stores.toolPatternStore) : "",
-    skillsSummary: buildSkillsSummary(discoverSkills(repoRoot))
+    skillsSummary: buildSkillsSummary(skills)
   };
 }
+function writeCompressedSkillsArtifact(repoRoot, skills) {
+  try {
+    const contextDir = join121(repoRoot, OMNIUS_DIR, "context");
+    mkdirSync60(contextDir, { recursive: true });
+    const bySource = /* @__PURE__ */ new Map();
+    for (const skill of skills) bySource.set(skill.source, (bySource.get(skill.source) ?? 0) + 1);
+    const top = skills.slice(0, 30).map((skill) => ({
+      name: skill.name,
+      source: skill.source,
+      description: skill.description.slice(0, 220),
+      triggers: skill.triggers.slice(0, 4)
+    }));
+    writeFileSync55(
+      join121(contextDir, "skills-compressed.json"),
+      JSON.stringify(
+        {
+          schema: "omnius.skills-compressed.v1",
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          totalSkills: skills.length,
+          sourceCounts: Object.fromEntries([...bySource.entries()].sort((a2, b) => a2[0].localeCompare(b[0]))),
+          defaultLimit: 30,
+          skills: top
+        },
+        null,
+        2
+      ) + "\n",
+      "utf-8"
+    );
+  } catch {
+  }
+}
 function formatContextForPrompt(ctx3, modelTier = "large") {
   const sections = [];
   if (ctx3.environment) {
@@ -612741,11 +613205,11 @@ var init_realtime = __esm({
 });
 
 // packages/cli/src/tui/memory-paths.ts
-import { mkdirSync as mkdirSync60 } from "node:fs";
+import { mkdirSync as mkdirSync61 } from "node:fs";
 import { join as join123 } from "node:path";
 function omniusMemoryDbPaths(repoRoot) {
   const dir = join123(repoRoot, ".omnius");
-  mkdirSync60(dir, { recursive: true });
+  mkdirSync61(dir, { recursive: true });
   return {
     dir,
     episodes: join123(dir, "episodes.db"),
@@ -613885,7 +614349,7 @@ __export(banner_exports, {
   setBannerWriter: () => setBannerWriter,
   setGridText: () => setGridText
 });
-import { existsSync as existsSync111, readFileSync as readFileSync89, writeFileSync as writeFileSync55, mkdirSync as mkdirSync61 } from "node:fs";
+import { existsSync as existsSync111, readFileSync as readFileSync89, writeFileSync as writeFileSync56, mkdirSync as mkdirSync62 } from "node:fs";
 import { join as join124 } from "node:path";
 function setBannerWriter(writer) {
   chromeWrite3 = writer;
@@ -614020,8 +614484,8 @@ function createSponsorBanner(sponsorName, tagline, primaryColor = 214, bgColor =
 }
 function saveBannerDesign(workDir, design) {
   const dir = join124(workDir, ".omnius", "banners");
-  mkdirSync61(dir, { recursive: true });
-  writeFileSync55(join124(dir, `${design.id}.json`), JSON.stringify(design, null, 2), "utf8");
+  mkdirSync62(dir, { recursive: true });
+  writeFileSync56(join124(dir, `${design.id}.json`), JSON.stringify(design, null, 2), "utf8");
 }
 function loadBannerDesign(workDir, id) {
   const file = join124(workDir, ".omnius", "banners", `${id}.json`);
@@ -614357,7 +614821,7 @@ var init_banner = __esm({
 });
 
 // packages/cli/src/tui/carousel-descriptors.ts
-import { existsSync as existsSync112, readFileSync as readFileSync90, writeFileSync as writeFileSync56, mkdirSync as mkdirSync62, readdirSync as readdirSync38 } from "node:fs";
+import { existsSync as existsSync112, readFileSync as readFileSync90, writeFileSync as writeFileSync57, mkdirSync as mkdirSync63, readdirSync as readdirSync38 } from "node:fs";
 import { join as join125, basename as basename28 } from "node:path";
 function loadToolProfile(repoRoot) {
   const filePath = join125(repoRoot, OMNIUS_DIR, "context", TOOL_PROFILE_FILE);
@@ -614370,8 +614834,8 @@ function loadToolProfile(repoRoot) {
 }
 function saveToolProfile(repoRoot, profile) {
   const contextDir = join125(repoRoot, OMNIUS_DIR, "context");
-  mkdirSync62(contextDir, { recursive: true });
-  writeFileSync56(join125(contextDir, TOOL_PROFILE_FILE), JSON.stringify(profile, null, 2), "utf-8");
+  mkdirSync63(contextDir, { recursive: true });
+  writeFileSync57(join125(contextDir, TOOL_PROFILE_FILE), JSON.stringify(profile, null, 2), "utf-8");
 }
 function categorizeToolCall(toolName) {
   for (const cat2 of TOOL_CATEGORIES) {
@@ -614437,13 +614901,13 @@ function loadCachedDescriptors(repoRoot) {
 }
 function saveCachedDescriptors(repoRoot, phrases, sourceHash) {
   const contextDir = join125(repoRoot, OMNIUS_DIR, "context");
-  mkdirSync62(contextDir, { recursive: true });
+  mkdirSync63(contextDir, { recursive: true });
   const cached = {
     phrases,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     sourceHash
   };
-  writeFileSync56(join125(contextDir, DESCRIPTOR_FILE), JSON.stringify(cached, null, 2), "utf-8");
+  writeFileSync57(join125(contextDir, DESCRIPTOR_FILE), JSON.stringify(cached, null, 2), "utf-8");
 }
 function generateDescriptors(repoRoot) {
   const profile = loadToolProfile(repoRoot);
@@ -615519,13 +615983,13 @@ var init_stream_renderer = __esm({
 });
 
 // packages/cli/src/tui/edit-history.ts
-import { appendFileSync as appendFileSync9, mkdirSync as mkdirSync63 } from "node:fs";
+import { appendFileSync as appendFileSync9, mkdirSync as mkdirSync64 } from "node:fs";
 import { join as join126 } from "node:path";
 function createEditHistoryLogger(repoRoot, sessionId) {
   const historyDir = join126(repoRoot, ".omnius", "history");
   const logPath3 = join126(historyDir, "edits.jsonl");
   try {
-    mkdirSync63(historyDir, { recursive: true });
+    mkdirSync64(historyDir, { recursive: true });
   } catch {
   }
   function logToolCall(toolName, toolArgs, success) {
@@ -615663,7 +616127,7 @@ var init_promptLoader3 = __esm({
 });
 
 // packages/cli/src/tui/dream-engine.ts
-import { mkdirSync as mkdirSync64, writeFileSync as writeFileSync57, readFileSync as readFileSync92, existsSync as existsSync114, readdirSync as readdirSync39 } from "node:fs";
+import { mkdirSync as mkdirSync65, writeFileSync as writeFileSync58, readFileSync as readFileSync92, existsSync as existsSync114, readdirSync as readdirSync39 } from "node:fs";
 import { join as join128, basename as basename29 } from "node:path";
 import { execSync as execSync55 } from "node:child_process";
 function setDreamWriteContent(fn) {
@@ -615883,8 +616347,8 @@ var init_dream_engine = __esm({
         }
         try {
           const dir = join128(targetPath, "..");
-          mkdirSync64(dir, { recursive: true });
-          writeFileSync57(targetPath, content, "utf-8");
+          mkdirSync65(dir, { recursive: true });
+          writeFileSync58(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 };
@@ -615925,7 +616389,7 @@ var init_dream_engine = __esm({
             return { success: false, output: "", error: "old_string not found in file", durationMs: Date.now() - start2 };
           }
           content = content.replace(oldStr, newStr);
-          writeFileSync57(targetPath, content, "utf-8");
+          writeFileSync58(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 };
@@ -615971,8 +616435,8 @@ var init_dream_engine = __esm({
         }
         try {
           const dir = join128(targetPath, "..");
-          mkdirSync64(dir, { recursive: true });
-          writeFileSync57(targetPath, content, "utf-8");
+          mkdirSync65(dir, { recursive: true });
+          writeFileSync58(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 };
@@ -616013,7 +616477,7 @@ var init_dream_engine = __esm({
             return { success: false, output: "", error: "old_string not found in file", durationMs: Date.now() - start2 };
           }
           content = content.replace(oldStr, newStr);
-          writeFileSync57(targetPath, content, "utf-8");
+          writeFileSync58(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 };
@@ -616101,7 +616565,7 @@ var init_dream_engine = __esm({
           startedAt: (/* @__PURE__ */ new Date()).toISOString(),
           results: []
         };
-        mkdirSync64(this.dreamsDir, { recursive: true });
+        mkdirSync65(this.dreamsDir, { recursive: true });
         this.saveDreamState();
         try {
           for (let cycle = 1; cycle <= totalCycles; cycle++) {
@@ -616174,7 +616638,7 @@ ${result.summary}`;
               renderDreamContraction(cycle);
               const cycleSummary = this.buildCycleSummary(cycle, previousFindings);
               const summaryPath = join128(this.dreamsDir, `cycle-${cycle}-summary.md`);
-              writeFileSync57(summaryPath, cycleSummary, "utf-8");
+              writeFileSync58(summaryPath, cycleSummary, "utf-8");
             }
             if (mode === "lucid" && !this.abortController.signal.aborted) {
               this.saveVersionCheckpoint(cycle);
@@ -616836,8 +617300,8 @@ ${summaryResult}
 *Generated by omnius autoresearch swarm*
 `;
         try {
-          mkdirSync64(this.dreamsDir, { recursive: true });
-          writeFileSync57(reportPath, report2, "utf-8");
+          mkdirSync65(this.dreamsDir, { recursive: true });
+          writeFileSync58(reportPath, report2, "utf-8");
         } catch {
         }
         renderSwarmComplete(workspace);
@@ -616929,7 +617393,7 @@ ${summaryResult}
               return { success: false, output: "", error: "todos must be an array" };
             }
             try {
-              writeFileSync57(todoPath3, JSON.stringify({ todos, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2), "utf-8");
+              writeFileSync58(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");
@@ -616977,11 +617441,11 @@ ${summary}` };
                   addedAt: (/* @__PURE__ */ new Date()).toISOString()
                 };
                 notes2.push(note);
-                writeFileSync57(notesPath, JSON.stringify(notes2, null, 2), "utf-8");
+                writeFileSync58(notesPath, JSON.stringify(notes2, null, 2), "utf-8");
                 return { success: true, output: `Note added: [${note.category}] ${note.content.slice(0, 80)}` };
               }
               if (action === "clear") {
-                writeFileSync57(notesPath, "[]", "utf-8");
+                writeFileSync58(notesPath, "[]", "utf-8");
                 return { success: true, output: "All notes cleared." };
               }
               if (action === "search") {
@@ -617019,7 +617483,7 @@ ${summary}` };
       saveVersionCheckpoint(cycle) {
         const checkpointDir3 = join128(this.dreamsDir, "checkpoints", `cycle-${cycle}`);
         try {
-          mkdirSync64(checkpointDir3, { recursive: true });
+          mkdirSync65(checkpointDir3, { recursive: true });
           try {
             const gitStatus = execSync55("git status --porcelain", {
               cwd: this.repoRoot,
@@ -617036,10 +617500,10 @@ ${summary}` };
               encoding: "utf-8",
               timeout: 5e3
             }).trim();
-            writeFileSync57(join128(checkpointDir3, "git-status.txt"), gitStatus, "utf-8");
-            writeFileSync57(join128(checkpointDir3, "git-diff.patch"), gitDiff, "utf-8");
-            writeFileSync57(join128(checkpointDir3, "git-hash.txt"), gitHash, "utf-8");
-            writeFileSync57(
+            writeFileSync58(join128(checkpointDir3, "git-status.txt"), gitStatus, "utf-8");
+            writeFileSync58(join128(checkpointDir3, "git-diff.patch"), gitDiff, "utf-8");
+            writeFileSync58(join128(checkpointDir3, "git-hash.txt"), gitHash, "utf-8");
+            writeFileSync58(
               join128(checkpointDir3, "checkpoint.json"),
               JSON.stringify({
                 cycle,
@@ -617051,7 +617515,7 @@ ${summary}` };
             );
             renderInfo(`Checkpoint saved: cycle ${cycle} (${gitHash.slice(0, 8)})`);
           } catch {
-            writeFileSync57(
+            writeFileSync58(
               join128(checkpointDir3, "checkpoint.json"),
               JSON.stringify({ cycle, timestamp: (/* @__PURE__ */ new Date()).toISOString(), mode: this.state.mode }, null, 2),
               "utf-8"
@@ -617113,7 +617577,7 @@ ${files.map((f2) => `- [\`${f2}\`](./${f2})`).join("\n")}
 ---
 *Auto-generated by omnius dream engine*
 `;
-          writeFileSync57(join128(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
+          writeFileSync58(join128(this.dreamsDir, "PROPOSAL-INDEX.md"), index, "utf-8");
         } catch {
         }
       }
@@ -617135,7 +617599,7 @@ ${files.map((f2) => `- [\`${f2}\`](./${f2})`).join("\n")}
         };
         renderInfo("Memory consolidation starting — Phase 1: Orient → Phase 2: Gather → Phase 3: Consolidate → Phase 4: Prune");
         const memoryDir = join128(this.repoRoot, ".omnius", "memory");
-        mkdirSync64(memoryDir, { recursive: true });
+        mkdirSync65(memoryDir, { recursive: true });
         let prompt;
         try {
           prompt = loadPrompt3("tui/dream-consolidate.md", {
@@ -617201,7 +617665,7 @@ ${files.map((f2) => `- [\`${f2}\`](./${f2})`).join("\n")}
             durationMs
           });
           try {
-            writeFileSync57(
+            writeFileSync58(
               join128(memoryDir, ".last-consolidation"),
               JSON.stringify({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), summary: result.summary?.slice(0, 500) }) + "\n"
             );
@@ -617219,7 +617683,7 @@ ${files.map((f2) => `- [\`${f2}\`](./${f2})`).join("\n")}
       /** Save dream state for resume/inspection */
       saveDreamState() {
         try {
-          writeFileSync57(
+          writeFileSync58(
             join128(this.dreamsDir, "dream-state.json"),
             JSON.stringify(this.state, null, 2) + "\n",
             "utf-8"
@@ -617600,7 +618064,7 @@ var init_bless_engine = __esm({
 });
 
 // packages/cli/src/tui/dmn-engine.ts
-import { existsSync as existsSync115, readFileSync as readFileSync93, writeFileSync as writeFileSync58, mkdirSync as mkdirSync65, readdirSync as readdirSync40, unlinkSync as unlinkSync21 } from "node:fs";
+import { existsSync as existsSync115, readFileSync as readFileSync93, writeFileSync as writeFileSync59, mkdirSync as mkdirSync66, readdirSync as readdirSync40, unlinkSync as unlinkSync21 } from "node:fs";
 import { join as join129, basename as basename30 } from "node:path";
 function buildDMNGatherPrompt(recentTaskSummaries, dueReminders, attentionItems, memoryTopics, capabilities, competence, reflectionBuffer) {
   const competenceReport = competence.length > 0 ? competence.map((c8) => {
@@ -617708,7 +618172,7 @@ var init_dmn_engine = __esm({
         this.repoRoot = repoRoot;
         this.stateDir = join129(repoRoot, ".omnius", "dmn");
         this.historyDir = join129(repoRoot, ".omnius", "dmn", "cycles");
-        mkdirSync65(this.historyDir, { recursive: true });
+        mkdirSync66(this.historyDir, { recursive: true });
         this.loadState();
       }
       config;
@@ -618372,7 +618836,7 @@ OUTPUT: Call task_complete with JSON:
       }
       saveState() {
         try {
-          writeFileSync58(
+          writeFileSync59(
             join129(this.stateDir, "state.json"),
             JSON.stringify(this.state, null, 2) + "\n",
             "utf-8"
@@ -618383,23 +618847,62 @@ OUTPUT: Call task_complete with JSON:
       saveCycleResult(result) {
         try {
           const filename = `cycle-${result.cycleNumber}-${Date.now()}.json`;
-          writeFileSync58(
+          writeFileSync59(
             join129(this.historyDir, filename),
             JSON.stringify(result, null, 2) + "\n",
             "utf-8"
           );
-          const files = readdirSync40(this.historyDir).filter((f2) => f2.startsWith("cycle-") && f2.endsWith(".json")).sort();
-          if (files.length > 50) {
-            for (const old of files.slice(0, files.length - 50)) {
-              try {
-                unlinkSync21(join129(this.historyDir, old));
-              } catch {
-              }
+          this.pruneCycleHistory();
+        } catch {
+        }
+      }
+      pruneCycleHistory() {
+        const files = readdirSync40(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(readFileSync93(join129(this.historyDir, file), "utf-8"));
+            latestByFingerprint.set(this.fingerprintCycle(parsed), file);
+          } catch {
+            keep.add(file);
+          }
+        }
+        for (const file of latestByFingerprint.values()) keep.add(file);
+        const maxFiles = 50;
+        if (keep.size > maxFiles) {
+          const protectedFiles = /* @__PURE__ */ new Set([files[0], files[files.length - 1]]);
+          const removableKeepers = [...keep].filter((file) => !protectedFiles.has(file)).sort();
+          for (const file of removableKeepers.slice(0, keep.size - maxFiles)) {
+            keep.delete(file);
+          }
+        }
+        for (const file of files) {
+          if (!keep.has(file)) {
+            try {
+              unlinkSync21(join129(this.historyDir, file));
+            } catch {
             }
           }
-        } catch {
         }
       }
+      fingerprintCycle(result) {
+        const selected = result.selectedTask ? [
+          result.selectedTask.category,
+          result.selectedTask.task,
+          result.selectedTask.rationale,
+          result.selectedTask.provenance.join("|")
+        ].join(" ") : "null-selection";
+        const normalized = cleanForStorage(`${selected}
+${result.reasoning}`).toLowerCase().replace(/\d+/g, "#").replace(/\s+/g, " ").trim().slice(0, 1200);
+        let hash = 2166136261;
+        for (let i2 = 0; i2 < normalized.length; i2++) {
+          hash ^= normalized.charCodeAt(i2);
+          hash = Math.imul(hash, 16777619);
+        }
+        return (hash >>> 0).toString(16);
+      }
     };
   }
 });
@@ -620175,11 +620678,11 @@ var init_telegram_stats_menu = __esm({
 import { createCipheriv as createCipheriv4, createDecipheriv as createDecipheriv4, randomBytes as randomBytes23 } from "node:crypto";
 import {
   existsSync as existsSync117,
-  mkdirSync as mkdirSync66,
+  mkdirSync as mkdirSync67,
   readFileSync as readFileSync95,
   statSync as statSync42,
   unlinkSync as unlinkSync22,
-  writeFileSync as writeFileSync59
+  writeFileSync as writeFileSync60
 } from "node:fs";
 import { mkdir as mkdir19 } from "node:fs/promises";
 import {
@@ -620196,7 +620699,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 = join131(repoRoot, ".omnius", "telegram-creative", key);
-  mkdirSync66(root, { recursive: true });
+  mkdirSync67(root, { recursive: true });
   return root;
 }
 function formatTelegramCreativeWorkspacePrompt(root) {
@@ -620348,8 +620851,8 @@ function scopedTool(base3, root, mode) {
         if (mode === "edit" && !existsSync117(guarded.path.abs)) {
           const materialized = materializeTelegramCreativeArtifactForSend(rootAbs, guarded.path.rel);
           if (!materialized.ok) return denied(materialized.error);
-          mkdirSync66(dirname37(guarded.path.abs), { recursive: true });
-          writeFileSync59(guarded.path.abs, readFileSync95(materialized.path));
+          mkdirSync67(dirname37(guarded.path.abs), { recursive: true });
+          writeFileSync60(guarded.path.abs, readFileSync95(materialized.path));
           materialized.cleanup?.();
           restoredEditPath = guarded.path.abs;
         }
@@ -620437,10 +620940,10 @@ function manifestPath(root) {
   return join131(root, MANIFEST_FILE);
 }
 function ensureManifest(root) {
-  mkdirSync66(root, { recursive: true });
+  mkdirSync67(root, { recursive: true });
   const path12 = manifestPath(root);
   if (!existsSync117(path12)) {
-    writeFileSync59(path12, JSON.stringify({ files: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n", "utf8");
+    writeFileSync60(path12, JSON.stringify({ files: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n", "utf8");
   }
 }
 function readManifest(root) {
@@ -620466,7 +620969,7 @@ function readManifest(root) {
 }
 function writeManifest(root, manifest) {
   ensureManifest(root);
-  writeFileSync59(manifestPath(root), JSON.stringify(manifest, null, 2) + "\n", "utf8");
+  writeFileSync60(manifestPath(root), JSON.stringify(manifest, null, 2) + "\n", "utf8");
 }
 function manifestHas(root, relPath) {
   const rel = relPath.replace(/\\/g, "/");
@@ -620490,7 +620993,7 @@ function rememberCreated(root, absPath) {
         }
       }
     }
-    mkdirSync66(join131(root, OBJECTS_DIR), { recursive: true });
+    mkdirSync67(join131(root, OBJECTS_DIR), { recursive: true });
     const data = readFileSync95(guarded.path.abs);
     const prefix = randomBytes23(48);
     const key = randomBytes23(32);
@@ -620500,7 +621003,7 @@ function rememberCreated(root, absPath) {
     const tag = cipher.getAuthTag();
     const storedRel = join131(OBJECTS_DIR, `${Date.now()}-${randomBytes23(12).toString("hex")}.blob`).replace(/\\/g, "/");
     const storedAbs = join131(root, storedRel);
-    writeFileSync59(storedAbs, Buffer.concat([prefix, encrypted]));
+    writeFileSync60(storedAbs, Buffer.concat([prefix, encrypted]));
     try {
       unlinkSync22(guarded.path.abs);
     } catch {
@@ -620559,9 +621062,9 @@ function materializeTelegramCreativeArtifactForSend(root, rawPath) {
       payload = Buffer.concat([decipher.update(payload), decipher.final()]);
     }
     const stageDir = join131(rootAbs, SEND_DIR, `${Date.now()}-${randomBytes23(8).toString("hex")}`);
-    mkdirSync66(stageDir, { recursive: true });
+    mkdirSync67(stageDir, { recursive: true });
     const staged = join131(stageDir, object.originalName || basename32(rel));
-    writeFileSync59(staged, payload);
+    writeFileSync60(staged, payload);
     return {
       ok: true,
       path: staged,
@@ -621228,7 +621731,7 @@ var init_soul_observations = __esm({
 });
 
 // packages/cli/src/tui/telegram-channel-dmn.ts
-import { existsSync as existsSync118, mkdirSync as mkdirSync67, readdirSync as readdirSync42, readFileSync as readFileSync96, writeFileSync as writeFileSync60 } from "node:fs";
+import { existsSync as existsSync118, mkdirSync as mkdirSync68, readdirSync as readdirSync42, readFileSync as readFileSync96, writeFileSync as writeFileSync61 } from "node:fs";
 import { join as join132 } from "node:path";
 import { createHash as createHash26 } from "node:crypto";
 function safeFilePart(value2) {
@@ -621788,12 +622291,12 @@ ${artifact.personaContext}
 }
 function writeTelegramChannelDaydream(repoRoot, artifact) {
   const dir = sessionDir(repoRoot, artifact.sessionKey);
-  mkdirSync67(dir, { recursive: true });
+  mkdirSync68(dir, { recursive: true });
   const base3 = `${artifact.generatedAt.replace(/[:.]/g, "-")}-${artifact.id}`;
   const jsonPath = join132(dir, `${base3}.json`);
   const markdownPath = join132(dir, `${base3}.md`);
-  writeFileSync60(jsonPath, JSON.stringify(artifact, null, 2) + "\n", "utf8");
-  writeFileSync60(markdownPath, formatTelegramChannelDaydreamMarkdown(artifact), "utf8");
+  writeFileSync61(jsonPath, JSON.stringify(artifact, null, 2) + "\n", "utf8");
+  writeFileSync61(markdownPath, formatTelegramChannelDaydreamMarkdown(artifact), "utf8");
   return { dir, jsonPath, markdownPath };
 }
 function latestTelegramChannelDaydream(repoRoot, sessionKey) {
@@ -623546,7 +624049,7 @@ var init_vision_ingress = __esm({
 });
 
 // packages/cli/src/tui/telegram-bridge.ts
-import { mkdirSync as mkdirSync68, existsSync as existsSync120, unlinkSync as unlinkSync24, readdirSync as readdirSync43, statSync as statSync43, statfsSync as statfsSync5, readFileSync as readFileSync98, writeFileSync as writeFileSync62, appendFileSync as appendFileSync10 } from "node:fs";
+import { mkdirSync as mkdirSync69, existsSync as existsSync120, unlinkSync as unlinkSync24, readdirSync as readdirSync43, statSync as statSync43, statfsSync as statfsSync5, readFileSync as readFileSync98, writeFileSync as writeFileSync63, appendFileSync as appendFileSync10 } from "node:fs";
 import { join as join134, resolve as resolve48, basename as basename33, relative as relative13, isAbsolute as isAbsolute8, extname as extname16 } from "node:path";
 import { homedir as homedir43 } from "node:os";
 import { writeFile as writeFileAsync } from "node:fs/promises";
@@ -626818,7 +627321,7 @@ ${message2}`)
       appendTelegramConversationLedger(sessionKey, entry) {
         if (!this.repoRoot) return;
         try {
-          mkdirSync68(this.telegramConversationDir, { recursive: true });
+          mkdirSync69(this.telegramConversationDir, { recursive: true });
           appendFileSync10(
             this.telegramConversationLedgerPath(sessionKey),
             JSON.stringify({ sessionKey, ...entry }) + "\n",
@@ -627068,7 +627571,7 @@ ${mediaContext}` : ""
           return null;
         }
         try {
-          mkdirSync68(resolve48(this.repoRoot, ".omnius"), { recursive: true });
+          mkdirSync69(resolve48(this.repoRoot, ".omnius"), { recursive: true });
           const db = initDb(this.telegramSqlitePath);
           db.exec(`
         CREATE TABLE IF NOT EXISTS telegram_messages (
@@ -627790,7 +628293,7 @@ ${mediaContext}` : ""
       saveTelegramConversationState(sessionKey) {
         if (!this.repoRoot) return;
         try {
-          mkdirSync68(this.telegramConversationDir, { recursive: true });
+          mkdirSync69(this.telegramConversationDir, { recursive: true });
           const participants = [...this.chatParticipants.get(sessionKey)?.values() ?? []].map((profile) => ({
             ...profile,
             toneTags: [...profile.toneTags]
@@ -627807,7 +628310,7 @@ ${mediaContext}` : ""
             stimulation: this.stimulation.getState(sessionKey),
             reflection: this.channelReflectionState.get(sessionKey) ?? { autoFollowup: false }
           };
-          writeFileSync62(this.telegramConversationPath(sessionKey), JSON.stringify(payload, null, 2) + "\n", "utf8");
+          writeFileSync63(this.telegramConversationPath(sessionKey), JSON.stringify(payload, null, 2) + "\n", "utf8");
         } catch {
         }
       }
@@ -631126,7 +631629,7 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
           this.startTelegramSubAgentWatchdog();
           await this.prepareTelegramLongPolling();
           try {
-            mkdirSync68(this.mediaCacheDir, { recursive: true });
+            mkdirSync69(this.mediaCacheDir, { recursive: true });
           } catch {
           }
           try {
@@ -631237,7 +631740,7 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
         this.refreshActiveTelegramInteractionCount();
       }
       claimTelegramOwnerLock(lockDir, botUserId, botUsername) {
-        mkdirSync68(lockDir, { recursive: true });
+        mkdirSync69(lockDir, { recursive: true });
         const lockFile = join134(lockDir, `bot-${botUserId}.owner.lock`);
         if (existsSync120(lockFile)) {
           try {
@@ -631252,7 +631755,7 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
             if (e2 instanceof Error && e2.message.startsWith("Telegram bot @")) throw e2;
           }
         }
-        writeFileSync62(
+        writeFileSync63(
           lockFile,
           JSON.stringify({
             pid: process.pid,
@@ -634071,8 +634574,8 @@ Scoped workspace: ${scopedRoot}`,
         return join134(this.telegramToolButtonDir, `${safe}.json`);
       }
       writeTelegramToolButtonState(state) {
-        mkdirSync68(this.telegramToolButtonDir, { recursive: true });
-        writeFileSync62(this.telegramToolButtonPath(state.nonce), JSON.stringify(state, null, 2) + "\n", "utf-8");
+        mkdirSync69(this.telegramToolButtonDir, { recursive: true });
+        writeFileSync63(this.telegramToolButtonPath(state.nonce), JSON.stringify(state, null, 2) + "\n", "utf-8");
       }
       readTelegramToolButtonState(nonce) {
         try {
@@ -635959,9 +636462,9 @@ import {
   existsSync as existsSync121,
   readFileSync as readFileSync99,
   readdirSync as readdirSync44,
-  writeFileSync as writeFileSync63,
+  writeFileSync as writeFileSync64,
   renameSync as renameSync6,
-  mkdirSync as mkdirSync69,
+  mkdirSync as mkdirSync70,
   unlinkSync as unlinkSync25,
   appendFileSync as appendFileSync11
 } from "node:fs";
@@ -635980,20 +636483,20 @@ function inFlightPath(id) {
 }
 function persistSession(s2) {
   try {
-    mkdirSync69(sessionsDir(), { recursive: true });
+    mkdirSync70(sessionsDir(), { recursive: true });
     const final2 = sessionPath(s2.id);
     const tmp = `${final2}.tmp.${process.pid}.${Date.now()}`;
-    writeFileSync63(tmp, JSON.stringify(s2, null, 2), "utf-8");
+    writeFileSync64(tmp, JSON.stringify(s2, null, 2), "utf-8");
     renameSync6(tmp, final2);
   } catch {
   }
 }
 function persistInFlight(j) {
   try {
-    mkdirSync69(sessionsDir(), { recursive: true });
+    mkdirSync70(sessionsDir(), { recursive: true });
     const final2 = inFlightPath(j.sessionId);
     const tmp = `${final2}.tmp.${process.pid}.${Date.now()}`;
-    writeFileSync63(tmp, JSON.stringify(j, null, 2), "utf-8");
+    writeFileSync64(tmp, JSON.stringify(j, null, 2), "utf-8");
     renameSync6(tmp, final2);
   } catch {
   }
@@ -636025,7 +636528,7 @@ function loadPersistedSessions() {
               parsed.error = "Daemon restart while subprocess was running";
               parsed.completedAt = Date.now();
               try {
-                writeFileSync63(fp, JSON.stringify(parsed, null, 2), "utf-8");
+                writeFileSync64(fp, JSON.stringify(parsed, null, 2), "utf-8");
               } catch {
               }
               report2.staleInFlight++;
@@ -636208,7 +636711,7 @@ function checkinPath(sessionId) {
 }
 function appendCheckin(sessionId, steering) {
   try {
-    mkdirSync69(sessionsDir(), { recursive: true });
+    mkdirSync70(sessionsDir(), { recursive: true });
     const fp = checkinPath(sessionId);
     const entry = JSON.stringify({ ts: Date.now(), steering }) + "\n";
     appendFileSync11(fp, entry, "utf-8");
@@ -636606,7 +637109,7 @@ __export(projects_exports, {
   setCurrentProject: () => setCurrentProject,
   unregisterProject: () => unregisterProject
 });
-import { readFileSync as readFileSync100, writeFileSync as writeFileSync64, mkdirSync as mkdirSync70, existsSync as existsSync122, statSync as statSync44, renameSync as renameSync7 } from "node:fs";
+import { readFileSync as readFileSync100, writeFileSync as writeFileSync65, mkdirSync as mkdirSync71, existsSync as existsSync122, statSync as statSync44, renameSync as renameSync7 } from "node:fs";
 import { homedir as homedir45 } from "node:os";
 import { basename as basename34, join as join136, resolve as resolve49 } from "node:path";
 import { randomUUID as randomUUID15 } from "node:crypto";
@@ -636622,9 +637125,9 @@ function readAll2() {
   }
 }
 function writeAll(file) {
-  mkdirSync70(OMNIUS_DIR3, { recursive: true });
+  mkdirSync71(OMNIUS_DIR3, { recursive: true });
   const tmp = `${PROJECTS_FILE}.${randomUUID15().slice(0, 8)}.tmp`;
-  writeFileSync64(tmp, JSON.stringify(file, null, 2), "utf8");
+  writeFileSync65(tmp, JSON.stringify(file, null, 2), "utf8");
   renameSync7(tmp, PROJECTS_FILE);
 }
 function listProjects() {
@@ -636706,8 +637209,8 @@ function setCurrentProject(root) {
   if (!entry) return null;
   currentRoot = canonical;
   try {
-    mkdirSync70(OMNIUS_DIR3, { recursive: true });
-    writeFileSync64(CURRENT_FILE, `${canonical}
+    mkdirSync71(OMNIUS_DIR3, { recursive: true });
+    writeFileSync65(CURRENT_FILE, `${canonical}
 `, "utf8");
   } catch {
   }
@@ -637597,7 +638100,7 @@ var init_access_policy = __esm({
 
 // packages/cli/src/api/project-preferences.ts
 import { createHash as createHash30 } from "node:crypto";
-import { existsSync as existsSync123, mkdirSync as mkdirSync71, readFileSync as readFileSync101, renameSync as renameSync8, writeFileSync as writeFileSync65, unlinkSync as unlinkSync26 } from "node:fs";
+import { existsSync as existsSync123, mkdirSync as mkdirSync72, readFileSync as readFileSync101, renameSync as renameSync8, writeFileSync as writeFileSync66, unlinkSync as unlinkSync26 } from "node:fs";
 import { homedir as homedir46 } from "node:os";
 import { join as join137, resolve as resolve50 } from "node:path";
 import { randomUUID as randomUUID16 } from "node:crypto";
@@ -637616,11 +638119,11 @@ function rootSentinelPath(root) {
 }
 function ensureDir(root) {
   const dir = projectDir(root);
-  mkdirSync71(dir, { recursive: true });
+  mkdirSync72(dir, { recursive: true });
   const sentinel = rootSentinelPath(root);
   try {
     if (!existsSync123(sentinel)) {
-      writeFileSync65(sentinel, `${resolve50(root)}
+      writeFileSync66(sentinel, `${resolve50(root)}
 `, "utf8");
     }
   } catch {
@@ -637649,12 +638152,12 @@ function writeProjectPreferences(root, partial) {
   };
   const file = prefsPath(root);
   const tmp = `${file}.${randomUUID16().slice(0, 8)}.tmp`;
-  writeFileSync65(tmp, JSON.stringify(merged, null, 2), "utf8");
+  writeFileSync66(tmp, JSON.stringify(merged, null, 2), "utf8");
   try {
     renameSync8(tmp, file);
   } catch (err) {
     try {
-      writeFileSync65(file, JSON.stringify(merged, null, 2), "utf8");
+      writeFileSync66(file, JSON.stringify(merged, null, 2), "utf8");
     } catch {
     }
     try {
@@ -638581,13 +639084,13 @@ __export(audit_log_exports, {
   recordAudit: () => recordAudit,
   sanitizeBody: () => sanitizeBody
 });
-import { mkdirSync as mkdirSync72, appendFileSync as appendFileSync12, readFileSync as readFileSync102, existsSync as existsSync124 } from "node:fs";
+import { mkdirSync as mkdirSync73, appendFileSync as appendFileSync12, readFileSync as readFileSync102, existsSync as existsSync124 } from "node:fs";
 import { join as join138 } from "node:path";
 function initAuditLog(omniusDir) {
   auditDir = join138(omniusDir, "audit");
   auditFile = join138(auditDir, "audit.jsonl");
   try {
-    mkdirSync72(auditDir, { recursive: true });
+    mkdirSync73(auditDir, { recursive: true });
     initialized = true;
   } catch {
   }
@@ -638655,7 +639158,7 @@ var init_audit_log = __esm({
 
 // packages/cli/src/api/disk-task-output.ts
 import { open } from "node:fs/promises";
-import { existsSync as existsSync125, mkdirSync as mkdirSync73, statSync as statSync45 } from "node:fs";
+import { existsSync as existsSync125, mkdirSync as mkdirSync74, statSync as statSync45 } from "node:fs";
 import { dirname as dirname39 } from "node:path";
 import * as fsConstants from "node:constants";
 var O_NOFOLLOW2, O_APPEND2, O_CREAT2, O_WRONLY2, OPEN_FLAGS_WRITE, OPEN_MODE, DiskTaskOutput;
@@ -638675,7 +639178,7 @@ var init_disk_task_output = __esm({
       fileSize = 0;
       constructor(outputPath3) {
         this.path = outputPath3;
-        mkdirSync73(dirname39(outputPath3), { recursive: true });
+        mkdirSync74(dirname39(outputPath3), { recursive: true });
       }
       /** Queue content for async append. Non-blocking. */
       append(chunk) {
@@ -639740,13 +640243,13 @@ __export(runtime_keys_exports, {
   mintKey: () => mintKey,
   revokeByPrefix: () => revokeByPrefix
 });
-import { existsSync as existsSync127, readFileSync as readFileSync104, writeFileSync as writeFileSync66, mkdirSync as mkdirSync74, chmodSync as chmodSync3 } from "node:fs";
+import { existsSync as existsSync127, readFileSync as readFileSync104, writeFileSync as writeFileSync67, mkdirSync as mkdirSync75, chmodSync as chmodSync3 } from "node:fs";
 import { join as join140 } from "node:path";
 import { homedir as homedir48 } from "node:os";
 import { randomBytes as randomBytes25 } from "node:crypto";
 function ensureDir2() {
   const dir = join140(homedir48(), ".omnius");
-  if (!existsSync127(dir)) mkdirSync74(dir, { recursive: true });
+  if (!existsSync127(dir)) mkdirSync75(dir, { recursive: true });
 }
 function loadAll() {
   if (!existsSync127(KEYS_FILE)) return [];
@@ -639761,7 +640264,7 @@ function loadAll() {
 }
 function persistAll(records) {
   ensureDir2();
-  writeFileSync66(KEYS_FILE, JSON.stringify(records, null, 2), "utf-8");
+  writeFileSync67(KEYS_FILE, JSON.stringify(records, null, 2), "utf-8");
   try {
     chmodSync3(KEYS_FILE, 384);
   } catch {
@@ -639995,7 +640498,7 @@ __export(graphical_sudo_exports, {
   runGraphicalSudo: () => runGraphicalSudo
 });
 import { spawn as spawn30 } from "node:child_process";
-import { existsSync as existsSync129, mkdirSync as mkdirSync75, writeFileSync as writeFileSync67, chmodSync as chmodSync4 } from "node:fs";
+import { existsSync as existsSync129, mkdirSync as mkdirSync76, writeFileSync as writeFileSync68, chmodSync as chmodSync4 } from "node:fs";
 import { join as join142 } from "node:path";
 import { tmpdir as tmpdir21 } from "node:os";
 function detectSudoHelper() {
@@ -640019,7 +640522,7 @@ function which2(cmd) {
 }
 function ensureAskpassShim(helper, description) {
   const shimDir = join142(tmpdir21(), "omnius-askpass");
-  mkdirSync75(shimDir, { recursive: true });
+  mkdirSync76(shimDir, { recursive: true });
   const shim = join142(shimDir, `${helper}.sh`);
   let body;
   if (helper === "zenity") {
@@ -640031,7 +640534,7 @@ exec zenity --password --title="Omnius needs sudo" --text="${description.replace
 exec kdialog --password "${description.replace(/"/g, '\\"')}" 2>/dev/null
 `;
   }
-  writeFileSync67(shim, body, "utf-8");
+  writeFileSync68(shim, body, "utf-8");
   chmodSync4(shim, 493);
   return shim;
 }
@@ -642622,8 +643125,8 @@ function readAimsFile(name10, fallback) {
 }
 function writeAimsFile(name10, data) {
   const dir = aimsDir();
-  const { mkdirSync: mkdirSync84, writeFileSync: wf, renameSync: rn } = __require("node:fs");
-  mkdirSync84(dir, { recursive: true });
+  const { mkdirSync: mkdirSync85, writeFileSync: wf, renameSync: rn } = __require("node:fs");
+  mkdirSync85(dir, { recursive: true });
   const finalPath = join143(dir, name10);
   const tmpPath = `${finalPath}.tmp.${process.pid}.${Date.now()}`;
   try {
@@ -652460,11 +652963,11 @@ var init_auth_oidc = __esm({
 });
 
 // packages/cli/src/api/usage-tracker.ts
-import { mkdirSync as mkdirSync76, readFileSync as readFileSync107, writeFileSync as writeFileSync68, existsSync as existsSync131 } from "node:fs";
+import { mkdirSync as mkdirSync77, readFileSync as readFileSync107, writeFileSync as writeFileSync69, existsSync as existsSync131 } from "node:fs";
 import { join as join144 } from "node:path";
 function initUsageTracker(omniusDir) {
   const dir = join144(omniusDir, "usage");
-  mkdirSync76(dir, { recursive: true });
+  mkdirSync77(dir, { recursive: true });
   usageFile = join144(dir, "token-usage.json");
   try {
     if (existsSync131(usageFile)) {
@@ -652504,7 +653007,7 @@ function flush2() {
   if (!initialized2 || !dirty) return;
   try {
     store.lastSaved = (/* @__PURE__ */ new Date()).toISOString();
-    writeFileSync68(usageFile, JSON.stringify(store, null, 2), "utf-8");
+    writeFileSync69(usageFile, JSON.stringify(store, null, 2), "utf-8");
     dirty = false;
   } catch {
   }
@@ -652532,7 +653035,7 @@ var init_usage_tracker = __esm({
 });
 
 // packages/cli/src/api/profiles.ts
-import { existsSync as existsSync132, readFileSync as readFileSync108, writeFileSync as writeFileSync69, mkdirSync as mkdirSync77, readdirSync as readdirSync47, unlinkSync as unlinkSync27 } from "node:fs";
+import { existsSync as existsSync132, readFileSync as readFileSync108, writeFileSync as writeFileSync70, mkdirSync as mkdirSync78, readdirSync as readdirSync47, unlinkSync as unlinkSync27 } from "node:fs";
 import { join as join145 } from "node:path";
 import { homedir as homedir51 } from "node:os";
 import { createCipheriv as createCipheriv5, createDecipheriv as createDecipheriv5, randomBytes as randomBytes26, scryptSync as scryptSync3 } from "node:crypto";
@@ -652596,16 +653099,16 @@ function loadProfile(name10, password, projectDir2) {
 }
 function saveProfile(profile, password, scope = "global", projectDir2) {
   const dir = scope === "project" ? projectProfileDir(projectDir2) : globalProfileDir();
-  mkdirSync77(dir, { recursive: true });
+  mkdirSync78(dir, { recursive: true });
   const sanitized = profile.name.replace(/[^a-zA-Z0-9_-]/g, "");
   const filePath = join145(dir, `${sanitized}.json`);
   profile.modified = (/* @__PURE__ */ new Date()).toISOString();
   if (password) {
     const encrypted = encryptProfile(profile, password);
-    writeFileSync69(filePath, JSON.stringify(encrypted, null, 2), { mode: 384 });
+    writeFileSync70(filePath, JSON.stringify(encrypted, null, 2), { mode: 384 });
   } else {
     profile.encrypted = false;
-    writeFileSync69(filePath, JSON.stringify(profile, null, 2), { mode: 420 });
+    writeFileSync70(filePath, JSON.stringify(profile, null, 2), { mode: 420 });
   }
 }
 function deleteProfile(name10, scope = "global", projectDir2) {
@@ -652789,7 +653292,7 @@ var init_profiles = __esm({
 
 // packages/cli/src/docker.ts
 import { execSync as execSync57, spawn as spawn31 } from "node:child_process";
-import { existsSync as existsSync133, mkdirSync as mkdirSync78, writeFileSync as writeFileSync70 } from "node:fs";
+import { existsSync as existsSync133, mkdirSync as mkdirSync79, writeFileSync as writeFileSync71 } from "node:fs";
 import { join as join146, resolve as resolve51, dirname as dirname40 } from "node:path";
 import { homedir as homedir52 } from "node:os";
 import { fileURLToPath as fileURLToPath18 } from "node:url";
@@ -652940,7 +653443,7 @@ async function ensureOmniusImage(force = false) {
     buildContext = dockerDir;
   } else {
     buildContext = join146(homedir52(), ".omnius", "docker-build");
-    mkdirSync78(buildContext, { recursive: true });
+    mkdirSync79(buildContext, { recursive: true });
     writeDockerfiles(buildContext);
   }
   try {
@@ -653014,8 +653517,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 "$@"
 `;
-  writeFileSync70(join146(dir, "Dockerfile"), dockerfile);
-  writeFileSync70(join146(dir, "docker-entrypoint.sh"), entrypoint, { mode: 493 });
+  writeFileSync71(join146(dir, "Dockerfile"), dockerfile);
+  writeFileSync71(join146(dir, "docker-entrypoint.sh"), entrypoint, { mode: 493 });
 }
 function hasNvidiaGpu() {
   try {
@@ -653273,7 +653776,7 @@ import { fileURLToPath as fileURLToPath19 } from "node:url";
 import { dirname as dirname41, join as join148, resolve as resolve52 } from "node:path";
 import { homedir as homedir53 } from "node:os";
 import { spawn as spawn32, execSync as execSync58 } from "node:child_process";
-import { mkdirSync as mkdirSync79, writeFileSync as writeFileSync71, readFileSync as readFileSync109, readdirSync as readdirSync48, existsSync as existsSync134, watch as fsWatch4, renameSync as renameSync9, unlinkSync as unlinkSync28 } from "node:fs";
+import { mkdirSync as mkdirSync80, writeFileSync as writeFileSync72, readFileSync as readFileSync109, readdirSync as readdirSync48, existsSync as existsSync134, watch as fsWatch4, renameSync as renameSync9, unlinkSync as unlinkSync28 } from "node:fs";
 import { randomBytes as randomBytes27, randomUUID as randomUUID17 } from "node:crypto";
 import { createHash as createHash33 } from "node:crypto";
 function memoryDbPaths3(baseDir = process.cwd()) {
@@ -654048,7 +654551,7 @@ function ollamaStream(ollamaUrl, path12, method, body, onData, onEnd, onError, t
 function jobsDir() {
   const root = resolve52(process.cwd());
   const dir = join148(root, ".omnius", "jobs");
-  mkdirSync79(dir, { recursive: true });
+  mkdirSync80(dir, { recursive: true });
   return dir;
 }
 function loadJob(id) {
@@ -654393,11 +654896,11 @@ function atomicJobWrite(dir, id, job) {
   const finalPath = join148(dir, `${id}.json`);
   const tmpPath = `${finalPath}.tmp.${process.pid}.${Date.now()}`;
   try {
-    writeFileSync71(tmpPath, JSON.stringify(job, null, 2), "utf-8");
+    writeFileSync72(tmpPath, JSON.stringify(job, null, 2), "utf-8");
     renameSync9(tmpPath, finalPath);
   } catch {
     try {
-      writeFileSync71(finalPath, JSON.stringify(job, null, 2), "utf-8");
+      writeFileSync72(finalPath, JSON.stringify(job, null, 2), "utf-8");
     } catch {
     }
     try {
@@ -655880,10 +656383,10 @@ function readUpdateState() {
 function writeUpdateState(state) {
   try {
     const dir = join148(homedir53(), ".omnius");
-    mkdirSync79(dir, { recursive: true });
+    mkdirSync80(dir, { recursive: true });
     const finalPath = updateStateFile();
     const tmpPath = `${finalPath}.tmp.${process.pid}`;
-    writeFileSync71(tmpPath, JSON.stringify(state, null, 2), "utf-8");
+    writeFileSync72(tmpPath, JSON.stringify(state, null, 2), "utf-8");
     renameSync9(tmpPath, finalPath);
   } catch {
   }
@@ -656184,7 +656687,7 @@ async function handleV1Run(req2, res) {
     cwd4 = resolve52(workingDir);
   } else if (isolate) {
     const wsDir = join148(dir, "..", "workspaces", id);
-    mkdirSync79(wsDir, { recursive: true });
+    mkdirSync80(wsDir, { recursive: true });
     cwd4 = wsDir;
   } else {
     cwd4 = resolve52(process.cwd());
@@ -657492,10 +657995,10 @@ async function handleRequest(req2, res, ollamaUrl, verbose) {
           return;
         }
         const { tmpdir: tmpdir23 } = await import("node:os");
-        const { writeFileSync: writeFileSync76, unlinkSync: unlinkSync29 } = await import("node:fs");
+        const { writeFileSync: writeFileSync77, unlinkSync: unlinkSync29 } = await import("node:fs");
         const { join: pjoin } = await import("node:path");
         const tmpPath = pjoin(tmpdir23(), `omnius-clone-upload-${Date.now()}-${safeName3}`);
-        writeFileSync76(tmpPath, buf);
+        writeFileSync77(tmpPath, buf);
         try {
           const ve = getVoiceEngine();
           const msg = await ve.setCloneVoice(tmpPath);
@@ -658087,7 +658590,7 @@ data: ${JSON.stringify(data)}
         }
         for (const f2 of seenFiles) {
           try {
-            writeFileSync71(f2, JSON.stringify({ tasks: [] }, null, 2));
+            writeFileSync72(f2, JSON.stringify({ tasks: [] }, null, 2));
             deleted++;
           } catch {
           }
@@ -659301,11 +659804,11 @@ function setScheduledEnabled(id, enabled2) {
     arr[target.index].enabled = enabled2;
     if (Array.isArray(json?.tasks)) {
       json.tasks = arr;
-      writeFileSync71(target.file, JSON.stringify(json, null, 2));
+      writeFileSync72(target.file, JSON.stringify(json, null, 2));
     } else if (Array.isArray(json)) {
-      writeFileSync71(target.file, JSON.stringify(arr, null, 2));
+      writeFileSync72(target.file, JSON.stringify(arr, null, 2));
     } else {
-      writeFileSync71(target.file, JSON.stringify({ tasks: arr }, null, 2));
+      writeFileSync72(target.file, JSON.stringify({ tasks: arr }, null, 2));
     }
     if (!enabled2) {
       try {
@@ -659335,11 +659838,11 @@ function deleteScheduledById(id) {
     arr.splice(target.index, 1);
     if (Array.isArray(json?.tasks)) {
       json.tasks = arr;
-      writeFileSync71(target.file, JSON.stringify(json, null, 2));
+      writeFileSync72(target.file, JSON.stringify(json, null, 2));
     } else if (Array.isArray(json)) {
-      writeFileSync71(target.file, JSON.stringify(arr, null, 2));
+      writeFileSync72(target.file, JSON.stringify(arr, null, 2));
     } else {
-      writeFileSync71(target.file, JSON.stringify({ tasks: arr }, null, 2));
+      writeFileSync72(target.file, JSON.stringify({ tasks: arr }, null, 2));
     }
     const candidates = [];
     if (id) candidates.push(id);
@@ -659607,9 +660110,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 };
-          mkdirSync79(join148(wdir, ".omnius", "scheduled"), { recursive: true });
-          mkdirSync79(join148(wdir, ".omnius", "scheduled", "logs"), { recursive: true });
-          writeFileSync71(file, JSON.stringify(toWrite, null, 2));
+          mkdirSync80(join148(wdir, ".omnius", "scheduled"), { recursive: true });
+          mkdirSync80(join148(wdir, ".omnius", "scheduled", "logs"), { recursive: true });
+          writeFileSync72(file, JSON.stringify(toWrite, null, 2));
           adopted.push({ file, index: arr.length - 1 });
         }
       } else {
@@ -659742,9 +660245,9 @@ Persistent=true
 WantedBy=timers.target
 `;
         if (!dryRun) {
-          mkdirSync79(unitDir, { recursive: true });
-          writeFileSync71(svc, svcText);
-          writeFileSync71(tim, timText);
+          mkdirSync80(unitDir, { recursive: true });
+          writeFileSync72(svc, svcText);
+          writeFileSync72(tim, timText);
           try {
             const { execSync: es } = require4("node:child_process");
             es("systemctl --user daemon-reload", { stdio: "pipe" });
@@ -659888,7 +660391,7 @@ function startApiServer(options2 = {}) {
   if (!apiTestMode) try {
     const dir = todoDir();
     try {
-      mkdirSync79(dir, { recursive: true });
+      mkdirSync80(dir, { recursive: true });
     } catch {
     }
     const cache8 = /* @__PURE__ */ new Map();
@@ -660066,8 +660569,8 @@ function startApiServer(options2 = {}) {
             runtimeAccessMode = requested;
             try {
               const dir = join148(homedir53(), ".omnius");
-              mkdirSync79(dir, { recursive: true });
-              writeFileSync71(join148(dir, "access"), `${runtimeAccessMode}
+              mkdirSync80(dir, { recursive: true });
+              writeFileSync72(join148(dir, "access"), `${runtimeAccessMode}
 `, "utf8");
             } catch {
             }
@@ -660369,7 +660872,7 @@ function startApiServer(options2 = {}) {
       return;
     }
     try {
-      const { writeFileSync: writeFileSync76, mkdirSync: mkdirSync84, existsSync: _exists, readFileSync: _rfs } = require4("node:fs");
+      const { writeFileSync: writeFileSync77, mkdirSync: mkdirSync85, existsSync: _exists, readFileSync: _rfs } = require4("node:fs");
       const { join: _join } = require4("node:path");
       const { homedir: _homedir } = require4("node:os");
       const apiHint = JSON.stringify({
@@ -660398,8 +660901,8 @@ function startApiServer(options2 = {}) {
       let written = 0;
       for (const dir of dirSet) {
         try {
-          if (!_exists(dir)) mkdirSync84(dir, { recursive: true });
-          writeFileSync76(_join(dir, "api-port.json"), apiHint);
+          if (!_exists(dir)) mkdirSync85(dir, { recursive: true });
+          writeFileSync77(_join(dir, "api-port.json"), apiHint);
           written++;
         } catch {
         }
@@ -660683,9 +661186,9 @@ async function handleChatAttachmentUpload(req2, res) {
     }
     const safeName3 = filename.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 180) || `attachment-${Date.now()}.bin`;
     const dir = join148(process.cwd(), ".omnius", "gui-attachments");
-    mkdirSync79(dir, { recursive: true });
+    mkdirSync80(dir, { recursive: true });
     const localPath = join148(dir, `${Date.now()}-${randomUUID17().slice(0, 8)}-${safeName3}`);
-    writeFileSync71(localPath, Buffer.from(base642, "base64"));
+    writeFileSync72(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;
@@ -661053,15 +661556,15 @@ __export(clipboard_media_exports, {
   pasteClipboardImageToFile: () => pasteClipboardImageToFile
 });
 import { execFileSync as execFileSync8, execSync as execSync59 } from "node:child_process";
-import { mkdirSync as mkdirSync80, readFileSync as readFileSync110, rmSync as rmSync6, writeFileSync as writeFileSync72 } from "node:fs";
+import { mkdirSync as mkdirSync81, readFileSync as readFileSync110, rmSync as rmSync6, writeFileSync as writeFileSync73 } from "node:fs";
 import { join as join149 } from "node:path";
 function pasteClipboardImageToFile(repoRoot) {
   const image = readClipboardImage();
   if (!image) return null;
   const dir = join149(repoRoot, ".omnius", "clipboard");
-  mkdirSync80(dir, { recursive: true });
+  mkdirSync81(dir, { recursive: true });
   const path12 = join149(dir, `clipboard-${Date.now()}${image.ext}`);
-  writeFileSync72(path12, image.buffer);
+  writeFileSync73(path12, image.buffer);
   return { path: path12, buffer: image.buffer, mime: image.mime };
 }
 function readClipboardImage() {
@@ -661130,11 +661633,11 @@ import { createRequire as createRequire8 } from "node:module";
 import { fileURLToPath as fileURLToPath20 } from "node:url";
 import {
   readFileSync as readFileSync111,
-  writeFileSync as writeFileSync73,
+  writeFileSync as writeFileSync74,
   appendFileSync as appendFileSync13,
   rmSync as rmSync7,
   readdirSync as readdirSync49,
-  mkdirSync as mkdirSync81
+  mkdirSync as mkdirSync82
 } from "node:fs";
 import { existsSync as existsSync135 } from "node:fs";
 import { execSync as execSync60 } from "node:child_process";
@@ -663975,7 +664478,7 @@ When done, either call task_complete with your answer, or use FINAL_VAR(variable
           if (existsSync135(ikFile)) {
             ikState = JSON.parse(readFileSync111(ikFile, "utf8"));
           } else {
-            mkdirSync81(ikDir, { recursive: true });
+            mkdirSync82(ikDir, { recursive: true });
             const machineId = Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
             ikState = {
               self_id: `omnius-${machineId}`,
@@ -664085,7 +664588,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();
-          writeFileSync73(ikFile, JSON.stringify(ikState, null, 2));
+          writeFileSync74(ikFile, JSON.stringify(ikState, null, 2));
         } catch (ikErr) {
           try {
             console.error("[IK-OBSERVE]", ikErr);
@@ -664141,7 +664644,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();
-            writeFileSync73(ikFile, JSON.stringify(ikState, null, 2));
+            writeFileSync74(ikFile, JSON.stringify(ikState, null, 2));
           }
         } catch {
         }
@@ -665739,12 +666242,12 @@ This is an independent background session started from /background.`
   function persistHistoryLine(line) {
     if (!line.trim()) return;
     try {
-      mkdirSync81(HISTORY_DIR, { recursive: true });
+      mkdirSync82(HISTORY_DIR, { recursive: true });
       appendFileSync13(HISTORY_FILE, line + "\n", "utf8");
       if (Math.random() < 0.02) {
         const all2 = readFileSync111(HISTORY_FILE, "utf8").trim().split("\n");
         if (all2.length > MAX_HISTORY_LINES) {
-          writeFileSync73(
+          writeFileSync74(
             HISTORY_FILE,
             all2.slice(-MAX_HISTORY_LINES).join("\n") + "\n",
             "utf8"
@@ -666648,8 +667151,8 @@ Log: ${nexusLogPath}`)
     setSessionTitle(title) {
       sessionTitle = title.trim() || null;
       try {
-        mkdirSync81(join150(repoRoot, ".omnius"), { recursive: true });
-        writeFileSync73(join150(repoRoot, ".omnius", "session-title"), `${sessionTitle ?? ""}
+        mkdirSync82(join150(repoRoot, ".omnius"), { recursive: true });
+        writeFileSync74(join150(repoRoot, ".omnius", "session-title"), `${sessionTitle ?? ""}
 `, "utf8");
       } catch {
       }
@@ -669723,7 +670226,7 @@ async function runWithTUI(task, config, repoPath, callbacks) {
       if (existsSync135(ikFile)) {
         ikState = JSON.parse(readFileSync111(ikFile, "utf8"));
       } else {
-        mkdirSync81(ikDir, { recursive: true });
+        mkdirSync82(ikDir, { recursive: true });
         ikState = {
           self_id: `omnius-${Date.now().toString(36)}`,
           version: 1,
@@ -669776,7 +670279,7 @@ async function runWithTUI(task, config, repoPath, callbacks) {
       );
       ikState.session_count = (ikState.session_count || 0) + 1;
       ikState.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-      writeFileSync73(ikFile, JSON.stringify(ikState, null, 2));
+      writeFileSync74(ikFile, JSON.stringify(ikState, null, 2));
     } catch (ikErr) {
     }
     try {
@@ -669808,8 +670311,8 @@ async function runWithTUI(task, config, repoPath, callbacks) {
           tags: ["general"]
         });
         if (variants.length > 50) variants = variants.slice(-50);
-        mkdirSync81(archeDir, { recursive: true });
-        writeFileSync73(archeFile, JSON.stringify(variants, null, 2));
+        mkdirSync82(archeDir, { recursive: true });
+        writeFileSync74(archeFile, JSON.stringify(variants, null, 2));
       } catch {
       }
     }
@@ -669840,7 +670343,7 @@ async function runWithTUI(task, config, repoPath, callbacks) {
           updated = true;
         }
         if (updated) {
-          writeFileSync73(metaFile2, JSON.stringify(store2, null, 2));
+          writeFileSync74(metaFile2, JSON.stringify(store2, null, 2));
         }
       }
     } catch {
@@ -669899,7 +670402,7 @@ Rules:
             const { initDb: initDb2 } = __require("@omnius/memory");
             const { ProceduralMemoryStore: ProceduralMemoryStore2 } = __require("@omnius/memory");
             const dbDir = join150(repoRoot, ".omnius", "memory");
-            mkdirSync81(dbDir, { recursive: true });
+            mkdirSync82(dbDir, { recursive: true });
             const db = initDb2(join150(dbDir, "structured.db"));
             const memStore = new ProceduralMemoryStore2(db);
             memStore.createWithEmbedding(
@@ -669948,8 +670451,8 @@ Rules:
             accessCount: 0
           });
           if (store2.length > 100) store2 = store2.slice(-100);
-          mkdirSync81(metaDir, { recursive: true });
-          writeFileSync73(storeFile, JSON.stringify(store2, null, 2));
+          mkdirSync82(metaDir, { recursive: true });
+          writeFileSync74(storeFile, JSON.stringify(store2, null, 2));
         }
       }
     } catch {
@@ -670013,7 +670516,7 @@ Rules:
         );
         ikState.session_count = (ikState.session_count || 0) + 1;
         ikState.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-        writeFileSync73(ikFile, JSON.stringify(ikState, null, 2));
+        writeFileSync74(ikFile, JSON.stringify(ikState, null, 2));
       }
       const metaFile2 = join150(
         repoRoot,
@@ -670041,7 +670544,7 @@ Rules:
             (item.scores.confidence || 0.5) - 0.02
           );
         }
-        writeFileSync73(metaFile2, JSON.stringify(store2, null, 2));
+        writeFileSync74(metaFile2, JSON.stringify(store2, null, 2));
       }
       try {
         const archeDir = join150(repoRoot, ".omnius", "arche");
@@ -670063,8 +670566,8 @@ Rules:
           tags: ["general"]
         });
         if (variants.length > 50) variants = variants.slice(-50);
-        mkdirSync81(archeDir, { recursive: true });
-        writeFileSync73(archeFile, JSON.stringify(variants, null, 2));
+        mkdirSync82(archeDir, { recursive: true });
+        writeFileSync74(archeFile, JSON.stringify(variants, null, 2));
       } catch {
       }
     } catch {
@@ -670166,13 +670669,13 @@ __export(run_exports, {
 });
 import { resolve as resolve54 } from "node:path";
 import { spawn as spawn33 } from "node:child_process";
-import { mkdirSync as mkdirSync82, writeFileSync as writeFileSync74, readFileSync as readFileSync112, readdirSync as readdirSync50, existsSync as existsSync136 } from "node:fs";
+import { mkdirSync as mkdirSync83, writeFileSync as writeFileSync75, readFileSync as readFileSync112, readdirSync as readdirSync50, existsSync as existsSync136 } from "node:fs";
 import { randomBytes as randomBytes28 } from "node:crypto";
 import { join as join151 } from "node:path";
 function jobsDir2(repoPath) {
   const root = resolve54(repoPath ?? process.cwd());
   const dir = join151(root, ".omnius", "jobs");
-  mkdirSync82(dir, { recursive: true });
+  mkdirSync83(dir, { recursive: true });
   return dir;
 }
 async function runCommand2(opts, config) {
@@ -670294,7 +670797,7 @@ async function runBackground(task, config, opts) {
     }
   });
   job.pid = child.pid ?? 0;
-  writeFileSync74(join151(dir, `${id}.json`), JSON.stringify(job, null, 2));
+  writeFileSync75(join151(dir, `${id}.json`), JSON.stringify(job, null, 2));
   let output = "";
   child.stdout?.on("data", (chunk) => {
     output += chunk.toString();
@@ -670310,7 +670813,7 @@ async function runBackground(task, config, opts) {
       job.summary = result.summary;
       job.durationMs = result.durationMs;
       job.error = result.error;
-      writeFileSync74(join151(dir, `${id}.json`), JSON.stringify(job, null, 2));
+      writeFileSync75(join151(dir, `${id}.json`), JSON.stringify(job, null, 2));
     } catch {
     }
   });
@@ -670944,7 +671447,7 @@ __export(eval_exports, {
   evalCommand: () => evalCommand
 });
 import { tmpdir as tmpdir22 } from "node:os";
-import { mkdirSync as mkdirSync83, writeFileSync as writeFileSync75 } from "node:fs";
+import { mkdirSync as mkdirSync84, writeFileSync as writeFileSync76 } from "node:fs";
 import { join as join153 } from "node:path";
 async function evalCommand(opts, config) {
   const suiteName = opts.suite ?? "basic";
@@ -671075,8 +671578,8 @@ async function evalCommand(opts, config) {
 }
 function createTempEvalRepo() {
   const dir = join153(tmpdir22(), `omnius-eval-${Date.now()}`);
-  mkdirSync83(dir, { recursive: true });
-  writeFileSync75(
+  mkdirSync84(dir, { recursive: true });
+  writeFileSync76(
     join153(dir, "package.json"),
     JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n",
     "utf8"
@@ -671603,11 +672106,11 @@ function crashLog(label, err) {
   const logLine = `[${timestamp}] ${label}: ${msg}
 `;
   try {
-    const { appendFileSync: appendFileSync14, mkdirSync: mkdirSync84 } = __require("node:fs");
+    const { appendFileSync: appendFileSync14, mkdirSync: mkdirSync85 } = __require("node:fs");
     const { join: join155 } = __require("node:path");
     const { homedir: homedir56 } = __require("node:os");
     const logDir = join155(homedir56(), ".omnius");
-    mkdirSync84(logDir, { recursive: true });
+    mkdirSync85(logDir, { recursive: true });
     appendFileSync14(join155(logDir, "crash.log"), logLine);
   } catch {
   }