omnius 1.0.538 → 1.0.540

package/dist/index.js

@@ -573290,17 +573290,18 @@ function buildTrajectoryCheckpoint(input) {
   const focus = sanitizeTrajectoryText(input.focusDirective, 300);
   const targetPath = inferTargetPath(combinedFailure || outcomeText || focus) ?? latestFailure?.targetPath ?? mostRecentTargetForTool(observations, latestFailure?.toolName);
   const targetFreshness = targetPath ? input.evidenceFreshness?.(targetPath) ?? "unknown" : "unknown";
+  const modifiedFiles = Array.from(state.modifiedFiles).slice(-3);
   const fullWriteIssue = (latestFailure?.toolName === "file_write" || fallbackFailure?.tool === "file_write" || /file_write/i.test(combinedFailure)) && /FULL FILE (?:WRITE LOOP BLOCKED|REWRITE CONTRACT)|overwrite(?:=true)?|expected_hash|Refusing to overwrite existing file/i.test(combinedFailure);
+  const fullWriteRecoveredByMutation = fullWriteIssue && Boolean(targetPath) && modifiedFiles.some(([path16]) => sameProjectPath(path16, targetPath)) && typeof latestFailure?.turn === "number" && typeof input.lastMutationTurn === "number" && input.lastMutationTurn > latestFailure.turn;
   const explicitBlock = /(?:permission denied|needs user input|ask_user|cannot proceed|external dependency|\[.*BLOCKED\])/i.test(combinedFailure);
   const hasRecentFailure = Boolean(combinedFailure);
-  const modifiedFiles = Array.from(state.modifiedFiles).slice(-3);
   const verifierDue = modifiedFiles.length > 0 && (input.lastVerifier?.turn === void 0 || input.lastMutationTurn !== void 0 && (input.lastVerifier.turn ?? -1) < input.lastMutationTurn);
   let assessment = "on_trajectory";
   let nextAction = sanitizeTrajectoryText(state.nextAction, 260) || "Take one narrow, evidence-backed action that advances the active task.";
   let successEvidence = "A tool result directly confirms the next action advanced the stated goal.";
   const openQuestions = [];
   const doNotRepeat = [];
-  if (fullWriteIssue) {
+  if (fullWriteIssue && !fullWriteRecoveredByMutation) {
     assessment = "recovery_required";
     const target = targetPath || "the existing target file";
     nextAction = targetFreshness === "fresh" ? `Use file_edit/file_patch for the local change in ${target}; do not resume full-file writes.` : `file_read ${target}, then prefer file_edit/file_patch for the local change.`;
@@ -573309,7 +573310,7 @@ function buildTrajectoryCheckpoint(input) {
     if (targetFreshness !== "fresh") {
       openQuestions.push(`Current bytes/hash for ${target} are not freshly evidenced.`);
     }
-  } else if (explicitBlock) {
+  } else if (explicitBlock && !fullWriteRecoveredByMutation) {
     assessment = "blocked";
     nextAction = "Resolve or report the explicit blocker with the evidence that established it.";
     successEvidence = "A new observation removes the blocker or documents why it cannot be removed.";
@@ -573319,7 +573320,7 @@ function buildTrajectoryCheckpoint(input) {
     nextAction = extractFocusNextAction(focus) || nextAction;
     successEvidence = "The focus recovery requirement is satisfied by a fresh tool observation.";
     doNotRepeat.push("Ignoring the active focus recovery directive.");
-  } else if (hasRecentFailure) {
+  } else if (hasRecentFailure && !fullWriteRecoveredByMutation) {
     assessment = "recovery_required";
     nextAction = "Use the newest failure evidence to make one different, narrow diagnostic or repair action.";
     successEvidence = "The next tool result changes, resolves, or explicitly narrows the observed failure.";
@@ -573329,6 +573330,9 @@ function buildTrajectoryCheckpoint(input) {
     nextAction = "Run the declared verifier or the narrowest relevant validation for the recent mutation.";
     successEvidence = "A post-mutation verifier result is recorded.";
   }
+  if (fullWriteIssue && fullWriteRecoveredByMutation) {
+    doNotRepeat.push("Returning to unguarded file_write after the targeted repair; verify the repair first.");
+  }
   const groundedFacts = [];
   if (state.currentStep.trim()) {
     groundedFacts.push({
@@ -573479,6 +573483,12 @@ function mostRecentTargetForTool(observations, toolName) {
   }
   return null;
 }
+function sameProjectPath(left, right) {
+  const normalize3 = (value2) => String(value2 ?? "").replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/\/+/g, "/").replace(/\/+$/, "");
+  const a2 = normalize3(left);
+  const b = normalize3(right);
+  return Boolean(a2 && b) && (a2 === b || a2.endsWith(`/${b}`) || b.endsWith(`/${a2}`));
+}
 function extractFocusNextAction(value2) {
   const match = /(?:Required next action|Next action)\s*:\s*(.+?)(?=\s+(?:Success evidence|Do not repeat|Attention rule)|$)/i.exec(value2);
   if (match?.[1])
@@ -577931,7 +577941,7 @@ function retireDuplicateToolFailures(messages2) {
     }
     out[index] = {
       ...message2,
-      content: "[retired_duplicate_tool_failure] a newer matching failure appears later. Use that latest diagnostic; retry only after refreshing prerequisite evidence or correcting the arguments."
+      content: "[retired_duplicate_tool_failure] a newer matching result appears later. Use that latest diagnostic; retry only after refreshing prerequisite evidence or correcting the arguments."
     };
   }
   return out;
@@ -580288,6 +580298,16 @@ var init_focusSupervisor = __esm({
         }
         return action;
       }
+      /**
+       * In silent small-model runner mode, cached failed shell output is diagnostic
+       * evidence, not a substitute for recovery. Asking a small model to "use cached
+       * evidence" repeatedly was itself a loop: it neither changed code nor
+       * selected a new diagnostic. Direct/strict supervisor consumers retain the
+       * legacy cache directive and its hard-block semantics.
+       */
+      shellFailureRequiredNextAction() {
+        return this.silent && this.modelTier === "small" ? "creative_pivot_or_research" : "use_cached_evidence";
+      }
       snapshot() {
         return {
           mode: this.mode,
@@ -580440,11 +580460,12 @@ var init_focusSupervisor = __esm({
           const advisoryOnly = this.repeatGateMax === 0;
           const hitLimit = input.cachedResultFailed ? 1 : Math.max(1, this.repeatGateMax - 1);
           const state = input.cachedResultFailed || duplicateHitCount >= hitLimit ? "cached_evidence" : "warn";
+          const requiredNextAction = input.cachedResultFailed && input.toolName === "shell" ? this.shellFailureRequiredNextAction() : "use_cached_evidence";
           const directive = this.setDirective({
             turn: input.turn,
             state,
             reason: input.cachedResultFailed ? `cached failed ${input.toolName} evidence already exists` : `duplicate ${input.toolName} call has cached evidence`,
-            requiredNextAction: "use_cached_evidence",
+            requiredNextAction,
             forbiddenActionFamilies: forbiddenCachedEvidenceFamilies(input, family)
           });
           if (strict && !advisoryOnly && (input.cachedResultFailed || duplicateHitCount >= hitLimit)) {
@@ -580560,7 +580581,7 @@ var init_focusSupervisor = __esm({
             actionFamily(input.toolName, input.args, this.familyCwd),
             input.toolName
           ]) : input.toolName === "shell" ? [actionFamily(input.toolName, input.args, this.familyCwd)] : [actionFamily(input.toolName, input.args, this.familyCwd)];
-          const requiredNextAction = ambiguousEditFailure ? "disambiguate_edit_match" : staleEditFailure ? "read_authoritative_target" : input.toolName === "shell" ? "use_cached_evidence" : this.resolveRequiredNextAction("update_todos");
+          const requiredNextAction = ambiguousEditFailure ? "disambiguate_edit_match" : staleEditFailure ? "read_authoritative_target" : input.toolName === "shell" ? this.shellFailureRequiredNextAction() : this.resolveRequiredNextAction("update_todos");
           this.setDirective({
             turn: input.turn,
             state: "forced_replan",
@@ -580572,10 +580593,10 @@ var init_focusSupervisor = __esm({
           const ambiguousEditFailure = isEditTool(input.toolName) && next.errorClass === "stale_ambiguous_target";
           const staleEditFailure = isEditTool(input.toolName) && next.errorClass.startsWith("stale_");
           const shellFailure = input.toolName === "shell";
-          const requiredNextAction = ambiguousEditFailure ? "disambiguate_edit_match" : staleEditFailure ? "read_authoritative_target" : shellFailure ? "use_cached_evidence" : this.resolveRequiredNextAction("update_todos");
+          const requiredNextAction = ambiguousEditFailure ? "disambiguate_edit_match" : staleEditFailure ? "read_authoritative_target" : shellFailure ? this.shellFailureRequiredNextAction() : this.resolveRequiredNextAction("update_todos");
           this.setDirective({
             turn: input.turn,
-            state: shellFailure ? "cached_evidence" : "warn",
+            state: shellFailure && !this.silent ? "cached_evidence" : "warn",
             reason: `first ${input.toolName} failure (${next.errorClass}): ${next.sample}`,
             requiredNextAction,
             forbiddenActionFamilies: shellFailure ? [actionFamily(input.toolName, input.args, this.familyCwd)] : [actionFamily(input.toolName, input.args, this.familyCwd)]
@@ -594299,12 +594320,13 @@ ${blob}
         this._readCoverage.set(iv.key, pruned.slice(0, 8));
       }
       _dedupeToolCallsForResponse(toolCalls, turn) {
-        if (toolCalls.length <= 1)
-          return toolCalls;
+        const idDeduped = this._dedupeRepeatedToolCallIdsForResponse(toolCalls, turn);
+        if (idDeduped.length <= 1)
+          return idDeduped;
         const seen = /* @__PURE__ */ new Set();
         const deduped = [];
         let dropped = 0;
-        for (const tc of toolCalls) {
+        for (const tc of idDeduped) {
           const fp = this._buildToolFingerprint(tc.name, tc.arguments ?? {});
           if (seen.has(fp)) {
             dropped++;
@@ -594322,6 +594344,36 @@ ${blob}
         }
         return deduped;
       }
+      /**
+       * A provider must never reuse a tool-call ID in one assistant response.
+       * Keep the first occurrence as the canonical call and drop later copies
+       * before either execution or transcript construction. This is deliberately
+       * narrower than fingerprint dedupe: the brute-force loop must still permit
+       * legitimate fresh reads that use distinct call IDs.
+       */
+      _dedupeRepeatedToolCallIdsForResponse(toolCalls, turn) {
+        if (toolCalls.length <= 1)
+          return toolCalls;
+        const seenIds = /* @__PURE__ */ new Set();
+        const deduped = [];
+        let dropped = 0;
+        for (const tc of toolCalls) {
+          if (seenIds.has(tc.id)) {
+            dropped++;
+            continue;
+          }
+          seenIds.add(tc.id);
+          deduped.push(tc);
+        }
+        if (dropped > 0) {
+          this.emit({
+            type: "status",
+            content: `Response ID dedupe: dropped ${dropped} repeated tool call ID${dropped === 1 ? "" : "s"} before execution (turn ${turn})`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+        return deduped;
+      }
       _decodeToolFingerprint(fingerprint) {
         const colonIdx = fingerprint.indexOf(":");
         const toolName = colonIdx > 0 ? fingerprint.slice(0, colonIdx) : fingerprint;
@@ -602228,7 +602280,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
             if (msg.toolCalls && msg.toolCalls.length > 0) {
               consecutiveTextOnly = 0;
               consecutiveThinkOnly = 0;
-              msg.toolCalls = msg.toolCalls;
+              msg.toolCalls = this._dedupeRepeatedToolCallIdsForResponse(msg.toolCalls, turn);
               if (msg.toolCalls.length === 0) {
                 messages2.push({
                   role: "system",
@@ -641565,17 +641617,28 @@ function stageForAgentEvent(event) {
       return { stage: "compacting" };
     case "debug_adversary":
       return { stage: "adversary_audit" };
-    case "trajectory_checkpoint":
-      if (/verification_due/i.test(event.content ?? "")) {
+    case "trajectory_checkpoint": {
+      const assessment = event.trajectory?.assessment;
+      if (assessment === "verification_due") {
         return { stage: "verifying", detail: "trajectory" };
       }
-      if (/\bblocked\b/i.test(event.content ?? "")) {
+      if (assessment === "blocked") {
         return { stage: "failed", detail: "trajectory" };
       }
+      if (assessment === "recovery_required") {
+        return { stage: "blocked", detail: "trajectory" };
+      }
+      if (/verification_due/i.test(event.content ?? "")) {
+        return { stage: "verifying", detail: "trajectory" };
+      }
       if (/recovery_required/i.test(event.content ?? "")) {
         return { stage: "blocked", detail: "trajectory" };
       }
+      if (/\bblocked\b/i.test(event.content ?? "")) {
+        return { stage: "failed", detail: "trajectory" };
+      }
       return { stage: "planning", detail: "trajectory" };
+    }
     case "complete":
       return { stage: "completed", detail: "done" };
     case "error":

package/npm-shrinkwrap.json

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

package/package.json

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