omnius 1.0.444 → 1.0.445

package/dist/index.js

@@ -298591,13 +298591,29 @@ Mark tasks complete IMMEDIATELY after finishing — don't batch. Never mark comp
               durationMs: performance.now() - start2
             };
           }
+          const inProgressIndexes = incoming.map((todo, index) => todo.status === "in_progress" ? index : -1).filter((index) => index >= 0);
+          if (inProgressIndexes.length === 0) {
+            const firstPending = incoming.findIndex((todo) => todo.status === "pending");
+            if (firstPending >= 0) {
+              incoming[firstPending] = { ...incoming[firstPending], status: "in_progress" };
+              repairNotes.push("promoted first pending todo to in_progress because a non-empty active checklist must name the current task");
+            }
+          } else if (inProgressIndexes.length > 1) {
+            const keep = inProgressIndexes[0];
+            for (const index of inProgressIndexes.slice(1)) {
+              incoming[index] = { ...incoming[index], status: "pending" };
+            }
+            repairNotes.push(`kept todo ${keep + 1} in_progress and demoted extra in_progress todos to pending`);
+          }
           const sessionId = typeof args["session_id"] === "string" && args["session_id"].trim() ? args["session_id"].trim() : typeof args["sessionId"] === "string" && args["sessionId"].trim() ? args["sessionId"].trim() : getTodoSessionId();
           const oldTodos = readTodos(sessionId);
           const canonicalize2 = (todos) => JSON.stringify(todos.map((t2) => ({
             content: t2.content,
             status: t2.status,
             parentId: t2.parentId ?? null,
-            blocker: t2.blocker ?? null
+            blocker: t2.blocker ?? null,
+            verifyCommand: t2.verifyCommand ?? null,
+            declaredArtifacts: Array.isArray(t2.declaredArtifacts) ? [...t2.declaredArtifacts].sort() : null
           })));
           const oldKey = canonicalize2(oldTodos);
           const newKey = canonicalize2(incoming);
@@ -298607,8 +298623,10 @@ Mark tasks complete IMMEDIATELY after finishing — don't batch. Never mark comp
               output: JSON.stringify({
                 reminder: "[NO-OP] You called todo_write with the same plan you already have. The list is unchanged. Use todo_write ONLY to add new tasks, mark a task in_progress / completed, or record a blocker — not as a way to re-read your plan (use todo_read for that, but the current plan is also surfaced automatically in your context). Proceed with the current in_progress task.",
                 todos: oldTodos,
-                noop: true
+                noop: true,
+                noProgress: true
               }),
+              noop: true,
               durationMs: performance.now() - start2
             };
           }
@@ -572729,6 +572747,7 @@ var init_context_fabric = __esm({
     "use strict";
     PRIORITY = {
       GOAL: 100,
+      ACTION_CONTRACT: 98,
       USER_STEERING: 95,
       TASK_STATE: 80,
       KNOWN_FILES: 70,
@@ -572746,6 +572765,7 @@ var init_context_fabric = __esm({
     KIND_ORDER = [
       "goal",
       "user_steering",
+      "action_contract",
       "task_state",
       "known_files",
       "recent_failure",
@@ -572762,6 +572782,7 @@ var init_context_fabric = __esm({
     KIND_LABELS = {
       goal: "Goal",
       user_steering: "User Steering",
+      action_contract: "Next Action Contract",
       task_state: "Task State",
       known_files: "Known Files",
       recent_failure: "Recent Failures",
@@ -572778,6 +572799,7 @@ var init_context_fabric = __esm({
     DEFAULT_KIND_CHAR_BUDGET = {
       goal: 900,
       user_steering: 1400,
+      action_contract: 1800,
       task_state: 1800,
       known_files: 2400,
       recent_failure: 2600,
@@ -574715,6 +574737,11 @@ var init_focusSupervisor = __esm({
           return;
         }
         if (input.toolName === "todo_write" && input.success) {
+          if (input.noop) {
+            this.lastDecision = "todo_noop_not_satisfied";
+            this.lastReason = "todo_write returned no-op; checklist state did not change";
+            return;
+          }
           this.clearSatisfiedDirective("todo plan updated", input.turn);
           return;
         }
@@ -578304,6 +578331,220 @@ ${parts.join("\n")}
         }
         return null;
       }
+      _currentWorkboardSnapshotForFrame() {
+        const dir = this._workboardDir();
+        const fromDisk = readActiveWorkboardSnapshot(dir, this._sessionId);
+        if (fromDisk) {
+          this._workboard = fromDisk;
+          return fromDisk;
+        }
+        if (this._workboard)
+          return this._workboard;
+        const goal = this._taskState.originalGoal || this._taskState.goal || "";
+        if (this._initialWorkboardCardsForGoal(goal).length === 0)
+          return null;
+        return this.getOrCreateWorkboard();
+      }
+      _workboardEvidenceCount(card) {
+        return card?.evidence?.length ?? 0;
+      }
+      _workboardHasEditEvidence(card) {
+        if (!card)
+          return false;
+        const editTools = /* @__PURE__ */ new Set(["file_write", "file_edit", "batch_edit", "file_patch"]);
+        return card.evidence.some((e2) => typeof e2.tool === "string" && editTools.has(e2.tool));
+      }
+      _workboardHasVerificationEvidence(card) {
+        if (!card)
+          return false;
+        return card.evidence.some((e2) => e2.tool === "shell" || e2.tool === "background_run");
+      }
+      _deriveWorkboardActionContract(snapshot) {
+        if (snapshot.cards.length === 0)
+          return null;
+        const byId = new Map(snapshot.cards.map((card) => [card.id, card]));
+        const discovery = byId.get("discover-current-state");
+        const implementation2 = byId.get("implement-repair");
+        const integration = byId.get("integrate-and-run");
+        const verification = byId.get("verify-observed-outcome");
+        const discoveryEvidence = this._workboardEvidenceCount(discovery);
+        const hasImplementationEvidence = this._workboardHasEditEvidence(implementation2);
+        const hasVerificationEvidence = this._workboardHasVerificationEvidence(integration);
+        if (hasImplementationEvidence && !hasVerificationEvidence && integration) {
+          return {
+            cardId: integration.id,
+            title: integration.title,
+            reason: "implementation evidence exists; exercise the changed runtime path before more discovery",
+            preferredTools: ["shell"]
+          };
+        }
+        if (hasVerificationEvidence && verification) {
+          return {
+            cardId: verification.id,
+            title: verification.title,
+            reason: "verification evidence exists; reconcile outcome, todos, and blockers",
+            preferredTools: ["todo_write", "task_complete"]
+          };
+        }
+        if (discoveryEvidence > 0 && !hasImplementationEvidence && implementation2) {
+          return {
+            cardId: implementation2.id,
+            title: implementation2.title,
+            reason: "discovery evidence is already present; land the smallest concrete repair",
+            preferredTools: ["file_write", "file_edit", "batch_edit", "file_patch"]
+          };
+        }
+        const active = snapshot.cards.find((card) => card.status === "in_progress") ?? snapshot.cards.find((card) => card.status === "needs_changes") ?? snapshot.cards.find((card) => card.status === "open") ?? discovery;
+        if (!active)
+          return null;
+        return {
+          cardId: active.id,
+          title: active.title,
+          reason: active.id === "discover-current-state" ? "no authoritative target evidence is recorded yet" : "workboard card is the next unresolved card",
+          preferredTools: active.id === "discover-current-state" ? ["file_read", "grep_search", "list_directory", "shell"] : ["file_write", "file_edit", "batch_edit", "file_patch", "shell"]
+        };
+      }
+      _focusToolsForRequiredAction(action) {
+        switch (action) {
+          case "update_todos":
+            return "todo_write with a changed plan/status, or a real file edit if that is the active work";
+          case "read_authoritative_target":
+          case "use_cached_evidence":
+            return "use cached evidence or one authoritative file_read/read-only shell, then act";
+          case "edit_different_target":
+            return "file_write, file_edit, batch_edit, or file_patch on a different supported target";
+          case "run_verification":
+            return "shell running the verification/runtime command";
+          case "report_blocked":
+          case "report_incomplete":
+            return "task_complete with the concrete blocker/incomplete evidence";
+          default:
+            return "choose the narrowest tool that advances the current card";
+        }
+      }
+      _renderNextActionContract(turn) {
+        const lines = ["[NEXT ACTION CONTRACT]", `turn=${turn}`];
+        const focus = this._focusSupervisor?.snapshot().directive ?? null;
+        if (focus) {
+          lines.push(`focus_required_next_action=${focus.requiredNextAction}`);
+          lines.push(`focus_valid_tools=${this._focusToolsForRequiredAction(focus.requiredNextAction)}`);
+          lines.push(`focus_reason=${focus.reason}`);
+        }
+        const snapshot = this._currentWorkboardSnapshotForFrame();
+        const action = snapshot ? this._deriveWorkboardActionContract(snapshot) : null;
+        if (snapshot && action) {
+          const byId = new Map(snapshot.cards.map((card) => [card.id, card]));
+          const discovery = byId.get("discover-current-state");
+          const implementation2 = byId.get("implement-repair");
+          const integration = byId.get("integrate-and-run");
+          const verification = byId.get("verify-observed-outcome");
+          lines.push(`workboard_current_card=${action.cardId} (${action.title})`);
+          lines.push(`workboard_preferred_tools=${action.preferredTools.join(", ")}`);
+          lines.push(`workboard_reason=${action.reason}`);
+          lines.push(`workboard_evidence_counts=discover:${this._workboardEvidenceCount(discovery)} implement:${this._workboardEvidenceCount(implementation2)} integrate:${this._workboardEvidenceCount(integration)} verify:${this._workboardEvidenceCount(verification)}`);
+          if (this._workboardHasEditEvidence(implementation2)) {
+            lines.push("implementation_state=mutation evidence is already recorded; do not treat discovery as the active phase");
+          }
+        }
+        const todos = this.readSessionTodos() ?? [];
+        if (todos.length > 0) {
+          const inProgress = todos.filter((todo) => todo.status === "in_progress");
+          const pending2 = todos.filter((todo) => todo.status === "pending");
+          const blocked = todos.filter((todo) => todo.status === "blocked");
+          lines.push(`todo_counts=in_progress:${inProgress.length} pending:${pending2.length} blocked:${blocked.length}`);
+          if (inProgress[0]) {
+            lines.push(`todo_current=${inProgress[0].content.slice(0, 180)}`);
+          } else if (pending2.length > 0) {
+            lines.push("todo_contract=mark exactly one pending todo in_progress before using the checklist as progress");
+          }
+        }
+        if (lines.length === 2)
+          return null;
+        lines.push("not_progress=repeat unchanged todo_write; repeat broad discovery already represented in this frame; keep discovery active after a real mutation");
+        return lines.join("\n");
+      }
+      _workboardTargetCardId(snapshot, toolName, result) {
+        const byId = new Map(snapshot.cards.map((card) => [card.id, card]));
+        if (this._isProjectEditTool(toolName) && this._isRealProjectMutation(toolName, result)) {
+          return byId.has("implement-repair") ? "implement-repair" : null;
+        }
+        if (toolName === "shell" || toolName === "background_run") {
+          const implementation2 = byId.get("implement-repair");
+          const target = this._workboardHasEditEvidence(implementation2) ? "integrate-and-run" : "discover-current-state";
+          return byId.has(target) ? target : null;
+        }
+        if (toolName === "file_read" || toolName === "file_explore" || toolName === "list_directory" || toolName === "grep_search" || toolName === "find_files" || toolName === "web_search") {
+          return byId.has("discover-current-state") ? "discover-current-state" : null;
+        }
+        const active = snapshot.cards.find((card) => card.status === "in_progress");
+        return active?.id ?? null;
+      }
+      _refreshWorkboardSnapshot(snapshot) {
+        const refreshed = readActiveWorkboardSnapshot(this._workboardDir(), this._sessionId) ?? snapshot;
+        this._workboard = refreshed;
+        return refreshed;
+      }
+      _advanceWorkboardForTool(snapshot, toolName, result, actor) {
+        const dir = this._workboardDir();
+        let current = snapshot;
+        const byId = () => new Map(current.cards.map((card) => [card.id, card]));
+        const editMutation = this._isProjectEditTool(toolName) && this._isRealProjectMutation(toolName, result);
+        try {
+          if (editMutation) {
+            let cards = byId();
+            const discovery = cards.get("discover-current-state");
+            if (discovery && discovery.status !== "verified" && discovery.evidence.length > 0) {
+              const completed = completeWorkboardCard(dir, {
+                runId: this._sessionId,
+                cardId: discovery.id,
+                actor,
+                outcome: "completed",
+                reason: "Implementation started after authoritative discovery evidence was recorded."
+              });
+              current = completed.snapshot;
+              cards = byId();
+              const completedDiscovery = cards.get("discover-current-state");
+              if (completedDiscovery?.status === "completed") {
+                const verified = completeWorkboardCard(dir, {
+                  runId: this._sessionId,
+                  cardId: completedDiscovery.id,
+                  actor,
+                  outcome: "verified",
+                  reason: "Discovery evidence was sufficient to select and mutate the implementation target."
+                });
+                current = verified.snapshot;
+                cards = byId();
+              }
+            }
+            const implementation2 = cards.get("implement-repair");
+            if (implementation2 && (implementation2.status === "open" || implementation2.status === "needs_changes")) {
+              current = updateWorkboardCard(dir, {
+                runId: this._sessionId,
+                cardId: implementation2.id,
+                actor,
+                updates: { status: "in_progress", lane: "worker" },
+                decisionReason: "Real project mutation landed; implementation is now the active phase."
+              });
+            }
+          }
+          if (toolName === "shell" || toolName === "background_run") {
+            const cards = byId();
+            const implementation2 = cards.get("implement-repair");
+            const integration = cards.get("integrate-and-run");
+            if (integration && this._workboardHasEditEvidence(implementation2) && (integration.status === "open" || integration.status === "needs_changes")) {
+              current = updateWorkboardCard(dir, {
+                runId: this._sessionId,
+                cardId: integration.id,
+                actor,
+                updates: { status: "in_progress", lane: "verification" },
+                decisionReason: "Runtime or verification command ran after implementation evidence."
+              });
+            }
+          }
+        } catch {
+        }
+        return this._refreshWorkboardSnapshot(current);
+      }
       /**
        * Record evidence from a tool call against the active workboard.
        * Matches by card assignee when the card is in progress.
@@ -578332,24 +578573,23 @@ ${parts.join("\n")}
             ref: typeof args["path"] === "string" ? args["path"]?.slice(0, 200) : void 0
           };
           const actor = this.options.subAgent ? "sub-agent" : "agent";
-          for (const card of board.cards) {
-            if (card.status !== "in_progress")
-              continue;
-            if (card.assignee && card.assignee !== actor && card.assignee !== "any")
-              continue;
-            if (toolName === "shell" && !card.evidenceRequirements.some((r2) => r2.toLowerCase().includes("shell") || r2.toLowerCase().includes("build") || r2.toLowerCase().includes("test")))
-              continue;
-            if (toolName === "file_write" && !card.evidenceRequirements.some((r2) => r2.toLowerCase().includes("file") || r2.toLowerCase().includes("write") || r2.toLowerCase().includes("implement")))
-              continue;
-            if (toolName === "file_read" && !card.evidenceRequirements.some((r2) => r2.toLowerCase().includes("read") || r2.toLowerCase().includes("explor") || r2.toLowerCase().includes("understand")))
-              continue;
-            attachWorkboardEvidence(dir, {
-              runId: this._sessionId,
-              cardId: card.id,
-              actor,
-              evidence
-            });
+          const advanced = this._advanceWorkboardForTool(board, toolName, result, actor);
+          const targetCardId = this._workboardTargetCardId(advanced, toolName, result);
+          if (!targetCardId)
+            return;
+          const targetCard = advanced.cards.find((card) => card.id === targetCardId);
+          if (!targetCard)
+            return;
+          if (targetCard.assignee && targetCard.assignee !== actor && targetCard.assignee !== "any") {
+            return;
           }
+          attachWorkboardEvidence(dir, {
+            runId: this._sessionId,
+            cardId: targetCard.id,
+            actor,
+            evidence
+          });
+          this._refreshWorkboardSnapshot(advanced);
         } catch {
         }
       }
@@ -579814,6 +580054,21 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
           return false;
         return true;
       }
+      _isTodoWriteNoopResult(result) {
+        if (!result)
+          return false;
+        if (result.noop === true)
+          return true;
+        const text2 = String(result.output ?? result.llmContent ?? "");
+        if (!text2 || !/"noop"\s*:\s*true/.test(text2))
+          return false;
+        try {
+          const parsed = JSON.parse(text2);
+          return parsed?.noop === true;
+        } catch {
+          return true;
+        }
+      }
       _toolEvidencePreview(result, displayOutput, max = 500, toolName) {
         const modelVisible = result.llmContent ?? result.output ?? displayOutput ?? "";
         const failurePrefix = result.success === false && result.error ? `Error: ${result.error}` : "";
@@ -582535,6 +582790,7 @@ ${chunk.content}`, {
         const failureBlock = this._renderRecentFailuresBlock(turn);
         const churnBlock = this._renderWriteChurnBlock(turn);
         const focusBlock = this._focusSupervisor?.renderFrame() ?? null;
+        const actionContractBlock = this._renderNextActionContract(turn);
         const toolCacheBlock = recentToolResults ? this._renderKnowledgeBlock(recentToolResults) : null;
         const anchorsBlock = this.surfaceAnchors(messages2);
         const pprMemoryBlock = this._lastPprMemoryLines.length > 0 ? `[Associative Memory - related prior experience]
@@ -582572,6 +582828,13 @@ ${this._lastPprMemoryLines.slice(0, 5).join("\n")}` : null;
             createdTurn: turn,
             ttlTurns: 1
           }),
+          signalFromBlock("action_contract", "turn.next-action-contract", actionContractBlock, {
+            id: "next-action-contract",
+            dedupeKey: "turn.next-action-contract",
+            priority: PRIORITY.ACTION_CONTRACT,
+            createdTurn: turn,
+            ttlTurns: 1
+          }),
           signalFromBlock("task_state", "turn.todos", todoBlock, {
             id: "todo-state",
             dedupeKey: "turn.todos",
@@ -587847,7 +588110,7 @@ Respond with EXACTLY this structure before your next tool call:
                     }
                   }
                 }
-                if (tc.name === "todo_write" && result.success) {
+                if (tc.name === "todo_write" && result.success && !this._isTodoWriteNoopResult(result)) {
                   if (this._progressGateActive) {
                     this.emit({
                       type: "status",
@@ -588430,7 +588693,7 @@ Respond with EXACTLY this structure before your next tool call:
                         timestamp: (/* @__PURE__ */ new Date()).toISOString()
                       });
                     }
-                    if (!this._newFieldNudgeFired) {
+                    if (!this._newFieldNudgeFired && !this._isTodoWriteNoopResult(result)) {
                       this._todoWritesObservedForNudge++;
                       const _anyFieldUsed = _todosNow.some((t2) => typeof t2.verifyCommand === "string" || Array.isArray(t2.declaredArtifacts));
                       if (this._todoWritesObservedForNudge >= 2 && !_anyFieldUsed) {
@@ -589047,7 +589310,8 @@ Evidence: ${evidencePreview}`.slice(0, 500);
                   output: result.output ?? result.llmContent ?? "",
                   error: result.error ?? "",
                   mutated: realFileMutation || shellFilesystemMutation,
-                  isReadLike
+                  isReadLike,
+                  noop: tc.name === "todo_write" ? this._isTodoWriteNoopResult(result) : result.noop
                 });
                 const focusSnapshotAfter = this._focusSupervisor?.snapshot();
                 focusAfterToolResult = focusSnapshotAfter ?? void 0;
@@ -589094,7 +589358,7 @@ Evidence: ${evidencePreview}`.slice(0, 500);
                 });
               } catch {
               }
-              if (tc.name === "todo_write") {
+              if (tc.name === "todo_write" && !this._isTodoWriteNoopResult(result)) {
                 this._lastTodoWriteTurn = turn;
               }
               if (tc.name === "file_read" || tc.name === "list_directory" || tc.name === "find_files" || tc.name === "grep_search") {
@@ -604602,12 +604866,14 @@ var init_py_embed = __esm({
 var listen_exports = {};
 __export(listen_exports, {
   ListenEngine: () => ListenEngine,
+  asrConsensusEnabled: () => asrConsensusEnabled,
   ensureTranscribeCliBackground: () => ensureTranscribeCliBackground,
   getListenEngine: () => getListenEngine,
   getListenLiveState: () => getListenLiveState,
   isAudioPath: () => isAudioPath,
   isTranscribablePath: () => isTranscribablePath,
   isVideoPath: () => isVideoPath,
+  resolveAsrConsensusModel: () => resolveAsrConsensusModel,
   transcribeFileViaWhisper: () => transcribeFileViaWhisper,
   waitForTranscribeCli: () => waitForTranscribeCli
 });
@@ -605012,9 +605278,25 @@ function defaultConsensusModel(primaryModel) {
   if (model === "large-v3" || model === "large") return "small";
   return "base";
 }
-function asrConsensusEnabled() {
-  const consensusEnv = String(process.env["OMNIUS_ASR_CONSENSUS"] ?? "").trim().toLowerCase();
-  return !(consensusEnv === "0" || consensusEnv === "off" || consensusEnv === "false");
+function resolveAsrConsensusModel(primaryModel) {
+  const disabled = String(process.env["OMNIUS_ASR_DISABLE_CONSENSUS"] ?? "").trim().toLowerCase();
+  if (disabled === "1" || disabled === "true" || disabled === "yes" || disabled === "on") {
+    return "off";
+  }
+  const consensusEnv = String(
+    process.env["OMNIUS_ASR_CONSENSUS"] ?? process.env["OMNIUS_ASR_CONSENSUS_MODEL"] ?? ""
+  ).trim().toLowerCase();
+  if (!consensusEnv) return "off";
+  if (["0", "off", "false", "no", "none", "disabled"].includes(consensusEnv)) {
+    return "off";
+  }
+  if (["1", "on", "true", "yes", "enabled", "auto"].includes(consensusEnv)) {
+    return defaultConsensusModel(primaryModel);
+  }
+  return consensusEnv;
+}
+function asrConsensusEnabled(primaryModel = "base") {
+  return resolveAsrConsensusModel(primaryModel) !== "off";
 }
 function liveAsrUseTranscribeCli() {
   const value2 = String(process.env["OMNIUS_ASR_USE_TRANSCRIBE_CLI"] ?? "").trim().toLowerCase();
@@ -605247,8 +605529,7 @@ var init_listen = __esm({
           model: this.model,
           lastStatus: `loading whisper ${this.model} model...`
         });
-        const consensusEnv = String(process.env["OMNIUS_ASR_CONSENSUS"] ?? "").trim().toLowerCase();
-        const consensusModel = consensusEnv === "0" || consensusEnv === "off" || consensusEnv === "false" ? "off" : consensusEnv || defaultConsensusModel(this.model);
+        const consensusModel = resolveAsrConsensusModel(this.model);
         const consensusThreshold = String(process.env["OMNIUS_ASR_CONSENSUS_THRESHOLD"] ?? "0.45");
         const silenceMs = String(process.env["OMNIUS_ASR_SILENCE_MS"] ?? "3000");
         this.process = spawn29(
@@ -605312,7 +605593,9 @@ var init_listen = __esm({
                     updateListenLiveState({
                       lastStatus: message2
                     });
-                    this.emit("status", message2);
+                    if (process.env["OMNIUS_ASR_VERBOSE_CONSENSUS"] === "1") {
+                      this.emit("status", message2);
+                    }
                   }
                   break;
                 case "vad": {
@@ -605665,7 +605948,7 @@ var init_listen = __esm({
           updateListenLiveState({ phase: "error", lastStatus: "no mic capture tool (arecord/sox/ffmpeg)" });
           return "No microphone capture tool found. Install arecord (Linux), sox (macOS), or ffmpeg.";
         }
-        const consensusEnabled = asrConsensusEnabled();
+        const consensusEnabled = asrConsensusEnabled(this.config.model);
         const useTranscribeCli = liveAsrUseTranscribeCli() && !consensusEnabled;
         const preferWhisperFallback = !useTranscribeCli;
         if (preferWhisperFallback) {
@@ -605959,7 +606242,7 @@ transcribe-cli error: ${transcribeCliError}` : "";
        * Caller is responsible for calling .stop() when done.
        */
       async createCallTranscriber() {
-        const requireConsensus = asrConsensusEnabled();
+        const requireConsensus = asrConsensusEnabled(this.config.model);
         const useTranscribeCli = liveAsrUseTranscribeCli() && !requireConsensus;
         let tc = useTranscribeCli ? await this.loadTranscribeCli() : null;
         if (useTranscribeCli && !tc && _bgInstallPromise) {
@@ -740566,10 +740849,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         sharedTranscriber: null
       };
       const engine = getListenEngine();
-      const callConsensusRequired = (() => {
-        const env2 = String(process.env["OMNIUS_ASR_CONSENSUS"] ?? "").trim().toLowerCase();
-        return !(env2 === "0" || env2 === "off" || env2 === "false");
-      })();
+      const callConsensusRequired = asrConsensusEnabled();
       const recentCallFinals = [];
       const normalizeCallTranscript = (value2) => value2.toLowerCase().replace(/[^\p{L}\p{N}\s']/gu, " ").replace(/\s+/g, " ").trim();
       const isLikelyCallAsrHallucination = (normalized) => /^(thanks|thank you) for watching(?: this video)?$/.test(normalized) || /^thanks for watching and/.test(normalized) || /\bdon't forget to (like|subscribe)\b/.test(normalized);

package/dist/scripts/live-whisper.py

@@ -14,8 +14,8 @@ Architecture (EGG voice/whisper lineage):
     (USB 2886:0018), the XMOS DSP's SPEECHDETECTED register gates utterances,
     on-chip echo cancellation is enabled, and the DOA angle is attached to
     transcripts. Falls back to adaptive energy VAD otherwise.
-  - Dual-model consensus: a second whisper model transcribes finalized
-    utterances in parallel; transcripts are only emitted when both agree.
+  - Optional dual-model consensus: a second whisper model can validate
+    finalized utterances when explicitly enabled.
 
 Protocol:
   stdin  — raw PCM16 audio (16kHz, mono, 16-bit signed LE)
@@ -58,6 +58,23 @@ SAMPLE_WIDTH = 2  # 16-bit
 BLOCK_SECONDS = 0.2
 BLOCK_SAMPLES = int(SAMPLE_RATE * BLOCK_SECONDS)
 
+
+def env_float(name: str, default: float) -> float:
+    raw = os.environ.get(name, "").strip()
+    if not raw:
+        return default
+    try:
+        return float(raw)
+    except ValueError:
+        return default
+
+
+def env_bool(name: str, default: bool = False) -> bool:
+    raw = os.environ.get(name, "").strip().lower()
+    if not raw:
+        return default
+    return raw in ("1", "true", "yes", "on", "enabled")
+
 # ---------------------------------------------------------------------------
 # Output helpers (JSON lines to stdout)
 # ---------------------------------------------------------------------------
@@ -450,7 +467,7 @@ def main():
     parser.add_argument("--chunk-seconds", type=float, default=3, help=argparse.SUPPRESS)
     parser.add_argument("--window-seconds", type=float, default=10, help=argparse.SUPPRESS)
     parser.add_argument("--language", default=None, help="Language code (e.g. en, es, fr). Auto-detect if omitted.")
-    parser.add_argument("--consensus-model", default="tiny",
+    parser.add_argument("--consensus-model", default="off",
                         help="Second whisper model run in parallel on finalized utterances; transcripts are only emitted when both models agree. 'off' disables.")
     parser.add_argument("--consensus-threshold", type=float, default=0.55,
                         help="Token similarity (0-1) required between the two models' transcripts.")
@@ -460,6 +477,18 @@ def main():
                         help="Audio kept from before speech onset.")
     parser.add_argument("--max-utterance-seconds", type=float, default=22,
                         help="Force-finalize utterances longer than this.")
+    parser.add_argument("--partials", action="store_true", default=env_bool("OMNIUS_ASR_PARTIALS", False),
+                        help="Emit interim Whisper transcripts during long utterances. Disabled by default to avoid silence/noise hallucinations.")
+    parser.add_argument("--min-speech-ms", type=float, default=env_float("OMNIUS_ASR_MIN_SPEECH_MS", 450.0),
+                        help="Minimum VAD-positive speech duration required before an utterance is sent to Whisper.")
+    parser.add_argument("--start-rms", type=float, default=env_float("OMNIUS_ASR_START_RMS", 0.0025),
+                        help="Minimum block RMS required for software VAD speech start.")
+    parser.add_argument("--energy-ratio", type=float, default=env_float("OMNIUS_ASR_ENERGY_RATIO", 3.5),
+                        help="Software VAD speech gate as a multiple of the adaptive noise floor.")
+    parser.add_argument("--min-utterance-rms", type=float, default=env_float("OMNIUS_ASR_MIN_UTTERANCE_RMS", 0.003),
+                        help="Minimum loud-block RMS required before final transcription.")
+    parser.add_argument("--min-utterance-peak", type=float, default=env_float("OMNIUS_ASR_MIN_UTTERANCE_PEAK", 0.015),
+                        help="Minimum utterance peak amplitude required when RMS is low.")
     args = parser.parse_args()
 
     import whisper
@@ -543,6 +572,9 @@ def main():
     utterance = []       # list of float32 blocks while capturing
     capturing = False
     silence_run = 0
+    speech_blocks = 0
+    utterance_rms_values = []
+    utterance_peak = 0.0
     noise_floor = None
     last_partial_at = 0.0
     last_final_text = ""
@@ -558,7 +590,7 @@ def main():
             noise_floor = 0.7 * noise_floor + 0.3 * block_rms  # drop fast
         else:
             noise_floor = 0.995 * noise_floor + 0.005 * block_rms  # creep up slowly
-        gate = max(1.5e-4, noise_floor * 2.5)  # ≥ ~8dB above floor
+        gate = max(float(args.start_rms), noise_floor * float(args.energy_ratio))
         return block_rms >= gate
 
     def transcribe_partial(samples):
@@ -574,9 +606,31 @@ def main():
         except Exception as e:
             emit_error(f"Transcription error: {e}")
 
-    def transcribe_final(samples):
-        nonlocal last_final_text
+    def utterance_quality_ok(samples, speech_block_count, rms_values, peak) -> bool:
         if len(samples) < int(0.4 * SAMPLE_RATE):
+            return False
+        speech_ms = speech_block_count * BLOCK_SECONDS * 1000.0
+        if speech_ms < float(args.min_speech_ms):
+            if env_bool("OMNIUS_ASR_VERBOSE_VAD", False):
+                emit_status(f"Dropped short VAD blob before Whisper: speech_ms={speech_ms:.0f}")
+            return False
+        if rms_values:
+            ordered = sorted(float(v) for v in rms_values)
+            loud_half = ordered[len(ordered) // 2:] or ordered
+            loud_rms = loud_half[len(loud_half) // 2]
+        else:
+            loud_rms = float(np.sqrt(np.mean(samples ** 2))) if len(samples) else 0.0
+        if loud_rms < float(args.min_utterance_rms) and peak < float(args.min_utterance_peak):
+            if env_bool("OMNIUS_ASR_VERBOSE_VAD", False):
+                emit_status(
+                    f"Dropped low-energy VAD blob before Whisper: loud_rms={loud_rms:.5f} peak={peak:.5f}"
+                )
+            return False
+        return True
+
+    def transcribe_final(samples, speech_block_count=0, rms_values=None, peak=0.0):
+        nonlocal last_final_text
+        if not utterance_quality_ok(samples, speech_block_count, rms_values or [], peak):
             return
         samples = amplify(samples)
         try:
@@ -612,7 +666,9 @@ def main():
                     last_final_text = primary_text
                     emit_transcript(primary_text, is_final=True, doa=primary_doa, consensus=True)
                 except Exception as e:
-                    emit_error(f"Consensus validation error: {e}")
+                    emit_consensus_rejected(primary_text, "", "validator_error")
+                    if env_bool("OMNIUS_ASR_VERBOSE_CONSENSUS", False):
+                        emit_status(f"Consensus validation error: {e}")
 
             threading.Thread(
                 target=validate_consensus,
@@ -664,12 +720,18 @@ def main():
                     if speech:
                         capturing = True
                         silence_run = 0
+                        speech_blocks = 1
+                        utterance_rms_values = [block_rms]
+                        utterance_peak = float(np.max(np.abs(block))) if len(block) else 0.0
                         utterance = list(preroll)
                         preroll.clear()
                     continue
 
                 utterance.append(block)
+                utterance_rms_values.append(block_rms)
+                utterance_peak = max(utterance_peak, float(np.max(np.abs(block))) if len(block) else 0.0)
                 if speech:
+                    speech_blocks += 1
                     silence_run = 0
                 else:
                     silence_run += 1
@@ -677,11 +739,17 @@ def main():
                 utter_samples = sum(len(b) for b in utterance)
                 if silence_run >= finalize_blocks or utter_samples >= max_utter_samples:
                     samples = np.concatenate(utterance)
+                    final_speech_blocks = speech_blocks
+                    final_rms_values = list(utterance_rms_values)
+                    final_peak = utterance_peak
                     capturing = False
                     utterance = []
                     silence_run = 0
-                    transcribe_final(samples)
-                elif utter_samples >= int(3.5 * SAMPLE_RATE) and now - last_partial_at >= 2.5:
+                    speech_blocks = 0
+                    utterance_rms_values = []
+                    utterance_peak = 0.0
+                    transcribe_final(samples, final_speech_blocks, final_rms_values, final_peak)
+                elif args.partials and utter_samples >= int(3.5 * SAMPLE_RATE) and now - last_partial_at >= 2.5:
                     last_partial_at = now
                     transcribe_partial(np.concatenate(utterance))
     except KeyboardInterrupt:
@@ -690,7 +758,12 @@ def main():
     # EOF: finalize any in-flight utterance.
     if utterance:
         try:
-            transcribe_final(np.concatenate(utterance))
+            transcribe_final(
+                np.concatenate(utterance),
+                speech_blocks,
+                list(utterance_rms_values),
+                utterance_peak,
+            )
         except Exception:
             pass
     if tuning is not None:

package/npm-shrinkwrap.json

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

package/package.json

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