@orion-agents/orion-code 0.3.1 → 0.3.4

package/dist/web/file-read-service.js

@@ -32,17 +32,22 @@ class FileReadServiceV1 {
         this.secret = (0, crypto_1.randomBytes)(32);
         this.pathById = new Map([[ROOT_NODE_ID, '']]);
         this.idByPath = new Map([['', ROOT_NODE_ID]]);
+        this.performance = { readOperations: 0, bytesRead: 0, itemsParsed: 0 };
         this.root = canonicalDirectory(workspace);
     }
     get rootId() {
         return ROOT_NODE_ID;
     }
+    performanceCounters() {
+        return Object.freeze({ ...this.performance });
+    }
     identifyRelativePath(relativePath) {
         const normalized = normalizeRelativePath(relativePath);
         this.resolveRelative(normalized);
         return this.remember(normalized);
     }
     list(input = {}) {
+        this.performance.readOperations += 1;
         const parentId = input.parentId ?? ROOT_NODE_ID;
         const pageSize = boundedPageSize(input.pageSize ?? DEFAULT_PAGE_SIZE);
         const parent = this.resolveNode(parentId);
@@ -62,6 +67,7 @@ class FileReadServiceV1 {
                 const entry = directory.readSync();
                 if (!entry)
                     break;
+                this.performance.itemsParsed += 1;
                 if (IGNORED_NAMES.has(entry.name))
                     continue;
                 if (visibleIndex < offset) {
@@ -102,12 +108,13 @@ class FileReadServiceV1 {
         });
     }
     readContent(input) {
+        this.performance.readOperations += 1;
         const limitBytes = boundedContentBytes(input.limitBytes ?? DEFAULT_CONTENT_BYTES);
         const node = this.resolveNode(input.fileId);
         if (!node.stat.isFile()) {
             throw new errors_1.WebWorkbenchError(409, 'File node is not a regular file.', 'file_not_regular');
         }
-        const sensitive = (0, redaction_1.isSensitiveFilePath)(node.relativePath);
+        const sensitive = isSensitiveResolvedPath(this.root, node.relativePath, node.canonicalPath);
         if (sensitive) {
             throw new errors_1.WebWorkbenchError(403, 'Sensitive file content is not available in the Web Workbench.', 'sensitive_file_blocked');
         }
@@ -125,8 +132,9 @@ class FileReadServiceV1 {
                 throw new errors_1.WebWorkbenchError(409, 'File changed before it was read.', 'file_revision_conflict');
             }
             const sample = Buffer.alloc(Math.min(8192, Number(before.size)));
-            if (sample.length > 0)
-                (0, fs_1.readSync)(descriptor, sample, 0, sample.length, 0);
+            if (sample.length > 0) {
+                this.performance.bytesRead += (0, fs_1.readSync)(descriptor, sample, 0, sample.length, 0);
+            }
             const binary = isBinary(sample);
             if (binary) {
                 return Object.freeze({
@@ -143,6 +151,20 @@ class FileReadServiceV1 {
             }
             const remaining = Math.max(0, Number(before.size) - offset);
             const page = readLineSafePage(descriptor, offset, remaining, limitBytes);
+            this.performance.bytesRead += page.bytesRead;
+            if (isBinary(page.content)) {
+                return Object.freeze({
+                    fileId: input.fileId,
+                    name: (0, path_1.basename)(node.relativePath),
+                    revision,
+                    sizeBytes: Number(before.size),
+                    binary: true,
+                    sensitive: false,
+                    mediaType: 'application/octet-stream',
+                    offsetBytes: offset,
+                    nextCursor: null,
+                });
+            }
             const contentBuffer = validUtf8Prefix(page.content);
             if (page.consumedBytes > 0 && contentBuffer.length === 0) {
                 throw new errors_1.WebWorkbenchError(415, 'File is not valid UTF-8 text.', 'file_binary');
@@ -183,24 +205,32 @@ class FileReadServiceV1 {
         const symlink = lexicalStat.isSymbolicLink();
         let readable = true;
         let effectiveStat = lexicalStat;
-        if (symlink) {
-            try {
-                const canonicalPath = (0, fs_1.realpathSync)(lexicalPath);
-                readable = isWithinRoot(canonicalPath, this.root);
-                if (readable)
-                    effectiveStat = (0, fs_1.statSync)(canonicalPath, { bigint: true });
-            }
-            catch {
-                readable = false;
-            }
+        let canonicalPath;
+        try {
+            canonicalPath = (0, fs_1.realpathSync)(lexicalPath);
+            readable = isWithinRoot(canonicalPath, this.root);
+            if (readable)
+                effectiveStat = (0, fs_1.statSync)(canonicalPath, { bigint: true });
         }
+        catch {
+            readable = false;
+        }
+        const targetKind = readable
+            ? effectiveStat.isDirectory()
+                ? 'directory'
+                : effectiveStat.isFile()
+                    ? 'file'
+                    : undefined
+            : undefined;
         return Object.freeze({
             id: this.remember(relativePath),
             name: (0, path_1.basename)(relativePath),
+            displayPath: normalizeRelativePath(relativePath),
             kind: symlink ? 'symlink' : effectiveStat.isDirectory() ? 'directory' : 'file',
+            ...(symlink && targetKind ? { targetKind } : {}),
             ...(effectiveStat.isFile() ? { sizeBytes: Number(effectiveStat.size) } : {}),
             modifiedAt: new Date(Number(effectiveStat.mtimeMs)).toISOString(),
-            sensitive: (0, redaction_1.isSensitiveFilePath)(relativePath),
+            sensitive: isSensitiveResolvedPath(this.root, relativePath, canonicalPath),
             readable,
         });
     }
@@ -299,7 +329,7 @@ class FileReadServiceV1 {
 exports.FileReadServiceV1 = FileReadServiceV1;
 function readLineSafePage(descriptor, offset, remaining, requestedBytes) {
     if (remaining === 0)
-        return { content: Buffer.alloc(0), consumedBytes: 0 };
+        return { content: Buffer.alloc(0), consumedBytes: 0, bytesRead: 0 };
     // Redaction rules are label-aware. Never split a logical line across pages or a caller could
     // request `token=` and its value in separate pages. A line larger than the bounded service
     // budget fails closed instead of returning an unsafe fragment.
@@ -310,19 +340,19 @@ function readLineSafePage(descriptor, offset, remaining, requestedBytes) {
     const target = Math.min(requestedBytes, bytesRead);
     const atEnd = offset + bytesRead >= offset + remaining;
     if (target === bytesRead && atEnd)
-        return { content, consumedBytes: bytesRead };
+        return { content, consumedBytes: bytesRead, bytesRead };
     const lastNewline = content.lastIndexOf(0x0a, Math.max(0, target - 1));
     if (lastNewline >= 0) {
         const consumedBytes = lastNewline + 1;
-        return { content: content.subarray(0, consumedBytes), consumedBytes };
+        return { content: content.subarray(0, consumedBytes), consumedBytes, bytesRead };
     }
     const nextNewline = content.indexOf(0x0a, target);
     if (nextNewline >= 0) {
         const consumedBytes = nextNewline + 1;
-        return { content: content.subarray(0, consumedBytes), consumedBytes };
+        return { content: content.subarray(0, consumedBytes), consumedBytes, bytesRead };
     }
     if (atEnd)
-        return { content, consumedBytes: bytesRead };
+        return { content, consumedBytes: bytesRead, bytesRead };
     throw new errors_1.WebWorkbenchError(413, 'A text line exceeds the safe Web preview limit.', 'file_line_too_long');
 }
 function canonicalDirectory(path) {
@@ -350,6 +380,13 @@ function isWithinRoot(candidate, root) {
     const rel = (0, path_1.relative)(root, candidate);
     return rel === '' || (!rel.startsWith(`..${path_1.sep}`) && rel !== '..' && !(0, path_1.isAbsolute)(rel));
 }
+function isSensitiveResolvedPath(root, aliasRelativePath, canonicalPath) {
+    if ((0, redaction_1.isSensitiveFilePath)(aliasRelativePath))
+        return true;
+    if (!canonicalPath || !isWithinRoot(canonicalPath, root))
+        return false;
+    return (0, redaction_1.isSensitiveFilePath)((0, path_1.relative)(root, canonicalPath));
+}
 function fingerprintStat(stat) {
     return (0, crypto_1.createHash)('sha256')
         .update([stat.dev, stat.ino, stat.mode, stat.size, stat.mtimeNs, stat.ctimeNs]

package/dist/web/git-read-model-service.d.ts

@@ -45,13 +45,21 @@ export interface WebGitDiffPageV1 {
     readonly nextCursor: string | null;
     readonly truncated: boolean;
 }
+export interface WebGitPerformanceCountersV1 {
+    readonly processCount: number;
+    readonly bytesRead: number;
+    readonly itemsParsed: number;
+}
 /** Bounded argv-only Git status/log/diff projection for one active Workspace. */
 export declare class GitReadModelServiceV1 {
     private readonly workspace;
     private readonly secret;
     private readonly pathById;
     private readonly idByPath;
+    private repositoryRoot?;
+    private readonly performance;
     constructor(workspace: string);
+    performanceCounters(): WebGitPerformanceCountersV1;
     status(input?: {
         readonly cursor?: string;
         readonly pageSize?: number;

package/dist/web/git-read-model-service.js

@@ -24,8 +24,12 @@ class GitReadModelServiceV1 {
         this.secret = (0, crypto_1.randomBytes)(32);
         this.pathById = new Map();
         this.idByPath = new Map();
+        this.performance = { processCount: 0, bytesRead: 0, itemsParsed: 0 };
         this.workspace = canonicalDirectory(workspace);
     }
+    performanceCounters() {
+        return Object.freeze({ ...this.performance });
+    }
     async status(input = {}) {
         const snapshot = await this.capture();
         const pageSize = boundedInteger(input.pageSize ?? DEFAULT_STATUS_PAGE_SIZE, 1, MAX_STATUS_PAGE_SIZE, 'pageSize');
@@ -90,6 +94,7 @@ class GitReadModelServiceV1 {
             .map(record => record.replace(/^\s+/u, '').replace(/\s+$/u, ''))
             .filter(Boolean)
             .map(parseCommit);
+        this.performance.itemsParsed += commits.length;
         const hasMore = commits.length > pageSize;
         const items = commits.slice(0, pageSize);
         return Object.freeze({
@@ -117,6 +122,9 @@ class GitReadModelServiceV1 {
         if (!record) {
             throw new errors_1.WebWorkbenchError(409, 'Git file changed before diff.', 'git_revision_conflict');
         }
+        if (isSensitiveGitRecord(record)) {
+            throw new errors_1.WebWorkbenchError(403, 'Sensitive file content is not available in the Web Workbench.', 'sensitive_file_blocked');
+        }
         const lineLimit = boundedInteger(input.lineLimit ?? DEFAULT_DIFF_LINES, 1, MAX_DIFF_LINES, 'lineLimit');
         const byteLimit = boundedInteger(input.byteLimit ?? DEFAULT_DIFF_BYTES, 1024, MAX_DIFF_BYTES, 'byteLimit');
         const offset = input.cursor
@@ -129,7 +137,14 @@ class GitReadModelServiceV1 {
             offset,
             lineLimit,
             byteLimit,
+            onProcess: () => {
+                this.performance.processCount += 1;
+            },
+            onBytes: bytes => {
+                this.performance.bytesRead += bytes;
+            },
         });
+        this.performance.itemsParsed += page.linesParsed;
         if (page.hasMore && page.returnedLines === 0) {
             throw new errors_1.WebWorkbenchError(500, 'Git diff pagination could not advance.', 'git_pagination_stalled');
         }
@@ -160,9 +175,12 @@ class GitReadModelServiceV1 {
     async capture() {
         let root;
         try {
-            root = (0, fs_1.realpathSync)((await this.runGit(['rev-parse', '--show-toplevel'], this.workspace)).trim());
+            root =
+                this.repositoryRoot ??
+                    (0, fs_1.realpathSync)((await this.runGit(['rev-parse', '--show-toplevel'], this.workspace)).trim());
             if (!isWithinRoot(root, this.workspace))
                 throw new Error('repository root escaped workspace');
+            this.repositoryRoot = root;
         }
         catch {
             const revision = (0, crypto_1.createHash)('sha256').update(`not-git:${this.workspace}`).digest('hex');
@@ -196,6 +214,7 @@ class GitReadModelServiceV1 {
             behind = Number.isSafeInteger(behindValue) ? behindValue : 0;
         }
         const records = parsePorcelainV1(rawStatus);
+        this.performance.itemsParsed += records.length;
         const fileFingerprints = records.map(record => fingerprintWorktreePath(root, record.path));
         const revision = (0, crypto_1.createHash)('sha256')
             .update(JSON.stringify({
@@ -245,6 +264,7 @@ class GitReadModelServiceV1 {
     }
     runGit(args, cwd) {
         return new Promise((resolvePromise, reject) => {
+            this.performance.processCount += 1;
             (0, child_process_1.execFile)('git', [...hardenedGitPrefix(), ...args], {
                 cwd,
                 encoding: 'utf8',
@@ -252,6 +272,8 @@ class GitReadModelServiceV1 {
                 maxBuffer: GIT_MAX_BUFFER,
                 env: gitEnvironment(),
             }, (error, stdout, stderr) => {
+                this.performance.bytesRead +=
+                    Buffer.byteLength(stdout, 'utf8') + Buffer.byteLength(stderr, 'utf8');
                 if (error) {
                     const processError = error;
                     const timedOut = processError.code === 'ETIMEDOUT' ||
@@ -421,13 +443,19 @@ function isConflictRecord(record) {
         `${record.indexStatus}${record.worktreeStatus}` === 'AA' ||
         `${record.indexStatus}${record.worktreeStatus}` === 'DD');
 }
+function isSensitiveGitRecord(record) {
+    return ((0, redaction_1.isSensitiveFilePath)(record.path) ||
+        (record.renamedFrom !== undefined && (0, redaction_1.isSensitiveFilePath)(record.renamedFrom)));
+}
 async function streamDiffPage(input) {
     const lines = [];
     let virtualLine = 0;
     let bytes = 0;
     let hasMore = false;
     let oversizedLine = false;
+    let linesParsed = 0;
     const acceptLine = (raw) => {
+        linesParsed += 1;
         const line = (0, redaction_1.redactTraceText)(raw.split(input.cwd).join('[WORKSPACE]'));
         const lineBytes = Buffer.byteLength(line, 'utf8') + 1;
         if (lineBytes > input.byteLimit) {
@@ -455,6 +483,8 @@ async function streamDiffPage(input) {
             args: command.args,
             acceptedExitCodes: command.acceptedExitCodes ?? [0],
             onLine: acceptLine,
+            onProcess: input.onProcess,
+            onBytes: input.onBytes,
         });
         if (!completed) {
             hasMore = true;
@@ -464,10 +494,11 @@ async function streamDiffPage(input) {
     if (oversizedLine) {
         throw new errors_1.WebWorkbenchError(413, 'A Git diff line exceeds the bounded page size.', 'git_line_too_long');
     }
-    return Object.freeze({ lines, returnedLines: lines.length, hasMore });
+    return Object.freeze({ lines, returnedLines: lines.length, hasMore, linesParsed });
 }
 function streamGitLines(input) {
     return new Promise((resolvePromise, reject) => {
+        input.onProcess();
         const child = (0, child_process_1.spawn)('git', [...hardenedGitPrefix(), ...input.args], {
             cwd: input.cwd,
             env: gitEnvironment(),
@@ -487,6 +518,7 @@ function streamGitLines(input) {
         timer.unref();
         child.stdout.setEncoding('utf8');
         child.stdout.on('data', (chunk) => {
+            input.onBytes(Buffer.byteLength(chunk, 'utf8'));
             if (paginationStopped || timedOut || outputTooLarge)
                 return;
             outputBytes += Buffer.byteLength(chunk, 'utf8');
@@ -514,6 +546,7 @@ function streamGitLines(input) {
         });
         child.stderr.setEncoding('utf8');
         child.stderr.on('data', (chunk) => {
+            input.onBytes(Buffer.byteLength(chunk, 'utf8'));
             outputBytes += Buffer.byteLength(chunk, 'utf8');
             if (outputBytes > GIT_MAX_BUFFER && !outputTooLarge) {
                 outputTooLarge = true;

package/dist/web/protocol.d.ts

@@ -2,12 +2,15 @@ import type { AgentRuntimeEvent } from '../runtime/agent-runtime-protocol';
 import type { AgentRuntimeControllerInput } from '../runtime/agent-runtime-controller';
 import type { GoalRuntimeControlV2 } from '../runtime/goal-runtime-coordinator';
 import type { RuntimeEventEnvelopeV1 } from '../runtime/protocol/runtime-protocol-v1';
+import type { PlanReviewResolutionReceiptV1 } from '../runtime/plan-review';
+import type { SessionComposerRuntimeStateV1, SessionModelCatalogEntryV1, SessionModelSwitchReceiptV1, SessionPermissionReceiptV1 } from '../runtime/session-composer-control';
 import type { ToolDetailPage, ToolDetailSummary } from '../runtime/tool-detail-repository';
 import type { SessionMeta } from '../services/session-storage';
 import type { ToolConfirmationPolicy } from '../services/global-config';
 import type { WebFileContentPageV1, WebFileNodeV1, WebFileTreePageV1 } from './file-read-service';
 import type { WebGitCommitV1, WebGitDiffPageV1, WebGitFileV1, WebGitLogPageV1, WebGitStatusV1 } from './git-read-model-service';
 import type { WebReviewSnapshotV1, WebReviewVerificationV1 } from './review-service';
+import type { WebSessionRuntimeSummaryV1 } from './session-runtime-registry';
 import type { WebTerminalCreateResultV1, WebTerminalExitV1, WebTerminalGapV1, WebTerminalMetadataV1, WebTerminalOutputFrameV1, WebTerminalStateV1 } from './terminal-manager';
 export declare const WEB_API_VERSION: 1;
 export declare const WEB_NONCE_HEADER = "x-orion-web-nonce";
@@ -24,6 +27,7 @@ export type WebSettingsAppliesV1 = 'live' | 'next-logical-request' | 'new-sessio
 export type WebSettingsStateV1 = 'ready' | 'invalid' | 'read-only' | 'unavailable';
 export type WebThemePreferenceV1 = 'system' | 'light' | 'dark';
 export type WebMotionPreferenceV1 = 'system' | 'reduced';
+export type WebUiStylePreferenceV1 = 'classic' | 'orion-blocksmith';
 export type WebEffortPreferenceV1 = 'auto' | 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
 export interface WebSettingsFieldViewV1<T> {
     readonly effectiveValue: T;
@@ -43,7 +47,7 @@ export interface WebCredentialSlotViewV1 {
     readonly writable: false;
 }
 export interface WebSettingsDocumentV1 {
-    readonly schemaVersion: 1;
+    readonly schemaVersion: 2;
     readonly revision: string;
     readonly state: WebSettingsStateV1;
     readonly writable: boolean;
@@ -51,6 +55,7 @@ export interface WebSettingsDocumentV1 {
     readonly workspace: string;
     readonly sections: {
         readonly appearance: {
+            readonly style: WebSettingsFieldViewV1<WebUiStylePreferenceV1>;
             readonly theme: WebSettingsFieldViewV1<WebThemePreferenceV1>;
             readonly motion: WebSettingsFieldViewV1<WebMotionPreferenceV1>;
         };
@@ -76,8 +81,15 @@ export interface WebSettingsDocumentV1 {
 }
 /** Compatibility name retained inside the unreleased v0.3 Web implementation. */
 export type WebSettingsSnapshotV1 = WebSettingsDocumentV1;
-export type WebSettingsKeyV1 = 'appearance.theme' | 'appearance.motion' | 'defaults.model' | 'defaults.effort' | 'permissions.toolConfirmation';
+export type WebSettingsKeyV1 = 'appearance.style' | 'appearance.theme' | 'appearance.motion' | 'defaults.model' | 'defaults.effort' | 'permissions.toolConfirmation';
 export type WebSettingsOperationV1 = {
+    readonly op: 'set';
+    readonly key: 'appearance.style';
+    readonly value: WebUiStylePreferenceV1;
+} | {
+    readonly op: 'unset';
+    readonly key: 'appearance.style';
+} | {
     readonly op: 'set';
     readonly key: 'appearance.theme';
     readonly value: WebThemePreferenceV1;
@@ -115,6 +127,8 @@ export type WebSettingsOperationV1 = {
 };
 export interface WebSettingsUpdateRequestV1 {
     readonly requestId: string;
+    readonly workspaceId: string;
+    readonly expectedContextRevision: string;
     readonly expectedRevision: string;
     readonly operations: readonly WebSettingsOperationV1[];
 }
@@ -152,9 +166,133 @@ export interface WebPlanViewV1 {
     readonly returnMode: 'build' | 'auto';
     readonly digest: string;
 }
+export type WebContextReferenceV1 = {
+    readonly kind: 'file';
+    readonly id: string;
+    readonly label: string;
+    readonly revision: string;
+} | {
+    readonly kind: 'folder';
+    readonly id: string;
+    readonly label: string;
+    readonly revision: string;
+} | {
+    readonly kind: 'review';
+    readonly id: string;
+    readonly label: string;
+    readonly gitRevision: string;
+} | {
+    readonly kind: 'session';
+    readonly id: string;
+    readonly label: string;
+    readonly digest: string;
+} | {
+    readonly kind: 'skill';
+    readonly id: string;
+    readonly label: string;
+    readonly digest: string;
+};
+export interface WebPlanReviewViewV1 {
+    readonly planDigest: string;
+    readonly revision: string;
+    readonly status: 'awaiting_review' | 'approved' | 'continued' | 'cancelled';
+    readonly createdAt: number;
+    readonly createdModel: string;
+    readonly returnMode: 'build' | 'auto';
+    readonly resolvedAt?: number;
+}
+export interface WebComposerControlStateV1 {
+    readonly apiVersion: 1;
+    readonly workspaceId: string;
+    readonly sessionId: string;
+    readonly contextRevision: string;
+    readonly controlRevision: string;
+    readonly sessionRuntime: WebSessionRuntimeSummaryV1;
+    readonly processing: boolean;
+    readonly mode: {
+        readonly baseMode: 'interactive' | 'plan' | 'auto';
+        readonly pendingBaseMode: 'interactive' | 'plan' | 'auto' | null;
+    };
+    readonly model: SessionComposerRuntimeStateV1['model'];
+    readonly permission: SessionComposerRuntimeStateV1['permission'];
+    readonly contextUsage: SessionComposerRuntimeStateV1['contextUsage'];
+    readonly compactAvailable: boolean;
+    readonly pending: SessionComposerRuntimeStateV1['pending'];
+    readonly lastError: SessionComposerRuntimeStateV1['lastError'];
+    readonly planReview: WebPlanReviewViewV1 | null;
+    readonly queue: {
+        readonly items: readonly {
+            readonly id: string;
+            readonly text: string;
+            readonly queuedAt: number;
+            readonly revision: number;
+        }[];
+        readonly limit: number;
+    };
+}
+export interface WebModelCatalogPageV1 extends WebPageV1<SessionModelCatalogEntryV1> {
+    readonly revision: string;
+    readonly unavailableProviders: readonly {
+        readonly id: string;
+        readonly reason: string;
+    }[];
+}
+interface WebComposerActionBaseV1 {
+    readonly requestId: string;
+    readonly workspaceId: string;
+    readonly expectedContextRevision: string;
+    readonly expectedSessionId: string;
+    readonly expectedSessionRuntimeRevision: string;
+    readonly expectedControlRevision: string;
+}
+export type WebComposerActionV1 = WebComposerActionBaseV1 & ({
+    readonly type: 'set_agent_mode';
+    readonly mode: 'interactive' | 'plan' | 'auto';
+} | {
+    readonly type: 'set_permission_override';
+    readonly value: ToolConfirmationPolicy;
+} | {
+    readonly type: 'clear_permission_override';
+} | {
+    readonly type: 'select_model';
+    readonly modelId: string;
+    readonly effort?: WebEffortPreferenceV1;
+} | {
+    readonly type: 'compact_context';
+} | {
+    readonly type: 'review_plan';
+    readonly planDigest: string;
+    readonly action: 'approve' | 'continue' | 'cancel';
+    readonly feedback?: string;
+} | {
+    readonly type: 'edit_queue_item';
+    readonly itemId: string;
+    readonly expectedItemRevision: number;
+    readonly text: string;
+} | {
+    readonly type: 'move_queue_item';
+    readonly itemId: string;
+    readonly expectedItemRevision: number;
+    readonly targetIndex: number;
+} | {
+    readonly type: 'remove_queue_item';
+    readonly itemId: string;
+    readonly expectedItemRevision: number;
+});
+export interface WebComposerActionResultV1 {
+    readonly requestId: string;
+    readonly outcome: 'applied' | 'deferred';
+    readonly controlRevision: string;
+    readonly state: WebComposerControlStateV1;
+    readonly modelReceipt?: SessionModelSwitchReceiptV1;
+    readonly permissionReceipt?: SessionPermissionReceiptV1;
+    readonly planReviewReceipt?: PlanReviewResolutionReceiptV1;
+    readonly detail?: string;
+}
 export interface WebSessionSnapshotV1 {
     readonly apiVersion: 1;
     readonly session: WebSessionSummaryV1;
+    readonly sessionRuntime: WebSessionRuntimeSummaryV1;
     readonly threadId: string | null;
     readonly threadCursor: number;
     readonly eventCursor: number;
@@ -180,6 +318,7 @@ export interface WebSessionSnapshotV1 {
     readonly pendingApprovals: readonly WebPendingPermissionV1[];
     readonly goal: WebGoalViewV1 | null;
     readonly plan: WebPlanViewV1 | null;
+    readonly composer: WebComposerControlStateV1;
     readonly recoveryDiagnostics: readonly unknown[];
 }
 export interface WebSkillSummaryV1 {
@@ -277,16 +416,21 @@ export interface WebSessionSummaryV1 {
     readonly createdAt: string;
     readonly updatedAt: string;
     readonly messageCount: number;
+    readonly contextDigest: string;
     readonly taskSummary?: string;
     readonly activeGoalId?: string;
     readonly activeGoalObjective?: string;
 }
-export type WebCommandTypeV1 = 'submit' | 'queue_followup' | 'remove_followup' | 'clear_followups' | 'interrupt' | 'permission_decision' | 'goal_control' | 'permission_mode_change' | 'cycle_agent_mode' | 'set_agent_mode';
+export type WebCommandTypeV1 = 'submit' | 'cancel_queued_turn' | 'queue_followup' | 'remove_followup' | 'clear_followups' | 'interrupt' | 'permission_decision' | 'goal_control' | 'permission_mode_change' | 'cycle_agent_mode' | 'set_agent_mode';
 export interface WebCommandV1 {
     readonly requestId: string;
+    readonly workspaceId: string;
+    readonly expectedContextRevision: string;
     readonly expectedSessionId: string;
+    readonly expectedSessionRuntimeRevision: string;
     readonly type: WebCommandTypeV1;
     readonly text?: string;
+    readonly queueId?: string;
     readonly itemId?: string;
     readonly requestPermissionId?: string;
     readonly approved?: boolean;
@@ -295,11 +439,20 @@ export interface WebCommandV1 {
     readonly objective?: string;
     readonly toolConfirmation?: ToolConfirmationPolicy;
     readonly agentMode?: 'interactive' | 'plan' | 'auto';
+    readonly contextReferences?: readonly WebContextReferenceV1[];
 }
 export interface WebCommandResultV1 {
     readonly requestId: string;
     readonly result: string;
+    readonly sessionRuntime: WebSessionRuntimeSummaryV1;
+    readonly queueId?: string;
+    readonly queuePosition?: number;
     readonly detail?: string;
+    readonly contextReceipt?: {
+        readonly manifestDigest: string;
+        readonly referenceCount: number;
+        readonly totalBytes: number;
+    };
 }
 export interface WebSessionMutationResultV1 {
     readonly requestId: string;
@@ -311,6 +464,12 @@ export interface WebSettingsMutationResultV1 {
     readonly appliedKeys: readonly WebSettingsKeyV1[];
     readonly settings: WebSettingsDocumentV1;
 }
+export type WebWorkspaceMutationPhaseV1 = 'queued' | 'running' | 'completed' | 'failed' | 'cancelled';
+export interface WebWorkspaceMutationStateV1 {
+    readonly callId: string;
+    readonly phase: WebWorkspaceMutationPhaseV1;
+    readonly queuePosition?: number;
+}
 export type WebWorkbenchEventV1 = {
     readonly type: 'runtime_event';
     readonly value: AgentRuntimeEvent;
@@ -333,6 +492,15 @@ export type WebWorkbenchEventV1 = {
     readonly workspaceId: string;
     readonly resources: readonly WebWorkspaceResourceV1[];
     readonly reason: WebWorkspaceInvalidationReasonV1;
+} | {
+    readonly type: 'composer_state_changed';
+    readonly state: WebComposerControlStateV1;
+} | {
+    readonly type: 'session_runtime_changed';
+    readonly runtime: WebSessionRuntimeSummaryV1;
+} | {
+    readonly type: 'workspace_mutation_changed';
+    readonly state: WebWorkspaceMutationStateV1;
 } | {
     readonly type: 'replay_reset';
     readonly reason: string;
@@ -386,6 +554,27 @@ export type WebEventEnvelopeV1 = WebEventEnvelopeBaseV1 & ({
         readonly resources: readonly WebWorkspaceResourceV1[];
         readonly reason: WebWorkspaceInvalidationReasonV1;
     };
+} | {
+    readonly type: 'composer_state_changed';
+    readonly sessionId: string;
+    readonly durable: true;
+    readonly payload: {
+        readonly state: WebComposerControlStateV1;
+    };
+} | {
+    readonly type: 'session_runtime_changed';
+    readonly sessionId: string;
+    readonly durable: true;
+    readonly payload: {
+        readonly runtime: WebSessionRuntimeSummaryV1;
+    };
+} | {
+    readonly type: 'workspace_mutation_changed';
+    readonly sessionId: string;
+    readonly durable: false;
+    readonly payload: {
+        readonly state: WebWorkspaceMutationStateV1;
+    };
 } | {
     readonly type: 'replay_reset';
     readonly durable: true;
@@ -402,6 +591,7 @@ export declare class WebProtocolError extends Error {
 export declare function parseWebSettingsUpdate(value: unknown): WebSettingsUpdateRequestV1;
 export declare function parseWebOpenSettingsDocument(value: unknown): WebOpenSettingsDocumentRequestV1;
 export declare function parseWebContextActivate(value: unknown): WebContextActivateRequestV1;
+export declare function parseWebComposerAction(value: unknown): WebComposerActionV1;
 export declare function parseWebCommand(value: unknown): WebCommandV1;
 export declare function toAgentRuntimeInput(command: WebCommandV1): AgentRuntimeControllerInput;
 export declare function projectSessionSummary(session: SessionMeta): WebSessionSummaryV1;