omnius 1.0.376 → 1.0.378

package/dist/index.js

@@ -559711,13 +559711,6 @@ var init_completionLedger = __esm({
 // packages/orchestrator/dist/completionAutoFinalize.js
 function buildTruthBasedCompletion(input) {
   const maxAge = input.maxValidationAgeTurns ?? 8;
-  if (input.todos.length === 0) {
-    return { ready: false, reason: "no active todo tree" };
-  }
-  const open2 = input.todos.filter((todo) => todo.status !== "completed");
-  if (open2.length > 0) {
-    return { ready: false, reason: `${open2.length} open todo(s)` };
-  }
   if (input.verifyFailureCount > 0) {
     return {
       ready: false,
@@ -559735,6 +559728,33 @@ function buildTruthBasedCompletion(input) {
     };
   }
   const files = (input.filesEdited ?? []).filter((file) => file.path.trim().length > 0).slice(0, 12);
+  if (input.todos.length === 0) {
+    if (files.length === 0) {
+      return { ready: false, reason: "no active todo tree or changed files" };
+    }
+    if (typeof input.lastMutationTurn === "number" && input.lastMutationTurn >= 0 && input.lastValidationTurn < input.lastMutationTurn) {
+      return {
+        ready: false,
+        reason: "validation happened before the last mutation"
+      };
+    }
+    const fileLines2 = files.map((file) => `- ${file.action ? `${file.action} ` : ""}${file.path}`).join("\n");
+    const summary2 = [
+      "Completed with direct task evidence.",
+      fileLines2 ? `Files changed:
+${fileLines2}` : null,
+      `Validation passed after the last mutation: ${input.lastValidationCommand}`
+    ].filter((line) => Boolean(line)).join("\n\n");
+    return {
+      ready: true,
+      reason: `changed files validated ${age} turn(s) ago`,
+      summary: summary2
+    };
+  }
+  const open2 = input.todos.filter((todo) => todo.status !== "completed");
+  if (open2.length > 0) {
+    return { ready: false, reason: `${open2.length} open todo(s)` };
+  }
   const todoLines = input.todos.slice(0, 12).map((todo) => {
     const id = todo.id ? `${todo.id}: ` : "";
     return `- ${id}${todo.content}`;
@@ -573462,6 +573482,9 @@ ${modelVisible}` : modelVisible || result.error || displayOutput || "";
         const realFileMutation = input.realFileMutation ?? this._isRealProjectMutation(input.toolName, input.result);
         const attemptedTargetPaths = this._extractToolTargetPaths(input.toolName, input.args, input.result);
         const realMutationPaths = input.realMutationPaths ?? (realFileMutation ? attemptedTargetPaths : []);
+        if (this._shouldSuppressCompletionDiscoveryEvidence(input.toolName, input.result, attemptedTargetPaths)) {
+          return;
+        }
         this._completionLedger = recordToolEvidence(this._completionLedger, {
           name: input.toolName,
           success: input.result.success,
@@ -573483,6 +573506,14 @@ ${modelVisible}` : modelVisible || result.error || displayOutput || "";
         }
         this._saveCompletionLedgerSafe();
       }
+      _shouldSuppressCompletionDiscoveryEvidence(toolName, result, targetPaths) {
+        if (result.success !== true)
+          return false;
+        if (toolName === "file_read") {
+          return targetPaths.length > 0 && targetPaths.some((path12) => this._evidenceLedger.hasFresh(path12));
+        }
+        return toolName === "list_directory" || toolName === "find_files" || toolName === "grep_search";
+      }
       _isAtomicBatchEditAbort(toolName, result) {
         if (toolName !== "batch_edit" || !result || result.success !== false) {
           return false;
@@ -578285,6 +578316,7 @@ TASK: ${scrubbedTask}` : scrubbedTask;
               currentTurn: turn,
               lastValidationTurn: this._lastBuildSuccessTurn,
               lastValidationCommand: this._lastBuildSuccessCommand,
+              lastMutationTurn: this._lastFileWriteTurn,
               verifyFailureCount: this._verifyFailures.size,
               filesEdited: [...this._taskState.modifiedFiles.entries()].map(([path12, action]) => ({ path: path12, action }))
             });
@@ -580568,6 +580600,43 @@ Use the saved fact to continue the promised synthesis or next concrete step, or
                   systemGuidance: staleEditBlock
                 };
               }
+              const staleRewriteBlock = this.staleEditOverwritePreflightBlock(tc.name, tc.arguments ?? {});
+              if (staleRewriteBlock) {
+                this.emit({
+                  type: "tool_call",
+                  toolName: tc.name,
+                  toolArgs: tc.arguments,
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                this.emit({
+                  type: "tool_result",
+                  toolName: tc.name,
+                  success: false,
+                  content: staleRewriteBlock.slice(0, 120),
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                this._tagSyntheticFailure({
+                  mode: "step_repetition",
+                  rationale: "full-file overwrite attempted while a stale narrow-edit repair lock is active"
+                });
+                if (this._completionLedger) {
+                  this._completionLedger = recordToolEvidence(this._completionLedger, {
+                    name: tc.name,
+                    success: false,
+                    outputPreview: staleRewriteBlock.slice(0, 500),
+                    argsKey: tc.arguments ? JSON.stringify(tc.arguments).slice(0, 300) : ""
+                  });
+                  this._saveCompletionLedgerSafe();
+                }
+                return {
+                  tc,
+                  output: staleRewriteBlock,
+                  success: false,
+                  systemGuidance: staleRewriteBlock
+                };
+              }
               const baseIsReadLike = ![
                 "file_write",
                 "file_edit",
@@ -581517,8 +581586,10 @@ Respond with EXACTLY this structure before your next tool call:
                 if (tc.name === "shell") {
                   const _shellCmd2 = String(tc.arguments?.["command"] ?? tc.arguments?.["cmd"] ?? "");
                   const _declaredVerify = this._matchedDeclaredVerifyCommand(_shellCmd2);
+                  const _lastVerifier = this._lastVerifierResult;
+                  const _noTodoDirectValidation = !_declaredVerify && (this.readSessionTodos() || []).length === 0 && this._taskState.modifiedFiles.size > 0 && _lastVerifier?.outcomeClass === "verified";
                   const _legacyGenericValidation = process.env["OMNIUS_ENABLE_GENERIC_COMPLETION_COMMAND_HEURISTIC"] === "1" && /\b(build|test|run\b|start\b|serve\b|verify|check)\b/i.test(_shellCmd2);
-                  if (_declaredVerify || _legacyGenericValidation) {
+                  if (_declaredVerify || _noTodoDirectValidation || _legacyGenericValidation) {
                     this._lastBuildSuccessTurn = turn;
                     this._lastBuildSuccessCommand = (_declaredVerify || _shellCmd2).slice(0, 200);
                     this._truthAutoCompleteBlockedValidationTurn = -1;
@@ -582409,7 +582480,7 @@ Then use file_read on individual FILES inside it.`);
                   handledIds.add(matchTc.id);
                   const output = sr.result.success ? sr.result.output : `Error: ${sr.result.error || "unknown"}
 ${sr.result.output}`;
-                  messages2.push(this.buildToolMessage(output, matchTc.id, matchTc.name));
+                  messages2.push(this.buildModelFacingToolMessage(output, matchTc.id, matchTc.name, matchTc.arguments, sr.result.success));
                   if (matchTc.name === "task_complete") {
                     if (!sr.result.success) {
                       messages2.push({
@@ -582477,7 +582548,7 @@ ${sr.result.output}`;
                     break;
                   const r2 = await executeSingle(tc);
                   if (r2) {
-                    messages2.push(this.buildToolMessage(r2.output, r2.tc.id, r2.tc.name));
+                    messages2.push(this.buildModelFacingToolMessage(r2.output, r2.tc.id, r2.tc.name, r2.tc.arguments, r2.success));
                     if (r2.systemGuidance) {
                       messages2.push({
                         role: "system",
@@ -582588,7 +582659,7 @@ ${sr.result.output}`;
                 }, 5);
                 for (const r2 of results) {
                   if (r2) {
-                    messages2.push(this.buildToolMessage(r2.output, r2.tc.id, r2.tc.name));
+                    messages2.push(this.buildModelFacingToolMessage(r2.output, r2.tc.id, r2.tc.name, r2.tc.arguments, r2.success));
                     if (r2.systemGuidance) {
                       messages2.push({
                         role: "system",
@@ -583481,7 +583552,7 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                 } else {
                   this._consecutiveEnoent = 0;
                 }
-                const toolMsg = this.buildToolMessage(output, tc.id, tc.name);
+                const toolMsg = this.buildModelFacingToolMessage(output, tc.id, tc.name, tc.arguments, result.success);
                 messages2.push(toolMsg);
                 if (tc.name === "task_complete") {
                   if (!result.success) {
@@ -583630,6 +583701,60 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
             }
           }
         }
+        if (!completed && !this._completionIncompleteVerification && process.env["OMNIUS_DISABLE_TRUTH_AUTOCOMPLETE"] !== "1") {
+          try {
+            const _finalTurn = Math.max(this._lastBuildSuccessTurn, this._lastFileWriteTurn, toolCallLog.at(-1)?.turn ?? -1, 0);
+            const _todos = this.readSessionTodos() || [];
+            const _truthCompletion = buildTruthBasedCompletion({
+              todos: _todos,
+              currentTurn: _finalTurn,
+              lastValidationTurn: this._lastBuildSuccessTurn,
+              lastValidationCommand: this._lastBuildSuccessCommand,
+              lastMutationTurn: this._lastFileWriteTurn,
+              verifyFailureCount: this._verifyFailures.size,
+              filesEdited: [...this._taskState.modifiedFiles.entries()].map(([path12, action]) => ({ path: path12, action }))
+            });
+            if (_truthCompletion.ready && this._truthAutoCompleteBlockedValidationTurn !== this._lastBuildSuccessTurn) {
+              const _summary = _truthCompletion.summary || "Completed.";
+              const _args = { summary: _summary };
+              if (!holdTaskCompleteGates(_args, _finalTurn)) {
+                const _bpFinalTruth = await this._runBackwardPassReview(_finalTurn, toolCallLog, _summary);
+                if (!_bpFinalTruth || _bpFinalTruth.proceed) {
+                  completed = true;
+                  summary = _summary;
+                  this.emit({
+                    type: "status",
+                    content: `REG-31: run-end truth-based completion synthesized (${_truthCompletion.reason})`,
+                    turn: _finalTurn,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
+                  this._onTypedEvent?.({
+                    type: "completion_requested",
+                    runId: this._sessionId ?? "unknown",
+                    summary: summary.slice(0, 500),
+                    sourcePath: "direct",
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
+                  if (summary && !this._assistantTextEmitted) {
+                    this.emit({
+                      type: "assistant_text",
+                      content: summary,
+                      source: "task_complete_summary",
+                      turn: _finalTurn,
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                    });
+                    this._assistantTextEmitted = true;
+                  }
+                } else if (_bpFinalTruth.feedback) {
+                  emitBackwardPassAdvisory(_bpFinalTruth.feedback, _finalTurn);
+                }
+              } else {
+                this._truthAutoCompleteBlockedValidationTurn = this._lastBuildSuccessTurn;
+              }
+            }
+          } catch {
+          }
+        }
         const durationMs = Date.now() - start2;
         const incompleteVerification = this._completionIncompleteVerification;
         if (incompleteVerification && !summary) {
@@ -584460,6 +584585,75 @@ ${marker}` : marker);
         }
         return { role: "tool", content: messageContent, tool_call_id: toolCallId };
       }
+      buildModelFacingToolMessage(output, toolCallId, toolName, args, success) {
+        return this.buildToolMessage(this.compactDiscoveryOutputForModel(toolName, args, output, success), toolCallId, toolName);
+      }
+      compactDiscoveryOutputForModel(toolName, args, output, success) {
+        if (success !== true)
+          return output;
+        if (this.shouldBypassDiscoveryCompaction(output))
+          return output;
+        const displayOutput = this.unwrapToolOutputForDisplay(output);
+        if (toolName === "file_read") {
+          const path13 = this.extractPrimaryToolPath(args);
+          if (!path13 || !this._evidenceLedger.hasFresh(path13))
+            return output;
+          const entry = this._evidenceLedger.get(path13);
+          return this.wrapToolOutputForModel(toolName, [
+            "[DISCOVERY COMPACTED - file_read evidence captured]",
+            `path=${path13}`,
+            `captured=${this.countTextLines(displayOutput)} lines, ${displayOutput.length} chars${entry ? `, fidelity=${entry.fidelity}` : ""}`,
+            'active_context="Evidence already gathered this run"',
+            "Use the active evidence frame. Re-read only if that frame marks this file STALE or you need a distinct range."
+          ].join("\n"));
+        }
+        const previewSpec = toolName === "list_directory" ? { label: "directory listing", maxLines: 40, maxChars: 2400 } : toolName === "find_files" ? { label: "file discovery", maxLines: 60, maxChars: 3e3 } : toolName === "grep_search" ? { label: "search matches", maxLines: 40, maxChars: 3e3 } : null;
+        if (!previewSpec)
+          return output;
+        const path12 = this.extractPrimaryToolPath(args);
+        const preview = this.boundedDiscoveryPreview(displayOutput, previewSpec.maxLines, previewSpec.maxChars);
+        return this.wrapToolOutputForModel(toolName, [
+          `[DISCOVERY BOUNDED - ${previewSpec.label}]`,
+          path12 ? `path=${path12}` : "",
+          `captured=${this.countTextLines(displayOutput)} lines, ${displayOutput.length} chars`,
+          `preview_lines=${preview.keptLines}/${preview.totalLines}`,
+          "Keep these discovered candidates in mind; repeat this discovery only if the underlying filesystem/search scope has changed.",
+          "",
+          preview.text
+        ].filter(Boolean).join("\n"));
+      }
+      shouldBypassDiscoveryCompaction(output) {
+        return output.includes("[IMAGE_BASE64:") || output.includes("[BRANCH-EXTRACT]") || output.includes("[STOP RE-READING") || output.includes("[Tool output truncated") || output.includes(TRIAGE_ENVELOPE_MARKER);
+      }
+      countTextLines(text2) {
+        if (!text2)
+          return 0;
+        return text2.split("\n").length;
+      }
+      boundedDiscoveryPreview(text2, maxLines, maxChars) {
+        const lines = text2.split("\n");
+        const kept = [];
+        let used = 0;
+        for (const line of lines) {
+          if (kept.length >= maxLines)
+            break;
+          const next = line.slice(0, Math.max(0, maxChars - used));
+          if (next.length === 0 && line.length > 0)
+            break;
+          kept.push(next);
+          used += next.length + 1;
+          if (used >= maxChars)
+            break;
+        }
+        if (kept.length < lines.length) {
+          kept.push(`[... ${lines.length - kept.length} additional line(s) compacted ...]`);
+        }
+        return {
+          text: kept.join("\n"),
+          totalLines: lines.length,
+          keptLines: Math.min(kept.length, lines.length)
+        };
+      }
       // -------------------------------------------------------------------------
       // Output folding — keep head + tail, omit middle (preserves errors at end)
       // -------------------------------------------------------------------------
@@ -584544,15 +584738,32 @@ ${marker}` : marker);
           return "stale_old_string";
         return null;
       }
-      staleEditFamilyKey(toolName, path12, errorKind, targetHash) {
-        return toolName + ":" + path12 + ":" + errorKind + ":" + targetHash;
+      staleEditPathKey(path12) {
+        const trimmed = path12.trim();
+        if (!trimmed)
+          return "";
+        try {
+          return _pathResolve(this._workingDirectory || process.cwd(), trimmed).replace(/\\/g, "/");
+        } catch {
+          return trimmed.replace(/\\/g, "/").replace(/^\.\/+/, "");
+        }
+      }
+      staleEditFamilyKey(toolName, pathKey, errorKind, targetHash, latestFileHash) {
+        return [
+          toolName,
+          pathKey || "(unknown)",
+          errorKind,
+          targetHash,
+          latestFileHash || "unknown-file-hash"
+        ].join(":");
       }
       staleEditPreflightBlock(toolName, args) {
         const target = this.staleEditTarget(toolName, args);
         if (!target)
           return null;
+        const pathKey = this.staleEditPathKey(target.path);
         for (const entry of this._staleEditFamilies.values()) {
-          if (entry.tool !== toolName || entry.path !== target.path || entry.targetHash !== target.targetHash)
+          if (entry.tool !== toolName || entry.pathKey !== pathKey || entry.targetHash !== target.targetHash)
             continue;
           const hasFreshRead = entry.lastReadTurn > entry.lastFailureTurn;
           const hasFreshMutation = entry.lastMutationTurn > entry.lastFailureTurn;
@@ -584569,23 +584780,65 @@ ${marker}` : marker);
         }
         return null;
       }
+      staleEditOverwritePreflightBlock(toolName, args) {
+        if (toolName !== "file_write")
+          return null;
+        if (process.env["OMNIUS_ALLOW_STALE_REPAIR_OVERWRITE"] === "1")
+          return null;
+        if (this.options.modelTier !== "small" && this.options.modelTier !== "medium")
+          return null;
+        if (args?.["dry_run"] === true || args?.["dryRun"] === true)
+          return null;
+        const path12 = this.extractPrimaryToolPath(args);
+        if (!path12)
+          return null;
+        const pathKey = this.staleEditPathKey(path12);
+        const active = [...this._staleEditFamilies.values()].filter((entry) => entry.pathKey === pathKey).sort((a2, b) => b.lastFailureTurn - a2.lastFailureTurn).find((entry) => {
+          const hasFreshRead = entry.lastReadTurn > entry.lastFailureTurn;
+          const hasFreshMutation = entry.lastMutationTurn > entry.lastFailureTurn;
+          return !hasFreshMutation && (entry.count >= 2 || !hasFreshRead);
+        });
+        if (!active)
+          return null;
+        return [
+          `[EDIT REPAIR LOCK] A recent narrow edit to ${active.path} failed because the model-visible target diverged from disk (${active.errorKind}; latest_file_hash=${active.latestFileHash || "unknown"}).`,
+          `This full-file overwrite was NOT executed. A stale narrow edit must not be repaired by broad file regeneration on ${this.options.modelTier ?? "unknown"} tier models.`,
+          ``,
+          `Allowed next actions:`,
+          `1. file_read ${active.path} once and construct file_edit from exact current text.`,
+          `2. file_patch/file_edit against the latest file hash or a different target.`,
+          `3. file_write with dry_run=true only to validate a full rewrite proposal without changing disk.`,
+          `4. run verification if the desired change is already present, or report the explicit blocker instead of completing.`,
+          ``,
+          `Stale target preview: ${active.preview}`
+        ].join("\n");
+      }
       noteStaleEditGuardOutcome(toolName, args, result, turn) {
         const path12 = this.extractPrimaryToolPath(args);
+        const pathKey = path12 ? this.staleEditPathKey(path12) : "";
         if (toolName === "file_read" && path12 && result.success) {
           for (const entry of this._staleEditFamilies.values()) {
-            if (entry.path === path12)
+            if (entry.pathKey === pathKey)
               entry.lastReadTurn = turn;
           }
           return;
         }
+        if (toolName === "file_write" && path12 && result.success && result.mutated !== false) {
+          for (const [key2, entry] of this._staleEditFamilies) {
+            if (entry.pathKey === pathKey)
+              this._staleEditFamilies.delete(key2);
+          }
+          return;
+        }
         if (!this.isEditToolName(toolName))
           return;
         const target = this.staleEditTarget(toolName, args);
         if (!target)
           return;
+        const targetPathKey = this.staleEditPathKey(target.path);
         if (result.success && result.mutated !== false) {
           for (const [key2, entry] of this._staleEditFamilies) {
-            if (entry.path === target.path)
+            if (entry.pathKey === targetPathKey)
               this._staleEditFamilies.delete(key2);
           }
           return;
@@ -584593,14 +584846,17 @@ ${marker}` : marker);
         const errorKind = this.classifyStaleEditFailure(toolName, result);
         if (!errorKind)
           return;
-        const key = this.staleEditFamilyKey(toolName, target.path, errorKind, target.targetHash);
+        const latestFileHash = typeof result.beforeHash === "string" && result.beforeHash.trim() ? result.beforeHash.trim() : typeof result.afterHash === "string" && result.afterHash.trim() ? result.afterHash.trim() : "unknown-file-hash";
+        const key = this.staleEditFamilyKey(toolName, targetPathKey, errorKind, target.targetHash, latestFileHash);
         const existing = this._staleEditFamilies.get(key);
         this._staleEditFamilies.set(key, {
           count: (existing?.count ?? 0) + 1,
           path: target.path,
+          pathKey: targetPathKey,
           tool: toolName,
           errorKind,
           targetHash: target.targetHash,
+          latestFileHash,
           lastFailureTurn: turn,
           lastReadTurn: existing?.lastReadTurn ?? -1,
           lastMutationTurn: existing?.lastMutationTurn ?? -1,
@@ -652150,7 +652406,7 @@ function getModelTier(modelName) {
   if (sizeMatch) {
     const size = parseInt(sizeMatch[1], 10);
     if (size >= 30) return "large";
-    if (size >= 8) return "medium";
+    if (size >= 14) return "medium";
     return "small";
   }
   if (/\b(small|mini|nano|tiny)\b/.test(m2)) return "small";
@@ -725784,6 +726040,7 @@ async function runCommand2(opts, config) {
       await runJson(opts.task, mergedConfig, opts.repoPath);
     } else {
       await runWithTUI(opts.task, mergedConfig, opts.repoPath);
+      if (shouldForceSingleRunExit()) process.exit(0);
     }
   } else {
     await startInteractive(mergedConfig, opts.repoPath);
@@ -725883,6 +726140,12 @@ function shouldForceJsonExit() {
     return false;
   return true;
 }
+function shouldForceSingleRunExit() {
+  if (process.env["OMNIUS_SINGLE_RUN_NO_FORCE_EXIT"] === "1") return false;
+  if (process.env["VITEST"] === "true" || process.env["NODE_ENV"] === "test")
+    return false;
+  return true;
+}
 function extractSummary(captured) {
   const all2 = captured.join("");
   const match = all2.match(/task_complete.*?summary[:\s]*["']?([^"'\n]+)/i);

package/npm-shrinkwrap.json

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

package/package.json

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