@orion-agents/orion-code 0.3.0 → 0.3.1

package/dist/web/workbench-controller.js

@@ -2,30 +2,34 @@
 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 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 global_config_1 = require("../services/global-config");
 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;
 /** Owns the sole runtime/controller pair exposed through the local Web host. */
 class WebWorkbenchController {
     constructor(options) {
@@ -33,10 +37,27 @@ class WebWorkbenchController {
         this.sessionViews = new Map();
         this.sessionViewBytes = 0;
         this.toolDetails = new tool_detail_repository_1.FileToolDetailRepository();
+        this.contextRevisionValue = (0, crypto_1.randomUUID)();
+        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 +65,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 +78,7 @@ class WebWorkbenchController {
     }
     static async create(options) {
         const workbench = new WebWorkbenchController(options);
+        workbench.initializeWorkspaceRegistry();
         await workbench.installRuntime(workbench.workspaceValue);
         return workbench;
     }
@@ -67,11 +91,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 +111,10 @@ class WebWorkbenchController {
                 skills: true,
                 mcp: true,
                 diagnostics: true,
+                review: true,
+                files: true,
+                git: true,
+                terminal: this.terminalManager.available,
             },
         });
     }
@@ -89,7 +122,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();
@@ -99,85 +132,207 @@ class WebWorkbenchController {
         }
     }
     listWorkspaces() {
-        const paths = new Set([this.workspaceValue]);
         const counts = new Map();
         for (const session of (0, session_storage_1.listSessions)()) {
             try {
                 const path = canonicalDirectory(session.projectPath);
-                paths.add(path);
                 counts.set(path, (counts.get(path) ?? 0) + 1);
             }
             catch {
                 // Stale projects remain in session history but are not selectable workspaces.
             }
         }
-        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,
-        })));
+        return Object.freeze(this.workspaceRegistry.list().map(entry => {
+            let available = false;
+            try {
+                available = canonicalDirectory(entry.canonicalPath) === entry.canonicalPath;
+            }
+            catch {
+                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 } : {}),
+            });
+        }));
+    }
+    listWorkspaceSessions(workspaceId) {
+        const entry = this.workspaceRegistry.find(workspaceId);
+        if (!entry) {
+            throw new errors_1.WebWorkbenchError(404, 'Workspace was not found.', 'workspace_not_found');
+        }
+        try {
+            canonicalDirectory(entry.canonicalPath);
+        }
+        catch {
+            throw new errors_1.WebWorkbenchError(409, 'Workspace is unavailable.', 'workspace_unavailable');
+        }
+        return Object.freeze((0, session_storage_1.listProjectSessions)(entry.canonicalPath).map(protocol_1.projectSessionSummary));
+    }
+    async workspaceProjectSummary(workspaceId) {
+        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 });
+        return 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,
+        });
     }
-    listSessions() {
-        return Object.freeze((0, session_storage_1.listProjectSessions)(this.workspaceValue).map(protocol_1.projectSessionSummary));
+    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');
+        }
     }
-    sessionSnapshot(sessionId, cursor, pageSize = 50, tail = false) {
+    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, 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 +349,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 +357,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,8 +385,11 @@ class WebWorkbenchController {
             pendingApprovals: Object.freeze(pendingPermissions),
             goal,
             plan,
-            recoveryDiagnostics: view?.diagnostics ?? [],
+            recoveryDiagnostics: indexedPage ? [] : (view?.diagnostics ?? []),
         });
+        if (context)
+            this.assertContextGuard(context);
+        return snapshot;
     }
     async skills() {
         const descriptors = (await this.runtimeValue.inspectSkills?.()) ?? [];
@@ -270,7 +430,9 @@ 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.' }
+                    : {}),
             });
         }));
     }
@@ -280,7 +442,7 @@ class WebWorkbenchController {
     async readToolDetail(callId, offsetBytes, limitBytes) {
         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.');
+            throw new errors_1.WebWorkbenchError(404, 'Tool detail was not found.');
         return this.toolDetails.read({
             callId: entry.callId,
             sequence: entry.sequence,
@@ -288,85 +450,195 @@ class WebWorkbenchController {
             outputBytes: entry.outputBytes,
         }, { offsetBytes, limitBytes }, this.workspaceValue);
     }
-    async createSession(name) {
+    listFiles(context, input) {
+        this.assertContextGuard(context);
+        const result = this.fileService.list(input);
+        this.assertContextGuard(context);
+        return result;
+    }
+    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');
+            finally {
+                this.suppressContextEdges -= 1;
             }
-            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);
+            this.emitState();
+            this.emitWorkspaceResourceInvalidation('context-change');
+            if (targetWorkspace !== previousWorkspace)
+                this.emitSettingsWorkspaceChange();
         })().finally(() => {
             if (this.transition === transition)
                 this.transition = undefined;
@@ -377,6 +649,7 @@ class WebWorkbenchController {
     dispatch(raw) {
         const command = (0, protocol_1.parseWebCommand)(raw);
         return this.executeMutation(command.requestId, 'command', command, () => {
+            this.assertCommandSession(command.expectedSessionId);
             const runtimeResult = this.controllerValue.handle((0, protocol_1.toAgentRuntimeInput)(command));
             return Object.freeze({
                 requestId: command.requestId,
@@ -389,7 +662,7 @@ class WebWorkbenchController {
         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 +684,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,24 +696,24 @@ 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() {
@@ -478,21 +751,29 @@ class WebWorkbenchController {
         this.closed = true;
         await this.controllerValue.stopActiveTurn();
         await this.controllerValue.waitForIdle();
+        this.closeWorkspaceWatchers();
+        await this.terminalManager.shutdown();
         await this.runtimeValue.shutdown();
         this.eventHub.close();
     }
-    async installRuntime(workspace) {
+    async installRuntime(workspace, publishState = true) {
         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;
                 const activeThread = activeSessionId && this.activeOrionRuntime?.sessionId === activeSessionId
                     ? this.activeOrionRuntime.runtime.thread.getProjection().threadId
@@ -503,6 +784,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,15 +806,104 @@ class WebWorkbenchController {
                 suppressAbortNotice: true,
             },
         });
-        this.emitState();
+        this.installWorkspaceWatchers();
+        if (publishState)
+            this.emitState(false);
     }
-    emitState() {
+    emitState(advanceRevision = true) {
+        if (this.suppressContextEdges > 0)
+            return;
+        if (advanceRevision)
+            this.contextRevisionValue = (0, crypto_1.randomUUID)();
+        const workspace = this.activeWorkspaceEntry();
         this.eventHub.emit({
             type: 'workbench_state',
+            contextRevision: this.contextRevisionValue,
+            workspaceId: workspace.id,
             workspace: this.workspaceValue,
             activeSessionId: this.runtimeValue.getSession()?.id ?? null,
         });
     }
+    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();
+    }
+    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;
         const pending = [];
@@ -612,31 +985,91 @@ 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 pickPlanReceipt(receipt) {
     return Object.freeze({
@@ -687,11 +1120,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 +1132,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 +1181,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 +1224,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 +1234,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) {