@qwen-code/web-shell 0.26.0 → 0.26.1-nightly.20261026.34769f9d41

package/dist/types/components/managed/generated/managed-agent-api.d.ts

@@ -91,7 +91,7 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** @description Maps workspaceId/cwdRelative to public Workspace selection without using environmentId or absolute cwd. Shares G0's opt-in initial file-tool Turn admission with public Session creation: the server-selected profile for the built-in qwen-code agent, and the profile selected by a stored definition's single allowlisted hosted_profile tools entry for a definition-pinned Session. Newly bound qwen-code Sessions, including empty creation, persist hosted-workspace-shell/1 with mandatory default/auto-edit approval when the Shell deployment opt-in is enabled; otherwise they persist hosted-workspace-files/1 with the configured file approval mode. The switch does not override a stored AgentDefinition's compiled profile or approval mode. Public callers cannot select the built-in profile. Any caller holding the OPERATOR role may submit later Turns and rename the Session under the same opt-in, while the Workspace registry row stays ACTIVE and still backs the binding, the actor recorded by the Workspace create command keeps OPERATOR or above, and the Session is active and undeleted and is either a qwen-code Session on the frozen execution profile or pinned to a stored definition; Workspace close follows its separate close capability and lifecycle admission; the same caller may cancel a running Turn (its delivery re-checks no grant it needs survives the cancellation), and the Session's own liveness keeps OPERATOR access even when its Workspace's background-exit observation closes some other bound Session; cancel is always allowed for its own running Turn even outside the Workspace files opt-in. A definition-pinned Session keeps its pinned revision's tool profile, model and instructions for its whole life, and a replay of the create command reuses the original pin; a WebShell Session inherits its Workspace's default Workspace selection when the request omits one. Shell Sessions additionally require the Shell opt-in and valid persisted approval for fresh Turns; disabling only Shell admission preserves original-key replay and accepted approvals and cancellation while Workspace files remain enabled and persisted approval remains valid. The public Shell tool list does not include the child agent tool. Invalid approval or files-off can refuse attachment. Public Shell close, archive, unarchive and delete stay unavailable, including protocol-0. Fresh Shell sending also requires foregroundShell=true; workspaceTurns alone is not sufficient Shell Turn admission. Manual rename uses the independent rename capability. */
+        /** @description Maps workspaceId/cwdRelative to public Workspace selection without using environmentId or absolute cwd. Shares G0's opt-in initial file-tool Turn admission with public Session creation: the server-selected profile for the built-in qwen-code agent, and the profile selected by a stored definition's single allowlisted hosted_profile tools entry for a definition-pinned Session. Newly bound qwen-code Sessions, including empty creation, persist hosted-workspace-shell/1 with mandatory default/auto-edit approval when the Shell deployment opt-in is enabled; otherwise they persist hosted-workspace-files/1 with the configured file approval mode. The switch does not override a stored AgentDefinition's compiled profile or approval mode. Public callers cannot select the built-in profile. Any caller holding the OPERATOR role may submit later Turns and rename the Session under the same opt-in, while the Workspace registry row stays ACTIVE and still backs the binding, the actor recorded by the Workspace create command keeps OPERATOR or above, and the Session is active and undeleted and is either a qwen-code Session on the frozen execution profile or pinned to a stored definition; Workspace close follows its separate close capability and lifecycle admission; the same caller may cancel a running Turn (its delivery re-checks no grant it needs survives the cancellation), and the Session's own liveness keeps OPERATOR access even when its Workspace's background-exit observation closes some other bound Session; cancel is always allowed for its own running Turn even outside the Workspace files opt-in. A definition-pinned Session keeps its pinned revision's tool profile, model and instructions for its whole life, and a replay of the create command reuses the original pin; a WebShell Session inherits its Workspace's default Workspace selection when the request omits one. Shell Sessions additionally require the Shell opt-in and valid persisted approval for fresh Turns; disabling only Shell admission preserves original-key replay and accepted approvals and cancellation while Workspace files remain enabled and persisted approval remains valid. Qualified new public Shell Sessions expose agent by default under the public-child deployment switch and runtime/Harness admission; existing Sessions retain their original tool scope. Invalid approval or files-off can refuse attachment. Public Shell close and active delete require lifecycle v2 and reliable original-Worker stop support; archive and unarchive require completed close proof. Fresh Shell sending also requires foregroundShell=true; workspaceTurns alone is not sufficient Shell Turn admission. Manual rename uses the independent rename capability. */
         post: operations["webShellCreateSession"];
         delete?: never;
         options?: never;
@@ -108,6 +108,7 @@ export interface paths {
         };
         get?: never;
         put?: never;
+        /** @description Admits the command durably and returns its operation identity, admission stage and delivery state. Replaying the same idempotency key returns the original command operation. Existing Session and actor authorization checks apply. */
         post: operations["webShellSubmitTurn"];
         delete?: never;
         options?: never;
@@ -124,6 +125,7 @@ export interface paths {
         };
         get?: never;
         put?: never;
+        /** @description Admits the command durably and returns its operation identity, admission stage and delivery state. Replaying the same idempotency key returns the original command operation. Existing Session and actor authorization checks apply. */
         post: operations["webShellCancelTurn"];
         delete?: never;
         options?: never;
@@ -148,23 +150,6 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/agent/web-shell/v1/sessions/cwd/change": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        get?: never;
-        put?: never;
-        /** @description W2, implemented: the camelCase twin of the public changeSessionCwd with the matched refusal order: 400 invalid_request for a missing or malformed field; 401 actor_required without a trusted actor; 400 invalid_idempotency_key for a malformed idempotencyKey — with two documented divergences: a key over 128 characters is refused during request validation with 400 invalid_request before the service's check, and a blank idempotencyKey is refused there too, while the public header answers 400 invalid_idempotency_key for both shapes; 400 invalid_cwd for a lexical violation and 400 invalid_request for an expectedContextRevision below 1; 404 session_not_found for an unknown Session id; 400 unsupported_feature for an unbound Session; 404 session_not_found for an unreadable Session; 409 idempotency_conflict when one key carries different content, and a completed change under the same key always replays instead, before the role refusal; 403 session_operation_forbidden when a readable actor's Workspace role is below OPERATOR; 409 workspace_unavailable when execution is disabled; 404 session_not_found for a deleted Session; then 409 session_state_conflict, 409 workspace_unavailable from moved Registry facts (the recorded create-command actor's grant included, and the settlement re-checks the V56-persisted initiator the same way, so demoting either actor fails the operation, exactly like the public surface), 409 context_revision_conflict and 409 session_context_busy. Poll the operation or await session.context.changed; do not treat 202 as activation. */
-        post: operations["webShellChangeCwd"];
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
     "/api/agent/web-shell/v1/operations/query": {
         parameters: {
             query?: never;
@@ -523,7 +508,7 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** @description Change the execution approval policy of an eligible Workspace Session: built-in qwen-code or a stored AgentDefinition on exactly hosted-workspace-files/1 or hosted-workspace-shell/1,/2. With liveSupported, execution policy changes affect subsequent current-Turn permission checks and permit eligible pending ordinary tool approvals. Otherwise the Session must be idle. Plan changes remain idle-only. Requires its recorded owner, current OPERATOR or OWNER access and Session-specific Harness feature support. Changes are revision-checked and actor/session-scoped idempotent. Definition creation policy and pins remain immutable. */
+        /** @description Change the execution approval policy of an eligible Workspace Session: built-in qwen-code or a stored AgentDefinition on exactly hosted-workspace-files/1, hosted-workspace-files/3 or hosted-workspace-shell/1. With liveSupported, execution policy changes affect subsequent current-Turn permission checks and permit eligible pending ordinary tool approvals. Otherwise the Session must be idle. Plan changes remain idle-only. Requires its recorded owner, current OPERATOR or OWNER access and Session-specific Harness feature support. Changes are revision-checked and actor/session-scoped idempotent. Definition creation policy and pins remain immutable. Classifier auto requires auto-approval/1. Optional permissionRules requires permission-rules/1 and an idle Session. Omitted rules preserve the current selection; three empty arrays clear it. Mode, Plan and rules share one approval revision and receipt. Persisted rules are also snapshotted at Turn admission; replay preserves the original policy. Empty rules are omitted from responses and Harness payloads. */
         post: operations["changeWebShellSessionApproval"];
         delete?: never;
         options?: never;
@@ -706,112 +691,486 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-}
-export type webhooks = Record<string, never>;
-export interface components {
-    schemas: {
-        PublicMcpCatalog: {
-            /** @constant */
-            object: "agent.mcp_catalog";
-            /** Format: uuid */
-            session_id: string;
-            servers: components["schemas"]["PublicMcpServerCatalog"][];
+    "/api/agent/web-shell/v1/sessions/compress": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
         };
-        PublicMcpServerCatalog: {
-            server_id: string;
-            server_revision: number;
-            /** @description The pinned catalog revision; null while no catalog has been published. */
-            catalog_revision: number | null;
-            tools: components["schemas"]["PublicMcpTool"][];
-            resources: components["schemas"]["PublicMcpResource"][];
-            prompts: components["schemas"]["PublicMcpPrompt"][];
-            discovery: components["schemas"]["PublicMcpDiscovery"];
+        get?: never;
+        put?: never;
+        /** @description Admits idle-only context compression without creating a Turn. A trusted Workspace OPERATOR or OWNER is required. Read authorization precedes actor-scoped idempotency replay; replay precedes mutable role, capability, revision and busy checks. Expected compaction revision begins at zero. Returns 409 session_context_busy for active or queued Turns, approvals, unsettled Hooks, recovery or conflicting context operations; 409 compaction_revision_conflict for a stale revision; 409 idempotency_conflict for key reuse with different content. A 202 is durable admission; query the original operation for completion. Unknown acceptance is reconciled from native evidence without blind redelivery. A compressed outcome invalidates the prior context usage until a new main-model observation; noop and failure preserve history and revision. */
+        post: operations["webShellCompressContext"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/session-mcp/management/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
         };
-        PublicMcpTool: {
-            name: string;
-            description?: string;
-            input_schema: {
-                [key: string]: unknown;
-            };
+        get?: never;
+        put?: never;
+        /** @description Requires a trusted Workspace operator and the Session creator execution grants. Manage only the selected active public Session; commands retain immutable definition pins, serialize while idle, and select only deployed Runtime definitions. Status reads persisted receipts without restarting or replaying the original effect. Management reattachment never drives recovery, cleanup, or wake dispatch. After a Harness restart, continue or recover the Session through its normal execution flow first; otherwise management returns 409 hosted_mcp_session_load_required. A fresh empty Session can initialize without a Turn; command status never creates one. Unsupported management queries return supported=false. Responses never include private executable recipes or credentials. */
+        post: operations["queryWebShellSessionMcpManagement"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/session-mcp/management/submit": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
         };
-        PublicMcpResource: {
-            name: string;
-            uri: string;
-            description?: string;
-            mime_type?: string;
+        get?: never;
+        put?: never;
+        /** @description Requires a trusted Workspace operator and the Session creator execution grants. Manage only the selected active public Session; commands retain immutable definition pins, serialize while idle, and select only deployed Runtime definitions. Status reads persisted receipts without restarting or replaying the original effect. Management reattachment never drives recovery, cleanup, or wake dispatch. After a Harness restart, continue or recover the Session through its normal execution flow first; otherwise management returns 409 hosted_mcp_session_load_required. A fresh empty Session can initialize without a Turn; command status never creates one. Unsupported management queries return supported=false. Responses never include private executable recipes or credentials. */
+        post: operations["submitWebShellSessionMcpManagement"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/session-mcp/management/operations/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
         };
-        PublicMcpPrompt: {
-            name: string;
-            description?: string;
-            arguments?: components["schemas"]["PublicMcpPromptArgument"][];
+        get?: never;
+        put?: never;
+        /** @description Requires a trusted Workspace operator and the Session creator execution grants. Manage only the selected active public Session; commands retain immutable definition pins, serialize while idle, and select only deployed Runtime definitions. Status reads persisted receipts without restarting or replaying the original effect. Management reattachment never drives recovery, cleanup, or wake dispatch. After a Harness restart, continue or recover the Session through its normal execution flow first; otherwise management returns 409 hosted_mcp_session_load_required. A fresh empty Session can initialize without a Turn; command status never creates one. Unsupported management queries return supported=false. Responses never include private executable recipes or credentials. */
+        post: operations["queryWebShellSessionMcpManagementOperation"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/session-recovery/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
         };
-        PublicMcpPromptArgument: {
-            name: string;
-            description?: string;
-            required?: boolean;
+        get?: never;
+        put?: never;
+        /** @description Read authorized durable recovery facts and only already attached Harness evidence without loading a Session, acquiring a Runtime, invoking tools or models, stopping work or clearing a block. Missing or unreadable native readiness evidence never proves ready. This is Session-scoped; ordinary Workspace admission and concurrent unrelated Sessions remain independent. */
+        post: operations["queryWebShellSessionRecovery"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/session-recovery/recheck": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
         };
-        PublicMcpDiscovery: {
-            /** @enum {string} */
-            tools: "complete" | "partial" | "failed" | "stale";
-            /** @enum {string} */
-            resources: "complete" | "partial" | "failed" | "stale";
-            /** @enum {string} */
-            prompts: "complete" | "partial" | "failed" | "stale";
+        get?: never;
+        put?: never;
+        /** @description Recheck only the latest original Turn under the existing cancellation/cleanup authorization. Repeated requests coalesce and may only advance existing cancellation/reconciliation or retry settled cleanup; they never resubmit input, replay effects, reset retry budgets or change claim generations. A stale Turn returns recovery_target_changed and ineligible work returns recovery_recheck_unavailable. 202 means requested, not cancelled or ready. For a terminal Java Turn whose Harness attachment is cold or whose status cannot be read, this POST may attempt a narrow cleanup-only load. It must verify the original prompt has a durable native terminal, covered continuation checkpoint or lawful initial state, and no pending input before retrying only its existing cleanup. It never resumes models, tools, MCP or Hooks, clears a permanent journal block, or treats a historical SQL failure as native settlement. */
+        post: operations["recheckWebShellSessionRecovery"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/sessions/export/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
         };
-        InputBlock: components["schemas"]["InputTextBlock"] | components["schemas"]["InputFileBlock"] | components["schemas"]["InputImageBlock"];
-        PublicArtifact: {
-            /** @constant */
-            object: "agent.artifact";
-            id: string;
-            session_id: string;
-            result_id: string;
-            revision: string;
-            /** @enum {string} */
-            stream_role: "stdout" | "stderr";
-            /** Format: int64 */
-            byte_length: number;
-            sha256: string;
-            media_type: string;
-            /** @enum {string} */
-            availability: "available" | "unavailable";
-            /**
-             * Format: int64
-             * @description Unix epoch milliseconds, unlike the seconds that the public Session, Turn, Event and Item resources report.
-             */
-            created_at: number;
+        get?: never;
+        put?: never;
+        /**
+         * Read one immutable public Session snapshot page for reading exports
+         * @description Requires current Session read authorization on every page. Reuses the public item snapshot cursor, whose subsequent pages retain the original snapshot version and watermark. No private journal, Runtime or storage credentials are returned. The client waits for a snapshot covering its captured Session watermark before using its first page.
+         */
+        post: operations["webShellExportSession"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/user-messages/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
         };
-        WebShellListRequest: {
-            cursor?: string | null;
-            /** @default 20 */
-            limit?: number | null;
+        get?: never;
+        put?: never;
+        /** Query or mutate the durable Session user message queue */
+        post: operations["webShellQueryUserMessages"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/user-messages/command": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
         };
-        WebShellSessionRequest: {
-            /** Format: uuid */
-            sessionId: string;
+        get?: never;
+        put?: never;
+        /** Query or mutate the durable Session user message queue */
+        post: operations["webShellCommandUserMessages"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/workspace-extensions/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
         };
-        WebShellTranscriptRequest: {
-            /** Format: uuid */
-            sessionId: string;
-            cursor?: string | null;
-            /** @default 100 */
-            limit?: number | null;
+        get?: never;
+        put?: never;
+        /** @description Requires an authenticated actor with a read grant on the persisted Workspace. Reads durable metadata only; never creates a Runtime, loads a Harness Session, or retries an original operation. */
+        post: operations["queryWorkspaceExtensionPackages"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/workspace-extensions/packages/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
         };
-        WebShellStreamRequest: {
-            /** Format: uuid */
-            sessionId: string;
-            /**
-             * Format: int64
-             * @default 0
-             */
-            afterSequence?: number | null;
+        get?: never;
+        put?: never;
+        /** @description Requires an authenticated actor with a read grant on the persisted Workspace. Reads durable metadata only; never creates a Runtime, loads a Harness Session, or retries an original operation. */
+        post: operations["queryWorkspaceExtensionPackage"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/workspace-extensions/settings/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
         };
-        WebShellCreateRequest: {
-            /** @description Trace correlation only. */
-            requestId?: string | null;
-            idempotencyKey: string;
-            agentId: string;
-            /** @description Planned; phase one rejects non-blank values. */
-            environmentId?: string | null;
+        get?: never;
+        put?: never;
+        /** @description Requires an authenticated actor with a read grant on the persisted Workspace. Reads durable metadata only; never creates a Runtime, loads a Harness Session, or retries an original operation. */
+        post: operations["queryWorkspaceExtensionPackageSettings"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/workspace-extensions/settings/submit": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Requires the same Workspace operator and deployment permission as publication. Writes a complete encrypted settings revision with optimistic concurrency; old pinned revisions remain available. No values are returned. */
+        post: operations["submitWorkspaceExtensionPackageSettings"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/workspace-extensions/operations/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Requires an authenticated actor with a read grant on the persisted Workspace. Reads durable metadata only; never creates a Runtime, loads a Harness Session, or retries an original operation. The querying actor must own the original publication or settings operation. */
+        post: operations["queryWorkspaceExtensionPackageOperation"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/workspace-extensions/publish": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Requires an ACTIVE Workspace, an authenticated operator and the deployment extension allowlist. The Idempotency-Key binds an actor-scoped durable operation. Publication retains immutable tar.gz bytes under a server-assigned stable extension identity; it does not activate a Session. The manifest query is base64url JSON and is covered by the existing request signature. Archive contents and Runtime compatibility are validated by the target compiler before activation. */
+        post: operations["publishWebShellWorkspaceExtensionPackage"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/session-extensions/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Requires a Workspace reader for status and OPERATOR for changes. Status reads durable configuration and never loads a Harness or retries an operation. Apply requires an idle Session and the original Runtime with the package execution contract; a committed unknown outcome fences new execution until the original operation is reconciled. Explicit recovery compiles previous content into a new revision. */
+        post: operations["webShellSessionExtensionsQuery"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/session-extensions/submit": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Requires a Workspace reader for status and OPERATOR for changes. Status reads durable configuration and never loads a Harness or retries an operation. Apply requires an idle Session and the original Runtime with the package execution contract; a committed unknown outcome fences new execution until the original operation is reconciled. Explicit recovery compiles previous content into a new revision. */
+        post: operations["webShellSessionExtensionsSubmit"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/session-extensions/continue": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Requires a Workspace reader for status and OPERATOR for changes. Status reads durable configuration and never loads a Harness or retries an operation. Apply requires an idle Session and the original Runtime with the package execution contract; a committed unknown outcome fences new execution until the original operation is reconciled. Explicit recovery compiles previous content into a new revision. */
+        post: operations["webShellSessionExtensionsContinue"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/session-extensions/recover-previous": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Requires a Workspace reader for status and OPERATOR for changes. Status reads durable configuration and never loads a Harness or retries an operation. Apply requires an idle Session and the original Runtime with the package execution contract; a committed unknown outcome fences new execution until the original operation is reconciled. Explicit recovery compiles previous content into a new revision. */
+        post: operations["webShellSessionExtensionsRecoverPrevious"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/workspaces/files/upload": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Upload one binary file to a persisted Workspace
+         * @description Requires a trusted actor with OPERATOR or OWNER access, enabled Workspace files, verified LOCAL or SSH_LOCAL storage and an updated CLI. Uploads are limited to 8 MiB, require an existing parent directory and never overwrite an occupied path. A durable physical storage hold excludes tool execution and retirement until the original upload has a definite terminal result. Repeating the same upload ID reconciles its original command without replaying mutation; changed requests conflict. CSI is unsupported and never falls back to a primary Workspace. An uncertain result returns 503 workspace_upload_pending and must be queried by the original upload ID.
+         */
+        post: operations["webShellWorkspaceFilesUpload"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/workspaces/files/uploads/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Reconcile the original Workspace upload
+         * @description Only the admitting actor with a current Workspace operator grant can query the upload. Status checks use the frozen original storage target and never execute an upload or select a replacement Runtime. Reconciliation remains available through storage fencing; pending commands retain their durable hold. The server also reconciles pending uploads after client cancellation or restart.
+         */
+        post: operations["webShellWorkspaceFilesUploadQuery"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        PublicMcpCatalog: {
+            /** @constant */
+            object: "agent.mcp_catalog";
+            /** Format: uuid */
+            session_id: string;
+            servers: components["schemas"]["PublicMcpServerCatalog"][];
+        };
+        PublicMcpServerCatalog: {
+            server_id: string;
+            server_revision: number;
+            /** @description The pinned catalog revision; null while no catalog has been published. */
+            catalog_revision: number | null;
+            tools: components["schemas"]["PublicMcpTool"][];
+            resources: components["schemas"]["PublicMcpResource"][];
+            prompts: components["schemas"]["PublicMcpPrompt"][];
+            discovery: components["schemas"]["PublicMcpDiscovery"];
+        };
+        PublicMcpTool: {
+            name: string;
+            description?: string;
+            input_schema: {
+                [key: string]: unknown;
+            };
+        };
+        PublicMcpResource: {
+            name: string;
+            uri: string;
+            description?: string;
+            mime_type?: string;
+        };
+        PublicMcpPrompt: {
+            name: string;
+            description?: string;
+            arguments?: components["schemas"]["PublicMcpPromptArgument"][];
+        };
+        PublicMcpPromptArgument: {
+            name: string;
+            description?: string;
+            required?: boolean;
+        };
+        PublicMcpDiscovery: {
+            /** @enum {string} */
+            tools: "complete" | "partial" | "failed" | "stale";
+            /** @enum {string} */
+            resources: "complete" | "partial" | "failed" | "stale";
+            /** @enum {string} */
+            prompts: "complete" | "partial" | "failed" | "stale";
+        };
+        InputBlock: components["schemas"]["InputTextBlock"] | components["schemas"]["InputFileBlock"] | components["schemas"]["InputImageBlock"];
+        PublicArtifact: {
+            /** @constant */
+            object: "agent.artifact";
+            id: string;
+            session_id: string;
+            result_id: string;
+            revision: string;
+            /** @enum {string} */
+            stream_role: "stdout" | "stderr";
+            /** Format: int64 */
+            byte_length: number;
+            sha256: string;
+            media_type: string;
+            /** @enum {string} */
+            availability: "available" | "unavailable";
+            /**
+             * Format: int64
+             * @description Unix epoch milliseconds, unlike the seconds that the public Session, Turn, Event and Item resources report.
+             */
+            created_at: number;
+        };
+        WebShellListRequest: {
+            cursor?: string | null;
+            /** @default 20 */
+            limit?: number | null;
+            /**
+             * @description Filter before pagination. Omission preserves all readable, undeleted Sessions. Cursors are bound to the normalized archive state and title query.
+             * @default all
+             * @enum {string}
+             */
+            archiveState?: "unarchived" | "archived" | "all";
+            /** @description Case-insensitive literal title substring, with surrounding whitespace stripped. Empty means no title filter; %, _ and backslash are literal. Applied before pagination. Cursors are bound to the stripped query and archiveState; listing is not a snapshot across title or archive changes. */
+            titleQuery?: string | null;
+        };
+        WebShellSessionRequest: {
+            /** Format: uuid */
+            sessionId: string;
+        };
+        WebShellTranscriptRequest: {
+            /** Format: uuid */
+            sessionId: string;
+            cursor?: string | null;
+            /** @default 100 */
+            limit?: number | null;
+        };
+        WebShellStreamRequest: {
+            /** Format: uuid */
+            sessionId: string;
+            /**
+             * Format: int64
+             * @default 0
+             */
+            afterSequence?: number | null;
+        };
+        WebShellCreateRequest: {
+            /** @description Trace correlation only. */
+            requestId?: string | null;
+            idempotencyKey: string;
+            agentId: string;
+            /** @description Optional host-catalog model for a bound built-in qwen-code Session. Requires modelSelectionSupported. Persisted atomically before the first Turn and included in creation idempotency; omission preserves the default model and old digest. */
+            modelId?: string;
             /** @description The server enforces the bound in UTF-16 code units (Java String.length()), so an astral character counts as two: a title this schema's code-point maxLength accepts can still exceed the server's 256-unit bound and answer 400 invalid_title. */
             title?: string | null;
             /** @description Text has a 4,000,000-character aggregate budget and per-block 1,000,000-character cap, counted in code points. Hosted also enforces its 64 KiB durable-record limit for text-only inputs and a 32 MiB prepared-snapshot ceiling. A complete canonical input containing file/image attachments must fit within 8 MiB and requires input-attachments/1. */
@@ -827,6 +1186,8 @@ export interface components {
             planMode?: boolean;
             /** @description Optional static Skills imported from the enabled management catalog or added explicitly to the pinned AgentDefinition catalog. The merged catalog has unique names, at most 256 entries, 512 KiB per body and 2 MiB compact JSON. Requires session-skills/2; persisted immutably and included in creation idempotency. */
             skills?: components["schemas"]["SessionCreationSkill"][];
+            /** @description Optional immutable initial extension selection. Omission keeps the legacy configuration path; an explicit empty array starts the unified configuration format. Included in creation idempotency and applied before the first model request. Requires session-extension-packages/1 and an extension-capable original Runtime. */
+            extensionPins?: components["schemas"]["ManagedExtensionPackagePin"][];
         };
         WebShellSubmitRequest: {
             /** @description Trace correlation only. */
@@ -837,12 +1198,6 @@ export interface components {
             /** @description Text has a 4,000,000-character aggregate budget and per-block 1,000,000-character cap, counted in code points. Hosted also enforces its 64 KiB durable-record limit for text-only inputs and a 32 MiB prepared-snapshot ceiling. A complete canonical input containing file/image attachments must fit within 8 MiB and requires input-attachments/1. */
             input?: components["schemas"]["InputBlock"][];
             metadata?: components["schemas"]["WebShellMetadata"];
-            /**
-             * @description D7-3. java_durable asks for the java_durable admission view: the 202 then names the command's operation (operationId, admissionStage, deliveryState), so a lost response resolves through that operation. Only a deployment whose Sessions advertise durableOperations admits it; elsewhere it answers 400 unsupported_feature before anything is read or written. Absent or harness_confirmed keeps today's response. harness_confirmed is the pinned reference design's qwen_confirmed. The request digest leaves this field out, so a retry under the same idempotencyKey replays the same command in either view.
-             * @default harness_confirmed
-             * @enum {string}
-             */
-            admissionProfile?: "harness_confirmed" | "java_durable";
         };
         WebShellCancelRequest: {
             /** @description Trace correlation only. */
@@ -851,34 +1206,36 @@ export interface components {
             /** Format: uuid */
             sessionId: string;
             turnId: string;
-            /**
-             * @description D7-3. java_durable asks for the java_durable admission view: the 202 then names the command's operation (operationId, admissionStage, deliveryState), so a lost response resolves through that operation. Only a deployment whose Sessions advertise durableOperations admits it; elsewhere it answers 400 unsupported_feature before anything is read or written. Absent or harness_confirmed keeps today's response. harness_confirmed is the pinned reference design's qwen_confirmed. The request digest leaves this field out, so a retry under the same idempotencyKey replays the same command in either view.
-             * @default harness_confirmed
-             * @enum {string}
-             */
-            admissionProfile?: "harness_confirmed" | "java_durable";
         };
         /** @description Arbitrary caller metadata, as a JSON object (or null). Accepted and ignored in Phase 1: nothing from it is persisted. On WebShellCreateRequest the Session title travels in that request's own `title` field; WebShellSubmitRequest has no title surface. Any keys are valid. */
         WebShellMetadata: {
             [key: string]: unknown;
         } | null;
-        /** @description accepted means Java durable delivery responsibility, not model execution. The three operation fields come together, and only on a Turn input or cancel admission that asked for admissionProfile java_durable on a deployment advertising durableOperations (D7-3): operationId names the command's original submit_input or cancel operation, readable through the operation query, and admissionStage and deliveryState are that operation's latest durable values. A fresh input reads java_durable and pending; a cancel of a Turn that already ended reads its settled values. A retry under the same key answers the same operation with replayed true. Missing fields keep the legacy harness_confirmed response semantics, also for Session creation and for a replayed command recorded before v1.58. */
+        /** @description Command admission. Session creation and internal commands may omit operation fields. */
         WebShellAdmission: {
             /** Format: uuid */
             sessionId: string;
             turnId?: string | null;
             status: string;
             replayed: boolean;
+            /** @description Durable operation identifier for turn submission or cancellation. */
             operationId?: string;
-            /** @enum {string} */
+            /**
+             * @description Persisted admission stage of the operation.
+             * @enum {string}
+             */
             admissionStage?: "java_durable" | "harness_confirmed";
-            /** @enum {string} */
+            /**
+             * @description Current delivery state of the operation.
+             * @enum {string}
+             */
             deliveryState?: "pending" | "leased" | "confirmed" | "blocked";
         };
         WebShellTurn: {
             turnId: string;
             /** Format: uuid */
             sessionId: string;
+            /** @description recovery_blocked with hosted_harness_recovery_blocked means the Harness stopped without a safely settled Turn. The input remains active internally. Execution redispatch is parked, while bounded read-only observation of the original Harness journal may settle a later terminal result. Policy changes and lifecycle close wait for settlement; explicit cancellation remains available. */
             status: string;
             /** Format: int64 */
             submittedAt: number;
@@ -908,7 +1265,7 @@ export interface components {
              * @description Current effective approval policy; initialApprovalMode retains the immutable creation policy.
              * @enum {string}
              */
-            approvalMode?: "default" | "auto-edit" | "yolo";
+            approvalMode?: "default" | "auto" | "auto-edit" | "yolo";
             modelContext?: components["schemas"]["WebShellModelContext"];
             modelSelection?: components["schemas"]["WebShellModelSelection"];
             /** Format: int64 */
@@ -922,18 +1279,25 @@ export interface components {
             planMode?: boolean;
             /** @description Optional deployment capability; missing means false. */
             planModeSupported?: boolean;
+            /**
+             * Format: int64
+             * @description Sequence of the most recent native context.compacted event; independent of Workspace context revision. Omitted when retained pre-upgrade evidence cannot establish the revision, and context compression is unavailable.
+             * @default 0
+             */
+            compactionRevision?: number | null;
+            /** @description Current durable context compression operation, including recovery_blocked; absent when none is active. */
+            contextCompressionOperationId?: string | null;
+            /** @description Current unsettled lifecycle operation, queried in batch under Session read authorization. A failed close/delete may leave the Session closing/deleting; only explicit retry starts a new operation. Settled Sessions omit this projection. */
+            lifecycleOperation?: components["schemas"]["WebShellLifecycleOperation"];
+            recovery?: components["schemas"]["SessionRecovery"];
         };
         WebShellSessionCapabilities: {
             /**
-             * @description True when Workspace files are enabled, the bound Session is active and undeleted, the caller holds OPERATOR or above on the Workspace and the exact ACTIVE Registry generation/storage and create-command-actor OPERATOR/OWNER grant still hold, matching cwd admission. This does not promise an idle Session and is independent of workspaceTurns execution-profile gates. Missing means false. Existing operations remain queryable under read authorization even when this capability is false.
+             * @deprecated
+             * @description Retired: Session directory-change submission has been removed; always false.
              * @default false
              */
             cwdChange?: boolean;
-            /**
-             * @description D7-3. Present only on a deployment that enables the java_durable admission profile, where it is true while the Session is readable: a Turn input or cancel may then ask for admissionProfile java_durable. Omitted elsewhere, where asking for it answers 400 unsupported_feature.
-             * @default false
-             */
-            durableOperations?: boolean;
             /** @default false */
             actions: boolean;
             /**
@@ -944,22 +1308,22 @@ export interface components {
             tasks: boolean;
             artifacts: boolean;
             /**
-             * @description Deployment support for close independently of archive/delete. Admission also requires Session ownership and current read access for a bound Session.
+             * @description Close support including current actor authority. Workspace-bound Sessions require the recorded Session owner and current read access. Source-state and idle admission remain authoritative on the server.
              * @default false
              */
             sessionClose?: boolean;
             /**
-             * @description Optional support for this retention operation. For a Workspace-bound Session requires completed reliable-close evidence; authorization and source-state validation still apply.
+             * @description Archive support including current actor authority. Workspace-bound Sessions require completed reliable-close evidence, the recorded Session owner and current read access. Source-state and idle admission remain authoritative on the server.
              * @default false
              */
             sessionArchive?: boolean;
             /**
-             * @description Optional support for this retention operation. For a Workspace-bound Session requires completed reliable-close evidence; authorization and source-state validation still apply.
+             * @description Unarchive support including current actor authority. Workspace-bound Sessions require completed reliable-close evidence, the recorded Session owner and current read access. Source-state and idle admission remain authoritative on the server.
              * @default false
              */
             sessionUnarchive?: boolean;
             /**
-             * @description Optional support capability. ACTIVE Workspace files Sessions require L3 lifecycle protocol and reliable original Runtime stop; CLOSED/ARCHIVED Sessions use independent L2 close evidence. Current creator/read authorization and idle/source-state admission checks still apply. The aggregate session lifecycle capability is unchanged.
+             * @description Delete support including current actor authority. ACTIVE Workspace Sessions require a supported reliable-close protocol; CLOSED/ARCHIVED Sessions use completed close evidence. Workspace-bound Sessions require the recorded Session owner and current read access. Source-state and idle admission remain authoritative on the server. The aggregate session lifecycle capability is unchanged.
              * @default false
              */
             sessionDelete?: boolean;
@@ -967,7 +1331,7 @@ export interface components {
             foregroundShell?: boolean;
             /** @description The caller may request an idle Session model change using the server model catalog. Missing means unsupported; authorization and revision admission still apply. */
             modelChange?: boolean;
-            /** @description The caller owns this eligible Workspace Session with current OPERATOR or OWNER access. Built-in qwen-code requires approval-selection/1; stored AgentDefinitions on exactly hosted-workspace-files/1 or hosted-workspace-shell/1,/2 also require agent-definition-approval-selection/1. Idle-state admission is checked separately. Missing means false. */
+            /** @description The caller owns this eligible Workspace Session with current OPERATOR or OWNER access. Built-in qwen-code requires approval-selection/1; stored AgentDefinitions on exactly hosted-workspace-files/1, hosted-workspace-files/3 or hosted-workspace-shell/1 also require agent-definition-approval-selection/1. Idle-state admission is checked separately. Missing means false. */
             approvalModeChange?: boolean;
             /** @description Optional deployment capability; missing means false. */
             inputAttachments?: boolean;
@@ -976,6 +1340,16 @@ export interface components {
              * @default false
              */
             rename?: boolean;
+            /**
+             * @description Requires a compatible Hosted Harness and an active Workspace Session. WebShell also reflects the current caller OPERATOR or OWNER grant; admission separately checks idle state.
+             * @default false
+             */
+            contextCompression?: boolean;
+            /**
+             * @description Public child orchestration support for this persisted Session; launch and caller authorization are checked separately.
+             * @default false
+             */
+            childAgents?: boolean;
         };
         WebShellSessionPage: {
             data: components["schemas"]["WebShellSession"][];
@@ -1115,7 +1489,7 @@ export interface components {
                  * @default false
                  */
                 workspaceContext: boolean;
-                /** @description Supports authorized Workspace discovery, Session creation, and saved binding read-back. This capability does not advertise execution readiness. Deployments may separately opt in to an initial Workspace Turn at creation: Read/Write/Edit under hosted-workspace-files/1, or file tools plus mandatory-approval foreground Shell under hosted-workspace-shell/1 when the Shell opt-in is enabled. The public Shell tool list does not include the child agent tool. Callers holding the OPERATOR role may submit later Turns or rename under the same opt-in while the registry row stays ACTIVE and still backs the Session's binding and the actor recorded by the Workspace create command keeps OPERATOR or above, and may cancel a running Turn (its delivery re-checks no grants). Shell fresh sending also requires foregroundShell=true. Public Shell close, archive, unarchive and delete stay unavailable, including protocol-0, while close of other profiles follows its separate capability and lifecycle admission; archive, delete and unarchive follow their separate retention capabilities after reliable Workspace close. */
+                /** @description Supports authorized Workspace discovery, Session creation, and saved binding read-back. This capability does not advertise execution readiness. Deployments may separately opt in to an initial Workspace Turn at creation: Read/Write/Edit under hosted-workspace-files/1, or file tools plus mandatory-approval foreground Shell under hosted-workspace-shell/1 when the Shell opt-in is enabled. Qualified new public Shell Sessions expose agent by default under the public-child deployment switch and runtime/Harness admission; existing Sessions retain their original tool scope. Callers holding the OPERATOR role may submit later Turns or rename under the same opt-in while the registry row stays ACTIVE and still backs the Session's binding and the actor recorded by the Workspace create command keeps OPERATOR or above, and may cancel a running Turn (its delivery re-checks no grants). Shell fresh sending also requires foregroundShell=true. Public Shell close and active delete require lifecycle v2 and reliable original-Worker stop support; archive and unarchive require completed close proof, while close of other profiles follows its separate capability and lifecycle admission; archive, delete and unarchive follow their separate retention capabilities after reliable Workspace close. */
                 workspaceBinding: boolean;
                 /** @description Supports creating empty Workspaces under the operator-controlled root. Missing or false means unsupported; current actor and server admission checks still apply. */
                 workspaceCreation?: boolean;
@@ -1134,15 +1508,6 @@ export interface components {
                 canCreateSession?: true;
             }) | null;
         };
-        WebShellChangeCwdRequest: {
-            /** Format: uuid */
-            sessionId: string;
-            idempotencyKey: string;
-            cwdRelative: components["schemas"]["WorkspaceRelativePath"];
-            /** Format: int64 */
-            expectedContextRevision: number;
-            requestId?: string | null;
-        };
         WebShellOperationRequest: {
             /** Format: uuid */
             sessionId: string;
@@ -1285,13 +1650,18 @@ export interface components {
             policyRevision: string;
             answers: components["schemas"]["WebShellQuestionAnswer"][];
         };
-        WebShellOperation: components["schemas"]["WebShellCwdOperation"] | components["schemas"]["WebShellCommandOperation"];
+        WebShellOperation: components["schemas"]["WebShellCwdOperation"] | components["schemas"]["WebShellCommandOperation"] | components["schemas"]["WebShellContextCompressionOperation"];
         WebShellActionQueryRequest: {
             /** Format: uuid */
             sessionId: string;
             cursor?: string;
             /** @default 20 */
             limit?: number;
+            /**
+             * @description Include pending permission Actions of this public root Session and its direct children; each Action retains its actual owning sessionId.
+             * @default false
+             */
+            includeChildren?: boolean;
         };
         WebShellActionGetRequest: {
             /** Format: uuid */
@@ -1310,6 +1680,8 @@ export interface components {
             /** Format: uuid */
             sessionId: string;
             idempotencyKey: string;
+            /** @description Trace-only client request identity, excluded from idempotency digests. */
+            requestId?: string | null;
         };
         WebShellWorkspaceQueryRequest: {
             cursor?: string | null;
@@ -1374,11 +1746,20 @@ export interface components {
             /** @description The newest Artifacts that hold durable task output, at most 100, oldest first. Entries must not rotate out until older Artifacts can be enumerated and attributed to the task: an evicted Artifact stays readable by id through the Session artifact routes but is no longer discoverable from the task. */
             artifactRefs: string[];
             actionCapabilities: components["schemas"]["TaskActionCapability"][];
+            /** @description A durable stop request has been recorded. This does not prove that the task has terminated. */
+            stopRequested?: boolean;
+            /**
+             * @description The actual immutable approval mode of this public child Session.
+             * @enum {string}
+             */
+            approvalMode?: "default" | "auto-edit" | "yolo";
         } & (unknown & unknown & unknown & unknown & unknown);
         WebShellTaskPage: {
             data: components["schemas"]["WebShellTask"][];
             hasMore: boolean;
             nextCursor?: string | null;
+            /** @description The total number of nonterminal child Agent tasks in this Session, independent of pagination. */
+            activeChildCount?: number;
         } & unknown;
         /** @description One task event: a logical state change, a bounded output chunk, or an Artifact reference. High-volume output goes to Artifacts or bounded chunks in this paged stream, never one Session event per raw line. The closed schema validates the server's own version; clients ignore unknown optional fields and unknown types and checkpoint their cursors. Strict response validation against an older minor version is not supported. Event identity, position, payload and accepted schema/projection versions are immutable across restart, projection rebuild and archival. */
         WebShellTaskEvent: {
@@ -1533,6 +1914,8 @@ export interface components {
             planModeSupported?: boolean;
             /** @description Optional deployment capability; missing means false. */
             inputAttachments?: boolean;
+            /** @description Optional capability for modelId on Workspace creation. Missing means false. */
+            modelSelectionSupported?: boolean;
             /** @description Optional deployment capability; missing means false. Requires a compatible Harness and durable Session Store. */
             skillsSupported?: boolean;
         };
@@ -1584,15 +1967,19 @@ export interface components {
             /** @description Execution approval can change during a Turn when true. Missing means idle-only; Plan changes remain idle-only. */
             liveSupported?: boolean;
             /** @enum {string} */
-            approvalMode: "default" | "auto-edit" | "yolo";
+            approvalMode: "default" | "auto" | "auto-edit" | "yolo";
             /** Format: int64 */
             approvalRevision: number;
-            availableApprovalModes: ("default" | "auto-edit" | "yolo")[];
+            availableApprovalModes: ("default" | "auto" | "auto-edit" | "yolo")[];
             supported: boolean;
             /** @description Persisted public Plan overlay, independent of execution permission. Omission on a change preserves the selected state. */
             planMode?: boolean;
             /** @description Optional deployment capability; missing means false. */
             planModeSupported?: boolean;
+            /** @description Persisted rules, including when execution capability is unavailable. Omitted when empty. */
+            permissionRules?: components["schemas"]["ManagedPermissionRules"];
+            /** @description Owner-authorized Session rule editing is available only with Harness permission-rules/1 support. Missing means false. Rule changes require an idle Session. */
+            permissionRulesSupported?: boolean;
         };
         WebShellChangeApprovalRequest: {
             sessionId: string;
@@ -1601,19 +1988,23 @@ export interface components {
             idempotencyKey: string;
             requestId?: string;
             /** @enum {string} */
-            approvalMode: "default" | "auto-edit" | "yolo";
+            approvalMode: "default" | "auto" | "auto-edit" | "yolo";
             /** @description Persisted public Plan overlay, independent of execution permission. Omission on a change preserves the selected state. */
             planMode?: boolean;
+            /** @description Omission preserves the persisted rules. Supplying three empty arrays clears them. Rule edits require an idle Session, and share the approval revision and idempotency receipt with mode changes. */
+            permissionRules?: components["schemas"]["ManagedPermissionRules"];
         };
         WebShellApprovalChangeResult: {
             sessionId: string;
             /** @enum {string} */
-            approvalMode: "default" | "auto-edit" | "yolo";
+            approvalMode: "default" | "auto" | "auto-edit" | "yolo";
             /** Format: int64 */
             approvalRevision: number;
             replayed: boolean;
             /** @description Persisted public Plan overlay, independent of execution permission. Omission on a change preserves the selected state. */
             planMode?: boolean;
+            /** @description Committed rules; omitted when empty. Replayed requests return their original policy receipt. */
+            permissionRules?: components["schemas"]["ManagedPermissionRules"];
         };
         WebShellRuntimeNode: {
             nodeId: string;
@@ -1728,6 +2119,8 @@ export interface components {
             directory: string;
             entries: components["schemas"]["WebShellWorkspaceFileEntry"][];
             truncated: boolean;
+            /** @description Present only when the selected CLI supports durable Workspace uploads. */
+            maxUploadBytes?: number;
         };
         WebShellWorkspaceFileSnapshot: {
             scopeRevision: string;
@@ -1777,7 +2170,7 @@ export interface components {
         };
         WebShellRenameResult: {
             sessionId: string;
-            /** @description Current persisted title from the confirmed mutation or completed replay. Existing legacy titles can exceed the fresh-title input bound. */
+            /** @description Current persisted title from the confirmed mutation or completed replay. */
             title: string;
             replayed: boolean;
         };
@@ -1795,6 +2188,340 @@ export interface components {
             /** @description Whether the user may invoke this Skill; defaults to true. */
             user_invocable?: boolean;
         };
+        WebShellContextCompressionRequest: {
+            requestId?: string;
+            sessionId: string;
+            idempotencyKey: string;
+            /** Format: int64 */
+            expectedCompactionRevision: number;
+        };
+        WebShellContextCompressionOperation: {
+            operationId: string;
+            /** Format: uuid */
+            sessionId: string;
+            /** @constant */
+            type: "context_compression";
+            /** @enum {string} */
+            status: "pending" | "running" | "recovery_blocked" | "completed" | "failed";
+            /** Format: int64 */
+            expectedCompactionRevision: number;
+            /** Format: int64 */
+            compactionRevision?: number | null;
+            /** @enum {string|null} */
+            outcome?: "compressed" | "noop" | null;
+            failureCode?: string | null;
+            replayed: boolean;
+        };
+        ManagedMcpServerPin: {
+            serverId: string;
+            serverRevision: number;
+            definitionDigest: string;
+        };
+        ManagedMcpPublishedServer: {
+            serverId: string;
+            serverRevision: number;
+            definitionDigest: string;
+            /** @enum {string} */
+            transport: "stdio" | "streamable-http" | "sse";
+        };
+        ManagedMcpManagementServer: {
+            serverId: string;
+            serverRevision: number;
+            definitionDigest: string;
+            /** @enum {string} */
+            state: "enabled" | "disabled" | "removed";
+        };
+        ManagedMcpManagementOperation: {
+            /** Format: uuid */
+            operationId: string;
+            /** @enum {string} */
+            action: "add" | "edit" | "remove" | "enable" | "disable" | "reload" | "restart";
+            serverId: string;
+            revision: number;
+            /** @enum {string} */
+            state: "pending" | "settled" | "failed" | "recovery_required";
+            error?: {
+                code: string;
+            };
+        };
+        ManagedMcpManagementSnapshot: {
+            sessionId: string;
+            revision: number;
+            supported: boolean;
+            availableServers: components["schemas"]["ManagedMcpPublishedServer"][];
+            servers: components["schemas"]["ManagedMcpManagementServer"][];
+            operation?: components["schemas"]["ManagedMcpManagementOperation"];
+        };
+        WebShellMcpManagementQuery: {
+            sessionId: string;
+            requestId?: string;
+        };
+        WebShellMcpManagementSubmit: {
+            sessionId: string;
+            requestId?: string;
+            idempotencyKey: string;
+            /** @enum {string} */
+            action: "add" | "edit" | "remove" | "enable" | "disable" | "reload" | "restart";
+            serverId: string;
+            expectedRevision: number;
+            server?: components["schemas"]["ManagedMcpServerPin"];
+        };
+        WebShellMcpManagementOperationQuery: {
+            sessionId: string;
+            /** Format: uuid */
+            operationId: string;
+            requestId?: string;
+        };
+        SessionRecoveryActions: {
+            recheck: boolean;
+            cancel: boolean;
+            continueInNewSession: boolean;
+        };
+        /** @description Separate from Session lifecycle and Turn outcome. ready requires affirmative native input settlement and an admissible continuation boundary with no active Java Turn or blocking debt. Actions are authorization-scoped hints, checked again by their mutations. A new-Session action opens an editable text handoff and grants no additional Workspace permission. A cold or unreadable terminal Turn may advertise a proof-checked cleanup recheck while remaining operator_required with nextTurnAllowed=false; only affirmative native evidence after that mutation can establish readiness. */
+        SessionRecovery: {
+            /** @enum {string} */
+            state: "recovering" | "awaiting_evidence" | "cleanup_pending" | "ready" | "operator_required";
+            reasonCode: string;
+            /** @description Public Turn identity; never an internal prompt, checkpoint or execution reference. */
+            turnId?: string;
+            nextTurnAllowed: boolean;
+            actions: components["schemas"]["SessionRecoveryActions"];
+            /**
+             * Format: int64
+             * @description Known next reconciliation time in Unix epoch milliseconds.
+             */
+            nextRecheckAt?: number;
+        };
+        WebShellRecoveryRecheckRequest: {
+            sessionId: string;
+            turnId: string;
+        };
+        WebShellLifecycleOperation: {
+            operationId: string;
+            /** @enum {string} */
+            type: "close" | "archive" | "delete";
+            /** @enum {string} */
+            status: "pending" | "running" | "completed" | "failed" | "recovery_blocked";
+            failureCode?: string | null;
+        };
+        WebShellExportPage: {
+            items: components["schemas"]["WebShellItem"][];
+            nextCursor?: string | null;
+            hasMore: boolean;
+            /** Format: int64 */
+            snapshotThroughSequence: number;
+        };
+        WebShellExportRequest: {
+            /** Format: uuid */
+            sessionId: string;
+            cursor?: string | null;
+            /** @default 100 */
+            limit?: number | null;
+        };
+        /** @description Durable Turn input or cancellation admission. The operation identifies the saved command and remains stable across idempotent retries. */
+        WebShellTurnAdmission: {
+            /** Format: uuid */
+            sessionId: string;
+            turnId: string;
+            status: string;
+            replayed: boolean;
+            /** @description Durable operation identifier for turn submission or cancellation. */
+            operationId: string;
+            /**
+             * @description Persisted admission stage of the operation.
+             * @enum {string}
+             */
+            admissionStage: "java_durable" | "harness_confirmed";
+            /**
+             * @description Current delivery state of the operation.
+             * @enum {string}
+             */
+            deliveryState: "pending" | "leased" | "confirmed" | "blocked";
+        };
+        /** @description Session-scoped portable permission-rules/1. Each rule must be trimmed, nonempty, free of control characters, and at most 512 UTF-8 bytes. At most 32 unique strings per list, 64 across all lists and 8192 UTF-8 bytes of compact JSON. Tool names and aliases match whole tools; MCP names may end with a wildcard. Bash/Shell/run_shell_command/monitor command globs and WebFetch/web_fetch(domain:host) are supported; file-path specifiers and arbitrary tool predicates are rejected. Deny takes precedence over ask, then allow, in every mode. Rules do not provide filesystem or process isolation. */
+        ManagedPermissionRules: {
+            allow: string[];
+            ask: string[];
+            deny: string[];
+        };
+        UserMessage: {
+            id: string;
+            sequence: number;
+            revision: number;
+            /** @enum {string} */
+            state: "queued" | "claimed" | "recovery_blocked";
+            input: {
+                type: string;
+                text?: string;
+                resource?: {
+                    uri: string;
+                    text: string;
+                    mimeType: string;
+                };
+            }[];
+            turnId?: string | null;
+        };
+        UserMessageSnapshot: {
+            paused: boolean;
+            messages: components["schemas"]["UserMessage"][];
+        };
+        /** @description submit queues input; edit only changes queued input. withdraw removes queued input or explicitly discards recovery_blocked input without replaying it. Unknown delivery may already have reached the original Turn: discarding does not undo it, preserves late durable receipts and keeps the queue paused until resume. In-flight claimed input remains immutable. Commands replay the actor-scoped recorded result before checking new-work availability. */
+        UserMessageCommand: {
+            /** @enum {string} */
+            action: "submit" | "edit" | "withdraw" | "resume";
+            messageId?: string;
+            expectedRevision?: number;
+            input?: components["schemas"]["InputBlock"][];
+        };
+        WebShellUserMessageQuery: {
+            sessionId: string;
+        };
+        WebShellUserMessageCommand: {
+            sessionId: string;
+            idempotencyKey: string;
+            command: components["schemas"]["UserMessageCommand"];
+        };
+        ManagedExtensionPackagePin: {
+            extensionId: string;
+            /** Format: int64 */
+            packageRevision: number;
+            packageDigest: string;
+            /** Format: int64 */
+            settingsRevision?: number;
+        };
+        ManagedExtensionPackageManifest: {
+            /** @enum {integer} */
+            schemaVersion: 1;
+            /** @enum {integer} */
+            compilerVersion: 1;
+            name: string;
+            version: string;
+            target: {
+                /** @enum {string} */
+                platform: "linux" | "darwin";
+                /** @enum {string} */
+                arch: "x64" | "arm64" | "any";
+            };
+            components: ("skills" | "commands" | "agents" | "context" | "mcp" | "hooks" | "settings")[];
+            /** @enum {string} */
+            sourceType?: "git" | "github-release" | "npm" | "directory" | "archive" | "archive-url" | "link" | "snapshot";
+            /** @description Exact source commit, resolved npm version, or imported content revision. Supplied together with sourceType. */
+            sourceRevision?: string;
+        };
+        ManagedExtensionPackage: {
+            pin: components["schemas"]["ManagedExtensionPackagePin"];
+            manifest: components["schemas"]["ManagedExtensionPackageManifest"];
+            /** Format: int64 */
+            byteLength: number;
+        };
+        ManagedExtensionPackageCatalog: {
+            supported: boolean;
+            extensions: components["schemas"]["ManagedExtensionPackage"][];
+        };
+        ManagedExtensionPackageSettings: {
+            /** Format: int64 */
+            settingsRevision: number;
+            configuredKeys: string[];
+        };
+        ManagedExtensionPackageOperation: {
+            operationId: string;
+            extensionId: string;
+            /** @enum {string} */
+            kind: "publish" | "settings";
+            /** @enum {string} */
+            state: "pending" | "settled";
+            /** Format: int64 */
+            revision: number;
+            packageDigest: string | null;
+        };
+        WebShellExtensionWorkspaceQuery: {
+            workspaceId: string;
+        };
+        WebShellExtensionQuery: {
+            workspaceId: string;
+            extensionId: string;
+        };
+        WebShellExtensionOperationQuery: {
+            workspaceId: string;
+            operationId: string;
+        };
+        WebShellExtensionPackageQuery: {
+            workspaceId: string;
+            pin: components["schemas"]["ManagedExtensionPackagePin"];
+        };
+        WebShellExtensionSettingsSubmit: {
+            workspaceId: string;
+            extensionId: string;
+            idempotencyKey: string;
+            /** Format: int64 */
+            expectedRevision: number;
+            /** @description Complete settings revision, bounded to 8 KiB UTF-8 JSON. Values are encrypted at rest and never returned by metadata or operation queries. */
+            values: {
+                [key: string]: string;
+            };
+        };
+        ManagedExtensionApplySelection: {
+            expectedConfigRevision: number;
+            extensions: components["schemas"]["ManagedExtensionPackagePin"][];
+        };
+        ManagedExtensionApplyOperation: {
+            /** Format: uuid */
+            operationId: string;
+            /** @enum {string} */
+            state: "preparing" | "prepared" | "committed" | "active" | "recovery_required" | "failed";
+            /** @enum {string} */
+            mode: "apply" | "recoverPrevious";
+            revision: number;
+            error?: {
+                code: string;
+            };
+        };
+        ManagedExtensionManagementSnapshot: {
+            sessionId: string;
+            supported: boolean;
+            revision: number;
+            extensions: components["schemas"]["ManagedExtensionPackagePin"][];
+            requestedExtensions: components["schemas"]["ManagedExtensionPackagePin"][];
+            operation?: components["schemas"]["ManagedExtensionApplyOperation"];
+        };
+        WebShellExtensionSessionQuery: {
+            sessionId: string;
+            /** Format: uuid */
+            operationId?: string;
+        };
+        WebShellExtensionSessionOperation: {
+            sessionId: string;
+            /** Format: uuid */
+            operationId: string;
+        };
+        WebShellExtensionSessionSubmit: {
+            sessionId: string;
+            idempotencyKey: string;
+            command: components["schemas"]["ManagedExtensionApplySelection"];
+        };
+        WebShellWorkspaceFileUploadResult: {
+            scopeRevision: string;
+            /** Format: uuid */
+            uploadId: string;
+            path: string;
+            sizeBytes: number;
+            sha256: string;
+        };
+        WebShellWorkspaceFileUploadStatus: {
+            scopeRevision: string;
+            /** Format: uuid */
+            uploadId: string;
+            path: string;
+            sizeBytes: number;
+            sha256: string;
+            /** @enum {string} */
+            state: "completed" | "failed" | "pending";
+            code?: string;
+        };
+        WebShellWorkspaceFileUploadQueryRequest: {
+            /** Format: uuid */
+            uploadId: string;
+        };
     };
     responses: {
         /** @description The authenticated actor belongs to another tenant than X-Qwen-Tenant-Id or has an invalid ID (actor_scope_mismatch, which the tenant filter answers on every /v1/agents/ and WebShell route), or the resource is readable but the actor lacks this operation or the original Action responder permission. Artifact content reads may also return artifact_content_forbidden when the actor cannot read the original bytes. */
@@ -1839,50 +2566,605 @@ export interface components {
                 [name: string]: unknown;
             };
             content: {
-                "application/json": components["schemas"]["ErrorEnvelope"];
+                "application/json": components["schemas"]["ErrorEnvelope"];
+            };
+        };
+        /** @description Resource absent or outside the caller tenant scope. */
+        NotFound: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorEnvelope"];
+            };
+        };
+        /** @description Replay cursor is older than the retained replay floor. */
+        CursorExpired: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorEnvelope"];
+            };
+        };
+        /** @description Task event cursor is strictly below the task's durable retention floor, which survives an empty retained set; equality is valid. The envelope's replay_floor_sequence and snapshot_through_sequence stay absent because task cursors are opaque. */
+        TaskCursorExpired: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorEnvelope"];
+            };
+        };
+        /** @description A dependency such as the Hosted Harness is unavailable; retry later. */
+        Unavailable: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorEnvelope"];
+            };
+        };
+    };
+    parameters: {
+        IdempotencyKey: string;
+    };
+    requestBodies: never;
+    headers: {
+        /** @description True when an accepted command or operation was replayed for the same idempotency key and digest without repeating its mutation. Session mutation responses represent the recorded outcome on the Session as last visible — a rename or unarchive replay after delete answers with the Session's pre-delete status rather than 404, while a create replay after delete answers 404 on the public create route, which re-reads the Session before responding, and answers the recorded 202 admission carrying the tombstoned sessionId on the WebShell create route, which does not re-read it; operation responses represent the original operation at its current state. */
+        IdempotentReplay: boolean;
+        /** @description Trace-only correlation identifier; never an idempotency key. */
+        RequestId: string;
+    };
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    webShellListSessions: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellListRequest"];
+            };
+        };
+        responses: {
+            /** @description WebShell session page. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellSessionPage"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
+    webShellGetSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellSessionRequest"];
+            };
+        };
+        responses: {
+            /** @description WebShell session. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellSession"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
+    webShellRenameSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellRenameRequest"];
+            };
+        };
+        responses: {
+            /** @description Confirmed persisted Session title, or an authorized completed replay. */
+            200: {
+                headers: {
+                    "X-Request-Id": components["headers"]["RequestId"];
+                    "X-Qwen-Idempotent-Replay": components["headers"]["IdempotentReplay"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellRenameResult"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            413: components["responses"]["PayloadTooLarge"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    webShellTranscript: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellTranscriptRequest"];
+            };
+        };
+        responses: {
+            /** @description Event transcript page. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellTranscript"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
+    webShellStreamEvents: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellStreamRequest"];
+            };
+        };
+        responses: {
+            /** @description SSE stream. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/event-stream": string;
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
+    webShellCreateSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellCreateRequest"];
+            };
+        };
+        responses: {
+            /** @description Session admitted. */
+            202: {
+                headers: {
+                    "X-Request-Id": components["headers"]["RequestId"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellAdmission"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            413: components["responses"]["PayloadTooLarge"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    webShellSubmitTurn: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellSubmitRequest"];
+            };
+        };
+        responses: {
+            /** @description Turn admitted. */
+            202: {
+                headers: {
+                    "X-Request-Id": components["headers"]["RequestId"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellTurnAdmission"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
+    webShellCancelTurn: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellCancelRequest"];
+            };
+        };
+        responses: {
+            /** @description Cancellation durably admitted. */
+            202: {
+                headers: {
+                    "X-Request-Id": components["headers"]["RequestId"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellTurnAdmission"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
+    webShellQueryWorkspaces: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellWorkspaceQueryRequest"];
+            };
+        };
+        responses: {
+            /** @description Authorized durable resource view; no Runtime startup required. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellWorkspacePage"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
+    webShellQueryCwdOperation: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellOperationRequest"];
+            };
+        };
+        responses: {
+            /** @description Same authorized operation semantics as the public API. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellOperation"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
+    queryWebShellActions: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellActionQueryRequest"];
+            };
+        };
+        responses: {
+            /** @description Same authorized operation semantics as the public API. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellActionPage"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            /** @description Unknown or unreadable Session (session_not_found), or unknown Action (action_not_found). */
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
+    getWebShellAction: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellActionGetRequest"];
+            };
+        };
+        responses: {
+            /** @description Same authorized operation semantics as the public API. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellAction"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            /** @description Unknown or unreadable Session (session_not_found), or unknown Action (action_not_found). */
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
+    respondWebShellAction: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellActionRespondRequest"];
+            };
+        };
+        responses: {
+            /** @description Same authorized operation semantics as the public API. */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellCommandOperation"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            /** @description Responding requires the Session's recorded owner or a Workspace OPERATOR (action_forbidden); a Shell Session's Actions may be answered only by its recorded owner. An unbound Session with no recorded creator and no recorded create command (anonymous open-mode creation, or an unbound Session created before the V40 migration that also has no Workspace creation record) answers to any caller in its tenant, matching its read ACL; a bound Session with no recorded owner answers through the create-command actor recorded for it, or through the Workspace role arm. The tenant filter's 403 actor_scope_mismatch also applies on this route. */
+            403: components["responses"]["Forbidden"];
+            /** @description Unknown or unreadable Session (session_not_found), or unknown Action (action_not_found). */
+            404: components["responses"]["NotFound"];
+            /** @description Idempotency conflict, a non-active Session (session_inactive), or an ended Action (action_expired, action_cancelled, action_already_resolved). An existing matching response replays before the Session-state check. */
+            409: components["responses"]["Conflict"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
+    closeWebShellSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellLifecycleRequest"];
+            };
+        };
+        responses: {
+            /** @description Same authorized operation semantics as the public API. */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellCommandOperation"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
+    archiveWebShellSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellLifecycleRequest"];
+            };
+        };
+        responses: {
+            /** @description Same authorized operation semantics as the public API. */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellCommandOperation"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
+    deleteWebShellSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellLifecycleRequest"];
             };
         };
-        /** @description Resource absent or outside the caller tenant scope. */
-        NotFound: {
-            headers: {
-                [name: string]: unknown;
+        responses: {
+            /** @description Same authorized operation semantics as the public API. */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellCommandOperation"];
+                };
             };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
+    webShellGetWorkspace: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
             content: {
-                "application/json": components["schemas"]["ErrorEnvelope"];
+                "application/json": components["schemas"]["WebShellWorkspaceGetRequest"];
             };
         };
-        /** @description Task event cursor is strictly below the task's durable retention floor, which survives an empty retained set; equality is valid. The envelope's replay_floor_sequence and snapshot_through_sequence stay absent because task cursors are opaque. */
-        TaskCursorExpired: {
-            headers: {
-                [name: string]: unknown;
+        responses: {
+            /** @description Authorized durable resource view; no Runtime startup required. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellWorkspace"];
+                };
             };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
+    queryWebShellTasks: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
             content: {
-                "application/json": components["schemas"]["ErrorEnvelope"];
+                "application/json": components["schemas"]["WebShellTaskQueryRequest"];
             };
         };
-        /** @description A dependency such as the Hosted Harness is unavailable; retry later. */
-        Unavailable: {
-            headers: {
-                [name: string]: unknown;
-            };
-            content: {
-                "application/json": components["schemas"]["ErrorEnvelope"];
+        responses: {
+            /** @description Same authorized task semantics as the public API. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellTaskPage"];
+                };
             };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            413: components["responses"]["PayloadTooLarge"];
         };
     };
-    parameters: never;
-    requestBodies: never;
-    headers: {
-        /** @description True when an accepted command or operation was replayed for the same idempotency key and digest without repeating its mutation. Session mutation responses represent the recorded outcome on the Session as last visible — a rename or unarchive replay after delete answers with the Session's pre-delete status rather than 404, while a create replay after delete answers 404 on the public create route, which re-reads the Session before responding, and answers the recorded 202 admission carrying the tombstoned sessionId on the WebShell create route, which does not re-read it; operation responses represent the original operation at its current state. */
-        IdempotentReplay: boolean;
-        /** @description Trace-only correlation identifier; never an idempotency key. */
-        RequestId: string;
-    };
-    pathItems: never;
-}
-export type $defs = Record<string, never>;
-export interface operations {
-    webShellListSessions: {
+    getWebShellTask: {
         parameters: {
             query?: never;
             header?: never;
@@ -1891,26 +3173,27 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellListRequest"];
+                "application/json": components["schemas"]["WebShellTaskGetRequest"];
             };
         };
         responses: {
-            /** @description WebShell session page. */
+            /** @description Same authorized task semantics as the public API. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellSessionPage"];
+                    "application/json": components["schemas"]["WebShellTask"];
                 };
             };
             400: components["responses"]["BadRequest"];
             401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
             413: components["responses"]["PayloadTooLarge"];
         };
     };
-    webShellGetSession: {
+    queryWebShellTaskEvents: {
         parameters: {
             query?: never;
             header?: never;
@@ -1919,27 +3202,28 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellSessionRequest"];
+                "application/json": components["schemas"]["WebShellTaskEventQueryRequest"];
             };
         };
         responses: {
-            /** @description WebShell session. */
+            /** @description Same authorized task semantics as the public task events route, including the durable retention floor, committed-prefix publication, Artifact recovery order and client tolerance of unknown optional fields and event types. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellSession"];
+                    "application/json": components["schemas"]["WebShellTaskEventPage"];
                 };
             };
             400: components["responses"]["BadRequest"];
             401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
+            409: components["responses"]["TaskCursorExpired"];
             413: components["responses"]["PayloadTooLarge"];
         };
     };
-    webShellRenameSession: {
+    cancelWebShellTask: {
         parameters: {
             query?: never;
             header?: never;
@@ -1948,19 +3232,18 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellRenameRequest"];
+                "application/json": components["schemas"]["WebShellTaskCancelRequest"];
             };
         };
         responses: {
-            /** @description Confirmed persisted Session title, or an authorized completed replay. */
-            200: {
+            /** @description Same authorized task cancellation semantics as the public API: key validation, current access, idempotent replay, then new-request capability, Session, task and storage-migration checks (409 workspace_unavailable under a migration fence). Replay returns the same operation and latest durable state. 202 is durable admission, completed is authority acceptance, and neither proves physical stop. Admission requires no other open operation on the Session (409 session_operation_active), as on the lifecycle routes. A requestId in the body becomes the response's X-Request-Id and stays out of the request digest. */
+            202: {
                 headers: {
                     "X-Request-Id": components["headers"]["RequestId"];
-                    "X-Qwen-Idempotent-Replay": components["headers"]["IdempotentReplay"];
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellRenameResult"];
+                    "application/json": components["schemas"]["WebShellCommandOperation"];
                 };
             };
             400: components["responses"]["BadRequest"];
@@ -1969,10 +3252,9 @@ export interface operations {
             404: components["responses"]["NotFound"];
             409: components["responses"]["Conflict"];
             413: components["responses"]["PayloadTooLarge"];
-            503: components["responses"]["Unavailable"];
         };
     };
-    webShellTranscript: {
+    getWebShellToolResult: {
         parameters: {
             query?: never;
             header?: never;
@@ -1981,27 +3263,61 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellTranscriptRequest"];
+                "application/json": components["schemas"]["WebShellToolResultRequest"];
             };
         };
         responses: {
-            /** @description Event transcript page. */
+            /** @description Authorized persisted tool result resource. */
             200: {
                 headers: {
+                    "Cache-Control"?: "private, no-store";
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellTranscript"];
+                    "application/json": components["schemas"]["ToolResultResponse"];
+                };
+            };
+            /** @description Invalid request. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
+                };
+            };
+            /** @description Trusted actor required. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
                 };
             };
-            400: components["responses"]["BadRequest"];
-            401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
-            404: components["responses"]["NotFound"];
+            /** @description Unknown or unreadable resource. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
+                };
+            };
             413: components["responses"]["PayloadTooLarge"];
+            /** @description Resource temporarily unavailable. */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
+                };
+            };
         };
     };
-    webShellStreamEvents: {
+    getWebShellArtifact: {
         parameters: {
             query?: never;
             header?: never;
@@ -2010,27 +3326,61 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellStreamRequest"];
+                "application/json": components["schemas"]["WebShellArtifactRequest"];
             };
         };
         responses: {
-            /** @description SSE stream. */
+            /** @description Authorized persisted artifact metadata. */
             200: {
                 headers: {
+                    "Cache-Control"?: "private, no-store";
                     [name: string]: unknown;
                 };
                 content: {
-                    "text/event-stream": string;
+                    "application/json": components["schemas"]["ArtifactResponse"];
+                };
+            };
+            /** @description Invalid request. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
+                };
+            };
+            /** @description Trusted actor required. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
                 };
             };
-            400: components["responses"]["BadRequest"];
-            401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
-            404: components["responses"]["NotFound"];
+            /** @description Unknown or unreadable resource. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
+                };
+            };
             413: components["responses"]["PayloadTooLarge"];
+            /** @description Resource temporarily unavailable. */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
+                };
+            };
         };
     };
-    webShellCreateSession: {
+    queryWebShellArtifacts: {
         parameters: {
             query?: never;
             header?: never;
@@ -2039,30 +3389,61 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellCreateRequest"];
+                "application/json": components["schemas"]["WebShellArtifactQueryRequest"];
             };
         };
         responses: {
-            /** @description Session admitted. */
-            202: {
+            /** @description Authorized artifact metadata page. */
+            200: {
+                headers: {
+                    "Cache-Control"?: "private, no-store";
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellArtifactPage"];
+                };
+            };
+            /** @description Invalid request. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
+                };
+            };
+            /** @description Trusted actor required. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
+                };
+            };
+            403: components["responses"]["Forbidden"];
+            /** @description Unknown or unreadable resource. */
+            404: {
                 headers: {
-                    "X-Request-Id": components["headers"]["RequestId"];
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellAdmission"];
+                    "application/json": components["schemas"]["ErrorEnvelope"];
                 };
             };
-            400: components["responses"]["BadRequest"];
-            401: components["responses"]["Unauthorized"];
-            403: components["responses"]["Forbidden"];
-            404: components["responses"]["NotFound"];
-            409: components["responses"]["Conflict"];
             413: components["responses"]["PayloadTooLarge"];
-            503: components["responses"]["Unavailable"];
+            /** @description Resource temporarily unavailable. */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
+                };
+            };
         };
     };
-    webShellSubmitTurn: {
+    unarchiveWebShellSession: {
         parameters: {
             query?: never;
             header?: never;
@@ -2071,18 +3452,18 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellSubmitRequest"];
+                "application/json": components["schemas"]["WebShellLifecycleRequest"];
             };
         };
         responses: {
-            /** @description Turn admitted. */
-            202: {
+            /** @description Current WebShell Session; replay does not repeat the mutation. */
+            200: {
                 headers: {
-                    "X-Request-Id": components["headers"]["RequestId"];
+                    "X-Qwen-Idempotent-Replay": components["headers"]["IdempotentReplay"];
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellAdmission"];
+                    "application/json": components["schemas"]["WebShellSession"];
                 };
             };
             400: components["responses"]["BadRequest"];
@@ -2093,7 +3474,7 @@ export interface operations {
             413: components["responses"]["PayloadTooLarge"];
         };
     };
-    webShellCancelTurn: {
+    webShellCreateWorkspace: {
         parameters: {
             query?: never;
             header?: never;
@@ -2102,18 +3483,17 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellCancelRequest"];
+                "application/json": components["schemas"]["WebShellWorkspaceCreateRequest"];
             };
         };
         responses: {
-            /** @description Cancellation durably admitted. */
-            202: {
+            /** @description Created Workspace or authorized same-key replay. */
+            200: {
                 headers: {
-                    "X-Request-Id": components["headers"]["RequestId"];
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellAdmission"];
+                    "application/json": components["schemas"]["WebShellWorkspace"];
                 };
             };
             400: components["responses"]["BadRequest"];
@@ -2124,7 +3504,7 @@ export interface operations {
             413: components["responses"]["PayloadTooLarge"];
         };
     };
-    webShellQueryWorkspaces: {
+    queryWebShellSessionOptions: {
         parameters: {
             query?: never;
             header?: never;
@@ -2133,17 +3513,17 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellWorkspaceQueryRequest"];
+                "application/json": components["schemas"]["WebShellSessionOptionsRequest"];
             };
         };
         responses: {
-            /** @description Authorized durable resource view; no Runtime startup required. */
+            /** @description Effective default and supported policies. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellWorkspacePage"];
+                    "application/json": components["schemas"]["WebShellSessionOptions"];
                 };
             };
             400: components["responses"]["BadRequest"];
@@ -2153,7 +3533,7 @@ export interface operations {
             413: components["responses"]["PayloadTooLarge"];
         };
     };
-    webShellChangeCwd: {
+    queryWebShellSessionModels: {
         parameters: {
             query?: never;
             header?: never;
@@ -2162,17 +3542,17 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellChangeCwdRequest"];
+                "application/json": components["schemas"]["WebShellSessionModelsRequest"];
             };
         };
         responses: {
-            /** @description Durable cwd operation; acceptance does not mean the new cwd is active. */
-            202: {
+            /** @description Session model options. */
+            200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellCwdOperation"];
+                    "application/json": components["schemas"]["WebShellSessionModels"];
                 };
             };
             400: components["responses"]["BadRequest"];
@@ -2183,7 +3563,7 @@ export interface operations {
             413: components["responses"]["PayloadTooLarge"];
         };
     };
-    webShellQueryCwdOperation: {
+    changeWebShellSessionModel: {
         parameters: {
             query?: never;
             header?: never;
@@ -2192,17 +3572,17 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellOperationRequest"];
+                "application/json": components["schemas"]["WebShellChangeModelRequest"];
             };
         };
         responses: {
-            /** @description Same authorized operation semantics as the public API. */
+            /** @description The admitted model selection, or the same original result on replay. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellOperation"];
+                    "application/json": components["schemas"]["WebShellModelChangeResult"];
                 };
             };
             400: components["responses"]["BadRequest"];
@@ -2213,7 +3593,7 @@ export interface operations {
             413: components["responses"]["PayloadTooLarge"];
         };
     };
-    queryWebShellActions: {
+    queryWebShellSessionApproval: {
         parameters: {
             query?: never;
             header?: never;
@@ -2222,29 +3602,28 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellActionQueryRequest"];
+                "application/json": components["schemas"]["WebShellSessionApprovalRequest"];
             };
         };
         responses: {
-            /** @description Same authorized operation semantics as the public API. */
+            /** @description The current policy options. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellActionPage"];
+                    "application/json": components["schemas"]["WebShellSessionApproval"];
                 };
             };
             400: components["responses"]["BadRequest"];
             401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
-            /** @description Unknown or unreadable Session (session_not_found), or unknown Action (action_not_found). */
             404: components["responses"]["NotFound"];
             409: components["responses"]["Conflict"];
             413: components["responses"]["PayloadTooLarge"];
         };
     };
-    getWebShellAction: {
+    changeWebShellSessionApproval: {
         parameters: {
             query?: never;
             header?: never;
@@ -2253,62 +3632,54 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellActionGetRequest"];
+                "application/json": components["schemas"]["WebShellChangeApprovalRequest"];
             };
         };
         responses: {
-            /** @description Same authorized operation semantics as the public API. */
+            /** @description The committed approval selection, or its original receipt on replay. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellAction"];
+                    "application/json": components["schemas"]["WebShellApprovalChangeResult"];
                 };
             };
             400: components["responses"]["BadRequest"];
             401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
-            /** @description Unknown or unreadable Session (session_not_found), or unknown Action (action_not_found). */
             404: components["responses"]["NotFound"];
             409: components["responses"]["Conflict"];
             413: components["responses"]["PayloadTooLarge"];
         };
     };
-    respondWebShellAction: {
+    webShellQueryRuntimeNodes: {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["WebShellActionRespondRequest"];
-            };
-        };
+        requestBody?: never;
         responses: {
-            /** @description Same authorized operation semantics as the public API. */
-            202: {
+            /** @description SSH registration capability and authorized machine display names. */
+            200: {
                 headers: {
+                    "X-Request-Id": components["headers"]["RequestId"];
+                    "Cache-Control"?: "no-store";
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellCommandOperation"];
+                    "application/json": components["schemas"]["WebShellRuntimeNodePage"];
                 };
             };
             400: components["responses"]["BadRequest"];
             401: components["responses"]["Unauthorized"];
-            /** @description Responding requires the Session's recorded owner or a Workspace OPERATOR (action_forbidden); a Shell Session's Actions may be answered only by its recorded owner. An unbound Session with no recorded creator and no recorded create command (anonymous open-mode creation, or an unbound Session created before the V40 migration that also has no Workspace creation record) answers to any caller in its tenant, matching its read ACL; a bound Session with no recorded owner answers through the create-command actor recorded for it, or through the Workspace role arm. The tenant filter's 403 actor_scope_mismatch also applies on this route. */
             403: components["responses"]["Forbidden"];
-            /** @description Unknown or unreadable Session (session_not_found), or unknown Action (action_not_found). */
-            404: components["responses"]["NotFound"];
-            /** @description Idempotency conflict, a non-active Session (session_inactive), or an ended Action (action_expired, action_cancelled, action_already_resolved). An existing matching response replays before the Session-state check. */
-            409: components["responses"]["Conflict"];
             413: components["responses"]["PayloadTooLarge"];
         };
     };
-    closeWebShellSession: {
+    webShellCheckWorkspaceDirectory: {
         parameters: {
             query?: never;
             header?: never;
@@ -2317,17 +3688,19 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellLifecycleRequest"];
+                "application/json": components["schemas"]["WebShellWorkspaceDirectoryRequest"];
             };
         };
         responses: {
-            /** @description Same authorized operation semantics as the public API. */
-            202: {
+            /** @description Validated canonical directory on the selected Linux or macOS node. */
+            200: {
                 headers: {
+                    "X-Request-Id": components["headers"]["RequestId"];
+                    "Cache-Control"?: "no-store";
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellCommandOperation"];
+                    "application/json": components["schemas"]["WebShellWorkspaceDirectory"];
                 };
             };
             400: components["responses"]["BadRequest"];
@@ -2336,9 +3709,19 @@ export interface operations {
             404: components["responses"]["NotFound"];
             409: components["responses"]["Conflict"];
             413: components["responses"]["PayloadTooLarge"];
+            /** @description The SSH bootstrap response is invalid. */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
+                };
+            };
+            503: components["responses"]["Unavailable"];
         };
     };
-    archiveWebShellSession: {
+    webShellGetWorkspaceOperation: {
         parameters: {
             query?: never;
             header?: never;
@@ -2347,28 +3730,29 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellLifecycleRequest"];
+                "application/json": components["schemas"]["WebShellWorkspaceOperationRequest"];
             };
         };
         responses: {
-            /** @description Same authorized operation semantics as the public API. */
-            202: {
+            /** @description Latest durable state of the original actor-owned registration. */
+            200: {
                 headers: {
+                    "X-Request-Id": components["headers"]["RequestId"];
+                    "Cache-Control"?: "no-store";
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellCommandOperation"];
+                    "application/json": components["schemas"]["WebShellWorkspaceCreateOperation"];
                 };
             };
             400: components["responses"]["BadRequest"];
             401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
-            409: components["responses"]["Conflict"];
             413: components["responses"]["PayloadTooLarge"];
         };
     };
-    deleteWebShellSession: {
+    webShellRegisterWorkspace: {
         parameters: {
             query?: never;
             header?: never;
@@ -2377,17 +3761,19 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellLifecycleRequest"];
+                "application/json": components["schemas"]["WebShellWorkspaceRegisterRequest"];
             };
         };
         responses: {
-            /** @description Same authorized operation semantics as the public API. */
+            /** @description Durable registration operation; repeated requests retain the original identity. */
             202: {
                 headers: {
+                    "X-Request-Id": components["headers"]["RequestId"];
+                    "Cache-Control"?: "no-store";
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellCommandOperation"];
+                    "application/json": components["schemas"]["WebShellWorkspaceCreateOperation"];
                 };
             };
             400: components["responses"]["BadRequest"];
@@ -2398,7 +3784,7 @@ export interface operations {
             413: components["responses"]["PayloadTooLarge"];
         };
     };
-    webShellGetWorkspace: {
+    queryWebShellWorkspaceDirectories: {
         parameters: {
             query?: never;
             header?: never;
@@ -2407,27 +3793,27 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellWorkspaceGetRequest"];
+                "application/json": components["schemas"]["WebShellWorkspaceDirectoryQueryRequest"];
             };
         };
         responses: {
-            /** @description Authorized durable resource view; no Runtime startup required. */
+            /** @description Authorized existing directories. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellWorkspace"];
+                    "application/json": components["schemas"]["WebShellWorkspaceDirectoryPage"];
                 };
             };
             400: components["responses"]["BadRequest"];
             401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
-            413: components["responses"]["PayloadTooLarge"];
+            409: components["responses"]["Conflict"];
         };
     };
-    queryWebShellTasks: {
+    queryWebShellSessionMcp: {
         parameters: {
             query?: never;
             header?: never;
@@ -2436,17 +3822,17 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellTaskQueryRequest"];
+                "application/json": components["schemas"]["WebShellSessionRequest"];
             };
         };
         responses: {
-            /** @description Same authorized task semantics as the public API. */
+            /** @description Session MCP catalog snapshot. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellTaskPage"];
+                    "application/json": components["schemas"]["PublicMcpCatalog"];
                 };
             };
             400: components["responses"]["BadRequest"];
@@ -2456,7 +3842,7 @@ export interface operations {
             413: components["responses"]["PayloadTooLarge"];
         };
     };
-    getWebShellTask: {
+    queryWebShellSessionSkills: {
         parameters: {
             query?: never;
             header?: never;
@@ -2465,27 +3851,28 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellTaskGetRequest"];
+                "application/json": components["schemas"]["WebShellSessionRequest"];
             };
         };
         responses: {
-            /** @description Same authorized task semantics as the public API. */
+            /** @description Session static Skill metadata. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellTask"];
+                    "application/json": components["schemas"]["WebShellSessionSkills"];
                 };
             };
             400: components["responses"]["BadRequest"];
             401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
             413: components["responses"]["PayloadTooLarge"];
         };
     };
-    queryWebShellTaskEvents: {
+    webShellWorkspaceFilesQuery: {
         parameters: {
             query?: never;
             header?: never;
@@ -2494,28 +3881,28 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellTaskEventQueryRequest"];
+                "application/json": components["schemas"]["WebShellWorkspaceFileQueryRequest"];
             };
         };
         responses: {
-            /** @description Same authorized task semantics as the public task events route, including the durable retention floor, committed-prefix publication, Artifact recovery order and client tolerance of unknown optional fields and event types. */
+            /** @description Authorized Workspace file result. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellTaskEventPage"];
+                    "application/json": components["schemas"]["WebShellWorkspaceFilePage"];
                 };
             };
             400: components["responses"]["BadRequest"];
             401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
-            409: components["responses"]["TaskCursorExpired"];
-            413: components["responses"]["PayloadTooLarge"];
+            409: components["responses"]["Conflict"];
+            503: components["responses"]["Unavailable"];
         };
     };
-    cancelWebShellTask: {
+    webShellWorkspaceFilesRead: {
         parameters: {
             query?: never;
             header?: never;
@@ -2524,18 +3911,17 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellTaskCancelRequest"];
+                "application/json": components["schemas"]["WebShellWorkspaceFileReadRequest"];
             };
         };
         responses: {
-            /** @description Same authorized task cancellation semantics as the public API: key validation, current access, idempotent replay, then new-request capability, Session, task and storage-migration checks (409 workspace_unavailable under a migration fence). Replay returns the same operation and latest durable state. 202 is durable admission, completed is authority acceptance, and neither proves physical stop. Admission requires no other open operation on the Session (409 session_operation_active), as on the lifecycle routes. A requestId in the body becomes the response's X-Request-Id and stays out of the request digest. */
-            202: {
+            /** @description Authorized Workspace file result. */
+            200: {
                 headers: {
-                    "X-Request-Id": components["headers"]["RequestId"];
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellCommandOperation"];
+                    "application/json": components["schemas"]["WebShellWorkspaceFileSnapshot"];
                 };
             };
             400: components["responses"]["BadRequest"];
@@ -2543,10 +3929,10 @@ export interface operations {
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
             409: components["responses"]["Conflict"];
-            413: components["responses"]["PayloadTooLarge"];
+            503: components["responses"]["Unavailable"];
         };
     };
-    getWebShellToolResult: {
+    getWebShellToolDetails: {
         parameters: {
             query?: never;
             header?: never;
@@ -2559,14 +3945,14 @@ export interface operations {
             };
         };
         responses: {
-            /** @description Authorized persisted tool result resource. */
+            /** @description Bounded saved ReadFile/Shell input and text output, read on demand; requires a trusted actor and current Session/Workspace read access. Available to authorized readers without a feature switch. */
             200: {
                 headers: {
                     "Cache-Control"?: "private, no-store";
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["ToolResultResponse"];
+                    "application/json": components["schemas"]["WebShellToolDetails"];
                 };
             };
             /** @description Invalid request. */
@@ -2597,6 +3983,7 @@ export interface operations {
                     "application/json": components["schemas"]["ErrorEnvelope"];
                 };
             };
+            409: components["responses"]["Conflict"];
             413: components["responses"]["PayloadTooLarge"];
             /** @description Resource temporarily unavailable. */
             503: {
@@ -2609,7 +3996,7 @@ export interface operations {
             };
         };
     };
-    getWebShellArtifact: {
+    webShellCompressContext: {
         parameters: {
             query?: never;
             header?: never;
@@ -2618,61 +4005,28 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellArtifactRequest"];
+                "application/json": components["schemas"]["WebShellContextCompressionRequest"];
             };
         };
-        responses: {
-            /** @description Authorized persisted artifact metadata. */
-            200: {
-                headers: {
-                    "Cache-Control"?: "private, no-store";
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["ArtifactResponse"];
-                };
-            };
-            /** @description Invalid request. */
-            400: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["ErrorEnvelope"];
-                };
-            };
-            /** @description Trusted actor required. */
-            401: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["ErrorEnvelope"];
-                };
-            };
-            403: components["responses"]["Forbidden"];
-            /** @description Unknown or unreadable resource. */
-            404: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["ErrorEnvelope"];
-                };
-            };
-            413: components["responses"]["PayloadTooLarge"];
-            /** @description Resource temporarily unavailable. */
-            503: {
+        responses: {
+            /** @description Durable context compression operation. */
+            202: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["ErrorEnvelope"];
+                    "application/json": components["schemas"]["WebShellContextCompressionOperation"];
                 };
             };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            413: components["responses"]["PayloadTooLarge"];
         };
     };
-    queryWebShellArtifacts: {
+    queryWebShellSessionMcpManagement: {
         parameters: {
             query?: never;
             header?: never;
@@ -2681,22 +4035,27 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellArtifactQueryRequest"];
+                "application/json": components["schemas"]["WebShellMcpManagementQuery"];
             };
         };
         responses: {
-            /** @description Authorized artifact metadata page. */
+            /** @description Session-local MCP settings and operation snapshot. Inventory describes published pins rather than live connection health; operation status omits inventory. */
             200: {
                 headers: {
-                    "Cache-Control"?: "private, no-store";
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellArtifactPage"];
+                    "application/json": components["schemas"]["ManagedMcpManagementSnapshot"];
                 };
             };
-            /** @description Invalid request. */
-            400: {
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            413: components["responses"]["PayloadTooLarge"];
+            /** @description The original MCP Runtime or management operation cannot be confirmed. Retry the same operation identity. */
+            503: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -2704,27 +4063,37 @@ export interface operations {
                     "application/json": components["schemas"]["ErrorEnvelope"];
                 };
             };
-            /** @description Trusted actor required. */
-            401: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["ErrorEnvelope"];
-                };
+        };
+    };
+    submitWebShellSessionMcpManagement: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellMcpManagementSubmit"];
             };
-            403: components["responses"]["Forbidden"];
-            /** @description Unknown or unreadable resource. */
-            404: {
+        };
+        responses: {
+            /** @description Session-local MCP settings and operation snapshot. Inventory describes published pins rather than live connection health; operation status omits inventory. */
+            200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["ErrorEnvelope"];
+                    "application/json": components["schemas"]["ManagedMcpManagementSnapshot"];
                 };
             };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
             413: components["responses"]["PayloadTooLarge"];
-            /** @description Resource temporarily unavailable. */
+            /** @description The original MCP Runtime or management operation cannot be confirmed. Retry the same operation identity. */
             503: {
                 headers: {
                     [name: string]: unknown;
@@ -2735,7 +4104,7 @@ export interface operations {
             };
         };
     };
-    unarchiveWebShellSession: {
+    queryWebShellSessionMcpManagementOperation: {
         parameters: {
             query?: never;
             header?: never;
@@ -2744,18 +4113,17 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellLifecycleRequest"];
+                "application/json": components["schemas"]["WebShellMcpManagementOperationQuery"];
             };
         };
         responses: {
-            /** @description Current WebShell Session; replay does not repeat the mutation. */
+            /** @description Session-local MCP settings and operation snapshot. Inventory describes published pins rather than live connection health; operation status omits inventory. */
             200: {
                 headers: {
-                    "X-Qwen-Idempotent-Replay": components["headers"]["IdempotentReplay"];
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellSession"];
+                    "application/json": components["schemas"]["ManagedMcpManagementSnapshot"];
                 };
             };
             400: components["responses"]["BadRequest"];
@@ -2764,9 +4132,18 @@ export interface operations {
             404: components["responses"]["NotFound"];
             409: components["responses"]["Conflict"];
             413: components["responses"]["PayloadTooLarge"];
+            /** @description The original MCP Runtime or management operation cannot be confirmed. Retry the same operation identity. */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
+                };
+            };
         };
     };
-    webShellCreateWorkspace: {
+    queryWebShellSessionRecovery: {
         parameters: {
             query?: never;
             header?: never;
@@ -2775,17 +4152,17 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellWorkspaceCreateRequest"];
+                "application/json": components["schemas"]["WebShellSessionRequest"];
             };
         };
         responses: {
-            /** @description Created Workspace or authorized same-key replay. */
+            /** @description Current recovery evidence. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellWorkspace"];
+                    "application/json": components["schemas"]["SessionRecovery"];
                 };
             };
             400: components["responses"]["BadRequest"];
@@ -2794,9 +4171,10 @@ export interface operations {
             404: components["responses"]["NotFound"];
             409: components["responses"]["Conflict"];
             413: components["responses"]["PayloadTooLarge"];
+            503: components["responses"]["Unavailable"];
         };
     };
-    queryWebShellSessionOptions: {
+    recheckWebShellSessionRecovery: {
         parameters: {
             query?: never;
             header?: never;
@@ -2805,27 +4183,29 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellSessionOptionsRequest"];
+                "application/json": components["schemas"]["WebShellRecoveryRecheckRequest"];
             };
         };
         responses: {
-            /** @description Effective default and supported policies. */
-            200: {
+            /** @description Current recovery evidence; recheck admission is not settlement. */
+            202: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellSessionOptions"];
+                    "application/json": components["schemas"]["SessionRecovery"];
                 };
             };
             400: components["responses"]["BadRequest"];
             401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
             413: components["responses"]["PayloadTooLarge"];
+            503: components["responses"]["Unavailable"];
         };
     };
-    queryWebShellSessionModels: {
+    webShellExportSession: {
         parameters: {
             query?: never;
             header?: never;
@@ -2834,28 +4214,28 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellSessionModelsRequest"];
+                "application/json": components["schemas"]["WebShellExportRequest"];
             };
         };
         responses: {
-            /** @description Session model options. */
+            /** @description Immutable public item snapshot page. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellSessionModels"];
+                    "application/json": components["schemas"]["WebShellExportPage"];
                 };
             };
             400: components["responses"]["BadRequest"];
             401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
-            409: components["responses"]["Conflict"];
+            409: components["responses"]["CursorExpired"];
             413: components["responses"]["PayloadTooLarge"];
         };
     };
-    changeWebShellSessionModel: {
+    webShellQueryUserMessages: {
         parameters: {
             query?: never;
             header?: never;
@@ -2864,17 +4244,17 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellChangeModelRequest"];
+                "application/json": components["schemas"]["WebShellUserMessageQuery"];
             };
         };
         responses: {
-            /** @description The admitted model selection, or the same original result on replay. */
+            /** @description Authoritative queue snapshot */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellModelChangeResult"];
+                    "application/json": components["schemas"]["UserMessageSnapshot"];
                 };
             };
             400: components["responses"]["BadRequest"];
@@ -2883,9 +4263,10 @@ export interface operations {
             404: components["responses"]["NotFound"];
             409: components["responses"]["Conflict"];
             413: components["responses"]["PayloadTooLarge"];
+            503: components["responses"]["Unavailable"];
         };
     };
-    queryWebShellSessionApproval: {
+    webShellCommandUserMessages: {
         parameters: {
             query?: never;
             header?: never;
@@ -2894,17 +4275,17 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellSessionApprovalRequest"];
+                "application/json": components["schemas"]["WebShellUserMessageCommand"];
             };
         };
         responses: {
-            /** @description The current policy options. */
+            /** @description Authoritative queue snapshot */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellSessionApproval"];
+                    "application/json": components["schemas"]["UserMessageSnapshot"];
                 };
             };
             400: components["responses"]["BadRequest"];
@@ -2913,9 +4294,10 @@ export interface operations {
             404: components["responses"]["NotFound"];
             409: components["responses"]["Conflict"];
             413: components["responses"]["PayloadTooLarge"];
+            503: components["responses"]["Unavailable"];
         };
     };
-    changeWebShellSessionApproval: {
+    queryWorkspaceExtensionPackages: {
         parameters: {
             query?: never;
             header?: never;
@@ -2924,17 +4306,17 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellChangeApprovalRequest"];
+                "application/json": components["schemas"]["WebShellExtensionWorkspaceQuery"];
             };
         };
         responses: {
-            /** @description The committed approval selection, or its original receipt on replay. */
+            /** @description Persisted Workspace extension resource. Contains no settings values or executable recipes. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellApprovalChangeResult"];
+                    "application/json": components["schemas"]["ManagedExtensionPackageCatalog"];
                 };
             };
             400: components["responses"]["BadRequest"];
@@ -2945,33 +4327,37 @@ export interface operations {
             413: components["responses"]["PayloadTooLarge"];
         };
     };
-    webShellQueryRuntimeNodes: {
+    queryWorkspaceExtensionPackage: {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellExtensionPackageQuery"];
+            };
+        };
         responses: {
-            /** @description SSH registration capability and authorized machine display names. */
+            /** @description Persisted Workspace extension resource. Contains no settings values or executable recipes. */
             200: {
                 headers: {
-                    "X-Request-Id": components["headers"]["RequestId"];
-                    "Cache-Control"?: "no-store";
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellRuntimeNodePage"];
+                    "application/json": components["schemas"]["ManagedExtensionPackage"];
                 };
             };
             400: components["responses"]["BadRequest"];
             401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
             413: components["responses"]["PayloadTooLarge"];
         };
     };
-    webShellCheckWorkspaceDirectory: {
+    queryWorkspaceExtensionPackageSettings: {
         parameters: {
             query?: never;
             header?: never;
@@ -2980,19 +4366,17 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellWorkspaceDirectoryRequest"];
+                "application/json": components["schemas"]["WebShellExtensionQuery"];
             };
         };
         responses: {
-            /** @description Validated canonical directory on the selected Linux or macOS node. */
+            /** @description Persisted Workspace extension resource. Contains no settings values or executable recipes. */
             200: {
                 headers: {
-                    "X-Request-Id": components["headers"]["RequestId"];
-                    "Cache-Control"?: "no-store";
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellWorkspaceDirectory"];
+                    "application/json": components["schemas"]["ManagedExtensionPackageSettings"];
                 };
             };
             400: components["responses"]["BadRequest"];
@@ -3001,19 +4385,9 @@ export interface operations {
             404: components["responses"]["NotFound"];
             409: components["responses"]["Conflict"];
             413: components["responses"]["PayloadTooLarge"];
-            /** @description The SSH bootstrap response is invalid. */
-            502: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["ErrorEnvelope"];
-                };
-            };
-            503: components["responses"]["Unavailable"];
         };
     };
-    webShellGetWorkspaceOperation: {
+    submitWorkspaceExtensionPackageSettings: {
         parameters: {
             query?: never;
             header?: never;
@@ -3022,29 +4396,28 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellWorkspaceOperationRequest"];
+                "application/json": components["schemas"]["WebShellExtensionSettingsSubmit"];
             };
         };
         responses: {
-            /** @description Latest durable state of the original actor-owned registration. */
+            /** @description Persisted Workspace extension resource. Contains no settings values or executable recipes. */
             200: {
                 headers: {
-                    "X-Request-Id": components["headers"]["RequestId"];
-                    "Cache-Control"?: "no-store";
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellWorkspaceCreateOperation"];
+                    "application/json": components["schemas"]["ManagedExtensionPackageOperation"];
                 };
             };
             400: components["responses"]["BadRequest"];
             401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
             413: components["responses"]["PayloadTooLarge"];
         };
     };
-    webShellRegisterWorkspace: {
+    queryWorkspaceExtensionPackageOperation: {
         parameters: {
             query?: never;
             header?: never;
@@ -3053,19 +4426,17 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellWorkspaceRegisterRequest"];
+                "application/json": components["schemas"]["WebShellExtensionOperationQuery"];
             };
         };
         responses: {
-            /** @description Durable registration operation; repeated requests retain the original identity. */
-            202: {
+            /** @description Persisted Workspace extension resource. Contains no settings values or executable recipes. */
+            200: {
                 headers: {
-                    "X-Request-Id": components["headers"]["RequestId"];
-                    "Cache-Control"?: "no-store";
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellWorkspaceCreateOperation"];
+                    "application/json": components["schemas"]["ManagedExtensionPackageOperation"];
                 };
             };
             400: components["responses"]["BadRequest"];
@@ -3076,26 +4447,33 @@ export interface operations {
             413: components["responses"]["PayloadTooLarge"];
         };
     };
-    queryWebShellWorkspaceDirectories: {
+    publishWebShellWorkspaceExtensionPackage: {
         parameters: {
-            query?: never;
-            header?: never;
+            query: {
+                workspaceId: string;
+                extensionId?: string;
+                packageDigest: string;
+                manifest: string;
+            };
+            header: {
+                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
+            };
             path?: never;
             cookie?: never;
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellWorkspaceDirectoryQueryRequest"];
+                "application/octet-stream": string;
             };
         };
         responses: {
-            /** @description Authorized existing directories. */
+            /** @description Persisted Workspace extension resource. Contains no settings values or executable recipes. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellWorkspaceDirectoryPage"];
+                    "application/json": components["schemas"]["ManagedExtensionPackageOperation"];
                 };
             };
             400: components["responses"]["BadRequest"];
@@ -3103,9 +4481,10 @@ export interface operations {
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
             409: components["responses"]["Conflict"];
+            413: components["responses"]["PayloadTooLarge"];
         };
     };
-    queryWebShellSessionMcp: {
+    webShellSessionExtensionsQuery: {
         parameters: {
             query?: never;
             header?: never;
@@ -3114,27 +4493,37 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellSessionRequest"];
+                "application/json": components["schemas"]["WebShellExtensionSessionQuery"];
             };
         };
         responses: {
-            /** @description Session MCP catalog snapshot. */
+            /** @description Persisted or reconciled Session configuration; contains no settings values or private executable recipes. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["PublicMcpCatalog"];
+                    "application/json": components["schemas"]["ManagedExtensionManagementSnapshot"];
                 };
             };
             400: components["responses"]["BadRequest"];
             401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
             413: components["responses"]["PayloadTooLarge"];
+            /** @description The original MCP Runtime or management operation cannot be confirmed. Retry the same operation identity. */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
+                };
+            };
         };
     };
-    queryWebShellSessionSkills: {
+    webShellSessionExtensionsSubmit: {
         parameters: {
             query?: never;
             header?: never;
@@ -3143,17 +4532,17 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellSessionRequest"];
+                "application/json": components["schemas"]["WebShellExtensionSessionSubmit"];
             };
         };
         responses: {
-            /** @description Session static Skill metadata. */
+            /** @description Persisted or reconciled Session configuration; contains no settings values or private executable recipes. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellSessionSkills"];
+                    "application/json": components["schemas"]["ManagedExtensionManagementSnapshot"];
                 };
             };
             400: components["responses"]["BadRequest"];
@@ -3162,9 +4551,18 @@ export interface operations {
             404: components["responses"]["NotFound"];
             409: components["responses"]["Conflict"];
             413: components["responses"]["PayloadTooLarge"];
+            /** @description The original MCP Runtime or management operation cannot be confirmed. Retry the same operation identity. */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
+                };
+            };
         };
     };
-    webShellWorkspaceFilesQuery: {
+    webShellSessionExtensionsContinue: {
         parameters: {
             query?: never;
             header?: never;
@@ -3173,17 +4571,17 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellWorkspaceFileQueryRequest"];
+                "application/json": components["schemas"]["WebShellExtensionSessionOperation"];
             };
         };
         responses: {
-            /** @description Authorized Workspace file result. */
+            /** @description Persisted or reconciled Session configuration; contains no settings values or private executable recipes. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellWorkspaceFilePage"];
+                    "application/json": components["schemas"]["ManagedExtensionManagementSnapshot"];
                 };
             };
             400: components["responses"]["BadRequest"];
@@ -3191,10 +4589,19 @@ export interface operations {
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
             409: components["responses"]["Conflict"];
-            503: components["responses"]["Unavailable"];
+            413: components["responses"]["PayloadTooLarge"];
+            /** @description The original MCP Runtime or management operation cannot be confirmed. Retry the same operation identity. */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
+                };
+            };
         };
     };
-    webShellWorkspaceFilesRead: {
+    webShellSessionExtensionsRecoverPrevious: {
         parameters: {
             query?: never;
             header?: never;
@@ -3203,17 +4610,17 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellWorkspaceFileReadRequest"];
+                "application/json": components["schemas"]["WebShellExtensionSessionOperation"];
             };
         };
         responses: {
-            /** @description Authorized Workspace file result. */
+            /** @description Persisted or reconciled Session configuration; contains no settings values or private executable recipes. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellWorkspaceFileSnapshot"];
+                    "application/json": components["schemas"]["ManagedExtensionManagementSnapshot"];
                 };
             };
             400: components["responses"]["BadRequest"];
@@ -3221,34 +4628,53 @@ export interface operations {
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
             409: components["responses"]["Conflict"];
-            503: components["responses"]["Unavailable"];
+            413: components["responses"]["PayloadTooLarge"];
+            /** @description The original MCP Runtime or management operation cannot be confirmed. Retry the same operation identity. */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
+                };
+            };
         };
     };
-    getWebShellToolDetails: {
+    webShellWorkspaceFilesUpload: {
         parameters: {
-            query?: never;
+            query: {
+                workspaceId: string;
+                cwdRelative: string;
+                path: string;
+                expectedScopeRevision: string;
+                uploadId: string;
+            };
             header?: never;
             path?: never;
             cookie?: never;
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["WebShellToolResultRequest"];
+                "application/octet-stream": string;
             };
         };
         responses: {
-            /** @description Bounded saved ReadFile/Shell input and text output, read on demand; requires a trusted actor and current Session/Workspace read access. Available to authorized readers without a feature switch. */
+            /** @description Workspace upload result. */
             200: {
                 headers: {
-                    "Cache-Control"?: "private, no-store";
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["WebShellToolDetails"];
+                    "application/json": components["schemas"]["WebShellWorkspaceFileUploadResult"];
                 };
             };
-            /** @description Invalid request. */
-            400: {
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            /** @description The upload exceeds the 8 MiB binary limit. */
+            413: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -3256,8 +4682,8 @@ export interface operations {
                     "application/json": components["schemas"]["ErrorEnvelope"];
                 };
             };
-            /** @description Trusted actor required. */
-            401: {
+            /** @description Uploads require unencoded application/octet-stream bytes. */
+            415: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -3265,27 +4691,37 @@ export interface operations {
                     "application/json": components["schemas"]["ErrorEnvelope"];
                 };
             };
-            403: components["responses"]["Forbidden"];
-            /** @description Unknown or unreadable resource. */
-            404: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["ErrorEnvelope"];
-                };
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    webShellWorkspaceFilesUploadQuery: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellWorkspaceFileUploadQueryRequest"];
             };
-            409: components["responses"]["Conflict"];
-            413: components["responses"]["PayloadTooLarge"];
-            /** @description Resource temporarily unavailable. */
-            503: {
+        };
+        responses: {
+            /** @description Workspace upload result. */
+            200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["ErrorEnvelope"];
+                    "application/json": components["schemas"]["WebShellWorkspaceFileUploadStatus"];
                 };
             };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            503: components["responses"]["Unavailable"];
         };
     };
 }