omnius 1.0.477 → 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();
   }
 });
 
@@ -577058,6 +577172,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 +577311,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 +577368,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 +577437,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 +577451,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
@@ -580759,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)
@@ -587819,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, "_");
@@ -589681,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();
@@ -596496,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)}"`,
@@ -607130,6 +607462,7 @@ __export(dist_exports3, {
   buildRecentSteeringContext: () => buildRecentSteeringContext,
   buildSkillDescription: () => buildSkillDescription,
   buildSteeringPacket: () => buildSteeringPacket,
+  buildUnitTodos: () => buildUnitTodos,
   checkMilestoneComplete: () => checkMilestoneComplete,
   chooseCheapModelRoute: () => chooseCheapModelRoute,
   claimAssertion: () => claimAssertion,
@@ -607163,6 +607496,7 @@ __export(dist_exports3, {
   criticalPathDepth: () => criticalPathDepth,
   debugArtifactRoot: () => debugArtifactRoot,
   decomposeSpec: () => decomposeSpec,
+  decomposeToUnits: () => decomposeToUnits,
   defaultContextWindowDumpLocations: () => defaultContextWindowDumpLocations,
   deleteAgentTaskSidecar: () => deleteAgentTaskSidecar,
   deriveClaimsFromProposedText: () => deriveClaimsFromProposedText,
@@ -607175,6 +607509,7 @@ __export(dist_exports3, {
   discoverSystemOllamaModelStore: () => discoverSystemOllamaModelStore,
   evaluateExecutorStep: () => evaluateExecutorStep,
   evaluateSpecGate: () => evaluateSpecGate,
+  evaluateUnitResult: () => evaluateUnitResult,
   executeBatch: () => executeBatch,
   executeHook: () => executeHook,
   expandContextReference: () => expandContextReference,
@@ -607406,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.477",
+  "version": "1.0.478",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.477",
+      "version": "1.0.478",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.477",
+  "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",