praxis-agent 0.35.0 → 0.36.0

package/dist/application/session-service.js

@@ -5,7 +5,7 @@ import { basename, dirname, extname, isAbsolute, join, relative, resolve, } from
 import { isPathWithin } from '../platform/path-containment.js';
 import { AGENT_COLOR_DEFAULT, agentColorMessage, getClaudeEffectiveAgentColor, } from '../compatibility/claude/agent-color.js';
 import { createClaudeCompactEntries, formatClaudeCompactSummary, getCumulativeDroppedTokens, } from '../compatibility/claude/compaction.js';
-import { discoverClaudeProjectRoot, isClaudeSessionId, resolveClaudePaths, resolveClaudeScheduledTaskFile, } from '../compatibility/claude/paths.js';
+import { discoverClaudeProjectRoot, resolveClaudePaths, resolveClaudeScheduledTaskFile, } from '../compatibility/claude/paths.js';
 import { isClaudeAgentId } from '../compatibility/claude/sidechain.js';
 import { resolveDataPlanePaths, resolveScheduledTaskFile, } from '../persistence/data-plane.js';
 import { downloadClaudeFileResources, } from '../compatibility/claude/file-resources.js';
@@ -23,13 +23,18 @@ 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 { ContextBudget, ContextRecoveryPlanner, contextRecoveryMadeProgress, estimateModelRequestTokens, isPromptTooLongError, } from '../core/context-budget.js';
+import { isSessionId } from '../core/session.js';
+import { ContextBudget, estimateModelRequestTokens, isPromptTooLongError, } from '../core/context-budget.js';
+import { ContextEngine } from './context-engine.js';
+import { TurnMemoryCoordinator } from './turn-memory-coordinator.js';
 import { injectFirstUserMessageContext, projectContextSnapshot, } from '../core/context.js';
 import { assembleContextSnapshot } from '../core/prompt-composer.js';
 import { ClaudeHookToolCoordinator } from '../hooks/claude-hook-tools.js';
 import { ClaudeFileChangeWatcher } from '../hooks/claude-file-change-watcher.js';
 import { ClaudeTranscriptStore, } from '../persistence/claude-transcript-store.js';
 import { ClaudeSessionIndexCandidateError, readClaudeSessionIndexes, } from '../persistence/claude-session-index.js';
+import { readNativeTranscript, readNativeTranscriptIndexes, exportNativeTranscript, NativeTranscriptIndexCandidateError, } from '../persistence/native-transcript-reader.js';
+import { lastUserPrompt, projectTranscriptDisplay, } from './transcript-projection.js';
 import { InMemoryTranscriptStore } from '../persistence/in-memory-transcript-store.js';
 import { SubagentLifecycleStore } from '../persistence/subagent-lifecycle-store.js';
 import { ModelCompactor } from './model-compactor.js';
@@ -78,6 +83,42 @@ function mainAgentToolNames(tools, agent) {
         .map(({ name }) => name)
         .filter((name) => (!requested || requested.has(name)) && !disallowed.has(name));
 }
+function sessionMetadataFields(metadata, options) {
+    const name = metadata.title ??
+        (options.agentNameFallback ? metadata.agentName : undefined);
+    const prLink = metadata.prLink;
+    return {
+        ...(name === undefined ? {} : { name }),
+        ...(metadata.tag === undefined ? {} : { tag: metadata.tag }),
+        ...(metadata.agentName === undefined
+            ? {}
+            : { agentName: metadata.agentName }),
+        ...(metadata.agentColor === undefined
+            ? {}
+            : { agentColor: metadata.agentColor }),
+        ...(metadata.agentSetting === undefined
+            ? {}
+            : { agentSetting: metadata.agentSetting }),
+        ...(metadata.permissionMode === undefined
+            ? {}
+            : { permissionMode: metadata.permissionMode }),
+        ...(metadata.mode === undefined ? {} : { mode: metadata.mode }),
+        ...(prLink === undefined
+            ? {}
+            : {
+                prNumber: prLink.prNumber,
+                ...(prLink.prUrl === undefined ? {} : { prUrl: prLink.prUrl }),
+                ...(prLink.prRepository === undefined
+                    ? {}
+                    : { prRepository: prLink.prRepository }),
+            }),
+    };
+}
+function isSessionCandidateError(error) {
+    return (error instanceof ClaudeSessionIndexCandidateError ||
+        error instanceof NativeTranscriptIndexCandidateError ||
+        ['ENOENT', 'ENOTDIR', 'ELOOP'].includes(error.code ?? ''));
+}
 const emptyToolRegistry = {
     definitions: () => [],
     schedulingPolicy: () => ({ concurrency: 'exclusive' }),
@@ -1554,19 +1595,62 @@ export class ClaudeSessionService {
         }
         catch (error) {
             if (error.code === 'ENOENT')
-                return [];
-            throw error;
+                names = [];
+            else
+                throw error;
         }
         const discoveredSessionIds = names
             .filter((name) => extname(name) === '.jsonl')
             .map((name) => basename(name, '.jsonl'))
-            .filter((sessionId) => isClaudeSessionId(sessionId));
+            .filter((sessionId) => isSessionId(sessionId));
         const sessionIds = [
             ...new Set([
                 ...discoveredSessionIds,
                 ...this.explicitSessionFiles.keys(),
             ]),
         ];
+        if (this.options.dataPlane === 'native') {
+            const nativeResults = await readNativeTranscriptIndexes(sessionIds.map((sessionId) => ({
+                sessionId,
+                path: this.explicitSessionFiles.get(sessionId) ??
+                    join(projectRoot, `${sessionId}.jsonl`),
+            })));
+            const legacyResults = await readClaudeSessionIndexes(nativeResults.flatMap((result) => 'result' in result && result.result.format === 'legacy'
+                ? [{ sessionId: result.sessionId, path: result.path }]
+                : []), this.schema);
+            const legacyBySessionId = new Map(legacyResults.map((result) => [result.sessionId, result]));
+            const nativeSummaries = nativeResults.map((result) => {
+                try {
+                    if ('error' in result)
+                        throw result.error;
+                    const file = result.result;
+                    if (file.format === 'legacy') {
+                        const legacy = legacyBySessionId.get(result.sessionId);
+                        if (!legacy)
+                            throw new Error(`Missing legacy transcript index for ${result.sessionId}`);
+                        if ('error' in legacy)
+                            throw legacy.error;
+                        return this.claudeSessionSummary(result.sessionId, legacy.index);
+                    }
+                    return {
+                        sessionId: result.sessionId,
+                        lastPrompt: lastUserPrompt(file.records.map((record) => record.event)),
+                        updatedAt: file.updatedAt,
+                        status: this.nativeSessionStatus(file.issue, file.records.length),
+                        issue: file.issue,
+                    };
+                }
+                catch (error) {
+                    if (isSessionCandidateError(error))
+                        return null;
+                    throw error;
+                }
+            });
+            return nativeSummaries
+                .filter((summary) => summary !== null)
+                .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt) ||
+                left.sessionId.localeCompare(right.sessionId));
+        }
         if (discoveredRoot !== undefined) {
             for (const sessionId of discoveredSessionIds) {
                 this.discoveredProjectRoots.set(sessionId, projectRoot);
@@ -1581,46 +1665,11 @@ export class ClaudeSessionService {
             try {
                 if ('error' in result)
                     throw result.error;
-                const { sessionId, index } = result;
-                const metadata = reduceClaudeSessionMetadata(index.entries, sessionId);
-                const name = metadata.title ?? metadata.agentName;
-                const prLink = metadata.prLink;
-                return {
-                    sessionId,
-                    ...(name === undefined ? {} : { name }),
-                    ...(metadata.tag === undefined ? {} : { tag: metadata.tag }),
-                    ...(metadata.agentName === undefined
-                        ? {}
-                        : { agentName: metadata.agentName }),
-                    ...(metadata.agentColor === undefined
-                        ? {}
-                        : { agentColor: metadata.agentColor }),
-                    ...(metadata.agentSetting === undefined
-                        ? {}
-                        : { agentSetting: metadata.agentSetting }),
-                    ...(metadata.permissionMode === undefined
-                        ? {}
-                        : { permissionMode: metadata.permissionMode }),
-                    ...(metadata.mode === undefined ? {} : { mode: metadata.mode }),
-                    lastPrompt: metadata.lastPrompt ?? null,
-                    updatedAt: index.updatedAt,
-                    status: this.sessionStatus(index.issue, index.entries.length),
-                    issue: index.issue,
-                    ...(prLink
-                        ? {
-                            prNumber: prLink.prNumber,
-                            prUrl: prLink.prUrl,
-                            prRepository: prLink.prRepository,
-                        }
-                        : {}),
-                };
+                return this.claudeSessionSummary(result.sessionId, result.index);
             }
             catch (error) {
-                if (error instanceof ClaudeSessionIndexCandidateError)
-                    return null;
-                if (['ENOENT', 'ENOTDIR', 'ELOOP'].includes(error.code ?? '')) {
+                if (isSessionCandidateError(error))
                     return null;
-                }
                 throw error;
             }
         });
@@ -1631,6 +1680,37 @@ export class ClaudeSessionService {
     }
     async inspect(sessionId) {
         this.assertSessionPersistence();
+        if (this.options.dataPlane === 'native') {
+            const paths = this.paths(sessionId);
+            const file = await readNativeTranscript(paths.sessionFile);
+            if (file.format === 'legacy') {
+                const recovery = await this.store(sessionId).loadReadOnly();
+                const metadata = reduceClaudeSessionMetadata(recovery.entries, sessionId);
+                return {
+                    sessionId,
+                    ...sessionMetadataFields(metadata, { agentNameFallback: false }),
+                    lastPrompt: metadata.lastPrompt ?? null,
+                    updatedAt: file.updatedAt,
+                    status: this.sessionStatus(recovery.issue, recovery.entries.length),
+                    issue: recovery.issue,
+                    writeMode: this.schema.writeMode,
+                    entryCount: recovery.entries.length,
+                    byteLength: file.byteLength,
+                    newlineTerminated: file.newlineTerminated,
+                };
+            }
+            return {
+                sessionId,
+                lastPrompt: lastUserPrompt(file.records.map((record) => record.event)),
+                updatedAt: file.updatedAt,
+                status: this.nativeSessionStatus(file.issue, file.records.length),
+                issue: file.issue,
+                writeMode: file.writeMode,
+                entryCount: file.records.length,
+                byteLength: file.byteLength,
+                newlineTerminated: file.newlineTerminated,
+            };
+        }
         await this.discoverProjectRoot(sessionId);
         const paths = this.paths(sessionId);
         let metadata;
@@ -1645,30 +1725,9 @@ export class ClaudeSessionService {
         }
         const recovery = await this.store(sessionId).loadReadOnly();
         const sessionMetadata = reduceClaudeSessionMetadata(recovery.entries, sessionId);
-        const prLink = sessionMetadata.prLink;
         return {
             sessionId,
-            ...(sessionMetadata.title === undefined
-                ? {}
-                : { name: sessionMetadata.title }),
-            ...(sessionMetadata.tag === undefined
-                ? {}
-                : { tag: sessionMetadata.tag }),
-            ...(sessionMetadata.agentName === undefined
-                ? {}
-                : { agentName: sessionMetadata.agentName }),
-            ...(sessionMetadata.agentColor === undefined
-                ? {}
-                : { agentColor: sessionMetadata.agentColor }),
-            ...(sessionMetadata.agentSetting === undefined
-                ? {}
-                : { agentSetting: sessionMetadata.agentSetting }),
-            ...(sessionMetadata.permissionMode === undefined
-                ? {}
-                : { permissionMode: sessionMetadata.permissionMode }),
-            ...(sessionMetadata.mode === undefined
-                ? {}
-                : { mode: sessionMetadata.mode }),
+            ...sessionMetadataFields(sessionMetadata, { agentNameFallback: false }),
             lastPrompt: sessionMetadata.lastPrompt ?? null,
             updatedAt: metadata.mtime.toISOString(),
             status: this.sessionStatus(recovery.issue, recovery.entries.length),
@@ -1678,13 +1737,6 @@ export class ClaudeSessionService {
             entryCount: recovery.entries.length,
             byteLength: recovery.tail.byteLength,
             newlineTerminated: recovery.tail.newlineTerminated,
-            ...(prLink
-                ? {
-                    prNumber: prLink.prNumber,
-                    prUrl: prLink.prUrl,
-                    prRepository: prLink.prRepository,
-                }
-                : {}),
         };
     }
     async readEffectiveAgentColor(sessionId) {
@@ -1694,6 +1746,8 @@ export class ClaudeSessionService {
     }
     async export(sessionId) {
         this.assertSessionPersistence();
+        if (this.options.dataPlane === 'native')
+            return exportNativeTranscript(this.paths(sessionId).sessionFile);
         await this.discoverProjectRoot(sessionId);
         try {
             return await this.store(sessionId).exportReadOnly();
@@ -1709,17 +1763,40 @@ export class ClaudeSessionService {
         this.assertSessionPersistence();
         const path = resolve(requestedPath);
         const pathMetadata = await lstat(path);
+        const dataPlaneName = this.options.dataPlane === 'native' ? 'Native' : 'Claude';
         if (!pathMetadata.isFile()) {
-            throw new Error(`Claude resume path must be a regular JSONL file: ${path}`);
+            throw new Error(`${dataPlaneName} resume path must be a regular JSONL file: ${path}`);
         }
         if (extname(path).toLowerCase() !== '.jsonl') {
-            throw new Error(`Claude resume path must end in .jsonl: ${path}`);
+            throw new Error(`${dataPlaneName} resume path must end in .jsonl: ${path}`);
         }
         const sessionId = basename(path, '.jsonl');
-        if (!isClaudeSessionId(sessionId)) {
-            throw new Error(`Claude resume path filename must be a session UUID: ${path}`);
+        if (!isSessionId(sessionId)) {
+            throw new Error(`${dataPlaneName} resume path filename must be a session UUID: ${path}`);
         }
         const canonicalPath = await realpath(path);
+        if (this.options.dataPlane === 'native') {
+            const detected = await readNativeTranscript(canonicalPath);
+            if (detected.format === 'native') {
+                if (detected.issue?.kind === 'unsupported-version')
+                    throw new Error('Native resume transcript version is unsupported');
+                if (detected.issue ||
+                    !detected.newlineTerminated ||
+                    detected.records.length === 0)
+                    throw new Error('Native resume transcript must be a complete non-empty newline-terminated file');
+                if (detected.records.some((record) => record.event.sessionId !== sessionId))
+                    throw new Error('Native resume transcript contains a different sessionId');
+                this.explicitSessionFiles.set(sessionId, canonicalPath);
+                this.discoveredProjectRoots.set(sessionId, dirname(canonicalPath));
+                return {
+                    sessionId,
+                    lastPrompt: lastUserPrompt(detected.records.map((record) => record.event)),
+                    updatedAt: detected.updatedAt,
+                    status: 'read-only',
+                    issue: detected.issue,
+                };
+            }
+        }
         const exact = this.pathsForCwd(sessionId, this.activeCwd());
         const candidate = new ClaudeTranscriptStore({
             sessionFile: canonicalPath,
@@ -1733,6 +1810,10 @@ export class ClaudeSessionService {
         if (snapshot.entries.length === 0) {
             throw new Error('Claude resume transcript must not be empty');
         }
+        if (this.options.dataPlane === 'native' &&
+            this.schema.writeMode !== 'read-write') {
+            throw new Error('Native legacy resume transcript is read-only');
+        }
         let matchingSessionIdentity = false;
         for (const entry of snapshot.entries) {
             if (entry.sessionId === sessionId)
@@ -1750,40 +1831,21 @@ export class ClaudeSessionService {
         this.explicitResumeLeafUuids.set(sessionId, selected.leafUuid);
         this.discoveredProjectRoots.set(sessionId, dirname(canonicalPath));
         const metadata = reduceClaudeSessionMetadata(snapshot.entries, sessionId);
-        const prLink = metadata.prLink;
         return {
             sessionId,
-            ...(metadata.title === undefined ? {} : { name: metadata.title }),
-            ...(metadata.tag === undefined ? {} : { tag: metadata.tag }),
-            ...(metadata.agentName === undefined
-                ? {}
-                : { agentName: metadata.agentName }),
-            ...(metadata.agentColor === undefined
-                ? {}
-                : { agentColor: metadata.agentColor }),
-            ...(metadata.agentSetting === undefined
-                ? {}
-                : { agentSetting: metadata.agentSetting }),
-            ...(metadata.permissionMode === undefined
-                ? {}
-                : { permissionMode: metadata.permissionMode }),
-            ...(metadata.mode === undefined ? {} : { mode: metadata.mode }),
+            ...sessionMetadataFields(metadata, { agentNameFallback: false }),
             lastPrompt: metadata.lastPrompt ?? null,
             updatedAt: pathMetadata.mtime.toISOString(),
             status: this.sessionStatus(null, snapshot.entries.length),
             issue: null,
-            ...(prLink === undefined
-                ? {}
-                : {
-                    prNumber: prLink.prNumber,
-                    ...(prLink.prUrl === undefined ? {} : { prUrl: prLink.prUrl }),
-                    ...(prLink.prRepository === undefined
-                        ? {}
-                        : { prRepository: prLink.prRepository }),
-                }),
         };
     }
     async transcript(sessionId, resumeSessionAt) {
+        if (this.options.dataPlane === 'native') {
+            const file = await readNativeTranscript(this.paths(sessionId).sessionFile);
+            if (file.format === 'native')
+                return projectTranscriptDisplay(file.records.map((record) => record.event), resumeSessionAt);
+        }
         await this.discoverProjectRoot(sessionId);
         try {
             const recovery = await this.store(sessionId).loadReadOnly();
@@ -2371,6 +2433,7 @@ export class ClaudeSessionService {
     }
     async fork(parentSessionId, sessionId = randomUUID(), resumeSessionAt) {
         this.assertSessionPersistence();
+        await this.assertNativeWriteTargetIsLegacy(parentSessionId);
         this.assertWritable();
         const entries = await this.nativeForkEntries(parentSessionId, sessionId, resumeSessionAt);
         const result = await this.store(sessionId).create(entries);
@@ -2701,6 +2764,8 @@ export class ClaudeSessionService {
         const skipUserPrompt = submission.kind === 'retry';
         const controller = new TurnTerminalController(this.options.eventSink ?? (() => undefined));
         try {
+            if (requireExisting)
+                await this.assertNativeWriteTargetIsLegacy(sessionId);
             this.assertWritable();
             if (prompt.length === 0 && images.length === 0 && documents.length === 0)
                 throw new Error('Prompt must not be empty');
@@ -2834,14 +2899,25 @@ export class ClaudeSessionService {
                         agent?.initialPrompt
                         ? `${agent.initialPrompt}\n\n${prompt}`
                         : prompt);
-                const projectMemoryRecallTurn = !skipUserPrompt && shellCommand === undefined
-                    ? this.options.projectMemoryRecall?.prefetch({
-                        sessionId,
+                const sessionMemory = this.sessionMemoryController(sessionId);
+                const turnMemory = new TurnMemoryCoordinator({
+                    sessionId,
+                    ...(sessionMemory ? { session: sessionMemory } : {}),
+                    ...(this.options.projectMemoryRecall
+                        ? { projectRecall: this.options.projectMemoryRecall }
+                        : {}),
+                    ...(this.options.projectMemoryExtraction
+                        ? { projectExtraction: this.options.projectMemoryExtraction }
+                        : {}),
+                    warn: (message) => this.options.eventSink?.({ type: 'warning', message }),
+                });
+                if (!skipUserPrompt && shellCommand === undefined) {
+                    turnMemory.prefetch({
                         turnId: randomUUID(),
                         prompt: effectivePrompt,
                         ...(signal ? { signal } : {}),
-                    })
-                    : undefined;
+                    });
+                }
                 const initialPricing = this.options.pricing?.resolve(provider.model ?? 'praxis/provider');
                 if (this.options.maxBudgetUsd !== undefined && !initialPricing) {
                     throw new Error(`Cannot enforce --max-budget-usd: no pricing is configured for model ${provider.model ?? 'praxis/provider'}`);
@@ -3206,7 +3282,11 @@ export class ClaudeSessionService {
                 let currentTurnToolCalls = 0;
                 let projectMemoryMaintained = false;
                 let projectMemoryRecallMessages = [];
+                let observeModelRequestUsage = () => undefined;
                 const observer = {
+                    modelRequestCompleted: async (input) => {
+                        observeModelRequestUsage(input);
+                    },
                     assistantCompleted: async (message) => {
                         const [entry] = translateProviderEvents([
                             {
@@ -3292,7 +3372,7 @@ export class ClaudeSessionService {
                             if (path &&
                                 isPathWithin(this.options.projectMemoryDirectory, path)) {
                                 if (call.name === 'Read') {
-                                    this.options.projectMemoryRecall?.recordRead(sessionId, path);
+                                    turnMemory.recordRead(path);
                                 }
                                 else if (call.name === 'Write' || call.name === 'Edit') {
                                     projectMemoryMaintained = true;
@@ -3302,7 +3382,7 @@ export class ClaudeSessionService {
                                 for (const accessedPath of toolResult.accessedPaths ?? []) {
                                     const resolvedAccessedPath = resolve(this.activeCwd(), accessedPath);
                                     if (isPathWithin(this.options.projectMemoryDirectory, resolvedAccessedPath)) {
-                                        this.options.projectMemoryRecall?.recordRead(sessionId, resolvedAccessedPath);
+                                        turnMemory.recordRead(resolvedAccessedPath);
                                     }
                                 }
                             }
@@ -3408,7 +3488,6 @@ export class ClaudeSessionService {
                             tail: settingTail,
                         };
                     }
-                    const sessionMemory = this.sessionMemoryController(sessionId);
                     let agentSystem = null;
                     let planModeMessage;
                     let sessionMemoryMessage = null;
@@ -3422,9 +3501,7 @@ export class ClaudeSessionService {
                         agentSystem = await this.mainAgentSystemPrompt(agent);
                         planModeMessage =
                             this.options.interactiveTools?.contextMessage(sessionId);
-                        sessionMemoryMessage = sessionMemory
-                            ? this.sessionMemoryMessage(await sessionMemory.summary())
-                            : null;
+                        sessionMemoryMessage = this.sessionMemoryMessage(await turnMemory.sessionSummary());
                         const assembledContext = await assembleContextSnapshot(this.options.contextAssembler, {
                             cwd: this.activeCwd(),
                             lifecycleId: sessionId,
@@ -3479,7 +3556,17 @@ export class ClaudeSessionService {
                         ? (structuredTools?.definitions() ?? [])
                         : [];
                     const budget = this.contextBudget(provider);
-                    const recoveryPlanner = new ContextRecoveryPlanner();
+                    const contextEngine = new ContextEngine({
+                        ...(budget ? { budget } : {}),
+                        autoCompact: this.options.autoCompact !== false,
+                        memory: {
+                            beforeCompact: () => turnMemory.beforeCompact(),
+                            afterCompact: () => turnMemory.afterCompact(),
+                        },
+                    });
+                    observeModelRequestUsage = ({ usage, messages, tools }) => {
+                        contextEngine.observeUsage(usage, messages, tools);
+                    };
                     const pendingUserMessages = expandedMessages.map((message, index) => ({
                         role: 'user',
                         content: message.text,
@@ -3531,276 +3618,301 @@ export class ClaudeSessionService {
                     const injectDynamicContext = (messages) => injectFirstUserMessageContext(messages, contextProjection.firstUserMessageContext);
                     const injectTurnContext = (messages) => injectAgentMentionContext(injectDynamicContext(messages));
                     let compactionAnchorUuid = this.lastMessageUuid(snapshot.entries);
-                    const compactIfNeeded = async (pendingMessages = [], preservedUserMessages = [], options = {}) => {
-                        if (!budget || this.options.autoCompact === false)
-                            return;
-                        const historyMessages = [
-                            ...projectClaudeModelMessages(snapshot.entries),
-                            ...projectMemoryRecallMessages,
-                        ];
-                        const predicted = budget.evaluate([
-                            ...contextMessages,
-                            ...injectTurnContext([...historyMessages, ...pendingMessages]),
-                        ], definitions, options);
-                        if (!predicted.shouldCompact)
-                            return;
-                        const irreducibleMessages = [
-                            ...contextMessages,
-                            ...injectTurnContext([
-                                ...pendingMessages,
-                                ...preservedUserMessages.map((content) => ({
-                                    role: 'user',
-                                    content,
-                                })),
-                            ]),
-                        ];
-                        const irreducible = budget.evaluate(irreducibleMessages, definitions);
-                        budget.assertFits(irreducible);
-                        let logicalParentUuid = compactionAnchorUuid;
-                        if (!logicalParentUuid || historyMessages.length === 0) {
-                            budget.assertFits(predicted);
-                            throw new Error('Cannot compact an empty Claude transcript');
-                        }
-                        if (findUnresolvedClaudeToolCalls(snapshot.entries).length > 0) {
-                            throw new Error('Cannot compact a Claude session with unresolved tool calls');
-                        }
-                        const preCompact = await this.runAdvisoryHook(sessionId, 'PreCompact', { trigger: 'auto', custom_instructions: null }, 'auto', signal);
-                        const memorySelection = sessionMemory
-                            ? await this.selectMemoryPreservedCompact(sessionId, selectClaudeActiveTranscript(snapshot.entries))
-                            : null;
-                        const compactorMessages = memorySelection
-                            ? [
-                                memorySelection.memoryMessage,
-                                ...projectClaudeModelMessages(memorySelection.compactedEntries),
-                            ]
-                            : historyMessages;
-                        compactorMessages.push(...successfulHookOutput(preCompact).map((content) => ({
-                            role: 'user',
-                            content: `Additional summarization context: ${content}`,
-                        })));
-                        if (memorySelection) {
-                            logicalParentUuid = memorySelection.logicalParentUuid;
-                        }
-                        this.options.eventSink?.({ type: 'state', state: 'compacting' });
-                        const compactEnvelope = budget.evaluate([
-                            ...irreducibleMessages,
-                            {
+                    const contextTransitionPort = (pendingMessages = [], preservedUserMessages = []) => ({
+                        current: () => {
+                            const historyMessages = [
+                                ...projectClaudeModelMessages(snapshot.entries),
+                                ...projectMemoryRecallMessages,
+                            ];
+                            return {
+                                messages: [
+                                    ...contextMessages,
+                                    ...injectTurnContext([
+                                        ...historyMessages,
+                                        ...pendingMessages,
+                                    ]),
+                                ],
+                                tools: definitions,
+                            };
+                        },
+                        irreducible: () => ({
+                            messages: [
+                                ...contextMessages,
+                                ...injectTurnContext([
+                                    ...pendingMessages,
+                                    ...preservedUserMessages.map((content) => ({
+                                        role: 'user',
+                                        content,
+                                    })),
+                                ]),
+                            ],
+                            tools: definitions,
+                        }),
+                        propose: async () => {
+                            if (!budget) {
+                                throw new Error('Context budget is unavailable');
+                            }
+                            const historyMessages = [
+                                ...projectClaudeModelMessages(snapshot.entries),
+                                ...projectMemoryRecallMessages,
+                            ];
+                            const irreducibleMessages = [
+                                ...contextMessages,
+                                ...injectTurnContext([
+                                    ...pendingMessages,
+                                    ...preservedUserMessages.map((content) => ({
+                                        role: 'user',
+                                        content,
+                                    })),
+                                ]),
+                            ];
+                            let logicalParentUuid = compactionAnchorUuid;
+                            if (!logicalParentUuid || historyMessages.length === 0) {
+                                throw new Error('Cannot compact an empty Claude transcript');
+                            }
+                            if (findUnresolvedClaudeToolCalls(snapshot.entries).length > 0) {
+                                throw new Error('Cannot compact a Claude session with unresolved tool calls');
+                            }
+                            const preCompact = await this.runAdvisoryHook(sessionId, 'PreCompact', { trigger: 'auto', custom_instructions: null }, 'auto', signal);
+                            const memorySelection = sessionMemory
+                                ? await this.selectMemoryPreservedCompact(sessionId, selectClaudeActiveTranscript(snapshot.entries), { sessionMemoryReady: true })
+                                : null;
+                            const compactorMessages = memorySelection
+                                ? [
+                                    memorySelection.memoryMessage,
+                                    ...projectClaudeModelMessages(memorySelection.compactedEntries),
+                                ]
+                                : historyMessages;
+                            compactorMessages.push(...successfulHookOutput(preCompact).map((content) => ({
                                 role: 'user',
-                                content: formatClaudeCompactSummary(''),
-                            },
-                        ], definitions);
-                        let targetTokens = Math.min(8192, compactEnvelope.availableTokens - compactEnvelope.estimatedTokens);
-                        if (targetTokens < 1) {
-                            budget.assertFits(budget.evaluate([
+                                content: `Additional summarization context: ${content}`,
+                            })));
+                            if (memorySelection) {
+                                logicalParentUuid = memorySelection.logicalParentUuid;
+                            }
+                            this.options.eventSink?.({ type: 'state', state: 'compacting' });
+                            const compactEnvelope = budget.evaluate([
                                 ...irreducibleMessages,
                                 {
                                     role: 'user',
-                                    content: formatClaudeCompactSummary('a'),
+                                    content: formatClaudeCompactSummary(''),
                                 },
-                            ], definitions));
-                            targetTokens = 1;
-                        }
-                        const compacted = await (this.options.compactor ?? new ModelCompactor(provider)).compact({
-                            messages: compactorMessages,
-                            targetTokens,
-                            contextWindowTokens: budget.contextWindowTokens,
-                            ...(signal ? { signal } : {}),
-                        });
-                        const { durationMs: compactedDurationMs, durationWithoutRetriesMs: compactedDurationWithoutRetriesMs, } = requireCompactionDurations(compacted);
-                        const proposedCompactionDurationMs = (compactionDurationMs ?? 0) + compactedDurationMs;
-                        if (!Number.isFinite(proposedCompactionDurationMs)) {
-                            throw new TypeError('compaction durationMs total overflow');
-                        }
-                        const proposedCompactionDurationWithoutRetriesMs = (compactionDurationWithoutRetriesMs ?? 0) +
-                            compactedDurationWithoutRetriesMs;
-                        if (!Number.isFinite(proposedCompactionDurationWithoutRetriesMs)) {
-                            throw new TypeError('compaction durationWithoutRetriesMs total overflow');
-                        }
-                        const boundaryUuid = randomUUID();
-                        const summaryUuid = randomUUID();
-                        const timestamp = new Date().toISOString();
-                        const preTokens = budget.evaluate([...contextMessages, ...injectTurnContext(historyMessages)], definitions).estimatedTokens;
-                        const compactEntries = (postTokens) => {
-                            const uuids = [boundaryUuid, summaryUuid];
-                            return createClaudeCompactEntries({
+                            ], definitions);
+                            let targetTokens = Math.min(8192, compactEnvelope.availableTokens -
+                                compactEnvelope.estimatedTokens);
+                            if (targetTokens < 1) {
+                                budget.assertFits(budget.evaluate([
+                                    ...irreducibleMessages,
+                                    {
+                                        role: 'user',
+                                        content: formatClaudeCompactSummary('a'),
+                                    },
+                                ], definitions));
+                                targetTokens = 1;
+                            }
+                            const compacted = await (this.options.compactor ?? new ModelCompactor(provider)).compact({
+                                messages: compactorMessages,
+                                targetTokens,
+                                contextWindowTokens: budget.contextWindowTokens,
+                                ...(signal ? { signal } : {}),
+                            });
+                            const { durationMs: compactedDurationMs, durationWithoutRetriesMs: compactedDurationWithoutRetriesMs, } = requireCompactionDurations(compacted);
+                            const proposedCompactionDurationMs = (compactionDurationMs ?? 0) + compactedDurationMs;
+                            if (!Number.isFinite(proposedCompactionDurationMs)) {
+                                throw new TypeError('compaction durationMs total overflow');
+                            }
+                            const proposedCompactionDurationWithoutRetriesMs = (compactionDurationWithoutRetriesMs ?? 0) +
+                                compactedDurationWithoutRetriesMs;
+                            if (!Number.isFinite(proposedCompactionDurationWithoutRetriesMs)) {
+                                throw new TypeError('compaction durationWithoutRetriesMs total overflow');
+                            }
+                            const boundaryUuid = randomUUID();
+                            const summaryUuid = randomUUID();
+                            const timestamp = new Date().toISOString();
+                            const preTokens = budget.evaluate([...contextMessages, ...injectTurnContext(historyMessages)], definitions).estimatedTokens;
+                            const compactEntries = (postTokens) => {
+                                const uuids = [boundaryUuid, summaryUuid];
+                                return createClaudeCompactEntries({
+                                    sessionId,
+                                    logicalParentUuid,
+                                    summary: compacted.summary,
+                                    preTokens,
+                                    postTokens,
+                                    previousCumulativeDroppedTokens: getCumulativeDroppedTokens(snapshot.entries),
+                                    durationMs: compactedDurationMs,
+                                    cwd: this.activeCwd(),
+                                    claudeVersion: this.options.claudeVersion,
+                                    gitBranch: null,
+                                    ...(memorySelection
+                                        ? {
+                                            preservedUuids: memorySelection.preservedEntries.flatMap((entry) => typeof entry.uuid === 'string' ? [entry.uuid] : []),
+                                        }
+                                        : {}),
+                                    createUuid: () => uuids.shift() ?? randomUUID(),
+                                    now: () => timestamp,
+                                });
+                            };
+                            const provisionalEntries = compactEntries(0);
+                            const compactSummaryUuid = provisionalEntries.at(-1)?.uuid;
+                            if (typeof compactSummaryUuid !== 'string') {
+                                throw new Error('Could not create Claude compact summary');
+                            }
+                            const replayUuids = preservedUserMessages.map(() => randomUUID());
+                            const replayEntries = translateProviderEvents(preservedUserMessages.map((text, index) => index === 0
+                                ? { type: 'user-text', text }
+                                : { type: 'user-text-block', text }), {
                                 sessionId,
-                                logicalParentUuid,
-                                summary: compacted.summary,
-                                preTokens,
-                                postTokens,
-                                previousCumulativeDroppedTokens: getCumulativeDroppedTokens(snapshot.entries),
-                                durationMs: compactedDurationMs,
+                                parentUuid: compactSummaryUuid,
                                 cwd: this.activeCwd(),
                                 claudeVersion: this.options.claudeVersion,
                                 gitBranch: null,
-                                ...(memorySelection
-                                    ? {
-                                        preservedUuids: memorySelection.preservedEntries.flatMap((entry) => typeof entry.uuid === 'string' ? [entry.uuid] : []),
-                                    }
-                                    : {}),
-                                createUuid: () => uuids.shift() ?? randomUUID(),
+                                history: [...snapshot.entries, ...provisionalEntries],
+                                createUuid: () => replayUuids.shift() ?? randomUUID(),
                                 now: () => timestamp,
                             });
-                        };
-                        const provisionalEntries = compactEntries(0);
-                        const compactSummaryUuid = provisionalEntries.at(-1)?.uuid;
-                        if (typeof compactSummaryUuid !== 'string') {
-                            throw new Error('Could not create Claude compact summary');
-                        }
-                        const replayUuids = preservedUserMessages.map(() => randomUUID());
-                        const replayEntries = translateProviderEvents(preservedUserMessages.map((text, index) => index === 0
-                            ? { type: 'user-text', text }
-                            : { type: 'user-text-block', text }), {
-                            sessionId,
-                            parentUuid: compactSummaryUuid,
-                            cwd: this.activeCwd(),
-                            claudeVersion: this.options.claudeVersion,
-                            gitBranch: null,
-                            history: [...snapshot.entries, ...provisionalEntries],
-                            createUuid: () => replayUuids.shift() ?? randomUUID(),
-                            now: () => timestamp,
-                        });
-                        const compactedHistory = [
-                            ...projectClaudeModelMessages([
-                                ...snapshot.entries,
-                                ...provisionalEntries,
+                            const compactedHistory = [
+                                ...projectClaudeModelMessages([
+                                    ...snapshot.entries,
+                                    ...provisionalEntries,
+                                    ...replayEntries,
+                                ]),
+                                ...projectMemoryRecallMessages,
+                            ];
+                            const afterHistory = budget.evaluate([...contextMessages, ...injectTurnContext(compactedHistory)], definitions);
+                            const proposedMessages = [
+                                ...contextMessages,
+                                ...injectTurnContext([...compactedHistory, ...pendingMessages]),
+                            ];
+                            const entries = [
+                                ...compactEntries(afterHistory.estimatedTokens),
                                 ...replayEntries,
-                            ]),
-                            ...projectMemoryRecallMessages,
-                        ];
-                        const afterHistory = budget.evaluate([...contextMessages, ...injectTurnContext(compactedHistory)], definitions);
-                        const afterPending = budget.evaluate([
-                            ...contextMessages,
-                            ...injectTurnContext([...compactedHistory, ...pendingMessages]),
-                        ], definitions);
-                        budget.assertFits(afterPending);
-                        if (options.promptTooLong === true &&
-                            !contextRecoveryMadeProgress({
-                                beforeOccupancyTokens: predicted.occupancyTokens,
-                                afterOccupancyTokens: afterPending.occupancyTokens,
-                            })) {
-                            throw new Error('Reactive context compaction made no occupancy progress');
-                        }
-                        const entries = [
-                            ...compactEntries(afterHistory.estimatedTokens),
-                            ...replayEntries,
-                        ];
-                        if (signal?.aborted)
-                            throw new AgentRunCancelledError();
-                        // Construct the exact tracker mutations for this single committed
-                        // boundary and preflight them against a clone of the live tracker so
-                        // invalid input or cumulative overflow rejects before the compact
-                        // boundary is appended rather than after a half-commit.
-                        const tracker = this.sessionCostTrackers.get(sessionId);
-                        if (!tracker) {
-                            throw new Error(`Session cost tracker is not active for session ${sessionId}`);
-                        }
-                        const compactModel = compacted.model !== undefined && compacted.model.trim() !== ''
-                            ? compacted.model
-                            : provider.model;
-                        const compactModelNonBlank = compactModel !== undefined && compactModel.trim() !== '';
-                        if (hasNonZeroUsage(compacted.usage) && !compactModelNonBlank) {
-                            throw new Error('Auto compact usage requires a nonblank model identity');
-                        }
-                        let meteringTurnInput;
-                        if (compactModelNonBlank && hasNonZeroUsage(compacted.usage)) {
-                            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 (compactedDurationMs > 0 ||
-                            compactedDurationWithoutRetriesMs > 0) {
-                            meteringDurationsInput = {
-                                ...(compactedDurationMs === 0
-                                    ? {}
-                                    : { apiDurationMs: compactedDurationMs }),
-                                apiDurationWithoutRetriesMs: compactedDurationWithoutRetriesMs,
-                            };
-                        }
-                        if (meteringTurnInput !== undefined ||
-                            meteringDurationsInput !== undefined) {
-                            const preflight = new ClaudeSessionCostTracker({
-                                sessionId,
-                                restored: tracker.snapshot(),
-                            });
-                            if (meteringTurnInput !== undefined) {
-                                preflight.recordTurn(meteringTurnInput);
+                            ];
+                            if (signal?.aborted)
+                                throw new AgentRunCancelledError();
+                            // Construct the exact tracker mutations for this single committed
+                            // boundary and preflight them against a clone of the live tracker so
+                            // invalid input or cumulative overflow rejects before the compact
+                            // boundary is appended rather than after a half-commit.
+                            const tracker = this.sessionCostTrackers.get(sessionId);
+                            if (!tracker) {
+                                throw new Error(`Session cost tracker is not active for session ${sessionId}`);
                             }
-                            if (meteringDurationsInput !== undefined) {
-                                preflight.recordDurations(meteringDurationsInput);
+                            const compactModel = compacted.model !== undefined && compacted.model.trim() !== ''
+                                ? compacted.model
+                                : provider.model;
+                            const compactModelNonBlank = compactModel !== undefined && compactModel.trim() !== '';
+                            if (hasNonZeroUsage(compacted.usage) && !compactModelNonBlank) {
+                                throw new Error('Auto compact usage requires a nonblank model identity');
                             }
-                        }
-                        const appendResult = await lease.appendMany(snapshot.tail, entries);
-                        if (appendResult.status === 'conflict') {
-                            throw new Error(`Claude transcript append conflict: ${appendResult.reason}`);
-                        }
-                        snapshot = {
-                            entries: [...snapshot.entries, ...entries],
-                            tail: appendResult.tail,
-                        };
-                        const metadataEntries = createClaudeDurableMetadataSnapshot(snapshot.entries, sessionId);
-                        if (metadataEntries.length > 0) {
-                            const metadataAppend = await lease.appendMany(snapshot.tail, metadataEntries);
-                            if (metadataAppend.status === 'conflict') {
-                                throw new Error(`Claude metadata snapshot conflict: ${metadataAppend.reason}`);
+                            let meteringTurnInput;
+                            if (compactModelNonBlank && hasNonZeroUsage(compacted.usage)) {
+                                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 }),
+                                };
                             }
-                            snapshot = {
-                                entries: [...snapshot.entries, ...metadataEntries],
-                                tail: metadataAppend.tail,
+                            let meteringDurationsInput;
+                            if (compactedDurationMs > 0 ||
+                                compactedDurationWithoutRetriesMs > 0) {
+                                meteringDurationsInput = {
+                                    ...(compactedDurationMs === 0
+                                        ? {}
+                                        : { apiDurationMs: compactedDurationMs }),
+                                    apiDurationWithoutRetriesMs: compactedDurationWithoutRetriesMs,
+                                };
+                            }
+                            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);
+                                }
+                            }
+                            return {
+                                envelope: {
+                                    messages: proposedMessages,
+                                    tools: definitions,
+                                },
+                                commit: async () => {
+                                    if (signal?.aborted)
+                                        throw new AgentRunCancelledError();
+                                    const appendResult = await lease.appendMany(snapshot.tail, entries);
+                                    if (appendResult.status === 'conflict') {
+                                        throw new Error(`Claude transcript append conflict: ${appendResult.reason}`);
+                                    }
+                                    snapshot = {
+                                        entries: [...snapshot.entries, ...entries],
+                                        tail: appendResult.tail,
+                                    };
+                                    const metadataEntries = createClaudeDurableMetadataSnapshot(snapshot.entries, sessionId);
+                                    if (metadataEntries.length > 0) {
+                                        const metadataAppend = await lease.appendMany(snapshot.tail, metadataEntries);
+                                        if (metadataAppend.status === 'conflict') {
+                                            throw new Error(`Claude metadata snapshot conflict: ${metadataAppend.reason}`);
+                                        }
+                                        snapshot = {
+                                            entries: [...snapshot.entries, ...metadataEntries],
+                                            tail: metadataAppend.tail,
+                                        };
+                                    }
+                                    this.rememberDurableMetadata(sessionId, snapshot.entries);
+                                    await this.runAdvisoryHook(sessionId, 'PostCompact', { trigger: 'auto', compact_summary: compacted.summary }, 'auto', signal);
+                                    // The boundary is durable: mirror Claude's full-compact behavior by
+                                    // rerunning SessionStart with source compact and refreshing the
+                                    // runtime-only context so the next request retains current
+                                    // instructions, plan state, session memory, and hook context.
+                                    if (this.options.hooks) {
+                                        const outcome = await this.hookLifecycle.refresh(sessionId, hookSession, signal);
+                                        if (outcome)
+                                            await recordHookOutcome(outcome);
+                                    }
+                                    this.options.contextAssembler?.invalidate?.({
+                                        lifecycleId: sessionId,
+                                        reason: 'compact',
+                                    });
+                                    await refreshRuntimeContext();
+                                    this.options.eventSink?.({
+                                        type: 'compact-boundary',
+                                        trigger: 'auto',
+                                        preTokens,
+                                        uuid: boundaryUuid,
+                                    });
+                                    compactionAnchorUuid = compactSummaryUuid;
+                                    compactionUsage = mergeUsage(compactionUsage, compacted.usage);
+                                    compactionDurationMs = proposedCompactionDurationMs;
+                                    compactionDurationWithoutRetriesMs =
+                                        proposedCompactionDurationWithoutRetriesMs;
+                                    if (meteringTurnInput !== undefined) {
+                                        compactionModelUsage = mergeSessionRawModelUsage(compactionModelUsage, { [meteringTurnInput.model]: compacted.usage });
+                                    }
+                                    // Commit the preflighted mutations once the boundary is durable so a
+                                    // later main-provider failure or cancellation cannot lose the
+                                    // compactor's usage/cost/API durations.
+                                    if (meteringTurnInput !== undefined) {
+                                        tracker.recordTurn(meteringTurnInput);
+                                    }
+                                    if (meteringDurationsInput !== undefined) {
+                                        tracker.recordDurations(meteringDurationsInput);
+                                    }
+                                },
                             };
-                        }
-                        this.rememberDurableMetadata(sessionId, snapshot.entries);
-                        await this.runAdvisoryHook(sessionId, 'PostCompact', { trigger: 'auto', compact_summary: compacted.summary }, 'auto', signal);
-                        // The boundary is durable: mirror Claude's full-compact behavior by
-                        // rerunning SessionStart with source compact and refreshing the
-                        // runtime-only context so the next request retains current
-                        // instructions, plan state, session memory, and hook context.
-                        if (this.options.hooks) {
-                            const outcome = await this.hookLifecycle.refresh(sessionId, hookSession, signal);
-                            if (outcome)
-                                await recordHookOutcome(outcome);
-                        }
-                        this.options.contextAssembler?.invalidate?.({
-                            lifecycleId: sessionId,
-                            reason: 'compact',
-                        });
-                        this.options.projectMemoryRecall?.recordCompact(sessionId);
-                        await refreshRuntimeContext();
-                        this.options.eventSink?.({
-                            type: 'compact-boundary',
-                            trigger: 'auto',
-                            preTokens,
-                            uuid: boundaryUuid,
-                        });
-                        compactionAnchorUuid = compactSummaryUuid;
-                        compactionUsage = mergeUsage(compactionUsage, compacted.usage);
-                        compactionDurationMs = proposedCompactionDurationMs;
-                        compactionDurationWithoutRetriesMs =
-                            proposedCompactionDurationWithoutRetriesMs;
-                        if (meteringTurnInput !== undefined) {
-                            compactionModelUsage = mergeSessionRawModelUsage(compactionModelUsage, { [meteringTurnInput.model]: compacted.usage });
-                        }
-                        // Commit the preflighted mutations once the boundary is durable so a
-                        // later main-provider failure or cancellation cannot lose the
-                        // compactor's usage/cost/API durations.
-                        if (meteringTurnInput !== undefined) {
-                            tracker.recordTurn(meteringTurnInput);
-                        }
-                        if (meteringDurationsInput !== undefined) {
-                            tracker.recordDurations(meteringDurationsInput);
-                        }
-                    };
-                    await compactIfNeeded(pendingUserMessages);
+                        },
+                    });
+                    await contextEngine.prepare(contextTransitionPort(pendingUserMessages), signal);
                     for (const [index, message] of expandedMessages.entries()) {
                         if (shellCommand !== undefined)
                             break;
@@ -3936,7 +4048,7 @@ export class ClaudeSessionService {
                         });
                     }
                     if (budget) {
-                        await compactIfNeeded([], currentTurnUserMessages ?? []);
+                        await contextEngine.prepare(contextTransitionPort([], currentTurnUserMessages ?? []), signal);
                         budget.assertFits(budget.evaluate([
                             ...contextMessages,
                             ...injectTurnContext(projectClaudeModelMessages(snapshot.entries)),
@@ -3967,13 +4079,13 @@ export class ClaudeSessionService {
                             ? { deferFailureKinds: ['prompt_too_long'] }
                             : {}),
                         reloadMessages: async () => {
-                            const recalled = projectMemoryRecallTurn?.consumeIfSettled();
+                            const recalled = turnMemory.consumeRecall();
                             if (recalled) {
                                 projectMemoryRecallMessages = [
                                     { role: 'user', content: recalled.content },
                                 ];
                             }
-                            await compactIfNeeded([], currentTurnUserMessages ?? []);
+                            await contextEngine.prepare(contextTransitionPort([], currentTurnUserMessages ?? []), signal);
                             runtimeRequest.stableSystemMessageCount = stableSystemMessageCount;
                             return [
                                 ...contextMessages,
@@ -4089,24 +4201,8 @@ export class ClaudeSessionService {
                         catch (error) {
                             if (!budget || !isPromptTooLongError(error))
                                 throw error;
-                            if (recoveryPlanner.reactiveRetriesRemaining === 0) {
-                                surfaceExhaustedRecovery(error);
-                                throw error;
-                            }
-                            const beforeRecovery = budget.evaluate(runtimeRequest.messages, definitions);
-                            try {
-                                await compactIfNeeded([], currentTurnUserMessages ?? [], {
-                                    promptTooLong: true,
-                                });
-                            }
-                            catch (compactionError) {
-                                if (signal?.aborted ||
-                                    compactionError instanceof AgentRunCancelledError) {
-                                    throw new AgentRunCancelledError();
-                                }
-                                // Compaction could not free the provider-bounded context; surface
-                                // the original prompt-too-long error rather than the compaction
-                                // failure.
+                            const recovery = await contextEngine.recover(error, contextTransitionPort([], currentTurnUserMessages ?? []), signal);
+                            if (recovery.kind !== 'retry') {
                                 surfaceExhaustedRecovery(error);
                                 throw error;
                             }
@@ -4120,14 +4216,6 @@ export class ClaudeSessionService {
                                 ]),
                             ];
                             runtimeRequest.stableSystemMessageCount = stableSystemMessageCount;
-                            const afterRecovery = budget.evaluate(runtimeRequest.messages, definitions);
-                            if (recoveryPlanner.consumeReactiveRetry({
-                                beforeOccupancyTokens: beforeRecovery.occupancyTokens,
-                                afterOccupancyTokens: afterRecovery.occupancyTokens,
-                            }) !== 'reactive-retry') {
-                                surfaceExhaustedRecovery(error);
-                                throw error;
-                            }
                             runtimeRequest.deferFailureKinds = true;
                             try {
                                 result = await attemptMainTurn();
@@ -4135,7 +4223,6 @@ export class ClaudeSessionService {
                             catch (retryError) {
                                 // Exactly one reactive retry is consumed; fail deterministically
                                 // and surface the original prompt-too-long error.
-                                recoveryPlanner.recordFailure();
                                 if (signal?.aborted ||
                                     retryError instanceof AgentRunCancelledError) {
                                     throw new AgentRunCancelledError();
@@ -4160,16 +4247,6 @@ export class ClaudeSessionService {
                         }
                         throw error;
                     }
-                    recoveryPlanner.recordSuccess();
-                    const mainModel = provider.model !== undefined && provider.model.trim() !== ''
-                        ? provider.model
-                        : undefined;
-                    const observedUsage = (mainModel !== undefined
-                        ? result.modelUsage?.[mainModel]
-                        : undefined) ??
-                        Object.values(result.modelUsage ?? {})[0] ??
-                        result.usage;
-                    budget?.observeUsage(observedUsage, runtimeRequest.messages, definitions);
                     if (structuredCapture && structuredCapture.calls !== 1) {
                         throw new Error(`StructuredOutput must be called exactly once (received ${structuredCapture.calls})`);
                     }
@@ -4270,32 +4347,23 @@ export class ClaudeSessionService {
                                 : { linesRemoved: foregroundLineChanges.linesRemoved }),
                         });
                     }
-                    if (sessionMemory && finalLeafUuid) {
-                        const memorySnapshot = projectClaudeModelMessages(snapshot.entries);
-                        const providerVisibleMessages = [
-                            ...contextMessages,
-                            ...injectTurnContext(memorySnapshot),
-                        ];
-                        const currentContextTokens = budget
-                            ? budget.evaluate(providerVisibleMessages, definitions)
-                                .occupancyTokens
-                            : estimateModelRequestTokens(providerVisibleMessages, definitions);
-                        try {
-                            await sessionMemory.observeContext(currentContextTokens, currentTurnToolCalls, finalLeafUuid, memorySnapshot);
-                        }
-                        catch (error) {
-                            // A failed observation must not fail the user turn; the sidecar
-                            // retains a retryable error for the next observation.
-                            this.options.eventSink?.({
-                                type: 'warning',
-                                message: `Session memory observation failed: ${error instanceof Error ? error.message : String(error)}`,
-                            });
-                        }
-                    }
-                    this.options.projectMemoryExtraction?.observe({
-                        sessionId,
+                    const memorySnapshot = projectClaudeModelMessages(snapshot.entries);
+                    const providerVisibleMessages = [
+                        ...contextMessages,
+                        ...injectTurnContext(memorySnapshot),
+                    ];
+                    const currentContextTokens = contextEngine.report({
+                        messages: providerVisibleMessages,
+                        tools: definitions,
+                    })?.occupancyTokens ??
+                        estimateModelRequestTokens(providerVisibleMessages, definitions);
+                    await turnMemory.observeSuccess({
+                        ...(finalLeafUuid ? { messageId: finalLeafUuid } : {}),
+                        occupancyTokens: currentContextTokens,
+                        toolCalls: currentTurnToolCalls,
+                        messages: memorySnapshot,
+                        projectMessages: projectMemoryMessages(snapshot.entries),
                         directMaintenance: projectMemoryMaintained,
-                        messages: projectMemoryMessages(snapshot.entries),
                     });
                     turnCompleted = true;
                     return {
@@ -4425,11 +4493,12 @@ export class ClaudeSessionService {
      *  recent suffix. Returns null to fall back to the existing full-compaction
      *  behavior (missing/invalid watermark, empty projection, or oversized
      *  projection). */
-    async selectMemoryPreservedCompact(sessionId, activeEntries) {
+    async selectMemoryPreservedCompact(sessionId, activeEntries, options = {}) {
         const controller = this.sessionMemoryController(sessionId);
         if (controller === null)
             return null;
-        await controller.waitForCompact();
+        if (options.sessionMemoryReady !== true)
+            await controller.waitForCompact();
         let watermark = null;
         let memorySummary = '';
         try {
@@ -5061,12 +5130,37 @@ export class ClaudeSessionService {
             return 'corrupt';
         return this.schema.writeMode === 'read-write' ? 'ready' : 'read-only';
     }
+    nativeSessionStatus(issue, entryCount) {
+        if (issue?.kind === 'unsupported-version')
+            return 'read-only';
+        if (entryCount === 0 || issue)
+            return 'corrupt';
+        return 'read-only';
+    }
+    claudeSessionSummary(sessionId, index) {
+        const metadata = reduceClaudeSessionMetadata(index.entries, sessionId);
+        return {
+            sessionId,
+            ...sessionMetadataFields(metadata, { agentNameFallback: true }),
+            lastPrompt: metadata.lastPrompt ?? null,
+            updatedAt: index.updatedAt,
+            status: this.sessionStatus(index.issue, index.entries.length),
+            issue: index.issue,
+        };
+    }
     provider() {
         if (!this.options.provider) {
             throw new Error('A model provider is required for run and resume');
         }
         return this.options.provider;
     }
+    async assertNativeWriteTargetIsLegacy(sessionId) {
+        if (this.options.dataPlane !== 'native')
+            return;
+        const existing = await readNativeTranscript(this.paths(sessionId).sessionFile);
+        if (existing.format === 'native')
+            throw new Error('native transcript is read-only until native writes are enabled');
+    }
     model() {
         return this.activeProvider?.model ?? this.options.provider?.model;
     }
@@ -5124,7 +5218,7 @@ export class ClaudeSessionService {
         return this.sessionMemoryProviderFactory() !== null;
     }
     sessionMemoryController(sessionId) {
-        if (!this.sessionMemoryEnabled() || !isClaudeSessionId(sessionId)) {
+        if (!this.sessionMemoryEnabled() || !isSessionId(sessionId)) {
             return null;
         }
         let controller = this.sessionMemoryControllers.get(sessionId);