omnius 1.0.270 → 1.0.272

package/dist/index.js

@@ -546546,7 +546546,10 @@ var init_agent_tool = __esm({
           lines.push(prompt);
           return lines.join("\n");
         })();
-        if (isolation === "worktree") {
+        const fullDefault = process.env["OMNIUS_FULL_SUBAGENT_DEFAULT"] !== "0";
+        const workCapableType = subagentType === "general" || subagentType === "coordinator";
+        const routeToSubprocess = isolation === "worktree" || fullDefault && runInBackground && workCapableType;
+        if (routeToSubprocess) {
           this.callbacks.onViewRegister?.(agentId, label);
           const spawn35 = this.callbacks.spawnSubprocess({
             id: agentId,
@@ -555351,6 +555354,31 @@ var init_textSanitize = __esm({
   }
 });
 
+// packages/orchestrator/dist/permissionRuleset.js
+function checkDoomLoop(context2) {
+  const history = context2.toolCallHistory;
+  if (!history || history.length < 3)
+    return null;
+  const lastCall = history[history.length - 1];
+  const recent = history.slice(-4);
+  let identicalCount = 1;
+  for (let i2 = history.length - 2; i2 >= Math.max(0, history.length - 4); i2--) {
+    const prev = history[i2];
+    if (prev.tool === lastCall.tool && JSON.stringify(prev.args) === JSON.stringify(lastCall.args)) {
+      identicalCount++;
+    }
+  }
+  if (identicalCount >= 3) {
+    return "ask";
+  }
+  return null;
+}
+var init_permissionRuleset = __esm({
+  "packages/orchestrator/dist/permissionRuleset.js"() {
+    "use strict";
+  }
+});
+
 // packages/orchestrator/dist/completionContract.js
 function normalizeText(value2, max = 500) {
   const text2 = String(value2 ?? "").trim().replace(/\s+/g, " ");
@@ -564853,7 +564881,7 @@ RECOVERY: cd to the directory containing '${file}', run a plain install with no
 
 // packages/orchestrator/dist/agenticRunner.js
 import { existsSync as _fsExistsSync, readFileSync as _fsReadFileSync, writeFileSync as _fsWriteFileSync, appendFileSync as _fsAppendFileSync, unlinkSync as _fsUnlinkSync, mkdirSync as _fsMkdirSync } from "node:fs";
-import { execFile as _execFile } from "node:child_process";
+import { execFile as _execFile, spawn as _spawn } from "node:child_process";
 import { createHash as _createHash } from "node:crypto";
 import { join as _pathJoin, resolve as _pathResolve } from "node:path";
 import { tmpdir as _osTmpdir } from "node:os";
@@ -565337,6 +565365,7 @@ var init_agenticRunner = __esm({
   "packages/orchestrator/dist/agenticRunner.js"() {
     "use strict";
     init_textSanitize();
+    init_permissionRuleset();
     init_completionLedger();
     init_dist6();
     init_ollama_pool();
@@ -565686,6 +565715,10 @@ var init_agenticRunner = __esm({
       // post-implementation reviewer.
       _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.
+      _completionVerifyRejections = 0;
       _lastBackwardPassVerdict = null;
       _lastBackwardPassCritique = null;
       // Run-local completion contract inferred from the user's ask/context before
@@ -566057,6 +566090,7 @@ ${parts.join("\n")}
           allowTurnExtension: options2?.allowTurnExtension ?? true,
           completionProvenanceGuard: options2?.completionProvenanceGuard ?? true,
           backwardPassReview: options2?.backwardPassReview,
+          completionVerifyCommand: options2?.completionVerifyCommand,
           disableAdversaryCritic,
           disableStepCritic: disableAdversaryCritic,
           modelTier: options2?.modelTier ?? "large",
@@ -567322,7 +567356,114 @@ ${input.answerText ?? ""}`.toLowerCase().trim();
        * up auto-blocking and surfaces a status event so the caller can take
        * a different path (eg. surface to user). max cycles enforced here.
        */
+      /**
+       * Completion compile/verify gate (opt-in). Runs a configured shell command
+       * (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).
+       *
+       * Default OFF: unset command → `{ proceed: true }`, preserving the prior
+       * "no deterministic verification gate" behaviour for every existing caller.
+       */
+      async _runCompletionVerifyGate(turn) {
+        const cmd = this.options.completionVerifyCommand || process.env["OMNIUS_COMPLETION_VERIFY_CMD"] || "";
+        if (!cmd.trim())
+          return { proceed: true };
+        const changed = [...this._taskState.modifiedFiles.keys()];
+        const codeChanged = changed.some((p2) => /\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|kt|c|cc|cpp|h|hpp|swift|rb|php)$/i.test(p2));
+        if (!codeChanged)
+          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."
+          ].join("\n");
+          this.emit({
+            type: "status",
+            content: `completion verify gate exhausted after ${this._completionVerifyRejections} attempts; completing with caveat`,
+            turn,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return { proceed: true };
+        }
+        const timeoutMs = parseInt(process.env["OMNIUS_COMPLETION_VERIFY_TIMEOUT_MS"] || "180000", 10) || 18e4;
+        const wd = this._workingDirectory || process.cwd();
+        this.emit({
+          type: "status",
+          content: `completion verify gate: running '${cmd}' (cwd=${wd})`,
+          turn,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        const { exitCode, outTail } = await new Promise((resolve70) => {
+          const chunks = [];
+          let settled = false;
+          const child = _spawn(cmd, {
+            cwd: wd,
+            shell: true,
+            env: process.env,
+            stdio: ["ignore", "pipe", "pipe"]
+          });
+          const onData = (d2) => {
+            chunks.push(d2.toString());
+            if (chunks.length > 400)
+              chunks.splice(0, chunks.length - 400);
+          };
+          child.stdout?.on("data", onData);
+          child.stderr?.on("data", onData);
+          const killTimer = setTimeout(() => {
+            try {
+              child.kill("SIGKILL");
+            } catch {
+            }
+          }, timeoutMs);
+          killTimer.unref?.();
+          const finish = (code8) => {
+            if (settled)
+              return;
+            settled = true;
+            clearTimeout(killTimer);
+            resolve70({ exitCode: code8, outTail: chunks.join("").slice(-4e3) });
+          };
+          child.on("error", () => finish(1));
+          child.on("close", (code8) => finish(code8 ?? 1));
+        });
+        if (exitCode === 0) {
+          this.emit({
+            type: "status",
+            content: `completion verify gate PASSED ('${cmd}')`,
+            turn,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return { proceed: true };
+        }
+        this._completionVerifyRejections++;
+        this.emit({
+          type: "status",
+          content: `completion verify gate FAILED (exit ${exitCode}); task_complete blocked (attempt ${this._completionVerifyRejections}/${maxRejections})`,
+          turn,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        const feedback = [
+          `[COMPLETION BLOCKED — verification failed] You modified code, but the verify command exited ${exitCode}:`,
+          `  $ ${cmd}`,
+          "",
+          "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)`,
+          "",
+          "--- verify output (tail) ---",
+          outTail || "(no output captured)"
+        ].join("\n");
+        return { proceed: false, feedback };
+      }
       async _runBackwardPassReview(turn, toolCallLog, proposedSummary = "") {
+        const _verify = await this._runCompletionVerifyGate(turn);
+        if (!_verify.proceed)
+          return _verify;
         if (this._completionLedger && proposedSummary) {
           const _newClaims = deriveClaimsFromProposedText({
             text: proposedSummary,
@@ -567832,10 +567973,12 @@ ${body}`;
               }
               const prior = seen.get(fp);
               if (prior) {
+                const priorContent = typeof messages2[prior.idx]?.content === "string" ? messages2[prior.idx].content : "";
+                const priorFailed = ERROR_MARKERS.test(priorContent);
                 pending2.push({
                   idx: prior.idx,
                   reason: "dedupe",
-                  replacement: `${DEDUPE_PREFIX} ${scanTurn} — duplicate ${name10}() call]`
+                  replacement: priorFailed ? `${DEDUPE_PREFIX} ${scanTurn} — duplicate ${name10}() call; the earlier call FAILED (same error as the retained copy below). Do not retry identically.]` : `${DEDUPE_PREFIX} ${scanTurn} — duplicate ${name10}() call]`
                 });
                 seen.set(fp, { turn: scanTurn, idx: resultIdx });
                 continue;
@@ -567847,10 +567990,11 @@ ${body}`;
                 if (priorResource && priorResource.idx !== resultIdx) {
                   const priorContent = typeof messages2[priorResource.idx]?.content === "string" ? messages2[priorResource.idx].content : "";
                   if (!priorContent.startsWith(PRUNE_PREFIX) && !priorContent.startsWith(DEDUPE_PREFIX) && !priorContent.startsWith(FILE_AGED_PREFIX)) {
+                    const priorResFailed = ERROR_MARKERS.test(priorContent);
                     pending2.push({
                       idx: priorResource.idx,
                       reason: "dedupe",
-                      replacement: `${DEDUPE_PREFIX} ${scanTurn} — semantic duplicate ${name10}() (same resource: ${rkey})]`
+                      replacement: priorResFailed ? `${DEDUPE_PREFIX} ${scanTurn} — semantic duplicate ${name10}() (same resource: ${rkey}); the earlier call FAILED. Do not retry identically.]` : `${DEDUPE_PREFIX} ${scanTurn} — semantic duplicate ${name10}() (same resource: ${rkey})]`
                     });
                   }
                 }
@@ -570164,6 +570308,7 @@ Respond with your assessment, then take action.`;
         this._abortController = new AbortController();
         this._fileWritesThisRun = 0;
         this._backwardPassCyclesUsed = 0;
+        this._completionVerifyRejections = 0;
         this._lastBackwardPassVerdict = null;
         this._lastBackwardPassCritique = null;
         this._completionContract = null;
@@ -572790,6 +572935,44 @@ Corrective action: try a different approach first: read relevant files, adjust a
                 timestampMs: Date.now()
               });
               const _toolLogTailIdx = toolCallLog.length - 1;
+              if (tc.name !== "task_complete") {
+                const doomHistory = toolCallLog.slice(-5).map((e2) => ({ tool: e2.name, args: e2.argsKey }));
+                doomHistory.push({
+                  tool: tc.name,
+                  args: this._buildExactArgsKey(tc.arguments ?? {})
+                });
+                const doom = checkDoomLoop({
+                  permission: tc.name,
+                  target: "",
+                  toolCallHistory: doomHistory
+                });
+                if (doom === "ask" && cohort && cohort.failure >= 3 && cohort.success === 0) {
+                  const stopMsg = `[blocked: doom-loop] '${tc.name}' has been called with identical arguments 3+ times and has failed every time. This exact call was NOT executed. Stop repeating it. Choose ONE: (a) change the arguments or approach, (b) read/inspect to understand why it fails, or (c) if genuinely blocked, call task_complete and state the blocker plainly.`;
+                  this.emit({
+                    type: "tool_call",
+                    toolName: tc.name,
+                    toolArgs: tc.arguments,
+                    turn,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
+                  const lastLog = toolCallLog[_toolLogTailIdx];
+                  if (lastLog) {
+                    lastLog.success = false;
+                    lastLog.mutated = false;
+                    lastLog.mutatedFiles = [];
+                    lastLog.outputPreview = stopMsg.slice(0, 100);
+                  }
+                  this.emit({
+                    type: "tool_result",
+                    toolName: tc.name,
+                    success: false,
+                    content: stopMsg.slice(0, 200),
+                    turn,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
+                  return { tc, output: stopMsg, success: false };
+                }
+              }
               if (editFeedbackRequiredBeforeMoreEdits && this._isProjectEditTool(tc.name)) {
                 this.emit({
                   type: "tool_call",
@@ -573971,8 +574154,23 @@ Respond with EXACTLY this structure before your next tool call:
                 }
               }
               const isFileMutation = realFileMutation;
-              if (isFileMutation && dedupHitCount.size > 0) {
-                dedupHitCount.clear();
+              if (isFileMutation) {
+                if (realMutationPaths.length > 0) {
+                  for (const mp of realMutationPaths) {
+                    if (!mp)
+                      continue;
+                    for (const key of Array.from(dedupHitCount.keys())) {
+                      if (key.includes(mp))
+                        dedupHitCount.delete(key);
+                    }
+                    for (const key of Array.from(recentToolResults.keys())) {
+                      if (key.includes(mp))
+                        recentToolResults.delete(key);
+                    }
+                  }
+                } else if (dedupHitCount.size > 0) {
+                  dedupHitCount.clear();
+                }
               }
               if (isFileMutation && recentToolResults.size > 0) {
                 for (const key of Array.from(recentToolResults.keys())) {
@@ -602335,7 +602533,7 @@ var init_call_agent = __esm({
       }
       /** Initialize the runner with appropriate tools for the access tier */
       async init() {
-        const backend = new OllamaAgenticBackend(this.config.backendUrl, this.config.model, this.config.apiKey);
+        const backend = new OllamaAgenticBackend(this.config.backendUrl, this.config.model, this.config.apiKey, false);
         this.backend = backend;
         const feed = getActivityFeed();
         const systemPrompt = this.buildSystemPrompt();
@@ -609025,15 +609223,10 @@ ${CONTENT_BG_SEQ}`);
       copySessionToClipboard() {
         const lines = this._contentLines;
         if (!lines || lines.length === 0) return;
-        const offset = this._contentScrollOffset;
-        const visible = this.contentHeight;
-        const startIdx = Math.max(0, offset);
-        const endIdx = Math.min(lines.length, startIdx + visible);
-        const visibleLines = lines.slice(startIdx, endIdx);
-        const stripped = visibleLines.map(
+        const stripped = lines.map(
           (line) => line.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "").replace(/\x1B\]?[^\x07]*\x07/g, "")
         );
-        const text2 = stripped.join("\n");
+        const text2 = stripped.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd();
         if (text2.length === 0) return;
         const ok3 = copyText(text2);
         const pos = this.rowPositions(termRows());
@@ -705646,7 +705839,13 @@ Review its full output via sub_agent(action='output', id='${id}')`
             backend = new OllamaAgenticBackend(
               config.backendUrl,
               opts.model,
-              config.apiKey
+              config.apiKey,
+              // Sub-agents: force thinking OFF explicitly. Thinking models
+              // interleave <think> blocks that corrupt tool-call parsing for
+              // Qwen/Ollama. Relying on the constructor default is fragile
+              // (breaks if OMNIUS_ENABLE_THINKING=1 is inherited); pass false
+              // so sub-agent tool loops are always clean.
+              false
             );
           }
           const subTier = getModelTier(opts.model);
@@ -705683,6 +705882,10 @@ Review its full output via sub_agent(action='output', id='${id}')`
             `Sub-agent ${subAgentId}`,
             "sub"
           );
+          subRunner.onEvent((event) => {
+            const line = formatSubAgentEventForView(event);
+            if (line) statusBar.writeToAgentView(subAgentId, line);
+          });
           subRunner.registerTool(
             createTaskCompleteTool(subTier, repoRoot, true)
           );
@@ -705725,11 +705928,21 @@ ${result.summary}`
           };
         },
         spawnSubprocess: (opts) => {
-          const entry = spawnFullSubAgent(opts.task, {
-            model: opts.model,
-            backendUrl: config.backendUrl,
-            workingDir: opts.workingDir
-          });
+          const entry = spawnFullSubAgent(
+            opts.task,
+            {
+              model: opts.model,
+              backendUrl: config.backendUrl,
+              workingDir: opts.workingDir
+            },
+            // Stream the full sub-agent's stdout into its toolbar view so the
+            // clickable tab shows live output instead of staying empty.
+            (text2) => statusBar.writeToAgentView(opts.id, text2),
+            (id, exitCode) => statusBar.updateAgentViewStatus(
+              opts.id,
+              exitCode === 0 ? "completed" : "failed"
+            )
+          );
           return { id: entry.id, pid: entry.pid ?? 0 };
         },
         trackTask: (id, promise) => {

package/npm-shrinkwrap.json

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

package/package.json

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