@orion-agents/orion-code 0.1.7 → 0.1.9

package/dist/framework/query.js

@@ -11,6 +11,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryLoopError = exports.DEFAULT_LOOP_BUDGET = exports.DEFAULT_MAX_MODEL_VISIBLE_TOOL_RESULT_BYTES = void 0;
+exports.withLoopFinishReason = withLoopFinishReason;
 exports.createLocalFastPathLoopStats = createLocalFastPathLoopStats;
 exports.createFailedLoopStats = createFailedLoopStats;
 exports.query = query;
@@ -18,12 +19,14 @@ 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 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");
 exports.DEFAULT_MAX_MODEL_VISIBLE_TOOL_RESULT_BYTES = 4096;
 function isAborted(signal) {
     return signal?.aborted === true;
@@ -120,23 +123,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: '/loop-stats',
+            });
+        }
+        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 +281,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';
@@ -404,18 +536,44 @@ function omitModelVisibleToolResult(executed, maxAggregateBytes) {
         summarizedBytes: Math.max(0, fullBytes - bytes),
     };
 }
+function queryCompactCommit(mode, result, before, after, prepareSource, semanticHarnessState) {
+    return {
+        mode,
+        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,
+        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 +601,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 +671,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, toolExecutor, 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;
+    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);
+    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),
+    });
     // 无限循环，依赖安全机制停止
     while (true) {
         turn++;
@@ -483,16 +722,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);
@@ -532,8 +761,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 +804,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, compactPrepareSource, harness?.toJSON());
             publishAutoCompact(params.onAutoCompact, {
                 mode: 'predictive',
                 before: contextBeforePredictiveCompact,
@@ -591,7 +826,25 @@ 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);
@@ -707,6 +960,7 @@ async function* query(params) {
                 confirmToolUse: params.confirmToolUse,
                 permissionMode: params.permissionMode,
                 toolConfirmation: params.toolConfirmation,
+                toolAllowlist: params.toolAllowlist,
                 harnessBlockedResult: harness ? drift => harness.asToolBlockedResult(drift) : undefined,
                 maxParallelToolCalls,
             })) {
@@ -723,6 +977,12 @@ async function* query(params) {
                 stats.toolResultBytes += executed.outputBytes ?? byteLength(executed.result);
                 stats.modelVisibleToolBytes += modelVisible.bytes;
                 stats.summarizedBytes += modelVisible.summarizedBytes;
+                stats.lastToolName = tc.function.name;
+                stats.lastToolSummary = (executed.summary ?? executed.error ?? '')
+                    .replace(/\s+/gu, ' ')
+                    .trim()
+                    .slice(0, 240);
+                stats.lastToolSuccess = executed.success;
                 strategyTracker.recordResult(attemptId, executed.strategyResult, executed.strategyError, executed.duration);
                 harness?.recordToolResult({
                     name: tc.function.name,
@@ -805,6 +1065,9 @@ async function* query(params) {
                         });
                         stats.toolResultBytes += skippedBytes;
                         stats.modelVisibleToolBytes += skippedBytes;
+                        stats.lastToolName = skipped.function.name;
+                        stats.lastToolSummary = skippedError;
+                        stats.lastToolSuccess = false;
                         yield {
                             type: 'tool_result',
                             name: skipped.function.name,
@@ -871,11 +1134,15 @@ 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;
             }
@@ -898,8 +1165,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);
@@ -909,20 +1194,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, pendingCompact?.prepareSource ?? compactPrepareSource, pendingCompact?.semanticHarnessState ?? harness?.toJSON());
             publishAutoCompact(params.onAutoCompact, {
                 mode: 'threshold',
                 before: contextBeforeThresholdCompact,
@@ -941,12 +1213,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;
     }