praxis-agent 0.36.0 → 0.37.0

package/dist/application/subagent-service.js

@@ -12,6 +12,7 @@ import { injectFirstUserMessageContext, projectContextSnapshot, } from '../core/
 import { assembleContextSnapshot } from '../core/prompt-composer.js';
 import { ContextBudget } from '../core/context-budget.js';
 import { AgentRuntime, } from '../core/runtime.js';
+import { composePermissionResolvers } from '../core/permission-policy.js';
 import { resolveToolSchedulingPolicy } from '../core/tool-scheduling-policy.js';
 import { BUILTIN_STATUSLINE_AGENT_PATH, } from '../extensions/claude-extensions.js';
 import { ClaudeHookToolCoordinator } from '../hooks/claude-hook-tools.js';
@@ -23,6 +24,8 @@ import { BackgroundAgentManager, BackgroundAgentRunError, BackgroundAgentShutdow
 import { isBackgroundBashTaskId } from './background-task-id.js';
 import { createManagedWorktree, restoreManagedWorktree, } from './managed-worktree.js';
 import { createWorkflowWorktree } from './workflow-worktree.js';
+import { NativeSidechainTranscript, } from './native-sidechain-transcript.js';
+import { DurableFollowUpTracker, } from './durable-follow-up.js';
 const DEFAULT_MAX_DEPTH = 4;
 const DEFAULT_MAX_CALLS = 16;
 const DEFAULT_MAX_OUTPUT_BYTES = 1024 * 1024;
@@ -128,6 +131,48 @@ async function readSidechainMetadataName(metadataFile) {
         return undefined;
     }
 }
+function projectNativeSidechainContinuationMessages(messages) {
+    const callCounts = new Map();
+    const resultCounts = new Map();
+    for (const message of messages) {
+        if (message.role === 'assistant') {
+            for (const call of message.toolCalls ?? [])
+                callCounts.set(call.id, (callCounts.get(call.id) ?? 0) + 1);
+        }
+        else if (message.role === 'tool') {
+            resultCounts.set(message.toolCallId, (resultCounts.get(message.toolCallId) ?? 0) + 1);
+        }
+    }
+    for (const [callId, count] of callCounts) {
+        if (count > 1)
+            throw new Error(`Native sidechain continuation has duplicate tool ID ${callId}`);
+    }
+    for (const [callId, count] of resultCounts) {
+        if (count > 1)
+            throw new Error(`Native sidechain continuation has duplicate tool result ${callId}`);
+    }
+    const resolved = new Set([...callCounts.keys()].filter((callId) => resultCounts.get(callId) === 1));
+    return messages.flatMap((message) => {
+        if (message.role === 'assistant') {
+            const toolCalls = (message.toolCalls ?? []).filter((call) => resolved.has(call.id));
+            if (message.content.trim() === '' && toolCalls.length === 0)
+                return [];
+            return [
+                {
+                    role: 'assistant',
+                    content: message.content,
+                    ...(message.thinkingBlocks
+                        ? { thinkingBlocks: message.thinkingBlocks }
+                        : {}),
+                    ...(toolCalls.length === 0 ? {} : { toolCalls }),
+                },
+            ];
+        }
+        if (message.role === 'tool' && !resolved.has(message.toolCallId))
+            return [];
+        return [message];
+    });
+}
 export class StructuredOutputRegistry {
     base;
     schema;
@@ -459,8 +504,19 @@ export class ClaudeSubagentExecutor {
     }
     constructor(options) {
         this.options = options;
+        if (options.experimentalNativeTranscriptWrites === true &&
+            (options.dataPlane !== 'native' || options.persistence !== 'disk')) {
+            throw new Error('experimental native transcript writes require native dataPlane and disk persistence');
+        }
+        if (options.experimentalNativeTranscriptWrites === true &&
+            options.hooks !== undefined) {
+            throw new Error('experimental native sidechain writes do not support Claude hooks');
+        }
         this.schema = selectClaudeSchemaAdapter(options.claudeVersion);
     }
+    nativeSidechainWritesEnabled() {
+        return this.options.experimentalNativeTranscriptWrites === true;
+    }
     async close() {
         for (const agentId of [...this.foreground.keys()]) {
             this.backgroundForegroundTask(agentId);
@@ -763,20 +819,30 @@ export class ClaudeSubagentExecutor {
             return settleInitialSetupFailure(error, initialIsolation);
         }
         const agentCwd = initialIsolation?.cwd ?? parentCwd;
-        const sidechain = this.sidechainStore(sessionId, agentId, sidechainPaths, paths.praxisRoot);
-        const root = createClaudeSidechainRoot({
-            sessionId,
-            promptId,
-            prompt: input.prompt,
-            agentId,
-            cwd: agentCwd,
-            claudeVersion: this.options.claudeVersion,
-            gitBranch: null,
-            uuid: randomUUID(),
-            timestamp: new Date().toISOString(),
-        });
+        const nativeSidechain = this.nativeSidechainWritesEnabled()
+            ? new NativeSidechainTranscript({
+                ...sidechainPaths,
+                lockFile: join(paths.praxisRoot, 'locks', `${sessionId}-${agentId}.lock`),
+            })
+            : undefined;
+        const claudeSidechain = nativeSidechain
+            ? undefined
+            : this.sidechainStore(sessionId, agentId, sidechainPaths, paths.praxisRoot);
+        const root = nativeSidechain
+            ? undefined
+            : createClaudeSidechainRoot({
+                sessionId,
+                promptId,
+                prompt: input.prompt,
+                agentId,
+                cwd: agentCwd,
+                claudeVersion: this.options.claudeVersion,
+                gitBranch: null,
+                uuid: randomUUID(),
+                timestamp: new Date().toISOString(),
+            });
         try {
-            await sidechain.create(root, {
+            const metadata = {
                 agentType: input.subagentType,
                 description: input.description,
                 toolUseId: call.id,
@@ -788,7 +854,19 @@ export class ClaudeSubagentExecutor {
                 ...(input.isolation ? { isolation: input.isolation } : {}),
                 ...(parentAgentId ? { parentAgentId } : {}),
                 ...(initialIsolation ? { worktreePath: initialIsolation.cwd } : {}),
-            });
+            };
+            if (nativeSidechain) {
+                await nativeSidechain.create(input.prompt, {
+                    ...metadata,
+                    cwd: agentCwd,
+                    promptId,
+                });
+            }
+            else {
+                if (!claudeSidechain || !root)
+                    throw new Error('Claude sidechain initialization is unavailable');
+                await claudeSidechain.create(root, metadata);
+            }
         }
         catch (error) {
             return settleInitialSetupFailure(error, initialIsolation);
@@ -803,21 +881,28 @@ export class ClaudeSubagentExecutor {
             ...(initialExecution ? { initialExecution } : {}),
             ...(initialIsolation ? { initialIsolation } : {}),
             createIsolation: () => this.createAgentWorktree(paths.praxisRoot, sessionId, agentId, parentCwd),
-            execute: (cwd, message, signal, continuation) => sidechain.withLease(async (lease) => this.runSidechain({
-                lease,
-                root,
-                input,
-                provider,
-                agentId,
-                spawnDepth,
-                promptId,
-                toolUseId: call.id,
-                transcriptPath: sidechainPaths.transcriptFile,
-                toolResultDirectory: join(paths.projectRoot, sessionId, 'tool-results'),
-                ...(continuation ? { continuationMessage: message } : {}),
-                signal,
-                cwd,
-            })),
+            execute: async (cwd, message, signal, continuation) => {
+                const run = (lease) => this.runSidechain({
+                    ...lease,
+                    sessionId,
+                    input,
+                    provider,
+                    agentId,
+                    spawnDepth,
+                    promptId,
+                    toolUseId: call.id,
+                    transcriptPath: sidechainPaths.transcriptFile,
+                    toolResultDirectory: join(paths.projectRoot, sessionId, 'tool-results'),
+                    ...(continuation ? { continuationMessage: message } : {}),
+                    signal,
+                    cwd,
+                });
+                if (nativeSidechain)
+                    return nativeSidechain.withLease((nativeLease) => run({ nativeLease }));
+                if (!claudeSidechain)
+                    throw new Error('Claude sidechain execution is unavailable');
+                return claudeSidechain.withLease((claudeLease) => run({ claudeLease }));
+            },
         });
         const resolvedModel = provider.model ?? 'praxis/provider';
         const spec = {
@@ -1314,7 +1399,13 @@ export class ClaudeSubagentExecutor {
             metadataFile: agentFiles.metadataFile,
         };
         const sessionPaths = this.sessionPaths(options.sessionId);
-        const sidechain = new ClaudeSidechainStore(paths, join(sessionPaths.praxisRoot, 'locks', `${options.sessionId}-${options.runId}-${options.agentId}.lock`), this.schema);
+        const lockFile = join(sessionPaths.praxisRoot, 'locks', `${options.sessionId}-${options.runId}-${options.agentId}.lock`);
+        const nativeSidechain = this.nativeSidechainWritesEnabled()
+            ? new NativeSidechainTranscript({ ...paths, lockFile })
+            : undefined;
+        const claudeSidechain = nativeSidechain
+            ? undefined
+            : new ClaudeSidechainStore(paths, lockFile, this.schema);
         const isolation = options.isolation
             ? await createWorkflowWorktree({
                 cwd: this.cwd(),
@@ -1324,29 +1415,47 @@ export class ClaudeSubagentExecutor {
             })
             : null;
         const agentCwd = isolation?.cwd ?? this.cwd();
-        const root = createClaudeSidechainRoot({
-            sessionId: options.sessionId,
-            promptId: options.promptId,
-            prompt: options.prompt,
-            agentId: options.agentId,
-            cwd: agentCwd,
-            claudeVersion: this.options.claudeVersion,
-            gitBranch: null,
-            uuid: randomUUID(),
-            timestamp: new Date().toISOString(),
-        });
+        const root = nativeSidechain
+            ? undefined
+            : createClaudeSidechainRoot({
+                sessionId: options.sessionId,
+                promptId: options.promptId,
+                prompt: options.prompt,
+                agentId: options.agentId,
+                cwd: agentCwd,
+                claudeVersion: this.options.claudeVersion,
+                gitBranch: null,
+                uuid: randomUUID(),
+                timestamp: new Date().toISOString(),
+            });
         const startedAt = Date.now();
         const structured = { calls: 0, value: undefined };
         let run;
         let cleanup;
         try {
-            await sidechain.createWorkflow(root, {
-                agentType: options.agentType ?? 'workflow-subagent',
-                spawnDepth: 1,
-            });
-            run = await sidechain.withLease((lease) => this.runSidechain({
-                lease,
-                root,
+            if (nativeSidechain) {
+                await nativeSidechain.create(options.prompt, {
+                    agentType: options.agentType ?? 'workflow-subagent',
+                    description: input.description,
+                    toolUseId: `workflow:${options.runId}`,
+                    spawnDepth: 1,
+                    cwd: agentCwd,
+                    promptId: options.promptId,
+                    ...(options.isolation ? { isolation: options.isolation } : {}),
+                    ...(isolation ? { worktreePath: isolation.cwd } : {}),
+                });
+            }
+            else {
+                if (!claudeSidechain || !root)
+                    throw new Error('Claude workflow sidechain is unavailable');
+                await claudeSidechain.createWorkflow(root, {
+                    agentType: options.agentType ?? 'workflow-subagent',
+                    spawnDepth: 1,
+                });
+            }
+            const runWithLease = (lease) => this.runSidechain({
+                ...lease,
+                sessionId: options.sessionId,
                 input,
                 provider,
                 agentId: options.agentId,
@@ -1360,7 +1469,15 @@ export class ClaudeSubagentExecutor {
                 ...(options.effort ? { effort: options.effort } : {}),
                 ...(options.signal ? { signal: options.signal } : {}),
                 cwd: agentCwd,
-            }));
+            });
+            if (nativeSidechain) {
+                run = await nativeSidechain.withLease((nativeLease) => runWithLease({ nativeLease }));
+            }
+            else {
+                if (!claudeSidechain)
+                    throw new Error('Claude workflow sidechain is unavailable');
+                run = await claudeSidechain.withLease((claudeLease) => runWithLease({ claudeLease }));
+            }
         }
         finally {
             cleanup = await isolation?.cleanup();
@@ -1465,7 +1582,7 @@ export class ClaudeSubagentExecutor {
         }
         const agentId = String(call.input.to);
         const summary = typeof call.input.summary === 'string' ? call.input.summary : undefined;
-        const owned = this.options.sendOwnedBackgroundAgent?.(sessionId, agentId, String(call.input.message), summary, call.id);
+        const owned = await this.options.sendOwnedBackgroundAgent?.(sessionId, agentId, String(call.input.message), summary, call.id);
         if (owned !== undefined && owned !== null) {
             return { content: owned, isError: false };
         }
@@ -1528,34 +1645,48 @@ export class ClaudeSubagentExecutor {
         if (!sidechainPaths)
             return;
         const agentId = sidechainPaths.agentId;
-        const sidechain = new ClaudeSidechainStore(sidechainPaths, join(paths.praxisRoot, 'locks', `${sessionId}-${agentId}.lock`), this.schema);
-        let snapshot;
+        const lockFile = join(paths.praxisRoot, 'locks', `${sessionId}-${agentId}.lock`);
+        const nativeSidechain = this.nativeSidechainWritesEnabled()
+            ? new NativeSidechainTranscript({ ...sidechainPaths, lockFile })
+            : undefined;
+        const claudeSidechain = nativeSidechain
+            ? undefined
+            : new ClaudeSidechainStore(sidechainPaths, lockFile, this.schema);
+        let metadata = null;
+        let root;
+        let projected;
         try {
-            snapshot = await sidechain.loadReadOnly();
+            if (nativeSidechain) {
+                await nativeSidechain.loadReadOnly();
+                metadata = await nativeSidechain.metadata();
+                projected = await nativeSidechain.withLease(async (lease) => lease.activeMessages());
+            }
+            else {
+                if (!claudeSidechain)
+                    throw new Error('Claude persisted sidechain is unavailable');
+                const snapshot = await claudeSidechain.loadReadOnly();
+                metadata = await claudeSidechain.metadata().catch((error) => {
+                    if (error.code === 'ENOENT')
+                        return null;
+                    throw error;
+                });
+                root = snapshot.entries[0];
+                if (!root || root.type !== 'user') {
+                    throw new Error(`Background agent ${agentId} has no sidechain root`);
+                }
+                projected = projectClaudeModelMessages(snapshot.entries);
+            }
         }
         catch (error) {
             if (error.code === 'ENOENT')
                 return;
             throw error;
         }
-        let metadata = null;
-        try {
-            metadata = await sidechain.metadata();
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT')
-                throw error;
-        }
-        const root = snapshot.entries[0];
-        if (!root || root.type !== 'user') {
+        const rootMessage = projected[0];
+        if (rootMessage?.role !== 'user' || rootMessage.content.trim() === '') {
             throw new Error(`Background agent ${agentId} has no sidechain root`);
         }
-        const prompt = typeof root.message === 'object' &&
-            root.message !== null &&
-            typeof root.message.content === 'string'
-            ? String(root.message.content)
-            : '';
-        const projected = projectClaudeModelMessages(snapshot.entries);
+        const prompt = rootMessage.content;
         const lastAssistant = projected.at(-1);
         const completed = lastAssistant?.role === 'assistant' &&
             lastAssistant.content.trim().length > 0 &&
@@ -1621,7 +1752,9 @@ export class ClaudeSubagentExecutor {
             }
         }
         else {
-            const persistedCwd = root.cwd;
+            const persistedCwd = nativeSidechain
+                ? metadata.cwd
+                : root?.cwd;
             if (typeof persistedCwd === 'string' &&
                 persistedCwd.length > 0 &&
                 !persistedCwd.includes('\0') &&
@@ -1656,6 +1789,9 @@ export class ClaudeSubagentExecutor {
             runInBackground: true,
         };
         const provider = this.options.provider;
+        const recoveredPromptId = nativeSidechain
+            ? metadata.promptId
+            : String(root?.promptId ?? randomUUID());
         const backgroundRun = this.createBackgroundAgentRun({
             input,
             parentCwd: restoredCwd,
@@ -1664,21 +1800,28 @@ export class ClaudeSubagentExecutor {
             initialLifecycleState: lifecycle.lifecycle.state,
             ...(restoredIsolation ? { initialIsolation: restoredIsolation } : {}),
             createIsolation: () => this.createAgentWorktree(paths.praxisRoot, sessionId, agentId, parentCwd),
-            execute: (cwd, message, signal, continuation) => sidechain.withLease(async (lease) => this.runSidechain({
-                lease,
-                root,
-                input,
-                provider,
-                agentId,
-                spawnDepth,
-                promptId: String(root.promptId ?? randomUUID()),
-                toolUseId,
-                transcriptPath: sidechainPaths.transcriptFile,
-                toolResultDirectory: join(paths.projectRoot, sessionId, 'tool-results'),
-                ...(continuation ? { continuationMessage: message } : {}),
-                signal,
-                cwd,
-            })),
+            execute: async (cwd, message, signal, continuation) => {
+                const run = (lease) => this.runSidechain({
+                    ...lease,
+                    sessionId,
+                    input,
+                    provider,
+                    agentId,
+                    spawnDepth,
+                    promptId: recoveredPromptId,
+                    toolUseId,
+                    transcriptPath: sidechainPaths.transcriptFile,
+                    toolResultDirectory: join(paths.projectRoot, sessionId, 'tool-results'),
+                    ...(continuation ? { continuationMessage: message } : {}),
+                    signal,
+                    cwd,
+                });
+                if (nativeSidechain)
+                    return nativeSidechain.withLease((nativeLease) => run({ nativeLease }));
+                if (!claudeSidechain)
+                    throw new Error('Claude persisted sidechain is unavailable');
+                return claudeSidechain.withLease((claudeLease) => run({ claudeLease }));
+            },
         });
         const spec = {
             agentId,
@@ -1861,42 +2004,77 @@ export class ClaudeSubagentExecutor {
     async runSidechain(options) {
         const cwd = options.cwd ?? this.cwd();
         const permissions = options.input.permissionMode && options.input.permissionMode !== 'default'
-            ? this.options.permissionResolverForMode?.(options.input.permissionMode)
+            ? (() => {
+                const mode = options.input.permissionMode;
+                if (!mode)
+                    return undefined;
+                const child = this.options.permissionResolverForMode?.(mode);
+                return child
+                    ? composePermissionResolvers(this.options.permissions, child)
+                    : undefined;
+            })()
             : this.options.permissions;
         if (!permissions) {
             throw new Error('Agent permission mode overrides are unavailable');
         }
-        let snapshot = await options.lease.load();
+        if ((options.claudeLease === undefined) ===
+            (options.nativeLease === undefined))
+            throw new Error('Exactly one sidechain transcript lease is required');
+        const claudeLease = options.claudeLease;
+        const nativeLease = options.nativeLease;
+        let snapshot = claudeLease
+            ? await claudeLease.load()
+            : undefined;
+        const requireClaudeSnapshot = () => {
+            if (!snapshot)
+                throw new Error('Claude sidechain snapshot is unavailable');
+            return snapshot;
+        };
+        const nativeInterruption = nativeLease?.interruption();
+        if (nativeInterruption?.kind === 'indeterminate-tools')
+            throw new Error(`Native sidechain tool execution is indeterminate: ${nativeInterruption.callIds.join(', ')}`);
+        const nativeRecoveryCalls = options.continuationMessage === undefined &&
+            nativeInterruption?.kind === 'recoverable-tools'
+            ? [...nativeInterruption.calls]
+            : [];
         if (options.continuationMessage !== undefined) {
             // Validate ambiguous tool linkage before the append-only sidechain is
             // mutated. The projection is rebuilt after appending the one explicit
             // continuation prompt so that prompt is visible to the provider.
-            projectClaudeSidechainContinuationMessages(snapshot.entries);
-            const [entry] = translateProviderEvents([
-                {
-                    type: 'user-text-block',
-                    text: `The coordinator sent a message while you were working:\n${options.continuationMessage}\n\nAddress this before completing your current task.`,
-                },
-            ], {
-                sessionId: String(options.root.sessionId),
-                parentUuid: snapshot.tail.lastUuid,
-                cwd,
-                claudeVersion: this.options.claudeVersion,
-                gitBranch: null,
-                history: snapshot.entries,
-            });
-            if (!entry)
-                throw new Error('Could not translate subagent message');
-            const sidechainEntry = toClaudeSidechainEntry(entry, options.agentId, options.input.subagentType);
-            const appendResult = await options.lease.append(snapshot.tail, sidechainEntry);
-            if (appendResult.status === 'conflict') {
-                throw new Error(`Claude sidechain append conflict: ${appendResult.reason}`);
+            const continuation = `The coordinator sent a message while you were working:\n${options.continuationMessage}\n\nAddress this before completing your current task.`;
+            if (nativeLease) {
+                projectNativeSidechainContinuationMessages(nativeLease.activeMessages());
+                await nativeLease.appendMessages({
+                    messages: [{ role: 'user', content: continuation }],
+                });
+            }
+            else {
+                const current = requireClaudeSnapshot();
+                projectClaudeSidechainContinuationMessages(current.entries);
+                const [entry] = translateProviderEvents([{ type: 'user-text-block', text: continuation }], {
+                    sessionId: options.sessionId,
+                    parentUuid: current.tail.lastUuid,
+                    cwd,
+                    claudeVersion: this.options.claudeVersion,
+                    gitBranch: null,
+                    history: current.entries,
+                });
+                if (!entry)
+                    throw new Error('Could not translate subagent message');
+                const sidechainEntry = toClaudeSidechainEntry(entry, options.agentId, options.input.subagentType);
+                if (!claudeLease)
+                    throw new Error('Claude sidechain continuation is unavailable');
+                const appendResult = await claudeLease.append(current.tail, sidechainEntry);
+                if (appendResult.status === 'conflict') {
+                    throw new Error(`Claude sidechain append conflict: ${appendResult.reason}`);
+                }
+                snapshot = {
+                    entries: [...current.entries, sidechainEntry],
+                    tail: appendResult.tail,
+                };
             }
-            snapshot = {
-                entries: [...snapshot.entries, sidechainEntry],
-                tail: appendResult.tail,
-            };
         }
+        const durableFollowUps = new DurableFollowUpTracker();
         let toolUseCount = 0;
         let taskTokenTotal = 0;
         let recordedUsage = { inputTokens: 0, outputTokens: 0 };
@@ -1907,29 +2085,37 @@ export class ClaudeSubagentExecutor {
         let recordedApiDurationSeen = false;
         let lastToolName;
         const taskStartedAt = Date.now();
-        const append = async (entry) => {
-            const result = await options.lease.append(snapshot.tail, entry);
+        const appendClaude = async (entry) => {
+            if (!claudeLease)
+                throw new Error('Claude sidechain append is unavailable');
+            const current = requireClaudeSnapshot();
+            const result = await claudeLease.append(current.tail, entry);
             if (result.status === 'conflict') {
                 throw new Error(`Claude sidechain append conflict: ${result.reason}`);
             }
-            snapshot = { entries: [...snapshot.entries, entry], tail: result.tail };
+            snapshot = { entries: [...current.entries, entry], tail: result.tail };
+        };
+        const translationContext = () => {
+            const current = requireClaudeSnapshot();
+            return {
+                sessionId: options.sessionId,
+                parentUuid: current.tail.lastUuid,
+                cwd,
+                claudeVersion: this.options.claudeVersion,
+                gitBranch: null,
+                history: current.entries,
+            };
         };
-        const translationContext = () => ({
-            sessionId: String(options.root.sessionId),
-            parentUuid: snapshot.tail.lastUuid,
-            cwd,
-            claudeVersion: this.options.claudeVersion,
-            gitBranch: null,
-            history: snapshot.entries,
-        });
         const recordHookOutcome = async (outcome) => {
+            if (nativeLease)
+                throw new Error('Claude hooks are unavailable for native sidechains');
             for (const entry of createClaudeHookAttachmentEntries(outcome, translationContext())) {
-                await append(toClaudeSidechainEntry(entry, options.agentId, options.input.subagentType));
+                await appendClaude(toClaudeSidechainEntry(entry, options.agentId, options.input.subagentType));
             }
         };
         const customAgent = this.agentDefinition(options.input);
         const hookSession = {
-            session_id: String(options.root.sessionId),
+            session_id: options.sessionId,
             transcript_path: options.transcriptPath,
             cwd,
             permission_mode: options.input.permissionMode ?? 'default',
@@ -1979,7 +2165,7 @@ export class ClaudeSubagentExecutor {
             recordedDurationApiWithoutRetriesMs += withoutRetries;
             recordedApiDurationSeen = true;
         };
-        const nestedTools = this.registry(String(options.root.sessionId), options.spawnDepth, () => options.promptId, options.agentId);
+        const nestedTools = this.registry(options.sessionId, options.spawnDepth, () => options.promptId, options.agentId);
         const agentMcp = customAgent?.mcpServers?.length
             ? await this.options.mcp?.connectAgent?.({
                 specs: customAgent.mcpServers,
@@ -2074,8 +2260,29 @@ export class ClaudeSubagentExecutor {
             maxToolInputBytes: 1024 * 1024,
         });
         const observer = {
+            toolExecutionStarted: async (call) => {
+                await nativeLease?.beginToolExecution(call.id);
+            },
             assistantCompleted: async (message) => {
                 commitProviderUsage();
+                if (nativeLease) {
+                    await nativeLease.appendMessages({
+                        messages: [
+                            {
+                                role: 'assistant',
+                                content: message.content,
+                                ...(message.thinkingBlocks
+                                    ? { thinkingBlocks: message.thinkingBlocks }
+                                    : {}),
+                                ...(message.toolCalls?.length
+                                    ? { toolCalls: message.toolCalls }
+                                    : {}),
+                            },
+                        ],
+                        model: options.provider.model ?? 'praxis/provider',
+                    });
+                    return;
+                }
                 const [entry] = translateProviderEvents([
                     {
                         type: 'assistant-message',
@@ -2090,7 +2297,7 @@ export class ClaudeSubagentExecutor {
                 ], translationContext());
                 if (!entry)
                     throw new Error('Could not translate subagent response');
-                await append(toClaudeSidechainEntry(entry, options.agentId, options.input.subagentType));
+                await appendClaude(toClaudeSidechainEntry(entry, options.agentId, options.input.subagentType));
             },
             toolCompleted: async (call, result) => {
                 if (result.usage) {
@@ -2114,6 +2321,16 @@ export class ClaudeSubagentExecutor {
                     nestedToolUseCount > 0) {
                     toolUseCount += nestedToolUseCount;
                 }
+                if (nativeLease) {
+                    await nativeLease.appendToolCompletion({
+                        callId: call.id,
+                        result,
+                        ...(result.followUpUserMessages?.length
+                            ? { followUpUserMessages: result.followUpUserMessages }
+                            : {}),
+                    });
+                    return;
+                }
                 const [entry] = translateProviderEvents([
                     {
                         type: 'tool-result',
@@ -2135,16 +2352,19 @@ export class ClaudeSubagentExecutor {
                 ], translationContext());
                 if (!entry)
                     throw new Error('Could not translate subagent tool result');
-                await append(toClaudeSidechainEntry(entry, options.agentId, options.input.subagentType));
+                await appendClaude(toClaudeSidechainEntry(entry, options.agentId, options.input.subagentType));
             },
             followUpUserMessagesCompleted: async (messages) => {
                 for (const text of messages) {
-                    const [entry] = translateProviderEvents([{ type: 'user-text-block', text }], translationContext());
-                    if (!entry)
-                        throw new Error('Could not translate subagent follow-up');
-                    await append(toClaudeSidechainEntry(entry, options.agentId, options.input.subagentType));
+                    if (!nativeLease) {
+                        const [entry] = translateProviderEvents([{ type: 'user-text-block', text }], translationContext());
+                        if (!entry)
+                            throw new Error('Could not translate subagent follow-up');
+                        await appendClaude(toClaudeSidechainEntry(entry, options.agentId, options.input.subagentType));
+                    }
                     await this.background.acknowledge([text]);
                 }
+                await durableFollowUps.followUpUserMessagesCompleted(messages);
             },
         };
         this.options.eventSink?.({
@@ -2212,11 +2432,16 @@ export class ClaudeSubagentExecutor {
                 });
                 const contextProjection = projectContextSnapshot(assembledContext);
                 stableSystemMessageCount = contextProjection.stableSystemSectionCount;
+                const transcriptMessages = nativeLease
+                    ? options.continuationMessage === undefined
+                        ? nativeLease.activeMessages()
+                        : projectNativeSidechainContinuationMessages(nativeLease.activeMessages())
+                    : options.continuationMessage === undefined
+                        ? projectClaudeModelMessages(requireClaudeSnapshot().entries)
+                        : projectClaudeSidechainContinuationMessages(requireClaudeSnapshot().entries);
                 const messages = [
                     ...contextProjection.systemMessages,
-                    ...injectFirstUserMessageContext(options.continuationMessage === undefined
-                        ? projectClaudeModelMessages(snapshot.entries)
-                        : projectClaudeSidechainContinuationMessages(snapshot.entries), contextProjection.firstUserMessageContext),
+                    ...injectFirstUserMessageContext(transcriptMessages, contextProjection.firstUserMessageContext),
                     ...preloadedSkills,
                 ];
                 observedMessages = messages;
@@ -2227,9 +2452,27 @@ export class ClaudeSubagentExecutor {
             };
             const configuredEffort = typeof customAgent?.effort === 'string' ? customAgent.effort : undefined;
             const effectiveEffort = options.effort ?? configuredEffort;
+            if (nativeRecoveryCalls.length > 0) {
+                if (!nativeLease)
+                    throw new Error('Native sidechain recovery lease is unavailable');
+                await runtime.recoverToolCalls(nativeRecoveryCalls, {
+                    cwd,
+                    toolResultDirectory: options.toolResultDirectory,
+                    messages: nativeLease.activeMessages(),
+                    observer,
+                    ...(this.options.approveTool
+                        ? { approveTool: this.options.approveTool }
+                        : {}),
+                    permissionUpdates: this.options.permissionUpdates?.() ?? [],
+                    ...(this.options.onPermissionUpdates
+                        ? { onPermissionUpdates: this.options.onPermissionUpdates }
+                        : {}),
+                    ...(options.signal ? { signal: options.signal } : {}),
+                });
+            }
             const initialMessages = await assembleMessages();
             const runtimeRequest = {
-                sessionId: String(options.root.sessionId),
+                sessionId: options.sessionId,
                 messages: initialMessages,
                 collectMetrics: true,
                 stableSystemMessageCount,
@@ -2249,10 +2492,17 @@ export class ClaudeSubagentExecutor {
                 ...(this.options.onPermissionUpdates
                     ? { onPermissionUpdates: this.options.onPermissionUpdates }
                     : {}),
-                ...(scopedHooks || this.options.backgroundTaskNotifications
+                ...(scopedHooks ||
+                    this.options.backgroundTaskNotifications ||
+                    this.options.durableFollowUpSource
                     ? {
                         onStop: async (text) => {
                             const messages = [];
+                            const durableBatch = await this.options.durableFollowUpSource?.();
+                            if (durableBatch) {
+                                durableFollowUps.register(durableBatch);
+                                messages.push(...durableBatch.messages);
+                            }
                             const outcome = await scopedHooks?.run({
                                 ...hookSession,
                                 hook_event_name: 'SubagentStop',
@@ -2269,15 +2519,13 @@ export class ClaudeSubagentExecutor {
                                     messages.push(`SubagentStop hook error: ${outcome.blockedReason}`);
                                 }
                             }
-                            await this.hydratePersistedTasks(String(options.root.sessionId), options.cwd ?? this.cwd());
+                            await this.hydratePersistedTasks(options.sessionId, options.cwd ?? this.cwd());
                             await this.reconcileDeliveredNotifications((notification) => {
                                 const markers = backgroundAgentNotificationMarkers(notification);
-                                return snapshot.entries.some((entry) => {
-                                    if (entry.type !== 'user')
-                                        return false;
-                                    const source = JSON.stringify(entry.message);
-                                    return markers.every((marker) => source.includes(marker));
-                                });
+                                const source = JSON.stringify(nativeLease
+                                    ? nativeLease.activeMessages()
+                                    : requireClaudeSnapshot().entries);
+                                return markers.every((marker) => source.includes(marker));
                             });
                             const background = await this.background.notifications({
                                 waitForRunning: false,