praxis-agent 0.55.0 → 0.55.2

package/dist/application/session-service.js

@@ -8,22 +8,21 @@ import { formatClaudeCompactSummary } from '../native/compaction.js';
 import { isClaudeAgentId } from '../native/sidechain.js';
 import { assertNativeDataPlane, resolveDataPlanePaths, resolveScheduledTaskFile, } from '../persistence/data-plane.js';
 import { downloadClaudeFileResources, } from '../native/file-resources.js';
-import { selectClaudeActiveTranscript } from '../native/history.js';
 import { ClaudeFileHistory } from '../native/file-history.js';
 import { getClaudeAgentSetting, projectClaudeModelMessages, } from '../native/projection.js';
 import { projectNativeSessionEntries } from './native-session-projection.js';
 import { classifyClaudeInterruption, } from '../native/interruption.js';
 import { findUnresolvedClaudeToolCalls, getClaudeContentBlocks, } from '../native/tool-links.js';
-import { createClaudeAgentSettingEntry, createClaudeHookAttachmentEntries, createClaudeLastPromptEntry, createClaudeRuleAttachmentEntry, translateProviderEvents, } from '../native/translation.js';
+import { createClaudeAgentSettingEntry, createClaudeHookAttachmentEntries, createClaudeRuleAttachmentEntry, translateProviderEvents, } from '../native/translation.js';
 import { AgentRunCancelledError, AgentRuntime, MALFORMED_TOOL_INPUT_MESSAGE, ModelProviderError, } from '../core/runtime.js';
 import { resolveToolSchedulingPolicy } from '../core/tool-scheduling-policy.js';
 import { BackgroundTaskRuntime, } from './background-task-runtime.js';
 import { backgroundAgentNotificationMarkers, } from './background-agent-manager.js';
 import { usageCostUsd } from '../core/usage.js';
 import { isSessionId } from '../core/session.js';
-import { ActiveTurnInputMailbox, } from '../core/active-turn-input.js';
 import { ContextBudget, estimateModelRequestTokens, isPromptTooLongError, } from '../core/context-budget.js';
 import { ContextEngine } from './context-engine.js';
+import { ContextPreparation } from './context-preparation.js';
 import { TurnMemoryCoordinator } from './turn-memory-coordinator.js';
 import { injectFirstUserMessageContext, projectContextSnapshot, } from '../core/context.js';
 import { assembleContextSnapshot } from '../core/prompt-composer.js';
@@ -34,11 +33,13 @@ import { lastUserPrompt, projectTranscriptDisplay, unresolvedActiveToolCallIds,
 import { InMemoryTranscriptStore } from '../persistence/in-memory-transcript-store.js';
 import { NativeTranscriptStore, } from '../persistence/native-transcript-store.js';
 import { NativeSessionTranscript, } from './native-session-transcript.js';
+import { TurnPersistence } from './turn-persistence.js';
+import { TurnAccounting } from './turn-accounting.js';
 import { SubagentLifecycleStore } from '../persistence/subagent-lifecycle-store.js';
 import { ModelCompactor } from './model-compactor.js';
 import { agentMemoryPrompt, ClaudeSubagentExecutor, StructuredOutputRegistry, } from './subagent-service.js';
 import { ScheduledPromptManager, } from './scheduled-prompt-manager.js';
-import { TurnTerminalController } from './turn-lifecycle.js';
+import { TurnCoordinator } from './turn-lifecycle.js';
 import { ClaudeScheduledToolRegistry } from '../tools/claude-scheduled-tools.js';
 import { ClaudeTaskToolRegistry } from '../tools/claude-task-tools.js';
 import { ClaudeWorkflowToolRegistry } from '../tools/claude-workflow-tools.js';
@@ -249,18 +250,6 @@ function requireCompactionDurations(result) {
     }
     return { durationMs, durationWithoutRetriesMs };
 }
-function addToolDuration(value, total) {
-    if (value === undefined)
-        return total;
-    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
-        throw new TypeError('durationToolMs must be a finite nonnegative number');
-    }
-    const next = total + value;
-    if (!Number.isFinite(next) || next < 0) {
-        throw new TypeError('durationToolMs total overflow');
-    }
-    return next;
-}
 function addApiDuration(value, total, field) {
     if (value === undefined)
         return total;
@@ -273,36 +262,6 @@ function addApiDuration(value, total, field) {
     }
     return next;
 }
-function createLineCountAccumulator() {
-    let linesAdded = 0;
-    let linesRemoved = 0;
-    const addCounter = (current, value, field) => {
-        if (value === undefined)
-            return current;
-        if (!Number.isSafeInteger(value) || value < 0) {
-            throw new TypeError(`${field} must be a nonnegative safe integer`);
-        }
-        const next = current + value;
-        if (!Number.isSafeInteger(next) || next < 0) {
-            throw new TypeError(`${field} total must be a nonnegative safe integer`);
-        }
-        return next;
-    };
-    return {
-        get linesAdded() {
-            return linesAdded;
-        },
-        get linesRemoved() {
-            return linesRemoved;
-        },
-        add(input) {
-            if (input.isError)
-                return;
-            linesAdded = addCounter(linesAdded, input.linesAdded, 'linesAdded');
-            linesRemoved = addCounter(linesRemoved, input.linesRemoved, 'linesRemoved');
-        },
-    };
-}
 export function workflowTokenTarget(prompt) {
     const match = /(?:^|\s)\+(\d+(?:\.\d+)?)([km])\b/iu.exec(prompt);
     if (!match)
@@ -495,22 +454,6 @@ function validSessionName(value) {
         ? name.toLocaleLowerCase()
         : null;
 }
-function projectMemoryMessages(entries) {
-    return selectClaudeActiveTranscript(entries).flatMap((entry) => {
-        if (typeof entry.uuid !== 'string')
-            return [];
-        return projectClaudeModelMessages([entry]).flatMap((message) => (message.role === 'user' || message.role === 'assistant') &&
-            message.content.trim().length > 0
-            ? [
-                {
-                    id: entry.uuid,
-                    role: message.role,
-                    content: message.content,
-                },
-            ]
-            : []);
-    });
-}
 function successfulHookOutput(outcome) {
     return (outcome?.executions ?? []).flatMap((execution) => {
         const output = execution.stdout.trim();
@@ -684,12 +627,16 @@ export class ClaudeSessionService {
     hookLifecycle;
     leadOperations;
     fileChangeWatcher;
-    activeTurnInputs = new Map();
+    turnCoordinator;
     runtimeCwd;
     constructor(options) {
         const dataPlane = options.dataPlane ?? 'native';
         assertNativeDataPlane(dataPlane);
         this.options = { ...options, dataPlane };
+        this.turnCoordinator = new TurnCoordinator({
+            eventSink: options.eventSink ?? (() => undefined),
+            createSteeringId: randomUUID,
+        });
         this.assertNativeTranscriptOptions();
         this.leadOperations = options.teamLeadOperations ?? null;
         this.hookLifecycle = new HookLifecycle(options.hooks, options.eventSink);
@@ -899,18 +846,7 @@ export class ClaudeSessionService {
     }
     async close() {
         this.closing = true;
-        for (const { mailbox } of this.activeTurnInputs.values()) {
-            if (!mailbox)
-                continue;
-            for (const item of mailbox.close()) {
-                this.options.eventSink?.({
-                    type: 'user-input-rejected',
-                    id: item.id,
-                    content: item.content,
-                    reason: 'closed',
-                });
-            }
-        }
+        this.turnCoordinator.close();
         await this.fileChangeWatcher?.close(5_000);
         await this.hookLifecycle.close();
         await this.drainDetachedHookRuns(5_000);
@@ -1330,28 +1266,10 @@ export class ClaudeSessionService {
         });
     }
     steer(sessionId, content) {
-        const active = this.activeTurnInputs.get(sessionId);
-        if (!active)
-            return { kind: 'no-active-turn' };
-        const mailbox = active.mailbox;
-        if (!mailbox)
-            return { kind: 'not-steerable' };
-        const result = mailbox.enqueue(content);
-        if (result.kind === 'accepted')
-            return result;
-        if (result.kind === 'empty')
-            return result;
-        return { kind: 'turn-completing' };
+        return this.turnCoordinator.steer(sessionId, content);
     }
     withdrawSteering(sessionId, id) {
-        const active = this.activeTurnInputs.get(sessionId);
-        if (!active)
-            return { kind: 'no-active-turn' };
-        const mailbox = active.mailbox;
-        if (!mailbox)
-            return { kind: 'not-steerable' };
-        const result = mailbox.withdraw(id);
-        return result.kind === 'withdrawn' ? result : { kind: 'not-pending' };
+        return this.turnCoordinator.withdrawSteering(sessionId, id);
     }
     async resumeShell(sessionId, command, signal, name, resumeSessionAt) {
         this.worktreeManager?.bindSession(sessionId);
@@ -2535,29 +2453,8 @@ export class ClaudeSessionService {
         const documents = submission.kind === 'prompt' ? (submission.documents ?? []) : [];
         const shellCommand = submission.kind === 'shell' ? submission.command : undefined;
         const skipUserPrompt = submission.kind === 'retry';
-        const controller = new TurnTerminalController(this.options.eventSink ?? (() => undefined));
-        let activeTurnInput;
-        let activeTurnRecord;
-        try {
+        return this.turnCoordinator.run(request, async ({ emit, steering }) => {
             this.assertTurnWritable();
-            if (prompt.length === 0 && images.length === 0 && documents.length === 0)
-                throw new Error('Prompt must not be empty');
-            if (name !== undefined && name.length === 0) {
-                throw new Error('Session name must not be empty');
-            }
-            if (shellCommand !== undefined && shellCommand.trim().length === 0) {
-                throw new Error('Shell command must not be empty');
-            }
-            if (this.activeTurnInputs.has(sessionId)) {
-                throw new Error(`conflict: locked (session ${sessionId} already has an active turn)`);
-            }
-            activeTurnRecord =
-                shellCommand === undefined
-                    ? {
-                        mailbox: (activeTurnInput = new ActiveTurnInputMailbox(randomUUID)),
-                    }
-                    : {};
-            this.activeTurnInputs.set(sessionId, activeTurnRecord);
             await this.activateSessionCostTracker(sessionId);
             await this.ensureFileResources(sessionId, signal);
             this.worktreeManager?.bindSession(sessionId);
@@ -2575,39 +2472,47 @@ export class ClaudeSessionService {
             }
             const sessionPaths = this.paths(sessionId);
             const toolResultDirectory = join(sessionPaths.projectRoot, sessionId, 'tool-results');
-            const runUnderLease = async (lease, nativeLease) => {
-                const loadedSnapshot = await lease.load();
-                let snapshot = {
-                    entries: projectNativeSessionEntries(nativeLease.activeEvents()),
-                    tail: loadedSnapshot.tail,
+            const runUnderLease = async (persistence) => {
+                const activeTracker = this.sessionCostTrackers.get(sessionId);
+                if (!activeTracker) {
+                    throw new Error(`Session cost tracker is not active for session ${sessionId}`);
+                }
+                const turnAccounting = new TurnAccounting({
+                    tracker: activeTracker,
+                    ...(this.options.pricing ? { pricing: this.options.pricing } : {}),
+                });
+                const projectionSnapshot = () => {
+                    const view = persistence.view();
+                    return {
+                        entries: [...view.projectionEntries],
+                        tail: view.projectionTail,
+                    };
+                };
+                const commitProjection = async (entries) => {
+                    await persistence.commit({ kind: 'projection', entries });
                 };
                 const activeTurnMessages = () => {
                     // Native events remain authoritative; refresh the derived projection
                     // after each append so memory/compaction sees the live branch.
-                    snapshot = {
-                        ...snapshot,
-                        entries: projectNativeSessionEntries(nativeLease.activeEvents()),
-                    };
-                    return nativeLease.activeMessages();
+                    const view = persistence.refresh();
+                    return [...view.activeMessages];
                 };
-                if (nativeLease &&
-                    name !== undefined &&
-                    this.options.sessionPersistence !== false) {
+                if (name !== undefined && this.options.sessionPersistence !== false) {
                     const marker = `<praxis-session-name>${name}</praxis-session-name>`;
-                    if (!nativeLease
-                        .activeEvents()
-                        .some((event) => event.kind === 'messages' &&
+                    if (!persistence
+                        .view()
+                        .activeEvents.some((event) => event.kind === 'messages' &&
                         event.messages.some((message) => message.role === 'user' && message.content === marker))) {
-                        await nativeLease.appendMessages({
-                            messages: [{ role: 'user', content: marker }],
+                        await persistence.commit({
+                            kind: 'messages',
+                            input: { messages: [{ role: 'user', content: marker }] },
                         });
                     }
                 }
-                const nativeInterruption = nativeLease?.interruption();
+                const nativeInterruption = persistence.view().interruption;
                 if (nativeInterruption?.kind === 'indeterminate-tools')
                     throw new Error(`Native tool execution is indeterminate: ${nativeInterruption.callIds.join(', ')}`);
-                const nativeResumeInterrupted = nativeLease !== undefined &&
-                    this.options.resumeInterruptedTurn === true &&
+                const nativeResumeInterrupted = this.options.resumeInterruptedTurn === true &&
                     (nativeInterruption?.kind === 'interrupted-prompt' ||
                         nativeInterruption?.kind === 'interrupted-turn');
                 const shouldSkipUserPrompt = () => skipUserPrompt || nativeResumeInterrupted;
@@ -2618,48 +2523,35 @@ export class ClaudeSessionService {
                     shellCommand === undefined &&
                     !shouldSkipUserPrompt() &&
                     !(this.options.approveRecovery !== undefined &&
-                        findUnresolvedClaudeToolCalls(snapshot.entries).length > 0)) {
-                    const interruption = classifyClaudeInterruption(snapshot.entries);
+                        findUnresolvedClaudeToolCalls(projectionSnapshot().entries).length >
+                            0)) {
+                    const interruption = classifyClaudeInterruption(projectionSnapshot().entries);
                     if ((interruption.kind === 'interrupted-prompt' ||
                         interruption.kind === 'interrupted-turn') &&
                         interruption.prompt !== undefined &&
                         interruption.replayEntries !== undefined) {
                         automaticReplayPrompt = interruption.prompt;
-                        snapshot = {
-                            entries: interruption.replayEntries,
-                            tail: {
-                                ...snapshot.tail,
-                                branchParentId: interruption.replayParentUuid ?? null,
-                            },
-                        };
                     }
                 }
                 const initialTransition = this.worktreeManager?.consumeTransition('__initial__');
-                if (initialTransition && snapshot.entries.length === 0) {
+                if (initialTransition && projectionSnapshot().entries.length === 0) {
                     const stateEntry = {
                         type: 'worktree-state',
                         worktreeSession: initialTransition.state,
                         sessionId,
                     };
-                    const stateTail = await this.append(lease, snapshot.tail, stateEntry);
-                    snapshot = {
-                        entries: [...snapshot.entries, stateEntry],
-                        tail: stateTail,
-                    };
+                    await commitProjection([stateEntry]);
                 }
-                this.restoreWorktree(snapshot.entries);
-                this.options.interactiveTools?.restore(sessionId, snapshot.entries);
+                this.restoreWorktree(projectionSnapshot().entries);
+                this.options.interactiveTools?.restore(sessionId, projectionSnapshot().entries);
                 if (requireExisting &&
                     name !== undefined &&
-                    !this.hasSessionName(snapshot.entries, name)) {
+                    !this.hasSessionName(projectionSnapshot().entries, name)) {
                     const entries = this.sessionNameEntries(sessionId, name);
-                    const appendResult = await this.appendProjectionMany(snapshot.tail, entries);
-                    snapshot = {
-                        entries: [...snapshot.entries, ...entries],
-                        tail: appendResult.tail,
-                    };
+                    await commitProjection(entries);
                 }
-                const agentName = this.options.agent ?? getClaudeAgentSetting(snapshot.entries);
+                const agentName = this.options.agent ??
+                    getClaudeAgentSetting(projectionSnapshot().entries);
                 const agent = this.resolveAgent(agentName);
                 const provider = this.providerForAgent(agent);
                 this.activeProvider = provider;
@@ -2706,11 +2598,9 @@ export class ClaudeSessionService {
                         ...(this.options.fileRewindRoots ?? []),
                     ])
                     : null;
-                const unresolvedToolCalls = nativeLease
-                    ? nativeInterruption?.kind === 'recoverable-tools'
-                        ? [...nativeInterruption.calls]
-                        : []
-                    : findUnresolvedClaudeToolCalls(snapshot.entries);
+                const unresolvedToolCalls = nativeInterruption?.kind === 'recoverable-tools'
+                    ? [...nativeInterruption.calls]
+                    : [];
                 const pendingRecoveryToolCallIds = new Set(unresolvedToolCalls.map((call) => call.id));
                 const pendingRecoveryHookOutcomes = [];
                 let refreshRuntimeContext;
@@ -2724,26 +2614,25 @@ export class ClaudeSessionService {
                     permission_mode: 'default',
                 };
                 const appendHookOutcome = async (outcome) => {
-                    for (const entry of createClaudeHookAttachmentEntries(outcome, this.translationContext(sessionId, snapshot))) {
-                        const tail = await this.append(lease, snapshot.tail, entry);
-                        snapshot = { entries: [...snapshot.entries, entry], tail };
-                        if (nativeLease) {
-                            const attachment = entry.attachment;
-                            const raw = attachment?.content;
-                            const content = typeof raw === 'string'
-                                ? raw
-                                : Array.isArray(raw)
-                                    ? raw
-                                        .filter((value) => typeof value === 'string')
-                                        .join('\n')
-                                    : raw && typeof raw === 'object' && 'content' in raw
-                                        ? String(raw.content)
-                                        : '';
-                            if (content) {
-                                await nativeLease.appendMessages({
-                                    messages: [{ role: 'user', content }],
-                                });
-                            }
+                    for (const entry of createClaudeHookAttachmentEntries(outcome, this.translationContext(sessionId, projectionSnapshot()))) {
+                        const attachment = entry.attachment;
+                        const raw = attachment?.content;
+                        const content = typeof raw === 'string'
+                            ? raw
+                            : Array.isArray(raw)
+                                ? raw.filter((value) => typeof value === 'string').join('\n')
+                                : raw && typeof raw === 'object' && 'content' in raw
+                                    ? String(raw.content)
+                                    : '';
+                        if (content) {
+                            await persistence.commit({
+                                kind: 'messages',
+                                input: { messages: [{ role: 'user', content }] },
+                                projectionEntries: [entry],
+                            });
+                        }
+                        else {
+                            await commitProjection([entry]);
                         }
                     }
                 };
@@ -2756,11 +2645,11 @@ export class ClaudeSessionService {
                 };
                 const flushRecoveryHookOutcomes = async () => {
                     const entries = [];
-                    let history = snapshot.entries;
-                    let parentUuid = this.logicalTailUuid(snapshot.tail);
+                    let history = projectionSnapshot().entries;
+                    let parentUuid = this.logicalTailUuid(projectionSnapshot().tail);
                     for (const outcome of pendingRecoveryHookOutcomes) {
                         const outcomeEntries = createClaudeHookAttachmentEntries(outcome, {
-                            ...this.translationContext(sessionId, snapshot),
+                            ...this.translationContext(sessionId, projectionSnapshot()),
                             parentUuid,
                             history,
                         });
@@ -2774,8 +2663,7 @@ export class ClaudeSessionService {
                         pendingRecoveryHookOutcomes.length = 0;
                         return;
                     }
-                    const appendResult = await this.appendProjectionMany(snapshot.tail, entries);
-                    snapshot = { entries: history, tail: appendResult.tail };
+                    await commitProjection(entries);
                     pendingRecoveryHookOutcomes.length = 0;
                 };
                 const capabilities = this.toolCapabilities();
@@ -2916,7 +2804,7 @@ export class ClaudeSessionService {
                                 backgroundTaskNotifications: (waitForRunning) => taskTools.notifications(waitForRunning),
                             }
                             : {}),
-                        notificationDelivered: (notification) => transcriptContainsBackgroundAgentNotification(snapshot.entries, notification),
+                        notificationDelivered: (notification) => transcriptContainsBackgroundAgentNotification(projectionSnapshot().entries, notification),
                         stopOwnedBackgroundAgent: (ownerSessionId, agentId) => this.backgroundTasks.stopAgent(ownerSessionId, agentId),
                         outputOwnedBackgroundAgent: (ownerSessionId, agentId, options) => this.backgroundTasks.outputAgent(ownerSessionId, agentId, options),
                         sendOwnedBackgroundAgent: (ownerSessionId, agentId, message, summary, toolUseId) => this.sendOwnedBackgroundAgent(ownerSessionId, agentId, message, summary, toolUseId),
@@ -2929,7 +2817,7 @@ export class ClaudeSessionService {
                 }
                 const agentTools = subagentExecutor
                     ? subagentExecutor.registry(sessionId, 0, (callId) => currentPromptId ??
-                        this.promptIdForToolCall(snapshot.entries, callId))
+                        this.promptIdForToolCall(projectionSnapshot().entries, callId))
                     : baseTools;
                 const turnTools = this.workflowManager && subagentExecutor && agentTools
                     ? new ClaudeWorkflowToolRegistry({
@@ -2941,7 +2829,7 @@ export class ClaudeSessionService {
                         configRoot: this.options.configRoot,
                         sessionId,
                         promptIdForCall: (callId) => currentPromptId ??
-                            this.promptIdForToolCall(snapshot.entries, callId),
+                            this.promptIdForToolCall(projectionSnapshot().entries, callId),
                         defaultModel: provider.model ?? 'praxis/provider',
                         tokenBudget: workflowTokenTarget(effectivePrompt),
                         enabled: capabilities.has('Workflow'),
@@ -2994,13 +2882,13 @@ export class ClaudeSessionService {
                                 return interactiveMessageTools.execute(call, context);
                             }
                             const snapshotMessageId = currentPromptId ??
-                                this.promptIdForToolCall(snapshot.entries, call.id);
+                                this.promptIdForToolCall(projectionSnapshot().entries, call.id);
                             const assistantMessageId = lastAssistantUuid ??
-                                this.assistantIdForToolCall(snapshot.entries, call.id);
+                                this.assistantIdForToolCall(projectionSnapshot().entries, call.id);
                             if (!snapshotMessageId || !assistantMessageId) {
                                 throw new Error('Claude file history could not link tool call');
                             }
-                            const prepared = await fileHistory.prepareMutation(snapshot.entries, snapshotMessageId, path);
+                            const prepared = await fileHistory.prepareMutation(projectionSnapshot().entries, snapshotMessageId, path);
                             let result;
                             try {
                                 result = await interactiveMessageTools.execute(call, context);
@@ -3015,18 +2903,18 @@ export class ClaudeSessionService {
                             }
                             const entry = prepared.commit(assistantMessageId);
                             if (entry) {
-                                const tail = await this.append(lease, snapshot.tail, entry);
-                                snapshot = { entries: [...snapshot.entries, entry], tail };
-                                if (nativeLease) {
-                                    await nativeLease.appendMessages({
+                                await persistence.commit({
+                                    kind: 'messages',
+                                    input: {
                                         messages: [
                                             {
                                                 role: 'user',
                                                 content: `<praxis-file-history>${JSON.stringify(entry)}</praxis-file-history>`,
                                             },
                                         ],
-                                    });
-                                }
+                                    },
+                                    projectionEntries: [entry],
+                                });
                             }
                             return result;
                         },
@@ -3071,7 +2959,7 @@ export class ClaudeSessionService {
                         deferPreToolUseOutcome: (call) => pendingRecoveryToolCallIds.has(call.id),
                     })
                     : null;
-                const runtime = new AgentRuntime(provider, controller.emit, {
+                const runtime = new AgentRuntime(provider, emit, {
                     emitInitialContextState: false,
                     ...(this.options.emitToolUseSummaries
                         ? {
@@ -3104,14 +2992,13 @@ export class ClaudeSessionService {
                 const durableFollowUps = new DurableFollowUpTracker();
                 const claimedToolCallIds = new Set();
                 const observer = {
-                    ...(nativeLease
-                        ? {
-                            toolExecutionStarted: async (call) => {
-                                await nativeLease.beginToolExecution(call.id);
-                                claimedToolCallIds.add(call.id);
-                            },
-                        }
-                        : {}),
+                    toolExecutionStarted: async (call) => {
+                        await persistence.commit({
+                            kind: 'tool-execution-started',
+                            callId: call.id,
+                        });
+                        claimedToolCallIds.add(call.id);
+                    },
                     modelRequestCompleted: async (input) => {
                         observeModelRequestUsage(input);
                     },
@@ -3127,13 +3014,12 @@ export class ClaudeSessionService {
                                 providerMessageId: `msg_${randomUUID().replaceAll('-', '')}`,
                                 model: provider.model ?? 'praxis/provider',
                             },
-                        ], this.translationContext(sessionId, snapshot));
+                        ], this.translationContext(sessionId, projectionSnapshot()));
                         if (!entry)
                             throw new Error('Could not translate assistant response');
-                        const tail = await this.append(lease, snapshot.tail, entry);
-                        snapshot = { entries: [...snapshot.entries, entry], tail };
-                        lastAssistantUuid = nativeLease
-                            ? await nativeLease.appendMessages({
+                        const nativeReceipt = await persistence.commit({
+                            kind: 'messages',
+                            input: {
                                 messages: [
                                     {
                                         role: 'assistant',
@@ -3147,29 +3033,26 @@ export class ClaudeSessionService {
                                     },
                                 ],
                                 model: provider.model ?? 'praxis/provider',
-                            })
-                            : typeof entry.uuid === 'string'
-                                ? entry.uuid
-                                : lastAssistantUuid;
+                            },
+                            projectionEntries: [entry],
+                        });
+                        if (nativeReceipt.kind !== 'messages')
+                            throw new Error('Turn persistence returned an invalid message receipt');
+                        lastAssistantUuid = nativeReceipt.eventId;
                     },
                     toolCompleted: async (call, toolResult) => {
-                        currentTurnToolCalls += 1;
                         const transition = this.worktreeManager?.consumeTransition(call.id);
                         if (transition) {
-                            this.options.contextAssembler?.invalidate?.({
-                                lifecycleId: sessionId,
-                                reason: 'worktree',
-                            });
                             const stateEntry = {
                                 type: 'worktree-state',
                                 worktreeSession: transition.state,
                                 sessionId,
                             };
-                            const stateTail = await this.append(lease, snapshot.tail, stateEntry);
-                            snapshot = {
-                                entries: [...snapshot.entries, stateEntry],
-                                tail: stateTail,
-                            };
+                            await commitProjection([stateEntry]);
+                            this.options.contextAssembler?.invalidate?.({
+                                lifecycleId: sessionId,
+                                reason: 'worktree',
+                            });
                         }
                         const permissionMode = this.options.interactiveTools?.consumeTransition(call.id);
                         if (permissionMode) {
@@ -3178,21 +3061,18 @@ export class ClaudeSessionService {
                                 permissionMode,
                                 sessionId,
                             };
-                            const modeTail = await this.append(lease, snapshot.tail, modeEntry);
-                            snapshot = {
-                                entries: [...snapshot.entries, modeEntry],
-                                tail: modeTail,
-                            };
-                            if (nativeLease) {
-                                await nativeLease.appendMessages({
+                            await persistence.commit({
+                                kind: 'messages',
+                                input: {
                                     messages: [
                                         {
                                             role: 'user',
                                             content: `/permission-mode ${permissionMode}`,
                                         },
                                     ],
-                                });
-                            }
+                                },
+                                projectionEntries: [modeEntry],
+                            });
                             // Interactive mode transitions change the runtime system
                             // context for the very next provider request. Refresh here so
                             // an EnterPlanMode/ExitPlanMode tool call is immediately
@@ -3200,43 +3080,21 @@ export class ClaudeSessionService {
                             if (typeof refreshRuntimeContext === 'function')
                                 await refreshRuntimeContext();
                         }
-                        if (nativeLease) {
-                            if (!claimedToolCallIds.has(call.id) && !signal?.aborted) {
-                                await nativeLease.beginToolExecution(call.id);
-                                claimedToolCallIds.add(call.id);
-                            }
-                            await nativeLease.appendToolCompletion({
+                        if (!claimedToolCallIds.has(call.id) && !signal?.aborted) {
+                            await persistence.commit({
+                                kind: 'tool-execution-started',
                                 callId: call.id,
-                                result: toolResult,
                             });
+                            claimedToolCallIds.add(call.id);
                         }
-                        else {
-                            const [entry] = translateProviderEvents([
-                                {
-                                    type: 'tool-result',
-                                    toolCallId: call.id,
-                                    content: toolResult.content,
-                                    ...(toolResult.contentBlocks
-                                        ? { contentBlocks: toolResult.contentBlocks }
-                                        : {}),
-                                    ...(toolResult.images ? { images: toolResult.images } : {}),
-                                    ...(toolResult.documents
-                                        ? { documents: toolResult.documents }
-                                        : {}),
-                                    isError: toolResult.isError,
-                                    ...(toolResult.nativeToolUseResult
-                                        ? { nativeToolUseResult: toolResult.nativeToolUseResult }
-                                        : {}),
-                                    ...(toolResult.nativeMcpMeta
-                                        ? { nativeMcpMeta: toolResult.nativeMcpMeta }
-                                        : {}),
-                                },
-                            ], this.translationContext(sessionId, snapshot));
-                            if (!entry)
-                                throw new Error('Could not translate tool result');
-                            const tail = await this.append(lease, snapshot.tail, entry);
-                            snapshot = { entries: [...snapshot.entries, entry], tail };
-                        }
+                        await persistence.commit({
+                            kind: 'tool-completion',
+                            input: {
+                                callId: call.id,
+                                result: toolResult,
+                            },
+                        });
+                        currentTurnToolCalls += 1;
                         if (!toolResult.isError && this.options.projectMemoryDirectory) {
                             const pathValue = call.input.file_path;
                             const path = typeof pathValue === 'string'
@@ -3266,23 +3124,23 @@ export class ClaudeSessionService {
                             !toolResult.accessedPaths) {
                             return;
                         }
-                        const attachedRulePaths = this.attachedRulePaths(snapshot.entries);
+                        const attachedRulePaths = this.attachedRulePaths(projectionSnapshot().entries);
                         for (const filePath of toolResult.accessedPaths) {
                             const rules = await this.options.conditionalRuleResolver.resolve(filePath, [...attachedRulePaths]);
                             for (const rule of rules) {
-                                const attachment = createClaudeRuleAttachmentEntry(rule, this.displayRulePath(rule.path), this.translationContext(sessionId, snapshot));
-                                const attachmentTail = await this.append(lease, snapshot.tail, attachment);
-                                snapshot = {
-                                    entries: [...snapshot.entries, attachment],
-                                    tail: attachmentTail,
-                                };
-                                if (nativeLease) {
-                                    const ruleContent = rule.content.trim();
-                                    if (ruleContent.length > 0) {
-                                        await nativeLease.appendMessages({
+                                const attachment = createClaudeRuleAttachmentEntry(rule, this.displayRulePath(rule.path), this.translationContext(sessionId, projectionSnapshot()));
+                                const ruleContent = rule.content.trim();
+                                if (ruleContent.length > 0) {
+                                    await persistence.commit({
+                                        kind: 'messages',
+                                        input: {
                                             messages: [{ role: 'user', content: ruleContent }],
-                                        });
-                                    }
+                                        },
+                                        projectionEntries: [attachment],
+                                    });
+                                }
+                                else {
+                                    await commitProjection([attachment]);
                                 }
                                 attachedRulePaths.add(rule.path);
                                 await this.instructionLoaded(sessionId, {
@@ -3303,44 +3161,20 @@ export class ClaudeSessionService {
                     },
                     followUpUserMessagesCompleted: async (messages) => {
                         for (const content of messages) {
-                            if (nativeLease) {
-                                await nativeLease.appendMessages({
-                                    messages: [{ role: 'user', content }],
-                                });
-                                currentTurnUserMessages?.push(content);
-                                await Promise.all(this.sessionSubagentExecutors(sessionId, true).map((executor) => executor.acknowledgeNotifications([content])));
-                                continue;
-                            }
-                            const [followUpEntry] = translateProviderEvents([{ type: 'user-text-block', text: content }], this.translationContext(sessionId, snapshot));
-                            if (!followUpEntry) {
-                                throw new Error('Could not translate tool follow-up message');
-                            }
-                            const followUpTail = await this.append(lease, snapshot.tail, followUpEntry);
-                            snapshot = {
-                                entries: [...snapshot.entries, followUpEntry],
-                                tail: followUpTail,
-                            };
+                            await persistence.commit({
+                                kind: 'messages',
+                                input: { messages: [{ role: 'user', content }] },
+                            });
                             currentTurnUserMessages?.push(content);
                             await Promise.all(this.sessionSubagentExecutors(sessionId, true).map((executor) => executor.acknowledgeNotifications([content])));
                         }
                         await durableFollowUps.followUpUserMessagesCompleted(messages);
                     },
                     userInputDelivered: async (item) => {
-                        if (nativeLease) {
-                            await nativeLease.appendMessages({
-                                messages: [{ role: 'user', content: item.content }],
-                            });
-                            currentTurnUserMessages?.push(item.content);
-                            return;
-                        }
-                        const [steeringEntry] = translateProviderEvents([{ type: 'user-text-block', text: item.content }], this.translationContext(sessionId, snapshot));
-                        if (!steeringEntry)
-                            throw new Error('Could not translate steering message');
-                        const steeringTail = await this.append(lease, snapshot.tail, steeringEntry);
-                        snapshot = {
-                            entries: [...snapshot.entries, steeringEntry],
-                            tail: steeringTail,
-                        };
+                        await persistence.commit({
+                            kind: 'messages',
+                            input: { messages: [{ role: 'user', content: item.content }] },
+                        });
                         currentTurnUserMessages?.push(item.content);
                     },
                 };
@@ -3384,48 +3218,51 @@ export class ClaudeSessionService {
                         throw new Error(`Claude session tool call ${unresolvedToolCall.id} requires explicit recovery approval`);
                     }
                     const recoveryResults = await runtime.recoverToolCalls(unresolvedToolCalls, recoveryRequest);
-                    const recoveryUsage = recoveryResults.reduce((usage, result) => result.usage ? mergeUsage(usage, result.usage) : usage, { inputTokens: 0, outputTokens: 0 });
-                    const recoveryModelUsage = mergeSessionRawModelUsage(...recoveryResults.map((result) => result.isError ? undefined : result.modelUsage));
-                    const foregroundLineChanges = createLineCountAccumulator();
-                    for (const result of recoveryResults) {
-                        foregroundLineChanges.add(result);
-                    }
                     if (this.options.agent &&
                         agent &&
-                        getClaudeAgentSetting(snapshot.entries) !== this.options.agent) {
+                        getClaudeAgentSetting(projectionSnapshot().entries) !==
+                            this.options.agent) {
                         const agentSetting = createClaudeAgentSettingEntry(sessionId, this.options.agent);
-                        const settingTail = await this.append(lease, snapshot.tail, agentSetting);
-                        snapshot = {
-                            entries: [...snapshot.entries, agentSetting],
-                            tail: settingTail,
-                        };
-                        if (nativeLease) {
-                            await nativeLease.appendMessages({
+                        await persistence.commit({
+                            kind: 'messages',
+                            input: {
                                 messages: [
                                     {
                                         role: 'user',
                                         content: `<praxis-agent-setting>${this.options.agent}</praxis-agent-setting>`,
                                     },
                                 ],
-                            });
-                        }
+                            },
+                            projectionEntries: [agentSetting],
+                        });
                     }
                     let agentSystem = null;
                     let planModeMessage;
                     let sessionMemoryMessage = null;
-                    let contextMessages = [];
-                    let contextProjection = {
-                        systemMessages: [],
-                        stableSystemSectionCount: 0,
-                    };
-                    let stableSystemMessageCount = 0;
+                    let agentMentionMessages = [];
+                    const contextPreparation = new ContextPreparation({
+                        ...(this.options.contextAssembler
+                            ? { assembler: this.options.contextAssembler }
+                            : {}),
+                        sources: {
+                            history: activeTurnMessages,
+                            memory: () => projectMemoryRecallMessages,
+                            activeTools: () => provider.capabilities.tools
+                                ? (activeTurnTools?.definitions() ?? [])
+                                : [],
+                        },
+                        agentMentions: () => ({
+                            prompt: effectivePrompt,
+                            messages: agentMentionMessages,
+                        }),
+                    });
                     refreshRuntimeContext = async () => {
                         agentSystem = await this.mainAgentSystemPrompt(agent);
                         planModeMessage =
                             this.options.interactiveTools?.contextMessage(sessionId);
                         // DEBUG_PLAN_CONTEXT
                         sessionMemoryMessage = this.sessionMemoryMessage(await turnMemory.sessionSummary());
-                        const assembledContext = await assembleContextSnapshot(this.options.contextAssembler, {
+                        await contextPreparation.refresh({
                             cwd: this.activeCwd(),
                             lifecycleId: sessionId,
                             ...(agentSystem
@@ -3442,10 +3279,6 @@ export class ClaudeSessionService {
                                     : {}),
                             },
                         });
-                        contextProjection = projectContextSnapshot(assembledContext);
-                        stableSystemMessageCount =
-                            contextProjection.stableSystemSectionCount;
-                        contextMessages = [...contextProjection.systemMessages];
                     };
                     await refreshRuntimeContext();
                     const expansion = shouldSkipUserPrompt()
@@ -3468,16 +3301,6 @@ export class ClaudeSessionService {
                         type: 'state',
                         state: 'assembling-context',
                     });
-                    let compactionUsage = {
-                        inputTokens: 0,
-                        outputTokens: 0,
-                    };
-                    let compactionDurationMs;
-                    let compactionDurationWithoutRetriesMs;
-                    let compactionModelUsage;
-                    const currentDefinitions = () => provider.capabilities.tools
-                        ? (activeTurnTools?.definitions() ?? [])
-                        : [];
                     const budget = this.contextBudget(provider);
                     const contextEngine = new ContextEngine({
                         ...(budget ? { budget } : {}),
@@ -3509,88 +3332,49 @@ export class ClaudeSessionService {
                             ? { documents }
                             : {}),
                     }));
-                    const agentMentionMessages = shellCommand === undefined && !shouldSkipUserPrompt()
-                        ? (this.options.extensions?.agentMentionMessages(effectivePrompt) ?? [])
-                        : [];
-                    const injectAgentMentionContext = (messages) => {
-                        if (agentMentionMessages.length === 0)
-                            return [...messages];
-                        let insertionIndex = messages.length;
-                        let foundPrompt = false;
-                        for (let index = messages.length - 1; index >= 0; index -= 1) {
-                            const message = messages[index];
-                            if (message?.role === 'user' &&
-                                typeof message.content === 'string' &&
-                                message.content.endsWith(effectivePrompt)) {
-                                insertionIndex = index;
-                                foundPrompt = true;
-                                break;
-                            }
-                        }
-                        if (!foundPrompt)
-                            return [...messages];
-                        return [
-                            ...messages.slice(0, insertionIndex),
-                            ...agentMentionMessages.map((content) => ({
-                                role: 'user',
-                                content,
-                            })),
-                            ...messages.slice(insertionIndex),
-                        ];
-                    };
-                    const injectDynamicContext = (messages) => injectFirstUserMessageContext(messages, contextProjection.firstUserMessageContext);
-                    const injectTurnContext = (messages) => injectAgentMentionContext(injectDynamicContext(messages));
-                    let compactionAnchorUuid = this.lastMessageUuid(snapshot.entries);
+                    agentMentionMessages =
+                        shellCommand === undefined && !shouldSkipUserPrompt()
+                            ? (this.options.extensions?.agentMentionMessages(effectivePrompt) ?? [])
+                            : [];
+                    let compactionAnchorUuid = this.lastMessageUuid(projectionSnapshot().entries);
                     const contextTransitionPort = (pendingMessages = [], preservedUserMessages = []) => ({
                         current: () => {
-                            const historyMessages = [
-                                ...activeTurnMessages(),
-                                ...projectMemoryRecallMessages,
-                            ];
-                            return {
-                                messages: [
-                                    ...contextMessages,
-                                    ...injectTurnContext([
-                                        ...historyMessages,
-                                        ...pendingMessages,
-                                    ]),
-                                ],
-                                tools: currentDefinitions(),
-                            };
+                            const projection = contextPreparation.project({
+                                pendingMessages,
+                            });
+                            return projection.envelope;
                         },
-                        irreducible: () => ({
-                            messages: [
-                                ...contextMessages,
-                                ...injectTurnContext([
-                                    ...pendingMessages,
-                                    ...preservedUserMessages.map((content) => ({
-                                        role: 'user',
-                                        content,
-                                    })),
-                                ]),
+                        irreducible: () => contextPreparation.project({
+                            includeHistory: false,
+                            includeMemory: false,
+                            pendingMessages: [
+                                ...pendingMessages,
+                                ...preservedUserMessages.map((content) => ({
+                                    role: 'user',
+                                    content,
+                                })),
                             ],
-                            tools: currentDefinitions(),
-                        }),
+                        }).envelope,
                         propose: async () => {
-                            const activeNativeLease = nativeLease;
                             if (!budget)
                                 throw new Error('Context budget is unavailable');
-                            const definitions = currentDefinitions();
+                            const definitions = contextPreparation.project().envelope.tools;
                             const historyMessages = activeTurnMessages();
                             if (historyMessages.length === 0)
                                 throw new Error('Cannot compact an empty native transcript');
                             if (unresolvedActiveToolCallIds(historyMessages).length > 0)
                                 throw new Error('Cannot compact a native transcript with unresolved tool calls');
-                            const irreducibleMessages = [
-                                ...contextMessages,
-                                ...injectTurnContext([
+                            const irreducibleMessages = contextPreparation.project({
+                                includeHistory: false,
+                                includeMemory: false,
+                                pendingMessages: [
                                     ...pendingMessages,
                                     ...preservedUserMessages.map((content) => ({
                                         role: 'user',
                                         content,
                                     })),
-                                ]),
-                            ];
+                                ],
+                            }).envelope.messages;
                             let compactableMessages = historyMessages;
                             let preservedMessages = [];
                             let compactionLogicalParentId;
@@ -3627,15 +3411,15 @@ export class ClaudeSessionService {
                                         !promptContents.has(message.content)),
                                 ];
                                 if (earliest === 0 && preservedUserMessages[0] !== undefined) {
-                                    compactionLogicalParentId = activeNativeLease
-                                        .activeEvents()
-                                        .find((event) => event.kind === 'messages' &&
+                                    compactionLogicalParentId = persistence
+                                        .view()
+                                        .activeEvents.find((event) => event.kind === 'messages' &&
                                         event.messages.some((message) => message.role === 'user' &&
                                             message.content === preservedUserMessages[0]))?.id;
                                 }
                             }
                             const memorySelection = sessionMemory
-                                ? await this.selectMemoryPreservedCompact(sessionId, projectNativeSessionEntries(activeNativeLease.activeEvents()))
+                                ? await this.selectMemoryPreservedCompact(sessionId, persistence.view().projectionEntries)
                                 : null;
                             if (memorySelection) {
                                 compactableMessages = [
@@ -3656,9 +3440,9 @@ export class ClaudeSessionService {
                                 preservedMessages = historyMessages.filter((message) => message.role === 'user');
                                 const anchor = preservedMessages[0];
                                 if (anchor !== undefined) {
-                                    compactionLogicalParentId = nativeLease
-                                        .activeEvents()
-                                        .find((event) => event.kind === 'messages' &&
+                                    compactionLogicalParentId = persistence
+                                        .view()
+                                        .activeEvents.find((event) => event.kind === 'messages' &&
                                         event.messages.some((message) => message.role === 'user' &&
                                             message.content === anchor.content))?.id;
                                 }
@@ -3692,15 +3476,6 @@ export class ClaudeSessionService {
                             const { durationMs, durationWithoutRetriesMs } = requireCompactionDurations(compacted);
                             if (signal?.aborted)
                                 throw new AgentRunCancelledError();
-                            const proposedCompactionDurationMs = (compactionDurationMs ?? 0) + durationMs;
-                            if (!Number.isFinite(proposedCompactionDurationMs)) {
-                                throw new TypeError('compaction durationMs total overflow');
-                            }
-                            const proposedCompactionDurationWithoutRetriesMs = (compactionDurationWithoutRetriesMs ?? 0) +
-                                durationWithoutRetriesMs;
-                            if (!Number.isFinite(proposedCompactionDurationWithoutRetriesMs)) {
-                                throw new TypeError('compaction durationWithoutRetriesMs total overflow');
-                            }
                             const postTokens = estimateModelRequestTokens([
                                 { role: 'user', content: compacted.summary },
                                 ...preservedMessages,
@@ -3708,63 +3483,27 @@ export class ClaudeSessionService {
                             const compactModel = compacted.model !== undefined && compacted.model.trim() !== ''
                                 ? compacted.model
                                 : provider.model;
-                            const meaningfulUsage = hasNonZeroUsage(compacted.usage);
-                            if (meaningfulUsage &&
-                                (compactModel === undefined || compactModel.trim() === ''))
-                                throw new Error('Auto compact usage requires a nonblank model identity');
-                            const tracker = this.sessionCostTrackers.get(sessionId);
-                            if (!tracker)
-                                throw new Error(`Session cost tracker is not active for session ${sessionId}`);
-                            let meteringTurnInput;
-                            if (meaningfulUsage &&
-                                compactModel !== undefined &&
-                                compactModel.trim() !== '') {
-                                const pricing = this.options.pricing?.resolve(compactModel);
-                                const costUsd = pricing
-                                    ? usageCostUsd(compacted.usage, pricing)
-                                    : undefined;
-                                meteringTurnInput = {
-                                    model: compactModel,
-                                    usage: compacted.usage,
-                                    ...(costUsd === undefined ? {} : { costUsd }),
-                                    ...(compacted.usage.webSearchRequests === undefined
-                                        ? {}
-                                        : {
-                                            webSearchRequests: compacted.usage.webSearchRequests,
-                                        }),
-                                };
-                            }
-                            let meteringDurationsInput;
-                            if (durationMs > 0 || durationWithoutRetriesMs > 0)
-                                meteringDurationsInput = {
-                                    ...(durationMs === 0 ? {} : { apiDurationMs: durationMs }),
-                                    apiDurationWithoutRetriesMs: durationWithoutRetriesMs,
-                                };
-                            if (meteringTurnInput !== undefined ||
-                                meteringDurationsInput !== undefined) {
-                                const preflight = new ClaudeSessionCostTracker({
-                                    sessionId,
-                                    restored: tracker.snapshot(),
-                                });
-                                if (meteringTurnInput !== undefined)
-                                    preflight.recordTurn(meteringTurnInput);
-                                if (meteringDurationsInput !== undefined)
-                                    preflight.recordDurations(meteringDurationsInput);
-                            }
+                            const preparedCompaction = turnAccounting.prepareCompaction({
+                                usage: compacted.usage,
+                                ...(compactModel === undefined ? {} : { model: compactModel }),
+                                durationApiMs: durationMs,
+                                durationApiWithoutRetriesMs: durationWithoutRetriesMs,
+                            });
                             const summaryMessage = {
                                 role: 'user',
                                 content: compacted.summary,
                             };
                             let replayMessages = preservedMessages;
                             try {
-                                const replayReport = budget.evaluate([
-                                    ...contextMessages,
-                                    ...injectTurnContext([
+                                const replayReport = budget.evaluate(contextPreparation.project({
+                                    includeHistory: false,
+                                    includeMemory: false,
+                                    pendingMessages: [
                                         summaryMessage,
                                         ...replayMessages,
                                         ...pendingMessages,
-                                    ]),
-                                ], definitions);
+                                    ],
+                                }).envelope.messages, definitions);
                                 if (replayReport.shouldCompact)
                                     throw new Error('replay overflow');
                             }
@@ -3775,40 +3514,39 @@ export class ClaudeSessionService {
                                 // contains its contents and user prompts remain available.
                                 replayMessages = replayMessages.filter((message) => message.role === 'user' && !Array.isArray(message.content));
                             }
-                            const proposedMessages = [
-                                ...contextMessages,
-                                ...injectTurnContext([
-                                    summaryMessage,
-                                    ...replayMessages,
-                                    ...pendingMessages,
-                                ]),
-                            ];
+                            const replacement = contextPreparation.proposeHistoryReplacement({
+                                historyMessages: [summaryMessage, ...replayMessages],
+                                pendingMessages,
+                            });
                             return {
-                                envelope: {
-                                    messages: proposedMessages,
-                                    tools: definitions,
-                                },
+                                envelope: replacement.envelope,
                                 commit: async () => {
                                     if (signal?.aborted)
                                         throw new AgentRunCancelledError();
-                                    const ids = await nativeLease.appendCompaction({
-                                        summary: compacted.summary,
-                                        trigger: 'auto',
-                                        preTokens,
-                                        postTokens,
-                                        durationMs,
-                                        preservedMessages: replayMessages,
-                                        ...(compactionLogicalParentId === undefined
-                                            ? {}
-                                            : { logicalParentId: compactionLogicalParentId }),
-                                        ...(memorySelection
-                                            ? {
-                                                direction: 'from',
-                                                messagesSummarized: compactableMessages.length,
-                                                preservePrefix: false,
-                                            }
-                                            : {}),
-                                    });
+                                    const committed = await replacement.commit(() => persistence.commit({
+                                        kind: 'compaction',
+                                        input: {
+                                            summary: compacted.summary,
+                                            trigger: 'auto',
+                                            preTokens,
+                                            postTokens,
+                                            durationMs,
+                                            preservedMessages: replayMessages,
+                                            ...(compactionLogicalParentId === undefined
+                                                ? {}
+                                                : { logicalParentId: compactionLogicalParentId }),
+                                            ...(memorySelection
+                                                ? {
+                                                    direction: 'from',
+                                                    messagesSummarized: compactableMessages.length,
+                                                    preservePrefix: false,
+                                                }
+                                                : {}),
+                                        },
+                                    }));
+                                    const ids = committed.value;
+                                    if (ids.kind !== 'compaction')
+                                        throw new Error('Turn persistence returned an invalid compaction receipt');
                                     await this.runAdvisoryHook(sessionId, 'PostCompact', { trigger: 'auto', compact_summary: compacted.summary }, 'auto', signal);
                                     if (this.options.hooks) {
                                         const outcome = await this.hookLifecycle.refresh(sessionId, hookSession, signal);
@@ -3826,21 +3564,7 @@ export class ClaudeSessionService {
                                         preTokens,
                                         uuid: ids.boundaryId,
                                     });
-                                    compactionUsage = mergeUsage(compactionUsage, compacted.usage);
-                                    compactionDurationMs =
-                                        (compactionDurationMs ?? 0) + durationMs;
-                                    compactionDurationWithoutRetriesMs =
-                                        (compactionDurationWithoutRetriesMs ?? 0) +
-                                            durationWithoutRetriesMs;
-                                    if (meteringTurnInput !== undefined) {
-                                        tracker.recordTurn(meteringTurnInput);
-                                    }
-                                    if (compactModel !== undefined &&
-                                        compactModel.trim() !== '') {
-                                        compactionModelUsage = mergeSessionRawModelUsage(compactionModelUsage, { [compactModel]: compacted.usage });
-                                    }
-                                    if (meteringDurationsInput !== undefined)
-                                        tracker.recordDurations(meteringDurationsInput);
+                                    preparedCompaction.commit();
                                 },
                             };
                         },
@@ -3868,7 +3592,7 @@ export class ClaudeSessionService {
                             : index === 0
                                 ? { type: 'user-text', text: message.text }
                                 : { type: 'user-text-block', text: message.text };
-                        const [userEntry] = translateProviderEvents([persistenceEvent], this.translationContext(sessionId, snapshot));
+                        const [userEntry] = translateProviderEvents([persistenceEvent], this.translationContext(sessionId, projectionSnapshot()));
                         if (!userEntry)
                             throw new Error('Could not translate user prompt');
                         if (currentPromptId === null &&
@@ -3876,13 +3600,9 @@ export class ClaudeSessionService {
                             currentPromptId = userEntry.uuid;
                             compactionAnchorUuid ??= userEntry.uuid;
                         }
-                        const userTail = await this.append(lease, snapshot.tail, userEntry);
-                        snapshot = {
-                            entries: [...snapshot.entries, userEntry],
-                            tail: userTail,
-                        };
-                        if (nativeLease) {
-                            const nativePromptId = await nativeLease.appendMessages({
+                        const nativePrompt = await persistence.commit({
+                            kind: 'messages',
+                            input: {
                                 messages: [
                                     {
                                         role: 'user',
@@ -3893,29 +3613,29 @@ export class ClaudeSessionService {
                                             : {}),
                                     },
                                 ],
-                            });
-                            // File-history snapshots key their metadata to the durable
-                            // native event id, not the scratch compatibility projection id.
-                            currentPromptId = nativePromptId;
-                        }
+                            },
+                            projectionEntries: [userEntry],
+                        });
+                        // File-history snapshots key their metadata to the durable native
+                        // event id, not the compatibility projection id.
+                        if (nativePrompt.kind !== 'messages')
+                            throw new Error('Turn persistence returned an invalid message receipt');
+                        currentPromptId = nativePrompt.eventId;
                     }
                     if (fileHistory && currentPromptId) {
-                        const historySnapshot = await fileHistory.snapshot(snapshot.entries, currentPromptId);
-                        const historyTail = await this.append(lease, snapshot.tail, historySnapshot);
-                        snapshot = {
-                            entries: [...snapshot.entries, historySnapshot],
-                            tail: historyTail,
-                        };
-                        if (nativeLease) {
-                            await nativeLease.appendMessages({
+                        const historySnapshot = await fileHistory.snapshot(projectionSnapshot().entries, currentPromptId);
+                        await persistence.commit({
+                            kind: 'messages',
+                            input: {
                                 messages: [
                                     {
                                         role: 'user',
                                         content: `<praxis-file-history>${JSON.stringify(historySnapshot)}</praxis-file-history>`,
                                     },
                                 ],
-                            });
-                        }
+                            },
+                            projectionEntries: [historySnapshot],
+                        });
                     }
                     if (this.options.hooks && !shouldSkipUserPrompt()) {
                         const outcome = await this.options.hooks.run({
@@ -3929,11 +3649,7 @@ export class ClaudeSessionService {
                             throw new Error(`UserPromptSubmit hook error: ${outcome.blockedReason}`);
                         }
                     }
-                    let shellUsage = { inputTokens: 0, outputTokens: 0 };
-                    let shellModelUsage;
-                    let shellDurationApiMs;
-                    let shellDurationApiWithoutRetriesMs;
-                    let shellToolDurationMs;
+                    let shellResult;
                     if (shellCommand !== undefined) {
                         const call = {
                             id: `shell_${randomUUID().replaceAll('-', '')}`,
@@ -3945,7 +3661,6 @@ export class ClaudeSessionService {
                             callId: call.id,
                             command: shellCommand,
                         });
-                        let shellResult;
                         try {
                             shellResult = await runtime.executeDirectToolCall(call, {
                                 cwd: this.activeCwd(),
@@ -3972,15 +3687,6 @@ export class ClaudeSessionService {
                             });
                             throw error;
                         }
-                        shellUsage = shellResult.usage ?? shellUsage;
-                        shellDurationApiMs = shellResult.durationApiMs;
-                        shellDurationApiWithoutRetriesMs =
-                            shellResult.durationApiWithoutRetriesMs;
-                        shellToolDurationMs = shellResult.durationToolMs;
-                        if (!shellResult.isError) {
-                            shellModelUsage = shellResult.modelUsage;
-                            foregroundLineChanges.add(shellResult);
-                        }
                         const stdout = shellResult.processOutput?.stdout ??
                             (shellResult.isError ? '' : shellResult.content);
                         const stderr = shellResult.processOutput?.stderr ??
@@ -3990,22 +3696,15 @@ export class ClaudeSessionService {
                             { type: 'bash-input', command: shellCommand },
                             { type: 'bash-output', stdout, stderr },
                         ], {
-                            ...this.translationContext(sessionId, snapshot),
+                            ...this.translationContext(sessionId, projectionSnapshot()),
                             createUuid: () => shellUuids.shift() ?? randomUUID(),
                         });
                         if (!inputEntry || !outputEntry) {
                             throw new Error('Could not translate shell command result');
                         }
-                        const shellAppend = await this.appendProjectionMany(snapshot.tail, [
-                            inputEntry,
-                            outputEntry,
-                        ]);
-                        snapshot = {
-                            entries: [...snapshot.entries, inputEntry, outputEntry],
-                            tail: shellAppend.tail,
-                        };
-                        if (nativeLease) {
-                            await nativeLease.appendMessages({
+                        await persistence.commit({
+                            kind: 'messages',
+                            input: {
                                 messages: [
                                     {
                                         role: 'user',
@@ -4016,8 +3715,9 @@ export class ClaudeSessionService {
                                         content: `<bash-stdout>${stdout}</bash-stdout><bash-stderr>${stderr}</bash-stderr>`,
                                     },
                                 ],
-                            });
-                        }
+                            },
+                            projectionEntries: [inputEntry, outputEntry],
+                        });
                         currentTurnUserMessages.push(`<bash-stdout>${stdout}</bash-stdout><bash-stderr>${stderr}</bash-stderr>`);
                         this.options.eventSink?.({
                             type: 'shell-result',
@@ -4028,92 +3728,48 @@ export class ClaudeSessionService {
                         });
                     }
                     if (shellCommand !== undefined) {
-                        const tracker = this.sessionCostTrackers.get(sessionId);
-                        if (!tracker) {
-                            throw new Error(`Session cost tracker is not active for session ${sessionId}`);
-                        }
-                        const totalUsage = mergeUsage(recoveryUsage, shellUsage);
-                        const turnModelUsage = mergeSessionRawModelUsage(recoveryModelUsage, shellModelUsage);
-                        let rawCostUsd;
-                        if (turnModelUsage) {
-                            for (const [model, usage] of Object.entries(turnModelUsage)) {
-                                const pricing = this.options.pricing?.resolve(model);
-                                const costUsd = pricing
-                                    ? usageCostUsd(usage, pricing)
-                                    : undefined;
-                                if (costUsd !== undefined)
-                                    rawCostUsd = (rawCostUsd ?? 0) + costUsd;
-                                tracker.recordTurn({
-                                    model,
-                                    usage,
-                                    ...(costUsd === undefined ? {} : { costUsd }),
-                                    ...(usage.webSearchRequests === undefined
-                                        ? {}
-                                        : { webSearchRequests: usage.webSearchRequests }),
-                                });
-                            }
-                        }
-                        let combinedToolDurationMs = 0;
-                        for (const recoveryResult of recoveryResults) {
-                            combinedToolDurationMs = addToolDuration(recoveryResult.durationToolMs, combinedToolDurationMs);
-                        }
-                        combinedToolDurationMs = addToolDuration(shellToolDurationMs, combinedToolDurationMs);
-                        tracker.recordDurations({
-                            ...(shellDurationApiMs === undefined
-                                ? {}
-                                : { apiDurationMs: shellDurationApiMs }),
-                            ...(shellDurationApiWithoutRetriesMs === undefined
-                                ? {}
-                                : {
-                                    apiDurationWithoutRetriesMs: shellDurationApiWithoutRetriesMs,
-                                }),
-                            ...(combinedToolDurationMs === 0
-                                ? {}
-                                : { toolDurationMs: combinedToolDurationMs }),
+                        if (!shellResult)
+                            throw new Error('Shell command produced no result');
+                        const accounting = turnAccounting.complete({
+                            kind: 'shell',
+                            recovery: recoveryResults,
+                            result: shellResult,
                         });
-                        if (foregroundLineChanges.linesAdded !== 0 ||
-                            foregroundLineChanges.linesRemoved !== 0) {
-                            tracker.recordLineChanges({
-                                ...(foregroundLineChanges.linesAdded === 0
-                                    ? {}
-                                    : { linesAdded: foregroundLineChanges.linesAdded }),
-                                ...(foregroundLineChanges.linesRemoved === 0
-                                    ? {}
-                                    : { linesRemoved: foregroundLineChanges.linesRemoved }),
-                            });
-                        }
                         turnCompleted = true;
                         return {
                             sessionId,
                             text: '',
-                            usage: totalUsage,
-                            ...(rawCostUsd === undefined ? {} : { costUsd: rawCostUsd }),
-                            ...(turnModelUsage ? { modelUsage: { ...turnModelUsage } } : {}),
-                            ...(shellDurationApiMs === undefined
+                            usage: accounting.usage,
+                            ...(accounting.costUsd === undefined
+                                ? {}
+                                : { costUsd: accounting.costUsd }),
+                            ...(accounting.modelUsage === undefined
                                 ? {}
-                                : { durationApiMs: shellDurationApiMs }),
+                                : { modelUsage: accounting.modelUsage }),
+                            ...(accounting.durationApiMs === undefined
+                                ? {}
+                                : { durationApiMs: accounting.durationApiMs }),
                         };
                     }
                     if (shellCommand === undefined && budget) {
-                        const definitions = currentDefinitions();
                         await contextEngine.prepare(contextTransitionPort([], currentTurnUserMessages ?? []), signal);
-                        budget.assertFits(budget.evaluate([
-                            ...contextMessages,
-                            ...injectTurnContext(activeTurnMessages()),
-                        ], definitions));
+                        const projection = contextPreparation.project({
+                            includeMemory: false,
+                        });
+                        budget.assertFits(budget.evaluate(projection.envelope.messages, projection.envelope.tools));
                     }
                     let stopHookActive = false;
+                    const initialProjection = contextPreparation.project({
+                        includeMemory: false,
+                    });
                     const runtimeRequest = {
                         sessionId,
-                        messages: [
-                            ...contextMessages,
-                            ...injectTurnContext(activeTurnMessages()),
-                        ],
-                        stableSystemMessageCount,
+                        messages: initialProjection.envelope.messages,
+                        stableSystemMessageCount: initialProjection.stableSystemMessageCount,
                         cwd: this.activeCwd(),
                         toolResultDirectory,
                         observer,
-                        ...(activeTurnInput ? { steering: activeTurnInput } : {}),
+                        ...(steering ? { steering } : {}),
                         ...(this.options.effort ? { effort: this.options.effort } : {}),
                         ...(this.options.maxModelTurns !== undefined
                             ? { maxModelTurns: this.options.maxModelTurns }
@@ -4138,14 +3794,10 @@ export class ClaudeSessionService {
                             if (shellCommand === undefined) {
                                 await contextEngine.prepare(contextTransitionPort([], currentTurnUserMessages ?? []), signal);
                             }
-                            runtimeRequest.stableSystemMessageCount = stableSystemMessageCount;
-                            return [
-                                ...contextMessages,
-                                ...injectTurnContext([
-                                    ...activeTurnMessages(),
-                                    ...projectMemoryRecallMessages,
-                                ]),
-                            ];
+                            const projection = contextPreparation.project();
+                            runtimeRequest.stableSystemMessageCount =
+                                projection.stableSystemMessageCount;
+                            return projection.envelope.messages;
                         },
                         ...(this.options.hooks ||
                             subagentExecutor ||
@@ -4176,9 +3828,7 @@ export class ClaudeSessionService {
                                     }
                                     const claimedAgentIds = new Set(this.sessionSubagentExecutors(sessionId, true).flatMap((executor) => executor.notificationClaimAgentIds()));
                                     await Promise.all(this.sessionSubagentExecutors(sessionId, true).map((executor) => {
-                                        const delivered = (notification) => transcriptContainsBackgroundAgentNotification(nativeLease
-                                            ? nativeLease.activeMessages()
-                                            : snapshot.entries, notification);
+                                        const delivered = (notification) => transcriptContainsBackgroundAgentNotification(persistence.view().activeMessages, notification);
                                         return this.hostedSubagents.has(executor)
                                             ? executor.reconcileDetachedNotifications(delivered)
                                             : executor.reconcileDeliveredNotifications(delivered);
@@ -4186,11 +3836,8 @@ export class ClaudeSessionService {
                                     await subagentExecutor?.hydratePersistedTasks(sessionId, this.activeCwd(), claimedAgentIds);
                                     const background = await this.collectSubagentNotifications(sessionId, subagentExecutor ?? undefined);
                                     if (background) {
-                                        if (nativeLease) {
-                                            for (const message of background.messages) {
-                                                await this.appendBackgroundNotification(sessionId, message, nativeLease);
-                                            }
-                                        }
+                                        for (const message of background.messages)
+                                            await this.appendBackgroundNotification(sessionId, message, persistence);
                                         messages.push(...background.messages);
                                     }
                                     const workflow = await this.workflowManager?.notifications(true);
@@ -4274,14 +3921,10 @@ export class ClaudeSessionService {
                             }
                             // The single reactive retry must use the compacted transcript, not
                             // the stale request copy captured before the compact boundary.
-                            runtimeRequest.messages = [
-                                ...contextMessages,
-                                ...injectTurnContext([
-                                    ...activeTurnMessages(),
-                                    ...projectMemoryRecallMessages,
-                                ]),
-                            ];
-                            runtimeRequest.stableSystemMessageCount = stableSystemMessageCount;
+                            const projection = contextPreparation.project();
+                            runtimeRequest.messages = projection.envelope.messages;
+                            runtimeRequest.stableSystemMessageCount =
+                                projection.stableSystemMessageCount;
                             runtimeRequest.deferFailureKinds = true;
                             try {
                                 result = await attemptMainTurn();
@@ -4320,108 +3963,20 @@ export class ClaudeSessionService {
                     if (!finalLeafUuid) {
                         throw new Error('Could not locate final assistant response');
                     }
-                    if (!nativeLease && !skipUserPrompt) {
-                        const lastPrompt = createClaudeLastPromptEntry({
-                            sessionId,
-                            lastPrompt: effectivePrompt,
-                            leafUuid: finalLeafUuid,
-                        });
-                        const tail = await this.append(lease, snapshot.tail, lastPrompt);
-                        snapshot = {
-                            entries: [...snapshot.entries, lastPrompt],
-                            tail,
-                        };
-                    }
-                    const totalUsage = mergeUsage(mergeUsage(mergeUsage(recoveryUsage, compactionUsage), shellUsage), result.usage);
-                    const tracker = this.sessionCostTrackers.get(sessionId);
-                    if (!tracker) {
-                        throw new Error(`Session cost tracker is not active for session ${sessionId}`);
-                    }
-                    const turnModelUsage = mergeSessionRawModelUsage(recoveryModelUsage, compactionModelUsage, shellModelUsage, result.modelUsage);
-                    const combinedDurationMs = compactionDurationMs === undefined &&
-                        result.durationApiMs === undefined
-                        ? undefined
-                        : (compactionDurationMs ?? 0) + (result.durationApiMs ?? 0);
-                    let rawCostUsd;
-                    if (turnModelUsage) {
-                        for (const [model, usage] of Object.entries(turnModelUsage)) {
-                            const pricing = this.options.pricing?.resolve(model);
-                            const costUsd = pricing ? usageCostUsd(usage, pricing) : undefined;
-                            if (costUsd !== undefined)
-                                rawCostUsd = (rawCostUsd ?? 0) + costUsd;
-                        }
-                    }
-                    // Auto-compaction metering was already recorded atomically with each
-                    // committed boundary, and externally metered tool-summary metrics were
-                    // committed through the summary callback, so the live tracker receives
-                    // only the unrecorded subset here. The inclusive public aggregates
-                    // above still contain every row and duration.
-                    const trackedModelUsage = mergeSessionRawModelUsage(recoveryModelUsage, shellModelUsage, result.unrecordedModelUsage ?? result.modelUsage);
-                    if (trackedModelUsage) {
-                        for (const [model, usage] of Object.entries(trackedModelUsage)) {
-                            const pricing = this.options.pricing?.resolve(model);
-                            const costUsd = pricing ? usageCostUsd(usage, pricing) : undefined;
-                            tracker.recordTurn({
-                                model,
-                                usage,
-                                ...(costUsd === undefined ? {} : { costUsd }),
-                                ...(usage.webSearchRequests === undefined
-                                    ? {}
-                                    : { webSearchRequests: usage.webSearchRequests }),
-                            });
-                        }
-                    }
-                    let combinedToolDurationMs = 0;
-                    for (const recoveryResult of recoveryResults) {
-                        combinedToolDurationMs = addToolDuration(recoveryResult.durationToolMs, combinedToolDurationMs);
-                    }
-                    combinedToolDurationMs = addToolDuration(result.durationToolMs, combinedToolDurationMs);
-                    const trackedDurationApiMs = result.unrecordedDurationApiMs ?? result.durationApiMs;
-                    const trackedDurationApiWithoutRetriesMs = result.unrecordedDurationApiWithoutRetriesMs ??
-                        result.durationApiWithoutRetriesMs;
-                    tracker.recordDurations({
-                        ...(trackedDurationApiMs === undefined
-                            ? {}
-                            : { apiDurationMs: trackedDurationApiMs }),
-                        ...(trackedDurationApiWithoutRetriesMs === undefined
-                            ? {}
-                            : {
-                                apiDurationWithoutRetriesMs: trackedDurationApiWithoutRetriesMs,
-                            }),
-                        ...(combinedToolDurationMs === 0
-                            ? {}
-                            : { toolDurationMs: combinedToolDurationMs }),
-                    });
-                    foregroundLineChanges.add({
-                        isError: false,
-                        ...(result.linesAdded === undefined
-                            ? {}
-                            : { linesAdded: result.linesAdded }),
-                        ...(result.linesRemoved === undefined
-                            ? {}
-                            : { linesRemoved: result.linesRemoved }),
+                    const accounting = turnAccounting.complete({
+                        kind: 'runtime',
+                        recovery: recoveryResults,
+                        result,
                     });
-                    if (foregroundLineChanges.linesAdded !== 0 ||
-                        foregroundLineChanges.linesRemoved !== 0) {
-                        tracker.recordLineChanges({
-                            ...(foregroundLineChanges.linesAdded === 0
-                                ? {}
-                                : { linesAdded: foregroundLineChanges.linesAdded }),
-                            ...(foregroundLineChanges.linesRemoved === 0
-                                ? {}
-                                : { linesRemoved: foregroundLineChanges.linesRemoved }),
-                        });
-                    }
                     const memorySnapshot = activeTurnMessages();
-                    const nativeMemoryMessageId = nativeLease
-                        ? projectNativeSessionEntries(nativeLease.activeEvents()).at(-1)
-                            ?.uuid
-                        : undefined;
-                    const providerVisibleMessages = [
-                        ...contextMessages,
-                        ...injectTurnContext(memorySnapshot),
-                    ];
-                    const definitions = currentDefinitions();
+                    const nativeMemoryMessageId = persistence
+                        .view()
+                        .projectionEntries.at(-1)?.uuid;
+                    const providerProjection = contextPreparation.project({
+                        includeMemory: false,
+                    });
+                    const providerVisibleMessages = providerProjection.envelope.messages;
+                    const definitions = providerProjection.envelope.tools;
                     const currentContextTokens = contextEngine.report({
                         messages: providerVisibleMessages,
                         tools: definitions,
@@ -4438,18 +3993,16 @@ export class ClaudeSessionService {
                         occupancyTokens: currentContextTokens,
                         toolCalls: currentTurnToolCalls,
                         messages: memorySnapshot,
-                        projectMessages: nativeLease
-                            ? memorySnapshot.flatMap((message, index) => (message.role === 'user' || message.role === 'assistant') &&
-                                message.content.trim().length > 0
-                                ? [
-                                    {
-                                        id: `${finalLeafUuid ?? sessionId}:${index}`,
-                                        role: message.role,
-                                        content: message.content,
-                                    },
-                                ]
-                                : [])
-                            : projectMemoryMessages(snapshot.entries),
+                        projectMessages: memorySnapshot.flatMap((message, index) => (message.role === 'user' || message.role === 'assistant') &&
+                            message.content.trim().length > 0
+                            ? [
+                                {
+                                    id: `${finalLeafUuid ?? sessionId}:${index}`,
+                                    role: message.role,
+                                    content: message.content,
+                                },
+                            ]
+                            : []),
                         directMaintenance: projectMemoryMaintained,
                     });
                     turnCompleted = true;
@@ -4458,12 +4011,16 @@ export class ClaudeSessionService {
                         text: structuredCapture && structuredCapture.calls === 1
                             ? JSON.stringify(structuredCapture.value)
                             : result.text,
-                        usage: totalUsage,
-                        ...(combinedDurationMs === undefined
+                        usage: accounting.usage,
+                        ...(accounting.durationApiMs === undefined
                             ? {}
-                            : { durationApiMs: combinedDurationMs }),
-                        ...(rawCostUsd === undefined ? {} : { costUsd: rawCostUsd }),
-                        ...(turnModelUsage ? { modelUsage: { ...turnModelUsage } } : {}),
+                            : { durationApiMs: accounting.durationApiMs }),
+                        ...(accounting.costUsd === undefined
+                            ? {}
+                            : { costUsd: accounting.costUsd }),
+                        ...(accounting.modelUsage === undefined
+                            ? {}
+                            : { modelUsage: accounting.modelUsage }),
                         ...(structuredCapture && structuredCapture.calls === 1
                             ? { structuredOutput: structuredCapture.value }
                             : {}),
@@ -4499,35 +4056,12 @@ export class ClaudeSessionService {
                         : { kind: 'resume', atEventId: resumeSessionAt }
                     : { kind: 'start' };
                 result = await nativeTranscript.withLease(activationKind, async (nativeLease) => {
-                    const scratch = new InMemoryTranscriptStore();
-                    const scratchResult = await scratch.withLease((scratchLease) => runUnderLease(scratchLease, nativeLease));
-                    if (scratchResult.status === 'conflict') {
-                        throw new Error(`native scratch transcript conflict: ${scratchResult.reason}`);
-                    }
-                    return scratchResult.value;
+                    const persistence = new TurnPersistence({ native: nativeLease });
+                    return runUnderLease(persistence);
                 });
             }
-            controller.complete();
             return result;
-        }
-        catch (error) {
-            controller.fail(error, signal);
-            throw error;
-        }
-        finally {
-            if (activeTurnInput !== undefined) {
-                for (const item of activeTurnInput.close()) {
-                    this.options.eventSink?.({
-                        type: 'user-input-rejected',
-                        id: item.id,
-                        content: item.content,
-                        reason: signal?.aborted ? 'cancelled' : 'failed',
-                    });
-                }
-            }
-            if (this.activeTurnInputs.get(sessionId) === activeTurnRecord)
-                this.activeTurnInputs.delete(sessionId);
-        }
+        });
     }
     async ensureFileResources(sessionId, signal) {
         const resources = this.options.fileResources ?? [];
@@ -4901,6 +4435,16 @@ export class ClaudeSessionService {
         });
     }
     async appendBackgroundNotification(sessionId, content, nativeLease) {
+        if (nativeLease instanceof TurnPersistence) {
+            if (nativeLease.view().activeMessages.length === 0) {
+                throw new Error(`Native session not found: ${sessionId}`);
+            }
+            await nativeLease.commit({
+                kind: 'messages',
+                input: { messages: [{ role: 'user', content }] },
+            });
+            return true;
+        }
         if (nativeLease) {
             if (nativeLease.activeMessages().length === 0) {
                 throw new Error(`Native session not found: ${sessionId}`);
@@ -5290,32 +4834,6 @@ export class ClaudeSessionService {
         }
         return factory(base, operations, sessionId, enabledTools);
     }
-    async append(lease, tail, entry) {
-        void lease;
-        return this.appendProjectionMany(tail, [entry]).then((result) => result.tail);
-    }
-    /**
-     * Update the in-memory compatibility projection used by the turn pipeline.
-     * Authoritative native persistence is performed by NativeSessionTranscript;
-     * these entries are never written to the native event store.
-     */
-    async appendProjectionMany(tail, entries) {
-        if (entries.length === 0)
-            throw new Error('Cannot append an empty projection');
-        const lastUuid = [...entries]
-            .reverse()
-            .find((entry) => typeof entry.uuid === 'string')?.uuid;
-        return {
-            status: 'appended',
-            tail: {
-                ...tail,
-                byteLength: tail.byteLength + entries.length,
-                lastLineHash: `projection:${tail.byteLength + entries.length}`,
-                lastEventId: typeof lastUuid === 'string' ? lastUuid : tail.lastEventId,
-                ...(tail.branchParentId === undefined ? {} : { branchParentId: null }),
-            },
-        };
-    }
     logicalTailUuid(tail) {
         return tail.branchParentId ?? tail.lastEventId;
     }