@nexus-cortex/core 4.124.37 → 4.124.38

package/dist/orchestrator/CortexOrchestrator.js

@@ -90,6 +90,7 @@ import { InitCortexContext, MemoryWrite, MemoryRecall } from '../tools/context-m
 import { pruneAgedToolResults } from '../conversation/ToolResultPruner.js';
 import { detectTailRepetition, tailLoopGuardEnabled } from './tailRepetitionDetector.js';
 import { resolveEffortRamp, rampEffortFor } from './effortRamp.js';
+import { resolveWallDrop, resolveOutputCap, dropWalledTurn, resolveWallSummary, extractWalledReasoning, clipReasoning, formatWallSummary } from './wallGuard.js';
 import { resolveComputeNudge, computeNudgeDecision, buildComputeNudgeLine, lastAssistantReasoningTokens } from './computeNudge.js';
 import { classifyEmptyResponse, emptyResponseNudge, nudgeForbidsTools, emptyResponseNudgeFor, isReasoningExhaustion, stepDownEffort, effortLadderFor, resolveExhaustLadderMode, resolveReasoningExhaustBackoff } from './emptyResponseClassifier.js';
 import { isImageRejectionError, stripRejectedImages } from './imageRejectionHeal.js'; // R154
@@ -1707,6 +1708,7 @@ export class CortexOrchestrator {
         if (!this.sessionTimeline) {
             throw new Error('Session not initialized. Call createSession() first.');
         }
+        this.applyOutputCap(options); // HB-OUTPUT-CAP (dark)
         // Item 10: full-mass pre-assembly boundary — doctrine curation completes
         // BEFORE the turn-0 prompt is built (under defer this no-ops here and the
         // lift boundary awaits instead; one-shot flag makes both calls safe).
@@ -2572,6 +2574,10 @@ export class CortexOrchestrator {
                         console.warn(`[Orchestrator] Empty response detected (${emptyClass.kind}, hadReasoning=${emptyClass.hadReasoning}, iteration=${toolCallIteration}). ` +
                             `Retrying once with explicit completion prompt.`);
                         const exhaustionLevel = this.armReasoningBackoffIfExhausted(emptyClass, options.parameters?.reasoningEffort ?? effectiveModel?.reasoning?.effort, toolCallIteration, currentAssistantMessage?.usage?.outputTokens, effectiveModel.provider);
+                        // HB-WALL-DROP (CORTEX_WALL_DROP, dark): drop the walled turn + carry the nudge on the newest tool_result (cache-preserving retry).
+                        const wallSummary = await this.summarizeWall(emptyClass, toolCallIteration, false); // HB-WALL-SUMMARY (dark); '' when off/failed
+                        const wallNudge = `<system-reminder>${emptyResponseNudgeFor(emptyClass, exhaustionLevel, effectiveModel?.limits?.outputTokens)}${nudgeForbidsTools(emptyClass.kind) ? ' Do not call any more tools.' : ''}${wallSummary}</system-reminder>`;
+                        const wallDrop = this.applyWallDrop(emptyClass, wallNudge, toolCallIteration, false);
                         // R26 (2026-05-15, surfaced by A/B benchmark): the empty assistant
                         // turn is already in messageHistory. The retry below rebuilds the
                         // full history and re-sends it. Anthropic's Messages API tolerates
@@ -2580,8 +2586,8 @@ export class CortexOrchestrator {
                         // the entire retry. R18b was validated on Claude, so this was
                         // invisible until a grok run emitted an empty turn. Repair the
                         // empty assistant message in-place with a minimal placeholder so
-                        // every provider's message-content contract is satisfied.
-                        for (let i = this.messageHistory.length - 1; i >= 0; i--) {
+                        // every provider's message-content contract is satisfied. (Skipped when HB-WALL-DROP removed the turn.)
+                        for (let i = wallDrop.dropped ? -1 : this.messageHistory.length - 1; i >= 0; i--) {
                             const m = this.messageHistory[i];
                             const isAssistant = m?.type === 'assistant' || m?.message?.role === 'assistant';
                             if (!isAssistant)
@@ -2610,7 +2616,7 @@ export class CortexOrchestrator {
                                 role: 'user',
                                 content: [{
                                         type: 'text',
-                                        text: `<system-reminder>${emptyResponseNudgeFor(emptyClass, exhaustionLevel, effectiveModel?.limits?.outputTokens)}${nudgeForbidsTools(emptyClass.kind) ? ' Do not call any more tools.' : ''}</system-reminder>`,
+                                        text: wallNudge,
                                     }],
                             },
                             timeline: {
@@ -2624,8 +2630,10 @@ export class CortexOrchestrator {
                                 apiPattern: effectiveModel.api.pattern,
                             },
                         };
-                        this.messageHistory.push(followupUserMessage);
-                        await this.historyStore.appendMessage(this.currentSessionId, followupUserMessage);
+                        if (wallDrop.carrier !== 'tool_result') { // HB-WALL-DROP carried the nudge on the newest tool_result already
+                            this.messageHistory.push(followupUserMessage);
+                            await this.historyStore.appendMessage(this.currentSessionId, followupUserMessage);
+                        }
                         // Build a continuation request and re-call. Mirrors the
                         // tool-result continuation path (lines ~1395-1466) but without
                         // tool_result blocks.
@@ -4130,6 +4138,7 @@ export class CortexOrchestrator {
         if (!this.currentSessionId || !this.sessionTimeline) {
             throw new Error('Session not initialized. Call createSession() first.');
         }
+        this.applyOutputCap(options); // HB-OUTPUT-CAP (dark)
         // Graduation-signal capture (Decision Capture Layer §5) — same as sendMessage:
         // score the previous turn's prediction against THIS user message + record.
         if (this.pendingTurnPrediction && this.pendingTurnPrediction.sessionId === this.currentSessionId) {
@@ -4778,8 +4787,12 @@ export class CortexOrchestrator {
                     console.warn(`[Orchestrator Streaming] R32/R18b: Empty response (${emptyClass.kind}, iteration=${toolCallIteration}). ` +
                         `Retrying with tools preserved.`);
                     const exhaustionLevel = this.armReasoningBackoffIfExhausted(emptyClass, options.parameters?.reasoningEffort ?? effectiveModel?.reasoning?.effort, toolCallIteration, this.messageHistory[this.messageHistory.length - 1]?.usage?.outputTokens, effectiveModel.provider);
-                    // R26 repair: ensure the empty assistant turn has content (xAI hard-400s on empty)
-                    for (let i = this.messageHistory.length - 1; i >= 0; i--) {
+                    // HB-WALL-DROP (streaming parity).
+                    const wallSummary = await this.summarizeWall(emptyClass, toolCallIteration, true);
+                    const wallNudge = `<system-reminder>${emptyResponseNudgeFor(emptyClass, exhaustionLevel, effectiveModel?.limits?.outputTokens)}${nudgeForbidsTools(emptyClass.kind) ? ' Do not call any more tools.' : ''}${wallSummary}</system-reminder>`;
+                    const wallDrop = this.applyWallDrop(emptyClass, wallNudge, toolCallIteration, true);
+                    // R26 repair: ensure the empty assistant turn has content (xAI hard-400s on empty). Skipped when HB-WALL-DROP removed it.
+                    for (let i = wallDrop.dropped ? -1 : this.messageHistory.length - 1; i >= 0; i--) {
                         const m = this.messageHistory[i];
                         const isAssistant = m?.type === 'assistant' || m?.message?.role === 'assistant';
                         if (!isAssistant)
@@ -4802,7 +4815,7 @@ export class CortexOrchestrator {
                             role: 'user',
                             content: [{
                                     type: 'text',
-                                    text: `<system-reminder>${emptyResponseNudgeFor(emptyClass, exhaustionLevel, effectiveModel?.limits?.outputTokens)}${nudgeForbidsTools(emptyClass.kind) ? ' Do not call any more tools.' : ''}</system-reminder>`,
+                                    text: wallNudge,
                                 }],
                         },
                         timeline: {
@@ -4816,8 +4829,10 @@ export class CortexOrchestrator {
                             apiPattern: effectiveModel.api.pattern,
                         },
                     };
-                    this.messageHistory.push(followupUserMessage);
-                    await this.historyStore.appendMessage(this.currentSessionId, followupUserMessage);
+                    if (wallDrop.carrier !== 'tool_result') {
+                        this.messageHistory.push(followupUserMessage);
+                        await this.historyStore.appendMessage(this.currentSessionId, followupUserMessage);
+                    }
                     try {
                         await this.ensureHistoryFitsModel(effectiveModel);
                         const retryEffort = this.consumeReasoningBackoff() ?? options.parameters?.reasoningEffort; // R153 backoff > request param
@@ -9219,6 +9234,57 @@ export class CortexOrchestrator {
             return undefined;
         }
     }
+    /** HB-WALL-SUMMARY (CORTEX_WALL_SUMMARY=on, dark): one helper call condensing the walled turn's reasoning; returns the attributed block for
+     *  the nudge, or '' (off / not a reasoning wall / no reasoning / timeout / error). Must run BEFORE HB-WALL-DROP removes the turn. */
+    async summarizeWall(cls, iteration, streaming) {
+        const cfg = resolveWallSummary();
+        if (!cfg.enabled || !isReasoningExhaustion(cls) || !this.helperMiddleware?.summarizeWalledThinking)
+            return '';
+        const t0 = Date.now();
+        let block = '';
+        let inputChars = 0;
+        let ok = false;
+        try {
+            const reasoning = extractWalledReasoning(this.messageHistory);
+            inputChars = reasoning.length;
+            if (reasoning.trim()) {
+                const reply = await withTimeout(this.helperMiddleware.summarizeWalledThinking({ reasoning: clipReasoning(reasoning, cfg.headChars, cfg.tailChars), helperModelId: this.config.reactiveMentorship?.helperModelId }), cfg.timeoutMs);
+                block = formatWallSummary(typeof reply === 'string' ? reply : '');
+                ok = !!block;
+            }
+        }
+        catch {
+            block = '';
+        }
+        const store = this.getDecisionStore();
+        if (store)
+            void store.recordEvent({ sessionId: this.currentSessionId ?? 'unknown', kind: 'wall_summary', detail: { iteration, inputChars, summaryChars: block.length, ok, ms: Date.now() - t0, streaming } }).catch(() => { });
+        return block;
+    }
+    /** HB-OUTPUT-CAP (CORTEX_OUTPUT_CAP_TOKENS, dark): fills the action model's maxTokens when the request did not set one. */
+    applyOutputCap(options) {
+        const cap = resolveOutputCap();
+        if (!cap)
+            return;
+        options.parameters = options.parameters || {};
+        options.parameters.maxTokens ??= cap;
+    }
+    /** HB-WALL-DROP (CORTEX_WALL_DROP=on, dark): on a reasoning-exhaustion wall, drop the walled turn from the in-memory history and carry
+     *  the nudge on the newest tool_result; one wall_drop event per drop. Fail-open (no drop). */
+    applyWallDrop(cls, nudge, iteration, streaming) {
+        try {
+            if (!isReasoningExhaustion(cls) || !resolveWallDrop())
+                return { dropped: false };
+            const r = dropWalledTurn(this.messageHistory, nudge);
+            const store = this.getDecisionStore();
+            if (r.dropped && store)
+                void store.recordEvent({ sessionId: this.currentSessionId ?? 'unknown', kind: 'wall_drop', detail: { iteration, droppedChars: r.droppedChars, carrier: r.carrier, streaming } }).catch(() => { });
+            return r;
+        }
+        catch {
+            return { dropped: false };
+        }
+    }
     /**
      * HB-COMPUTE-NUDGE (CORTEX_COMPUTE_NUDGE=on, dark): when the response that issued this round reasoned past the threshold,
      * append one 'compute/test instead of deliberating' line to the tail of the newest tool_result (the HB-TURN-STATUS carrier —