praxis-agent 0.33.0 → 0.35.0

package/dist/application/subagent-service.js

@@ -1,14 +1,15 @@
 import { randomBytes, randomUUID } from 'node:crypto';
 import { lstat, mkdir, readFile, readdir } from 'node:fs/promises';
-import { join, relative } from 'node:path';
+import { isAbsolute, join, relative } from 'node:path';
 import { Ajv2020 } from 'ajv/dist/2020.js';
 import { resolveClaudePaths } from '../compatibility/claude/paths.js';
 import { workflowAgentFiles } from '../compatibility/claude/workflow.js';
-import { createClaudeAsyncAgentToolUseResult, createClaudeAgentToolUseResult, createClaudeSidechainRoot, resolveClaudeSidechainPaths, toClaudeSidechainEntry, } from '../compatibility/claude/sidechain.js';
-import { projectClaudeModelMessages } from '../compatibility/claude/projection.js';
+import { createClaudeAsyncAgentToolUseResult, createClaudeAgentToolUseResult, createClaudeSidechainRoot, isClaudeAgentId, resolveClaudeSidechainPaths, toClaudeSidechainEntry, } from '../compatibility/claude/sidechain.js';
+import { projectClaudeModelMessages, projectClaudeSidechainContinuationMessages, } from '../compatibility/claude/projection.js';
 import { selectClaudeSchemaAdapter, } from '../compatibility/claude/schema.js';
 import { createClaudeHookAttachmentEntries, translateProviderEvents, } from '../compatibility/claude/translation.js';
-import { injectFirstUserMessageContext, } from '../core/context.js';
+import { injectFirstUserMessageContext, projectContextSnapshot, } from '../core/context.js';
+import { assembleContextSnapshot } from '../core/prompt-composer.js';
 import { ContextBudget } from '../core/context-budget.js';
 import { AgentRuntime, } from '../core/runtime.js';
 import { resolveToolSchedulingPolicy } from '../core/tool-scheduling-policy.js';
@@ -16,21 +17,105 @@ import { BUILTIN_STATUSLINE_AGENT_PATH, } from '../extensions/claude-extensions.
 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 { resolveDataPlanePaths, } from '../persistence/data-plane.js';
-import { BackgroundAgentManager, BackgroundAgentRunError, } from './background-agent-manager.js';
+import { BackgroundAgentManager, BackgroundAgentRunError, BackgroundAgentShutdownError, backgroundAgentNotificationMarkers, } from './background-agent-manager.js';
 import { isBackgroundBashTaskId } from './background-task-id.js';
-import { createManagedWorktree, } from './managed-worktree.js';
+import { createManagedWorktree, restoreManagedWorktree, } from './managed-worktree.js';
 import { createWorkflowWorktree } from './workflow-worktree.js';
 const DEFAULT_MAX_DEPTH = 4;
 const DEFAULT_MAX_CALLS = 16;
 const DEFAULT_MAX_OUTPUT_BYTES = 1024 * 1024;
 const SIDECHAIN_DISCOVERY_MAX_DEPTH = 4;
+function mergeSubagentUsage(left, right) {
+    for (const usage of [left, right]) {
+        for (const field of [
+            'inputTokens',
+            'outputTokens',
+            'cacheReadInputTokens',
+            'cacheCreationInputTokens',
+            'webSearchRequests',
+        ]) {
+            const value = usage[field];
+            if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
+                throw new Error(`Subagent usage has an invalid ${field}`);
+            }
+        }
+        for (const field of ['contextWindow', 'maxOutputTokens']) {
+            const value = usage[field];
+            if (value !== undefined && (!Number.isSafeInteger(value) || value < 1)) {
+                throw new Error(`Subagent usage has an invalid ${field}`);
+            }
+        }
+    }
+    const counters = {
+        inputTokens: left.inputTokens + right.inputTokens,
+        outputTokens: left.outputTokens + right.outputTokens,
+        cacheReadInputTokens: (left.cacheReadInputTokens ?? 0) + (right.cacheReadInputTokens ?? 0),
+        cacheCreationInputTokens: (left.cacheCreationInputTokens ?? 0) +
+            (right.cacheCreationInputTokens ?? 0),
+        webSearchRequests: (left.webSearchRequests ?? 0) + (right.webSearchRequests ?? 0),
+    };
+    if (Object.values(counters).some((value) => !Number.isSafeInteger(value))) {
+        throw new Error('Subagent usage total overflow');
+    }
+    const metadata = (field) => {
+        const leftValue = left[field];
+        const rightValue = right[field];
+        if (leftValue !== undefined &&
+            rightValue !== undefined &&
+            leftValue !== rightValue) {
+            throw new Error(`Subagent usage has conflicting ${field}`);
+        }
+        return leftValue ?? rightValue;
+    };
+    const contextWindow = metadata('contextWindow');
+    const maxOutputTokens = metadata('maxOutputTokens');
+    return {
+        inputTokens: counters.inputTokens,
+        outputTokens: counters.outputTokens,
+        ...(counters.cacheReadInputTokens === 0
+            ? {}
+            : { cacheReadInputTokens: counters.cacheReadInputTokens }),
+        ...(counters.cacheCreationInputTokens === 0
+            ? {}
+            : { cacheCreationInputTokens: counters.cacheCreationInputTokens }),
+        ...(counters.webSearchRequests === 0
+            ? {}
+            : { webSearchRequests: counters.webSearchRequests }),
+        ...(contextWindow === undefined ? {} : { contextWindow }),
+        ...(maxOutputTokens === undefined ? {} : { maxOutputTokens }),
+    };
+}
+function mergeSubagentModelUsage(target, source) {
+    for (const [model, usage] of Object.entries(source)) {
+        if (model.trim().length === 0) {
+            throw new Error('Subagent model usage has a blank model name');
+        }
+        target.set(model, mergeSubagentUsage(target.get(model) ?? { inputTokens: 0, outputTokens: 0 }, usage));
+    }
+}
+class SubagentExecutionFailure extends Error {
+    result;
+    name = 'SubagentExecutionFailure';
+    constructor(cause, result) {
+        super(cause instanceof Error ? cause.message : String(cause), { cause });
+        this.result = result;
+    }
+}
 const structuredOnlyTools = {
     definitions: () => [],
     schedulingPolicy: () => ({ concurrency: 'exclusive' }),
     prepare: async (call) => call,
     execute: async () => ({ content: '', isError: false }),
 };
+function sidechainAgentIdFromFile(fileName, suffix) {
+    if (!fileName.startsWith('agent-') || !fileName.endsWith(suffix)) {
+        return undefined;
+    }
+    const agentId = fileName.slice('agent-'.length, -suffix.length);
+    return isClaudeAgentId(agentId) ? agentId : undefined;
+}
 async function readSidechainMetadataName(metadataFile) {
     try {
         const value = JSON.parse(await readFile(metadataFile, 'utf8'));
@@ -368,6 +453,7 @@ export class ClaudeSubagentExecutor {
     calls = 0;
     background = new BackgroundAgentManager();
     ephemeralSidechains = new Map();
+    foreground = new Map();
     isEnabled(name) {
         return this.options.toolNames?.includes(name) ?? true;
     }
@@ -376,14 +462,55 @@ export class ClaudeSubagentExecutor {
         this.schema = selectClaudeSchemaAdapter(options.claudeVersion);
     }
     async close() {
+        for (const agentId of [...this.foreground.keys()]) {
+            this.backgroundForegroundTask(agentId);
+        }
         await this.background.close();
+        this.foreground.clear();
         this.ephemeralSidechains.clear();
     }
     backgroundSnapshots() {
         return this.background.snapshots();
     }
+    hasForegroundTask() {
+        return this.foreground.size > 0;
+    }
+    backgroundForegroundTask(identifier) {
+        const candidates = [...this.foreground.entries()];
+        const selected = identifier === undefined
+            ? candidates.at(-1)
+            : candidates.find(([agentId, task]) => agentId === identifier || task.spec.name === identifier);
+        if (!selected) {
+            throw new Error(identifier === undefined
+                ? 'No foreground agent is running'
+                : `No foreground agent found with ID or name: ${identifier}`);
+        }
+        const [, task] = selected;
+        if (task.backgrounded) {
+            throw new Error(`Agent ${task.spec.agentId} is already backgrounded`);
+        }
+        const snapshot = this.background.adopt({
+            spec: task.spec,
+            controller: task.controller,
+            operation: task.operation,
+            startedAt: task.startedAt,
+        });
+        task.backgrounded = true;
+        task.detachParentSignal();
+        task.resolveHandoff();
+        return snapshot;
+    }
     stopBackgroundTask(taskId) {
-        return this.background.stop(taskId);
+        return this.background.stopAndWait(taskId);
+    }
+    outputBackgroundTask(taskId, options) {
+        return this.background.output(taskId, options);
+    }
+    sendBackgroundMessage(agentId, message, summary, toolUseId) {
+        return this.background.send(agentId, message, summary, toolUseId);
+    }
+    stopAllBackgroundTasks() {
+        return this.background.stopAll();
     }
     cwd() {
         return this.options.cwdProvider?.() ?? this.options.cwd;
@@ -398,7 +525,7 @@ export class ClaudeSubagentExecutor {
             ? definition.model
             : undefined;
         const model = environmentModel || input.model || configuredModel;
-        const parentPermissionMode = this.options.parentPermissionMode?.();
+        const parentPermissionMode = this.options.parentPermissionMode?.() ?? 'default';
         const definitionCanOverridePermissionMode = ![
             'acceptEdits',
             'auto',
@@ -406,7 +533,7 @@ export class ClaudeSubagentExecutor {
         ].includes(parentPermissionMode ?? 'default');
         const permissionMode = input.permissionMode ??
             (definitionCanOverridePermissionMode
-                ? definition?.permissionMode
+                ? (definition?.permissionMode ?? parentPermissionMode)
                 : parentPermissionMode);
         const isolation = input.isolation ?? definition?.isolation;
         return {
@@ -417,8 +544,8 @@ export class ClaudeSubagentExecutor {
             runInBackground: input.runInBackground || definition?.background === true,
         };
     }
-    registry(sessionId, depth, promptIdForCall) {
-        return new ClaudeSubagentToolRegistry(this.options.baseTools, this, sessionId, depth, promptIdForCall);
+    registry(sessionId, depth, promptIdForCall, parentAgentId) {
+        return new ClaudeSubagentToolRegistry(this.options.baseTools, this, sessionId, depth, promptIdForCall, parentAgentId);
     }
     definitions() {
         return {
@@ -558,7 +685,9 @@ export class ClaudeSubagentExecutor {
         if (input.model && !this.options.providerForModel) {
             throw new Error('Agent model overrides are unavailable for this provider');
         }
-        if (input.permissionMode && !this.options.permissionResolverForMode) {
+        if (input.permissionMode &&
+            input.permissionMode !== 'default' &&
+            !this.options.permissionResolverForMode) {
             throw new Error('Agent permission mode overrides are unavailable');
         }
         return {
@@ -576,7 +705,7 @@ export class ClaudeSubagentExecutor {
             },
         };
     }
-    async execute(call, sessionId, depth, promptId, context) {
+    async execute(call, sessionId, depth, promptId, context, parentAgentId) {
         this.calls += 1;
         const maxCalls = this.options.maxCalls ?? DEFAULT_MAX_CALLS;
         if (this.calls > maxCalls) {
@@ -585,11 +714,12 @@ export class ClaudeSubagentExecutor {
         const input = this.resolveAgentInput(parseAgentInput(call));
         const spawnDepth = depth + 1;
         const agentId = `a${randomBytes(8).toString('hex')}`;
-        const paths = this.sessionPaths(sessionId);
+        const parentCwd = context.cwd;
+        const paths = this.sessionPaths(sessionId, parentCwd);
         const initialIsolation = input.isolation
-            ? await this.createAgentWorktree(paths.praxisRoot, sessionId, agentId)
+            ? await this.createAgentWorktree(paths.praxisRoot, sessionId, agentId, parentCwd)
             : undefined;
-        const agentCwd = initialIsolation?.cwd ?? this.cwd();
+        const agentCwd = initialIsolation?.cwd ?? parentCwd;
         const sidechainPaths = resolveClaudeSidechainPaths(paths.projectRoot, sessionId, agentId);
         const sidechain = this.sidechainStore(sessionId, agentId, sidechainPaths, paths.praxisRoot);
         const root = createClaudeSidechainRoot({
@@ -614,6 +744,8 @@ export class ClaudeSubagentExecutor {
                     ? { permissionMode: input.permissionMode }
                     : {}),
                 ...(input.isolation ? { isolation: input.isolation } : {}),
+                ...(parentAgentId ? { parentAgentId } : {}),
+                ...(initialIsolation ? { worktreePath: initialIsolation.cwd } : {}),
             });
         }
         catch (error) {
@@ -623,10 +755,15 @@ export class ClaudeSubagentExecutor {
         const provider = input.model
             ? (this.options.providerForModel?.(input.model) ?? this.options.provider)
             : this.options.provider;
-        const run = this.createBackgroundAgentRun({
+        const lifecycleStore = this.options.persistence === 'memory'
+            ? undefined
+            : new SubagentLifecycleStore(paths.praxisRoot, sessionId, agentId, sidechainPaths.transcriptFile);
+        const backgroundRun = this.createBackgroundAgentRun({
             input,
+            parentCwd,
+            ...(lifecycleStore ? { lifecycle: lifecycleStore } : {}),
             ...(initialIsolation ? { initialIsolation } : {}),
-            createIsolation: () => this.createAgentWorktree(paths.praxisRoot, sessionId, agentId),
+            createIsolation: () => this.createAgentWorktree(paths.praxisRoot, sessionId, agentId, parentCwd),
             execute: (cwd, message, signal, continuation) => sidechain.withLease(async (lease) => this.runSidechain({
                 lease,
                 root,
@@ -643,48 +780,82 @@ export class ClaudeSubagentExecutor {
                 cwd,
             })),
         });
-        if (input.runInBackground) {
-            const resolvedModel = provider.model ?? 'praxis/provider';
-            this.background.launch({
+        const resolvedModel = provider.model ?? 'praxis/provider';
+        const spec = {
+            agentId,
+            ...(input.name ? { name: input.name } : {}),
+            agentType: input.subagentType,
+            description: input.description,
+            prompt: input.prompt,
+            toolUseId: call.id,
+            outputFile: sidechainPaths.transcriptFile,
+            resolvedModel,
+            run: backgroundRun.run,
+            markBackground: backgroundRun.markBackground,
+            ...(lifecycleStore
+                ? {
+                    acknowledgeNotification: (notificationId) => lifecycleStore.acknowledgeNotification(notificationId),
+                    prepareNotificationDetached: (notificationId, model) => lifecycleStore.prepareNotificationDetached(notificationId, model),
+                    confirmNotificationDetached: (notificationId) => lifecycleStore.confirmNotificationDetached(notificationId),
+                }
+                : {}),
+        };
+        const asyncResult = () => ({
+            content: this.asyncLaunchResult({
                 agentId,
-                ...(input.name ? { name: input.name } : {}),
-                agentType: input.subagentType,
                 description: input.description,
-                prompt: input.prompt,
-                toolUseId: call.id,
                 outputFile: sidechainPaths.transcriptFile,
-                resolvedModel,
-                run,
-            });
-            return {
-                content: this.asyncLaunchResult({
+                ...(initialIsolation ? { worktreePath: initialIsolation.cwd } : {}),
+            }),
+            isError: false,
+            nativeToolUseResult: {
+                ...createClaudeAsyncAgentToolUseResult({
+                    prompt: input.prompt,
                     agentId,
                     description: input.description,
+                    resolvedModel,
                     outputFile: sidechainPaths.transcriptFile,
-                    ...(initialIsolation ? { worktreePath: initialIsolation.cwd } : {}),
                 }),
-                isError: false,
-                nativeToolUseResult: {
-                    ...createClaudeAsyncAgentToolUseResult({
-                        prompt: input.prompt,
-                        agentId,
-                        description: input.description,
-                        resolvedModel,
-                        outputFile: sidechainPaths.transcriptFile,
-                    }),
-                    ...(initialIsolation ? { worktreePath: initialIsolation.cwd } : {}),
-                },
-            };
+                ...(initialIsolation ? { worktreePath: initialIsolation.cwd } : {}),
+            },
+        });
+        if (input.runInBackground) {
+            this.background.launch(spec);
+            return asyncResult();
         }
         const controller = new AbortController();
-        const abort = () => controller.abort();
+        const abort = () => controller.abort(context.signal?.reason);
         context.signal?.addEventListener('abort', abort, { once: true });
+        if (context.signal?.aborted)
+            abort();
+        const operation = backgroundRun.run(input.prompt, controller.signal, false, call.id);
+        let resolveHandoff;
+        const handoff = new Promise((resolve) => {
+            resolveHandoff = resolve;
+        });
+        const foreground = {
+            spec,
+            controller,
+            operation,
+            startedAt: Date.now(),
+            detachParentSignal: () => context.signal?.removeEventListener('abort', abort),
+            resolveHandoff,
+            backgrounded: false,
+        };
+        this.foreground.set(agentId, foreground);
         let result;
         try {
-            result = await run(input.prompt, controller.signal, false);
+            const outcome = await Promise.race([
+                operation.then((value) => ({ kind: 'completed', value })),
+                handoff.then(() => ({ kind: 'backgrounded' })),
+            ]);
+            if (outcome.kind === 'backgrounded')
+                return asyncResult();
+            result = outcome.value;
         }
         finally {
-            context.signal?.removeEventListener('abort', abort);
+            foreground.detachParentSignal();
+            this.foreground.delete(agentId);
         }
         const maxOutputBytes = this.options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
         if (Buffer.byteLength(result.text) > maxOutputBytes) {
@@ -721,7 +892,7 @@ export class ClaudeSubagentExecutor {
                     agentId,
                     agentType: input.subagentType,
                     text: result.text,
-                    resolvedModel: provider.model ?? 'praxis/provider',
+                    resolvedModel,
                     durationMs: result.durationMs,
                     usage: result.usage,
                     toolUseCount: result.toolUseCount,
@@ -750,23 +921,23 @@ export class ClaudeSubagentExecutor {
         }
         return store;
     }
-    sessionPaths(sessionId) {
+    sessionPaths(sessionId, cwd = this.cwd()) {
         return this.options.dataPlane === 'native'
             ? resolveDataPlanePaths({
                 dataPlane: 'native',
                 root: this.options.configRoot,
-                cwd: this.cwd(),
+                cwd,
                 sessionId,
             })
             : resolveClaudePaths({
                 configDir: this.options.configRoot,
-                cwd: this.cwd(),
+                cwd,
                 sessionId,
             });
     }
-    createAgentWorktree(praxisRoot, sessionId, agentId) {
+    createAgentWorktree(praxisRoot, sessionId, agentId, cwd = this.cwd()) {
         return createManagedWorktree({
-            cwd: this.cwd(),
+            cwd,
             parentDirectory: join(praxisRoot, 'agent-worktrees'),
             directoryName: `${sessionId}-${agentId}`,
             label: 'Agent',
@@ -775,55 +946,184 @@ export class ClaudeSubagentExecutor {
     createBackgroundAgentRun(options) {
         let availableIsolation = options.initialIsolation;
         let retainedIsolation;
-        return async (message, signal, continuation) => {
-            const isolation = options.input.isolation
-                ? (retainedIsolation ??
-                    availableIsolation ??
-                    (await options.createIsolation()))
-                : undefined;
-            availableIsolation = undefined;
+        let notificationExpected = options.input.runInBackground;
+        const run = async (message, signal, continuation, currentToolUseId) => {
+            await options.lifecycle?.write('running');
             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;
             try {
-                result = await options.execute(isolation?.cwd ?? this.cwd(), message, signal, continuation);
+                result = await options.execute(isolation?.cwd ?? options.parentCwd, message, signal, continuation);
             }
             catch (error) {
                 failure = error;
             }
             finally {
-                cleanup = await isolation?.cleanup();
+                try {
+                    cleanup = await isolation?.cleanup();
+                }
+                catch (error) {
+                    failure ??= error;
+                }
                 retainedIsolation = cleanup?.retained ? isolation : undefined;
             }
             if (failure !== undefined) {
-                if (isolation && cleanup) {
-                    const message = failure instanceof Error ? failure.message : String(failure);
-                    const result = {
-                        text: message,
-                        usage: { inputTokens: 0, outputTokens: 0 },
-                        toolUseCount: 0,
-                        durationMs: Date.now() - startedAt,
-                        isolationPath: isolation.cwd,
-                        isolationRetained: cleanup.retained,
-                        ...(cleanup.reason ? { isolationWarning: cleanup.reason } : {}),
-                    };
-                    throw new BackgroundAgentRunError(cleanup.reason ? `${message}\n${cleanup.reason}` : message, result, failure);
-                }
-                if (cleanup?.reason) {
-                    throw new Error(`${failure instanceof Error ? failure.message : String(failure)}\n${cleanup.reason}`, { cause: failure });
+                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
+                        ? {
+                            notification: {
+                                id: notificationId,
+                                status,
+                                toolUseId: currentToolUseId,
+                                error: detail,
+                            },
+                        }
+                        : {}),
+                });
+                if (!notificationExpected && !isolation && !cleanup?.reason) {
+                    throw underlyingFailure;
                 }
-                throw failure;
+                throw new BackgroundAgentRunError(detail, { ...failureResult, ...(notificationId ? { notificationId } : {}) }, underlyingFailure);
             }
-            if (!result)
-                throw new Error('Agent completed without a result');
-            return {
+            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 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
+                    ? {
+                        notification: {
+                            id: notificationId,
+                            status,
+                            toolUseId: currentToolUseId,
+                            error: status === 'killed' ? (detail ?? null) : null,
+                        },
+                    }
+                    : {}),
+            });
+            return {
+                ...finalResult,
+                ...(notificationId ? { notificationId } : {}),
+            };
+        };
+        return {
+            run,
+            markBackground: () => {
+                notificationExpected = true;
+            },
         };
     }
     async runWorkflowAgent(options) {
@@ -976,10 +1276,17 @@ export class ClaudeSubagentExecutor {
             input: { to, message, ...(summary === undefined ? {} : { summary }) },
         };
     }
-    async executeManagement(call, sessionId) {
+    async executeManagement(call, sessionId, context) {
         if (call.name === 'TaskOutput') {
             const taskId = String(call.input.task_id);
-            await this.hydrateCompletedTask(sessionId, taskId);
+            const owned = await this.options.outputOwnedBackgroundAgent?.(sessionId, taskId, {
+                block: Boolean(call.input.block),
+                timeout: Number(call.input.timeout),
+            });
+            if (owned !== undefined && owned !== null) {
+                return { content: owned, isError: false };
+            }
+            await this.hydratePersistedTask(sessionId, taskId, context.cwd);
             return {
                 content: await this.background.output(taskId, {
                     block: Boolean(call.input.block),
@@ -990,23 +1297,77 @@ export class ClaudeSubagentExecutor {
         }
         if (call.name === 'TaskStop') {
             const taskId = String(call.input.task_id);
-            await this.hydrateCompletedTask(sessionId, taskId);
-            return { content: this.background.stop(taskId), isError: false };
+            const owned = await this.options.stopOwnedBackgroundAgent?.(sessionId, taskId);
+            if (owned !== undefined && owned !== null) {
+                return { content: owned, isError: false };
+            }
+            await this.hydratePersistedTask(sessionId, taskId, context.cwd);
+            return {
+                content: await this.background.stopAndWait(taskId),
+                isError: false,
+            };
         }
         const agentId = String(call.input.to);
-        await this.hydrateCompletedTask(sessionId, agentId);
+        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);
+        if (owned !== undefined && owned !== null) {
+            return { content: owned, isError: false };
+        }
+        await this.hydratePersistedTask(sessionId, agentId, context.cwd);
         return {
-            content: this.background.send(agentId, String(call.input.message), typeof call.input.summary === 'string' ? call.input.summary : undefined, call.id),
+            content: this.background.send(agentId, String(call.input.message), summary, call.id),
             isError: false,
         };
     }
-    notifications(waitForRunning) {
-        return this.background.notifications({ waitForRunning });
+    notifications(waitForRunning, consume = true) {
+        return this.background.notifications({ waitForRunning, consume });
+    }
+    acknowledgeNotifications(messages) {
+        return this.background.acknowledge(messages);
+    }
+    prepareNotificationsDetached(messages) {
+        return this.background.prepareNotificationsDetached(messages);
+    }
+    confirmNotificationsDetached(messages) {
+        return this.background.confirmNotificationsDetached(messages);
+    }
+    reconcileDeliveredNotifications(delivered = this.options.notificationDelivered ?? (() => false)) {
+        return this.background.acknowledgeDelivered(delivered);
+    }
+    reconcileDetachedNotifications(delivered) {
+        return this.background.acknowledgeDeliveredAsDetached(delivered);
+    }
+    notificationClaimAgentIds() {
+        return this.background.notificationClaimAgentIds();
     }
-    async hydrateCompletedTask(sessionId, identifier) {
+    async hydratePersistedTasks(sessionId, parentCwd, excludedAgentIds = new Set()) {
+        if (this.options.persistence === 'memory')
+            return;
+        const paths = this.sessionPaths(sessionId, parentCwd);
+        const candidates = await this.discoverSidechainCandidates(paths.projectRoot, sessionId);
+        for (const agentId of new Set(candidates.map((candidate) => candidate.agentId))) {
+            if (excludedAgentIds.has(agentId) || this.background.has(agentId)) {
+                continue;
+            }
+            try {
+                const lifecycle = await new SubagentLifecycleStore(paths.praxisRoot, sessionId, agentId).read();
+                if (!lifecycle?.notifications?.some((notification) => !notification.consumed)) {
+                    continue;
+                }
+                await this.hydratePersistedTask(sessionId, agentId, parentCwd);
+            }
+            catch (error) {
+                this.options.eventSink?.({
+                    type: 'warning',
+                    message: `Background agent ${agentId} could not be recovered automatically: ${error instanceof Error ? error.message : String(error)}`,
+                });
+            }
+        }
+    }
+    async hydratePersistedTask(sessionId, identifier, parentCwd) {
         if (this.background.has(identifier))
             return;
-        const paths = this.sessionPaths(sessionId);
+        const paths = this.sessionPaths(sessionId, parentCwd);
         const sidechainPaths = await this.resolvePersistedSidechain(paths.projectRoot, sessionId, identifier);
         if (!sidechainPaths)
             return;
@@ -1040,10 +1401,14 @@ export class ClaudeSubagentExecutor {
             : '';
         const projected = projectClaudeModelMessages(snapshot.entries);
         const lastAssistant = projected.at(-1);
-        if (!lastAssistant ||
-            lastAssistant.role !== 'assistant' ||
-            (lastAssistant.toolCalls?.length ?? 0) > 0) {
-            throw new Error(`Background agent ${agentId} is not completed`);
+        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 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`);
         }
         const agentType = metadata?.agentType ?? 'general-purpose';
         const description = metadata?.description ?? 'Recovered Claude sidechain';
@@ -1051,7 +1416,60 @@ export class ClaudeSubagentExecutor {
         const spawnDepth = metadata?.spawnDepth ?? 1;
         const name = metadata?.name;
         const permissionMode = metadata?.permissionMode;
-        const isolation = metadata?.isolation;
+        let isolation = metadata?.isolation;
+        let restoredIsolation;
+        let restoredCwd = parentCwd;
+        if (isolation === 'worktree') {
+            if (metadata?.worktreePath === undefined) {
+                this.options.eventSink?.({
+                    type: 'warning',
+                    message: `Background agent ${agentId} has no retained worktree path; falling back to parent cwd ${parentCwd}`,
+                });
+                isolation = undefined;
+            }
+            else {
+                try {
+                    restoredIsolation = await restoreManagedWorktree({
+                        cwd: parentCwd,
+                        path: metadata.worktreePath,
+                        label: 'Agent',
+                    });
+                }
+                catch (error) {
+                    this.options.eventSink?.({
+                        type: 'warning',
+                        message: `Background agent ${agentId} could not restore its retained worktree; falling back to parent cwd ${parentCwd}: ${error instanceof Error ? error.message : String(error)}`,
+                    });
+                    isolation = undefined;
+                }
+            }
+        }
+        else {
+            const persistedCwd = root.cwd;
+            if (typeof persistedCwd === 'string' &&
+                persistedCwd.length > 0 &&
+                !persistedCwd.includes('\0') &&
+                isAbsolute(persistedCwd)) {
+                try {
+                    if (!(await lstat(persistedCwd)).isDirectory()) {
+                        throw new Error('persisted cwd is not a directory');
+                    }
+                    restoredCwd = persistedCwd;
+                }
+                catch (error) {
+                    this.options.eventSink?.({
+                        type: 'warning',
+                        message: `Background agent ${agentId} could not restore its persisted cwd; falling back to parent cwd ${parentCwd}: ${error instanceof Error ? error.message : String(error)}`,
+                    });
+                }
+            }
+            else {
+                this.options.eventSink?.({
+                    type: 'warning',
+                    message: `Background agent ${agentId} has an invalid persisted cwd; falling back to parent cwd ${parentCwd}`,
+                });
+            }
+        }
         const input = {
             description,
             prompt,
@@ -1062,9 +1480,12 @@ export class ClaudeSubagentExecutor {
             runInBackground: true,
         };
         const provider = this.options.provider;
-        const run = this.createBackgroundAgentRun({
+        const backgroundRun = this.createBackgroundAgentRun({
             input,
-            createIsolation: () => this.createAgentWorktree(paths.praxisRoot, sessionId, agentId),
+            parentCwd: restoredCwd,
+            lifecycle: lifecycleStore,
+            ...(restoredIsolation ? { initialIsolation: restoredIsolation } : {}),
+            createIsolation: () => this.createAgentWorktree(paths.praxisRoot, sessionId, agentId, parentCwd),
             execute: (cwd, message, signal, continuation) => sidechain.withLease(async (lease) => this.runSidechain({
                 lease,
                 root,
@@ -1081,7 +1502,7 @@ export class ClaudeSubagentExecutor {
                 cwd,
             })),
         });
-        this.background.registerCompleted({
+        const spec = {
             agentId,
             ...(name ? { name } : {}),
             agentType,
@@ -1090,16 +1511,57 @@ export class ClaudeSubagentExecutor {
             toolUseId,
             outputFile: sidechainPaths.transcriptFile,
             resolvedModel: provider.model ?? 'praxis/provider',
-            run,
-        }, {
-            text: lastAssistant.content,
-            usage: { inputTokens: 0, outputTokens: 0 },
-            toolUseCount: 0,
-            durationMs: 0,
-        });
+            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);
+        }
+        for (const notification of lifecycle?.notifications ?? []) {
+            if (notification.consumed)
+                continue;
+            if (this.options.notificationDelivered?.({
+                agentId,
+                toolUseId: notification.toolUseId,
+                status: notification.status,
+            })) {
+                if (notification.accounting?.kind === 'detached' &&
+                    !notification.accounting.delivered) {
+                    await lifecycleStore.confirmNotificationDetached(notification.id);
+                }
+                await lifecycleStore.acknowledgeNotification(notification.id);
+                continue;
+            }
+            this.background.registerPersistedNotification(agentId, {
+                id: notification.id,
+                status: notification.status === 'killed' ? 'stopped' : notification.status,
+                result: notification.result,
+                error: notification.error,
+                toolUseId: notification.toolUseId,
+            });
+        }
     }
     async resolvePersistedSidechain(projectRoot, sessionId, identifier) {
-        const isAgentId = /^a[0-9a-f]{16}$/u.test(identifier);
+        const isAgentId = isClaudeAgentId(identifier);
         const isName = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/u.test(identifier);
         if (!isAgentId && !isName)
             return null;
@@ -1107,6 +1569,9 @@ export class ClaudeSubagentExecutor {
         const matches = candidates.filter((candidate) => isAgentId
             ? candidate.agentId === identifier
             : candidate.name === identifier);
+        if (matches.length > 1) {
+            throw new Error(`Ambiguous persisted background agent ${identifier}: ${matches.length} sidechains match`);
+        }
         matches.sort((left, right) => (right.metadataModifiedAt ?? -Infinity) -
             (left.metadataModifiedAt ?? -Infinity) ||
             left.agentId.localeCompare(right.agentId) ||
@@ -1151,11 +1616,9 @@ export class ClaudeSubagentExecutor {
                 }
                 if (!entry.isFile())
                     return;
-                const metadataMatch = /^agent-(a[0-9a-f]{16})\.meta\.json$/u.exec(entry.name);
-                if (metadataMatch) {
-                    const agentId = metadataMatch[1];
-                    if (agentId === undefined)
-                        return;
+                const metadataAgentId = sidechainAgentIdFromFile(entry.name, '.meta.json');
+                if (metadataAgentId !== undefined) {
+                    const agentId = metadataAgentId;
                     const transcriptEntry = byName.get(`agent-${agentId}.jsonl`);
                     if (!transcriptEntry ||
                         transcriptEntry.isSymbolicLink() ||
@@ -1183,12 +1646,10 @@ export class ClaudeSubagentExecutor {
                     });
                     return;
                 }
-                const transcriptMatch = /^agent-(a[0-9a-f]{16})\.jsonl$/u.exec(entry.name);
-                if (!transcriptMatch)
-                    return;
-                const agentId = transcriptMatch[1];
-                if (agentId === undefined)
+                const transcriptAgentId = sidechainAgentIdFromFile(entry.name, '.jsonl');
+                if (transcriptAgentId === undefined)
                     return;
+                const agentId = transcriptAgentId;
                 // A metadata companion (even an invalid one) is owned by the
                 // metadata branch; only a bare transcript without metadata is a
                 // legacy candidate.
@@ -1218,7 +1679,7 @@ export class ClaudeSubagentExecutor {
     }
     async runSidechain(options) {
         const cwd = options.cwd ?? this.cwd();
-        const permissions = options.input.permissionMode
+        const permissions = options.input.permissionMode && options.input.permissionMode !== 'default'
             ? this.options.permissionResolverForMode?.(options.input.permissionMode)
             : this.options.permissions;
         if (!permissions) {
@@ -1226,6 +1687,10 @@ export class ClaudeSubagentExecutor {
         }
         let snapshot = await options.lease.load();
         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',
@@ -1253,6 +1718,12 @@ export class ClaudeSubagentExecutor {
         }
         let toolUseCount = 0;
         let taskTokenTotal = 0;
+        let recordedUsage = { inputTokens: 0, outputTokens: 0 };
+        let pendingProviderUsage;
+        const recordedModelUsage = new Map();
+        let recordedDurationApiMs = 0;
+        let recordedDurationApiWithoutRetriesMs = 0;
+        let recordedApiDurationSeen = false;
         let lastToolName;
         const taskStartedAt = Date.now();
         const append = async (entry) => {
@@ -1286,7 +1757,48 @@ export class ClaudeSubagentExecutor {
         const scopedHooks = scopedHookSettings.length > 0
             ? this.options.hooks?.withAdditionalSettings(scopedHookSettings)
             : this.options.hooks;
-        const nestedTools = this.registry(String(options.root.sessionId), options.spawnDepth, () => options.promptId);
+        const commitProviderUsage = () => {
+            if (!pendingProviderUsage)
+                return;
+            recordedUsage = mergeSubagentUsage(recordedUsage, pendingProviderUsage);
+            const model = options.provider.model?.trim();
+            if (model) {
+                mergeSubagentModelUsage(recordedModelUsage, {
+                    [model]: {
+                        ...pendingProviderUsage,
+                        ...(options.provider.capabilities.contextWindowTokens === undefined
+                            ? {}
+                            : {
+                                contextWindow: options.provider.capabilities.contextWindowTokens,
+                            }),
+                        ...(options.provider.capabilities.maxOutputTokens === undefined
+                            ? {}
+                            : {
+                                maxOutputTokens: options.provider.capabilities.maxOutputTokens,
+                            }),
+                    },
+                });
+            }
+            pendingProviderUsage = undefined;
+        };
+        const recordApiDuration = (options) => {
+            if (options.durationApiMs === undefined &&
+                options.durationApiWithoutRetriesMs === undefined) {
+                return;
+            }
+            const total = options.durationApiMs ?? 0;
+            const withoutRetries = options.durationApiWithoutRetriesMs ?? total;
+            if (!Number.isFinite(total) ||
+                total < 0 ||
+                !Number.isFinite(withoutRetries) ||
+                withoutRetries < 0) {
+                throw new Error('Subagent API duration must be finite and nonnegative');
+            }
+            recordedDurationApiMs += total;
+            recordedDurationApiWithoutRetriesMs += withoutRetries;
+            recordedApiDurationSeen = true;
+        };
+        const nestedTools = this.registry(String(options.root.sessionId), options.spawnDepth, () => options.promptId, options.agentId);
         const agentMcp = customAgent?.mcpServers?.length
             ? await this.options.mcp?.connectAgent?.({
                 specs: customAgent.mcpServers,
@@ -1330,6 +1842,7 @@ export class ClaudeSubagentExecutor {
             : permissions;
         const emit = (event) => {
             if (event.type === 'usage') {
+                pendingProviderUsage = event.usage;
                 taskTokenTotal += event.usage.inputTokens + event.usage.outputTokens;
                 this.options.eventSink?.({
                     type: 'task-progress',
@@ -1381,6 +1894,7 @@ export class ClaudeSubagentExecutor {
         });
         const observer = {
             assistantCompleted: async (message) => {
+                commitProviderUsage();
                 const [entry] = translateProviderEvents([
                     {
                         type: 'assistant-message',
@@ -1398,6 +1912,13 @@ export class ClaudeSubagentExecutor {
                 await append(toClaudeSidechainEntry(entry, options.agentId, options.input.subagentType));
             },
             toolCompleted: async (call, result) => {
+                if (result.usage) {
+                    recordedUsage = mergeSubagentUsage(recordedUsage, result.usage);
+                }
+                if (result.isError === false && result.modelUsage) {
+                    mergeSubagentModelUsage(recordedModelUsage, result.modelUsage);
+                }
+                recordApiDuration(result);
                 if (result.isError === false) {
                     const linesAdded = result.linesAdded ?? 0;
                     const linesRemoved = result.linesRemoved ?? 0;
@@ -1441,6 +1962,7 @@ export class ClaudeSubagentExecutor {
                     if (!entry)
                         throw new Error('Could not translate subagent follow-up');
                     await append(toClaudeSidechainEntry(entry, options.agentId, options.input.subagentType));
+                    await this.background.acknowledge([text]);
                 }
             },
         };
@@ -1474,9 +1996,6 @@ export class ClaudeSubagentExecutor {
             const agentSystem = memoryPrompt
                 ? `${baseSystem}\n\n${memoryPrompt}`
                 : baseSystem;
-            const system = options.outputSchema
-                ? `${agentSystem}\n\nYou MUST call StructuredOutput exactly once at the end with a value matching its schema.`
-                : agentSystem;
             const preloadedSkills = agentSkillMessages(this.options.extensions, customAgent);
             let stopHookActive = false;
             const contextBudget = options.provider.capabilities.contextWindowTokens
@@ -1495,20 +2014,28 @@ export class ClaudeSubagentExecutor {
                 ? runtimeTools.definitions()
                 : [];
             let observedMessages;
+            let stableSystemMessageCount = 0;
             const assembleMessages = async () => {
-                const assembledContext = await this.options.contextAssembler?.assemble({
+                const assembledContext = await assembleContextSnapshot(this.options.contextAssembler, {
                     cwd,
                     lifecycleId: options.agentId,
                     mode: 'subagent',
-                    baseSystemPrompt: system,
+                    baseSystemPrompt: agentSystem,
+                    ...(options.outputSchema
+                        ? {
+                            turn: {
+                                structuredOutput: true,
+                            },
+                        }
+                        : {}),
                 });
-                const composedSubagentPolicy = assembledContext?.promptSections?.some((section) => section.id === 'subagent-policy');
+                const contextProjection = projectContextSnapshot(assembledContext);
+                stableSystemMessageCount = contextProjection.stableSystemSectionCount;
                 const messages = [
-                    ...(assembledContext?.systemMessages ?? []),
-                    ...(composedSubagentPolicy
-                        ? []
-                        : [{ role: 'system', content: system }]),
-                    ...injectFirstUserMessageContext(projectClaudeModelMessages(snapshot.entries), assembledContext?.firstUserMessageContext),
+                    ...contextProjection.systemMessages,
+                    ...injectFirstUserMessageContext(options.continuationMessage === undefined
+                        ? projectClaudeModelMessages(snapshot.entries)
+                        : projectClaudeSidechainContinuationMessages(snapshot.entries), contextProjection.firstUserMessageContext),
                     ...preloadedSkills,
                 ];
                 observedMessages = messages;
@@ -1519,11 +2046,17 @@ export class ClaudeSubagentExecutor {
             };
             const configuredEffort = typeof customAgent?.effort === 'string' ? customAgent.effort : undefined;
             const effectiveEffort = options.effort ?? configuredEffort;
-            const result = await runtime.run({
+            const initialMessages = await assembleMessages();
+            const runtimeRequest = {
                 sessionId: String(options.root.sessionId),
-                messages: await assembleMessages(),
+                messages: initialMessages,
                 collectMetrics: true,
-                reloadMessages: assembleMessages,
+                stableSystemMessageCount,
+                reloadMessages: async () => {
+                    const messages = await assembleMessages();
+                    runtimeRequest.stableSystemMessageCount = stableSystemMessageCount;
+                    return messages;
+                },
                 cwd,
                 ...(effectiveEffort ? { effort: effectiveEffort } : {}),
                 toolResultDirectory: options.toolResultDirectory,
@@ -1555,10 +2088,26 @@ export class ClaudeSubagentExecutor {
                                     messages.push(`SubagentStop hook error: ${outcome.blockedReason}`);
                                 }
                             }
+                            await this.hydratePersistedTasks(String(options.root.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 background = await this.background.notifications({
                                 waitForRunning: false,
                                 excludeAgentId: options.agentId,
+                                consume: false,
                             });
+                            recordedUsage = mergeSubagentUsage(recordedUsage, background.usage);
+                            if (background.modelUsage) {
+                                mergeSubagentModelUsage(recordedModelUsage, background.modelUsage);
+                            }
+                            recordApiDuration(background);
                             messages.push(...background.messages);
                             messages.push(...((await this.options.backgroundTaskNotifications?.(true)) ?? []));
                             return {
@@ -1580,7 +2129,8 @@ export class ClaudeSubagentExecutor {
                     }
                     : {}),
                 ...(options.signal ? { signal: options.signal } : {}),
-            });
+            };
+            const result = await runtime.run(runtimeRequest);
             contextBudget?.observeUsage(result.usage, observedMessages ?? [], definitions);
             this.options.eventSink?.({
                 type: 'task-progress',
@@ -1614,20 +2164,38 @@ export class ClaudeSubagentExecutor {
             };
         }
         catch (error) {
-            this.options.eventSink?.({
-                type: 'task-notification',
-                taskId: options.agentId,
-                ...(options.toolUseId ? { toolUseId: options.toolUseId } : {}),
-                status: options.signal?.aborted ? 'stopped' : 'failed',
-                outputFile: options.transcriptPath,
-                summary: error instanceof Error ? error.message : String(error),
-                usage: {
-                    totalTokens: 0,
-                    toolUses: toolUseCount,
-                    durationMs: Date.now() - taskStartedAt,
-                },
+            commitProviderUsage();
+            const partialModelUsage = recordedModelUsage.size === 0
+                ? undefined
+                : Object.fromEntries(recordedModelUsage);
+            if (!(options.signal?.reason instanceof BackgroundAgentShutdownError)) {
+                this.options.eventSink?.({
+                    type: 'task-notification',
+                    taskId: options.agentId,
+                    ...(options.toolUseId ? { toolUseId: options.toolUseId } : {}),
+                    status: options.signal?.aborted ? 'stopped' : 'failed',
+                    outputFile: options.transcriptPath,
+                    summary: error instanceof Error ? error.message : String(error),
+                    usage: {
+                        totalTokens: recordedUsage.inputTokens + recordedUsage.outputTokens,
+                        toolUses: toolUseCount,
+                        durationMs: Date.now() - taskStartedAt,
+                    },
+                });
+            }
+            throw new SubagentExecutionFailure(error, {
+                text: error instanceof Error ? error.message : String(error),
+                usage: recordedUsage,
+                ...(partialModelUsage ? { modelUsage: partialModelUsage } : {}),
+                ...(recordedApiDurationSeen
+                    ? {
+                        durationApiMs: recordedDurationApiMs,
+                        durationApiWithoutRetriesMs: recordedDurationApiWithoutRetriesMs,
+                    }
+                    : {}),
+                toolUseCount,
+                durationMs: Date.now() - taskStartedAt,
             });
-            throw error;
         }
         finally {
             await agentMcp?.close().catch((error) => {
@@ -1645,12 +2213,14 @@ class ClaudeSubagentToolRegistry {
     sessionId;
     depth;
     promptIdForCall;
-    constructor(base, executor, sessionId, depth, promptIdForCall) {
+    parentAgentId;
+    constructor(base, executor, sessionId, depth, promptIdForCall, parentAgentId) {
         this.base = base;
         this.executor = executor;
         this.sessionId = sessionId;
         this.depth = depth;
         this.promptIdForCall = promptIdForCall;
+        this.parentAgentId = parentAgentId;
     }
     definitions() {
         const base = this.base.definitions();
@@ -1698,21 +2268,21 @@ class ClaudeSubagentToolRegistry {
     }
     async execute(call, context) {
         if (call.name === 'SendMessage') {
-            return this.executor.executeManagement(call, this.sessionId);
+            return this.executor.executeManagement(call, this.sessionId, context);
         }
         if (call.name === 'TaskOutput' || call.name === 'TaskStop') {
             const taskId = call.input.task_id ?? call.input.shell_id;
             if (typeof taskId === 'string' && isBackgroundBashTaskId(taskId)) {
                 return this.base.execute(call, context);
             }
-            return this.executor.executeManagement(call, this.sessionId);
+            return this.executor.executeManagement(call, this.sessionId, context);
         }
         if (call.name !== 'Agent')
             return this.base.execute(call, context);
         const promptId = this.promptIdForCall(call.id);
         if (!promptId)
             throw new Error(`Could not locate prompt for Agent ${call.id}`);
-        return this.executor.execute(call, this.sessionId, this.depth, promptId, context);
+        return this.executor.execute(call, this.sessionId, this.depth, promptId, context, this.parentAgentId);
     }
 }
 //# sourceMappingURL=subagent-service.js.map