praxis-agent 0.35.0 → 0.37.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,14 +23,21 @@ 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, unresolvedActiveToolCallIds, } from './transcript-projection.js';
 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 { SubagentLifecycleStore } from '../persistence/subagent-lifecycle-store.js';
 import { ModelCompactor } from './model-compactor.js';
 import { agentMemoryPrompt, ClaudeSubagentExecutor, StructuredOutputRegistry, } from './subagent-service.js';
@@ -49,6 +56,7 @@ import { FilteredToolRegistry } from '../tools/filtered-tool-registry.js';
 import { ClaudeCapabilityToolRegistry, resolveClaudeToolCapabilities, } from '../tools/claude-capabilities.js';
 import { generateToolUseSummary } from './tool-use-summary.js';
 import { ClaudeUserMessageToolRegistry, } from '../tools/claude-user-message.js';
+import { DurableFollowUpTracker } from './durable-follow-up.js';
 function agentPermissionMode(mode) {
     return mode === undefined || mode === 'manual' ? 'default' : mode;
 }
@@ -78,6 +86,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' }),
@@ -671,10 +715,13 @@ export class ClaudeSessionService {
     sessionMemoryControllers = new Map();
     resolvedSessionMemoryProvider;
     hookLifecycle;
+    leadOperations;
     fileChangeWatcher;
     runtimeCwd;
     constructor(options) {
         this.options = options;
+        this.assertNativeTranscriptOptions();
+        this.leadOperations = options.teamLeadOperations ?? null;
         this.hookLifecycle = new HookLifecycle(options.hooks, options.eventSink);
         this.runtimeCwd = options.workspace?.cwd() ?? options.cwd;
         this.fileChangeWatcher = options.hooks
@@ -901,6 +948,7 @@ export class ClaudeSessionService {
         await this.closeCostSavePromise;
         this.mcpClosePromise ??= this.options.mcp?.close?.() ?? Promise.resolve();
         await this.mcpClosePromise;
+        await this.leadOperations?.close();
     }
     async transitionHookSession(sessionId, reason) {
         await this.hookLifecycle.transition(sessionId, reason);
@@ -1078,6 +1126,9 @@ export class ClaudeSessionService {
                         throw new Error('A model provider is required to execute hosted Agent tools');
                     })(),
                 persistence: this.options.sessionPersistence === false ? 'memory' : 'disk',
+                ...(this.options.experimentalNativeTranscriptWrites === true
+                    ? { experimentalNativeTranscriptWrites: true }
+                    : {}),
                 ...(this.options.providerForModel
                     ? { providerForModel: this.options.providerForModel }
                     : {}),
@@ -1179,7 +1230,9 @@ export class ClaudeSessionService {
         const interactiveRegistry = this.options.interactiveTools
             ? this.options.interactiveTools.registry(messageRegistry, sessionId)
             : messageRegistry;
-        const capabilityRegistry = new ClaudeCapabilityToolRegistry(interactiveRegistry, capabilities);
+        const teamToolNames = this.capabilityToolNames(this.options.teamToolNames, capabilities);
+        const teamRegistry = this.teamRegistry(interactiveRegistry, sessionId, teamToolNames);
+        const capabilityRegistry = new ClaudeCapabilityToolRegistry(teamRegistry, capabilities);
         const preferredOrder = [
             'Agent',
             'AskUserQuestion',
@@ -1212,6 +1265,11 @@ export class ClaudeSessionService {
             'ScheduleWakeup',
             'Monitor',
             'PushNotification',
+            'TeamCreate',
+            'TeamResume',
+            'TeamList',
+            'TeamAccept',
+            'TeamStop',
         ];
         const hostedRegistry = {
             definitions: () => {
@@ -1554,19 +1612,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 +1682,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)
+                if (isSessionCandidateError(error))
                     return null;
-                if (['ENOENT', 'ENOTDIR', 'ELOOP'].includes(error.code ?? '')) {
-                    return null;
-                }
                 throw error;
             }
         });
@@ -1631,6 +1697,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 +1742,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 +1754,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 +1763,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 +1780,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 +1827,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 +1848,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();
@@ -1804,6 +1883,25 @@ export class ClaudeSessionService {
     }
     async interruption(sessionId) {
         this.assertSessionPersistence();
+        if (this.options.dataPlane === 'native') {
+            const sessionPaths = this.paths(sessionId);
+            const nativeTranscript = new NativeSessionTranscript({
+                sessionId,
+                store: new NativeTranscriptStore({
+                    transcriptFile: sessionPaths.sessionFile,
+                    lockFile: join(sessionPaths.praxisRoot, 'locks', `${sessionId}.lock`),
+                }),
+            });
+            return nativeTranscript.withLease({ kind: 'resume' }, async (lease) => {
+                const interruption = lease.interruption();
+                if (interruption.kind === 'recoverable-tools' ||
+                    interruption.kind === 'indeterminate-tools')
+                    return { kind: 'interrupted-turn' };
+                if (interruption.kind === 'interrupted-prompt')
+                    return { kind: 'interrupted-prompt', prompt: interruption.prompt };
+                return { kind: interruption.kind };
+            });
+        }
         await this.discoverProjectRoot(sessionId);
         const snapshot = await this.store(sessionId).loadReadOnly();
         if (snapshot.entries.length === 0) {
@@ -2163,6 +2261,97 @@ export class ClaudeSessionService {
         return { resumeSessionAt, entryCount: result.value.entries.length };
     }
     async compact(sessionId, signal, selection) {
+        if (this.nativeTranscriptWritesEnabled()) {
+            if (selection)
+                throw new Error('Native compaction supports only the full active branch');
+            this.assertSessionPersistence();
+            const provider = this.provider();
+            await this.activateSessionCostTracker(sessionId);
+            const sessionPaths = this.paths(sessionId);
+            const nativeTranscript = new NativeSessionTranscript({
+                sessionId,
+                store: new NativeTranscriptStore({
+                    transcriptFile: sessionPaths.sessionFile,
+                    lockFile: join(sessionPaths.praxisRoot, 'locks', `${sessionId}.lock`),
+                }),
+            });
+            return nativeTranscript.withLease({ kind: 'resume' }, async (lease) => {
+                const messages = lease.activeMessages();
+                if (messages.length === 0)
+                    throw new Error('Cannot compact an empty native transcript');
+                const preTokens = estimateModelRequestTokens(messages);
+                this.options.eventSink?.({ type: 'state', state: 'compacting' });
+                const contextWindowTokens = this.contextBudget(provider)?.contextWindowTokens ??
+                    provider.capabilities.contextWindowTokens ??
+                    200_000;
+                const compacted = await (this.options.compactor ?? new ModelCompactor(provider)).compact({
+                    messages,
+                    targetTokens: Math.min(8192, Math.max(1, Math.floor(contextWindowTokens / 4))),
+                    contextWindowTokens,
+                    ...(signal ? { signal } : {}),
+                });
+                if (signal?.aborted)
+                    throw new AgentRunCancelledError();
+                const { durationMs, durationWithoutRetriesMs } = requireCompactionDurations(compacted);
+                requireManualCompactUsage(compacted.usage);
+                const compactModel = compacted.model !== undefined && compacted.model.trim() !== ''
+                    ? compacted.model
+                    : provider.model;
+                const meaningfulMetering = compacted.summary.trim().length > 0 &&
+                    (hasNonZeroUsage(compacted.usage) || durationMs > 0);
+                if (meaningfulMetering &&
+                    (compactModel === undefined || compactModel.trim() === ''))
+                    throw new Error('Manual 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 (meaningfulMetering &&
+                    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 }),
+                        apiDurationMs: durationMs,
+                        apiDurationWithoutRetriesMs: durationWithoutRetriesMs,
+                    };
+                    const preflight = new ClaudeSessionCostTracker({
+                        sessionId,
+                        restored: tracker.snapshot(),
+                    });
+                    preflight.recordTurn(meteringTurnInput);
+                }
+                const postTokens = estimateModelRequestTokens([
+                    { role: 'user', content: compacted.summary },
+                ]);
+                if (signal?.aborted)
+                    throw new AgentRunCancelledError();
+                const ids = await lease.appendCompaction({
+                    summary: compacted.summary,
+                    trigger: 'manual',
+                    preTokens,
+                    postTokens,
+                    durationMs,
+                });
+                if (meteringTurnInput !== undefined)
+                    tracker.recordTurn(meteringTurnInput);
+                this.options.eventSink?.({
+                    type: 'compact-boundary',
+                    trigger: 'manual',
+                    preTokens,
+                    uuid: ids.boundaryId,
+                });
+                return { summary: compacted.summary, usage: compacted.usage, preTokens };
+            });
+        }
         this.assertWritable();
         const provider = this.provider();
         const result = await this.turnStore(sessionId).withLease(async (lease) => {
@@ -2370,7 +2559,38 @@ export class ClaudeSessionService {
         return result.value;
     }
     async fork(parentSessionId, sessionId = randomUUID(), resumeSessionAt) {
+        if (this.nativeTranscriptWritesEnabled()) {
+            this.assertSessionPersistence();
+            const sourcePaths = this.paths(parentSessionId);
+            const targetPaths = this.paths(sessionId);
+            const source = new NativeSessionTranscript({
+                sessionId: parentSessionId,
+                store: new NativeTranscriptStore({
+                    transcriptFile: sourcePaths.sessionFile,
+                    lockFile: join(sourcePaths.praxisRoot, 'locks', `${parentSessionId}.lock`),
+                }),
+            });
+            const target = new NativeSessionTranscript({
+                sessionId,
+                store: new NativeTranscriptStore({
+                    transcriptFile: targetPaths.sessionFile,
+                    lockFile: join(targetPaths.praxisRoot, 'locks', `${sessionId}.lock`),
+                }),
+            });
+            await source.forkTo(target, {
+                ...(resumeSessionAt === undefined
+                    ? {}
+                    : { atEventId: resumeSessionAt }),
+                ensureExisting: false,
+            });
+            this.options.contextAssembler?.invalidate?.({
+                lifecycleId: sessionId,
+                reason: 'fork',
+            });
+            return { sessionId, parentSessionId };
+        }
         this.assertSessionPersistence();
+        await this.assertNativeWriteTargetIsLegacy(parentSessionId);
         this.assertWritable();
         const entries = await this.nativeForkEntries(parentSessionId, sessionId, resumeSessionAt);
         const result = await this.store(sessionId).create(entries);
@@ -2384,6 +2604,39 @@ export class ClaudeSessionService {
         return { sessionId, parentSessionId };
     }
     async ensureFork(parentSessionId, sessionId, checkpoint) {
+        if (this.nativeTranscriptWritesEnabled()) {
+            this.assertSessionPersistence();
+            const sourcePaths = this.paths(parentSessionId);
+            const targetPaths = this.paths(sessionId);
+            const source = new NativeSessionTranscript({
+                sessionId: parentSessionId,
+                store: new NativeTranscriptStore({
+                    transcriptFile: sourcePaths.sessionFile,
+                    lockFile: join(sourcePaths.praxisRoot, 'locks', `${parentSessionId}.lock`),
+                }),
+            });
+            const target = new NativeSessionTranscript({
+                sessionId,
+                store: new NativeTranscriptStore({
+                    transcriptFile: targetPaths.sessionFile,
+                    lockFile: join(targetPaths.praxisRoot, 'locks', `${sessionId}.lock`),
+                }),
+            });
+            await source.forkTo(target, {
+                ...(checkpoint?.resumeSessionAt === undefined
+                    ? {}
+                    : { atEventId: checkpoint.resumeSessionAt }),
+                ...(checkpoint?.entryCount === undefined
+                    ? {}
+                    : { recordCount: checkpoint.entryCount }),
+                ensureExisting: true,
+            });
+            this.options.contextAssembler?.invalidate?.({
+                lifecycleId: sessionId,
+                reason: 'fork',
+            });
+            return { sessionId, parentSessionId };
+        }
         this.assertSessionPersistence();
         this.assertWritable();
         const expected = await this.nativeForkEntries(parentSessionId, sessionId, checkpoint?.resumeSessionAt, checkpoint?.entryCount);
@@ -2701,7 +2954,12 @@ export class ClaudeSessionService {
         const skipUserPrompt = submission.kind === 'retry';
         const controller = new TurnTerminalController(this.options.eventSink ?? (() => undefined));
         try {
-            this.assertWritable();
+            if (this.nativeTranscriptWritesEnabled() && name !== undefined) {
+                throw new Error('experimental native session names are not enabled');
+            }
+            if (requireExisting)
+                await this.assertNativeWriteTargetIsLegacy(sessionId);
+            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) {
@@ -2711,7 +2969,8 @@ export class ClaudeSessionService {
                 throw new Error('Shell command must not be empty');
             }
             await this.activateSessionCostTracker(sessionId);
-            if (this.options.sessionPersistence !== false) {
+            if (this.options.sessionPersistence !== false &&
+                !this.nativeTranscriptWritesEnabled()) {
                 this.durableMetadataSessions.add(sessionId);
             }
             await this.ensureFileResources(sessionId, signal);
@@ -2730,9 +2989,13 @@ export class ClaudeSessionService {
             }
             const sessionPaths = this.paths(sessionId);
             const toolResultDirectory = join(sessionPaths.projectRoot, sessionId, 'tool-results');
-            const store = this.turnStore(sessionId);
-            const leaseResult = await store.withLease(async (lease) => {
-                if (!requireExisting) {
+            const runUnderLease = async (lease, nativeLease) => {
+                const rememberDurableMetadata = (observed) => {
+                    if (!nativeLease)
+                        this.rememberDurableMetadata(sessionId, observed);
+                };
+                const store = nativeLease ? undefined : this.turnStore(sessionId);
+                if (store && !requireExisting) {
                     const initialization = name === undefined
                         ? await store.reserve()
                         : await store.create(this.sessionNameEntries(sessionId, name));
@@ -2741,8 +3004,21 @@ export class ClaudeSessionService {
                     }
                 }
                 let snapshot = await lease.load();
+                const activeTurnMessages = () => nativeLease
+                    ? nativeLease.activeMessages()
+                    : projectClaudeModelMessages(snapshot.entries);
+                const nativeInterruption = nativeLease?.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 &&
+                    (nativeInterruption?.kind === 'interrupted-prompt' ||
+                        nativeInterruption?.kind === 'interrupted-turn');
+                const shouldSkipUserPrompt = () => skipUserPrompt || nativeResumeInterrupted;
                 let automaticReplayPrompt;
-                if (requireExisting &&
+                if (store &&
+                    !nativeLease &&
+                    requireExisting &&
                     this.options.sessionPersistence === false &&
                     snapshot.entries.length === 0) {
                     const persisted = await this.store(sessionId).load();
@@ -2752,17 +3028,18 @@ export class ClaudeSessionService {
                             snapshot = await lease.load();
                     }
                 }
-                if (requireExisting && snapshot.entries.length === 0) {
+                if (!nativeLease && requireExisting && snapshot.entries.length === 0) {
                     throw new Error(`Claude session not found: ${sessionId}`);
                 }
-                this.rememberDurableMetadata(sessionId, snapshot.entries);
-                if (resumeSessionAt !== undefined) {
+                rememberDurableMetadata(snapshot.entries);
+                if (!nativeLease && resumeSessionAt !== undefined) {
                     snapshot = {
                         entries: selectClaudeTranscriptAtMessage(snapshot.entries, resumeSessionAt),
                         tail: { ...snapshot.tail, branchParentUuid: resumeSessionAt },
                     };
                 }
-                else if (this.explicitResumeLeafUuids.has(sessionId)) {
+                else if (!nativeLease &&
+                    this.explicitResumeLeafUuids.has(sessionId)) {
                     const selected = selectClaudeTranscriptFromNewestLeaf(snapshot.entries);
                     this.explicitResumeLeafUuids.set(sessionId, selected.leafUuid);
                     snapshot = {
@@ -2774,7 +3051,7 @@ export class ClaudeSessionService {
                     resumeSessionAt === undefined &&
                     this.options.resumeInterruptedTurn === true &&
                     shellCommand === undefined &&
-                    !skipUserPrompt &&
+                    !shouldSkipUserPrompt() &&
                     !(this.options.approveRecovery !== undefined &&
                         findUnresolvedClaudeToolCalls(snapshot.entries).length > 0)) {
                     const interruption = classifyClaudeInterruption(snapshot.entries);
@@ -2804,7 +3081,7 @@ export class ClaudeSessionService {
                         entries: [...snapshot.entries, stateEntry],
                         tail: stateTail,
                     };
-                    this.rememberDurableMetadata(sessionId, snapshot.entries);
+                    rememberDurableMetadata(snapshot.entries);
                 }
                 this.restoreWorktree(snapshot.entries);
                 this.options.interactiveTools?.restore(sessionId, snapshot.entries);
@@ -2820,7 +3097,7 @@ export class ClaudeSessionService {
                         entries: [...snapshot.entries, ...entries],
                         tail: appendResult.tail,
                     };
-                    this.rememberDurableMetadata(sessionId, snapshot.entries);
+                    rememberDurableMetadata(snapshot.entries);
                 }
                 const agentName = this.options.agent ?? getClaudeAgentSetting(snapshot.entries);
                 const agent = this.resolveAgent(agentName);
@@ -2828,20 +3105,31 @@ export class ClaudeSessionService {
                 this.activeProvider = provider;
                 const effectivePrompt = automaticReplayPrompt ??
                     (!requireExisting &&
-                        !skipUserPrompt &&
+                        !shouldSkipUserPrompt() &&
                         !this.options.agentInitialPromptHandledExternally &&
                         shellCommand === undefined &&
                         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 (!shouldSkipUserPrompt() && 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'}`);
@@ -2856,7 +3144,11 @@ export class ClaudeSessionService {
                         ...(this.options.fileRewindRoots ?? []),
                     ])
                     : null;
-                const unresolvedToolCalls = findUnresolvedClaudeToolCalls(snapshot.entries);
+                const unresolvedToolCalls = nativeLease
+                    ? nativeInterruption?.kind === 'recoverable-tools'
+                        ? [...nativeInterruption.calls]
+                        : []
+                    : findUnresolvedClaudeToolCalls(snapshot.entries);
                 const pendingRecoveryToolCallIds = new Set(unresolvedToolCalls.map((call) => call.id));
                 const pendingRecoveryHookOutcomes = [];
                 const currentHookCwd = () => this.activeCwd();
@@ -2986,6 +3278,9 @@ export class ClaudeSessionService {
                         claudeVersion: this.options.claudeVersion,
                         provider,
                         persistence: this.options.sessionPersistence === false ? 'memory' : 'disk',
+                        ...(this.options.experimentalNativeTranscriptWrites === true
+                            ? { experimentalNativeTranscriptWrites: true }
+                            : {}),
                         ...(this.options.providerForModel
                             ? { providerForModel: this.options.providerForModel }
                             : {}),
@@ -3146,7 +3441,7 @@ export class ClaudeSessionService {
                     }
                     : interactiveMessageTools;
                 const capabilityTools = fileHistoryTools
-                    ? new ClaudeCapabilityToolRegistry(fileHistoryTools, capabilities)
+                    ? new ClaudeCapabilityToolRegistry(this.teamRegistry(fileHistoryTools, sessionId, this.capabilityToolNames(this.options.teamToolNames, capabilities)), capabilities)
                     : undefined;
                 const structuredCapture = this.options.structuredOutputSchema
                     ? { calls: 0, value: undefined }
@@ -3206,7 +3501,19 @@ export class ClaudeSessionService {
                 let currentTurnToolCalls = 0;
                 let projectMemoryMaintained = false;
                 let projectMemoryRecallMessages = [];
+                let observeModelRequestUsage = () => undefined;
+                const durableFollowUps = new DurableFollowUpTracker();
                 const observer = {
+                    ...(nativeLease
+                        ? {
+                            toolExecutionStarted: async (call) => {
+                                await nativeLease.beginToolExecution(call.id);
+                            },
+                        }
+                        : {}),
+                    modelRequestCompleted: async (input) => {
+                        observeModelRequestUsage(input);
+                    },
                     assistantCompleted: async (message) => {
                         const [entry] = translateProviderEvents([
                             {
@@ -3224,8 +3531,25 @@ export class ClaudeSessionService {
                             throw new Error('Could not translate assistant response');
                         const tail = await this.append(lease, snapshot.tail, entry);
                         snapshot = { entries: [...snapshot.entries, entry], tail };
-                        lastAssistantUuid =
-                            typeof entry.uuid === 'string' ? entry.uuid : lastAssistantUuid;
+                        lastAssistantUuid = nativeLease
+                            ? await nativeLease.appendMessages({
+                                messages: [
+                                    {
+                                        role: 'assistant',
+                                        content: message.content,
+                                        ...(message.thinkingBlocks?.length
+                                            ? { thinkingBlocks: message.thinkingBlocks }
+                                            : {}),
+                                        ...(message.toolCalls?.length
+                                            ? { toolCalls: message.toolCalls }
+                                            : {}),
+                                    },
+                                ],
+                                model: provider.model ?? 'praxis/provider',
+                            })
+                            : typeof entry.uuid === 'string'
+                                ? entry.uuid
+                                : lastAssistantUuid;
                     },
                     toolCompleted: async (call, toolResult) => {
                         currentTurnToolCalls += 1;
@@ -3259,31 +3583,42 @@ export class ClaudeSessionService {
                                 tail: modeTail,
                             };
                         }
-                        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 };
+                        if (nativeLease) {
+                            await nativeLease.appendToolCompletion({
+                                callId: call.id,
+                                result: toolResult,
+                                ...(toolResult.followUpUserMessages === undefined
+                                    ? {}
+                                    : { followUpUserMessages: toolResult.followUpUserMessages }),
+                            });
+                        }
+                        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 };
+                        }
                         if (!toolResult.isError && this.options.projectMemoryDirectory) {
                             const pathValue = call.input.file_path;
                             const path = typeof pathValue === 'string'
@@ -3292,7 +3627,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 +3637,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);
                                     }
                                 }
                             }
@@ -3354,6 +3689,7 @@ export class ClaudeSessionService {
                             currentTurnUserMessages?.push(content);
                             await Promise.all(this.sessionSubagentExecutors(sessionId, true).map((executor) => executor.acknowledgeNotifications([content])));
                         }
+                        await durableFollowUps.followUpUserMessagesCompleted(messages);
                     },
                 };
                 let turnCompleted = false;
@@ -3366,7 +3702,7 @@ export class ClaudeSessionService {
                     const recoveryRequest = {
                         cwd: this.activeCwd(),
                         toolResultDirectory,
-                        messages: projectClaudeModelMessages(snapshot.entries),
+                        messages: activeTurnMessages(),
                         observer,
                         permissionUpdates: this.sessionPermissionUpdates.get(sessionId) ?? [],
                         onPermissionUpdates: (updates) => this.applyPermissionUpdates(sessionId, updates),
@@ -3408,7 +3744,6 @@ export class ClaudeSessionService {
                             tail: settingTail,
                         };
                     }
-                    const sessionMemory = this.sessionMemoryController(sessionId);
                     let agentSystem = null;
                     let planModeMessage;
                     let sessionMemoryMessage = null;
@@ -3422,9 +3757,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,
@@ -3448,7 +3781,7 @@ export class ClaudeSessionService {
                         contextMessages = [...contextProjection.systemMessages];
                     };
                     await refreshRuntimeContext();
-                    const expansion = skipUserPrompt
+                    const expansion = shouldSkipUserPrompt()
                         ? { userMessages: [] }
                         : shellCommand === undefined
                             ? this.options.extensions
@@ -3479,7 +3812,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,
@@ -3499,7 +3842,7 @@ export class ClaudeSessionService {
                             ? { documents }
                             : {}),
                     }));
-                    const agentMentionMessages = shellCommand === undefined && !skipUserPrompt
+                    const agentMentionMessages = shellCommand === undefined && !shouldSkipUserPrompt()
                         ? (this.options.extensions?.agentMentionMessages(effectivePrompt) ?? [])
                         : [];
                     const injectAgentMentionContext = (messages) => {
@@ -3531,276 +3874,445 @@ 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) => ({
+                    const contextTransitionPort = (pendingMessages = [], preservedUserMessages = []) => ({
+                        current: () => {
+                            const historyMessages = [
+                                ...activeTurnMessages(),
+                                ...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 (nativeLease) {
+                                if (!budget)
+                                    throw new Error('Context budget is unavailable');
+                                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');
+                                let compactableMessages = historyMessages;
+                                let preservedMessages = [];
+                                if (preservedUserMessages.length > 0) {
+                                    let searchFrom = historyMessages.length;
+                                    const matchedIndexes = [];
+                                    for (let markerIndex = preservedUserMessages.length - 1; markerIndex >= 0; markerIndex -= 1) {
+                                        const marker = preservedUserMessages[markerIndex];
+                                        let found = -1;
+                                        for (let index = searchFrom - 1; index >= 0; index -= 1) {
+                                            const message = historyMessages[index];
+                                            if (message?.role === 'user' &&
+                                                message.content === marker) {
+                                                found = index;
+                                                break;
+                                            }
+                                        }
+                                        if (found < 0)
+                                            throw new Error('Native automatic compaction could not match the current-turn suffix');
+                                        matchedIndexes.push(found);
+                                        searchFrom = found;
+                                    }
+                                    const earliest = Math.min(...matchedIndexes);
+                                    compactableMessages = historyMessages.slice(0, earliest);
+                                    preservedMessages = historyMessages.slice(earliest);
+                                }
+                                if (compactableMessages.length === 0)
+                                    throw new Error('Cannot compact native transcript: no compactable prefix');
+                                const preTokens = estimateModelRequestTokens(compactableMessages);
+                                const compacted = await (this.options.compactor ?? new ModelCompactor(provider)).compact({
+                                    messages: compactableMessages,
+                                    targetTokens: Math.min(8192, Math.max(1, Math.floor(budget.contextWindowTokens / 4))),
+                                    contextWindowTokens: budget.contextWindowTokens,
+                                    ...(signal ? { signal } : {}),
+                                });
+                                const { durationMs, durationWithoutRetriesMs } = requireCompactionDurations(compacted);
+                                if (signal?.aborted)
+                                    throw new AgentRunCancelledError();
+                                const postTokens = estimateModelRequestTokens([
+                                    { role: 'user', content: compacted.summary },
+                                    ...preservedMessages,
+                                ]);
+                                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 summaryMessage = {
                                     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,
-                            {
+                                    content: compacted.summary,
+                                };
+                                const proposedMessages = [
+                                    ...contextMessages,
+                                    ...injectTurnContext([
+                                        summaryMessage,
+                                        ...preservedMessages,
+                                        ...pendingMessages,
+                                    ]),
+                                ];
+                                return {
+                                    envelope: { messages: proposedMessages, tools: definitions },
+                                    commit: async () => {
+                                        if (signal?.aborted)
+                                            throw new AgentRunCancelledError();
+                                        const ids = await nativeLease.appendCompaction({
+                                            summary: compacted.summary,
+                                            trigger: 'auto',
+                                            preTokens,
+                                            postTokens,
+                                            durationMs,
+                                            preservedMessages,
+                                        });
+                                        this.options.eventSink?.({
+                                            type: 'compact-boundary',
+                                            trigger: 'auto',
+                                            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);
+                                    },
+                                };
+                            }
+                            if (!budget) {
+                                throw new Error('Context budget is unavailable');
+                            }
+                            const historyMessages = [
+                                ...activeTurnMessages(),
+                                ...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,
+                                        };
+                                    }
+                                    rememberDurableMetadata(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;
@@ -3834,6 +4346,20 @@ export class ClaudeSessionService {
                             entries: [...snapshot.entries, userEntry],
                             tail: userTail,
                         };
+                        if (nativeLease) {
+                            await nativeLease.appendMessages({
+                                messages: [
+                                    {
+                                        role: 'user',
+                                        content: message.text,
+                                        ...(messageImages.length ? { images: messageImages } : {}),
+                                        ...(index === attachmentIndex && documents.length > 0
+                                            ? { documents }
+                                            : {}),
+                                    },
+                                ],
+                            });
+                        }
                     }
                     if (fileHistory && currentPromptId) {
                         const historySnapshot = await fileHistory.snapshot(snapshot.entries, currentPromptId);
@@ -3843,7 +4369,7 @@ export class ClaudeSessionService {
                             tail: historyTail,
                         };
                     }
-                    if (this.options.hooks && !skipUserPrompt) {
+                    if (this.options.hooks && !shouldSkipUserPrompt()) {
                         const outcome = await this.options.hooks.run({
                             ...hookSession,
                             hook_event_name: 'UserPromptSubmit',
@@ -3874,7 +4400,7 @@ export class ClaudeSessionService {
                                 cwd: this.activeCwd(),
                                 sessionId,
                                 toolResultDirectory,
-                                messages: projectClaudeModelMessages(snapshot.entries),
+                                messages: activeTurnMessages(),
                                 observer: {
                                     assistantCompleted: async () => undefined,
                                     toolCompleted: async () => undefined,
@@ -3926,6 +4452,20 @@ export class ClaudeSessionService {
                             entries: [...snapshot.entries, inputEntry, outputEntry],
                             tail: shellAppend.tail,
                         };
+                        if (nativeLease) {
+                            await nativeLease.appendMessages({
+                                messages: [
+                                    {
+                                        role: 'user',
+                                        content: `<bash-input>${shellCommand}</bash-input>`,
+                                    },
+                                    {
+                                        role: 'user',
+                                        content: `<bash-stdout>${stdout}</bash-stdout><bash-stderr>${stderr}</bash-stderr>`,
+                                    },
+                                ],
+                            });
+                        }
                         currentTurnUserMessages.push(`<bash-stdout>${stdout}</bash-stdout><bash-stderr>${stderr}</bash-stderr>`);
                         this.options.eventSink?.({
                             type: 'shell-result',
@@ -3936,10 +4476,10 @@ export class ClaudeSessionService {
                         });
                     }
                     if (budget) {
-                        await compactIfNeeded([], currentTurnUserMessages ?? []);
+                        await contextEngine.prepare(contextTransitionPort([], currentTurnUserMessages ?? []), signal);
                         budget.assertFits(budget.evaluate([
                             ...contextMessages,
-                            ...injectTurnContext(projectClaudeModelMessages(snapshot.entries)),
+                            ...injectTurnContext(activeTurnMessages()),
                         ], definitions));
                     }
                     let stopHookActive = false;
@@ -3947,7 +4487,7 @@ export class ClaudeSessionService {
                         sessionId,
                         messages: [
                             ...contextMessages,
-                            ...injectTurnContext(projectClaudeModelMessages(snapshot.entries)),
+                            ...injectTurnContext(activeTurnMessages()),
                         ],
                         stableSystemMessageCount,
                         cwd: this.activeCwd(),
@@ -3967,18 +4507,18 @@ 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,
                                 ...injectTurnContext([
-                                    ...projectClaudeModelMessages(snapshot.entries),
+                                    ...activeTurnMessages(),
                                     ...projectMemoryRecallMessages,
                                 ]),
                             ];
@@ -3987,10 +4527,16 @@ export class ClaudeSessionService {
                             subagentExecutor ||
                             taskTools ||
                             this.scheduledPrompts ||
-                            this.workflowManager
+                            this.workflowManager ||
+                            this.leadOperations
                             ? {
                                 onStop: async (text) => {
                                     const messages = [];
+                                    const teamInbox = await this.leadOperations?.projectInbox(sessionId);
+                                    if (teamInbox) {
+                                        durableFollowUps.register(teamInbox);
+                                        messages.push(...teamInbox.messages);
+                                    }
                                     const outcome = await this.options.hooks?.run({
                                         ...hookSession,
                                         hook_event_name: 'Stop',
@@ -4089,24 +4635,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;
                             }
@@ -4115,19 +4645,11 @@ export class ClaudeSessionService {
                             runtimeRequest.messages = [
                                 ...contextMessages,
                                 ...injectTurnContext([
-                                    ...projectClaudeModelMessages(snapshot.entries),
+                                    ...activeTurnMessages(),
                                     ...projectMemoryRecallMessages,
                                 ]),
                             ];
                             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 +4657,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 +4681,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})`);
                     }
@@ -4177,7 +4688,7 @@ export class ClaudeSessionService {
                     if (!finalLeafUuid) {
                         throw new Error('Could not locate final assistant response');
                     }
-                    if (!skipUserPrompt) {
+                    if (!nativeLease && !skipUserPrompt) {
                         const lastPrompt = createClaudeLastPromptEntry({
                             sessionId,
                             lastPrompt: effectivePrompt,
@@ -4189,7 +4700,7 @@ export class ClaudeSessionService {
                             tail,
                         };
                     }
-                    this.rememberDurableMetadata(sessionId, snapshot.entries);
+                    rememberDurableMetadata(snapshot.entries);
                     const totalUsage = mergeUsage(mergeUsage(mergeUsage(recoveryUsage, compactionUsage), shellUsage), result.usage);
                     const tracker = this.sessionCostTrackers.get(sessionId);
                     if (!tracker) {
@@ -4270,32 +4781,25 @@ 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 = activeTurnMessages();
+                    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: nativeLease
+                            ? []
+                            : projectMemoryMessages(snapshot.entries),
                         directMaintenance: projectMemoryMaintained,
-                        messages: projectMemoryMessages(snapshot.entries),
                     });
                     turnCompleted = true;
                     return {
@@ -4319,11 +4823,39 @@ export class ClaudeSessionService {
                         await this.hookLifecycle.end(sessionId, 'other');
                     }
                 }
-            });
-            if (leaseResult.status === 'conflict') {
-                throw new Error(`Claude transcript append conflict: ${leaseResult.reason}`);
+            };
+            let result;
+            if (this.nativeTranscriptWritesEnabled()) {
+                const nativeStore = new NativeTranscriptStore({
+                    transcriptFile: sessionPaths.sessionFile,
+                    lockFile: join(sessionPaths.praxisRoot, 'locks', `${sessionId}.lock`),
+                });
+                const nativeTranscript = new NativeSessionTranscript({
+                    sessionId,
+                    store: nativeStore,
+                });
+                const activationKind = requireExisting
+                    ? resumeSessionAt === undefined
+                        ? { kind: 'resume' }
+                        : { 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;
+                });
+            }
+            else {
+                const store = this.turnStore(sessionId);
+                const leaseResult = await store.withLease((lease) => runUnderLease(lease));
+                if (leaseResult.status === 'conflict') {
+                    throw new Error(`Claude transcript append conflict: ${leaseResult.reason}`);
+                }
+                result = leaseResult.value;
             }
-            const result = leaseResult.value;
             controller.complete();
             return result;
         }
@@ -4425,11 +4957,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 {
@@ -5052,21 +5585,110 @@ export class ClaudeSessionService {
         }
     }
     assertWritable() {
+        if (this.nativeTranscriptWritesEnabled()) {
+            throw new Error('experimental native operational writes are not enabled');
+        }
         if (this.schema.writeMode !== 'read-write') {
             throw new Error(`Claude ${this.options.claudeVersion} session is read-only`);
         }
     }
+    assertTurnWritable() {
+        if (this.nativeTranscriptWritesEnabled())
+            return;
+        this.assertWritable();
+    }
     sessionStatus(issue, entryCount) {
         if (issue || entryCount === 0)
             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 this.nativeTranscriptWritesEnabled() ? 'ready' : 'read-only';
+    }
+    nativeTranscriptWritesEnabled() {
+        return this.options.experimentalNativeTranscriptWrites === true;
+    }
+    assertNativeTranscriptOptions() {
+        if (!this.nativeTranscriptWritesEnabled())
+            return;
+        if (this.options.dataPlane !== 'native')
+            throw new Error('experimental native transcript writes require dataPlane native');
+        if (this.options.sessionPersistence === false)
+            throw new Error('experimental native transcript writes require sessionPersistence');
+        const incompatible = [
+            ['hooks', this.options.hooks !== undefined],
+            [
+                'conditionalRuleResolver',
+                this.options.conditionalRuleResolver !== undefined,
+            ],
+            ['extensions', this.options.extensions !== undefined],
+            ['agent', this.options.agent !== undefined],
+            ['fileCheckpointing', this.options.fileCheckpointing === true],
+            ['fileRewindRoots', (this.options.fileRewindRoots?.length ?? 0) > 0],
+            ['interactiveTools', this.options.interactiveTools !== undefined],
+            ['mcp', this.options.mcp !== undefined],
+            ['taskToolNames', (this.options.taskToolNames?.length ?? 0) > 0],
+            [
+                'scheduledToolNames',
+                (this.options.scheduledToolNames?.length ?? 0) > 0,
+            ],
+            ['enableDynamicWakeups', this.options.enableDynamicWakeups === true],
+            ['enableSessionMemory', this.options.enableSessionMemory === true],
+            [
+                'sessionMemoryProviderFactory',
+                this.options.sessionMemoryProviderFactory !== undefined,
+            ],
+            [
+                'projectMemoryDirectory',
+                this.options.projectMemoryDirectory !== undefined,
+            ],
+            ['projectMemoryRecall', this.options.projectMemoryRecall !== undefined],
+            [
+                'projectMemoryExtraction',
+                this.options.projectMemoryExtraction !== undefined,
+            ],
+            ['sessionKind', this.options.sessionKind !== undefined],
+            ['workspace', this.options.workspace !== undefined],
+            ['initialWorktree', this.options.initialWorktree === true],
+            ['initialWorktreeName', this.options.initialWorktreeName !== undefined],
+            ['enableWorktrees', this.options.enableWorktrees === true],
+            ['worktreeToolNames', (this.options.worktreeToolNames?.length ?? 0) > 0],
+            ['worktreeBaseRef', this.options.worktreeBaseRef !== undefined],
+        ];
+        const active = incompatible.find(([, enabled]) => enabled);
+        if (active)
+            throw new Error(`experimental native transcript writes incompatible with option ${active[0]}`);
+    }
+    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.nativeTranscriptWritesEnabled())
+            return;
+        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 +5746,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);
@@ -5267,6 +5889,7 @@ export class ClaudeSessionService {
             ...(this.options.enableSubagents === undefined
                 ? {}
                 : { subagents: this.options.enableSubagents }),
+            teams: this.leadOperations !== null,
             ...(this.options.toolCapabilityEnvironment
                 ? { env: this.options.toolCapabilityEnvironment }
                 : {}),
@@ -5283,7 +5906,20 @@ export class ClaudeSessionService {
             'CronDelete',
             'CronList',
             'ScheduleWakeup',
-        ].includes(name) || capabilities.has(name));
+        ].includes(name) || capabilities.has(name))
+            .filter((name) => !name.startsWith('Team') || capabilities.has(name));
+    }
+    teamRegistry(base, sessionId, enabledTools) {
+        if (enabledTools.length === 0)
+            return base;
+        const operations = this.leadOperations;
+        if (!operations)
+            return base;
+        const factory = this.options.teamLeadToolRegistryFactory;
+        if (!factory) {
+            throw new Error('Team lead operations require a Team lead tool registry factory');
+        }
+        return factory(base, operations, sessionId, enabledTools);
     }
     async append(lease, tail, entry) {
         const result = await lease.append(tail, entry);