omnius 1.0.477 → 1.0.479

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();
   }
 });
 
@@ -552472,7 +552586,7 @@ var init_agent_tool = __esm({
           },
           subagent_type: {
             type: "string",
-            enum: ["general", "explore", "plan", "coordinator"],
+            enum: ["general", "explore", "plan", "coordinator", "fixer"],
             description: "Agent type determining tool access and behavior (default: general)"
           },
           deployment_pattern: {
@@ -576129,6 +576243,13 @@ function failureProgressSignal(text2) {
   }
   return lines > 0 ? lines : void 0;
 }
+function isVerificationCommand(toolName, output) {
+  if (isEditTool(toolName))
+    return false;
+  if (toolName !== "shell" && toolName !== "background_run")
+    return false;
+  return failureProgressSignal(output) != null;
+}
 function actionFamily(toolName, args, cwd4) {
   if (isEditTool(toolName)) {
     const path13 = primaryPath(args);
@@ -576590,10 +576711,24 @@ var init_focusSupervisor = __esm({
             // Root fix: progress = the action's error count dropped, not that an
             // edit happened. Extract the signal from the action's own output so a
             // futile edit loop (rebuilding with the same error count) escalates.
-            failureSignal: failureProgressSignal(input.output || input.error)
+            failureSignal: failureProgressSignal(input.output || input.error),
+            // Build-as-feedback: a build/test command is the verification oracle,
+            // never a failing action to abandon. When set, the breaker caps this
+            // family below terminal abandon and escalates to decompose-and-delegate.
+            isVerificationFeedback: isVerificationCommand(input.toolName, input.output || input.error)
           });
           this.sawMutationSinceFailure = false;
-          if (verdict.tier === "abandon") {
+          if (verdict.recommendedAction === "decompose_and_delegate") {
+            this.setDirective({
+              turn: input.turn,
+              state: "forced_replan",
+              reason: verdict.reason,
+              requiredNextAction: this.resolveRequiredNextAction("delegate_isolated_fix"),
+              forbiddenActionFamilies: [
+                actionFamily(input.toolName, input.args, this.familyCwd)
+              ]
+            });
+          } else if (verdict.tier === "abandon") {
             this.markTerminalIncomplete(verdict.reason, input.turn);
           } else if (verdict.tier === "stalled") {
             this.setDirective({
@@ -576788,7 +576923,10 @@ var init_convergence_breaker = __esm({
         }
         const sessionCount = Math.max(1, obs.sessionCount);
         const totalRounds = Math.max(1, base3 + sessionCount - dec);
-        const tier = this.tierFor(totalRounds);
+        let tier = this.tierFor(totalRounds);
+        if (obs.isVerificationFeedback && tier === "abandon") {
+          tier = "stalled";
+        }
         this.live.set(obs.family, { totalRounds, tier });
         const carry = this.store.load(obs.family);
         this.store.save({
@@ -576797,7 +576935,7 @@ var init_convergence_breaker = __esm({
           lastSample: obs.sample ?? carry?.lastSample,
           updatedAtMs: Date.now()
         });
-        return this.verdict(obs.family, totalRounds, tier, obs.sample);
+        return this.verdict(obs.family, totalRounds, tier, obs.sample, obs.isVerificationFeedback ?? false);
       }
       /** Clear a family's carry when its underlying work is verified/complete. */
       resolve(family) {
@@ -576825,8 +576963,18 @@ var init_convergence_breaker = __esm({
           return "converging_warn";
         return "healthy";
       }
-      verdict(family, totalRounds, tier, sample) {
+      verdict(family, totalRounds, tier, sample, verificationFeedback = false) {
         const suffix = sample ? `: ${sample}` : "";
+        if (verificationFeedback && (tier === "stalled" || tier === "abandon")) {
+          return {
+            tier: "stalled",
+            tripped: true,
+            totalRounds,
+            family,
+            reason: `verification command "${family}" has reported the same diagnostic set for ${totalRounds} rounds without shrinking. The build is FEEDBACK, not a failing action — do NOT abandon and do NOT re-run it blindly. Decompose its diagnostics: pick the single top implicated file/symbol, delegate an isolated investigate→fix sub-task for it (sub_agent), then re-run the build to test. Repeat until the diagnostic count drops${suffix}`,
+            recommendedAction: "decompose_and_delegate"
+          };
+        }
         switch (tier) {
           case "abandon":
             return {
@@ -577058,6 +577206,93 @@ var init_spec_gate = __esm({
   }
 });
 
+// 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";
@@ -577110,6 +577345,7 @@ var init_longhaul_integration = __esm({
     init_convergence_breaker();
     init_coherence_gate();
     init_spec_gate();
+    init_decomposition_orchestrator();
     init_dist5();
     init_dist();
     init_dist();
@@ -577166,6 +577402,8 @@ var init_longhaul_integration = __esm({
        * 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,
@@ -577233,8 +577471,10 @@ var init_longhaul_integration = __esm({
           if (verdict.regime === "regenerate")
             return this.locked.size;
           for (const s2 of extractSymbols3(input.content, lang)) {
-            if (!this.locked.has(s2.name))
+            if (!this.locked.has(s2.name)) {
               this.locked.set(s2.name, s2);
+              this.lockedSource.set(s2.name, input.path);
+            }
           }
           return this.locked.size;
         } catch {
@@ -577245,6 +577485,39 @@ var init_longhaul_integration = __esm({
       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
@@ -577274,6 +577547,39 @@ var init_longhaul_integration = __esm({
        * Uses the model's own compiler output — no separate compiler run. Generic
        * across gcc/clang/tsc; returns null when there's nothing structural.
        */
+      /**
+       * B (delegation): turn a stuck build's diagnostics into an ACTIONABLE isolated
+       * sub-task. The main loop is the orchestrator — it holds trajectory and
+       * delegates; it must not keep re-running the build in a saturating context.
+       * This picks the single top structural diagnostic (a file+symbol the compiler
+       * named) and returns the exact `sub_agent` call to spawn an isolated,
+       * small-context worker that fixes JUST that unit, then folds a one-line result
+       * back. Generic: symbols/files come from the compiler's own output, no
+       * toolchain literals. Returns null when the output has no nameable structural
+       * unit (nothing concrete to delegate).
+       */
+      buildDelegationDirective(output) {
+        try {
+          const diags = parseCompilerDiagnostics(String(output || ""));
+          const structural = diags.filter((d2) => d2.kind === "signature_mismatch" || d2.kind === "duplicate_definition" || d2.kind === "unknown_member" || d2.kind === "unknown_symbol" || d2.kind === "type_error");
+          const top = structural.find((d2) => d2.file && d2.symbol) ?? structural.find((d2) => d2.file) ?? diags.find((d2) => d2.file) ?? structural[0] ?? diags[0];
+          if (!top)
+            return null;
+          const file = top.file ?? "the top implicated file";
+          const symbol3 = top.symbol ? ` symbol \`${top.symbol}\`` : "";
+          const kind = top.kind.replace(/_/g, " ");
+          const contractHint = top.symbol && this.lockedSource.has(top.symbol) ? ` The locked contract for \`${top.symbol}\` lives in ${this.lockedSource.get(top.symbol)} — match it exactly.` : "";
+          return `[DELEGATE — build is feedback, not the task] The build reported a stable diagnostic set. Do NOT re-run the build and do NOT keep editing in this context. Delegate ONE isolated fix to a seeded sub-agent, then re-run the build to test:
+  sub_agent({
+    subagent_type: "fixer",
+    description: "fix ${top.symbol ?? file}",
+    prompt: "In ${file}, resolve the ${kind}${symbol3}. Read ONLY ${file} (and the file that declares${symbol3 || " the offending symbol"}). Make the minimal edit to satisfy the contract. Do not touch unrelated files. Report a one-line outcome.${contractHint}"
+  })
+The sub-agent works in its own small context; when it folds back, run the build once to verify the diagnostic count dropped, then delegate the next one. This is fan-out/converge — keep THIS context on trajectory, not on the raw fix.`;
+        } catch {
+          return null;
+        }
+      }
       diagnosticGuidance(output) {
         try {
           const diags = parseCompilerDiagnostics(String(output || ""));
@@ -580759,6 +581065,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)
@@ -587819,7 +588127,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, "_");
@@ -589681,6 +590005,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();
@@ -592754,6 +593079,16 @@ ${specDir}` : specDir;
 
 ${diag}` : diag;
                     }
+                    const focusDir = this._focusSupervisor?.snapshot().directive;
+                    const wantsDelegation = focusDir?.requiredNextAction === "delegate_isolated_fix" || this._decomp2GateActive;
+                    if (wantsDelegation) {
+                      const delegateDir = lh.buildDelegationDirective(result.output ?? result.error ?? "");
+                      if (delegateDir) {
+                        runtimeSystemGuidance = runtimeSystemGuidance ? `${runtimeSystemGuidance}
+
+${delegateDir}` : delegateDir;
+                      }
+                    }
                   }
                 }
               } catch {
@@ -596496,6 +596831,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)}"`,
@@ -603061,7 +603470,7 @@ function resolveAgentTools(type, availableTools) {
 function buildAgentTypeSummary() {
   return _registry2.buildTypeSummary();
 }
-var CORE_TOOLS2, READ_ONLY_TOOLS, COORDINATOR_TOOLS, AGENT_DISALLOWED_TOOLS, GENERAL_AGENT, EXPLORE_AGENT, PLAN_AGENT, COORDINATOR_AGENT, AgentTypeRegistry, _registry2;
+var CORE_TOOLS2, READ_ONLY_TOOLS, COORDINATOR_TOOLS, AGENT_DISALLOWED_TOOLS, GENERAL_AGENT, EXPLORE_AGENT, PLAN_AGENT, COORDINATOR_AGENT, FIXER_TOOLS, FIXER_AGENT, AgentTypeRegistry, _registry2;
 var init_agent_types = __esm({
   "packages/orchestrator/dist/agent-types.js"() {
     "use strict";
@@ -603184,6 +603593,34 @@ var init_agent_types = __esm({
       canSpawnAgents: true,
       systemPromptAddition: "You are a coordinator agent. Your role is to break down complex tasks into sub-tasks and delegate them to worker agents. You CANNOT edit files directly — you must spawn agents to do the work. Monitor their progress via task notifications and coordinate their efforts."
     };
+    FIXER_TOOLS = [
+      "file_read",
+      "file_edit",
+      "file_patch",
+      "shell",
+      // run the build/test to verify its own fix
+      "grep",
+      "glob",
+      "task_complete"
+    ];
+    FIXER_AGENT = {
+      type: "fixer",
+      description: "Isolated single-unit fix worker. Minimal tools (read/edit/build/locate). Dispatched to resolve ONE named diagnostic in ONE file against the locked contract, then report a one-line outcome. Use for delegated build-diagnostic fixes in the fan-out/converge loop.",
+      allowedTools: [...FIXER_TOOLS],
+      disallowedTools: [
+        "file_write",
+        // prefer targeted edit/patch over whole-file writes
+        "agent",
+        "send_message",
+        ...AGENT_DISALLOWED_TOOLS
+      ],
+      maxTurns: 0,
+      // unlimited; halt only on task_complete or abort
+      model: "inherit",
+      isolation: "none",
+      canSpawnAgents: false,
+      systemPromptAddition: "You are an isolated FIX worker with a deliberately small context and tool set. You were given ONE specific diagnostic to resolve in ONE file. Read ONLY that file and the file that declares the offending symbol; make the MINIMAL edit to satisfy the locked contract; run the build once to confirm your change reduced the error; then call task_complete with a single-line outcome (what you changed and whether it verified). Do NOT refactor, do NOT touch unrelated files, do NOT expand scope. Fold back fast."
+    };
     AgentTypeRegistry = class {
       types = /* @__PURE__ */ new Map();
       constructor() {
@@ -603191,6 +603628,7 @@ var init_agent_types = __esm({
         this.register(EXPLORE_AGENT);
         this.register(PLAN_AGENT);
         this.register(COORDINATOR_AGENT);
+        this.register(FIXER_AGENT);
       }
       /** Register a new agent type (or override existing) */
       register(def) {
@@ -607130,6 +607568,7 @@ __export(dist_exports3, {
   buildRecentSteeringContext: () => buildRecentSteeringContext,
   buildSkillDescription: () => buildSkillDescription,
   buildSteeringPacket: () => buildSteeringPacket,
+  buildUnitTodos: () => buildUnitTodos,
   checkMilestoneComplete: () => checkMilestoneComplete,
   chooseCheapModelRoute: () => chooseCheapModelRoute,
   claimAssertion: () => claimAssertion,
@@ -607163,6 +607602,7 @@ __export(dist_exports3, {
   criticalPathDepth: () => criticalPathDepth,
   debugArtifactRoot: () => debugArtifactRoot,
   decomposeSpec: () => decomposeSpec,
+  decomposeToUnits: () => decomposeToUnits,
   defaultContextWindowDumpLocations: () => defaultContextWindowDumpLocations,
   deleteAgentTaskSidecar: () => deleteAgentTaskSidecar,
   deriveClaimsFromProposedText: () => deriveClaimsFromProposedText,
@@ -607175,6 +607615,7 @@ __export(dist_exports3, {
   discoverSystemOllamaModelStore: () => discoverSystemOllamaModelStore,
   evaluateExecutorStep: () => evaluateExecutorStep,
   evaluateSpecGate: () => evaluateSpecGate,
+  evaluateUnitResult: () => evaluateUnitResult,
   executeBatch: () => executeBatch,
   executeHook: () => executeHook,
   expandContextReference: () => expandContextReference,
@@ -607406,6 +607847,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.477",
+  "version": "1.0.479",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.477",
+      "version": "1.0.479",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

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