omnius 1.0.233 → 1.0.234

package/dist/index.js

@@ -7416,12 +7416,12 @@ Meta: ${metaKeys.map((k) => `${k}="${meta[k]?.slice(0, 80)}"`).join(", ")}`);
               if (!text)
                 continue;
               const record = {};
-              for (const [field] of Object.entries(schema)) {
-                const normalized = field.replace(/_/g, "[_ ]?");
+              for (const [field2] of Object.entries(schema)) {
+                const normalized = field2.replace(/_/g, "[_ ]?");
                 const pattern = new RegExp(`${normalized}[:\\s]+([^\\n]+)`, "i");
                 const match = text.match(pattern);
                 if (match)
-                  record[field] = match[1]?.trim();
+                  record[field2] = match[1]?.trim();
               }
               if (Object.keys(record).length > 0)
                 extracted.push(record);
@@ -10194,13 +10194,13 @@ function buildImageMarker(buffer2) {
   return { mimeType, base64: out.toString("base64") };
 }
 function classifyBrowserGate(input) {
-  const haystack = `${input.url}
+  const haystack2 = `${input.url}
 ${input.html.slice(0, 8e4)}
 ${input.text.slice(0, 2e4)}`.toLowerCase();
   const contentHaystack = `${input.html.slice(0, 8e4)}
 ${input.text.slice(0, 2e4)}`.toLowerCase();
   const evidence = [];
-  const addIf = (kind, confidence2, pattern, label, hay = haystack) => {
+  const addIf = (kind, confidence2, pattern, label, hay = haystack2) => {
     if (!pattern.test(hay))
       return null;
     evidence.push(label);
@@ -10223,7 +10223,7 @@ ${input.text.slice(0, 2e4)}`.toLowerCase();
       evidence: [`HTTP ${statusFailures[0].status} seen for ${statusFailures[0].url}`]
     };
   }
-  if (/\b(enable javascript|javascript is disabled|please enable cookies)\b/i.test(haystack)) {
+  if (/\b(enable javascript|javascript is disabled|please enable cookies)\b/i.test(haystack2)) {
     return { kind: "js_render_failed", confidence: 0.72, evidence: ["JavaScript/cookie render warning found"] };
   }
   if (input.errors.length > 0) {
@@ -12042,36 +12042,36 @@ function extractEditPath(args) {
   }
   return null;
 }
-function countOccurrences(haystack, needle) {
+function countOccurrences(haystack2, needle) {
   let count = 0;
   let pos = 0;
-  while ((pos = haystack.indexOf(needle, pos)) !== -1) {
+  while ((pos = haystack2.indexOf(needle, pos)) !== -1) {
     count++;
     pos += needle.length;
   }
   return count;
 }
-function findMatchLines(haystack, needle) {
+function findMatchLines(haystack2, needle) {
   const lines = [];
   let pos = 0;
-  while ((pos = haystack.indexOf(needle, pos)) !== -1) {
-    const lineNumber = haystack.slice(0, pos).split("\n").length;
+  while ((pos = haystack2.indexOf(needle, pos)) !== -1) {
+    const lineNumber = haystack2.slice(0, pos).split("\n").length;
     lines.push(lineNumber);
     pos += needle.length;
   }
   return lines;
 }
-function findMatchOffsets(haystack, needle) {
+function findMatchOffsets(haystack2, needle) {
   const offsets = [];
   let pos = 0;
-  while ((pos = haystack.indexOf(needle, pos)) !== -1) {
+  while ((pos = haystack2.indexOf(needle, pos)) !== -1) {
     offsets.push(pos);
     pos += needle.length;
   }
   return offsets;
 }
-function replaceAllOccurrences(haystack, needle, replacement) {
-  return haystack.split(needle).join(replacement);
+function replaceAllOccurrences(haystack2, needle, replacement) {
+  return haystack2.split(needle).join(replacement);
 }
 var FileEditTool;
 var init_file_edit = __esm({
@@ -13280,12 +13280,12 @@ function extractSearchTerms(query) {
   return terms2;
 }
 function lexicalHitScore(text, terms2) {
-  const haystack = text.toLowerCase();
+  const haystack2 = text.toLowerCase();
   if (terms2.length === 0)
     return 0;
   let hits = 0;
   for (const term of terms2) {
-    if (haystack.includes(term))
+    if (haystack2.includes(term))
       hits++;
   }
   return clamp012(hits / terms2.length);
@@ -22250,8 +22250,8 @@ function isConsolidated(item) {
   const metadataConsolidated = item.metadata?.["consolidated"] ?? item.metadata?.["isConsolidated"];
   if (typeof metadataConsolidated === "boolean")
     return metadataConsolidated;
-  const haystack = `${item.kind} ${item.source} ${String(item.metadata?.["stage"] ?? "")}`.toLowerCase();
-  return /\b(gist|summary|semantic|memory|reflection|self_model|social_state|compressed|context_frame|anchor)\b/.test(haystack);
+  const haystack2 = `${item.kind} ${item.source} ${String(item.metadata?.["stage"] ?? "")}`.toLowerCase();
+  return /\b(gist|summary|semantic|memory|reflection|self_model|social_state|compressed|context_frame|anchor)\b/.test(haystack2);
 }
 function addBucket(buckets, key, tokens, consolidated) {
   const k = key || "unknown";
@@ -23971,13 +23971,13 @@ function searchFile(repoRoot, fullPath, query, snippetChars) {
   } catch {
     return null;
   }
-  const haystack = flattenSessionContent(raw);
-  const lowerHaystack = haystack.toLowerCase();
+  const haystack2 = flattenSessionContent(raw);
+  const lowerHaystack = haystack2.toLowerCase();
   const lowerQuery = query.toLowerCase();
   const positions = allIndexesOf(lowerHaystack, lowerQuery);
   if (positions.length === 0)
     return null;
-  const snippets = positions.slice(0, 3).map((pos) => buildSnippet(haystack, pos, query.length, snippetChars));
+  const snippets = positions.slice(0, 3).map((pos) => buildSnippet(haystack2, pos, query.length, snippetChars));
   const stat8 = statSync8(fullPath);
   return {
     file: relative2(repoRoot, fullPath),
@@ -25086,19 +25086,19 @@ var init_aiwg_workflow = __esm({
 // packages/execution/dist/tools/batch-edit.js
 import { readFile as readFile7, writeFile as writeFile5 } from "node:fs/promises";
 import { resolve as resolve16 } from "node:path";
-function findMatchOffsetsBatch(haystack, needle) {
+function findMatchOffsetsBatch(haystack2, needle) {
   const offsets = [];
   let pos = 0;
-  while ((pos = haystack.indexOf(needle, pos)) !== -1) {
+  while ((pos = haystack2.indexOf(needle, pos)) !== -1) {
     offsets.push(pos);
     pos += needle.length;
   }
   return offsets;
 }
-function countOccurrences2(haystack, needle) {
+function countOccurrences2(haystack2, needle) {
   let count = 0;
   let pos = 0;
-  while ((pos = haystack.indexOf(needle, pos)) !== -1) {
+  while ((pos = haystack2.indexOf(needle, pos)) !== -1) {
     count++;
     pos += needle.length;
   }
@@ -47679,7 +47679,7 @@ function FpSqrt(P2) {
     return sqrt9mod16(P2);
   return tonelliShanks(P2);
 }
-function validateField(field) {
+function validateField(field2) {
   const initial = {
     ORDER: "bigint",
     BYTES: "number",
@@ -47689,8 +47689,8 @@ function validateField(field) {
     map2[val] = "function";
     return map2;
   }, initial);
-  validateObject(field, opts);
-  return field;
+  validateObject(field2, opts);
+  return field2;
 }
 function FpPow(Fp, num2, power) {
   if (power < _0n2)
@@ -47998,12 +47998,12 @@ function mulEndoUnsafe(Point, point, k1, k2) {
   }
   return { p1, p2 };
 }
-function createField(order, field, isLE2) {
-  if (field) {
-    if (field.ORDER !== order)
+function createField(order, field2, isLE2) {
+  if (field2) {
+    if (field2.ORDER !== order)
       throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
-    validateField(field);
-    return field;
+    validateField(field2);
+    return field2;
   } else {
     return Field(order, { isLE: isLE2 });
   }
@@ -95916,12 +95916,12 @@ var require_x509_cjs = __commonJS({
         const res = super.toTextObjectEmpty();
         for (const name10 of this.items) {
           const nameObj = name10.toTextObject();
-          let field = res[nameObj[TextObject.NAME]];
-          if (!Array.isArray(field)) {
-            field = [];
-            res[nameObj[TextObject.NAME]] = field;
+          let field2 = res[nameObj[TextObject.NAME]];
+          if (!Array.isArray(field2)) {
+            field2 = [];
+            res[nameObj[TextObject.NAME]] = field2;
           }
-          field.push(nameObj);
+          field2.push(nameObj);
         }
         return res;
       }
@@ -96578,12 +96578,12 @@ var require_x509_cjs = __commonJS({
         urls.forEach((name10, index) => {
           const nameObj = name10.toTextObject();
           const indexedKey = `${nameObj[TextObject.NAME]} ${index + 1}`;
-          let field = names2[indexedKey];
-          if (!Array.isArray(field)) {
-            field = [];
-            names2[indexedKey] = field;
+          let field2 = names2[indexedKey];
+          if (!Array.isArray(field2)) {
+            field2 = [];
+            names2[indexedKey] = field2;
           }
-          field.push(nameObj);
+          field2.push(nameObj);
         });
         obj[key] = names2;
       }
@@ -98300,8 +98300,8 @@ var require_crypto = __commonJS({
         notAfter: cert.notAfter
       };
     };
-    function getCsrAsn1CharStringType(field) {
-      switch (field) {
+    function getCsrAsn1CharStringType(field2) {
+      switch (field2) {
         case "C":
           return "printableString";
         case "E":
@@ -109178,7 +109178,7 @@ var require_form_data = __commonJS({
     util2.inherits(FormData2, CombinedStream);
     FormData2.LINE_BREAK = "\r\n";
     FormData2.DEFAULT_CONTENT_TYPE = "application/octet-stream";
-    FormData2.prototype.append = function(field, value2, options2) {
+    FormData2.prototype.append = function(field2, value2, options2) {
       options2 = options2 || {};
       if (typeof options2 === "string") {
         options2 = { filename: options2 };
@@ -109191,7 +109191,7 @@ var require_form_data = __commonJS({
         this._error(new Error("Arrays are not supported."));
         return;
       }
-      var header = this._multiPartHeader(field, value2, options2);
+      var header = this._multiPartHeader(field2, value2, options2);
       var footer = this._multiPartFooter();
       append(header);
       append(value2);
@@ -109242,7 +109242,7 @@ var require_form_data = __commonJS({
         callback("Unknown stream");
       }
     };
-    FormData2.prototype._multiPartHeader = function(field, value2, options2) {
+    FormData2.prototype._multiPartHeader = function(field2, value2, options2) {
       if (typeof options2.header === "string") {
         return options2.header;
       }
@@ -109251,7 +109251,7 @@ var require_form_data = __commonJS({
       var contents = "";
       var headers = {
         // add custom disposition as third element or keep it two elements if not
-        "Content-Disposition": ["form-data", 'name="' + field + '"'].concat(contentDisposition || []),
+        "Content-Disposition": ["form-data", 'name="' + field2 + '"'].concat(contentDisposition || []),
         // if no content type. allow it to be empty array
         "Content-Type": [].concat(contentType || [])
       };
@@ -114124,10 +114124,10 @@ var require_http = __commonJS({
        * @param {string} field Meta field name
        * @returns {Promise<string|null>} Meta field value
        */
-      async getMetaField(field) {
+      async getMetaField(field2) {
         const dir = await this.getDirectory();
-        if ("meta" in dir && field in dir.meta) {
-          return dir.meta[field];
+        if ("meta" in dir && field2 in dir.meta) {
+          return dir.meta[field2];
         }
         return null;
       }
@@ -161578,41 +161578,41 @@ var require_eventsource_stream = __commonJS({
         if (colonPosition === 0) {
           return;
         }
-        let field = "";
+        let field2 = "";
         let value2 = "";
         if (colonPosition !== -1) {
-          field = line.subarray(0, colonPosition).toString("utf8");
+          field2 = line.subarray(0, colonPosition).toString("utf8");
           let valueStart = colonPosition + 1;
           if (line[valueStart] === SPACE) {
             ++valueStart;
           }
           value2 = line.subarray(valueStart).toString("utf8");
         } else {
-          field = line.toString("utf8");
+          field2 = line.toString("utf8");
           value2 = "";
         }
-        switch (field) {
+        switch (field2) {
           case "data":
-            if (event[field] === void 0) {
-              event[field] = value2;
+            if (event[field2] === void 0) {
+              event[field2] = value2;
             } else {
-              event[field] += `
+              event[field2] += `
 ${value2}`;
             }
             break;
           case "retry":
             if (isASCIINumber(value2)) {
-              event[field] = value2;
+              event[field2] = value2;
             }
             break;
           case "id":
             if (isValidLastEventId(value2)) {
-              event[field] = value2;
+              event[field2] = value2;
             }
             break;
           case "event":
             if (value2.length > 0) {
-              event[field] = value2;
+              event[field2] = value2;
             }
             break;
         }
@@ -252716,13 +252716,13 @@ var init_RTCIceCandidate = __esm({
           __privateSet4(this, _relatedAddress, null);
           __privateSet4(this, _relatedPort, null);
           for (let i2 = 8; i2 < fields.length; i2++) {
-            const field = fields[i2];
-            if (field === "raddr") {
+            const field2 = fields[i2];
+            if (field2 === "raddr") {
               __privateSet4(this, _relatedAddress, fields[i2 + 1]);
-            } else if (field === "rport") {
+            } else if (field2 === "rport") {
               __privateSet4(this, _relatedPort, parseInt(fields[i2 + 1], 10));
             }
-            if (__privateGet4(this, _protocol2) === "tcp" && field === "tcptype") {
+            if (__privateGet4(this, _protocol2) === "tcp" && field2 === "tcptype") {
               __privateSet4(this, _tcpType, fields[i2 + 1]);
             }
           }
@@ -271686,21 +271686,21 @@ Homeostasis: uncertainty=${h.uncertainty.toFixed(2)} coherence=${h.coherence.toF
       // ── Propose Update ───────────────────────────────────────────────────────
       async proposeUpdate(args, start2) {
         const changeType = String(args.change_type ?? "new_fact");
-        const field = String(args.field ?? "");
+        const field2 = String(args.field ?? "");
         const value2 = String(args.value ?? "");
         const justification = String(args.justification ?? "");
-        if (!field || !value2) {
+        if (!field2 || !value2) {
           return { success: false, output: "field and value required", durationMs: performance.now() - start2 };
         }
         if (this.reflectionGate) {
           try {
-            const proposal = `${changeType}: ${field} = ${value2}. Justification: ${justification}`;
-            const verdict = await this.reflectionGate(proposal, `Identity update to ${field}`);
+            const proposal = `${changeType}: ${field2} = ${value2}. Justification: ${justification}`;
+            const verdict = await this.reflectionGate(proposal, `Identity update to ${field2}`);
             if (verdict.status === "block") {
               return {
                 success: false,
                 output: `Identity update BLOCKED by reflection gate:
-  Proposal: ${changeType} on ${field}
+  Proposal: ${changeType} on ${field2}
   Findings: ${verdict.findings.join("; ")}
   The reflection layer vetoed this self-update per COHERE invariant.`,
                 durationMs: performance.now() - start2
@@ -271713,7 +271713,7 @@ Homeostasis: uncertainty=${h.uncertainty.toFixed(2)} coherence=${h.coherence.toF
           await this.hydrate(start2);
         const oldVersion = this.selfState.version;
         this.selfState.version++;
-        switch (field) {
+        switch (field2) {
           case "narrative_summary":
             this.selfState.narrative_summary = value2;
             break;
@@ -271749,11 +271749,11 @@ Homeostasis: uncertainty=${h.uncertainty.toFixed(2)} coherence=${h.coherence.toF
             }
             break;
           default:
-            return { success: false, output: `Unknown field: ${field}`, durationMs: performance.now() - start2 };
+            return { success: false, output: `Unknown field: ${field2}`, durationMs: performance.now() - start2 };
         }
         this.selfState.version_history.push({
           version: this.selfState.version,
-          change: `${changeType}: ${field} = ${value2.slice(0, 100)} — ${justification.slice(0, 100)}`,
+          change: `${changeType}: ${field2} = ${value2.slice(0, 100)} — ${justification.slice(0, 100)}`,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
         if (this.selfState.version_history.length > 50) {
@@ -271766,7 +271766,7 @@ Homeostasis: uncertainty=${h.uncertainty.toFixed(2)} coherence=${h.coherence.toF
         return {
           success: true,
           output: `Identity updated: v${oldVersion} → v${this.selfState.version}
-Change: ${changeType} on ${field}
+Change: ${changeType} on ${field2}
 Justification: ${justification || "(none provided)"}`,
           durationMs: performance.now() - start2
         };
@@ -298725,8 +298725,8 @@ ${lanes.join("\n")}
           if (other === void 0) return 1;
           return compareValues(this.major, other.major) || compareValues(this.minor, other.minor) || compareValues(this.patch, other.patch) || comparePrereleaseIdentifiers(this.prerelease, other.prerelease);
         }
-        increment(field) {
-          switch (field) {
+        increment(field2) {
+          switch (field2) {
             case "major":
               return new _Version2(this.major + 1, 0, 0);
             case "minor":
@@ -298734,7 +298734,7 @@ ${lanes.join("\n")}
             case "patch":
               return new _Version2(this.major, this.minor, this.patch + 1);
             default:
-              return Debug.assertNever(field);
+              return Debug.assertNever(field2);
           }
         }
         with(fields) {
@@ -347877,8 +347877,8 @@ ${lanes.join("\n")}
       var runtimeDependencyFields = ["dependencies", "peerDependencies", "optionalDependencies"];
       function getAllRuntimeDependencies(packageJson) {
         let result;
-        for (const field of runtimeDependencyFields) {
-          const deps = packageJson[field];
+        for (const field2 of runtimeDependencyFields) {
+          const deps = packageJson[field2];
           if (deps && typeof deps === "object") {
             result = concatenate(result, getOwnKeys(deps));
           }
@@ -446102,13 +446102,13 @@ ${lanes.join("\n")}
         }
         return !isStringANonContextualKeyword(res) ? res || "_" : `_${res}`;
       }
-      function stringContainsAt(haystack, needle, startIndex) {
+      function stringContainsAt(haystack2, needle, startIndex) {
         const needleLength = needle.length;
-        if (needleLength + startIndex > haystack.length) {
+        if (needleLength + startIndex > haystack2.length) {
           return false;
         }
         for (let i2 = 0; i2 < needleLength; i2++) {
-          if (needle.charCodeAt(i2) !== haystack.charCodeAt(i2 + startIndex)) return false;
+          if (needle.charCodeAt(i2) !== haystack2.charCodeAt(i2 + startIndex)) return false;
         }
         return true;
       }
@@ -555108,7 +555108,7 @@ function renderCriticPrompt(inputs) {
   lines.push(`You are a CRITIC sub-agent. The IMPLEMENTER agent claims to have`);
   lines.push(`completed the work below and called task_complete. Your job is to`);
   lines.push(`audit the implementation and decide whether to APPROVE, REQUEST`);
-  lines.push(`CHANGES, or REJECT the claim.`);
+  lines.push(`CHANGES, or BLOCK the claim.`);
   lines.push(``);
   lines.push(`## Cycle: ${cycle + 1} of ${maxCycles}`);
   lines.push(``);
@@ -555118,6 +555118,11 @@ function renderCriticPrompt(inputs) {
   lines.push(`## Working directory`);
   lines.push(inputs.workingDir);
   lines.push(``);
+  if (inputs.finalSummary && inputs.finalSummary.trim().length > 0) {
+    lines.push(`## Proposed final summary / claims`);
+    lines.push(inputs.finalSummary.slice(0, 2e3));
+    lines.push(``);
+  }
   if (inputs.systemPromptDigest && inputs.systemPromptDigest.trim().length > 0) {
     lines.push(`## Constraints from the implementer's system prompt`);
     lines.push(inputs.systemPromptDigest.slice(0, 1500));
@@ -555133,6 +555138,34 @@ function renderCriticPrompt(inputs) {
     }
   }
   lines.push(``);
+  lines.push(`## Observed tool evidence`);
+  if (!inputs.toolEvidence || inputs.toolEvidence.length === 0) {
+    lines.push(`(no tool evidence recorded)`);
+  } else {
+    for (const entry of inputs.toolEvidence.slice(-30)) {
+      const status = entry.success ? "ok" : "failed";
+      const turn = typeof entry.turn === "number" ? ` turn=${entry.turn}` : "";
+      const mutated = entry.mutated ? " mutated=true" : "";
+      const args = entry.argsKey ? ` args=${entry.argsKey.slice(0, 180)}` : "";
+      const preview = entry.outputPreview ? ` -> ${entry.outputPreview.slice(0, 240)}` : "";
+      lines.push(`- [${status}] ${entry.name}${turn}${mutated}${args}${preview}`);
+    }
+  }
+  lines.push(``);
+  if (inputs.completionContractIssues && inputs.completionContractIssues.length > 0) {
+    lines.push(`## Completion-contract gaps`);
+    for (const gap of inputs.completionContractIssues.slice(0, 12)) {
+      lines.push(`- ${gap.slice(0, 300)}`);
+    }
+    lines.push(``);
+  }
+  if (inputs.openLoops && inputs.openLoops.length > 0) {
+    lines.push(`## Open loops / unresolved work`);
+    for (const loop of inputs.openLoops.slice(0, 12)) {
+      lines.push(`- ${loop.slice(0, 300)}`);
+    }
+    lines.push(``);
+  }
   lines.push(`## Files modified (${inputs.diff.length} total)`);
   if (inputs.diff.length === 0) {
     lines.push(`(no file changes detected — this run produced no on-disk artifacts)`);
@@ -555193,6 +555226,10 @@ function renderCriticPrompt(inputs) {
   lines.push(`    that say "(none specified)" / "(no items)" / "(empty)" alongside framing`);
   lines.push(`    text that asserts the section IS load-bearing. These contradictions`);
   lines.push(`    indicate the generator wasn't tested with the empty / minimal-input case.`);
+  lines.push(`13. **Claim/evidence mismatch**: Every high-risk claim in the proposed final`);
+  lines.push(`    summary must be backed by observed tool evidence above. Server/tunnel/API/`);
+  lines.push(`    model/frontend/delivery claims require direct probes or receipts, not`);
+  lines.push(`    inference from a command merely starting without error.`);
   lines.push(``);
   lines.push(`Do NOT flag:`);
   lines.push(`- Stylistic choices (formatting, naming) unless they hide a real bug.`);
@@ -555206,7 +555243,7 @@ function renderCriticPrompt(inputs) {
   lines.push(``);
   lines.push("```json");
   lines.push(`{`);
-  lines.push(`  "verdict": "approve" | "request_changes" | "reject",`);
+  lines.push(`  "verdict": "approve" | "request_changes" | "blocked",`);
   lines.push(`  "rationale": "<1-3 sentence summary>",`);
   lines.push(`  "pass": ["<file paths cleared with no issues>"],`);
   lines.push(`  "issues": [`);
@@ -555226,8 +555263,9 @@ function renderCriticPrompt(inputs) {
   lines.push(`- **approve**: no critical/high issues; only nits if any.`);
   lines.push(`- **request_changes**: at least one critical/high issue OR ≥ 3 medium issues.`);
   lines.push(`  The implementer will be given your issues list and asked to fix.`);
-  lines.push(`- **reject**: implementation is fundamentally wrong (wrong directory, no real`);
-  lines.push(`  output, all gaps unresolved). Use sparingly — escalates to the user.`);
+  lines.push(`- **blocked**: completion cannot be verified or the implementation is`);
+  lines.push(`  fundamentally wrong (wrong directory, no real output, all gaps unresolved,`);
+  lines.push(`  required external dependency unavailable). Ends as incomplete verification.`);
   lines.push(``);
   lines.push(`Be honest. Approving broken work wastes the user's time more than asking for`);
   lines.push(`changes. Be specific. Vague feedback is useless to the implementer.`);
@@ -555278,8 +555316,8 @@ function parseCriticVerdict(rawResponse) {
   let verdict;
   if (rawVerdict === "approve" || rawVerdict === "approved")
     verdict = "approve";
-  else if (rawVerdict === "reject" || rawVerdict === "rejected")
-    verdict = "reject";
+  else if (rawVerdict === "blocked" || rawVerdict === "block" || rawVerdict === "reject" || rawVerdict === "rejected")
+    verdict = "blocked";
   else if (rawVerdict === "request_changes" || rawVerdict === "changes" || rawVerdict === "request-changes")
     verdict = "request_changes";
   else {
@@ -555334,8 +555372,12 @@ function renderVerdictForFeedback(verdict) {
       lines.push(`  - ${t2}`);
     lines.push(``);
   }
-  lines.push(`Address these issues, then re-call task_complete. Do NOT call task_complete`);
-  lines.push(`again until you've made concrete edits to fix the items above.`);
+  if (verdict.verdict === "blocked") {
+    lines.push(`Completion is blocked. Report the blocker and missing evidence as incomplete_verification; do not claim success.`);
+  } else {
+    lines.push(`Address these issues, then re-call task_complete. Do NOT call task_complete`);
+    lines.push(`again until you've made concrete edits to fix the items above.`);
+  }
   return lines.join("\n");
 }
 var init_backward_pass_critic = __esm({
@@ -555442,6 +555484,10 @@ async function runBackwardPass(opts) {
     diff,
     planStatus: opts.planStatus,
     recentFailures: opts.recentFailures,
+    finalSummary: opts.finalSummary,
+    toolEvidence: opts.toolEvidence,
+    completionContractIssues: opts.completionContractIssues,
+    openLoops: opts.openLoops,
     systemPromptDigest: opts.systemPromptDigest,
     cycle: opts.cycle,
     maxCycles: opts.maxCycles
@@ -558290,6 +558336,291 @@ var init_specDecomposer = __esm({
   }
 });
 
+// packages/orchestrator/dist/completionContract.js
+function normalizeText(value2, max = 240) {
+  const text = String(value2 ?? "").trim().replace(/\s+/g, " ");
+  return text ? text.slice(0, max) : "";
+}
+function normalizeCompletionKey(value2, fallback = "item") {
+  const key = String(value2 ?? fallback).trim().toLowerCase().replace(/[^a-z0-9_.:-]+/g, "_").replace(/_{2,}/g, "_").replace(/^[_:.-]+|[_:.-]+$/g, "").slice(0, 96);
+  return key || fallback;
+}
+function field(key, label, description, acceptanceCriteria, sourceMode = "derived", elevation = "required") {
+  return {
+    key: normalizeCompletionKey(key),
+    label,
+    fieldType: "text",
+    elevation,
+    sourceMode,
+    description,
+    acceptanceCriteria
+  };
+}
+function dedupFields(fields) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const item of fields) {
+    if (seen.has(item.key))
+      continue;
+    seen.add(item.key);
+    out.push(item);
+  }
+  return out;
+}
+function requirementFromRule(rule) {
+  const id = normalizeCompletionKey(`req.${rule.surface}`);
+  return {
+    id,
+    surface: rule.surface,
+    label: rule.label,
+    evidenceKind: rule.evidenceKind,
+    acceptanceCriteria: rule.acceptanceCriteria,
+    variableKeys: rule.fields.map((item) => item.key)
+  };
+}
+function inferCompletionContract(taskText) {
+  const text = String(taskText || "");
+  const matched = RULES2.filter((rule) => rule.detect.test(text));
+  const effective = matched;
+  const requirements = effective.map(requirementFromRule);
+  const fields = dedupFields(effective.flatMap((rule) => rule.fields));
+  const verifyRequirementIds = requirements.map((requirement) => requirement.id);
+  const phases = [
+    {
+      key: "execute",
+      label: "Execute",
+      instructions: "Complete the requested work while preserving artifacts, outputs, and observations needed for validation.",
+      requirementIds: [],
+      fields: [],
+      gate: {
+        key: "execution_trace",
+        instructions: "Record concrete outputs and blockers as work proceeds."
+      }
+    },
+    {
+      key: "verify",
+      label: "Verify",
+      instructions: "Validate the result against the operator request and required evidence surfaces before delivery.",
+      requirementIds: verifyRequirementIds,
+      fields,
+      gate: {
+        key: "acceptance_gate",
+        instructions: "Every required evidence surface must have an observed tool result, or the final summary must report BLOCKED/unverified for that surface."
+      }
+    },
+    {
+      key: "deliver",
+      label: "Deliver",
+      instructions: "Return the outcome with evidence, unresolved blockers, and next actions.",
+      requirementIds: verifyRequirementIds,
+      fields: [],
+      gate: {
+        key: "result_readback",
+        instructions: "Do not claim completion beyond the evidence collected during verification."
+      }
+    }
+  ];
+  return {
+    goalSummary: normalizeText(text, 500),
+    surfaces: requirements.map((requirement) => requirement.surface),
+    fields,
+    requirements,
+    phases,
+    acceptanceCriteria: requirements.map((requirement) => requirement.acceptanceCriteria)
+  };
+}
+function inferCompletionContractFromTexts(texts, fallbackSummary = "") {
+  const combined = texts.map((text) => String(text ?? "").trim()).filter(Boolean).join("\n\n");
+  if (combined)
+    return inferCompletionContract(combined);
+  return inferCompletionContract(fallbackSummary);
+}
+function haystack(entry) {
+  return `${entry.name} ${entry.argsKey ?? ""} ${entry.outputPreview ?? ""}`.toLowerCase();
+}
+function hasSuccessful(log22, predicate) {
+  return log22.some((entry) => entry.success === true && predicate(entry, haystack(entry)));
+}
+function completionEvidenceSatisfied(requirement, log22) {
+  switch (requirement.evidenceKind) {
+    case "build_or_test":
+      return hasSuccessful(log22, (entry, text) => entry.mutated === true || /\b(test|typecheck|tsc|lint|build|compile|vitest|jest|pytest|cargo test|go test|npm run|pnpm .*build)\b/.test(text));
+    case "browser_observation":
+      return hasSuccessful(log22, (entry, text) => /^(browser_action|playwright_browser|carbonyl_browser)$/.test(entry.name) && /\b(observe|screenshot|dom|page_errors|console|network|visible|title|url)\b/.test(text));
+    case "desktop_observation":
+      return hasSuccessful(log22, (entry, text) => /^(desktop_describe|desktop_click|vision_action_loop|screenshot)$/.test(entry.name) && /\b(observe|screenshot|visible|verification|desktop|screen)\b/.test(text));
+    case "source_citation":
+      return hasSuccessful(log22, (entry, text) => /^(file_read|grep_search|find_files|list_directory|web_search|web_fetch|web_crawl|log_explore|diagnostic|shell)$/.test(entry.name) || /\b(source|evidence|root cause|log|file|line|http|arxiv|paper)\b/.test(text));
+    case "service_start": {
+      const hasStartup = hasSuccessful(log22, (_entry, text) => /\b(listen|listening|started|ready|localhost|127\.0\.0\.1|0\.0\.0\.0|port\s*\d{2,5}|http:\/\/)\b/.test(text));
+      const hasDirectProbe = hasSuccessful(log22, (_entry, text) => /\b(curl|fetch|web_fetch|health|status|http\/[12](?:\.[0-9])?|200|201|204|30[1278])\b/.test(text) && /\b(localhost|127\.0\.0\.1|0\.0\.0\.0|http:\/\/|https:\/\/|port\s*\d{2,5})\b/.test(text) && !/\b(502|500|connection refused|not found|failed|error)\b/.test(text));
+      return hasStartup && hasDirectProbe;
+    }
+    case "network_probe":
+      return hasSuccessful(log22, (_entry, text) => /\b(curl|fetch|web_fetch|browser|http\/[12](?:\.[0-9])?|status|200|30[1278])\b/.test(text) && /\b(http|https|trycloudflare|tunnel|ngrok|expose|public url)\b/.test(text) && !/\b(1033|502|connection refused|not found|failed|error)\b/.test(text));
+    case "api_probe":
+      return hasSuccessful(log22, (_entry, text) => /\b(curl|fetch|http|api|endpoint|route|json|sse|stream|status|response|200|201|204)\b/.test(text) && !/\b(json\.parse|unexpected character|502|500|failed|error)\b/.test(text));
+    case "model_probe": {
+      const hasAvailability = hasSuccessful(log22, (_entry, text) => /\b(ollama|\/api\/tags|\/v1\/models|model(?:s)?\s+(?:available|listed|present)|available\s+model|qwen|llama)\b/.test(text) && !/\b(no response|timeout|not available|missing|failed|error|502)\b/.test(text));
+      const hasInference = hasSuccessful(log22, (_entry, text) => /\b(\/api\/chat|\/api\/generate|inference|generate|chat|completion|smoke|response|done)\b/.test(text) && !/\b(no response|timeout|not available|missing|failed|error|502)\b/.test(text));
+      return hasAvailability && hasInference;
+    }
+    case "delivery_receipt":
+      return hasSuccessful(log22, (entry, text) => /^(send_message|telegram|telegram_send|notify|web_fetch|shell)$/.test(entry.name) && /\b(sent|delivered|ok|success|message id|recipient|telegram)\b/.test(text));
+    case "frontend_runtime_probe":
+      return hasSuccessful(log22, (entry, text) => /^(browser_action|playwright_browser|carbonyl_browser|shell)$/.test(entry.name) && /\b(browser|page|console|page_errors|network|screenshot|dom|render|localhost|http|ui)\b/.test(text) && !/\b(json\.parse|page error|console error|network failure|failed|error|502|1033)\b/.test(text));
+  }
+}
+function completionContractIssues(args) {
+  if (args.blockedSummary)
+    return [];
+  const issues = [];
+  for (const requirement of args.contract.requirements) {
+    if (completionEvidenceSatisfied(requirement, args.log))
+      continue;
+    issues.push(`${requirement.label} is not proven. Required evidence: ${requirement.acceptanceCriteria}`);
+  }
+  return issues;
+}
+function formatCompletionContract(contract) {
+  const lines = [];
+  lines.push(`[DYNAMIC COMPLETION CONTRACT]`);
+  lines.push(`Goal: ${contract.goalSummary || "(no goal text)"}`);
+  lines.push(`Required evidence surfaces: ${contract.surfaces.join(", ") || "none"}`);
+  lines.push(``);
+  lines.push(`Nested variables to track:`);
+  if (contract.fields.length === 0) {
+    lines.push(`- none inferred`);
+  } else {
+    for (const fieldItem of contract.fields.slice(0, 20)) {
+      lines.push(`- ${fieldItem.key} (${fieldItem.elevation}, ${fieldItem.sourceMode}): ${fieldItem.acceptanceCriteria}`);
+    }
+    if (contract.fields.length > 20)
+      lines.push(`- ... +${contract.fields.length - 20} more`);
+  }
+  lines.push(``);
+  lines.push(`Verification requirements:`);
+  for (const requirement of contract.requirements) {
+    lines.push(`- ${requirement.id}: ${requirement.acceptanceCriteria}`);
+  }
+  lines.push(``);
+  lines.push(`Flow: execute -> verify gate -> deliver readback. Missing facts become variables or blockers; they are not assumptions.`);
+  return lines.join("\n");
+}
+var RULES2;
+var init_completionContract = __esm({
+  "packages/orchestrator/dist/completionContract.js"() {
+    "use strict";
+    RULES2 = [
+      {
+        surface: "code",
+        label: "Code/file changes",
+        evidenceKind: "build_or_test",
+        detect: /\b(implement|fix|patch|refactor|rewrite|build|compile|typecheck|test suite|unit test|integration test|source file|codebase|package|typescript|javascript|python|rust|golang)\b/i,
+        acceptanceCriteria: "A relevant build, test, typecheck, lint, or runtime command succeeds after the final file mutation.",
+        fields: [
+          field("code.verify.command", "Verification command", "Command that proves the changed code still works.", "The command is run after the final edit and its real output is observed.")
+        ]
+      },
+      {
+        surface: "browser",
+        label: "Browser/UI state",
+        evidenceKind: "browser_observation",
+        detect: /\b(browser|web\s*page|website|page|playwright|selenium|chromedriver|chrome|headless|gui|login|captcha|form|account|submit|click|type|fill)\b/i,
+        acceptanceCriteria: "A fresh browser observation after the final action shows the expected state and no blocking page/console/network errors.",
+        fields: [
+          field("browser.final_state", "Expected browser state", "The visible browser state that proves the user flow worked.", "A browser observation after the final action shows this state.")
+        ]
+      },
+      {
+        surface: "desktop",
+        label: "Desktop state",
+        evidenceKind: "desktop_observation",
+        detect: /\b(desktop|screen|application|app\b|window|file manager|open a file|laptop|screenshot|vision_action_loop|desktop_describe|desktop_click)\b/i,
+        acceptanceCriteria: "A fresh desktop/vision observation after the final action proves the visible state.",
+        fields: [
+          field("desktop.final_state", "Expected desktop state", "The visible desktop state that proves completion.", "A desktop observation after the final action shows this state.")
+        ]
+      },
+      {
+        surface: "research",
+        label: "Research/root-cause claims",
+        evidenceKind: "source_citation",
+        detect: /\b(discover|root cause|triage|deep dive|review|audit|investigate|prove|validate|forensics|diagnostic|failure mode|literature|source)\b/i,
+        acceptanceCriteria: "Claims cite inspected files, command outputs, logs, documents, or web/source artifacts observed during the run.",
+        fields: [
+          field("research.evidence.items", "Evidence items", "Concrete inspected artifacts supporting the claim.", "Each important claim maps to at least one observed artifact or source.", "data_library", "preferred")
+        ]
+      },
+      {
+        surface: "service",
+        label: "Local service/server",
+        evidenceKind: "service_start",
+        detect: /\b(server|service|daemon|dev server|localhost|listen(?:ing)?|port\s+\d{2,5}|host(?:s|ed|ing)?|online|start(?:ed)?\s+(?:the\s+)?(?:app|server|service))\b/i,
+        acceptanceCriteria: "The service is started, the expected port/base URL is known, and a direct probe reaches it.",
+        fields: [
+          field("runtime.service.port", "Service port", "Port or base URL the local service should listen on.", "A probe reaches the same port/base URL."),
+          field("runtime.service.health_url", "Health URL", "URL or route used to verify the service.", "The route returns a non-error response or expected content.")
+        ]
+      },
+      {
+        surface: "tunnel",
+        label: "Public tunnel",
+        evidenceKind: "network_probe",
+        detect: /\b(cloudflared|cloudflare|tunnel|public url|trycloudflare|ngrok|tailscale funnel|expose)\b/i,
+        acceptanceCriteria: "The public tunnel URL is observed and a network probe confirms it reaches the intended local service.",
+        fields: [
+          field("network.tunnel.public_url", "Public tunnel URL", "Externally reachable URL exposed to the user.", "A probe to this URL returns expected content/status."),
+          field("network.tunnel.target", "Tunnel target", "Local URL/port the tunnel forwards to.", "The target matches the running service port.")
+        ]
+      },
+      {
+        surface: "api",
+        label: "API behavior",
+        evidenceKind: "api_probe",
+        detect: /\b(api|endpoint|route|http|json|sse|streaming|request|response|curl|fetch|webhook)\b/i,
+        acceptanceCriteria: "A realistic request reaches the endpoint and the response body/status/stream shape is inspected.",
+        fields: [
+          field("api.probe.request", "API probe request", "Representative request used to verify the endpoint.", "The request is actually sent and the response is inspected."),
+          field("api.probe.expected_shape", "Expected response shape", "Status/body/stream shape that proves the API works.", "Observed response matches this shape.")
+        ]
+      },
+      {
+        surface: "llm_service",
+        label: "LLM/model service",
+        evidenceKind: "model_probe",
+        detect: /\b(ollama|model|llama|qwen|inference|chat completions?|\/api\/tags|\/v1\/models|think(?:ing)?\s*:\s*false|disable thinking)\b/i,
+        acceptanceCriteria: "Available models are listed or queried, the selected model is present, and one minimal inference/request path is smoke-tested.",
+        fields: [
+          field("runtime.ollama.base_url", "Model service base URL", "Base URL for the model service.", "The base URL responds to a model-list or inference request."),
+          field("runtime.ollama.model", "Selected model", "Model name intended for inference.", "The model appears in a real availability check or successful inference response.")
+        ]
+      },
+      {
+        surface: "delivery",
+        label: "External delivery",
+        evidenceKind: "delivery_receipt",
+        detect: /\b(send|sent|message|dm|email|telegram|slack|discord|share(?:d)?|notify|link to|recipient)\b/i,
+        acceptanceCriteria: "The delivery tool/API returns a success receipt for the intended recipient or the summary reports delivery as unverified/blocked.",
+        fields: [
+          field("delivery.recipients", "Recipients", "People, channels, or addresses that should receive the result.", "Each claimed recipient has a send receipt or is reported unverified."),
+          field("delivery.payload", "Delivery payload", "Link/message/artifact sent to recipients.", "The payload matches the verified result.")
+        ]
+      },
+      {
+        surface: "frontend_runtime",
+        label: "Frontend runtime",
+        evidenceKind: "frontend_runtime_probe",
+        detect: /\b(frontend|ui|nextjs|next\.js|react|page\.tsx|browser|checkbox|clickable|chat interface|progress bar|client)\b/i,
+        acceptanceCriteria: "The UI is opened or smoke-tested after API changes; console, page, and critical network errors are inspected.",
+        fields: [
+          field("frontend.user_flow", "Frontend user flow", "Concrete user flow that proves the UI works.", "The flow is exercised in a browser/runtime probe.")
+        ]
+      }
+    ];
+  }
+});
+
 // packages/orchestrator/dist/modelProfile.js
 function resolveModelProfile(model) {
   const m2 = model.toLowerCase();
@@ -560514,6 +560845,7 @@ var init_agenticRunner = __esm({
     init_app_state();
     init_streaming_executor();
     init_specDecomposer();
+    init_completionContract();
     init_modelProfile();
     init_failureHandoff();
     init_context_fabric();
@@ -560816,7 +561148,7 @@ var init_agenticRunner = __esm({
       _fileWritesSinceLastWorldState = 0;
       // REG-47: backward-pass critic. After task_complete is requested, a
       // dedicated CRITIC sub-agent reviews the diff + plan reconciliation +
-      // recent failures and votes approve / request_changes / reject. On
+      // recent failures and votes approve / request_changes / blocked. On
       // request_changes the issues are injected as feedback and the loop
       // continues. Cycle-bounded so a stubborn/wrong critic can't block
       // forever. Skipped for trivial runs (no file mutations).
@@ -560826,15 +561158,22 @@ var init_agenticRunner = __esm({
       _fileWritesThisRun = 0;
       _backwardPassCyclesUsed = 0;
       _lastBackwardPassVerdict = null;
+      // Run-local completion contract inferred from the user's ask/context before
+      // the first model turn. The model can add evidence, but cannot weaken this
+      // supervisor-owned contract via todo fields or final-summary wording.
+      _completionContract = null;
+      _completionContractSeedText = "";
       // REG-54: completion-gate anti-collapse circuit breaker. The no-progress and
       // completion-provenance gates can hold task_complete indefinitely. When a
       // collapsed/weak model resubmits the same (or a similar) completion summary,
       // the gate rejects it every turn and the model re-emits the identical
       // task_complete forever — a mode-collapse loop. Unlike the backward-pass
       // critic (REG-47), these gates had no cycle bound. We track consecutive holds
-      // of the same summary and fail open after a small threshold so the run
-      // terminates instead of spinning. Reset whenever a completion is allowed.
+      // of the same summary and terminate as incomplete_verification after a
+      // small threshold so the run stops without falsely marking completion.
+      // Reset whenever a completion is allowed.
       _completionHoldState = { count: 0, lastKey: "" };
+      _completionIncompleteVerification = null;
       // ── WO-AM-01/04/10: Associative memory stores ──
       // Episode store: every tool call → persistent episode with importance + decay
       // Temporal KG: entities + relations with temporal validity (valid_from/valid_until)
@@ -561084,6 +561423,31 @@ var init_agenticRunner = __esm({
         const configured = (this.options.stateDir || "").trim();
         return configured ? _pathResolve(configured) : _pathJoin(process.cwd(), ".omnius");
       }
+      _persistCompletionContract(contract) {
+        try {
+          const dir = _pathJoin(this.omniusStateDir(), "completion-contracts");
+          _fsMkdirSync(dir, { recursive: true });
+          _fsWriteFileSync(_pathJoin(dir, `${this._sessionId}.json`), JSON.stringify({
+            sessionId: this._sessionId,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            contract
+          }, null, 2), "utf8");
+        } catch {
+        }
+      }
+      _initializeCompletionContract(task, context2) {
+        this._completionContractSeedText = [task, context2 ?? ""].map((text) => String(text || "").trim()).filter(Boolean).join("\n\n");
+        this._completionContract = inferCompletionContractFromTexts([this._completionContractSeedText], task);
+        this._persistCompletionContract(this._completionContract);
+        return this._completionContract;
+      }
+      _completionContractForClaims(...claimTexts) {
+        const base3 = this._completionContract;
+        const extras = claimTexts.map((text) => String(text ?? "").trim()).filter(Boolean);
+        if (extras.length === 0 && base3)
+          return base3;
+        return inferCompletionContractFromTexts([this._completionContractSeedText, ...extras], base3?.goalSummary || this._taskState.originalGoal || this._taskState.goal || "");
+      }
       /** Get current task state (for external inspection) */
       get taskState() {
         return this._taskState;
@@ -561929,8 +562293,10 @@ Do NOT call task_complete until all items are marked completed via todo_write.`;
       buildMissionCompletionContract(task, context2) {
         if (process.env["OMNIUS_DISABLE_MISSION_COMPLETION_CONTRACT"] === "1")
           return "";
-        const profile = this._inferCompletionProfile(`${task}
-${context2 ?? ""}`);
+        const profileText = `${task}
+${context2 ?? ""}`;
+        const profile = this._inferCompletionProfile(profileText);
+        const completionContract = this._completionContract || this._completionContractForClaims(profileText);
         const requirements = [];
         if (profile.browser)
           requirements.push("browser/UI state must be proven by a post-action screenshot/DOM/observe_bundle pass");
@@ -561940,6 +562306,18 @@ ${context2 ?? ""}`);
           requirements.push("code/file changes must be proven by a relevant build/test/typecheck/runtime command after the last edit");
         if (profile.research)
           requirements.push("research/root-cause claims must cite concrete inspected files, commands, logs, or source artifacts");
+        if (profile.service)
+          requirements.push("local services must be proven by startup evidence plus a direct probe to the claimed port or base URL");
+        if (profile.tunnel)
+          requirements.push("public tunnel claims must be proven by the observed public URL and a network probe showing it reaches the intended local service");
+        if (profile.api)
+          requirements.push("API/streaming claims must be proven by a realistic request whose status and response shape were inspected");
+        if (profile.llmService)
+          requirements.push("LLM/model-service claims must be proven by model availability and a minimal inference or model-list probe");
+        if (profile.delivery)
+          requirements.push("message/share/delivery claims must be proven by a send receipt for each claimed recipient or reported as unverified");
+        if (profile.frontendRuntime)
+          requirements.push("frontend runtime claims must be proven by a browser/runtime smoke check of the user-facing flow");
         if (requirements.length === 0)
           requirements.push("final claims must name the concrete evidence used or state that the task required no external action");
         return [
@@ -561954,17 +562332,39 @@ ${context2 ?? ""}`);
           `A command succeeding proves only that it ran — NOT that the intended effect was achieved. When an action is meant to start, produce, change, or send something, verify that end-state directly with a separate observation before claiming it works; do not infer success from the absence of an error.`,
           `Treat a negative, empty, or error result as evidence of absence or failure and report it as such. Do NOT reinterpret it as success or explain it away with an untested theory; if you have a candidate explanation, prove it with another observation first. Never assert a causal or ownership relationship between processes, files, components, sessions, or memories unless the observed output explicitly shows it — invented provenance is a completion-blocking failure.`,
           `For browser/form/account/send flows: after the last click/type/navigate/submit action, capture a fresh browser observation and verify the visible final state before completion.`,
-          `If completion is impossible, use a summary beginning BLOCKED: and name the exact blocker plus the evidence already collected.`
+          `If completion is impossible, use a summary beginning BLOCKED: and name the exact blocker plus the evidence already collected.`,
+          ``,
+          formatCompletionContract(completionContract)
         ].join("\n");
       }
       _inferCompletionProfile(text) {
         const t2 = text.toLowerCase();
-        const browser3 = /\b(browser|web\s*page|website|page|playwright|selenium|chromedriver|chrome|headless|gui|proton|login|captcha|form|account|compose|mail|submit|click|type|fill)\b/.test(t2);
-        const desktop = /\b(desktop|screen|application|app\b|window|file manager|open a file|laptop|screenshot|vision_action_loop|desktop_describe|desktop_click)\b/.test(t2);
-        const code8 = /\b(implement|fix|patch|refactor|rewrite|build|compile|typecheck|test suite|unit test|integration test|source file|codebase|package|typescript|javascript|python|rust|golang)\b/.test(t2);
-        const research = /\b(discover|root cause|triage|deep dive|review|audit|investigate|prove|validate|forensics|diagnostic|failure mode)\b/.test(t2);
+        const contract = this._completionContractForClaims(text);
+        const hasSurface = (surface) => contract.surfaces.includes(surface);
+        const browser3 = hasSurface("browser") || /\b(browser|web\s*page|website|page|playwright|selenium|chromedriver|chrome|headless|gui|proton|login|captcha|form|account|compose|mail|submit|click|type|fill)\b/.test(t2);
+        const desktop = hasSurface("desktop") || /\b(desktop|screen|application|app\b|window|file manager|open a file|laptop|screenshot|vision_action_loop|desktop_describe|desktop_click)\b/.test(t2);
+        const code8 = hasSurface("code") || /\b(implement|fix|patch|refactor|rewrite|build|compile|typecheck|test suite|unit test|integration test|source file|codebase|package|typescript|javascript|python|rust|golang)\b/.test(t2);
+        const research = hasSurface("research") || /\b(discover|root cause|triage|deep dive|review|audit|investigate|prove|validate|forensics|diagnostic|failure mode)\b/.test(t2);
+        const service = hasSurface("service");
+        const tunnel = hasSurface("tunnel");
+        const api = hasSurface("api");
+        const llmService = hasSurface("llm_service");
+        const delivery = hasSurface("delivery");
+        const frontendRuntime = hasSurface("frontend_runtime");
         const formLike = /\b(form|fill|submit|signup|sign up|login|log in|account|compose|send|sent|mail|captcha|checkout|payment|upload)\b/.test(t2);
-        return { browser: browser3, desktop, code: code8, research, formLike };
+        return {
+          browser: browser3,
+          desktop,
+          code: code8,
+          research,
+          service,
+          tunnel,
+          api,
+          llmService,
+          delivery,
+          frontendRuntime,
+          formLike
+        };
       }
       _completionSummaryHasProvenance(summary) {
         return /\b(provenance|evidence|verified|validated|confirmed|observed|screenshot|dom|console|network|log|test|typecheck|build|passed|opened|sent|created|submitted|blocked)\b/i.test(summary);
@@ -562365,6 +562765,7 @@ ${context2 ?? ""}`);
         const summary = input.summary || "";
         const blockedSummary = this._isBlockedCompletionSummary(summary);
         const profile = this._inferCompletionProfile(input.taskGoal);
+        const completionContract = this._completionContractForClaims(input.summary, input.answerText);
         const log22 = input.toolCallLog.filter((entry) => entry.name !== "task_complete");
         const claimText = `${summary}
 ${input.answerText ?? ""}`;
@@ -562392,7 +562793,7 @@ ${input.answerText ?? ""}`;
         const desktopUsed = log22.some((entry) => /^(desktop_describe|desktop_click|vision_action_loop|screenshot)$/.test(entry.name));
         const mutated = log22.some((entry) => entry.mutated === true);
         const issues = [];
-        const actionHeavy = profile.browser || profile.desktop || profile.code || profile.research || browserUsed || desktopUsed || mutated || this._fileWritesThisRun > 0;
+        const actionHeavy = profile.browser || profile.desktop || profile.code || profile.research || profile.service || profile.tunnel || profile.api || profile.llmService || profile.delivery || profile.frontendRuntime || completionContract.requirements.length > 0 || browserUsed || desktopUsed || mutated || this._fileWritesThisRun > 0;
         if (!actionHeavy)
           return { proceed: true };
         if (blockedSummary)
@@ -562469,6 +562870,11 @@ ${input.answerText ?? ""}`;
         if (!this._completionSummaryHasProvenance(summary)) {
           issues.push("The completion summary does not include an explicit Evidence/Provenance note.");
         }
+        issues.push(...completionContractIssues({
+          contract: completionContract,
+          log: log22,
+          blockedSummary
+        }));
         if (issues.length === 0)
           return { proceed: true };
         const recentEvidence = successfulNonCompletion.slice(-6).map((entry) => {
@@ -562527,11 +562933,11 @@ ${recentVisualEvidence}` : `Recent structured visual evidence: none recorded.`,
        * up auto-blocking and surfaces a status event so the caller can take
        * a different path (eg. surface to user). max cycles enforced here.
        */
-      async _runBackwardPassReview(turn) {
+      async _runBackwardPassReview(turn, toolCallLog, proposedSummary = "") {
         const optOverride = this.options.backwardPassReview;
-        const raw = (process.env["OMNIUS_BACKWARD_PASS"] || "off").toLowerCase();
-        const envEnabled = raw === "on" || raw === "1" || raw === "true";
-        const enabled2 = optOverride === true || optOverride !== false && envEnabled;
+        const raw = (process.env["OMNIUS_BACKWARD_PASS"] || "on").toLowerCase();
+        const envDisabled = raw === "off" || raw === "0" || raw === "false";
+        const enabled2 = optOverride === true || optOverride !== false && !envDisabled;
         if (!enabled2)
           return { proceed: true };
         const minWrites = parseInt(process.env["OMNIUS_BACKWARD_PASS_MIN_WRITES"] || "1", 10) || 1;
@@ -562539,12 +562945,30 @@ ${recentVisualEvidence}` : `Recent structured visual evidence: none recorded.`,
           return { proceed: true };
         const maxCycles = parseInt(process.env["OMNIUS_BACKWARD_PASS_MAX_CYCLES"] || "2", 10) || 2;
         if (this._backwardPassCyclesUsed >= maxCycles) {
+          const reason = `backward-pass review exhausted ${this._backwardPassCyclesUsed}/${maxCycles} cycle(s) without approval`;
+          this._completionIncompleteVerification = {
+            reason,
+            summary: [
+              "INCOMPLETE_VERIFICATION: backward-pass review did not approve completion before the review cycle limit.",
+              "",
+              `Attempted summary: ${proposedSummary || "(no summary)"}`,
+              "",
+              "Not verified / blocked:",
+              reason,
+              "",
+              "Evidence:",
+              `Last backward-pass verdict: ${this._lastBackwardPassVerdict || "unknown"}`
+            ].join("\n")
+          };
           this.emit({
             type: "status",
-            content: `REG-47 backward-pass skipped — already used ${this._backwardPassCyclesUsed}/${maxCycles} cycles. Allowing task_complete.`,
+            content: `REG-47 backward-pass exhausted ${this._backwardPassCyclesUsed}/${maxCycles} cycles; ending as incomplete_verification instead of completing.`,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
-          return { proceed: true };
+          return {
+            proceed: false,
+            feedback: "Backward-pass review cycle limit was reached before approval. End as incomplete_verification and report the missing verification evidence instead of claiming completion."
+          };
         }
         const _backend = this.backend;
         const _criticTimeoutMs = parseInt(process.env["OMNIUS_BACKWARD_PASS_TIMEOUT_MS"] || "120000", 10) || 12e4;
@@ -562604,6 +563028,24 @@ ${recentVisualEvidence}` : `Recent structured visual evidence: none recorded.`,
           attempts: entry.attempts,
           preview: (entry.wentWrong || "").slice(0, 200)
         })).sort((a2, b) => b.attempts - a2.attempts).slice(0, 5);
+        const criticToolEvidence = toolCallLog.filter((entry) => entry.name !== "task_complete").slice(-40).map((entry) => ({
+          name: entry.name,
+          argsKey: entry.argsKey.slice(0, 300),
+          success: entry.success === true,
+          outputPreview: (entry.outputPreview ?? "").slice(0, 500),
+          turn: entry.turn,
+          mutated: entry.mutated === true
+        }));
+        const completionContract = this._completionContractForClaims(proposedSummary);
+        const criticContractIssues = completionContractIssues({
+          contract: completionContract,
+          log: toolCallLog.filter((entry) => entry.name !== "task_complete"),
+          blockedSummary: /^\s*BLOCKED\b/i.test(proposedSummary || "")
+        });
+        const openLoops = [
+          ...todos.filter((todo) => todo.status !== "completed" && todo.status !== "blocked").slice(0, 12).map((todo) => `todo still ${todo.status}: ${todo.content}`),
+          ...recentFailures.filter((failure) => failure.attempts >= 3).map((failure) => `unresolved repeated failure: ${failure.stem} (${failure.attempts} attempts)`)
+        ];
         let result;
         try {
           result = await runBackwardPass({
@@ -562616,6 +563058,10 @@ ${recentVisualEvidence}` : `Recent structured visual evidence: none recorded.`,
               rationale: t2.rationale
             })),
             recentFailures,
+            finalSummary: proposedSummary,
+            toolEvidence: criticToolEvidence,
+            completionContractIssues: criticContractIssues,
+            openLoops,
             callable,
             maxFiles: parseInt(process.env["OMNIUS_BACKWARD_PASS_MAX_FILES"] || "60", 10) || 60,
             maxFilePreviewBytes: parseInt(process.env["OMNIUS_BACKWARD_PASS_MAX_FILE_PREVIEW"] || "8000", 10) || 8e3,
@@ -562623,12 +563069,30 @@ ${recentVisualEvidence}` : `Recent structured visual evidence: none recorded.`,
             maxCycles
           });
         } catch (e2) {
+          const reason = `backward-pass runner failed: ${e2 instanceof Error ? e2.message : String(e2)}`;
+          this._completionIncompleteVerification = {
+            reason,
+            summary: [
+              "INCOMPLETE_VERIFICATION: backward-pass review could not verify completion.",
+              "",
+              `Attempted summary: ${proposedSummary || "(no summary)"}`,
+              "",
+              "Not verified / blocked:",
+              reason,
+              "",
+              "Evidence:",
+              criticContractIssues.length > 0 ? criticContractIssues.map((issue) => `- ${issue}`).join("\n") : "No completion-contract gaps were available before the critic failure."
+            ].join("\n")
+          };
           this.emit({
             type: "status",
-            content: `REG-47 backward-pass runner threw: ${e2 instanceof Error ? e2.message : String(e2)}. Allowing task_complete (fail-soft).`,
+            content: `REG-47 backward-pass runner threw: ${e2 instanceof Error ? e2.message : String(e2)}. Ending as incomplete_verification instead of completing.`,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
-          return { proceed: true };
+          return {
+            proceed: false,
+            feedback: "Backward-pass review failed before completion could be verified. Report incomplete_verification rather than claiming success."
+          };
         }
         this._backwardPassCyclesUsed++;
         this._lastBackwardPassVerdict = result.verdict.verdict;
@@ -562641,10 +563105,25 @@ ${recentVisualEvidence}` : `Recent structured visual evidence: none recorded.`,
         if (result.verdict.verdict === "approve")
           return { proceed: true };
         const feedback = result.feedbackMessage;
-        if (result.verdict.verdict === "reject") {
+        if (result.verdict.verdict === "blocked") {
+          const reason = `backward-pass critic blocked completion: ${result.verdict.rationale.slice(0, 240)}`;
+          this._completionIncompleteVerification = {
+            reason,
+            summary: [
+              "INCOMPLETE_VERIFICATION: backward-pass critic blocked completion.",
+              "",
+              `Attempted summary: ${proposedSummary || "(no summary)"}`,
+              "",
+              "Not verified / blocked:",
+              reason,
+              "",
+              "Evidence:",
+              feedback
+            ].join("\n")
+          };
           this.emit({
             type: "status",
-            content: `REG-47 critic REJECTED implementation. Rationale: ${result.verdict.rationale.slice(0, 200)}`,
+            content: `REG-47 critic BLOCKED completion. Rationale: ${result.verdict.rationale.slice(0, 200)}`,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
         }
@@ -565165,6 +565644,9 @@ Respond with your assessment, then take action.`;
         this._fileWritesThisRun = 0;
         this._backwardPassCyclesUsed = 0;
         this._lastBackwardPassVerdict = null;
+        this._completionContract = null;
+        this._completionContractSeedText = "";
+        this._completionIncompleteVerification = null;
         this._lastWorldStateTurn = -1;
         this._fileWritesSinceLastWorldState = 0;
         this._resetVisualEvidenceState();
@@ -565303,6 +565785,7 @@ Respond with your assessment, then take action.`;
           verbose: false
         });
         this._hookManager.runSessionHook("session_start", this._sessionId);
+        this._initializeCompletionContract(task, context2);
         this._sessionStartMs = Date.now();
         if (process.env["OMNIUS_DISABLE_PREFLIGHT"] !== "1") {
           try {
@@ -565726,6 +566209,8 @@ TASK: ${scrubbedTask}` : scrubbedTask;
           });
           if (!gate.shouldInject || !gate.content)
             return false;
+          lastCompletionGateReason = "discovery happened but no deliverable or explicit blocker is recorded";
+          lastCompletionGateFeedback = gate.content;
           messages2.push({ role: "system", content: gate.content });
           this.emit({
             type: "status",
@@ -565735,6 +566220,8 @@ TASK: ${scrubbedTask}` : scrubbedTask;
           });
           return true;
         };
+        let lastCompletionGateReason = "";
+        let lastCompletionGateFeedback = "";
         const holdProvenanceTaskComplete = (args, turn) => {
           const proposedSummary = extractTaskCompleteSummary(args);
           const lastAssistantText = (() => {
@@ -565754,6 +566241,8 @@ TASK: ${scrubbedTask}` : scrubbedTask;
           });
           if (gate.proceed)
             return false;
+          lastCompletionGateReason = gate.reason;
+          lastCompletionGateFeedback = gate.feedback;
           messages2.push({
             role: "system",
             content: gate.feedback
@@ -565796,13 +566285,31 @@ TASK: ${scrubbedTask}` : scrubbedTask;
             this._completionHoldState.count = 1;
           }
           if (this._completionHoldState.count >= completionHoldEscapeMax) {
+            const proposedSummary = extractTaskCompleteSummary(args) || "(no summary)";
+            const reason = lastCompletionGateReason || "required completion evidence is still missing";
+            const evidenceFeedback = lastCompletionGateFeedback ? lastCompletionGateFeedback.trim().slice(0, 4e3) : "No additional gate details were recorded.";
+            const incompleteSummary = [
+              "INCOMPLETE_VERIFICATION: completion was requested repeatedly, but required evidence is still missing.",
+              "",
+              `Attempted summary: ${proposedSummary}`,
+              "",
+              "Not verified / blocked:",
+              reason,
+              "",
+              "Evidence:",
+              evidenceFeedback
+            ].join("\n");
+            this._completionIncompleteVerification = {
+              reason,
+              summary: incompleteSummary
+            };
             messages2.push({
               role: "system",
-              content: `[COMPLETION GATE ESCAPE] task_complete was held ${this._completionHoldState.count} times for the same summary without new progress. The gate feedback above is not being acted on, so completion is now ALLOWED to avoid a stall/mode-collapse loop. If the summary lacks evidence, that limitation stands in the final result.`
+              content: `[INCOMPLETE VERIFICATION TERMINAL STATE] task_complete was held ${this._completionHoldState.count} times for the same summary without new evidence. The run is ending as incomplete_verification, not completed. Report the missing evidence plainly.`
             });
             this.emit({
               type: "status",
-              content: `completion gates yielding after ${this._completionHoldState.count} repeated holds to prevent a mode-collapse loop`,
+              content: `completion gates ended run as incomplete_verification after ${this._completionHoldState.count} repeated holds: ${reason}`,
               turn,
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
@@ -565810,9 +566317,9 @@ TASK: ${scrubbedTask}` : scrubbedTask;
               type: "adversary_reaction",
               adversary: {
                 class: "guidance",
-                shortText: "Completion gate escape (anti-loop)",
+                shortText: "Completion gate terminal incomplete",
                 confidence: 0.9,
-                details: `Same task_complete summary held ${this._completionHoldState.count}× — failing open to terminate the run.`
+                details: `Same task_complete summary held ${this._completionHoldState.count}x; ending incomplete_verification instead of completing.`
               },
               turn,
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -565828,11 +566335,11 @@ TASK: ${scrubbedTask}` : scrubbedTask;
             role: "system",
             content: `${feedback}
 
-[ADVISORY ONLY] Backward-pass critique is non-blocking; do not treat this as a tool failure or completion refusal.`
+[COMPLETION BLOCKED] Backward-pass critique requested changes. Continue the work, gather evidence, then call task_complete again only after addressing it.`
           });
           this.emit({
             type: "status",
-            content: "backward-pass critique emitted without blocking completion",
+            content: "backward-pass critique blocked completion",
             turn,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
@@ -568003,7 +568510,7 @@ Corrective action: try a different approach first: read relevant files, adjust a
                 } else if (tool.parameters && typeof tool.parameters === "object") {
                   const required = tool.parameters.required;
                   if (Array.isArray(required)) {
-                    const missing = required.filter((field) => tc.arguments[field] === void 0 || tc.arguments[field] === null);
+                    const missing = required.filter((field2) => tc.arguments[field2] === void 0 || tc.arguments[field2] === null);
                     if (missing.length > 0) {
                       validationError = `Missing required parameter(s): ${missing.join(", ")}`;
                     }
@@ -569385,11 +569892,17 @@ ${sr.result.output}`;
                       });
                     } else {
                       if (holdTaskCompleteGates(matchTc.arguments, turn)) {
+                        if (this._completionIncompleteVerification)
+                          break;
                         continue;
                       }
-                      const _bp1 = await this._runBackwardPassReview(turn);
-                      if (_bp1 && !_bp1.proceed && _bp1.feedback) {
-                        emitBackwardPassAdvisory(_bp1.feedback, turn);
+                      const _bp1 = await this._runBackwardPassReview(turn, toolCallLog, extractTaskCompleteSummary(matchTc.arguments));
+                      if (_bp1 && !_bp1.proceed) {
+                        if (_bp1.feedback)
+                          emitBackwardPassAdvisory(_bp1.feedback, turn);
+                        if (this._completionIncompleteVerification)
+                          break;
+                        continue;
                       }
                       completed = true;
                       summary = extractTaskCompleteSummary(matchTc.arguments);
@@ -569408,7 +569921,7 @@ ${sr.result.output}`;
                   }
                 }
               }
-              if (!completed) {
+              if (!completed && !this._completionIncompleteVerification) {
                 const unhandled = rawToolCalls.filter((tc) => !handledIds.has(tc.id));
                 for (const tc of unhandled) {
                   if (this.aborted)
@@ -569440,11 +569953,17 @@ ${sr.result.output}`;
                         });
                       } else {
                         if (holdTaskCompleteGates(r2.tc.arguments, turn)) {
+                          if (this._completionIncompleteVerification)
+                            break;
                           continue;
                         }
-                        const _bp2 = await this._runBackwardPassReview(turn);
-                        if (_bp2 && !_bp2.proceed && _bp2.feedback) {
-                          emitBackwardPassAdvisory(_bp2.feedback, turn);
+                        const _bp2 = await this._runBackwardPassReview(turn, toolCallLog, extractTaskCompleteSummary(r2.tc.arguments));
+                        if (_bp2 && !_bp2.proceed) {
+                          if (_bp2.feedback)
+                            emitBackwardPassAdvisory(_bp2.feedback, turn);
+                          if (this._completionIncompleteVerification)
+                            break;
+                          continue;
                         }
                         completed = true;
                         summary = extractTaskCompleteSummary(r2.tc.arguments);
@@ -569532,11 +570051,17 @@ ${sr.result.output}`;
                         });
                       } else {
                         if (holdTaskCompleteGates(r2.tc.arguments, turn)) {
+                          if (this._completionIncompleteVerification)
+                            break;
                           continue;
                         }
-                        const _bp3 = await this._runBackwardPassReview(turn);
-                        if (_bp3 && !_bp3.proceed && _bp3.feedback) {
-                          emitBackwardPassAdvisory(_bp3.feedback, turn);
+                        const _bp3 = await this._runBackwardPassReview(turn, toolCallLog, extractTaskCompleteSummary(r2.tc.arguments));
+                        if (_bp3 && !_bp3.proceed) {
+                          if (_bp3.feedback)
+                            emitBackwardPassAdvisory(_bp3.feedback, turn);
+                          if (this._completionIncompleteVerification)
+                            break;
+                          continue;
                         }
                         completed = true;
                         summary = extractTaskCompleteSummary(r2.tc.arguments);
@@ -569555,11 +570080,11 @@ ${sr.result.output}`;
                     }
                   }
                 }
-                if (completed)
+                if (completed || this._completionIncompleteVerification)
                   break;
               }
             }
-            if (completed)
+            if (completed || this._completionIncompleteVerification)
               break;
             this.adversaryObserve(messages2, turn);
             const currentRepScore = this.detectRepetition(toolCallLog);
@@ -569753,6 +570278,8 @@ Call task_complete(summary="...") NOW with whatever you have.`
             if (/task.?complete|all tests pass/i.test(content)) {
               const completionArgs = { summary: content };
               if (holdTaskCompleteGates(completionArgs, turn)) {
+                if (this._completionIncompleteVerification)
+                  break;
                 continue;
               }
               completed = true;
@@ -570324,11 +570851,17 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                     });
                   } else {
                     if (holdTaskCompleteGates(tc.arguments, turn)) {
+                      if (this._completionIncompleteVerification)
+                        break;
                       continue;
                     }
-                    const _bp4 = await this._runBackwardPassReview(turn);
-                    if (_bp4 && !_bp4.proceed && _bp4.feedback) {
-                      emitBackwardPassAdvisory(_bp4.feedback, turn);
+                    const _bp4 = await this._runBackwardPassReview(turn, toolCallLog, extractTaskCompleteSummary(tc.arguments));
+                    if (_bp4 && !_bp4.proceed) {
+                      if (_bp4.feedback)
+                        emitBackwardPassAdvisory(_bp4.feedback, turn);
+                      if (this._completionIncompleteVerification)
+                        break;
+                      continue;
                     }
                     completed = true;
                     summary = extractTaskCompleteSummary(tc.arguments);
@@ -570346,7 +570879,7 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                   }
                 }
               }
-              if (completed)
+              if (completed || this._completionIncompleteVerification)
                 break;
             } else {
               const content = msg.content || "";
@@ -570377,6 +570910,8 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                 } else {
                   const completionArgs = { summary: content };
                   if (holdTaskCompleteGates(completionArgs, turn)) {
+                    if (this._completionIncompleteVerification)
+                      break;
                     continue;
                   }
                   completed = true;
@@ -570426,6 +570961,10 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
           }
         }
         const durationMs = Date.now() - start2;
+        if (this._completionIncompleteVerification && !summary) {
+          summary = this._completionIncompleteVerification.summary;
+        }
+        const runStatus = completed ? "completed" : this._completionIncompleteVerification ? "incomplete_verification" : "incomplete";
         this._emitMASTSummary("run-end");
         this.emit({
           type: "complete",
@@ -570477,7 +571016,7 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
           const consolidation = {
             sessionId: this._sessionId,
             task: cleanedTask.slice(0, 500),
-            outcome: completed ? "success" : this.aborted ? "aborted" : "timeout",
+            outcome: completed ? "success" : this.aborted ? "aborted" : runStatus === "incomplete_verification" ? "incomplete_verification" : "timeout",
             turns: messages2.filter((m2) => m2.role === "assistant").length,
             toolsUsed: [...new Set(toolCallLog.map((tc) => tc.name))],
             filesModified: extractPaths(toolCallLog, [
@@ -571053,7 +571592,7 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
             // training. Storing the scaffolded version would teach future models
             // to reproduce signpost text as part of their task understanding.
             task: cleanedTask.slice(0, 1e3),
-            outcome: completed ? "pass" : this.aborted ? "aborted" : "timeout",
+            outcome: completed ? "pass" : this.aborted ? "aborted" : runStatus === "incomplete_verification" ? "incomplete_verification" : "timeout",
             model: this.backend.model ?? "unknown",
             modelTier: this.options.modelTier ?? "large",
             turns: messages2.filter((m2) => m2.role === "assistant").length,
@@ -571127,6 +571666,7 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
         } catch {
         }
         return {
+          status: runStatus,
           completed,
           turns: messages2.filter((m2) => m2.role === "assistant").length,
           toolCalls: toolCallCount,
@@ -579393,11 +579933,11 @@ function isHandoffVague(handoff) {
     /resolved the problem/i
   ];
   const vagueFields = [handoff.salientSummary, handoff.whatWasImplemented, handoff.whatWasLeftUndone];
-  for (const field of vagueFields) {
-    if (!field)
+  for (const field2 of vagueFields) {
+    if (!field2)
       continue;
     for (const pattern of vaguePatterns) {
-      if (pattern.test(field) && field.length < 100) {
+      if (pattern.test(field2) && field2.length < 100) {
         return true;
       }
     }
@@ -580521,6 +581061,8 @@ __export(dist_exports3, {
   clearTurnState: () => clearTurnState,
   combineValidatorResults: () => combineValidatorResults,
   compilePersonalityPrompt: () => compilePersonalityPrompt,
+  completionContractIssues: () => completionContractIssues,
+  completionEvidenceSatisfied: () => completionEvidenceSatisfied,
   computeStabilityHash: () => computeStabilityHash,
   computeTodoReminder: () => computeTodoReminder,
   createAppState: () => createAppState,
@@ -580540,6 +581082,7 @@ __export(dist_exports3, {
   extractLessons: () => extractLessons,
   extractMidTaskSteeringInput: () => extractMidTaskSteeringInput,
   extractTaskCompleteSummary: () => extractTaskCompleteSummary,
+  formatCompletionContract: () => formatCompletionContract,
   formatHermesToolResponse: () => formatHermesToolResponse,
   generateAssertionId: () => generateAssertionId,
   generateFeatureId: () => generateFeatureId,
@@ -580566,6 +581109,8 @@ __export(dist_exports3, {
   getSidecarPath: () => getSidecarPath,
   getStartupOrder: () => getStartupOrder,
   getStateSummary: () => getStateSummary,
+  inferCompletionContract: () => inferCompletionContract,
+  inferCompletionContractFromTexts: () => inferCompletionContractFromTexts,
   initializeValidationState: () => initializeValidationState,
   interpretSteeringIngress: () => interpretSteeringIngress,
   isConcurrencySafe: () => isConcurrencySafe,
@@ -580576,6 +581121,7 @@ __export(dist_exports3, {
   loadMemoryWeightingConfig: () => loadMemoryWeightingConfig,
   loadStabilityIndex: () => loadStabilityIndex,
   materializeMemoryItems: () => materializeMemoryItems,
+  normalizeCompletionKey: () => normalizeCompletionKey,
   parseCritique: () => parseCritique,
   parseMetaCritique: () => parseMetaCritique,
   parsePlan: () => parsePlan,
@@ -580675,6 +581221,7 @@ var init_dist8 = __esm({
     init_skill_fork();
     init_missionSystem();
     init_specDecomposer();
+    init_completionContract();
     init_streaming_executor();
     init_app_state();
     init_textSanitize();
@@ -601179,10 +601726,10 @@ ${CONTENT_BG_SEQ}`);
         let removed = false;
         const start2 = Math.max(0, this._contentLines.length - maxRecentLines);
         for (let i2 = this._contentLines.length - 1; i2 >= start2; i2--) {
-          const haystack = normalize2(this._contentLines[i2] ?? "");
-          if (haystack.length < 12) continue;
-          const shortHaystack = haystack.slice(0, Math.min(40, haystack.length));
-          if (haystack.includes(shortNeedle) || needle.includes(shortHaystack)) {
+          const haystack2 = normalize2(this._contentLines[i2] ?? "");
+          if (haystack2.length < 12) continue;
+          const shortHaystack = haystack2.slice(0, Math.min(40, haystack2.length));
+          if (haystack2.includes(shortNeedle) || needle.includes(shortHaystack)) {
             this._contentLines.splice(i2, 1);
             removed = true;
           }
@@ -640872,7 +641419,7 @@ var init_component_benefit = __esm({
       }
       /** Record one batch — for each sampled component, did the decision text reference its needle? */
       recordOutcome(chatKey, samples, decisionText) {
-        const haystack = decisionText.toLowerCase();
+        const haystack2 = decisionText.toLowerCase();
         let map2 = this._byChat.get(chatKey);
         if (!map2) {
           map2 = /* @__PURE__ */ new Map();
@@ -640881,7 +641428,7 @@ var init_component_benefit = __esm({
         const now = Date.now();
         for (const sample of samples) {
           const needle = sample.needle.toLowerCase();
-          const hit = needle.length >= 3 && haystack.includes(needle);
+          const hit = needle.length >= 3 && haystack2.includes(needle);
           let st = map2.get(sample.key);
           if (!st) {
             st = { score: 0.5, samples: 0, hits: 0, lastSeenAt: now };
@@ -649514,11 +650061,11 @@ ${mediaContext}` : ""
         const baseRecord = base3;
         const rawProperties = baseRecord["properties"];
         const properties = rawProperties && typeof rawProperties === "object" && !Array.isArray(rawProperties) ? { ...rawProperties } : {};
-        for (const field of fields) {
-          const property = properties[field];
+        for (const field2 of fields) {
+          const property = properties[field2];
           if (property && typeof property === "object" && !Array.isArray(property)) {
             const currentDescription = typeof property["description"] === "string" ? String(property["description"]) : "";
-            properties[field] = {
+            properties[field2] = {
               ...property,
               description: [currentDescription, description].filter(Boolean).join(" ")
             };
@@ -651636,10 +652183,10 @@ ${retryText}`,
         })).filter((model) => Boolean(model.name)) : [];
       }
       telegramModelParameterBillions(model) {
-        const haystack = `${model.name} ${model.parameterSize ?? ""}`.toLowerCase();
-        const billion = haystack.match(/(\d+(?:\.\d+)?)\s*(?:b|bn)\b/);
+        const haystack2 = `${model.name} ${model.parameterSize ?? ""}`.toLowerCase();
+        const billion = haystack2.match(/(\d+(?:\.\d+)?)\s*(?:b|bn)\b/);
         if (billion) return Number(billion[1]);
-        const million = haystack.match(/(\d+(?:\.\d+)?)\s*m\b/);
+        const million = haystack2.match(/(\d+(?:\.\d+)?)\s*m\b/);
         if (million) return Number(million[1]) / 1e3;
         return null;
       }
@@ -653106,7 +653653,9 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
         return state.messageId ?? null;
       }
       telegramAdminRunCompleted(subAgent) {
-        return subAgent.runnerCompleted === true || subAgent.completionBoundarySeen;
+        if (subAgent.runnerStatus === "incomplete_verification") return false;
+        if (subAgent.runnerStatus === "completed") return true;
+        return subAgent.runnerCompleted === true;
       }
       telegramAdminLastRunSignals(subAgent) {
         const state = subAgent.adminLivePanelNonce ? this.telegramAdminLivePanels.get(subAgent.adminLivePanelNonce) : void 0;
@@ -653125,18 +653674,49 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
         ].filter(Boolean).join(", ");
         const summary = cleanTelegramVisibleReply(subAgent.runnerSummary || "");
         const signals = this.telegramAdminLastRunSignals(subAgent);
+        const verificationIncomplete = subAgent.runnerStatus === "incomplete_verification";
         const parts = [
-          `INCOMPLETE: admin run exited before task_complete${stats ? ` after ${stats}` : ""}.`,
-          "This is not a completed task. The run should be resumed or retried; no successful completion boundary was observed.",
-          signals ? `Last observed tool/status:
-${signals}` : "",
-          finalText ? `Last visible draft:
-${finalText}` : "",
-          summary ? `Runner summary:
-${summary}` : ""
+          `Done:
+No completed result.`,
+          `Verified:
+${verificationIncomplete ? `INCOMPLETE_VERIFICATION: admin run stopped with missing completion evidence${stats ? ` after ${stats}` : ""}.` : `INCOMPLETE: admin run exited before task_complete${stats ? ` after ${stats}` : ""}.`}`,
+          `Not verified / blocked:
+${verificationIncomplete ? "Required verification evidence was still missing after repeated completion attempts." : "No successful completion boundary was observed."}${summary ? `
+
+Runner summary:
+${summary}` : ""}${finalText ? `
+
+Last visible draft:
+${finalText}` : ""}`,
+          `Evidence:
+${signals || "No final validating tool/status signal was available."}`
         ].filter(Boolean);
         return parts.join("\n\n");
       }
+      telegramAdminCompletionRunText(subAgent, finalText) {
+        const summary = cleanTelegramVisibleReply(subAgent.runnerSummary || "");
+        const signals = this.telegramAdminLastRunSignals(subAgent);
+        const stats = [
+          typeof subAgent.runnerTurns === "number" ? `${subAgent.runnerTurns} turn(s)` : "",
+          typeof subAgent.runnerToolCalls === "number" ? `${subAgent.runnerToolCalls} tool call(s)` : ""
+        ].filter(Boolean).join(", ");
+        const done = finalText || summary || "Run completed.";
+        const verified = [
+          `Backend status: ${subAgent.runnerStatus || (subAgent.runnerCompleted ? "completed" : "unknown")}.`,
+          stats ? `Run shape: ${stats}.` : "",
+          summary && summary !== finalText ? `Runner summary: ${summary}` : ""
+        ].filter(Boolean).join("\n");
+        return [
+          `Done:
+${done}`,
+          `Verified:
+${verified || "Completion boundary observed."}`,
+          `Not verified / blocked:
+None reported by the runner.`,
+          `Evidence:
+${signals || summary || "Canonical runner status reported completed."}`
+        ].join("\n\n");
+      }
       pruneTelegramContextExplorers() {
         const now = Date.now();
         for (const [id, state] of this.telegramContextExplorerStates) {
@@ -653788,6 +654368,18 @@ Join: ${newUrl}`);
             return;
           }
           if (!finalText) {
+            if (isAdminDM && this.telegramAdminRunCompleted(subAgent)) {
+              const deliveredFinalText2 = this.telegramAdminCompletionRunText(subAgent, "");
+              this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `completed: ${deliveredFinalText2}`);
+              this.subAgentViewCallbacks?.onStatus(subAgent.viewId, "completed");
+              if (!msg.guestQueryId) {
+                await this.finalizeTelegramAdminLivePanel(subAgent, msg, deliveredFinalText2, "completed");
+              } else if (subAgent.liveMessageId) {
+                await this.deleteLiveMessage(msg.chatId, subAgent.liveMessageId).catch(() => {
+                });
+              }
+              return;
+            }
             if (msg.chatType !== "private") {
               this.maybeLogTelegramGroupSkip(msg, "discretion: skipped reply");
             } else {
@@ -653807,17 +654399,18 @@ Join: ${newUrl}`);
             await subAgent.liveMessagePromise.catch(() => {
             });
           }
-          const finalHtml = convertMarkdownToTelegramHTML(finalText);
-          const contextExplorerState = !isAdminDM && msg.chatType !== "private" && !msg.guestQueryId ? this.buildTelegramContextExplorerState(msg, subAgent, finalHtml, finalText) : null;
+          const deliveredFinalText = isAdminDM ? this.telegramAdminCompletionRunText(subAgent, finalText) : finalText;
+          const finalHtml = convertMarkdownToTelegramHTML(deliveredFinalText);
+          const contextExplorerState = !isAdminDM && msg.chatType !== "private" && !msg.guestQueryId ? this.buildTelegramContextExplorerState(msg, subAgent, finalHtml, deliveredFinalText) : null;
           const contextExplorerReplyMarkup = contextExplorerState ? this.telegramContextExplorerReplyMarkup(contextExplorerState.id) : void 0;
-          const sentMessageId = isAdminDM && !msg.guestQueryId ? await this.finalizeTelegramAdminLivePanel(subAgent, msg, finalText, "completed") : await this.sendOrEditFinalTelegramHTML(msg, finalHtml, subAgent.liveMessageId, contextExplorerReplyMarkup);
+          const sentMessageId = isAdminDM && !msg.guestQueryId ? await this.finalizeTelegramAdminLivePanel(subAgent, msg, deliveredFinalText, "completed") : await this.sendOrEditFinalTelegramHTML(msg, finalHtml, subAgent.liveMessageId, contextExplorerReplyMarkup);
           if (contextExplorerState && sentMessageId !== null) {
             this.pruneTelegramContextExplorers();
             contextExplorerState.messageId = sentMessageId;
             this.telegramContextExplorerStates.set(contextExplorerState.id, contextExplorerState);
           }
           if (sentMessageId !== null || msg.guestQueryId) {
-            this.recordTelegramAssistantMessage(msg, finalText, subAgentProfile, {
+            this.recordTelegramAssistantMessage(msg, deliveredFinalText, subAgentProfile, {
               messageId: sentMessageId,
               replyToMessageId: msg.chatType !== "private" ? msg.messageId : void 0
             });
@@ -653827,11 +654420,11 @@ Join: ${newUrl}`);
           await this.sendGeneratedArtifactsFromSubAgent(
             msg,
             subAgent,
-            finalText,
+            deliveredFinalText,
             Boolean(subAgent.liveMessageId && !msg.guestQueryId)
           );
-          this.tuiWrite(() => renderTelegramSubAgentComplete(msg.username, finalText));
-          this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `completed: ${finalText}`);
+          this.tuiWrite(() => renderTelegramSubAgentComplete(msg.username, deliveredFinalText));
+          this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `completed: ${deliveredFinalText}`);
           this.subAgentViewCallbacks?.onStatus(subAgent.viewId, "completed");
           if (shouldDeferNotes) {
             this.deliverTelegramPostReplyNotes(
@@ -653841,7 +654434,7 @@ Join: ${newUrl}`);
               decision2,
               this.telegramMessageIdentitySalienceSignals(msg),
               daydreamOpportunities,
-              finalText
+              deliveredFinalText
             );
           }
         } catch (err) {
@@ -653951,20 +654544,22 @@ Join: ${newUrl}`);
             return;
           }
           if (!finalText) {
+            const deliveredFinalText2 = this.telegramAdminCompletionRunText(subAgent, "");
             if (!msg.guestQueryId) {
-              await this.finalizeTelegramAdminLivePanel(subAgent, msg, "", "completed");
+              await this.finalizeTelegramAdminLivePanel(subAgent, msg, deliveredFinalText2, "completed");
             } else if (subAgent.liveMessageId) {
               await this.deleteLiveMessage(msg.chatId, subAgent.liveMessageId).catch(() => {
               });
             }
-            this.subAgentViewCallbacks?.onWrite(subAgent.viewId, "completed: no model reply");
+            this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `completed: ${deliveredFinalText2}`);
             this.subAgentViewCallbacks?.onStatus(subAgent.viewId, "completed");
             return;
           }
-          const finalHtml = convertMarkdownToTelegramHTML(finalText);
-          const sentMessageId = !msg.guestQueryId ? await this.finalizeTelegramAdminLivePanel(subAgent, msg, finalText, "completed") : await this.sendOrEditFinalTelegramHTML(msg, finalHtml, subAgent.liveMessageId);
+          const deliveredFinalText = this.telegramAdminCompletionRunText(subAgent, finalText);
+          const finalHtml = convertMarkdownToTelegramHTML(deliveredFinalText);
+          const sentMessageId = !msg.guestQueryId ? await this.finalizeTelegramAdminLivePanel(subAgent, msg, deliveredFinalText, "completed") : await this.sendOrEditFinalTelegramHTML(msg, finalHtml, subAgent.liveMessageId);
           if (sentMessageId !== null || msg.guestQueryId) {
-            this.recordTelegramAssistantMessage(msg, finalText, "chat", {
+            this.recordTelegramAssistantMessage(msg, deliveredFinalText, "chat", {
               messageId: sentMessageId,
               replyToMessageId: msg.chatType !== "private" ? msg.messageId : void 0
             });
@@ -653974,10 +654569,10 @@ Join: ${newUrl}`);
           await this.sendGeneratedArtifactsFromSubAgent(
             msg,
             subAgent,
-            finalText,
+            deliveredFinalText,
             Boolean(subAgent.liveMessageId && !msg.guestQueryId)
           );
-          this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `completed: ${finalText}`);
+          this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `completed: ${deliveredFinalText}`);
           this.subAgentViewCallbacks?.onStatus(subAgent.viewId, "completed");
         } catch (err) {
           if (subAgent.typingInterval) {
@@ -654613,10 +655208,14 @@ ${creativeWorkspace}` : ""}`;
         };
         const result = await runner.run(userPrompt, systemCtx);
         subAgent.runnerCompleted = result.completed;
+        subAgent.runnerStatus = result.status;
         subAgent.runnerTurns = result.turns;
         subAgent.runnerToolCalls = result.toolCalls;
         subAgent.runnerSummary = result.summary;
-        if (result.completed) subAgent.completionBoundarySeen = true;
+        if (result.status === "completed") subAgent.completionBoundarySeen = true;
+        if (result.status === "incomplete_verification") {
+          subAgent.completionBoundarySeen = false;
+        }
         return selectTelegramFinalResponse({
           visibleReplyText: subAgent.visibleReplyText,
           assistantText: subAgent.assistantText,
@@ -654839,9 +655438,9 @@ ${result.llmContent ?? result.output}` };
                   if (effectiveUserId !== void 0 && ids.includes(effectiveUserId)) return true;
                   const usernames = (Array.isArray(card.usernames) ? card.usernames : []).map((name10) => name10.replace(/^@/, "").toLowerCase());
                   if (effectiveUsername && usernames.includes(effectiveUsername)) return true;
-                  const haystack = [card.title, card.speakers.join(" "), card.notes.join(" ")].join(" ").toLowerCase();
-                  if (effectiveUserId !== void 0 && haystack.includes(`user:${effectiveUserId}`)) return true;
-                  if (effectiveUsername && haystack.includes(`@${effectiveUsername}`)) return true;
+                  const haystack2 = [card.title, card.speakers.join(" "), card.notes.join(" ")].join(" ").toLowerCase();
+                  if (effectiveUserId !== void 0 && haystack2.includes(`user:${effectiveUserId}`)) return true;
+                  if (effectiveUsername && haystack2.includes(`@${effectiveUsername}`)) return true;
                   return false;
                 });
                 const queryTokens = telegramMemoryTokens(query);
@@ -657615,13 +658214,13 @@ ${text}`.trim());
         }
       }
       async sendMediaReferenceStrict(chatId, media, options2 = {}) {
-        const { method, field } = mediaTelegramMethod(media.kind);
+        const { method, field: field2 } = mediaTelegramMethod(media.kind);
         const caption = options2.caption?.trim();
         const replyParameters = telegramReplyParameters(options2.replyToMessageId);
         if (media.source === "url") {
           const result2 = await this.apiCall(method, {
             chat_id: chatId,
-            [field]: media.value,
+            [field2]: media.value,
             ...caption ? { caption } : {},
             ...replyParameters ? { reply_parameters: replyParameters } : {}
           });
@@ -657650,7 +658249,7 @@ ${text}`.trim());
         parts.push(Buffer.from(`--${boundary}\r
 `));
         parts.push(Buffer.from(
-          `Content-Disposition: form-data; name="${field}"; filename="${filename}"\r
+          `Content-Disposition: form-data; name="${field2}"; filename="${filename}"\r
 Content-Type: ${contentType}\r
 \r
 `
@@ -657899,9 +658498,9 @@ Content-Type: ${contentType}\r
         for (const [name10, value2] of Object.entries(fields)) {
           addField(name10, value2);
         }
-        for (const [field, pathOrFileId] of Object.entries(files)) {
+        for (const [field2, pathOrFileId] of Object.entries(files)) {
           if (!existsSync131(pathOrFileId)) {
-            addField(field, pathOrFileId);
+            addField(field2, pathOrFileId);
             continue;
           }
           const buffer2 = readFileSync108(pathOrFileId);
@@ -657909,8 +658508,8 @@ Content-Type: ${contentType}\r
           parts.push(Buffer.from(`--${boundary}\r
 `));
           parts.push(Buffer.from(
-            `Content-Disposition: form-data; name="${field}"; filename="${filename}"\r
-Content-Type: ${mimeForPath(pathOrFileId, field === "photo" ? "image" : "video")}\r
+            `Content-Disposition: form-data; name="${field2}"; filename="${filename}"\r
+Content-Type: ${mimeForPath(pathOrFileId, field2 === "photo" ? "image" : "video")}\r
 \r
 `
           ));