praxis-agent 0.36.0 → 0.37.0

package/dist/application/session-service.js

@@ -34,8 +34,10 @@ import { ClaudeFileChangeWatcher } from '../hooks/claude-file-change-watcher.js'
 import { ClaudeTranscriptStore, } from '../persistence/claude-transcript-store.js';
 import { ClaudeSessionIndexCandidateError, readClaudeSessionIndexes, } from '../persistence/claude-session-index.js';
 import { readNativeTranscript, readNativeTranscriptIndexes, exportNativeTranscript, NativeTranscriptIndexCandidateError, } from '../persistence/native-transcript-reader.js';
-import { lastUserPrompt, projectTranscriptDisplay, } from './transcript-projection.js';
+import { 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';
@@ -54,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;
 }
@@ -712,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
@@ -942,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);
@@ -1119,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 }
                     : {}),
@@ -1220,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',
@@ -1253,6 +1265,11 @@ export class ClaudeSessionService {
             'ScheduleWakeup',
             'Monitor',
             'PushNotification',
+            'TeamCreate',
+            'TeamResume',
+            'TeamList',
+            'TeamAccept',
+            'TeamStop',
         ];
         const hostedRegistry = {
             definitions: () => {
@@ -1866,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) {
@@ -2225,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) => {
@@ -2432,6 +2559,36 @@ 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();
@@ -2447,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);
@@ -2764,9 +2954,12 @@ export class ClaudeSessionService {
         const skipUserPrompt = submission.kind === 'retry';
         const controller = new TurnTerminalController(this.options.eventSink ?? (() => undefined));
         try {
+            if (this.nativeTranscriptWritesEnabled() && name !== undefined) {
+                throw new Error('experimental native session names are not enabled');
+            }
             if (requireExisting)
                 await this.assertNativeWriteTargetIsLegacy(sessionId);
-            this.assertWritable();
+            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) {
@@ -2776,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);
@@ -2795,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));
@@ -2806,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();
@@ -2817,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 = {
@@ -2839,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);
@@ -2869,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);
@@ -2885,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);
@@ -2893,7 +3105,7 @@ export class ClaudeSessionService {
                 this.activeProvider = provider;
                 const effectivePrompt = automaticReplayPrompt ??
                     (!requireExisting &&
-                        !skipUserPrompt &&
+                        !shouldSkipUserPrompt() &&
                         !this.options.agentInitialPromptHandledExternally &&
                         shellCommand === undefined &&
                         agent?.initialPrompt
@@ -2911,7 +3123,7 @@ export class ClaudeSessionService {
                         : {}),
                     warn: (message) => this.options.eventSink?.({ type: 'warning', message }),
                 });
-                if (!skipUserPrompt && shellCommand === undefined) {
+                if (!shouldSkipUserPrompt() && shellCommand === undefined) {
                     turnMemory.prefetch({
                         turnId: randomUUID(),
                         prompt: effectivePrompt,
@@ -2932,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();
@@ -3062,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 }
                             : {}),
@@ -3222,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 }
@@ -3283,7 +3502,15 @@ export class ClaudeSessionService {
                 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);
                     },
@@ -3304,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;
@@ -3339,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'
@@ -3434,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;
@@ -3446,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),
@@ -3525,7 +3781,7 @@ export class ClaudeSessionService {
                         contextMessages = [...contextProjection.systemMessages];
                     };
                     await refreshRuntimeContext();
-                    const expansion = skipUserPrompt
+                    const expansion = shouldSkipUserPrompt()
                         ? { userMessages: [] }
                         : shellCommand === undefined
                             ? this.options.extensions
@@ -3586,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) => {
@@ -3621,7 +3877,7 @@ export class ClaudeSessionService {
                     const contextTransitionPort = (pendingMessages = [], preservedUserMessages = []) => ({
                         current: () => {
                             const historyMessages = [
-                                ...projectClaudeModelMessages(snapshot.entries),
+                                ...activeTurnMessages(),
                                 ...projectMemoryRecallMessages,
                             ];
                             return {
@@ -3649,11 +3905,155 @@ export class ClaudeSessionService {
                             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: 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 = [
-                                ...projectClaudeModelMessages(snapshot.entries),
+                                ...activeTurnMessages(),
                                 ...projectMemoryRecallMessages,
                             ];
                             const irreducibleMessages = [
@@ -3869,7 +4269,7 @@ export class ClaudeSessionService {
                                             tail: metadataAppend.tail,
                                         };
                                     }
-                                    this.rememberDurableMetadata(sessionId, snapshot.entries);
+                                    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
@@ -3946,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);
@@ -3955,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',
@@ -3986,7 +4400,7 @@ export class ClaudeSessionService {
                                 cwd: this.activeCwd(),
                                 sessionId,
                                 toolResultDirectory,
-                                messages: projectClaudeModelMessages(snapshot.entries),
+                                messages: activeTurnMessages(),
                                 observer: {
                                     assistantCompleted: async () => undefined,
                                     toolCompleted: async () => undefined,
@@ -4038,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',
@@ -4051,7 +4479,7 @@ export class ClaudeSessionService {
                         await contextEngine.prepare(contextTransitionPort([], currentTurnUserMessages ?? []), signal);
                         budget.assertFits(budget.evaluate([
                             ...contextMessages,
-                            ...injectTurnContext(projectClaudeModelMessages(snapshot.entries)),
+                            ...injectTurnContext(activeTurnMessages()),
                         ], definitions));
                     }
                     let stopHookActive = false;
@@ -4059,7 +4487,7 @@ export class ClaudeSessionService {
                         sessionId,
                         messages: [
                             ...contextMessages,
-                            ...injectTurnContext(projectClaudeModelMessages(snapshot.entries)),
+                            ...injectTurnContext(activeTurnMessages()),
                         ],
                         stableSystemMessageCount,
                         cwd: this.activeCwd(),
@@ -4090,7 +4518,7 @@ export class ClaudeSessionService {
                             return [
                                 ...contextMessages,
                                 ...injectTurnContext([
-                                    ...projectClaudeModelMessages(snapshot.entries),
+                                    ...activeTurnMessages(),
                                     ...projectMemoryRecallMessages,
                                 ]),
                             ];
@@ -4099,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',
@@ -4211,7 +4645,7 @@ export class ClaudeSessionService {
                             runtimeRequest.messages = [
                                 ...contextMessages,
                                 ...injectTurnContext([
-                                    ...projectClaudeModelMessages(snapshot.entries),
+                                    ...activeTurnMessages(),
                                     ...projectMemoryRecallMessages,
                                 ]),
                             ];
@@ -4254,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,
@@ -4266,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) {
@@ -4347,7 +4781,7 @@ export class ClaudeSessionService {
                                 : { linesRemoved: foregroundLineChanges.linesRemoved }),
                         });
                     }
-                    const memorySnapshot = projectClaudeModelMessages(snapshot.entries);
+                    const memorySnapshot = activeTurnMessages();
                     const providerVisibleMessages = [
                         ...contextMessages,
                         ...injectTurnContext(memorySnapshot),
@@ -4362,7 +4796,9 @@ export class ClaudeSessionService {
                         occupancyTokens: currentContextTokens,
                         toolCalls: currentTurnToolCalls,
                         messages: memorySnapshot,
-                        projectMessages: projectMemoryMessages(snapshot.entries),
+                        projectMessages: nativeLease
+                            ? []
+                            : projectMemoryMessages(snapshot.entries),
                         directMaintenance: projectMemoryMaintained,
                     });
                     turnCompleted = true;
@@ -4387,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;
         }
@@ -5121,10 +5585,18 @@ 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';
@@ -5135,7 +5607,61 @@ export class ClaudeSessionService {
             return 'read-only';
         if (entryCount === 0 || issue)
             return 'corrupt';
-        return 'read-only';
+        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);
@@ -5155,6 +5681,8 @@ export class ClaudeSessionService {
         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);
@@ -5361,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 }
                 : {}),
@@ -5377,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);