@nexus-cortex/core 4.108.9 → 4.108.11

package/dist/orchestrator/CortexOrchestrator.js

@@ -43,11 +43,11 @@ import { renderResumeMemoryPrompt, buildRebuildInstructions, resolveCheckpointBa
 import { resolveCortexStateDir, cortexStatePath } from '../utils/stateDir.js';
 import { collectWorkspaceDelta, detectCheckCommand, runCheck, resolveJudgeGroundingConfig } from '../training/judgeEvidence.js';
 import { resolveMentorRoleConfig, describeMentorWire, describeMentorDelivery, mentorSurfaceTimeoutMs } from '../training/mentorRole.js';
-import { resolveOuterToolDeadlineMs } from './outerToolTimeout.js';
+import { resolveOuterToolDeadlineMs, resolveOuterToolTimeoutFloorMs } from './outerToolTimeout.js';
 import { resolveSubAgentTimeoutMs } from './subAgentTimeout.js';
 import { resolveTurnDeadlineMs, timeBudgetState, timeBudgetWarnNudge } from './timeBudget.js';
 import { readStagedDoctrine, applyCuratedDoctrine, runOrientForStaging, withTimeout } from './doctrineCuration.js';
-import { ExactRepeatTracker } from '../training/loopLadder.js';
+import { ExactRepeatTracker, notePollResults } from '../training/loopLadder.js';
 import { slashCommandRegistry } from '../commands/SlashCommandRegistry.js';
 import { prefixMcpToolName, parseMcpToolName } from '../mcp/mcpToolNamespacing.js';
 import { DecisionStore } from '../training/DecisionStore.js';
@@ -1582,6 +1582,10 @@ export class CortexOrchestrator {
         let currentAssistantCanonicalMessage = assistantCanonicalMessage;
         this.recordDsmlRecovery(currentAssistantCanonicalMessage);
         let toolCallIteration = 0;
+        // R137 HB-POLL-REPEAT-BREAKER: the exact-repeat breaker used to force-exit by overwriting
+        // toolCallIteration = MAX_TOOL_ITERATIONS, which banked toolCallIterations=1000 (a metrics
+        // artifact). An explicit flag ends the loop the same way and keeps the true count.
+        let loopBreak = false;
         // Loop control settings — single source of truth via getLoopControlConfig()
         const loopDefaults = this.getLoopControlConfig();
         // CORTEX_ACTION_EFFORT: static reasoning effort for the PRIMARY (action) model — fills the
@@ -1596,6 +1600,7 @@ export class CortexOrchestrator {
         }
         const MAX_TOOL_ITERATIONS = loopDefaults.maxToolIterations;
         const TOOL_TIMEOUT_MS = loopDefaults.toolTimeoutMs;
+        const OUTER_TOOL_TIMEOUT_FLOOR_MS = loopDefaults.outerToolTimeoutFloorMs;
         const MAX_CONSECUTIVE_ERRORS = loopDefaults.maxConsecutiveErrors;
         const MAX_LOOP_REPETITIONS = loopDefaults.maxLoopRepetitions;
         const TOOL_BUDGET_SOFT = loopDefaults.toolBudgetSoft; // R29b brake
@@ -2312,8 +2317,9 @@ export class CortexOrchestrator {
                     if (matchCount >= MAX_LOOP_REPETITIONS) {
                         console.warn(`[Orchestrator Phase 2.5] Loop detected: Tool "${toolUse.name}" called ${matchCount} times with same input. Stopping to prevent infinite loop.`);
                         console.warn(`[Orchestrator Phase 2.5] Repeated input: ${inputHash.substring(0, 100)}...`);
-                        // Break out of the main while loop
-                        toolCallIteration = MAX_TOOL_ITERATIONS;
+                        // Break out of the main while loop (R137: flag, not a counter overwrite)
+                        loopBreak = true;
+                        this.recordLoopBreak(toolUse.name, matchCount, toolCallIteration);
                         break;
                     }
                 }
@@ -2321,7 +2327,7 @@ export class CortexOrchestrator {
                 // Without this, `break` above only exits the inner for, and the full tool
                 // batch still executes this iteration (defeats loop prevention).
                 // Orphaned tool_use blocks are handled by orphan-recovery at loop exit.
-                if (toolCallIteration >= MAX_TOOL_ITERATIONS) {
+                if (loopBreak || toolCallIteration >= MAX_TOOL_ITERATIONS) {
                     break;
                 }
                 // Phase 2.5 Day 3: Execute tools with timeout support
@@ -2333,7 +2339,7 @@ export class CortexOrchestrator {
                 const abortController = new AbortController();
                 // D-A (2026-09-04): outer cap must sit ABOVE the model's REQUESTED Bash timeout, not a static
                 // ~150s, or a legit `Bash({ timeout: 250000 })` is killed before ShellTool's own promote-at-deadline.
-                const outerDeadlineMs = resolveOuterToolDeadlineMs(toolUseBlocks, TOOL_TIMEOUT_MS, OUTER_TIMEOUT_GRACE_MS, this.subAgentBlockTimeoutMs);
+                const outerDeadlineMs = resolveOuterToolDeadlineMs(toolUseBlocks, TOOL_TIMEOUT_MS, OUTER_TIMEOUT_GRACE_MS, this.subAgentBlockTimeoutMs, OUTER_TOOL_TIMEOUT_FLOOR_MS);
                 const timeoutId = setTimeout(() => {
                     console.warn(`[Orchestrator Phase 2.5] Tool execution timeout after ${outerDeadlineMs}ms`);
                     abortController.abort();
@@ -2344,6 +2350,7 @@ export class CortexOrchestrator {
                     const toolResults = await this.handleToolCalls(toolUseBlocks, abortController.signal, structuredOutputState);
                     this.testPostExecThrow(); // test-only fault injection for the re-execution guard (inert in prod)
                     clearTimeout(timeoutId);
+                    notePollResults(exactRepeatTracker, toolUseBlocks, toolResults); // R137: poll repeats count only on identical STALLED output
                     // Unified Outcome Ladder: observe each result's TRUE outcome (exit
                     // codes, not wire is_error) and escalate on repeated failing
                     // approaches. The strongest signal this batch is injected at the
@@ -2978,8 +2985,11 @@ export class CortexOrchestrator {
                 break;
             }
         }
-        // Warn if we hit max iterations
-        if (toolCallIteration >= MAX_TOOL_ITERATIONS) {
+        // Warn if we hit max iterations (or the exact-repeat breaker ended the loop — R137)
+        if (loopBreak) {
+            console.warn(`[Orchestrator Phase 2.5] Exact-repeat breaker ended the tool loop at iteration ${toolCallIteration}. Stopping loop.`);
+        }
+        else if (toolCallIteration >= MAX_TOOL_ITERATIONS) {
             console.warn(`[Orchestrator Phase 2.5] Max tool iterations (${MAX_TOOL_ITERATIONS}) reached. Stopping loop.`);
         }
         // R29a: post-loop synthesis net. The tool loop can exit with the final
@@ -3743,6 +3753,7 @@ export class CortexOrchestrator {
         // Phase 2.8: Multi-turn tool execution loop (STREAMING VERSION)
         // Matches sendMessage() pattern exactly (lines 800-1229), but with streaming
         let toolCallIteration = 0;
+        let loopBreak = false; // R137: explicit exact-repeat break flag (parity with sendMessage; keeps the true iteration count)
         let totalToolErrors = 0;
         let emptyResponseRetryUsed = false; // R32: parity with sendMessage R18b guard
         let inactionNudgeUsed = false; // Inaction guard (backlog item 2) — streaming parity
@@ -3792,6 +3803,7 @@ export class CortexOrchestrator {
         const MAX_CONSECUTIVE_ERRORS = loopDefaults.maxConsecutiveErrors;
         const MAX_LOOP_REPETITIONS = loopDefaults.maxLoopRepetitions;
         const TOOL_TIMEOUT_MS = loopDefaults.toolTimeoutMs;
+        const OUTER_TOOL_TIMEOUT_FLOOR_MS = loopDefaults.outerToolTimeoutFloorMs;
         const TOOL_BUDGET_SOFT = loopDefaults.toolBudgetSoft; // R29b brake
         // R64: TOOL_BUDGET_SOFT <= 0 disables the budget-pressure system entirely
         // (no reminders, no force-synthesis cap). Runaway protection then rests on
@@ -4125,7 +4137,8 @@ export class CortexOrchestrator {
                     if (this.config.debug) {
                         console.warn(`[Orchestrator Streaming] Loop detected: Tool "${toolUse.name}" called ${matchCount} times with same input. Stopping.`);
                     }
-                    toolCallIteration = MAX_TOOL_ITERATIONS; // Force exit
+                    loopBreak = true; // Force exit (R137: flag, not a counter overwrite)
+                    this.recordLoopBreak(toolUse.name, matchCount, toolCallIteration);
                     break;
                 }
             }
@@ -4133,14 +4146,14 @@ export class CortexOrchestrator {
             // Without this, `break` above only exits the inner for, and the full tool
             // batch still executes this iteration (defeats loop prevention).
             // Orphaned tool_use blocks are handled by orphan-recovery at loop exit.
-            if (toolCallIteration >= MAX_TOOL_ITERATIONS) {
+            if (loopBreak || toolCallIteration >= MAX_TOOL_ITERATIONS) {
                 break;
             }
             // Execute tools with timeout (outer cap fires a grace period AFTER the tool's own deadline —
             // see the non-stream site: ShellTool's promote-at-deadline must win the race; 4.90.1)
             const abortController = new AbortController();
             // D-A (2026-09-04): outer cap sits above the requested Bash timeout (see the non-stream site).
-            const outerDeadlineMs = resolveOuterToolDeadlineMs(toolUseBlocks, TOOL_TIMEOUT_MS, OUTER_TIMEOUT_GRACE_MS, this.subAgentBlockTimeoutMs);
+            const outerDeadlineMs = resolveOuterToolDeadlineMs(toolUseBlocks, TOOL_TIMEOUT_MS, OUTER_TIMEOUT_GRACE_MS, this.subAgentBlockTimeoutMs, OUTER_TOOL_TIMEOUT_FLOOR_MS);
             const timeoutId = setTimeout(() => {
                 if (this.config.debug) {
                     console.warn(`[Orchestrator Streaming] Tool execution timeout after ${outerDeadlineMs}ms`);
@@ -4152,6 +4165,7 @@ export class CortexOrchestrator {
                 const toolResults = await this.handleToolCalls(toolUseBlocks, abortController.signal, structuredOutputState);
                 this.testPostExecThrow(); // test-only fault injection for the re-execution guard (inert in prod)
                 clearTimeout(timeoutId);
+                notePollResults(streamRepeatTracker, toolUseBlocks, toolResults); // R137 (streaming parity)
                 // 4.91.0: EndTurn gates for STREAMING (were sendMessage-only) — same evidence + evaluation.
                 ev.noteToolResults(toolResults);
                 evaluateEndTurnGates(ev, toolResults, toolUseBlocks, this.gateDeps());
@@ -4791,10 +4805,12 @@ export class CortexOrchestrator {
                 }
             }
         }
-        // Warn if hit max iterations
-        if (toolCallIteration >= MAX_TOOL_ITERATIONS) {
+        // Warn if hit max iterations (or the exact-repeat breaker ended the loop — R137)
+        if (loopBreak || toolCallIteration >= MAX_TOOL_ITERATIONS) {
             if (this.config.debug) {
-                console.warn(`[Orchestrator Streaming] Max tool iterations (${MAX_TOOL_ITERATIONS}) reached. Stopping loop.`);
+                console.warn(loopBreak
+                    ? `[Orchestrator Streaming] Exact-repeat breaker ended the tool loop at iteration ${toolCallIteration}. Stopping loop.`
+                    : `[Orchestrator Streaming] Max tool iterations (${MAX_TOOL_ITERATIONS}) reached. Stopping loop.`);
             }
         }
         // R29a (streaming parity): post-loop synthesis net. R32 added the R18b
@@ -5138,6 +5154,8 @@ export class CortexOrchestrator {
             // coercion silently replaced an explicit 0 with 15.
             toolBudgetSoft: Number.isFinite(softRaw) && softRaw >= 0 ? softRaw : 400,
             toolTimeoutMs: this.config.loopControl?.toolTimeoutMs ?? 120000,
+            // CORTEX_OUTER_TOOL_TIMEOUT_MS: floor for the outer per-batch abort (0 = no floor, byte-identical).
+            outerToolTimeoutFloorMs: resolveOuterToolTimeoutFloorMs(),
             maxLoopRepetitions: this.config.loopControl?.maxLoopRepetitions ?? 5,
             // #2 wall-clock deadline: opt-in (0 = disabled), env CORTEX_TURN_DEADLINE_MS is the fallback.
             turnDeadlineMs: resolveTurnDeadlineMs(this.config.loopControl?.turnDeadlineMs),
@@ -6262,6 +6280,17 @@ export class CortexOrchestrator {
      * @param signal AbortSignal for cancellation
      * @returns Array of tool results
      */
+    /** R137 HB-POLL-REPEAT-BREAKER: bank the exact-repeat break as a decisions event (mechanism-engagement evidence). */
+    recordLoopBreak(tool, matchCount, iteration) {
+        const store = this.getDecisionStore();
+        if (store)
+            void store.recordEvent({
+                sessionId: this.currentSessionId ?? 'unknown',
+                kind: 'loop_break',
+                toolName: tool,
+                detail: { tool, matchCount, iteration },
+            }).catch(() => { });
+    }
     async handleToolCalls(toolUseBlocks, signal, structuredOutputState) {
         // StructuredOutput (grok-build port): intercept BEFORE any dispatch — the
         // synthetic tool is request-scoped (never in a registry) and must NEVER