@hansjm10/volt-coding-agent 0.0.0-bootstrap.0 → 0.1.0

package/dist/core/subagents/manager.js

@@ -0,0 +1,820 @@
+import { randomUUID } from "node:crypto";
+import { createInProcessRpcClient } from "../../modes/rpc/in-process-rpc-client.js";
+import { createAgentSessionRuntime, } from "../agent-session-runtime.js";
+import { parseModelPattern } from "../model-resolver.js";
+import { SessionManager } from "../session-manager.js";
+import { SubagentDelegationScope, } from "./delegation-scope.js";
+export class SubagentDefinitionNotFoundError extends Error {
+    agentName;
+    availableNames;
+    diagnostics;
+    constructor(agentName, availableNames, diagnostics = []) {
+        super(agentName.trim() ? `Subagent definition "${agentName}" was not found` : "Subagent definition name is required");
+        this.name = "SubagentDefinitionNotFoundError";
+        this.agentName = agentName;
+        this.availableNames = availableNames;
+        this.diagnostics = diagnostics;
+    }
+}
+export class SubagentDefinitionConfigurationError extends Error {
+    agentName;
+    field;
+    constructor(agentName, field, message) {
+        super(`Invalid subagent definition "${agentName}" ${field}: ${message}`);
+        this.name = "SubagentDefinitionConfigurationError";
+        this.agentName = agentName;
+        this.field = field;
+    }
+}
+const VALID_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+const MAX_RETAINED_ACTIVITIES = 50;
+const MAX_RETAINED_ACTIVITY_EVENTS = 2_000;
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function getTerminalActivityResult(event) {
+    for (let index = event.messages.length - 1; index >= 0; index -= 1) {
+        const message = event.messages[index];
+        if (!message || message.role !== "assistant") {
+            continue;
+        }
+        const assistant = message;
+        if (assistant.stopReason === "aborted") {
+            return { status: "aborted" };
+        }
+        if (assistant.stopReason === "error") {
+            return {
+                status: "failed",
+                ...(typeof assistant.errorMessage === "string" ? { error: assistant.errorMessage } : {}),
+            };
+        }
+        return { status: "completed" };
+    }
+    return { status: "completed" };
+}
+function isThinkingLevel(value) {
+    return VALID_THINKING_LEVELS.includes(value);
+}
+function normalizeUniqueNames(names) {
+    if (!names) {
+        return undefined;
+    }
+    return Array.from(new Set(names.map((name) => name.trim()).filter((name) => name.length > 0)));
+}
+function resolveEffectiveTools(options) {
+    const normalizedRequested = normalizeUniqueNames(options.requestedTools);
+    const normalizedAllowed = normalizeUniqueNames(options.allowedTools);
+    const normalizedExcluded = normalizeUniqueNames(options.excludedTools);
+    let effectiveTools;
+    if (normalizedRequested && normalizedAllowed) {
+        const allowed = new Set(normalizedAllowed);
+        effectiveTools = normalizedRequested.filter((toolName) => allowed.has(toolName));
+    }
+    else if (normalizedRequested) {
+        effectiveTools = normalizedRequested;
+    }
+    else if (normalizedAllowed) {
+        effectiveTools = normalizedAllowed;
+    }
+    else if (normalizedExcluded) {
+        effectiveTools = normalizeUniqueNames(options.defaultTools);
+    }
+    if (!effectiveTools || !normalizedExcluded) {
+        return effectiveTools;
+    }
+    const excluded = new Set(normalizedExcluded);
+    return effectiveTools.filter((toolName) => !excluded.has(toolName));
+}
+class LocalSubagentHandle {
+    id;
+    sessionId;
+    client;
+    abortRuntime;
+    removeFromManager;
+    onPromptStarted;
+    onPromptFailed;
+    onAbortRequested;
+    onTerminal;
+    waitForIdle;
+    eventListeners = new Set();
+    endPromise;
+    resolveEnd = () => { };
+    rejectEnd = () => { };
+    latestEndEvent;
+    settlementWatcherStarted = false;
+    promptStarted = false;
+    promptAccepted = false;
+    promptMessageObserved = false;
+    endSettled = false;
+    ownershipSettled = false;
+    abortRequested = false;
+    disposed = false;
+    disposePromise;
+    constructor(options) {
+        this.id = options.id;
+        this.sessionId = options.sessionId;
+        this.client = options.client;
+        this.abortRuntime = options.abortRuntime;
+        this.removeFromManager = options.removeFromManager;
+        this.onPromptStarted = options.onPromptStarted;
+        this.onPromptFailed = options.onPromptFailed;
+        this.onAbortRequested = options.onAbortRequested;
+        this.onTerminal = options.onTerminal;
+        this.waitForIdle = options.waitForIdle;
+        this.endPromise = new Promise((resolve, reject) => {
+            this.resolveEnd = resolve;
+            this.rejectEnd = reject;
+        });
+        void this.endPromise.catch(() => { });
+    }
+    async prompt(message) {
+        this.assertOpen();
+        this.promptStarted = true;
+        this.onPromptStarted(message);
+        try {
+            await this.client.prompt(message, undefined, () => {
+                this.promptAccepted = true;
+            });
+        }
+        catch (error) {
+            this.onPromptFailed(error);
+            this.settleOwnership();
+            throw error;
+        }
+    }
+    async abort() {
+        this.assertOpen();
+        this.abortRequested = true;
+        this.onAbortRequested();
+        // Abort the in-process runtime directly so cancellation is signalled before
+        // concurrent disposal can close the loopback transport.
+        await this.abortRuntime();
+    }
+    async getState() {
+        this.assertOpen();
+        return this.client.getState();
+    }
+    async getTranscript(options = {}) {
+        this.assertOpen();
+        return this.client.getTranscript(options);
+    }
+    async getSessionStats() {
+        this.assertOpen();
+        return this.client.getSessionStats();
+    }
+    waitForEnd() {
+        return this.endPromise;
+    }
+    onEvent(listener) {
+        this.eventListeners.add(listener);
+        return () => {
+            this.eventListeners.delete(listener);
+        };
+    }
+    dispose() {
+        if (this.disposePromise) {
+            return this.disposePromise;
+        }
+        this.disposed = true;
+        this.waitForIdle = undefined;
+        const abortInFlightRun = !this.endSettled && !this.abortRequested;
+        if (abortInFlightRun) {
+            // Disposing a still-running child must not orphan its turn: when the
+            // runtime is retained (daemon hosts keep child runtimes attachable),
+            // client.stop() only closes the loopback transport and the child would
+            // keep running on a result nobody can receive. Abort the runtime
+            // directly — the public abort() asserts the handle is still open — and
+            // do it fire-and-forget so a slow-to-cancel child cannot wedge
+            // disposal (and with it a lease handoff). Skipped when an abort was
+            // already requested through the handle so the runtime is signalled
+            // exactly once. Mark the abort request before rejecting the end
+            // promise so the manager's terminal handler records "aborted" rather
+            // than "failed".
+            this.onAbortRequested();
+            void this.abortRuntime().catch(() => undefined);
+        }
+        this.settleOwnership();
+        if (!this.endSettled) {
+            this.endSettled = true;
+            this.rejectEnd(new Error(`Subagent ${this.id} was disposed before completion`));
+        }
+        this.disposePromise = Promise.resolve().then(async () => {
+            try {
+                await this.client.stop();
+            }
+            finally {
+                this.eventListeners.clear();
+                this.removeFromManager(this.id);
+            }
+        });
+        return this.disposePromise;
+    }
+    handleEvent(event) {
+        if (this.disposed) {
+            return;
+        }
+        if (event.type === "message_start" &&
+            (event.message.role === "user" || event.message.role === "custom") &&
+            this.promptStarted) {
+            this.promptMessageObserved = true;
+        }
+        if (event.type === "agent_end" && this.promptMessageObserved) {
+            this.latestEndEvent = event;
+        }
+        for (const listener of this.eventListeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                // Listener failures should not break the child RPC event stream.
+            }
+        }
+        const shouldWatchSettlement = (event.type === "agent_end" && this.promptMessageObserved) ||
+            (event.type === "agent_settled" && this.promptAccepted);
+        if (shouldWatchSettlement && !this.settlementWatcherStarted && !this.disposed && !this.endSettled) {
+            this.settlementWatcherStarted = true;
+            void this.settleAfterIdle();
+        }
+    }
+    async settleAfterIdle() {
+        const waitForIdle = this.waitForIdle;
+        this.waitForIdle = undefined;
+        if (!waitForIdle) {
+            return;
+        }
+        try {
+            await waitForIdle();
+        }
+        catch (error) {
+            if (!this.disposed && !this.endSettled) {
+                this.endSettled = true;
+                this.settleOwnership();
+                this.rejectEnd(error instanceof Error ? error : new Error(String(error)));
+            }
+            return;
+        }
+        if (this.disposed || this.endSettled) {
+            return;
+        }
+        const latestEndEvent = this.latestEndEvent;
+        if (!this.promptMessageObserved || !latestEndEvent) {
+            this.endSettled = true;
+            this.settleOwnership();
+            this.rejectEnd(new Error(`Subagent ${this.id} settled without an agent result`));
+            return;
+        }
+        this.endSettled = true;
+        this.settleOwnership();
+        const event = latestEndEvent.willRetry ? { ...latestEndEvent, willRetry: false } : latestEndEvent;
+        this.resolveEnd({ id: this.id, sessionId: this.sessionId, event });
+    }
+    assertOpen() {
+        if (this.disposed) {
+            throw new Error(`Subagent ${this.id} is disposed`);
+        }
+    }
+    settleOwnership() {
+        if (this.ownershipSettled)
+            return;
+        this.ownershipSettled = true;
+        this.onTerminal();
+    }
+}
+export class SubagentManager {
+    createRuntime;
+    cwd;
+    agentDir;
+    resourceLoader;
+    parentSessionManager;
+    allowedTools;
+    subagentContext;
+    requestTimeoutMs;
+    retainRuntimeOnDispose;
+    onRuntimeCreated;
+    handles = new Map();
+    activities = new Map();
+    activityListeners = new Set();
+    childStartCount = 0;
+    disposePromise;
+    pendingStartCount = 0;
+    pendingStartWaiters = new Set();
+    constructor(options) {
+        this.createRuntime = options.createRuntime;
+        this.cwd = options.cwd;
+        this.agentDir = options.agentDir;
+        this.resourceLoader = options.resourceLoader;
+        this.parentSessionManager = options.parentSessionManager;
+        this.allowedTools = normalizeUniqueNames(options.allowedTools);
+        this.subagentContext = options.subagentContext;
+        this.requestTimeoutMs = options.requestTimeoutMs;
+        this.retainRuntimeOnDispose = options.retainRuntimeOnDispose ?? false;
+        this.onRuntimeCreated = options.onRuntimeCreated;
+    }
+    createDelegationScope(options = {}) {
+        this.assertNotDisposed();
+        const inherited = this.subagentContext?.delegationScope;
+        if (inherited) {
+            return { scope: inherited, owned: false };
+        }
+        return { scope: new SubagentDelegationScope(options), owned: true };
+    }
+    async start(options = {}) {
+        const finishStart = this.beginStart();
+        let releaseReservation = () => undefined;
+        let scopeLease;
+        let treeReservation;
+        try {
+            releaseReservation = this.reserveChildStart(undefined);
+            scopeLease = this.resolveDelegationScope(options.delegationScope);
+            treeReservation = scopeLease.scope.reserve("subagent", (this.subagentContext?.depth ?? 0) + 1);
+            return await this.startRuntime(options, undefined, {
+                scopeLease,
+                reservation: treeReservation,
+            });
+        }
+        catch (error) {
+            releaseReservation();
+            treeReservation?.rollback();
+            if (scopeLease?.owned)
+                scopeLease.scope.dispose();
+            throw error;
+        }
+        finally {
+            finishStart();
+        }
+    }
+    listDefinitions(options = {}) {
+        const resourceLoader = options.resourceLoader ?? this.resourceLoader;
+        return resourceLoader?.getSubagents().definitions ?? [];
+    }
+    /**
+     * Definitions permitted by this runtime's delegation policy (`allowedSubagents`),
+     * ignoring exhaustible depth and child-start budgets. Callers use this to distinguish
+     * never-permitted names from exhausted budgets, which report precise errors on start.
+     */
+    listPermittedDefinitions(options = {}) {
+        const definitions = this.listDefinitions(options);
+        const allowedSubagents = normalizeUniqueNames(this.subagentContext?.allowedSubagents);
+        if (!allowedSubagents) {
+            return definitions;
+        }
+        const allowedNames = new Set(allowedSubagents);
+        return definitions.filter((definition) => allowedNames.has(definition.name));
+    }
+    /** Definitions this runtime may delegate to right now, including depth and child-start budgets. */
+    listAvailableDefinitions(options = {}) {
+        const context = this.subagentContext;
+        if (context &&
+            ((context.maxSubagentDepth !== undefined && context.depth >= context.maxSubagentDepth) ||
+                (context.maxChildAgents !== undefined && this.childStartCount >= context.maxChildAgents))) {
+            return [];
+        }
+        return this.listPermittedDefinitions(options);
+    }
+    /** List active and recently completed child runs, newest and active first. */
+    listActivities() {
+        return Array.from(this.activities.values())
+            .sort((left, right) => {
+            if (left.status === "running" && right.status !== "running")
+                return -1;
+            if (left.status !== "running" && right.status === "running")
+                return 1;
+            return right.startedAt - left.startedAt;
+        })
+            .map((activity) => this.snapshotActivity(activity));
+    }
+    /** Subscribe to live child activity changes. Snapshots remain available after handle disposal. */
+    subscribeActivities(listener) {
+        this.activityListeners.add(listener);
+        return () => {
+            this.activityListeners.delete(listener);
+        };
+    }
+    getDefinition(agentName, options = {}) {
+        return this.resolveDefinition(agentName, options.resourceLoader);
+    }
+    async startByName(agentName, options = {}) {
+        const finishStart = this.beginStart();
+        let releaseReservation = () => undefined;
+        let scopeLease;
+        let treeReservation;
+        try {
+            const definition = this.getDefinition(agentName, { resourceLoader: options.resourceLoader });
+            releaseReservation = this.reserveChildStart(definition.name);
+            scopeLease = this.resolveDelegationScope(options.delegationScope);
+            treeReservation = scopeLease.scope.reserve(definition.name, (this.subagentContext?.depth ?? 0) + 1);
+            return await this.startRuntime(options, {
+                definition,
+                allowedTools: options.allowedTools ?? this.allowedTools,
+            }, {
+                scopeLease,
+                reservation: treeReservation,
+            });
+        }
+        catch (error) {
+            releaseReservation();
+            treeReservation?.rollback();
+            if (scopeLease?.owned)
+                scopeLease.scope.dispose();
+            throw error;
+        }
+        finally {
+            finishStart();
+        }
+    }
+    async dispose() {
+        if (!this.disposePromise) {
+            this.disposePromise = (async () => {
+                await this.waitForPendingStarts();
+                const handles = Array.from(this.handles.values());
+                try {
+                    await Promise.allSettled(handles.map((handle) => handle.dispose()));
+                }
+                finally {
+                    this.activityListeners.clear();
+                }
+            })();
+        }
+        await this.disposePromise;
+    }
+    reserveChildStart(agentName) {
+        const context = this.subagentContext;
+        if (!context) {
+            return () => undefined;
+        }
+        if (!agentName) {
+            throw new Error(`Subagent "${context.agentName}" cannot start unnamed child subagents.`);
+        }
+        if (context.maxSubagentDepth !== undefined && context.depth >= context.maxSubagentDepth) {
+            throw new Error(`Subagent "${context.agentName}" cannot delegate to "${agentName}": maxSubagentDepth ${context.maxSubagentDepth} reached at depth ${context.depth}.`);
+        }
+        const allowedSubagents = normalizeUniqueNames(context.allowedSubagents);
+        if (allowedSubagents && allowedSubagents.length === 0) {
+            throw new Error(`Subagent "${context.agentName}" cannot delegate to "${agentName}": no child subagents are allowed.`);
+        }
+        if (allowedSubagents && !allowedSubagents.includes(agentName)) {
+            throw new Error(`Subagent "${context.agentName}" cannot delegate to "${agentName}". Allowed subagents: ${allowedSubagents.join(", ")}.`);
+        }
+        if (context.maxChildAgents !== undefined && this.childStartCount >= context.maxChildAgents) {
+            throw new Error(`Subagent "${context.agentName}" cannot start more than ${context.maxChildAgents} child subagent${context.maxChildAgents === 1 ? "" : "s"}.`);
+        }
+        this.childStartCount += 1;
+        let released = false;
+        return () => {
+            if (released) {
+                return;
+            }
+            released = true;
+            this.childStartCount = Math.max(0, this.childStartCount - 1);
+        };
+    }
+    assertNotDisposed() {
+        if (this.disposePromise)
+            throw new Error("Subagent manager is disposed");
+    }
+    beginStart() {
+        this.assertNotDisposed();
+        this.pendingStartCount += 1;
+        let finished = false;
+        return () => {
+            if (finished)
+                return;
+            finished = true;
+            this.pendingStartCount = Math.max(0, this.pendingStartCount - 1);
+            if (this.pendingStartCount === 0) {
+                for (const resolve of this.pendingStartWaiters)
+                    resolve();
+                this.pendingStartWaiters.clear();
+            }
+        };
+    }
+    waitForPendingStarts() {
+        if (this.pendingStartCount === 0)
+            return Promise.resolve();
+        return new Promise((resolve) => this.pendingStartWaiters.add(resolve));
+    }
+    resolveDelegationScope(requested) {
+        const inherited = this.subagentContext?.delegationScope;
+        if (inherited)
+            return { scope: inherited, owned: false };
+        if (requested)
+            return { scope: requested, owned: false };
+        return { scope: new SubagentDelegationScope(), owned: true };
+    }
+    createChildSubagentContext(definition, delegationScope) {
+        if (!definition) {
+            return undefined;
+        }
+        const parentPath = this.subagentContext?.path ?? [];
+        const inheritedMaxDepth = this.subagentContext?.maxSubagentDepth;
+        const definitionMaxDepth = definition.maxSubagentDepth;
+        const maxSubagentDepth = inheritedMaxDepth === undefined
+            ? definitionMaxDepth
+            : definitionMaxDepth === undefined
+                ? inheritedMaxDepth
+                : Math.min(inheritedMaxDepth, definitionMaxDepth);
+        return {
+            depth: (this.subagentContext?.depth ?? 0) + 1,
+            agentName: definition.name,
+            path: [...parentPath, definition.name],
+            delegationScope,
+            allowedSubagents: definition.allowedSubagents ?? [],
+            ...(maxSubagentDepth !== undefined ? { maxSubagentDepth } : {}),
+            ...(definition.maxChildAgents !== undefined ? { maxChildAgents: definition.maxChildAgents } : {}),
+        };
+    }
+    async startRuntime(options, definitionOptions, delegation) {
+        const cwd = options.cwd ?? this.cwd;
+        const agentDir = options.agentDir ?? this.agentDir;
+        const sessionManager = options.sessionManager ?? this.createDefaultChildSessionManager(cwd);
+        const id = `sa_${randomUUID()}`;
+        if (!delegation) {
+            throw new Error("Subagent delegation scope is required");
+        }
+        const subagentContext = this.createChildSubagentContext(definitionOptions?.definition, delegation.scopeLease.scope);
+        const runtime = await this.createChildRuntime({ cwd, agentDir, sessionManager, subagentContext });
+        const unsubscribeScopeAccounting = runtime.session.subscribe((event) => {
+            if (event.type === "turn_end") {
+                delegation.scopeLease.scope.recordTurn();
+                return;
+            }
+            if (event.type !== "message_end" || event.message.role !== "assistant")
+                return;
+            const usage = event.message.usage;
+            delegation.scopeLease.scope.recordUsage(usage.input + usage.output + usage.cacheRead + usage.cacheWrite, usage.cost.total);
+        });
+        let client;
+        try {
+            if (definitionOptions) {
+                await this.applyDefinitionToRuntime(runtime, definitionOptions.definition, definitionOptions.allowedTools);
+            }
+            let handle;
+            client = await createInProcessRpcClient(runtime, {
+                disposeRuntimeOnClose: !this.retainRuntimeOnDispose,
+                requestTimeoutMs: options.requestTimeoutMs ?? this.requestTimeoutMs,
+                onEvent: (event) => {
+                    this.recordActivityEvent(id, event);
+                    handle?.handleEvent(event);
+                },
+            });
+            await this.notifyRuntimeCreated({ id, runtime, definition: definitionOptions?.definition });
+            this.registerActivity(id, runtime, definitionOptions?.definition);
+            handle = new LocalSubagentHandle({
+                id,
+                sessionId: runtime.session.sessionId,
+                client,
+                abortRuntime: () => runtime.session.abort(),
+                removeFromManager: (handleId) => {
+                    this.handles.delete(handleId);
+                },
+                onPromptStarted: (message) => this.updateActivityTask(id, message),
+                onPromptFailed: (error) => this.finishActivity(id, "failed", errorMessage(error)),
+                onAbortRequested: () => this.markActivityAbortRequested(id),
+                onTerminal: () => {
+                    unsubscribeScopeAccounting();
+                    delegation.reservation.release();
+                    if (delegation.scopeLease.owned)
+                        delegation.scopeLease.scope.dispose();
+                },
+                waitForIdle: () => runtime.session.waitForIdle(),
+            });
+            delegation.reservation.commit(id, () => {
+                void runtime.session.abort();
+            });
+            this.handles.set(id, handle);
+            void handle.waitForEnd().then((result) => {
+                const terminal = getTerminalActivityResult(result.event);
+                this.finishActivity(id, terminal.status, terminal.error);
+            }, (error) => {
+                const activity = this.activities.get(id);
+                const status = activity?.abortRequested ? "aborted" : "failed";
+                this.finishActivity(id, status, status === "failed" ? errorMessage(error) : undefined);
+            });
+            return handle;
+        }
+        catch (error) {
+            unsubscribeScopeAccounting();
+            await client?.stop().catch(() => undefined);
+            await runtime.dispose().catch(() => undefined);
+            throw error;
+        }
+    }
+    registerActivity(id, runtime, definition) {
+        const now = Date.now();
+        const activity = {
+            id,
+            sessionId: runtime.session.sessionId,
+            agent: {
+                name: definition?.name ?? "subagent",
+                source: definition?.source,
+            },
+            task: undefined,
+            status: "running",
+            startedAt: now,
+            updatedAt: now,
+            finishedAt: undefined,
+            abortRequested: false,
+            events: [],
+            droppedEvents: 0,
+            transcript: [],
+            sessionStats: undefined,
+            error: undefined,
+            runtime,
+            nextSequence: 0,
+        };
+        this.activities.set(id, activity);
+        this.trimActivities();
+        this.notifyActivity(activity);
+    }
+    updateActivityTask(id, task) {
+        const activity = this.activities.get(id);
+        if (!activity || activity.status !== "running")
+            return;
+        activity.task = task;
+        activity.updatedAt = Date.now();
+        this.notifyActivity(activity);
+    }
+    markActivityAbortRequested(id) {
+        const activity = this.activities.get(id);
+        if (!activity || activity.status !== "running")
+            return;
+        activity.abortRequested = true;
+        activity.updatedAt = Date.now();
+        this.notifyActivity(activity);
+    }
+    recordActivityEvent(id, event) {
+        const activity = this.activities.get(id);
+        if (!activity)
+            return;
+        const now = Date.now();
+        const previous = activity.events[activity.events.length - 1];
+        const coalesceMessageUpdate = previous?.event.type === "message_update" && event.type === "message_update";
+        const coalesceToolUpdate = previous?.event.type === "tool_execution_update" &&
+            event.type === "tool_execution_update" &&
+            previous.event.toolCallId === event.toolCallId;
+        if (previous && (coalesceMessageUpdate || coalesceToolUpdate)) {
+            previous.timestamp = now;
+            previous.event = event;
+        }
+        else {
+            activity.events.push({ sequence: activity.nextSequence, timestamp: now, event });
+            activity.nextSequence += 1;
+            if (activity.events.length > MAX_RETAINED_ACTIVITY_EVENTS) {
+                activity.events.shift();
+                activity.droppedEvents += 1;
+            }
+        }
+        activity.updatedAt = now;
+        this.notifyActivity(activity);
+    }
+    finishActivity(id, status, error) {
+        const activity = this.activities.get(id);
+        if (!activity || activity.status !== "running")
+            return;
+        const runtime = activity.runtime;
+        if (runtime) {
+            activity.transcript = [...runtime.session.messages];
+            activity.sessionStats = runtime.session.getSessionStats();
+        }
+        const now = Date.now();
+        activity.runtime = undefined;
+        activity.status = status;
+        activity.finishedAt = now;
+        activity.updatedAt = now;
+        activity.error = error;
+        this.notifyActivity(activity);
+        this.trimActivities();
+    }
+    snapshotActivity(activity) {
+        const runtime = activity.runtime;
+        const transcript = runtime ? [...runtime.session.messages] : [...activity.transcript];
+        const sessionStats = runtime ? runtime.session.getSessionStats() : activity.sessionStats;
+        return {
+            id: activity.id,
+            sessionId: activity.sessionId,
+            agent: { ...activity.agent },
+            ...(activity.task !== undefined ? { task: activity.task } : {}),
+            status: activity.status,
+            startedAt: activity.startedAt,
+            updatedAt: activity.updatedAt,
+            ...(activity.finishedAt !== undefined ? { finishedAt: activity.finishedAt } : {}),
+            abortRequested: activity.abortRequested,
+            events: activity.events.map((entry) => ({ ...entry })),
+            droppedEvents: activity.droppedEvents,
+            transcript,
+            ...(sessionStats ? { sessionStats } : {}),
+            ...(activity.error ? { error: activity.error } : {}),
+        };
+    }
+    notifyActivity(activity) {
+        for (const listener of this.activityListeners) {
+            try {
+                listener(activity.id);
+            }
+            catch {
+                // Observer failures must not affect child execution.
+            }
+        }
+    }
+    trimActivities() {
+        while (this.activities.size > MAX_RETAINED_ACTIVITIES) {
+            let oldestTerminal;
+            for (const activity of this.activities.values()) {
+                if (activity.status !== "running") {
+                    oldestTerminal = activity;
+                    break;
+                }
+            }
+            if (!oldestTerminal)
+                return;
+            this.activities.delete(oldestTerminal.id);
+        }
+    }
+    createDefaultChildSessionManager(cwd) {
+        if (!this.parentSessionManager?.isPersisted()) {
+            return SessionManager.inMemory(cwd);
+        }
+        const parentSession = this.parentSessionManager.getSessionFile();
+        return SessionManager.create(cwd, this.parentSessionManager.getSessionDir(), {
+            origin: "subagent",
+            ...(parentSession ? { parentSession } : {}),
+        });
+    }
+    async notifyRuntimeCreated(options) {
+        if (!this.onRuntimeCreated) {
+            return;
+        }
+        await this.onRuntimeCreated({
+            id: options.id,
+            sessionId: options.runtime.session.sessionId,
+            runtime: options.runtime,
+            ...(options.definition ? { definition: options.definition } : {}),
+            ...(this.parentSessionManager ? { parentSessionId: this.parentSessionManager.getSessionId() } : {}),
+            ...(this.parentSessionManager?.getSessionFile()
+                ? { parentSessionFile: this.parentSessionManager.getSessionFile() }
+                : {}),
+        });
+    }
+    resolveDefinition(agentName, resourceLoaderOverride) {
+        const resourceLoader = resourceLoaderOverride ?? this.resourceLoader;
+        if (!resourceLoader) {
+            throw new SubagentDefinitionNotFoundError(agentName, []);
+        }
+        const result = resourceLoader.getSubagents();
+        const definition = result.definitions.find((candidate) => candidate.name === agentName.trim());
+        if (!definition) {
+            throw new SubagentDefinitionNotFoundError(agentName, result.definitions.map((candidate) => candidate.name), result.diagnostics);
+        }
+        return definition;
+    }
+    async applyDefinitionToRuntime(runtime, definition, allowedTools) {
+        const allowedSubagents = normalizeUniqueNames(definition.allowedSubagents) ?? [];
+        const activeTools = resolveEffectiveTools({
+            requestedTools: definition.tools,
+            excludedTools: allowedSubagents.length === 0
+                ? [...(definition.excludedTools ?? []), "subagent"]
+                : definition.excludedTools,
+            allowedTools,
+            defaultTools: runtime.session.getActiveToolNames(),
+        });
+        if (activeTools) {
+            runtime.session.setActiveToolsByName(activeTools);
+        }
+        runtime.session.appendSystemPromptContext(definition.systemPrompt);
+        let thinkingLevel = this.validateThinkingLevel(definition);
+        if (definition.model) {
+            const availableModels = await runtime.session.modelRegistry.getAvailable();
+            const resolved = parseModelPattern(definition.model, availableModels, {
+                allowInvalidThinkingLevelFallback: false,
+            });
+            if (!resolved.model) {
+                throw new SubagentDefinitionConfigurationError(definition.name, "model", `model reference "${definition.model}" is not available or is not configured`);
+            }
+            await runtime.session.setModel(resolved.model, { persistDefault: false });
+            thinkingLevel ??= resolved.thinkingLevel;
+        }
+        if (thinkingLevel) {
+            runtime.session.setThinkingLevel(thinkingLevel, { persistDefault: false });
+        }
+    }
+    validateThinkingLevel(definition) {
+        if (!definition.thinking) {
+            return undefined;
+        }
+        // Discovery keeps invalid frontmatter as diagnostics, but definition-backed starts fail
+        // before prompting so callers get a clear configuration error for this subagent.
+        if (!isThinkingLevel(definition.thinking)) {
+            throw new SubagentDefinitionConfigurationError(definition.name, "thinking", `"${definition.thinking}" is not a supported thinking level`);
+        }
+        return definition.thinking;
+    }
+    async createChildRuntime(options) {
+        return createAgentSessionRuntime(this.createRuntime, {
+            cwd: options.cwd,
+            agentDir: options.agentDir,
+            sessionManager: options.sessionManager,
+            ...(options.subagentContext ? { subagentContext: options.subagentContext } : {}),
+        });
+    }
+}
+//# sourceMappingURL=manager.js.map