@orion-agents/orion-code 0.1.8 → 0.2.0

package/dist/framework/query.js

@@ -10,7 +10,8 @@
  * chunks directly to stdout via the callback.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryLoopError = exports.DEFAULT_LOOP_BUDGET = exports.DEFAULT_MAX_MODEL_VISIBLE_TOOL_RESULT_BYTES = void 0;
+exports.QueryLoopError = exports.DEFAULT_MAX_MODEL_VISIBLE_TOOL_RESULT_BYTES = exports.DEFAULT_LOOP_BUDGET = void 0;
+exports.withLoopFinishReason = withLoopFinishReason;
 exports.createLocalFastPathLoopStats = createLocalFastPathLoopStats;
 exports.createFailedLoopStats = createFailedLoopStats;
 exports.query = query;
@@ -18,13 +19,19 @@ const llm_1 = require("../services/llm");
 const tool_1 = require("./tool");
 const strategy_tracker_1 = require("../core/strategy-tracker");
 const auto_compact_1 = require("../services/compact/auto-compact");
+const fingerprint_1 = require("../services/compact/fingerprint");
 const tool_call_groups_1 = require("../services/compact/tool-call-groups");
-const tool_scheduler_1 = require("./tool-scheduler");
+const tool_call_orchestrator_1 = require("./tool-call-orchestrator");
 const token_estimate_1 = require("../utils/token-estimate");
 const tool_serializer_1 = require("./tool-serializer");
 const model_context_1 = require("../services/model-context");
-const tools_1 = require("../tools");
+const stop_decision_1 = require("./stop-decision");
+const loop_budget_contract_1 = require("./loop-budget-contract");
+var loop_budget_contract_2 = require("./loop-budget-contract");
+Object.defineProperty(exports, "DEFAULT_LOOP_BUDGET", { enumerable: true, get: function () { return loop_budget_contract_2.DEFAULT_LOOP_BUDGET; } });
 exports.DEFAULT_MAX_MODEL_VISIBLE_TOOL_RESULT_BYTES = 4096;
+/** Read-only tools eligible for the fragmentation hint; kept loop-local so Query has no tool registry. */
+const BATCH_READ_ALLOWED_TOOLS = new Set(['git_status', 'list_files', 'glob', 'grep', 'read_file']);
 function isAborted(signal) {
     return signal?.aborted === true;
 }
@@ -75,15 +82,6 @@ function parseBatchReadEvidenceSteps(result) {
         ];
     });
 }
-exports.DEFAULT_LOOP_BUDGET = {
-    maxLlmRequestsPerUserTurn: 24,
-    maxToolCallsPerUserTurn: 120,
-    maxReadOnlyFragmentation: 3,
-    maxModelVisibleToolBytes: 64 * 1024,
-    profile: 'default',
-    baseProfile: 'default',
-    configOverride: false,
-};
 const COMPLEX_LOOP_BUDGET = {
     maxLlmRequestsPerUserTurn: 48,
     maxToolCallsPerUserTurn: 180,
@@ -120,23 +118,152 @@ function createLoopStats() {
         localFastPathUsed: false,
     };
 }
-function cloneLoopStats(stats, finishReason) {
-    return {
+function stopDecisionForLoop(stats, finishReason) {
+    if (finishReason === 'compact_paused' && stats.compactFailure) {
+        const failure = stats.compactFailure;
+        return (0, stop_decision_1.createStopDecision)({
+            scope: 'request',
+            status: 'stopped',
+            disposition: 'pause_scope',
+            reason: { code: failure.code, message: failure.message },
+            evidence: [
+                {
+                    kind: 'resource_limit',
+                    source: `compact:${failure.mode}`,
+                    detail: `${failure.beforeTokens} tokens before compact; ${failure.afterTokens ?? 'unknown'} after; target ${failure.targetTokens}.`,
+                },
+            ],
+            nextActions: [
+                { kind: 'inspect', label: 'Inspect current context pressure', command: '/context' },
+                { kind: 'change_input', label: 'Narrow or split the current instruction' },
+                { kind: 'raise_budget', label: 'Select a larger-context model or raise the budget' },
+                { kind: 'resume', label: 'Resume after changing context or budget', command: '继续' },
+            ],
+            resources: {
+                tokens: {
+                    used: Math.max(0, Math.round(failure.afterTokens ?? failure.beforeTokens)),
+                    limit: Math.max(0, Math.round(failure.targetTokens)),
+                },
+            },
+        });
+    }
+    const status = finishReason === 'completed'
+        ? 'completed'
+        : finishReason === 'cancelled'
+            ? 'cancelled'
+            : finishReason === 'failed'
+                ? 'failed'
+                : finishReason === 'blocked'
+                    ? 'blocked'
+                    : 'stopped';
+    const reasonCode = finishReason === 'budget_exceeded'
+        ? /LLM request budget/iu.test(stats.budgetExceededReason ?? '')
+            ? 'llm_request_budget'
+            : /tool call budget/iu.test(stats.budgetExceededReason ?? '')
+                ? 'tool_call_budget'
+                : /preflight|provider/iu.test(stats.budgetExceededReason ?? '')
+                    ? 'provider_preflight_budget'
+                    : 'resource_budget'
+        : finishReason;
+    const resumable = finishReason === 'budget_exceeded' ||
+        finishReason === 'completion_gate' ||
+        finishReason === 'blocked';
+    const evidence = [];
+    if (finishReason === 'budget_exceeded') {
+        evidence.push({
+            kind: 'resource_limit',
+            source: 'query',
+            detail: stats.budgetExceededReason ?? 'request resource budget reached',
+        });
+    }
+    if (stats.lastToolName) {
+        evidence.push({
+            kind: 'tool_boundary',
+            source: stats.lastToolName,
+            detail: stats.lastToolSummary ?? `last tool success=${String(stats.lastToolSuccess)}`,
+        });
+    }
+    const nextActions = [];
+    for (const action of stats.continuationActions ?? []) {
+        if (action === 'reply_continue') {
+            nextActions.push({ kind: 'continue', label: 'Continue the same objective', command: '继续' });
+        }
+        else if (action === 'raise_budget') {
+            nextActions.push({ kind: 'raise_budget', label: 'Raise the intentional loop budget' });
+        }
+        else if (action === 'inspect_loop_stats') {
+            nextActions.push({
+                kind: 'inspect',
+                label: 'Inspect loop statistics',
+                command: '/usage',
+            });
+        }
+        else {
+            nextActions.push({ kind: 'change_input', label: 'Provide a narrower instruction' });
+        }
+    }
+    return (0, stop_decision_1.createStopDecision)({
+        scope: 'request',
+        status,
+        disposition: resumable ? 'resume_allowed' : 'finish_scope',
+        reason: {
+            code: reasonCode,
+            message: finishReason === 'budget_exceeded'
+                ? (stats.budgetExceededReason ?? 'Request resource budget reached')
+                : `Request finished with ${finishReason}`,
+        },
+        evidence,
+        nextActions,
+        resources: {
+            turns: { used: stats.turnsStarted },
+            llmRequests: {
+                used: stats.llmRequests,
+                ...(stats.loopBudgetMaxLlmRequests === undefined
+                    ? {}
+                    : { limit: stats.loopBudgetMaxLlmRequests }),
+            },
+            toolCalls: {
+                used: stats.toolCalls,
+                ...(stats.loopBudgetMaxToolCalls === undefined
+                    ? {}
+                    : { limit: stats.loopBudgetMaxToolCalls }),
+            },
+            modelVisibleToolBytes: {
+                used: stats.modelVisibleToolBytes,
+                ...(stats.loopBudgetMaxModelVisibleBytes === undefined
+                    ? {}
+                    : { limit: stats.loopBudgetMaxModelVisibleBytes }),
+            },
+        },
+    });
+}
+/** Rebuild terminal loop stats and its StopDecision as one atomic projection. */
+function withLoopFinishReason(stats, finishReason) {
+    const resolvedReason = finishReason;
+    const cloned = {
         ...stats,
-        finishReason: finishReason ?? stats.finishReason,
+        finishReason: resolvedReason,
     };
+    if (resolvedReason !== 'running')
+        cloned.stopDecision = stopDecisionForLoop(cloned, resolvedReason);
+    else
+        delete cloned.stopDecision;
+    return cloned;
+}
+function cloneLoopStats(stats, finishReason) {
+    return withLoopFinishReason(stats, finishReason ?? stats.finishReason);
 }
 function byteLength(text) {
     return Buffer.byteLength(text, 'utf8');
 }
 function createLocalFastPathLoopStats(overrides = {}) {
-    return {
+    return cloneLoopStats({
         ...createLoopStats(),
         turnsStarted: 1,
         finishReason: 'completed',
         localFastPathUsed: true,
         ...overrides,
-    };
+    });
 }
 function createFailedLoopStats(options = {}) {
     const { loopBudget, diagnostics, ...overrides } = options;
@@ -149,7 +276,7 @@ function createFailedLoopStats(options = {}) {
     };
     applyLoopBudgetStats(stats, resolveLoopBudget(loopBudget));
     applyLlmRequestDiagnostics(stats, diagnostics);
-    return stats;
+    return cloneLoopStats(stats);
 }
 function isLoopBudgetSource(value) {
     return value === 'default' || value === 'complex' || value === 'release' || value === 'config';
@@ -164,16 +291,16 @@ function resolveLoopBudget(partial) {
     const inferredConfigOverride = hasNumericOverrides && !hasExplicitProfile;
     const configOverride = partial?.configOverride === true || inferredConfigOverride;
     return {
-        ...exports.DEFAULT_LOOP_BUDGET,
+        ...loop_budget_contract_1.DEFAULT_LOOP_BUDGET,
         ...numericOverrides,
         profile: isLoopBudgetSource(partial?.profile)
             ? partial.profile
             : configOverride
                 ? 'config'
-                : exports.DEFAULT_LOOP_BUDGET.profile,
+                : loop_budget_contract_1.DEFAULT_LOOP_BUDGET.profile,
         baseProfile: isLoopBudgetBaseProfile(partial?.baseProfile)
             ? partial.baseProfile
-            : exports.DEFAULT_LOOP_BUDGET.baseProfile,
+            : loop_budget_contract_1.DEFAULT_LOOP_BUDGET.baseProfile,
         configOverride,
     };
 }
@@ -235,14 +362,14 @@ function budgetExceededEvent(llm, stats, reason) {
         'inspect_loop_stats',
         'raise_budget',
     ];
-    const continuationHint = 'Reply `继续` to continue the same objective, give a narrower next step, inspect /loop-stats, or raise agentLoop.budget for intentional long work.';
+    const continuationHint = 'Reply `继续` to continue the same objective, give a narrower next step, inspect /usage, or raise agentLoop.budget for intentional long work.';
     return {
         type: 'complete',
         content: [
             `Agent loop budget reached: ${reason}.`,
             'I stopped this turn to avoid unnecessary model requests and preserved the current session state.',
             'To continue the same objective, reply `继续` or provide the next concrete step.',
-            'Use /loop-stats to inspect request/tool counts. For intentional long work, raise agentLoop.budget in orion.json.',
+            'Use /usage to inspect request/tool counts. For intentional long work, raise agentLoop.budget in orion.json.',
         ].join('\n'),
         model: llm.getModel(),
         stats: cloneLoopStats({
@@ -404,18 +531,46 @@ function omitModelVisibleToolResult(executed, maxAggregateBytes) {
         summarizedBytes: Math.max(0, fullBytes - bytes),
     };
 }
+function queryCompactCommit(mode, result, before, after, uncompactedHistory, prepareSource, semanticHarnessState) {
+    return {
+        mode,
+        uncompactedHistory: uncompactedHistory.map(message => ({ ...message })),
+        modelHistory: result.messages.map(message => ({ ...message })),
+        summary: {
+            text: result.summary,
+            generatedAt: result.summaryGeneratedAt,
+            source: result.summarySource,
+        },
+        before,
+        after,
+        prepareSource,
+        semanticHarnessState,
+        fingerprint: result.fingerprint,
+        beforeTokens: result.beforeTokens,
+        afterTokens: result.afterTokens,
+        plan: structuredClone(result.plan),
+        semanticSummary: structuredClone(result.semanticSummary),
+        diagnostics: result.diagnostics.map(diagnostic => ({ ...diagnostic })),
+    };
+}
 function attachCompactCommit(event, compact, messages, usage) {
     const eventWithUsage = usage ? { ...event, usage: { ...usage } } : event;
     return compact
         ? {
             ...eventWithUsage,
-            compact: {
-                ...compact,
-                modelHistory: messages.map(message => ({ ...message })),
-            },
+            compact: bindCompactCommitToHistory(compact, messages),
         }
         : eventWithUsage;
 }
+function bindCompactCommitToHistory(compact, messages) {
+    const modelHistory = messages.map(message => ({ ...message }));
+    return {
+        ...compact,
+        uncompactedHistory: compact.uncompactedHistory.map(message => ({ ...message })),
+        modelHistory,
+        afterTokens: (0, token_estimate_1.estimateMessagesTokens)(modelHistory),
+    };
+}
 function publishContextUsage(params, autoCompact, modelId, usedTokens, source = 'estimated') {
     const stats = autoCompact.getStats();
     const usage = (0, model_context_1.createContextUsageSnapshot)({
@@ -443,6 +598,57 @@ function publishAutoCompact(callback, notice) {
         // Runtime observers must never break autonomous compaction.
     }
 }
+function validateFinalCompactRequest(result, autoCompact, modelId, harness, messagesForHarness, input) {
+    const assembled = harness
+        ? harness.assembleMessages(result.messages, {
+            input,
+            tools: messagesForHarness,
+        })
+        : result.messages;
+    const estimatedTokens = (0, token_estimate_1.estimateMessagesTokens)(assembled);
+    const observedTokens = autoCompact.adjustTokenEstimate(estimatedTokens, modelId);
+    const compactStats = autoCompact.getStats();
+    const targetTokens = Math.max(1, Math.floor(compactStats.safeInputBudget * compactStats.targetRatio));
+    if (observedTokens <= targetTokens)
+        return { valid: true, observedTokens, targetTokens };
+    return {
+        valid: false,
+        code: 'no_headroom',
+        message: `Final assembled request uses ${observedTokens} tokens after compact; safe target is ${targetTokens}.`,
+        observedTokens,
+        targetTokens,
+    };
+}
+function failureForUnchangedCompactAttempt(attempt, autoCompact) {
+    const compactStats = autoCompact.getStats();
+    const beforeTokens = (0, token_estimate_1.estimateMessagesTokens)(attempt.messages);
+    return {
+        code: attempt.status === 'duplicate' ? 'context_thrash' : 'no_headroom',
+        message: attempt.status === 'duplicate'
+            ? 'The same high-pressure context reached compact again without new durable progress.'
+            : 'Compact could not reduce the high-pressure context, so the request was paused.',
+        mode: attempt.mode,
+        fingerprint: attempt.fingerprint,
+        consecutiveNoProgressAttempts: attempt.consecutiveNoProgressAttempts,
+        beforeTokens,
+        afterTokens: beforeTokens,
+        safeInputBudget: compactStats.safeInputBudget,
+        targetTokens: Math.max(1, Math.floor(compactStats.safeInputBudget * compactStats.targetRatio)),
+    };
+}
+function compactPausedEvent(llm, stats, failure, content) {
+    stats.compactFailure = {
+        ...failure,
+        validationErrors: failure.validationErrors?.map(error => ({ ...error })),
+    };
+    return {
+        type: 'complete',
+        content: content ??
+            `Context compaction paused this request: ${failure.message} Change context or budget, then resume.`,
+        model: llm.getModel(),
+        stats: cloneLoopStats(stats, 'compact_paused'),
+    };
+}
 // ============================================================================
 // query() — async generator
 // ============================================================================
@@ -462,19 +668,49 @@ function publishAutoCompact(callback, notice) {
  * }
  */
 async function* query(params) {
-    const { messages, tools, toolExecutor, llm, maxTurns, // 无默认值，可选参数
-    abortSignal, streamCallbacks, costTracker, strategyTracker = (0, strategy_tracker_1.createStrategyTracker)({ maxAttempts: 5 }), // 增加到 5 次
+    const { messages, tools: initialTools, toolExecutor: initialToolExecutor, llm, abortSignal, streamCallbacks, costTracker, strategyTracker = (0, strategy_tracker_1.createStrategyTracker)({ maxAttempts: 5 }), // 增加到 5 次
     harness, input, maxParallelToolCalls = 6, } = params;
-    const openaiTools = (0, tool_1.toOpenAITools)(tools);
     let turn = 0;
     let consecutiveCompletionGateBlocks = 0;
     const stats = createLoopStats();
     let pendingCompact;
+    const uncompactedMessages = messages.map(message => ({ ...message }));
+    const appendMessage = (message) => {
+        messages.push(message);
+        uncompactedMessages.push({ ...message });
+        if (pendingCompact) {
+            pendingCompact.uncompactedHistory = uncompactedMessages.map(entry => ({ ...entry }));
+        }
+    };
+    let compactPrepareSource;
+    const captureCompactPrepareSource = () => {
+        if (compactPrepareSource)
+            return compactPrepareSource;
+        try {
+            compactPrepareSource = params.onCompactPrepare?.();
+        }
+        catch {
+            // Candidate preparation may continue in memory, but persistence will fail
+            // closed because semantic checkpoint commits require this receipt.
+            compactPrepareSource = undefined;
+        }
+        return compactPrepareSource;
+    };
     let aggregateUsage;
-    let loopBudget = resolveLoopBudget(params.loopBudget);
+    // Preserve the old option as a resource-budget alias. It no longer emits a
+    // task-like `max_turns` completion or claims that the objective completed.
+    const legacyRequestBudget = typeof params.maxTurns === 'number' && Number.isFinite(params.maxTurns) && params.maxTurns > 0
+        ? Math.floor(params.maxTurns)
+        : undefined;
+    let loopBudget = resolveLoopBudget({
+        ...params.loopBudget,
+        ...(params.loopBudget?.maxLlmRequestsPerUserTurn === undefined && legacyRequestBudget
+            ? { maxLlmRequestsPerUserTurn: legacyRequestBudget }
+            : {}),
+    });
     applyLoopBudgetStats(stats, loopBudget);
     const maxModelVisibleToolResultBytes = Math.max(512, params.maxModelVisibleToolResultBytes ?? exports.DEFAULT_MAX_MODEL_VISIBLE_TOOL_RESULT_BYTES);
-    const fragmentedReadOnlyTools = new Set(tools_1.BATCH_READ_ALLOWED_TOOLS);
+    const fragmentedReadOnlyTools = new Set(BATCH_READ_ALLOWED_TOOLS);
     // 无限循环，依赖安全机制停止
     while (true) {
         turn++;
@@ -483,16 +719,6 @@ async function* query(params) {
             yield attachCompactCommit(cancelledCompleteEvent(llm, stats), pendingCompact, messages, aggregateUsage);
             return;
         }
-        // Safety valve: check maxTurns if specified (optional)
-        if (maxTurns && turn > maxTurns) {
-            yield attachCompactCommit({
-                type: 'complete',
-                content: `Reached maximum turns (${maxTurns}). Task may be incomplete.`,
-                model: llm.getModel(),
-                stats: cloneLoopStats(stats, 'max_turns'),
-            }, pendingCompact, messages, aggregateUsage);
-            return;
-        }
         if (shouldPromoteDefaultBudget(stats, loopBudget)) {
             loopBudget = promoteDefaultBudgetToComplex(loopBudget);
             applyLoopBudgetStats(stats, loopBudget);
@@ -501,6 +727,24 @@ async function* query(params) {
             yield attachCompactCommit(budgetExceededEvent(llm, stats, `LLM request budget ${loopBudget.maxLlmRequestsPerUserTurn} reached`), pendingCompact, messages, aggregateUsage);
             return;
         }
+        const resolvedStep = params.resolveStep
+            ? await params.resolveStep({
+                requestIndex: turn - 1,
+                messages: messages.map(message => ({ ...message })),
+                input,
+                abortSignal,
+            })
+            : { tools: initialTools, toolExecutor: initialToolExecutor };
+        const tools = [...resolvedStep.tools];
+        let toolExecutor = resolvedStep.toolExecutor;
+        const openaiTools = (0, tool_1.toOpenAITools)(tools);
+        harness?.updateCapabilityProfile?.({
+            modelId: llm.getModel(),
+            contextWindow: (0, model_context_1.getModelContextWindow)(llm.getModel()),
+            permissionMode: params.permissionMode ?? 'default',
+            toolConfirmation: params.toolConfirmation ?? 'allow',
+            tools: tools.map(tool => tool.name),
+        });
         // Request start
         yield { type: 'request_start', model: llm.getModel(), turn };
         stats.turnsStarted = turn;
@@ -532,8 +776,27 @@ async function* query(params) {
         const predictedTokens = autoCompact.adjustTokenEstimate(requestEstimatedTokens, llm.getModel());
         const contextBeforePredictiveCompact = publishContextUsage(params, autoCompact, llm.getModel(), predictedTokens, autoCompact.hasProviderCalibration(llm.getModel()) ? 'provider_adjusted' : 'estimated');
         const preCompactObjective = harness?.getCapsule()?.contract?.objective;
-        const preCompacted = await autoCompact.checkPredictiveAndCompact(messages, predictedTokens);
-        if (preCompacted !== messages) {
+        const compactToolDescriptions = tools.map(tool => ({
+            name: tool.name,
+            description: tool.description,
+        }));
+        const predictiveStats = autoCompact.getStats();
+        if (predictiveStats.enabled &&
+            predictedTokens / Math.max(1, predictiveStats.safeInputBudget) >=
+                predictiveStats.predictiveCompactThreshold) {
+            captureCompactPrepareSource();
+        }
+        const preCompactAttempt = await autoCompact.checkPredictiveCompactOutcome(messages, predictedTokens, result => validateFinalCompactRequest(result, autoCompact, llm.getModel(), harness, compactToolDescriptions, input));
+        if (preCompactAttempt.status === 'paused') {
+            yield attachCompactCommit(compactPausedEvent(llm, stats, preCompactAttempt.failure), pendingCompact, messages, aggregateUsage);
+            return;
+        }
+        if (preCompactAttempt.status === 'duplicate' || preCompactAttempt.status === 'rejected') {
+            yield attachCompactCommit(compactPausedEvent(llm, stats, failureForUnchangedCompactAttempt(preCompactAttempt, autoCompact)), pendingCompact, messages, aggregateUsage);
+            return;
+        }
+        const preCompacted = preCompactAttempt.messages;
+        if (preCompactAttempt.status === 'compacted') {
             stats.compactTrigger = 'pre_turn';
             messages.length = 0;
             messages.push(...preCompacted);
@@ -556,20 +819,7 @@ async function* query(params) {
             const compactedTokens = autoCompact.adjustTokenEstimate(requestEstimatedTokens, llm.getModel());
             autoCompact.getCtxPercent(compactedTokens);
             const contextAfterPredictiveCompact = publishContextUsage(params, autoCompact, llm.getModel(), compactedTokens, autoCompact.hasProviderCalibration(llm.getModel()) ? 'provider_adjusted' : 'estimated');
-            const result = autoCompact.getLastCompactResult();
-            if (result) {
-                pendingCompact = {
-                    mode: 'predictive',
-                    modelHistory: result.messages.map(message => ({ ...message })),
-                    summary: {
-                        text: result.summary,
-                        generatedAt: result.summaryGeneratedAt,
-                        source: result.summarySource,
-                    },
-                    before: contextBeforePredictiveCompact,
-                    after: contextAfterPredictiveCompact,
-                };
-            }
+            pendingCompact = queryCompactCommit('predictive', preCompactAttempt.result, contextBeforePredictiveCompact, contextAfterPredictiveCompact, uncompactedMessages, compactPrepareSource, harness?.toJSON());
             publishAutoCompact(params.onAutoCompact, {
                 mode: 'predictive',
                 before: contextBeforePredictiveCompact,
@@ -591,12 +841,39 @@ async function* query(params) {
                 omittedEvidence: compactPromptEvidence(assemblyStats.omittedEvidence, 8),
                 includedEvidenceCount: assemblyStats.includedEvidence.length,
                 omittedEvidenceCount: assemblyStats.omittedEvidence.length,
+                sectionManifest: assemblyStats.sectionManifest?.map(item => ({ ...item })) ?? [],
+                overBudget: assemblyStats.overBudget === true,
+                capabilityProfileVersion: assemblyStats.capabilityProfileVersion,
+                capabilityProfileFingerprint: assemblyStats.capabilityProfileFingerprint,
             };
+            if (assemblyStats.overBudget) {
+                yield attachCompactCommit(compactPausedEvent(llm, stats, {
+                    code: 'mandatory_context_over_budget',
+                    message: `Mandatory Harness context uses ${assemblyStats.estimatedTokens} tokens; its atomic section budget is ${assemblyStats.budgetTokens}.`,
+                    mode: 'predictive',
+                    fingerprint: (0, fingerprint_1.canonicalMessagesFingerprint)(requestMessages),
+                    consecutiveNoProgressAttempts: 1,
+                    beforeTokens: assemblyStats.estimatedTokens,
+                    afterTokens: assemblyStats.estimatedTokens,
+                    safeInputBudget: assemblyStats.budgetTokens,
+                    targetTokens: assemblyStats.budgetTokens,
+                }, 'Mandatory task context does not fit its atomic prompt budget. Narrow the contract or choose a larger-context model, then resume.'), pendingCompact, messages, aggregateUsage);
+                return;
+            }
         }
         if (isAborted(abortSignal)) {
             yield attachCompactCommit(cancelledCompleteEvent(llm, stats), pendingCompact, messages, aggregateUsage);
             return;
         }
+        if (resolvedStep.bindModelRequest) {
+            const bound = await resolvedStep.bindModelRequest({
+                requestIndex: turn - 1,
+                messages: requestMessages.map(message => ({ ...message })),
+                tools,
+                abortSignal,
+            });
+            toolExecutor = bound.toolExecutor;
+        }
         let response;
         try {
             stats.llmRequests++;
@@ -649,29 +926,21 @@ async function* query(params) {
                 content: response.content,
                 tool_calls: toolCalls,
             };
-            messages.push(assistantMsg);
+            appendMessage(assistantMsg);
             harness?.recordAssistantResponse(response);
             yield {
                 type: 'assistant_tool_calls',
                 content: response.content,
                 toolCalls,
             };
-            const preparedCalls = (0, tool_scheduler_1.prepareToolCalls)({
+            const preparedCalls = (0, tool_call_orchestrator_1.prepareToolCalls)({
                 toolCalls,
                 tools,
-                toolExecutor,
-                permissionMode: params.permissionMode,
-                toolConfirmation: params.toolConfirmation,
-                toolAllowlist: params.toolAllowlist,
-                confirmToolUse: params.confirmToolUse,
-                toolContext: params.toolContext,
-                abortSignal,
                 startApproach: (toolName) => strategyTracker.startApproach(toolName),
                 addToolToTracker: (attemptId, toolName) => strategyTracker.addTool(attemptId, toolName),
                 harnessDriftCheck: harness
                     ? ({ name, args }) => harness.beforeToolUse({ name, args })
                     : undefined,
-                harnessBlockedResult: harness ? drift => harness.asToolBlockedResult(drift) : undefined,
             });
             stats.toolCalls += preparedCalls.length;
             for (const prepared of preparedCalls) {
@@ -701,13 +970,9 @@ async function* query(params) {
                     batchIndex: prepared.index,
                 };
             }
-            for await (const executed of (0, tool_scheduler_1.executeToolCalls)(preparedCalls, {
+            for await (const executed of (0, tool_call_orchestrator_1.executeToolCalls)(preparedCalls, {
                 toolExecutor,
                 abortSignal,
-                confirmToolUse: params.confirmToolUse,
-                permissionMode: params.permissionMode,
-                toolConfirmation: params.toolConfirmation,
-                toolAllowlist: params.toolAllowlist,
                 harnessBlockedResult: harness ? drift => harness.asToolBlockedResult(drift) : undefined,
                 maxParallelToolCalls,
             })) {
@@ -786,7 +1051,7 @@ async function* query(params) {
                     batchCount: toolCalls.length,
                     batchIndex: prepared.index,
                 };
-                messages.push({
+                appendMessage({
                     role: 'tool',
                     content: modelVisible.result,
                     tool_call_id: tc.id,
@@ -830,7 +1095,7 @@ async function* query(params) {
                             batchCount: toolCalls.length,
                             batchIndex: skippedPrepared.index,
                         };
-                        messages.push({
+                        appendMessage({
                             role: 'tool',
                             content: skippedResult,
                             tool_call_id: skipped.id,
@@ -846,14 +1111,14 @@ async function* query(params) {
             }
             if (pendingStrategySuggestion) {
                 yield { type: 'strategy_exhausted', suggestion: pendingStrategySuggestion };
-                messages.push({
+                appendMessage({
                     role: 'user',
                     content: pendingStrategySuggestion,
                 });
                 strategyTracker.reset();
             }
             if (stats.singleReadOnlyStreak >= loopBudget.maxReadOnlyFragmentation) {
-                messages.push({
+                appendMessage({
                     role: 'system',
                     content: [
                         '[Orion Code loop hint]',
@@ -871,7 +1136,7 @@ async function* query(params) {
             role: 'assistant',
             content: response.content,
         };
-        messages.push(assistantMsg);
+        appendMessage(assistantMsg);
         harness?.recordAssistantResponse(response);
         // No tool calls — done, unless the harness requires one more pass.
         const completionGate = harness?.beforeComplete();
@@ -881,15 +1146,19 @@ async function* query(params) {
                 const missing = completionGate.missing?.length
                     ? completionGate.missing.join('; ')
                     : 'required verification evidence is missing';
+                const stoppedStats = cloneLoopStats(stats, 'completion_gate');
+                if (completionGate.stopDecision) {
+                    stoppedStats.stopDecision = completionGate.stopDecision;
+                }
                 yield attachCompactCommit({
                     type: 'complete',
                     content: `Completion gate stopped this turn: ${missing}\nRun the required verification, then continue.`,
                     model: response.model || llm.getModel(),
-                    stats: cloneLoopStats(stats, 'completion_gate'),
+                    stats: stoppedStats,
                 }, pendingCompact, messages, aggregateUsage);
                 return;
             }
-            messages.push(harness.asCompletionBlockedMessage(completionGate));
+            appendMessage(harness.asCompletionBlockedMessage(completionGate));
             stats.finishReason = 'completion_gate';
             continue;
         }
@@ -908,8 +1177,26 @@ async function* query(params) {
         const contextBeforeThresholdCompact = publishContextUsage(params, autoCompact, response.model || llm.getModel(), currentContextTokens, autoCompact.hasProviderCalibration(response.model || llm.getModel())
             ? 'provider_adjusted'
             : 'estimated');
-        const compacted = await autoCompact.checkAndCompact(messages, currentContextTokens);
-        if (compacted !== messages) {
+        const validatePostCompact = (result) => validateFinalCompactRequest(result, autoCompact, response.model || llm.getModel(), harness, compactToolDescriptions, input);
+        const thresholdStats = autoCompact.getStats();
+        if (!pendingCompact &&
+            thresholdStats.enabled &&
+            currentContextTokens / Math.max(1, thresholdStats.safeInputBudget) >= thresholdStats.threshold) {
+            captureCompactPrepareSource();
+        }
+        const postCompactAttempt = pendingCompact
+            ? await autoCompact.ensureHeadroomAndCompactOutcome(messages, currentContextTokens, validatePostCompact)
+            : await autoCompact.checkAndCompactOutcome(messages, currentContextTokens, validatePostCompact);
+        if (postCompactAttempt.status === 'paused') {
+            yield attachCompactCommit(compactPausedEvent(llm, stats, postCompactAttempt.failure, response.content), pendingCompact, messages, aggregateUsage);
+            return;
+        }
+        if (postCompactAttempt.status === 'duplicate' || postCompactAttempt.status === 'rejected') {
+            yield attachCompactCommit(compactPausedEvent(llm, stats, failureForUnchangedCompactAttempt(postCompactAttempt, autoCompact), response.content), pendingCompact, messages, aggregateUsage);
+            return;
+        }
+        const compacted = postCompactAttempt.messages;
+        if (postCompactAttempt.status === 'compacted') {
             stats.compactTrigger = stats.compactTrigger ?? 'post_turn';
             messages.length = 0;
             messages.push(...compacted);
@@ -919,20 +1206,7 @@ async function* query(params) {
             const contextAfterThresholdCompact = publishContextUsage(params, autoCompact, response.model || llm.getModel(), compactedTokens, autoCompact.hasProviderCalibration(response.model || llm.getModel())
                 ? 'provider_adjusted'
                 : 'estimated');
-            const result = autoCompact.getLastCompactResult();
-            if (result) {
-                pendingCompact = {
-                    mode: 'threshold',
-                    modelHistory: result.messages.map(message => ({ ...message })),
-                    summary: {
-                        text: result.summary,
-                        generatedAt: result.summaryGeneratedAt,
-                        source: result.summarySource,
-                    },
-                    before: contextBeforeThresholdCompact,
-                    after: contextAfterThresholdCompact,
-                };
-            }
+            pendingCompact = queryCompactCommit(pendingCompact?.mode ?? 'threshold', postCompactAttempt.result, contextBeforeThresholdCompact, contextAfterThresholdCompact, uncompactedMessages, pendingCompact?.prepareSource ?? compactPrepareSource, pendingCompact?.semanticHarnessState ?? harness?.toJSON());
             publishAutoCompact(params.onAutoCompact, {
                 mode: 'threshold',
                 before: contextBeforeThresholdCompact,
@@ -951,12 +1225,7 @@ async function* query(params) {
             usage: aggregateUsage,
             model: response.model,
             stats: cloneLoopStats(stats, 'completed'),
-            compact: pendingCompact
-                ? {
-                    ...pendingCompact,
-                    modelHistory: messages.map(message => ({ ...message })),
-                }
-                : undefined,
+            compact: pendingCompact ? bindCompactCommitToHistory(pendingCompact, messages) : undefined,
         };
         return;
     }