@nexus-cortex/core 4.124.39 → 4.124.41

package/dist/orchestrator/CortexOrchestrator.js

@@ -20,7 +20,7 @@ import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
 import { execSync } from 'node:child_process';
 import { ENV_RECON_COMMAND, resolveLiftPlanConfig, parsePlannerResponse, bankPlanText } from '../training/liftPlanner.js';
 import { clipIn, FULL_CAPS, HINTS, resolveInventory, resolveInventoryPath } from '../training/steerInputs.js';
-import { resolveEndTurnResolverConfig, parseResolverVerdict, effectiveMaxRejects, budgetedVetoEscalation, decideVetoAction, shouldFinishConfirm, buildFinishConfirmMessage, buildMeetsConfirmMessage, gapHoldable, parseSpecChecks, groundSpecCheck, specFailFraction, applyVetoFloor, holdProgressed, planSimilarity, specCheckEvidence, specBlockForJudge, dropSpecEchoes, specBlockForWriter, vetoMessageLead } from '../training/endTurnResolver.js';
+import { resolveEndTurnResolverConfig, parseResolverVerdict, effectiveMaxRejects, budgetedVetoEscalation, decideVetoAction, shouldFinishConfirm, buildFinishConfirmMessage, buildMeetsConfirmMessage, gapHoldable, parseSpecChecks, groundSpecCheck, specFailFraction, applyVetoFloor, holdProgressed, planSimilarity, specCheckEvidence, specBlockForJudge, dropSpecEchoes, specBlockForWriter, vetoMessageLead, RESOLVER_SCALE_CLAUSE } from '../training/endTurnResolver.js';
 import { jevAvailable, jevNoul, buildGapHoldState, GAP_HOLD_QUESTIONS } from '../training/jevGate.js'; // R173b
 import { resolveFrameConfig, FRAME_CONTRACT, FRAME_TOOL_NAME } from '../frames/frameConfig.js'; // R179
 import { FrameRunner } from '../frames/frameRunner.js'; // R179
@@ -91,6 +91,8 @@ 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 { resolvePid1Guard, detectPid1Note } from './pid1Guard.js'; // R209
+import { PlateauStopTracker, plateauBootInstruction, plateauStatusSegment } from './plateauStop.js'; // R210
 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
@@ -214,6 +216,9 @@ export class CortexOrchestrator {
      *  exactly once, at the anchor-lift boundary. One-shot per orchestrator. */
     deferredCorpusDelivered = false;
     liftNudgeDelivered = false; // A′ proposal-1: lift-boundary SearchTools/AskForAdvice nudge, one-shot
+    pid1NoteChecked = false; // R209 HB-CONTAINER-PID1: PID 1 inspected once, at the first tool_result boundary
+    plateauInstructionDelivered = false; // R210 HB-PLATEAU-STOP: boot instruction, one-shot at the first tool_result boundary
+    plateauTracker = new PlateauStopTracker(); // R210: per-session PLATEAU_METRIC series
     // CORTEX_LOOP_TOOL_BLOCK (hard loop intervention): when the ladder flags a
     // non-converging same-approach loop, disable the looping tool's EXECUTOR for
     // ONE turn (tools list unchanged → cache-safe); a call to it returns an
@@ -401,6 +406,75 @@ export class CortexOrchestrator {
             return tools; // interactive: keep it
         return tools.filter((t) => t.name !== 'AskUserQuestion');
     }
+    /** R209 HB-CONTAINER-PID1 (CORTEX_PID1_GUARD=on, dark): at the first tool_result boundary (the boot observation), when PID 1 is not
+     *  the harness, append ONE note naming PID 1 and the services it supervises — killing them stops the container and ends the session.
+     *  Independent of the tool anchor. One-shot; Linux-only; fail-safe (no note on any error). Event pid1_guard when the note is added. */
+    deliverPid1NoteAtBoot() {
+        if (this.pid1NoteChecked || !resolvePid1Guard())
+            return;
+        try {
+            const lastMsg = this.messageHistory[this.messageHistory.length - 1];
+            if (lastMsg?.message?.content?.[0]?.type !== 'tool_result')
+                return; // not the boundary yet — leave the one-shot open
+            this.pid1NoteChecked = true;
+            const r = detectPid1Note();
+            if (!r)
+                return;
+            lastMsg.message.content.push({ type: 'text', text: `<system-reminder>\n${r.note}\n</system-reminder>` });
+            const store = this.getDecisionStore();
+            if (store)
+                void store.recordEvent({ sessionId: this.currentSessionId ?? 'unknown', kind: 'pid1_guard', detail: { noted: true, pid1Cmd: r.info.pid1Cmd, children: r.info.children, chars: r.note.length } }).catch(() => { });
+            if (this.config.debug)
+                console.log(`[Pid1Guard] boot note delivered (PID 1 = ${r.info.pid1Cmd}, ${r.info.children.length} child(ren))`);
+        }
+        catch { /* fail-safe: no note */ }
+    }
+    /** R210 HB-PLATEAU-STOP (CORTEX_PLATEAU_STOP=on, dark): at the first tool_result boundary (same carrier and boundary as the R209
+     *  PID 1 note), append ONE system-reminder asking the model to print `PLATEAU_METRIC <name>=<number> dir=<max|min>` after every
+     *  evaluation and keep the deliverable at its best result. Off → nothing. One-shot; fail-safe. */
+    deliverPlateauInstructionAtBoot() {
+        if (this.plateauInstructionDelivered)
+            return;
+        try {
+            const text = plateauBootInstruction();
+            if (!text)
+                return;
+            const lastMsg = this.messageHistory[this.messageHistory.length - 1];
+            if (lastMsg?.message?.content?.[0]?.type !== 'tool_result')
+                return; // not the boundary yet — leave the one-shot open
+            this.plateauInstructionDelivered = true;
+            lastMsg.message.content.push({ type: 'text', text: `<system-reminder>\n${text}\n</system-reminder>` });
+            if (this.config.debug)
+                console.log('[PlateauStop] boot instruction delivered');
+        }
+        catch { /* fail-safe: no instruction */ }
+    }
+    /** R210 HB-PLATEAU-STOP: scan this round's tool results for PLATEAU_METRIC reports and return the plateau reminder (or null) for
+     *  the budget-steering signals line. Off → null without scanning. Events: plateau_metric_seen (first report of a metric name),
+     *  plateau_stop (each firing, max 2 per session). Never throws. */
+    observePlateau(toolResults, iteration, streaming) {
+        try {
+            const r = this.plateauTracker.step(toolResults); // off → returns before touching the results
+            if (!r.newMetrics.length && !r.fire)
+                return null;
+            const store = this.getDecisionStore();
+            const sessionId = this.currentSessionId ?? 'unknown';
+            for (const m of r.newMetrics) {
+                if (store)
+                    void store.recordEvent({ sessionId, kind: 'plateau_metric_seen', detail: { name: m.name, dir: m.dir, value: m.value, iteration, streaming } }).catch(() => { });
+            }
+            if (r.fire) {
+                if (store)
+                    void store.recordEvent({ sessionId, kind: 'plateau_stop', detail: { ...r.fire, iteration, streaming } }).catch(() => { });
+                if (this.config.debug)
+                    console.log(`[PlateauStop] ${r.fire.name} plateau (${r.fire.improvementPct}% over the window, ${r.fire.points} points) — firing ${r.fire.firing}`);
+            }
+            return r.signal;
+        }
+        catch {
+            return null;
+        }
+    }
     /** A′ proposal-1: at the anchor-lift boundary, when deferred loading is on and
      *  CORTEX_LIFT_NUDGE is truthy, append a MINIMAL system-reminder pointing the model
      *  at SearchTools (to reach the tools the deferred filter hides — names come from
@@ -1290,6 +1364,9 @@ export class CortexOrchestrator {
             // what it judged, not just counts — so a k=5 run can score the resolver's JUDGMENT QUALITY
             // (was the GAP warranted? was the fix plan good? did it judge the right artifact?) and not
             // merely that it fired. Bounded caps keep the decisions row sane. See HARNESS_IMPROVEMENT_BACKLOG.
+            // R208 HB-VERIFY-AT-SCALE (CORTEX_VERIFY_SCALE=on, dark): the judge persona carried the scale rubric item on this adjudication.
+            if (store && cfg.verifyScale)
+                void store.recordEvent({ sessionId, kind: 'verify_scale_item', toolName: 'EndTurn', detail: { surface: 'endturn-resolver', clauseChars: RESOLVER_SCALE_CLAUSE.length, roundsUsed, meets: verdict.meets, parsed: verdict.parsed, confidence: verdict.confidence } }).catch(() => { });
             if (store)
                 void store.recordEvent({
                     sessionId,
@@ -1309,6 +1386,7 @@ export class CortexOrchestrator {
                         derivation: cfg.derivation, derivationAgreement: derivationInfo?.agreement ?? null, derivationHeld: !!derivationHold, // R176
                         reqLedger: cfg.reqLedger, reqLines: reqCounts.lines, reqOpen: reqCounts.open, reqExercised: reqCounts.exercised, reqFailed: reqCounts.failed, reqUnverifiable: reqCounts.unverifiable, reqHeld: !!reqHold, reqHolds: this.reqLedgerHolds, reqGenLatencyMs: this.reqLedgerMeta.genLatencyMs, reqJev: cfg.reqLedgerJev, reqJevAsked: reqJev?.asked ?? 0, reqJevClosed: reqJev?.closed ?? [], reqJevLatencyMs: reqJev?.latencyMs ?? 0, // R187/R187b
                         reqFailVeto: !!reqFailVeto, reqFailVetoes: this.reqLedgerFailVetoes, reqFailedNow, reqFailJev, // R192
+                        verifyScale: cfg.verifyScale, // R208
                         reqBroken: [...this.reqLedgerBroken], reqLinesDetail: (this.reqLedger ?? []).map((e) => ({ id: e.id, kind: e.kind, status: e.status, check: !!e.check, runs: e.runs, last: (e.lastResult ?? '').split('\n').slice(0, 2).join(' / ').slice(0, 200) })), // R191: per-line outcomes so a false-failure read is possible from the decisions file
                         latencyMs, rawLen: (text ?? '').length,
                         deltaChars: workspaceDelta.length, checkRan: !!checkResult, checkPassed: checkResult ? /→ PASSED/.test(checkResult) : null,
@@ -3482,8 +3560,10 @@ export class CortexOrchestrator {
                         }
                         timeSignal = de?.signal || timeBudgetWarnNudge(Date.now() - loopStartMs, TURN_DEADLINE_MS);
                     }
-                    if (budgetSignal || diversityWarning || ladderSignal || timeSignal || budgetVisSignal) {
-                        const signals = [budgetSignal, diversityWarning, ladderSignal, timeSignal, budgetVisSignal].filter(Boolean).join('\n');
+                    // R210 HB-PLATEAU-STOP (dark unless CORTEX_PLATEAU_STOP): PLATEAU_METRIC series → one stop reminder on a plateau (same carrier).
+                    const plateauSignal = this.observePlateau(toolResults, toolCallIteration, false);
+                    if (budgetSignal || diversityWarning || ladderSignal || timeSignal || budgetVisSignal || plateauSignal) {
+                        const signals = [budgetSignal, diversityWarning, ladderSignal, timeSignal, budgetVisSignal, plateauSignal].filter(Boolean).join('\n');
                         const lastMsg = this.messageHistory[this.messageHistory.length - 1];
                         if (lastMsg?.message?.content?.[0]?.type === 'tool_result') {
                             const block = lastMsg.message.content[0];
@@ -3502,6 +3582,7 @@ export class CortexOrchestrator {
                                     ladderSignal ? (ladderPollSteer ? 'poll_steer' : 'ladder') : null,
                                     timeSignal ? 'time' : null,
                                     budgetVisSignal ? 'budget_visibility' : null,
+                                    plateauSignal ? 'plateau' : null,
                                 ].filter(Boolean);
                                 void store
                                     .recordEvent({
@@ -3589,6 +3670,8 @@ export class CortexOrchestrator {
                     // Send tool results back to model and get continuation response
                     // Proactive context management - ensure history fits before continuation
                     await this.ensureHistoryFitsModel(effectiveModel);
+                    this.deliverPid1NoteAtBoot(); // R209 HB-CONTAINER-PID1 (dark unless CORTEX_PID1_GUARD): PID 1 note on the boot observation
+                    this.deliverPlateauInstructionAtBoot(); // R210 HB-PLATEAU-STOP (dark unless CORTEX_PLATEAU_STOP): PLATEAU_METRIC instruction
                     // Anchor lift (BASH_PLUS_SPEC.md P0): the first tool call has executed —
                     // this continuation is the first tool_result boundary, so the session's
                     // full profile applies from here. Rebuild from allTools because the
@@ -5316,8 +5399,10 @@ export class CortexOrchestrator {
                     }
                     timeSignal = de?.signal || timeBudgetWarnNudge(Date.now() - loopStartMs, TURN_DEADLINE_MS);
                 }
-                if (budgetSignal || diversityWarning || ladderSignal || timeSignal || budgetVisSignal) {
-                    const signals = [budgetSignal, diversityWarning, ladderSignal, timeSignal, budgetVisSignal].filter(Boolean).join('\n');
+                // R210 HB-PLATEAU-STOP (streaming parity).
+                const plateauSignal = this.observePlateau(toolResults, toolCallIteration, true);
+                if (budgetSignal || diversityWarning || ladderSignal || timeSignal || budgetVisSignal || plateauSignal) {
+                    const signals = [budgetSignal, diversityWarning, ladderSignal, timeSignal, budgetVisSignal, plateauSignal].filter(Boolean).join('\n');
                     const lastMsg = this.messageHistory[this.messageHistory.length - 1];
                     if (lastMsg?.message?.content?.[0]?.type === 'tool_result') {
                         const block = lastMsg.message.content[0];
@@ -5333,6 +5418,7 @@ export class CortexOrchestrator {
                                 ladderSignal ? (ladderPollSteer ? 'poll_steer' : 'ladder') : null,
                                 timeSignal ? 'time' : null,
                                 budgetVisSignal ? 'budget_visibility' : null,
+                                plateauSignal ? 'plateau' : null,
                             ].filter(Boolean);
                             void store
                                 .recordEvent({
@@ -5412,6 +5498,8 @@ export class CortexOrchestrator {
                 // Send continuation request with tool results
                 // Proactive context management - ensure history fits before streaming continuation
                 await this.ensureHistoryFitsModel(effectiveModel);
+                this.deliverPid1NoteAtBoot(); // R209 HB-CONTAINER-PID1 — streaming mirror
+                this.deliverPlateauInstructionAtBoot(); // R210 HB-PLATEAU-STOP — streaming mirror
                 // Anchor lift — streaming mirror of the sendMessage continuation path.
                 if (!this.anchorLifted &&
                     resolveToolAnchor(process.env, this.cardAnchorProfile) &&
@@ -6826,6 +6914,7 @@ export class CortexOrchestrator {
                 contextWindow: model.limits?.contextWindow ?? this.lastKnownContextWindow,
                 shells,
                 nowMs: now,
+                plateau: plateauStatusSegment(this.plateauTracker), // R210: null when CORTEX_PLATEAU_STOP is off or no metric seen → line unchanged
             });
             if (appendStatusToNewestToolResult(this.messageHistory, line)) {
                 this.turnStatusLines++;