omnius 1.0.535 → 1.0.536

package/dist/index.js

@@ -567114,13 +567114,103 @@ function normalizeShellCommand(command) {
 function splitConjunctiveVerifyCommand(command) {
   return normalizeShellCommand(command).split(/\s+&&\s+/).map((part) => part.trim()).filter(Boolean);
 }
+function stripVerifierFallbackSuffix(command) {
+  let quote2 = null;
+  for (let i2 = 0; i2 < command.length - 1; i2++) {
+    const ch = command[i2];
+    if (quote2) {
+      if (ch === quote2 && command[i2 - 1] !== "\\")
+        quote2 = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote2 = ch;
+      continue;
+    }
+    if (ch === "|" && command[i2 + 1] === "|") {
+      return command.slice(0, i2).trim();
+    }
+  }
+  return command.trim();
+}
+function stageHeadProgram(stage2) {
+  const tokens = stage2.trim().split(/\s+/);
+  let i2 = 0;
+  while (i2 < tokens.length) {
+    const token = tokens[i2];
+    if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(token)) {
+      i2++;
+      continue;
+    }
+    const base3 = token.replace(/^["']|["']$/g, "").split("/").pop() ?? token;
+    if (STAGE_PREFIX_PROGRAMS.has(base3)) {
+      i2++;
+      if (base3 === "timeout" && /^[0-9]+[smhd]?$/.test(tokens[i2] ?? ""))
+        i2++;
+      continue;
+    }
+    return base3.toLowerCase();
+  }
+  return null;
+}
+function commandIsPureReadOnlyPipeline(command) {
+  const stages = [];
+  let current = "";
+  let quote2 = null;
+  const raw = command.trim();
+  if (!raw)
+    return false;
+  for (let i2 = 0; i2 < raw.length; i2++) {
+    const ch = raw[i2];
+    if (quote2) {
+      current += ch;
+      if (ch === quote2 && raw[i2 - 1] !== "\\")
+        quote2 = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote2 = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === "&" && raw[i2 + 1] === "&") {
+      stages.push(current);
+      current = "";
+      i2++;
+      continue;
+    }
+    if (ch === "|") {
+      stages.push(current);
+      current = "";
+      if (raw[i2 + 1] === "|")
+        i2++;
+      continue;
+    }
+    if (ch === ";") {
+      stages.push(current);
+      current = "";
+      continue;
+    }
+    if (ch === "$" && raw[i2 + 1] === "(")
+      return false;
+    if (ch === "`")
+      return false;
+    current += ch;
+  }
+  stages.push(current);
+  const meaningful = stages.map((s2) => s2.trim()).filter(Boolean);
+  if (meaningful.length === 0)
+    return false;
+  return meaningful.every((stage2) => {
+    const head = stageHeadProgram(stage2);
+    return head !== null && PURE_READER_PROGRAMS.has(head);
+  });
+}
 function commandReliablySatisfiesVerifyCommand(observedCommand, verifyCommand) {
   const observed = normalizeShellCommand(observedCommand);
-  const expected = normalizeShellCommand(verifyCommand);
+  const expected = normalizeShellCommand(stripVerifierFallbackSuffix(verifyCommand));
   if (!observed || !expected)
     return false;
-  if (expected.includes(" || "))
-    return false;
   if (observed === expected)
     return true;
   if (observed.startsWith(`${expected} && `) && !observed.includes(" || ")) {
@@ -567141,9 +567231,93 @@ function verifyCommandSatisfiedByShellHistory(verifyCommand, history) {
     return false;
   return parts.every((part) => successful.some((entry) => commandReliablySatisfiesVerifyCommand(entry.command, part)));
 }
+var PURE_READER_PROGRAMS, STAGE_PREFIX_PROGRAMS;
 var init_verificationCommand = __esm({
   "packages/orchestrator/dist/verificationCommand.js"() {
     "use strict";
+    PURE_READER_PROGRAMS = /* @__PURE__ */ new Set([
+      "cat",
+      "tac",
+      "tail",
+      "head",
+      "less",
+      "more",
+      "grep",
+      "egrep",
+      "fgrep",
+      "rg",
+      "ag",
+      "awk",
+      "gawk",
+      "sed",
+      "gsed",
+      "sort",
+      "uniq",
+      "wc",
+      "cut",
+      "tr",
+      "column",
+      "echo",
+      "printf",
+      "ls",
+      "dir",
+      "find",
+      "fd",
+      "stat",
+      "file",
+      "strings",
+      "hexdump",
+      "xxd",
+      "od",
+      "jq",
+      "yq",
+      "tee",
+      "dirname",
+      "basename",
+      "readlink",
+      "realpath",
+      "pwd",
+      "date",
+      "true",
+      "false",
+      "test",
+      "type",
+      "which",
+      "whoami",
+      "env",
+      "printenv",
+      "sleep",
+      "cd",
+      "diff",
+      "cmp",
+      "md5sum",
+      "sha1sum",
+      "sha256sum",
+      "du",
+      "df",
+      "nl",
+      "paste",
+      "join",
+      "comm",
+      "expand",
+      "unexpand",
+      "fold",
+      "rev",
+      "seq",
+      "xargs"
+    ]);
+    STAGE_PREFIX_PROGRAMS = /* @__PURE__ */ new Set([
+      "sudo",
+      "command",
+      "builtin",
+      "nice",
+      "ionice",
+      "time",
+      "timeout",
+      "nohup",
+      "stdbuf",
+      "unbuffer"
+    ]);
   }
 });
 
@@ -589283,8 +589457,9 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
           return this._declaredVerifierCommand;
         }
         const diagnostics = parseCompilerDiagnostics(output);
-        if (diagnostics.length > 0 && this._shellResultLooksLikeVerification({ command: trimmed }, { success: false, output })) {
-          return trimmed;
+        if (diagnostics.length > 0 && !commandIsPureReadOnlyPipeline(trimmed)) {
+          const latched = stripVerifierFallbackSuffix(trimmed);
+          return latched || trimmed;
         }
         return null;
       }
@@ -589294,19 +589469,68 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
           return false;
         return commandReliablySatisfiesVerifyCommand(command.trim(), state.verifierCommand);
       }
+      /**
+       * When a tool result was triaged for size (full payload saved to
+       * `.omnius/tool-results/<hash>.txt`), append the saved payload so
+       * diagnostics parsing sees the complete output. Without this, a large
+       * failed build's `file:line:col: error:` lines can be cut out of the
+       * triage envelope and the run never registers as a verifier run.
+       * Best effort and bounded — never throws into the loop.
+       */
+      _expandTriagedPayloadForDiagnostics(text2) {
+        if (!text2 || !text2.includes(TRIAGE_SAVED_PATH_MARKER))
+          return text2;
+        const MAX_PAYLOAD_BYTES = 1e6;
+        const MAX_FILES2 = 2;
+        const extras = [];
+        let searchFrom = 0;
+        for (let i2 = 0; i2 < MAX_FILES2; i2++) {
+          const markerAt = text2.indexOf(TRIAGE_SAVED_PATH_MARKER, searchFrom);
+          if (markerAt === -1)
+            break;
+          const pathStart = markerAt + TRIAGE_SAVED_PATH_MARKER.length;
+          const restOfLine = text2.slice(pathStart, text2.indexOf("\n", pathStart) === -1 ? void 0 : text2.indexOf("\n", pathStart));
+          searchFrom = pathStart;
+          const endIdx = (() => {
+            const emDash = restOfLine.indexOf(" — ");
+            if (emDash !== -1)
+              return emDash;
+            const bracket = restOfLine.indexOf("]");
+            return bracket !== -1 ? bracket : restOfLine.length;
+          })();
+          const savedPath = restOfLine.slice(0, endIdx).trim();
+          if (!savedPath)
+            continue;
+          try {
+            if (!_fsExistsSync(savedPath))
+              continue;
+            const stat9 = _fsStatSync(savedPath);
+            if (!stat9.isFile())
+              continue;
+            const raw = _fsReadFileSync(savedPath, "utf8");
+            extras.push(raw.length > MAX_PAYLOAD_BYTES ? raw.slice(0, MAX_PAYLOAD_BYTES) : raw);
+          } catch {
+          }
+        }
+        if (extras.length === 0)
+          return text2;
+        return `${text2}
+${extras.join("\n")}`;
+      }
       _observeCompileVerifierResult(input) {
         const diagnostics = rankCompilerDiagnostics(parseCompilerDiagnostics(input.output));
+        const verifierCommand = stripVerifierFallbackSuffix(input.verifierCommand) || input.verifierCommand.trim();
         const previousDiagnostics = this._lastDeclaredVerifierDiagnostics;
-        this._declaredVerifierCommand = input.verifierCommand;
+        this._declaredVerifierCommand = verifierCommand;
         this._lastDeclaredVerifierOutput = input.output;
         this._lastDeclaredVerifierDiagnostics = diagnostics;
         if (!this._compileFixLoop && diagnostics.length === 0)
           return null;
-        const verifierFingerprint = compileFixVerifierFingerprint(input.verifierCommand);
+        const verifierFingerprint = compileFixVerifierFingerprint(verifierCommand);
         const existingCards = this._compileFixLoop?.cards ?? [];
         const cards = diagnostics.length > 0 ? buildCompileFixCards({
           diagnostics,
-          verifierCommand: input.verifierCommand,
+          verifierCommand,
           turn: input.turn,
           existingCards
         }) : existingCards;
@@ -589315,22 +589539,25 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
           existingCards,
           observedCards: cards,
           diagnostics,
-          verifierCommand: input.verifierCommand,
+          verifierCommand,
           turn: input.turn,
           verifierPassed: input.success && diagnostics.length === 0
         });
         this._compileFixLoop = {
           active: diagnostics.length > 0 || nextCards.some((card) => card.status !== "verified"),
-          verifierCommand: input.verifierCommand,
+          verifierCommand,
           verifierFingerprint,
           verifierDirtySinceTurn: null,
           lastVerifierRunTurn: input.turn,
           lastVerifierPassedTurn: input.success && diagnostics.length === 0 ? input.turn : null,
           lastMutationTurn: this._compileFixLoop?.lastMutationTurn ?? null,
-          cards: nextCards
+          cards: nextCards,
+          // A live verifier run resolves the gate's demand — the block streak
+          // is over regardless of pass/fail.
+          preflightBlockStreak: 0
         };
         this._mirrorCompileFixCardsToWorkboard(nextCards, {
-          command: input.verifierCommand,
+          command: verifierCommand,
           success: input.success && diagnostics.length === 0,
           turn: input.turn,
           beforeDiagnosticCount: previousDiagnostics.length,
@@ -589342,7 +589569,7 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
         if (input.success && diagnostics.length === 0) {
           this.emit({
             type: "status",
-            content: `compile_error_fix_loop: verifier passed (${input.verifierCommand}); compile cards verified`,
+            content: `compile_error_fix_loop: verifier passed (${verifierCommand}); compile cards verified`,
             turn: input.turn,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
@@ -589361,7 +589588,7 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
         }
         this.emit({
           type: "status",
-          content: `compile_error_fix_loop_started: verifierCommand=${input.verifierCommand}; cardId=${top.id}; diagnosticFingerprint=${top.diagnostic.fingerprint}; afterDiagnosticCount=${diagnostics.length}`,
+          content: `compile_error_fix_loop_started: verifierCommand=${verifierCommand}; cardId=${top.id}; diagnosticFingerprint=${top.diagnostic.fingerprint}; afterDiagnosticCount=${diagnostics.length}`,
           turn: input.turn,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
@@ -589561,14 +589788,7 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
         if (!state?.active)
           return;
         const normalized = paths.map((p2) => this._normalizeEvidencePath(p2)).filter(Boolean);
-        const owned = state.cards.flatMap((card) => card.ownedFiles);
-        const todos = this.readSessionTodos() || [];
-        const artifacts = todos.flatMap((todo) => Array.isArray(todo.declaredArtifacts) ? todo.declaredArtifacts.filter((p2) => typeof p2 === "string") : []);
-        const relevant = normalized.length === 0 || normalized.some((pathValue) => {
-          if (pathValue.startsWith(".omnius/"))
-            return false;
-          return owned.some((ownedPath) => this._pathsOverlapForVerifier(pathValue, ownedPath)) || artifacts.some((artifactPath) => this._pathsOverlapForVerifier(pathValue, artifactPath)) || /\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|kt|c|cc|cpp|cxx|h|hpp|hh|hxx|ino)$/i.test(pathValue);
-        });
+        const relevant = normalized.length === 0 || this._compileFixPathsTouchProjectSources(normalized, state);
         if (!relevant)
           return;
         state.verifierDirtySinceTurn = turn;
@@ -589595,6 +589815,24 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
       }
+      /**
+       * True when any of the given normalized paths touches project source:
+       * files owned by compile-fix cards, declared todo artifacts, or files
+       * with a source-code extension. Build side effects (logs, artifacts,
+       * `.omnius/` bookkeeping) do not count.
+       */
+      _compileFixPathsTouchProjectSources(normalizedPaths, state) {
+        const owned = state.cards.flatMap((card) => card.ownedFiles);
+        const todos = this.readSessionTodos() || [];
+        const artifacts = todos.flatMap((todo) => Array.isArray(todo.declaredArtifacts) ? todo.declaredArtifacts.filter((p2) => typeof p2 === "string") : []);
+        return normalizedPaths.some((pathValue) => {
+          if (pathValue.startsWith(".omnius/"))
+            return false;
+          return owned.some((ownedPath) => this._pathsOverlapForVerifier(pathValue, ownedPath)) || artifacts.some((artifactPath) => this._pathsOverlapForVerifier(pathValue, artifactPath)) || /\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|kt|c|cc|cpp|cxx|h|hpp|hh|hxx|ino)$/i.test(pathValue);
+        });
+      }
+      /** Consecutive preflight blocks before the gate yields instead of blocking. */
+      static COMPILE_FIX_GATE_YIELD_AFTER = 3;
       _compileFixLoopPreflightBlock(toolName, args, turn, shellLikelyMutatesFilesystem) {
         const state = this._compileFixLoop;
         if (!state?.active)
@@ -589605,29 +589843,62 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
         if (toolName === "shell") {
           const command = String(args["command"] ?? args["cmd"] ?? "").trim();
           if (commandReliablySatisfiesVerifyCommand(command, state.verifierCommand)) {
+            state.preflightBlockStreak = 0;
             return null;
           }
           if (!shellLikelyMutatesFilesystem)
             return null;
+          const extraction = extractShellMutationPaths(command, {
+            workingDir: this.authoritativeWorkingDirectory()
+          });
+          const mutationPaths = extraction.paths.map((p2) => this._normalizeEvidencePath(p2)).filter(Boolean);
+          if (mutationPaths.length === 0 || !this._compileFixPathsTouchProjectSources(mutationPaths, state)) {
+            return null;
+          }
         } else if (!this._isProjectEditTool(toolName)) {
           return null;
         }
+        const yieldAfter = _AgenticRunner.COMPILE_FIX_GATE_YIELD_AFTER;
+        const streak = (state.preflightBlockStreak ?? 0) + 1;
+        if (streak > yieldAfter) {
+          state.preflightBlockStreak = 0;
+          this.emit({
+            type: "status",
+            content: `compile_error_verifier_dirty: gate yielded to ${toolName} after ${yieldAfter} consecutive blocks at turn ${turn}`,
+            turn,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return {
+            kind: "yield",
+            notice: [
+              `[COMPILE FIX GATE YIELDED — verifier still required]`,
+              `The verifier-required gate blocked ${yieldAfter} consecutive tool calls and is yielding so work can continue.`,
+              `Verifier evidence is still stale. Run the verifier as your next evidence step:`,
+              `  ${state.verifierCommand}`,
+              `Any real build/test command whose output shows current compiler diagnostics is also accepted as the live verifier.`,
+              `task_complete remains blocked until a verifier run passes after the last mutation.`
+            ].join("\n")
+          };
+        }
+        state.preflightBlockStreak = streak;
         const message2 = [
           `[COMPILE ERROR FIX LOOP BLOCKED — declared verifier required]`,
           `A compile-fix card was patched, so the next mutation/evidence step must be the live verifier.`,
-          `verifierCommand: ${state.verifierCommand}`,
+          `Run this now: ${state.verifierCommand}`,
+          `Any real build/test command whose output shows current compiler diagnostics is also accepted.`,
           `dirtySinceTurn: ${state.verifierDirtySinceTurn}`,
           `lastMutationTurn: ${state.lastMutationTurn}`,
           `lastVerifierRunTurn: ${state.lastVerifierRunTurn}`,
-          `blockedTool: ${toolName}`
+          `blockedTool: ${toolName}`,
+          `consecutiveBlocks: ${streak}/${yieldAfter} (gate yields after ${yieldAfter})`
         ].join("\n");
         this.emit({
           type: "status",
-          content: `compile_error_verifier_dirty: blocked ${toolName} at turn ${turn}`,
+          content: `compile_error_verifier_dirty: blocked ${toolName} at turn ${turn} (${streak}/${yieldAfter})`,
           turn,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
-        return message2;
+        return { kind: "block", message: message2 };
       }
       _compileFixLoopCompletionBlocker(turn) {
         const state = this._compileFixLoop;
@@ -589985,6 +590256,8 @@ ${modelVisible}` : modelVisible || result.error || displayOutput || "";
         if (!command.trim())
           return false;
         void result;
+        if (commandIsPureReadOnlyPipeline(command))
+          return false;
         return /\b(test|tests|vitest|jest|pytest|go test|cargo test|npm test|pnpm test|yarn test|typecheck|tsc|build|verify|verification|check)\b/i.test(command);
       }
       _shouldSuppressCompletionDiscoveryEvidence(toolName, result, targetPaths) {
@@ -598420,8 +598693,10 @@ ${cachedResult}`,
                   };
                 }
               }
-              const compileLoopPreflightBlock = !repeatShortCircuit ? this._compileFixLoopPreflightBlock(tc.name, tc.arguments ?? {}, turn, shellLikelyMutatesFilesystem) : null;
-              if (compileLoopPreflightBlock) {
+              const compileLoopPreflight = !repeatShortCircuit ? this._compileFixLoopPreflightBlock(tc.name, tc.arguments ?? {}, turn, shellLikelyMutatesFilesystem) : null;
+              if (compileLoopPreflight?.kind === "yield") {
+                pushSoftInjection("system", compileLoopPreflight.notice);
+              } else if (compileLoopPreflight) {
                 this.emit({
                   type: "tool_call",
                   toolName: tc.name,
@@ -598433,7 +598708,7 @@ ${cachedResult}`,
                   type: "tool_result",
                   toolName: tc.name,
                   success: false,
-                  content: compileLoopPreflightBlock.slice(0, 120),
+                  content: compileLoopPreflight.message.slice(0, 120),
                   turn,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
@@ -598443,9 +598718,9 @@ ${cachedResult}`,
                 });
                 return {
                   tc,
-                  output: compileLoopPreflightBlock,
+                  output: compileLoopPreflight.message,
                   success: false,
-                  systemGuidance: compileLoopPreflightBlock
+                  systemGuidance: compileLoopPreflight.message
                 };
               }
               this.emit({
@@ -600037,8 +600312,7 @@ ${structuralGuardGuidance}` : structuralGuardGuidance;
               }
               if (tc.name === "shell" && result.runtimeAuthored !== true) {
                 const shellCommand = String(tc.arguments?.["command"] ?? tc.arguments?.["cmd"] ?? "");
-                const compileOutput = `${result.output ?? ""}
-${result.error ?? ""}`;
+                const compileOutput = this._expandTriagedPayloadForDiagnostics([result.output, result.llmContent, result.error].filter((part) => typeof part === "string" && part.length > 0).join("\n"));
                 const verifierCommand = this._declaredVerifierCommandForShell(shellCommand, compileOutput);
                 if (verifierCommand) {
                   const compileGuidance = this._observeCompileVerifierResult({

package/npm-shrinkwrap.json

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

package/package.json

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