praxis-agent 0.35.0 → 0.37.0

package/dist/application/subagent-service.js

@@ -12,17 +12,20 @@ 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';
 import { ClaudeSidechainStore } from '../persistence/claude-sidechain-store.js';
 import { InMemorySidechainStore } from '../persistence/in-memory-sidechain-store.js';
-import { SubagentLifecycleStore } from '../persistence/subagent-lifecycle-store.js';
+import { SubagentLifecycleStore, } from '../persistence/subagent-lifecycle-store.js';
 import { resolveDataPlanePaths, } from '../persistence/data-plane.js';
 import { BackgroundAgentManager, BackgroundAgentRunError, BackgroundAgentShutdownError, backgroundAgentNotificationMarkers, } from './background-agent-manager.js';
 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);
@@ -716,25 +772,77 @@ export class ClaudeSubagentExecutor {
         const agentId = `a${randomBytes(8).toString('hex')}`;
         const parentCwd = context.cwd;
         const paths = this.sessionPaths(sessionId, parentCwd);
-        const initialIsolation = input.isolation
-            ? await this.createAgentWorktree(paths.praxisRoot, sessionId, agentId, parentCwd)
+        const sidechainPaths = resolveClaudeSidechainPaths(paths.projectRoot, sessionId, agentId);
+        const lifecycleStore = this.options.persistence === 'memory'
+            ? undefined
+            : new SubagentLifecycleStore(paths.praxisRoot, sessionId, agentId, sidechainPaths.transcriptFile);
+        const initialExecution = lifecycleStore
+            ? await lifecycleStore.start()
             : undefined;
+        let initialIsolation;
+        const settleInitialSetupFailure = async (primary, isolation) => {
+            const secondary = [];
+            const message = primary instanceof Error ? primary.message : String(primary);
+            try {
+                await initialExecution?.finish('failed', {
+                    text: message,
+                    usage: { inputTokens: 0, outputTokens: 0 },
+                    toolUseCount: 0,
+                    durationMs: 0,
+                }, message);
+            }
+            catch (error) {
+                secondary.push(error);
+            }
+            try {
+                await initialExecution?.release();
+            }
+            catch (error) {
+                secondary.push(error);
+            }
+            try {
+                await isolation?.cleanup();
+            }
+            catch (error) {
+                secondary.push(error);
+            }
+            if (secondary.length > 0)
+                throw new AggregateError([primary, ...secondary], 'Background agent setup and cleanup failed');
+            throw primary;
+        };
+        try {
+            initialIsolation = input.isolation
+                ? await this.createAgentWorktree(paths.praxisRoot, sessionId, agentId, parentCwd)
+                : undefined;
+        }
+        catch (error) {
+            return settleInitialSetupFailure(error, initialIsolation);
+        }
         const agentCwd = initialIsolation?.cwd ?? parentCwd;
-        const sidechainPaths = resolveClaudeSidechainPaths(paths.projectRoot, sessionId, agentId);
-        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,
@@ -746,39 +854,55 @@ 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) {
-            await initialIsolation?.cleanup();
-            throw error;
+            return settleInitialSetupFailure(error, initialIsolation);
         }
         const provider = input.model
             ? (this.options.providerForModel?.(input.model) ?? this.options.provider)
             : this.options.provider;
-        const lifecycleStore = this.options.persistence === 'memory'
-            ? undefined
-            : new SubagentLifecycleStore(paths.praxisRoot, sessionId, agentId, sidechainPaths.transcriptFile);
         const backgroundRun = this.createBackgroundAgentRun({
             input,
             parentCwd,
             ...(lifecycleStore ? { lifecycle: lifecycleStore } : {}),
+            ...(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 = {
@@ -790,6 +914,7 @@ export class ClaudeSubagentExecutor {
             toolUseId: call.id,
             outputFile: sidechainPaths.transcriptFile,
             resolvedModel,
+            lifecycle: backgroundRun.lifecycle,
             run: backgroundRun.run,
             markBackground: backgroundRun.markBackground,
             ...(lifecycleStore
@@ -820,7 +945,18 @@ export class ClaudeSubagentExecutor {
             },
         });
         if (input.runInBackground) {
-            this.background.launch(spec);
+            try {
+                this.background.launch(spec);
+            }
+            catch (error) {
+                try {
+                    await backgroundRun.disposeBeforeStart();
+                }
+                catch (cleanupError) {
+                    throw new AggregateError([error, cleanupError], 'Background agent launch and pre-start cleanup failed');
+                }
+                throw error;
+            }
             return asyncResult();
         }
         const controller = new AbortController();
@@ -947,183 +1083,288 @@ export class ClaudeSubagentExecutor {
         let availableIsolation = options.initialIsolation;
         let retainedIsolation;
         let notificationExpected = options.input.runInBackground;
+        let recoverNext = options.recover ?? false;
+        let pendingExecution = options.initialExecution;
+        let disposed = false;
+        let lifecycleState = options.initialExecution?.snapshot.state ??
+            options.initialLifecycleState ??
+            'queued';
+        const lifecycleListeners = new Set();
+        const publishLifecycle = (state) => {
+            lifecycleState = state;
+            if (state === 'orphaned')
+                recoverNext = true;
+            for (const listener of lifecycleListeners)
+                listener(state);
+        };
+        const lifecycle = {
+            current: () => lifecycleState,
+            subscribe(listener) {
+                lifecycleListeners.add(listener);
+                return () => lifecycleListeners.delete(listener);
+            },
+        };
+        const disposeBeforeStart = async () => {
+            if (disposed)
+                return;
+            disposed = true;
+            const execution = pendingExecution;
+            pendingExecution = undefined;
+            const isolation = availableIsolation;
+            availableIsolation = undefined;
+            const errors = [];
+            if (execution) {
+                try {
+                    const snapshot = await execution.finish('failed', {
+                        text: 'Background agent launch was rejected before execution started',
+                        usage: { inputTokens: 0, outputTokens: 0 },
+                        toolUseCount: 0,
+                        durationMs: 0,
+                    }, 'Background agent launch was rejected before execution started');
+                    publishLifecycle(snapshot.state);
+                }
+                catch (error) {
+                    errors.push(error);
+                }
+                finally {
+                    try {
+                        await execution.release();
+                        publishLifecycle(execution.snapshot.state);
+                    }
+                    catch (error) {
+                        errors.push(error);
+                    }
+                }
+            }
+            if (isolation) {
+                try {
+                    await isolation.cleanup();
+                }
+                catch (error) {
+                    errors.push(error);
+                }
+            }
+            if (errors.length > 0) {
+                throw new AggregateError(errors, 'Background agent pre-start cleanup failed');
+            }
+        };
         const run = async (message, signal, continuation, currentToolUseId) => {
-            await options.lifecycle?.write('running');
+            let execution;
+            let cancellation;
+            let lifecycleTerminalized = false;
+            let onAbort;
             const startedAt = Date.now();
             let isolation;
-            try {
-                isolation = options.input.isolation
-                    ? (retainedIsolation ??
-                        availableIsolation ??
-                        (await options.createIsolation()))
-                    : undefined;
-            }
-            catch (error) {
-                const failureMessage = error instanceof Error ? error.message : String(error);
-                const failureResult = {
-                    text: failureMessage,
-                    usage: { inputTokens: 0, outputTokens: 0 },
-                    toolUseCount: 0,
-                    durationMs: Date.now() - startedAt,
-                };
-                const status = signal.aborted ? 'killed' : 'failed';
-                const notificationId = notificationExpected &&
-                    !(signal.reason instanceof BackgroundAgentShutdownError)
-                    ? randomUUID()
-                    : undefined;
-                await options.lifecycle?.write(status, failureMessage, {
-                    result: failureResult,
-                    ...(notificationId
-                        ? {
-                            notification: {
-                                id: notificationId,
-                                status,
-                                toolUseId: currentToolUseId,
-                                error: failureMessage,
-                            },
-                        }
-                        : {}),
-                });
-                if (!notificationExpected)
-                    throw error;
-                throw new BackgroundAgentRunError(failureMessage, { ...failureResult, ...(notificationId ? { notificationId } : {}) }, error);
-            }
-            availableIsolation = undefined;
             let result;
             let failure;
             let cleanup;
+            const finishLifecycle = async (state, result, detail, notification) => {
+                if (execution) {
+                    const snapshot = await execution.finish(state, result, detail, notification);
+                    publishLifecycle(snapshot.state);
+                }
+                else
+                    publishLifecycle(state);
+            };
             try {
-                result = await options.execute(isolation?.cwd ?? options.parentCwd, message, signal, continuation);
-            }
-            catch (error) {
-                failure = error;
-            }
-            finally {
+                if (pendingExecution) {
+                    execution = pendingExecution;
+                    pendingExecution = undefined;
+                    publishLifecycle(execution.snapshot.state);
+                }
+                else if (options.lifecycle) {
+                    execution = await options.lifecycle.acquire(recoverNext ? 'recover' : continuation ? 'continue' : 'start');
+                    publishLifecycle(execution.snapshot.state);
+                    recoverNext = false;
+                }
+                if (execution) {
+                    const snapshot = await execution.running();
+                    publishLifecycle(snapshot.state);
+                }
+                else {
+                    publishLifecycle('running');
+                }
+                onAbort = () => {
+                    if (cancellation)
+                        return;
+                    if (!execution) {
+                        cancellation = Promise.resolve(publishLifecycle('cancelling'));
+                        return;
+                    }
+                    const activeExecution = execution;
+                    const transition = activeExecution.beginCancellation();
+                    transition.catch(() => undefined);
+                    const observedCancellation = transition
+                        .then((snapshot) => publishLifecycle(snapshot.state))
+                        .finally(() => publishLifecycle(activeExecution.snapshot.state));
+                    observedCancellation.catch(() => undefined);
+                    cancellation = observedCancellation;
+                };
+                signal.addEventListener('abort', onAbort, { once: true });
+                if (signal.aborted)
+                    onAbort();
                 try {
-                    cleanup = await isolation?.cleanup();
+                    isolation = options.input.isolation
+                        ? (retainedIsolation ??
+                            availableIsolation ??
+                            (await options.createIsolation()))
+                        : undefined;
+                    availableIsolation = undefined;
+                    result = await options.execute(isolation?.cwd ?? options.parentCwd, message, signal, continuation);
                 }
                 catch (error) {
-                    failure ??= error;
+                    failure = error;
                 }
-                retainedIsolation = cleanup?.retained ? isolation : undefined;
-            }
-            if (failure !== undefined) {
-                const underlyingFailure = failure instanceof SubagentExecutionFailure ? failure.cause : failure;
-                const failureMessage = underlyingFailure instanceof Error
-                    ? underlyingFailure.message
-                    : String(underlyingFailure);
-                const detail = cleanup?.reason
-                    ? `${failureMessage}\n${cleanup.reason}`
-                    : failureMessage;
-                const partialResult = failure instanceof SubagentExecutionFailure
-                    ? failure.result
-                    : undefined;
-                const failureResult = {
-                    ...partialResult,
-                    text: failureMessage,
-                    usage: partialResult?.usage ?? {
-                        inputTokens: 0,
-                        outputTokens: 0,
-                    },
-                    toolUseCount: partialResult?.toolUseCount ?? 0,
-                    durationMs: Date.now() - startedAt,
-                    ...(isolation ? { isolationPath: isolation.cwd } : {}),
-                    ...(cleanup ? { isolationRetained: cleanup.retained } : {}),
-                    ...(cleanup?.reason ? { isolationWarning: cleanup.reason } : {}),
-                };
-                const status = signal.aborted ? 'killed' : 'failed';
-                const notificationId = notificationExpected &&
-                    !(signal.reason instanceof BackgroundAgentShutdownError)
-                    ? randomUUID()
-                    : undefined;
-                await options.lifecycle?.write(status, detail, {
-                    result: failureResult,
-                    ...(notificationId
+                finally {
+                    try {
+                        cleanup = await isolation?.cleanup();
+                    }
+                    catch (error) {
+                        failure ??= error;
+                    }
+                    retainedIsolation = cleanup?.retained ? isolation : undefined;
+                }
+                if (failure !== undefined) {
+                    const underlyingFailure = failure instanceof SubagentExecutionFailure
+                        ? failure.cause
+                        : failure;
+                    const failureMessage = underlyingFailure instanceof Error
+                        ? underlyingFailure.message
+                        : String(underlyingFailure);
+                    const detail = cleanup?.reason
+                        ? `${failureMessage}\n${cleanup.reason}`
+                        : failureMessage;
+                    const partialResult = failure instanceof SubagentExecutionFailure
+                        ? failure.result
+                        : undefined;
+                    const failureResult = {
+                        ...partialResult,
+                        text: failureMessage,
+                        usage: partialResult?.usage ?? {
+                            inputTokens: 0,
+                            outputTokens: 0,
+                        },
+                        toolUseCount: partialResult?.toolUseCount ?? 0,
+                        durationMs: Date.now() - startedAt,
+                        ...(isolation ? { isolationPath: isolation.cwd } : {}),
+                        ...(cleanup ? { isolationRetained: cleanup.retained } : {}),
+                        ...(cleanup?.reason ? { isolationWarning: cleanup.reason } : {}),
+                    };
+                    await cancellation;
+                    const status = signal.aborted ? 'killed' : 'failed';
+                    const notificationId = notificationExpected &&
+                        !(signal.reason instanceof BackgroundAgentShutdownError)
+                        ? randomUUID()
+                        : undefined;
+                    await finishLifecycle(signal.aborted ? 'cancelled' : 'failed', failureResult, detail, notificationId
                         ? {
-                            notification: {
-                                id: notificationId,
-                                status,
-                                toolUseId: currentToolUseId,
-                                error: detail,
-                            },
+                            id: notificationId,
+                            status,
+                            toolUseId: currentToolUseId,
+                            error: detail,
                         }
-                        : {}),
-                });
-                if (!notificationExpected && !isolation && !cleanup?.reason) {
-                    throw underlyingFailure;
+                        : undefined);
+                    lifecycleTerminalized = true;
+                    if (!notificationExpected && !isolation && !cleanup?.reason) {
+                        throw underlyingFailure;
+                    }
+                    throw new BackgroundAgentRunError(detail, { ...failureResult, ...(notificationId ? { notificationId } : {}) }, underlyingFailure);
                 }
-                throw new BackgroundAgentRunError(detail, { ...failureResult, ...(notificationId ? { notificationId } : {}) }, underlyingFailure);
-            }
-            if (!result) {
-                const error = new Error('Agent completed without a result');
-                const failureResult = {
-                    text: error.message,
-                    usage: { inputTokens: 0, outputTokens: 0 },
-                    toolUseCount: 0,
+                if (!result) {
+                    const error = new Error('Agent completed without a result');
+                    const failureResult = {
+                        text: error.message,
+                        usage: { inputTokens: 0, outputTokens: 0 },
+                        toolUseCount: 0,
+                        durationMs: Date.now() - startedAt,
+                        ...(isolation ? { isolationPath: isolation.cwd } : {}),
+                        ...(cleanup ? { isolationRetained: cleanup.retained } : {}),
+                        ...(cleanup?.reason ? { isolationWarning: cleanup.reason } : {}),
+                    };
+                    const notificationId = notificationExpected &&
+                        !(signal.reason instanceof BackgroundAgentShutdownError)
+                        ? randomUUID()
+                        : undefined;
+                    await cancellation;
+                    await finishLifecycle(signal.aborted ? 'cancelled' : 'failed', failureResult, error.message, notificationId
+                        ? {
+                            id: notificationId,
+                            status: signal.aborted ? 'killed' : 'failed',
+                            toolUseId: currentToolUseId,
+                            error: error.message,
+                        }
+                        : undefined);
+                    lifecycleTerminalized = true;
+                    if (!notificationExpected)
+                        throw error;
+                    throw new BackgroundAgentRunError(error.message, { ...failureResult, ...(notificationId ? { notificationId } : {}) }, error);
+                }
+                const finalResult = {
+                    ...result,
                     durationMs: Date.now() - startedAt,
                     ...(isolation ? { isolationPath: isolation.cwd } : {}),
                     ...(cleanup ? { isolationRetained: cleanup.retained } : {}),
                     ...(cleanup?.reason ? { isolationWarning: cleanup.reason } : {}),
                 };
+                await cancellation;
+                const status = signal.aborted ? 'killed' : 'completed';
+                const detail = signal.aborted
+                    ? 'Agent was aborted before terminal cleanup'
+                    : undefined;
                 const notificationId = notificationExpected &&
                     !(signal.reason instanceof BackgroundAgentShutdownError)
                     ? randomUUID()
                     : undefined;
-                await options.lifecycle?.write('failed', error.message, {
-                    result: failureResult,
-                    ...(notificationId
-                        ? {
-                            notification: {
-                                id: notificationId,
-                                status: 'failed',
-                                toolUseId: currentToolUseId,
-                                error: error.message,
-                            },
-                        }
-                        : {}),
-                });
-                if (!notificationExpected)
-                    throw error;
-                throw new BackgroundAgentRunError(error.message, { ...failureResult, ...(notificationId ? { notificationId } : {}) }, error);
-            }
-            const finalResult = {
-                ...result,
-                durationMs: Date.now() - startedAt,
-                ...(isolation ? { isolationPath: isolation.cwd } : {}),
-                ...(cleanup ? { isolationRetained: cleanup.retained } : {}),
-                ...(cleanup?.reason ? { isolationWarning: cleanup.reason } : {}),
-            };
-            const status = signal.aborted ? 'killed' : 'completed';
-            const detail = signal.aborted
-                ? 'Agent was aborted before terminal cleanup'
-                : undefined;
-            const notificationId = notificationExpected &&
-                !(signal.reason instanceof BackgroundAgentShutdownError)
-                ? randomUUID()
-                : undefined;
-            await options.lifecycle?.write(status, detail, {
-                result: finalResult,
-                ...(notificationId
+                await finishLifecycle(signal.aborted ? 'cancelled' : 'completed', finalResult, detail, notificationId
                     ? {
-                        notification: {
-                            id: notificationId,
-                            status,
-                            toolUseId: currentToolUseId,
-                            error: status === 'killed' ? (detail ?? null) : null,
-                        },
+                        id: notificationId,
+                        status,
+                        toolUseId: currentToolUseId,
+                        error: status === 'killed' ? (detail ?? null) : null,
                     }
-                    : {}),
-            });
-            return {
-                ...finalResult,
-                ...(notificationId ? { notificationId } : {}),
-            };
+                    : undefined);
+                lifecycleTerminalized = true;
+                return {
+                    ...finalResult,
+                    ...(notificationId ? { notificationId } : {}),
+                };
+            }
+            finally {
+                if (onAbort)
+                    signal.removeEventListener('abort', onAbort);
+                if (!lifecycleTerminalized) {
+                    try {
+                        await execution?.release();
+                    }
+                    catch (releaseError) {
+                        this.options.eventSink?.({
+                            type: 'warning',
+                            message: `Background agent execution cleanup could not release its durable owner; durable owner reconciliation is required: ${releaseError instanceof Error ? releaseError.message : String(releaseError)}`,
+                        });
+                    }
+                    finally {
+                        if (execution)
+                            publishLifecycle(execution.snapshot.state);
+                    }
+                }
+                else {
+                    try {
+                        await execution?.release();
+                    }
+                    finally {
+                        if (execution)
+                            publishLifecycle(execution.snapshot.state);
+                    }
+                }
+            }
         };
         return {
             run,
             markBackground: () => {
                 notificationExpected = true;
             },
+            disposeBeforeStart,
+            lifecycle,
         };
     }
     async runWorkflowAgent(options) {
@@ -1158,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(),
@@ -1168,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,
@@ -1204,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();
@@ -1309,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 };
         }
@@ -1372,40 +1645,74 @@ 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 &&
             (lastAssistant.toolCalls?.length ?? 0) === 0;
         const lifecycleStore = new SubagentLifecycleStore(paths.praxisRoot, sessionId, agentId, sidechainPaths.transcriptFile);
-        const lifecycle = await lifecycleStore.read();
+        const ownership = await lifecycleStore.reconcileOwnerLoss();
+        if (ownership.owned)
+            return;
+        let lifecycle = await lifecycleStore.read();
+        if (!lifecycle) {
+            const seed = await lifecycleStore.start();
+            await seed.running();
+            if (completed) {
+                await seed.finish('completed', {
+                    text: lastAssistant?.content ?? '',
+                    usage: { inputTokens: 0, outputTokens: 0 },
+                    toolUseCount: 0,
+                    durationMs: 0,
+                });
+            }
+            await seed.release();
+            lifecycle = await lifecycleStore.read();
+        }
+        if (!lifecycle) {
+            throw new Error(`Unable to establish lifecycle state for background agent ${agentId}`);
+        }
         const lifecycleIsCurrent = lifecycle !== null && (await lifecycleStore.matchesTranscript(lifecycle));
         if (lifecycleIsCurrent && lifecycle.status === 'completed' && !completed) {
             throw new Error(`Background agent ${agentId} has completed lifecycle state but an incomplete sidechain`);
@@ -1445,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') &&
@@ -1480,27 +1789,39 @@ 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,
             lifecycle: lifecycleStore,
+            recover: lifecycle.lifecycle.state === 'orphaned',
+            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,
@@ -1511,31 +1832,34 @@ export class ClaudeSubagentExecutor {
             toolUseId,
             outputFile: sidechainPaths.transcriptFile,
             resolvedModel: provider.model ?? 'praxis/provider',
+            lifecycle: backgroundRun.lifecycle,
             run: backgroundRun.run,
             markBackground: backgroundRun.markBackground,
             acknowledgeNotification: (notificationId) => lifecycleStore.acknowledgeNotification(notificationId),
             prepareNotificationDetached: (notificationId, model) => lifecycleStore.prepareNotificationDetached(notificationId, model),
             confirmNotificationDetached: (notificationId) => lifecycleStore.confirmNotificationDetached(notificationId),
         };
-        if (lifecycleIsCurrent && lifecycle.status === 'failed') {
-            this.background.registerTerminal(spec, 'failed', lifecycle.detail ?? 'Persisted agent failed');
-        }
-        else if (lifecycleIsCurrent && lifecycle.status === 'killed') {
-            this.background.registerTerminal(spec, 'stopped', lifecycle.detail ?? 'Persisted agent was killed');
-        }
-        else if (completed) {
-            this.background.registerCompleted(spec, lifecycleIsCurrent && lifecycle.result
-                ? lifecycle.result
-                : {
-                    text: lastAssistant.content,
-                    usage: { inputTokens: 0, outputTokens: 0 },
-                    toolUseCount: 0,
-                    durationMs: 0,
-                });
-        }
-        else {
-            this.background.registerInterrupted(spec);
-        }
+        this.background.registerPersisted(spec, {
+            ...(lifecycleIsCurrent && lifecycle.result
+                ? { result: lifecycle.result }
+                : completed
+                    ? {
+                        result: {
+                            text: lastAssistant.content,
+                            usage: { inputTokens: 0, outputTokens: 0 },
+                            toolUseCount: 0,
+                            durationMs: 0,
+                        },
+                    }
+                    : {}),
+            ...(lifecycleIsCurrent && lifecycle.status === 'failed'
+                ? { error: lifecycle.detail ?? 'Persisted agent failed' }
+                : lifecycleIsCurrent && lifecycle.status === 'killed'
+                    ? { error: lifecycle.detail ?? 'Persisted agent was killed' }
+                    : !completed && lifecycle.lifecycle.state === 'orphaned'
+                        ? { error: 'Persisted agent was interrupted before completion' }
+                        : {}),
+        });
         for (const notification of lifecycle?.notifications ?? []) {
             if (notification.consumed)
                 continue;
@@ -1553,7 +1877,7 @@ export class ClaudeSubagentExecutor {
             }
             this.background.registerPersistedNotification(agentId, {
                 id: notification.id,
-                status: notification.status === 'killed' ? 'stopped' : notification.status,
+                status: notification.status === 'killed' ? 'cancelled' : notification.status,
                 result: notification.result,
                 error: notification.error,
                 toolUseId: notification.toolUseId,
@@ -1680,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 };
@@ -1726,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',
@@ -1798,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,
@@ -1893,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',
@@ -1909,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) {
@@ -1933,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',
@@ -1954,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?.({
@@ -2031,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;
@@ -2046,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,
@@ -2068,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',
@@ -2088,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,