@modelprofile.com/flexharness 10.24.0 → 11.0.0

package/dist_ts/classes.flexharness.prompts.js

@@ -0,0 +1,659 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessAbortError, FlexHarnessNotFoundError, FlexHarnessQueueFullError, FlexHarnessSessionBusyError, FlexHarnessSlashCommandReentryError, FlexHarnessSteerRejectedError, FlexHarnessStoreCommitUncertainError, FlexHarnessValidationError, errorToInfo, } from './errors.js';
+import { cloneSerializable } from './utils.json.js';
+import { normalizeFlexPrompt } from './utils.prompt.js';
+import { jsonBytes, publicSnapshot, requireTransferIdentifier } from './utils.transfer.js';
+import { validateIdentifier, validatePromptOptions } from './utils.validation.js';
+import { createSessionMetricsOperation } from './utils.sessionmetrics.js';
+import { combineErrors, isAbortError } from './utils.flexharness.js';
+const maxScheduleDebounceMs = 24 * 60 * 60 * 1000;
+function containsStoreCommitUncertainty(error, seen = new Set()) {
+    if (error instanceof FlexHarnessStoreCommitUncertainError)
+        return true;
+    if (!(error instanceof Error) || seen.has(error))
+        return false;
+    seen.add(error);
+    try {
+        if (error instanceof AggregateError) {
+            for (const nested of error.errors) {
+                if (containsStoreCommitUncertainty(nested, seen))
+                    return true;
+            }
+        }
+        return containsStoreCommitUncertainty(error.cause, seen);
+    }
+    catch {
+        return false;
+    }
+}
+/** The prompt queue: admission, scheduling, promotion and cancellation of prompts and steers. */
+export class FlexHarnessPromptQueue {
+    core;
+    pendingPromptAdmissionOwners = new Set();
+    promptQueueSequence = 0;
+    pendingPromptAdmissions = 0;
+    pendingPromptAdmissionBytes = 0;
+    constructor(core) {
+        this.core = core;
+    }
+    promptAdmissionByteSize(prompt, options, scheduleKey, debounceMs) {
+        return jsonBytes({
+            prompt: normalizeFlexPrompt(prompt),
+            options: cloneSerializable(options),
+            scheduleKey,
+            debounceMs,
+        });
+    }
+    isSessionRuntimeIdle(state, stored) {
+        return stored.session.status === 'idle'
+            && !state.activeRuns.has(stored.session.sessionId)
+            && stored.outstandingPromptsById.size === 0;
+    }
+    async prompt(scopeId, sessionId, prompt, options = {}) {
+        const admission = await this.startPrompt(scopeId, sessionId, prompt, options);
+        return admission.completion;
+    }
+    async startPrompt(scopeId, sessionId, prompt, options = {}) {
+        validatePromptOptions(options, false);
+        const queued = await this.enqueuePromptInternal(scopeId, sessionId, prompt, options);
+        return queued.started;
+    }
+    async enqueuePrompt(scopeId, sessionId, prompt, options = {}) {
+        validatePromptOptions(options, false);
+        const queued = await this.enqueuePromptInternal(scopeId, sessionId, prompt, options);
+        return queued.admission;
+    }
+    async schedulePrompt(scopeId, sessionId, scheduleKey, prompt, options = {}) {
+        validateIdentifier(scheduleKey, 'scheduleKey');
+        requireTransferIdentifier(scheduleKey, 'scheduleKey');
+        validatePromptOptions(options, true);
+        const debounceMs = options.debounceMs ?? 50;
+        if (!Number.isSafeInteger(debounceMs) || debounceMs < 0 || debounceMs > maxScheduleDebounceMs) {
+            throw new FlexHarnessValidationError(`debounceMs must be an integer from 0 through ${maxScheduleDebounceMs}.`);
+        }
+        const queued = await this.enqueuePromptInternal(scopeId, sessionId, prompt, options, scheduleKey, debounceMs);
+        const admission = await queued.started;
+        return Object.freeze({ ...admission, scheduleKey });
+    }
+    async getPromptQueueEntry(scopeId, sessionId, queueId) {
+        validateIdentifier(queueId, 'queueId');
+        requireTransferIdentifier(queueId, 'queueId');
+        const { state } = await this.core.resolveState(scopeId);
+        this.core.assertStateAcceptingWork(state);
+        const stored = this.core.requireSession(state, sessionId);
+        const entry = this.promptQueueEntry(stored, queueId);
+        if (!entry)
+            throw new FlexHarnessNotFoundError('Prompt queue entry', queueId);
+        return publicSnapshot(entry);
+    }
+    async listPromptQueueEntries(scopeId, sessionId) {
+        const { state } = await this.core.resolveState(scopeId);
+        this.core.assertStateAcceptingWork(state);
+        const stored = this.core.requireSession(state, sessionId);
+        return publicSnapshot([
+            ...[...stored.outstandingPromptsById.values()].map((entry) => this.projectPromptQueueEntry(entry)),
+            ...stored.terminalPromptQueueEntries.values(),
+        ].sort((left, right) => left.queueSequence - right.queueSequence));
+    }
+    async cancelPrompt(scopeId, sessionId, queueId) {
+        validateIdentifier(queueId, 'queueId');
+        requireTransferIdentifier(queueId, 'queueId');
+        const { scope, state } = await this.core.resolveState(scopeId);
+        const stored = this.core.requireSession(state, sessionId);
+        const queued = stored.outstandingPromptsById.get(queueId);
+        if (!queued) {
+            if (stored.terminalPromptQueueEntries.has(queueId))
+                return false;
+            throw new FlexHarnessNotFoundError('Prompt queue entry', queueId);
+        }
+        return this.cancelQueuedPrompt(queued, this.core.trustInternalError(new FlexHarnessAbortError('The queued prompt was cancelled.')), this.core.compaction.createCompactorContext(scopeId, scope.scope, state.storageKey, sessionId));
+    }
+    async cancelScheduledPrompt(scopeId, sessionId, scheduleKey) {
+        validateIdentifier(scheduleKey, 'scheduleKey');
+        const { scope, state } = await this.core.resolveState(scopeId);
+        const stored = this.core.requireSession(state, sessionId);
+        const queued = [...stored.outstandingPromptsById.values()]
+            .find((entry) => entry.scheduleKey === scheduleKey);
+        if (!queued)
+            return false;
+        const cancellation = this.core.trustInternalError(new FlexHarnessAbortError('The scheduled run was cancelled.'));
+        return this.cancelQueuedPrompt(queued, cancellation, this.core.compaction.createCompactorContext(scopeId, scope.scope, state.storageKey, sessionId));
+    }
+    async steerPrompt(scopeId, sessionId, queueId, steer) {
+        validateIdentifier(queueId, 'queueId');
+        requireTransferIdentifier(queueId, 'queueId');
+        validateIdentifier(steer.steerId, 'steerId');
+        requireTransferIdentifier(steer.steerId, 'steerId');
+        this.core.assertOpen();
+        const prompt = normalizeFlexPrompt(steer.prompt);
+        const byteSize = this.promptAdmissionByteSize(steer.prompt, {});
+        const { state } = await this.core.resolveState(scopeId);
+        this.core.assertStateAcceptingWork(state);
+        const stored = this.core.requireSession(state, sessionId);
+        this.core.assertSessionWritable(stored);
+        if (stored.session.agent !== undefined) {
+            throw new FlexHarnessValidationError('Subagent sessions can only be prompted through the foreground delegate tool.');
+        }
+        const run = state.activeRuns.get(sessionId);
+        if (!run || run.queueId !== queueId) {
+            if (stored.outstandingPromptsById.has(queueId) || stored.terminalPromptQueueEntries.has(queueId)) {
+                throw new FlexHarnessSteerRejectedError('not-running', steer.steerId);
+            }
+            throw new FlexHarnessNotFoundError('Prompt queue entry', queueId);
+        }
+        return this.admitRunSteer(run, steer, prompt, byteSize);
+    }
+    /** The shared synchronous admission point; neither entrypoint starts or resumes a run. */
+    admitRunSteer(run, steer, prompt, byteSize) {
+        if (run.phase === 'closing'
+            || run.phase === 'finalizing'
+            || run.phase === 'promoting'
+            || run.callbacksClosed
+            || run.controller.signal.aborted
+            || run.stop.signal.aborted
+            || run.state.activeRuns.get(run.sessionId) !== run)
+            throw new FlexHarnessSteerRejectedError('not-running', steer.steerId);
+        const steering = run.steering;
+        if (!steering.input.closed && !steering.accepted.has(steer.steerId)) {
+            if (steering.accepted.size - steering.applied.size
+                >= this.core.promptQueueLimits.maxOutstandingPromptsPerSession) {
+                throw new FlexHarnessQueueFullError(`Session "${run.sessionId}" has reached its pending steer limit.`);
+            }
+            // Pending steers hold outstanding prompt bytes of the session until they are taken in.
+            if (steering.stored.outstandingPromptBytes + byteSize
+                > this.core.promptQueueLimits.maxOutstandingBytesPerSession) {
+                throw new FlexHarnessQueueFullError(`Session "${run.sessionId}" has reached its outstanding prompt byte limit.`);
+            }
+        }
+        try {
+            steering.input.add({
+                inputId: steer.steerId,
+                content: cloneSerializable(prompt.modelMessage.content),
+            });
+        }
+        catch (error) {
+            if (error instanceof plugins.AgentPendingInputRejectedError) {
+                throw new FlexHarnessSteerRejectedError(error.reason === 'duplicate' ? 'duplicate' : 'not-running', steer.steerId);
+            }
+            throw error;
+        }
+        steering.accepted.set(steer.steerId, { prompt, byteSize });
+        steering.stored.outstandingPromptBytes += byteSize;
+        this.core.emitEvent(run.scopeId, run.stored.session, {
+            type: 'prompt.steer.accepted',
+            queueId: run.queueId,
+            runId: run.runId,
+            steerId: steer.steerId,
+        });
+        return { steerId: steer.steerId, queueId: run.queueId, runId: run.runId };
+    }
+    async enqueuePromptInternal(scopeId, sessionId, prompt, options, scheduleKey, debounceMs, delegationSeed, admissionSignal, slashCommandAdmission = false) {
+        this.core.assertOpen();
+        const normalizedPrompt = normalizeFlexPrompt(prompt);
+        const normalizedOptions = cloneSerializable(options);
+        const byteSize = this.promptAdmissionByteSize(prompt, options, scheduleKey, debounceMs);
+        const releasePendingAdmission = this.reservePendingPromptAdmission(byteSize);
+        let resolveSettled;
+        const pendingOwner = {
+            controller: new AbortController(),
+            settled: new Promise((resolve) => {
+                resolveSettled = resolve;
+            }),
+            resolveSettled: () => resolveSettled(),
+        };
+        this.pendingPromptAdmissionOwners.add(pendingOwner);
+        const admissionSignals = [
+            pendingOwner.controller.signal,
+            ...(admissionSignal === undefined ? [] : [admissionSignal]),
+        ];
+        let abortAdmission;
+        const abortPromise = new Promise((_resolve, reject) => {
+            abortAdmission = () => {
+                const aborted = admissionSignals.find((signal) => signal.aborted);
+                reject(aborted?.reason ?? new FlexHarnessAbortError());
+            };
+            for (const signal of admissionSignals) {
+                signal.addEventListener('abort', abortAdmission, { once: true });
+            }
+            if (admissionSignals.some((signal) => signal.aborted))
+                abortAdmission();
+        });
+        try {
+            const resolved = await Promise.race([this.core.resolveState(scopeId), abortPromise]);
+            const state = resolved.state;
+            await Promise.race([state.scopeQueue, abortPromise]);
+            if (admissionSignal?.aborted) {
+                throw admissionSignal.reason ?? new FlexHarnessAbortError();
+            }
+            this.core.assertStateAcceptingWork(state);
+            const stored = this.core.requireSession(state, sessionId);
+            this.core.assertSessionWritable(stored);
+            const sessionKey = this.core.commands.slashCommandSessionKey(state.storageKey, sessionId);
+            const invocationOwner = this.core.commands.slashCommandInvocationContext.getStore();
+            if (invocationOwner?.sessionKey === sessionKey) {
+                throw this.core.trustInternalError(new FlexHarnessSlashCommandReentryError(sessionId));
+            }
+            if (!slashCommandAdmission && this.core.commands.activeSlashCommandExecutions.has(sessionKey)) {
+                throw new FlexHarnessSessionBusyError(sessionId, 'already has an active slash command execution');
+            }
+            if (stored.pendingReversion) {
+                throw new FlexHarnessSessionBusyError(sessionId, 'has a pending reversion operation');
+            }
+            if (stored.session.agent !== undefined && delegationSeed === undefined) {
+                throw new FlexHarnessValidationError('Subagent sessions can only be prompted through the foreground delegate tool.');
+            }
+            if (delegationSeed !== undefined) {
+                this.core.admission.assertDelegatedRunAdmissionOwnership(delegationSeed, state, stored, scopeId);
+            }
+            if (stored.outstandingPromptsById.size >= this.core.promptQueueLimits.maxOutstandingPromptsPerSession) {
+                throw new FlexHarnessQueueFullError(`Session "${sessionId}" has reached its outstanding prompt limit.`);
+            }
+            if (stored.outstandingPromptBytes + byteSize
+                > this.core.promptQueueLimits.maxOutstandingBytesPerSession) {
+                throw new FlexHarnessQueueFullError(`Session "${sessionId}" has reached its outstanding prompt byte limit.`);
+            }
+            if (scheduleKey
+                && [...stored.outstandingPromptsById.values()]
+                    .some((entry) => entry.scheduleKey === scheduleKey)) {
+                throw new FlexHarnessSessionBusyError(sessionId, `already has scheduled key "${scheduleKey}"`);
+            }
+            let resolveCompletion;
+            let rejectCompletion;
+            const completion = new Promise((resolve, reject) => {
+                resolveCompletion = resolve;
+                rejectCompletion = reject;
+            });
+            void completion.catch(() => undefined);
+            let resolveStarted;
+            let rejectStarted;
+            const started = new Promise((resolve, reject) => {
+                resolveStarted = resolve;
+                rejectStarted = reject;
+            });
+            void started.catch(() => undefined);
+            const queued = {
+                state,
+                stored,
+                scopeId,
+                scope: delegationSeed === undefined ? resolved.scope.scope : delegationSeed.scope,
+                sessionId,
+                queueId: plugins.crypto.randomUUID(),
+                queueSequence: ++this.promptQueueSequence,
+                status: 'queued',
+                queuedAt: new Date().toISOString(),
+                ...(scheduleKey === undefined ? {} : { scheduleKey, debounceMs }),
+                prompt: normalizedPrompt,
+                options: normalizedOptions,
+                ...(delegationSeed === undefined ? {} : { delegationSeed }),
+                byteSize,
+                completion,
+                resolveCompletion,
+                rejectCompletion,
+                started,
+                resolveStarted,
+                rejectStarted,
+            };
+            stored.promptQueue.push(queued);
+            stored.outstandingPromptsById.set(queued.queueId, queued);
+            stored.outstandingPromptBytes += byteSize;
+            this.emitPromptQueueEvent(queued, 'prompt.queued');
+            this.schedulePromptQueueDrain(state, stored);
+            return {
+                admission: Object.freeze({ queueId: queued.queueId, completion }),
+                started,
+                queued,
+            };
+        }
+        finally {
+            for (const signal of admissionSignals) {
+                signal.removeEventListener('abort', abortAdmission);
+            }
+            this.pendingPromptAdmissionOwners.delete(pendingOwner);
+            releasePendingAdmission();
+            pendingOwner.resolveSettled();
+        }
+    }
+    reservePendingPromptAdmission(byteSize) {
+        if (this.pendingPromptAdmissions >= this.core.promptQueueLimits.maxPendingAdmissions) {
+            throw new FlexHarnessQueueFullError('FlexHarness has reached its pending prompt admission limit.');
+        }
+        if (this.pendingPromptAdmissionBytes + byteSize
+            > this.core.promptQueueLimits.maxPendingAdmissionBytes) {
+            throw new FlexHarnessQueueFullError('FlexHarness has reached its pending prompt admission byte limit.');
+        }
+        this.pendingPromptAdmissions++;
+        this.pendingPromptAdmissionBytes += byteSize;
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.pendingPromptAdmissions--;
+            this.pendingPromptAdmissionBytes -= byteSize;
+        };
+    }
+    schedulePromptQueueDrain(state, stored) {
+        if (stored.promptQueueDrain)
+            return;
+        let drain;
+        drain = Promise.resolve()
+            .then(() => this.drainPromptQueue(state, stored))
+            .finally(() => {
+            if (stored.promptQueueDrain === drain)
+                delete stored.promptQueueDrain;
+            if (stored.promptQueue.length > 0
+                && !state.activeRuns.has(stored.session.sessionId)
+                && state.lifecycle === 'active'
+                && state.sessions.get(stored.session.sessionId) === stored)
+                this.schedulePromptQueueDrain(state, stored);
+        });
+        stored.promptQueueDrain = drain;
+        void drain.catch(() => undefined);
+    }
+    async drainPromptQueue(state, stored) {
+        while (state.lifecycle === 'active'
+            && state.sessions.get(stored.session.sessionId) === stored
+            && !state.activeRuns.has(stored.session.sessionId)) {
+            const queued = stored.promptQueue.shift();
+            if (!queued)
+                return;
+            if (stored.outstandingPromptsById.get(queued.queueId) !== queued)
+                continue;
+            queued.status = 'starting';
+            queued.runId = plugins.crypto.randomUUID();
+            queued.startedAt = new Date().toISOString();
+            const run = this.core.runs.createActiveRun(queued);
+            state.activeRuns.set(queued.sessionId, run);
+            try {
+                await this.promoteQueuedPrompt(queued, run);
+                return;
+            }
+            catch (error) {
+                if (state.activeRuns.get(queued.sessionId) === run)
+                    state.activeRuns.delete(queued.sessionId);
+                const cancellation = isAbortError(error);
+                this.finishQueuedPrompt(queued, cancellation ? 'cancelled' : 'failed', error);
+                if (state.lifecycle !== 'active')
+                    return;
+            }
+        }
+    }
+    assertPromptPromotion(queued, run) {
+        if (run.controller.signal.aborted) {
+            throw run.controller.signal.reason ?? new FlexHarnessAbortError();
+        }
+        this.core.assertStateAcceptingWork(run.state);
+        if (run.state.sessions.get(run.sessionId) !== run.stored
+            || run.stored.outstandingPromptsById.get(run.queueId) !== queued
+            || run.state.activeRuns.get(run.sessionId) !== run)
+            throw this.core.trustInternalError(new FlexHarnessAbortError('The prompt was retired during admission.'));
+        if (queued.delegationSeed) {
+            this.core.admission.assertDelegatedRunAdmissionOwnership(queued.delegationSeed, run.state, run.stored, run.scopeId);
+            if (run.queueId !== queued.queueId
+                || run.runId !== queued.runId
+                || run.sessionId !== queued.delegationSeed.sessionId) {
+                throw this.core.trustInternalError(new FlexHarnessAbortError('The delegated prompt lost its exact child run ownership.'));
+            }
+        }
+    }
+    async promoteQueuedPrompt(queued, run) {
+        const prompt = queued.prompt;
+        const options = queued.options;
+        let projectionReserved = false;
+        // Open from the reservation until its messages are announced or rolled back.
+        let closeReservationPublication = () => undefined;
+        try {
+            try {
+                this.assertPromptPromotion(queued, run);
+                await this.core.admission.acquireDelegatedRunAdmission(queued, run);
+                this.assertPromptPromotion(queued, run);
+                await this.core.reversions.commitRevertedBranch(run.state, run.stored, run.scopeId, run.scope);
+                this.assertPromptPromotion(queued, run);
+                const generationPrompt = cloneSerializable(prompt.modelMessage.content);
+                this.assertPromptPromotion(queued, run);
+                run.transaction = await this.core.compaction.withRunCompactorContext(run, () => run.stored.agentSession.beginGeneration(generationPrompt, { generationId: run.runId }));
+                this.assertPromptPromotion(queued, run);
+                const reservation = this.core.runs.createReservation(run, prompt);
+                closeReservationPublication = this.core.openPublication(run.state, run.sessionId);
+                run.metricsOperation = createSessionMetricsOperation(run.runId, 'generation');
+                await this.core.mutateProjection(run.state, run.stored, () => {
+                    if (run.stored.metrics.pendingGenerationId !== undefined) {
+                        throw new Error('Session metrics already owns a generation.');
+                    }
+                    run.stored.metrics.pendingGenerationId = run.runId;
+                    run.stored.messages.push(reservation.userMessage, reservation.assistantMessage);
+                    if (run.stored.session.agent === undefined) {
+                        this.core.reversions.pruneReversionState(run.stored, true);
+                        const captureId = this.core.turnReversionProvider
+                            ? this.core.reversions.reversionId('capture', run.state.storageKey, run.sessionId, run.runId)
+                            : undefined;
+                        const protocolVersion = this.core.reversions.reversionProviderProtocolVersion() ?? 1;
+                        run.stored.reversionSegments.push({
+                            runId: run.runId,
+                            userMessageId: reservation.userMessage.messageId,
+                            status: 'capturing',
+                            contextAvailable: true,
+                            eventIds: [],
+                            workspaceCaptured: captureId !== undefined,
+                            protocolVersion,
+                            provenance: captureId === undefined ? 'transcript' : 'workspace',
+                            ...(captureId === undefined ? {} : { disposition: 'pending' }),
+                            ...(captureId === undefined ? {} : { captureId }),
+                        });
+                        if (captureId) {
+                            run.stored.pendingReversion = {
+                                kind: 'capture',
+                                runId: run.runId,
+                                captureId,
+                                state: 'preparing',
+                                protocolVersion,
+                            };
+                        }
+                    }
+                });
+                projectionReserved = true;
+                run.reservedUserMessage = publicSnapshot(reservation.userMessage);
+                run.reservedAssistantMessage = publicSnapshot(reservation.assistantMessage);
+                this.assertPromptPromotion(queued, run);
+                await this.core.mutateScope(run.state, () => {
+                    if (run.controller.signal.aborted) {
+                        throw run.controller.signal.reason ?? new FlexHarnessAbortError();
+                    }
+                    if (run.state.tombstones.has(run.sessionId) || run.state.sessions.get(run.sessionId) !== run.stored) {
+                        throw new FlexHarnessAbortError('The session was deleted during prompt admission.');
+                    }
+                    run.stored.session.status = run.scheduleKey ? 'scheduled' : 'running';
+                    run.stored.session.activity = {
+                        runId: run.runId,
+                        status: run.scheduleKey ? 'scheduled' : 'running',
+                        startedAt: reservation.userMessage.createdAt,
+                    };
+                    run.stored.session.updatedAt = reservation.userMessage.createdAt;
+                });
+            }
+            catch (error) {
+                if (containsStoreCommitUncertainty(error))
+                    run.state.lifecycle = 'fenced';
+                const safeError = this.core.projectExternalError(run, error, projectionReserved ? 'persistence' : 'agentSession');
+                let cleanupErrors = [];
+                let cleanupFailure;
+                try {
+                    await this.core.admission.closeRunDelegatedRunAdmission(run, !run.delegatedRunAdmissionOwner?.acquisitionDetached);
+                }
+                catch (closeError) {
+                    cleanupErrors.push(closeError);
+                }
+                try {
+                    cleanupErrors.push(...await this.core.runs.rollbackAdmission(run, projectionReserved, safeError));
+                }
+                catch (rollbackError) {
+                    cleanupFailure = rollbackError;
+                }
+                if (cleanupFailure !== undefined && cleanupErrors.length > 0) {
+                    cleanupFailure = combineErrors([cleanupFailure, ...cleanupErrors]);
+                }
+                if (run.state.lifecycle === 'fenced' && cleanupFailure === undefined) {
+                    const combined = combineErrors([safeError, ...cleanupErrors]);
+                    try {
+                        await this.core.lifecycle.fenceNamespace(run.state, run, combined);
+                    }
+                    catch (fenceError) {
+                        cleanupFailure = fenceError;
+                    }
+                }
+                const rejection = cleanupFailure
+                    ?? (cleanupErrors.length > 0 ? combineErrors([safeError, ...cleanupErrors]) : safeError);
+                throw rejection;
+            }
+            const runType = run.scheduleKey ? 'run.scheduled' : 'run.started';
+            this.core.emitEvent(run.scopeId, run.stored.session, {
+                type: runType,
+                runId: run.runId,
+                messageId: run.userMessageId,
+                session: publicSnapshot(run.stored.session),
+            });
+            for (const message of [run.reservedUserMessage, run.reservedAssistantMessage]) {
+                this.core.emitEvent(run.scopeId, run.stored.session, {
+                    type: 'message.created',
+                    runId: run.runId,
+                    messageId: message.messageId,
+                    message,
+                });
+            }
+        }
+        finally {
+            closeReservationPublication();
+        }
+        queued.status = run.scheduleKey ? 'scheduled' : 'starting';
+        this.emitPromptQueueEvent(queued, 'prompt.started');
+        queued.resolveStarted(Object.freeze({
+            queueId: queued.queueId,
+            runId: run.runId,
+            completion: queued.completion,
+        }));
+        run.phase = run.scheduleKey ? 'scheduled' : 'running';
+        const generateOptions = {
+            transaction: run.transaction,
+            abort: run.controller.signal,
+            stop: run.stop.signal,
+            prepare: (context) => this.core.runs.prepareGeneration(run, options, context.abortSignal),
+            pendingInput: run.steering.input,
+            activateOnBackgroundJobs: true,
+            onCacheDispatch: (dispatch) => { run.cacheDispatch = dispatch; },
+            onInputApplied: (input) => this.core.runs.applyRunSteer(run, input),
+            beforeFinish: (context) => this.core.subagentTasks.awaitNextBackgroundSubagent(run, context.abortSignal),
+        };
+        const generation = this.core.compaction.withRunCompactorContext(run, () => run.scheduleKey
+            ? run.stored.agentSession.scheduleGenerate({
+                key: run.scheduleKey,
+                debounceMs: run.debounceMs,
+                ...generateOptions,
+            })
+            : run.stored.agentSession.generate(generateOptions));
+        const execution = this.core.runs.executeRun(run, generation).then((result) => this.finishQueuedPrompt(queued, 'completed', undefined, result), (error) => this.finishQueuedPrompt(queued, isAbortError(error) ? 'cancelled' : 'failed', error)).finally(() => this.schedulePromptQueueDrain(run.state, run.stored));
+        void execution.catch(() => undefined);
+    }
+    projectPromptQueueEntry(queued) {
+        return {
+            queueId: queued.queueId,
+            queueSequence: queued.queueSequence,
+            scopeId: queued.scopeId,
+            sessionId: queued.sessionId,
+            status: queued.status,
+            queuedAt: queued.queuedAt,
+            ...(queued.runId ? { runId: queued.runId } : {}),
+            ...(queued.scheduleKey ? { scheduleKey: queued.scheduleKey } : {}),
+            ...(queued.startedAt ? { startedAt: queued.startedAt } : {}),
+        };
+    }
+    promptQueueEntry(stored, queueId) {
+        const outstanding = stored.outstandingPromptsById.get(queueId);
+        return outstanding
+            ? this.projectPromptQueueEntry(outstanding)
+            : stored.terminalPromptQueueEntries.get(queueId);
+    }
+    emitPromptQueueEvent(queued, type, entry = this.projectPromptQueueEntry(queued)) {
+        this.core.emitEvent(queued.scopeId, queued.stored.session, {
+            type,
+            queueId: queued.queueId,
+            ...(entry.runId ? { runId: entry.runId } : {}),
+            entry: publicSnapshot(entry),
+        });
+    }
+    finishQueuedPrompt(queued, status, error, result) {
+        const stored = queued.stored;
+        if (stored.outstandingPromptsById.get(queued.queueId) !== queued)
+            return;
+        stored.promptQueue = stored.promptQueue.filter((entry) => entry !== queued);
+        stored.outstandingPromptsById.delete(queued.queueId);
+        stored.outstandingPromptBytes = Math.max(0, stored.outstandingPromptBytes - queued.byteSize);
+        delete queued.prompt;
+        delete queued.options;
+        delete queued.delegationSeed;
+        const steering = queued.steering === undefined ? undefined : this.core.runs.closeRunSteering(queued.steering);
+        const terminal = {
+            ...this.projectPromptQueueEntry(queued),
+            status,
+            finishedAt: new Date().toISOString(),
+            ...(error === undefined ? {} : { error: errorToInfo(error) }),
+            keptInContext: steering?.keptInContext ?? false,
+            ...(steering === undefined || steering.unappliedSteerIds.length === 0
+                ? {}
+                : { unappliedSteerIds: [...steering.unappliedSteerIds] }),
+        };
+        stored.terminalPromptQueueEntries.set(queued.queueId, terminal);
+        while (stored.terminalPromptQueueEntries.size
+            > this.core.promptQueueLimits.maxTerminalEntriesPerSession) {
+            const oldest = stored.terminalPromptQueueEntries.keys().next().value;
+            if (!oldest)
+                break;
+            stored.terminalPromptQueueEntries.delete(oldest);
+        }
+        this.emitPromptQueueEvent(queued, 'prompt.finished', terminal);
+        if (status === 'completed') {
+            if (!result)
+                throw new Error('A completed queued prompt requires a result.');
+            queued.resolveCompletion(result);
+        }
+        else {
+            const rejection = error ?? this.core.trustInternalError(new FlexHarnessAbortError());
+            queued.rejectStarted(rejection);
+            queued.rejectCompletion(rejection);
+        }
+    }
+    cancelQueuedPrompt(queued, reason, context) {
+        if (queued.stored.outstandingPromptsById.get(queued.queueId) !== queued)
+            return false;
+        if (queued.status === 'queued') {
+            this.finishQueuedPrompt(queued, 'cancelled', reason);
+            this.schedulePromptQueueDrain(queued.state, queued.stored);
+            return true;
+        }
+        const run = queued.state.activeRuns.get(queued.sessionId);
+        if (!run || run.queueId !== queued.queueId)
+            return false;
+        if (run.phase === 'finalizing' || run.phase === 'promoting')
+            return false;
+        this.core.runs.cancelRun(run, reason, context);
+        return true;
+    }
+    cancelStoredPromptQueue(stored, reason, excludedQueueId, context) {
+        for (const queued of [...stored.outstandingPromptsById.values()]) {
+            if (queued.queueId === excludedQueueId)
+                continue;
+            this.cancelQueuedPrompt(queued, reason, context);
+        }
+    }
+    purgeStoredPromptQueue(stored) {
+        for (const queued of stored.outstandingPromptsById.values()) {
+            delete queued.prompt;
+            delete queued.options;
+            delete queued.delegationSeed;
+        }
+        stored.promptQueue.length = 0;
+        stored.outstandingPromptsById.clear();
+        stored.terminalPromptQueueEntries.clear();
+        stored.outstandingPromptBytes = 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.flexharness.prompts.js","sourceRoot":"","sources":["../ts/classes.flexharness.prompts.ts"],"names":[],"mappings":"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"}