@nexus-cortex/core 4.108.2 → 4.108.4

package/dist/orchestrator/CortexOrchestrator.js

@@ -16,7 +16,7 @@ import { sanitizeHistoryForDisplay } from './displayHistorySanitizer.js';
 import { verifyCoordinates, deterministicCoordinateScore } from './coordinateVerification.js';
 import { buildRouterSample, appendJsonlRotating } from './cortexTrainingRecord.js';
 import { join as pathJoin } from 'path';
-import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
 import { execSync } from 'node:child_process';
 import { ENV_RECON_COMMAND, resolveLiftPlanConfig } from '../training/liftPlanner.js';
 import { resolveEndTurnResolverConfig, parseResolverVerdict } from '../training/endTurnResolver.js';
@@ -38,8 +38,8 @@ import { toolFactory } from '../tools/ToolFactory.js';
 import { resolveToolProfile, resolveToolAnchor, resolveFrameProfile, resolveLiftNudge, resolveLiftPlan, resolveEndTurnResolver, resolveHeadlessDropAskUser, resolveDeferredLoading, isNarrowProfile, isToolAllowedByProfile, applyToolProfile, webToolBlocked, resolveVisionHelperModel, resolveVisionHandoffMax, resolveSliceNudge, resolveSliceBlock, resolveSliceBlockAt, resolveSliceBlockMax } from '../tools/ToolProfile.js';
 import { sliceReadFile, decideSliceBlock } from './sliceBlock.js';
 import { TurnEvidence, evaluateEndTurnGates, buildMissingEndTurnReminder } from './endTurnGates.js';
-import { resolveCompactionResume, extractFirstUserText, pickDropped, buildCompactionResumeReminder, isCompactionResumeMessage } from './compactionResume.js';
-import { renderResumeMemoryPrompt, buildRebuildInstructions, resolveCheckpointBand } from './compactionResumeTemplate.js';
+import { resolveCompactionResume, pickDropped, buildCompactionResumeReminder, isCompactionResumeMessage, resolveTaskText, resumeMemoryTargetTokens, coversAll, buildRollingSeedMessage, memoryIndexLine, upsertMemoryIndex } from './compactionResume.js';
+import { renderResumeMemoryPrompt, buildRebuildInstructions, resolveCheckpointBand, resolveRearmBand } from './compactionResumeTemplate.js';
 import { collectWorkspaceDelta, detectCheckCommand, runCheck, resolveJudgeGroundingConfig } from '../training/judgeEvidence.js';
 import { resolveMentorRoleConfig, describeMentorWire, describeMentorDelivery, mentorSurfaceTimeoutMs } from '../training/mentorRole.js';
 import { resolveOuterToolDeadlineMs } from './outerToolTimeout.js';
@@ -115,6 +115,9 @@ export class CortexOrchestrator {
     /** HB-COMPACTION-RESUME v2: pressure-rung checkpoint state (once per band; reused at compaction). */
     lastCheckpointBand = 0;
     lastResumeMemory = null;
+    pinnedTaskText = '';
+    /** 4.108.4: session start — the mtime floor for the non-git workspace delta at compaction. */
+    sessionStartMs = Date.now();
     /** Pending TURN_SUMMARY_PREDICTION awaiting the user's ACTUAL next message —
      *  scored + recorded at the next sendMessage (graduation-signal capture,
      *  Decision Capture Layer §5). In-memory only; lost on restart by design. */
@@ -5689,12 +5692,40 @@ export class CortexOrchestrator {
     /** HB-COMPACTION-RESUME: best-effort write of the resume memory to .cortex/memory/resume-<session>.md (synchronous fs). */
     writeResumeMemoryFile(text, why) {
         try {
-            const dir = pathJoin(this.config.projectPath || process.cwd(), '.cortex', 'memory');
+            const cortexDir = pathJoin(this.config.projectPath || process.cwd(), '.cortex');
+            const dir = pathJoin(cortexDir, 'memory');
             mkdirSync(dir, { recursive: true });
-            writeFileSync(pathJoin(dir, `resume-${this.currentSessionId}.md`), `---\nname: resume-${this.currentSessionId}\ndescription: resume memory — ${why}\ntype: project\n---\n${text}\n`);
+            const name = `resume-${this.currentSessionId}`;
+            writeFileSync(pathJoin(dir, `${name}.md`), `---\nname: ${name}\ndescription: resume memory — ${why}\ntype: project\n---\n${text}\n`);
+            // 4.108.4: index it in .cortex/MEMORY.md (the harness's two-tier memory) so MemoryRecall and a resumed session can find it.
+            const indexPath = pathJoin(cortexDir, 'MEMORY.md');
+            let current = '';
+            try {
+                current = readFileSync(indexPath, 'utf8');
+            }
+            catch {
+                current = '';
+            }
+            writeFileSync(indexPath, upsertMemoryIndex(current, name, memoryIndexLine(name, `resume memory (${why}) — load after a context compaction or session resume`)));
         }
         catch { /* best-effort */ }
     }
+    /** 4.108.4: the working tree as it is RIGHT NOW — git state when the workspace is a repo (forced past the per-turn lever), else
+     *  the mtime-based file delta since session start. Read from disk at compaction; capped so it cannot crowd the kept history. */
+    buildCompactionWorkspaceState() {
+        try {
+            const root = process.env.PROJECT_ROOT || this.config.projectPath || this.config.workingDirectory || process.cwd();
+            let state = this.systemReminderInjector.buildGitContextSection(root, { force: true }) ?? '';
+            if (!state.trim()) {
+                state = collectWorkspaceDelta(root, this.sessionStartMs, { ...resolveJudgeGroundingConfig(), delta: true, deltaMaxFiles: 0 });
+            }
+            const MAX = 2500;
+            return state.length > MAX ? state.slice(0, MAX) + '\n[… workspace state truncated]' : state;
+        }
+        catch {
+            return '';
+        }
+    }
     async ensureHistoryFitsModel(model) {
         // Capture the active model's context window for request-build-time
         // pruning (pruneAgedForRequest) — set before any early return so the
@@ -5720,8 +5751,13 @@ export class CortexOrchestrator {
             actualToolTokens: this.currentToolTokens,
             actualSystemTokens: 0
         };
-        // Calculate compaction threshold using model's configuration (with accurate overrides)
-        const threshold = this.contextBudgetManager.getCompactionThreshold(model, budgetOverrides);
+        // Calculate compaction threshold using model's configuration (with accurate overrides).
+        // CORTEX_COMPACTION_THRESHOLD_TOKENS (4.108.3, test/ops override): a positive integer replaces the card-derived threshold so the
+        // checkpoint rung + compaction can be exercised in a short live run (efficacy proof before any long-horizon bench).
+        const thresholdOverride = Number(String(process.env.CORTEX_COMPACTION_THRESHOLD_TOKENS ?? '').trim() || 0);
+        const threshold = thresholdOverride > 0
+            ? thresholdOverride
+            : this.contextBudgetManager.getCompactionThreshold(model, budgetOverrides);
         if (this.config.debug) {
             console.log(`[Orchestrator Context] Current tokens: ${currentTokens}, Threshold: ${threshold} (tool reserve: ${this.currentToolTokens})`);
         }
@@ -5734,10 +5770,12 @@ export class CortexOrchestrator {
             if (band > this.lastCheckpointBand) {
                 this.lastCheckpointBand = band;
                 try {
-                    const r = await this.helperMiddleware.summarizeForResume(this.convertToCanonicalMessages([...this.messageHistory]), model, 6000, renderResumeMemoryPrompt('{{CONVERSATION}}', 6000));
+                    const tgt = resumeMemoryTargetTokens(threshold);
+                    const r = await this.helperMiddleware.summarizeForResume(this.convertToCanonicalMessages([...this.messageHistory]), model, tgt, renderResumeMemoryPrompt('{{CONVERSATION}}', tgt));
                     const text = String(r?.summary ?? '');
                     if (text.trim()) {
-                        this.lastResumeMemory = { text, tokensAt: currentTokens, turn: this.turnNumber, helperModelId: r?.helperModelId, cost: Number(r?.cost ?? 0) };
+                        this.lastResumeMemory = { text, tokensAt: currentTokens, turn: this.turnNumber, helperModelId: r?.helperModelId, cost: Number(r?.cost ?? 0),
+                            covered: new WeakSet(this.messageHistory) };
                         this.writeResumeMemoryFile(text, `checkpoint band ${band} (${currentTokens}/${threshold} tokens, turn ${this.turnNumber})`);
                         const store = this.getDecisionStore();
                         if (store)
@@ -5762,6 +5800,8 @@ export class CortexOrchestrator {
         try {
             // Calculate available budget for history (with accurate overrides)
             const budget = this.contextBudgetManager.calculateBudget(model, budgetOverrides);
+            if (thresholdOverride > 0)
+                budget.availableForHistory = Math.floor(thresholdOverride * 0.5); // override: keep ~half the forced window
             // Determine selection strategy based on model configuration
             const strategy = model.compaction?.behavior?.compactOlder ? 'preserve-critical' : 'sliding-window';
             // Select messages that fit within budget (standard path — no thinking stripping)
@@ -5780,13 +5820,16 @@ export class CortexOrchestrator {
             // session JSONL (so a bench can count compactions), (5) .cortex/memory/resume-<session>.md is written.
             const compactionResume = resolveCompactionResume();
             const dropped = pickDropped(this.messageHistory, selectedMessages);
-            const taskText = extractFirstUserText(this.messageHistory);
+            const taskText = resolveTaskText(this.messageHistory, this.pinnedTaskText);
+            if (taskText)
+                this.pinnedTaskText = taskText;
             let resumeText = '';
             let resumeHelper;
             let resumeCost = 0;
             let memorySource = 'none';
-            // v2: a checkpoint written within the last ~15% of the threshold is fresh enough to reuse (no second helper call)
-            if (compactionResume && this.lastResumeMemory && (currentTokens - this.lastResumeMemory.tokensAt) <= threshold * 0.15) {
+            // v3 (4.108.3): reuse the checkpoint only if it already covered every message being dropped. The v2 token-distance test went
+            // negative after the first compaction and replayed one stale checkpoint forever (the hardened live proof: 27 compactions, 0 fresh memories).
+            if (compactionResume && this.lastResumeMemory && coversAll(this.lastResumeMemory.covered, dropped)) {
                 resumeText = this.lastResumeMemory.text;
                 resumeHelper = this.lastResumeMemory.helperModelId;
                 resumeCost = 0;
@@ -5794,11 +5837,22 @@ export class CortexOrchestrator {
             }
             else if (compactionResume && dropped.length > 0 && this.config.useHelperModels && typeof this.helperMiddleware?.summarizeForResume === 'function') {
                 try {
-                    const r = await this.helperMiddleware.summarizeForResume(this.convertToCanonicalMessages(dropped), model, 6000, renderResumeMemoryPrompt('{{CONVERSATION}}', 6000));
+                    const tgt = resumeMemoryTargetTokens(threshold);
+                    // v3: roll the prior memory forward — the helper summarizes [prior memory, ...newly dropped] into ONE memory.
+                    const prior = this.lastResumeMemory;
+                    const seed = prior && prior.text.trim() ? [buildRollingSeedMessage(prior.text)] : [];
+                    const r = await this.helperMiddleware.summarizeForResume(this.convertToCanonicalMessages([...seed, ...dropped]), model, tgt, renderResumeMemoryPrompt('{{CONVERSATION}}', tgt));
                     resumeText = String(r?.summary ?? '');
                     resumeHelper = r?.helperModelId;
                     resumeCost = Number(r?.cost ?? 0);
-                    memorySource = resumeText.trim() ? 'dropped' : 'none';
+                    memorySource = resumeText.trim() ? (seed.length ? 'rolled' : 'dropped') : 'none';
+                    if (resumeText.trim()) {
+                        const covered = prior?.covered ?? new WeakSet();
+                        for (const m of dropped)
+                            if (m && typeof m === 'object')
+                                covered.add(m);
+                        this.lastResumeMemory = { text: resumeText, tokensAt: currentTokens, turn: this.turnNumber, helperModelId: resumeHelper, cost: resumeCost, covered };
+                    }
                 }
                 catch (e) {
                     console.error('[Orchestrator Context] resume memory summary failed (degrading to task-only reminder):', e?.message ?? e);
@@ -5807,10 +5861,21 @@ export class CortexOrchestrator {
             // Update message history with selected messages (dropping any OLDER compaction reminder — the new one supersedes it)
             this.messageHistory = compactionResume ? selectedMessages.filter((m) => !isCompactionResumeMessage(m)) : selectedMessages;
             if (compactionResume && dropped.length > 0) {
+                // v3: re-arm the checkpoint rung relative to the post-compaction level so a fresh whole-conversation memory is written
+                // again as the context climbs (v2 left lastCheckpointBand at its pre-compaction high-water mark → the rung never re-fired).
+                this.lastCheckpointBand = resolveRearmBand(newTokenCount, threshold);
+                const workspaceState = this.buildCompactionWorkspaceState();
+                let sessionPath;
+                try {
+                    sessionPath = this.currentSessionId ? this.historyStore.getSessionPath(this.currentSessionId) : undefined;
+                }
+                catch {
+                    sessionPath = undefined;
+                }
                 const text = buildCompactionResumeReminder({
                     turn: this.turnNumber, droppedCount: dropped.length, keptCount: this.messageHistory.length,
                     tokensBefore: currentTokens, tokensAfter: newTokenCount, resumeText, taskText, helperModelId: resumeHelper,
-                    rebuild: buildRebuildInstructions(), memorySource,
+                    rebuild: buildRebuildInstructions({ sessionPath }), memorySource, workspaceState,
                 });
                 const reminder = {
                     uuid: uuidv4(),
@@ -5833,7 +5898,8 @@ export class CortexOrchestrator {
                         kind: 'compaction',
                         detail: { mode: 'proactive', turn: this.turnNumber, tokensBefore: currentTokens, tokensAfter: newTokenCount,
                             dropped: dropped.length, kept: selectedMessages.length, resumeChars: resumeText.length,
-                            helperModelId: resumeHelper ?? null, cost: resumeCost, taskPinned: taskText.length > 0, memorySource },
+                            helperModelId: resumeHelper ?? null, cost: resumeCost, taskPinned: taskText.length > 0, memorySource,
+                            workspaceStateChars: workspaceState.length, sessionPath: sessionPath ?? null },
                     }).catch(() => { });
                 if (this.config.debug)
                     console.log(`[Orchestrator Context] resume reminder injected (${resumeText.length} chars memory, task pinned=${taskText.length > 0})`);