@nexus-cortex/core 4.124.14 → 4.124.17

package/dist/orchestrator/CortexOrchestrator.js

@@ -23,7 +23,8 @@ import { resolveEndTurnResolverConfig, parseResolverVerdict, effectiveMaxRejects
 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
-import { parseRequirementLedger, initLedger, updateLedger, ledgerCounts, ledgerHoldable, formatLedgerForWriter, formatLedgerForJudge, formatLedgerHoldMessage, buildLedgerJevState, buildLedgerJevQuestions, applyLedgerJevAnswers } from '../training/requirementLedger.js'; // R187
+import { emptySessionUsage, addMainUsage } from '../training/usageAccounting.js'; // R190
+import { parseRequirementLedger, initLedger, updateLedger, ledgerCounts, ledgerHoldable, formatLedgerForWriter, formatLedgerForJudge, formatLedgerHoldMessage, buildLedgerJevState, buildLedgerJevQuestions, applyLedgerJevAnswers, looksLikeBrokenCheck } from '../training/requirementLedger.js'; // R187 / R191
 import { isValueShapedTask, parseDerivationReply, methodsDiffer, parseValueLines, extractNumbers, reconcile, buildDerivationHoldMessage, isDerivationCommandAllowed, checkRunPassed, checkRunBody } from '../training/independentDerivation.js'; // R176
 import { resolveDeadlineExitConfig, deadlineExitCallBudget, parseDeadlineExitVerdict } from '../training/deadlineExitMentor.js';
 import { isTaskShaped } from './requirementsVerification.js';
@@ -252,8 +253,11 @@ export class CortexOrchestrator {
     specChecksPromise = null; // R174b: authored at lift in the background (CORTEX_JUDGE_SPEC_TESTS_AT=lift)
     reqLedger = null; // R187: the stated-requirement ledger for this turn (null = not yet authored)
     reqLedgerPromise = null; // R187: authored at lift in the background
+    sessionUsage = emptySessionUsage(); // R190: every main-model request this session (exact) + helper calls (estimated)
     reqLedgerHolds = 0; // R187: ledger holds used this turn
+    reqLedgerRetried = false; // R187c: one re-author at the first finish after an empty lift-time result
     reqLedgerMeta = { genLatencyMs: 0, raw: 0, refused: 0 }; // R187
+    reqLedgerBroken = new Set(); // R191: ids whose check was dropped as malformed
     specFailHistory = new Map(); // R174b: consecutive identical spec failures
     lastHoldMs = 0; // R173c: wall clock of the last hold/veto this turn
     derivationHolds = 0; // R176: independent-derivation holds this turn (max 1)
@@ -603,6 +607,15 @@ export class CortexOrchestrator {
         }
         catch { /* fail-open */ }
     }
+    /** R190: the session usage with the helper middleware's estimated calls merged in, plus a decision-store row so trajectories carry it. */
+    snapshotSessionUsage() {
+        const h = this.helperMiddleware?.getHelperUsageEstimate?.();
+        const snap = { ...this.sessionUsage, helper: h ? { ...h } : { ...this.sessionUsage.helper } };
+        const store = this.getDecisionStore();
+        if (store)
+            void store.recordEvent({ sessionId: this.currentSessionId ?? 'unknown', kind: 'session_usage', detail: { ...snap } }).catch(() => { });
+        return snap;
+    }
     /** Bounded read-only environment recon (ENV_RECON_COMMAND), gathered ONCE and cached — shared by the
      *  lift planner and the EndTurn resolver. Fail-open: partial stdout on timeout/non-zero, else empty. */
     gatherEnvReport(opts = {}) {
@@ -801,7 +814,9 @@ export class CortexOrchestrator {
             this.reqLedger = [];
             return [];
         }
-        const tmo = mentorSurfaceTimeoutMs('endturn-resolver', parseInt(process.env.CORTEX_ENDTURN_RESOLVER_TIMEOUT_MS ?? '90000', 10));
+        // R187c: the extractor runs in the background at lift beside the planner (which itself takes 80–190 s on pro), so it gets the planner's
+        // timeout, not the judge's 90 s — the 09-23 L7 smoke lost the whole ledger to a 98-s pro call (deliveredBy none).
+        const tmo = mentorSurfaceTimeoutMs('lift-plan', parseInt(process.env.CORTEX_JUDGE_REQ_LEDGER_TIMEOUT_MS ?? process.env.CORTEX_LIFT_PLAN_TIMEOUT_MS ?? '180000', 10));
         try {
             const raw = await withTimeout(this.helperMiddleware.deriveRequirementLedger({ task, envReport: this.gatherEnvReport({ fresh: false }), max: cfg.reqLedgerMax, helperModelId: this.config.reactiveMentorship?.helperModelId }), tmo);
             const lines = parseRequirementLedger(raw ?? '', cfg.reqLedgerMax);
@@ -949,7 +964,17 @@ export class CortexOrchestrator {
             if (cfg.reqLedger) {
                 if (this.reqLedger === null)
                     this.reqLedger = await (this.reqLedgerPromise ?? this.authorRequirementLedger(task));
-                const runs = this.reqLedger.filter((e) => e.check).map((e) => { const r = runCheck(judgeCwd, e.check, jcfg); return { id: e.id, result: r, cls: classifyCheckRun(r) }; });
+                // R187c: an empty ledger from a timed-out lift-time call is retried ONCE here (the judge would otherwise run with no lines all session)
+                if (this.reqLedger.length === 0 && !this.reqLedgerRetried) {
+                    this.reqLedgerRetried = true;
+                    this.reqLedger = await this.authorRequirementLedger(task);
+                }
+                // R191: a check whose failure is its own defect (usage error, missing script, syntax error) is BROKEN, not FAILED — L7 09-23: photonic's
+                // extractor guessed a checker's CLI, two lines failed at every finish on a passing solution, and the writer spent turns on the "harness quirk".
+                const runs = this.reqLedger.filter((e) => e.check).map((e) => { const r = runCheck(judgeCwd, e.check, jcfg); const k = classifyCheckRun(r); const cls = k !== 'passed' && looksLikeBrokenCheck(r) ? 'broken' : k; return { id: e.id, result: r, cls }; });
+                for (const x of runs)
+                    if (x.cls === 'broken')
+                        this.reqLedgerBroken.add(x.id);
                 this.reqLedger = updateLedger(this.reqLedger, runs);
                 // R187b: Jev decides the lines the shell could not — typed per-line questions on the writer's attestation + harness evidence.
                 if (cfg.reqLedgerJev && jevAvailable() && this.reqLedger.some((e) => e.status === 'open' || e.status === 'unverifiable')) {
@@ -1202,6 +1227,7 @@ export class CortexOrchestrator {
                         vetoMinRemaining: cfg.vetoMinRemaining, belowFloor, holdProgressed: holdProg, holdGapMs: msSinceLastHold, planSim: Number(planSimilarity(this.judgePriorPlan, verdict.plan).toFixed(3)), msSinceLastHold, // R173c
                         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
+                        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,
                         liftPlanChars: this.liftPlanText.length,
@@ -2255,6 +2281,7 @@ export class CortexOrchestrator {
         this.reqLedgerHolds = 0;
         this.reqLedgerMeta = { genLatencyMs: 0, raw: 0, refused: 0 };
         this.reqLedgerDelivered = false;
+        this.reqLedgerRetried = false;
         this.lastHoldMs = 0;
         this.derivationHolds = 0; // R165 per-turn / R174 / R173c / R176
         this.recordDsmlRecovery(currentAssistantCanonicalMessage);
@@ -3949,10 +3976,10 @@ export class CortexOrchestrator {
             messageId: currentAssistantMessage.uuid,
             content: currentAssistantCanonicalMessage.content,
             toolUses: allExecutedToolUses,
-            usage: convertedResponse.usage || {
-                inputTokens: 0,
-                outputTokens: 0,
-                totalTokens: 0
+            usage: {
+                ...(convertedResponse.usage || { inputTokens: 0, outputTokens: 0, totalTokens: 0 }),
+                // R190: the whole session's tokens — every main request (exact) + helper/mentor calls (estimated) — not the last request's
+                session: this.snapshotSessionUsage(),
             },
             model: {
                 id: model.id,
@@ -3960,6 +3987,7 @@ export class CortexOrchestrator {
             },
             metadata: {
                 conversationId: this.currentConversationId,
+                sessionUsage: this.snapshotSessionUsage(), // R190
                 usedHelperModel,
                 compactionTriggered: usedHelperModel,
                 serverSideTools: serverSideMetadata || undefined,
@@ -4475,6 +4503,7 @@ export class CortexOrchestrator {
         this.reqLedgerHolds = 0;
         this.reqLedgerMeta = { genLatencyMs: 0, raw: 0, refused: 0 };
         this.reqLedgerDelivered = false;
+        this.reqLedgerRetried = false;
         this.lastHoldMs = 0;
         this.derivationHolds = 0; // R165 per-turn / R174 / R173c / R176
         this.recordDsmlRecovery(currentAssistantCanonicalMessage);
@@ -5795,6 +5824,7 @@ export class CortexOrchestrator {
                 usage: {
                     inputTokens: finalUsage.inputTokens || 0,
                     outputTokens: finalUsage.outputTokens || 0,
+                    session: this.snapshotSessionUsage(), // R190
                 },
                 durationMs: Date.now() - turnStartMs,
                 toolCallIterations: toolCallIteration,
@@ -6637,6 +6667,7 @@ export class CortexOrchestrator {
      * absorbed by the delta logic in anchoredRequestEstimate.
      */
     noteRequestUsage(usage) {
+        this.sessionUsage = addMainUsage(this.sessionUsage, usage); // R190: cumulative first — the anchor logic below skips zero usage
         const promptTokens = Number(usage?.inputTokens ?? 0);
         if (!(promptTokens > 0))
             return;