@nexus-cortex/core 4.96.1 → 4.98.0

package/dist/orchestrator/CortexOrchestrator.js

@@ -35,7 +35,8 @@ import { CacheMetricsAccumulator } from '../session/CacheMetricsAccumulator.js';
 import { SubAgentProcessManager, createSubAgentProcessManager } from './SubAgentProcessManager.js';
 // Phase 1: Tool Architecture Refactor - Unified Tool Registry
 import { toolFactory } from '../tools/ToolFactory.js';
-import { resolveToolProfile, resolveToolAnchor, resolveFrameProfile, resolveLiftNudge, resolveLiftPlan, resolveEndTurnResolver, resolveHeadlessDropAskUser, resolveDeferredLoading, isNarrowProfile, isToolAllowedByProfile, applyToolProfile, webToolBlocked, resolveVisionHelperModel, resolveVisionHandoffMax, resolveSliceNudge } from '../tools/ToolProfile.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 { resolveOuterToolDeadlineMs } from './outerToolTimeout.js';
 import { resolveTurnDeadlineMs, timeBudgetState, timeBudgetWarnNudge } from './timeBudget.js';
@@ -1518,6 +1519,7 @@ export class CortexOrchestrator {
         // Keep executing tools until model returns a text response
         let currentAssistantMessage = assistantMessage;
         let currentAssistantCanonicalMessage = assistantCanonicalMessage;
+        this.recordDsmlRecovery(currentAssistantCanonicalMessage);
         let toolCallIteration = 0;
         // Loop control settings — single source of truth via getLoopControlConfig()
         const loopDefaults = this.getLoopControlConfig();
@@ -3635,6 +3637,7 @@ export class CortexOrchestrator {
             throw new Error('No response message returned from provider');
         }
         let currentAssistantCanonicalMessage = convertedResponse.messages[0];
+        this.recordDsmlRecovery(currentAssistantCanonicalMessage);
         const assistantMessageId = currentAssistantCanonicalMessage.uuid;
         const assistantMessage = {
             uuid: assistantMessageId,
@@ -6077,6 +6080,12 @@ export class CortexOrchestrator {
                     results.push(await this.processToolTraining(toolUse, loopBlocked));
                     continue;
                 }
+                // CORTEX_SLICE_BLOCK: coercively block re-slicing a static file (force Read) — dark.
+                const sliceBlocked = this.maybeBlockSliceRead(toolUse);
+                if (sliceBlocked) {
+                    results.push(await this.processToolTraining(toolUse, sliceBlocked));
+                    continue;
+                }
                 // Context management tools (CORTEX.md generation + two-tier memory)
                 const contextManagementToolNames = [
                     'InitCortexContext',
@@ -6507,6 +6516,10 @@ export class CortexOrchestrator {
             const loopBlocked = await this.maybeBlockLoopingTool(toolUse);
             if (loopBlocked)
                 return loopBlocked;
+            // CORTEX_SLICE_BLOCK: coercively block re-slicing a static file (force Read) — dark.
+            const sliceBlocked = this.maybeBlockSliceRead(toolUse);
+            if (sliceBlocked)
+                return sliceBlocked;
             // Context management tools
             const contextManagementToolNames = ['InitCortexContext'];
             const isContextManagementTool = contextManagementToolNames.includes(toolUse.name);
@@ -7251,6 +7264,8 @@ export class CortexOrchestrator {
     visionHandoffsThisTurn = 0;
     /** Per-session bash slice-read counts per file (CORTEX_SLICE_NUDGE). */
     sliceReads = new Map();
+    /** Per-session coercive-block counts per file (CORTEX_SLICE_BLOCK — HB-SLICE-BLOCK). */
+    sliceBlockCounts = new Map();
     /** Dependencies the shared EndTurn gates need from the orchestrator (endTurnGates.ts). */
     gateDeps() {
         return {
@@ -7278,11 +7293,9 @@ export class CortexOrchestrator {
     applySliceNudge(toolUse, result) {
         if (toolUse.name !== 'Bash' || result.is_error || !resolveSliceNudge(process.env))
             return;
-        const cmd = String(toolUse.input?.command ?? '');
-        const m = cmd.match(/(?:sed\s+-n\s+['"]?\d+\s*,\s*\d+\s*p['"]?|head\s+-n?\s*\d+|tail\s+-n?\s*\d+)\s+([^\s;|&>]+)/);
-        if (!m)
+        const file = sliceReadFile(String(toolUse.input?.command ?? ''));
+        if (!file)
             return;
-        const file = m[1];
         const n = (this.sliceReads.get(file) ?? 0) + 1;
         this.sliceReads.set(file, n);
         if (n !== 3)
@@ -7292,6 +7305,37 @@ export class CortexOrchestrator {
         }
         this.gateDeps().recordEvent('steering_injected', { kind: 'slice_read', file, count: n }, 'Bash');
     }
+    /**
+     * CORTEX_SLICE_BLOCK (HB-SLICE-BLOCK) — the coercive escalation of the ignored slice-nudge.
+     * PRE-EXECUTION gate (sibling of maybeBlockLoopingTool): if the model is calling Bash to slice-read
+     * a STATIC/source file it has already sliced >= CORTEX_SLICE_BLOCK_AT times, do NOT run the slice —
+     * return an append-only redirect error steering it to Read (bounded to CORTEX_SLICE_BLOCK_MAX blocks
+     * per file). Append-mostly logs are exempt (legit re-tailing). Dark by default. Evidence: full-sample
+     * mining showed the soft nudge is ignored ~80% of re-tested cases (docs/HB-SLICE-BLOCK-SPEC.md).
+     */
+    maybeBlockSliceRead(toolUse) {
+        if (toolUse.name !== 'Bash' || !resolveSliceBlock(process.env))
+            return null;
+        const file = sliceReadFile(String(toolUse.input?.command ?? ''));
+        if (!file)
+            return null;
+        const priorSlices = this.sliceReads.get(file) ?? 0;
+        const priorBlocks = this.sliceBlockCounts.get(file) ?? 0;
+        const decision = decideSliceBlock(file, priorSlices, priorBlocks, resolveSliceBlockAt(process.env), resolveSliceBlockMax(process.env));
+        if (decision.action !== 'block')
+            return null;
+        this.sliceBlockCounts.set(file, priorBlocks + 1);
+        const store = this.getDecisionStore();
+        if (store)
+            void store.recordEvent({
+                sessionId: this.currentSessionId ?? 'unknown',
+                kind: 'slice_block', toolName: 'Bash',
+                detail: { file, priorSlices, blockNumber: priorBlocks + 1 },
+            }).catch(() => { });
+        if (this.config.debug)
+            console.log(`[SliceBlock] blocked slice-read of ${file} (${priorSlices} prior slices, block #${priorBlocks + 1})`);
+        return { tool_use_id: toolUse.id, tool_name: toolUse.name, content: decision.message, is_error: true, metadata: { sliceBlock: true, file } };
+    }
     async applyVisionHandoffs() {
         const queue = this.pendingVisionHandoffs;
         this.pendingVisionHandoffs = [];
@@ -7432,6 +7476,31 @@ export class CortexOrchestrator {
         }
         return this.decisionStore;
     }
+    /** HB-DSML-PARSE observability (2026-09-09): if the DeepSeek DSML tool-call recovery fired on this
+     *  response (recovered tool_use ids are prefixed `dsml_`), record ONE countable `dsml_recovered`
+     *  decision event so the bench data shows how often the leak occurred + that the fix is live.
+     *  Observability only — never throws into the turn. */
+    recordDsmlRecovery(msg) {
+        try {
+            const content = Array.isArray(msg?.content) ? msg.content : [];
+            const recovered = content.filter((b) => b?.type === 'tool_use' && typeof b?.toolUse?.id === 'string' && b.toolUse.id.startsWith('dsml_'));
+            if (recovered.length === 0)
+                return;
+            const store = this.getDecisionStore();
+            if (store) {
+                void store
+                    .recordEvent({
+                    sessionId: this.currentSessionId ?? 'unknown',
+                    kind: 'dsml_recovered',
+                    detail: { count: recovered.length, tools: recovered.map((b) => b.toolUse?.name) },
+                })
+                    .catch(() => { });
+            }
+            if (this.config.debug)
+                console.log(`[HB-DSML-PARSE] dsml_recovered event (count=${recovered.length})`);
+        }
+        catch { /* observability only */ }
+    }
     isRecordingEnabled() {
         return process.env.CORTEX_RECORD_DECISIONS !== 'false';
     }