omnius 1.0.521 → 1.0.523

package/dist/index.js

@@ -581447,26 +581447,26 @@ function classifyShellIntent(cmd) {
 function verifyShellOutcome(command, ctx3, result) {
   const cmd = (command ?? "").trim();
   if (!cmd)
-    return baseline("shell:empty");
+    return withStatusChannels(baseline("shell:empty"), result.success);
   const cwd4 = resolveCwd(cmd, ctx3.cwd);
   const intent = classifyShellIntent(cmd);
   const baseBucket = intentBucketFor(intent, cwd4);
   if (!result.success) {
-    return { trustworthy: true, intentBucket: baseBucket, outcomeClass: "broken" };
+    return withStatusChannels({ trustworthy: true, intentBucket: baseBucket, outcomeClass: "broken" }, false);
   }
   if (intent.klass === "read" || intent.klass === "verify") {
-    return { trustworthy: true, intentBucket: baseBucket, outcomeClass: "verified" };
+    return withStatusChannels({ trustworthy: true, intentBucket: baseBucket, outcomeClass: "verified" }, true);
   }
   if (intent.klass !== "mutate") {
-    return { trustworthy: true, intentBucket: baseBucket, outcomeClass: "unknown" };
+    return withStatusChannels({ trustworthy: true, intentBucket: baseBucket, outcomeClass: "unknown" }, true);
   }
   const mtimeCheck = checkMutateMtimeDelta(intent, cwd4, ctx3, result);
   const invariantCheck = checkManifestInvariant(cwd4, baseBucket);
   if (!mtimeCheck.trustworthy)
-    return mtimeCheck;
+    return withStatusChannels(mtimeCheck, true);
   if (!invariantCheck.trustworthy)
-    return invariantCheck;
-  return invariantCheck.outcomeClass !== "unknown" ? invariantCheck : mtimeCheck;
+    return withStatusChannels(invariantCheck, true);
+  return withStatusChannels(invariantCheck.outcomeClass !== "unknown" ? invariantCheck : mtimeCheck, true);
 }
 function checkMutateMtimeDelta(intent, cwd4, ctx3, _result) {
   const bucket = intentBucketFor(intent, cwd4);
@@ -581731,6 +581731,19 @@ function intentBucketFor(intent, cwd4) {
 function baseline(intentBucket) {
   return { trustworthy: true, intentBucket, outcomeClass: "unknown" };
 }
+function withStatusChannels(result, commandSuccess) {
+  const environmentWarnings = result.trustworthy || !result.syntheticError ? [] : [result.syntheticError];
+  return {
+    ...result,
+    command_status: {
+      success: commandSuccess,
+      outcomeClass: result.outcomeClass,
+      intentBucket: result.intentBucket
+    },
+    environment_warnings: environmentWarnings,
+    policy_warnings: []
+  };
+}
 function resolveCwd(cmd, fallback) {
   const cdMatch = cmd.match(/^cd\s+([^&\s]+)\s*&&/);
   if (cdMatch && cdMatch[1])
@@ -583472,8 +583485,9 @@ var init_agenticRunner = __esm({
       _fileWritesThisRun = 0;
       _backwardPassCyclesUsed = 0;
       // Completion compile/verify gate: count of times task_complete was blocked
-      // because the configured verify command failed. Bounded by
-      // OMNIUS_COMPLETION_VERIFY_MAX to avoid an endless verify→fix→verify loop.
+      // because the configured verify command failed. After the retry budget is
+      // spent, the run stops as incomplete_verification instead of completing with
+      // stale or failing verifier evidence.
       _completionVerifyRejections = 0;
       // Diagnostics counter for the inference-driven resolution gate (the real
       // bounded escape is the same-summary completion-hold counter / REG-54).
@@ -583835,6 +583849,34 @@ var init_agenticRunner = __esm({
         result.failureDiagnosis = diagnosis;
         return diagnosis;
       }
+      _buildStaleHashRetryGuidance(toolName, args, result) {
+        if (result.success || !this._isProjectEditTool(toolName))
+          return null;
+        if (result.failureDiagnosis?.kind !== "stale_hash")
+          return null;
+        const path15 = this._extractToolTargetPaths(toolName, args, result)[0];
+        const freshHash = typeof result.beforeHash === "string" && /^[a-f0-9]{64}$/i.test(result.beforeHash) ? result.beforeHash : null;
+        if (!path15 || !freshHash)
+          return null;
+        const retry = {
+          failure_family: "stale_hash",
+          guardrail: "one_assisted_refresh_only",
+          retry: {
+            tool: toolName,
+            args: { ...args, expected_hash: freshHash }
+          },
+          fresh_evidence: {
+            path: path15,
+            expected_hash: freshHash
+          }
+        };
+        return [
+          `[STALE_HASH_RETRY]`,
+          `The edit failed only because expected_hash was stale. The runtime refreshed the current file hash once.`,
+          `Retry the same targeted edit with this fresh expected_hash; if it fails again, re-read the exact target range instead of broadening the edit.`,
+          JSON.stringify(retry)
+        ].join("\n");
+      }
       _failureRecoveryCardInput(diagnosis) {
         return {
           id: failureCardId(diagnosis),
@@ -586123,6 +586165,67 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
         }
         return best;
       }
+      _pathsOverlapForVerifier(left, right) {
+        const a2 = this._normalizeEvidencePath(left);
+        const b = this._normalizeEvidencePath(right);
+        if (!a2 || !b)
+          return false;
+        return a2 === b || a2.startsWith(`${b}/`) || b.startsWith(`${a2}/`);
+      }
+      _completionVerifierGapsAfterFinalMutation(todos, toolCallLog) {
+        const gaps = [];
+        for (const todo of todos) {
+          if (todo.status !== "completed")
+            continue;
+          const verifyCommand = typeof todo.verifyCommand === "string" ? todo.verifyCommand.trim() : "";
+          if (!verifyCommand)
+            continue;
+          const declaredArtifacts = Array.isArray(todo.declaredArtifacts) ? todo.declaredArtifacts.filter((p2) => typeof p2 === "string" && p2.trim().length > 0).map((p2) => this._normalizeEvidencePath(p2)) : [];
+          let lastMutationTurn = -1;
+          let lastMutationIndex = -1;
+          for (const [index, entry] of toolCallLog.entries()) {
+            if (!entry.mutated)
+              continue;
+            const turn = typeof entry.turn === "number" ? entry.turn : -1;
+            const mutationPaths = Array.isArray(entry.mutatedFiles) ? entry.mutatedFiles.filter((p2) => typeof p2 === "string" && p2.trim().length > 0) : [];
+            const relevant = declaredArtifacts.length === 0 ? true : mutationPaths.some((mutatedPath) => declaredArtifacts.some((artifactPath) => this._pathsOverlapForVerifier(mutatedPath, artifactPath)));
+            if (relevant) {
+              lastMutationIndex = Math.max(lastMutationIndex, index);
+              lastMutationTurn = Math.max(lastMutationTurn, turn);
+            }
+          }
+          const shellHistoryAfterMutation = toolCallLog.filter((entry) => entry.name === "shell" && toolCallLog.indexOf(entry) > lastMutationIndex).map((entry) => ({
+            command: this._shellCommandFromArgsKey(entry.argsKey),
+            success: entry.success === true
+          }));
+          if (!verifyCommandSatisfiedByShellHistory(verifyCommand, shellHistoryAfterMutation)) {
+            gaps.push({
+              todo,
+              verifyCommand,
+              declaredArtifacts,
+              lastMutationTurn
+            });
+          }
+        }
+        return gaps;
+      }
+      _formatFreshVerifierGapFeedback(gaps) {
+        const lines = gaps.slice(0, 8).map((gap) => {
+          const artifacts = gap.declaredArtifacts.length ? ` artifacts=${gap.declaredArtifacts.join(", ")}` : " artifacts=(none declared; any later project mutation invalidates verifier evidence)";
+          const mutation = gap.lastMutationTurn >= 0 ? ` last_relevant_mutation_turn=${gap.lastMutationTurn}` : " no_mutation_recorded";
+          return `  - ${gap.todo.content.slice(0, 120)} :: verifyCommand=\`${gap.verifyCommand}\`;${mutation};${artifacts}`;
+        });
+        return [
+          `[COMPLETION BLOCKED — fresh verifier required]`,
+          `Completed todos with verifyCommand must have a live successful verifier after the final relevant mutation.`,
+          `Prior verifier results are not accepted after a declared artifact changes.`,
+          ``,
+          `Unverified completed todo(s):`,
+          ...lines,
+          ``,
+          `Run the listed verifier command(s) now. If one fails, keep the todo in_progress or blocked and make one targeted fix before retrying.`
+        ].join("\n");
+      }
       _shellCommandFromArgsKey(argsKey) {
         const parsed = this._parseExactArgsKey(argsKey);
         return parsed.get("command") ?? parsed.get("cmd") ?? "";
@@ -586929,9 +587032,8 @@ ${shellLines.join("\n")}` : "Commands run: none"
        * (e.g. a typecheck/build) before `task_complete` is accepted, but ONLY when
        * the run actually modified code files. A non-zero exit blocks completion and
        * feeds the error output back so the model fixes it before retrying. Bounded
-       * by OMNIUS_COMPLETION_VERIFY_MAX rejections so a persistently-failing build
-       * does not trap the run forever (it completes with a caveat instead — the
-       * same anti-collapse philosophy as the backward-pass cycle cap).
+       * by OMNIUS_COMPLETION_VERIFY_MAX rejections; after the budget is spent, the
+       * run stops as incomplete_verification instead of accepting task_complete.
        *
        * Default OFF: unset command → `{ proceed: true }`, preserving the prior
        * "no deterministic verification gate" behaviour for every existing caller.
@@ -586946,17 +587048,25 @@ ${shellLines.join("\n")}` : "Commands run: none"
           return { proceed: true };
         const maxRejections = parseInt(process.env["OMNIUS_COMPLETION_VERIFY_MAX"] || "3", 10) || 3;
         if (this._completionVerifyRejections >= maxRejections) {
-          this._completionCaveat = [
-            `[COMPLETION CAVEAT] Verify command still failing after ${this._completionVerifyRejections} attempt(s): ${cmd}`,
-            "Completing with unresolved build/verify errors — treat as a follow-up blocker."
+          const summary = [
+            `INCOMPLETE_VERIFICATION: declared completion verifier is still failing after ${this._completionVerifyRejections} attempt(s).`,
+            ``,
+            `Verifier command: ${cmd}`,
+            ``,
+            `Stop reason: verifier_still_failing`,
+            `The task cannot be marked complete until this command succeeds after the final mutation.`
           ].join("\n");
+          this._completionIncompleteVerification = {
+            reason: "verifier_still_failing",
+            summary
+          };
           this.emit({
             type: "status",
-            content: `completion verify gate exhausted after ${this._completionVerifyRejections} attempts; completing with caveat`,
+            content: `completion verify gate exhausted after ${this._completionVerifyRejections} attempt(s); marking incomplete_verification`,
             turn,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
-          return { proceed: true };
+          return { proceed: false, feedback: summary };
         }
         const timeoutMs = parseInt(process.env["OMNIUS_COMPLETION_VERIFY_TIMEOUT_MS"] || "180000", 10) || 18e4;
         const wd = this._workingDirectory || process.cwd();
@@ -587033,7 +587143,7 @@ ${outTail || "(no output captured)"}`,
           "",
           "You CANNOT call task_complete until this passes. Fix the errors below, then",
           "re-run the verify command yourself (via shell) to confirm before completing.",
-          `(attempt ${this._completionVerifyRejections}/${maxRejections} — after that the run completes with a caveat)`,
+          `(attempt ${this._completionVerifyRejections}/${maxRejections} — after that the run stops as incomplete_verification)`,
           "",
           "--- verify output (tail) ---",
           outTail || "(no output captured)"
@@ -591484,7 +591594,26 @@ TASK: ${scrubbedTask}` : scrubbedTask;
           return true;
         };
         const holdUnresolvedVerificationTaskComplete = (turn) => {
-          const newFailures = [...this._verifyFailures].filter((f2) => !this._verifyFailuresBaseline.has(f2));
+          const todos = this.readSessionTodos() || [];
+          const freshVerifierGaps = this._completionVerifierGapsAfterFinalMutation(todos, toolCallLog);
+          const gapContents = new Set(freshVerifierGaps.map((gap) => gap.todo.content));
+          for (const todo of todos) {
+            if (todo.status === "completed" && typeof todo.verifyCommand === "string" && todo.verifyCommand.trim().length > 0) {
+              if (gapContents.has(todo.content)) {
+                this._verifyCommandFailures.add(todo.content);
+              } else {
+                this._verifyCommandFailures.delete(todo.content);
+              }
+              this._refreshTodoVerificationFailure(todo.content);
+            }
+          }
+          const freshGapFailures = freshVerifierGaps.map((gap) => gap.todo.content);
+          const newFailures = [
+            .../* @__PURE__ */ new Set([
+              ...[...this._verifyFailures].filter((f2) => !this._verifyFailuresBaseline.has(f2)),
+              ...freshGapFailures
+            ])
+          ];
           if (newFailures.length === 0)
             return false;
           const failures = newFailures.slice(0, 8);
@@ -591492,6 +591621,8 @@ TASK: ${scrubbedTask}` : scrubbedTask;
             `[COMPLETION BLOCKED — unresolved todo verification]`,
             `The active todo list still contains completed items whose required evidence has not been satisfied by work done in THIS task.`,
             ``,
+            freshVerifierGaps.length > 0 ? this._formatFreshVerifierGapFeedback(freshVerifierGaps) : "",
+            freshVerifierGaps.length > 0 ? `` : "",
             `Unresolved verification item(s) introduced this run:`,
             ...failures.map((item) => `  - ${item}`),
             ``,
@@ -591521,15 +591652,20 @@ TASK: ${scrubbedTask}` : scrubbedTask;
         })();
         const holdTaskCompleteGates = (args, turn) => {
           if (this._completionHoldState.total >= completionHoldHardMax) {
-            const caveat = [
-              `[UNVERIFIED — completion accepted after ${this._completionHoldState.total} gate holds]`,
-              lastCompletionGateReason ? `Last unresolved gate: ${lastCompletionGateReason.slice(0, 300)}` : ""
+            const incompleteSummary = [
+              `INCOMPLETE_VERIFICATION: completion was requested after ${this._completionHoldState.total} gate hold(s), but required evidence is still missing.`,
+              lastCompletionGateReason ? `Last unresolved gate: ${lastCompletionGateReason.slice(0, 300)}` : "",
+              lastCompletionGateFeedback ? `
+Evidence:
+${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
             ].filter(Boolean).join("\n");
-            this._completionCaveat = this._completionCaveat ? `${this._completionCaveat}
-${caveat}` : caveat;
+            this._completionIncompleteVerification = {
+              reason: lastCompletionGateCode === "todo_verification" ? "verifier_still_failing" : "completion_evidence_missing",
+              summary: incompleteSummary
+            };
             this.emit({
               type: "status",
-              content: `Completion hold hard-escape: allowing task_complete after ${this._completionHoldState.total} total holds (caveat recorded)`,
+              content: `Completion hold hard-escape: marking incomplete_verification after ${this._completionHoldState.total} total holds`,
               turn,
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
@@ -591537,7 +591673,7 @@ ${caveat}` : caveat;
             this._completionHoldState.lastKey = "";
             this._completionHoldState.total = 0;
             lastCompletionGateCode = "";
-            return false;
+            return true;
           }
           const held = holdUnresolvedVerificationTaskComplete(turn) || holdNoProgressTaskComplete(args, turn) || holdProvenanceTaskComplete(args, turn);
           if (!held) {
@@ -595887,6 +596023,15 @@ ${bookkeepingGuidance}` : bookkeepingGuidance;
                 delete result.failureDiagnosis;
               } else {
                 this._diagnoseToolFailure(tc.name, tc.arguments, result);
+                const staleHashRetryGuidance = this._buildStaleHashRetryGuidance(tc.name, tc.arguments, result);
+                if (staleHashRetryGuidance) {
+                  output += `
+
+${staleHashRetryGuidance}`;
+                  runtimeSystemGuidance = runtimeSystemGuidance ? `${runtimeSystemGuidance}
+
+${staleHashRetryGuidance}` : staleHashRetryGuidance;
+                }
               }
               const currentLogEntry = toolCallLog[_toolLogTailIdx];
               if (currentLogEntry) {
@@ -598806,8 +598951,14 @@ ${marker}` : marker);
           return { args, patchedCount: 0 };
         }
         if (toolName === "file_edit") {
-          if (this._normalizeExpectedHashValue(this._rawExpectedHashValue(args))) {
-            return { args, patchedCount: 0 };
+          const currentHash = this._normalizeExpectedHashValue(this._rawExpectedHashValue(args));
+          if (currentHash) {
+            const path16 = this.extractPrimaryToolPath(args);
+            const fresh2 = path16 ? this._freshReadHashForEditPath(path16) : null;
+            if (!fresh2 || fresh2.hash === currentHash) {
+              return { args, patchedCount: 0 };
+            }
+            return { args: { ...args, expected_hash: fresh2.hash }, patchedCount: 1 };
           }
           const path15 = this.extractPrimaryToolPath(args);
           const fresh = path15 ? this._freshReadHashForEditPath(path15) : null;
@@ -598833,11 +598984,15 @@ ${marker}` : marker);
           if (!edit || typeof edit !== "object" || Array.isArray(edit))
             return edit;
           const rec = edit;
-          if (this._normalizeExpectedHashValue(this._rawExpectedHashValue(rec))) {
-            return rec;
-          }
           const path15 = typeof rec["path"] === "string" ? rec["path"] : typeof rec["file"] === "string" ? rec["file"] : "";
           const fresh = path15 ? this._freshReadHashForEditPath(path15) : null;
+          const currentHash = this._normalizeExpectedHashValue(this._rawExpectedHashValue(rec));
+          if (currentHash) {
+            if (!fresh || fresh.hash === currentHash)
+              return rec;
+            patchedCount++;
+            return { ...rec, expected_hash: fresh.hash };
+          }
           if (!fresh)
             return rec;
           patchedCount++;
@@ -599067,6 +599222,40 @@ ${marker}` : marker);
         return changed ? next : args;
       }
       _normalizeToolArgsForExecution(toolName, args) {
+        if (toolName === "todo_write") {
+          if (args["todos"] !== void 0)
+            return args;
+          const content = String(args["content"] ?? "").trim();
+          if (!content)
+            return args;
+          const action = String(args["action"] ?? "").trim().toLowerCase();
+          const rawStatus = String(args["status"] ?? "").trim();
+          const status = ["pending", "in_progress", "completed", "blocked"].includes(rawStatus) ? rawStatus : action === "complete" || action === "completed" || action === "done" ? "completed" : action === "block" || action === "blocked" ? "blocked" : "in_progress";
+          const todo = { content, status };
+          if (typeof args["id"] === "string" && args["id"].trim()) {
+            todo["id"] = args["id"].trim();
+          }
+          if (typeof args["parentId"] === "string" && args["parentId"].trim()) {
+            todo["parentId"] = args["parentId"].trim();
+          }
+          const artifact = args["file"] ?? args["path"];
+          if (typeof artifact === "string" && artifact.trim()) {
+            todo["declaredArtifacts"] = [artifact.trim()];
+          }
+          if (typeof args["verifyCommand"] === "string" && args["verifyCommand"].trim()) {
+            todo["verifyCommand"] = args["verifyCommand"].trim();
+          }
+          if (typeof args["blocker"] === "string" && args["blocker"].trim()) {
+            todo["blocker"] = args["blocker"].trim();
+          }
+          const next2 = { todos: [todo] };
+          if (typeof args["session_id"] === "string" && args["session_id"].trim()) {
+            next2["session_id"] = args["session_id"].trim();
+          } else if (typeof args["sessionId"] === "string" && args["sessionId"].trim()) {
+            next2["session_id"] = args["sessionId"].trim();
+          }
+          return next2;
+        }
         if (toolName === "working_notes") {
           let next2 = args;
           const copy2 = () => {
@@ -599225,7 +599414,7 @@ ${marker}` : marker);
         return [
           "[EDIT FRESHNESS CONTRACT]",
           "Exact replacement edits must be built from verified current file content, not remembered text.",
-          "Before file_edit or batch_edit can run, each target must carry expected_hash from file_read. If the runner has fresh read evidence, it will attach that hash automatically; otherwise the edit tool verifies the provided hash against disk before mutating.",
+          "Before file_edit or batch_edit can run, each target must carry expected_hash from file_read. If the runner has fresh read evidence, it will attach or refresh that hash automatically; otherwise the edit tool verifies the provided hash against disk before mutating.",
           "For multiple edits to the same file, use one batch_edit against the same expected_hash so all replacements validate atomically before the file changes.",
           "",
           ...problems.map((problem) => `- ${problem}`),

package/npm-shrinkwrap.json

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

package/package.json

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