@orion-agents/orion-code 0.3.1 → 0.3.4

package/dist/runtime/session-composer-control.js

@@ -0,0 +1,532 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionComposerControlServiceV1 = exports.SessionComposerControlError = void 0;
+const crypto_1 = require("crypto");
+const compact_1 = require("../services/compact");
+const model_context_1 = require("../services/model-context");
+const model_registry_1 = require("../services/model-registry");
+const effort_1 = require("../services/effort");
+const global_config_1 = require("../services/global-config");
+const session_storage_1 = require("../services/session-storage");
+const token_estimate_1 = require("../utils/token-estimate");
+const canonical_1 = require("./protocol/canonical");
+class SessionComposerControlError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'SessionComposerControlError';
+    }
+}
+exports.SessionComposerControlError = SessionComposerControlError;
+/** Product-owned Session control service shared by slash commands and Web. */
+class SessionComposerControlServiceV1 {
+    constructor(options) {
+        this.options = options;
+        this.listeners = new Set();
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    describe() {
+        const session = this.options.getSession() ?? this.options.ensureSession();
+        return this.project(session, true);
+    }
+    describeSession(session) {
+        return this.project(session, this.options.getSession()?.id === session.id);
+    }
+    catalog() {
+        const registry = this.options.config.modelRegistry;
+        const profiles = registry?.enabledProfiles ?? [this.legacyProfile(this.options.config.model)];
+        const models = Object.freeze(profiles.map(profile => {
+            const provider = registry?.providers.get(profile.provider);
+            return Object.freeze({
+                id: profile.id,
+                label: profile.displayName ?? profile.id,
+                providerId: profile.provider,
+                providerLabel: provider?.displayName ?? profile.provider,
+                contextWindow: profile.resolvedContextWindow,
+                maxOutputTokens: profile.resolvedMaxOutputTokens,
+                reasoning: Boolean(profile.reasoningCapability),
+                effortLevels: Object.freeze([...(profile.reasoningCapability?.supportedLevels ?? [])]),
+                ...(profile.reasoningCapability?.defaultLevel
+                    ? { defaultEffort: profile.reasoningCapability.defaultLevel }
+                    : {}),
+                aliases: Object.freeze([...(profile.aliases ?? [])]),
+                fingerprint: profile.fingerprint,
+            });
+        }));
+        const unavailableProviders = Object.freeze(registry
+            ? [...registry.providers.values()]
+                .filter(provider => !providerCredentialAvailable(provider.apiKey))
+                .map(provider => Object.freeze({
+                id: provider.id,
+                reason: 'The configured credential slot is unavailable.',
+            }))
+            : []);
+        return Object.freeze({
+            revision: (0, canonical_1.digestRuntimeValue)({ models, unavailableProviders }),
+            models,
+            unavailableProviders,
+        });
+    }
+    async selectModel(input) {
+        if (input.effort !== undefined && !(0, effort_1.isEffortPreference)(input.effort)) {
+            throw new SessionComposerControlError('model_effort_unsupported', `Unsupported effort preference: ${String(input.effort)}`);
+        }
+        const session = this.options.getSession() ?? this.options.ensureSession();
+        const before = (0, session_storage_1.projectSessionComposerPreferences)(session);
+        const profile = this.resolveProfile(input.modelId);
+        const requestedEffort = input.effort ?? session.effortPreference ?? 'auto';
+        const resolvedEffort = this.resolveEffort(profile, requestedEffort);
+        if (requestedEffort !== 'auto' && !resolvedEffort.supported) {
+            throw new SessionComposerControlError('model_effort_unsupported', resolvedEffort.warning ?? `Effort ${requestedEffort} is unavailable for ${profile.id}.`);
+        }
+        if (!this.options.runtimeIdle()) {
+            this.pendingModel = Object.freeze({
+                sessionId: session.id,
+                modelId: profile.id,
+                effort: requestedEffort,
+            });
+            this.lastError = undefined;
+            this.emitChanged();
+            return Object.freeze({
+                receiptId: (0, crypto_1.randomUUID)(),
+                fromModelId: session.model,
+                toModelId: profile.id,
+                requestedEffort,
+                compacted: false,
+                compactRequired: profile.resolvedContextWindow < this.project(session, true).model.contextWindow,
+                compactPreflight: 'deferred',
+                appliesFrom: 'next-logical-request',
+                sessionPreferencesDigest: (0, canonical_1.digestRuntimeValue)({
+                    current: (0, session_storage_1.projectSessionComposerPreferences)(session),
+                    pending: this.pendingModel,
+                }),
+            });
+        }
+        this.pendingModel = undefined;
+        const previousCoordinatorModel = this.options.modelCoordinator?.getCurrent()?.id;
+        let persisted = null;
+        let switchResult = {
+            success: true,
+            compacted: false,
+            compactRequired: false,
+            compactPreflight: 'not_required',
+        };
+        const effortValue = requestedEffort === 'auto' ? undefined : requestedEffort;
+        try {
+            // Commit the cheap, CAS-protected Session metadata first. A semantic
+            // compact is append-only and cannot be honestly "undone" after its
+            // checkpoint is installed, so it must never run before this write can
+            // succeed. Any later preflight failure rolls this metadata write back.
+            persisted = (0, session_storage_1.updateSessionComposerPreferences)(session.id, {
+                expected: before,
+                model: profile.id,
+                effort: { value: effortValue },
+            });
+            if (!persisted) {
+                throw new SessionComposerControlError('session_unavailable', `Session ${session.id} is no longer available.`);
+            }
+            copySessionPreferences(session, persisted);
+            if (this.options.modelCoordinator) {
+                switchResult = await this.options.modelCoordinator.switchToWithCompactPreflight(profile.id, request => this.commitCompact(request));
+                if (!switchResult.success) {
+                    throw new SessionComposerControlError('model_unavailable', switchResult.error ?? `Model ${profile.id} could not be selected.`);
+                }
+            }
+            this.options.applySessionState(session);
+        }
+        catch (error) {
+            let rollbackFailed = false;
+            if (persisted) {
+                try {
+                    const restored = (0, session_storage_1.updateSessionComposerPreferences)(session.id, {
+                        expected: (0, session_storage_1.projectSessionComposerPreferences)(persisted),
+                        model: before.model,
+                        effort: { value: before.effortPreference },
+                    });
+                    if (restored)
+                        copySessionPreferences(session, restored);
+                    else
+                        rollbackFailed = true;
+                }
+                catch {
+                    rollbackFailed = true;
+                }
+            }
+            if (previousCoordinatorModel)
+                this.options.modelCoordinator?.initModel(previousCoordinatorModel);
+            if (error instanceof session_storage_1.SessionComposerPreferencesConflictError) {
+                const latest = (0, session_storage_1.loadSessionMeta)(session.id);
+                if (latest)
+                    copySessionPreferences(session, latest);
+                else
+                    restoreSessionObject(session, before);
+                this.options.applySessionState(session);
+                return this.failControl(session.id, new SessionComposerControlError('composer_control_conflict', error.message));
+            }
+            restoreSessionObject(session, before);
+            this.options.applySessionState(session);
+            if (rollbackFailed) {
+                return this.failControl(session.id, new SessionComposerControlError('composer_recovery_required', 'Model selection failed and its durable Session metadata could not be rolled back.'));
+            }
+            if (error instanceof SessionComposerControlError) {
+                return this.failControl(session.id, error);
+            }
+            return this.failControl(session.id, new SessionComposerControlError('model_switch_rolled_back', `Model switch was rolled back: ${error instanceof Error ? error.message : String(error)}`));
+        }
+        const current = (0, session_storage_1.projectSessionComposerPreferences)(session);
+        this.lastError = undefined;
+        this.emitChanged();
+        return Object.freeze({
+            receiptId: (0, crypto_1.randomUUID)(),
+            fromModelId: before.model,
+            toModelId: profile.id,
+            requestedEffort,
+            compacted: switchResult.compacted === true,
+            compactRequired: switchResult.compactRequired === true,
+            compactPreflight: switchResult.compactPreflight ?? 'not_required',
+            appliesFrom: 'immediate',
+            sessionPreferencesDigest: (0, canonical_1.digestRuntimeValue)(current),
+        });
+    }
+    async setEffort(effort) {
+        const session = this.options.getSession() ?? this.options.ensureSession();
+        return this.selectModel({ modelId: session.model, effort });
+    }
+    async setPermissionOverride(override) {
+        if (override !== null && !['ask', 'allow', 'deny'].includes(override)) {
+            throw new SessionComposerControlError('permission_override_rejected', `Unsupported tool confirmation policy: ${String(override)}`);
+        }
+        const session = this.options.getSession() ?? this.options.ensureSession();
+        const previousState = this.project(session, true).permission;
+        const idle = this.options.runtimeIdle();
+        const before = (0, session_storage_1.projectSessionComposerPreferences)(session);
+        let persisted = null;
+        try {
+            persisted = (0, session_storage_1.updateSessionComposerPreferences)(session.id, {
+                expected: before,
+                permission: { value: override ?? undefined },
+            });
+            if (!persisted) {
+                throw new SessionComposerControlError('session_unavailable', `Session ${session.id} is no longer available.`);
+            }
+            copySessionPreferences(session, persisted);
+            this.options.applySessionState(session);
+            if (idle)
+                await this.options.rebindSessionRuntime();
+        }
+        catch (error) {
+            let rollbackFailed = false;
+            if (persisted) {
+                const applied = (0, session_storage_1.projectSessionComposerPreferences)(persisted);
+                try {
+                    const restored = (0, session_storage_1.updateSessionComposerPreferences)(session.id, {
+                        expected: applied,
+                        permission: { value: before.toolConfirmationOverride },
+                    });
+                    if (restored)
+                        copySessionPreferences(session, restored);
+                    else
+                        rollbackFailed = true;
+                }
+                catch {
+                    rollbackFailed = true;
+                }
+            }
+            if (error instanceof session_storage_1.SessionComposerPreferencesConflictError) {
+                const latest = (0, session_storage_1.loadSessionMeta)(session.id);
+                if (latest)
+                    copySessionPreferences(session, latest);
+                else
+                    restoreSessionObject(session, before);
+                this.options.applySessionState(session);
+                if (idle)
+                    await this.options.rebindSessionRuntime().catch(() => undefined);
+                return this.failControl(session.id, new SessionComposerControlError('composer_control_conflict', error.message));
+            }
+            restoreSessionObject(session, before);
+            this.options.applySessionState(session);
+            if (idle)
+                await this.options.rebindSessionRuntime().catch(() => undefined);
+            if (rollbackFailed) {
+                return this.failControl(session.id, new SessionComposerControlError('composer_recovery_required', 'Permission selection failed and its durable Session metadata could not be rolled back.'));
+            }
+            if (error instanceof SessionComposerControlError) {
+                return this.failControl(session.id, error);
+            }
+            return this.failControl(session.id, new SessionComposerControlError('permission_override_rejected', `Permission override was rolled back: ${error instanceof Error ? error.message : String(error)}`));
+        }
+        const currentState = this.project(session, true).permission;
+        const current = (0, session_storage_1.projectSessionComposerPreferences)(session);
+        this.lastError = undefined;
+        this.emitChanged();
+        return Object.freeze({
+            receiptId: (0, crypto_1.randomUUID)(),
+            previous: previousState,
+            current: currentState,
+            appliesFrom: idle ? 'immediate' : 'next-tool-admission',
+            sessionPreferencesDigest: (0, canonical_1.digestRuntimeValue)(current),
+        });
+    }
+    /** Apply controls queued during an active turn before the next logical request starts. */
+    async applyPendingAtLogicalBoundary() {
+        if (!this.options.runtimeIdle())
+            return;
+        const session = this.options.getSession();
+        if (!session) {
+            this.pendingModel = undefined;
+            this.emitChanged();
+            return;
+        }
+        const pendingModel = this.pendingModel?.sessionId === session.id ? this.pendingModel : undefined;
+        this.pendingModel = undefined;
+        this.emitChanged();
+        try {
+            if (pendingModel) {
+                await this.selectModel({ modelId: pendingModel.modelId, effort: pendingModel.effort });
+            }
+        }
+        catch (error) {
+            const normalized = error instanceof SessionComposerControlError
+                ? error
+                : new SessionComposerControlError('composer_recovery_required', error instanceof Error ? error.message : String(error));
+            return this.failControl(session.id, normalized);
+        }
+    }
+    project(session, active) {
+        const profile = this.resolveProfile(session.model);
+        const effort = this.resolveEffort(profile, session.effortPreference ?? 'auto');
+        const provider = this.options.config.modelRegistry?.providers.get(profile.provider);
+        const projectDefault = this.options.projectToolConfirmation();
+        const observedUsage = this.options.store.getSnapshot().contextUsage;
+        const contextUsage = active &&
+            observedUsage &&
+            (observedUsage.modelId === profile.id || observedUsage.modelId === profile.model)
+            ? observedUsage
+            : null;
+        return Object.freeze({
+            sessionId: session.id,
+            model: Object.freeze({
+                modelId: profile.id,
+                providerId: profile.provider || null,
+                providerLabel: provider?.displayName ?? profile.provider ?? null,
+                contextWindow: profile.resolvedContextWindow,
+                maxOutputTokens: profile.resolvedMaxOutputTokens,
+                effort: Object.freeze({
+                    requested: effort.requested,
+                    effective: effort.effective ?? null,
+                    source: effort.source,
+                    supported: effort.supported,
+                    supportedLevels: Object.freeze([...effort.supportedLevels]),
+                    ...(effort.warning ? { warning: effort.warning } : {}),
+                }),
+            }),
+            permission: Object.freeze({
+                effective: session.toolConfirmationOverride ?? projectDefault,
+                override: session.toolConfirmationOverride ?? null,
+                projectDefault,
+                source: session.toolConfirmationOverride === undefined ? 'project' : 'session',
+            }),
+            contextUsage,
+            pending: Object.freeze({
+                model: active && this.pendingModel?.sessionId === session.id
+                    ? Object.freeze({
+                        modelId: this.pendingModel.modelId,
+                        effort: this.pendingModel.effort,
+                    })
+                    : null,
+                permission: null,
+            }),
+            lastError: active && this.lastError?.sessionId === session.id
+                ? Object.freeze({ code: this.lastError.code, message: this.lastError.message })
+                : null,
+        });
+    }
+    resolveProfile(selector) {
+        const registry = this.options.config.modelRegistry;
+        const profile = registry
+            ? (0, model_registry_1.lookupProfile)(registry, selector)
+            : selector === this.options.config.model || selector === this.options.getSession()?.model
+                ? this.legacyProfile(selector)
+                : undefined;
+        if (!profile) {
+            throw new SessionComposerControlError('model_unavailable', `Model ${selector} is not enabled in the configured registry.`);
+        }
+        return profile;
+    }
+    legacyProfile(modelId) {
+        return (0, model_registry_1.resolveModelProfile)({
+            id: modelId,
+            model: modelId,
+            provider: 'legacy',
+            enabled: true,
+        }, {
+            id: 'legacy',
+            baseUrl: this.options.config.apiBaseUrl ?? 'https://legacy.invalid',
+            apiKey: '',
+            protocol: 'openai-completions',
+            displayName: 'Legacy provider',
+        });
+    }
+    resolveEffort(profile, requested) {
+        return (0, effort_1.resolveProfileEffort)(profile, {
+            session: requested,
+            project: (0, global_config_1.getProjectConfig)(this.options.cwd).defaultEffort,
+            global: (0, global_config_1.loadGlobalConfig)().defaultEffort ?? this.options.config.defaultEffort,
+        });
+    }
+    emitChanged() {
+        for (const listener of this.listeners)
+            listener();
+    }
+    failControl(sessionId, error) {
+        this.lastError = Object.freeze({
+            sessionId,
+            code: error.code,
+            message: error.message,
+        });
+        this.emitChanged();
+        throw error;
+    }
+    async commitCompact(request) {
+        const history = this.options.store.getSnapshot().conversationHistory;
+        const currentTokens = (0, token_estimate_1.estimateMessagesTokens)(history);
+        if (currentTokens <= request.safeInputBudget) {
+            return { status: 'not_needed', currentTokens };
+        }
+        const session = this.options.getSession() ?? this.options.ensureSession();
+        const prepareSource = (0, session_storage_1.prepareSessionCompactSourceReceipt)(session.id);
+        const result = await (0, compact_1.compactMessages)(history, {
+            maxMessages: 20,
+            contextCapsule: this.options.store.getSnapshot().harnessState?.capsule,
+            harnessState: this.options.store.getSnapshot().harnessState,
+            llm: this.options.llm ?? undefined,
+            compactMode: 'manual',
+            safeInputBudget: request.safeInputBudget,
+            targetRatio: 0.65,
+        });
+        if (result.afterTokens > request.targetTokens) {
+            return {
+                status: 'rejected',
+                error: `Compact candidate uses ${result.afterTokens} tokens; target is ${request.targetTokens}.`,
+            };
+        }
+        const afterUsage = {
+            ...(0, model_context_1.createContextUsageSnapshot)({
+                modelId: request.to.id,
+                usedTokens: result.afterTokens,
+                source: 'estimated',
+                outputReserveTokens: request.to.resolvedMaxOutputTokens,
+            }),
+            contextWindow: request.to.resolvedContextWindow,
+            safeInputBudget: request.safeInputBudget,
+            percent: Math.min(100, Math.floor((result.afterTokens / request.safeInputBudget) * 100)),
+            rawPercent: Math.min(100, Math.floor((result.afterTokens / request.to.resolvedContextWindow) * 100)),
+        };
+        const traceTurnId = 'composer:model-switch';
+        const traceDetails = {
+            model: request.to.id,
+            compactMode: 'manual',
+            compactStrategy: 'model-switch-semantic-v2',
+            compactCandidateFingerprint: result.fingerprint,
+            compactBeforeTokens: result.beforeTokens,
+            compactAfterTokens: result.afterTokens,
+            compactTargetTokens: result.plan.targetTokens,
+            compactTargetRatio: result.plan.targetRatio,
+            compactDiagnosticsCount: result.diagnostics.length,
+            compactSourceMessageCount: prepareSource.sourceMessageCount,
+        };
+        (0, session_storage_1.appendSessionTraceEvent)(session.id, {
+            turnId: traceTurnId,
+            type: 'compact_prepare',
+            ...traceDetails,
+        });
+        const checkpoint = (0, session_storage_1.commitSessionCompactCheckpoint)({
+            sessionId: session.id,
+            mode: 'manual',
+            modelId: request.to.id,
+            sourceMessageCount: prepareSource.sourceMessageCount,
+            transcriptStartMessageIndex: Math.max(0, prepareSource.sourceMessageCount - 20),
+            modelHistory: result.messages,
+            summary: {
+                text: result.summary,
+                generatedAt: result.summaryGeneratedAt,
+                source: result.summarySource,
+            },
+            beforeUsage: (0, model_context_1.createContextUsageSnapshot)({
+                modelId: request.from.id,
+                usedTokens: currentTokens,
+                source: 'estimated',
+                outputReserveTokens: request.from.resolvedMaxOutputTokens,
+            }),
+            afterUsage,
+            strategy: 'model-switch-semantic-v2',
+            harnessState: this.options.store.getSnapshot().harnessState,
+            prepareSource,
+            candidate: {
+                fingerprint: result.fingerprint,
+                beforeTokens: result.beforeTokens,
+                afterTokens: result.afterTokens,
+                plan: result.plan,
+                semanticSummary: result.semanticSummary,
+                diagnostics: result.diagnostics,
+            },
+        });
+        for (const type of [
+            'compact_validate',
+            'compact_commit',
+            'compact_boundary',
+            'compact_completed',
+        ]) {
+            (0, session_storage_1.appendSessionTraceEvent)(session.id, {
+                turnId: traceTurnId,
+                type,
+                checkpointId: checkpoint.checkpointId,
+                success: true,
+                ...traceDetails,
+            });
+        }
+        this.options.store.setState({ conversationHistory: checkpoint.modelHistory });
+        this.options.store.setContextUsage(afterUsage);
+        return {
+            status: 'committed',
+            afterTokens: checkpoint.candidateReceipt.afterTokens,
+            candidateFingerprint: checkpoint.candidateReceipt.candidateFingerprint,
+        };
+    }
+}
+exports.SessionComposerControlServiceV1 = SessionComposerControlServiceV1;
+function copySessionPreferences(target, source) {
+    target.model = source.model;
+    target.updatedAt = source.updatedAt;
+    target.updatedAtIso = source.updatedAtIso;
+    if (source.effortPreference === undefined)
+        delete target.effortPreference;
+    else
+        target.effortPreference = source.effortPreference;
+    if (source.toolConfirmationOverride === undefined)
+        delete target.toolConfirmationOverride;
+    else
+        target.toolConfirmationOverride = source.toolConfirmationOverride;
+}
+function restoreSessionObject(target, source) {
+    target.model = source.model;
+    if (source.effortPreference === undefined)
+        delete target.effortPreference;
+    else
+        target.effortPreference = source.effortPreference;
+    if (source.toolConfirmationOverride === undefined)
+        delete target.toolConfirmationOverride;
+    else
+        target.toolConfirmationOverride = source.toolConfirmationOverride;
+}
+function providerCredentialAvailable(apiKey) {
+    if (!apiKey.trim())
+        return false;
+    if (!apiKey.startsWith('$'))
+        return true;
+    return Boolean(process.env[apiKey.slice(1)]?.trim());
+}
+//# sourceMappingURL=session-composer-control.js.map

package/dist/runtime/step-snapshot.d.ts

@@ -133,6 +133,7 @@ export declare class ToolRouterSnapshotV1 {
     assertIntegrity(): void;
 }
 export interface BoundToolExecutionRequestV1 {
+    readonly invocationId: string;
     readonly snapshot: StepSnapshotV1;
     readonly toolName: string;
     readonly args: Record<string, unknown>;
@@ -140,6 +141,15 @@ export interface BoundToolExecutionRequestV1 {
     readonly enforcement: 'full' | 'partial' | 'none';
     readonly abortSignal?: AbortSignal;
 }
+export interface WorkspaceMutationCoordinatorV1 {
+    runWorkspaceMutation<T>(input: {
+        readonly workspaceId: string;
+        readonly invocationId: string;
+        readonly toolName: string;
+        readonly args: Readonly<Record<string, unknown>>;
+        readonly abortSignal?: AbortSignal;
+    }, operation: () => T | Promise<T>): Promise<T>;
+}
 export interface BoundToolExecutionResultV1 {
     readonly terminal: 'completed' | 'failed' | 'interrupted' | 'indeterminate';
     readonly result: ToolResult;
@@ -147,6 +157,8 @@ export interface BoundToolExecutionResultV1 {
 }
 /** The only runtime primitive allowed to call a frozen concrete tool executor. */
 export declare class ExecutionService {
+    private readonly workspaceMutations?;
+    constructor(workspaceMutations?: WorkspaceMutationCoordinatorV1 | undefined);
     run(request: BoundToolExecutionRequestV1): Promise<BoundToolExecutionResultV1>;
 }
 export interface StepSnapshotV1 {

package/dist/runtime/step-snapshot.js

@@ -105,6 +105,9 @@ class ToolRouterSnapshotV1 {
 exports.ToolRouterSnapshotV1 = ToolRouterSnapshotV1;
 /** The only runtime primitive allowed to call a frozen concrete tool executor. */
 class ExecutionService {
+    constructor(workspaceMutations) {
+        this.workspaceMutations = workspaceMutations;
+    }
     async run(request) {
         const startedAt = Date.now();
         request.snapshot.toolRouter.assertIntegrity();
@@ -132,7 +135,17 @@ class ExecutionService {
         const timeout = setTimeout(() => timeoutController.abort(new Error('Tool invocation timed out')), request.snapshot.executionPolicy.timeoutMs);
         timeout.unref?.();
         try {
-            const result = await request.snapshot.toolRouter.executeBound(EXECUTION_SERVICE_TOKEN, request.toolName, structuredClone(request.args), { ...request.context, abortSignal: timeoutController.signal });
+            const execute = () => request.snapshot.toolRouter.executeBound(EXECUTION_SERVICE_TOKEN, request.toolName, structuredClone(request.args), { ...request.context, abortSignal: timeoutController.signal });
+            const descriptor = request.snapshot.toolRouter.resolveDescriptor(request.toolName);
+            const result = descriptor?.risk.effect === 'workspace_write' && this.workspaceMutations
+                ? await this.workspaceMutations.runWorkspaceMutation({
+                    workspaceId: request.snapshot.authority.projectRoot,
+                    invocationId: request.invocationId,
+                    toolName: request.toolName,
+                    args: request.args,
+                    abortSignal: timeoutController.signal,
+                }, execute)
+                : await execute();
             const presented = persistLargeToolOutput(request.context.cwd, request.toolName, result);
             return {
                 terminal: timeoutController.signal.aborted

package/dist/runtime/subagent-thread-runtime.js

@@ -624,7 +624,7 @@ function replayAllEvents(store) {
     const events = [];
     let cursor = 0;
     while (true) {
-        const page = store.replay(cursor);
+        const page = store.replay(cursor, undefined, 'subagent_receipt_journal');
         events.push(...page.events);
         if (!page.hasMore)
             return events;

package/dist/runtime/thread-event-store.d.ts

@@ -14,6 +14,7 @@ export interface ThreadEventReplayV1 {
     readonly nextCursor: number;
     readonly hasMore: boolean;
 }
+export type ThreadEventReplayReasonV1 = 'direct' | 'capability_receipt_journal' | 'durable_tool_receipt' | 'legacy_materializer' | 'runtime_diagnostics_legacy' | 'subagent_receipt_journal' | 'thread_session_view' | 'turn_commit_journal' | 'ui_gap_recovery' | 'ui_initial_history';
 export interface ThreadEventCommitV1 {
     readonly events: readonly RuntimeEventEnvelopeV1[];
     readonly projection: ThreadProjectionV1;
@@ -84,11 +85,19 @@ export interface ThreadEventStoreOptionsV1 {
         readonly events: number;
     }) => void;
 }
+export interface ThreadEventStorePerformanceCountersV1 {
+    readonly logScans: number;
+    readonly bytesScanned: number;
+    readonly eventsScanned: number;
+    readonly scanReasons: Readonly<Record<string, number>>;
+}
 export declare class ThreadEventStoreError extends Error {
     readonly code: 'ORION_THREAD_EVENT_CORRUPT' | 'ORION_THREAD_EVENT_LIMIT' | 'ORION_THREAD_EVENT_CURSOR' | 'ORION_THREAD_EVENT_IDENTITY' | 'ORION_THREAD_COMPACT_INVALID' | 'ORION_THREAD_COMPACT_CONFLICT';
     readonly offset?: number | undefined;
     constructor(code: 'ORION_THREAD_EVENT_CORRUPT' | 'ORION_THREAD_EVENT_LIMIT' | 'ORION_THREAD_EVENT_CURSOR' | 'ORION_THREAD_EVENT_IDENTITY' | 'ORION_THREAD_COMPACT_INVALID' | 'ORION_THREAD_COMPACT_CONFLICT', message: string, offset?: number | undefined);
 }
+/** Process-local monotonic read counters for diagnostics and switch budgets. */
+export declare function threadEventStorePerformanceCountersV1(): ThreadEventStorePerformanceCountersV1;
 /**
  * Append-only durable fact store for a single Thread.
  *
@@ -120,7 +129,7 @@ export declare class ThreadEventStore {
     createEphemeral<T extends Extract<RuntimeEventV1, {
         type: 'item.delta';
     }>>(input: AppendRuntimeEventV1<T>): RuntimeEventEnvelopeV1<T>;
-    replay(cursor?: number, limit?: number): ThreadEventReplayV1;
+    replay(cursor?: number, limit?: number, reason?: ThreadEventReplayReasonV1): ThreadEventReplayV1;
     /**
      * Verify and seal an immutable imported prefix. The first call may scan the
      * authoritative log; later processes reuse the prefix receipt while the