omnius 1.0.474 → 1.0.476

package/dist/index.js

@@ -576110,6 +576110,25 @@ function normalizeShellForFamily(command, cwd4) {
   } while (s2 !== prev);
   return s2.replace(/\s+/g, " ").trim();
 }
+function failureProgressSignal(text2) {
+  const s2 = String(text2 || "");
+  if (!s2.trim())
+    return void 0;
+  let explicit;
+  for (const m2 of s2.matchAll(/(\d+)\s+(?:errors?|failures?|failed|problems?)\b/gi)) {
+    const n2 = Number(m2[1]);
+    if (Number.isFinite(n2))
+      explicit = Math.max(explicit ?? 0, n2);
+  }
+  if (explicit != null)
+    return explicit;
+  let lines = 0;
+  for (const line of s2.split(/\r?\n/)) {
+    if (/\b(errors?|fail(?:ed|ure|ures|s)?)\b/i.test(line))
+      lines++;
+  }
+  return lines > 0 ? lines : void 0;
+}
 function actionFamily(toolName, args, cwd4) {
   if (isEditTool(toolName)) {
     const path13 = primaryPath(args);
@@ -576567,7 +576586,11 @@ var init_focusSupervisor = __esm({
             turn: input.turn,
             sample: next.sample,
             errorClass: next.errorClass,
-            mutatedSinceLast: this.sawMutationSinceFailure
+            mutatedSinceLast: this.sawMutationSinceFailure,
+            // 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)
           });
           this.sawMutationSinceFailure = false;
           if (verdict.tier === "abandon") {
@@ -576730,6 +576753,8 @@ var init_convergence_breaker = __esm({
       baseline = /* @__PURE__ */ new Map();
       /** Progress decay accumulated this session (one per productive mutation). */
       decay = /* @__PURE__ */ new Map();
+      /** Last verification signal (error count) seen per family, for delta-based progress. */
+      lastSignal = /* @__PURE__ */ new Map();
       constructor(options2 = {}) {
         this.warnRound = Math.max(1, options2.warnRound ?? DEFAULTS.warnRound);
         this.stallRound = Math.max(this.warnRound + 1, options2.stallRound ?? DEFAULTS.stallRound);
@@ -576749,7 +576774,15 @@ var init_convergence_breaker = __esm({
         }
         const base3 = this.baseline.get(obs.family) ?? 0;
         let dec = this.decay.get(obs.family) ?? 0;
-        if (obs.mutatedSinceLast) {
+        let madeProgress;
+        if (obs.failureSignal != null) {
+          const prev = this.lastSignal.get(obs.family);
+          madeProgress = prev != null && obs.failureSignal < prev;
+          this.lastSignal.set(obs.family, obs.failureSignal);
+        } else {
+          madeProgress = Boolean(obs.mutatedSinceLast);
+        }
+        if (madeProgress) {
           dec += 1;
           this.decay.set(obs.family, dec);
         }
@@ -576771,6 +576804,7 @@ var init_convergence_breaker = __esm({
         this.live.delete(family);
         this.baseline.delete(family);
         this.decay.delete(family);
+        this.lastSignal.delete(family);
         this.store.save({ family, rounds: 0, updatedAtMs: Date.now() });
       }
       snapshot() {
@@ -577035,6 +577069,40 @@ var init_longhaul_integration = __esm({
           return null;
         }
       }
+      /**
+       * WO-1 (PyTy pattern): parse a failed build/verify command's own output for
+       * named STRUCTURAL contract violations (signature mismatch / duplicate
+       * definition / unknown member or symbol) and return guidance naming the exact
+       * drifted symbols, so the next edit targets the drift instead of guessing.
+       * Uses the model's own compiler output — no separate compiler run. Generic
+       * across gcc/clang/tsc; returns null when there's nothing structural.
+       */
+      diagnosticGuidance(output) {
+        try {
+          const diags = parseCompilerDiagnostics(String(output || ""));
+          const byKind = /* @__PURE__ */ new Map();
+          for (const d2 of diags) {
+            if (d2.kind !== "signature_mismatch" && d2.kind !== "duplicate_definition" && d2.kind !== "unknown_member" && d2.kind !== "unknown_symbol")
+              continue;
+            if (!d2.symbol)
+              continue;
+            const arr = byKind.get(d2.kind) ?? [];
+            if (!arr.includes(d2.symbol) && arr.length < 4)
+              arr.push(d2.symbol);
+            byKind.set(d2.kind, arr);
+          }
+          const parts = [];
+          for (const [kind, syms] of byKind) {
+            if (syms.length)
+              parts.push(`${kind.replace(/_/g, " ")} → ${syms.join(", ")}`);
+          }
+          if (parts.length === 0)
+            return null;
+          return `Compiler reports structural contract violations — reconcile these EXACT symbols before editing unrelated files: ${parts.join("; ")}. A signature/definition mismatch means a declaration and its use disagree; fix them against the locked contract (or regenerate the unit) rather than patching around it.`;
+        } catch {
+          return null;
+        }
+      }
       /**
        * WO-5: decide whether to compact now (threshold AND rubric). The hard ceiling
        * guarantees a truly-full window still compacts.
@@ -592471,6 +592539,14 @@ ${rec.guidance}` : rec.guidance;
 ${dir}` : dir;
                     }
                   }
+                  if (!result.success) {
+                    const diag = lh.diagnosticGuidance(result.output ?? result.error ?? "");
+                    if (diag) {
+                      runtimeSystemGuidance = runtimeSystemGuidance ? `${runtimeSystemGuidance}
+
+${diag}` : diag;
+                    }
+                  }
                 }
               } catch {
               }

package/npm-shrinkwrap.json

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

package/package.json

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