omnius 1.0.376 → 1.0.377

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}`;
@@ -578285,6 +578305,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 +580589,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 +581575,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;
@@ -584544,15 +584604,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 +584646,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 +584712,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 +652272,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 +725906,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 +726006,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.377",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.376",
+      "version": "1.0.377",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

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