mixdog 0.9.151 → 0.9.152

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

@@ -17,6 +17,7 @@ import {
 import { isContextOverflowError } from '../providers/retry-classifier.mjs';
 import { tryReadCached, setReadCached, invalidatePathForSession, clearReadDedupSession, extractTouchedPathsFromPatch, tryScopedToolCached, setScopedToolCached, clearScopedToolsForSession, clearScopedToolsForSessionPaths, invalidatePrefetchCache } from './read-dedup.mjs';
 import { isInvalidToolArgsMarker, formatInvalidToolArgsResult } from '../providers/openai-compat-stream.mjs';
+import { cloneProviderReplay } from '../providers/lib/provider-replay.mjs';
 
 import {
     _stripMcpPrefix,
@@ -310,6 +311,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         const reasoningItems = Array.isArray(resp.reasoningItems) && resp.reasoningItems.length
             ? resp.reasoningItems
             : null;
+        const providerReplay = cloneProviderReplay(resp.providerReplay);
         const thinkingBlocks = Array.isArray(resp.thinkingBlocks) && resp.thinkingBlocks.length
             ? resp.thinkingBlocks
             : null;
@@ -335,18 +337,19 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
             : null;
         // A native-only turn (server tool blocks, no flattened text) is real
         // assistant output and must stay committable — not treated as empty.
-        if (!content && !reasoningContent && !reasoningItems && !thinkingBlocks && !assistantBlocks) return false;
+        if (!content && !reasoningContent && !reasoningItems && !thinkingBlocks && !assistantBlocks && !providerReplay) return false;
         const message = attachAssistantTranscriptMetadata({
             role: 'assistant',
             content,
+            ...(providerReplay ? { providerReplay } : {}),
             // assistantBlocks already contains the thinking blocks verbatim in
             // stream order, so thinkingBlocks is redundant (and would be
             // double-counted by the context estimator) when it is present.
-            ...(assistantBlocks ? { assistantBlocks } : {}),
+            ...(assistantBlocks && !providerReplay ? { assistantBlocks } : {}),
             // Anthropic adaptive-thinking signatures must be replayed verbatim
             // before the continuation turn, just like tool-call trajectories.
-            ...(thinkingBlocks && !assistantBlocks ? { thinkingBlocks } : {}),
-            ...(reasoningItems ? { reasoningItems } : {}),
+            ...(thinkingBlocks && !assistantBlocks && !providerReplay ? { thinkingBlocks } : {}),
+            ...(reasoningItems && !providerReplay ? { reasoningItems } : {}),
             ...(reasoningContent ? { reasoningContent } : {}),
             ...(providerMetadata ? { providerMetadata } : {}),
             ...(stopReason ? { stopReason } : {}),
@@ -1011,6 +1014,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         // every assistant message body.
         recordToolBatch(sessionId, calls.length);
         await Promise.resolve(onToolCall?.(iterations, calls));
+        const _providerReplay = cloneProviderReplay(response.providerReplay);
         // Append assistant message with tool calls. reasoningItems is the
         // OpenAI Responses API replay payload (encrypted_content blobs);
         // providers that ignore it just see an extra field and drop it,
@@ -1030,6 +1034,9 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
             // the whole request uncached — so a model that patches twice in a
             // row also never sees a marker where its own last patch should be.
             toolCalls: compactToolCallsForHistory(calls, { deferBodies: true }),
+            ...(_providerReplay
+                ? { providerReplay: _providerReplay }
+                : {}),
             // MIXED Anthropic turn (native server tools + client tool_use):
             // the ordered `server_tool_use` / `*_tool_result` blocks exist ONLY
             // in this verbatim list and are order-bound (a result block is
@@ -1040,6 +1047,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
             // text/thinking/tool_use blocks), so nothing is emitted twice and
             // non-Anthropic providers simply ignore the field.
             ...(Array.isArray(response.assistantBlocks) && response.assistantBlocks.length
+                && !_providerReplay
                 ? { assistantBlocks: response.assistantBlocks }
                 : {}),
             // Anthropic adaptive thinking: prior-turn thinking blocks must be
@@ -1051,9 +1059,11 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
             // second copy would double-count in the context estimator.
             ...(Array.isArray(response.thinkingBlocks) && response.thinkingBlocks.length
                 && !(Array.isArray(response.assistantBlocks) && response.assistantBlocks.length)
+                && !_providerReplay
                 ? { thinkingBlocks: response.thinkingBlocks }
                 : {}),
             ...(Array.isArray(response.reasoningItems) && response.reasoningItems.length
+                && !_providerReplay
                 ? { reasoningItems: response.reasoningItems }
                 : {}),
             ...(typeof response.reasoningContent === 'string' && response.reasoningContent

package/src/runtime/agent/orchestrator/session/cache/read-cache.mjs

@@ -260,6 +260,19 @@ export function clearReadDedupSession(sessionId) {
     clearScopedCounters(sessionId);
 }
 
+/**
+ * Start a fresh read epoch after compaction removes prior tool results from
+ * the active context. Both layers must reset together: retaining the result
+ * cache can bypass snapshot recreation, while retaining the persisted
+ * snapshot can make a fresh read answer only "[file unchanged]".
+ */
+export function resetReadStateAfterCompaction(sessionId) {
+    if (!sessionId) return;
+    _bySession.delete(sessionId);
+    _reverseIdx.delete(sessionId);
+    releaseReadSnapshotScope(sessionId, { deletePersisted: true, persist: false });
+}
+
 registerSessionPurgeHook((sessionId) => {
     clearReadDedupSession(sessionId);
     releaseReadSnapshotScope(sessionId, { deletePersisted: true, persist: false });

package/src/runtime/agent/orchestrator/session/compact/runner.mjs

@@ -589,11 +589,34 @@ function withoutRecallReplayMetadata(message) {
     return copy;
 }
 
+function hasAtomicReplayState(message) {
+    if (!message || message.role !== 'assistant') return false;
+    if (Array.isArray(message.providerReplay?.items) && message.providerReplay.items.length) return true;
+    if (Array.isArray(message.assistantBlocks) && message.assistantBlocks.length) return true;
+    if (Array.isArray(message.thinkingBlocks) && message.thinkingBlocks.length) return true;
+    if (Array.isArray(message.reasoningItems) && message.reasoningItems.length) return true;
+    if (Array.isArray(message.providerMetadata?.gemini?.thoughtParts)
+        && message.providerMetadata.gemini.thoughtParts.length) return true;
+    if (Array.isArray(message.providerMetadata?.gemini?.textParts)
+        && message.providerMetadata.gemini.textParts.length) return true;
+    if (Array.isArray(message.toolCalls)
+        && message.toolCalls.some((call) => typeof call?.thoughtSignature === 'string' && call.thoughtSignature)) {
+        return true;
+    }
+    if (typeof message.reasoningContent === 'string' && message.reasoningContent) return true;
+    const openRouter = message.providerMetadata?.openrouter;
+    const reasoningDetails = openRouter?.reasoning_details ?? openRouter?.reasoningDetails;
+    return Array.isArray(reasoningDetails) && reasoningDetails.length > 0;
+}
+
 function fitRecallMessageToCap(message, cap, rawText = null) {
     const text = rawText == null
         ? (typeof message?.content === 'string' ? message.content : extractText(message))
         : String(rawText);
-    for (const base of [message, withoutRecallReplayMetadata(message)]) {
+    const bases = hasAtomicReplayState(message)
+        ? [message]
+        : [message, withoutRecallReplayMetadata(message)];
+    for (const base of bases) {
         if (!base || typeof base !== 'object') continue;
         if (estimateMessagesTokens([{ ...base, content: text }]) <= cap) {
             return { ...base, content: text };

package/src/runtime/agent/orchestrator/session/compaction-read-reset.test.mjs

@@ -0,0 +1,161 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+
+import { executeBuiltinTool } from '../tools/builtin.mjs';
+import { COMPACT_TYPE_SEMANTIC } from './compact.mjs';
+import { runSessionCompaction } from './manager/compaction-runner.mjs';
+import { runPreSendCompactPass } from './pre-send-compact.mjs';
+import { resetReadStateAfterCompaction } from './read-dedup.mjs';
+
+const SUMMARY = [
+    '## Goal',
+    '- continue after compaction',
+    '',
+    '## Constraints & Preferences',
+    '- (none)',
+    '',
+    '## Progress',
+    '### Done',
+    '- old context summarized',
+    '',
+    '### In Progress',
+    '- (none)',
+    '',
+    '### Blocked',
+    '- (none)',
+    '',
+    '## Key Decisions',
+    '- (none)',
+    '',
+    '## Next Steps',
+    '- reread the working file',
+    '',
+    '## Critical Context',
+    '- active file must be readable again',
+    '',
+    '## Relevant Files',
+    '- working.txt',
+].join('\n');
+
+function fixture(t, tag) {
+    const dir = mkdtempSync(join(tmpdir(), `mixdog-compact-read-${tag}-`));
+    const file = join(dir, 'working.txt');
+    const sessionId = `compact-read-${tag}-${process.pid}-${Date.now()}`;
+    writeFileSync(file, 'alpha\nbeta\n', 'utf8');
+    t.after(() => {
+        resetReadStateAfterCompaction(sessionId);
+        rmSync(dir, { recursive: true, force: true });
+    });
+    return { dir, file, sessionId };
+}
+
+async function establishUnchangedSnapshot({ dir, file, sessionId }) {
+    const first = String(await executeBuiltinTool('read', { path: file }, dir, { sessionId }));
+    assert.match(first, /alpha/);
+    const duplicate = await executeBuiltinTool('read', { path: file }, dir, { sessionId });
+    assert.equal(duplicate, `[file unchanged: ${file.replaceAll('\\', '/')}]`);
+}
+
+function semanticProvider(name) {
+    return {
+        name,
+        async send() {
+            return { content: SUMMARY };
+        },
+    };
+}
+
+test('manual compaction starts a fresh read epoch', async (t) => {
+    const fx = fixture(t, 'manual');
+    await establishUnchangedSnapshot(fx);
+
+    const session = {
+        id: fx.sessionId,
+        provider: 'compact-read-manual',
+        model: 'fake-model',
+        contextWindow: 100_000,
+        compactBoundaryTokens: 100_000,
+        messages: [
+            { role: 'system', content: 'system rules stay exact' },
+            { role: 'user', content: 'older request about working.txt' },
+            { role: 'assistant', content: 'older answer with file details' },
+            { role: 'user', content: 'current request remains verbatim' },
+        ],
+        tools: [],
+        compaction: {
+            type: COMPACT_TYPE_SEMANTIC,
+            compactType: COMPACT_TYPE_SEMANTIC,
+            tailTurns: 1,
+        },
+    };
+    const result = await runSessionCompaction(session, {
+        mode: 'manual',
+        force: true,
+        compactType: COMPACT_TYPE_SEMANTIC,
+        provider: semanticProvider('compact-read-manual'),
+        model: 'fake-model',
+    });
+
+    assert.equal(result.changed, true);
+    const reread = String(await executeBuiltinTool('read', { path: fx.file }, fx.dir, { sessionId: fx.sessionId }));
+    assert.doesNotMatch(reread, /file unchanged/);
+    assert.match(reread, /alpha/);
+});
+
+test('automatic pre-send compaction resets reads only after transcript change', async (t) => {
+    const fx = fixture(t, 'auto');
+    await establishUnchangedSnapshot(fx);
+
+    const session = {
+        id: fx.sessionId,
+        owner: 'agent',
+        provider: 'compact-read-auto',
+        model: 'fake-model',
+        cwd: fx.dir,
+        contextWindow: 20_000,
+        compactBoundaryTokens: 20_000,
+        messages: [
+            { role: 'user', content: 'small request' },
+            { role: 'assistant', content: 'small answer' },
+        ],
+        tools: [],
+        compaction: { auto: true, tailTurns: 1 },
+    };
+    const state = {
+        provider: semanticProvider('compact-read-auto'),
+        messages: session.messages,
+        model: session.model,
+        requestTools: [],
+        sessionRef: session,
+        sessionId: fx.sessionId,
+        cwd: fx.dir,
+        opts: {},
+        signal: null,
+        iterations: 1,
+        lastUsage: null,
+        firstTurnUsage: null,
+        providerState: null,
+        reactiveOverflowRetryPending: false,
+        loopUsageMetricsTurnId: () => 'test-turn',
+        loopUsageMetricsEpoch: () => 0,
+    };
+
+    const noChange = await runPreSendCompactPass(state);
+    assert.equal(noChange.compactChanged, false);
+    const stillUnchanged = await executeBuiltinTool('read', { path: fx.file }, fx.dir, { sessionId: fx.sessionId });
+    assert.equal(stillUnchanged, `[file unchanged: ${fx.file.replaceAll('\\', '/')}]`);
+
+    session.messages.unshift(
+        { role: 'user', content: `large old request ${'context '.repeat(12_000)}` },
+        { role: 'assistant', content: `large old answer ${'detail '.repeat(12_000)}` },
+    );
+    const changed = await runPreSendCompactPass({ ...state, messages: session.messages });
+    assert.equal(changed.compactChanged, true);
+
+    const reread = String(await executeBuiltinTool('read', { path: fx.file }, fx.dir, { sessionId: fx.sessionId }));
+    assert.doesNotMatch(reread, /file unchanged/);
+    assert.match(reread, /alpha/);
+});

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

@@ -336,20 +336,26 @@ function messageEstimateText(m) {
         try { text += `\n${JSON.stringify(m.toolCalls)}`; }
         catch { text += `\n[${m.toolCalls.length} tool calls]`; }
     }
+    const providerReplayItems = m.role === 'assistant' && Array.isArray(m.providerReplay?.items)
+        ? m.providerReplay.items
+        : null;
+    if (providerReplayItems?.length) {
+        text += `\n${nativeBlocksEstimateText(providerReplayItems)}`;
+    }
     // Anthropic adaptive-thinking blocks round-trip verbatim (thinking text +
     // signature / redacted data) and are re-sent on tool-continuation turns, so
     // they consume real input tokens. Count them or trim/compact undercounts.
-    if (m.role === 'assistant' && Array.isArray(m.thinkingBlocks) && m.thinkingBlocks.length) {
+    if (!providerReplayItems && m.role === 'assistant' && Array.isArray(m.thinkingBlocks) && m.thinkingBlocks.length) {
         text += `\n${nativeBlocksEstimateText(m.thinkingBlocks)}`;
     }
     // Some provider adapters replay their native assistant representation
     // instead of content/toolCalls. Project it through the media normalizer so
     // text/tool metadata and opaque reasoning are counted without base64 image
     // bytes dominating the estimate.
-    if (m.role === 'assistant' && Array.isArray(m.assistantBlocks) && m.assistantBlocks.length) {
+    if (!providerReplayItems && m.role === 'assistant' && Array.isArray(m.assistantBlocks) && m.assistantBlocks.length) {
         text += `\n${nativeBlocksEstimateText(m.assistantBlocks)}`;
     }
-    if (m.role === 'assistant' && Array.isArray(m.reasoningItems) && m.reasoningItems.length) {
+    if (!providerReplayItems && 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,
@@ -357,7 +363,7 @@ function messageEstimateText(m) {
     const geminiThoughtParts = m.role === 'assistant'
         ? m.providerMetadata?.gemini?.thoughtParts
         : null;
-    if (Array.isArray(geminiThoughtParts) && geminiThoughtParts.length) {
+    if (!providerReplayItems && Array.isArray(geminiThoughtParts) && geminiThoughtParts.length) {
         text += `\n${nativeBlocksEstimateText(geminiThoughtParts)}`;
     }
     if (m.role === 'tool' && m.toolCallId) text += `\n${m.toolCallId}`;
@@ -384,6 +390,7 @@ function messageImageDescriptors(m) {
     return [
         ...contentImageDescriptors(m.content),
         ...(m.role === 'assistant' ? contentImageDescriptors(m.assistantBlocks) : []),
+        ...(m.role === 'assistant' ? contentImageDescriptors(m.providerReplay?.items) : []),
     ];
 }
 function messageImageAllowance(m) {
@@ -441,6 +448,7 @@ function contextMessageFingerprint(message) {
             assistantBlocks: contextValueFingerprint(null),
             reasoningItems: contextValueFingerprint(null),
             providerMetadata: contextValueFingerprint(null),
+            providerReplay: contextValueFingerprint(null),
             toolCallId: null,
         };
     }
@@ -452,6 +460,7 @@ function contextMessageFingerprint(message) {
         assistantBlocks: contextValueFingerprint(message.assistantBlocks),
         reasoningItems: contextValueFingerprint(message.reasoningItems),
         providerMetadata: contextValueFingerprint(message.providerMetadata),
+        providerReplay: contextValueFingerprint(message.providerReplay),
         toolCallId: message?.toolCallId || null,
     };
 }
@@ -468,6 +477,7 @@ function sameContextMessageFingerprint(a, b) {
         && sameContextValueFingerprint(a.assistantBlocks, b.assistantBlocks)
         && sameContextValueFingerprint(a.reasoningItems, b.reasoningItems)
         && sameContextValueFingerprint(a.providerMetadata, b.providerMetadata)
+        && sameContextValueFingerprint(a.providerReplay, b.providerReplay)
         && a.toolCallId === b.toolCallId;
 }
 

package/src/runtime/agent/orchestrator/session/loop/recall-fasttrack.mjs

@@ -1,6 +1,6 @@
 // Recall-fasttrack compaction pipeline (digest injection).
-// Hydrates the session transcript into the memory pipeline (ingest_session),
-// then injects a small newest-first digest + recall pointer into the
+// Reads the session transcript already persisted by the memory watcher, then
+// injects a small newest-first digest + recall pointer into the
 // compacted messages. The former full-dump path (dump_session_roots +
 // synchronous cycle1 drain) was removed 2026-07: the drain ran memory-
 // pipeline LLM chunking calls inside the compaction (11.9s of a measured

package/src/runtime/agent/orchestrator/session/loop/tool-exec.mjs

@@ -117,6 +117,10 @@ async function runReadOnlyIoWithDeadline(name, parentSignal, run) {
 
 export { runReadOnlyIoWithDeadline as _runReadOnlyIoWithDeadlineForTest };
 
+export function resolveToolCompletionSessionId({ callerSessionId } = {}) {
+    return String(callerSessionId || '').trim();
+}
+
 let codeGraphRuntimePromise = null;
 async function executeCodeGraphToolLazy(name, args, cwd, signal = null, options = {}) {
     codeGraphRuntimePromise ??= import('../../tools/code-graph.mjs');
@@ -170,7 +174,14 @@ async function executeToolOwned(name, args, cwd, callerSessionId, sessionRef, ex
     const toolOpts = scopedCacheOutcome
         ? { ...executeOpts, scopedCacheOutcome }
         : executeOpts;
-    const notificationSessionId = String(executeOpts.notifySessionId || sessionRef?.ownerSessionId || callerSessionId || '').trim();
+    // A background tool belongs to the session that invoked it. Subagent
+    // sessions carry the top-level UI session in ownerSessionId, but routing a
+    // shell completion there leaks the child task into the lead transcript.
+    const notificationSessionId = resolveToolCompletionSessionId({
+        callerSessionId,
+        ownerSessionId: sessionRef?.ownerSessionId,
+        requestedNotificationSessionId: executeOpts.notifySessionId,
+    });
     const notifyFn = typeof executeOpts.notifyFn === 'function'
         ? executeOpts.notifyFn
         : (text, meta = {}) => {

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

@@ -6,6 +6,7 @@
 import { createHash, randomUUID } from 'crypto';
 import { getProvider } from '../../providers/registry.mjs';
 import { readStreamOutcome } from '../../providers/lib/stream-outcome.mjs';
+import { cloneProviderReplay } from '../../providers/lib/provider-replay.mjs';
 import { classifyError } from '../../providers/retry-classifier.mjs';
 import { normalizeCompactType, DEFAULT_COMPACT_TYPE } from '../compact.mjs';
 import { loadSession, saveSession, saveSessionAsync, saveSessionAsyncDeferred, readSessionLifecycleFromDisk } from '../store.mjs';
@@ -60,11 +61,9 @@ import {
 } from './message-sanitize.mjs';
 import { createTurnInterruptionTracker } from './turn-interruption.mjs';
 import {
-    cancelPendingTurnCheckpoint,
     clearTurnCheckpoint,
+    createTurnCheckpointRecorder,
     recoverTurnCheckpoint,
-    turnMessagesForCheckpoint,
-    writeTurnCheckpoint,
 } from './turn-checkpoint.mjs';
 import { _getAgentLoop } from './runtime-loaders.mjs';
 import { getAgentRuntimeSync } from './agent-runtime-singleton.mjs';
@@ -344,29 +343,30 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
         const _turnCheckpointToken = randomUUID();
         const _turnCheckpointStartedAt = Date.now();
         const _codexTurnId = _codexWireSessionId ? mintUuidV7(_turnCheckpointStartedAt) : null;
+        // Coalescing window for streaming-delta flushes. It is no longer a
+        // throttle on a full-snapshot rewrite: each flush now journals only the
+        // delta since the previous one, so the window just bounds syscalls.
         const _TURN_CHECKPOINT_THROTTLE_MS = 150;
         let _turnCheckpointTimer = null;
         let _turnCheckpointStopped = false;
         let _turnCheckpointLastAt = 0;
         let _turnCheckpointWarned = false;
+        // The recorder writes this turn's header synchronously on its first
+        // flush (the crash-durability anchor for the prompt, landing before the
+        // provider runs) and appends bounded deltas afterwards.
+        const _turnCheckpointRecorder = createTurnCheckpointRecorder({
+            sessionId,
+            generation: askGeneration,
+            turnToken: _turnCheckpointToken,
+            startedAt: _turnCheckpointStartedAt,
+        });
         const _flushTurnCheckpoint = () => {
             if (_turnCheckpointStopped || !_turnOutgoing || !cancelledUserTurnContent) return false;
             try {
-                const written = writeTurnCheckpoint({
-                    sessionId,
-                    generation: askGeneration,
-                    turnToken: _turnCheckpointToken,
-                    startedAt: _turnCheckpointStartedAt,
+                const written = _turnCheckpointRecorder.record({
                     currentUserContent: cancelledUserTurnContent,
-                    turnMessages: turnMessagesForCheckpoint(_turnOutgoing, cancelledUserTurnContent),
-                    interruption: _turnInterruption.snapshot(),
-                }, {
-                    // The turn's first checkpoint is the crash-durability
-                    // anchor for the prompt and must land before the provider
-                    // runs; every later streaming/tool-boundary flush moves to
-                    // the async latest-wins lane so serialization+disk never
-                    // stall the engine thread mid-stream.
-                    sync: _turnCheckpointLastAt === 0,
+                    turnOutgoing: _turnOutgoing,
+                    interruption: _turnInterruption,
                 });
                 if (written) _turnCheckpointLastAt = Date.now();
                 return written;
@@ -398,7 +398,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             _turnCheckpointStopped = true;
             if (_turnCheckpointTimer) clearTimeout(_turnCheckpointTimer);
             _turnCheckpointTimer = null;
-            cancelPendingTurnCheckpoint(sessionId);
+            _turnCheckpointRecorder.stop();
         };
         let _interruptionSnapshot = null;
         const _prepareCloseSnapshot = (abortReason) => {
@@ -406,6 +406,9 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             if (!activeSession) return null;
             _stopTurnCheckpoint();
             activeSession.liveTurnMessages = null;
+            // Interruption finalize below rewrites the transcript; the
+            // mid-turn provider prefix snapshot must not survive it.
+            delete activeSession._providerPrefixGuardState;
             _turnInterruption.restoreTombstonedText();
             const finalized = _turnInterruption.finalize({
                 turnOutgoing: _turnOutgoing || activeSession.messages,
@@ -848,6 +851,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                     ? result.historyContent
                     : (result.content || '');
                 const _terminalStop = result?.stopReason ?? result?.stop_reason ?? null;
+                const _providerReplay = cloneProviderReplay(result.providerReplay);
                 session.messages.push({
                     role: 'assistant',
                     // Keep content as-is in memory (model-visible). Image bytes,
@@ -855,6 +859,9 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                     // time inside the session store (store.mjs _sessionForDisk).
                     content: persistedAssistantContent,
                     ...(_assistantTranscriptMeta ? { meta: { transcript: _assistantTranscriptMeta } } : {}),
+                    ...(_providerReplay
+                        ? { providerReplay: _providerReplay }
+                        : {}),
                     ...(typeof result.reasoningContent === 'string' && result.reasoningContent
                         ? { reasoningContent: result.reasoningContent }
                         : {}),
@@ -1088,6 +1095,12 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             if (activeSession) {
                 activeSession.liveTurnMessages = null;
                 delete activeSession.activeTurnCheckpoint;
+                // The provider prefix snapshot commits per successful send
+                // INSIDE the turn, while the transcript unwinds to its
+                // pre-turn/finalized shape below. A surviving mid-turn
+                // snapshot flags every retry as history_shrink ("Session
+                // state changed unexpectedly."), so it unwinds with the turn.
+                delete activeSession._providerPrefixGuardState;
             }
             // Restore before ANY finalization path. In particular, cancellation
             // can race the acknowledged non-streaming restart and surface as a

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

@@ -29,6 +29,7 @@ import { uncachedInputTokensForProvider } from './usage-metrics.mjs';
 import { pruneOffloadSession } from '../tool-result-offload.mjs';
 import { _getPendingMessagesForSession } from './pending-messages.mjs';
 import { isSessionCompactionBlocked } from './runtime-liveness.mjs';
+import { resetReadStateAfterCompaction } from '../read-dedup.mjs';
 import {
     compactTargetBudget as compactTargetBudgetForPolicy,
     currentContextEstimateTokens,
@@ -449,6 +450,7 @@ export async function runSessionCompaction(session, opts = {}) {
     const unchangedReason = changed ? null : (force ? 'nothing to compact' : 'below threshold');
     const now = Date.now();
     session.messages = compacted;
+    if (changed) resetReadStateAfterCompaction(resolvedSessionId);
     // Best-effort GC only: the 10-minute mtime gate plus this idle-only guard
     // lets an in-flight turn's sidecars survive until a later compaction/close.
     const pruneSessionId = resolvedSessionId;

package/src/runtime/agent/orchestrator/session/manager/message-sanitize.mjs

@@ -81,6 +81,9 @@ function applyCompactFailurePersistToSession(activeSession, {
     if (!messagesAdvanced) {
         activeSession.messages = sanitized;
         activeSession.providerState = undefined;
+        // Sanitized replacement can rewrite/shrink the transcript; the
+        // provider prefix snapshot must re-baseline with it.
+        delete activeSession._providerPrefixGuardState;
     }
     activeSession.updatedAt = Date.now();
     activeSession.lastUsedAt = Date.now();

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

@@ -229,6 +229,9 @@ export async function clearSessionMessages(sessionId, options = {}) {
         }
     }
     session.messages = keep;
+    // Clear truncates the transcript wholesale; drop the provider prefix
+    // snapshot so the next send re-baselines instead of history_shrink.
+    delete session._providerPrefixGuardState;
     resetSessionBp3Environment(session);
     session.totalInputTokens = 0;
     session.totalOutputTokens = 0;
@@ -340,8 +343,10 @@ export async function rewindSessionMessagesTo(sessionId, options = {}) {
     if (start < 0) return null;
     const removed = messages.length - start;
     session.messages = messages.slice(0, start);
-    // The provider cache is keyed on the exact prefix we just truncated.
+    // The provider cache is keyed on the exact prefix we just truncated;
+    // the prefix-guard snapshot describes it too and must go with it.
     session.providerState = undefined;
+    delete session._providerPrefixGuardState;
     session.updatedAt = Date.now();
     session.lastUsedAt = Date.now();
     await saveSessionAsync(session, { expectedGeneration: session.generation });

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

@@ -316,9 +316,7 @@ export function createSession(opts) {
         sessionCwdLine
             ? `- Cwd: ${sessionCwdLine} — the active Project root; relative paths and shell commands resolve here.`
             : '',
-        !ownerIsAgent
-            ? `- Shell: ${process.platform === 'win32' ? 'PowerShell' : 'Bash'}. Use ${process.platform === 'win32' ? 'PowerShell' : 'Bash'} syntax unless the user specifies otherwise.`
-            : '',
+        `- Shell: ${process.platform === 'win32' ? 'PowerShell' : 'Bash'}. Use ${process.platform === 'win32' ? 'PowerShell' : 'Bash'} syntax unless the user specifies otherwise.`,
         // A startup inventory of PATH binaries used to sit here; see
         // runtime-capabilities.mjs for why it cannot be stated truthfully
         // before a command has run. Whether the cwd is inside a repository is