@orion-agents/orion-code 0.3.2 → 0.3.7

package/dist/web/protocol.d.ts

@@ -10,6 +10,7 @@ import type { ToolConfirmationPolicy } from '../services/global-config';
 import type { WebFileContentPageV1, WebFileNodeV1, WebFileTreePageV1 } from './file-read-service';
 import type { WebGitCommitV1, WebGitDiffPageV1, WebGitFileV1, WebGitLogPageV1, WebGitStatusV1 } from './git-read-model-service';
 import type { WebReviewSnapshotV1, WebReviewVerificationV1 } from './review-service';
+import type { WebSessionRuntimeSummaryV1 } from './session-runtime-registry';
 import type { WebTerminalCreateResultV1, WebTerminalExitV1, WebTerminalGapV1, WebTerminalMetadataV1, WebTerminalOutputFrameV1, WebTerminalStateV1 } from './terminal-manager';
 export declare const WEB_API_VERSION: 1;
 export declare const WEB_NONCE_HEADER = "x-orion-web-nonce";
@@ -26,6 +27,7 @@ export type WebSettingsAppliesV1 = 'live' | 'next-logical-request' | 'new-sessio
 export type WebSettingsStateV1 = 'ready' | 'invalid' | 'read-only' | 'unavailable';
 export type WebThemePreferenceV1 = 'system' | 'light' | 'dark';
 export type WebMotionPreferenceV1 = 'system' | 'reduced';
+export type WebUiStylePreferenceV1 = 'classic' | 'orion-blocksmith';
 export type WebEffortPreferenceV1 = 'auto' | 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
 export interface WebSettingsFieldViewV1<T> {
     readonly effectiveValue: T;
@@ -45,7 +47,7 @@ export interface WebCredentialSlotViewV1 {
     readonly writable: false;
 }
 export interface WebSettingsDocumentV1 {
-    readonly schemaVersion: 1;
+    readonly schemaVersion: 2;
     readonly revision: string;
     readonly state: WebSettingsStateV1;
     readonly writable: boolean;
@@ -53,6 +55,7 @@ export interface WebSettingsDocumentV1 {
     readonly workspace: string;
     readonly sections: {
         readonly appearance: {
+            readonly style: WebSettingsFieldViewV1<WebUiStylePreferenceV1>;
             readonly theme: WebSettingsFieldViewV1<WebThemePreferenceV1>;
             readonly motion: WebSettingsFieldViewV1<WebMotionPreferenceV1>;
         };
@@ -78,8 +81,15 @@ export interface WebSettingsDocumentV1 {
 }
 /** Compatibility name retained inside the unreleased v0.3 Web implementation. */
 export type WebSettingsSnapshotV1 = WebSettingsDocumentV1;
-export type WebSettingsKeyV1 = 'appearance.theme' | 'appearance.motion' | 'defaults.model' | 'defaults.effort' | 'permissions.toolConfirmation';
+export type WebSettingsKeyV1 = 'appearance.style' | 'appearance.theme' | 'appearance.motion' | 'defaults.model' | 'defaults.effort' | 'permissions.toolConfirmation';
 export type WebSettingsOperationV1 = {
+    readonly op: 'set';
+    readonly key: 'appearance.style';
+    readonly value: WebUiStylePreferenceV1;
+} | {
+    readonly op: 'unset';
+    readonly key: 'appearance.style';
+} | {
     readonly op: 'set';
     readonly key: 'appearance.theme';
     readonly value: WebThemePreferenceV1;
@@ -117,6 +127,8 @@ export type WebSettingsOperationV1 = {
 };
 export interface WebSettingsUpdateRequestV1 {
     readonly requestId: string;
+    readonly workspaceId: string;
+    readonly expectedContextRevision: string;
     readonly expectedRevision: string;
     readonly operations: readonly WebSettingsOperationV1[];
 }
@@ -195,6 +207,7 @@ export interface WebComposerControlStateV1 {
     readonly sessionId: string;
     readonly contextRevision: string;
     readonly controlRevision: string;
+    readonly sessionRuntime: WebSessionRuntimeSummaryV1;
     readonly processing: boolean;
     readonly mode: {
         readonly baseMode: 'interactive' | 'plan' | 'auto';
@@ -229,6 +242,7 @@ interface WebComposerActionBaseV1 {
     readonly workspaceId: string;
     readonly expectedContextRevision: string;
     readonly expectedSessionId: string;
+    readonly expectedSessionRuntimeRevision: string;
     readonly expectedControlRevision: string;
 }
 export type WebComposerActionV1 = WebComposerActionBaseV1 & ({
@@ -278,6 +292,7 @@ export interface WebComposerActionResultV1 {
 export interface WebSessionSnapshotV1 {
     readonly apiVersion: 1;
     readonly session: WebSessionSummaryV1;
+    readonly sessionRuntime: WebSessionRuntimeSummaryV1;
     readonly threadId: string | null;
     readonly threadCursor: number;
     readonly eventCursor: number;
@@ -397,6 +412,8 @@ export interface WebSessionSummaryV1 {
     readonly id: string;
     readonly projectPath: string;
     readonly name?: string;
+    /** v0.3.7 — User-assigned tags (optional, sorted as stored). */
+    readonly tags?: readonly string[];
     readonly model: string;
     readonly createdAt: string;
     readonly updatedAt: string;
@@ -406,12 +423,16 @@ export interface WebSessionSummaryV1 {
     readonly activeGoalId?: string;
     readonly activeGoalObjective?: string;
 }
-export type WebCommandTypeV1 = 'submit' | 'queue_followup' | 'remove_followup' | 'clear_followups' | 'interrupt' | 'permission_decision' | 'goal_control' | 'permission_mode_change' | 'cycle_agent_mode' | 'set_agent_mode';
+export type WebCommandTypeV1 = 'submit' | 'cancel_queued_turn' | 'queue_followup' | 'remove_followup' | 'clear_followups' | 'interrupt' | 'permission_decision' | 'goal_control' | 'permission_mode_change' | 'cycle_agent_mode' | 'set_agent_mode';
 export interface WebCommandV1 {
     readonly requestId: string;
+    readonly workspaceId: string;
+    readonly expectedContextRevision: string;
     readonly expectedSessionId: string;
+    readonly expectedSessionRuntimeRevision: string;
     readonly type: WebCommandTypeV1;
     readonly text?: string;
+    readonly queueId?: string;
     readonly itemId?: string;
     readonly requestPermissionId?: string;
     readonly approved?: boolean;
@@ -425,6 +446,9 @@ export interface WebCommandV1 {
 export interface WebCommandResultV1 {
     readonly requestId: string;
     readonly result: string;
+    readonly sessionRuntime: WebSessionRuntimeSummaryV1;
+    readonly queueId?: string;
+    readonly queuePosition?: number;
     readonly detail?: string;
     readonly contextReceipt?: {
         readonly manifestDigest: string;
@@ -442,6 +466,12 @@ export interface WebSettingsMutationResultV1 {
     readonly appliedKeys: readonly WebSettingsKeyV1[];
     readonly settings: WebSettingsDocumentV1;
 }
+export type WebWorkspaceMutationPhaseV1 = 'queued' | 'running' | 'completed' | 'failed' | 'cancelled';
+export interface WebWorkspaceMutationStateV1 {
+    readonly callId: string;
+    readonly phase: WebWorkspaceMutationPhaseV1;
+    readonly queuePosition?: number;
+}
 export type WebWorkbenchEventV1 = {
     readonly type: 'runtime_event';
     readonly value: AgentRuntimeEvent;
@@ -467,6 +497,12 @@ export type WebWorkbenchEventV1 = {
 } | {
     readonly type: 'composer_state_changed';
     readonly state: WebComposerControlStateV1;
+} | {
+    readonly type: 'session_runtime_changed';
+    readonly runtime: WebSessionRuntimeSummaryV1;
+} | {
+    readonly type: 'workspace_mutation_changed';
+    readonly state: WebWorkspaceMutationStateV1;
 } | {
     readonly type: 'replay_reset';
     readonly reason: string;
@@ -527,6 +563,20 @@ export type WebEventEnvelopeV1 = WebEventEnvelopeBaseV1 & ({
     readonly payload: {
         readonly state: WebComposerControlStateV1;
     };
+} | {
+    readonly type: 'session_runtime_changed';
+    readonly sessionId: string;
+    readonly durable: true;
+    readonly payload: {
+        readonly runtime: WebSessionRuntimeSummaryV1;
+    };
+} | {
+    readonly type: 'workspace_mutation_changed';
+    readonly sessionId: string;
+    readonly durable: false;
+    readonly payload: {
+        readonly state: WebWorkspaceMutationStateV1;
+    };
 } | {
     readonly type: 'replay_reset';
     readonly durable: true;

package/dist/web/protocol.js

@@ -79,6 +79,7 @@ function parseWebComposerAction(value) {
         'workspaceId',
         'expectedContextRevision',
         'expectedSessionId',
+        'expectedSessionRuntimeRevision',
         'expectedControlRevision',
         'type',
     ];
@@ -98,12 +99,14 @@ function parseWebComposerAction(value) {
     const workspaceId = requireUuidString(row.workspaceId, 'workspaceId');
     const expectedContextRevision = requireUuidString(row.expectedContextRevision, 'expectedContextRevision');
     const expectedSessionId = requireUuidString(row.expectedSessionId, 'expectedSessionId');
+    const expectedSessionRuntimeRevision = requireUuidString(row.expectedSessionRuntimeRevision, 'expectedSessionRuntimeRevision');
     const expectedControlRevision = requireUuidString(row.expectedControlRevision, 'expectedControlRevision');
     const base = {
         requestId,
         workspaceId,
         expectedContextRevision,
         expectedSessionId,
+        expectedSessionRuntimeRevision,
         expectedControlRevision,
     };
     switch (type) {
@@ -188,13 +191,15 @@ function parseWebComposerAction(value) {
 }
 function parseWebSettingsUpdateValue(value) {
     const row = requireRecord(value, 'Settings request');
-    assertOnlyKeys(row, ['requestId', 'expectedRevision', 'operations'], 'settings');
+    assertOnlyKeys(row, ['requestId', 'workspaceId', 'expectedContextRevision', 'expectedRevision', 'operations'], 'settings');
     if (Buffer.byteLength(JSON.stringify(row), 'utf8') > SETTINGS_MAX_BODY_BYTES) {
         throw new WebProtocolError(`Settings request exceeds ${SETTINGS_MAX_BODY_BYTES} bytes`);
     }
     const requestId = requireBoundedString(row.requestId, 'requestId', 128);
     if (!UUID_PATTERN.test(requestId))
         throw new WebProtocolError('requestId must be a UUID');
+    const workspaceId = requireUuidString(row.workspaceId, 'workspaceId');
+    const expectedContextRevision = requireUuidString(row.expectedContextRevision, 'expectedContextRevision');
     const expectedRevision = requireBoundedString(row.expectedRevision, 'expectedRevision', 128);
     if (!SETTINGS_REVISION_PATTERN.test(expectedRevision)) {
         throw new WebProtocolError('expectedRevision is not a valid Settings revision');
@@ -215,6 +220,8 @@ function parseWebSettingsUpdateValue(value) {
     });
     return Object.freeze({
         requestId,
+        workspaceId,
+        expectedContextRevision,
         expectedRevision,
         operations: Object.freeze(operations),
     });
@@ -223,6 +230,7 @@ function parseSettingsOperation(value, index) {
     const row = requireRecord(value, `operations[${index}]`);
     const op = requireEnum(row.op, `operations[${index}].op`, ['set', 'unset']);
     const key = requireEnum(row.key, `operations[${index}].key`, [
+        'appearance.style',
         'appearance.theme',
         'appearance.motion',
         'defaults.model',
@@ -236,6 +244,15 @@ function parseSettingsOperation(value, index) {
         throw new WebProtocolError(`operations[${index}].value is required for set`);
     }
     switch (key) {
+        case 'appearance.style':
+            return {
+                op,
+                key,
+                value: requireEnum(row.value, `operations[${index}].value`, [
+                    'classic',
+                    'orion-blocksmith',
+                ]),
+            };
         case 'appearance.theme':
             return {
                 op,
@@ -285,9 +302,13 @@ function parseWebCommand(value) {
     const row = requireRecord(value, 'Command body');
     assertOnlyKeys(row, [
         'requestId',
+        'workspaceId',
+        'expectedContextRevision',
         'expectedSessionId',
+        'expectedSessionRuntimeRevision',
         'type',
         'text',
+        'queueId',
         'itemId',
         'requestPermissionId',
         'approved',
@@ -299,9 +320,15 @@ function parseWebCommand(value) {
         'contextReferences',
     ]);
     const requestId = requireBoundedString(row.requestId, 'requestId', 128);
-    const expectedSessionId = requireBoundedString(row.expectedSessionId, 'expectedSessionId', 256);
+    if (!UUID_PATTERN.test(requestId))
+        throw new WebProtocolError('requestId must be a UUID');
+    const workspaceId = requireUuidString(row.workspaceId, 'workspaceId');
+    const expectedContextRevision = requireUuidString(row.expectedContextRevision, 'expectedContextRevision');
+    const expectedSessionId = requireUuidString(row.expectedSessionId, 'expectedSessionId');
+    const expectedSessionRuntimeRevision = requireUuidString(row.expectedSessionRuntimeRevision, 'expectedSessionRuntimeRevision');
     const type = requireEnum(row.type, 'type', [
         'submit',
+        'cancel_queued_turn',
         'queue_followup',
         'remove_followup',
         'clear_followups',
@@ -314,11 +341,15 @@ function parseWebCommand(value) {
     ]);
     const command = {
         requestId,
+        workspaceId,
+        expectedContextRevision,
         expectedSessionId,
+        expectedSessionRuntimeRevision,
         type,
         ...(row.text === undefined
             ? {}
             : { text: requireBoundedString(row.text, 'text', exports.WEB_MAX_BODY_BYTES) }),
+        ...(row.queueId === undefined ? {} : { queueId: requireUuidString(row.queueId, 'queueId') }),
         ...(row.itemId === undefined
             ? {}
             : { itemId: requireBoundedString(row.itemId, 'itemId', 256) }),
@@ -374,6 +405,8 @@ function toAgentRuntimeInput(command) {
     switch (command.type) {
         case 'submit':
             return { type: 'submit', text: command.text, source: 'programmatic' };
+        case 'cancel_queued_turn':
+            throw new WebProtocolError('cancel_queued_turn is handled by the Web Session registry');
         case 'queue_followup':
             return { type: 'queue_followup', text: command.text, source: 'programmatic' };
         case 'remove_followup':
@@ -431,6 +464,7 @@ function projectSessionSummary(session) {
                 messageCount: session.messageCount ?? 0,
             }),
         ...(session.taskSummary ? { taskSummary: session.taskSummary } : {}),
+        ...(session.tags && session.tags.length > 0 ? { tags: Object.freeze([...session.tags]) } : {}),
         ...(session.activeGoalId ? { activeGoalId: session.activeGoalId } : {}),
         ...(session.activeGoalObjective ? { activeGoalObjective: session.activeGoalObjective } : {}),
     });
@@ -456,6 +490,9 @@ function validateCommandFields(command) {
     if ((command.type === 'submit' || command.type === 'queue_followup') && !command.text?.trim()) {
         throw new WebProtocolError(`${command.type} requires non-empty text`);
     }
+    if (command.type === 'cancel_queued_turn' && !command.queueId) {
+        throw new WebProtocolError('cancel_queued_turn requires queueId');
+    }
     if (command.type === 'remove_followup' && !command.itemId) {
         throw new WebProtocolError('remove_followup requires itemId');
     }

package/dist/web/review-service.d.ts

@@ -20,6 +20,7 @@ export interface WebReviewSnapshotV1 {
     readonly isRepository: boolean;
     readonly clean: boolean;
     readonly changedFiles: readonly WebGitFileV1[];
+    readonly totalChangedFiles: number;
     readonly stagedCount: number;
     readonly unstagedCount: number;
     readonly untrackedCount: number;

package/dist/web/review-service.js

@@ -45,6 +45,7 @@ class ReviewServiceV1 {
             isRepository: status.isRepository,
             clean: status.clean,
             changedFiles: Object.freeze(changedFiles),
+            totalChangedFiles: status.totalFiles,
             stagedCount: status.staged.length,
             unstagedCount: status.unstaged.length,
             untrackedCount: status.untracked.length,

package/dist/web/server.js

@@ -55,14 +55,28 @@ async function startOrionWebServer(options) {
             return closing;
         closing = (async () => {
             clearInterval(heartbeat);
-            await terminalSockets.close();
-            await workbench.shutdown();
-            await closeServer(server);
+            const failures = [];
+            await captureCloseFailure(failures, () => terminalSockets.close());
+            await captureCloseFailure(failures, () => workbench.shutdown());
+            await captureCloseFailure(failures, () => closeServer(server));
+            if (failures.length > 0) {
+                const error = new Error('Orion Web Host shutdown was incomplete.');
+                Object.defineProperty(error, 'failures', { value: Object.freeze([...failures]) });
+                throw error;
+            }
         })();
         return closing;
     };
     return Object.freeze({ host: HOST, port, url: origin, nonce, workbench, server, close });
 }
+async function captureCloseFailure(failures, operation) {
+    try {
+        await operation();
+    }
+    catch (error) {
+        failures.push(error);
+    }
+}
 async function handleRequest(context) {
     const { request, response } = context;
     applySecurityHeaders(response, context.nonce);
@@ -98,6 +112,13 @@ async function handleRequest(context) {
         sendJson(response, 200, collectionPage(url, `workspace-sessions-${workspaceId}`, context.workbench.listWorkspaceSessions(workspaceId, contextGuard), session => session.id));
         return;
     }
+    const archivedSessionsMatch = path.match(/^\/workspaces\/([^/]+)\/sessions\/archived$/);
+    if (method === 'GET' && archivedSessionsMatch) {
+        const workspaceId = safeDecodePathSegment(archivedSessionsMatch[1]);
+        const contextGuard = requireContextGuardQuery(url);
+        sendJson(response, 200, collectionPage(url, `workspace-sessions-archived-${workspaceId}`, context.workbench.listArchivedWorkspaceSessions(workspaceId, contextGuard), session => session.id));
+        return;
+    }
     const workspaceSummaryMatch = path.match(/^\/workspaces\/([^/]+)\/summary$/);
     if (method === 'GET' && workspaceSummaryMatch) {
         const workspaceId = requireUuid(safeDecodePathSegment(workspaceSummaryMatch[1]), 'workspaceId');
@@ -210,7 +231,12 @@ async function handleRequest(context) {
     const snapshotMatch = path.match(/^\/sessions\/([^/]+)\/snapshot$/);
     if (method === 'GET' && snapshotMatch) {
         const contextGuard = requireContextGuardQuery(url);
-        sendJson(response, 200, context.workbench.sessionSnapshot(safeDecodePathSegment(snapshotMatch[1]), url.searchParams.get('cursor') ?? undefined, pageSize(url), url.searchParams.get('tail') === '1', contextGuard));
+        sendJson(response, 200, context.workbench.sessionSnapshot(safeDecodePathSegment(snapshotMatch[1]), url.searchParams.get('cursor') ?? undefined, pageSize(url), 
+        // A recovery snapshot starts at the latest bounded transcript page and
+        // pages backward. Older clients did not send the internal `tail=1`
+        // hint, so absence must still use the indexed tail path rather than
+        // reopening and replaying the complete Thread.
+        url.searchParams.get('tail') !== '0', contextGuard));
         return;
     }
     const composerStateMatch = path.match(/^\/sessions\/([^/]+)\/composer-state$/);
@@ -251,7 +277,7 @@ async function handleRequest(context) {
         assertOnlyKeys(body, ['requestId', 'name', 'expectedContextRevision', 'workspaceId']);
         const requestId = requireUuid(body.requestId, 'requestId');
         const contextGuard = requireContextGuardRecord(body);
-        const name = typeof body.name === 'string' ? body.name : '';
+        const name = requireText(body.name, 'name', 120);
         const sessionId = safeDecodePathSegment(sessionMatch[1]);
         const result = await context.workbench.executeMutation(requestId, 'session.rename', { sessionId, name, ...contextGuard }, () => ({
             requestId,
@@ -260,6 +286,68 @@ async function handleRequest(context) {
         sendJson(response, 200, result);
         return;
     }
+    // v0.3.7 — Session tags / archive / restore / delete. One mutation family:
+    // every body carries a requestId so the idempotency ledger dedupes retries.
+    const sessionTagsMatch = path.match(/^\/sessions\/([^/]+)\/tags$/);
+    if (method === 'POST' && sessionTagsMatch) {
+        assertMutation(request, context.nonce, context.origin);
+        const body = requireRecord(await readJson(request), 'Session tags request');
+        assertOnlyKeys(body, ['requestId', 'tags', 'expectedContextRevision', 'workspaceId']);
+        const requestId = requireUuid(body.requestId, 'requestId');
+        const contextGuard = requireContextGuardRecord(body);
+        const sessionId = safeDecodePathSegment(sessionTagsMatch[1]);
+        const result = await context.workbench.executeMutation(requestId, 'session.tags', { sessionId, tags: body.tags, ...contextGuard }, () => ({
+            requestId,
+            session: context.workbench.setSessionTags(sessionId, body.tags, contextGuard),
+        }));
+        sendJson(response, 200, result);
+        return;
+    }
+    const sessionArchiveMatch = path.match(/^\/sessions\/([^/]+)\/archive$/);
+    if (method === 'POST' && sessionArchiveMatch) {
+        assertMutation(request, context.nonce, context.origin);
+        const body = requireRecord(await readJson(request), 'Session archive request');
+        assertOnlyKeys(body, ['requestId', 'expectedContextRevision', 'workspaceId']);
+        const requestId = requireUuid(body.requestId, 'requestId');
+        const contextGuard = requireContextGuardRecord(body);
+        const sessionId = safeDecodePathSegment(sessionArchiveMatch[1]);
+        const result = await context.workbench.executeMutation(requestId, 'session.archive', { sessionId, ...contextGuard }, () => ({
+            requestId,
+            session: context.workbench.archiveSession(sessionId, contextGuard),
+        }));
+        sendJson(response, 200, result);
+        return;
+    }
+    const sessionRestoreMatch = path.match(/^\/sessions\/([^/]+)\/restore$/);
+    if (method === 'POST' && sessionRestoreMatch) {
+        assertMutation(request, context.nonce, context.origin);
+        const body = requireRecord(await readJson(request), 'Session restore request');
+        assertOnlyKeys(body, ['requestId', 'expectedContextRevision', 'workspaceId']);
+        const requestId = requireUuid(body.requestId, 'requestId');
+        const contextGuard = requireContextGuardRecord(body);
+        const sessionId = safeDecodePathSegment(sessionRestoreMatch[1]);
+        const result = await context.workbench.executeMutation(requestId, 'session.restore', { sessionId, ...contextGuard }, () => ({
+            requestId,
+            session: context.workbench.restoreSession(sessionId, contextGuard),
+        }));
+        sendJson(response, 200, result);
+        return;
+    }
+    const sessionDeleteMatch = path.match(/^\/sessions\/([^/]+)$/);
+    if (method === 'DELETE' && sessionDeleteMatch) {
+        assertMutation(request, context.nonce, context.origin);
+        const body = requireRecord(await readJson(request), 'Session delete request');
+        assertOnlyKeys(body, ['requestId', 'expectedContextRevision', 'workspaceId']);
+        const requestId = requireUuid(body.requestId, 'requestId');
+        const contextGuard = requireContextGuardRecord(body);
+        const sessionId = safeDecodePathSegment(sessionDeleteMatch[1]);
+        const result = await context.workbench.executeMutation(requestId, 'session.delete', { sessionId, ...contextGuard }, () => ({
+            requestId,
+            deleted: context.workbench.deleteSession(sessionId, contextGuard).deleted,
+        }));
+        sendJson(response, 200, result);
+        return;
+    }
     if (method === 'POST' && path === '/commands') {
         assertMutation(request, context.nonce, context.origin);
         sendJson(response, 202, await context.workbench.dispatch(await readJson(request)));
@@ -272,7 +360,12 @@ async function handleRequest(context) {
     if (method === 'PATCH' && path === '/settings') {
         assertMutation(request, context.nonce, context.origin, 'settings_write_forbidden');
         const body = (0, protocol_1.parseWebSettingsUpdate)(await readJson(request));
-        const result = await context.workbench.executeMutation(body.requestId, 'settings.update', { expectedRevision: body.expectedRevision, operations: body.operations }, async () => ({ requestId: body.requestId, ...(await context.workbench.updateSettings(body)) }));
+        const result = await context.workbench.executeMutation(body.requestId, 'settings.update', {
+            workspaceId: body.workspaceId,
+            expectedContextRevision: body.expectedContextRevision,
+            expectedRevision: body.expectedRevision,
+            operations: body.operations,
+        }, async () => ({ requestId: body.requestId, ...(await context.workbench.updateSettings(body)) }));
         sendJson(response, 200, result);
         return;
     }

package/dist/web/session-runtime-registry.d.ts

@@ -0,0 +1,138 @@
+export interface WebSessionActorKeyV1 {
+    readonly workspaceId: string;
+    readonly sessionId: string;
+}
+export type WebSessionActorPhaseV1 = 'cold' | 'starting' | 'idle' | 'queued' | 'running' | 'waiting_approval' | 'stopping' | 'interrupted' | 'failed';
+export interface WebSessionRuntimeSummaryV1 extends WebSessionActorKeyV1 {
+    readonly runtimeRevision: string;
+    readonly phase: WebSessionActorPhaseV1;
+    readonly queueId?: string;
+    readonly queuePosition?: number;
+    readonly pendingApprovalCount: number;
+    readonly resident: boolean;
+    readonly estimatedBytes: number;
+    readonly updatedAt: string;
+}
+export interface WebSessionTurnStartV1<T> {
+    /** Synchronous command admission returned to the HTTP caller. */
+    readonly accepted: T;
+    /** Resolves only after the logical turn, including approval waits, is terminal. */
+    readonly settled: Promise<void>;
+}
+export type WebSessionTurnAdmissionV1<T> = {
+    readonly status: 'started';
+    readonly accepted: T;
+    readonly runtime: WebSessionRuntimeSummaryV1;
+} | {
+    readonly status: 'queued';
+    readonly queueId: string;
+    readonly queuePosition: number;
+    readonly runtime: WebSessionRuntimeSummaryV1;
+};
+export interface WebSessionRuntimeRegistryOptionsV1<TActor extends object> {
+    readonly createActor: (key: WebSessionActorKeyV1) => Promise<TActor>;
+    /**
+     * Finish actor startup only after the registry owns the returned resource.
+     * This lets the registry quarantine and retry cleanup when initialization
+     * fails instead of losing the only handle to a partially started actor.
+     */
+    readonly initializeActor?: (actor: TActor, key: WebSessionActorKeyV1) => Promise<void>;
+    readonly closeActor: (actor: TActor, reason: string) => Promise<void>;
+    readonly estimateActorBytes?: (actor: TActor) => number;
+    readonly maxRunningSessions?: number;
+    readonly maxResidentSessionActors?: number;
+    readonly now?: () => number;
+    readonly createRevision?: () => string;
+    readonly onSummaryChanged?: (summary: WebSessionRuntimeSummaryV1) => void;
+}
+/**
+ * Bounded Web-only Session actor pool.
+ *
+ * It owns concurrency admission and actor lifetime, but deliberately knows
+ * nothing about React, HTTP, OrionRuntime, or TUI semantics. Callers provide a
+ * Session-scoped actor and a logical-turn terminal promise. This keeps Web
+ * parallelism out of the single-session CLI/TUI runner.
+ */
+export declare class WebSessionRuntimeRegistryV1<TActor extends object> {
+    private readonly options;
+    private readonly records;
+    private readonly queue;
+    private readonly maxRunningSessions;
+    private readonly maxResidentSessionActors;
+    private readonly now;
+    private readonly createRevision;
+    private capacityQueue;
+    private ordinal;
+    private runningCountValue;
+    private closed;
+    private actorsCreatedCount;
+    private actorsClosedCount;
+    private actorsEvictedCount;
+    constructor(options: WebSessionRuntimeRegistryOptionsV1<TActor>);
+    get runningCount(): number;
+    get residentCount(): number;
+    /**
+     * Cumulative actor pool counters since the registry was created. E2E and
+     * diagnostics compare two reads to prove a pure Session selection allocated
+     * no Session actor (actorsCreated delta 0) and performed no capacity
+     * eviction (actorsEvicted delta 0) while the pool keeps actors alive.
+     */
+    stats(): {
+        readonly actorsCreated: number;
+        readonly actorsClosed: number;
+        readonly actorsEvicted: number;
+    };
+    summary(key: WebSessionActorKeyV1): WebSessionRuntimeSummaryV1;
+    summaries(): readonly WebSessionRuntimeSummaryV1[];
+    /**
+     * Return the current resident actor without starting a cold Session.
+     *
+     * Snapshot/read paths use this to project live state while preserving the
+     * cold-read invariant: merely selecting or inspecting a Session must not
+     * allocate a Runtime or consume a running slot.
+     */
+    residentActor(key: WebSessionActorKeyV1): {
+        readonly actor: TActor;
+        readonly runtime: WebSessionRuntimeSummaryV1;
+    } | undefined;
+    ensureResident(key: WebSessionActorKeyV1, expectedRuntimeRevision?: string): Promise<{
+        readonly actor: TActor;
+        readonly runtime: WebSessionRuntimeSummaryV1;
+    }>;
+    withActor<T>(key: WebSessionActorKeyV1, expectedRuntimeRevision: string, action: (actor: TActor) => T | Promise<T>): Promise<{
+        readonly result: T;
+        readonly runtime: WebSessionRuntimeSummaryV1;
+    }>;
+    admitTurn<T>(input: {
+        readonly key: WebSessionActorKeyV1;
+        readonly expectedRuntimeRevision: string;
+        readonly start: (actor: TActor) => Promise<WebSessionTurnStartV1<T>>;
+    }): Promise<WebSessionTurnAdmissionV1<T>>;
+    cancelQueued(key: WebSessionActorKeyV1, queueId: string, expectedRuntimeRevision: string): WebSessionRuntimeSummaryV1;
+    setPendingApprovalCount(key: WebSessionActorKeyV1, count: number): WebSessionRuntimeSummaryV1;
+    evict(key: WebSessionActorKeyV1, reason?: string): Promise<void>;
+    shutdown(reason?: string): Promise<void>;
+    private record;
+    private ensureResidentLocked;
+    private makeCapacityLocked;
+    private isEvictable;
+    private closeResidentLocked;
+    private startTurn;
+    private finishTurn;
+    private drainQueue;
+    private publishQueuePositions;
+    private snapshot;
+    private assertRevision;
+    private transition;
+    private touch;
+    private bump;
+    private publish;
+    private withCapacityLock;
+    private assertOpen;
+}
+export declare class WebSessionRuntimeRegistryError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string, message: string);
+}
+//# sourceMappingURL=session-runtime-registry.d.ts.map