@nexus-cortex/core 4.89.0 → 4.90.1

package/dist/orchestrator/CortexOrchestrator.js

@@ -30,7 +30,7 @@ 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, resolveHeadlessDropAskUser, resolveDeferredLoading, isNarrowProfile, isToolAllowedByProfile, applyToolProfile, webToolBlocked } from '../tools/ToolProfile.js';
+import { resolveToolProfile, resolveToolAnchor, resolveFrameProfile, resolveLiftNudge, resolveHeadlessDropAskUser, resolveDeferredLoading, isNarrowProfile, isToolAllowedByProfile, applyToolProfile, webToolBlocked, resolveVisionHelperModel } from '../tools/ToolProfile.js';
 import { readStagedDoctrine, applyCuratedDoctrine, runOrientForStaging, withTimeout } from './doctrineCuration.js';
 import { ExactRepeatTracker } from '../training/loopLadder.js';
 import { slashCommandRegistry } from '../commands/SlashCommandRegistry.js';
@@ -44,7 +44,7 @@ import { classifyToolOutcome } from '../training/toolOutcome.js';
 import { LoopLadder, formatLadderSignal } from '../training/loopLadder.js';
 import { shouldNudgeInaction, formatInactionNudge } from './inactionGuard.js';
 import { applyImageTtlForRequest } from './imageTtl.js';
-import { verifyRequirements, resolveEndTurnRequirementsMode } from './requirementsVerification.js';
+import { verifyRequirements, resolveEndTurnRequirementsMode, resolveEndTurnRequirementsStrict } from './requirementsVerification.js';
 import { verifyIntegrity, resolveEndTurnIntegrityMode } from './integrityVerification.js';
 import { detectSurrenderText, resolveSurrenderNudgeMode, SURRENDER_REMINDER } from './turnEndGuards.js';
 import { ModelRouterMatrix } from '../training/ModelRouterMatrix.js';
@@ -64,6 +64,8 @@ import { detectTailRepetition, tailLoopGuardEnabled } from './tailRepetitionDete
 import { classifyEmptyResponse, emptyResponseNudge } from './emptyResponseClassifier.js';
 // PTC: Progressive tool loading for non-PTC providers
 import { ClientSideToolFilter } from '../tools/ClientSideToolFilter.js';
+/** Grace the orchestrator's outer tool-abort waits past the tool's own deadline (ShellTool promote/kill fires first; 4.90.1). */
+const OUTER_TIMEOUT_GRACE_MS = 30_000;
 /**
  * Cortex Orchestrator - Phase 2.1
  *
@@ -478,7 +480,7 @@ export class CortexOrchestrator {
                     const catalogVision = this.getModel(this.currentModelId ?? '')?.vision === true;
                     return [...toolFactory.getAllTools(), ...extras]
                         .filter((t) => endTurnGateOn || t.name !== 'EndTurn')
-                        .filter((t) => catalogVision || t.name !== 'ReadImage')
+                        .filter((t) => catalogVision || !!resolveVisionHelperModel(process.env) || t.name !== 'ReadImage')
                         .filter((t) => (seen.has(t.name) ? false : (seen.add(t.name), true)))
                         .map((t) => ({
                         name: namingHandler.convertName(t.name, convention),
@@ -634,7 +636,7 @@ export class CortexOrchestrator {
         const visionOn = model?.vision === true;
         const factoryTools = this.applyBaseToolAllowlist(toolFactory.getAllTools()
             .filter(t => endTurnGateOn || t.name !== 'EndTurn')
-            .filter(t => visionOn || t.name !== 'ReadImage'));
+            .filter(t => visionOn || !!resolveVisionHelperModel(process.env) || t.name !== 'ReadImage'));
         // Tool-profile: MCP/management/context tools bypass ToolFactory, so the
         // bash-only arm must suppress them here or the surface leaks (lean keeps
         // them — they are part of the "guided" surface under test).
@@ -898,7 +900,7 @@ export class CortexOrchestrator {
         // Thread the CARD's anchor to the executors (per-orchestrator config, by
         // reference) so framing-aware executor behavior (ShellTool steering
         // default) is model-card/registry-scoped, not process-global env.
-        this.executorRegistry.updateConfig({ activeAnchorProfile: this.cardAnchorProfile, allowCommandSubstitution: this.approvalMode.autoApproveActions });
+        this.executorRegistry.updateConfig({ activeAnchorProfile: this.cardAnchorProfile, allowCommandSubstitution: this.approvalMode.autoApproveActions, headless: this.approvalMode.autoApproveActions });
         if (toolsToUse && toolsToUse.length > 0) {
             toolsToUse = this.applyAnchorIfArmed(toolsToUse);
         }
@@ -1909,11 +1911,16 @@ export class CortexOrchestrator {
                     break;
                 }
                 // Phase 2.5 Day 3: Execute tools with timeout support
+                // 🔴 4.90.1: this OUTER abort must not race ShellTool's own deadline — ShellTool promotes a
+                // still-running Bash to the background AT TOOL_TIMEOUT_MS (TOOL_TIMEOUT_MODE), and an outer
+                // abort at the same instant made the promote inert (v4 pro/train-fasttext: 22 "cancelled",
+                // 0 promotions). The outer timer is the last-resort cap for hung tools: it fires a grace
+                // period AFTER the tool's own deadline.
                 const abortController = new AbortController();
                 const timeoutId = setTimeout(() => {
-                    console.warn(`[Orchestrator Phase 2.5] Tool execution timeout after ${TOOL_TIMEOUT_MS}ms`);
+                    console.warn(`[Orchestrator Phase 2.5] Tool execution timeout after ${TOOL_TIMEOUT_MS + OUTER_TIMEOUT_GRACE_MS}ms`);
                     abortController.abort();
-                }, TOOL_TIMEOUT_MS);
+                }, TOOL_TIMEOUT_MS + OUTER_TIMEOUT_GRACE_MS);
                 // Track which tool_use_ids have been processed to avoid duplicates in error handler
                 const processedToolUseIds = new Set();
                 try {
@@ -2095,6 +2102,8 @@ export class CortexOrchestrator {
                                     verification: etUse?.input?.verification,
                                     userTaskText: this.lastRealUserText(),
                                     turnUsedMutatingTool,
+                                    strict: resolveEndTurnRequirementsStrict(process.env),
+                                    toolOutputs: thisTurnToolOutputs.join('\n'),
                                 });
                                 if (s4.ok) {
                                     endTurnCalled = true;
@@ -2156,6 +2165,7 @@ export class CortexOrchestrator {
                     // Item 7: scrub ReadImage payloads from metadata BEFORE persist;
                     // the images inject as a user message after the results land.
                     const pendingImages = this.collectPendingImages(toolResults, effectiveModel.vision === true);
+                    await this.applyVisionHandoffs();
                     // Create tool_result messages and add to history
                     for (const toolResult of toolResults) {
                         const toolResultMessageId = uuidv4();
@@ -3196,7 +3206,7 @@ export class CortexOrchestrator {
         // Thread the CARD's anchor to the executors (per-orchestrator config, by
         // reference) so framing-aware executor behavior (ShellTool steering
         // default) is model-card/registry-scoped, not process-global env.
-        this.executorRegistry.updateConfig({ activeAnchorProfile: this.cardAnchorProfile, allowCommandSubstitution: this.approvalMode.autoApproveActions });
+        this.executorRegistry.updateConfig({ activeAnchorProfile: this.cardAnchorProfile, allowCommandSubstitution: this.approvalMode.autoApproveActions, headless: this.approvalMode.autoApproveActions });
         if (toolsToUse && toolsToUse.length > 0) {
             toolsToUse = this.applyAnchorIfArmed(toolsToUse);
         }
@@ -3735,14 +3745,15 @@ export class CortexOrchestrator {
             if (toolCallIteration >= MAX_TOOL_ITERATIONS) {
                 break;
             }
-            // Execute tools with timeout
+            // Execute tools with timeout (outer cap fires a grace period AFTER the tool's own deadline —
+            // see the non-stream site: ShellTool's promote-at-deadline must win the race; 4.90.1)
             const abortController = new AbortController();
             const timeoutId = setTimeout(() => {
                 if (this.config.debug) {
-                    console.warn(`[Orchestrator Streaming] Tool execution timeout after ${TOOL_TIMEOUT_MS}ms`);
+                    console.warn(`[Orchestrator Streaming] Tool execution timeout after ${TOOL_TIMEOUT_MS + OUTER_TIMEOUT_GRACE_MS}ms`);
                 }
                 abortController.abort();
-            }, TOOL_TIMEOUT_MS);
+            }, TOOL_TIMEOUT_MS + OUTER_TIMEOUT_GRACE_MS);
             try {
                 // Execute tools (reuse existing method)
                 const toolResults = await this.handleToolCalls(toolUseBlocks, abortController.signal, structuredOutputState);
@@ -3808,6 +3819,7 @@ export class CortexOrchestrator {
                 }
                 // Item 7: scrub ReadImage payloads before persist (streaming parity).
                 const pendingImages = this.collectPendingImages(toolResults, effectiveModel.vision === true);
+                await this.applyVisionHandoffs();
                 // Create tool_result messages and save to history
                 for (const toolResult of toolResults) {
                     // Emit tool result as streaming chunk for CLI display
@@ -6801,6 +6813,43 @@ export class CortexOrchestrator {
      *  hallucinated/PTC call that slipped the surface gate), the result is
      *  rewritten into an actionable error — a text-only model must never have
      *  an image dangled at it. */
+    /** Vision hand-off queue (filled by collectPendingImages for text-only primaries). */
+    pendingVisionHandoffs = [];
+    /** Resolve queued ReadImage hand-offs through the helper middleware: the vision helper's TEXT
+     *  replaces the tool_result content. Failures degrade to the pre-hand-off guidance (bash OCR). */
+    async applyVisionHandoffs() {
+        const queue = this.pendingVisionHandoffs;
+        this.pendingVisionHandoffs = [];
+        for (const h of queue) {
+            const modelId = resolveVisionHelperModel(process.env) || 'deepseek-v4-flash-vision-exp';
+            try {
+                const t0 = Date.now();
+                const text = await this.helperMiddleware.describeImage({
+                    mediaType: h.payload.mediaType, base64: h.payload.base64, prompt: h.prompt, filePath: h.filePath, helperModelId: modelId,
+                });
+                h.tr.is_error = false;
+                h.tr.content =
+                    `[ReadImage → vision helper ${modelId}${h.filePath ? ` on ${h.filePath}` : ''}]\n` +
+                        (text || '(the vision helper returned no description)') +
+                        `\n\n(Read by the vision helper on your behalf — the active model is text-only. Ask again with a more specific \`prompt\` if you need a different reading.)`;
+                if (this.config.debug)
+                    console.log(`[VisionHandoff] ${modelId} described ${h.filePath || 'image'} in ${Date.now() - t0}ms (${(text || '').length} chars)`);
+                const store = this.getDecisionStore();
+                if (store) {
+                    void store.recordEvent({
+                        sessionId: this.currentSessionId ?? 'unknown', kind: 'steering_injected', toolName: 'ReadImage',
+                        detail: { kind: 'vision_handoff', helper: modelId, chars: (text || '').length, filePath: h.filePath },
+                    }).catch(() => { });
+                }
+            }
+            catch (err) {
+                h.tr.is_error = true;
+                h.tr.content =
+                    `ReadImage vision hand-off failed (${modelId}: ${err?.message || err}). ` +
+                        'Extract what you need through bash instead (e.g. tesseract OCR, ffprobe, PIL).';
+            }
+        }
+    }
     collectPendingImages(toolResults, modelVision) {
         const out = [];
         for (const tr of toolResults) {
@@ -6811,6 +6860,16 @@ export class CortexOrchestrator {
             if (tr.is_error)
                 continue;
             if (!modelVision) {
+                // VISION HAND-OFF (2026-09-02): a text-only primary called ReadImage. If a vision helper
+                // is configured, queue the payload for the helper middleware (applyVisionHandoffs runs
+                // right after this at both call sites and REPLACES the tool_result with the helper's
+                // text). The primary never receives an image payload — item 7's safety intent holds.
+                if (resolveVisionHelperModel(process.env)) {
+                    this.pendingVisionHandoffs.push({ tr, payload, prompt: tr.metadata?.imagePrompt, filePath: tr.metadata?.imageFilePath });
+                    delete tr.metadata.imagePrompt;
+                    delete tr.metadata.imageFilePath;
+                    continue;
+                }
                 tr.is_error = true;
                 tr.content =
                     'ReadImage requires a vision-capable model — the active model cannot see images. ' +
@@ -7055,6 +7114,13 @@ export class CortexOrchestrator {
         const store = this.getDecisionStore();
         if (!store)
             return result;
+        // TOOL_TIMEOUT_MODE engagement evidence: a promoted-to-background tool call.
+        if (result.metadata?.promotedToBackground) {
+            void store.recordEvent({
+                sessionId: this.currentSessionId ?? 'unknown', kind: 'steering_injected', toolName: toolUse.name,
+                detail: { kind: 'tool_promoted', bashId: result.metadata.promotedToBackground },
+            }).catch(() => { });
+        }
         // Unified outcome layer (docs/UNIFIED_OUTCOME_LADDER.md): ONE failure
         // semantics for recording + reminders. Critically, a bash command that
         // ran and exited nonzero is a FAILURE here even though its tool result