omnius 1.0.159 → 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 };
+      }
     };
   }
 });
@@ -20856,6 +20884,7 @@ import { existsSync as existsSync24, readdirSync as readdirSync10, readFileSync
 import { join as join27, basename as basename4, dirname as dirname5 } from "node:path";
 import { homedir as homedir8 } from "node:os";
 import { execSync as execSync14 } from "node:child_process";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 function getAiwgPaths() {
   const dataDir = join27(homedir8(), ".local", "share", "ai-writing-guide");
   return {
@@ -20910,6 +20939,24 @@ function findAiwgPackageRoot() {
   _cachedAiwgPkgRoot = null;
   return null;
 }
+function hasBundledOmniusDocs(root) {
+  return existsSync24(join27(root, ".aiwg", "addons", "omnius-docs", "skills", "omnius-docs", "SKILL.md")) && existsSync24(join27(root, ".aiwg", "addons", "omnius-rest-docs", "skills", "omnius-rest-docs", "SKILL.md")) && existsSync24(join27(root, "docs", "agent-memory", "INDEX.md"));
+}
+function findBundledOmniusDocsRoot() {
+  const envRoot = process.env["OMNIUS_DOCS_ROOT"];
+  if (envRoot && hasBundledOmniusDocs(envRoot))
+    return envRoot;
+  let current = dirname5(fileURLToPath2(import.meta.url));
+  for (let depth = 0; depth < 8; depth++) {
+    if (hasBundledOmniusDocs(current))
+      return current;
+    const parent = dirname5(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  return null;
+}
 function discoverSkills(repoRoot) {
   const skills = /* @__PURE__ */ new Map();
   const { frameworksDir, addonsDir, pluginsDir } = getAiwgPaths();
@@ -20953,9 +21000,29 @@ function discoverSkills(repoRoot) {
       loadComponent(join27(pluginsDir, plugin), `plugin:${plugin}`);
     }
   }
+  const bundledDocsRoot = findBundledOmniusDocsRoot();
+  if (bundledDocsRoot) {
+    const bundledAddons = join27(bundledDocsRoot, ".aiwg", "addons");
+    for (const addon of safeReaddir2(bundledAddons, true)) {
+      if (addon !== "omnius-docs" && addon !== "omnius-rest-docs")
+        continue;
+      loadComponent(join27(bundledAddons, addon), `bundled-addon:${addon}`);
+    }
+  }
   const projectAiwg = join27(repoRoot, ".aiwg");
   loadSkillsFromDir(join27(projectAiwg, "skills"), "project", skills);
   loadCommandsFromDir(join27(projectAiwg, "commands"), "project", skills);
+  for (const [kind, sourcePrefix] of [
+    ["addons", "project-addon"],
+    ["extensions", "project-extension"],
+    ["frameworks", "project-framework"],
+    ["plugins", "project-plugin"]
+  ]) {
+    const bundleRoot = join27(projectAiwg, kind);
+    for (const bundle of safeReaddir2(bundleRoot, true)) {
+      loadComponent(join27(bundleRoot, bundle), `${sourcePrefix}:${bundle}`);
+    }
+  }
   const projectOmniusSkills = join27(repoRoot, ".omnius", "skills");
   loadSkillsFromDir(projectOmniusSkills, "local", skills);
   return Array.from(skills.values());
@@ -21400,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: []
@@ -21413,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)));
@@ -21427,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) {
@@ -21441,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"),
@@ -91796,7 +91883,7 @@ var require_axios = __commonJS({
     var isNumber2 = typeOfTest("number");
     var isObject = (thing) => thing !== null && typeof thing === "object";
     var isBoolean = (thing) => thing === true || thing === false;
-    var isPlainObject = (val) => {
+    var isPlainObject2 = (val) => {
       if (kindOf(val) !== "object") {
         return false;
       }
@@ -91901,9 +91988,9 @@ var require_axios = __commonJS({
           return;
         }
         const targetKey = caseless && findKey(result, key) || key;
-        if (isPlainObject(result[targetKey]) && isPlainObject(val)) {
+        if (isPlainObject2(result[targetKey]) && isPlainObject2(val)) {
           result[targetKey] = merge2(result[targetKey], val);
-        } else if (isPlainObject(val)) {
+        } else if (isPlainObject2(val)) {
           result[targetKey] = merge2({}, val);
         } else if (isArray(val)) {
           result[targetKey] = val.slice();
@@ -92137,7 +92224,7 @@ var require_axios = __commonJS({
       isNumber: isNumber2,
       isBoolean,
       isObject,
-      isPlainObject,
+      isPlainObject: isPlainObject2,
       isEmptyObject,
       isReadableStream,
       isRequest,
@@ -225156,7 +225243,7 @@ var require_defaults = __commonJS({
 var require_Utility = __commonJS({
   "../node_modules/xmlbuilder/lib/Utility.js"(exports, module) {
     (function() {
-      var assign, getValue, isArray, isEmpty, isFunction, isObject, isPlainObject, slice2 = [].slice, hasProp = {}.hasOwnProperty;
+      var assign, getValue, isArray, isEmpty, isFunction, isObject, isPlainObject2, slice2 = [].slice, hasProp = {}.hasOwnProperty;
       assign = function() {
         var i2, key, len, source, sources, target;
         target = arguments[0], sources = 2 <= arguments.length ? slice2.call(arguments, 1) : [];
@@ -225201,7 +225288,7 @@ var require_Utility = __commonJS({
           return true;
         }
       };
-      isPlainObject = function(val) {
+      isPlainObject2 = function(val) {
         var ctor, proto;
         return isObject(val) && (proto = Object.getPrototypeOf(val)) && (ctor = proto.constructor) && typeof ctor === "function" && ctor instanceof ctor && Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object);
       };
@@ -225217,7 +225304,7 @@ var require_Utility = __commonJS({
       module.exports.isObject = isObject;
       module.exports.isArray = isArray;
       module.exports.isEmpty = isEmpty;
-      module.exports.isPlainObject = isPlainObject;
+      module.exports.isPlainObject = isPlainObject2;
       module.exports.getValue = getValue;
     }).call(exports);
   }
@@ -228031,7 +228118,7 @@ var require_XMLStringWriter = __commonJS({
 var require_XMLDocument = __commonJS({
   "../node_modules/xmlbuilder/lib/XMLDocument.js"(exports, module) {
     (function() {
-      var NodeType, XMLDOMConfiguration, XMLDOMImplementation, XMLDocument, XMLNode, XMLStringWriter, XMLStringifier, isPlainObject, extend = function(child, parent) {
+      var NodeType, XMLDOMConfiguration, XMLDOMImplementation, XMLDocument, XMLNode, XMLStringWriter, XMLStringifier, isPlainObject2, extend = function(child, parent) {
         for (var key in parent) {
           if (hasProp.call(parent, key)) child[key] = parent[key];
         }
@@ -228043,7 +228130,7 @@ var require_XMLDocument = __commonJS({
         child.__super__ = parent.prototype;
         return child;
       }, hasProp = {}.hasOwnProperty;
-      isPlainObject = require_Utility().isPlainObject;
+      isPlainObject2 = require_Utility().isPlainObject;
       XMLDOMImplementation = require_XMLDOMImplementation();
       XMLDOMConfiguration = require_XMLDOMConfiguration();
       XMLNode = require_XMLNode();
@@ -228153,7 +228240,7 @@ var require_XMLDocument = __commonJS({
           writerOptions = {};
           if (!writer) {
             writer = this.options.writer;
-          } else if (isPlainObject(writer)) {
+          } else if (isPlainObject2(writer)) {
             writerOptions = writer;
             writer = this.options.writer;
           }
@@ -228238,8 +228325,8 @@ var require_XMLDocument = __commonJS({
 var require_XMLDocumentCB = __commonJS({
   "../node_modules/xmlbuilder/lib/XMLDocumentCB.js"(exports, module) {
     (function() {
-      var NodeType, WriterState, XMLAttribute, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDocument, XMLDocumentCB, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStringWriter, XMLStringifier, XMLText, getValue, isFunction, isObject, isPlainObject, ref, hasProp = {}.hasOwnProperty;
-      ref = require_Utility(), isObject = ref.isObject, isFunction = ref.isFunction, isPlainObject = ref.isPlainObject, getValue = ref.getValue;
+      var NodeType, WriterState, XMLAttribute, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDocument, XMLDocumentCB, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStringWriter, XMLStringifier, XMLText, getValue, isFunction, isObject, isPlainObject2, ref, hasProp = {}.hasOwnProperty;
+      ref = require_Utility(), isObject = ref.isObject, isFunction = ref.isFunction, isPlainObject2 = ref.isPlainObject, getValue = ref.getValue;
       NodeType = require_NodeType();
       XMLDocument = require_XMLDocument();
       XMLElement = require_XMLElement();
@@ -228267,7 +228354,7 @@ var require_XMLDocumentCB = __commonJS({
           writerOptions = {};
           if (!options2.writer) {
             options2.writer = new XMLStringWriter();
-          } else if (isPlainObject(options2.writer)) {
+          } else if (isPlainObject2(options2.writer)) {
             writerOptions = options2.writer;
             options2.writer = new XMLStringWriter();
           }
@@ -247631,8 +247718,8 @@ var require_fill_range = __commonJS({
     var util2 = __require("util");
     var toRegexRange = require_to_regex_range();
     var isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
-    var transform = (toNumber) => {
-      return (value2) => toNumber === true ? Number(value2) : String(value2);
+    var transform = (toNumber2) => {
+      return (value2) => toNumber2 === true ? Number(value2) : String(value2);
     };
     var isValidValue = (value2) => {
       return typeof value2 === "number" || typeof value2 === "string" && value2 !== "";
@@ -247652,13 +247739,13 @@ var require_fill_range = __commonJS({
       }
       return options2.stringify === true;
     };
-    var pad = (input, maxLength, toNumber) => {
+    var pad = (input, maxLength, toNumber2) => {
       if (maxLength > 0) {
         let dash = input[0] === "-" ? "-" : "";
         if (dash) input = input.slice(1);
         input = dash + input.padStart(dash ? maxLength - 1 : maxLength, "0");
       }
-      if (toNumber === false) {
+      if (toNumber2 === false) {
         return String(input);
       }
       return input;
@@ -247741,8 +247828,8 @@ var require_fill_range = __commonJS({
       step = Math.max(Math.abs(step), 1);
       let padded = zeros(startString) || zeros(endString) || zeros(stepString);
       let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
-      let toNumber = padded === false && stringify2(start2, end, options2) === false;
-      let format3 = options2.transform || transform(toNumber);
+      let toNumber2 = padded === false && stringify2(start2, end, options2) === false;
+      let format3 = options2.transform || transform(toNumber2);
       if (options2.toRegex && step === 1) {
         return toRange(toMaxLen(start2, maxLen), toMaxLen(end, maxLen), true, options2);
       }
@@ -247754,7 +247841,7 @@ var require_fill_range = __commonJS({
         if (options2.toRegex === true && step > 1) {
           push(a2);
         } else {
-          range.push(pad(format3(a2, index), maxLen, toNumber));
+          range.push(pad(format3(a2, index), maxLen, toNumber2));
         }
         a2 = descending ? a2 - step : a2 + step;
         index++;
@@ -252908,9 +252995,9 @@ var init_src107 = __esm({
 // ../node_modules/steno/lib/index.js
 import { rename as rename3, writeFile as writeFile10 } from "node:fs/promises";
 import { basename as basename6, dirname as dirname8, join as join31 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 function getTempFilename(file) {
-  const f2 = file instanceof URL ? fileURLToPath2(file) : file.toString();
+  const f2 = file instanceof URL ? fileURLToPath3(file) : file.toString();
   return join31(dirname8(f2), `.${basename6(f2)}.tmp`);
 }
 async function retryAsyncOperation(fn, maxRetries, delayMs) {
@@ -254218,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 = `
@@ -254244,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 {
@@ -254853,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))
@@ -254884,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 ──────────────────────────────────────────────────────────
@@ -255331,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 = [];
@@ -255352,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");
@@ -263698,7 +263785,7 @@ __export(vision_exports, {
 import { readFileSync as readFileSync23, existsSync as existsSync31, statSync as statSync14, unlinkSync as unlinkSync5, writeFileSync as writeFileSync14 } from "node:fs";
 import { execSync as execSync16, spawn as spawn11, spawnSync as spawnSync3 } from "node:child_process";
 import { resolve as resolve22, extname as extname6, basename as basename7, dirname as dirname9, join as join42 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 async function probeStation(endpoint) {
   try {
     const healthUrl = endpoint.replace(/\/v1\/?$/, "/health");
@@ -263726,7 +263813,7 @@ function findStationBinary() {
   const omniusVenvBin = isWin2 ? join42(venvBase, "Scripts", "moondream-station.exe") : join42(venvBase, "bin", "moondream-station");
   if (existsSync31(omniusVenvBin))
     return omniusVenvBin;
-  const thisDir = dirname9(fileURLToPath3(import.meta.url));
+  const thisDir = dirname9(fileURLToPath4(import.meta.url));
   const pyBin = isWin2 ? "Scripts/python.exe" : "bin/python";
   const localVenvPaths = [
     resolve22(thisDir, `../../../../.moondream-venv/${pyBin}`),
@@ -263763,7 +263850,7 @@ async function autoLaunchStation(port = 2020) {
   const pythonBin = findStationBinary();
   if (!pythonBin)
     return false;
-  const thisDir = dirname9(fileURLToPath3(import.meta.url));
+  const thisDir = dirname9(fileURLToPath4(import.meta.url));
   const launcherScript = resolve22(thisDir, "../../scripts/start-moondream.py");
   if (!existsSync31(launcherScript))
     return false;
@@ -265352,10 +265439,10 @@ ${text}`,
 import { existsSync as existsSync34, statSync as statSync17 } from "node:fs";
 import { resolve as resolve25, basename as basename10, dirname as dirname10, join as join45 } from "node:path";
 import { execSync as execSync20 } from "node:child_process";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { homedir as homedir12, tmpdir as tmpdir8 } from "node:os";
 function findOcrScript() {
-  const thisDir = dirname10(fileURLToPath4(import.meta.url));
+  const thisDir = dirname10(fileURLToPath5(import.meta.url));
   const devPath3 = resolve25(thisDir, "../../scripts/ocr-advanced.py");
   if (existsSync34(devPath3))
     return devPath3;
@@ -265656,7 +265743,7 @@ Note: Advanced Python pipeline not available — install pytesseract, opencv-pyt
 import { execSync as execSync21, spawn as spawn12 } from "node:child_process";
 import { copyFileSync, existsSync as existsSync35, mkdirSync as mkdirSync13, readFileSync as readFileSync26 } from "node:fs";
 import { basename as basename11, dirname as dirname11, join as join46, resolve as resolve26 } from "node:path";
-import { fileURLToPath as fileURLToPath5 } from "node:url";
+import { fileURLToPath as fileURLToPath6 } from "node:url";
 function findScrapeScript() {
   const candidates = [
     // Published npm package: dist/scripts/web_scrape.py
@@ -265810,7 +265897,7 @@ var init_browser_action = __esm({
     "use strict";
     init_dom_summary();
     init_network_egress_policy();
-    __dirname3 = dirname11(fileURLToPath5(import.meta.url));
+    __dirname3 = dirname11(fileURLToPath6(import.meta.url));
     DEFAULT_PORT = 8130;
     SCRAPE_SCRIPT = findScrapeScript();
     BASE_URL = `http://localhost:${DEFAULT_PORT}`;
@@ -266173,9 +266260,9 @@ var init_browser_action = __esm({
 import { execSync as execSync22, spawn as spawn13 } from "node:child_process";
 import { existsSync as existsSync36, readFileSync as readFileSync27, writeFileSync as writeFileSync15, mkdirSync as mkdirSync14, appendFileSync, copyFileSync as copyFileSync2 } from "node:fs";
 import { join as join47, resolve as resolve27, dirname as dirname12 } from "node:path";
-import { fileURLToPath as fileURLToPath6 } from "node:url";
+import { fileURLToPath as fileURLToPath7 } from "node:url";
 function findAutoresearchScript(scriptName) {
-  const thisDir = dirname12(fileURLToPath6(import.meta.url));
+  const thisDir = dirname12(fileURLToPath7(import.meta.url));
   const devPath3 = resolve27(thisDir, "../../scripts", scriptName);
   if (existsSync36(devPath3))
     return devPath3;
@@ -522366,11 +522453,11 @@ import { execSync as execSync40, spawnSync as spawnSync6 } from "node:child_proc
 import { existsSync as existsSync51, mkdirSync as mkdirSync25, writeFileSync as writeFileSync23, readFileSync as readFileSync38, unlinkSync as unlinkSync11 } from "node:fs";
 import { dirname as dirname15, join as join67, resolve as resolve34 } from "node:path";
 import { tmpdir as tmpdir17, homedir as homedir21 } from "node:os";
-import { fileURLToPath as fileURLToPath7 } from "node:url";
+import { fileURLToPath as fileURLToPath8 } from "node:url";
 function _findNemotronScript() {
   const candidates = [];
   try {
-    const here = dirname15(fileURLToPath7(import.meta.url));
+    const here = dirname15(fileURLToPath8(import.meta.url));
     candidates.push(resolve34(here, "../../scripts/live-nemotron.py"));
     candidates.push(resolve34(here, "../../../scripts/live-nemotron.py"));
   } catch {
@@ -526320,7 +526407,7 @@ Topic: ${segments.slice(0, 5).map((s2) => s2.text).join(" ").slice(0, 300)}`,
 import { existsSync as existsSync58, readFileSync as readFileSync44, statSync as statSync25 } from "node:fs";
 import { spawn as spawn19 } from "node:child_process";
 import { resolve as resolve36, dirname as dirname18, join as join73, basename as basename16 } from "node:path";
-import { fileURLToPath as fileURLToPath8 } from "node:url";
+import { fileURLToPath as fileURLToPath9 } from "node:url";
 import { homedir as homedir25 } from "node:os";
 function loadConfig2() {
   if (!existsSync58(CONFIG_PATH))
@@ -526343,7 +526430,7 @@ async function probeSidecar(port) {
   }
 }
 function findLauncherScript() {
-  const here = dirname18(fileURLToPath8(import.meta.url));
+  const here = dirname18(fileURLToPath9(import.meta.url));
   const candidates = [
     resolve36(here, "../../scripts/start-video-scan.py"),
     resolve36(here, "../scripts/start-video-scan.py")
@@ -526571,7 +526658,7 @@ Format OK: ${r2.format_ok}`;
 import { existsSync as existsSync59, readFileSync as readFileSync45 } from "node:fs";
 import { spawn as spawn20 } from "node:child_process";
 import { resolve as resolve37, dirname as dirname19, join as join74, basename as basename17 } from "node:path";
-import { fileURLToPath as fileURLToPath9 } from "node:url";
+import { fileURLToPath as fileURLToPath10 } from "node:url";
 import { homedir as homedir26 } from "node:os";
 function loadConfig3() {
   if (!existsSync59(CONFIG_PATH2))
@@ -526594,7 +526681,7 @@ async function probeSidecar2(port) {
   }
 }
 function findLauncherScript2() {
-  const here = dirname19(fileURLToPath9(import.meta.url));
+  const here = dirname19(fileURLToPath10(import.meta.url));
   const candidates = [
     resolve37(here, "../../scripts/start-lance.py"),
     resolve37(here, "../scripts/start-lance.py")
@@ -528913,7 +529000,7 @@ var init_dist6 = __esm({
 // packages/orchestrator/dist/promptLoader.js
 import { readFileSync as readFileSync49, existsSync as existsSync63 } from "node:fs";
 import { join as join77, dirname as dirname21 } from "node:path";
-import { fileURLToPath as fileURLToPath10 } from "node:url";
+import { fileURLToPath as fileURLToPath11 } from "node:url";
 function loadPrompt(promptPath, vars) {
   let content = cache5.get(promptPath);
   if (content === void 0) {
@@ -528932,7 +529019,7 @@ var __filename3, __dirname4, PROMPTS_DIR, cache5;
 var init_promptLoader = __esm({
   "packages/orchestrator/dist/promptLoader.js"() {
     "use strict";
-    __filename3 = fileURLToPath10(import.meta.url);
+    __filename3 = fileURLToPath11(import.meta.url);
     __dirname4 = dirname21(__filename3);
     PROMPTS_DIR = join77(__dirname4, "..", "prompts");
     cache5 = /* @__PURE__ */ new Map();
@@ -532148,7 +532235,7 @@ var init_personality = __esm({
 // packages/orchestrator/dist/critic.js
 function buildForceProgressBlockMessage(call, hits) {
   const argPreview = JSON.stringify(call.args ?? {}).slice(0, 200);
-  return `[FORCED PROGRESS BLOCK — duplicate ${call.tool} call skipped; this is not a tool failure. You have called ${call.tool}(${argPreview}) ${hits} times with identical arguments. The runtime did not re-run the tool; it is returning the cached result below so you can proceed without retrying.
+  return `[FORCED PROGRESS BLOCK — duplicate ${call.tool} call skipped; this is not a tool failure. You have called ${call.tool}(${argPreview}) ${hits} times with identical arguments. The runtime did not re-run the tool; it is returning the prior result below so you can proceed without retrying.
 
 Progress is REQUIRED before this tool will run again with the same arguments. To proceed, do one of these:
   • file_write or file_edit to make progress, OR
@@ -532157,7 +532244,7 @@ Progress is REQUIRED before this tool will run again with the same arguments. To
   • Call a different tool or use different arguments.]`;
 }
 function buildCachedResultEnvelope(result) {
-  return `[CACHED RESULT — you already have this information from a prior successful call. Do NOT call this tool again with the same arguments.]
+  return `[CACHED RESULT — you already have this information from a prior identical call. Do NOT call this tool again with the same arguments.]
 ${result}`;
 }
 function evaluate(inputs) {
@@ -532170,7 +532257,8 @@ function evaluate(inputs) {
       cachedResult: cached ? buildCachedResultEnvelope(cached.result) : null
     };
   }
-  if (isReadLike) {
+  const cacheEligible = isReadLike || proposedCall.tool === "shell";
+  if (cacheEligible) {
     const cached = recentToolResults.get(fingerprint);
     if (cached !== void 0) {
       const hits = (dedupHitCount.get(fingerprint) ?? 0) + 1;
@@ -542541,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 {
         }
       }
@@ -544478,6 +544566,510 @@ var init_modelProfile = __esm({
   }
 });
 
+// packages/orchestrator/dist/failureHandoff.js
+function isPlainObject(value2) {
+  return !!value2 && typeof value2 === "object" && !Array.isArray(value2);
+}
+function toEntries(patterns) {
+  if (!patterns)
+    return [];
+  if (patterns instanceof Map)
+    return Array.from(patterns.entries());
+  if (isPlainObject(patterns))
+    return Object.entries(patterns);
+  return [];
+}
+function toNumber(value2, fallback = 0) {
+  return typeof value2 === "number" && Number.isFinite(value2) ? value2 : fallback;
+}
+function toOptionalNumber(value2) {
+  return typeof value2 === "number" && Number.isFinite(value2) ? value2 : void 0;
+}
+function cleanInline(value2, max = 220) {
+  if (typeof value2 !== "string")
+    return "";
+  const normalized = value2.split("\n").map((line) => line.trim()).filter(Boolean).join(" ");
+  return normalized.length > max ? `${normalized.slice(0, max - 3)}...` : normalized;
+}
+function normalizeModifiedFiles(modifiedFiles) {
+  if (!modifiedFiles)
+    return [];
+  if (modifiedFiles instanceof Map)
+    return Array.from(modifiedFiles.entries());
+  if (Array.isArray(modifiedFiles))
+    return modifiedFiles;
+  if (isPlainObject(modifiedFiles))
+    return Object.entries(modifiedFiles);
+  return [];
+}
+function recordEntry(merged, entry) {
+  const existing = merged.get(entry.signature);
+  if (!existing || entry.count > existing.count) {
+    merged.set(entry.signature, entry);
+    return;
+  }
+  if (existing.guidance.length === 0 && entry.guidance.length > 0) {
+    merged.set(entry.signature, { ...existing, guidance: entry.guidance });
+  }
+}
+function normalizeFailurePatterns(patterns) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const [signature, raw] of toEntries(patterns)) {
+    if (signature === "patterns" && isPlainObject(raw)) {
+      for (const legacyRaw of Object.values(raw)) {
+        if (!isPlainObject(legacyRaw))
+          continue;
+        const legacyId = cleanInline(legacyRaw["id"], 120);
+        const pattern = cleanInline(legacyRaw["pattern"], 220);
+        const cause = cleanInline(legacyRaw["cause"], 220);
+        const solution = cleanInline(legacyRaw["solution"], 260);
+        const legacySignature = legacyId || pattern;
+        if (!legacySignature)
+          continue;
+        const guidanceParts = [cause, solution].filter(Boolean);
+        recordEntry(merged, {
+          signature: legacySignature,
+          count: toNumber(legacyRaw["count"], 1),
+          guidance: guidanceParts.length > 0 ? guidanceParts.join(" ") : pattern,
+          lastSeen: toOptionalNumber(legacyRaw["lastSeen"]),
+          source: "legacy"
+        });
+      }
+      continue;
+    }
+    if (!isPlainObject(raw))
+      continue;
+    const count = toNumber(raw["count"], 0);
+    if (count <= 0)
+      continue;
+    recordEntry(merged, {
+      signature,
+      count,
+      guidance: cleanInline(raw["guidance"], 300),
+      tool: cleanInline(raw["tool"], 80) || void 0,
+      errorType: cleanInline(raw["errorType"], 80) || void 0,
+      lastSeen: toOptionalNumber(raw["lastSeen"]),
+      source: "direct"
+    });
+  }
+  return Array.from(merged.values()).sort((a2, b) => {
+    if (b.count !== a2.count)
+      return b.count - a2.count;
+    return a2.signature.localeCompare(b.signature);
+  });
+}
+function buildFailureModeHandoff(input) {
+  const patterns = normalizeFailurePatterns(input.errorPatterns).slice(0, input.maxPatterns ?? 10);
+  const toolCalls = input.toolCallLog ?? [];
+  const maxRecentCalls = input.maxRecentCalls ?? 8;
+  const recentCalls = maxRecentCalls > 0 ? toolCalls.slice(-maxRecentCalls) : [];
+  const failedCalls = toolCalls.filter((call) => call.success === false);
+  const modified = normalizeModifiedFiles(input.taskState?.modifiedFiles);
+  const failedApproaches = input.taskState?.failedApproaches ?? [];
+  const completedSteps = input.taskState?.completedSteps ?? [];
+  const pendingSteps = input.taskState?.pendingSteps ?? [];
+  const currentStep = cleanInline(input.taskState?.currentStep, 180);
+  const nextAction = cleanInline(input.taskState?.nextAction, 180);
+  const goal = cleanInline(input.taskGoal || input.taskState?.goal || input.taskState?.originalGoal || "", 260);
+  if (patterns.length === 0 && recentCalls.length === 0 && modified.length === 0 && failedApproaches.length === 0 && !goal) {
+    return null;
+  }
+  const lines = ["[FAILURE-MODE INTAKE]"];
+  if (goal)
+    lines.push(`Goal: ${goal}`);
+  if (patterns.length > 0) {
+    lines.push("Top persisted failure modes:");
+    for (const p2 of patterns) {
+      const guidance = p2.guidance ? ` - ${p2.guidance}` : "";
+      lines.push(`- ${p2.signature} x${p2.count}${guidance}`);
+    }
+  }
+  if (recentCalls.length > 0) {
+    const total = toolCalls.length;
+    const failed = failedCalls.length;
+    const mutations = toolCalls.filter((call) => call.mutated || (call.mutatedFiles?.length ?? 0) > 0).length;
+    lines.push(`Current run: ${total} tool calls, ${failed} failed, ${mutations} mutation calls.`);
+    const lastFailure = failedCalls[failedCalls.length - 1];
+    if (lastFailure) {
+      const preview = cleanInline(lastFailure.outputPreview, 240);
+      lines.push(`Last raw failure: ${lastFailure.name}${preview ? ` - ${preview}` : ""}`);
+    }
+  }
+  if (modified.length > 0) {
+    lines.push(`Files touched: ${modified.slice(-8).map(([path12, action]) => `${path12} (${action})`).join(", ")}`);
+  } else {
+    lines.push("Files touched: none recorded.");
+  }
+  if (completedSteps.length > 0) {
+    lines.push(`Recent completed steps: ${completedSteps.slice(-4).join("; ")}`);
+  }
+  if (currentStep)
+    lines.push(`Current step: ${currentStep}`);
+  if (failedApproaches.length > 0) {
+    lines.push(`Failed approaches: ${failedApproaches.slice(-4).join("; ")}`);
+  }
+  if (pendingSteps.length > 0) {
+    lines.push(`Remaining work: ${pendingSteps.slice(0, 5).join("; ")}`);
+  } else if (nextAction) {
+    lines.push(`Next action: ${nextAction}`);
+  }
+  lines.push("Operating rule: base the next move on the raw failure/output state above; do not repeat the same failed approach unchanged.");
+  lines.push("[/FAILURE-MODE INTAKE]");
+  return lines.join("\n");
+}
+function computeCommitProgressGate(input) {
+  const cooldown = input.cooldownTurns ?? 4;
+  if (typeof input.lastInjectedTurn === "number" && input.lastInjectedTurn >= 0 && input.turn - input.lastInjectedTurn < cooldown) {
+    return { shouldInject: false };
+  }
+  const touched = normalizeModifiedFiles(input.taskState?.modifiedFiles);
+  const mutationCalls = input.toolCallLog.filter((call) => call.mutated || (call.mutatedFiles?.length ?? 0) > 0);
+  if (touched.length > 0 || mutationCalls.length > 0) {
+    return { shouldInject: false };
+  }
+  const successfulDiscovery = input.toolCallLog.filter((call) => call.success === true && DISCOVERY_TOOLS.has(call.name));
+  if (successfulDiscovery.length < 3)
+    return { shouldInject: false };
+  const lastTools = input.toolCallLog.slice(-5).map((call) => `${call.name}:${call.success === false ? "failed" : "ok"}`).join(", ");
+  return {
+    shouldInject: true,
+    content: [
+      "[PROGRESS GATE - evidence gathered, no files changed]",
+      `Successful discovery calls: ${successfulDiscovery.length}. Files touched: none recorded.`,
+      lastTools ? `Recent tools: ${lastTools}.` : "",
+      "If the current task requires a repo change, make the smallest direct edit now. If no edit is required, or a blocker prevents one, state that explicitly in the next action instead of doing generic discovery.",
+      "[/PROGRESS GATE]"
+    ].filter(Boolean).join("\n")
+  };
+}
+function computeShellFailurePivot(input) {
+  const cooldown = input.cooldownTurns ?? 3;
+  if (typeof input.lastInjectedTurn === "number" && input.lastInjectedTurn >= 0 && input.turn - input.lastInjectedTurn < cooldown) {
+    return { shouldInject: false };
+  }
+  const recentShellFailures = input.toolCallLog.slice(-4).filter((call) => call.name === "shell" && call.success === false);
+  if (recentShellFailures.length < 2)
+    return { shouldInject: false };
+  const raw = recentShellFailures.map((call) => cleanInline(call.outputPreview, 220)).filter(Boolean).slice(-2);
+  return {
+    shouldInject: true,
+    content: [
+      "[SHELL FAILURE PIVOT - raw output repeated]",
+      `Recent failed shell calls: ${recentShellFailures.length}.`,
+      raw.length > 0 ? `Raw failure preview: ${raw.join(" | ")}` : "",
+      "Switch approach before issuing another shell command with similar intent. Prefer a direct file/tool action when it can make progress, or run one simpler command that isolates a single missing fact.",
+      "[/SHELL FAILURE PIVOT]"
+    ].filter(Boolean).join("\n")
+  };
+}
+function computeNoProgressCompletionGate(input) {
+  const touched = normalizeModifiedFiles(input.taskState?.modifiedFiles);
+  const mutationCalls = input.toolCallLog.filter((call) => call.mutated || (call.mutatedFiles?.length ?? 0) > 0);
+  if (touched.length > 0 || mutationCalls.length > 0) {
+    return { shouldInject: false };
+  }
+  const successfulDiscovery = input.toolCallLog.filter((call) => call.success === true && DISCOVERY_TOOLS.has(call.name));
+  if (successfulDiscovery.length < 3)
+    return { shouldInject: false };
+  const summary = (input.summary ?? "").trim();
+  if (summary.startsWith("BLOCKED:") || summary.startsWith("NO FILE CHANGES REQUIRED:")) {
+    return { shouldInject: false };
+  }
+  return {
+    shouldInject: true,
+    content: [
+      "[TASK_COMPLETE HELD - no recorded deliverable]",
+      `This run has ${successfulDiscovery.length} successful discovery calls and no recorded file mutations.`,
+      "If the requested work truly needs no file change, retry task_complete with summary starting `NO FILE CHANGES REQUIRED:` and explain the evidence. If you are blocked, retry with `BLOCKED:` and the blocker. Otherwise make the smallest direct change before completing.",
+      "[/TASK_COMPLETE HELD]"
+    ].join("\n")
+  };
+}
+var DISCOVERY_TOOLS;
+var init_failureHandoff = __esm({
+  "packages/orchestrator/dist/failureHandoff.js"() {
+    "use strict";
+    DISCOVERY_TOOLS = /* @__PURE__ */ new Set([
+      "file_read",
+      "grep_search",
+      "find_files",
+      "list_directory",
+      "file_explore",
+      "memory_read",
+      "working_notes",
+      "memex_retrieve"
+    ]);
+  }
+});
+
+// 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, {
@@ -545826,6 +546418,8 @@ var init_agenticRunner = __esm({
     init_streaming_executor();
     init_specDecomposer();
     init_modelProfile();
+    init_failureHandoff();
+    init_context_fabric();
     TOOL_SUBSETS = {
       web: ["web_search", "web_fetch", "web_crawl"],
       code: [
@@ -546263,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)
@@ -548427,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;
@@ -548485,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) {
@@ -548501,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) {
@@ -548524,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:`
         ];
@@ -548535,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)
@@ -548548,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";
@@ -548717,6 +549386,24 @@ ${blob}
           return "undefined";
         return value2;
       }
+      _buildShellCacheResult(args, result) {
+        const command = String(args["command"] ?? args["cmd"] ?? "").slice(0, 800);
+        const status = result.success ? "success" : "failure";
+        const error = String(result.error ?? "").trim();
+        const output = String(result.output ?? "").trim();
+        const lines = [
+          "[SHELL RESULT CACHE]",
+          `status: ${status}`,
+          command ? `command: ${command}` : "",
+          error ? "error:" : "",
+          error ? error.slice(0, 3e3) : "",
+          output ? "output:" : "",
+          output ? output.slice(0, 5e3) : ""
+        ].filter(Boolean);
+        const body = lines.join("\n");
+        return body.length > 8e3 ? `${body.slice(0, 8e3)}
+... [shell cache payload truncated; full output was already captured by the original tool result/log packet if applicable]` : body;
+      }
       _isStatefulBrowserTool(name10) {
         return name10 === "playwright_browser" || name10 === "browser_action";
       }
@@ -549250,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");
@@ -549292,10 +549981,16 @@ Respond with your assessment, then take action.`;
             try {
               if (fs11.existsSync(patternsFile)) {
                 const saved = JSON.parse(fs11.readFileSync(patternsFile, "utf8"));
-                for (const [sig, pattern] of Object.entries(saved)) {
-                  const existing = this._errorPatterns.get(sig);
-                  if (!existing || (pattern.count ?? 0) > (existing.count ?? 0)) {
-                    this._errorPatterns.set(sig, pattern);
+                for (const pattern of normalizeFailurePatterns(saved)) {
+                  const existing = this._errorPatterns.get(pattern.signature);
+                  if (!existing || pattern.count > (existing.count ?? 0)) {
+                    this._errorPatterns.set(pattern.signature, {
+                      count: pattern.count,
+                      guidance: pattern.guidance,
+                      lastSeen: pattern.lastSeen,
+                      tool: pattern.tool,
+                      errorType: pattern.errorType
+                    });
                   }
                 }
               }
@@ -549578,6 +550273,29 @@ TASK: ${scrubbedTask}` : scrubbedTask;
           }
         } catch {
         }
+        if (process.env["OMNIUS_DISABLE_FAILURE_HANDOFF"] !== "1") {
+          try {
+            const failureHandoff = buildFailureModeHandoff({
+              taskGoal: cleanedTask,
+              errorPatterns: this._errorPatterns,
+              toolCallLog,
+              taskState: this._taskState,
+              maxPatterns: 10,
+              maxRecentCalls: 0
+            });
+            if (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 {
+          }
+        }
         let toolDefs = await this.buildToolDefinitions();
         const baseInstructions = getSystemPromptForTier(this.options.modelTier);
         this.checkPromptToolParity(baseInstructions, toolDefs);
@@ -549635,6 +550353,9 @@ TASK: ${scrubbedTask}` : scrubbedTask;
         let consecutiveEmptyResponses = 0;
         let sameToolFailStreak = 0;
         let sameToolFailName = null;
+        let lastFailureHandoffTurn = -1;
+        let lastCommitGateTurn = -1;
+        let lastShellPivotTurn = -1;
         const recentToolResults = /* @__PURE__ */ new Map();
         const dedupHitCount = /* @__PURE__ */ new Map();
         const DEDUP_ESCALATION_THRESHOLD = 3;
@@ -549690,6 +550411,26 @@ TASK: ${scrubbedTask}` : scrubbedTask;
           }
           return false;
         };
+        const holdNoProgressTaskComplete = (args, turn) => {
+          if (process.env["OMNIUS_DISABLE_PROGRESS_GATES"] === "1")
+            return false;
+          const proposedSummary = extractTaskCompleteSummary(args);
+          const gate = computeNoProgressCompletionGate({
+            summary: proposedSummary,
+            toolCallLog,
+            taskState: this._taskState
+          });
+          if (!gate.shouldInject || !gate.content)
+            return false;
+          messages2.push({ role: "system", content: gate.content });
+          this.emit({
+            type: "status",
+            content: "task_complete held: discovery happened but no deliverable or explicit blocker is recorded",
+            turn,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return true;
+        };
         const turnCap = this.options.maxTurns && this.options.maxTurns > 0 ? this.options.maxTurns : Number.MAX_SAFE_INTEGER;
         for (let turn = 0; turn < turnCap; turn++) {
           clearTurnState(this._appState);
@@ -551004,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 {
             }
@@ -551016,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,
@@ -551088,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);
@@ -551705,6 +552422,15 @@ ${memoryLines.join("\n")}`
               if (observerRedundantBlock) {
                 this._littlemanRedundantBlocks.delete(toolFingerprint);
               }
+              const markSyntheticToolLog = (outputPreview) => {
+                const lastLog = toolCallLog[_toolLogTailIdx];
+                if (!lastLog)
+                  return;
+                lastLog.success = true;
+                lastLog.mutated = false;
+                lastLog.mutatedFiles = [];
+                lastLog.outputPreview = outputPreview.slice(0, 100);
+              };
               {
                 const _reflStem = buildStem(tc.name, tc.arguments ?? {});
                 if (!this._reflectionsInjectedThisTurn.has(_reflStem)) {
@@ -551773,6 +552499,7 @@ ${memoryLines.join("\n")}`
                 const blockMsg = criticDecision.cachedResult ? `[BLOCKED — this tool+args already succeeded. Re-served from cache:]
 
 ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confirmed this tool already succeeded with these arguments on a prior turn. Do NOT re-run. Use your prior findings to proceed.]`;
+                markSyntheticToolLog(blockMsg);
                 this.emit({
                   type: "tool_result",
                   toolName: tc.name,
@@ -551820,6 +552547,9 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
 `;
                 const truncatedCache = criticDecision.cachedResult.length > 500 ? criticDecision.cachedResult.slice(0, 500) + `
 ... [${criticDecision.cachedResult.length - 500} chars omitted — same as before]` : criticDecision.cachedResult;
+                markSyntheticToolLog(`${criticDecision.blockMessage}
+
+${truncatedCache}`);
                 return {
                   tc,
                   output: `${criticDecision.blockMessage}
@@ -551849,6 +552579,7 @@ ${header}${truncatedCache}`
                 const truncatedCache = criticDecision.cachedResult.length > 500 ? criticDecision.cachedResult.slice(0, 500) + `
 ... [${criticDecision.cachedResult.length - 500} chars omitted — same as before]` : criticDecision.cachedResult;
                 const dedupOutput = header + truncatedCache;
+                markSyntheticToolLog(dedupOutput);
                 this.emit({
                   type: "tool_result",
                   toolName: tc.name,
@@ -552689,9 +553420,9 @@ Respond with EXACTLY this structure before your next tool call:
                   }
                 }
               }
-              if (isReadLike && result.success) {
+              if (isReadLike && result.success || tc.name === "shell") {
                 recentToolResults.set(toolFingerprint, {
-                  result: (result.output ?? "").slice(0, 2e3),
+                  result: tc.name === "shell" ? this._buildShellCacheResult(tc.arguments, result) : (result.output ?? "").slice(0, 2e3),
                   compacted: false
                 });
                 if (recentToolResults.size > 500) {
@@ -552706,6 +553437,12 @@ Respond with EXACTLY this structure before your next tool call:
               if (isFileMutation && dedupHitCount.size > 0) {
                 dedupHitCount.clear();
               }
+              if (isFileMutation && recentToolResults.size > 0) {
+                for (const key of Array.from(recentToolResults.keys())) {
+                  if (key.startsWith("shell:"))
+                    recentToolResults.delete(key);
+                }
+              }
               if (isFileMutation) {
                 this._fileWritesSinceLastWorldState += Math.max(1, realMutationPaths.length);
                 this._fileWritesThisRun += Math.max(1, realMutationPaths.length);
@@ -553112,6 +553849,68 @@ Then use file_read on individual FILES inside it.`);
               } else if (!isEisdir) {
                 this._consecutiveEnoent = 0;
               }
+              if (process.env["OMNIUS_DISABLE_PROGRESS_GATES"] !== "1") {
+                const commitGate = computeCommitProgressGate({
+                  toolCallLog,
+                  taskState: this._taskState,
+                  turn,
+                  lastInjectedTurn: lastCommitGateTurn
+                });
+                if (commitGate.shouldInject && commitGate.content) {
+                  messages2.push({ role: "system", content: commitGate.content });
+                  lastCommitGateTurn = turn;
+                  this.emit({
+                    type: "status",
+                    content: "Progress gate injected: discovery succeeded but no file changes are recorded",
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
+                }
+                const shellPivot = computeShellFailurePivot({
+                  toolCallLog,
+                  taskState: this._taskState,
+                  turn,
+                  lastInjectedTurn: lastShellPivotTurn
+                });
+                if (shellPivot.shouldInject && 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",
+                    content: "Shell failure pivot injected from recent raw shell failures",
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
+                }
+              }
+              if (process.env["OMNIUS_DISABLE_FAILURE_HANDOFF"] !== "1" && !result.success && turn - lastFailureHandoffTurn >= 4) {
+                const runtimeHandoff = buildFailureModeHandoff({
+                  taskGoal: cleanedTask,
+                  errorPatterns: this._errorPatterns,
+                  toolCallLog,
+                  taskState: this._taskState,
+                  maxPatterns: 5,
+                  maxRecentCalls: 6
+                });
+                if (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;
+                }
+              }
               return { tc, output };
             };
             const rawToolCalls = msg.toolCalls;
@@ -553171,6 +553970,9 @@ ${sr.result.output}`;
                         timestamp: (/* @__PURE__ */ new Date()).toISOString()
                       });
                     } else {
+                      if (holdNoProgressTaskComplete(matchTc.arguments, turn)) {
+                        continue;
+                      }
                       const _bp1 = await this._runBackwardPassReview(turn);
                       if (_bp1 && !_bp1.proceed && _bp1.feedback) {
                         messages2.push({ role: "system", content: _bp1.feedback });
@@ -553212,6 +554014,9 @@ ${sr.result.output}`;
                           timestamp: (/* @__PURE__ */ new Date()).toISOString()
                         });
                       } else {
+                        if (holdNoProgressTaskComplete(r2.tc.arguments, turn)) {
+                          continue;
+                        }
                         const _bp2 = await this._runBackwardPassReview(turn);
                         if (_bp2 && !_bp2.proceed && _bp2.feedback) {
                           messages2.push({ role: "system", content: _bp2.feedback });
@@ -553288,6 +554093,9 @@ ${sr.result.output}`;
                           timestamp: (/* @__PURE__ */ new Date()).toISOString()
                         });
                       } else {
+                        if (holdNoProgressTaskComplete(r2.tc.arguments, turn)) {
+                          continue;
+                        }
                         const _bp3 = await this._runBackwardPassReview(turn);
                         if (_bp3 && !_bp3.proceed && _bp3.feedback) {
                           messages2.push({ role: "system", content: _bp3.feedback });
@@ -553735,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,
@@ -554026,6 +554841,9 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                       timestamp: (/* @__PURE__ */ new Date()).toISOString()
                     });
                   } else {
+                    if (holdNoProgressTaskComplete(tc.arguments, turn)) {
+                      continue;
+                    }
                     const _bp4 = await this._runBackwardPassReview(turn);
                     if (_bp4 && !_bp4.proceed && _bp4.feedback) {
                       messages2.push({ role: "system", content: _bp4.feedback });
@@ -554076,6 +554894,23 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                   });
                 } else {
+                  if (process.env["OMNIUS_DISABLE_PROGRESS_GATES"] !== "1") {
+                    const gate = computeNoProgressCompletionGate({
+                      summary: content,
+                      toolCallLog,
+                      taskState: this._taskState
+                    });
+                    if (gate.shouldInject && gate.content) {
+                      messages2.push({ role: "system", content: gate.content });
+                      this.emit({
+                        type: "status",
+                        content: "text completion held: discovery happened but no deliverable or explicit blocker is recorded",
+                        turn,
+                        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                      });
+                      continue;
+                    }
+                  }
                   completed = true;
                   summary = content;
                   break;
@@ -554629,10 +555464,10 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
                 try {
-                  const { mkdirSync: mkdirSync84, 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);
@@ -554672,9 +555507,57 @@ 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"] || "60", 10) || 60;
+                      const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
+                      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);
+                      const toDelete = /* @__PURE__ */ new Set();
+                      for (const entry of summaries) {
+                        if (entry.mtimeMs < cutoff)
+                          toDelete.add(entry.filePath);
+                      }
+                      for (const entry of summaries.slice(maxFiles)) {
+                        toDelete.add(entry.filePath);
+                      }
+                      for (const filePath of toDelete) {
+                        try {
+                          unlinkSync29(filePath);
+                        } catch {
+                        }
+                      }
+                      if (toDelete.size > 0) {
+                        this.emit({
+                          type: "status",
+                          content: `Knowledge graph summaries pruned: ${toDelete.size} old file(s) removed`,
+                          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                        });
+                      }
+                    } catch {
+                    }
+                  }
                 } catch {
                 }
               }
@@ -554925,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
@@ -555311,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,
@@ -555326,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 {
         }
       }
@@ -555360,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",
@@ -555968,10 +556858,38 @@ ${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 {
+            const compactFailureHandoff = buildFailureModeHandoff({
+              taskGoal: this._taskState.goal,
+              errorPatterns: this._errorPatterns,
+              taskState: this._taskState,
+              maxPatterns: 6,
+              maxRecentCalls: 0
+            });
+            if (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 {
+          }
         }
         const ctxWindow = this.options.contextWindowSize;
         if (ctxWindow > 0) {
@@ -557569,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, "\\\\");
@@ -563466,7 +564384,7 @@ import { spawn as spawn24, execSync as execSync47 } from "node:child_process";
 import { accessSync, constants, existsSync as existsSync87, mkdirSync as mkdirSync48, writeFileSync as writeFileSync43, readdirSync as readdirSync28 } from "node:fs";
 import { join as join102, dirname as dirname27 } from "node:path";
 import { homedir as homedir32 } from "node:os";
-import { fileURLToPath as fileURLToPath11 } from "node:url";
+import { fileURLToPath as fileURLToPath12 } from "node:url";
 import { EventEmitter as EventEmitter6 } from "node:events";
 import { createInterface as createInterface2 } from "node:readline";
 function isAudioPath(path12) {
@@ -563548,7 +564466,7 @@ function findMicCaptureCommand() {
   return null;
 }
 function findTranscribeFileScript() {
-  const thisDir = dirname27(fileURLToPath11(import.meta.url));
+  const thisDir = dirname27(fileURLToPath12(import.meta.url));
   const candidates = [
     join102(thisDir, "../../../../packages/execution/scripts/transcribe-file.py"),
     join102(thisDir, "../../../packages/execution/scripts/transcribe-file.py"),
@@ -563633,7 +564551,7 @@ async function transcribeFileViaWhisper(filePath, model) {
   });
 }
 function findLiveWhisperScript() {
-  const thisDir = dirname27(fileURLToPath11(import.meta.url));
+  const thisDir = dirname27(fileURLToPath12(import.meta.url));
   const candidates = [
     join102(thisDir, "../../../../packages/execution/scripts/live-whisper.py"),
     join102(thisDir, "../../../packages/execution/scripts/live-whisper.py"),
@@ -577183,7 +578101,7 @@ var init_render2 = __esm({
 // packages/prompts/dist/promptLoader.js
 import { readFileSync as readFileSync74, existsSync as existsSync93 } from "node:fs";
 import { join as join108, dirname as dirname29 } from "node:path";
-import { fileURLToPath as fileURLToPath12 } from "node:url";
+import { fileURLToPath as fileURLToPath13 } from "node:url";
 function loadPrompt2(promptPath, vars) {
   let content = cache6.get(promptPath);
   if (content === void 0) {
@@ -577202,7 +578120,7 @@ var __filename4, __dirname5, devPath, publishedPath, PROMPTS_DIR2, cache6;
 var init_promptLoader2 = __esm({
   "packages/prompts/dist/promptLoader.js"() {
     "use strict";
-    __filename4 = fileURLToPath12(import.meta.url);
+    __filename4 = fileURLToPath13(import.meta.url);
     __dirname5 = dirname29(__filename4);
     devPath = join108(__dirname5, "..", "templates");
     publishedPath = join108(__dirname5, "..", "prompts", "templates");
@@ -577318,7 +578236,7 @@ var init_task_templates = __esm({
 
 // packages/prompts/dist/index.js
 import { join as join109, dirname as dirname30 } from "node:path";
-import { fileURLToPath as fileURLToPath13 } from "node:url";
+import { fileURLToPath as fileURLToPath14 } from "node:url";
 var _dir, _packageRoot;
 var init_dist9 = __esm({
   "packages/prompts/dist/index.js"() {
@@ -577327,7 +578245,7 @@ var init_dist9 = __esm({
     init_render2();
     init_task_templates();
     init_render2();
-    _dir = dirname30(fileURLToPath13(import.meta.url));
+    _dir = dirname30(fileURLToPath14(import.meta.url));
     _packageRoot = join109(_dir, "..");
   }
 });
@@ -578190,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")}
@@ -584689,7 +585607,7 @@ import { existsSync as existsSync96, writeFileSync as writeFileSync49, readFileS
 import { join as join112, dirname as dirname32 } from "node:path";
 import { homedir as homedir36 } from "node:os";
 import { execSync as execSync50, spawn as spawn27 } from "node:child_process";
-import { fileURLToPath as fileURLToPath14 } from "node:url";
+import { fileURLToPath as fileURLToPath15 } from "node:url";
 function execAsync(cmd, opts = {}) {
   return new Promise((resolve57, reject) => {
     const child = spawn27("bash", ["-c", cmd], {
@@ -585500,7 +586418,7 @@ function getShippedVoicesDir() {
     // repo root
   ];
   try {
-    const modDir = dirname32(fileURLToPath14(import.meta.url));
+    const modDir = dirname32(fileURLToPath15(import.meta.url));
     candidates.push(join112(modDir, "..", "..", "..", "voices", "personaplex"));
     candidates.push(join112(modDir, "..", "..", "..", "..", "voices", "personaplex"));
   } catch {
@@ -592424,7 +593342,7 @@ import { spawn as spawn29 } from "node:child_process";
 import { existsSync as existsSync103, readFileSync as readFileSync82, writeFileSync as writeFileSync51, mkdirSync as mkdirSync56, unlinkSync as unlinkSync19, openSync as openSync3, closeSync as closeSync3 } from "node:fs";
 import { join as join117 } from "node:path";
 import { homedir as homedir39 } from "node:os";
-import { fileURLToPath as fileURLToPath15 } from "node:url";
+import { fileURLToPath as fileURLToPath16 } from "node:url";
 import { dirname as dirname33 } from "node:path";
 function getDaemonPort() {
   const env2 = process.env["OMNIUS_HOST"];
@@ -592490,7 +593408,7 @@ async function resolveDaemonCommand(nodeExe) {
     if (first2) candidates.push(first2);
   } catch {
   }
-  const thisDir = dirname33(fileURLToPath15(import.meta.url));
+  const thisDir = dirname33(fileURLToPath16(import.meta.url));
   candidates.push(join117(thisDir, "index.js"));
   const seen = /* @__PURE__ */ new Set();
   for (const candidate of candidates) {
@@ -598977,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."
@@ -599248,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 {
             }
           }
@@ -599264,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 {
           }
@@ -599368,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 {
         }
       }
@@ -599383,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(
@@ -607203,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");
@@ -607218,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));
@@ -608689,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 {
       }
     }
@@ -608899,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(),
@@ -608907,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(
             {
@@ -608980,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(),
@@ -608988,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,
@@ -609920,11 +610838,11 @@ async function handleUpdate(subcommand, ctx3) {
   let currentVersion = "0.0.0";
   try {
     const { createRequire: createRequire10 } = await import("node:module");
-    const { fileURLToPath: fileURLToPath21 } = await import("node:url");
+    const { fileURLToPath: fileURLToPath22 } = await import("node:url");
     const { dirname: dirname44, join: join155 } = await import("node:path");
     const { existsSync: existsSync138 } = await import("node:fs");
     const req2 = createRequire10(import.meta.url);
-    const thisDir = dirname44(fileURLToPath21(import.meta.url));
+    const thisDir = dirname44(fileURLToPath22(import.meta.url));
     const candidates = [
       join155(thisDir, "..", "package.json"),
       join155(thisDir, "..", "..", "package.json"),
@@ -611554,10 +612472,10 @@ var init_commands = __esm({
           }
           try {
             const { createRequire: createRequire10 } = await import("node:module");
-            const { fileURLToPath: fileURLToPath21 } = await import("node:url");
+            const { fileURLToPath: fileURLToPath22 } = await import("node:url");
             const { dirname: pathDirname, join: pathJoin } = await import("node:path");
             const localRequire = createRequire10(import.meta.url);
-            const here = pathDirname(fileURLToPath21(import.meta.url));
+            const here = pathDirname(fileURLToPath22(import.meta.url));
             let version4 = "?";
             for (const up of ["..", "../..", "../../.."]) {
               try {
@@ -611577,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."
@@ -611602,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 {
           }
@@ -611769,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";
@@ -612002,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),
@@ -612012,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) {
@@ -612254,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"),
@@ -613398,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;
@@ -613533,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`);
@@ -613870,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);
@@ -613883,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) {
@@ -613950,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);
@@ -615032,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) {
@@ -615148,7 +616099,7 @@ var init_edit_history = __esm({
 // packages/cli/src/tui/promptLoader.ts
 import { readFileSync as readFileSync91, existsSync as existsSync113 } from "node:fs";
 import { join as join127, dirname as dirname36 } from "node:path";
-import { fileURLToPath as fileURLToPath16 } from "node:url";
+import { fileURLToPath as fileURLToPath17 } from "node:url";
 function loadPrompt3(promptPath, vars) {
   let content = cache7.get(promptPath);
   if (content === void 0) {
@@ -615166,7 +616117,7 @@ var __filename5, __dirname6, devPath2, publishedPath2, PROMPTS_DIR3, cache7;
 var init_promptLoader3 = __esm({
   "packages/cli/src/tui/promptLoader.ts"() {
     "use strict";
-    __filename5 = fileURLToPath16(import.meta.url);
+    __filename5 = fileURLToPath17(import.meta.url);
     __dirname6 = dirname36(__filename5);
     devPath2 = join127(__dirname6, "..", "..", "prompts");
     publishedPath2 = join127(__dirname6, "..", "prompts");
@@ -615176,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) {
@@ -615396,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 };
@@ -615438,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 };
@@ -615484,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 };
@@ -615526,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 };
@@ -615614,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++) {
@@ -615687,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);
@@ -616349,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);
@@ -616442,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");
@@ -616490,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") {
@@ -616532,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,
@@ -616549,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,
@@ -616564,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"
@@ -616626,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 {
         }
       }
@@ -616648,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", {
@@ -616714,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"
             );
@@ -616732,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"
@@ -617113,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) => {
@@ -617221,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;
@@ -617885,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"
@@ -617896,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);
+      }
     };
   }
 });
@@ -619688,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 {
@@ -619709,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) {
@@ -619861,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;
         }
@@ -619950,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) {
@@ -619979,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, "/");
@@ -620003,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);
@@ -620013,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 {
@@ -620072,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,
@@ -620741,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) {
@@ -621301,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) {
@@ -623059,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";
@@ -626331,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",
@@ -626581,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 (
@@ -627303,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]
@@ -627320,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 {
         }
       }
@@ -630639,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 {
@@ -630750,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 {
@@ -630765,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,
@@ -633584,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 {
@@ -635472,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";
@@ -635493,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 {
   }
@@ -635538,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++;
@@ -635721,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");
@@ -636119,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";
@@ -636135,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() {
@@ -636219,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 {
   }
@@ -637110,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";
@@ -637129,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 {
@@ -637162,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 {
@@ -638094,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 {
   }
@@ -638168,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;
@@ -638188,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) {
@@ -639253,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 [];
@@ -639274,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 {
@@ -639508,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() {
@@ -639532,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") {
@@ -639544,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;
 }
@@ -642135,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 {
@@ -651973,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)) {
@@ -652017,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 {
   }
@@ -652045,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";
@@ -652109,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) {
@@ -652302,10 +653292,10 @@ 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 fileURLToPath17 } from "node:url";
+import { fileURLToPath as fileURLToPath18 } from "node:url";
 function getDockerDir() {
   try {
     if (typeof __dirname !== "undefined") {
@@ -652314,7 +653304,7 @@ function getDockerDir() {
   } catch {
   }
   try {
-    const thisDir = dirname40(fileURLToPath17(import.meta.url));
+    const thisDir = dirname40(fileURLToPath18(import.meta.url));
     return join146(thisDir, "..", "..", "..", "docker");
   } catch {
   }
@@ -652453,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 {
@@ -652527,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 {
@@ -652782,11 +653772,11 @@ __export(serve_exports, {
 import * as http5 from "node:http";
 import * as https3 from "node:https";
 import { createRequire as createRequire7 } from "node:module";
-import { fileURLToPath as fileURLToPath18 } from "node:url";
+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()) {
@@ -652799,7 +653789,7 @@ function memoryDbPaths3(baseDir = process.cwd()) {
 }
 function getVersion3() {
   try {
-    const thisDir = dirname41(fileURLToPath18(import.meta.url));
+    const thisDir = dirname41(fileURLToPath19(import.meta.url));
     const candidates = [
       join148(thisDir, "..", "package.json"),
       join148(thisDir, "..", "..", "package.json"),
@@ -653561,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) {
@@ -653906,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 {
@@ -655393,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 {
   }
@@ -655697,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());
@@ -657005,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);
@@ -657600,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 {
           }
@@ -658814,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 {
@@ -658848,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);
@@ -659120,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 {
@@ -659255,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" });
@@ -659401,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();
@@ -659579,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 {
             }
@@ -659882,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({
@@ -659911,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 {
         }
@@ -660196,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;
@@ -660566,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() {
@@ -660640,14 +661630,14 @@ var init_clipboard_media = __esm({
 import { cwd } from "node:process";
 import { resolve as resolve53, join as join150, dirname as dirname42, extname as extname17, relative as relative14 } from "node:path";
 import { createRequire as createRequire8 } from "node:module";
-import { fileURLToPath as fileURLToPath19 } from "node:url";
+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";
@@ -660665,7 +661655,7 @@ function formatTimeAgo2(date) {
 function getVersion4() {
   try {
     const require5 = createRequire8(import.meta.url);
-    const thisDir = dirname42(fileURLToPath19(import.meta.url));
+    const thisDir = dirname42(fileURLToPath20(import.meta.url));
     const candidates = [
       join150(thisDir, "..", "package.json"),
       join150(thisDir, "..", "..", "package.json"),
@@ -663488,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}`,
@@ -663598,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);
@@ -663654,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 {
         }
@@ -665252,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"
@@ -666161,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 {
       }
@@ -669236,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,
@@ -669289,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 {
@@ -669321,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 {
       }
     }
@@ -669353,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 {
@@ -669412,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(
@@ -669461,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 {
@@ -669526,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,
@@ -669554,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");
@@ -669576,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 {
@@ -669679,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) {
@@ -669807,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();
@@ -669823,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 {
     }
   });
@@ -670457,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";
@@ -670588,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"
@@ -670653,7 +671643,7 @@ init_updater();
 init_typed_node_events();
 import { createRequire as createRequire9 } from "node:module";
 import { parseArgs as nodeParseArgs2 } from "node:util";
-import { fileURLToPath as fileURLToPath20 } from "node:url";
+import { fileURLToPath as fileURLToPath21 } from "node:url";
 import { dirname as dirname43, join as join154 } from "node:path";
 
 // packages/cli/src/cli.ts
@@ -670802,7 +671792,7 @@ try {
 function getVersion5() {
   try {
     const require5 = createRequire9(import.meta.url);
-    const pkgPath = join154(dirname43(fileURLToPath20(import.meta.url)), "..", "package.json");
+    const pkgPath = join154(dirname43(fileURLToPath21(import.meta.url)), "..", "package.json");
     const pkg = require5(pkgPath);
     return pkg.version;
   } catch {
@@ -671116,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 {
   }