omnius 1.0.353 → 1.0.354

package/dist/index.js

@@ -567440,6 +567440,81 @@ var init_adversaryStream = __esm({
   }
 });
 
+// packages/orchestrator/dist/completion-resolution-verifier.js
+function resolutionSystemPrompt() {
+  return [
+    "You are a COMPLETION VERIFIER. A coding agent wants to mark a task complete.",
+    "Your only job: decide whether the ACTIONS IT TOOK actually accomplish the ORIGINAL request.",
+    "",
+    "Judge from the ORIGINAL REQUEST and the ACTIONS + EVIDENCE only. The agent's own",
+    "summary is just a CLAIM — never treat the claim as proof. The agent has a documented",
+    "bias toward declaring success prematurely, so be strict:",
+    "  - An edit is not a fix unless the evidence shows the failing thing now passes.",
+    "  - 'started' / a PID / a log line is not 'running' or 'working'.",
+    "  - exit code 0 on an unrelated command does not resolve the request.",
+    "  - Doing PART of the request, or adjacent work, is NOT resolution.",
+    "  - If the request had multiple parts, EVERY part must be addressed.",
+    "",
+    "Respond with ONLY a JSON object, no prose, no code fences:",
+    '{"resolved": true|false,',
+    ' "confidence": 0.0-1.0,',
+    ' "missing": ["each concrete part of the ORIGINAL request not yet accomplished"],',
+    ' "rationale": "2-3 sentences citing the specific actions/evidence (or their absence)"}',
+    "",
+    "Set resolved=true ONLY when the actions+evidence directly and fully accomplish the",
+    "original request. When in doubt, resolved=false and name what is missing."
+  ].join("\n");
+}
+function buildResolutionPrompt(i2) {
+  return [
+    "ORIGINAL REQUEST (what the user actually asked for):",
+    i2.originalGoal.slice(0, 2e3) || "(empty)",
+    "",
+    "ACTIONS THE AGENT TOOK:",
+    i2.actionsDigest.slice(0, 3e3) || "(none recorded)",
+    "",
+    "GROUNDED EVIDENCE (outcomes, tests, files):",
+    i2.evidenceDigest.slice(0, 2e3) || "(none recorded)",
+    "",
+    "THE AGENT'S COMPLETION CLAIM (audit this — do NOT trust it as evidence):",
+    i2.proposedSummary.slice(0, 1500) || "(empty)",
+    "",
+    "Does the work above directly and fully accomplish the ORIGINAL REQUEST? Return ONLY the JSON object."
+  ].join("\n");
+}
+function parseResolutionVerdict(raw) {
+  if (!raw)
+    return null;
+  const text2 = raw.trim().replace(/^```(?:json)?/i, "").replace(/```$/i, "").trim();
+  const start2 = text2.indexOf("{");
+  const end = text2.lastIndexOf("}");
+  if (start2 < 0 || end <= start2)
+    return null;
+  let obj;
+  try {
+    obj = JSON.parse(text2.slice(start2, end + 1));
+  } catch {
+    return null;
+  }
+  let confidence2 = Number(obj["confidence"]);
+  if (!Number.isFinite(confidence2))
+    confidence2 = 0.6;
+  confidence2 = Math.min(1, Math.max(0, confidence2));
+  const missingRaw = obj["missing"];
+  const missing = Array.isArray(missingRaw) ? missingRaw.map((m2) => String(m2)).filter((m2) => m2.trim()).slice(0, 12) : [];
+  return {
+    resolved: obj["resolved"] === true,
+    confidence: confidence2,
+    missing,
+    rationale: String(obj["rationale"] ?? "").slice(0, 800)
+  };
+}
+var init_completion_resolution_verifier = __esm({
+  "packages/orchestrator/dist/completion-resolution-verifier.js"() {
+    "use strict";
+  }
+});
+
 // packages/orchestrator/dist/evidenceBranch.js
 function queryTerms(query) {
   return [
@@ -569606,6 +569681,7 @@ var init_agenticRunner = __esm({
     init_context_fabric();
     init_evidenceLedger();
     init_adversaryStream();
+    init_completion_resolution_verifier();
     init_evidenceBranch();
     init_resolution_memory();
     init_contextEngine();
@@ -569923,6 +569999,9 @@ var init_agenticRunner = __esm({
       // because the configured verify command failed. Bounded by
       // OMNIUS_COMPLETION_VERIFY_MAX to avoid an endless verify→fix→verify loop.
       _completionVerifyRejections = 0;
+      // Diagnostics counter for the inference-driven resolution gate (the real
+      // bounded escape is the same-summary completion-hold counter / REG-54).
+      _resolutionGateRejections = 0;
       _lastBackwardPassVerdict = null;
       _lastBackwardPassCritique = null;
       // Run-local completion contract inferred from the user's ask/context before
@@ -571733,6 +571812,119 @@ ${input.answerText ?? ""}`.toLowerCase().trim();
        * up auto-blocking and surfaces a status event so the caller can take
        * a different path (eg. surface to user). max cycles enforced here.
        */
+      /**
+       * Inference-driven, original-request-anchored completion gate. Runs ONE
+       * grounded LLM call (native /api/chat via _auxInferenceBackend) asking whether
+       * the actions taken actually resolve the ORIGINAL request. Returns
+       * { proceed:false, feedback, reason } to HOLD task_complete when not resolved.
+       * Bounded: after OMNIUS_COMPLETION_HOLD_MAX holds of the same summary the
+       * existing REG-54 escape finishes the run as incomplete_verification.
+       *
+       * Disabled by OMNIUS_DISABLE_RESOLUTION_GATE=1, by disableAdversaryCritic, by
+       * a missing backend, or when the run took no file/shell actions. Fails OPEN on
+       * any inference error — never hard-stalls a run because the verifier hiccuped.
+       *
+       * Anti-reward-hacking: the verdict is judged from originalGoal + actions +
+       * evidence; proposedSummary is passed only as "the claim under audit".
+       */
+      async _runResolutionGate(turn, proposedSummary, toolCallLog) {
+        if (process.env["OMNIUS_DISABLE_RESOLUTION_GATE"] === "1")
+          return { proceed: true };
+        if (this.options.disableAdversaryCritic === true)
+          return { proceed: true };
+        if (!this.backend || typeof this.backend.chatCompletion !== "function")
+          return { proceed: true };
+        if (this._resolutionGateRejections >= 3)
+          return { proceed: true };
+        if (/^\s*BLOCKED\b/i.test(proposedSummary))
+          return { proceed: true };
+        const originalGoal = (this._taskState.originalGoal || this._taskState.goal || "").trim();
+        if (!originalGoal)
+          return { proceed: true };
+        const actionable = toolCallLog.some((e2) => e2.mutated || e2.name === "shell" || e2.name === "file_write" || e2.name === "file_edit");
+        if (!actionable)
+          return { proceed: true };
+        const filesChanged = [...this._taskState.modifiedFiles.entries()].map(([p2, action]) => `  - ${action} ${p2}`).slice(0, 40);
+        const shellLines = toolCallLog.filter((e2) => e2.name === "shell").slice(-12).map((e2) => `  - shell: ${e2.success ? "ok" : "FAIL"} — ${(e2.outputPreview || "").slice(0, 120)}`);
+        const actionsDigest = [
+          filesChanged.length ? `Files changed (${filesChanged.length}):
+${filesChanged.join("\n")}` : "Files changed: none",
+          shellLines.length ? `Recent commands:
+${shellLines.join("\n")}` : "Commands run: none"
+        ].join("\n");
+        const wf = this._worldFacts;
+        const evidenceParts = [];
+        if (wf?.lastTest?.summary) {
+          evidenceParts.push(`Last test outcome: ${wf.lastTest.passed ? "PASSED" : "FAILED"} — ${wf.lastTest.summary.slice(0, 200)}`);
+        }
+        const failCount = toolCallLog.filter((e2) => e2.success === false).length;
+        evidenceParts.push(`Failed tool calls this run: ${failCount}`);
+        const evidenceDigest = evidenceParts.join("\n");
+        let verdict = null;
+        try {
+          const backend = this._auxInferenceBackend();
+          for (let attempt = 0; attempt < 2 && !verdict; attempt++) {
+            const resp = await backend.chatCompletion({
+              messages: [
+                { role: "system", content: resolutionSystemPrompt() },
+                {
+                  role: "user",
+                  content: buildResolutionPrompt({
+                    originalGoal,
+                    actionsDigest,
+                    evidenceDigest,
+                    proposedSummary
+                  })
+                }
+              ],
+              tools: [],
+              temperature: 0,
+              maxTokens: 700,
+              timeoutMs: 3e4
+            });
+            verdict = parseResolutionVerdict(resp.choices?.[0]?.message?.content ?? "");
+          }
+        } catch {
+          verdict = null;
+        }
+        if (!verdict)
+          return { proceed: true };
+        if (verdict.resolved || verdict.confidence < 0.5) {
+          this._resolutionGateRejections = 0;
+          return { proceed: true };
+        }
+        this._resolutionGateRejections++;
+        const missing = verdict.missing.length ? verdict.missing.map((m2) => `  • ${m2}`).join("\n") : "  • (verifier did not enumerate specific gaps; re-read the original request)";
+        const feedback = [
+          `[COMPLETION BLOCKED — actions do not yet resolve the original request]`,
+          `Original request: ${originalGoal.slice(0, 300)}`,
+          `Verifier rationale: ${verdict.rationale}`,
+          `Still unaddressed:`,
+          missing,
+          ``,
+          `Do the work that actually accomplishes the unaddressed items above, then re-verify.`,
+          `Do NOT call task_complete again until each item is done AND its result is evidenced.`
+        ].join("\n");
+        const reason = `task resolution not verified (${verdict.missing.length} item(s) unaddressed)`;
+        this.emit({
+          type: "adversary_reaction",
+          adversary: {
+            class: "false_success",
+            shortText: `Completion blocked — ${verdict.missing.length} request item(s) unresolved`,
+            confidence: verdict.confidence,
+            details: feedback
+          },
+          turn,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        this.emit({
+          type: "status",
+          content: `Resolution gate HELD task_complete: ${reason}`,
+          turn,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return { proceed: false, feedback, reason };
+      }
       /**
        * Completion compile/verify gate (opt-in). Runs a configured shell command
        * (e.g. a typecheck/build) before `task_complete` is accepted, but ONLY when
@@ -571841,6 +572033,13 @@ ${input.answerText ?? ""}`.toLowerCase().trim();
         const _verify = await this._runCompletionVerifyGate(turn);
         if (!_verify.proceed)
           return _verify;
+        const _resolution = await this._runResolutionGate(turn, proposedSummary, toolCallLog);
+        if (!_resolution.proceed) {
+          return {
+            proceed: false,
+            feedback: _resolution.feedback ?? "Completion not resolved."
+          };
+        }
         if (this._completionLedger && proposedSummary) {
           const _newClaims = deriveClaimsFromProposedText({
             text: proposedSummary,
@@ -574960,6 +575159,7 @@ Respond with your assessment, then take action.`;
         this._fileWritesThisRun = 0;
         this._backwardPassCyclesUsed = 0;
         this._completionVerifyRejections = 0;
+        this._resolutionGateRejections = 0;
         this._lastBackwardPassVerdict = null;
         this._lastBackwardPassCritique = null;
         this._completionContract = null;

package/npm-shrinkwrap.json

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

package/package.json

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