omnius 1.0.476 → 1.0.478

package/dist/index.js

@@ -26393,6 +26393,116 @@ var init_compaction_policy = __esm({
   }
 });
 
+// packages/memory/dist/evidence-retirement.js
+function extractDiagnosticSymbols(text2) {
+  const symbols = /* @__PURE__ */ new Set();
+  let count = 0;
+  for (const line of text2.split("\n")) {
+    if (!DIAG_LINE.test(line))
+      continue;
+    count += 1;
+    let m2;
+    QUOTED_SYMBOL.lastIndex = 0;
+    while ((m2 = QUOTED_SYMBOL.exec(line)) !== null) {
+      if (/^[A-Za-z_]/.test(m2[1]) && !m2[1].includes("/"))
+        symbols.add(m2[1]);
+      if (symbols.size >= 12)
+        break;
+    }
+  }
+  return { count, symbols: [...symbols] };
+}
+function isRetirableEvidence(message2, minChars) {
+  if (message2.pinned)
+    return false;
+  if (typeof message2.content !== "string")
+    return false;
+  if (message2.content.length < minChars)
+    return false;
+  if (message2.role === "tool")
+    return true;
+  if (message2.role !== "system")
+    return false;
+  return EVIDENCE_MARKERS.some((m2) => message2.content.includes(m2));
+}
+function foldEvidenceOutcome(message2) {
+  const text2 = message2.content;
+  const diag = extractDiagnosticSymbols(text2);
+  if (diag.count > 0) {
+    const syms = diag.symbols.slice(0, 6);
+    const exit = /exit_code:\s*(\d+)|Exit code (\d+)/.exec(text2);
+    const code8 = exit ? exit[1] ?? exit[2] : void 0;
+    return `${diag.count} diagnostic(s)${code8 ? ` (exit ${code8})` : ""}${syms.length ? `: ${syms.join(", ")}` : ""}`;
+  }
+  const fileHdr = /\[FILE CONTEXT[^\]]*\]/.exec(text2);
+  if (fileHdr)
+    return fileHdr[0].replace(/^\[|\]$/g, "").trim();
+  if (text2.includes("[SHELL TRANSCRIPT]")) {
+    const cmd = /command:\s*([^\n]+)/.exec(text2);
+    const exit = /exit_code:\s*(\d+)|Exit code (\d+)/.exec(text2);
+    const err = /(^|\n)\s*([^\n]*\berror\b[^\n]*)/i.exec(text2);
+    const parts = [
+      cmd ? `cmd: ${cmd[1].trim().slice(0, 80)}` : "",
+      exit ? `exit ${exit[1] ?? exit[2]}` : "",
+      err ? err[2].trim().slice(0, 100) : ""
+    ].filter(Boolean);
+    if (parts.length)
+      return parts.join("; ");
+  }
+  const firstLine = text2.split("\n").map((l2) => l2.trim()).find((l2) => l2.length > 0 && !EVIDENCE_MARKERS.some((m2) => l2.startsWith(m2)));
+  return (firstLine ?? "evidence").slice(0, 120);
+}
+function retirementStub(message2, outcome, originalChars) {
+  const ref = message2.diskRef ? ` ref=${message2.diskRef}` : "";
+  const tool = message2.toolName ? ` tool=${message2.toolName}` : "";
+  const turn = typeof message2.turn === "number" ? ` turn=${message2.turn}` : "";
+  return `[RETIRED EVIDENCE${tool}${turn} bytes=${originalChars}${ref}] outcome: ${outcome}
+(full evidence retired to disk — re-read the file or re-run the command to re-materialise if you need the detail)`;
+}
+function retireStaleEvidence(messages2, options2) {
+  const keepRecentTurns = Math.max(0, options2.keepRecentTurns ?? 2);
+  const minChars = Math.max(256, options2.minChars ?? 2e3);
+  const summarize2 = options2.summarize ?? foldEvidenceOutcome;
+  const staleBefore = options2.currentTurn - keepRecentTurns;
+  let retiredCount = 0;
+  let reclaimedChars = 0;
+  const out = messages2.map((message2) => {
+    if (typeof message2.turn !== "number" || message2.turn > staleBefore) {
+      return message2;
+    }
+    if (!isRetirableEvidence(message2, minChars))
+      return message2;
+    const originalChars = message2.content.length;
+    let outcome;
+    try {
+      outcome = summarize2(message2);
+    } catch {
+      outcome = "evidence";
+    }
+    const stub = retirementStub(message2, outcome, originalChars);
+    if (stub.length >= originalChars)
+      return message2;
+    retiredCount += 1;
+    reclaimedChars += originalChars - stub.length;
+    return { ...message2, content: stub };
+  });
+  return { messages: out, retiredCount, reclaimedChars };
+}
+var DIAG_LINE, QUOTED_SYMBOL, EVIDENCE_MARKERS;
+var init_evidence_retirement = __esm({
+  "packages/memory/dist/evidence-retirement.js"() {
+    "use strict";
+    DIAG_LINE = /\berror\b\s*:/i;
+    QUOTED_SYMBOL = /['"`]([A-Za-z_][A-Za-z0-9_:.<>]{1,80})['"`]/g;
+    EVIDENCE_MARKERS = [
+      "[SHELL TRANSCRIPT]",
+      "[FILE CONTEXT",
+      "[RUN EVIDENCE]",
+      "[TOOL RESULT]"
+    ];
+  }
+});
+
 // packages/memory/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
@@ -26494,6 +26604,7 @@ __export(dist_exports, {
   extractTrace: () => extractTrace,
   findNeighbors: () => findNeighbors,
   fingerprintSignature: () => fingerprintSignature,
+  foldEvidenceOutcome: () => foldEvidenceOutcome,
   freshNodeId: () => freshNodeId,
   generateEmbedding: () => generateEmbedding,
   generateEmbeddingBatch: () => generateEmbeddingBatch,
@@ -26503,6 +26614,7 @@ __export(dist_exports, {
   inferDomainFromEpisode: () => inferDomainFromEpisode,
   ingestContextFeedbackMarkdown: () => ingestContextFeedbackMarkdown,
   initDb: () => initDb,
+  isRetirableEvidence: () => isRetirableEvidence,
   isSessionGist: () => isSessionGist,
   lightSleep: () => lightSleep,
   linkEpisode: () => linkEpisode,
@@ -26525,6 +26637,7 @@ __export(dist_exports, {
   reinforceGraphNodes: () => reinforceGraphNodes,
   remDream: () => remDream,
   resetCRLConfigStore: () => resetCRLConfigStore,
+  retireStaleEvidence: () => retireStaleEvidence,
   retrieveByPPR: () => retrieveByPPR,
   runConsolidationCycle: () => runConsolidationCycle,
   runMemoryMaintenance: () => runMemoryMaintenance,
@@ -26609,6 +26722,7 @@ var init_dist = __esm({
     init_attention_select();
     init_context_folding();
     init_compaction_policy();
+    init_evidence_retirement();
   }
 });
 
@@ -576954,9 +577068,235 @@ var init_coherence_gate = __esm({
   }
 });
 
+// packages/orchestrator/dist/spec-gate.js
+function definitionCount(source, name10) {
+  const n2 = escapeRegExp2(name10);
+  const patterns = [
+    new RegExp(`}\\s*${n2}\\s*;`, "g"),
+    // } Name;  (typedef struct/enum)
+    new RegExp(`\\b(?:struct|class|enum|union)\\s+${n2}\\s*[:{]`, "g"),
+    new RegExp(`\\b(?:interface|type|class|enum)\\s+${n2}\\b`, "g"),
+    new RegExp(`\\btypedef\\s+[^;{]+\\b${n2}\\s*;`, "g")
+  ];
+  let total = 0;
+  for (const re of patterns)
+    total += (source.match(re) ?? []).length;
+  return total;
+}
+function hasField(source, symbol3, field) {
+  const n2 = escapeRegExp2(symbol3);
+  const block = source.match(new RegExp(`(?:struct|class|enum|union|interface)\\s+${n2}[^{]*{([\\s\\S]*?)}|{([\\s\\S]*?)}\\s*${n2}\\s*;`));
+  const body = block?.[1] ?? block?.[2] ?? "";
+  if (!body)
+    return false;
+  return new RegExp(`\\b${escapeRegExp2(field)}\\b`).test(body);
+}
+function hasSignature(source, fragment) {
+  const norm = (s2) => s2.replace(/\s+/g, " ").trim();
+  return norm(source).includes(norm(fragment));
+}
+function evaluateSpecGate(unit, contract, opts = {}) {
+  const violations = [];
+  const expected = new Set(opts.expectedSymbols ?? []);
+  for (const spec of contract.symbols) {
+    const count = definitionCount(unit.source, spec.name);
+    const mustDefine = expected.has(spec.name);
+    if (count === 0) {
+      if (mustDefine) {
+        violations.push({
+          symbol: spec.name,
+          kind: "missing_symbol",
+          detail: `unit ${unit.path} must declare ${spec.kind} ${spec.name} but it is absent`
+        });
+      }
+      continue;
+    }
+    if (count > 1) {
+      violations.push({
+        symbol: spec.name,
+        kind: "duplicate_symbol",
+        detail: `${spec.name} is defined ${count}× in ${unit.path}; the contract permits exactly one`
+      });
+    }
+    for (const field of spec.fields ?? []) {
+      if (!hasField(unit.source, spec.name, field)) {
+        violations.push({
+          symbol: spec.name,
+          kind: "missing_field",
+          detail: `${spec.name} is missing required member "${field}"`
+        });
+      }
+    }
+    if (spec.signature && !hasSignature(unit.source, spec.signature)) {
+      violations.push({
+        symbol: spec.name,
+        kind: "signature_divergence",
+        detail: `${spec.name} does not match the contract signature "${spec.signature}"`
+      });
+    }
+  }
+  const pass = violations.length === 0;
+  return {
+    pass,
+    violations,
+    summary: pass ? `spec gate PASS for ${unit.path}` : `spec gate FAIL for ${unit.path}: ${violations.length} violation(s) — ${violations.map((v) => `${v.symbol}:${v.kind}`).join(", ")}`
+  };
+}
+function evaluateExecutorStep(input) {
+  const spec = evaluateSpecGate(input.unit, input.contract, {
+    expectedSymbols: input.expectedSymbols
+  });
+  if (input.convergenceTier === "abandon" || input.convergenceTier === "stalled") {
+    return {
+      decision: "replan",
+      spec,
+      reason: `convergence ${input.convergenceTier}: stop patching ${input.unit.path}; re-plan / regenerate from the locked contract`
+    };
+  }
+  const boundaryOk = input.boundaryOk ?? true;
+  if (spec.pass && boundaryOk) {
+    return { decision: "accept", spec, reason: `${input.unit.path} accepted` };
+  }
+  return {
+    decision: "reject_regenerate",
+    spec,
+    reason: spec.pass ? `${input.unit.path} passed the spec gate but failed to compile — regenerate` : spec.summary
+  };
+}
+function escapeRegExp2(s2) {
+  return s2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var init_spec_gate = __esm({
+  "packages/orchestrator/dist/spec-gate.js"() {
+    "use strict";
+  }
+});
+
+// packages/orchestrator/dist/decomposition-orchestrator.js
+function decomposeToUnits(modules, contract, symbolSources = /* @__PURE__ */ new Map(), options2 = {}) {
+  const maxUnits = Math.max(1, options2.maxUnits ?? 200);
+  const units = [];
+  const symbolsByPath = /* @__PURE__ */ new Map();
+  for (const spec of contract.symbols) {
+    const src2 = symbolSources.get(spec.name);
+    if (!src2)
+      continue;
+    const arr = symbolsByPath.get(src2) ?? [];
+    arr.push(spec);
+    symbolsByPath.set(src2, arr);
+  }
+  let i2 = 0;
+  for (const m2 of modules) {
+    if (units.length >= maxUnits)
+      break;
+    const fileId = `unit-file-${++i2}`;
+    const symbols = symbolsByPath.get(m2.path) ?? [];
+    units.push({
+      id: fileId,
+      path: m2.path,
+      content: `Implement ${m2.path} (delegate via sub_agent for isolated context)`,
+      status: "pending",
+      exitCriterion: symbols.length > 0 ? `${m2.path} compiles AND declares ${symbols.map((s2) => s2.name).join(", ")} matching the locked contract` : `${m2.path} compiles cleanly`
+    });
+    let j = 0;
+    for (const s2 of symbols) {
+      if (units.length >= maxUnits)
+        break;
+      units.push({
+        id: `${fileId}-sym-${++j}`,
+        parentId: fileId,
+        path: m2.path,
+        symbol: s2.name,
+        content: `Declare ${s2.kind} ${s2.name} in ${m2.path} to match the locked contract`,
+        status: "pending",
+        exitCriterion: `${s2.name} declared exactly once with the contract shape; ${m2.path} compiles`
+      });
+    }
+  }
+  return units;
+}
+function evaluateUnitResult(input) {
+  const expectedSymbols = input.unit.symbol ? [input.unit.symbol] : input.contract.symbols.filter((s2) => true).map((s2) => s2.name).filter((name10) => input.emittedSource.includes(name10));
+  const spec = evaluateSpecGate({ path: input.unit.path, source: input.emittedSource }, input.contract, { expectedSymbols });
+  const diagnostics = parseCompilerDiagnostics(String(input.buildOutput || ""));
+  const structural = diagnostics.filter((d2) => d2.kind === "signature_mismatch" || d2.kind === "duplicate_definition" || d2.kind === "unknown_member" || d2.kind === "unknown_symbol" || d2.kind === "type_error");
+  if (spec.pass && structural.length === 0) {
+    const label = input.unit.symbol ?? input.unit.path;
+    return {
+      decision: "accept",
+      foldSummary: `${label}: verified (declares ${expectedSymbols.join(", ") || "unit"}, compiles clean)`,
+      violations: [],
+      diagnosticsCount: 0
+    };
+  }
+  const reasons = [];
+  if (!spec.pass)
+    reasons.push(spec.summary);
+  if (structural.length > 0) {
+    const syms = [...new Set(structural.map((d2) => d2.symbol).filter(Boolean))];
+    reasons.push(`${structural.length} compiler diagnostic(s)${syms.length ? ` on ${syms.slice(0, 4).join(", ")}` : ""}`);
+  }
+  return {
+    decision: "reject_regenerate",
+    rejectReason: `Unit ${input.unit.path}${input.unit.symbol ? ` (${input.unit.symbol})` : ""} does not verify — regenerate against the locked contract: ${reasons.join("; ")}`,
+    violations: spec.violations,
+    diagnosticsCount: structural.length
+  };
+}
+function buildUnitTodos(units) {
+  return units.map((u) => ({
+    id: u.id,
+    content: u.content,
+    status: u.status,
+    ...u.parentId ? { parentId: u.parentId } : {}
+  }));
+}
+var init_decomposition_orchestrator = __esm({
+  "packages/orchestrator/dist/decomposition-orchestrator.js"() {
+    "use strict";
+    init_spec_gate();
+    init_dist5();
+  }
+});
+
 // packages/orchestrator/dist/longhaul-integration.js
 import fs6 from "node:fs";
 import path7 from "node:path";
+function extractSymbols3(content, language) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (name10, kind, body) => {
+    if (!name10 || seen.has(name10))
+      return;
+    seen.add(name10);
+    const fields = body ? extractFields(body) : [];
+    out.push({ name: name10, kind, ...fields.length ? { fields } : {} });
+  };
+  if (language === "cpp" || language === "unknown") {
+    for (const m2 of content.matchAll(/\{([\s\S]*?)\}\s*([A-Za-z_]\w*)\s*;/g))
+      push(m2[2], "struct", m2[1]);
+    for (const m2 of content.matchAll(/\b(struct|class|enum|union)\s+([A-Za-z_]\w*)\s*(?::[^{]*)?\{([\s\S]*?)\}/g))
+      push(m2[2], m2[1] === "union" ? "struct" : m2[1], m2[3]);
+  }
+  if (language === "typescript" || language === "unknown") {
+    for (const m2 of content.matchAll(/\b(interface|class|enum)\s+([A-Za-z_]\w*)\s*(?:extends[^{]*)?\{([\s\S]*?)\}/g))
+      push(m2[2], m2[1], m2[3]);
+    for (const m2 of content.matchAll(/\btype\s+([A-Za-z_]\w*)\s*=/g))
+      push(m2[1], "type");
+  }
+  return out;
+}
+function extractFields(body) {
+  const fields = [];
+  for (const line of body.split(/[;,\n]/)) {
+    const ts = line.match(/^\s*([A-Za-z_]\w*)\s*[?:]/);
+    const c9 = line.match(/([A-Za-z_]\w*)\s*$/);
+    const name10 = ts ? ts[1] : c9 ? c9[1] : void 0;
+    if (name10 && !FIELD_STOPWORDS.test(name10) && !fields.includes(name10))
+      fields.push(name10);
+  }
+  return fields.slice(0, 24);
+}
 function languageOf(p2) {
   if (/\.(c|cc|cpp|cxx|h|hh|hpp|hxx|ino)$/i.test(p2))
     return "cpp";
@@ -576964,12 +577304,14 @@ function languageOf(p2) {
     return "typescript";
   return "unknown";
 }
-var JsonConvergenceStore, EDIT_TOOLS, LongHaulComponents;
+var JsonConvergenceStore, EDIT_TOOLS, LongHaulComponents, FIELD_STOPWORDS;
 var init_longhaul_integration = __esm({
   "packages/orchestrator/dist/longhaul-integration.js"() {
     "use strict";
     init_convergence_breaker();
     init_coherence_gate();
+    init_spec_gate();
+    init_decomposition_orchestrator();
     init_dist5();
     init_dist();
     init_dist();
@@ -577019,6 +577361,15 @@ var init_longhaul_integration = __esm({
       adaptiveEdit;
       coherenceGate;
       contextFolder;
+      /**
+       * WO-6: the locked contract — accumulated from COHERENT boundary units only.
+       * A drifted/incoherent unit is never locked (WO-2 fires regenerate for it
+       * instead), so this can only ever hold a self-consistent type spec. Gives the
+       * breaker's "regenerate from the locked contract" guidance a real target.
+       */
+      locked = /* @__PURE__ */ new Map();
+      /** WO-11: provenance — which file each locked symbol was declared in. */
+      lockedSource = /* @__PURE__ */ new Map();
       constructor(options2) {
         this.convergenceBreaker = new ConvergenceBreaker({
           ...options2.convergence,
@@ -577069,6 +577420,91 @@ var init_longhaul_integration = __esm({
           return null;
         }
       }
+      /**
+       * WO-6: lock a boundary unit into the contract IFF it is coherent. A drifted
+       * unit is never locked (WO-2 handles it), so the contract only ever holds
+       * self-consistent symbol shapes. Returns the current contract size.
+       */
+      maybeLockContract(input) {
+        try {
+          if (!input.content)
+            return this.locked.size;
+          const lang = input.language ?? languageOf(input.path);
+          const verdict = this.coherenceGate.evaluate({
+            source: input.content,
+            language: lang
+          });
+          if (verdict.regime === "regenerate")
+            return this.locked.size;
+          for (const s2 of extractSymbols3(input.content, lang)) {
+            if (!this.locked.has(s2.name)) {
+              this.locked.set(s2.name, s2);
+              this.lockedSource.set(s2.name, input.path);
+            }
+          }
+          return this.locked.size;
+        } catch {
+          return this.locked.size;
+        }
+      }
+      /** WO-6: the accumulated locked contract (for the breaker's regenerate target). */
+      lockedContract() {
+        return { symbols: [...this.locked.values()] };
+      }
+      /** WO-11: map of locked symbol name → declaring file (for per-symbol units). */
+      symbolSources() {
+        return new Map(this.lockedSource);
+      }
+      /**
+       * WO-11: extreme-granularity unit todo TREE for the TUI expanded-list mirror.
+       * When the locked contract has symbols, each file expands into per-symbol
+       * children; otherwise it degrades to the existing per-file granularity (safe
+       * drop-in). Enriches as the contract fills across the run.
+       */
+      unitTreeTodos(modules) {
+        try {
+          const units = decomposeToUnits(modules, this.lockedContract(), this.symbolSources());
+          return buildUnitTodos(units);
+        } catch {
+          return modules.map((m2, i2) => ({
+            id: `unit-file-${i2 + 1}`,
+            content: `Implement ${m2.path}`,
+            status: "pending"
+          }));
+        }
+      }
+      /** WO-11: whether the contract is rich enough to expand into symbol children. */
+      hasSymbolGranularity() {
+        return this.lockedSource.size > 0;
+      }
+      /**
+       * WO-11: compile-verify-FOLD gate for a delegated unit's result. Accept only
+       * when it matches the contract AND compiles; else return the regenerate reason.
+       */
+      evaluateUnit(input) {
+        return evaluateUnitResult({ ...input, contract: this.lockedContract() });
+      }
+      /**
+       * WO-6: gate an emitted boundary unit against the locked contract. Returns
+       * guidance naming symbols that diverge from (or duplicate) a locked shape, so
+       * "regenerate from the locked contract" has a concrete target. Only fires for
+       * symbols already locked from earlier coherent code — never invents violations.
+       */
+      specGateGuidance(input) {
+        try {
+          if (this.locked.size === 0 || !input.content)
+            return null;
+          const res = evaluateSpecGate({ path: input.path, source: input.content }, this.lockedContract());
+          if (res.pass)
+            return null;
+          const relevant = res.violations.filter((v) => this.locked.has(v.symbol));
+          if (relevant.length === 0)
+            return null;
+          return `${input.path} diverges from the LOCKED CONTRACT (established from earlier coherent code): ${relevant.map((v) => `${v.symbol} (${v.kind})`).join(", ")}. Do not redefine or reshape a locked symbol — reconcile this unit to the contract shape, or regenerate it against the contract.`;
+        } catch {
+          return null;
+        }
+      }
       /**
        * WO-1 (PyTy pattern): parse a failed build/verify command's own output for
        * named STRUCTURAL contract violations (signature mismatch / duplicate
@@ -577142,6 +577578,7 @@ var init_longhaul_integration = __esm({
         }
       }
     };
+    FIELD_STOPWORDS = /^(struct|class|public|private|protected|const|unsigned|signed|static|typedef|enum|union|namespace|template|int|char|float|double|void|bool|long|short|size_t|uint\d+_t|int\d+_t|string|number|boolean|readonly)$/;
   }
 });
 
@@ -580561,6 +580998,8 @@ var init_agenticRunner = __esm({
       /** WO-1..WO-8 long-haul integration bundle (convergence, adaptive-edit,
        *  coherence, folding). Constructed at run setup alongside the supervisor. */
       _longHaul = null;
+      /** WO-11: decomposition modules (files) stashed for contract-enriched todo trees. */
+      _decompModules = [];
       _focusTerminalLedgerRecorded = false;
       // Generic, cross-session failure→resolution learning: learns the token-level
       // change that turned a failed command into a working one (e.g. python→python3)
@@ -587621,7 +588060,23 @@ TASK: ${scrubbedTask}` : scrubbedTask;
             if (_decomp.modules.length > 0) {
               const _directive = buildDecompositionDirective(_decomp.modules, _decomp.strategy);
               messages2.push({ role: "system", content: _directive });
-              const _todos = buildDecompositionTodos(_decomp.modules);
+              this._decompModules = _decomp.modules;
+              if (this._longHaul) {
+                const _wd = this.authoritativeWorkingDirectory();
+                for (const _m of _decomp.modules) {
+                  try {
+                    const _abs = _pathResolve(_wd, _m.path);
+                    if (_fsExistsSync(_abs)) {
+                      this._longHaul.maybeLockContract({
+                        path: _m.path,
+                        content: _fsReadFileSync(_abs, "utf-8")
+                      });
+                    }
+                  } catch {
+                  }
+                }
+              }
+              const _todos = this._longHaul && this._longHaul.hasSymbolGranularity() ? this._longHaul.unitTreeTodos(_decomp.modules) : buildDecompositionTodos(_decomp.modules);
               try {
                 const sid = this._sessionId || process.env["OMNIUS_SESSION_ID"] || "default";
                 const safe = sid.replace(/[^a-zA-Z0-9_.-]/g, "_");
@@ -589483,6 +589938,7 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
             messages2.push(...compacted);
             compacted = messages2;
           }
+          this._retireStaleEvidenceInPlace(messages2, turn);
           if (turn > 0 && this._toolEvents.length > 0) {
             try {
               const _limits = this.contextLimits();
@@ -592538,6 +592994,16 @@ ${rec.guidance}` : rec.guidance;
 
 ${dir}` : dir;
                     }
+                    lh.maybeLockContract({ path: editPath, content: writtenContent });
+                    const specDir = lh.specGateGuidance({
+                      path: editPath,
+                      content: writtenContent
+                    });
+                    if (specDir) {
+                      runtimeSystemGuidance = runtimeSystemGuidance ? `${runtimeSystemGuidance}
+
+${specDir}` : specDir;
+                    }
                   }
                   if (!result.success) {
                     const diag = lh.diagnosticGuidance(result.output ?? result.error ?? "");
@@ -596288,6 +596754,80 @@ Actions: (1) list_directory on the parent directory to see what's there, (2) Che
        * Replaces both assistant messages AND their associated tool-result
        * messages in the turn range [startTurn, currentTurn].
        */
+      /**
+       * Staleness-based evidence retirement (WO-4 realized; operator's microcompaction
+       * goal). The sibling `_evictCompletedTodoMessages` only fires when a todo
+       * COMPLETES and — critically — SKIPS `system` messages. But the live
+       * `myactuator` frame (turn 11) was dominated by a ~77 KB `system`
+       * `[SHELL TRANSCRIPT]` pinned from turn 3: a stuck debug loop completes no
+       * todos, so nothing retired it, and system-role evidence is exempt from the
+       * todo evictor anyway.
+       *
+       * This pass fills that gap: it retires STALE, LARGE evidence bodies (tool
+       * results and marker-gated `system` evidence blocks — `[SHELL TRANSCRIPT]`,
+       * `[FILE CONTEXT`, `[RUN EVIDENCE]`) to a one-line world-state stub, keeping
+       * the OUTCOME resident and moving the bytes out. It mirrors the evictor's safe
+       * in-place, same-length-array style (no index shifting) and reuses the pure,
+       * unit-tested `isRetirableEvidence` / `foldEvidenceOutcome` from @omnius/memory
+       * for the decision — so directives, plans, the completion contract, ordinary
+       * reasoning, and the base prompt are never touched (they carry no evidence
+       * marker). Marker-gating is what makes touching `system` messages safe here.
+       *
+       * OPT-IN (`OMNIUS_EVIDENCE_RETIREMENT=1`) so it cannot perturb a live run until
+       * the operator flips it on and validates — matching the runtime-harness
+       * discipline we hold for anything that reshapes the model-visible frame. The
+       * canonical message history is unaffected structurally (same length); full
+       * evidence remains on disk (`.omnius/tool-results/`) and re-materialisable.
+       */
+      _retireStaleEvidenceInPlace(messages2, currentTurn) {
+        if (process.env["OMNIUS_EVIDENCE_RETIREMENT"] !== "1")
+          return;
+        const keepRecent = Math.max(0, Number(process.env["OMNIUS_EVIDENCE_KEEP_TURNS"] ?? 2));
+        const minChars = Math.max(512, Number(process.env["OMNIUS_EVIDENCE_MIN_CHARS"] ?? 2e3));
+        const staleBefore = currentTurn - keepRecent;
+        if (staleBefore <= 0)
+          return;
+        let turnCount = 0;
+        let retired = 0;
+        let reclaimed = 0;
+        for (let i2 = 0; i2 < messages2.length; i2++) {
+          const msg = messages2[i2];
+          if (msg.role === "assistant") {
+            turnCount++;
+            if (turnCount > staleBefore)
+              break;
+          }
+          const content = typeof msg.content === "string" ? msg.content : "";
+          if (!content)
+            continue;
+          if (content.startsWith("[RETIRED EVIDENCE") || content.startsWith("[Todo context archived") || content.startsWith("[Tool result cleared")) {
+            continue;
+          }
+          const rm4 = { role: msg.role, content };
+          if (!isRetirableEvidence(rm4, minChars))
+            continue;
+          let outcome;
+          try {
+            outcome = foldEvidenceOutcome(rm4);
+          } catch {
+            outcome = "evidence";
+          }
+          const stub = `[RETIRED EVIDENCE turn<=${staleBefore} bytes=${content.length}] outcome: ${outcome}
+(full evidence retired to disk — re-read the file or re-run the command to re-materialise if you need the detail)`;
+          if (stub.length >= content.length)
+            continue;
+          messages2[i2].content = stub;
+          retired += 1;
+          reclaimed += content.length - stub.length;
+        }
+        if (retired > 0) {
+          this.emit({
+            type: "status",
+            content: `[evidence-retirement] retired ${retired} stale evidence block(s), reclaimed ~${Math.round(reclaimed / 4)} tokens (world-state outcomes retained; bytes on disk)`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+      }
       _evictCompletedTodoMessages(startTurn, currentTurn, todoId, todoContent, messages2) {
         const placeholder = [
           `[Todo context archived: "${todoContent.slice(0, 120)}"`,
@@ -606839,110 +607379,6 @@ var init_conversational_scrutiny = __esm({
   }
 });
 
-// packages/orchestrator/dist/spec-gate.js
-function definitionCount(source, name10) {
-  const n2 = escapeRegExp2(name10);
-  const patterns = [
-    new RegExp(`}\\s*${n2}\\s*;`, "g"),
-    // } Name;  (typedef struct/enum)
-    new RegExp(`\\b(?:struct|class|enum|union)\\s+${n2}\\s*[:{]`, "g"),
-    new RegExp(`\\b(?:interface|type|class|enum)\\s+${n2}\\b`, "g"),
-    new RegExp(`\\btypedef\\s+[^;{]+\\b${n2}\\s*;`, "g")
-  ];
-  let total = 0;
-  for (const re of patterns)
-    total += (source.match(re) ?? []).length;
-  return total;
-}
-function hasField(source, symbol3, field) {
-  const n2 = escapeRegExp2(symbol3);
-  const block = source.match(new RegExp(`(?:struct|class|enum|union|interface)\\s+${n2}[^{]*{([\\s\\S]*?)}|{([\\s\\S]*?)}\\s*${n2}\\s*;`));
-  const body = block?.[1] ?? block?.[2] ?? "";
-  if (!body)
-    return false;
-  return new RegExp(`\\b${escapeRegExp2(field)}\\b`).test(body);
-}
-function hasSignature(source, fragment) {
-  const norm = (s2) => s2.replace(/\s+/g, " ").trim();
-  return norm(source).includes(norm(fragment));
-}
-function evaluateSpecGate(unit, contract, opts = {}) {
-  const violations = [];
-  const expected = new Set(opts.expectedSymbols ?? []);
-  for (const spec of contract.symbols) {
-    const count = definitionCount(unit.source, spec.name);
-    const mustDefine = expected.has(spec.name);
-    if (count === 0) {
-      if (mustDefine) {
-        violations.push({
-          symbol: spec.name,
-          kind: "missing_symbol",
-          detail: `unit ${unit.path} must declare ${spec.kind} ${spec.name} but it is absent`
-        });
-      }
-      continue;
-    }
-    if (count > 1) {
-      violations.push({
-        symbol: spec.name,
-        kind: "duplicate_symbol",
-        detail: `${spec.name} is defined ${count}× in ${unit.path}; the contract permits exactly one`
-      });
-    }
-    for (const field of spec.fields ?? []) {
-      if (!hasField(unit.source, spec.name, field)) {
-        violations.push({
-          symbol: spec.name,
-          kind: "missing_field",
-          detail: `${spec.name} is missing required member "${field}"`
-        });
-      }
-    }
-    if (spec.signature && !hasSignature(unit.source, spec.signature)) {
-      violations.push({
-        symbol: spec.name,
-        kind: "signature_divergence",
-        detail: `${spec.name} does not match the contract signature "${spec.signature}"`
-      });
-    }
-  }
-  const pass = violations.length === 0;
-  return {
-    pass,
-    violations,
-    summary: pass ? `spec gate PASS for ${unit.path}` : `spec gate FAIL for ${unit.path}: ${violations.length} violation(s) — ${violations.map((v) => `${v.symbol}:${v.kind}`).join(", ")}`
-  };
-}
-function evaluateExecutorStep(input) {
-  const spec = evaluateSpecGate(input.unit, input.contract, {
-    expectedSymbols: input.expectedSymbols
-  });
-  if (input.convergenceTier === "abandon" || input.convergenceTier === "stalled") {
-    return {
-      decision: "replan",
-      spec,
-      reason: `convergence ${input.convergenceTier}: stop patching ${input.unit.path}; re-plan / regenerate from the locked contract`
-    };
-  }
-  const boundaryOk = input.boundaryOk ?? true;
-  if (spec.pass && boundaryOk) {
-    return { decision: "accept", spec, reason: `${input.unit.path} accepted` };
-  }
-  return {
-    decision: "reject_regenerate",
-    spec,
-    reason: spec.pass ? `${input.unit.path} passed the spec gate but failed to compile — regenerate` : spec.summary
-  };
-}
-function escapeRegExp2(s2) {
-  return s2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-var init_spec_gate = __esm({
-  "packages/orchestrator/dist/spec-gate.js"() {
-    "use strict";
-  }
-});
-
 // packages/orchestrator/dist/index.js
 var dist_exports3 = {};
 __export(dist_exports3, {
@@ -607026,6 +607462,7 @@ __export(dist_exports3, {
   buildRecentSteeringContext: () => buildRecentSteeringContext,
   buildSkillDescription: () => buildSkillDescription,
   buildSteeringPacket: () => buildSteeringPacket,
+  buildUnitTodos: () => buildUnitTodos,
   checkMilestoneComplete: () => checkMilestoneComplete,
   chooseCheapModelRoute: () => chooseCheapModelRoute,
   claimAssertion: () => claimAssertion,
@@ -607059,6 +607496,7 @@ __export(dist_exports3, {
   criticalPathDepth: () => criticalPathDepth,
   debugArtifactRoot: () => debugArtifactRoot,
   decomposeSpec: () => decomposeSpec,
+  decomposeToUnits: () => decomposeToUnits,
   defaultContextWindowDumpLocations: () => defaultContextWindowDumpLocations,
   deleteAgentTaskSidecar: () => deleteAgentTaskSidecar,
   deriveClaimsFromProposedText: () => deriveClaimsFromProposedText,
@@ -607071,6 +607509,7 @@ __export(dist_exports3, {
   discoverSystemOllamaModelStore: () => discoverSystemOllamaModelStore,
   evaluateExecutorStep: () => evaluateExecutorStep,
   evaluateSpecGate: () => evaluateSpecGate,
+  evaluateUnitResult: () => evaluateUnitResult,
   executeBatch: () => executeBatch,
   executeHook: () => executeHook,
   expandContextReference: () => expandContextReference,
@@ -607302,6 +607741,7 @@ var init_dist8 = __esm({
     init_coherence_gate();
     init_spec_gate();
     init_longhaul_integration();
+    init_decomposition_orchestrator();
   }
 });
 

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.476",
+  "version": "1.0.478",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.476",
+      "version": "1.0.478",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.476",
+  "version": "1.0.478",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",