@felan-ai/felan 0.28.3 → 0.30.0

package/dist/subagents/host.js

@@ -1,1420 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { mkdir, readFile } from 'node:fs/promises';
-import { HostAgentRuntime, SessionManager, createAgentCoreSession, } from '@felan-ai/agent-core';
-import { bindSubagentSession, } from '@felan-ai/ext-subagents';
-import { CURRENT_SESSION_VERSION, } from '@earendil-works/pi-coding-agent';
-import { createLocalExtensionImporter } from '../extensions.js';
-import { createLocalAgentLogger } from '../logger.js';
-import { createLocalCodexStreamFunctionWrapper } from '../codex.js';
-import { createLocalAgentRuntimeFactoryRequest, } from '../runtime-factory.js';
-import { loadLocalChildSystemPromptAppends } from '../system-prompt.js';
-import { discoverLocalSubagents } from './catalog.js';
-import { LocalSubagentStore } from './store.js';
-const EXT_SUBAGENTS = '@felan-ai/ext-subagents';
-const MAX_RESULT_BYTES = 256 * 1024;
-const SYNTHESIS_PROMPT = 'Stop using tools. Summarize the work completed, findings, and any remaining uncertainty in a concise final response.';
-export function createLocalSubagentExtensionImporter(options, subagents, memoryHost) {
-    return createLocalExtensionImporter(subagents, options.modelRuntime, options.importExtension, undefined, memoryHost === undefined ? undefined : { role: 'reader', host: memoryHost }, options.outputStyle, undefined, undefined, options.backgroundBashCoordinator, options.backgroundBashCoordinatorOwner);
-}
-export class LocalSubagentHost {
-    descriptors;
-    policy;
-    #manager;
-    #sessionId;
-    constructor(manager, sessionId) {
-        this.#manager = manager;
-        this.#sessionId = sessionId;
-        this.descriptors = manager.descriptors;
-        this.policy = manager.policy;
-    }
-    static async create(options) {
-        const definitions = await discoverLocalSubagents(options.cwd, options.agentDir, options.homeDir);
-        const manager = await LocalSubagentManager.create(options, definitions);
-        return new LocalSubagentHost(manager, options.sessionId);
-    }
-    attachParent(port) {
-        return this.#manager.attachParent(this.#sessionId, port);
-    }
-    spawn(request, signal) {
-        return this.#manager.spawn(this.#sessionId, request, signal);
-    }
-    list(options) {
-        return this.#manager.list(this.#sessionId, options);
-    }
-    getResult(agentId, options) {
-        return this.#manager.getResult(this.#sessionId, agentId, options);
-    }
-    listLocalSubagents() {
-        return this.#manager.listLocalSubagents(this.#sessionId);
-    }
-    getLocalSubagent(agentId) {
-        return this.#manager.getLocalSubagent(this.#sessionId, agentId);
-    }
-    steer(agentId, message) {
-        return this.#manager.steer(this.#sessionId, agentId, message);
-    }
-    cancel(agentId, reason) {
-        return this.#manager.cancel(this.#sessionId, agentId, reason);
-    }
-    subscribe(listener) {
-        return this.#manager.subscribe(listener);
-    }
-    hasPendingWork() {
-        return this.#manager.hasPendingWork(this.#sessionId);
-    }
-    getUsage() {
-        return this.#manager.getUsage();
-    }
-    subscribeUsage(listener) {
-        return this.#manager.subscribeUsage(listener);
-    }
-    async shutdown() {
-        await this.#manager.shutdown();
-    }
-}
-export class LocalSubagentManager {
-    definitions;
-    descriptors;
-    policy;
-    #options;
-    #store;
-    #savingsReporter;
-    #children = new Map();
-    #ports = new Map();
-    #jobs = new Map();
-    #queue = [];
-    #listeners = new Set();
-    #usageListeners = new Set();
-    #deliveries = new Map();
-    #deliveryAttempts = new Map();
-    #deliveryTimers = new Map();
-    #concurrency;
-    #maxDepth;
-    #active = 0;
-    #closed = false;
-    #save = Promise.resolve();
-    #control = Promise.resolve();
-    #shutdown;
-    constructor(options, definitions) {
-        this.#options = options;
-        this.definitions = new Map(definitions.map((definition) => [definition.descriptor.id, definition]));
-        this.descriptors = Object.freeze(definitions.map((definition) => definition.descriptor));
-        this.#concurrency = boundedInteger(options.settings?.concurrency, 4, 1, 32);
-        this.#maxDepth = boundedInteger(options.settings?.maxDepth, 3, 1, 10);
-        this.#savingsReporter = options.savings?.createReporter(EXT_SUBAGENTS);
-        this.policy = Object.freeze({
-            maxPromptBytes: 128 * 1024,
-            maxDescriptionBytes: 512,
-            maxSteerBytes: 32 * 1024,
-        });
-        this.#store = new LocalSubagentStore(options.agentDir, options.sessionId);
-    }
-    static async create(options, definitions) {
-        const manager = new LocalSubagentManager(options, definitions);
-        const loaded = await manager.#store.load();
-        let reconciled = false;
-        const interrupted = new Set();
-        for (const stored of loaded) {
-            const child = fromStored(stored);
-            if (child.record.status === 'queued' || child.record.status === 'running') {
-                child.record = terminalRecord(child.record, 'cancelled', {
-                    code: 'host_shutdown',
-                    message: 'Local subagent was interrupted when the previous Felan Code process exited',
-                });
-                child.completionPending = child.deliveryId !== undefined;
-                interrupted.add(child.record.agentId);
-                reconciled = true;
-            }
-            manager.#children.set(child.record.agentId, child);
-        }
-        for (const child of manager.#children.values()) {
-            if (!child.sessionFile)
-                continue;
-            const usage = await loadSessionUsage(child.sessionFile, child.record.agentId);
-            if (usage)
-                child.usage = usage;
-            else
-                delete child.usage;
-            if (usage && (interrupted.has(child.record.agentId) || child.reportedSavings === undefined)) {
-                child.reportedSavings = { ...usage };
-                reconciled = true;
-            }
-        }
-        if (reconciled)
-            await manager.#persist();
-        return manager;
-    }
-    attachParent(sessionId, port) {
-        this.#ports.set(sessionId, port);
-        const replay = setTimeout(() => {
-            this.#deliverPending(sessionId).catch(() => { });
-        }, 0);
-        replay.unref();
-        return () => {
-            clearTimeout(replay);
-            if (this.#ports.get(sessionId) === port)
-                this.#ports.delete(sessionId);
-        };
-    }
-    async spawn(parentSessionId, request, signal) {
-        if (this.#closed)
-            return failure('host_unavailable', 'Local subagent host is closed');
-        if (signal?.aborted)
-            return failure('invalid_request', 'Subagent startup was aborted');
-        if (byteLength(request.prompt) > this.policy.maxPromptBytes
-            || byteLength(request.description) > this.policy.maxDescriptionBytes) {
-            return failure('invalid_request', 'Subagent prompt or description exceeds local policy');
-        }
-        if (request.maxTurns !== undefined && (!Number.isInteger(request.maxTurns) || request.maxTurns < 1 || request.maxTurns > 100)) {
-            return failure('invalid_request', 'maxTurns must be an integer from 1 to 100');
-        }
-        if (request.timeoutSeconds !== undefined
-            && (!Number.isInteger(request.timeoutSeconds) || request.timeoutSeconds < 1 || request.timeoutSeconds > 86_400)) {
-            return failure('invalid_request', 'timeoutSeconds must be an integer from 1 to 86400');
-        }
-        const definition = this.definitions.get(request.type);
-        if (!definition)
-            return failure('unknown_agent_type', `Unknown subagent type: ${request.type}`);
-        const resolvedModel = this.#resolveModel(request.model);
-        if (!resolvedModel.ok)
-            return resolvedModel;
-        if (!this.#supportsThinking(resolvedModel.value, request.thinking)) {
-            return failure('unsupported_thinking', 'The resolved model does not support the requested thinking level');
-        }
-        const normalizedRequest = {
-            ...request,
-            ...(resolvedModel.value === undefined ? {} : { model: resolvedModel.value }),
-        };
-        const admitted = await this.#serializeControl(async () => {
-            if (this.#closed)
-                return failure('host_unavailable', 'Local subagent host is closed');
-            if (signal?.aborted)
-                return failure('invalid_request', 'Subagent startup was aborted');
-            const context = this.#sessionContext(parentSessionId);
-            if (!context)
-                return failure('parent_unavailable', 'Parent subagent is unavailable');
-            if (context.depth >= this.#maxDepth) {
-                return failure('depth_exceeded', 'Maximum local subagent depth reached');
-            }
-            const parent = context.child;
-            const parentJob = this.#jobs.get(parentSessionId);
-            if (parent
-                && (isTerminal(parent.record.status) || parentJob?.terminalStatus !== undefined)) {
-                return failure('parent_unavailable', 'Parent subagent is no longer active');
-            }
-            if (parent
-                && !this.definitions.get(parent.record.type)?.descriptor.allowNesting) {
-                return failure('depth_exceeded', `${parent.record.type} does not allow nested subagents`);
-            }
-            if (this.#closed)
-                return failure('host_unavailable', 'Local subagent host is closed');
-            if (signal?.aborted)
-                return failure('invalid_request', 'Subagent startup was aborted');
-            const agentId = randomUUID();
-            const now = new Date().toISOString();
-            const record = {
-                agentId,
-                parentSessionId,
-                rootSessionId: context.rootSessionId,
-                type: request.type,
-                description: request.description,
-                status: 'queued',
-                createdAt: now,
-            };
-            const child = {
-                record,
-                request: normalizedRequest,
-                depth: context.depth + 1,
-                deliveryId: randomUUID(),
-                completionPending: false,
-            };
-            const job = this.#job(child, normalizedRequest.prompt);
-            this.#children.set(agentId, child);
-            this.#jobs.set(agentId, job);
-            try {
-                await this.#persist();
-            }
-            catch {
-                this.#children.delete(agentId);
-                this.#jobs.delete(agentId);
-                return failure('host_unavailable', 'Local subagent startup could not be persisted');
-            }
-            if (signal?.aborted) {
-                this.#children.delete(agentId);
-                this.#jobs.delete(agentId);
-                await this.#persist();
-                return failure('invalid_request', 'Subagent startup was aborted');
-            }
-            this.#emit();
-            return success({ child, job });
-        });
-        if (!admitted.ok)
-            return admitted;
-        const { child, job } = admitted.value;
-        const queued = cloneRecord(child.record);
-        this.#queue.push(job);
-        this.#drain();
-        return success(queued);
-    }
-    async list(parentSessionId, options) {
-        return this.#serializeControl(async () => {
-            if (!this.#sessionContext(parentSessionId))
-                return failure('parent_unavailable', 'Parent subagent is unavailable');
-            const direct = new Set([parentSessionId]);
-            if (options.includeDescendants) {
-                let changed = true;
-                while (changed) {
-                    changed = false;
-                    for (const child of this.#latestChildren()) {
-                        if (direct.has(child.record.parentSessionId) && !direct.has(child.record.agentId)) {
-                            direct.add(child.record.agentId);
-                            changed = true;
-                        }
-                    }
-                }
-            }
-            const limit = boundedInteger(options.limit, 20, 1, 50);
-            const records = this.#latestChildren()
-                .filter((child) => direct.has(child.record.parentSessionId))
-                .map((child) => cloneRecord(child.record))
-                .sort((left, right) => (subagentStatusPriority(left.status) - subagentStatusPriority(right.status)
-                || left.createdAt.localeCompare(right.createdAt)));
-            return success(records.slice(0, limit));
-        });
-    }
-    async getResult(parentSessionId, agentId, options) {
-        const authorized = await this.#serializeControl(async () => this.#directChild(parentSessionId, agentId));
-        if (!authorized.ok)
-            return authorized;
-        const result = await this.#resultRecord(authorized.value);
-        if (options?.acknowledge !== true || !isTerminal(result.status))
-            return success(result);
-        await this.#serializeControl(async () => {
-            const current = this.#directChild(parentSessionId, agentId);
-            if (!current.ok || current.value !== authorized.value)
-                return;
-            const child = current.value;
-            if (!child.completionPending || child.deliveryId === undefined)
-                return;
-            const deliveryId = child.deliveryId;
-            child.completionPending = false;
-            this.#ports.get(parentSessionId)?.acknowledgeCompletion?.(deliveryId);
-            await this.#persist();
-            this.#emit();
-        });
-        return success(result);
-    }
-    listLocalSubagents(parentSessionId) {
-        return this.#latestChildren()
-            .filter((child) => child.record.parentSessionId === parentSessionId)
-            .map(localView)
-            .sort((left, right) => left.createdAt.localeCompare(right.createdAt));
-    }
-    getLocalSubagent(parentSessionId, agentId) {
-        return this.listLocalSubagents(parentSessionId)
-            .find((child) => child.agentId === agentId);
-    }
-    async steer(parentSessionId, agentId, message) {
-        const prepared = await this.#serializeControl(async () => {
-            if (this.#closed)
-                return failure('host_unavailable', 'Local subagent host is closed');
-            const authorized = this.#directChild(parentSessionId, agentId);
-            if (!authorized.ok)
-                return authorized;
-            const child = authorized.value;
-            if (child.record.status === 'queued' || child.record.status === 'running') {
-                const steered = await this.#steerActive(child, message);
-                return steered.ok ? success({ kind: 'active', child: steered.value }) : steered;
-            }
-            if (!isContinuable(child)) {
-                return failure('not_steerable', 'Only retained completed or recoverable subagents can be continued');
-            }
-            return success({
-                kind: 'completed',
-                child,
-                sessionFile: child.sessionFile,
-                deliveryId: child.completionPending ? child.deliveryId : undefined,
-            });
-        });
-        if (!prepared.ok)
-            return prepared;
-        if (prepared.value.kind === 'active')
-            return success(cloneRecord(prepared.value.child.record));
-        const completion = prepared.value;
-        const sessionFile = completion.sessionFile;
-        if (!sessionFile)
-            return failure('not_steerable', 'The retained subagent session is unavailable');
-        try {
-            await preflightSessionFile(sessionFile, agentId);
-        }
-        catch {
-            return failure('not_steerable', 'The retained subagent session is unavailable');
-        }
-        const continued = await this.#serializeControl(async () => {
-            if (this.#closed)
-                return failure('host_unavailable', 'Local subagent host is closed');
-            const authorized = this.#directChild(parentSessionId, agentId);
-            if (!authorized.ok)
-                return authorized;
-            const child = authorized.value;
-            if (child.sessionFile !== sessionFile) {
-                return failure('not_steerable', 'The retained subagent session changed before continuation');
-            }
-            if (child.record.status === 'queued' || child.record.status === 'running') {
-                const steered = await this.#steerActive(child, message);
-                return steered.ok ? success({ child: steered.value, job: undefined }) : steered;
-            }
-            if (!isContinuable(child)) {
-                return failure('not_steerable', 'The retained subagent session changed before continuation');
-            }
-            const previousRecord = child.record;
-            const previousDeliveryId = child.deliveryId;
-            const previousCompletionPending = child.completionPending;
-            const previousDeliveryAttempt = previousDeliveryId === undefined
-                ? undefined
-                : this.#deliveryAttempts.get(previousDeliveryId);
-            const previousDeliveryTimer = previousDeliveryId === undefined
-                ? undefined
-                : this.#deliveryTimers.get(previousDeliveryId);
-            const previousDeliveryInFlight = previousDeliveryId !== undefined
-                && this.#deliveries.has(previousDeliveryId);
-            if (previousCompletionPending && previousDeliveryId !== undefined) {
-                this.#ports.get(parentSessionId)?.acknowledgeCompletion?.(previousDeliveryId);
-            }
-            child.record = {
-                agentId: child.record.agentId,
-                parentSessionId: child.record.parentSessionId,
-                rootSessionId: child.record.rootSessionId,
-                type: child.record.type,
-                description: child.record.description,
-                status: 'queued',
-                createdAt: child.record.createdAt,
-            };
-            child.deliveryId = randomUUID();
-            child.completionPending = false;
-            if (previousDeliveryId !== undefined) {
-                this.#deliveryAttempts.delete(previousDeliveryId);
-                const timer = this.#deliveryTimers.get(previousDeliveryId);
-                if (timer !== undefined)
-                    clearTimeout(timer);
-                this.#deliveryTimers.delete(previousDeliveryId);
-            }
-            const job = this.#job(child, message);
-            this.#jobs.set(agentId, job);
-            try {
-                await this.#persist();
-            }
-            catch {
-                this.#jobs.delete(agentId);
-                child.record = previousRecord;
-                child.completionPending = previousCompletionPending;
-                if (previousDeliveryId === undefined)
-                    delete child.deliveryId;
-                else
-                    child.deliveryId = previousDeliveryId;
-                if (previousDeliveryId !== undefined) {
-                    if (previousDeliveryAttempt === undefined)
-                        this.#deliveryAttempts.delete(previousDeliveryId);
-                    else
-                        this.#deliveryAttempts.set(previousDeliveryId, previousDeliveryAttempt);
-                    if (previousDeliveryTimer !== undefined) {
-                        this.#scheduleDeliveryRetry(child, previousDeliveryId, previousDeliveryAttempt ?? 0);
-                    }
-                    else if (previousCompletionPending && !previousDeliveryInFlight) {
-                        this.#scheduleDeliveryRetry(child, previousDeliveryId, previousDeliveryAttempt ?? 0);
-                    }
-                }
-                return failure('host_unavailable', 'Subagent continuation could not be persisted');
-            }
-            this.#queue.push(job);
-            this.#emit();
-            return success({ child, job });
-        });
-        if (!continued.ok)
-            return continued;
-        if (continued.value.job)
-            this.#drain();
-        return success(cloneRecord(continued.value.child.record));
-    }
-    async cancel(parentSessionId, agentId, reason = 'Cancelled by parent') {
-        const authorized = this.#directChild(parentSessionId, agentId);
-        if (!authorized.ok)
-            return authorized;
-        await this.#cancelTree(agentId, reason, 'cancelled', 'cancelled_by_parent', false);
-        return success(cloneRecord(this.#latest(agentId).record));
-    }
-    subscribe(listener) {
-        this.#listeners.add(listener);
-        listener(this.#latestChildren().map(localView));
-        return () => this.#listeners.delete(listener);
-    }
-    hasPendingWork(sessionId) {
-        const context = this.#sessionContext(sessionId);
-        if (!context)
-            return false;
-        return this.#latestChildren().some((child) => {
-            if (child.record.rootSessionId !== context.rootSessionId)
-                return false;
-            if (!isTerminal(child.record.status))
-                return true;
-            return child.record.parentSessionId === sessionId && child.completionPending;
-        });
-    }
-    getUsage() {
-        const totals = emptyUsageTotals();
-        for (const child of this.#children.values())
-            addUsage(totals, child.usage);
-        return totals;
-    }
-    subscribeUsage(listener) {
-        this.#usageListeners.add(listener);
-        return () => this.#usageListeners.delete(listener);
-    }
-    async shutdown() {
-        this.#shutdown ??= this.#performShutdown();
-        await this.#shutdown;
-    }
-    async #performShutdown() {
-        this.#closed = true;
-        for (const timer of this.#deliveryTimers.values())
-            clearTimeout(timer);
-        this.#deliveryTimers.clear();
-        await this.#serializeControl(async () => { });
-        for (const child of this.#latestChildren()) {
-            if (!isTerminal(child.record.status))
-                await this.#cancelTree(child.record.agentId, 'Local host exited');
-        }
-        await Promise.allSettled([...this.#jobs.values()].map((job) => job.runPromise ?? job.cancelPromise ?? Promise.resolve()));
-        await Promise.allSettled(this.#deliveries.values());
-        await this.#save;
-    }
-    async #steerActive(child, message) {
-        const job = this.#jobs.get(child.record.agentId);
-        if (!job || job.terminalStatus) {
-            return failure('not_steerable', 'Subagent session is unavailable');
-        }
-        if (job.control)
-            await job.control.steer(message);
-        else
-            job.queuedMessages.push(message);
-        return success(child);
-    }
-    #job(child, initialMessage) {
-        return {
-            child,
-            controller: new AbortController(),
-            initialMessage,
-            queuedMessages: [],
-            slotHeld: false,
-        };
-    }
-    #drain() {
-        this.#serializeControl(async () => {
-            while (!this.#closed && this.#active < this.#concurrency && this.#queue.length > 0) {
-                const job = this.#queue.shift();
-                if (job.child.record.status !== 'queued')
-                    continue;
-                await this.#beginRun(job);
-            }
-        }).catch(() => { });
-    }
-    async #beginRun(job) {
-        if (job.runPromise || job.child.record.status !== 'queued')
-            return;
-        if (!job.slotHeld) {
-            if (this.#active >= this.#concurrency) {
-                this.#queue.unshift(job);
-                return;
-            }
-            job.slotHeld = true;
-            this.#active += 1;
-        }
-        job.child.record = {
-            ...job.child.record,
-            status: 'running',
-            startedAt: new Date().toISOString(),
-        };
-        await this.#persist();
-        this.#emit();
-        job.runPromise = this.#run(job);
-    }
-    async #run(job) {
-        const child = job.child;
-        let timeout;
-        let outcome;
-        try {
-            if (child.request.timeoutSeconds) {
-                timeout = setTimeout(() => {
-                    this.#cancelTree(child.record.agentId, `Subagent timed out after ${child.request.timeoutSeconds} seconds`, 'timed_out', 'timed_out').catch(() => { });
-                }, child.request.timeoutSeconds * 1_000);
-                timeout.unref();
-            }
-            const definition = this.definitions.get(child.record.type);
-            if (!job.controller.signal.aborted) {
-                const queuedAtStart = job.queuedMessages.splice(0);
-                const input = {
-                    sessionId: child.record.agentId,
-                    rootSessionId: child.record.rootSessionId,
-                    depth: child.depth,
-                    subagents: new LocalSubagentHost(this, child.record.agentId),
-                    request: child.request,
-                    definition,
-                    cwd: this.#options.cwd,
-                    signal: job.controller.signal,
-                    initialMessage: [job.initialMessage, ...queuedAtStart].join('\n\n'),
-                    onReady: async (control) => {
-                        job.control = control;
-                        if (job.terminalStatus)
-                            this.#cancelControl(job);
-                        await job.cancelPromise;
-                        if (job.terminalStatus)
-                            return;
-                        const pending = job.queuedMessages.splice(0);
-                        for (const message of pending)
-                            await control.steer(message);
-                    },
-                    ...(child.sessionFile === undefined ? {} : { sessionFile: child.sessionFile }),
-                };
-                outcome = this.#options.runChild
-                    ? await this.#options.runChild(input)
-                    : await this.#runAgentCore(input, async (session, sessionFile) => {
-                        child.session = session;
-                        child.sessionFile = sessionFile;
-                        child.usage = usageFromEntries(session.sessionManager.getEntries());
-                        child.usageUnsubscribe?.();
-                        child.usageUnsubscribe = session.subscribe((event) => {
-                            if (event.type !== 'message_end'
-                                || event.message.role !== 'assistant')
-                                return;
-                            child.usage ??= emptyUsageTotals();
-                            child.usage.input += event.message.usage.input;
-                            child.usage.output += event.message.usage.output;
-                            child.usage.cacheRead += event.message.usage.cacheRead;
-                            child.usage.cacheWrite += event.message.usage.cacheWrite;
-                            child.usage.cacheWrite1h += event.message.usage.cacheWrite1h ?? 0;
-                            child.usage.cost += event.message.usage.cost.total;
-                            this.#emitUsage();
-                        });
-                        await this.#persist();
-                        this.#emit();
-                    });
-            }
-            await job.cancelPromise;
-            outcome ??= {};
-        }
-        catch {
-            await job.cancelPromise;
-            outcome = { error: { code: 'internal_error', message: 'Local subagent failed unexpectedly' } };
-        }
-        finally {
-            if (timeout)
-                clearTimeout(timeout);
-            let savingsMeasurement;
-            await this.#serializeControl(async () => {
-                child.usageUnsubscribe?.();
-                delete child.usageUnsubscribe;
-                if (outcome?.sessionFile) {
-                    child.sessionFile = outcome.sessionFile;
-                }
-                if (child.session) {
-                    child.usage = usageFromEntries(child.session.sessionManager.getEntries());
-                }
-                else if (child.sessionFile) {
-                    const usage = await loadSessionUsage(child.sessionFile, child.record.agentId);
-                    if (usage)
-                        child.usage = usage;
-                    else
-                        delete child.usage;
-                }
-                const terminalBeforeCleanup = isTerminal(child.record.status);
-                if (!terminalBeforeCleanup) {
-                    if (job.terminalStatus) {
-                        child.record = terminalRecord(child.record, job.terminalStatus, job.terminalError);
-                    }
-                    else if (outcome?.turnLimitReached) {
-                        child.record = terminalRecord(child.record, 'cancelled', {
-                            code: 'turn_limit_reached',
-                            message: `Subagent reached its ${child.request.maxTurns} turn limit`,
-                        });
-                    }
-                    else if (outcome?.error) {
-                        child.record = terminalRecord(child.record, 'failed', outcome.error);
-                    }
-                    else {
-                        child.record = {
-                            ...terminalRecord(child.record, 'completed'),
-                            result: boundResult(outcome?.result ?? ''),
-                        };
-                    }
-                }
-                savingsMeasurement = this.#prepareExploreSavings(child);
-                if (job.slotHeld) {
-                    job.slotHeld = false;
-                    this.#active -= 1;
-                }
-                this.#jobs.delete(child.record.agentId);
-                if (!terminalBeforeCleanup && child.deliveryId)
-                    child.completionPending = true;
-                await this.#persist();
-                this.#emit();
-            });
-            if (savingsMeasurement && this.#savingsReporter) {
-                try {
-                    await this.#savingsReporter.report(savingsMeasurement);
-                }
-                catch { }
-            }
-            try {
-                if (child.deliveryId)
-                    await this.#deliver(child, child.deliveryId);
-            }
-            finally {
-                this.#drain();
-            }
-        }
-    }
-    #requestCancellation(job, status, error) {
-        if (job.terminalStatus || isTerminal(job.child.record.status))
-            return;
-        job.terminalStatus = status;
-        job.terminalError = error;
-        job.controller.abort();
-        this.#cancelControl(job);
-    }
-    #cancelControl(job) {
-        if (!job.control || job.cancelPromise)
-            return;
-        job.cancelPromise = job.control.cancel().catch(() => { });
-    }
-    async #runAgentCore(input, onSession) {
-        const runtimeRequest = createLocalAgentRuntimeFactoryRequest(input.cwd, this.#options.agentDir, input.rootSessionId);
-        const memoryHost = this.#options.memoryHostFactory?.({
-            cwd: input.cwd,
-            sessionStorageRoot: runtimeRequest.sessionStorageRoot,
-        });
-        await Promise.all([
-            mkdir(this.#store.sessionDirectory(), { recursive: true }),
-            mkdir(runtimeRequest.sessionStorageRoot, { recursive: true }),
-            mkdir(runtimeRequest.agentStorageRoot, { recursive: true }),
-        ]);
-        if (input.signal.aborted)
-            return {};
-        const sessionManager = input.sessionFile
-            ? SessionManager.open(input.sessionFile, this.#store.sessionDirectory(), input.cwd)
-            : SessionManager.create(input.cwd, this.#store.sessionDirectory(), { id: input.sessionId });
-        const sessionFile = sessionManager.getSessionFile();
-        if (!sessionFile) {
-            return {
-                error: { code: 'internal_error', message: 'Subagent session file could not be created' },
-            };
-        }
-        const model = input.request.model ? this.#exactModel(input.request.model) : undefined;
-        if (input.request.model && !model) {
-            return { error: { code: 'unsupported_model', message: 'The requested model is unavailable' } };
-        }
-        const canNest = input.definition.descriptor.allowNesting && input.depth < this.#maxDepth;
-        const extensionPackages = canNest
-            ? this.#options.extensionPackages
-            : this.#options.extensionPackages.filter((packageName) => packageName !== EXT_SUBAGENTS);
-        if (input.signal.aborted)
-            return {};
-        const appendSystemPrompt = await loadLocalChildSystemPromptAppends(this.#options.agentDir, input.definition.prompt);
-        const runtime = this.#options.runtimeFactory?.(runtimeRequest)
-            ?? new HostAgentRuntime(input.cwd, {
-                ...runtimeRequest,
-                logger: createLocalAgentLogger(runtimeRequest.agentStorageRoot),
-                ...(this.#options.classifier === undefined ? {} : { classifier: this.#options.classifier }),
-            });
-        const wrapStreamFunction = await createLocalCodexStreamFunctionWrapper(extensionPackages, runtime, this.#options.agentDir);
-        const created = await createAgentCoreSession({
-            runtime,
-            ...(!this.#options.dynamicThinking || input.request.thinking !== undefined ? {} : {
-                dynamicThinking: true,
-            }),
-            ...(wrapStreamFunction === undefined ? {} : { wrapStreamFunction }),
-            extensionPackages,
-            importExtension: createLocalSubagentExtensionImporter(this.#options, input.subagents, memoryHost),
-            modelRuntime: this.#options.modelRuntime,
-            settingsManager: this.#options.settingsManager,
-            sessionManager,
-            appendSystemPrompt,
-            ...(this.#options.skillPaths === undefined ? {} : { skillPaths: this.#options.skillPaths }),
-            ...(model === undefined ? {} : { model }),
-            ...(input.request.thinking === undefined ? {} : { thinkingLevel: input.request.thinking }),
-            ...(this.#options.scopedModels === undefined
-                ? {}
-                : { scopedModels: this.#options.scopedModels }),
-            ...(this.#options.extensionConfigOverrides === undefined
-                ? {}
-                : { extensionConfigOverrides: this.#options.extensionConfigOverrides }),
-            ...(this.#options.savings === undefined ? {} : { savings: this.#options.savings }),
-            ...(this.#options.inlineExtensions === undefined
-                ? {}
-                : { inlineExtensions: this.#options.inlineExtensions }),
-        });
-        try {
-            await onSession(created.session, sessionFile);
-            bindSubagentSession({ host: input.subagents, session: created.session });
-            if (input.signal.aborted)
-                return sessionFileOutcome(created.session.sessionFile);
-            await created.session.bindExtensions(this.#options.extensionUiContext === undefined
-                ? { mode: 'print' }
-                : { mode: 'rpc', uiContext: this.#options.extensionUiContext });
-            if (input.definition.toolProfile === 'inspection') {
-                created.session.setActiveToolsByName(inspectionToolNames(created.session.getActiveToolNames()));
-            }
-            if (input.signal.aborted)
-                return sessionFileOutcome(created.session.sessionFile);
-            let turns = 0;
-            let turnLimitReached = false;
-            let synthesisRequested = false;
-            let cancellation;
-            const cancel = () => {
-                cancellation ??= created.session.abort();
-                return cancellation;
-            };
-            const unsubscribe = created.session.subscribe((event) => {
-                if (event.type !== 'turn_end')
-                    return;
-                turns += 1;
-                if (input.request.maxTurns
-                    && event.message.role === 'assistant'
-                    && event.message.stopReason === 'toolUse') {
-                    if (turns >= input.request.maxTurns) {
-                        turnLimitReached = true;
-                        cancel().catch(() => { });
-                    }
-                    else if (turns >= input.request.maxTurns - 1 && !synthesisRequested) {
-                        synthesisRequested = true;
-                        created.session.setActiveToolsByName([]);
-                        created.session.steer(SYNTHESIS_PROMPT).catch(() => { });
-                    }
-                }
-            });
-            const abort = () => {
-                cancel().catch(() => { });
-            };
-            input.signal.addEventListener('abort', abort, { once: true });
-            try {
-                if (input.signal.aborted) {
-                    await cancel();
-                    return sessionFileOutcome(created.session.sessionFile);
-                }
-                await input.onReady({
-                    steer: async (message) => { await created.session.steer(message); },
-                    cancel,
-                });
-                if (input.signal.aborted) {
-                    await cancel();
-                    return sessionFileOutcome(created.session.sessionFile);
-                }
-                let initialMessage = input.initialMessage;
-                if (input.request.maxTurns === 1) {
-                    synthesisRequested = true;
-                    created.session.setActiveToolsByName([]);
-                    initialMessage = `${initialMessage}\n\n${SYNTHESIS_PROMPT}`;
-                }
-                await created.session.prompt(initialMessage);
-                await cancellation;
-                const assistant = [...created.session.messages].reverse().find((message) => message.role === 'assistant');
-                if (turnLimitReached) {
-                    return {
-                        ...sessionFileOutcome(created.session.sessionFile),
-                        turnLimitReached: true,
-                    };
-                }
-                if (!assistant) {
-                    return {
-                        error: { code: 'internal_error', message: 'Subagent completed without an assistant response' },
-                        ...sessionFileOutcome(created.session.sessionFile),
-                    };
-                }
-                if (assistant.stopReason !== 'stop') {
-                    return {
-                        error: {
-                            code: assistant.stopReason === 'error' ? 'model_request_failed' : 'internal_error',
-                            message: assistant.stopReason === 'error'
-                                ? `Model request failed: ${sanitizeModelError(assistant.errorMessage)}`
-                                : `Subagent ended without a final response (${assistant.stopReason})`,
-                        },
-                        ...sessionFileOutcome(created.session.sessionFile),
-                    };
-                }
-                const result = assistant.content
-                    .filter((part) => part.type === 'text')
-                    .map((part) => part.text)
-                    .join('\n');
-                if (!result.trim()) {
-                    return {
-                        error: { code: 'internal_error', message: 'Subagent completed without a final result' },
-                        ...sessionFileOutcome(created.session.sessionFile),
-                    };
-                }
-                return {
-                    result,
-                    ...sessionFileOutcome(created.session.sessionFile),
-                    ...(turnLimitReached ? { turnLimitReached: true } : {}),
-                };
-            }
-            finally {
-                input.signal.removeEventListener('abort', abort);
-                await cancellation;
-                unsubscribe();
-            }
-        }
-        finally {
-            await shutdownSubagentSession(created.session);
-        }
-    }
-    #resolveModel(selector) {
-        if (!selector)
-            return success(undefined);
-        if (selector === 'inherit') {
-            return failure('unsupported_model', 'Parent model is unavailable');
-        }
-        const model = this.#exactModel(selector);
-        return model && this.#options.modelRuntime.hasConfiguredAuth(model.provider)
-            ? success(`${model.provider}/${model.id}`)
-            : failure('unsupported_model', 'The requested model is unavailable or unauthenticated');
-    }
-    #supportsThinking(modelReference, thinking) {
-        if (thinking === undefined || thinking === 'off')
-            return true;
-        if (!modelReference)
-            return false;
-        const model = this.#exactModel(modelReference);
-        if (!model?.reasoning)
-            return false;
-        const mapped = model.thinkingLevelMap?.[thinking];
-        return thinking === 'xhigh' || thinking === 'max'
-            ? mapped !== undefined && mapped !== null
-            : mapped !== null;
-    }
-    #exactModel(reference) {
-        const separator = reference.indexOf('/');
-        if (separator <= 0 || separator === reference.length - 1)
-            return undefined;
-        return this.#options.modelRuntime.getModel(reference.slice(0, separator), reference.slice(separator + 1));
-    }
-    #directChild(parentSessionId, agentId) {
-        const child = this.#children.get(agentId);
-        if (!child)
-            return failure('not_found', `Subagent not found: ${agentId}`);
-        if (child.record.parentSessionId !== parentSessionId) {
-            return failure('not_child', 'The subagent is not a direct child of this session');
-        }
-        return success(child);
-    }
-    #sessionContext(sessionId) {
-        if (sessionId === this.#options.sessionId) {
-            return { rootSessionId: sessionId, depth: 0 };
-        }
-        const child = this.#children.get(sessionId);
-        if (!child)
-            return undefined;
-        return { rootSessionId: child.record.rootSessionId, depth: child.depth, child };
-    }
-    async #cancelTree(agentId, reason, status = 'cancelled', errorCode = 'host_shutdown', waitForCleanup = true) {
-        const cancellation = await this.#serializeControl(async () => {
-            const descendants = this.#latestChildren()
-                .filter((entry) => entry.record.parentSessionId === agentId && !isTerminal(entry.record.status))
-                .map((entry) => entry.record.agentId);
-            const child = this.#latest(agentId);
-            if (!child || isTerminal(child.record.status)) {
-                return { descendants, cleanup: Promise.resolve(), deliveryId: undefined };
-            }
-            const job = this.#jobs.get(agentId);
-            if (child.record.status === 'queued') {
-                const queueIndex = job ? this.#queue.indexOf(job) : -1;
-                if (queueIndex >= 0)
-                    this.#queue.splice(queueIndex, 1);
-                job?.controller.abort();
-                if (job?.slotHeld) {
-                    job.slotHeld = false;
-                    this.#active -= 1;
-                }
-                child.record = terminalRecord(child.record, status, {
-                    code: errorCode,
-                    message: reason,
-                });
-                if (child.deliveryId)
-                    child.completionPending = true;
-                this.#jobs.delete(agentId);
-                await this.#persist();
-                this.#emit();
-                return { descendants, cleanup: Promise.resolve(), deliveryId: child.deliveryId };
-            }
-            if (!job)
-                return { descendants, cleanup: Promise.resolve(), deliveryId: undefined };
-            this.#requestCancellation(job, status, {
-                code: errorCode,
-                message: reason,
-            });
-            child.record = terminalRecord(child.record, status, {
-                code: errorCode,
-                message: reason,
-            });
-            if (child.deliveryId)
-                child.completionPending = true;
-            await this.#persist();
-            this.#emit();
-            return { descendants, cleanup: job.runPromise ?? Promise.resolve(), deliveryId: undefined };
-        });
-        await Promise.all(cancellation.descendants.map((childId) => (this.#cancelTree(childId, reason, status, errorCode, waitForCleanup))));
-        if (waitForCleanup)
-            await cancellation.cleanup;
-        if (cancellation.deliveryId) {
-            try {
-                const child = this.#latest(agentId);
-                if (child) {
-                    if (waitForCleanup)
-                        await this.#deliver(child, cancellation.deliveryId);
-                    else
-                        void this.#deliver(child, cancellation.deliveryId).catch(() => { });
-                }
-            }
-            finally {
-                this.#drain();
-            }
-        }
-    }
-    async #deliver(child, deliveryId) {
-        if (!child.completionPending || child.deliveryId !== deliveryId)
-            return;
-        const existing = this.#deliveries.get(deliveryId);
-        if (existing)
-            return existing;
-        const notice = completionNotice(child.record, deliveryId);
-        const delivery = (async () => {
-            const port = this.#ports.get(child.record.parentSessionId);
-            if (!port)
-                return;
-            try {
-                const outcome = await port.deliverCompletion(notice);
-                if (outcome === 'delivered') {
-                    this.#deliveryAttempts.delete(deliveryId);
-                    const timer = this.#deliveryTimers.get(deliveryId);
-                    if (timer !== undefined)
-                        clearTimeout(timer);
-                    this.#deliveryTimers.delete(deliveryId);
-                    await this.#serializeControl(async () => {
-                        if (child.deliveryId !== deliveryId)
-                            return;
-                        child.completionPending = false;
-                        await this.#persist();
-                        this.#emit();
-                    });
-                }
-                else {
-                    this.#scheduleDeliveryRetry(child, deliveryId);
-                }
-            }
-            catch {
-                this.#scheduleDeliveryRetry(child, deliveryId);
-            }
-        })();
-        this.#deliveries.set(deliveryId, delivery);
-        try {
-            await delivery;
-        }
-        finally {
-            if (this.#deliveries.get(deliveryId) === delivery)
-                this.#deliveries.delete(deliveryId);
-        }
-    }
-    #scheduleDeliveryRetry(child, deliveryId, completedAttempts) {
-        if (this.#closed || this.#deliveryTimers.has(deliveryId))
-            return;
-        const attempt = completedAttempts ?? this.#deliveryAttempts.get(deliveryId) ?? 0;
-        const nextAttempt = attempt + 1;
-        this.#deliveryAttempts.set(deliveryId, nextAttempt);
-        const delay = Math.min(5_000, 100 * (2 ** Math.min(nextAttempt - 1, 5)));
-        const retry = setTimeout(() => {
-            this.#deliveryTimers.delete(deliveryId);
-            this.#deliver(child, deliveryId).catch(() => { });
-        }, delay);
-        retry.unref();
-        this.#deliveryTimers.set(deliveryId, retry);
-    }
-    async #deliverPending(parentSessionId) {
-        const children = [...this.#children.values()]
-            .filter((child) => child.record.parentSessionId === parentSessionId && child.completionPending);
-        for (const child of children) {
-            if (child.deliveryId)
-                await this.#deliver(child, child.deliveryId);
-        }
-    }
-    #latest(agentId) {
-        return this.#children.get(agentId);
-    }
-    #latestChildren() {
-        return [...this.#children.values()];
-    }
-    #emit() {
-        const records = this.#latestChildren().map(localView);
-        for (const listener of this.#listeners)
-            listener(records);
-        this.#emitUsage();
-    }
-    #emitUsage() {
-        for (const listener of this.#usageListeners)
-            listener();
-    }
-    #prepareExploreSavings(child) {
-        if (child.record.type !== 'explore' || !child.usage)
-            return undefined;
-        if (!this.#savingsReporter
-            || child.record.status !== 'completed'
-            || !child.record.result?.trim()
-            || !child.request.parentModel
-            || !child.request.model
-            || child.request.parentModel.toLowerCase() === child.request.model.toLowerCase()) {
-            child.reportedSavings = { ...child.usage };
-            return undefined;
-        }
-        const usage = subtractUsage(child.usage, child.reportedSavings);
-        if (!usage) {
-            child.reportedSavings = { ...child.usage };
-            return undefined;
-        }
-        const parent = modelReference(child.request.parentModel);
-        const actual = modelReference(child.request.model);
-        if (!parent || !actual) {
-            child.reportedSavings = { ...child.usage };
-            return undefined;
-        }
-        const tokens = savingsTokens(usage);
-        child.reportedSavings = { ...child.usage };
-        return {
-            category: 'model-routing',
-            operation: 'explore-child',
-            baseline: { model: parent, tokens },
-            actual: {
-                model: actual,
-                tokens,
-                ...(usage.cost > 0 ? { costUsd: usage.cost } : {}),
-            },
-            basis: {
-                kind: 'estimated-baseline',
-                method: 'parent-model-reprice-observed-child-usage-v1',
-            },
-            dimensions: { techniques: ['explore', 'same-usage-reprice'] },
-        };
-    }
-    async #persist() {
-        const snapshot = [...this.#children.values()].map(toStored);
-        this.#save = this.#save.catch(() => { }).then(() => this.#store.save(snapshot));
-        await this.#save;
-    }
-    async #serializeControl(operation) {
-        const previous = this.#control;
-        let release;
-        this.#control = new Promise((resolve) => {
-            release = resolve;
-        });
-        await previous;
-        try {
-            return await operation();
-        }
-        finally {
-            release();
-        }
-    }
-    async #resultRecord(child) {
-        const record = cloneRecord(child.record);
-        if (record.status !== 'completed' || !child.sessionFile || !record.completedAt)
-            return record;
-        try {
-            const result = await finalAssistantText(child.sessionFile, record.completedAt);
-            return result === undefined ? record : { ...record, result };
-        }
-        catch {
-            return record;
-        }
-    }
-}
-async function shutdownSubagentSession(session) {
-    try {
-        if (session.extensionRunner.hasHandlers('session_shutdown')) {
-            await session.extensionRunner.emit({ type: 'session_shutdown', reason: 'quit' });
-        }
-    }
-    finally {
-        session.dispose();
-    }
-}
-export function inspectionToolNames(activeToolNames) {
-    const blocked = new Set([
-        'bash',
-        'edit',
-        'write',
-        'exec_command',
-        'write_stdin',
-        'write_background_bash',
-        'stop_background_bash',
-        'apply_patch',
-        'enter_prewalk',
-    ]);
-    const safe = activeToolNames.filter((name) => !blocked.has(name));
-    if (!safe.includes('read'))
-        safe.unshift('read');
-    return safe;
-}
-function completionNotice(record, deliveryId) {
-    return {
-        deliveryId,
-        parentSessionId: record.parentSessionId,
-        agentId: record.agentId,
-        type: record.type,
-        status: record.status,
-        ...(record.result === undefined ? {} : { summary: record.result.slice(0, 4_000) }),
-        ...(record.error === undefined ? {} : { error: record.error }),
-    };
-}
-function terminalRecord(record, status, error) {
-    return {
-        ...record,
-        status,
-        completedAt: new Date().toISOString(),
-        ...(error === undefined ? {} : { error }),
-    };
-}
-function isTerminal(status) {
-    return status === 'completed' || status === 'failed' || status === 'timed_out' || status === 'cancelled';
-}
-function isContinuable(child) {
-    if (!child.sessionFile)
-        return false;
-    if (child.record.status === 'completed')
-        return true;
-    if (child.record.status === 'failed' && child.record.error?.code === 'model_request_failed')
-        return true;
-    if (child.record.status !== 'cancelled')
-        return false;
-    return child.record.error?.code === 'turn_limit_reached'
-        || child.record.error?.code === 'host_shutdown';
-}
-function sanitizeModelError(value) {
-    const normalized = (value ?? 'unknown provider error')
-        .replace(/[\u0000-\u001F\u007F-\u009F]/gu, ' ')
-        .replace(/\s+/gu, ' ')
-        .trim();
-    if (!normalized)
-        return 'unknown provider error';
-    return normalized.length <= 300 ? normalized : `${normalized.slice(0, 299)}…`;
-}
-function success(value) {
-    return { ok: true, value };
-}
-function failure(code, message) {
-    return { ok: false, error: { code, message } };
-}
-function cloneRecord(record) {
-    return structuredClone(record);
-}
-function localView(child) {
-    return {
-        ...cloneRecord(child.record),
-        ...(child.request.model === undefined ? {} : { model: child.request.model }),
-        ...(child.session === undefined ? {} : { session: child.session }),
-        ...(child.usage === undefined ? {} : { usage: { ...child.usage } }),
-    };
-}
-function fromStored(stored) {
-    return structuredClone(stored);
-}
-function toStored(child) {
-    return structuredClone({
-        record: child.record,
-        request: child.request,
-        depth: child.depth,
-        ...(child.reportedSavings === undefined ? {} : { reportedSavings: child.reportedSavings }),
-        ...(child.sessionFile === undefined ? {} : { sessionFile: child.sessionFile }),
-        ...(child.deliveryId === undefined ? {} : { deliveryId: child.deliveryId }),
-        completionPending: child.completionPending,
-    });
-}
-function boundedInteger(value, fallback, minimum, maximum) {
-    return value === undefined || !Number.isInteger(value)
-        ? fallback
-        : Math.max(minimum, Math.min(maximum, value));
-}
-function subagentStatusPriority(status) {
-    switch (status) {
-        case 'running': return 0;
-        case 'queued': return 1;
-        case 'failed':
-        case 'timed_out':
-        case 'cancelled': return 2;
-        case 'completed': return 3;
-    }
-}
-function boundResult(result) {
-    const bytes = Buffer.from(result);
-    return bytes.byteLength <= MAX_RESULT_BYTES
-        ? result
-        : `${new TextDecoder().decode(bytes.subarray(0, MAX_RESULT_BYTES))}\n[truncated]`;
-}
-function byteLength(value) {
-    return Buffer.byteLength(value);
-}
-function emptyUsageTotals() {
-    return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cacheWrite1h: 0, cost: 0 };
-}
-function addUsage(target, source) {
-    if (!source)
-        return;
-    target.input += source.input;
-    target.output += source.output;
-    target.cacheRead += source.cacheRead;
-    target.cacheWrite += source.cacheWrite;
-    target.cacheWrite1h += source.cacheWrite1h;
-    target.cost += source.cost;
-}
-function usageFromEntries(entries) {
-    const totals = emptyUsageTotals();
-    for (const entry of entries) {
-        if (entry.type !== 'message' || entry.message.role !== 'assistant')
-            continue;
-        totals.input += entry.message.usage.input;
-        totals.output += entry.message.usage.output;
-        totals.cacheRead += entry.message.usage.cacheRead;
-        totals.cacheWrite += entry.message.usage.cacheWrite;
-        totals.cacheWrite1h += entry.message.usage.cacheWrite1h ?? 0;
-        totals.cost += entry.message.usage.cost.total;
-    }
-    return totals;
-}
-async function loadSessionUsage(sessionFile, expectedSessionId) {
-    try {
-        const totals = emptyUsageTotals();
-        let headerValidated = false;
-        for (const line of (await readFile(sessionFile, 'utf8')).split('\n')) {
-            if (!line.trim())
-                continue;
-            let entry;
-            try {
-                entry = JSON.parse(line);
-            }
-            catch {
-                if (!headerValidated)
-                    return undefined;
-                continue;
-            }
-            if (!headerValidated) {
-                if (typeof entry !== 'object'
-                    || entry === null
-                    || Reflect.get(entry, 'type') !== 'session'
-                    || Reflect.get(entry, 'id') !== expectedSessionId)
-                    return undefined;
-                headerValidated = true;
-                continue;
-            }
-            addPersistedAssistantUsage(totals, entry);
-        }
-        return headerValidated ? totals : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function addPersistedAssistantUsage(target, entry) {
-    if (typeof entry !== 'object'
-        || entry === null
-        || Reflect.get(entry, 'type') !== 'message')
-        return;
-    const message = Reflect.get(entry, 'message');
-    if (typeof message !== 'object' || message === null || Reflect.get(message, 'role') !== 'assistant')
-        return;
-    const usage = Reflect.get(message, 'usage');
-    if (typeof usage !== 'object' || usage === null)
-        return;
-    const cost = Reflect.get(usage, 'cost');
-    if (typeof cost !== 'object' || cost === null)
-        return;
-    const values = {
-        input: Reflect.get(usage, 'input'),
-        output: Reflect.get(usage, 'output'),
-        cacheRead: Reflect.get(usage, 'cacheRead'),
-        cacheWrite: Reflect.get(usage, 'cacheWrite'),
-        cacheWrite1h: Reflect.get(usage, 'cacheWrite1h') ?? 0,
-        cost: Reflect.get(cost, 'total'),
-    };
-    if (!Object.values(values).every((value) => typeof value === 'number' && Number.isFinite(value)))
-        return;
-    addUsage(target, values);
-}
-function subtractUsage(current, previous) {
-    const baseline = previous ?? emptyUsageTotals();
-    const result = {
-        input: current.input - baseline.input,
-        output: current.output - baseline.output,
-        cacheRead: current.cacheRead - baseline.cacheRead,
-        cacheWrite: current.cacheWrite - baseline.cacheWrite,
-        cacheWrite1h: current.cacheWrite1h - baseline.cacheWrite1h,
-        cost: current.cost - baseline.cost,
-    };
-    if (Object.values(result).some((value) => !Number.isFinite(value) || value < 0))
-        return undefined;
-    return result.input + result.output + result.cacheRead + result.cacheWrite > 0 ? result : undefined;
-}
-function savingsTokens(usage) {
-    return {
-        input: usage.input,
-        output: usage.output,
-        cacheRead: usage.cacheRead,
-        cacheWrite: usage.cacheWrite,
-        cacheWrite1h: usage.cacheWrite1h,
-    };
-}
-function modelReference(value) {
-    const separator = value.indexOf('/');
-    if (separator <= 0 || separator === value.length - 1)
-        return undefined;
-    return { provider: value.slice(0, separator), id: value.slice(separator + 1) };
-}
-function sessionFileOutcome(sessionFile) {
-    return sessionFile === undefined ? {} : { sessionFile };
-}
-async function preflightSessionFile(sessionFile, expectedSessionId) {
-    const contents = await readFile(sessionFile, 'utf8');
-    let header;
-    for (const line of contents.split('\n')) {
-        if (!line.trim())
-            continue;
-        const entry = JSON.parse(line);
-        header ??= entry;
-    }
-    if (typeof header !== 'object'
-        || header === null
-        || Reflect.get(header, 'type') !== 'session'
-        || Reflect.get(header, 'version') !== CURRENT_SESSION_VERSION
-        || Reflect.get(header, 'id') !== expectedSessionId
-        || typeof Reflect.get(header, 'timestamp') !== 'string'
-        || typeof Reflect.get(header, 'cwd') !== 'string') {
-        throw new Error('Retained session file has an invalid header');
-    }
-}
-async function finalAssistantText(sessionFile, completedAt) {
-    let result;
-    for (const line of (await readFile(sessionFile, 'utf8')).split('\n')) {
-        if (!line)
-            continue;
-        const entry = JSON.parse(line);
-        if (entry.type !== 'message'
-            || entry.message?.role !== 'assistant'
-            || typeof entry.timestamp !== 'string'
-            || entry.timestamp > completedAt
-            || !Array.isArray(entry.message.content))
-            continue;
-        result = entry.message.content
-            .filter((part) => (typeof part === 'object'
-            && part !== null
-            && Reflect.get(part, 'type') === 'text'
-            && typeof Reflect.get(part, 'text') === 'string'))
-            .map((part) => part.text)
-            .join('\n');
-    }
-    return result;
-}
-//# sourceMappingURL=host.js.map