@orion-agents/orion-code 0.3.1 → 0.3.2

package/dist/web/workbench-controller.js

@@ -11,11 +11,14 @@ 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_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");
@@ -30,6 +33,8 @@ var errors_2 = require("./errors");
 Object.defineProperty(exports, "WebWorkbenchError", { enumerable: true, get: function () { return errors_2.WebWorkbenchError; } });
 const SESSION_VIEW_CACHE_BYTES = 16 * 1024 * 1024;
 const MAX_MUTATION_RESULTS = 4096;
+const MAX_CONTEXT_REFERENCE_BYTES = 64 * 1024;
+const MAX_CONTEXT_MANIFEST_BYTES = 256 * 1024;
 /** Owns the sole runtime/controller pair exposed through the local Web host. */
 class WebWorkbenchController {
     constructor(options) {
@@ -38,6 +43,8 @@ class WebWorkbenchController {
         this.sessionViewBytes = 0;
         this.toolDetails = new tool_detail_repository_1.FileToolDetailRepository();
         this.contextRevisionValue = (0, crypto_1.randomUUID)();
+        this.composerRevisionValue = (0, crypto_1.randomUUID)();
+        this.suppressComposerEdges = 0;
         this.suppressContextEdges = 0;
         this.latestStatus = 'Ready';
         this.sessionTransition = false;
@@ -131,18 +138,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 +165,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 +182,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 +202,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 +212,9 @@ class WebWorkbenchController {
             dirtyCount: status.totalFiles,
             conflictCount: status.conflicted.length,
         });
+        if (context)
+            this.assertContextGuard(context);
+        return result;
     }
     setWorkspacePinned(workspaceId, pinned, context) {
         this.assertContextGuard(context);
@@ -385,15 +402,206 @@ class WebWorkbenchController {
             pendingApprovals: Object.freeze(pendingPermissions),
             goal,
             plan,
+            composer: this.projectComposerState(session, active),
             recoveryDiagnostics: indexedPage ? [] : (view?.diagnostics ?? []),
         });
         if (context)
             this.assertContextGuard(context);
         return snapshot;
     }
-    async skills() {
+    composerState(sessionId, context) {
+        if (context)
+            this.assertContextGuard(context);
+        this.assertCommandSession(sessionId);
+        const session = requireSession(sessionId);
+        const state = this.projectComposerState(session, true);
+        if (context)
+            this.assertContextGuard(context);
+        return state;
+    }
+    projectComposerState(session, active) {
+        const state = this.projectComposerStateValue(session, active);
+        if (!active)
+            return state;
+        // Durable Thread and Store authority can advance before the debounced SSE
+        // observer runs. Keep every projected control state and its CAS token in
+        // the same synchronous boundary so the UI never receives new controls
+        // paired with an older revision.
+        const authorityDigest = composerAuthorityDigest(state);
+        if (this.composerAuthorityDigest === undefined) {
+            this.composerAuthorityDigest = authorityDigest;
+            return state;
+        }
+        if (authorityDigest === this.composerAuthorityDigest)
+            return state;
+        this.bumpComposerRevision();
+        this.composerAuthorityDigest = authorityDigest;
+        return Object.freeze({ ...state, controlRevision: this.composerRevisionValue });
+    }
+    projectComposerStateValue(session, active) {
+        const controls = this.runtimeValue.sessionComposerControls;
+        if (!controls) {
+            throw new errors_1.WebWorkbenchError(503, 'Session Composer controls are unavailable.', 'composer_controls_unavailable');
+        }
+        const runtime = controls.describeSession(session);
+        const queue = active
+            ? this.controllerValue.getFollowupQueueSnapshot()
+            : { items: [], limit: 16 };
+        const projection = active && this.activeOrionRuntime?.sessionId === session.id
+            ? this.activeOrionRuntime.runtime.thread.getProjection()
+            : undefined;
+        const review = projection?.planReview;
+        const workspace = this.activeWorkspaceEntry();
+        return Object.freeze({
+            apiVersion: protocol_1.WEB_API_VERSION,
+            workspaceId: workspace.id,
+            sessionId: session.id,
+            contextRevision: this.contextRevisionValue,
+            controlRevision: this.composerRevisionValue,
+            processing: active &&
+                (this.runtimeValue.store.getSnapshot().isProcessing || Boolean(projection?.activeTurnId)),
+            mode: active
+                ? Object.freeze({ ...this.controllerValue.getAgentModeSnapshot() })
+                : Object.freeze({ baseMode: 'interactive', pendingBaseMode: null }),
+            model: runtime.model,
+            permission: runtime.permission,
+            contextUsage: runtime.contextUsage,
+            compactAvailable: active && this.controllerValue.canCompactContext(),
+            pending: runtime.pending,
+            lastError: runtime.lastError,
+            planReview: review
+                ? Object.freeze({
+                    planDigest: review.planDigest,
+                    revision: review.revision,
+                    status: review.status,
+                    createdAt: review.createdAt,
+                    createdModel: review.createdModel,
+                    returnMode: review.returnMode,
+                    ...(review.resolvedAt === undefined ? {} : { resolvedAt: review.resolvedAt }),
+                })
+                : null,
+            queue: Object.freeze({
+                items: Object.freeze(queue.items.map(item => Object.freeze({ ...item }))),
+                limit: queue.limit,
+            }),
+        });
+    }
+    modelCatalog(sessionId, context) {
+        if (context)
+            this.assertContextGuard(context);
+        this.assertCommandSession(sessionId);
+        const controls = this.runtimeValue.sessionComposerControls;
+        if (!controls) {
+            throw new errors_1.WebWorkbenchError(503, 'Session model catalog is unavailable.', 'composer_controls_unavailable');
+        }
+        const catalog = controls.catalog();
+        if (context)
+            this.assertContextGuard(context);
+        return catalog;
+    }
+    async applyComposerAction(input) {
+        this.assertContextGuard(input);
+        this.assertCommandSession(input.expectedSessionId);
+        const admittedState = this.composerState(input.expectedSessionId);
+        if (input.expectedControlRevision !== admittedState.controlRevision) {
+            throw new errors_1.WebWorkbenchError(409, 'Composer controls changed before the action was admitted.', 'composer_control_conflict');
+        }
+        const controls = this.runtimeValue.sessionComposerControls;
+        if (!controls) {
+            throw new errors_1.WebWorkbenchError(503, 'Session Composer controls are unavailable.', 'composer_controls_unavailable');
+        }
+        let outcome = 'applied';
+        let detail;
+        let modelReceipt;
+        let permissionReceipt;
+        let planReviewReceipt;
+        this.suppressComposerEdges += 1;
+        try {
+            switch (input.type) {
+                case 'set_agent_mode': {
+                    const result = this.controllerValue.setAgentMode(input.mode);
+                    outcome =
+                        result.type === 'agent_mode_changed' && result.appliesFrom === 'next-logical-request'
+                            ? 'deferred'
+                            : 'applied';
+                    detail = JSON.stringify(result);
+                    break;
+                }
+                case 'set_permission_override':
+                    permissionReceipt = await controls.setPermissionOverride(input.value);
+                    outcome = permissionReceipt.appliesFrom === 'immediate' ? 'applied' : 'deferred';
+                    break;
+                case 'clear_permission_override':
+                    permissionReceipt = await controls.setPermissionOverride(null);
+                    outcome = permissionReceipt.appliesFrom === 'immediate' ? 'applied' : 'deferred';
+                    break;
+                case 'select_model':
+                    modelReceipt = await controls.selectModel({
+                        modelId: input.modelId,
+                        ...(input.effort ? { effort: input.effort } : {}),
+                    });
+                    outcome = modelReceipt.appliesFrom === 'next-logical-request' ? 'deferred' : 'applied';
+                    break;
+                case 'compact_context': {
+                    const result = await this.controllerValue.compactContext();
+                    if (result.status === 'rejected') {
+                        throw new errors_1.WebWorkbenchError(409, 'Context compact was rejected.', 'runtime_busy');
+                    }
+                    detail = JSON.stringify(result);
+                    break;
+                }
+                case 'edit_queue_item':
+                    detail = JSON.stringify(this.controllerValue.editFollowupQueueItem(input.itemId, input.expectedItemRevision, input.text));
+                    break;
+                case 'move_queue_item':
+                    detail = JSON.stringify(this.controllerValue.moveFollowupQueueItem(input.itemId, input.expectedItemRevision, input.targetIndex));
+                    break;
+                case 'remove_queue_item':
+                    detail = JSON.stringify(this.controllerValue.removeFollowupQueueItem(input.itemId, input.expectedItemRevision));
+                    break;
+                case 'review_plan': {
+                    planReviewReceipt = await this.controllerValue.reviewPlan({
+                        planDigest: input.planDigest,
+                        action: input.action,
+                        ...(input.feedback ? { feedback: input.feedback } : {}),
+                    });
+                    if (input.action === 'approve')
+                        this.controllerValue.setAgentMode('interactive');
+                    else if (input.action === 'continue')
+                        this.controllerValue.setAgentMode('plan');
+                    detail = JSON.stringify(planReviewReceipt.admission);
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            throw mapComposerControlError(error);
+        }
+        finally {
+            this.suppressComposerEdges -= 1;
+        }
+        this.bumpComposerRevision();
+        const state = this.projectComposerStateValue(requireSession(input.expectedSessionId), true);
+        this.composerAuthorityDigest = composerAuthorityDigest(state);
+        this.eventHub.emit({ type: 'composer_state_changed', state }, true, {
+            sessionId: input.expectedSessionId,
+        });
+        return Object.freeze({
+            requestId: input.requestId,
+            outcome,
+            controlRevision: this.composerRevisionValue,
+            state,
+            ...(modelReceipt ? { modelReceipt } : {}),
+            ...(permissionReceipt ? { permissionReceipt } : {}),
+            ...(planReviewReceipt ? { planReviewReceipt } : {}),
+            ...(detail ? { detail } : {}),
+        });
+    }
+    async skills(context) {
+        if (context)
+            this.assertContextGuard(context);
         const descriptors = (await this.runtimeValue.inspectSkills?.()) ?? [];
-        return Object.freeze(descriptors.map(descriptor => Object.freeze({
+        const result = Object.freeze(descriptors.map(descriptor => Object.freeze({
             id: descriptor.id,
             name: descriptor.name,
             description: descriptor.description,
@@ -404,8 +612,13 @@ class WebWorkbenchController {
             requestedCapabilities: Object.freeze([...descriptor.requestedCapabilities]),
             digest: descriptor.digest,
         })));
+        if (context)
+            this.assertContextGuard(context);
+        return result;
     }
-    mcp() {
+    mcp(context) {
+        if (context)
+            this.assertContextGuard(context);
         const descriptors = this.runtimeValue.inspectMcp?.() ?? [];
         let runtimeServers = new Map();
         try {
@@ -417,7 +630,7 @@ class WebWorkbenchController {
         catch {
             // A concurrent session transition may close the previous diagnostics graph.
         }
-        return Object.freeze(descriptors.map(descriptor => {
+        const result = Object.freeze(descriptors.map(descriptor => {
             const runtime = runtimeServers.get(descriptor.id);
             return Object.freeze({
                 id: descriptor.id,
@@ -435,20 +648,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);
@@ -648,16 +874,179 @@ class WebWorkbenchController {
     }
     dispatch(raw) {
         const command = (0, protocol_1.parseWebCommand)(raw);
-        return this.executeMutation(command.requestId, 'command', command, () => {
+        return this.executeMutation(command.requestId, 'command', command, async () => {
+            this.assertCommandSession(command.expectedSessionId);
+            const resolved = await this.resolveCommandContext(command);
             this.assertCommandSession(command.expectedSessionId);
-            const runtimeResult = this.controllerValue.handle((0, protocol_1.toAgentRuntimeInput)(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 } : {}) });
+            const runtimeResult = this.controllerValue.handle(runtimeInput);
             return Object.freeze({
                 requestId: command.requestId,
                 result: runtimeResult.type,
                 detail: JSON.stringify(runtimeResult),
+                ...(resolved ? { contextReceipt: resolved.receipt } : {}),
             });
         });
     }
+    async resolveCommandContext(command) {
+        const references = command.contextReferences ?? [];
+        if (references.length === 0)
+            return undefined;
+        if (command.type !== 'submit' && command.type !== 'queue_followup') {
+            throw new errors_1.WebWorkbenchError(400, 'Context references are valid only for submitted or queued messages.', 'context_reference_invalid');
+        }
+        const resolved = [];
+        let totalBytes = 0;
+        for (const reference of references) {
+            let entry;
+            try {
+                entry = await this.resolveContextReference(reference);
+            }
+            catch (error) {
+                throw mapContextReferenceError(error);
+            }
+            const bytes = Buffer.byteLength(JSON.stringify(entry), 'utf8');
+            if (bytes > MAX_CONTEXT_REFERENCE_BYTES) {
+                throw new errors_1.WebWorkbenchError(413, 'A Context reference exceeds the per-reference byte budget.', 'context_reference_too_large');
+            }
+            totalBytes += bytes;
+            if (totalBytes > MAX_CONTEXT_MANIFEST_BYTES) {
+                throw new errors_1.WebWorkbenchError(413, 'Context references exceed the request byte budget.', 'context_reference_too_large');
+            }
+            resolved.push(Object.freeze(entry));
+        }
+        const manifestContent = Object.freeze({
+            version: 1,
+            references: Object.freeze(resolved),
+        });
+        const manifestDigest = (0, canonical_1.digestRuntimeValue)(manifestContent);
+        const manifest = Object.freeze({ ...manifestContent, manifestDigest });
+        return Object.freeze({
+            text: [
+                command.text.trim(),
+                '',
+                '[Orion Context Manifest V1]',
+                JSON.stringify(manifest),
+            ].join('\n'),
+            receipt: Object.freeze({
+                manifestDigest,
+                referenceCount: resolved.length,
+                totalBytes,
+            }),
+        });
+    }
+    async resolveContextReference(reference) {
+        switch (reference.kind) {
+            case 'file': {
+                const page = this.fileService.readContent({
+                    fileId: reference.id,
+                    limitBytes: MAX_CONTEXT_REFERENCE_BYTES,
+                });
+                if (page.revision !== reference.revision) {
+                    throw new errors_1.WebWorkbenchError(409, 'Referenced file changed.', 'context_reference_stale');
+                }
+                if (page.binary || page.content === undefined) {
+                    throw new errors_1.WebWorkbenchError(403, 'Binary files cannot be added to model Context.', 'context_reference_forbidden');
+                }
+                return {
+                    kind: 'file',
+                    id: reference.id,
+                    label: this.sanitizeContextText(page.name),
+                    revision: page.revision,
+                    content: this.sanitizeContextText(page.content),
+                    truncated: page.nextCursor !== null,
+                };
+            }
+            case 'folder': {
+                const page = this.fileService.list({ parentId: reference.id, pageSize: 100 });
+                if (page.revision !== reference.revision) {
+                    throw new errors_1.WebWorkbenchError(409, 'Referenced folder changed.', 'context_reference_stale');
+                }
+                return {
+                    kind: 'folder',
+                    id: reference.id,
+                    label: this.sanitizeContextText(reference.label),
+                    revision: page.revision,
+                    entries: page.items
+                        .filter(item => !item.sensitive)
+                        .map(item => ({
+                        name: this.sanitizeContextText(item.name),
+                        kind: item.kind,
+                        sizeBytes: item.sizeBytes ?? null,
+                    })),
+                    truncated: page.nextCursor !== null,
+                };
+            }
+            case 'review': {
+                const snapshot = await this.reviewService.snapshot();
+                if (snapshot.repositoryRevision !== reference.gitRevision) {
+                    throw new errors_1.WebWorkbenchError(409, 'Referenced Review changed.', 'context_reference_stale');
+                }
+                return {
+                    kind: 'review',
+                    id: reference.id,
+                    revision: snapshot.repositoryRevision,
+                    clean: snapshot.clean,
+                    files: snapshot.changedFiles.slice(0, 100).map(file => ({
+                        id: file.fileId,
+                        path: this.sanitizeContextText(file.path),
+                        indexStatus: file.indexStatus,
+                        worktreeStatus: file.worktreeStatus,
+                    })),
+                    truncated: snapshot.truncated || snapshot.changedFiles.length > 100,
+                };
+            }
+            case 'session': {
+                const session = requireSession(reference.id);
+                if (canonicalDirectory(session.projectPath) !== this.workspaceValue) {
+                    throw new errors_1.WebWorkbenchError(403, 'Referenced Session belongs to another Workspace.', 'context_reference_forbidden');
+                }
+                const summary = (0, protocol_1.projectSessionSummary)(session);
+                if (summary.contextDigest !== reference.digest) {
+                    throw new errors_1.WebWorkbenchError(409, 'Referenced Session changed.', 'context_reference_stale');
+                }
+                const page = (0, thread_session_view_1.loadThreadSessionSnapshotPageV1)(this.workspaceValue, session.id, undefined, 8);
+                return {
+                    kind: 'session',
+                    id: session.id,
+                    label: this.sanitizeContextText(session.name?.trim() || `Session ${session.id.slice(0, 8)}`),
+                    digest: summary.contextDigest,
+                    messages: (page?.transcript.items ?? []).map(message => ({
+                        role: message.role,
+                        content: this.sanitizeContextText(message.content),
+                    })),
+                    truncated: Boolean(page?.transcript.nextCursor),
+                };
+            }
+            case 'skill': {
+                const descriptor = ((await this.runtimeValue.inspectSkills?.()) ?? []).find(skill => skill.id === reference.id);
+                if (!descriptor || descriptor.digest !== reference.digest) {
+                    throw new errors_1.WebWorkbenchError(409, 'Referenced Skill changed.', 'context_reference_stale');
+                }
+                if (!descriptor.userInvocable) {
+                    throw new errors_1.WebWorkbenchError(403, 'Referenced Skill is not user-invocable.', 'context_reference_forbidden');
+                }
+                return {
+                    kind: 'skill',
+                    id: descriptor.id,
+                    label: this.sanitizeContextText(descriptor.name),
+                    digest: descriptor.digest,
+                    invocation: `$${descriptor.id}`,
+                    description: this.sanitizeContextText(descriptor.description),
+                };
+            }
+        }
+    }
+    sanitizeContextText(value) {
+        return (0, redaction_1.redactTraceText)(value).split(this.workspaceValue).join('<workspace>');
+    }
     async updateSettings(input) {
         this.assertSettingsAvailable();
         const update = this.runtimeValue.updateSettings;
@@ -716,7 +1105,9 @@ class WebWorkbenchController {
         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 +1116,7 @@ class WebWorkbenchController {
         const harness = activeSessionId
             ? ((await this.runtimeValue.getHarnessDiagnostics?.()) ?? null)
             : null;
-        return {
+        const result = {
             workspace: this.workspaceValue,
             activeSessionId,
             configured: this.runtimeValue.isConfigured,
@@ -743,7 +1134,14 @@ class WebWorkbenchController {
             mcp: { servers: mcpServerIds(mcp) },
             harness,
             eventStream: this.eventHub.snapshot(),
+            performance: {
+                files: this.fileService.performanceCounters(),
+                git: this.gitService.performanceCounters(),
+            },
         };
+        if (context)
+            this.assertContextGuard(context);
+        return result;
     }
     async shutdown() {
         if (this.closed)
@@ -752,11 +1150,13 @@ class WebWorkbenchController {
         await this.controllerValue.stopActiveTurn();
         await this.controllerValue.waitForIdle();
         this.closeWorkspaceWatchers();
+        this.closeComposerObserver();
         await this.terminalManager.shutdown();
         await this.runtimeValue.shutdown();
         this.eventHub.close();
     }
     async installRuntime(workspace, publishState = true) {
+        this.closeComposerObserver();
         const runtime = await this.createRuntime(workspace);
         this.closeWorkspaceWatchers();
         this.activeOrionRuntime = undefined;
@@ -775,6 +1175,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 +1221,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 +1234,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), true));
+            }
+            catch {
+                this.composerAuthorityDigest = undefined;
+            }
+        }
+        else {
+            this.composerAuthorityDigest = undefined;
+        }
         this.eventHub.emit({
             type: 'workbench_state',
             contextRevision: this.contextRevisionValue,
             workspaceId: workspace.id,
             workspace: this.workspaceValue,
-            activeSessionId: this.runtimeValue.getSession()?.id ?? null,
+            activeSessionId: sessionId,
         });
     }
     emitWorkspaceResourceInvalidation(reason) {
@@ -848,6 +1281,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) {
@@ -1071,6 +1540,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,