mixdog 0.9.51 → 0.9.53

package/src/runtime/agent/orchestrator/session/context-utils.mjs

@@ -1,7 +1,27 @@
 import { isOffloadedToolResultText } from './tool-result-offload.mjs';
 import { createHash } from 'node:crypto';
-import { isAgentOwner } from '../agent-owner.mjs';
+import { providerNativeToolPrefixCount } from '../../../../session-runtime/provider-request-tools.mjs';
 import { contentImageDescriptors, contentToText } from '../providers/media-normalization.mjs';
+export {
+    DEFAULT_COMPACTION_BUFFER_TOKENS,
+    DEFAULT_COMPACTION_BUFFER_RATIO,
+    DEFAULT_MAIN_COMPACTION_BUFFER_RATIO,
+    MAX_COMPACTION_BUFFER_RATIO,
+    DEFAULT_COMPACTION_KEEP_TOKENS,
+    positiveTokenInt,
+    normalizeCompactionBufferRatio,
+    resolveBufferRatioCandidate,
+    resolveCompactBufferRatio,
+    resolveMainCompactBufferRatio,
+    compactionBufferTokensForBoundary,
+    isPersistedZeroBufferTelemetry,
+    isLegacyDefaultBufferTelemetry,
+    compactBufferConfigForBoundary,
+    resolveCompactBufferTokens,
+    resolveMainCompactBufferTokens,
+    resolveCompactTriggerTokens,
+    resolveSessionCompactPolicy,
+} from './context-compaction-policy.mjs';
 
 // ---------------------------------------------------------------------------
 // Conservative, Unicode-aware token estimator.
@@ -148,6 +168,14 @@ export function messageEstimateText(m) {
     if (m.role === 'assistant' && Array.isArray(m.reasoningItems) && m.reasoningItems.length) {
         text += `\n${nativeBlocksEstimateText(m.reasoningItems)}`;
     }
+    // Provider-scoped replay metadata is never sent to a different provider,
+    // but Gemini replays signed thought parts on subsequent Gemini turns.
+    const geminiThoughtParts = m.role === 'assistant'
+        ? m.providerMetadata?.gemini?.thoughtParts
+        : null;
+    if (Array.isArray(geminiThoughtParts) && geminiThoughtParts.length) {
+        text += `\n${nativeBlocksEstimateText(geminiThoughtParts)}`;
+    }
     if (m.role === 'tool' && m.toolCallId) text += `\n${m.toolCallId}`;
     return text;
 }
@@ -212,6 +240,7 @@ function contextMessageFingerprint(message) {
             thinkingBlocks: contextValueFingerprint(null),
             assistantBlocks: contextValueFingerprint(null),
             reasoningItems: contextValueFingerprint(null),
+            providerMetadata: contextValueFingerprint(null),
             toolCallId: null,
         };
     }
@@ -222,6 +251,7 @@ function contextMessageFingerprint(message) {
         thinkingBlocks: contextValueFingerprint(message.thinkingBlocks),
         assistantBlocks: contextValueFingerprint(message.assistantBlocks),
         reasoningItems: contextValueFingerprint(message.reasoningItems),
+        providerMetadata: contextValueFingerprint(message.providerMetadata),
         toolCallId: message?.toolCallId || null,
     };
 }
@@ -237,6 +267,7 @@ function sameContextMessageFingerprint(a, b) {
         && sameContextValueFingerprint(a.thinkingBlocks, b.thinkingBlocks)
         && sameContextValueFingerprint(a.assistantBlocks, b.assistantBlocks)
         && sameContextValueFingerprint(a.reasoningItems, b.reasoningItems)
+        && sameContextValueFingerprint(a.providerMetadata, b.providerMetadata)
         && a.toolCallId === b.toolCallId;
 }
 
@@ -365,228 +396,6 @@ function contextSummaryResult(state, count) {
     };
 }
 
-export const DEFAULT_COMPACTION_BUFFER_TOKENS = 0;
-export const DEFAULT_COMPACTION_BUFFER_RATIO = 0.1;
-// Main/user recall-fasttrack compacts at 95% by default. Lower triggers remain
-// opt-in through the mainBuffer* configuration and MIXDOG_MAIN_COMPACT_BUFFER_*.
-export const DEFAULT_MAIN_COMPACTION_BUFFER_RATIO = 0.05;
-export const MAX_COMPACTION_BUFFER_RATIO = 0.25;
-const MAX_BUFFER_INPUT_RATIO = 0.999_999;
-export const DEFAULT_COMPACTION_KEEP_TOKENS = 8_000;
-const LEGACY_DEFAULT_COMPACTION_BUFFER_RATIO = 0.1;
-
-export function positiveTokenInt(value) {
-    const n = Number(value);
-    return Number.isFinite(n) && n > 0 ? Math.floor(n) : null;
-}
-
-function envTokenInt(name) {
-    return positiveTokenInt(process.env[name]);
-}
-
-export function normalizeCompactionBufferRatio(value, fallback = DEFAULT_COMPACTION_BUFFER_RATIO) {
-    const n = Number(value);
-    if (Number.isFinite(n) && n > 0) return n > 1 ? n / 100 : n;
-    return fallback;
-}
-
-// Percent-named inputs (bufferPercent / bufferPct / *_BUFFER_PERCENT) carry a
-// PERCENT: 1 means 1% (0.01). Ratio-named inputs (bufferRatio / bufferFraction)
-// carry a fraction: 0.01 means 1%, and a legacy value > 1 is read as a percent.
-export function resolveBufferRatioCandidate(percentInputs = [], ratioInputs = []) {
-    for (const raw of percentInputs) {
-        const n = Number(raw);
-        if (Number.isFinite(n) && n > 0) return Math.min(MAX_BUFFER_INPUT_RATIO, n / 100);
-    }
-    for (const raw of ratioInputs) {
-        const n = Number(raw);
-        if (Number.isFinite(n) && n > 0) return Math.min(MAX_BUFFER_INPUT_RATIO, n > 1 ? n / 100 : n);
-    }
-    return null;
-}
-
-export function resolveCompactBufferRatio(cfg = {}) {
-    const resolved = resolveBufferRatioCandidate(
-        [cfg.bufferPercent, cfg.bufferPct, process.env.MIXDOG_AGENT_COMPACT_BUFFER_PERCENT],
-        [cfg.bufferRatio, cfg.bufferFraction, process.env.MIXDOG_AGENT_COMPACT_BUFFER_RATIO],
-    );
-    return normalizeCompactionBufferRatio(resolved, DEFAULT_COMPACTION_BUFFER_RATIO);
-}
-
-// Main/user settings are deliberately separate from the semantic-agent buffer:
-// `buffer*` and MIXDOG_AGENT_COMPACT_BUFFER_* remain agent-only controls.
-// Source precedence is config before environment; within each source the fixed
-// unit precedence is tokens, percent, then ratio. Invalid/zero values are
-// ignored, and percent/ratio inputs are capped below 100%/1.0.
-function positiveTokenCandidate(values = []) {
-    for (const value of values) {
-        const tokens = positiveTokenInt(value);
-        if (tokens) return tokens;
-    }
-    return null;
-}
-
-function resolveMainBufferSetting(cfg = {}) {
-    const configTokens = positiveTokenCandidate([cfg.mainBufferTokens, cfg.mainBuffer]);
-    if (configTokens) return { tokens: configTokens };
-    const configRatio = resolveBufferRatioCandidate(
-        [cfg.mainBufferPercent, cfg.mainBufferPct],
-        [cfg.mainBufferRatio, cfg.mainBufferFraction],
-    );
-    if (configRatio !== null) return { ratio: configRatio };
-
-    const envTokens = positiveTokenCandidate([process.env.MIXDOG_MAIN_COMPACT_BUFFER_TOKENS]);
-    if (envTokens) return { tokens: envTokens };
-    const envRatio = resolveBufferRatioCandidate(
-        [process.env.MIXDOG_MAIN_COMPACT_BUFFER_PERCENT],
-        [process.env.MIXDOG_MAIN_COMPACT_BUFFER_RATIO],
-    );
-    return envRatio === null ? null : { ratio: envRatio };
-}
-
-export function resolveMainCompactBufferRatio(cfg = {}) {
-    const setting = resolveMainBufferSetting(cfg);
-    return setting?.ratio ?? DEFAULT_MAIN_COMPACTION_BUFFER_RATIO;
-}
-
-export function compactionBufferTokensForBoundary(boundaryTokens, opts = {}) {
-    const boundary = Math.max(0, Math.floor(Number(boundaryTokens) || 0));
-    const explicit = Math.max(0, Math.floor(Number(opts.explicitTokens) || 0));
-    if (!boundary) return explicit;
-    const maxRatio = normalizeCompactionBufferRatio(opts.maxRatio, MAX_COMPACTION_BUFFER_RATIO);
-    const cap = Math.max(0, Math.floor(boundary * maxRatio));
-    if (explicit > 0) return Math.max(0, Math.min(explicit, cap));
-    const ratio = normalizeCompactionBufferRatio(opts.ratio, DEFAULT_COMPACTION_BUFFER_RATIO);
-    return Math.max(0, Math.min(Math.floor(boundary * ratio), cap));
-}
-
-export function isPersistedZeroBufferTelemetry(cfg = {}, boundaryTokens = 0) {
-    const boundary = positiveTokenInt(boundaryTokens);
-    if (!boundary) return false;
-    if (envTokenInt('MIXDOG_AGENT_COMPACT_BUFFER_TOKENS')) return false;
-    for (const envName of ['MIXDOG_AGENT_COMPACT_BUFFER_PERCENT', 'MIXDOG_AGENT_COMPACT_BUFFER_RATIO']) {
-        const n = Number(process.env[envName]);
-        if (Number.isFinite(n) && n > 0) return false;
-    }
-    for (const key of ['bufferPercent', 'bufferPct', 'bufferFraction']) {
-        const n = Number(cfg?.[key]);
-        if (Number.isFinite(n) && n > 0) return false;
-    }
-    const ratio = Number(cfg?.bufferRatio);
-    if (Number.isFinite(ratio) && ratio > 0) return false;
-    const explicitTokens = Number(cfg?.bufferTokens ?? cfg?.buffer);
-    if (!Number.isFinite(explicitTokens) || explicitTokens !== 0) return false;
-    return true;
-}
-
-export function isLegacyDefaultBufferTelemetry(cfg = {}, boundaryTokens = 0) {
-    const boundary = positiveTokenInt(boundaryTokens);
-    if (!boundary) return false;
-    if (envTokenInt('MIXDOG_AGENT_COMPACT_BUFFER_TOKENS')) return false;
-    for (const envName of ['MIXDOG_AGENT_COMPACT_BUFFER_PERCENT', 'MIXDOG_AGENT_COMPACT_BUFFER_RATIO']) {
-        const n = Number(process.env[envName]);
-        if (Number.isFinite(n) && n > 0) return false;
-    }
-    // Percent/fraction-named fields are operator config. Legacy/default
-    // telemetry persisted bufferTokens + bufferRatio after a check/compact pass.
-    for (const key of ['bufferPercent', 'bufferPct', 'bufferFraction']) {
-        const n = Number(cfg?.[key]);
-        if (Number.isFinite(n) && n > 0) return false;
-    }
-    const explicitTokens = positiveTokenInt(cfg?.bufferTokens ?? cfg?.buffer);
-    const ratio = Number(cfg?.bufferRatio);
-    if (!explicitTokens || !Number.isFinite(ratio) || Math.abs(ratio - LEGACY_DEFAULT_COMPACTION_BUFFER_RATIO) > 1e-9) return false;
-    const expectedTokens = Math.floor(boundary * LEGACY_DEFAULT_COMPACTION_BUFFER_RATIO);
-    const cfgBoundary = positiveTokenInt(cfg?.boundaryTokens);
-    const cfgTrigger = positiveTokenInt(cfg?.triggerTokens);
-    return explicitTokens === expectedTokens
-        || (cfgBoundary === boundary && cfgTrigger > 0 && explicitTokens === Math.max(0, boundary - cfgTrigger));
-}
-
-export function compactBufferConfigForBoundary(cfg = {}, boundaryTokens = 0) {
-    const base = cfg || {};
-    if (!isLegacyDefaultBufferTelemetry(base, boundaryTokens)
-        && !isPersistedZeroBufferTelemetry(base, boundaryTokens)) {
-        return base;
-    }
-    return {
-        ...base,
-        bufferTokens: null,
-        buffer: null,
-        bufferRatio: null,
-    };
-}
-
-export function resolveCompactBufferTokens(boundaryTokens, cfg = {}, opts = {}) {
-    const boundary = positiveTokenInt(boundaryTokens);
-    const effectiveCfg = compactBufferConfigForBoundary(cfg, boundary);
-    const configured = positiveTokenInt(effectiveCfg.bufferTokens ?? effectiveCfg.buffer)
-        || envTokenInt('MIXDOG_AGENT_COMPACT_BUFFER_TOKENS')
-        || 0;
-    if (!boundary) return configured || positiveTokenInt(opts.defaultTokens) || DEFAULT_COMPACTION_BUFFER_TOKENS;
-    return compactionBufferTokensForBoundary(boundary, {
-        explicitTokens: configured,
-        ratio: resolveCompactBufferRatio(effectiveCfg),
-        maxRatio: opts.maxRatio ?? MAX_COMPACTION_BUFFER_RATIO,
-    });
-}
-
-export function resolveMainCompactBufferTokens(boundaryTokens, cfg = {}, opts = {}) {
-    const boundary = positiveTokenInt(boundaryTokens);
-    const setting = resolveMainBufferSetting(cfg);
-    const configured = setting?.tokens || 0;
-    if (!boundary) return configured || positiveTokenInt(opts.defaultTokens) || DEFAULT_COMPACTION_BUFFER_TOKENS;
-    return compactionBufferTokensForBoundary(boundary, {
-        explicitTokens: configured,
-        ratio: setting?.ratio ?? DEFAULT_MAIN_COMPACTION_BUFFER_RATIO,
-        maxRatio: opts.maxRatio ?? MAX_COMPACTION_BUFFER_RATIO,
-    });
-}
-
-export function resolveCompactTriggerTokens(sessionOrConfig = {}, boundaryTokens = 0) {
-    return resolveSessionCompactPolicy(sessionOrConfig, boundaryTokens).triggerTokens;
-}
-
-// Single source of truth for per-session compaction policy math. Manager
-// (compactTriggerForSession), the turn loop (resolveWorkerCompactPolicy), and
-// the /context gauge all derive their trigger/buffer from here so the numbers
-// never diverge. Rules:
-//   - a truly-explicit sub-boundary auto-compact limit always wins
-//     (trigger = limit) for every session type;
-//   - agent-owned semantic sessions otherwise keep the default early-trigger
-//     buffer (config-driven, default 10% -> compact at 90% of the boundary);
-//   - main/user recall-fasttrack sessions use their independently configurable
-//     buffer (default 25% -> compact at 75% of the effective boundary).
-// Returns the sanitized explicit limit (null when absent/legacy full-window)
-// plus triggerTokens / bufferTokens / bufferRatio for the given boundary.
-export function resolveSessionCompactPolicy(sessionOrConfig = {}, boundaryTokens = 0) {
-    const cfg = sessionOrConfig?.compaction || sessionOrConfig || {};
-    const boundary = positiveTokenInt(boundaryTokens);
-    if (!boundary) {
-        return {
-            autoCompactTokenLimit: null,
-            triggerTokens: null,
-            bufferTokens: 0,
-            bufferRatio: isAgentOwner(sessionOrConfig)
-                ? resolveCompactBufferRatio(cfg)
-                : resolveMainCompactBufferRatio(cfg),
-        };
-    }
-    const rawLimit = positiveTokenInt(sessionOrConfig?.autoCompactTokenLimit ?? cfg?.autoCompactTokenLimit);
-    const explicitLimit = rawLimit && rawLimit < boundary ? rawLimit : null;
-    let triggerTokens;
-    if (explicitLimit) {
-        triggerTokens = explicitLimit;
-    } else if (isAgentOwner(sessionOrConfig)) {
-        triggerTokens = Math.max(1, boundary - resolveCompactBufferTokens(boundary, cfg));
-    } else {
-        triggerTokens = Math.max(1, boundary - resolveMainCompactBufferTokens(boundary, cfg));
-    }
-    const bufferTokens = Math.max(0, boundary - triggerTokens);
-    const bufferRatio = bufferTokens / boundary;
-    return { autoCompactTokenLimit: explicitLimit, triggerTokens, bufferTokens, bufferRatio };
-}
-
 function stripSystemReminder(text) {
     return String(text || '')
         .replace(/^\s*<system-reminder>\s*/i, '')
@@ -680,8 +489,12 @@ const requestReserveTokenMemo = new WeakMap();
 
 function serializeToolSchemas(tools) {
     const list = Array.isArray(tools) ? tools : [];
+    const nativePrefixCount = providerNativeToolPrefixCount(list);
     try {
-        return JSON.stringify(list.map(tool => {
+        return JSON.stringify(list.map((tool, index) => {
+            if (index < nativePrefixCount) {
+                return tool;
+            }
             const wireTool = {
                 name: tool?.name,
                 description: tool?.description,

package/src/runtime/agent/orchestrator/session/loop/compact-policy.mjs

@@ -28,16 +28,6 @@ import { providerInputExcludesCache } from '../../providers/registry.mjs';
 // the recall-fasttrack injection cap uses (loop.mjs recallTokenCap). One
 // number governs every "share of model context" budget.
 
-function resolveSemanticCompactSetting(sessionRef, cfg = {}) {
-    // Types are hard-locked (agent -> semantic, main/user -> recall-fasttrack).
-    // Semantic must always be available as a compact path or agent sessions
-    // would have none (loop.mjs throws when no type is available). Env/cfg
-    // off-switches no longer apply.
-    void sessionRef;
-    void cfg;
-    return true;
-}
-
 function resolveCompactTypeSetting(sessionRef, cfg = {}) {
     // Agent-owned sessions are ALWAYS semantic. recall-fasttrack rebuilds
     // context from Memory recall, which is scoped to the user's main-session
@@ -171,7 +161,7 @@ export function resolveWorkerCompactPolicy(sessionRef, tools) {
             ? Number(sessionRef.effectiveContextWindowPercent ?? cfg.effectiveContextWindowPercent)
             : null,
         autoCompactTokenLimit: explicitAutoCompactTokenLimit,
-        semantic: compactTypeIsSemantic(compactType) && resolveSemanticCompactSetting(sessionRef, cfg),
+        semantic: compactTypeIsSemantic(compactType),
         recallFastTrack: compactTypeIsRecallFastTrack(compactType),
         semanticTimeoutMs: positiveTokenInt(cfg.timeoutMs) || envTokenInt('MIXDOG_AGENT_COMPACT_TIMEOUT_MS') || 30_000,
         tailTurns: positiveTokenInt(cfg.tailTurns) || envTokenInt('MIXDOG_AGENT_COMPACT_TAIL_TURNS') || 2,
@@ -191,15 +181,15 @@ function compactPressureTokens(messageTokensEst, policy) {
 
 function providerPressureTokens(sessionRef, usage) {
     if (!usage || typeof usage !== 'object') return 0;
-    const input = Math.max(0, Number(usage.inputTokens) || 0);
-    const cachedRead = Math.max(0, Number(usage.cachedTokens) || 0);
-    const cacheWrite = Math.max(0, Number(usage.cacheWriteTokens) || 0);
-    const explicitPrompt = Math.max(0, Number(usage.promptTokens) || 0);
+    const input = Math.max(0, Number(usage.mainInputTokens ?? usage.inputTokens) || 0);
+    const cachedRead = Math.max(0, Number(usage.mainCachedTokens ?? usage.cachedTokens) || 0);
+    const cacheWrite = Math.max(0, Number(usage.mainCacheWriteTokens ?? usage.cacheWriteTokens) || 0);
+    const explicitPrompt = Math.max(0, Number(usage.mainPromptTokens ?? usage.promptTokens) || 0);
     const normalizedPrompt = providerInputExcludesCache(sessionRef?.provider)
         ? input + cachedRead + cacheWrite
         : input;
     const prompt = Math.max(explicitPrompt, normalizedPrompt);
-    const output = Math.max(0, Number(usage.outputTokens) || 0);
+    const output = Math.max(0, Number(usage.mainOutputTokens ?? usage.outputTokens) || 0);
     return Math.max(0, Math.round(prompt + output));
 }
 
@@ -213,10 +203,14 @@ export function recordProviderContextBaseline(sessionRef, messages, usage, {
     sendTools = sessionRef?.tools,
 } = {}) {
     if (!sessionRef || !Array.isArray(messages)) return false;
+    if (usage?.mainUsageAvailable === false) {
+        invalidateProviderContextBaseline(sessionRef);
+        return false;
+    }
     const tokens = providerPressureTokens(sessionRef, usage);
     if (!tokens) return false;
     sessionRef.contextPressureBaselineTokens = tokens;
-    sessionRef.contextPressureBaselineOutputTokens = Math.max(0, Math.round(Number(usage?.outputTokens) || 0));
+    sessionRef.contextPressureBaselineOutputTokens = Math.max(0, Math.round(Number(usage?.mainOutputTokens ?? usage?.outputTokens) || 0));
     sessionRef.contextPressureBaselineMessageCount = messages.length;
     sessionRef.contextPressureBaselinePrefixSignature = contextMessagesSignature(messages);
     sessionRef.contextPressureBaselineProvider = sessionRef.provider || null;

package/src/runtime/agent/orchestrator/session/manager/ask-session.mjs

@@ -22,7 +22,6 @@ import {
     buildCurrentTimeBlock,
     buildSessionStartBlock,
     hasUserConversationMessage,
-    isInternalRuntimeNotificationText,
 } from './prompt-utils.mjs';
 import { _mergePendingMessageEntries, drainPendingMessages } from './pending-messages.mjs';
 import { persistIterationMetrics, applyAskTerminalUsageTotals } from './usage-metrics.mjs';
@@ -38,11 +37,16 @@ import {
     _touchRuntime,
     _unlinkParentAbortListener,
     _getRuntimeEntry,
+    _evictTerminalSessionRuntime,
 } from './runtime-liveness.mjs';
 import { SessionClosedError } from './session-errors.mjs';
 import { acquireSessionLock } from './session-lock.mjs';
 import { _tryBridgeExplicitPrefetch } from './prefetch-bridge.mjs';
-import { sanitizeSessionMessagesForModel, persistCompactedOutgoingAfterAskFailure } from './message-sanitize.mjs';
+import {
+    filterModelVisibleSessionMessages,
+    persistCompactedOutgoingAfterAskFailure,
+} from './message-sanitize.mjs';
+import { createTurnInterruptionTracker } from './turn-interruption.mjs';
 import { _getAgentLoop } from './runtime-loaders.mjs';
 import { getAgentRuntimeSync } from './agent-runtime-singleton.mjs';
 import { recordProviderContextBaseline } from '../loop/compact-policy.mjs';
@@ -188,6 +192,8 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
         let activeSession = preSession;
         let cancelledUserTurnContent = '';
         let _turnOutgoing = null;
+        const _turnInterruption = createTurnInterruptionTracker();
+        const _sessionStartMetaInjectedBeforeTurn = preSession.sessionStartMetaInjected === true;
         try {
             const session = activeSession;
             const provider = getProvider(session.provider);
@@ -244,7 +250,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             if (explicitPrefetchResult) {
                 _contextBlock += `# Prefetch\n${_capCtx(explicitPrefetchResult)}\n\n`;
             }
-            const historyMessages = sanitizeSessionMessagesForModel(session.messages);
+            const historyMessages = filterModelVisibleSessionMessages(session.messages);
             const beforeCount = historyMessages.length + 1;
             const promptTextForMetrics = promptContentText(prompt);
             // Soft warning only; real size management (compaction primary,
@@ -291,7 +297,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             // below overwrites this provisional transcript with the fully mutated
             // outgoing history and appends the assistant result, so no duplicate
             // user turn is introduced.
-            session.messages = sanitizeSessionMessagesForModel(outgoing);
+            session.messages = filterModelVisibleSessionMessages(outgoing);
             session.liveTurnMessages = outgoing;
             saveSessionAsync(session, { expectedGeneration: askGeneration }).catch((err) => {
                 try { process.stderr.write(`[session] preflight user-turn save failed: ${err?.message || err}\n`); } catch {}
@@ -324,6 +330,27 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                 });
             } catch { /* trace must never break the ask path */ }
             const agentLoop = await _getAgentLoop();
+            const _trackTextDelta = (chunk) => {
+                _turnInterruption.recordTextDelta(chunk);
+                if (typeof askOpts?.onTextDelta === 'function') askOpts.onTextDelta(chunk);
+            };
+            const _trackReasoningDelta = (chunk) => {
+                _turnInterruption.recordReasoningDelta(chunk);
+                if (typeof askOpts?.onReasoningDelta === 'function') askOpts.onReasoningDelta(chunk);
+            };
+            const _trackAssistantText = (text) => {
+                _turnInterruption.recordAssistantText(text);
+                if (typeof askOpts?.onAssistantText === 'function') askOpts.onAssistantText(text);
+            };
+            const _trackedOnToolCall = async (iteration, calls) => {
+                _turnInterruption.recordToolCalls(calls);
+                if (typeof onToolCall === 'function') return await onToolCall(iteration, calls);
+                return undefined;
+            };
+            const _trackToolResult = (message) => {
+                _turnInterruption.recordToolResult(message);
+                if (typeof askOpts?.onToolResult === 'function') askOpts.onToolResult(message);
+            };
             const priorToolApprovalHook = session.toolApprovalHook;
             if (typeof askOpts?.onToolApproval === 'function') {
                 session.toolApprovalHook = askOpts.onToolApproval;
@@ -331,13 +358,17 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             let result;
             try {
             result = await _api_call_with_interrupt(sessionId, (signal) =>
-                agentLoop(provider, outgoing, session.model, session.tools, onToolCall, effectiveCwd, {
+                agentLoop(provider, outgoing, session.model, session.tools, _trackedOnToolCall, effectiveCwd, {
                     effort: session.effort || null,
                     fast: session.fast === true,
                     sessionId,
-                    onTextDelta: typeof askOpts?.onTextDelta === 'function' ? askOpts.onTextDelta : undefined,
-                    onReasoningDelta: typeof askOpts?.onReasoningDelta === 'function' ? askOpts.onReasoningDelta : undefined,
-                    onAssistantText: typeof askOpts?.onAssistantText === 'function' ? askOpts.onAssistantText : undefined,
+                    onTextDelta: _trackTextDelta,
+                    onReasoningDelta: _trackReasoningDelta,
+                    onAssistantText: _trackAssistantText,
+                    onAssistantMessageCommitted: () => _turnInterruption.markAssistantMessageCommitted(),
+                    onAssistantToolCallObserved: (call, detail) => _turnInterruption.recordToolCalls([call], detail),
+                    onProviderSendStarted: () => _turnInterruption.markProviderSendStarted(),
+                    onToolPhaseStarted: () => _turnInterruption.markToolPhaseStarted(),
                     onUsageDelta: (d) => {
                         persistIterationMetrics(d).catch(() => {});
                         // provider_send usage arrives before agentLoop appends
@@ -348,16 +379,17 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                         // tool results/steering.
                         if (d?.source === 'provider_send') {
                             recordProviderContextBaseline(session, outgoing, {
-                                inputTokens: d.deltaInput,
-                                outputTokens: d.deltaOutput,
-                                promptTokens: d.deltaPrompt,
-                                cachedTokens: d.deltaCachedRead,
-                                cacheWriteTokens: d.deltaCacheWrite,
+                                mainUsageAvailable: d.contextUsageAvailable,
+                                inputTokens: d.contextInputTokens ?? d.deltaInput,
+                                outputTokens: d.contextOutputTokens ?? d.deltaOutput,
+                                promptTokens: d.contextPromptTokens ?? d.deltaPrompt,
+                                cachedTokens: d.contextCachedReadTokens ?? d.deltaCachedRead,
+                                cacheWriteTokens: d.contextCacheWriteTokens ?? d.deltaCacheWrite,
                             }, { boundary: 'request', sendTools: d.sendTools });
                         }
                         try { askOpts?.onUsageDelta?.(d); } catch {}
                     },
-                    onToolResult: typeof askOpts?.onToolResult === 'function' ? askOpts.onToolResult : undefined,
+                    onToolResult: _trackToolResult,
                     onToolApproval: typeof askOpts?.onToolApproval === 'function' ? askOpts.onToolApproval : undefined,
                     onCompactEvent: typeof askOpts?.onCompactEvent === 'function' ? askOpts.onCompactEvent : undefined,
                     // Claude Code parity: mid-chain queued prompt/notification
@@ -429,7 +461,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             // Update and save. outgoing is mutated in place by agentLoop
             // (compaction + safety trim), so its length reflects post-loop state.
             const messagesDropped = Math.max(0, beforeCount - outgoing.length);
-            session.messages = sanitizeSessionMessagesForModel(outgoing);
+            session.messages = filterModelVisibleSessionMessages(outgoing);
             // Turn committed into session.messages; drop the live-turn alias so
             // contextStatus() reverts to the authoritative committed transcript.
             session.liveTurnMessages = null;
@@ -451,6 +483,9 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                     ...(typeof result.reasoningContent === 'string' && result.reasoningContent
                         ? { reasoningContent: result.reasoningContent }
                         : {}),
+                    ...(result.providerMetadata && typeof result.providerMetadata === 'object'
+                        ? { providerMetadata: result.providerMetadata }
+                        : {}),
                 });
             } else {
                 // Empty terminal turn: still persist a forensic record so
@@ -576,12 +611,13 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                 });
                 recordStandaloneStatusTelemetry(session, result, Date.now() - _askStartedAt);
             }
-            // Persist opaque providerState for future stateful providers.
-            // No provider currently emits it (openai-oauth is stateless per
-            // contract), so this branch is dormant — kept so a future
-            // Responses-API provider with stable continuation can plug in
-            // without reworking the session shape.
-            if (result.providerState !== undefined) {
+            // Persist opaque providerState for stateful providers. The update
+            // bit distinguishes an adapter that emitted no state update from
+            // an explicit clear caused by compaction/provider reset.
+            if (result.providerStateUpdated === true
+                && (result.providerState === undefined || result.providerState === null)) {
+                delete session.providerState;
+            } else if (result.providerStateUpdated === true || result.providerState !== undefined) {
                 session.providerState = result.providerState;
             }
             const terminalResultPreview = {
@@ -634,28 +670,26 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                 const currentRuntime = _getRuntimeEntry(sessionId);
                 if (!currentRuntime?.closed) {
                     if (activeSession) {
-                        const originalMessages = Array.isArray(activeSession.messages) ? activeSession.messages : [];
-                        const cleanedMessages = sanitizeSessionMessagesForModel(originalMessages);
-                        const nextMessages = cleanedMessages.slice();
-                        // In-memory cancelled turn keeps its original content
-                        // (images intact for the next model send); the store
-                        // layer placeholders image bytes on disk serialization.
-                        const cancelledStoredContent = cancelledUserTurnContent;
-                        const shouldPreserveUserTurn = cancelledStoredContent && !isInternalRuntimeNotificationText(cancelledStoredContent);
-                        const lastMessage = nextMessages[nextMessages.length - 1];
-                        if (shouldPreserveUserTurn && !(lastMessage?.role === 'user' && promptContentText(lastMessage.content) === promptContentText(cancelledStoredContent))) {
-                            nextMessages.push({ role: 'user', content: cancelledStoredContent });
-                        }
-                        const messagesChanged = nextMessages.length !== originalMessages.length
-                            || nextMessages.some((message, index) => message !== originalMessages[index]);
-                        if (messagesChanged) {
-                            activeSession.messages = nextMessages;
-                            activeSession.updatedAt = Date.now();
-                            activeSession.lastUsedAt = Date.now();
-                            try {
-                                await saveSessionAsync(activeSession, { expectedGeneration: askGeneration });
-                            } catch { /* cancellation cleanup is best-effort */ }
+                        const finalized = _turnInterruption.finalize({
+                            turnOutgoing: _turnOutgoing || activeSession.messages,
+                            currentUserContent: cancelledUserTurnContent,
+                            abortReason: err.reason,
+                        });
+                        activeSession.messages = finalized.messages;
+                        if (!finalized.responsePreserved) {
+                            activeSession.sessionStartMetaInjected = _sessionStartMetaInjectedBeforeTurn;
+                        } else {
+                            // The opaque provider continuation now points at a
+                            // request that ended mid-turn. Force full transcript
+                            // replay on the next send instead of reusing it.
+                            activeSession.providerState = undefined;
                         }
+                        activeSession.updatedAt = Date.now();
+                        activeSession.lastUsedAt = Date.now();
+                        try {
+                            await saveSessionAsync(activeSession, { expectedGeneration: askGeneration });
+                        } catch { /* cancellation cleanup is best-effort */ }
+                        if (currentRuntime) currentRuntime.session = activeSession;
                     }
                     markSessionCancelled(sessionId);
                 }
@@ -715,6 +749,11 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             // Detach the live session reference; ask is over.
             entry.session = null;
         }
+        // Final-stage runtime diagnostics are useful only while the turn is
+        // unwinding. Once its controller is detached, retaining the full entry
+        // (and any accidental references hanging from it) for the host lifetime
+        // turns one-shot agent traffic into an unbounded manager Map.
+        _evictTerminalSessionRuntime(sessionId);
         unlock();
     }
 }

package/src/runtime/agent/orchestrator/session/manager/compaction-runner.mjs

@@ -12,6 +12,7 @@ import {
     effectiveBudget as compactEffectiveBudget,
     compactTypeIsRecallFastTrack,
     compactTypeIsSemantic,
+    normalizeCompactType,
     CONTEXT_SHARE_RATIO,
     RECALL_TOKEN_CAP_FLOOR_TOKENS,
 } from '../compact.mjs';
@@ -271,7 +272,13 @@ export async function runSessionCompaction(session, opts = {}) {
         : boundary;
     const pressureTokens = estimateTranscriptContextUsage(messages, session.tools || []);
     const beforeTokens = pressureTokens;
-    const compactType = compactTypeForSession(session);
+    // Manual /compact may explicitly request the original semantic path:
+    // summarize THIS session's transcript directly without hydrating/searching
+    // Memory first. Automatic and auto-clear compaction keep their configured
+    // recall-fasttrack behavior unless their caller explicitly changes it.
+    const compactType = mode === 'manual' && opts.compactType != null
+        ? normalizeCompactType(opts.compactType)
+        : compactTypeForSession(session);
     if (!force && pressureTokens < triggerTokens) return {
         changed: false,
         reason: 'below threshold',
@@ -358,6 +365,7 @@ export async function runSessionCompaction(session, opts = {}) {
                             tailTurns: positiveContextWindow(session.compaction?.tailTurns) || 2,
                             keepTokens: positiveContextWindow(session.compaction?.keepTokens ?? session.compaction?.keep?.tokens),
                             preserveRecentTokens: positiveContextWindow(session.compaction?.preserveRecentTokens),
+                            filterOldHistoryForIngest: opts.filterOldHistoryForIngest === true,
                             force: true,
                         },
                     );
@@ -401,6 +409,7 @@ export async function runSessionCompaction(session, opts = {}) {
                     tailTurns: positiveContextWindow(session.compaction?.tailTurns) || 2,
                     keepTokens: positiveContextWindow(session.compaction?.keepTokens ?? session.compaction?.keep?.tokens),
                     preserveRecentTokens: positiveContextWindow(session.compaction?.preserveRecentTokens),
+                    filterOldHistoryForIngest: opts.filterOldHistoryForIngest === true,
                     force: true,
                 },
             );