@orion-agents/orion-code 0.3.0 → 0.3.2

package/dist/web/workbench-controller.js

@@ -2,30 +2,39 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebWorkbenchController = exports.WebWorkbenchError = void 0;
 exports.pageItems = pageItems;
+exports.pageCollectionItems = pageCollectionItems;
+const crypto_1 = require("crypto");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const agent_runtime_controller_1 = require("../runtime/agent-runtime-controller");
+const durable_tool_receipt_reader_1 = require("../runtime/durable-tool-receipt-reader");
 const mcp_1 = require("../runtime/mcp");
 const product_bootstrap_1 = require("../runtime/product-bootstrap");
 const canonical_1 = require("../runtime/protocol/canonical");
+const plan_review_1 = require("../runtime/plan-review");
+const thread_session_index_1 = require("../runtime/thread-session-index");
 const thread_session_view_1 = require("../runtime/thread-session-view");
 const tool_detail_repository_1 = require("../runtime/tool-detail-repository");
 const turn_commit_1 = require("../runtime/turn-commit");
+const session_composer_control_1 = require("../runtime/session-composer-control");
 const global_config_1 = require("../services/global-config");
+const redaction_1 = require("../services/redaction");
 const settings_coordinator_1 = require("../services/settings-coordinator");
 const session_storage_1 = require("../services/session-storage");
+const workspace_registry_1 = require("../services/workspace-registry");
+const errors_1 = require("./errors");
 const event_hub_1 = require("./event-hub");
+const file_read_service_1 = require("./file-read-service");
+const git_read_model_service_1 = require("./git-read-model-service");
 const protocol_1 = require("./protocol");
-class WebWorkbenchError extends Error {
-    constructor(status, message, code = status === 409 ? 'request_conflict' : 'web_workbench_error') {
-        super(message);
-        this.status = status;
-        this.code = code;
-        this.name = 'WebWorkbenchError';
-    }
-}
-exports.WebWorkbenchError = WebWorkbenchError;
+const review_service_1 = require("./review-service");
+const terminal_manager_1 = require("./terminal-manager");
+var errors_2 = require("./errors");
+Object.defineProperty(exports, "WebWorkbenchError", { enumerable: true, get: function () { return errors_2.WebWorkbenchError; } });
 const SESSION_VIEW_CACHE_BYTES = 16 * 1024 * 1024;
+const MAX_MUTATION_RESULTS = 4096;
+const MAX_CONTEXT_REFERENCE_BYTES = 64 * 1024;
+const MAX_CONTEXT_MANIFEST_BYTES = 256 * 1024;
 /** Owns the sole runtime/controller pair exposed through the local Web host. */
 class WebWorkbenchController {
     constructor(options) {
@@ -33,10 +42,29 @@ class WebWorkbenchController {
         this.sessionViews = new Map();
         this.sessionViewBytes = 0;
         this.toolDetails = new tool_detail_repository_1.FileToolDetailRepository();
+        this.contextRevisionValue = (0, crypto_1.randomUUID)();
+        this.composerRevisionValue = (0, crypto_1.randomUUID)();
+        this.suppressComposerEdges = 0;
+        this.suppressContextEdges = 0;
         this.latestStatus = 'Ready';
+        this.sessionTransition = false;
         this.closed = false;
+        this.workspaceWatchers = [];
         this.workspaceValue = canonicalDirectory(options.cwd);
         this.eventHub = options.eventHub ?? new event_hub_1.WebEventHub();
+        this.workspaceRegistry = options.workspaceRegistry ?? new workspace_registry_1.WorkspaceRegistryV1();
+        this.terminalManager = new terminal_manager_1.TerminalManagerV1({
+            resolveWorkspace: workspaceId => this.workspaceRegistry.find(workspaceId)?.canonicalPath,
+            getActiveContext: () => ({
+                workspaceId: this.activeWorkspaceEntry().id,
+                contextRevision: this.contextRevisionValue,
+            }),
+            onWorkspaceMutationHint: workspaceId => {
+                if (workspaceId === this.activeWorkspaceEntry().id) {
+                    this.scheduleWorkspaceResourceInvalidation('terminal-command');
+                }
+            },
+        });
         this.createRuntime =
             options.createRuntime ??
                 (cwd => (0, product_bootstrap_1.createProductUiRuntime)({
@@ -44,6 +72,8 @@ class WebWorkbenchController {
                     shutdownReason: 'Orion Web Workbench shutdown',
                     onActiveSessionRuntime: (runtime, sessionId, activation) => this.observeThreadRuntime(runtime, sessionId, activation),
                     onSettingsInvalidated: event => {
+                        if (this.suppressContextEdges > 0)
+                            return;
                         this.eventHub.emit({
                             type: 'settings_invalidated',
                             revision: event.revision,
@@ -55,6 +85,7 @@ class WebWorkbenchController {
     }
     static async create(options) {
         const workbench = new WebWorkbenchController(options);
+        workbench.initializeWorkspaceRegistry();
         await workbench.installRuntime(workbench.workspaceValue);
         return workbench;
     }
@@ -67,11 +98,16 @@ class WebWorkbenchController {
     get controller() {
         return this.controllerValue;
     }
+    get contextRevision() {
+        return this.contextRevisionValue;
+    }
     bootstrap(nonce) {
         return Object.freeze({
             apiVersion: protocol_1.WEB_API_VERSION,
             productVersion: this.runtimeValue.version,
             nonce,
+            contextRevision: this.contextRevisionValue,
+            workspaceId: this.activeWorkspaceEntry().id,
             workspace: this.workspaceValue,
             configured: this.runtimeValue.isConfigured,
             activeSessionId: this.runtimeValue.getSession()?.id ?? null,
@@ -82,6 +118,10 @@ class WebWorkbenchController {
                 skills: true,
                 mcp: true,
                 diagnostics: true,
+                review: true,
+                files: true,
+                git: true,
+                terminal: this.terminalManager.available,
             },
         });
     }
@@ -89,7 +129,7 @@ class WebWorkbenchController {
         this.assertSettingsAvailable();
         const describe = this.runtimeValue.describeSettings;
         if (!describe) {
-            throw new WebWorkbenchError(503, 'The product Settings coordinator is unavailable.', 'settings_document_unavailable');
+            throw new errors_1.WebWorkbenchError(503, 'The product Settings coordinator is unavailable.', 'settings_document_unavailable');
         }
         try {
             return describe();
@@ -98,86 +138,218 @@ class WebWorkbenchController {
             throw mapSettingsError(error);
         }
     }
-    listWorkspaces() {
-        const paths = new Set([this.workspaceValue]);
-        const counts = new Map();
-        for (const session of (0, session_storage_1.listSessions)()) {
+    listWorkspaces(context) {
+        if (context)
+            this.assertContextGuard(context);
+        // Session metadata is canonicalized before it enters the catalog. The
+        // summary read model deliberately avoids sorting Sessions or re-running
+        // realpath/stat for every historical entry. Availability is checked once
+        // per registered Workspace below.
+        const counts = (0, session_storage_1.countSessionsByProject)();
+        const result = Object.freeze(this.workspaceRegistry.list().map(entry => {
+            let available = false;
             try {
-                const path = canonicalDirectory(session.projectPath);
-                paths.add(path);
-                counts.set(path, (counts.get(path) ?? 0) + 1);
+                available = canonicalDirectory(entry.canonicalPath) === entry.canonicalPath;
             }
             catch {
-                // Stale projects remain in session history but are not selectable workspaces.
+                available = false;
             }
+            return Object.freeze({
+                id: entry.id,
+                path: entry.canonicalPath,
+                label: entry.label || (0, path_1.basename)(entry.canonicalPath) || entry.canonicalPath,
+                active: entry.canonicalPath === this.workspaceValue,
+                available,
+                sessionCount: counts.get(entry.canonicalPath) ?? 0,
+                lastActivatedAt: entry.lastActivatedAt,
+                ...(entry.pinnedOrder !== undefined ? { pinnedOrder: entry.pinnedOrder } : {}),
+            });
+        }));
+        if (context)
+            this.assertContextGuard(context);
+        return result;
+    }
+    listWorkspaceSessions(workspaceId, context) {
+        if (context)
+            this.assertContextGuard(context);
+        const entry = this.workspaceRegistry.find(workspaceId);
+        if (!entry) {
+            throw new errors_1.WebWorkbenchError(404, 'Workspace was not found.', 'workspace_not_found');
         }
-        return Object.freeze([...paths].sort().map(path => Object.freeze({
-            path,
-            label: (0, path_1.basename)(path) || path,
-            active: path === this.workspaceValue,
-            sessionCount: counts.get(path) ?? 0,
-        })));
+        try {
+            canonicalDirectory(entry.canonicalPath);
+        }
+        catch {
+            throw new errors_1.WebWorkbenchError(409, 'Workspace is unavailable.', 'workspace_unavailable');
+        }
+        const result = Object.freeze((0, session_storage_1.listProjectSessions)(entry.canonicalPath).map(protocol_1.projectSessionSummary));
+        if (context)
+            this.assertContextGuard(context);
+        return result;
     }
-    listSessions() {
-        return Object.freeze((0, session_storage_1.listProjectSessions)(this.workspaceValue).map(protocol_1.projectSessionSummary));
+    async workspaceProjectSummary(workspaceId, context) {
+        if (context)
+            this.assertContextGuard(context);
+        const entry = this.workspaceRegistry.find(workspaceId);
+        if (!entry) {
+            throw new errors_1.WebWorkbenchError(404, 'Workspace was not found.', 'workspace_not_found');
+        }
+        let workspace;
+        try {
+            workspace = canonicalDirectory(entry.canonicalPath);
+        }
+        catch {
+            throw new errors_1.WebWorkbenchError(409, 'Workspace is unavailable.', 'workspace_unavailable');
+        }
+        const status = await new git_read_model_service_1.GitReadModelServiceV1(workspace).status({ pageSize: 2000 });
+        const result = Object.freeze({
+            workspaceId,
+            repositoryRevision: status.repositoryRevision,
+            isRepository: status.isRepository,
+            branch: status.branch,
+            detached: status.detached,
+            head: status.head,
+            dirtyCount: status.totalFiles,
+            conflictCount: status.conflicted.length,
+        });
+        if (context)
+            this.assertContextGuard(context);
+        return result;
+    }
+    setWorkspacePinned(workspaceId, pinned, context) {
+        this.assertContextGuard(context);
+        try {
+            this.workspaceRegistry.setPinned(workspaceId, pinned);
+        }
+        catch (error) {
+            throw mapWorkspaceRegistryError(error);
+        }
+        const updated = this.listWorkspaces().find(workspace => workspace.id === workspaceId);
+        if (!updated) {
+            throw new errors_1.WebWorkbenchError(404, 'Workspace was not found.', 'workspace_not_found');
+        }
+        return updated;
+    }
+    removeWorkspace(workspaceId, context) {
+        this.assertContextGuard(context);
+        const entry = this.workspaceRegistry.find(workspaceId);
+        if (!entry) {
+            throw new errors_1.WebWorkbenchError(404, 'Workspace was not found.', 'workspace_not_found');
+        }
+        if (entry.canonicalPath === this.workspaceValue) {
+            throw new errors_1.WebWorkbenchError(409, 'The active Workspace cannot be removed.', 'workspace_active');
+        }
+        this.terminalManager.closeWorkspace(workspaceId);
+        if (!this.workspaceRegistry.remove(workspaceId)) {
+            throw new errors_1.WebWorkbenchError(404, 'Workspace was not found.', 'workspace_not_found');
+        }
+    }
+    listSessions(context) {
+        if (context)
+            this.assertContextGuard(context);
+        const result = Object.freeze((0, session_storage_1.listProjectSessions)(this.workspaceValue).map(protocol_1.projectSessionSummary));
+        if (context)
+            this.assertContextGuard(context);
+        return result;
     }
-    sessionSnapshot(sessionId, cursor, pageSize = 50, tail = false) {
+    sessionSnapshot(sessionId, cursor, pageSize = 50, tail = false, context) {
+        if (context)
+            this.assertContextGuard(context);
         const session = requireSession(sessionId);
         if (canonicalDirectory(session.projectPath) !== this.workspaceValue) {
-            throw new WebWorkbenchError(409, 'Session belongs to another workspace.');
+            throw new errors_1.WebWorkbenchError(409, 'Session belongs to another workspace.');
         }
         const active = this.runtimeValue.getSession()?.id === session.id;
         const activeProjection = this.activeOrionRuntime?.sessionId === session.id
             ? this.activeOrionRuntime.runtime.thread.getProjection()
             : undefined;
+        let indexedPage;
+        if (tail) {
+            try {
+                indexedPage = (0, thread_session_view_1.loadThreadSessionSnapshotPageV1)(this.workspaceValue, session.id, cursor, pageSize);
+            }
+            catch (error) {
+                if (error instanceof thread_session_index_1.ThreadSessionIndexError) {
+                    throw new errors_1.WebWorkbenchError(error.code === 'ORION_THREAD_SESSION_CURSOR_STALE' ? 409 : 400, error.message, error.code === 'ORION_THREAD_SESSION_CURSOR_STALE'
+                        ? 'transcript_cursor_stale'
+                        : 'page_cursor_invalid');
+                }
+                throw error;
+            }
+        }
+        if (indexedPage &&
+            activeProjection &&
+            (indexedPage.cursor !== activeProjection.cursor ||
+                indexedPage.projectionDigest !== activeProjection.digest)) {
+            if (cursor) {
+                throw new errors_1.WebWorkbenchError(409, 'Active Thread changed after this transcript cursor was issued.', 'transcript_cursor_stale');
+            }
+            // Another process may have advanced the durable Thread before the active
+            // Runtime has adopted that head. Never combine the newer page with the
+            // older in-memory cursor/digest in one snapshot.
+            indexedPage = undefined;
+        }
         let view;
-        try {
-            view = this.loadSessionView(session, activeProjection);
+        if (!indexedPage && !activeProjection) {
+            try {
+                view = this.loadSessionView(session, activeProjection);
+            }
+            catch (error) {
+                if (!activeProjection)
+                    throw error;
+                view = undefined;
+            }
         }
-        catch (error) {
-            if (!activeProjection)
-                throw error;
-            view = undefined;
-        }
-        const transcriptSource = view
-            ? view.transcriptMessages
-            : activeProjection
-                ? Object.values(activeProjection.items)
-                    .filter(item => item.kind === 'message' &&
-                    item.status !== 'started' &&
-                    ['system', 'user', 'assistant', 'tool'].includes(item.role ?? ''))
-                    .sort((left, right) => left.startedSeq - right.startedSeq)
-                    .map(item => ({
-                    role: item.role,
-                    content: item.content ?? item.summary ?? item.error ?? '',
-                    timestamp: item.terminalSeq ?? item.startedSeq,
-                }))
-                : (0, session_storage_1.readSessionMessages)(session.id).map(message => ({
-                    role: message.role,
-                    content: message.content,
-                    timestamp: message.timestamp,
-                    ...(message.toolCallId ? { toolCallId: message.toolCallId } : {}),
-                    ...(message.tool_calls ? { tool_calls: message.tool_calls } : {}),
-                    ...(message.modelVisibleContent
-                        ? { modelVisibleContent: message.modelVisibleContent }
-                        : {}),
-                    ...(message.appliedSkills ? { appliedSkills: message.appliedSkills } : {}),
-                }));
-        const tailPage = tail ? pageTranscriptTail(transcriptSource, cursor, pageSize) : undefined;
-        const transcriptPage = tailPage ?? pageItems(transcriptSource, cursor, pageSize);
-        const transcriptOffset = tailPage?.offset ?? (cursor ? decodePageCursor(cursor) : 0);
+        const transcriptSource = indexedPage
+            ? indexedPage.transcript.items
+            : view
+                ? view.transcriptMessages
+                : activeProjection
+                    ? Object.values(activeProjection.items)
+                        .filter(item => item.kind === 'message' &&
+                        item.status !== 'started' &&
+                        ['system', 'user', 'assistant', 'tool'].includes(item.role ?? ''))
+                        .sort((left, right) => left.startedSeq - right.startedSeq)
+                        .map(item => ({
+                        role: item.role,
+                        content: item.content ?? item.summary ?? item.error ?? '',
+                        timestamp: item.terminalSeq ?? item.startedSeq,
+                    }))
+                    : (0, session_storage_1.readSessionMessages)(session.id).map(message => ({
+                        role: message.role,
+                        content: message.content,
+                        timestamp: message.timestamp,
+                        ...(message.toolCallId ? { toolCallId: message.toolCallId } : {}),
+                        ...(message.tool_calls ? { tool_calls: message.tool_calls } : {}),
+                        ...(message.modelVisibleContent
+                            ? { modelVisibleContent: message.modelVisibleContent }
+                            : {}),
+                        ...(message.appliedSkills ? { appliedSkills: message.appliedSkills } : {}),
+                    }));
+        const tailPage = tail && !indexedPage ? pageTranscriptTail(transcriptSource, cursor, pageSize) : undefined;
+        const transcriptPage = indexedPage
+            ? {
+                items: indexedPage.transcript.items,
+                nextCursor: indexedPage.transcript.nextCursor,
+            }
+            : (tailPage ?? pageItems(transcriptSource, cursor, pageSize));
+        const transcriptOffset = indexedPage
+            ? indexedPage.transcript.offset
+            : (tailPage?.offset ?? (cursor ? decodePageCursor(cursor) : 0));
         const transcript = Object.freeze({
             items: Object.freeze(transcriptPage.items.map((message, index) => ({
                 ...message,
                 id: `${session.id}:message:${transcriptOffset + index + 1}`,
             }))),
-            nextCursor: transcriptPage.nextCursor,
+            nextCursor: indexedPage?.transcript.nextCursor ?? transcriptPage.nextCursor,
         });
-        const commitProjections = view
-            ? uniqueCommitProjections([view.latestPlanTurnCommit, view.latestTurnCommit])
-            : activeProjection
-                ? latestAuthorityCommits(activeProjection)
-                : [];
+        const commitProjections = indexedPage
+            ? uniqueCommitProjections([indexedPage.latestPlanTurnCommit, indexedPage.latestTurnCommit])
+            : view
+                ? uniqueCommitProjections([view.latestPlanTurnCommit, view.latestTurnCommit])
+                : activeProjection
+                    ? latestAuthorityCommits(activeProjection)
+                    : [];
         const commits = commitProjections.map(commit => (0, turn_commit_1.parseTurnCommitV1)(commit.receipt));
         const latestCommit = commits.at(-1);
         const planCommit = [...commits].reverse().find(commit => commit.planReceipt);
@@ -194,7 +366,7 @@ class WebWorkbenchController {
                 allowedScopes: ['once', 'project', 'global'],
             }))
             : [];
-        const projectionStatus = activeProjection?.status ?? (view ? 'idle' : 'legacy');
+        const projectionStatus = activeProjection?.status ?? (indexedPage || view ? 'idle' : 'legacy');
         const goal = latestCommit?.goalState && latestCommit.goalStateDigest
             ? {
                 authority: 'turn_commit',
@@ -202,14 +374,16 @@ class WebWorkbenchController {
                 state: JSON.parse(latestCommit.goalState),
             }
             : null;
-        return Object.freeze({
+        const snapshot = Object.freeze({
             apiVersion: protocol_1.WEB_API_VERSION,
             session: (0, protocol_1.projectSessionSummary)(session),
-            threadId: activeProjection?.threadId ?? view?.threadId ?? null,
-            threadCursor: activeProjection?.cursor ?? view?.cursor ?? 0,
+            threadId: activeProjection?.threadId ?? indexedPage?.threadId ?? view?.threadId ?? null,
+            threadCursor: activeProjection?.cursor ?? indexedPage?.cursor ?? view?.cursor ?? 0,
             eventCursor: this.eventHub.snapshot().latest,
-            ...(activeProjection?.digest || view?.projectionDigest
-                ? { projectionDigest: activeProjection?.digest ?? view?.projectionDigest }
+            ...(activeProjection?.digest || indexedPage?.projectionDigest || view?.projectionDigest
+                ? {
+                    projectionDigest: activeProjection?.digest ?? indexedPage?.projectionDigest ?? view?.projectionDigest,
+                }
                 : {}),
             threadStatus: projectionStatus,
             ...(activeProjection?.activeTurnId ? { activeTurnId: activeProjection.activeTurnId } : {}),
@@ -228,12 +402,206 @@ class WebWorkbenchController {
             pendingApprovals: Object.freeze(pendingPermissions),
             goal,
             plan,
-            recoveryDiagnostics: view?.diagnostics ?? [],
+            composer: this.projectComposerState(session, active),
+            recoveryDiagnostics: indexedPage ? [] : (view?.diagnostics ?? []),
+        });
+        if (context)
+            this.assertContextGuard(context);
+        return snapshot;
+    }
+    composerState(sessionId, context) {
+        if (context)
+            this.assertContextGuard(context);
+        this.assertCommandSession(sessionId);
+        const session = requireSession(sessionId);
+        const state = this.projectComposerState(session, true);
+        if (context)
+            this.assertContextGuard(context);
+        return state;
+    }
+    projectComposerState(session, active) {
+        const state = this.projectComposerStateValue(session, active);
+        if (!active)
+            return state;
+        // Durable Thread and Store authority can advance before the debounced SSE
+        // observer runs. Keep every projected control state and its CAS token in
+        // the same synchronous boundary so the UI never receives new controls
+        // paired with an older revision.
+        const authorityDigest = composerAuthorityDigest(state);
+        if (this.composerAuthorityDigest === undefined) {
+            this.composerAuthorityDigest = authorityDigest;
+            return state;
+        }
+        if (authorityDigest === this.composerAuthorityDigest)
+            return state;
+        this.bumpComposerRevision();
+        this.composerAuthorityDigest = authorityDigest;
+        return Object.freeze({ ...state, controlRevision: this.composerRevisionValue });
+    }
+    projectComposerStateValue(session, active) {
+        const controls = this.runtimeValue.sessionComposerControls;
+        if (!controls) {
+            throw new errors_1.WebWorkbenchError(503, 'Session Composer controls are unavailable.', 'composer_controls_unavailable');
+        }
+        const runtime = controls.describeSession(session);
+        const queue = active
+            ? this.controllerValue.getFollowupQueueSnapshot()
+            : { items: [], limit: 16 };
+        const projection = active && this.activeOrionRuntime?.sessionId === session.id
+            ? this.activeOrionRuntime.runtime.thread.getProjection()
+            : undefined;
+        const review = projection?.planReview;
+        const workspace = this.activeWorkspaceEntry();
+        return Object.freeze({
+            apiVersion: protocol_1.WEB_API_VERSION,
+            workspaceId: workspace.id,
+            sessionId: session.id,
+            contextRevision: this.contextRevisionValue,
+            controlRevision: this.composerRevisionValue,
+            processing: active &&
+                (this.runtimeValue.store.getSnapshot().isProcessing || Boolean(projection?.activeTurnId)),
+            mode: active
+                ? Object.freeze({ ...this.controllerValue.getAgentModeSnapshot() })
+                : Object.freeze({ baseMode: 'interactive', pendingBaseMode: null }),
+            model: runtime.model,
+            permission: runtime.permission,
+            contextUsage: runtime.contextUsage,
+            compactAvailable: active && this.controllerValue.canCompactContext(),
+            pending: runtime.pending,
+            lastError: runtime.lastError,
+            planReview: review
+                ? Object.freeze({
+                    planDigest: review.planDigest,
+                    revision: review.revision,
+                    status: review.status,
+                    createdAt: review.createdAt,
+                    createdModel: review.createdModel,
+                    returnMode: review.returnMode,
+                    ...(review.resolvedAt === undefined ? {} : { resolvedAt: review.resolvedAt }),
+                })
+                : null,
+            queue: Object.freeze({
+                items: Object.freeze(queue.items.map(item => Object.freeze({ ...item }))),
+                limit: queue.limit,
+            }),
         });
     }
-    async skills() {
+    modelCatalog(sessionId, context) {
+        if (context)
+            this.assertContextGuard(context);
+        this.assertCommandSession(sessionId);
+        const controls = this.runtimeValue.sessionComposerControls;
+        if (!controls) {
+            throw new errors_1.WebWorkbenchError(503, 'Session model catalog is unavailable.', 'composer_controls_unavailable');
+        }
+        const catalog = controls.catalog();
+        if (context)
+            this.assertContextGuard(context);
+        return catalog;
+    }
+    async applyComposerAction(input) {
+        this.assertContextGuard(input);
+        this.assertCommandSession(input.expectedSessionId);
+        const admittedState = this.composerState(input.expectedSessionId);
+        if (input.expectedControlRevision !== admittedState.controlRevision) {
+            throw new errors_1.WebWorkbenchError(409, 'Composer controls changed before the action was admitted.', 'composer_control_conflict');
+        }
+        const controls = this.runtimeValue.sessionComposerControls;
+        if (!controls) {
+            throw new errors_1.WebWorkbenchError(503, 'Session Composer controls are unavailable.', 'composer_controls_unavailable');
+        }
+        let outcome = 'applied';
+        let detail;
+        let modelReceipt;
+        let permissionReceipt;
+        let planReviewReceipt;
+        this.suppressComposerEdges += 1;
+        try {
+            switch (input.type) {
+                case 'set_agent_mode': {
+                    const result = this.controllerValue.setAgentMode(input.mode);
+                    outcome =
+                        result.type === 'agent_mode_changed' && result.appliesFrom === 'next-logical-request'
+                            ? 'deferred'
+                            : 'applied';
+                    detail = JSON.stringify(result);
+                    break;
+                }
+                case 'set_permission_override':
+                    permissionReceipt = await controls.setPermissionOverride(input.value);
+                    outcome = permissionReceipt.appliesFrom === 'immediate' ? 'applied' : 'deferred';
+                    break;
+                case 'clear_permission_override':
+                    permissionReceipt = await controls.setPermissionOverride(null);
+                    outcome = permissionReceipt.appliesFrom === 'immediate' ? 'applied' : 'deferred';
+                    break;
+                case 'select_model':
+                    modelReceipt = await controls.selectModel({
+                        modelId: input.modelId,
+                        ...(input.effort ? { effort: input.effort } : {}),
+                    });
+                    outcome = modelReceipt.appliesFrom === 'next-logical-request' ? 'deferred' : 'applied';
+                    break;
+                case 'compact_context': {
+                    const result = await this.controllerValue.compactContext();
+                    if (result.status === 'rejected') {
+                        throw new errors_1.WebWorkbenchError(409, 'Context compact was rejected.', 'runtime_busy');
+                    }
+                    detail = JSON.stringify(result);
+                    break;
+                }
+                case 'edit_queue_item':
+                    detail = JSON.stringify(this.controllerValue.editFollowupQueueItem(input.itemId, input.expectedItemRevision, input.text));
+                    break;
+                case 'move_queue_item':
+                    detail = JSON.stringify(this.controllerValue.moveFollowupQueueItem(input.itemId, input.expectedItemRevision, input.targetIndex));
+                    break;
+                case 'remove_queue_item':
+                    detail = JSON.stringify(this.controllerValue.removeFollowupQueueItem(input.itemId, input.expectedItemRevision));
+                    break;
+                case 'review_plan': {
+                    planReviewReceipt = await this.controllerValue.reviewPlan({
+                        planDigest: input.planDigest,
+                        action: input.action,
+                        ...(input.feedback ? { feedback: input.feedback } : {}),
+                    });
+                    if (input.action === 'approve')
+                        this.controllerValue.setAgentMode('interactive');
+                    else if (input.action === 'continue')
+                        this.controllerValue.setAgentMode('plan');
+                    detail = JSON.stringify(planReviewReceipt.admission);
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            throw mapComposerControlError(error);
+        }
+        finally {
+            this.suppressComposerEdges -= 1;
+        }
+        this.bumpComposerRevision();
+        const state = this.projectComposerStateValue(requireSession(input.expectedSessionId), true);
+        this.composerAuthorityDigest = composerAuthorityDigest(state);
+        this.eventHub.emit({ type: 'composer_state_changed', state }, true, {
+            sessionId: input.expectedSessionId,
+        });
+        return Object.freeze({
+            requestId: input.requestId,
+            outcome,
+            controlRevision: this.composerRevisionValue,
+            state,
+            ...(modelReceipt ? { modelReceipt } : {}),
+            ...(permissionReceipt ? { permissionReceipt } : {}),
+            ...(planReviewReceipt ? { planReviewReceipt } : {}),
+            ...(detail ? { detail } : {}),
+        });
+    }
+    async skills(context) {
+        if (context)
+            this.assertContextGuard(context);
         const descriptors = (await this.runtimeValue.inspectSkills?.()) ?? [];
-        return Object.freeze(descriptors.map(descriptor => Object.freeze({
+        const result = Object.freeze(descriptors.map(descriptor => Object.freeze({
             id: descriptor.id,
             name: descriptor.name,
             description: descriptor.description,
@@ -244,8 +612,13 @@ class WebWorkbenchController {
             requestedCapabilities: Object.freeze([...descriptor.requestedCapabilities]),
             digest: descriptor.digest,
         })));
+        if (context)
+            this.assertContextGuard(context);
+        return result;
     }
-    mcp() {
+    mcp(context) {
+        if (context)
+            this.assertContextGuard(context);
         const descriptors = this.runtimeValue.inspectMcp?.() ?? [];
         let runtimeServers = new Map();
         try {
@@ -257,7 +630,7 @@ class WebWorkbenchController {
         catch {
             // A concurrent session transition may close the previous diagnostics graph.
         }
-        return Object.freeze(descriptors.map(descriptor => {
+        const result = Object.freeze(descriptors.map(descriptor => {
             const runtime = runtimeServers.get(descriptor.id);
             return Object.freeze({
                 id: descriptor.id,
@@ -270,103 +643,228 @@ class WebWorkbenchController {
                 generation: runtime?.generation ?? 0,
                 toolCount: runtime?.toolCount ?? 0,
                 activeCallCount: runtime?.activeCallCount ?? 0,
-                ...(runtime?.failure ? { failure: runtime.failure } : {}),
+                ...(runtime?.failure
+                    ? { failure: 'Runtime transport failure. See local Host diagnostics for details.' }
+                    : {}),
             });
         }));
+        if (context)
+            this.assertContextGuard(context);
+        return result;
     }
-    async listToolDetails() {
-        return Object.freeze(await this.toolDetails.list(this.workspaceValue));
+    async listToolDetails(context) {
+        if (context)
+            this.assertContextGuard(context);
+        const result = Object.freeze(await this.toolDetails.list(this.workspaceValue));
+        if (context)
+            this.assertContextGuard(context);
+        return result;
     }
-    async readToolDetail(callId, offsetBytes, limitBytes) {
+    async readToolDetail(callId, offsetBytes, limitBytes, context) {
+        if (context)
+            this.assertContextGuard(context);
         const entry = (await this.toolDetails.list(this.workspaceValue)).find(detail => detail.callId === callId || detail.artifactId === callId);
         if (!entry?.artifactId)
-            throw new WebWorkbenchError(404, 'Tool detail was not found.');
-        return this.toolDetails.read({
+            throw new errors_1.WebWorkbenchError(404, 'Tool detail was not found.');
+        const result = await this.toolDetails.read({
             callId: entry.callId,
             sequence: entry.sequence,
             artifactId: entry.artifactId,
             outputBytes: entry.outputBytes,
         }, { offsetBytes, limitBytes }, this.workspaceValue);
+        if (context)
+            this.assertContextGuard(context);
+        return result;
+    }
+    listFiles(context, input) {
+        this.assertContextGuard(context);
+        const result = this.fileService.list(input);
+        this.assertContextGuard(context);
+        return result;
     }
-    async createSession(name) {
+    readFileContent(context, input) {
+        this.assertContextGuard(context);
+        const result = this.fileService.readContent(input);
+        this.assertContextGuard(context);
+        return result;
+    }
+    async gitStatus(context, input) {
+        this.assertContextGuard(context);
+        const result = await this.gitService.status(input);
+        this.assertContextGuard(context);
+        return result;
+    }
+    async gitLog(context, input) {
+        this.assertContextGuard(context);
+        const result = await this.gitService.log(input);
+        this.assertContextGuard(context);
+        return result;
+    }
+    async gitDiff(context, input) {
+        this.assertContextGuard(context);
+        const result = await this.gitService.diff(input);
+        this.assertContextGuard(context);
+        return result;
+    }
+    async review(context) {
+        this.assertContextGuard(context);
+        try {
+            const result = await this.reviewService.snapshot();
+            this.assertContextGuard(context);
+            return result;
+        }
+        catch (error) {
+            if (error instanceof durable_tool_receipt_reader_1.DurableToolReceiptReaderError) {
+                throw new errors_1.WebWorkbenchError(500, 'Durable Review receipt facts failed integrity validation.', 'review_receipt_invalid');
+            }
+            throw error;
+        }
+    }
+    listTerminals(context) {
+        this.assertContextGuard(context);
+        const result = this.terminalManager.list(this.activeWorkspaceEntry().id);
+        this.assertContextGuard(context);
+        return result;
+    }
+    async createSession(name, context) {
         this.assertReadyForTransition('create a session');
-        // A new Session inherits the durable default; an override on the currently
-        // active Session must never leak into the next Session.
-        const session = (0, session_storage_1.createSession)(this.workspaceValue, this.settings().sections.defaults.model.effectiveValue);
-        (0, global_config_1.incrementSessionCount)();
-        const named = name?.trim() ? ((0, session_storage_1.renameSession)(session.id, name.trim()) ?? session) : session;
-        this.runtimeValue.setSession(named);
-        await this.runtimeValue.rebindSessionRuntime?.();
-        this.eventHub.emitRuntime({ type: 'transcript_clear' });
-        this.emitState();
-        return (0, protocol_1.projectSessionSummary)(named);
-    }
-    async activateSession(sessionId) {
+        if (context)
+            this.assertContextGuard(context);
+        this.sessionTransition = true;
+        try {
+            // A new Session inherits the durable default; an override on the currently
+            // active Session must never leak into the next Session.
+            const session = (0, session_storage_1.createSession)(this.workspaceValue, this.settings().sections.defaults.model.effectiveValue);
+            (0, global_config_1.incrementSessionCount)();
+            const named = name?.trim() ? ((0, session_storage_1.renameSession)(session.id, name.trim()) ?? session) : session;
+            this.runtimeValue.setSession(named);
+            await this.runtimeValue.rebindSessionRuntime?.();
+            this.eventHub.emitRuntime({ type: 'transcript_clear' });
+            this.emitState();
+            return (0, protocol_1.projectSessionSummary)(named);
+        }
+        finally {
+            this.sessionTransition = false;
+        }
+    }
+    async activateSession(sessionId, context) {
         this.assertReadyForTransition('switch sessions');
-        const session = requireSession(sessionId);
-        if (canonicalDirectory(session.projectPath) !== this.workspaceValue) {
-            throw new WebWorkbenchError(409, 'Session belongs to another workspace.');
+        if (context)
+            this.assertContextGuard(context);
+        this.sessionTransition = true;
+        this.suppressContextEdges += 1;
+        let activated = false;
+        try {
+            const session = requireSession(sessionId);
+            if (canonicalDirectory(session.projectPath) !== this.workspaceValue) {
+                throw new errors_1.WebWorkbenchError(409, 'Session belongs to another workspace.');
+            }
+            const result = this.controllerValue.handle({
+                type: 'select_session',
+                sessionId: session.id,
+                source: 'programmatic',
+            });
+            await this.controllerValue.waitForIdle();
+            if (this.runtimeValue.getSession()?.id !== session.id) {
+                throw new errors_1.WebWorkbenchError(409, 'Session activation was rejected by the runtime.');
+            }
+            activated = true;
+            return { requestId: `activate:${session.id}`, result: result.type };
         }
-        const result = this.controllerValue.handle({
-            type: 'select_session',
-            sessionId: session.id,
-            source: 'programmatic',
-        });
-        await this.controllerValue.waitForIdle();
-        if (this.runtimeValue.getSession()?.id !== session.id) {
-            throw new WebWorkbenchError(409, 'Session activation was rejected by the runtime.');
+        finally {
+            this.suppressContextEdges -= 1;
+            this.sessionTransition = false;
+            if (activated)
+                this.emitState();
         }
-        return { requestId: `activate:${session.id}`, result: result.type };
     }
-    renameSession(sessionId, name) {
+    renameSession(sessionId, name, context) {
+        if (context)
+            this.assertContextGuard(context);
         const session = requireSession(sessionId);
         if (canonicalDirectory(session.projectPath) !== this.workspaceValue) {
-            throw new WebWorkbenchError(409, 'Session belongs to another workspace.');
+            throw new errors_1.WebWorkbenchError(409, 'Session belongs to another workspace.');
         }
         if (name.length > 120)
-            throw new WebWorkbenchError(400, 'Session name is too long.');
+            throw new errors_1.WebWorkbenchError(400, 'Session name is too long.');
         const updated = (0, session_storage_1.renameSession)(session.id, name);
         if (!updated)
-            throw new WebWorkbenchError(404, 'Session no longer exists.');
+            throw new errors_1.WebWorkbenchError(404, 'Session no longer exists.');
         return (0, protocol_1.projectSessionSummary)(updated);
     }
-    async switchWorkspace(path) {
-        if (this.transition)
-            throw new WebWorkbenchError(409, 'A workspace transition is running.');
+    async switchWorkspace(path, context) {
+        this.assertContextGuard(context);
         const next = canonicalDirectory(path);
         if (next === this.workspaceValue)
             return;
-        this.assertReadyForTransition('switch workspaces');
+        let entry;
+        try {
+            entry = this.workspaceRegistry.register(next);
+        }
+        catch (error) {
+            throw mapWorkspaceRegistryError(error);
+        }
+        await this.activateContext({
+            expectedContextRevision: context.expectedContextRevision,
+            workspaceId: entry.id,
+            sessionId: null,
+        });
+    }
+    async activateContext(input) {
+        if (input.expectedContextRevision !== this.contextRevisionValue) {
+            throw new errors_1.WebWorkbenchError(409, 'The active Context changed before activation was admitted.', 'context_revision_conflict');
+        }
+        const entry = this.workspaceRegistry.find(input.workspaceId);
+        if (!entry)
+            throw new errors_1.WebWorkbenchError(404, 'Workspace was not found.', 'workspace_not_found');
+        const targetWorkspace = canonicalDirectory(entry.canonicalPath);
+        const targetSession = input.sessionId ? requireSession(input.sessionId) : null;
+        if (targetSession && canonicalDirectory(targetSession.projectPath) !== targetWorkspace) {
+            throw new errors_1.WebWorkbenchError(409, 'Session does not belong to the requested Workspace.', 'context_session_mismatch');
+        }
+        const currentSessionId = this.runtimeValue.getSession()?.id ?? null;
+        if (targetWorkspace === this.workspaceValue && targetSession?.id === currentSessionId)
+            return;
+        if (targetWorkspace === this.workspaceValue && !targetSession && currentSessionId === null)
+            return;
+        this.assertReadyForTransition('activate a Context');
+        const previousWorkspace = this.workspaceValue;
+        const previousSessionId = currentSessionId;
         const previousRuntime = this.runtimeValue;
         const previousController = this.controllerValue;
-        const previousWorkspace = this.workspaceValue;
         const transition = (async () => {
-            await previousController.stopActiveTurn();
-            await previousController.waitForIdle();
-            await previousRuntime.shutdown();
+            this.suppressContextEdges += 1;
             try {
-                await this.installRuntime(next);
+                await previousController.stopActiveTurn();
+                await previousController.waitForIdle();
+                if (targetWorkspace !== previousWorkspace) {
+                    await previousRuntime.shutdown();
+                    await this.installRuntime(targetWorkspace, false);
+                }
+                await this.restoreContextSession(targetSession?.id ?? null);
+                this.workspaceRegistry.register(targetWorkspace, { activated: true });
             }
-            catch (error) {
+            catch (activationError) {
                 try {
-                    await this.installRuntime(previousWorkspace);
+                    if (targetWorkspace !== previousWorkspace) {
+                        if (this.runtimeValue !== previousRuntime)
+                            await this.runtimeValue.shutdown();
+                        await this.installRuntime(previousWorkspace, false);
+                    }
+                    await this.restoreContextSession(previousSessionId);
                 }
                 catch {
-                    throw new WebWorkbenchError(503, 'Workspace activation failed and the previous workspace could not be restored.');
+                    throw new errors_1.WebWorkbenchError(503, 'Context activation failed and the previous Context could not be restored.', 'context_recovery_required');
                 }
-                throw error;
+                throw activationError;
             }
-            const describe = this.runtimeValue.describeSettings;
-            if (!describe) {
-                throw new WebWorkbenchError(503, 'The product Settings coordinator is unavailable.', 'settings_document_unavailable');
-            }
-            const settings = describe();
-            this.eventHub.emit({
-                type: 'settings_invalidated',
-                revision: settings.revision,
-                reason: 'workspace-change',
-                state: settings.state === 'ready' || settings.state === 'read-only' ? 'ready' : 'invalid',
-            }, false);
+            finally {
+                this.suppressContextEdges -= 1;
+            }
+            this.emitState();
+            this.emitWorkspaceResourceInvalidation('context-change');
+            if (targetWorkspace !== previousWorkspace)
+                this.emitSettingsWorkspaceChange();
         })().finally(() => {
             if (this.transition === transition)
                 this.transition = undefined;
@@ -376,20 +874,184 @@ class WebWorkbenchController {
     }
     dispatch(raw) {
         const command = (0, protocol_1.parseWebCommand)(raw);
-        return this.executeMutation(command.requestId, 'command', command, () => {
-            const runtimeResult = this.controllerValue.handle((0, protocol_1.toAgentRuntimeInput)(command));
+        return this.executeMutation(command.requestId, 'command', command, async () => {
+            this.assertCommandSession(command.expectedSessionId);
+            const resolved = await this.resolveCommandContext(command);
+            this.assertCommandSession(command.expectedSessionId);
+            const runtimeInput = resolved && command.type === 'queue_followup'
+                ? {
+                    type: 'queue_followup',
+                    text: command.text,
+                    resolvedText: resolved.text,
+                    source: 'programmatic',
+                }
+                : (0, protocol_1.toAgentRuntimeInput)({ ...command, ...(resolved ? { text: resolved.text } : {}) });
+            const runtimeResult = this.controllerValue.handle(runtimeInput);
             return Object.freeze({
                 requestId: command.requestId,
                 result: runtimeResult.type,
                 detail: JSON.stringify(runtimeResult),
+                ...(resolved ? { contextReceipt: resolved.receipt } : {}),
             });
         });
     }
+    async resolveCommandContext(command) {
+        const references = command.contextReferences ?? [];
+        if (references.length === 0)
+            return undefined;
+        if (command.type !== 'submit' && command.type !== 'queue_followup') {
+            throw new errors_1.WebWorkbenchError(400, 'Context references are valid only for submitted or queued messages.', 'context_reference_invalid');
+        }
+        const resolved = [];
+        let totalBytes = 0;
+        for (const reference of references) {
+            let entry;
+            try {
+                entry = await this.resolveContextReference(reference);
+            }
+            catch (error) {
+                throw mapContextReferenceError(error);
+            }
+            const bytes = Buffer.byteLength(JSON.stringify(entry), 'utf8');
+            if (bytes > MAX_CONTEXT_REFERENCE_BYTES) {
+                throw new errors_1.WebWorkbenchError(413, 'A Context reference exceeds the per-reference byte budget.', 'context_reference_too_large');
+            }
+            totalBytes += bytes;
+            if (totalBytes > MAX_CONTEXT_MANIFEST_BYTES) {
+                throw new errors_1.WebWorkbenchError(413, 'Context references exceed the request byte budget.', 'context_reference_too_large');
+            }
+            resolved.push(Object.freeze(entry));
+        }
+        const manifestContent = Object.freeze({
+            version: 1,
+            references: Object.freeze(resolved),
+        });
+        const manifestDigest = (0, canonical_1.digestRuntimeValue)(manifestContent);
+        const manifest = Object.freeze({ ...manifestContent, manifestDigest });
+        return Object.freeze({
+            text: [
+                command.text.trim(),
+                '',
+                '[Orion Context Manifest V1]',
+                JSON.stringify(manifest),
+            ].join('\n'),
+            receipt: Object.freeze({
+                manifestDigest,
+                referenceCount: resolved.length,
+                totalBytes,
+            }),
+        });
+    }
+    async resolveContextReference(reference) {
+        switch (reference.kind) {
+            case 'file': {
+                const page = this.fileService.readContent({
+                    fileId: reference.id,
+                    limitBytes: MAX_CONTEXT_REFERENCE_BYTES,
+                });
+                if (page.revision !== reference.revision) {
+                    throw new errors_1.WebWorkbenchError(409, 'Referenced file changed.', 'context_reference_stale');
+                }
+                if (page.binary || page.content === undefined) {
+                    throw new errors_1.WebWorkbenchError(403, 'Binary files cannot be added to model Context.', 'context_reference_forbidden');
+                }
+                return {
+                    kind: 'file',
+                    id: reference.id,
+                    label: this.sanitizeContextText(page.name),
+                    revision: page.revision,
+                    content: this.sanitizeContextText(page.content),
+                    truncated: page.nextCursor !== null,
+                };
+            }
+            case 'folder': {
+                const page = this.fileService.list({ parentId: reference.id, pageSize: 100 });
+                if (page.revision !== reference.revision) {
+                    throw new errors_1.WebWorkbenchError(409, 'Referenced folder changed.', 'context_reference_stale');
+                }
+                return {
+                    kind: 'folder',
+                    id: reference.id,
+                    label: this.sanitizeContextText(reference.label),
+                    revision: page.revision,
+                    entries: page.items
+                        .filter(item => !item.sensitive)
+                        .map(item => ({
+                        name: this.sanitizeContextText(item.name),
+                        kind: item.kind,
+                        sizeBytes: item.sizeBytes ?? null,
+                    })),
+                    truncated: page.nextCursor !== null,
+                };
+            }
+            case 'review': {
+                const snapshot = await this.reviewService.snapshot();
+                if (snapshot.repositoryRevision !== reference.gitRevision) {
+                    throw new errors_1.WebWorkbenchError(409, 'Referenced Review changed.', 'context_reference_stale');
+                }
+                return {
+                    kind: 'review',
+                    id: reference.id,
+                    revision: snapshot.repositoryRevision,
+                    clean: snapshot.clean,
+                    files: snapshot.changedFiles.slice(0, 100).map(file => ({
+                        id: file.fileId,
+                        path: this.sanitizeContextText(file.path),
+                        indexStatus: file.indexStatus,
+                        worktreeStatus: file.worktreeStatus,
+                    })),
+                    truncated: snapshot.truncated || snapshot.changedFiles.length > 100,
+                };
+            }
+            case 'session': {
+                const session = requireSession(reference.id);
+                if (canonicalDirectory(session.projectPath) !== this.workspaceValue) {
+                    throw new errors_1.WebWorkbenchError(403, 'Referenced Session belongs to another Workspace.', 'context_reference_forbidden');
+                }
+                const summary = (0, protocol_1.projectSessionSummary)(session);
+                if (summary.contextDigest !== reference.digest) {
+                    throw new errors_1.WebWorkbenchError(409, 'Referenced Session changed.', 'context_reference_stale');
+                }
+                const page = (0, thread_session_view_1.loadThreadSessionSnapshotPageV1)(this.workspaceValue, session.id, undefined, 8);
+                return {
+                    kind: 'session',
+                    id: session.id,
+                    label: this.sanitizeContextText(session.name?.trim() || `Session ${session.id.slice(0, 8)}`),
+                    digest: summary.contextDigest,
+                    messages: (page?.transcript.items ?? []).map(message => ({
+                        role: message.role,
+                        content: this.sanitizeContextText(message.content),
+                    })),
+                    truncated: Boolean(page?.transcript.nextCursor),
+                };
+            }
+            case 'skill': {
+                const descriptor = ((await this.runtimeValue.inspectSkills?.()) ?? []).find(skill => skill.id === reference.id);
+                if (!descriptor || descriptor.digest !== reference.digest) {
+                    throw new errors_1.WebWorkbenchError(409, 'Referenced Skill changed.', 'context_reference_stale');
+                }
+                if (!descriptor.userInvocable) {
+                    throw new errors_1.WebWorkbenchError(403, 'Referenced Skill is not user-invocable.', 'context_reference_forbidden');
+                }
+                return {
+                    kind: 'skill',
+                    id: descriptor.id,
+                    label: this.sanitizeContextText(descriptor.name),
+                    digest: descriptor.digest,
+                    invocation: `$${descriptor.id}`,
+                    description: this.sanitizeContextText(descriptor.description),
+                };
+            }
+        }
+    }
+    sanitizeContextText(value) {
+        return (0, redaction_1.redactTraceText)(value).split(this.workspaceValue).join('<workspace>');
+    }
     async updateSettings(input) {
         this.assertSettingsAvailable();
         const update = this.runtimeValue.updateSettings;
         if (!update) {
-            throw new WebWorkbenchError(503, 'The product Settings coordinator is unavailable.', 'settings_document_unavailable');
+            throw new errors_1.WebWorkbenchError(503, 'The product Settings coordinator is unavailable.', 'settings_document_unavailable');
         }
         try {
             const result = await update({
@@ -411,7 +1073,7 @@ class WebWorkbenchController {
         this.assertSettingsAvailable();
         const coordinator = this.runtimeValue.settingsCoordinator;
         if (!coordinator) {
-            throw new WebWorkbenchError(503, 'The product Settings coordinator is unavailable.', 'settings_document_unavailable');
+            throw new errors_1.WebWorkbenchError(503, 'The product Settings coordinator is unavailable.', 'settings_document_unavailable');
         }
         try {
             await coordinator.openDocument();
@@ -423,27 +1085,29 @@ class WebWorkbenchController {
     }
     executeMutation(requestId, operation, payload, action) {
         if (!requestId.trim() || requestId.length > 128) {
-            throw new WebWorkbenchError(400, 'requestId must be a non-empty string up to 128 characters.');
+            throw new errors_1.WebWorkbenchError(400, 'requestId must be a non-empty string up to 128 characters.');
         }
         const fingerprint = (0, canonical_1.digestRuntimeValue)({ operation, payload });
         const cached = this.mutationResults.get(requestId);
         if (cached) {
             if (cached.fingerprint !== fingerprint) {
-                throw new WebWorkbenchError(409, 'requestId was already used for another mutation.', 'request_id_conflict');
+                throw new errors_1.WebWorkbenchError(409, 'requestId was already used for another mutation.', 'request_id_conflict');
             }
             return cached.result;
         }
-        const result = Promise.resolve().then(action);
-        this.mutationResults.set(requestId, { fingerprint, result });
-        while (this.mutationResults.size > 512) {
-            const oldest = this.mutationResults.keys().next().value;
-            if (!oldest)
-                break;
-            this.mutationResults.delete(oldest);
+        if (this.mutationResults.size >= MAX_MUTATION_RESULTS) {
+            throw new errors_1.WebWorkbenchError(503, 'The mutation idempotency ledger is full; restart the local Web Host before retrying.', 'mutation_capacity_exhausted');
         }
+        const result = Promise.resolve().then(() => {
+            this.assertMutationAdmission();
+            return action();
+        });
+        this.mutationResults.set(requestId, { fingerprint, result });
         return result;
     }
-    async diagnostics() {
+    async diagnostics(context) {
+        if (context)
+            this.assertContextGuard(context);
         const state = this.runtimeValue.store.getSnapshot();
         const mcp = (0, mcp_1.loadFirstPartyMcpConfigurationV1)();
         const activeSessionId = this.runtimeValue.getSession()?.id ?? null;
@@ -452,7 +1116,7 @@ class WebWorkbenchController {
         const harness = activeSessionId
             ? ((await this.runtimeValue.getHarnessDiagnostics?.()) ?? null)
             : null;
-        return {
+        const result = {
             workspace: this.workspaceValue,
             activeSessionId,
             configured: this.runtimeValue.isConfigured,
@@ -470,7 +1134,14 @@ class WebWorkbenchController {
             mcp: { servers: mcpServerIds(mcp) },
             harness,
             eventStream: this.eventHub.snapshot(),
+            performance: {
+                files: this.fileService.performanceCounters(),
+                git: this.gitService.performanceCounters(),
+            },
         };
+        if (context)
+            this.assertContextGuard(context);
+        return result;
     }
     async shutdown() {
         if (this.closed)
@@ -478,22 +1149,47 @@ class WebWorkbenchController {
         this.closed = true;
         await this.controllerValue.stopActiveTurn();
         await this.controllerValue.waitForIdle();
+        this.closeWorkspaceWatchers();
+        this.closeComposerObserver();
+        await this.terminalManager.shutdown();
         await this.runtimeValue.shutdown();
         this.eventHub.close();
     }
-    async installRuntime(workspace) {
+    async installRuntime(workspace, publishState = true) {
+        this.closeComposerObserver();
         const runtime = await this.createRuntime(workspace);
+        this.closeWorkspaceWatchers();
         this.activeOrionRuntime = undefined;
         this.sessionViews.clear();
         this.sessionViewBytes = 0;
         this.latestStatus = 'Ready';
         this.workspaceValue = workspace;
         this.runtimeValue = runtime;
+        this.fileService = new file_read_service_1.FileReadServiceV1(workspace);
+        this.gitService = new git_read_model_service_1.GitReadModelServiceV1(workspace);
+        this.reviewService = new review_service_1.ReviewServiceV1(this.gitService, () => (0, durable_tool_receipt_reader_1.listProjectDurableToolReceiptRefsV1)(this.workspaceValue));
         const eventSink = {
             emit: (event) => {
                 if (event.type === 'status_changed')
                     this.latestStatus = event.message;
+                if (this.suppressContextEdges > 0)
+                    return undefined;
                 const activeSessionId = this.runtimeValue.getSession()?.id;
+                if (event.type === 'followup_queue_changed') {
+                    // The queue is part of the Composer CAS authority. Publishing the
+                    // Runtime queue event on its own lets the browser observe new items
+                    // with an older controlRevision and guarantees a 409 on its next
+                    // edit/move/remove action. Project one complete Composer state in
+                    // this same synchronous boundary instead. Composer actions suppress
+                    // their intermediate queue edge and publish their final state below.
+                    if (activeSessionId && this.suppressComposerEdges === 0) {
+                        const state = this.composerState(activeSessionId);
+                        this.eventHub.emit({ type: 'composer_state_changed', state }, true, {
+                            sessionId: activeSessionId,
+                        });
+                    }
+                    return undefined;
+                }
                 const activeThread = activeSessionId && this.activeOrionRuntime?.sessionId === activeSessionId
                     ? this.activeOrionRuntime.runtime.thread.getProjection().threadId
                     : undefined;
@@ -503,6 +1199,9 @@ class WebWorkbenchController {
                 });
                 if (event.type === 'session_restored')
                     this.emitState();
+                if (event.type === 'tool_finished') {
+                    this.scheduleWorkspaceResourceInvalidation('tool-finished');
+                }
                 return event.type === 'transcript_append' ? `web-entry-${envelope.cursor}` : undefined;
             },
         };
@@ -522,14 +1221,157 @@ class WebWorkbenchController {
                 suppressAbortNotice: true,
             },
         });
-        this.emitState();
+        this.composerRevisionValue = (0, crypto_1.randomUUID)();
+        this.composerAuthorityDigest = undefined;
+        this.composerStoreUnsubscribe = runtime.store.subscribe(() => this.scheduleComposerStateChanged());
+        this.composerControlsUnsubscribe = runtime.sessionComposerControls?.subscribe(() => this.scheduleComposerStateChanged());
+        this.installWorkspaceWatchers();
+        if (publishState)
+            this.emitState(false);
     }
-    emitState() {
+    emitState(advanceRevision = true) {
+        if (this.suppressContextEdges > 0)
+            return;
+        if (advanceRevision)
+            this.contextRevisionValue = (0, crypto_1.randomUUID)();
+        if (advanceRevision)
+            this.composerRevisionValue = (0, crypto_1.randomUUID)();
+        const workspace = this.activeWorkspaceEntry();
+        const sessionId = this.runtimeValue.getSession()?.id ?? null;
+        if (sessionId) {
+            try {
+                this.composerAuthorityDigest = composerAuthorityDigest(this.projectComposerStateValue(requireSession(sessionId), true));
+            }
+            catch {
+                this.composerAuthorityDigest = undefined;
+            }
+        }
+        else {
+            this.composerAuthorityDigest = undefined;
+        }
         this.eventHub.emit({
             type: 'workbench_state',
+            contextRevision: this.contextRevisionValue,
+            workspaceId: workspace.id,
             workspace: this.workspaceValue,
-            activeSessionId: this.runtimeValue.getSession()?.id ?? null,
+            activeSessionId: sessionId,
+        });
+    }
+    emitWorkspaceResourceInvalidation(reason) {
+        if (this.closed || this.suppressContextEdges > 0)
+            return;
+        this.eventHub.emit({
+            type: 'workspace_resource_invalidated',
+            workspaceId: this.activeWorkspaceEntry().id,
+            resources: ['files', 'git', 'review'],
+            reason,
+        }, false);
+    }
+    scheduleWorkspaceResourceInvalidation(reason) {
+        if (this.closed)
+            return;
+        if (this.resourceInvalidationTimer)
+            clearTimeout(this.resourceInvalidationTimer);
+        const workspace = this.workspaceValue;
+        this.resourceInvalidationTimer = setTimeout(() => {
+            this.resourceInvalidationTimer = undefined;
+            if (!this.closed && this.workspaceValue === workspace) {
+                this.emitWorkspaceResourceInvalidation(reason);
+            }
+        }, 120);
+        this.resourceInvalidationTimer.unref();
+    }
+    bumpComposerRevision() {
+        this.composerRevisionValue = (0, crypto_1.randomUUID)();
+    }
+    scheduleComposerStateChanged() {
+        if (this.closed ||
+            this.suppressComposerEdges > 0 ||
+            this.suppressContextEdges > 0 ||
+            !this.runtimeValue.getSession()) {
+            return;
+        }
+        if (this.composerChangeTimer)
+            clearTimeout(this.composerChangeTimer);
+        this.composerChangeTimer = setTimeout(() => {
+            this.composerChangeTimer = undefined;
+            const sessionId = this.runtimeValue.getSession()?.id;
+            if (!sessionId || this.closed || this.suppressComposerEdges > 0)
+                return;
+            try {
+                const state = this.composerState(sessionId);
+                this.eventHub.emit({ type: 'composer_state_changed', state }, true, { sessionId });
+            }
+            catch {
+                // A concurrent Context transition publishes a fresh baseline instead.
+            }
+        }, 100);
+        this.composerChangeTimer.unref();
+    }
+    closeComposerObserver() {
+        this.composerStoreUnsubscribe?.();
+        this.composerStoreUnsubscribe = undefined;
+        this.composerControlsUnsubscribe?.();
+        this.composerControlsUnsubscribe = undefined;
+        if (this.composerChangeTimer)
+            clearTimeout(this.composerChangeTimer);
+        this.composerChangeTimer = undefined;
+    }
+    installWorkspaceWatchers() {
+        const watchPaths = [this.workspaceValue, (0, path_1.resolve)(this.workspaceValue, '.git')].filter(path => (0, fs_1.existsSync)(path));
+        for (const path of watchPaths) {
+            try {
+                const watcher = (0, fs_1.watch)(path, { persistent: false }, () => this.scheduleWorkspaceResourceInvalidation('filesystem-change'));
+                watcher.on('error', () => {
+                    watcher.close();
+                    this.workspaceWatchers = this.workspaceWatchers.filter(item => item !== watcher);
+                });
+                this.workspaceWatchers.push(watcher);
+            }
+            catch {
+                // Watchers are only refresh hints. Revisioned reads and explicit refresh remain authoritative.
+            }
+        }
+    }
+    closeWorkspaceWatchers() {
+        if (this.resourceInvalidationTimer)
+            clearTimeout(this.resourceInvalidationTimer);
+        this.resourceInvalidationTimer = undefined;
+        for (const watcher of this.workspaceWatchers)
+            watcher.close();
+        this.workspaceWatchers = [];
+    }
+    async restoreContextSession(sessionId) {
+        if (!sessionId) {
+            this.runtimeValue.setSession(null);
+            await this.runtimeValue.rebindSessionRuntime?.();
+            if (this.suppressContextEdges === 0) {
+                this.eventHub.emitRuntime({ type: 'transcript_clear' });
+            }
+            return;
+        }
+        const result = this.controllerValue.handle({
+            type: 'select_session',
+            sessionId,
+            source: 'programmatic',
         });
+        await this.controllerValue.waitForIdle();
+        if (this.runtimeValue.getSession()?.id !== sessionId) {
+            throw new errors_1.WebWorkbenchError(409, `Session activation was rejected by the runtime (${result.type}).`, 'context_session_rejected');
+        }
+    }
+    emitSettingsWorkspaceChange() {
+        const describe = this.runtimeValue.describeSettings;
+        if (!describe) {
+            throw new errors_1.WebWorkbenchError(503, 'The product Settings coordinator is unavailable.', 'settings_document_unavailable');
+        }
+        const settings = describe();
+        this.eventHub.emit({
+            type: 'settings_invalidated',
+            revision: settings.revision,
+            reason: 'workspace-change',
+            state: settings.state === 'ready' || settings.state === 'read-only' ? 'ready' : 'invalid',
+        }, false);
     }
     observeThreadRuntime(runtime, sessionId, activation) {
         let replaying = true;
@@ -612,31 +1454,138 @@ class WebWorkbenchController {
     }
     assertReadyForTransition(operation) {
         if (this.closed)
-            throw new WebWorkbenchError(503, 'Web Workbench is closed.');
-        if (this.transition) {
-            throw new WebWorkbenchError(409, 'A workspace transition is running.', 'runtime_busy');
+            throw new errors_1.WebWorkbenchError(503, 'Web Workbench is closed.');
+        if (this.transition || this.sessionTransition) {
+            throw new errors_1.WebWorkbenchError(409, 'A workspace transition is running.', 'runtime_busy');
         }
         if (this.controllerValue.hasActiveTurn()) {
-            throw new WebWorkbenchError(409, `Cannot ${operation} while a turn is active.`, 'runtime_busy');
+            throw new errors_1.WebWorkbenchError(409, `Cannot ${operation} while a turn is active.`, 'runtime_busy');
+        }
+    }
+    assertMutationAdmission() {
+        if (this.closed)
+            throw new errors_1.WebWorkbenchError(503, 'Web Workbench is closed.');
+        if (this.transition || this.sessionTransition) {
+            throw new errors_1.WebWorkbenchError(409, 'A Context transition is running.', 'runtime_busy');
+        }
+    }
+    assertContextGuard(context) {
+        this.assertMutationAdmission();
+        if (context.expectedContextRevision !== this.contextRevisionValue ||
+            context.workspaceId !== this.activeWorkspaceEntry().id) {
+            throw new errors_1.WebWorkbenchError(409, 'The active Context changed before the operation was admitted.', 'context_revision_conflict');
+        }
+    }
+    assertCommandSession(expectedSessionId) {
+        if (this.closed)
+            throw new errors_1.WebWorkbenchError(503, 'Web Workbench is closed.');
+        if (this.transition || this.sessionTransition) {
+            throw new errors_1.WebWorkbenchError(409, 'A Session transition is running.', 'runtime_busy');
+        }
+        if (this.runtimeValue.getSession()?.id !== expectedSessionId) {
+            throw new errors_1.WebWorkbenchError(409, 'The active Session changed before the command was admitted.', 'active_session_changed');
         }
     }
     assertSettingsAvailable() {
         if (this.closed) {
-            throw new WebWorkbenchError(503, 'Web Workbench is closed.', 'settings_document_unavailable');
+            throw new errors_1.WebWorkbenchError(503, 'Web Workbench is closed.', 'settings_document_unavailable');
         }
         if (this.transition) {
-            throw new WebWorkbenchError(409, 'A workspace transition is running.', 'runtime_busy');
+            throw new errors_1.WebWorkbenchError(409, 'A workspace transition is running.', 'runtime_busy');
+        }
+    }
+    initializeWorkspaceRegistry() {
+        const paths = [this.workspaceValue];
+        for (const session of (0, session_storage_1.listSessions)()) {
+            try {
+                paths.push(canonicalDirectory(session.projectPath));
+            }
+            catch {
+                // Unavailable historical projects remain in the Session catalog but
+                // are not imported as selectable Workspace registry entries.
+            }
+        }
+        try {
+            this.workspaceRegistry.registerKnown(paths, this.workspaceValue);
+        }
+        catch (error) {
+            throw mapWorkspaceRegistryError(error);
+        }
+    }
+    activeWorkspaceEntry() {
+        const entry = this.workspaceRegistry
+            .list()
+            .find(candidate => candidate.canonicalPath === this.workspaceValue);
+        if (!entry) {
+            throw new errors_1.WebWorkbenchError(503, 'Active Workspace is missing from the registry.');
         }
+        return entry;
     }
 }
 exports.WebWorkbenchController = WebWorkbenchController;
+function mapWorkspaceRegistryError(error) {
+    if (error instanceof errors_1.WebWorkbenchError)
+        return error;
+    if (error instanceof workspace_registry_1.WorkspaceRegistryError) {
+        const status = error.code === 'workspace_registry_invalid' ? 503 : 409;
+        return new errors_1.WebWorkbenchError(status, error.message, error.code);
+    }
+    return new errors_1.WebWorkbenchError(503, 'Workspace registry is unavailable.');
+}
 function mapSettingsError(error) {
-    if (error instanceof WebWorkbenchError)
+    if (error instanceof errors_1.WebWorkbenchError)
         return error;
     if (error instanceof settings_coordinator_1.SettingsCoordinatorError) {
-        return new WebWorkbenchError(error.status, error.message, error.code);
+        return new errors_1.WebWorkbenchError(error.status, error.message, error.code);
     }
-    return new WebWorkbenchError(503, 'The product Settings coordinator is unavailable.', 'settings_document_unavailable');
+    return new errors_1.WebWorkbenchError(503, 'The product Settings coordinator is unavailable.', 'settings_document_unavailable');
+}
+function mapComposerControlError(error) {
+    if (error instanceof errors_1.WebWorkbenchError)
+        return error;
+    if (error instanceof agent_runtime_controller_1.FollowupQueueConflictError) {
+        return new errors_1.WebWorkbenchError(409, error.message, error.code);
+    }
+    if (error instanceof session_composer_control_1.SessionComposerControlError) {
+        const status = error.code === 'composer_recovery_required'
+            ? 503
+            : ['runtime_busy', 'composer_control_conflict'].includes(error.code)
+                ? 409
+                : 422;
+        return new errors_1.WebWorkbenchError(status, error.message, error.code);
+    }
+    if (error instanceof plan_review_1.PlanReviewControlError) {
+        const status = error.code === 'plan_review_invalid' ? 422 : 409;
+        return new errors_1.WebWorkbenchError(status, error.message, error.code);
+    }
+    return new errors_1.WebWorkbenchError(503, 'The Session Composer control action failed.', 'composer_control_failed');
+}
+function mapContextReferenceError(error) {
+    if (error instanceof errors_1.WebWorkbenchError) {
+        if (error.code.startsWith('context_reference_'))
+            return error;
+        if (error.status === 403 ||
+            ['sensitive_file_blocked', 'file_binary', 'file_not_regular'].includes(error.code)) {
+            return new errors_1.WebWorkbenchError(403, 'The Context reference is not available to the model.', 'context_reference_forbidden');
+        }
+        if (error.status === 404 || error.status === 409) {
+            return new errors_1.WebWorkbenchError(409, 'The Context reference changed or is no longer available.', 'context_reference_stale');
+        }
+    }
+    return new errors_1.WebWorkbenchError(422, 'The Context reference could not be resolved.', 'context_reference_invalid');
+}
+function composerAuthorityDigest(state) {
+    return (0, canonical_1.digestRuntimeValue)({
+        workspaceId: state.workspaceId,
+        sessionId: state.sessionId,
+        mode: state.mode,
+        model: state.model,
+        permission: state.permission,
+        pending: state.pending,
+        lastError: state.lastError,
+        planReview: state.planReview,
+        queue: state.queue,
+    });
 }
 function pickPlanReceipt(receipt) {
     return Object.freeze({
@@ -687,11 +1636,11 @@ function estimateSessionViewBytes(view) {
 }
 function pageItems(items, cursor, pageSize = 50) {
     if (!Number.isSafeInteger(pageSize) || pageSize < 1 || pageSize > 100) {
-        throw new WebWorkbenchError(400, 'pageSize must be an integer from 1 through 100.');
+        throw new errors_1.WebWorkbenchError(400, 'pageSize must be an integer from 1 through 100.');
     }
     const offset = cursor ? decodePageCursor(cursor) : 0;
     if (offset > items.length)
-        throw new WebWorkbenchError(400, 'Page cursor is out of range.');
+        throw new errors_1.WebWorkbenchError(400, 'Page cursor is out of range.');
     const page = items.slice(offset, offset + pageSize);
     const nextOffset = offset + page.length;
     return Object.freeze({
@@ -699,13 +1648,45 @@ function pageItems(items, cursor, pageSize = 50) {
         nextCursor: nextOffset < items.length ? encodePageCursor(nextOffset) : null,
     });
 }
+function pageCollectionItems(scope, items, cursor, pageSize, keyOf) {
+    if (!scope || scope.length > 80 || !/^[a-z][a-z0-9_-]*$/.test(scope)) {
+        throw new errors_1.WebWorkbenchError(500, 'Collection scope is invalid.');
+    }
+    if (!Number.isSafeInteger(pageSize) || pageSize < 1 || pageSize > 100) {
+        throw new errors_1.WebWorkbenchError(400, 'pageSize must be an integer from 1 through 100.');
+    }
+    const keys = items.map(keyOf);
+    if (keys.some(key => !key || key.length > 4096) || new Set(keys).size !== keys.length) {
+        throw new errors_1.WebWorkbenchError(500, `Collection ${scope} has invalid or duplicate keys.`);
+    }
+    const revision = (0, canonical_1.digestRuntimeValue)(items);
+    let offset = 0;
+    if (cursor) {
+        const decoded = decodeCollectionCursor(cursor, scope);
+        if (decoded.revision !== revision) {
+            throw new errors_1.WebWorkbenchError(409, 'Collection changed after this page cursor was issued.', 'collection_cursor_stale');
+        }
+        offset = keys.indexOf(decoded.after) + 1;
+        if (offset === 0) {
+            throw new errors_1.WebWorkbenchError(409, 'Collection page boundary no longer exists.', 'collection_cursor_stale');
+        }
+    }
+    const page = items.slice(offset, offset + pageSize);
+    const nextOffset = offset + page.length;
+    return Object.freeze({
+        items: Object.freeze(page),
+        nextCursor: nextOffset < items.length && page.length > 0
+            ? encodeCollectionCursor(scope, revision, keys[nextOffset - 1])
+            : null,
+    });
+}
 function pageTranscriptTail(items, cursor, pageSize = 50) {
     if (!Number.isSafeInteger(pageSize) || pageSize < 1 || pageSize > 100) {
-        throw new WebWorkbenchError(400, 'pageSize must be an integer from 1 through 100.');
+        throw new errors_1.WebWorkbenchError(400, 'pageSize must be an integer from 1 through 100.');
     }
     const end = cursor ? decodePageCursor(cursor) : items.length;
     if (end > items.length)
-        throw new WebWorkbenchError(400, 'Page cursor is out of range.');
+        throw new errors_1.WebWorkbenchError(400, 'Page cursor is out of range.');
     const offset = Math.max(0, end - pageSize);
     return Object.freeze({
         items: Object.freeze(items.slice(offset, end)),
@@ -716,9 +1697,37 @@ function pageTranscriptTail(items, cursor, pageSize = 50) {
 function encodePageCursor(offset) {
     return Buffer.from(JSON.stringify({ version: 1, offset })).toString('base64url');
 }
+function encodeCollectionCursor(scope, revision, after) {
+    return Buffer.from(JSON.stringify({ version: 2, kind: 'collection', scope, revision, after })).toString('base64url');
+}
+function decodeCollectionCursor(cursor, expectedScope) {
+    if (!cursor || cursor.length > 8192) {
+        throw new errors_1.WebWorkbenchError(400, 'Collection page cursor is invalid.');
+    }
+    try {
+        const parsed = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+        if (!parsed ||
+            typeof parsed !== 'object' ||
+            Array.isArray(parsed) ||
+            parsed.version !== 2 ||
+            parsed.kind !== 'collection' ||
+            parsed.scope !== expectedScope ||
+            typeof parsed.revision !== 'string' ||
+            typeof parsed.after !== 'string') {
+            throw new Error('invalid');
+        }
+        return {
+            revision: parsed.revision,
+            after: parsed.after,
+        };
+    }
+    catch {
+        throw new errors_1.WebWorkbenchError(400, 'Collection page cursor is invalid.');
+    }
+}
 function decodePageCursor(cursor) {
     if (!cursor || cursor.length > 512)
-        throw new WebWorkbenchError(400, 'Page cursor is invalid.');
+        throw new errors_1.WebWorkbenchError(400, 'Page cursor is invalid.');
     try {
         const parsed = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
         if (!parsed ||
@@ -731,7 +1740,7 @@ function decodePageCursor(cursor) {
         return parsed.offset;
     }
     catch {
-        throw new WebWorkbenchError(400, 'Page cursor is invalid.');
+        throw new errors_1.WebWorkbenchError(400, 'Page cursor is invalid.');
     }
 }
 function canonicalDirectory(path) {
@@ -741,26 +1750,26 @@ function canonicalDirectory(path) {
         canonical = (0, fs_1.realpathSync)(candidate);
     }
     catch {
-        throw new WebWorkbenchError(400, 'Workspace path does not exist.');
+        throw new errors_1.WebWorkbenchError(400, 'Workspace path does not exist.');
     }
     try {
         if (!(0, fs_1.statSync)(canonical).isDirectory()) {
-            throw new WebWorkbenchError(400, 'Workspace path must be a directory.');
+            throw new errors_1.WebWorkbenchError(400, 'Workspace path must be a directory.');
         }
     }
     catch (error) {
-        if (error instanceof WebWorkbenchError)
+        if (error instanceof errors_1.WebWorkbenchError)
             throw error;
-        throw new WebWorkbenchError(400, 'Workspace path is not readable.');
+        throw new errors_1.WebWorkbenchError(400, 'Workspace path is not readable.');
     }
     return canonical;
 }
 function requireSession(sessionId) {
     if (!sessionId.trim())
-        throw new WebWorkbenchError(400, 'Session id is required.');
+        throw new errors_1.WebWorkbenchError(400, 'Session id is required.');
     const session = (0, session_storage_1.loadSessionMeta)(sessionId);
     if (!session)
-        throw new WebWorkbenchError(404, 'Session was not found.');
+        throw new errors_1.WebWorkbenchError(404, 'Session was not found.');
     return session;
 }
 function mcpServerIds(config) {