@nexus-cortex/core 4.95.0 → 4.97.0

package/dist/orchestrator/CortexOrchestrator.js

@@ -1518,6 +1518,7 @@ export class CortexOrchestrator {
         // Keep executing tools until model returns a text response
         let currentAssistantMessage = assistantMessage;
         let currentAssistantCanonicalMessage = assistantCanonicalMessage;
+        this.recordDsmlRecovery(currentAssistantCanonicalMessage);
         let toolCallIteration = 0;
         // Loop control settings — single source of truth via getLoopControlConfig()
         const loopDefaults = this.getLoopControlConfig();
@@ -1548,6 +1549,12 @@ export class CortexOrchestrator {
         // Round 18b: track whether we've already retried on empty response so
         // we don't loop forever. See empty-detection block below.
         let emptyResponseRetryUsed = false;
+        // HB-ENDTURN-TERMINAL (2026-09-08): dark-lever gate + a SEPARATE bounded counter for the
+        // continue-kinds (truncated / reasoning_only_active). Those re-enter the loop with tools rather
+        // than burning the one-shot force-answer budget; capped so an empty-turn loop still terminates.
+        const EMPTY_TURN_CONTINUE = loopDefaults.emptyTurnContinue;
+        const EMPTY_CONTINUE_MAX = 3;
+        let emptyContinueCount = 0;
         // Inaction guard (backlog item 2 — the ladder's inverse): single-nudge
         // bound for the actless-verbose retry. Default OFF via env.
         let inactionNudgeUsed = false;
@@ -1653,16 +1660,32 @@ export class CortexOrchestrator {
                     // after its final tool call. Nudging it for "no text" would burn an
                     // extra round-trip (observed with haiku in the structured-output
                     // canary). The structured result IS the deliverable, so skip R18b.
-                    if (!hasVisibleText && !emptyResponseRetryUsed && !structuredOutputState?.result) {
-                        emptyResponseRetryUsed = true;
-                        // Typed empty-response classification (grok-build port): distinguish
-                        // reasoning_only (model reasoned but never answered) from
-                        // no_visible_content (nothing at all) for observability + a nudge
-                        // tailored to the failure shape. Does NOT change the one-bounded-retry
-                        // decision — only the log + nudge text.
-                        // D-E (2026-09-04): pass stopReason so a max_tokens truncation is classified 'truncated'
-                        // (continue), not 'reasoning_only' (which demands a final answer and just re-truncates).
-                        const emptyClass = classifyEmptyResponse(currentAssistantCanonicalMessage.content, convertedResponse.stopReason);
+                    // HB-ENDTURN-TERMINAL (2026-09-08): classify FIRST so retry policy keys on the kind.
+                    // loopHasBudget (dark-gated by CORTEX_EMPTY_TURN_CONTINUE) splits a reasoning-only empty turn
+                    // into reasoning_only_active (mid-recon → continue-with-tools, bounded) vs reasoning_only
+                    // (exhausted → force the answer, one-shot). Flag off → loopHasBudget false → byte-identical
+                    // to the prior one-shot guard.
+                    const loopHasBudget = EMPTY_TURN_CONTINUE
+                        && (TURN_DEADLINE_MS <= 0 || (Date.now() - loopStartMs) < 0.6 * TURN_DEADLINE_MS)
+                        && toolCallIteration < 0.6 * MAX_TOOL_ITERATIONS;
+                    // Typed empty-response classification (grok-build port): reasoning_only vs no_visible_content
+                    // for observability + a tailored nudge. D-E: stopReason distinguishes a max_tokens truncation
+                    // ('truncated' → continue) from a demand-final-answer.
+                    const emptyClass = (!hasVisibleText && !structuredOutputState?.result)
+                        ? classifyEmptyResponse(currentAssistantCanonicalMessage.content, convertedResponse.stopReason, loopHasBudget)
+                        : null;
+                    const isEmptyContinueKind = EMPTY_TURN_CONTINUE && !!emptyClass
+                        && (emptyClass.kind === 'truncated' || emptyClass.kind === 'reasoning_only_active');
+                    const canRetryEmpty = isEmptyContinueKind
+                        ? emptyContinueCount < EMPTY_CONTINUE_MAX
+                        : !emptyResponseRetryUsed;
+                    if (emptyClass && canRetryEmpty) {
+                        if (isEmptyContinueKind) {
+                            emptyContinueCount++;
+                        }
+                        else {
+                            emptyResponseRetryUsed = true;
+                        }
                         console.warn(`[Orchestrator] Empty response detected (${emptyClass.kind}, hadReasoning=${emptyClass.hadReasoning}, iteration=${toolCallIteration}). ` +
                             `Retrying once with explicit completion prompt.`);
                         // R26 (2026-05-15, surfaced by A/B benchmark): the empty assistant
@@ -3613,6 +3636,7 @@ export class CortexOrchestrator {
             throw new Error('No response message returned from provider');
         }
         let currentAssistantCanonicalMessage = convertedResponse.messages[0];
+        this.recordDsmlRecovery(currentAssistantCanonicalMessage);
         const assistantMessageId = currentAssistantCanonicalMessage.uuid;
         const assistantMessage = {
             uuid: assistantMessageId,
@@ -3714,6 +3738,10 @@ export class CortexOrchestrator {
         const TURN_DEADLINE_MS = loopDefaults.turnDeadlineMs;
         const loopStartMs = Date.now();
         let timeWarnFired = false;
+        // HB-ENDTURN-TERMINAL (2026-09-08): dark gate + bounded continue-counter (streaming parity).
+        const EMPTY_TURN_CONTINUE = loopDefaults.emptyTurnContinue;
+        const EMPTY_CONTINUE_MAX = 3;
+        let emptyContinueCount = 0;
         while (hasToolUse && toolCallIteration < MAX_TOOL_ITERATIONS) {
             const gateReRequest = pendingGateRequest;
             pendingGateRequest = false;
@@ -3741,10 +3769,29 @@ export class CortexOrchestrator {
                 // R32 (streaming R18b parity): detect empty/thinking-only responses.
                 // sendMessage retries ONCE inside the loop with tools preserved.
                 const hasVisibleText = hasVisibleAssistantText(currentAssistantCanonicalMessage.content);
-                if (!hasVisibleText && !emptyResponseRetryUsed) {
-                    emptyResponseRetryUsed = true;
-                    console.warn(`[Orchestrator Streaming] R32/R18b: Empty response (no tool_use, no text, iteration=${toolCallIteration}). ` +
-                        `Retrying once with tools preserved.`);
+                // HB-ENDTURN-TERMINAL (2026-09-08): classify-first + bounded continue (streaming parity with
+                // sendMessage). Flag off → loopHasBudget false → reasoning_only_active never selected → the
+                // guard reduces to the prior `!hasVisibleText && !emptyResponseRetryUsed` one-shot.
+                const loopHasBudget = EMPTY_TURN_CONTINUE
+                    && (TURN_DEADLINE_MS <= 0 || (Date.now() - loopStartMs) < 0.6 * TURN_DEADLINE_MS)
+                    && toolCallIteration < 0.6 * MAX_TOOL_ITERATIONS;
+                const emptyClass = !hasVisibleText
+                    ? classifyEmptyResponse(currentAssistantCanonicalMessage.content, undefined, loopHasBudget)
+                    : null;
+                const isEmptyContinueKind = EMPTY_TURN_CONTINUE && !!emptyClass
+                    && (emptyClass.kind === 'truncated' || emptyClass.kind === 'reasoning_only_active');
+                const canRetryEmpty = isEmptyContinueKind
+                    ? emptyContinueCount < EMPTY_CONTINUE_MAX
+                    : !emptyResponseRetryUsed;
+                if (emptyClass && canRetryEmpty) {
+                    if (isEmptyContinueKind) {
+                        emptyContinueCount++;
+                    }
+                    else {
+                        emptyResponseRetryUsed = true;
+                    }
+                    console.warn(`[Orchestrator Streaming] R32/R18b: Empty response (${emptyClass.kind}, iteration=${toolCallIteration}). ` +
+                        `Retrying with tools preserved.`);
                     // R26 repair: ensure the empty assistant turn has content (xAI hard-400s on empty)
                     for (let i = this.messageHistory.length - 1; i >= 0; i--) {
                         const m = this.messageHistory[i];
@@ -3769,7 +3816,7 @@ export class CortexOrchestrator {
                             role: 'user',
                             content: [{
                                     type: 'text',
-                                    text: '<system-reminder>Your previous response had no visible text. Please provide your final answer in plain text now — summarize your findings or complete the requested task. Do not call any more tools.</system-reminder>',
+                                    text: `<system-reminder>${emptyResponseNudge(emptyClass.kind)}${nudgeForbidsTools(emptyClass.kind) ? ' Do not call any more tools.' : ''}</system-reminder>`,
                                 }],
                         },
                         timeline: {
@@ -4528,6 +4575,33 @@ export class CortexOrchestrator {
                     input: block.toolUse.input
                 }));
                 hasToolUse = continuationToolUses.length > 0;
+                // HB-ENDTURN-TERMINAL (2026-09-08): the streaming loop exits on a no-tool turn, so a reasoning-only
+                // continuation WITH budget would otherwise fall to the terminal R29a synth. Instead keep the loop
+                // alive with the CONTINUE nudge (mid-recon), reusing the EndTurn gate's pendingGateRequest re-request
+                // (bypasses the empty-batch break + re-execution guard). Bounded by emptyContinueCount. Runs BEFORE
+                // the EndTurn gate so a mid-recon reasoning turn continues instead of being treated as a finish.
+                if (!hasToolUse && EMPTY_TURN_CONTINUE && emptyContinueCount < EMPTY_CONTINUE_MAX
+                    && !hasVisibleAssistantText(continuationAssistantCanonicalMessage.content)) {
+                    const budget = (TURN_DEADLINE_MS <= 0 || (Date.now() - loopStartMs) < 0.6 * TURN_DEADLINE_MS)
+                        && toolCallIteration < 0.6 * MAX_TOOL_ITERATIONS;
+                    const c = classifyEmptyResponse(continuationAssistantCanonicalMessage.content, undefined, budget);
+                    if (c.kind === 'reasoning_only_active' || c.kind === 'truncated') {
+                        emptyContinueCount++;
+                        const contMsg = {
+                            uuid: uuidv4(),
+                            timestamp: new Date().toISOString(),
+                            type: 'user',
+                            message: { role: 'user', content: [{ type: 'text', text: `<system-reminder>${emptyResponseNudge(c.kind)}</system-reminder>` }] },
+                            timeline: { sessionId: this.currentSessionId, conversationId: this.currentConversationId, turnNumber: this.turnNumber + 1 },
+                            model: { id: effectiveModel.id, provider: effectiveModel.provider, apiPattern: effectiveModel.api.pattern },
+                        };
+                        this.messageHistory.push(contMsg);
+                        await this.historyStore.appendMessage(this.currentSessionId, contMsg);
+                        console.warn(`[Orchestrator Streaming] HB-ENDTURN continue (${c.kind}, iteration=${toolCallIteration}) — re-requesting with tools.`);
+                        pendingGateRequest = true;
+                        hasToolUse = true;
+                    }
+                }
                 // 4.91.0 Stage-1 for STREAMING: tools were used but no valid EndTurn yet → append the reminder and
                 // run ONE more continuation with no tool batch (pendingGateRequest bypasses the empty-batch break
                 // and the re-execution guard). Two nudges, then fallback-accept (parity with sendMessage).
@@ -4993,6 +5067,10 @@ export class CortexOrchestrator {
             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),
+            // HB-ENDTURN-TERMINAL (2026-09-08, dark by default): when true, a reasoning-only empty turn WITH
+            // budget remaining is treated as mid-recon (continue-with-tools) instead of forced terminal
+            // surrender. Read as a dark lever (direct env), off = byte-identical to prior behavior.
+            emptyTurnContinue: process.env.CORTEX_EMPTY_TURN_CONTINUE === 'true',
         };
     }
     // Item 13c: fire on threshold CROSSINGS only (10, 20, 40… doubling) — the
@@ -7356,6 +7434,31 @@ export class CortexOrchestrator {
         }
         return this.decisionStore;
     }
+    /** HB-DSML-PARSE observability (2026-09-09): if the DeepSeek DSML tool-call recovery fired on this
+     *  response (recovered tool_use ids are prefixed `dsml_`), record ONE countable `dsml_recovered`
+     *  decision event so the bench data shows how often the leak occurred + that the fix is live.
+     *  Observability only — never throws into the turn. */
+    recordDsmlRecovery(msg) {
+        try {
+            const content = Array.isArray(msg?.content) ? msg.content : [];
+            const recovered = content.filter((b) => b?.type === 'tool_use' && typeof b?.toolUse?.id === 'string' && b.toolUse.id.startsWith('dsml_'));
+            if (recovered.length === 0)
+                return;
+            const store = this.getDecisionStore();
+            if (store) {
+                void store
+                    .recordEvent({
+                    sessionId: this.currentSessionId ?? 'unknown',
+                    kind: 'dsml_recovered',
+                    detail: { count: recovered.length, tools: recovered.map((b) => b.toolUse?.name) },
+                })
+                    .catch(() => { });
+            }
+            if (this.config.debug)
+                console.log(`[HB-DSML-PARSE] dsml_recovered event (count=${recovered.length})`);
+        }
+        catch { /* observability only */ }
+    }
     isRecordingEnabled() {
         return process.env.CORTEX_RECORD_DECISIONS !== 'false';
     }