praxis-agent 0.35.0 → 0.36.0

package/dist/application/subagent-service.js

@@ -17,7 +17,7 @@ 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 { 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';
@@ -716,11 +716,53 @@ 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,
@@ -749,19 +791,16 @@ export class ClaudeSubagentExecutor {
             });
         }
         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({
@@ -790,6 +829,7 @@ export class ClaudeSubagentExecutor {
             toolUseId: call.id,
             outputFile: sidechainPaths.transcriptFile,
             resolvedModel,
+            lifecycle: backgroundRun.lifecycle,
             run: backgroundRun.run,
             markBackground: backgroundRun.markBackground,
             ...(lifecycleStore
@@ -820,7 +860,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 +998,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) {
@@ -1405,7 +1561,27 @@ export class ClaudeSubagentExecutor {
             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`);
@@ -1484,6 +1660,8 @@ export class ClaudeSubagentExecutor {
             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({
@@ -1511,31 +1689,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 +1734,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,

package/dist/application/top-level-agent-manager.d.ts

@@ -59,6 +59,7 @@ export declare class TopLevelAgentManager {
         cwd?: string;
         all: boolean;
     }): Promise<TopLevelAgentSummary[]>;
+    private readLifecycleView;
     private nativeSessions;
     logs(id: string): Promise<string>;
     review(agent: Pick<TopLevelAgentSummary, 'id' | 'cwd' | 'sessionId'>): Promise<string>;