@nexus-cortex/core 4.88.1 → 4.88.3

package/dist/orchestrator/CortexOrchestrator.js

@@ -1199,6 +1199,9 @@ export class CortexOrchestrator {
         // read this turn (verifyCoordinates). Stage-2-grounded citations are the
         // trusted baseline a coordinate must map to.
         let lastEndTurnCitations;
+        // EFFORT TAIL one-shot (def-efdbb67fd8): the first EndTurn of this turn has
+        // been bounced for a high-effort re-attestation cycle.
+        let effortTailBounced = false;
         let endTurnLastToolName; // for the cortex training record
         // R60: the ROUTING decision = the FIRST real tool called in response to the
         // user prompt, WITH ITS ACTUAL INPUT ARGS. Previously the router sample's
@@ -2031,6 +2034,32 @@ export class CortexOrchestrator {
                         if (tr.tool_name !== 'EndTurn')
                             continue;
                         const etUse = toolUseBlocks.find((t) => t.name === 'EndTurn');
+                        // EFFORT TAIL (def-efdbb67fd8, finish-discipline half): the FIRST
+                        // EndTurn is the model's own "I'm done" declaration — generated at
+                        // body effort. Bounce it ONCE ("verify at depth") and arm the effort
+                        // pulse so the re-attestation cycle runs elevated: structure forces
+                        // the check (the gate), effort funds it (the pulse). One-shot per
+                        // turn; skipped when a thrash pulse is already active (chain already
+                        // elevated). Rides the same is_error rejection channel as Stages
+                        // 2/4/5; liveness bounded by the gate's existing fallback-accept.
+                        // Requires CORTEX_ENDTURN_GATE (EndTurn must be offered). Ship dark.
+                        if (process.env.CORTEX_EFFORT_TAIL === 'true' &&
+                            !effortTailBounced &&
+                            this.effortPulseRemaining <= 0) {
+                            effortTailBounced = true;
+                            const tailTurns = Math.max(1, parseInt(process.env.CORTEX_EFFORT_TAIL_TURNS || '2', 10) || 2);
+                            this.effortPulseRemaining = tailTurns;
+                            tr.is_error = true;
+                            tr.content =
+                                'Before finishing: verify at depth. Re-read the original task statement; ' +
+                                    're-open and check each requirement against the ACTUAL files/outputs you produced this turn ' +
+                                    '(do not rely on memory of them); fix anything that does not match; then call EndTurn again ' +
+                                    'with the verified attestation.';
+                            if (this.config.debug) {
+                                console.log(`[EffortTail] first EndTurn bounced — re-attestation at elevated effort (${this.effortPulseRemaining} continuation(s))`);
+                            }
+                            continue;
+                        }
                         const cits = etUse?.input?.citations;
                         lastEndTurnCitations = Array.isArray(cits) ? cits : undefined; // Stage 3 baseline
                         const verdict = verifyCitationsGrounded(cits, thisTurnToolOutputs.join('\n'));
@@ -2385,7 +2414,7 @@ export class CortexOrchestrator {
                         temperature: options.parameters?.temperature,
                         maxTokens: options.parameters?.maxTokens,
                         topP: options.parameters?.topP,
-                        reasoningEffort: options.parameters?.reasoningEffort, // GPT-5.1 reasoning level
+                        reasoningEffort: this.consumeEffortPulse() ?? options.parameters?.reasoningEffort, // effort pulse > request param > card
                         stream: options.streaming,
                         staticSystemPrompt: this.currentStaticSystemPrompt, // R28
                         conversationId: this.currentConversationId, // R28b
@@ -4009,7 +4038,7 @@ export class CortexOrchestrator {
                     temperature: options.parameters?.temperature,
                     maxTokens: options.parameters?.maxTokens,
                     topP: options.parameters?.topP,
-                    reasoningEffort: options.parameters?.reasoningEffort, // GPT-5.1 reasoning level
+                    reasoningEffort: this.consumeEffortPulse() ?? options.parameters?.reasoningEffort, // effort pulse > request param > card
                     stream: true, // STREAMING continuation
                     staticSystemPrompt: this.currentStaticSystemPrompt, // R28
                     conversationId: this.currentConversationId, // R28b
@@ -6887,6 +6916,17 @@ export class CortexOrchestrator {
             return undefined; // fail-open: never let the thrash read break a turn
         }
     }
+    /** EFFORT PULSE (ablation 'think harder' arm, def-efdbb67fd8): continuations
+     *  remaining at elevated reasoning effort after a cumulative-thrash trigger. */
+    effortPulseRemaining = 0;
+    /** While the pulse is armed, continuation requests run at the elevated level
+     *  (CORTEX_EFFORT_PULSE_LEVEL, default 'high'); decrements per consumed request. */
+    consumeEffortPulse() {
+        if (this.effortPulseRemaining <= 0)
+            return undefined;
+        this.effortPulseRemaining -= 1;
+        return (process.env.CORTEX_EFFORT_PULSE_LEVEL || 'high');
+    }
     /** Honored AskForAdvice consults per session (rate-limit + rung state; persists across turns). */
     mentorConsultCounts = new Map();
     /**
@@ -7070,6 +7110,39 @@ export class CortexOrchestrator {
                         }
                     }
                 }
+                // EFFORT PULSE trigger (def-efdbb67fd8, 'think harder' ablation arm): on
+                // cumulative thrash, escalate reasoning effort for the next N continuation
+                // requests — deep deliberation bought exactly at the stuck point. The
+                // introspective CONTRAST to the mentor's decorrelative consult: same
+                // trigger, same rstan gate (cumulative threshold), INDEPENDENT of
+                // CORTEX_MENTOR_AUTO so each ablation arm isolates cleanly. Ship dark.
+                if (process.env.CORTEX_EFFORT_PULSE === 'true' && outcome.status !== 'ok') {
+                    const cfgP = resolveThrashConfig();
+                    const [pOutcomes, pPrior] = await Promise.all([
+                        store.recentOutcomes(cfgP.window),
+                        store.failureCount(this.currentSessionId ?? 'unknown'),
+                    ]);
+                    pOutcomes.push(false);
+                    const pCum = pPrior + 1;
+                    const pState = resolveThrashState(pOutcomes, pCum, cfgP, pCum);
+                    if (pState.thrashing) {
+                        const turns = Math.max(1, parseInt(process.env.CORTEX_EFFORT_PULSE_TURNS || '2', 10) || 2);
+                        if (this.effortPulseRemaining < turns)
+                            this.effortPulseRemaining = turns;
+                        if (this.config.debug) {
+                            console.log(`[EffortPulse] armed (trigger: ${pState.trigger}, cumFails: ${pCum}) — next ${this.effortPulseRemaining} continuation(s) at elevated effort`);
+                        }
+                        // Mechanism-engagement evidence (bench adjudication rule): bank the
+                        // arm-fired fact in the decision store — console logs are not
+                        // harvested, so without this the pulse arm cannot prove it fired.
+                        void store.recordEvent({
+                            sessionId: this.currentSessionId ?? 'unknown',
+                            kind: 'effort_pulse',
+                            toolName: toolUse.name,
+                            detail: { trigger: pState.trigger, cumFailures: pCum, turns: this.effortPulseRemaining, level: process.env.CORTEX_EFFORT_PULSE_LEVEL || 'high' },
+                        }).catch(() => { });
+                    }
+                }
             }
             catch (err) {
                 if (this.config.debug) {