@orion-agents/orion-code 0.3.1 → 0.3.4

package/dist/web/protocol.js

@@ -4,9 +4,11 @@ exports.WebProtocolError = exports.WEB_MAX_BODY_BYTES = exports.WEB_USER_GESTURE
 exports.parseWebSettingsUpdate = parseWebSettingsUpdate;
 exports.parseWebOpenSettingsDocument = parseWebOpenSettingsDocument;
 exports.parseWebContextActivate = parseWebContextActivate;
+exports.parseWebComposerAction = parseWebComposerAction;
 exports.parseWebCommand = parseWebCommand;
 exports.toAgentRuntimeInput = toAgentRuntimeInput;
 exports.projectSessionSummary = projectSessionSummary;
+const canonical_1 = require("../runtime/protocol/canonical");
 exports.WEB_API_VERSION = 1;
 exports.WEB_NONCE_HEADER = 'x-orion-web-nonce';
 exports.WEB_USER_GESTURE_HEADER = 'x-orion-user-gesture';
@@ -59,15 +61,145 @@ function parseWebContextActivate(value) {
     const sessionId = row.sessionId === null ? null : requireBoundedString(row.sessionId, 'sessionId', 256);
     return Object.freeze({ requestId, expectedContextRevision, workspaceId, sessionId });
 }
+function parseWebComposerAction(value) {
+    const row = requireRecord(value, 'Composer action request');
+    const type = requireEnum(row.type, 'type', [
+        'set_agent_mode',
+        'set_permission_override',
+        'clear_permission_override',
+        'select_model',
+        'compact_context',
+        'review_plan',
+        'edit_queue_item',
+        'move_queue_item',
+        'remove_queue_item',
+    ]);
+    const baseKeys = [
+        'requestId',
+        'workspaceId',
+        'expectedContextRevision',
+        'expectedSessionId',
+        'expectedSessionRuntimeRevision',
+        'expectedControlRevision',
+        'type',
+    ];
+    const keysByType = {
+        set_agent_mode: ['mode'],
+        set_permission_override: ['value'],
+        clear_permission_override: [],
+        select_model: ['modelId', 'effort'],
+        compact_context: [],
+        review_plan: ['planDigest', 'action', 'feedback'],
+        edit_queue_item: ['itemId', 'expectedItemRevision', 'text'],
+        move_queue_item: ['itemId', 'expectedItemRevision', 'targetIndex'],
+        remove_queue_item: ['itemId', 'expectedItemRevision'],
+    };
+    assertOnlyKeys(row, [...baseKeys, ...keysByType[type]], 'Composer action');
+    const requestId = requireUuidString(row.requestId, 'requestId');
+    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) {
+        case 'set_agent_mode':
+            return Object.freeze({
+                ...base,
+                type,
+                mode: requireEnum(row.mode, 'mode', ['interactive', 'plan', 'auto']),
+            });
+        case 'set_permission_override':
+            return Object.freeze({
+                ...base,
+                type,
+                value: requireEnum(row.value, 'value', ['ask', 'allow', 'deny']),
+            });
+        case 'clear_permission_override':
+        case 'compact_context':
+            return Object.freeze({ ...base, type });
+        case 'select_model':
+            return Object.freeze({
+                ...base,
+                type,
+                modelId: requireBoundedString(row.modelId, 'modelId', 256),
+                ...(row.effort === undefined
+                    ? {}
+                    : {
+                        effort: requireEnum(row.effort, 'effort', [
+                            'auto',
+                            'none',
+                            'minimal',
+                            'low',
+                            'medium',
+                            'high',
+                            'xhigh',
+                            'max',
+                        ]),
+                    }),
+            });
+        case 'review_plan': {
+            const action = requireEnum(row.action, 'action', ['approve', 'continue', 'cancel']);
+            const feedback = row.feedback === undefined
+                ? undefined
+                : requireBoundedString(row.feedback, 'feedback', exports.WEB_MAX_BODY_BYTES);
+            if (action === 'continue' && !feedback) {
+                throw new WebProtocolError('continue plan review requires feedback');
+            }
+            if (action !== 'continue' && feedback) {
+                throw new WebProtocolError('feedback is accepted only when continuing plan review');
+            }
+            return Object.freeze({
+                ...base,
+                type,
+                planDigest: requireBoundedString(row.planDigest, 'planDigest', 128),
+                action,
+                ...(feedback ? { feedback } : {}),
+            });
+        }
+        case 'edit_queue_item':
+            return Object.freeze({
+                ...base,
+                type,
+                itemId: requireBoundedString(row.itemId, 'itemId', 256),
+                expectedItemRevision: requirePositiveInteger(row.expectedItemRevision, 'expectedItemRevision'),
+                text: requireBoundedString(row.text, 'text', exports.WEB_MAX_BODY_BYTES),
+            });
+        case 'move_queue_item':
+            return Object.freeze({
+                ...base,
+                type,
+                itemId: requireBoundedString(row.itemId, 'itemId', 256),
+                expectedItemRevision: requirePositiveInteger(row.expectedItemRevision, 'expectedItemRevision'),
+                targetIndex: requireNonNegativeInteger(row.targetIndex, 'targetIndex'),
+            });
+        case 'remove_queue_item':
+            return Object.freeze({
+                ...base,
+                type,
+                itemId: requireBoundedString(row.itemId, 'itemId', 256),
+                expectedItemRevision: requirePositiveInteger(row.expectedItemRevision, 'expectedItemRevision'),
+            });
+    }
+}
 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');
@@ -88,6 +220,8 @@ function parseWebSettingsUpdateValue(value) {
     });
     return Object.freeze({
         requestId,
+        workspaceId,
+        expectedContextRevision,
         expectedRevision,
         operations: Object.freeze(operations),
     });
@@ -96,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',
@@ -109,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,
@@ -158,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',
@@ -169,11 +317,18 @@ function parseWebCommand(value) {
         'objective',
         'toolConfirmation',
         'agentMode',
+        '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',
@@ -186,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) }),
@@ -235,6 +394,9 @@ function parseWebCommand(value) {
                     'auto',
                 ]),
             }),
+        ...(row.contextReferences === undefined
+            ? {}
+            : { contextReferences: parseContextReferences(row.contextReferences) }),
     };
     validateCommandFields(command);
     return Object.freeze(command);
@@ -243,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':
@@ -293,6 +457,12 @@ function projectSessionSummary(session) {
         createdAt,
         updatedAt,
         messageCount: session.messageCount ?? 0,
+        contextDigest: session.threadReadModel?.projectionDigest ??
+            (0, canonical_1.digestRuntimeValue)({
+                sessionId: session.id,
+                updatedAt,
+                messageCount: session.messageCount ?? 0,
+            }),
         ...(session.taskSummary ? { taskSummary: session.taskSummary } : {}),
         ...(session.activeGoalId ? { activeGoalId: session.activeGoalId } : {}),
         ...(session.activeGoalObjective ? { activeGoalObjective: session.activeGoalObjective } : {}),
@@ -311,9 +481,17 @@ function goalControlInput(command) {
     return { type: 'goal_control', action, source: 'programmatic' };
 }
 function validateCommandFields(command) {
+    if (command.contextReferences?.length &&
+        command.type !== 'submit' &&
+        command.type !== 'queue_followup') {
+        throw new WebProtocolError('contextReferences are only valid for submit or queue_followup');
+    }
     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');
     }
@@ -335,6 +513,53 @@ function validateCommandFields(command) {
         throw new WebProtocolError('set_agent_mode requires agentMode');
     }
 }
+function parseContextReferences(value) {
+    if (!Array.isArray(value) || value.length > 20) {
+        throw new WebProtocolError('contextReferences must contain at most 20 entries');
+    }
+    const seen = new Set();
+    return Object.freeze(value.map((entry, index) => {
+        const row = requireRecord(entry, `contextReferences[${index}]`);
+        const kind = requireEnum(row.kind, `contextReferences[${index}].kind`, [
+            'file',
+            'folder',
+            'review',
+            'session',
+            'skill',
+        ]);
+        const id = requireBoundedString(row.id, `contextReferences[${index}].id`, 256);
+        if (seen.has(`${kind}:${id}`)) {
+            throw new WebProtocolError(`Duplicate Context reference: ${kind}:${id}`);
+        }
+        seen.add(`${kind}:${id}`);
+        const label = requireBoundedString(row.label, `contextReferences[${index}].label`, 200);
+        if (kind === 'file' || kind === 'folder') {
+            assertOnlyKeys(row, ['kind', 'id', 'label', 'revision'], 'Context reference');
+            return Object.freeze({
+                kind,
+                id,
+                label,
+                revision: requireBoundedString(row.revision, `contextReferences[${index}].revision`, 256),
+            });
+        }
+        if (kind === 'review') {
+            assertOnlyKeys(row, ['kind', 'id', 'label', 'gitRevision'], 'Context reference');
+            return Object.freeze({
+                kind,
+                id,
+                label,
+                gitRevision: requireBoundedString(row.gitRevision, `contextReferences[${index}].gitRevision`, 256),
+            });
+        }
+        assertOnlyKeys(row, ['kind', 'id', 'label', 'digest'], 'Context reference');
+        return Object.freeze({
+            kind,
+            id,
+            label,
+            digest: requireBoundedString(row.digest, `contextReferences[${index}].digest`, 128),
+        });
+    }));
+}
 function requireRecord(value, name) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         throw new WebProtocolError(`${name} must be an object`);
@@ -355,6 +580,24 @@ function requireBoundedString(value, name, maxLength) {
         throw new WebProtocolError(`${name} exceeds ${maxLength} bytes`);
     return value;
 }
+function requireUuidString(value, name) {
+    const result = requireBoundedString(value, name, 128);
+    if (!UUID_PATTERN.test(result))
+        throw new WebProtocolError(`${name} must be a UUID`);
+    return result;
+}
+function requireNonNegativeInteger(value, name) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new WebProtocolError(`${name} must be a non-negative safe integer`);
+    }
+    return value;
+}
+function requirePositiveInteger(value, name) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new WebProtocolError(`${name} must be a positive safe integer`);
+    }
+    return value;
+}
 function requireBoolean(value, name) {
     if (typeof value !== 'boolean')
         throw new WebProtocolError(`${name} must be a boolean`);

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);
@@ -87,19 +101,21 @@ async function handleRequest(context) {
         return;
     }
     if (method === 'GET' && path === '/workspaces') {
-        sendJson(response, 200, collectionPage(url, 'workspaces', context.workbench.listWorkspaces(), workspace => workspace.id));
+        const contextGuard = requireContextGuardQuery(url);
+        sendJson(response, 200, collectionPage(url, 'workspaces', context.workbench.listWorkspaces(contextGuard), workspace => workspace.id));
         return;
     }
     const workspaceSessionsMatch = path.match(/^\/workspaces\/([^/]+)\/sessions$/);
     if (method === 'GET' && workspaceSessionsMatch) {
         const workspaceId = safeDecodePathSegment(workspaceSessionsMatch[1]);
-        sendJson(response, 200, collectionPage(url, `workspace-sessions-${workspaceId}`, context.workbench.listWorkspaceSessions(workspaceId), session => session.id));
+        const contextGuard = requireContextGuardQuery(url);
+        sendJson(response, 200, collectionPage(url, `workspace-sessions-${workspaceId}`, context.workbench.listWorkspaceSessions(workspaceId, contextGuard), session => session.id));
         return;
     }
     const workspaceSummaryMatch = path.match(/^\/workspaces\/([^/]+)\/summary$/);
     if (method === 'GET' && workspaceSummaryMatch) {
         const workspaceId = requireUuid(safeDecodePathSegment(workspaceSummaryMatch[1]), 'workspaceId');
-        sendJson(response, 200, await context.workbench.workspaceProjectSummary(workspaceId));
+        sendJson(response, 200, await context.workbench.workspaceProjectSummary(workspaceId, requireContextGuardQuery(url)));
         return;
     }
     const workspacePinMatch = path.match(/^\/workspaces\/([^/]+)\/pin$/);
@@ -208,7 +224,43 @@ 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$/);
+    if (method === 'GET' && composerStateMatch) {
+        const contextGuard = requireContextGuardQuery(url);
+        sendJson(response, 200, context.workbench.composerState(safeDecodePathSegment(composerStateMatch[1]), contextGuard));
+        return;
+    }
+    const modelCatalogMatch = path.match(/^\/sessions\/([^/]+)\/model-catalog$/);
+    if (method === 'GET' && modelCatalogMatch) {
+        const contextGuard = requireContextGuardQuery(url);
+        const sessionId = safeDecodePathSegment(modelCatalogMatch[1]);
+        const catalog = context.workbench.modelCatalog(sessionId, contextGuard);
+        const page = (0, workbench_controller_1.pageCollectionItems)('composer_models', catalog.models, url.searchParams.get('cursor') ?? undefined, pageSize(url), model => model.id);
+        sendJson(response, 200, {
+            revision: catalog.revision,
+            unavailableProviders: catalog.unavailableProviders,
+            ...page,
+        });
+        return;
+    }
+    const composerActionMatch = path.match(/^\/sessions\/([^/]+)\/composer-actions$/);
+    if (method === 'POST' && composerActionMatch) {
+        assertMutation(request, context.nonce, context.origin);
+        const sessionId = safeDecodePathSegment(composerActionMatch[1]);
+        const body = (0, protocol_1.parseWebComposerAction)(await readJson(request));
+        if (body.expectedSessionId !== sessionId) {
+            throw new protocol_1.WebProtocolError('expectedSessionId must match the Composer action route');
+        }
+        const result = await context.workbench.executeMutation(body.requestId, 'composer.action', body, () => context.workbench.applyComposerAction(body));
+        sendJson(response, 200, result);
         return;
     }
     const sessionMatch = path.match(/^\/sessions\/([^/]+)$/);
@@ -218,7 +270,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,
@@ -239,7 +291,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;
     }
@@ -251,11 +308,13 @@ async function handleRequest(context) {
         return;
     }
     if (method === 'GET' && path === '/skills') {
-        sendJson(response, 200, collectionPage(url, 'skills', await context.workbench.skills(), skill => skill.id));
+        const contextGuard = requireContextGuardQuery(url);
+        sendJson(response, 200, collectionPage(url, 'skills', await context.workbench.skills(contextGuard), skill => skill.id));
         return;
     }
     if (method === 'GET' && path === '/mcp') {
-        sendJson(response, 200, collectionPage(url, 'mcp', context.workbench.mcp(), server => server.id));
+        const contextGuard = requireContextGuardQuery(url);
+        sendJson(response, 200, collectionPage(url, 'mcp', context.workbench.mcp(contextGuard), server => server.id));
         return;
     }
     if (method === 'GET' && path === '/files') {
@@ -388,18 +447,20 @@ async function handleRequest(context) {
         return;
     }
     if (method === 'GET' && path === '/tool-details') {
-        sendJson(response, 200, collectionPage(url, 'tool-details', await context.workbench.listToolDetails(), detail => `${detail.sequence}:${detail.callId}`));
+        const contextGuard = requireContextGuardQuery(url);
+        sendJson(response, 200, collectionPage(url, 'tool-details', await context.workbench.listToolDetails(contextGuard), detail => `${detail.sequence}:${detail.callId}`));
         return;
     }
     const toolDetailMatch = path.match(/^\/tool-details\/([^/]+)$/);
     if (method === 'GET' && toolDetailMatch) {
+        const contextGuard = requireContextGuardQuery(url);
         const offsetBytes = boundedInteger(url.searchParams.get('offsetBytes'), 0, 0, 2 ** 31 - 1);
         const limitBytes = boundedInteger(url.searchParams.get('limitBytes'), 64 * 1024, 1, 1024 * 1024);
-        sendJson(response, 200, await context.workbench.readToolDetail(safeDecodePathSegment(toolDetailMatch[1]), offsetBytes, limitBytes));
+        sendJson(response, 200, await context.workbench.readToolDetail(safeDecodePathSegment(toolDetailMatch[1]), offsetBytes, limitBytes, contextGuard));
         return;
     }
     if (method === 'GET' && path === '/diagnostics') {
-        sendJson(response, 200, await context.workbench.diagnostics());
+        sendJson(response, 200, await context.workbench.diagnostics(requireContextGuardQuery(url)));
         return;
     }
     throw new HttpProblem(404, 'Route not found.');

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

@@ -0,0 +1,124 @@
+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;
+    constructor(options: WebSessionRuntimeRegistryOptionsV1<TActor>);
+    get runningCount(): number;
+    get residentCount(): 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