@orion-agents/orion-code 0.3.1 → 0.3.4

package/dist/web/workbench-controller.js

@@ -11,11 +11,15 @@ const durable_tool_receipt_reader_1 = require("../runtime/durable-tool-receipt-r
 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_event_store_1 = require("../runtime/thread-event-store");
 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");
@@ -23,28 +27,42 @@ 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 workspace_mutation_arbiter_1 = require("./workspace-mutation-arbiter");
 const protocol_1 = require("./protocol");
 const review_service_1 = require("./review-service");
+const session_runtime_registry_1 = require("./session-runtime-registry");
 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. */
+const MAX_CONTEXT_REFERENCE_BYTES = 64 * 1024;
+const MAX_CONTEXT_MANIFEST_BYTES = 256 * 1024;
+const CONTEXT_TRANSITION_MUTATIONS = new Set(['context.activate', 'workspace.activate']);
+/** Owns the Workspace surface plus the bounded Web Session actor registry. */
 class WebWorkbenchController {
     constructor(options) {
+        this.activeOrionRuntimes = new Map();
         this.mutationResults = new Map();
         this.sessionViews = new Map();
         this.sessionViewBytes = 0;
         this.toolDetails = new tool_detail_repository_1.FileToolDetailRepository();
+        this.workspaceMutationOwners = new Map();
+        this.pendingWorkspaceMutationStates = new Map();
         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.activeMutationCount = 0;
+        this.contextTransitionReserved = false;
         this.closed = false;
         this.workspaceWatchers = [];
         this.workspaceValue = canonicalDirectory(options.cwd);
         this.eventHub = options.eventHub ?? new event_hub_1.WebEventHub();
+        this.workspaceMutations = new workspace_mutation_arbiter_1.WorkspaceMutationArbiterV1({
+            onStateChanged: state => this.emitWorkspaceMutationState(state),
+        });
         this.workspaceRegistry = options.workspaceRegistry ?? new workspace_registry_1.WorkspaceRegistryV1();
         this.terminalManager = new terminal_manager_1.TerminalManagerV1({
             resolveWorkspace: workspaceId => this.workspaceRegistry.find(workspaceId)?.canonicalPath,
@@ -62,6 +80,7 @@ class WebWorkbenchController {
             options.createRuntime ??
                 (cwd => (0, product_bootstrap_1.createProductUiRuntime)({
                     cwd,
+                    workspaceMutationCoordinator: this.workspaceMutations,
                     shutdownReason: 'Orion Web Workbench shutdown',
                     onActiveSessionRuntime: (runtime, sessionId, activation) => this.observeThreadRuntime(runtime, sessionId, activation),
                     onSettingsInvalidated: event => {
@@ -75,6 +94,17 @@ class WebWorkbenchController {
                         }, false);
                     },
                 }));
+        this.createSessionRuntime =
+            options.createSessionRuntime ??
+                options.createRuntime ??
+                (cwd => (0, product_bootstrap_1.createProductUiRuntime)({
+                    cwd,
+                    workspaceRuntimeKernel: this.runtimeValue.workspaceRuntimeKernel,
+                    workspaceMutationCoordinator: this.workspaceMutations,
+                    shutdownReason: 'Orion Web Session actor shutdown',
+                    onActiveSessionRuntime: (runtime, sessionId, activation) => this.observeThreadRuntime(runtime, sessionId, activation),
+                }));
+        this.sessionRegistry = this.createSessionRegistry();
     }
     static async create(options) {
         const workbench = new WebWorkbenchController(options);
@@ -131,18 +161,15 @@ class WebWorkbenchController {
             throw mapSettingsError(error);
         }
     }
-    listWorkspaces() {
-        const counts = new Map();
-        for (const session of (0, session_storage_1.listSessions)()) {
-            try {
-                const path = canonicalDirectory(session.projectPath);
-                counts.set(path, (counts.get(path) ?? 0) + 1);
-            }
-            catch {
-                // Stale projects remain in session history but are not selectable workspaces.
-            }
-        }
-        return Object.freeze(this.workspaceRegistry.list().map(entry => {
+    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 {
                 available = canonicalDirectory(entry.canonicalPath) === entry.canonicalPath;
@@ -161,8 +188,13 @@ class WebWorkbenchController {
                 ...(entry.pinnedOrder !== undefined ? { pinnedOrder: entry.pinnedOrder } : {}),
             });
         }));
+        if (context)
+            this.assertContextGuard(context);
+        return result;
     }
-    listWorkspaceSessions(workspaceId) {
+    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');
@@ -173,9 +205,14 @@ class WebWorkbenchController {
         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));
+        const result = Object.freeze((0, session_storage_1.listProjectSessions)(entry.canonicalPath).map(protocol_1.projectSessionSummary));
+        if (context)
+            this.assertContextGuard(context);
+        return result;
     }
-    async workspaceProjectSummary(workspaceId) {
+    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');
@@ -188,7 +225,7 @@ class WebWorkbenchController {
             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({
+        const result = Object.freeze({
             workspaceId,
             repositoryRevision: status.repositoryRevision,
             isRepository: status.isRepository,
@@ -198,6 +235,9 @@ class WebWorkbenchController {
             dirtyCount: status.totalFiles,
             conflictCount: status.conflicted.length,
         });
+        if (context)
+            this.assertContextGuard(context);
+        return result;
     }
     setWorkspacePinned(workspaceId, pinned, context) {
         this.assertContextGuard(context);
@@ -242,10 +282,12 @@ class WebWorkbenchController {
         if (canonicalDirectory(session.projectPath) !== this.workspaceValue) {
             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;
+        const key = this.sessionActorKey(session);
+        const resident = this.sessionRegistry.residentActor(key);
+        const actor = resident?.actor;
+        const baseSessionRuntime = resident?.runtime ?? this.sessionRegistry.summary(key);
+        const active = actor !== undefined;
+        const activeProjection = this.activeOrionRuntimes.get(session.id)?.thread.getProjection();
         let indexedPage;
         if (tail) {
             try {
@@ -335,13 +377,26 @@ class WebWorkbenchController {
                     : [];
         const commits = commitProjections.map(commit => (0, turn_commit_1.parseTurnCommitV1)(commit.receipt));
         const latestCommit = commits.at(-1);
+        const latestProjectedTurn = activeProjection
+            ? Object.values(activeProjection.turns)
+                .sort((left, right) => left.startedSeq - right.startedSeq)
+                .at(-1)
+            : undefined;
+        const durableTerminal = latestProjectedTurn?.status ?? indexedPage?.latestTurn?.status ?? latestCommit?.terminal;
+        const recoverableTerminalPhase = durableTerminal === 'interrupted' || durableTerminal === 'failed'
+            ? durableTerminal
+            : undefined;
+        const sessionRuntime = recoverableTerminalPhase &&
+            ['cold', 'idle', 'interrupted', 'failed'].includes(baseSessionRuntime.phase)
+            ? Object.freeze({ ...baseSessionRuntime, phase: recoverableTerminalPhase })
+            : baseSessionRuntime;
         const planCommit = [...commits].reverse().find(commit => commit.planReceipt);
         const plan = planCommit?.planReceipt
             ? pickPlanReceipt((0, turn_commit_1.parsePlanReceiptV1)(planCommit.planReceipt))
             : null;
-        const state = this.runtimeValue.store.getSnapshot();
+        const state = (actor?.runtime ?? this.runtimeValue).store.getSnapshot();
         const pendingPermissions = active
-            ? this.controllerValue.getPendingPermissions().map(request => ({
+            ? actor.controller.getPendingPermissions().map(request => ({
                 id: request.id,
                 toolName: request.name,
                 ...(request.reason ? { reason: request.reason } : {}),
@@ -357,9 +412,16 @@ class WebWorkbenchController {
                 state: JSON.parse(latestCommit.goalState),
             }
             : null;
+        const projectedComposer = actor
+            ? this.projectActorComposerState(actor, session)
+            : this.projectComposerStateValue(session, undefined, indexedPage?.planReview);
+        const composer = projectedComposer.sessionRuntime.phase === sessionRuntime.phase
+            ? projectedComposer
+            : Object.freeze({ ...projectedComposer, sessionRuntime });
         const snapshot = Object.freeze({
             apiVersion: protocol_1.WEB_API_VERSION,
             session: (0, protocol_1.projectSessionSummary)(session),
+            sessionRuntime,
             threadId: activeProjection?.threadId ?? indexedPage?.threadId ?? view?.threadId ?? null,
             threadCursor: activeProjection?.cursor ?? indexedPage?.cursor ?? view?.cursor ?? 0,
             eventCursor: this.eventHub.snapshot().latest,
@@ -376,8 +438,8 @@ class WebWorkbenchController {
                 processing: active ? state.isProcessing : false,
                 agentMode: state.agentMode,
                 permissionMode: state.permissionMode,
-                status: this.latestStatus,
-                followups: active ? Object.freeze([...this.controllerValue.getFollowupQueue()]) : [],
+                status: actor?.latestStatus ?? 'Ready',
+                followups: active ? Object.freeze([...actor.controller.getFollowupQueue()]) : [],
                 followupLimit: 16,
                 contextUsage: active ? state.contextUsage : null,
                 tokenUsage: active ? state.tokenUsage : null,
@@ -385,15 +447,246 @@ class WebWorkbenchController {
             pendingApprovals: Object.freeze(pendingPermissions),
             goal,
             plan,
+            composer,
             recoveryDiagnostics: indexedPage ? [] : (view?.diagnostics ?? []),
         });
         if (context)
             this.assertContextGuard(context);
         return snapshot;
     }
-    async skills() {
+    composerState(sessionId, context) {
+        if (context)
+            this.assertContextGuard(context);
+        const session = requireSession(sessionId);
+        this.assertSessionWorkspace(session);
+        const actor = this.sessionRegistry.residentActor(this.sessionActorKey(session))?.actor;
+        const state = actor
+            ? this.projectActorComposerState(actor, session)
+            : this.projectComposerStateValue(session);
+        if (context)
+            this.assertContextGuard(context);
+        return state;
+    }
+    sessionRuntimeSummary(sessionId) {
+        const session = requireSession(sessionId);
+        this.assertSessionWorkspace(session);
+        return this.sessionRegistry.summary(this.sessionActorKey(session));
+    }
+    async waitForSessionIdle(sessionId) {
+        const session = requireSession(sessionId);
+        this.assertSessionWorkspace(session);
+        const actor = this.sessionRegistry.residentActor(this.sessionActorKey(session))?.actor;
+        await actor?.controller.waitForIdle();
+    }
+    projectActorComposerState(actor, session) {
+        const state = this.projectComposerStateValue(session, actor);
+        // 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 (actor.composerAuthorityDigest === undefined) {
+            actor.composerAuthorityDigest = authorityDigest;
+            return state;
+        }
+        if (authorityDigest === actor.composerAuthorityDigest)
+            return state;
+        actor.composerRevision = (0, crypto_1.randomUUID)();
+        actor.composerAuthorityDigest = authorityDigest;
+        return Object.freeze({ ...state, controlRevision: actor.composerRevision });
+    }
+    projectComposerStateValue(session, actor, indexedPlanReview) {
+        const runtimeOwner = actor?.runtime ?? this.runtimeValue;
+        const controller = actor?.controller;
+        const controls = runtimeOwner.sessionComposerControls;
+        if (!controls) {
+            throw new errors_1.WebWorkbenchError(503, 'Session Composer controls are unavailable.', 'composer_controls_unavailable');
+        }
+        const runtime = controls.describeSession(session);
+        const queue = actor
+            ? actor.controller.getFollowupQueueSnapshot()
+            : { items: [], limit: 16 };
+        const projection = actor
+            ? this.activeOrionRuntimes.get(session.id)?.thread.getProjection()
+            : undefined;
+        const review = projection?.planReview ?? indexedPlanReview;
+        const workspaceId = this.workspaceRegistry
+            .list()
+            .find(entry => entry.canonicalPath === canonicalDirectory(session.projectPath))?.id;
+        if (!workspaceId) {
+            throw new errors_1.WebWorkbenchError(404, 'Workspace was not found.', 'workspace_not_found');
+        }
+        const sessionRuntime = this.sessionRegistry.summary({ workspaceId, sessionId: session.id });
+        return Object.freeze({
+            apiVersion: protocol_1.WEB_API_VERSION,
+            workspaceId,
+            sessionId: session.id,
+            contextRevision: this.contextRevisionValue,
+            controlRevision: actor?.composerRevision ?? sessionRuntime.runtimeRevision,
+            sessionRuntime,
+            processing: Boolean(actor) &&
+                (runtimeOwner.store.getSnapshot().isProcessing || Boolean(projection?.activeTurnId)),
+            mode: controller
+                ? Object.freeze({ ...controller.getAgentModeSnapshot() })
+                : Object.freeze({ baseMode: 'interactive', pendingBaseMode: null }),
+            model: runtime.model,
+            permission: runtime.permission,
+            contextUsage: runtime.contextUsage,
+            compactAvailable: controller?.canCompactContext() ?? false,
+            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,
+            }),
+        });
+    }
+    modelCatalog(sessionId, context) {
+        if (context)
+            this.assertContextGuard(context);
+        const session = requireSession(sessionId);
+        this.assertSessionWorkspace(session);
+        const actor = this.sessionRegistry.residentActor(this.sessionActorKey(session))?.actor;
+        const controls = (actor?.runtime ?? 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);
+        const session = requireSession(input.expectedSessionId);
+        this.assertSessionWorkspace(session);
+        const key = this.sessionActorKey(session);
+        const wasResident = this.sessionRegistry.summary(key).resident;
+        let actor;
+        try {
+            actor = (await this.sessionRegistry.ensureResident(key, input.expectedSessionRuntimeRevision))
+                .actor;
+        }
+        catch (error) {
+            throw mapSessionRuntimeError(error);
+        }
+        const actorSession = actor.runtime.getSession();
+        if (!actorSession || actorSession.id !== input.expectedSessionId) {
+            throw new errors_1.WebWorkbenchError(503, 'Session actor is not bound to the expected Session.', 'session_unavailable');
+        }
+        if (!wasResident)
+            actor.composerRevision = input.expectedControlRevision;
+        const admittedState = this.projectActorComposerState(actor, actorSession);
+        if (input.expectedControlRevision !== admittedState.controlRevision) {
+            throw new errors_1.WebWorkbenchError(409, 'Composer controls changed before the action was admitted.', 'composer_control_conflict');
+        }
+        const controls = actor.runtime.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;
+        actor.suppressComposerEdges += 1;
+        try {
+            switch (input.type) {
+                case 'set_agent_mode': {
+                    const result = actor.controller.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 actor.controller.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(actor.controller.editFollowupQueueItem(input.itemId, input.expectedItemRevision, input.text));
+                    break;
+                case 'move_queue_item':
+                    detail = JSON.stringify(actor.controller.moveFollowupQueueItem(input.itemId, input.expectedItemRevision, input.targetIndex));
+                    break;
+                case 'remove_queue_item':
+                    detail = JSON.stringify(actor.controller.removeFollowupQueueItem(input.itemId, input.expectedItemRevision));
+                    break;
+                case 'review_plan': {
+                    planReviewReceipt = await actor.controller.reviewPlan({
+                        planDigest: input.planDigest,
+                        action: input.action,
+                        ...(input.feedback ? { feedback: input.feedback } : {}),
+                    });
+                    if (input.action === 'approve')
+                        actor.controller.setAgentMode('interactive');
+                    else if (input.action === 'continue')
+                        actor.controller.setAgentMode('plan');
+                    detail = JSON.stringify(planReviewReceipt.admission);
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            throw mapComposerControlError(error);
+        }
+        finally {
+            actor.suppressComposerEdges -= 1;
+        }
+        actor.composerRevision = (0, crypto_1.randomUUID)();
+        const state = this.projectComposerStateValue(actorSession, actor);
+        actor.composerAuthorityDigest = composerAuthorityDigest(state);
+        this.eventHub.emit({ type: 'composer_state_changed', state }, true, {
+            sessionId: input.expectedSessionId,
+        });
+        return Object.freeze({
+            requestId: input.requestId,
+            outcome,
+            controlRevision: actor.composerRevision,
+            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,
@@ -404,8 +697,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 {
@@ -417,7 +715,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,
@@ -435,20 +733,33 @@ class WebWorkbenchController {
                     : {}),
             });
         }));
+        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 errors_1.WebWorkbenchError(404, 'Tool detail was not found.');
-        return this.toolDetails.read({
+        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);
@@ -501,56 +812,28 @@ class WebWorkbenchController {
         return result;
     }
     async createSession(name, context) {
-        this.assertReadyForTransition('create a session');
         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;
-        }
+        // A new Session inherits the durable default; an override on another
+        // Session actor must never leak into it. Creation does not activate or
+        // close any actor; foreground selection belongs to the browser tab.
+        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.sessionRegistry.summary(this.sessionActorKey(named));
+        return (0, protocol_1.projectSessionSummary)(named);
     }
     async activateSession(sessionId, context) {
-        this.assertReadyForTransition('switch sessions');
         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 };
-        }
-        finally {
-            this.suppressContextEdges -= 1;
-            this.sessionTransition = false;
-            if (activated)
-                this.emitState();
-        }
+        const session = requireSession(sessionId);
+        this.assertSessionWorkspace(session);
+        const sessionRuntime = this.sessionRegistry.summary(this.sessionActorKey(session));
+        return {
+            requestId: `activate:${session.id}`,
+            result: 'foreground_session_selected',
+            sessionRuntime,
+        };
     }
     renameSession(sessionId, name, context) {
         if (context)
@@ -559,9 +842,12 @@ class WebWorkbenchController {
         if (canonicalDirectory(session.projectPath) !== this.workspaceValue) {
             throw new errors_1.WebWorkbenchError(409, 'Session belongs to another workspace.');
         }
-        if (name.length > 120)
+        const normalizedName = name.trim();
+        if (!normalizedName)
+            throw new errors_1.WebWorkbenchError(400, 'Session name is required.');
+        if (normalizedName.length > 120)
             throw new errors_1.WebWorkbenchError(400, 'Session name is too long.');
-        const updated = (0, session_storage_1.renameSession)(session.id, name);
+        const updated = (0, session_storage_1.renameSession)(session.id, normalizedName);
         if (!updated)
             throw new errors_1.WebWorkbenchError(404, 'Session no longer exists.');
         return (0, protocol_1.projectSessionSummary)(updated);
@@ -597,10 +883,13 @@ class WebWorkbenchController {
             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)
+        if (targetWorkspace === this.workspaceValue) {
+            if (targetSession)
+                this.sessionRegistry.summary(this.sessionActorKey(targetSession));
+            // Session foreground selection is browser-local. A same-Workspace
+            // selection never mutates the Host Context or any Session actor.
             return;
+        }
         this.assertReadyForTransition('activate a Context');
         const previousWorkspace = this.workspaceValue;
         const previousSessionId = currentSessionId;
@@ -612,10 +901,11 @@ class WebWorkbenchController {
                 await previousController.stopActiveTurn();
                 await previousController.waitForIdle();
                 if (targetWorkspace !== previousWorkspace) {
+                    await this.sessionRegistry.shutdown('Workspace Context changed');
                     await previousRuntime.shutdown();
                     await this.installRuntime(targetWorkspace, false);
+                    this.sessionRegistry = this.createSessionRegistry();
                 }
-                await this.restoreContextSession(targetSession?.id ?? null);
                 this.workspaceRegistry.register(targetWorkspace, { activated: true });
             }
             catch (activationError) {
@@ -624,6 +914,7 @@ class WebWorkbenchController {
                         if (this.runtimeValue !== previousRuntime)
                             await this.runtimeValue.shutdown();
                         await this.installRuntime(previousWorkspace, false);
+                        this.sessionRegistry = this.createSessionRegistry();
                     }
                     await this.restoreContextSession(previousSessionId);
                 }
@@ -648,17 +939,254 @@ 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,
-                result: runtimeResult.type,
-                detail: JSON.stringify(runtimeResult),
-            });
+        return this.executeMutation(command.requestId, 'command', command, async () => {
+            this.assertContextGuard(command);
+            const session = requireSession(command.expectedSessionId);
+            this.assertSessionWorkspace(session);
+            const key = this.sessionActorKey(session);
+            if (command.type === 'cancel_queued_turn') {
+                try {
+                    const sessionRuntime = this.sessionRegistry.cancelQueued(key, command.queueId, command.expectedSessionRuntimeRevision);
+                    return Object.freeze({
+                        requestId: command.requestId,
+                        result: 'session_turn_queue_cancelled',
+                        sessionRuntime,
+                    });
+                }
+                catch (error) {
+                    throw mapSessionRuntimeError(error);
+                }
+            }
+            const resolved = await this.resolveCommandContext(command);
+            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 } : {}) });
+            try {
+                if (command.type === 'submit') {
+                    const currentRuntime = this.sessionRegistry.summary(key);
+                    if (['running', 'waiting_approval'].includes(currentRuntime.phase)) {
+                        const routed = await this.sessionRegistry.withActor(key, command.expectedSessionRuntimeRevision, actor => {
+                            if (!actor.controller.hasActiveTurn()) {
+                                throw new session_runtime_registry_1.WebSessionRuntimeRegistryError(409, 'session_runtime_revision_conflict', 'The Session turn ended before steering was admitted.');
+                            }
+                            return actor.controller.handle(runtimeInput);
+                        });
+                        return Object.freeze({
+                            requestId: command.requestId,
+                            result: routed.result.type,
+                            detail: JSON.stringify(routed.result),
+                            sessionRuntime: routed.runtime,
+                            ...(resolved ? { contextReceipt: resolved.receipt } : {}),
+                        });
+                    }
+                    const admission = await this.sessionRegistry.admitTurn({
+                        key,
+                        expectedRuntimeRevision: command.expectedSessionRuntimeRevision,
+                        start: async (actor) => {
+                            const runtimeResult = actor.controller.handle(runtimeInput);
+                            return {
+                                accepted: runtimeResult,
+                                settled: actor.controller.waitForIdle(),
+                            };
+                        },
+                    });
+                    if (admission.status === 'queued') {
+                        return Object.freeze({
+                            requestId: command.requestId,
+                            result: 'session_turn_queued',
+                            queueId: admission.queueId,
+                            queuePosition: admission.queuePosition,
+                            sessionRuntime: admission.runtime,
+                            ...(resolved ? { contextReceipt: resolved.receipt } : {}),
+                        });
+                    }
+                    return Object.freeze({
+                        requestId: command.requestId,
+                        result: admission.accepted.type,
+                        detail: JSON.stringify(admission.accepted),
+                        sessionRuntime: admission.runtime,
+                        ...(resolved ? { contextReceipt: resolved.receipt } : {}),
+                    });
+                }
+                const routed = await this.sessionRegistry.withActor(key, command.expectedSessionRuntimeRevision, actor => {
+                    const runtimeResult = actor.controller.handle(runtimeInput);
+                    if (command.type === 'permission_decision') {
+                        this.sessionRegistry.setPendingApprovalCount(key, actor.controller.getPendingPermissions().length);
+                    }
+                    return runtimeResult;
+                });
+                return Object.freeze({
+                    requestId: command.requestId,
+                    result: routed.result.type,
+                    detail: JSON.stringify(routed.result),
+                    sessionRuntime: routed.runtime,
+                    ...(resolved ? { contextReceipt: resolved.receipt } : {}),
+                });
+            }
+            catch (error) {
+                throw mapSessionRuntimeError(error);
+            }
         });
     }
+    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.assertContextGuard(input);
         this.assertSettingsAvailable();
         const update = this.runtimeValue.updateSettings;
         if (!update) {
@@ -709,14 +1237,29 @@ class WebWorkbenchController {
         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();
-        });
+        const contextTransition = CONTEXT_TRANSITION_MUTATIONS.has(operation);
+        let result;
+        try {
+            this.reserveMutation(contextTransition);
+            result = Promise.resolve()
+                .then(() => {
+                this.assertMutationAdmission();
+                return action();
+            })
+                .finally(() => this.releaseMutation(contextTransition));
+        }
+        catch (error) {
+            // Mutation admission is part of the idempotent result contract. Cache a
+            // rejected Promise just like failures raised by the action so a retry of
+            // the same requestId cannot observe a different outcome.
+            result = Promise.reject(error);
+        }
         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;
@@ -725,7 +1268,7 @@ class WebWorkbenchController {
         const harness = activeSessionId
             ? ((await this.runtimeValue.getHarnessDiagnostics?.()) ?? null)
             : null;
-        return {
+        const result = {
             workspace: this.workspaceValue,
             activeSessionId,
             configured: this.runtimeValue.isConfigured,
@@ -743,20 +1286,233 @@ class WebWorkbenchController {
             mcp: { servers: mcpServerIds(mcp) },
             harness,
             eventStream: this.eventHub.snapshot(),
+            workspaceKernel: this.runtimeValue.workspaceRuntimeKernel?.diagnostics() ?? null,
+            performance: {
+                files: this.fileService.performanceCounters(),
+                git: this.gitService.performanceCounters(),
+                thread: {
+                    eventStore: (0, thread_event_store_1.threadEventStorePerformanceCountersV1)(),
+                    sessionIndex: (0, thread_session_index_1.threadSessionIndexPerformanceCountersV1)(),
+                },
+            },
         };
+        if (context)
+            this.assertContextGuard(context);
+        return result;
     }
     async shutdown() {
-        if (this.closed)
-            return;
+        if (this.shutdownResult)
+            return this.shutdownResult;
         this.closed = true;
-        await this.controllerValue.stopActiveTurn();
-        await this.controllerValue.waitForIdle();
-        this.closeWorkspaceWatchers();
-        await this.terminalManager.shutdown();
-        await this.runtimeValue.shutdown();
-        this.eventHub.close();
+        this.shutdownResult = this.shutdownOwnedResources();
+        return this.shutdownResult;
+    }
+    async shutdownOwnedResources() {
+        const failures = [];
+        this.workspaceMutations.close('Orion Web Workbench shutdown');
+        try {
+            await this.sessionRegistry.shutdown('Orion Web Workbench shutdown');
+        }
+        catch {
+            // The registry retains failed actor handles. Retry once after every
+            // actor received its first close attempt; a persistent failure remains
+            // an explicit Host shutdown error rather than an orphan hidden as GO.
+            try {
+                await this.sessionRegistry.shutdown('Orion Web Workbench shutdown retry');
+            }
+            catch (retryError) {
+                failures.push(retryError);
+            }
+        }
+        await captureShutdownFailure(failures, () => this.controllerValue.stopActiveTurn());
+        await captureShutdownFailure(failures, () => this.controllerValue.waitForIdle());
+        try {
+            this.closeWorkspaceWatchers();
+            this.closeComposerObserver();
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        await captureShutdownFailure(failures, () => this.terminalManager.shutdown());
+        await captureShutdownFailure(failures, () => this.runtimeValue.shutdown());
+        try {
+            this.eventHub.close();
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        this.workspaceMutationOwners.clear();
+        this.pendingWorkspaceMutationStates.clear();
+        if (failures.length > 0) {
+            throw new errors_1.WebWorkbenchError(503, `${failures.length} Web Workbench resource(s) could not be closed safely.`, 'workbench_shutdown_incomplete');
+        }
+    }
+    createSessionRegistry() {
+        return new session_runtime_registry_1.WebSessionRuntimeRegistryV1({
+            maxRunningSessions: 3,
+            maxResidentSessionActors: 4,
+            createActor: key => this.createSessionActor(key),
+            initializeActor: actor => actor.runtime.rebindSessionRuntime?.() ?? Promise.resolve(),
+            closeActor: (actor, reason) => this.closeSessionActor(actor, reason),
+            estimateActorBytes: actor => estimateSessionActorBytes(actor),
+            onSummaryChanged: runtime => {
+                if (this.closed || this.suppressContextEdges > 0)
+                    return;
+                this.eventHub.emit({ type: 'session_runtime_changed', runtime }, true, {
+                    sessionId: runtime.sessionId,
+                });
+            },
+        });
+    }
+    async createSessionActor(key) {
+        const workspace = this.workspaceRegistry.find(key.workspaceId);
+        if (!workspace) {
+            throw new errors_1.WebWorkbenchError(404, 'Workspace was not found.', 'workspace_not_found');
+        }
+        const session = requireSession(key.sessionId);
+        if (canonicalDirectory(session.projectPath) !== workspace.canonicalPath) {
+            throw new errors_1.WebWorkbenchError(409, 'Session belongs to another Workspace.', 'session_workspace_conflict');
+        }
+        const runtime = await this.createSessionRuntime(workspace.canonicalPath);
+        runtime.setSession(session);
+        const actorRef = {};
+        const eventSink = {
+            emit: (event) => this.emitSessionActorRuntimeEvent(key, runtime, actorRef.current, event),
+        };
+        const controller = new agent_runtime_controller_1.AgentRuntimeController({
+            runtime,
+            eventSink,
+            uiRenderer: 'web',
+            echoSubmittedInput: false,
+            useRuntimeToolPermissions: true,
+            uiCapabilities: {
+                structuredPickers: true,
+                inlineProgress: true,
+                suppressLegacyTokenMeta: true,
+                extraAssistantSpacing: true,
+                suppressAbortNotice: true,
+            },
+        });
+        const actor = {
+            key: Object.freeze({ ...key }),
+            runtime,
+            controller,
+            composerRevision: (0, crypto_1.randomUUID)(),
+            latestStatus: 'Ready',
+            suppressComposerEdges: 0,
+        };
+        actorRef.current = actor;
+        actor.composerStoreUnsubscribe = runtime.store.subscribe(() => this.scheduleActorComposerStateChanged(actor));
+        actor.composerControlsUnsubscribe = runtime.sessionComposerControls?.subscribe(() => this.scheduleActorComposerStateChanged(actor));
+        return actor;
+    }
+    async closeSessionActor(actor, _reason) {
+        if (actor.composerChangeTimer)
+            clearTimeout(actor.composerChangeTimer);
+        actor.composerChangeTimer = undefined;
+        actor.composerStoreUnsubscribe?.();
+        actor.composerControlsUnsubscribe?.();
+        actor.composerStoreUnsubscribe = undefined;
+        actor.composerControlsUnsubscribe = undefined;
+        await actor.controller.stopActiveTurn();
+        await actor.controller.waitForIdle();
+        await actor.runtime.shutdown();
+        this.activeOrionRuntimes.delete(actor.key.sessionId);
+        for (const [invocationId, owner] of this.workspaceMutationOwners) {
+            if (owner.sessionId === actor.key.sessionId && owner.workspaceId === actor.key.workspaceId) {
+                this.workspaceMutationOwners.delete(invocationId);
+                this.pendingWorkspaceMutationStates.delete(invocationId);
+            }
+        }
+    }
+    emitSessionActorRuntimeEvent(key, runtime, actor, event) {
+        if (event.type === 'status_changed' && actor)
+            actor.latestStatus = event.message;
+        if (event.type === 'followup_queue_changed') {
+            if (actor && actor.suppressComposerEdges === 0) {
+                this.publishActorComposerState(actor);
+            }
+            return undefined;
+        }
+        if (event.type === 'tool_started') {
+            this.workspaceMutationOwners.set(event.event.callId, Object.freeze({ ...key }));
+        }
+        const thread = this.activeOrionRuntimes.get(key.sessionId)?.thread.getProjection().threadId;
+        const envelope = this.eventHub.emitRuntime(event, {
+            sessionId: key.sessionId,
+            ...(thread ? { threadId: thread } : {}),
+        });
+        if (event.type === 'tool_started') {
+            const pendingMutation = this.pendingWorkspaceMutationStates.get(event.event.callId);
+            if (pendingMutation) {
+                this.pendingWorkspaceMutationStates.delete(event.event.callId);
+                this.emitWorkspaceMutationState(pendingMutation);
+            }
+        }
+        if (event.type === 'permission_requested' && actor) {
+            this.sessionRegistry.setPendingApprovalCount(key, actor.controller.getPendingPermissions().length);
+        }
+        if (event.type === 'tool_finished' && key.workspaceId === this.activeWorkspaceEntry().id) {
+            this.scheduleWorkspaceResourceInvalidation('tool-finished');
+        }
+        if (event.type === 'tool_finished') {
+            this.workspaceMutationOwners.delete(event.event.callId);
+            this.pendingWorkspaceMutationStates.delete(event.event.callId);
+        }
+        return event.type === 'transcript_append' ? `web-entry-${envelope.cursor}` : undefined;
+    }
+    emitWorkspaceMutationState(state) {
+        if (this.closed || this.suppressContextEdges > 0)
+            return;
+        const owner = this.workspaceMutationOwners.get(state.invocationId);
+        if (!owner) {
+            if (state.phase === 'queued' || state.phase === 'running') {
+                this.pendingWorkspaceMutationStates.set(state.invocationId, Object.freeze({ ...state }));
+            }
+            else {
+                this.pendingWorkspaceMutationStates.delete(state.invocationId);
+            }
+            return;
+        }
+        this.eventHub.emit({
+            type: 'workspace_mutation_changed',
+            state: {
+                callId: state.invocationId,
+                phase: state.phase,
+                ...(state.queuePosition === undefined ? {} : { queuePosition: state.queuePosition }),
+            },
+        }, false, { sessionId: owner.sessionId });
+        if (['completed', 'failed', 'cancelled'].includes(state.phase)) {
+            this.workspaceMutationOwners.delete(state.invocationId);
+            this.pendingWorkspaceMutationStates.delete(state.invocationId);
+        }
+    }
+    scheduleActorComposerStateChanged(actor) {
+        if (this.closed || actor.suppressComposerEdges > 0)
+            return;
+        if (actor.composerChangeTimer)
+            clearTimeout(actor.composerChangeTimer);
+        actor.composerChangeTimer = setTimeout(() => {
+            actor.composerChangeTimer = undefined;
+            if (this.closed || actor.suppressComposerEdges > 0)
+                return;
+            this.publishActorComposerState(actor);
+        }, 100);
+        actor.composerChangeTimer.unref();
+    }
+    publishActorComposerState(actor) {
+        try {
+            const state = this.projectActorComposerState(actor, requireSession(actor.key.sessionId));
+            this.eventHub.emit({ type: 'composer_state_changed', state }, true, {
+                sessionId: actor.key.sessionId,
+            });
+        }
+        catch {
+            // A concurrent actor teardown publishes its final Runtime summary.
+        }
     }
     async installRuntime(workspace, publishState = true) {
+        this.closeComposerObserver();
         const runtime = await this.createRuntime(workspace);
         this.closeWorkspaceWatchers();
         this.activeOrionRuntime = undefined;
@@ -775,6 +1531,21 @@ class WebWorkbenchController {
                 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;
@@ -806,6 +1577,10 @@ class WebWorkbenchController {
                 suppressAbortNotice: true,
             },
         });
+        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);
@@ -815,13 +1590,27 @@ class WebWorkbenchController {
             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)));
+            }
+            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) {
@@ -848,6 +1637,42 @@ class WebWorkbenchController {
         }, 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) {
@@ -929,6 +1754,7 @@ class WebWorkbenchController {
                 this.rememberSessionView(sessionId, activation.view);
             }
             this.activeOrionRuntime = { runtime, sessionId };
+            this.activeOrionRuntimes.set(sessionId, runtime);
         }
         catch (error) {
             unsubscribe();
@@ -938,6 +1764,9 @@ class WebWorkbenchController {
             unsubscribe();
             if (this.activeOrionRuntime?.runtime === runtime)
                 this.activeOrionRuntime = undefined;
+            if (this.activeOrionRuntimes.get(sessionId) === runtime) {
+                this.activeOrionRuntimes.delete(sessionId);
+            }
         };
     }
     loadSessionView(session, activeProjection) {
@@ -986,20 +1815,47 @@ class WebWorkbenchController {
     assertReadyForTransition(operation) {
         if (this.closed)
             throw new errors_1.WebWorkbenchError(503, 'Web Workbench is closed.');
-        if (this.transition || this.sessionTransition) {
+        if (this.transition || this.activeMutationCount > 0) {
             throw new errors_1.WebWorkbenchError(409, 'A workspace transition is running.', 'runtime_busy');
         }
         if (this.controllerValue.hasActiveTurn()) {
             throw new errors_1.WebWorkbenchError(409, `Cannot ${operation} while a turn is active.`, 'runtime_busy');
         }
+        const activeActor = this.sessionRegistry
+            .summaries()
+            .find(runtime => ['starting', 'queued', 'running', 'waiting_approval', 'stopping'].includes(runtime.phase));
+        if (activeActor) {
+            throw new errors_1.WebWorkbenchError(409, `Cannot ${operation} while Session ${activeActor.sessionId} is ${activeActor.phase}.`, 'runtime_busy');
+        }
     }
     assertMutationAdmission() {
         if (this.closed)
             throw new errors_1.WebWorkbenchError(503, 'Web Workbench is closed.');
-        if (this.transition || this.sessionTransition) {
+        if (this.transition) {
             throw new errors_1.WebWorkbenchError(409, 'A Context transition is running.', 'runtime_busy');
         }
     }
+    reserveMutation(contextTransition) {
+        this.assertMutationAdmission();
+        if (contextTransition) {
+            if (this.contextTransitionReserved || this.activeMutationCount > 0) {
+                throw new errors_1.WebWorkbenchError(409, 'Another mutation is still running.', 'runtime_busy');
+            }
+            this.contextTransitionReserved = true;
+            return;
+        }
+        if (this.contextTransitionReserved) {
+            throw new errors_1.WebWorkbenchError(409, 'A Context transition is being admitted.', 'runtime_busy');
+        }
+        this.activeMutationCount += 1;
+    }
+    releaseMutation(contextTransition) {
+        if (contextTransition) {
+            this.contextTransitionReserved = false;
+            return;
+        }
+        this.activeMutationCount = Math.max(0, this.activeMutationCount - 1);
+    }
     assertContextGuard(context) {
         this.assertMutationAdmission();
         if (context.expectedContextRevision !== this.contextRevisionValue ||
@@ -1010,13 +1866,25 @@ class WebWorkbenchController {
     assertCommandSession(expectedSessionId) {
         if (this.closed)
             throw new errors_1.WebWorkbenchError(503, 'Web Workbench is closed.');
-        if (this.transition || this.sessionTransition) {
+        if (this.transition) {
             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');
         }
     }
+    assertSessionWorkspace(session) {
+        if (canonicalDirectory(session.projectPath) !== this.workspaceValue) {
+            throw new errors_1.WebWorkbenchError(409, 'Session belongs to another Workspace.', 'session_workspace_conflict');
+        }
+    }
+    sessionActorKey(session) {
+        this.assertSessionWorkspace(session);
+        return Object.freeze({
+            workspaceId: this.activeWorkspaceEntry().id,
+            sessionId: session.id,
+        });
+    }
     assertSettingsAvailable() {
         if (this.closed) {
             throw new errors_1.WebWorkbenchError(503, 'Web Workbench is closed.', 'settings_document_unavailable');
@@ -1063,6 +1931,14 @@ function mapWorkspaceRegistryError(error) {
     }
     return new errors_1.WebWorkbenchError(503, 'Workspace registry is unavailable.');
 }
+function mapSessionRuntimeError(error) {
+    if (error instanceof errors_1.WebWorkbenchError)
+        return error;
+    if (error instanceof session_runtime_registry_1.WebSessionRuntimeRegistryError) {
+        return new errors_1.WebWorkbenchError(error.status, error.message, error.code);
+    }
+    throw error;
+}
 function mapSettingsError(error) {
     if (error instanceof errors_1.WebWorkbenchError)
         return error;
@@ -1071,6 +1947,53 @@ function mapSettingsError(error) {
     }
     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({
         body: receipt.plan,
@@ -1227,6 +2150,22 @@ function decodePageCursor(cursor) {
         throw new errors_1.WebWorkbenchError(400, 'Page cursor is invalid.');
     }
 }
+function estimateSessionActorBytes(actor) {
+    try {
+        return Math.max(256 * 1024, Buffer.byteLength(JSON.stringify(actor.runtime.store.getSnapshot()), 'utf8'));
+    }
+    catch {
+        return 256 * 1024;
+    }
+}
+async function captureShutdownFailure(failures, operation) {
+    try {
+        await operation();
+    }
+    catch (error) {
+        failures.push(error);
+    }
+}
 function canonicalDirectory(path) {
     const candidate = (0, path_1.resolve)(path);
     let canonical;