omnius 1.0.475 → 1.0.477

package/dist/index.js

@@ -576954,9 +576954,148 @@ 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/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 +577103,13 @@ 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_dist5();
     init_dist();
     init_dist();
@@ -577019,6 +577159,13 @@ 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();
       constructor(options2) {
         this.convergenceBreaker = new ConvergenceBreaker({
           ...options2.convergence,
@@ -577069,6 +577216,90 @@ 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);
+          }
+          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-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
+       * 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.
@@ -577108,6 +577339,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)$/;
   }
 });
 
@@ -592504,6 +592736,24 @@ ${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 ?? "");
+                    if (diag) {
+                      runtimeSystemGuidance = runtimeSystemGuidance ? `${runtimeSystemGuidance}
+
+${diag}` : diag;
+                    }
                   }
                 }
               } catch {
@@ -606797,110 +607047,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, {

package/npm-shrinkwrap.json

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

package/package.json

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