@opengeni/contracts 0.10.0 → 0.15.0

package/dist/index.d.ts

@@ -1,5 +1,80 @@
 import { z } from 'zod';
 
+/**
+ * Canonical bounded representation for `session_events.payload`.
+ *
+ * Session events are the lossy human/audit projection, not model memory and not
+ * an evidence blob store. This helper keeps that projection useful while making
+ * the loss explicit. It deliberately has no server-only dependency so the DB,
+ * realtime transports, SDK/React, and tests can share one wire contract.
+ */
+declare const SESSION_EVENT_PAYLOAD_MAX_BYTES: number;
+type SessionEventBoundarySurface = "durable_audit" | "database_guard" | "database_read_projection" | "http_projection" | "nats_legacy_guard" | "sse_legacy_guard" | "browser_legacy_guard";
+type SessionEventPayloadTruncation = {
+    truncated: true;
+    surface: SessionEventBoundarySurface;
+    reason: "payload_bytes_exceeded" | "payload_not_serializable" | "payload_measurement_bounded" | "inline_media_not_retained" | "database_guard";
+    originalBytes: number | null;
+    deliveredBytes: number;
+    omittedBytes: number | null;
+    estimatedOriginalTokens: number | null;
+    estimatedDeliveredTokens: number;
+    fullEvidence: {
+        available: false;
+        reason: "not_retained";
+    };
+    details: Array<{
+        path: string;
+        kind: "string" | "array" | "object" | "depth" | "budget" | "media" | "binary" | "unserializable";
+        originalBytes?: number;
+        deliveredBytes?: number;
+        omittedEntries?: number | null;
+        mediaType?: string;
+    }>;
+};
+type BoundSessionEventPayloadOptions = {
+    surface?: SessionEventBoundarySurface;
+    maxBytes?: number;
+};
+type SessionEventJsonMeasurement = {
+    bytes: number;
+    reason: null;
+} | {
+    bytes: null;
+    reason: "payload_not_serializable" | "payload_measurement_bounded";
+};
+type SessionEventMediaPreview = {
+    type: "media_preview";
+    mediaType: string;
+    inlineBytes: number | null;
+    fullOutputAvailable: false;
+    preview: string;
+};
+/** UTF-8 bytes used by the JSON wire/storage representation. */
+declare function sessionEventJsonBytes(value: unknown): number;
+/**
+ * Inspect a prospective event value without invoking accessors, custom
+ * serializers, or allocating its complete JSON representation. A null byte
+ * count is explicit: the traversal stopped at the global work/depth boundary
+ * or found serialization behavior that must first be normalized.
+ */
+declare function measureSessionEventJson(value: unknown): SessionEventJsonMeasurement;
+/** The same deliberately coarse bytes/4 token estimate used by Codex parity code. */
+declare function approximateSessionEventTokens(bytes: number): number;
+/** Truthful audit fact for inline media whose source bytes are not durably retained. */
+declare function sessionEventMediaPreview(mediaType: string, inlineBytes: number | null): SessionEventMediaPreview;
+/** Parse a base64 data URL into a compact audit fact without decoding/copying its bytes. */
+declare function sessionEventMediaPreviewFromDataUrl(value: string): SessionEventMediaPreview | null;
+/** Read explicit truncation metadata from a bounded object payload. */
+declare function sessionEventPayloadTruncation(payload: unknown): SessionEventPayloadTruncation | null;
+/**
+ * Return a byte-bounded audit payload. Unchanged ordinary payloads retain their
+ * reference. Oversized strings/containers get deterministic head+tail previews;
+ * inline images/binary values become metadata because `session_events` does not
+ * durably retain their source bytes as independently retrievable evidence.
+ */
+declare function boundSessionEventPayload<T>(payload: T, options?: BoundSessionEventPayloadOptions): T;
+
 declare const SessionStatus: z.ZodEnum<{
     queued: "queued";
     running: "running";
@@ -7,7 +82,6 @@ declare const SessionStatus: z.ZodEnum<{
     requires_action: "requires_action";
     recovering: "recovering";
     waiting_capacity: "waiting_capacity";
-    paused: "paused";
     failed: "failed";
     cancelled: "cancelled";
 }>;
@@ -225,26 +299,379 @@ declare const Workspace: z.ZodObject<{
     externalId: z.ZodNullable<z.ZodString>;
     agentInstructions: z.ZodNullable<z.ZodString>;
     settings: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    inferenceState: z.ZodEnum<{
-        paused: "paused";
-        active: "active";
-    }>;
-    inferenceGeneration: z.ZodNumber;
-    inferenceReason: z.ZodNullable<z.ZodString>;
-    inferenceChangedBy: z.ZodNullable<z.ZodString>;
-    inferenceChangedAt: z.ZodNullable<z.ZodString>;
+    inferenceControl: z.ZodObject<{
+        state: z.ZodEnum<{
+            active: "active";
+            paused: "paused";
+        }>;
+        revision: z.ZodNumber;
+        reason: z.ZodNullable<z.ZodString>;
+        changedBy: z.ZodNullable<z.ZodString>;
+        changedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
     defaultRigId: z.ZodNullable<z.ZodString>;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
 }, z.core.$strip>;
 type Workspace = z.infer<typeof Workspace>;
+declare const WorkspaceTranscriptionTarget: z.ZodObject<{
+    provider: z.ZodString;
+    model: z.ZodNullable<z.ZodString>;
+    credentialMode: z.ZodEnum<{
+        managed: "managed";
+        byok: "byok";
+    }>;
+    credentialConnectionId: z.ZodNullable<z.ZodString>;
+    region: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+type WorkspaceTranscriptionTarget = z.infer<typeof WorkspaceTranscriptionTarget>;
+declare const TranscriptionErrorCode: z.ZodEnum<{
+    cancelled: "cancelled";
+    unknown: "unknown";
+    provider: "provider";
+    permission_denied: "permission_denied";
+    not_supported: "not_supported";
+    network: "network";
+    policy_blocked: "policy_blocked";
+    timeout: "timeout";
+}>;
+type TranscriptionErrorCode = z.infer<typeof TranscriptionErrorCode>;
+declare const TranscriptionTimeSpan: z.ZodObject<{
+    startMilliseconds: z.ZodNumber;
+    endMilliseconds: z.ZodNumber;
+}, z.core.$strict>;
+type TranscriptionTimeSpan = z.infer<typeof TranscriptionTimeSpan>;
+declare const TranscriptionSpeaker: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type TranscriptionSpeaker = z.infer<typeof TranscriptionSpeaker>;
+declare const TranscriptionWord: z.ZodObject<{
+    text: z.ZodString;
+    span: z.ZodObject<{
+        startMilliseconds: z.ZodNumber;
+        endMilliseconds: z.ZodNumber;
+    }, z.core.$strict>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    speaker: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type TranscriptionWord = z.infer<typeof TranscriptionWord>;
+declare const TranscriptionResultMetadata: z.ZodObject<{
+    detectedLanguage: z.ZodOptional<z.ZodString>;
+    span: z.ZodOptional<z.ZodObject<{
+        startMilliseconds: z.ZodNumber;
+        endMilliseconds: z.ZodNumber;
+    }, z.core.$strict>>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    speaker: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    words: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        span: z.ZodObject<{
+            startMilliseconds: z.ZodNumber;
+            endMilliseconds: z.ZodNumber;
+        }, z.core.$strict>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        speaker: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+type TranscriptionResultMetadata = z.infer<typeof TranscriptionResultMetadata>;
+/** Strict provider-neutral event surface; provider payload bags are rejected. */
+declare const TranscriptionEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    localSessionId: z.ZodString;
+    sequence: z.ZodNumber;
+    occurredAt: z.ZodString;
+    type: z.ZodLiteral<"permission.requested">;
+}, z.core.$strict>, z.ZodObject<{
+    localSessionId: z.ZodString;
+    sequence: z.ZodNumber;
+    occurredAt: z.ZodString;
+    type: z.ZodLiteral<"session.opened">;
+    providerSessionId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    localSessionId: z.ZodString;
+    sequence: z.ZodNumber;
+    occurredAt: z.ZodString;
+    type: z.ZodLiteral<"transcript.partial">;
+    segmentId: z.ZodString;
+    text: z.ZodString;
+    metadata: z.ZodOptional<z.ZodObject<{
+        detectedLanguage: z.ZodOptional<z.ZodString>;
+        span: z.ZodOptional<z.ZodObject<{
+            startMilliseconds: z.ZodNumber;
+            endMilliseconds: z.ZodNumber;
+        }, z.core.$strict>>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        speaker: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        words: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            text: z.ZodString;
+            span: z.ZodObject<{
+                startMilliseconds: z.ZodNumber;
+                endMilliseconds: z.ZodNumber;
+            }, z.core.$strict>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            speaker: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    localSessionId: z.ZodString;
+    sequence: z.ZodNumber;
+    occurredAt: z.ZodString;
+    type: z.ZodLiteral<"transcript.final">;
+    segmentId: z.ZodString;
+    text: z.ZodString;
+    providerAcceptanceId: z.ZodString;
+    metadata: z.ZodOptional<z.ZodObject<{
+        detectedLanguage: z.ZodOptional<z.ZodString>;
+        span: z.ZodOptional<z.ZodObject<{
+            startMilliseconds: z.ZodNumber;
+            endMilliseconds: z.ZodNumber;
+        }, z.core.$strict>>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        speaker: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        words: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            text: z.ZodString;
+            span: z.ZodObject<{
+                startMilliseconds: z.ZodNumber;
+                endMilliseconds: z.ZodNumber;
+            }, z.core.$strict>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            speaker: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    localSessionId: z.ZodString;
+    sequence: z.ZodNumber;
+    occurredAt: z.ZodString;
+    type: z.ZodLiteral<"usage">;
+    audioMilliseconds: z.ZodNumber;
+    costUsd: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    localSessionId: z.ZodString;
+    sequence: z.ZodNumber;
+    occurredAt: z.ZodString;
+    type: z.ZodLiteral<"session.reconnecting">;
+    attempt: z.ZodNumber;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    localSessionId: z.ZodString;
+    sequence: z.ZodNumber;
+    occurredAt: z.ZodString;
+    type: z.ZodLiteral<"session.error">;
+    code: z.ZodEnum<{
+        cancelled: "cancelled";
+        unknown: "unknown";
+        provider: "provider";
+        permission_denied: "permission_denied";
+        not_supported: "not_supported";
+        network: "network";
+        policy_blocked: "policy_blocked";
+        timeout: "timeout";
+    }>;
+    recoverable: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    localSessionId: z.ZodString;
+    sequence: z.ZodNumber;
+    occurredAt: z.ZodString;
+    type: z.ZodLiteral<"session.closed">;
+    reason: z.ZodEnum<{
+        cancelled: "cancelled";
+        error: "error";
+        completed: "completed";
+        replaced: "replaced";
+    }>;
+}, z.core.$strict>], "type">;
+type TranscriptionEvent = z.infer<typeof TranscriptionEvent>;
+/**
+ * Workspace-only policy for the distinct speech-to-text capability. It never
+ * authorizes a turn model/provider and contains connection references rather
+ * than secrets. `acceptanceId` changes whenever an admin accepts a new target
+ * set, so clients can bind a microphone session to one exact policy revision.
+ */
+declare const WorkspaceTranscriptionPolicy: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    acceptanceId: z.ZodNullable<z.ZodString>;
+    primary: z.ZodNullable<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodNullable<z.ZodString>;
+        credentialMode: z.ZodEnum<{
+            managed: "managed";
+            byok: "byok";
+        }>;
+        credentialConnectionId: z.ZodNullable<z.ZodString>;
+        region: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    language: z.ZodNullable<z.ZodString>;
+    autoDetectLanguage: z.ZodBoolean;
+    diarization: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        maxSpeakers: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>;
+    retention: z.ZodObject<{
+        mode: z.ZodEnum<{
+            none: "none";
+            "provider-policy": "provider-policy";
+        }>;
+        maxDays: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>;
+    privacy: z.ZodObject<{
+        allowProviderLogging: z.ZodBoolean;
+        allowProviderTraining: z.ZodBoolean;
+    }, z.core.$strict>;
+    fallback: z.ZodObject<{
+        mode: z.ZodEnum<{
+            disabled: "disabled";
+            explicit: "explicit";
+        }>;
+        targets: z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodNullable<z.ZodString>;
+            credentialMode: z.ZodEnum<{
+                managed: "managed";
+                byok: "byok";
+            }>;
+            credentialConnectionId: z.ZodNullable<z.ZodString>;
+            region: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    cost: z.ZodObject<{
+        currency: z.ZodLiteral<"USD">;
+        maxPerHour: z.ZodNullable<z.ZodNumber>;
+        maxPerMonth: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type WorkspaceTranscriptionPolicy = z.infer<typeof WorkspaceTranscriptionPolicy>;
 declare const WorkspaceSettingsSchema: z.ZodObject<{
     memoryEnabled: z.ZodOptional<z.ZodBoolean>;
+    transcription: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        acceptanceId: z.ZodNullable<z.ZodString>;
+        primary: z.ZodNullable<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodNullable<z.ZodString>;
+            credentialMode: z.ZodEnum<{
+                managed: "managed";
+                byok: "byok";
+            }>;
+            credentialConnectionId: z.ZodNullable<z.ZodString>;
+            region: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        language: z.ZodNullable<z.ZodString>;
+        autoDetectLanguage: z.ZodBoolean;
+        diarization: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            maxSpeakers: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+        retention: z.ZodObject<{
+            mode: z.ZodEnum<{
+                none: "none";
+                "provider-policy": "provider-policy";
+            }>;
+            maxDays: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+        privacy: z.ZodObject<{
+            allowProviderLogging: z.ZodBoolean;
+            allowProviderTraining: z.ZodBoolean;
+        }, z.core.$strict>;
+        fallback: z.ZodObject<{
+            mode: z.ZodEnum<{
+                disabled: "disabled";
+                explicit: "explicit";
+            }>;
+            targets: z.ZodArray<z.ZodObject<{
+                provider: z.ZodString;
+                model: z.ZodNullable<z.ZodString>;
+                credentialMode: z.ZodEnum<{
+                    managed: "managed";
+                    byok: "byok";
+                }>;
+                credentialConnectionId: z.ZodNullable<z.ZodString>;
+                region: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        cost: z.ZodObject<{
+            currency: z.ZodLiteral<"USD">;
+            maxPerHour: z.ZodNullable<z.ZodNumber>;
+            maxPerMonth: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
 }, z.core.$loose>;
 type WorkspaceSettings = z.infer<typeof WorkspaceSettingsSchema>;
 declare function resolveWorkspaceMemoryEnabled(settings: unknown): boolean;
 declare const UpdateWorkspaceSettingsRequest: z.ZodObject<{
     memoryEnabled: z.ZodOptional<z.ZodBoolean>;
+    transcription: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        acceptanceId: z.ZodNullable<z.ZodString>;
+        primary: z.ZodNullable<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodNullable<z.ZodString>;
+            credentialMode: z.ZodEnum<{
+                managed: "managed";
+                byok: "byok";
+            }>;
+            credentialConnectionId: z.ZodNullable<z.ZodString>;
+            region: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        language: z.ZodNullable<z.ZodString>;
+        autoDetectLanguage: z.ZodBoolean;
+        diarization: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            maxSpeakers: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+        retention: z.ZodObject<{
+            mode: z.ZodEnum<{
+                none: "none";
+                "provider-policy": "provider-policy";
+            }>;
+            maxDays: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+        privacy: z.ZodObject<{
+            allowProviderLogging: z.ZodBoolean;
+            allowProviderTraining: z.ZodBoolean;
+        }, z.core.$strict>;
+        fallback: z.ZodObject<{
+            mode: z.ZodEnum<{
+                disabled: "disabled";
+                explicit: "explicit";
+            }>;
+            targets: z.ZodArray<z.ZodObject<{
+                provider: z.ZodString;
+                model: z.ZodNullable<z.ZodString>;
+                credentialMode: z.ZodEnum<{
+                    managed: "managed";
+                    byok: "byok";
+                }>;
+                credentialConnectionId: z.ZodNullable<z.ZodString>;
+                region: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        cost: z.ZodObject<{
+            currency: z.ZodLiteral<"USD">;
+            maxPerHour: z.ZodNullable<z.ZodNumber>;
+            maxPerMonth: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
 }, z.core.$loose>;
 type UpdateWorkspaceSettingsRequest = z.infer<typeof UpdateWorkspaceSettingsRequest>;
 declare const SetWorkspaceDefaultRigRequest: z.ZodObject<{
@@ -256,6 +683,30 @@ declare const UpdateWorkspaceModelPolicyRequest: z.ZodObject<{
     allowedModels: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
 }, z.core.$strip>;
 type UpdateWorkspaceModelPolicyRequest = z.infer<typeof UpdateWorkspaceModelPolicyRequest>;
+/** Reserved creator/initiator id used only by legacy-row migration defaults. */
+declare const UNATTRIBUTED_LEGACY_INITIATOR_SUBJECT_ID: "unattributed-legacy";
+/**
+ * A named machine/service principal asserted by a trusted embedding host. This
+ * deliberately excludes `kind: "subject"`: a delegated service assertion may
+ * describe causal machine work, but it is not a generic human-impersonation
+ * mechanism. The authenticated grant remains the authorization boundary.
+ */
+declare const ServiceTurnInitiator: z.ZodObject<{
+    kind: z.ZodLiteral<"service">;
+    subjectId: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ServiceTurnInitiator = z.infer<typeof ServiceTurnInitiator>;
+/**
+ * Immutable, non-secret provenance captured with an initiator. This is audit
+ * context (for example an external occurrence id), not a second identity or
+ * authorization surface.
+ */
+declare const TurnInitiatorContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+type TurnInitiatorContext = z.infer<typeof TurnInitiatorContext>;
+/** Bounded host provenance that cannot forge OpenGeni-owned lineage fields. */
+declare const ServiceTurnInitiatorContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+type ServiceTurnInitiatorContext = z.infer<typeof ServiceTurnInitiatorContext>;
 declare const AccountGrant: z.ZodObject<{
     accountId: z.ZodString;
     subjectId: z.ZodString;
@@ -354,6 +805,12 @@ declare const AccessGrant: z.ZodObject<{
         "rigs:manage": "rigs:manage";
     }>>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    serviceInitiator: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"service">;
+        subjectId: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    serviceInitiatorContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
 type AccessGrant = z.infer<typeof AccessGrant>;
 declare const AccessContext: z.ZodObject<{
@@ -461,6 +918,12 @@ declare const AccessContext: z.ZodObject<{
             "rigs:manage": "rigs:manage";
         }>>;
         metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        serviceInitiator: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"service">;
+            subjectId: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        serviceInitiatorContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>>;
     defaultAccountId: z.ZodNullable<z.ZodString>;
     defaultWorkspaceId: z.ZodNullable<z.ZodString>;
@@ -511,8 +974,16 @@ declare const DelegatedAccessTokenPayload: z.ZodObject<{
         "rigs:use": "rigs:use";
         "rigs:manage": "rigs:manage";
     }>>;
+    serviceInitiator: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"service">;
+        subjectId: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    serviceInitiatorContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     sessionId: z.ZodOptional<z.ZodString>;
     turnId: z.ZodOptional<z.ZodString>;
+    attemptId: z.ZodOptional<z.ZodString>;
+    executionGeneration: z.ZodOptional<z.ZodNumber>;
     exp: z.ZodNumber;
 }, z.core.$strip>;
 type DelegatedAccessTokenPayload = z.infer<typeof DelegatedAccessTokenPayload>;
@@ -1045,12 +1516,24 @@ declare const GitCredentialProvider: z.ZodEnum<{
     azure_devops: "azure_devops";
 }>;
 type GitCredentialProvider = z.infer<typeof GitCredentialProvider>;
+declare const GitCredentialBindingId: z.ZodString;
+type GitCredentialBindingId = z.infer<typeof GitCredentialBindingId>;
+declare const GitRepositoryAccess: z.ZodEnum<{
+    read: "read";
+    write: "write";
+}>;
+type GitRepositoryAccess = z.infer<typeof GitRepositoryAccess>;
 declare const GitCredentialRepositoryRef: z.ZodObject<{
     provider: z.ZodOptional<z.ZodEnum<{
         github: "github";
         gitlab: "gitlab";
         azure_devops: "azure_devops";
     }>>;
+    credentialBindingId: z.ZodOptional<z.ZodString>;
+    access: z.ZodOptional<z.ZodEnum<{
+        read: "read";
+        write: "write";
+    }>>;
     uri: z.ZodString;
     ref: z.ZodString;
     repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
@@ -1062,7 +1545,17 @@ type GitCredentialRepositoryRef = z.infer<typeof GitCredentialRepositoryRef>;
 type GitCredentialsRequest = {
     accountId: string;
     workspaceId: string;
+    /** Immutable authority admitted with the turn requesting this credential. */
+    sessionId: string;
+    rootSessionId: string;
+    turnId: string;
+    attemptId: string;
+    executionGeneration: number;
+    initiator: TurnInitiator;
+    initiatorContext: TurnInitiatorContext;
     provider?: GitCredentialProvider;
+    credentialBindingId?: GitCredentialBindingId;
+    providerHost?: string;
     purpose?: "token" | "identity";
     repositoryRefs?: GitCredentialRepositoryRef[];
     installationId: number;
@@ -1071,6 +1564,9 @@ type GitCredentialsRequest = {
 type GitCredentials = {
     token?: string;
     workspaceId: string;
+    credentialBindingId?: GitCredentialBindingId;
+    provider?: GitCredentialProvider;
+    providerHost?: string;
     expiresAt?: string | null;
     identity?: {
         name: string;
@@ -1089,9 +1585,190 @@ type SandboxSecrets = {
     name?: string;
     description?: string | null;
 };
+type CredentialAuthNeededReason = "missing_connection" | "expired" | "insufficient_scope" | "refresh_failed";
+/**
+ * Host-owned run credentials are materialized below one OpenGeni-owned sandbox
+ * directory. Paths are relative POSIX names; the runtime validates traversal,
+ * collisions, bounds, and modes before any content reaches a sandbox.
+ */
+type RunCredentialFile = {
+    path: string;
+    content: string;
+    mode?: "0400" | "0600";
+};
+type RunCredentialAuthNeeded = {
+    reason: CredentialAuthNeededReason;
+    providerDomain?: string;
+    connectionId?: string;
+    scopes?: string[];
+    resource?: string;
+    authorizationUrl?: string;
+    /** Bounded non-secret guidance. Never place credential material here. */
+    message?: string;
+};
+type RunCredentialRedaction = {
+    /** Bounded diagnostic label used only in the replacement marker. */
+    name: string;
+    /** One atomic secret value that must be removed from streamed/audit output. */
+    value: string;
+};
+type RunCredentialsRequest = {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    parentSessionId: string | null;
+    rootSessionId: string;
+    /** All sessions sharing this sandbox group share one OS/filesystem trust boundary. */
+    sandboxGroupId: string;
+    turnId: string;
+    attemptId: string;
+    executionGeneration: number;
+    /** Immutable authority admitted with this turn. */
+    initiator: TurnInitiator;
+    initiatorContext: TurnInitiatorContext;
+    effectiveSandboxBackend: SandboxBackend;
+    sandboxOs: SandboxOs;
+    purpose: "provision" | "renewal";
+    forceRefresh: boolean;
+    /** Informational standalone variable-set identity; never gates host resolution. */
+    variableSet: {
+        id: string;
+        name: string;
+    } | null;
+};
+type RunCredentialsResolution = {
+    /**
+     * The frozen target/attempt must not receive host material. Hosts use
+     * this for unsupported OSes/backends and policy-based opt-out; the
+     * decision must remain stable for the attempt.
+     */
+    status: "not_applicable";
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+} | {
+    status: "ok";
+    /** Scope echoes are mandatory and checked before materialization. */
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    /** Secret environment values. Always delivered off-manifest. */
+    environment: Record<string, string>;
+    files?: RunCredentialFile[];
+    /** Environment name to one returned relative file path. */
+    fileEnvironment?: Record<string, string>;
+    /**
+     * Atomic sensitive values embedded inside credential files or derived
+     * material. Environment values are registered automatically; hosts list
+     * additional file-contained values here so chunked output is redacted.
+     */
+    redactions?: RunCredentialRedaction[];
+    /** Earliest material expiry. Null/omitted uses a bounded refresh cadence. */
+    expiresAt?: string | null;
+    /** Partial degradation: usable material may coexist with reconnect notices. */
+    authNeeded?: RunCredentialAuthNeeded[];
+} | {
+    status: "auth_needed";
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    authNeeded: RunCredentialAuthNeeded[];
+};
+declare const McpConnectionResourceScope: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"repository">;
+}, z.core.$strict>;
+type McpConnectionResourceScope = z.infer<typeof McpConnectionResourceScope>;
+declare const McpServerConnectionRef: z.ZodObject<{
+    connectionId: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+    providerDomain: z.ZodString;
+    kind: z.ZodOptional<z.ZodEnum<{
+        oauth2: "oauth2";
+        api_key: "api_key";
+        app_install: "app_install";
+        delegated: "delegated";
+    }>>;
+    scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    resource: z.ZodOptional<z.ZodString>;
+    selectedResources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodLiteral<"repository">;
+    }, z.core.$strict>>>;
+    subjectScope: z.ZodOptional<z.ZodEnum<{
+        subject: "subject";
+        workspace: "workspace";
+    }>>;
+}, z.core.$strict>;
+type McpServerConnectionRef = z.infer<typeof McpServerConnectionRef>;
+type McpCredentialsRequest = {
+    accountId: string;
+    workspaceId: string;
+    /** Immediate session whose model or Toolspace call needs the credential. */
+    sessionId: string;
+    /** Workspace-scoped lineage root for host authorization and binding lookup. */
+    rootSessionId: string;
+    turnId: string;
+    /** Null only while a durable turn exists without a currently executing attempt. */
+    attemptId: string | null;
+    executionGeneration: number;
+    /** The immutable authority that admitted this turn. Never substitute the sandbox caller. */
+    initiator: TurnInitiator;
+    initiatorContext: TurnInitiatorContext;
+    /** Immediate technical caller, retained only as non-authoritative audit context. */
+    callerSubjectId?: string;
+    surface: "model" | "toolspace";
+    serverId: string;
+    toolName?: string;
+    connectionRef: McpServerConnectionRef;
+    forceRefresh: boolean;
+};
+type McpCredentialAuthNeededReason = CredentialAuthNeededReason | "unsupported_auth" | "resource_scope_unavailable";
+type McpCredentialResolution = {
+    status: "ok";
+    /** Scope echoes are mandatory and verified before any header is used. */
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    headers: Record<string, string>;
+    connectionId: string;
+    providerDomain: string;
+    provider?: string;
+    scopes?: string[];
+    resource?: string;
+    selectedResources?: McpConnectionResourceScope[];
+    expiresAt?: string | null;
+} | {
+    status: "auth_needed";
+    /** Scope echoes are mandatory even when the credential cannot be resolved. */
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    reason: McpCredentialAuthNeededReason;
+    providerDomain: string;
+    provider?: string;
+    connectionId?: string;
+    scopes?: string[];
+    resource?: string;
+    selectedResources?: McpConnectionResourceScope[];
+    authorizationUrl?: string;
+};
 type ConnectionCredentialsPort = {
     gitCredentials?(input: GitCredentialsRequest): Promise<GitCredentials>;
     sandboxSecrets?(input: SandboxSecretsRequest): Promise<SandboxSecrets>;
+    /**
+     * Resolve host-owned, session-aware sandbox credentials independently of an
+     * OpenGeni variable set. OpenGeni transports and renews the material; the host
+     * remains the sole owner of connection selection and credential policy.
+     */
+    runCredentials?(input: RunCredentialsRequest): Promise<RunCredentialsResolution>;
+    /**
+     * Resolve rotating MCP transport credentials at request time. Embedded hosts
+     * use this to keep their provider connection as the sole credential source;
+     * OpenGeni never requires a duplicate connection record. The same resolver is
+     * used by model-visible MCP tools and the additive Toolspace/Code Mode proxy.
+     */
+    mcpCredentials?(input: McpCredentialsRequest): Promise<McpCredentialResolution>;
 };
 type GitHubInstallationSummary = {
     installationId: number;
@@ -1099,11 +1776,30 @@ type GitHubInstallationSummary = {
     accountType: string | null;
     suspended: boolean;
 };
+type GitHubRepositoryPermissions = {
+    admin: boolean;
+    maintain: boolean;
+    push: boolean;
+    triage: boolean;
+    pull: boolean;
+};
+type GitHubUserRepositoryAccess = GitHubRepository & {
+    permissions: GitHubRepositoryPermissions;
+};
+type GitHubUserInstallationAccess = GitHubInstallationSummary & {
+    repositories: GitHubUserRepositoryAccess[];
+};
 type GitHubAppApiPort = {
+    authorizeUser?: (input: {
+        code: string;
+    }) => Promise<GitHubUserInstallationAccess[]>;
     verifyInstallationAccessForUser?: (input: {
         code: string;
         installationId: number;
     }) => Promise<GitHubInstallationSummary>;
+    getInstallation?: (input: {
+        installationId: number;
+    }) => Promise<GitHubInstallationSummary | null>;
     listRepositories?: (input: {
         installationIds?: number[];
     }) => Promise<GitHubRepository[]>;
@@ -1138,6 +1834,11 @@ declare const RepositoryResourceRef: z.ZodObject<{
         gitlab: "gitlab";
         azure_devops: "azure_devops";
     }>>;
+    credentialBindingId: z.ZodOptional<z.ZodString>;
+    access: z.ZodOptional<z.ZodEnum<{
+        read: "read";
+        write: "write";
+    }>>;
     repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
     installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
     projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
@@ -1146,6 +1847,18 @@ declare const RepositoryResourceRef: z.ZodObject<{
     githubRepositoryId: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 type RepositoryResourceRef = z.infer<typeof RepositoryResourceRef>;
+/**
+ * Resolve whether a repository participates in platform-brokered Git auth.
+ * Provider-less public repositories return null; legacy GitHub aliases infer
+ * GitHub only when both positive installation and repository ids are present.
+ */
+declare function gitCredentialProviderForRepository(resource: RepositoryResourceRef): GitCredentialProvider | null;
+/**
+ * Derive the one canonical runtime/broker identity for a repository credential.
+ * Every consumer must use this helper so mint grouping, token filenames, and
+ * credential-helper routing cannot diverge on legacy provider ids.
+ */
+declare function gitCredentialBindingIdForRepository(resource: RepositoryResourceRef, provider?: GitCredentialProvider | null): GitCredentialBindingId | null;
 declare const FileResourceRef: z.ZodObject<{
     kind: z.ZodLiteral<"file">;
     fileId: z.ZodString;
@@ -1163,6 +1876,11 @@ declare const ResourceRef: z.ZodDiscriminatedUnion<[z.ZodObject<{
         gitlab: "gitlab";
         azure_devops: "azure_devops";
     }>>;
+    credentialBindingId: z.ZodOptional<z.ZodString>;
+    access: z.ZodOptional<z.ZodEnum<{
+        read: "read";
+        write: "write";
+    }>>;
     repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
     installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
     projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
@@ -1175,20 +1893,47 @@ declare const ResourceRef: z.ZodDiscriminatedUnion<[z.ZodObject<{
     mountPath: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>], "kind">;
 type ResourceRef = z.infer<typeof ResourceRef>;
+declare class ResourceMountPathError extends Error {
+    constructor(message: string);
+}
+/**
+ * Normalize one workspace-relative resource mount path for every runtime.
+ *
+ * Backslashes are treated as separators so a path cannot be harmless on Linux
+ * but become traversal on a connected Windows machine. Empty, absolute,
+ * drive-qualified, dot-segment, NUL-containing, and repeated-separator paths
+ * fail closed instead of being silently reinterpreted.
+ */
+declare function normalizeResourceMountPath(path: string): string;
+/** Normalize a repository-internal subpath while preserving legacy `/path/` input. */
+declare function normalizeRepositorySubpath(path: string): string;
+/** A conservative collision identity that is portable to case-insensitive hosts. */
+declare function resourceMountPathCollisionKey(path: string): string;
+/**
+ * Default repository mount identity. The normalized remote host (including a
+ * non-default port) is part of the path, so equal owner/repo names on GitHub,
+ * GitLab, Azure DevOps, or a custom host do not collide. Encoding the host keeps
+ * IPv6/custom-port identities inside one portable path segment.
+ */
+declare function defaultRepositoryMountPath(uri: string): string;
+/** Resolve the exact mount used by API normalization, manifests, and clone hooks. */
+declare function resourceMountPath(resource: ResourceRef): string;
+/** Fail before sandbox execution when two resources share a portable path. */
+declare function assertUniqueResourceMountPaths(resources: readonly ResourceRef[]): void;
 declare const FileStatus: z.ZodEnum<{
     failed: "failed";
+    expired: "expired";
     pending_upload: "pending_upload";
     ready: "ready";
-    expired: "expired";
     deleted: "deleted";
 }>;
 type FileStatus = z.infer<typeof FileStatus>;
 declare const FileUploadStatus: z.ZodEnum<{
     failed: "failed";
+    completed: "completed";
     expired: "expired";
     pending: "pending";
     cleanup_pending: "cleanup_pending";
-    completed: "completed";
 }>;
 type FileUploadStatus = z.infer<typeof FileUploadStatus>;
 declare const FileAsset: z.ZodObject<{
@@ -1196,9 +1941,9 @@ declare const FileAsset: z.ZodObject<{
     workspaceId: z.ZodString;
     status: z.ZodEnum<{
         failed: "failed";
+        expired: "expired";
         pending_upload: "pending_upload";
         ready: "ready";
-        expired: "expired";
         deleted: "deleted";
     }>;
     filename: z.ZodString;
@@ -1234,9 +1979,9 @@ declare const CompleteFileUploadResponse: z.ZodObject<{
         workspaceId: z.ZodString;
         status: z.ZodEnum<{
             failed: "failed";
+            expired: "expired";
             pending_upload: "pending_upload";
             ready: "ready";
-            expired: "expired";
             deleted: "deleted";
         }>;
         filename: z.ZodString;
@@ -1748,6 +2493,27 @@ declare const SessionMcpServerInput: z.ZodObject<{
     cacheToolsList: z.ZodOptional<z.ZodBoolean>;
     requireApproval: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
     headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    connectionRef: z.ZodOptional<z.ZodObject<{
+        connectionId: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+        providerDomain: z.ZodString;
+        kind: z.ZodOptional<z.ZodEnum<{
+            oauth2: "oauth2";
+            api_key: "api_key";
+            app_install: "app_install";
+            delegated: "delegated";
+        }>>;
+        scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        resource: z.ZodOptional<z.ZodString>;
+        selectedResources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodLiteral<"repository">;
+        }, z.core.$strict>>>;
+        subjectScope: z.ZodOptional<z.ZodEnum<{
+            subject: "subject";
+            workspace: "workspace";
+        }>>;
+    }, z.core.$strict>>;
 }, z.core.$strip>;
 type SessionMcpServerInput = z.infer<typeof SessionMcpServerInput>;
 declare const SessionMcpCredentialUpdateInput: z.ZodObject<{
@@ -1761,6 +2527,27 @@ declare const SessionMcpServerMetadata: z.ZodObject<{
     url: z.ZodString;
     headerNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
     credentialVersion: z.ZodNumber;
+    connectionRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        connectionId: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+        providerDomain: z.ZodString;
+        kind: z.ZodOptional<z.ZodEnum<{
+            oauth2: "oauth2";
+            api_key: "api_key";
+            app_install: "app_install";
+            delegated: "delegated";
+        }>>;
+        scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        resource: z.ZodOptional<z.ZodString>;
+        selectedResources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodLiteral<"repository">;
+        }, z.core.$strict>>>;
+        subjectScope: z.ZodOptional<z.ZodEnum<{
+            subject: "subject";
+            workspace: "workspace";
+        }>>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>;
 type SessionMcpServerMetadata = z.infer<typeof SessionMcpServerMetadata>;
 declare class ResourceRefConflictError extends Error {
@@ -1783,6 +2570,7 @@ declare const SessionTurnStatus: z.ZodEnum<{
     cancelled: "cancelled";
     completed: "completed";
     superseded: "superseded";
+    withdrawn_for_edit: "withdrawn_for_edit";
 }>;
 type SessionTurnStatus = z.infer<typeof SessionTurnStatus>;
 declare const SessionTurnSource: z.ZodEnum<{
@@ -1795,18 +2583,18 @@ declare const SessionTurnSource: z.ZodEnum<{
 }>;
 type SessionTurnSource = z.infer<typeof SessionTurnSource>;
 declare const SessionControlState: z.ZodEnum<{
-    paused: "paused";
     active: "active";
+    paused: "paused";
 }>;
 type SessionControlState = z.infer<typeof SessionControlState>;
 declare const WorkspaceInferenceState: z.ZodEnum<{
-    paused: "paused";
     active: "active";
+    paused: "paused";
 }>;
 type WorkspaceInferenceState = z.infer<typeof WorkspaceInferenceState>;
 declare const SessionGoalStatus: z.ZodEnum<{
-    paused: "paused";
     active: "active";
+    paused: "paused";
     completed: "completed";
 }>;
 type SessionGoalStatus = z.infer<typeof SessionGoalStatus>;
@@ -1831,8 +2619,8 @@ declare const SessionGoal: z.ZodObject<{
     workspaceId: z.ZodString;
     sessionId: z.ZodString;
     status: z.ZodEnum<{
-        paused: "paused";
         active: "active";
+        paused: "paused";
         completed: "completed";
     }>;
     text: z.ZodString;
@@ -1862,8 +2650,8 @@ declare const GoalSpec: z.ZodObject<{
 type GoalSpec = z.infer<typeof GoalSpec>;
 declare const UpdateSessionGoalRequest: z.ZodObject<{
     status: z.ZodEnum<{
-        paused: "paused";
         active: "active";
+        paused: "paused";
     }>;
     rationale: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
@@ -1919,13 +2707,154 @@ type CompactSessionContextRequest = z.infer<typeof CompactSessionContextRequest>
 /** Outcome of a manual /compact trigger. */
 declare const CompactSessionContextResult: z.ZodObject<{
     status: z.ZodEnum<{
-        pending: "pending";
         completed: "completed";
+        pending: "pending";
         noop: "noop";
     }>;
     message: z.ZodString;
 }, z.core.$strip>;
 type CompactSessionContextResult = z.infer<typeof CompactSessionContextResult>;
+/**
+ * The principal whose authority accepted a session or turn. `subjectId` is an
+ * opaque host/standalone identity and therefore must never encode `kind` by
+ * convention: embedding hosts own their subject namespace.
+ */
+declare const TurnInitiator: z.ZodObject<{
+    subjectId: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    kind: z.ZodEnum<{
+        service: "service";
+        subject: "subject";
+    }>;
+}, z.core.$strip>;
+type TurnInitiator = z.infer<typeof TurnInitiator>;
+declare const SessionAuthorizationSurface: z.ZodEnum<{
+    toolspace: "toolspace";
+    http: "http";
+    core: "core";
+    stream: "stream";
+    first_party_mcp: "first_party_mcp";
+}>;
+type SessionAuthorizationSurface = z.infer<typeof SessionAuthorizationSurface>;
+declare const SessionAuthorizationOperation: z.ZodEnum<{
+    "session.read": "session.read";
+    "session.events.read": "session.events.read";
+    "session.stream.read": "session.stream.read";
+    "session.stream.acknowledge": "session.stream.acknowledge";
+    "session.turns.read": "session.turns.read";
+    "session.append": "session.append";
+    "session.steer": "session.steer";
+    "session.control": "session.control";
+    "session.queue.read": "session.queue.read";
+    "session.queue.control": "session.queue.control";
+    "session.composer.read": "session.composer.read";
+    "session.composer.write": "session.composer.write";
+    "session.lineage.read": "session.lineage.read";
+    "session.capture.read": "session.capture.read";
+    "session.files.read": "session.files.read";
+    "session.files.write": "session.files.write";
+    "session.git.read": "session.git.read";
+    "session.terminal.read": "session.terminal.read";
+    "session.terminal.control": "session.terminal.control";
+    "session.viewer.read": "session.viewer.read";
+    "session.viewer.control": "session.viewer.control";
+    "session.first_party_mcp.call": "session.first_party_mcp.call";
+    "session.toolspace.call": "session.toolspace.call";
+    "session.pin.write": "session.pin.write";
+    "session.codex_account.write": "session.codex_account.write";
+    "session.context.write": "session.context.write";
+    "session.approval.write": "session.approval.write";
+    "session.human_input.read": "session.human_input.read";
+    "session.human_input.write": "session.human_input.write";
+    "session.title.write": "session.title.write";
+    "session.goal.read": "session.goal.read";
+    "session.goal.write": "session.goal.write";
+    "session.child.create": "session.child.create";
+}>;
+type SessionAuthorizationOperation = z.infer<typeof SessionAuthorizationOperation>;
+declare const SessionAuthorizationActor: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"subject">;
+    subjectId: z.ZodString;
+    subjectLabel: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"agent_attempt">;
+    subjectId: z.ZodString;
+    callerSessionId: z.ZodString;
+    callerRootSessionId: z.ZodString;
+    turnId: z.ZodString;
+    attemptId: z.ZodString;
+    executionGeneration: z.ZodNumber;
+    initiator: z.ZodObject<{
+        subjectId: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        kind: z.ZodEnum<{
+            service: "service";
+            subject: "subject";
+        }>;
+    }, z.core.$strip>;
+    initiatorContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>], "kind">;
+type SessionAuthorizationActor = z.infer<typeof SessionAuthorizationActor>;
+declare const SessionAuthorizationTarget: z.ZodObject<{
+    sessionId: z.ZodString;
+    rootSessionId: z.ZodString;
+}, z.core.$strip>;
+type SessionAuthorizationTarget = z.infer<typeof SessionAuthorizationTarget>;
+type AuthorizeSessionInput = {
+    accountId: string;
+    workspaceId: string;
+    actor: SessionAuthorizationActor;
+    target: SessionAuthorizationTarget;
+    operation: SessionAuthorizationOperation;
+    surface: SessionAuthorizationSurface;
+};
+declare const SessionAuthorizationDecision: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    allowed: z.ZodLiteral<true>;
+    relatedSessionAccess: z.ZodOptional<z.ZodEnum<{
+        target: "target";
+        root: "root";
+    }>>;
+    reauthorizeAfterMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    allowed: z.ZodLiteral<false>;
+    reason: z.ZodEnum<{
+        forbidden: "forbidden";
+        not_found: "not_found";
+        revoked: "revoked";
+    }>;
+}, z.core.$strip>], "allowed">;
+type SessionAuthorizationDecision = z.infer<typeof SessionAuthorizationDecision>;
+/**
+ * A database-applicable listing scope. `rootSessionIds` includes every
+ * descendant of those lineage anchors; `sessionIds` authorizes only the exact
+ * sessions. Supplying neither is an explicit empty scope. OpenGeni intersects
+ * every id with the requested workspace and never trusts a host scope as
+ * session existence evidence.
+ */
+declare const SESSION_AUTHORIZATION_LIST_SCOPE_MAX_IDS = 10000;
+declare const SessionAuthorizationListScope: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"all">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"scoped">;
+    rootSessionIds: z.ZodArray<z.ZodString>;
+    sessionIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>], "kind">;
+type SessionAuthorizationListScope = z.infer<typeof SessionAuthorizationListScope>;
+type ResolveSessionAuthorizationListScopeInput = {
+    accountId: string;
+    workspaceId: string;
+    actor: SessionAuthorizationActor;
+    surface: SessionAuthorizationSurface;
+};
+type SessionAuthorizationPort = {
+    authorizeSession(input: AuthorizeSessionInput): Promise<SessionAuthorizationDecision>;
+    /**
+     * Return the complete current scope used inside OpenGeni's cursor query.
+     * This is deliberately not a post-filter callback: search, pinning, ordering,
+     * totals, and cursor advancement must all operate on authorized rows.
+     */
+    resolveListScope(input: ResolveSessionAuthorizationListScopeInput): Promise<SessionAuthorizationListScope>;
+};
 declare const SessionTurn: z.ZodObject<{
     id: z.ZodString;
     workspaceId: z.ZodString;
@@ -1942,6 +2871,7 @@ declare const SessionTurn: z.ZodObject<{
         cancelled: "cancelled";
         completed: "completed";
         superseded: "superseded";
+        withdrawn_for_edit: "withdrawn_for_edit";
     }>;
     source: z.ZodEnum<{
         user: "user";
@@ -1964,6 +2894,11 @@ declare const SessionTurn: z.ZodObject<{
             gitlab: "gitlab";
             azure_devops: "azure_devops";
         }>>;
+        credentialBindingId: z.ZodOptional<z.ZodString>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            write: "write";
+        }>>;
         repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
         installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
         projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
@@ -2012,6 +2947,15 @@ declare const SessionTurn: z.ZodObject<{
     executionGeneration: z.ZodNumber;
     activeAttemptId: z.ZodNullable<z.ZodString>;
     lineage: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    initiator: z.ZodObject<{
+        subjectId: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        kind: z.ZodEnum<{
+            service: "service";
+            subject: "subject";
+        }>;
+    }, z.core.$strip>;
+    initiatorContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     cancelledBy: z.ZodNullable<z.ZodString>;
     cancelReason: z.ZodNullable<z.ZodString>;
     startedAt: z.ZodNullable<z.ZodString>;
@@ -2020,19 +2964,256 @@ declare const SessionTurn: z.ZodObject<{
     updatedAt: z.ZodString;
 }, z.core.$strip>;
 type SessionTurn = z.infer<typeof SessionTurn>;
-declare const SessionQueueSnapshot: z.ZodObject<{
-    version: z.ZodNumber;
-    controlState: z.ZodEnum<{
-        paused: "paused";
+declare const EffectiveControlBlocker: z.ZodObject<{
+    kind: z.ZodEnum<{
+        workspace: "workspace";
+        session: "session";
+    }>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    displayName: z.ZodString;
+    actor: z.ZodNullable<z.ZodString>;
+    reason: z.ZodNullable<z.ZodString>;
+    changedAt: z.ZodNullable<z.ZodString>;
+    revision: z.ZodNumber;
+}, z.core.$strip>;
+type EffectiveControlBlocker = z.infer<typeof EffectiveControlBlocker>;
+declare const EffectiveControlResumeOption: z.ZodObject<{
+    scope: z.ZodEnum<{
+        workspace: "workspace";
+        session: "session";
+        selected: "selected";
+    }>;
+    targetId: z.ZodOptional<z.ZodString>;
+    selectedStateAfter: z.ZodEnum<{
         active: "active";
+        paused: "paused";
     }>;
-    controlGeneration: z.ZodNumber;
-    workspaceInferenceState: z.ZodEnum<{
+    remainingPrimaryBlocker: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            workspace: "workspace";
+            session: "session";
+        }>;
+        sessionId: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodString;
+        actor: z.ZodNullable<z.ZodString>;
+        reason: z.ZodNullable<z.ZodString>;
+        changedAt: z.ZodNullable<z.ZodString>;
+        revision: z.ZodNumber;
+    }, z.core.$strip>>;
+    impactCopy: z.ZodString;
+}, z.core.$strip>;
+type EffectiveControlResumeOption = z.infer<typeof EffectiveControlResumeOption>;
+declare const EffectiveSessionControl: z.ZodObject<{
+    state: z.ZodEnum<{
+        active: "active";
         paused: "paused";
+    }>;
+    controlVersion: z.ZodNumber;
+    controlEtag: z.ZodString;
+    directState: z.ZodEnum<{
         active: "active";
+        paused: "paused";
+    }>;
+    primaryBlocker: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            workspace: "workspace";
+            session: "session";
+        }>;
+        sessionId: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodString;
+        actor: z.ZodNullable<z.ZodString>;
+        reason: z.ZodNullable<z.ZodString>;
+        changedAt: z.ZodNullable<z.ZodString>;
+        revision: z.ZodNumber;
+    }, z.core.$strip>>;
+    additionalBlockerCount: z.ZodNumber;
+    blockers: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            workspace: "workspace";
+            session: "session";
+        }>;
+        sessionId: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodString;
+        actor: z.ZodNullable<z.ZodString>;
+        reason: z.ZodNullable<z.ZodString>;
+        changedAt: z.ZodNullable<z.ZodString>;
+        revision: z.ZodNumber;
+    }, z.core.$strip>>;
+    resumeOptions: z.ZodArray<z.ZodObject<{
+        scope: z.ZodEnum<{
+            workspace: "workspace";
+            session: "session";
+            selected: "selected";
+        }>;
+        targetId: z.ZodOptional<z.ZodString>;
+        selectedStateAfter: z.ZodEnum<{
+            active: "active";
+            paused: "paused";
+        }>;
+        remainingPrimaryBlocker: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                workspace: "workspace";
+                session: "session";
+            }>;
+            sessionId: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodString;
+            actor: z.ZodNullable<z.ZodString>;
+            reason: z.ZodNullable<z.ZodString>;
+            changedAt: z.ZodNullable<z.ZodString>;
+            revision: z.ZodNumber;
+        }, z.core.$strip>>;
+        impactCopy: z.ZodString;
+    }, z.core.$strip>>;
+    override: z.ZodNullable<z.ZodObject<{
+        rootSessionId: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strip>>;
+    settlement: z.ZodNullable<z.ZodObject<{
+        state: z.ZodLiteral<"stopping">;
+        attemptCount: z.ZodNumber;
+        interruptionPendingCount: z.ZodNumber;
+        quiescencePendingCount: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type EffectiveSessionControl = z.infer<typeof EffectiveSessionControl>;
+declare const SESSION_OPERATION_KEY_MAX_CHARS = 256;
+declare const SessionCommandReceipt: z.ZodObject<{
+    id: z.ZodString;
+    action: z.ZodString;
+    operationKey: z.ZodString;
+    targetSessionId: z.ZodNullable<z.ZodString>;
+    targetTurnId: z.ZodNullable<z.ZodString>;
+    appliedControlRevision: z.ZodNullable<z.ZodNumber>;
+    appliedQueueVersion: z.ZodNullable<z.ZodNumber>;
+    appliedTurnVersion: z.ZodNullable<z.ZodNumber>;
+    appliedDraftRevision: z.ZodNullable<z.ZodNumber>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+type SessionCommandReceipt = z.infer<typeof SessionCommandReceipt>;
+declare const ComposerDraft: z.ZodObject<{
+    revision: z.ZodNumber;
+    text: z.ZodString;
+    resources: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"repository">;
+        uri: z.ZodString;
+        ref: z.ZodString;
+        mountPath: z.ZodOptional<z.ZodString>;
+        subpath: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodEnum<{
+            github: "github";
+            gitlab: "gitlab";
+            azure_devops: "azure_devops";
+        }>>;
+        credentialBindingId: z.ZodOptional<z.ZodString>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            write: "write";
+        }>>;
+        repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        connectionId: z.ZodOptional<z.ZodString>;
+        githubInstallationId: z.ZodOptional<z.ZodNumber>;
+        githubRepositoryId: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"file">;
+        fileId: z.ZodString;
+        mountPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "kind">>;
+    tools: z.ZodArray<z.ZodObject<{
+        kind: z.ZodLiteral<"mcp">;
+        id: z.ZodString;
+        optional: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    model: z.ZodString;
+    reasoningEffort: z.ZodEnum<{
+        none: "none";
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
     }>;
-    workspaceInferenceGeneration: z.ZodNumber;
-    workspaceRunExceptionGeneration: z.ZodNullable<z.ZodNumber>;
+    sourceTurnId: z.ZodNullable<z.ZodString>;
+    sourceTurnVersion: z.ZodNullable<z.ZodNumber>;
+    updatedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type ComposerDraft = z.infer<typeof ComposerDraft>;
+declare const SessionQueueSnapshot: z.ZodObject<{
+    version: z.ZodNumber;
+    effectiveControl: z.ZodObject<{
+        state: z.ZodEnum<{
+            active: "active";
+            paused: "paused";
+        }>;
+        controlVersion: z.ZodNumber;
+        controlEtag: z.ZodString;
+        directState: z.ZodEnum<{
+            active: "active";
+            paused: "paused";
+        }>;
+        primaryBlocker: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                workspace: "workspace";
+                session: "session";
+            }>;
+            sessionId: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodString;
+            actor: z.ZodNullable<z.ZodString>;
+            reason: z.ZodNullable<z.ZodString>;
+            changedAt: z.ZodNullable<z.ZodString>;
+            revision: z.ZodNumber;
+        }, z.core.$strip>>;
+        additionalBlockerCount: z.ZodNumber;
+        blockers: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                workspace: "workspace";
+                session: "session";
+            }>;
+            sessionId: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodString;
+            actor: z.ZodNullable<z.ZodString>;
+            reason: z.ZodNullable<z.ZodString>;
+            changedAt: z.ZodNullable<z.ZodString>;
+            revision: z.ZodNumber;
+        }, z.core.$strip>>;
+        resumeOptions: z.ZodArray<z.ZodObject<{
+            scope: z.ZodEnum<{
+                workspace: "workspace";
+                session: "session";
+                selected: "selected";
+            }>;
+            targetId: z.ZodOptional<z.ZodString>;
+            selectedStateAfter: z.ZodEnum<{
+                active: "active";
+                paused: "paused";
+            }>;
+            remainingPrimaryBlocker: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    workspace: "workspace";
+                    session: "session";
+                }>;
+                sessionId: z.ZodOptional<z.ZodString>;
+                displayName: z.ZodString;
+                actor: z.ZodNullable<z.ZodString>;
+                reason: z.ZodNullable<z.ZodString>;
+                changedAt: z.ZodNullable<z.ZodString>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+            impactCopy: z.ZodString;
+        }, z.core.$strip>>;
+        override: z.ZodNullable<z.ZodObject<{
+            rootSessionId: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strip>>;
+        settlement: z.ZodNullable<z.ZodObject<{
+            state: z.ZodLiteral<"stopping">;
+            attemptCount: z.ZodNumber;
+            interruptionPendingCount: z.ZodNumber;
+            quiescencePendingCount: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    stoppingPreviousAttempt: z.ZodBoolean;
     items: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         workspaceId: z.ZodString;
@@ -2049,6 +3230,7 @@ declare const SessionQueueSnapshot: z.ZodObject<{
             cancelled: "cancelled";
             completed: "completed";
             superseded: "superseded";
+            withdrawn_for_edit: "withdrawn_for_edit";
         }>;
         source: z.ZodEnum<{
             user: "user";
@@ -2071,6 +3253,11 @@ declare const SessionQueueSnapshot: z.ZodObject<{
                 gitlab: "gitlab";
                 azure_devops: "azure_devops";
             }>>;
+            credentialBindingId: z.ZodOptional<z.ZodString>;
+            access: z.ZodOptional<z.ZodEnum<{
+                read: "read";
+                write: "write";
+            }>>;
             repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
             installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
             projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
@@ -2119,6 +3306,15 @@ declare const SessionQueueSnapshot: z.ZodObject<{
         executionGeneration: z.ZodNumber;
         activeAttemptId: z.ZodNullable<z.ZodString>;
         lineage: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        initiator: z.ZodObject<{
+            subjectId: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            kind: z.ZodEnum<{
+                service: "service";
+                subject: "subject";
+            }>;
+        }, z.core.$strip>;
+        initiatorContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         cancelledBy: z.ZodNullable<z.ZodString>;
         cancelReason: z.ZodNullable<z.ZodString>;
         startedAt: z.ZodNullable<z.ZodString>;
@@ -2128,84 +3324,304 @@ declare const SessionQueueSnapshot: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 type SessionQueueSnapshot = z.infer<typeof SessionQueueSnapshot>;
-declare const CancelSessionQueueItemRequest: z.ZodObject<{
+declare const MoveSessionQueueItemRequest: z.ZodObject<{
+    clientEventId: z.ZodString;
     expectedQueueVersion: z.ZodNumber;
-    expectedItemVersion: z.ZodNumber;
+    beforeTurnId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type MoveSessionQueueItemRequest = z.infer<typeof MoveSessionQueueItemRequest>;
+declare const EditSessionQueueItemRequest: z.ZodObject<{
+    clientEventId: z.ZodString;
+    expectedTurnVersion: z.ZodNumber;
+    expectedDraftRevision: z.ZodNumber;
+    replaceDraft: z.ZodBoolean;
+}, z.core.$strip>;
+type EditSessionQueueItemRequest = z.infer<typeof EditSessionQueueItemRequest>;
+declare const SteerSessionQueueItemRequest: z.ZodObject<{
+    clientEventId: z.ZodString;
+    expectedTurnVersion: z.ZodNumber;
+    controlEtag: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SteerSessionQueueItemRequest = z.infer<typeof SteerSessionQueueItemRequest>;
+declare const DeleteSessionQueueItemRequest: z.ZodObject<{
+    clientEventId: z.ZodString;
+    expectedTurnVersion: z.ZodNumber;
     reason: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-type CancelSessionQueueItemRequest = z.infer<typeof CancelSessionQueueItemRequest>;
+type DeleteSessionQueueItemRequest = z.infer<typeof DeleteSessionQueueItemRequest>;
+declare const SaveComposerDraftRequest: z.ZodObject<{
+    model: z.ZodString;
+    text: z.ZodString;
+    reasoningEffort: z.ZodEnum<{
+        none: "none";
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+    }>;
+    resources: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"repository">;
+        uri: z.ZodString;
+        ref: z.ZodString;
+        mountPath: z.ZodOptional<z.ZodString>;
+        subpath: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodEnum<{
+            github: "github";
+            gitlab: "gitlab";
+            azure_devops: "azure_devops";
+        }>>;
+        credentialBindingId: z.ZodOptional<z.ZodString>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            write: "write";
+        }>>;
+        repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        connectionId: z.ZodOptional<z.ZodString>;
+        githubInstallationId: z.ZodOptional<z.ZodNumber>;
+        githubRepositoryId: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"file">;
+        fileId: z.ZodString;
+        mountPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "kind">>;
+    tools: z.ZodArray<z.ZodObject<{
+        kind: z.ZodLiteral<"mcp">;
+        id: z.ZodString;
+        optional: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    expectedRevision: z.ZodNumber;
+}, z.core.$strip>;
+type SaveComposerDraftRequest = z.infer<typeof SaveComposerDraftRequest>;
+declare const WORKSPACE_CONTROL_REASON_MAX_BYTES: number;
+declare const WORKSPACE_CONTROL_ACTOR_MAX_BYTES = 1024;
+declare const WORKSPACE_CONTROL_EVENT_MAX_BYTES: number;
 declare const SessionControlRequest: z.ZodObject<{
-    mode: z.ZodEnum<{
+    action: z.ZodEnum<{
         pause: "pause";
         resume: "resume";
     }>;
     reason: z.ZodOptional<z.ZodString>;
-    clientEventId: z.ZodOptional<z.ZodString>;
-    expectedControlState: z.ZodOptional<z.ZodEnum<{
-        paused: "paused";
-        active: "active";
-    }>>;
-    expectedControlGeneration: z.ZodOptional<z.ZodNumber>;
-    expectedWorkspaceInferenceGeneration: z.ZodOptional<z.ZodNumber>;
+    clientEventId: z.ZodString;
+    expectedControlEtag: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type SessionControlRequest = z.infer<typeof SessionControlRequest>;
 declare const WorkspaceInferenceControlRequest: z.ZodObject<{
-    state: z.ZodEnum<{
-        paused: "paused";
-        active: "active";
+    action: z.ZodEnum<{
+        pause: "pause";
+        resume: "resume";
     }>;
-    reason: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
     clientEventId: z.ZodString;
-    expectedState: z.ZodEnum<{
-        paused: "paused";
-        active: "active";
-    }>;
-    expectedGeneration: z.ZodNumber;
-    exceptSessionIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    expectedRevision: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 type WorkspaceInferenceControlRequest = z.infer<typeof WorkspaceInferenceControlRequest>;
 declare const WorkspaceInferenceControlResponse: z.ZodObject<{
-    operationId: z.ZodString;
+    receipt: z.ZodObject<{
+        id: z.ZodString;
+        action: z.ZodString;
+        operationKey: z.ZodString;
+        targetSessionId: z.ZodNullable<z.ZodString>;
+        targetTurnId: z.ZodNullable<z.ZodString>;
+        appliedControlRevision: z.ZodNullable<z.ZodNumber>;
+        appliedQueueVersion: z.ZodNullable<z.ZodNumber>;
+        appliedTurnVersion: z.ZodNullable<z.ZodNumber>;
+        appliedDraftRevision: z.ZodNullable<z.ZodNumber>;
+        createdAt: z.ZodString;
+    }, z.core.$strip>;
     state: z.ZodEnum<{
-        paused: "paused";
         active: "active";
+        paused: "paused";
     }>;
-    generation: z.ZodNumber;
-    affectedSessionIds: z.ZodArray<z.ZodString>;
-    controlSessionIds: z.ZodArray<z.ZodString>;
-    exceptionSessionIds: z.ZodArray<z.ZodString>;
+    revision: z.ZodNumber;
+    interruptionCount: z.ZodNumber;
+    wakeCount: z.ZodNumber;
 }, z.core.$strip>;
 type WorkspaceInferenceControlResponse = z.infer<typeof WorkspaceInferenceControlResponse>;
-declare const SystemUpdateClassification: z.ZodEnum<{
-    success: "success";
-    failure: "failure";
-    action_required: "action_required";
-    info: "info";
-}>;
-type SystemUpdateClassification = z.infer<typeof SystemUpdateClassification>;
-declare const SessionSystemUpdateKind: z.ZodEnum<{
-    child_session_update: "child_session_update";
-    scheduled_wake: "scheduled_wake";
-    lifecycle_event: "lifecycle_event";
-    runtime_notice: "runtime_notice";
-}>;
-type SessionSystemUpdateKind = z.infer<typeof SessionSystemUpdateKind>;
-declare const SessionSystemUpdateState: z.ZodEnum<{
-    failed: "failed";
-    cancelled: "cancelled";
-    pending: "pending";
-    deferred: "deferred";
-    delivered: "delivered";
-}>;
-type SessionSystemUpdateState = z.infer<typeof SessionSystemUpdateState>;
-declare const SessionSystemUpdate: z.ZodObject<{
+/**
+ * One durable workspace-wide invalidation for one committed control revision.
+ * It is not conversation history and never becomes queue work; clients use it
+ * only to refetch authoritative workspace/session projections.
+ */
+declare const WorkspaceControlEventTruncation: z.ZodObject<{
+    truncated: z.ZodLiteral<true>;
+    surface: z.ZodEnum<{
+        durable_control: "durable_control";
+        database_guard: "database_guard";
+        http_projection: "http_projection";
+        nats_legacy_guard: "nats_legacy_guard";
+        sse_legacy_guard: "sse_legacy_guard";
+    }>;
+    deliveredBytes: z.ZodNumber;
+    fields: z.ZodArray<z.ZodObject<{
+        field: z.ZodEnum<{
+            reason: "reason";
+            actor: "actor";
+        }>;
+        originalBytes: z.ZodNumber;
+        deliveredBytes: z.ZodNumber;
+        omittedBytes: z.ZodNumber;
+    }, z.core.$strip>>;
+    fullEvidence: z.ZodObject<{
+        available: z.ZodLiteral<false>;
+        reason: z.ZodLiteral<"not_retained">;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type WorkspaceControlEventTruncation = z.infer<typeof WorkspaceControlEventTruncation>;
+declare const WorkspaceControlEvent: z.ZodObject<{
+    id: z.ZodString;
+    workspaceId: z.ZodString;
+    sequence: z.ZodNumber;
+    revision: z.ZodNumber;
+    type: z.ZodLiteral<"workspace.control.changed">;
+    scope: z.ZodEnum<{
+        workspace: "workspace";
+        session: "session";
+    }>;
+    rootSessionId: z.ZodNullable<z.ZodString>;
+    action: z.ZodEnum<{
+        pause: "pause";
+        resume: "resume";
+    }>;
+    automatic: z.ZodBoolean;
+    reason: z.ZodNullable<z.ZodString>;
+    actor: z.ZodString;
+    occurredAt: z.ZodString;
+    truncation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        truncated: z.ZodLiteral<true>;
+        surface: z.ZodEnum<{
+            durable_control: "durable_control";
+            database_guard: "database_guard";
+            http_projection: "http_projection";
+            nats_legacy_guard: "nats_legacy_guard";
+            sse_legacy_guard: "sse_legacy_guard";
+        }>;
+        deliveredBytes: z.ZodNumber;
+        fields: z.ZodArray<z.ZodObject<{
+            field: z.ZodEnum<{
+                reason: "reason";
+                actor: "actor";
+            }>;
+            originalBytes: z.ZodNumber;
+            deliveredBytes: z.ZodNumber;
+            omittedBytes: z.ZodNumber;
+        }, z.core.$strip>>;
+        fullEvidence: z.ZodObject<{
+            available: z.ZodLiteral<false>;
+            reason: z.ZodLiteral<"not_retained">;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type WorkspaceControlEvent = z.infer<typeof WorkspaceControlEvent>;
+type WorkspaceControlBoundarySurface = WorkspaceControlEventTruncation["surface"];
+type BoundWorkspaceControlEventOptions = {
+    surface?: WorkspaceControlBoundarySurface;
+    reasonOriginalBytes?: number | null;
+    actorOriginalBytes?: number | null;
+};
+/** UTF-8 byte count used by workspace-control storage and transport guards. */
+declare function workspaceControlUtf8Bytes(value: string): number;
+/**
+ * Canonical bounded invalidation event. The event is not a full evidence store:
+ * when a producer or legacy row exceeds a field cap, the retained head carries
+ * a visible marker and structured exact byte-loss facts.
+ */
+declare function boundWorkspaceControlEvent(event: WorkspaceControlEvent, options?: BoundWorkspaceControlEventOptions): WorkspaceControlEvent;
+declare const SystemUpdateClassification: z.ZodEnum<{
+    success: "success";
+    failure: "failure";
+    action_required: "action_required";
+    info: "info";
+}>;
+type SystemUpdateClassification = z.infer<typeof SystemUpdateClassification>;
+declare const SessionSystemUpdateKind: z.ZodEnum<{
+    scheduled_occurrence: "scheduled_occurrence";
+    goal_continuation: "goal_continuation";
+    agent_message: "agent_message";
+    agent_steer_instruction: "agent_steer_instruction";
+    child_terminal_result: "child_terminal_result";
+}>;
+type SessionSystemUpdateKind = z.infer<typeof SessionSystemUpdateKind>;
+declare const SessionSystemUpdatePayload: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"scheduled_occurrence">;
+    text: z.ZodString;
+    scheduledTaskId: z.ZodString;
+    scheduledTaskRunId: z.ZodString;
+    resources: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"repository">;
+        uri: z.ZodString;
+        ref: z.ZodString;
+        mountPath: z.ZodOptional<z.ZodString>;
+        subpath: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodEnum<{
+            github: "github";
+            gitlab: "gitlab";
+            azure_devops: "azure_devops";
+        }>>;
+        credentialBindingId: z.ZodOptional<z.ZodString>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            write: "write";
+        }>>;
+        repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        connectionId: z.ZodOptional<z.ZodString>;
+        githubInstallationId: z.ZodOptional<z.ZodNumber>;
+        githubRepositoryId: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"file">;
+        fileId: z.ZodString;
+        mountPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "kind">>>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodLiteral<"mcp">;
+        id: z.ZodString;
+        optional: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$loose>, z.ZodObject<{
+    type: z.ZodLiteral<"goal_continuation">;
+    goalId: z.ZodString;
+    goalVersion: z.ZodNumber;
+    prompt: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>, z.ZodObject<{
+    type: z.ZodLiteral<"agent_message">;
+    text: z.ZodString;
+    operationId: z.ZodString;
+}, z.core.$loose>, z.ZodObject<{
+    type: z.ZodLiteral<"agent_steer_instruction">;
+    instruction: z.ZodString;
+    operationId: z.ZodString;
+}, z.core.$loose>, z.ZodObject<{
+    type: z.ZodLiteral<"child_terminal_result">;
+    childSessionId: z.ZodString;
+    status: z.ZodEnum<{
+        idle: "idle";
+        failed: "failed";
+    }>;
+}, z.core.$loose>], "type">;
+type SessionSystemUpdatePayload = z.infer<typeof SessionSystemUpdatePayload>;
+declare const SessionSystemUpdateState: z.ZodEnum<{
+    failed: "failed";
+    cancelled: "cancelled";
+    pending: "pending";
+    superseded: "superseded";
+    deferred: "deferred";
+    delivered: "delivered";
+}>;
+type SessionSystemUpdateState = z.infer<typeof SessionSystemUpdateState>;
+declare const SessionSystemUpdate: z.ZodObject<{
     id: z.ZodString;
     sessionId: z.ZodString;
     kind: z.ZodEnum<{
-        child_session_update: "child_session_update";
-        scheduled_wake: "scheduled_wake";
-        lifecycle_event: "lifecycle_event";
-        runtime_notice: "runtime_notice";
+        scheduled_occurrence: "scheduled_occurrence";
+        goal_continuation: "goal_continuation";
+        agent_message: "agent_message";
+        agent_steer_instruction: "agent_steer_instruction";
+        child_terminal_result: "child_terminal_result";
     }>;
     classification: z.ZodEnum<{
         success: "success";
@@ -2216,12 +3632,71 @@ declare const SessionSystemUpdate: z.ZodObject<{
     sourceId: z.ZodString;
     dedupeKey: z.ZodString;
     summary: z.ZodString;
-    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    payload: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"scheduled_occurrence">;
+        text: z.ZodString;
+        scheduledTaskId: z.ZodString;
+        scheduledTaskRunId: z.ZodString;
+        resources: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"repository">;
+            uri: z.ZodString;
+            ref: z.ZodString;
+            mountPath: z.ZodOptional<z.ZodString>;
+            subpath: z.ZodOptional<z.ZodString>;
+            provider: z.ZodOptional<z.ZodEnum<{
+                github: "github";
+                gitlab: "gitlab";
+                azure_devops: "azure_devops";
+            }>>;
+            credentialBindingId: z.ZodOptional<z.ZodString>;
+            access: z.ZodOptional<z.ZodEnum<{
+                read: "read";
+                write: "write";
+            }>>;
+            repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            connectionId: z.ZodOptional<z.ZodString>;
+            githubInstallationId: z.ZodOptional<z.ZodNumber>;
+            githubRepositoryId: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"file">;
+            fileId: z.ZodString;
+            mountPath: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "kind">>>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodLiteral<"mcp">;
+            id: z.ZodString;
+            optional: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"goal_continuation">;
+        goalId: z.ZodString;
+        goalVersion: z.ZodNumber;
+        prompt: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"agent_message">;
+        text: z.ZodString;
+        operationId: z.ZodString;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"agent_steer_instruction">;
+        instruction: z.ZodString;
+        operationId: z.ZodString;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"child_terminal_result">;
+        childSessionId: z.ZodString;
+        status: z.ZodEnum<{
+            idle: "idle";
+            failed: "failed";
+        }>;
+    }, z.core.$loose>], "type">;
     lineage: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     state: z.ZodEnum<{
         failed: "failed";
         cancelled: "cancelled";
         pending: "pending";
+        superseded: "superseded";
         deferred: "deferred";
         delivered: "delivered";
     }>;
@@ -2515,8 +3990,8 @@ declare const ProposeRigChangeRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strip>], "kind">;
 type ProposeRigChangeRequest = z.infer<typeof ProposeRigChangeRequest>;
 declare const ScheduledTaskStatus: z.ZodEnum<{
-    paused: "paused";
     active: "active";
+    paused: "paused";
 }>;
 type ScheduledTaskStatus = z.infer<typeof ScheduledTaskStatus>;
 declare const ScheduledTaskRunStatus: z.ZodEnum<{
@@ -2579,6 +4054,11 @@ declare const ScheduledTaskAgentConfig: z.ZodObject<{
             gitlab: "gitlab";
             azure_devops: "azure_devops";
         }>>;
+        credentialBindingId: z.ZodOptional<z.ZodString>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            write: "write";
+        }>>;
         repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
         installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
         projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
@@ -2631,8 +4111,8 @@ declare const ScheduledTask: z.ZodObject<{
     workspaceId: z.ZodString;
     name: z.ZodString;
     status: z.ZodEnum<{
-        paused: "paused";
         active: "active";
+        paused: "paused";
     }>;
     schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"once">;
@@ -2681,6 +4161,11 @@ declare const ScheduledTask: z.ZodObject<{
                 gitlab: "gitlab";
                 azure_devops: "azure_devops";
             }>>;
+            credentialBindingId: z.ZodOptional<z.ZodString>;
+            access: z.ZodOptional<z.ZodEnum<{
+                read: "read";
+                write: "write";
+            }>>;
             repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
             installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
             projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
@@ -2806,6 +4291,11 @@ declare const CreateScheduledTaskRequest: z.ZodPreprocess<z.ZodObject<{
                 gitlab: "gitlab";
                 azure_devops: "azure_devops";
             }>>;
+            credentialBindingId: z.ZodOptional<z.ZodString>;
+            access: z.ZodOptional<z.ZodEnum<{
+                read: "read";
+                write: "write";
+            }>>;
             repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
             installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
             projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
@@ -2852,8 +4342,8 @@ declare const CreateScheduledTaskRequest: z.ZodPreprocess<z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>;
     status: z.ZodDefault<z.ZodEnum<{
-        paused: "paused";
         active: "active";
+        paused: "paused";
     }>>;
     variableSetId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     environmentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -2909,6 +4399,11 @@ declare const UpdateScheduledTaskRequest: z.ZodPreprocess<z.ZodObject<{
                 gitlab: "gitlab";
                 azure_devops: "azure_devops";
             }>>;
+            credentialBindingId: z.ZodOptional<z.ZodString>;
+            access: z.ZodOptional<z.ZodEnum<{
+                read: "read";
+                write: "write";
+            }>>;
             repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
             installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
             projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
@@ -2955,8 +4450,8 @@ declare const UpdateScheduledTaskRequest: z.ZodPreprocess<z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     status: z.ZodOptional<z.ZodEnum<{
-        paused: "paused";
         active: "active";
+        paused: "paused";
     }>>;
     variableSetId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     environmentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -2974,9 +4469,9 @@ declare const TriggerScheduledTaskRequest: z.ZodObject<{
 }, z.core.$strip>;
 type TriggerScheduledTaskRequest = z.infer<typeof TriggerScheduledTaskRequest>;
 declare const CapabilityPackConnectorAuthModel: z.ZodEnum<{
+    api_key: "api_key";
     oauth2_authorization_code_pkce: "oauth2_authorization_code_pkce";
     oauth2_authorization_code: "oauth2_authorization_code";
-    api_key: "api_key";
     credential_ref: "credential_ref";
 }>;
 type CapabilityPackConnectorAuthModel = z.infer<typeof CapabilityPackConnectorAuthModel>;
@@ -2985,9 +4480,9 @@ declare const CapabilityPackConnector: z.ZodObject<{
     name: z.ZodString;
     category: z.ZodString;
     authModel: z.ZodEnum<{
+        api_key: "api_key";
         oauth2_authorization_code_pkce: "oauth2_authorization_code_pkce";
         oauth2_authorization_code: "oauth2_authorization_code";
-        api_key: "api_key";
         credential_ref: "credential_ref";
     }>;
     providers: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -3084,9 +4579,9 @@ declare const CapabilityPack: z.ZodPreprocess<z.ZodObject<{
         name: z.ZodString;
         category: z.ZodString;
         authModel: z.ZodEnum<{
+            api_key: "api_key";
             oauth2_authorization_code_pkce: "oauth2_authorization_code_pkce";
             oauth2_authorization_code: "oauth2_authorization_code";
-            api_key: "api_key";
             credential_ref: "credential_ref";
         }>;
         providers: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -3174,9 +4669,9 @@ declare const RegisterCapabilityPackRequest: z.ZodPreprocess<z.ZodObject<{
         name: z.ZodString;
         category: z.ZodString;
         authModel: z.ZodEnum<{
+            api_key: "api_key";
             oauth2_authorization_code_pkce: "oauth2_authorization_code_pkce";
             oauth2_authorization_code: "oauth2_authorization_code";
-            api_key: "api_key";
             credential_ref: "credential_ref";
         }>;
         providers: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -3267,9 +4762,9 @@ declare const WorkspaceRegisteredPack: z.ZodObject<{
             name: z.ZodString;
             category: z.ZodString;
             authModel: z.ZodEnum<{
+                api_key: "api_key";
                 oauth2_authorization_code_pkce: "oauth2_authorization_code_pkce";
                 oauth2_authorization_code: "oauth2_authorization_code";
-                api_key: "api_key";
                 credential_ref: "credential_ref";
             }>;
             providers: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -3464,8 +4959,8 @@ declare const CreateSocialPostRequest: z.ZodObject<{
 }, z.core.$strip>;
 type CreateSocialPostRequest = z.infer<typeof CreateSocialPostRequest>;
 declare const ConnectionKind: z.ZodEnum<{
-    api_key: "api_key";
     oauth2: "oauth2";
+    api_key: "api_key";
     app_install: "app_install";
     delegated: "delegated";
 }>;
@@ -3473,27 +4968,10 @@ type ConnectionKind = z.infer<typeof ConnectionKind>;
 declare const ConnectionStatus: z.ZodEnum<{
     error: "error";
     active: "active";
-    needs_reauth: "needs_reauth";
     revoked: "revoked";
+    needs_reauth: "needs_reauth";
 }>;
 type ConnectionStatus = z.infer<typeof ConnectionStatus>;
-declare const McpServerConnectionRef: z.ZodObject<{
-    connectionId: z.ZodOptional<z.ZodString>;
-    providerDomain: z.ZodString;
-    kind: z.ZodOptional<z.ZodEnum<{
-        api_key: "api_key";
-        oauth2: "oauth2";
-        app_install: "app_install";
-        delegated: "delegated";
-    }>>;
-    scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    resource: z.ZodOptional<z.ZodString>;
-    subjectScope: z.ZodOptional<z.ZodEnum<{
-        workspace: "workspace";
-        subject: "subject";
-    }>>;
-}, z.core.$strict>;
-type McpServerConnectionRef = z.infer<typeof McpServerConnectionRef>;
 declare const ConnectionMetadata: z.ZodObject<{
     id: z.ZodString;
     accountId: z.ZodString;
@@ -3501,16 +4979,16 @@ declare const ConnectionMetadata: z.ZodObject<{
     subjectId: z.ZodNullable<z.ZodString>;
     providerDomain: z.ZodString;
     kind: z.ZodEnum<{
-        api_key: "api_key";
         oauth2: "oauth2";
+        api_key: "api_key";
         app_install: "app_install";
         delegated: "delegated";
     }>;
     status: z.ZodEnum<{
         error: "error";
         active: "active";
-        needs_reauth: "needs_reauth";
         revoked: "revoked";
+        needs_reauth: "needs_reauth";
     }>;
     grantedScopes: z.ZodArray<z.ZodString>;
     expiresAt: z.ZodNullable<z.ZodString>;
@@ -3530,8 +5008,8 @@ type ConnectionCredentialBundle = z.infer<typeof ConnectionCredentialBundle>;
 declare const CreateConnectionRequest: z.ZodObject<{
     providerDomain: z.ZodString;
     kind: z.ZodEnum<{
-        api_key: "api_key";
         oauth2: "oauth2";
+        api_key: "api_key";
         app_install: "app_install";
         delegated: "delegated";
     }>;
@@ -3546,16 +5024,16 @@ declare const UpdateConnectionRequest: z.ZodObject<{
     providerDomain: z.ZodOptional<z.ZodString>;
     subjectId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     kind: z.ZodOptional<z.ZodEnum<{
-        api_key: "api_key";
         oauth2: "oauth2";
+        api_key: "api_key";
         app_install: "app_install";
         delegated: "delegated";
     }>>;
     status: z.ZodOptional<z.ZodEnum<{
         error: "error";
         active: "active";
-        needs_reauth: "needs_reauth";
         revoked: "revoked";
+        needs_reauth: "needs_reauth";
     }>>;
     credential: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     grantedScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -3571,16 +5049,16 @@ declare const ConnectionResponse: z.ZodObject<{
         subjectId: z.ZodNullable<z.ZodString>;
         providerDomain: z.ZodString;
         kind: z.ZodEnum<{
-            api_key: "api_key";
             oauth2: "oauth2";
+            api_key: "api_key";
             app_install: "app_install";
             delegated: "delegated";
         }>;
         status: z.ZodEnum<{
             error: "error";
             active: "active";
-            needs_reauth: "needs_reauth";
             revoked: "revoked";
+            needs_reauth: "needs_reauth";
         }>;
         grantedScopes: z.ZodArray<z.ZodString>;
         expiresAt: z.ZodNullable<z.ZodString>;
@@ -3604,16 +5082,16 @@ declare const ListConnectionsResponse: z.ZodObject<{
         subjectId: z.ZodNullable<z.ZodString>;
         providerDomain: z.ZodString;
         kind: z.ZodEnum<{
-            api_key: "api_key";
             oauth2: "oauth2";
+            api_key: "api_key";
             app_install: "app_install";
             delegated: "delegated";
         }>;
         status: z.ZodEnum<{
             error: "error";
             active: "active";
-            needs_reauth: "needs_reauth";
             revoked: "revoked";
+            needs_reauth: "needs_reauth";
         }>;
         grantedScopes: z.ZodArray<z.ZodString>;
         expiresAt: z.ZodNullable<z.ZodString>;
@@ -3674,8 +5152,8 @@ declare const MarketingDailyAnalysisTaskRequest: z.ZodObject<{
     minute: z.ZodDefault<z.ZodNumber>;
     promptInstructions: z.ZodOptional<z.ZodString>;
     status: z.ZodDefault<z.ZodEnum<{
-        paused: "paused";
         active: "active";
+        paused: "paused";
     }>>;
     runMode: z.ZodDefault<z.ZodEnum<{
         new_session_per_run: "new_session_per_run";
@@ -3700,6 +5178,7 @@ declare const CapabilitySource: z.ZodEnum<{
     configured: "configured";
     manual: "manual";
     built_in: "built_in";
+    library: "library";
     public_registry: "public_registry";
     registry: "registry";
 }>;
@@ -3712,8 +5191,8 @@ type CapabilityInstallationStatus = z.infer<typeof CapabilityInstallationStatus>
 declare const CapabilityCatalogAuthKind: z.ZodEnum<{
     none: "none";
     unknown: "unknown";
-    api_key: "api_key";
     oauth2: "oauth2";
+    api_key: "api_key";
 }>;
 type CapabilityCatalogAuthKind = z.infer<typeof CapabilityCatalogAuthKind>;
 declare const CapabilityCatalogTier: z.ZodEnum<{
@@ -3743,6 +5222,7 @@ declare const CapabilityCatalogItem: z.ZodObject<{
         configured: "configured";
         manual: "manual";
         built_in: "built_in";
+        library: "library";
         public_registry: "public_registry";
         registry: "registry";
     }>;
@@ -3761,8 +5241,8 @@ declare const CapabilityCatalogItem: z.ZodObject<{
     authKind: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
         none: "none";
         unknown: "unknown";
-        api_key: "api_key";
         oauth2: "oauth2";
+        api_key: "api_key";
     }>>>;
     credentialFacts: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     tier: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
@@ -3831,6 +5311,7 @@ declare const CreateCapabilityCatalogItemRequest: z.ZodObject<{
         configured: "configured";
         manual: "manual";
         built_in: "built_in";
+        library: "library";
         public_registry: "public_registry";
         registry: "registry";
     }>>;
@@ -3850,18 +5331,23 @@ declare const EnableCapabilityRequest: z.ZodPreprocess<z.ZodObject<{
     metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     connectionRef: z.ZodOptional<z.ZodObject<{
         connectionId: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
         providerDomain: z.ZodString;
         kind: z.ZodOptional<z.ZodEnum<{
-            api_key: "api_key";
             oauth2: "oauth2";
+            api_key: "api_key";
             app_install: "app_install";
             delegated: "delegated";
         }>>;
         scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
         resource: z.ZodOptional<z.ZodString>;
+        selectedResources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodLiteral<"repository">;
+        }, z.core.$strict>>>;
         subjectScope: z.ZodOptional<z.ZodEnum<{
-            workspace: "workspace";
             subject: "subject";
+            workspace: "workspace";
         }>>;
     }, z.core.$strict>>;
     headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -3885,6 +5371,7 @@ declare const CapabilityCatalogResponse: z.ZodObject<{
             configured: "configured";
             manual: "manual";
             built_in: "built_in";
+            library: "library";
             public_registry: "public_registry";
             registry: "registry";
         }>;
@@ -3903,8 +5390,8 @@ declare const CapabilityCatalogResponse: z.ZodObject<{
         authKind: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
             none: "none";
             unknown: "unknown";
-            api_key: "api_key";
             oauth2: "oauth2";
+            api_key: "api_key";
         }>>>;
         credentialFacts: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
         tier: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
@@ -3977,6 +5464,7 @@ declare const DiscoverMcpCapabilitiesResponse: z.ZodObject<{
             configured: "configured";
             manual: "manual";
             built_in: "built_in";
+            library: "library";
             public_registry: "public_registry";
             registry: "registry";
         }>;
@@ -3995,8 +5483,8 @@ declare const DiscoverMcpCapabilitiesResponse: z.ZodObject<{
         authKind: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
             none: "none";
             unknown: "unknown";
-            api_key: "api_key";
             oauth2: "oauth2";
+            api_key: "api_key";
         }>>>;
         credentialFacts: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
         tier: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
@@ -4045,7 +5533,6 @@ declare const Session: z.ZodObject<{
         requires_action: "requires_action";
         recovering: "recovering";
         waiting_capacity: "waiting_capacity";
-        paused: "paused";
         failed: "failed";
         cancelled: "cancelled";
     }>;
@@ -4067,6 +5554,11 @@ declare const Session: z.ZodObject<{
             gitlab: "gitlab";
             azure_devops: "azure_devops";
         }>>;
+        credentialBindingId: z.ZodOptional<z.ZodString>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            write: "write";
+        }>>;
         repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
         installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
         projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
@@ -4084,6 +5576,15 @@ declare const Session: z.ZodObject<{
         optional: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
     metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdBy: z.ZodObject<{
+        subjectId: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        kind: z.ZodEnum<{
+            service: "service";
+            subject: "subject";
+        }>;
+    }, z.core.$strip>;
+    createdByContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     model: z.ZodString;
     sandboxBackend: z.ZodEnum<{
         docker: "docker";
@@ -4156,6 +5657,27 @@ declare const Session: z.ZodObject<{
         url: z.ZodString;
         headerNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
         credentialVersion: z.ZodNumber;
+        connectionRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            connectionId: z.ZodOptional<z.ZodString>;
+            provider: z.ZodOptional<z.ZodString>;
+            providerDomain: z.ZodString;
+            kind: z.ZodOptional<z.ZodEnum<{
+                oauth2: "oauth2";
+                api_key: "api_key";
+                app_install: "app_install";
+                delegated: "delegated";
+            }>>;
+            scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            resource: z.ZodOptional<z.ZodString>;
+            selectedResources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodLiteral<"repository">;
+            }, z.core.$strict>>>;
+            subjectScope: z.ZodOptional<z.ZodEnum<{
+                subject: "subject";
+                workspace: "workspace";
+            }>>;
+        }, z.core.$strict>>>;
     }, z.core.$strict>>>;
     parentSessionId: z.ZodNullable<z.ZodString>;
     createIdempotencyKey: z.ZodNullable<z.ZodString>;
@@ -4165,15 +5687,78 @@ declare const Session: z.ZodObject<{
     queueVersion: z.ZodNumber;
     queueHeadPosition: z.ZodNumber;
     queueTailPosition: z.ZodNumber;
-    controlState: z.ZodEnum<{
-        paused: "paused";
-        active: "active";
-    }>;
-    controlGeneration: z.ZodNumber;
-    controlReason: z.ZodNullable<z.ZodString>;
-    controlChangedBy: z.ZodNullable<z.ZodString>;
-    controlChangedAt: z.ZodNullable<z.ZodString>;
-    workspaceRunExceptionGeneration: z.ZodNullable<z.ZodNumber>;
+    effectiveControl: z.ZodObject<{
+        state: z.ZodEnum<{
+            active: "active";
+            paused: "paused";
+        }>;
+        controlVersion: z.ZodNumber;
+        controlEtag: z.ZodString;
+        directState: z.ZodEnum<{
+            active: "active";
+            paused: "paused";
+        }>;
+        primaryBlocker: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                workspace: "workspace";
+                session: "session";
+            }>;
+            sessionId: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodString;
+            actor: z.ZodNullable<z.ZodString>;
+            reason: z.ZodNullable<z.ZodString>;
+            changedAt: z.ZodNullable<z.ZodString>;
+            revision: z.ZodNumber;
+        }, z.core.$strip>>;
+        additionalBlockerCount: z.ZodNumber;
+        blockers: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                workspace: "workspace";
+                session: "session";
+            }>;
+            sessionId: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodString;
+            actor: z.ZodNullable<z.ZodString>;
+            reason: z.ZodNullable<z.ZodString>;
+            changedAt: z.ZodNullable<z.ZodString>;
+            revision: z.ZodNumber;
+        }, z.core.$strip>>;
+        resumeOptions: z.ZodArray<z.ZodObject<{
+            scope: z.ZodEnum<{
+                workspace: "workspace";
+                session: "session";
+                selected: "selected";
+            }>;
+            targetId: z.ZodOptional<z.ZodString>;
+            selectedStateAfter: z.ZodEnum<{
+                active: "active";
+                paused: "paused";
+            }>;
+            remainingPrimaryBlocker: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    workspace: "workspace";
+                    session: "session";
+                }>;
+                sessionId: z.ZodOptional<z.ZodString>;
+                displayName: z.ZodString;
+                actor: z.ZodNullable<z.ZodString>;
+                reason: z.ZodNullable<z.ZodString>;
+                changedAt: z.ZodNullable<z.ZodString>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+            impactCopy: z.ZodString;
+        }, z.core.$strip>>;
+        override: z.ZodNullable<z.ZodObject<{
+            rootSessionId: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strip>>;
+        settlement: z.ZodNullable<z.ZodObject<{
+            state: z.ZodLiteral<"stopping">;
+            attemptCount: z.ZodNumber;
+            interruptionPendingCount: z.ZodNumber;
+            quiescencePendingCount: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
     lastSequence: z.ZodNumber;
     codexPinnedCredentialId: z.ZodNullable<z.ZodString>;
     codexLastCredentialId: z.ZodNullable<z.ZodString>;
@@ -4188,33 +5773,298 @@ declare const Session: z.ZodObject<{
         attentionDescendants: z.ZodNumber;
         pausedDescendants: z.ZodNumber;
         failedDescendants: z.ZodNumber;
+        truncated: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
 }, z.core.$strip>;
 type Session = z.infer<typeof Session>;
-type SessionSummary = Session;
 /**
- * The canonical session-list page. Pinned rows are returned separately and are
- * excluded from `sessions`, so a cursor can page ordinary recency rows without
- * duplicating a pin. Pins are filtered by the same parent/search predicates as
- * ordinary rows and ordered by pinnedAt DESC, id DESC.
+ * Additive receipt returned only by session creation. `activeTurnId` remains an
+ * execution pointer and is correctly null while the first turn is queued;
+ * embedders use this immutable identity to correlate their preallocated run.
  */
-declare const SessionListResponse: z.ZodObject<{
-    pinned: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        workspaceId: z.ZodString;
-        accountId: z.ZodString;
-        status: z.ZodEnum<{
-            queued: "queued";
-            running: "running";
-            idle: "idle";
-            requires_action: "requires_action";
-            recovering: "recovering";
-            waiting_capacity: "waiting_capacity";
-            paused: "paused";
-            failed: "failed";
-            cancelled: "cancelled";
+declare const CreateSessionResponse: z.ZodObject<{
+    id: z.ZodString;
+    workspaceId: z.ZodString;
+    accountId: z.ZodString;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        idle: "idle";
+        requires_action: "requires_action";
+        recovering: "recovering";
+        waiting_capacity: "waiting_capacity";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>;
+    initialMessage: z.ZodString;
+    title: z.ZodNullable<z.ZodString>;
+    titleSource: z.ZodNullable<z.ZodEnum<{
+        user: "user";
+        agent: "agent";
+    }>>;
+    instructions: z.ZodNullable<z.ZodString>;
+    resources: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"repository">;
+        uri: z.ZodString;
+        ref: z.ZodString;
+        mountPath: z.ZodOptional<z.ZodString>;
+        subpath: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodEnum<{
+            github: "github";
+            gitlab: "gitlab";
+            azure_devops: "azure_devops";
+        }>>;
+        credentialBindingId: z.ZodOptional<z.ZodString>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            write: "write";
+        }>>;
+        repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        connectionId: z.ZodOptional<z.ZodString>;
+        githubInstallationId: z.ZodOptional<z.ZodNumber>;
+        githubRepositoryId: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"file">;
+        fileId: z.ZodString;
+        mountPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "kind">>;
+    tools: z.ZodArray<z.ZodObject<{
+        kind: z.ZodLiteral<"mcp">;
+        id: z.ZodString;
+        optional: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdBy: z.ZodObject<{
+        subjectId: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        kind: z.ZodEnum<{
+            service: "service";
+            subject: "subject";
+        }>;
+    }, z.core.$strip>;
+    createdByContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    model: z.ZodString;
+    sandboxBackend: z.ZodEnum<{
+        docker: "docker";
+        modal: "modal";
+        local: "local";
+        none: "none";
+        daytona: "daytona";
+        runloop: "runloop";
+        e2b: "e2b";
+        blaxel: "blaxel";
+        cloudflare: "cloudflare";
+        vercel: "vercel";
+        selfhosted: "selfhosted";
+    }>;
+    sandboxOs: z.ZodEnum<{
+        linux: "linux";
+        macos: "macos";
+        windows: "windows";
+    }>;
+    sandboxGroupId: z.ZodString;
+    activeSandboxId: z.ZodNullable<z.ZodString>;
+    activeEpoch: z.ZodNumber;
+    variableSetId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    environmentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    rigId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    rigVersionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    firstPartyMcpPermissions: z.ZodNullable<z.ZodArray<z.ZodEnum<{
+        "account:read": "account:read";
+        "account:admin": "account:admin";
+        "members:manage": "members:manage";
+        "workspace:create": "workspace:create";
+        "billing:read": "billing:read";
+        "billing:manage": "billing:manage";
+        "workspace:read": "workspace:read";
+        "workspace:admin": "workspace:admin";
+        "sessions:create": "sessions:create";
+        "sessions:read": "sessions:read";
+        "sessions:control": "sessions:control";
+        "stream:view": "stream:view";
+        "stream:control": "stream:control";
+        "stream:acknowledge": "stream:acknowledge";
+        "files:upload": "files:upload";
+        "files:read": "files:read";
+        "files:write": "files:write";
+        "terminal:attach": "terminal:attach";
+        "documents:manage": "documents:manage";
+        "documents:search": "documents:search";
+        "scheduled_tasks:manage": "scheduled_tasks:manage";
+        "scheduled_tasks:run": "scheduled_tasks:run";
+        "github:manage": "github:manage";
+        "github:use": "github:use";
+        "api_keys:manage": "api_keys:manage";
+        "connections:read": "connections:read";
+        "connections:write": "connections:write";
+        "environments:manage": "environments:manage";
+        "environments:use": "environments:use";
+        "variable-sets:manage": "variable-sets:manage";
+        "variable-sets:use": "variable-sets:use";
+        "mcp_servers:attach": "mcp_servers:attach";
+        "toolspace:call": "toolspace:call";
+        "goals:manage": "goals:manage";
+        "enrollments:read": "enrollments:read";
+        "enrollments:manage": "enrollments:manage";
+        "rigs:use": "rigs:use";
+        "rigs:manage": "rigs:manage";
+    }>>>;
+    mcpServers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        url: z.ZodString;
+        headerNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        credentialVersion: z.ZodNumber;
+        connectionRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            connectionId: z.ZodOptional<z.ZodString>;
+            provider: z.ZodOptional<z.ZodString>;
+            providerDomain: z.ZodString;
+            kind: z.ZodOptional<z.ZodEnum<{
+                oauth2: "oauth2";
+                api_key: "api_key";
+                app_install: "app_install";
+                delegated: "delegated";
+            }>>;
+            scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            resource: z.ZodOptional<z.ZodString>;
+            selectedResources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodLiteral<"repository">;
+            }, z.core.$strict>>>;
+            subjectScope: z.ZodOptional<z.ZodEnum<{
+                subject: "subject";
+                workspace: "workspace";
+            }>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+    parentSessionId: z.ZodNullable<z.ZodString>;
+    createIdempotencyKey: z.ZodNullable<z.ZodString>;
+    temporalWorkflowId: z.ZodNullable<z.ZodString>;
+    activeTurnId: z.ZodNullable<z.ZodString>;
+    lastInputTokens: z.ZodNullable<z.ZodNumber>;
+    queueVersion: z.ZodNumber;
+    queueHeadPosition: z.ZodNumber;
+    queueTailPosition: z.ZodNumber;
+    effectiveControl: z.ZodObject<{
+        state: z.ZodEnum<{
+            active: "active";
+            paused: "paused";
+        }>;
+        controlVersion: z.ZodNumber;
+        controlEtag: z.ZodString;
+        directState: z.ZodEnum<{
+            active: "active";
+            paused: "paused";
+        }>;
+        primaryBlocker: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                workspace: "workspace";
+                session: "session";
+            }>;
+            sessionId: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodString;
+            actor: z.ZodNullable<z.ZodString>;
+            reason: z.ZodNullable<z.ZodString>;
+            changedAt: z.ZodNullable<z.ZodString>;
+            revision: z.ZodNumber;
+        }, z.core.$strip>>;
+        additionalBlockerCount: z.ZodNumber;
+        blockers: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                workspace: "workspace";
+                session: "session";
+            }>;
+            sessionId: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodString;
+            actor: z.ZodNullable<z.ZodString>;
+            reason: z.ZodNullable<z.ZodString>;
+            changedAt: z.ZodNullable<z.ZodString>;
+            revision: z.ZodNumber;
+        }, z.core.$strip>>;
+        resumeOptions: z.ZodArray<z.ZodObject<{
+            scope: z.ZodEnum<{
+                workspace: "workspace";
+                session: "session";
+                selected: "selected";
+            }>;
+            targetId: z.ZodOptional<z.ZodString>;
+            selectedStateAfter: z.ZodEnum<{
+                active: "active";
+                paused: "paused";
+            }>;
+            remainingPrimaryBlocker: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    workspace: "workspace";
+                    session: "session";
+                }>;
+                sessionId: z.ZodOptional<z.ZodString>;
+                displayName: z.ZodString;
+                actor: z.ZodNullable<z.ZodString>;
+                reason: z.ZodNullable<z.ZodString>;
+                changedAt: z.ZodNullable<z.ZodString>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+            impactCopy: z.ZodString;
+        }, z.core.$strip>>;
+        override: z.ZodNullable<z.ZodObject<{
+            rootSessionId: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strip>>;
+        settlement: z.ZodNullable<z.ZodObject<{
+            state: z.ZodLiteral<"stopping">;
+            attemptCount: z.ZodNumber;
+            interruptionPendingCount: z.ZodNumber;
+            quiescencePendingCount: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    lastSequence: z.ZodNumber;
+    codexPinnedCredentialId: z.ZodNullable<z.ZodString>;
+    codexLastCredentialId: z.ZodNullable<z.ZodString>;
+    pinned: z.ZodDefault<z.ZodBoolean>;
+    pinnedAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    pinVersion: z.ZodDefault<z.ZodNumber>;
+    treeStats: z.ZodOptional<z.ZodObject<{
+        directChildren: z.ZodNumber;
+        totalDescendants: z.ZodNumber;
+        runningDescendants: z.ZodNumber;
+        queuedDescendants: z.ZodNumber;
+        attentionDescendants: z.ZodNumber;
+        pausedDescendants: z.ZodNumber;
+        failedDescendants: z.ZodNumber;
+        truncated: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    initialTurnId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type CreateSessionResponse = z.infer<typeof CreateSessionResponse>;
+type SessionSummary = Session;
+/**
+ * The canonical session-list page. Pinned rows are returned separately and are
+ * excluded from `sessions`, so a cursor can page ordinary recency rows without
+ * duplicating a pin. The newest 100 matching pins are returned, ordered by
+ * pinnedAt DESC, id DESC; `pinnedTruncated` makes an older-pin omission
+ * explicit. Pins are filtered by the same parent/search predicates as ordinary
+ * rows.
+ */
+declare const SessionListResponse: z.ZodObject<{
+    pinned: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        workspaceId: z.ZodString;
+        accountId: z.ZodString;
+        status: z.ZodEnum<{
+            queued: "queued";
+            running: "running";
+            idle: "idle";
+            requires_action: "requires_action";
+            recovering: "recovering";
+            waiting_capacity: "waiting_capacity";
+            failed: "failed";
+            cancelled: "cancelled";
         }>;
         initialMessage: z.ZodString;
         title: z.ZodNullable<z.ZodString>;
@@ -4234,6 +6084,11 @@ declare const SessionListResponse: z.ZodObject<{
                 gitlab: "gitlab";
                 azure_devops: "azure_devops";
             }>>;
+            credentialBindingId: z.ZodOptional<z.ZodString>;
+            access: z.ZodOptional<z.ZodEnum<{
+                read: "read";
+                write: "write";
+            }>>;
             repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
             installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
             projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
@@ -4251,6 +6106,15 @@ declare const SessionListResponse: z.ZodObject<{
             optional: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>;
         metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        createdBy: z.ZodObject<{
+            subjectId: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            kind: z.ZodEnum<{
+                service: "service";
+                subject: "subject";
+            }>;
+        }, z.core.$strip>;
+        createdByContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         model: z.ZodString;
         sandboxBackend: z.ZodEnum<{
             docker: "docker";
@@ -4323,6 +6187,27 @@ declare const SessionListResponse: z.ZodObject<{
             url: z.ZodString;
             headerNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
             credentialVersion: z.ZodNumber;
+            connectionRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                connectionId: z.ZodOptional<z.ZodString>;
+                provider: z.ZodOptional<z.ZodString>;
+                providerDomain: z.ZodString;
+                kind: z.ZodOptional<z.ZodEnum<{
+                    oauth2: "oauth2";
+                    api_key: "api_key";
+                    app_install: "app_install";
+                    delegated: "delegated";
+                }>>;
+                scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                resource: z.ZodOptional<z.ZodString>;
+                selectedResources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    kind: z.ZodLiteral<"repository">;
+                }, z.core.$strict>>>;
+                subjectScope: z.ZodOptional<z.ZodEnum<{
+                    subject: "subject";
+                    workspace: "workspace";
+                }>>;
+            }, z.core.$strict>>>;
         }, z.core.$strict>>>;
         parentSessionId: z.ZodNullable<z.ZodString>;
         createIdempotencyKey: z.ZodNullable<z.ZodString>;
@@ -4332,15 +6217,78 @@ declare const SessionListResponse: z.ZodObject<{
         queueVersion: z.ZodNumber;
         queueHeadPosition: z.ZodNumber;
         queueTailPosition: z.ZodNumber;
-        controlState: z.ZodEnum<{
-            paused: "paused";
-            active: "active";
-        }>;
-        controlGeneration: z.ZodNumber;
-        controlReason: z.ZodNullable<z.ZodString>;
-        controlChangedBy: z.ZodNullable<z.ZodString>;
-        controlChangedAt: z.ZodNullable<z.ZodString>;
-        workspaceRunExceptionGeneration: z.ZodNullable<z.ZodNumber>;
+        effectiveControl: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                paused: "paused";
+            }>;
+            controlVersion: z.ZodNumber;
+            controlEtag: z.ZodString;
+            directState: z.ZodEnum<{
+                active: "active";
+                paused: "paused";
+            }>;
+            primaryBlocker: z.ZodNullable<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    workspace: "workspace";
+                    session: "session";
+                }>;
+                sessionId: z.ZodOptional<z.ZodString>;
+                displayName: z.ZodString;
+                actor: z.ZodNullable<z.ZodString>;
+                reason: z.ZodNullable<z.ZodString>;
+                changedAt: z.ZodNullable<z.ZodString>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+            additionalBlockerCount: z.ZodNumber;
+            blockers: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    workspace: "workspace";
+                    session: "session";
+                }>;
+                sessionId: z.ZodOptional<z.ZodString>;
+                displayName: z.ZodString;
+                actor: z.ZodNullable<z.ZodString>;
+                reason: z.ZodNullable<z.ZodString>;
+                changedAt: z.ZodNullable<z.ZodString>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+            resumeOptions: z.ZodArray<z.ZodObject<{
+                scope: z.ZodEnum<{
+                    workspace: "workspace";
+                    session: "session";
+                    selected: "selected";
+                }>;
+                targetId: z.ZodOptional<z.ZodString>;
+                selectedStateAfter: z.ZodEnum<{
+                    active: "active";
+                    paused: "paused";
+                }>;
+                remainingPrimaryBlocker: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        workspace: "workspace";
+                        session: "session";
+                    }>;
+                    sessionId: z.ZodOptional<z.ZodString>;
+                    displayName: z.ZodString;
+                    actor: z.ZodNullable<z.ZodString>;
+                    reason: z.ZodNullable<z.ZodString>;
+                    changedAt: z.ZodNullable<z.ZodString>;
+                    revision: z.ZodNumber;
+                }, z.core.$strip>>;
+                impactCopy: z.ZodString;
+            }, z.core.$strip>>;
+            override: z.ZodNullable<z.ZodObject<{
+                rootSessionId: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+            settlement: z.ZodNullable<z.ZodObject<{
+                state: z.ZodLiteral<"stopping">;
+                attemptCount: z.ZodNumber;
+                interruptionPendingCount: z.ZodNumber;
+                quiescencePendingCount: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
         lastSequence: z.ZodNumber;
         codexPinnedCredentialId: z.ZodNullable<z.ZodString>;
         codexLastCredentialId: z.ZodNullable<z.ZodString>;
@@ -4355,10 +6303,12 @@ declare const SessionListResponse: z.ZodObject<{
             attentionDescendants: z.ZodNumber;
             pausedDescendants: z.ZodNumber;
             failedDescendants: z.ZodNumber;
+            truncated: z.ZodDefault<z.ZodBoolean>;
         }, z.core.$strip>>;
         createdAt: z.ZodString;
         updatedAt: z.ZodString;
     }, z.core.$strip>>;
+    pinnedTruncated: z.ZodOptional<z.ZodBoolean>;
     sessions: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         workspaceId: z.ZodString;
@@ -4370,7 +6320,6 @@ declare const SessionListResponse: z.ZodObject<{
             requires_action: "requires_action";
             recovering: "recovering";
             waiting_capacity: "waiting_capacity";
-            paused: "paused";
             failed: "failed";
             cancelled: "cancelled";
         }>;
@@ -4392,6 +6341,11 @@ declare const SessionListResponse: z.ZodObject<{
                 gitlab: "gitlab";
                 azure_devops: "azure_devops";
             }>>;
+            credentialBindingId: z.ZodOptional<z.ZodString>;
+            access: z.ZodOptional<z.ZodEnum<{
+                read: "read";
+                write: "write";
+            }>>;
             repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
             installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
             projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
@@ -4409,6 +6363,15 @@ declare const SessionListResponse: z.ZodObject<{
             optional: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>;
         metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        createdBy: z.ZodObject<{
+            subjectId: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            kind: z.ZodEnum<{
+                service: "service";
+                subject: "subject";
+            }>;
+        }, z.core.$strip>;
+        createdByContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         model: z.ZodString;
         sandboxBackend: z.ZodEnum<{
             docker: "docker";
@@ -4481,6 +6444,27 @@ declare const SessionListResponse: z.ZodObject<{
             url: z.ZodString;
             headerNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
             credentialVersion: z.ZodNumber;
+            connectionRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                connectionId: z.ZodOptional<z.ZodString>;
+                provider: z.ZodOptional<z.ZodString>;
+                providerDomain: z.ZodString;
+                kind: z.ZodOptional<z.ZodEnum<{
+                    oauth2: "oauth2";
+                    api_key: "api_key";
+                    app_install: "app_install";
+                    delegated: "delegated";
+                }>>;
+                scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                resource: z.ZodOptional<z.ZodString>;
+                selectedResources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    kind: z.ZodLiteral<"repository">;
+                }, z.core.$strict>>>;
+                subjectScope: z.ZodOptional<z.ZodEnum<{
+                    subject: "subject";
+                    workspace: "workspace";
+                }>>;
+            }, z.core.$strict>>>;
         }, z.core.$strict>>>;
         parentSessionId: z.ZodNullable<z.ZodString>;
         createIdempotencyKey: z.ZodNullable<z.ZodString>;
@@ -4490,29 +6474,93 @@ declare const SessionListResponse: z.ZodObject<{
         queueVersion: z.ZodNumber;
         queueHeadPosition: z.ZodNumber;
         queueTailPosition: z.ZodNumber;
-        controlState: z.ZodEnum<{
-            paused: "paused";
-            active: "active";
-        }>;
-        controlGeneration: z.ZodNumber;
-        controlReason: z.ZodNullable<z.ZodString>;
-        controlChangedBy: z.ZodNullable<z.ZodString>;
-        controlChangedAt: z.ZodNullable<z.ZodString>;
-        workspaceRunExceptionGeneration: z.ZodNullable<z.ZodNumber>;
-        lastSequence: z.ZodNumber;
-        codexPinnedCredentialId: z.ZodNullable<z.ZodString>;
-        codexLastCredentialId: z.ZodNullable<z.ZodString>;
-        pinned: z.ZodDefault<z.ZodBoolean>;
-        pinnedAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-        pinVersion: z.ZodDefault<z.ZodNumber>;
-        treeStats: z.ZodOptional<z.ZodObject<{
-            directChildren: z.ZodNumber;
-            totalDescendants: z.ZodNumber;
-            runningDescendants: z.ZodNumber;
-            queuedDescendants: z.ZodNumber;
+        effectiveControl: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                paused: "paused";
+            }>;
+            controlVersion: z.ZodNumber;
+            controlEtag: z.ZodString;
+            directState: z.ZodEnum<{
+                active: "active";
+                paused: "paused";
+            }>;
+            primaryBlocker: z.ZodNullable<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    workspace: "workspace";
+                    session: "session";
+                }>;
+                sessionId: z.ZodOptional<z.ZodString>;
+                displayName: z.ZodString;
+                actor: z.ZodNullable<z.ZodString>;
+                reason: z.ZodNullable<z.ZodString>;
+                changedAt: z.ZodNullable<z.ZodString>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+            additionalBlockerCount: z.ZodNumber;
+            blockers: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    workspace: "workspace";
+                    session: "session";
+                }>;
+                sessionId: z.ZodOptional<z.ZodString>;
+                displayName: z.ZodString;
+                actor: z.ZodNullable<z.ZodString>;
+                reason: z.ZodNullable<z.ZodString>;
+                changedAt: z.ZodNullable<z.ZodString>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+            resumeOptions: z.ZodArray<z.ZodObject<{
+                scope: z.ZodEnum<{
+                    workspace: "workspace";
+                    session: "session";
+                    selected: "selected";
+                }>;
+                targetId: z.ZodOptional<z.ZodString>;
+                selectedStateAfter: z.ZodEnum<{
+                    active: "active";
+                    paused: "paused";
+                }>;
+                remainingPrimaryBlocker: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        workspace: "workspace";
+                        session: "session";
+                    }>;
+                    sessionId: z.ZodOptional<z.ZodString>;
+                    displayName: z.ZodString;
+                    actor: z.ZodNullable<z.ZodString>;
+                    reason: z.ZodNullable<z.ZodString>;
+                    changedAt: z.ZodNullable<z.ZodString>;
+                    revision: z.ZodNumber;
+                }, z.core.$strip>>;
+                impactCopy: z.ZodString;
+            }, z.core.$strip>>;
+            override: z.ZodNullable<z.ZodObject<{
+                rootSessionId: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+            settlement: z.ZodNullable<z.ZodObject<{
+                state: z.ZodLiteral<"stopping">;
+                attemptCount: z.ZodNumber;
+                interruptionPendingCount: z.ZodNumber;
+                quiescencePendingCount: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        lastSequence: z.ZodNumber;
+        codexPinnedCredentialId: z.ZodNullable<z.ZodString>;
+        codexLastCredentialId: z.ZodNullable<z.ZodString>;
+        pinned: z.ZodDefault<z.ZodBoolean>;
+        pinnedAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        pinVersion: z.ZodDefault<z.ZodNumber>;
+        treeStats: z.ZodOptional<z.ZodObject<{
+            directChildren: z.ZodNumber;
+            totalDescendants: z.ZodNumber;
+            runningDescendants: z.ZodNumber;
+            queuedDescendants: z.ZodNumber;
             attentionDescendants: z.ZodNumber;
             pausedDescendants: z.ZodNumber;
             failedDescendants: z.ZodNumber;
+            truncated: z.ZodDefault<z.ZodBoolean>;
         }, z.core.$strip>>;
         createdAt: z.ZodString;
         updatedAt: z.ZodString;
@@ -4537,7 +6585,6 @@ declare const SessionLineageResponse: z.ZodObject<{
             requires_action: "requires_action";
             recovering: "recovering";
             waiting_capacity: "waiting_capacity";
-            paused: "paused";
             failed: "failed";
             cancelled: "cancelled";
         }>;
@@ -4559,6 +6606,11 @@ declare const SessionLineageResponse: z.ZodObject<{
                 gitlab: "gitlab";
                 azure_devops: "azure_devops";
             }>>;
+            credentialBindingId: z.ZodOptional<z.ZodString>;
+            access: z.ZodOptional<z.ZodEnum<{
+                read: "read";
+                write: "write";
+            }>>;
             repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
             installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
             projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
@@ -4576,6 +6628,15 @@ declare const SessionLineageResponse: z.ZodObject<{
             optional: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>;
         metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        createdBy: z.ZodObject<{
+            subjectId: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            kind: z.ZodEnum<{
+                service: "service";
+                subject: "subject";
+            }>;
+        }, z.core.$strip>;
+        createdByContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         model: z.ZodString;
         sandboxBackend: z.ZodEnum<{
             docker: "docker";
@@ -4648,6 +6709,27 @@ declare const SessionLineageResponse: z.ZodObject<{
             url: z.ZodString;
             headerNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
             credentialVersion: z.ZodNumber;
+            connectionRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                connectionId: z.ZodOptional<z.ZodString>;
+                provider: z.ZodOptional<z.ZodString>;
+                providerDomain: z.ZodString;
+                kind: z.ZodOptional<z.ZodEnum<{
+                    oauth2: "oauth2";
+                    api_key: "api_key";
+                    app_install: "app_install";
+                    delegated: "delegated";
+                }>>;
+                scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                resource: z.ZodOptional<z.ZodString>;
+                selectedResources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    kind: z.ZodLiteral<"repository">;
+                }, z.core.$strict>>>;
+                subjectScope: z.ZodOptional<z.ZodEnum<{
+                    subject: "subject";
+                    workspace: "workspace";
+                }>>;
+            }, z.core.$strict>>>;
         }, z.core.$strict>>>;
         parentSessionId: z.ZodNullable<z.ZodString>;
         createIdempotencyKey: z.ZodNullable<z.ZodString>;
@@ -4657,15 +6739,78 @@ declare const SessionLineageResponse: z.ZodObject<{
         queueVersion: z.ZodNumber;
         queueHeadPosition: z.ZodNumber;
         queueTailPosition: z.ZodNumber;
-        controlState: z.ZodEnum<{
-            paused: "paused";
-            active: "active";
-        }>;
-        controlGeneration: z.ZodNumber;
-        controlReason: z.ZodNullable<z.ZodString>;
-        controlChangedBy: z.ZodNullable<z.ZodString>;
-        controlChangedAt: z.ZodNullable<z.ZodString>;
-        workspaceRunExceptionGeneration: z.ZodNullable<z.ZodNumber>;
+        effectiveControl: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                paused: "paused";
+            }>;
+            controlVersion: z.ZodNumber;
+            controlEtag: z.ZodString;
+            directState: z.ZodEnum<{
+                active: "active";
+                paused: "paused";
+            }>;
+            primaryBlocker: z.ZodNullable<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    workspace: "workspace";
+                    session: "session";
+                }>;
+                sessionId: z.ZodOptional<z.ZodString>;
+                displayName: z.ZodString;
+                actor: z.ZodNullable<z.ZodString>;
+                reason: z.ZodNullable<z.ZodString>;
+                changedAt: z.ZodNullable<z.ZodString>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+            additionalBlockerCount: z.ZodNumber;
+            blockers: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    workspace: "workspace";
+                    session: "session";
+                }>;
+                sessionId: z.ZodOptional<z.ZodString>;
+                displayName: z.ZodString;
+                actor: z.ZodNullable<z.ZodString>;
+                reason: z.ZodNullable<z.ZodString>;
+                changedAt: z.ZodNullable<z.ZodString>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+            resumeOptions: z.ZodArray<z.ZodObject<{
+                scope: z.ZodEnum<{
+                    workspace: "workspace";
+                    session: "session";
+                    selected: "selected";
+                }>;
+                targetId: z.ZodOptional<z.ZodString>;
+                selectedStateAfter: z.ZodEnum<{
+                    active: "active";
+                    paused: "paused";
+                }>;
+                remainingPrimaryBlocker: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        workspace: "workspace";
+                        session: "session";
+                    }>;
+                    sessionId: z.ZodOptional<z.ZodString>;
+                    displayName: z.ZodString;
+                    actor: z.ZodNullable<z.ZodString>;
+                    reason: z.ZodNullable<z.ZodString>;
+                    changedAt: z.ZodNullable<z.ZodString>;
+                    revision: z.ZodNumber;
+                }, z.core.$strip>>;
+                impactCopy: z.ZodString;
+            }, z.core.$strip>>;
+            override: z.ZodNullable<z.ZodObject<{
+                rootSessionId: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+            settlement: z.ZodNullable<z.ZodObject<{
+                state: z.ZodLiteral<"stopping">;
+                attemptCount: z.ZodNumber;
+                interruptionPendingCount: z.ZodNumber;
+                quiescencePendingCount: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
         lastSequence: z.ZodNumber;
         codexPinnedCredentialId: z.ZodNullable<z.ZodString>;
         codexLastCredentialId: z.ZodNullable<z.ZodString>;
@@ -4680,6 +6825,7 @@ declare const SessionLineageResponse: z.ZodObject<{
             attentionDescendants: z.ZodNumber;
             pausedDescendants: z.ZodNumber;
             failedDescendants: z.ZodNumber;
+            truncated: z.ZodDefault<z.ZodBoolean>;
         }, z.core.$strip>>;
         createdAt: z.ZodString;
         updatedAt: z.ZodString;
@@ -4690,8 +6836,10 @@ declare const SessionLineageResponse: z.ZodObject<{
 type SessionLineageResponse = z.infer<typeof SessionLineageResponse>;
 declare const SessionEventType: z.ZodEnum<{
     "session.created": "session.created";
+    "session.event.envelope_omitted": "session.event.envelope_omitted";
     "session.status.changed": "session.status.changed";
     "session.requiresAction": "session.requiresAction";
+    "session.humanInput.requested": "session.humanInput.requested";
     "session.context.compaction.requested": "session.context.compaction.requested";
     "session.context.compacted": "session.context.compacted";
     "session.context.compaction.skipped": "session.context.compaction.skipped";
@@ -4699,6 +6847,7 @@ declare const SessionEventType: z.ZodEnum<{
     "user.message": "user.message";
     "user.pause": "user.pause";
     "user.approvalDecision": "user.approvalDecision";
+    "user.humanInputResponse": "user.humanInputResponse";
     "turn.queued": "turn.queued";
     "turn.started": "turn.started";
     "turn.completed": "turn.completed";
@@ -4714,6 +6863,7 @@ declare const SessionEventType: z.ZodEnum<{
     "agent.toolCall.output": "agent.toolCall.output";
     "agent.model.usage": "agent.model.usage";
     "tool.auth_needed": "tool.auth_needed";
+    "credential.auth_needed": "credential.auth_needed";
     "agent.updated": "agent.updated";
     "rig.setup.started": "rig.setup.started";
     "rig.setup.completed": "rig.setup.completed";
@@ -4738,6 +6888,7 @@ declare const SessionEventType: z.ZodEnum<{
     "session.control.steer_requested": "session.control.steer_requested";
     "workspace.inference.paused": "workspace.inference.paused";
     "workspace.inference.resumed": "workspace.inference.resumed";
+    "session.queue.changed": "session.queue.changed";
     "session.queue.prompt.cancelled": "session.queue.prompt.cancelled";
     "session.queue.history": "session.queue.history";
     "turn.event.rejected_late": "turn.event.rejected_late";
@@ -4776,23 +6927,99 @@ declare const SessionEventType: z.ZodEnum<{
     "machine.runner.restarted": "machine.runner.restarted";
 }>;
 type SessionEventType = z.infer<typeof SessionEventType>;
+/**
+ * Stable semantic groups for bounded session monitoring. These are a read
+ * projection only: an event keeps its canonical durable `type`, and callers
+ * can always combine a class with explicit type include/exclude filters.
+ */
+declare const SessionEventSemanticClass: z.ZodEnum<{
+    control: "control";
+    failure: "failure";
+    terminal: "terminal";
+    checkpoint: "checkpoint";
+    tool_receipt: "tool_receipt";
+    provider_account: "provider_account";
+}>;
+type SessionEventSemanticClass = z.infer<typeof SessionEventSemanticClass>;
+declare const SessionEventPayloadMode: z.ZodEnum<{
+    none: "none";
+    summary: "summary";
+    full: "full";
+}>;
+type SessionEventPayloadMode = z.infer<typeof SessionEventPayloadMode>;
+declare const SessionEventReadMode: z.ZodEnum<{
+    monitoring: "monitoring";
+    forensic: "forensic";
+}>;
+type SessionEventReadMode = z.infer<typeof SessionEventReadMode>;
+declare const SessionEventReadDirection: z.ZodEnum<{
+    after: "after";
+    before: "before";
+}>;
+type SessionEventReadDirection = z.infer<typeof SessionEventReadDirection>;
+declare const SESSION_EVENT_RAW_DELTA_TYPES: readonly ["agent.message.delta", "agent.reasoning.delta", "sandbox.command.output.delta", "terminal.pty.output.delta"];
+declare const SESSION_EVENT_SEMANTIC_CLASS_TYPES: {
+    readonly control: readonly ["session.status.changed", "session.requiresAction", "session.humanInput.requested", "user.pause", "user.approvalDecision", "user.humanInputResponse", "goal.set", "goal.updated", "goal.completed", "goal.paused", "goal.resumed", "goal.cleared", "goal.continuation", "system.update.pending", "system.update.delivered", "session.control.paused", "session.control.resumed", "session.control.steer_requested", "workspace.inference.paused", "workspace.inference.resumed", "session.queue.changed", "session.queue.prompt.cancelled"];
+    readonly terminal: readonly ["turn.completed", "turn.failed", "turn.cancelled", "turn.superseded", "goal.completed", "goal.paused", "rig.setup.completed", "rig.setup.skipped", "rig.setup.failed", "sandbox.operation.completed", "sandbox.operation.failed", "recording.available", "recording.failed", "terminal.pty.exited"];
+    readonly failure: readonly ["session.event.envelope_omitted", "turn.failed", "tool.auth_needed", "credential.auth_needed", "rig.setup.failed", "sandbox.operation.failed", "recording.failed", "sandbox.box.lost", "workspace.revision.degraded", "machine.op.failed", "machine.link.lost"];
+    readonly checkpoint: readonly ["session.context.compaction.requested", "session.context.compacted", "session.context.compaction.skipped", "session.context.cleared", "turn.recovery.requested", "session.queue.history", "sandbox.box.snapshot", "workspace.revision.captured"];
+    readonly tool_receipt: readonly ["agent.toolCall.created", "agent.toolCall.output", "tool.auth_needed", "artifact.created"];
+    readonly provider_account: readonly ["agent.model.usage", "codex.account.switched", "codex.credential.selected", "codex.capacity.waiting", "codex.capacity.resumed", "codex.capacity.superseded", "sandbox.box.created", "sandbox.box.lost", "sandbox.box.terminated", "sandbox.box.snapshot", "sandbox.env.drift", "session.route.reconciled", "machine.op.failed", "machine.op.recovered", "machine.link.lost", "machine.link.restored", "machine.runner.restarted"];
+};
+type ResolveSessionEventTypeFiltersInput = {
+    includeTypes?: readonly SessionEventType[] | undefined;
+    excludeTypes?: readonly SessionEventType[] | undefined;
+    includeClasses?: readonly SessionEventSemanticClass[] | undefined;
+    excludeClasses?: readonly SessionEventSemanticClass[] | undefined;
+    /** Applied unless the same type was explicitly included by type or class. */
+    defaultExcludeTypes?: readonly SessionEventType[] | undefined;
+};
+/** Resolve class/type filter algebra once so every read surface behaves alike. */
+declare function resolveSessionEventTypeFilters(input: ResolveSessionEventTypeFiltersInput): {
+    includeTypes: SessionEventType[];
+    excludeTypes: SessionEventType[];
+};
 declare const ToolAuthNeededPayload: z.ZodObject<{
     serverId: z.ZodString;
     toolName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     providerDomain: z.ZodString;
+    provider: z.ZodOptional<z.ZodString>;
     connectionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     reason: z.ZodEnum<{
-        expired: "expired";
         missing_connection: "missing_connection";
+        expired: "expired";
         insufficient_scope: "insufficient_scope";
         refresh_failed: "refresh_failed";
+        unsupported_auth: "unsupported_auth";
+        resource_scope_unavailable: "resource_scope_unavailable";
     }>;
     scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
     resource: z.ZodOptional<z.ZodString>;
+    selectedResources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodLiteral<"repository">;
+    }, z.core.$strict>>>;
     authorizationUrl: z.ZodOptional<z.ZodString>;
     subjectId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strip>;
 type ToolAuthNeededPayload = z.infer<typeof ToolAuthNeededPayload>;
+/** A host-owned non-tool credential needed by the active run. */
+declare const CredentialAuthNeededPayload: z.ZodObject<{
+    credentialClass: z.ZodLiteral<"run">;
+    providerDomain: z.ZodOptional<z.ZodString>;
+    connectionId: z.ZodOptional<z.ZodString>;
+    reason: z.ZodEnum<{
+        missing_connection: "missing_connection";
+        expired: "expired";
+        insufficient_scope: "insufficient_scope";
+        refresh_failed: "refresh_failed";
+    }>;
+    scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    resource: z.ZodOptional<z.ZodString>;
+    authorizationUrl: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type CredentialAuthNeededPayload = z.infer<typeof CredentialAuthNeededPayload>;
 declare const StreamUrlRotatedPayload: z.ZodObject<{
     url: z.ZodString;
     token: z.ZodNullable<z.ZodString>;
@@ -4933,8 +7160,8 @@ declare const FsChangedPayload: z.ZodObject<{
         oldPath: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     source: z.ZodDefault<z.ZodEnum<{
-        agent: "agent";
         write: "write";
+        agent: "agent";
         watch: "watch";
     }>>;
     revision: z.ZodNumber;
@@ -4981,10 +7208,10 @@ declare const TerminalPtyExitedPayload: z.ZodObject<{
     ptyId: z.ZodString;
     exitCode: z.ZodNullable<z.ZodNumber>;
     reason: z.ZodEnum<{
+        timeout: "timeout";
         exit: "exit";
         killed: "killed";
         owner_gone: "owner_gone";
-        timeout: "timeout";
     }>;
 }, z.core.$strip>;
 type TerminalPtyExitedPayload = z.infer<typeof TerminalPtyExitedPayload>;
@@ -5256,6 +7483,7 @@ type GitFileDiff = z.infer<typeof GitFileDiff>;
 declare const GitDiffRequest: z.ZodObject<{
     path: z.ZodDefault<z.ZodString>;
     staged: z.ZodDefault<z.ZodBoolean>;
+    includeUntracked: z.ZodDefault<z.ZodBoolean>;
     fromRef: z.ZodOptional<z.ZodString>;
     toRef: z.ZodOptional<z.ZodString>;
     pathspec: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -5956,8 +8184,10 @@ declare const SessionEvent: z.ZodObject<{
     sequence: z.ZodNumber;
     type: z.ZodEnum<{
         "session.created": "session.created";
+        "session.event.envelope_omitted": "session.event.envelope_omitted";
         "session.status.changed": "session.status.changed";
         "session.requiresAction": "session.requiresAction";
+        "session.humanInput.requested": "session.humanInput.requested";
         "session.context.compaction.requested": "session.context.compaction.requested";
         "session.context.compacted": "session.context.compacted";
         "session.context.compaction.skipped": "session.context.compaction.skipped";
@@ -5965,6 +8195,7 @@ declare const SessionEvent: z.ZodObject<{
         "user.message": "user.message";
         "user.pause": "user.pause";
         "user.approvalDecision": "user.approvalDecision";
+        "user.humanInputResponse": "user.humanInputResponse";
         "turn.queued": "turn.queued";
         "turn.started": "turn.started";
         "turn.completed": "turn.completed";
@@ -5980,6 +8211,7 @@ declare const SessionEvent: z.ZodObject<{
         "agent.toolCall.output": "agent.toolCall.output";
         "agent.model.usage": "agent.model.usage";
         "tool.auth_needed": "tool.auth_needed";
+        "credential.auth_needed": "credential.auth_needed";
         "agent.updated": "agent.updated";
         "rig.setup.started": "rig.setup.started";
         "rig.setup.completed": "rig.setup.completed";
@@ -6004,6 +8236,7 @@ declare const SessionEvent: z.ZodObject<{
         "session.control.steer_requested": "session.control.steer_requested";
         "workspace.inference.paused": "workspace.inference.paused";
         "workspace.inference.resumed": "workspace.inference.resumed";
+        "session.queue.changed": "session.queue.changed";
         "session.queue.prompt.cancelled": "session.queue.prompt.cancelled";
         "session.queue.history": "session.queue.history";
         "turn.event.rejected_late": "turn.event.rejected_late";
@@ -6056,20 +8289,378 @@ declare const SessionEvent: z.ZodObject<{
     duplicateReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strip>;
 type SessionEvent = z.infer<typeof SessionEvent>;
+/** Wire revision for the durable host event/usage export stream. */
+declare const OPENGENI_HOST_EXPORT_SCHEMA_REVISION: "2026-07-host-export-v1";
+/**
+ * Decimal string rather than a JavaScript number: export cursors are PostgreSQL
+ * bigint values and must remain exact beyond Number.MAX_SAFE_INTEGER.
+ */
+declare const HostExportCursor: z.ZodString;
+type HostExportCursor = z.infer<typeof HostExportCursor>;
+declare const HostExportConsumerId: z.ZodString;
+type HostExportConsumerId = z.infer<typeof HostExportConsumerId>;
+declare const HostExportInitiator: z.ZodObject<{
+    kind: z.ZodEnum<{
+        service: "service";
+        subject: "subject";
+    }>;
+    subjectId: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type HostExportInitiator = z.infer<typeof HostExportInitiator>;
+declare const HostExportInitiatorContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+type HostExportInitiatorContext = z.infer<typeof HostExportInitiatorContext>;
+/**
+ * Host streams are deliberately forward-tolerant across rolling upgrades.
+ * OpenGeni's application contract enumerates the event types known to this
+ * build, while the durable export may be read by an older host consumer after
+ * a newer writer has committed a bounded type. The database remains the
+ * authority for the byte bounds on these persisted strings.
+ */
+declare const HostSessionEvent: z.ZodObject<{
+    id: z.ZodString;
+    workspaceId: z.ZodString;
+    sessionId: z.ZodString;
+    sequence: z.ZodNumber;
+    payload: z.ZodDefault<z.ZodUnknown>;
+    occurredAt: z.ZodString;
+    turnId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    turnGeneration: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    turnAttemptId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    duplicateOfEventId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    type: z.ZodString;
+    clientEventId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    turnAssociation: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    duplicateReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+type HostSessionEvent = z.infer<typeof HostSessionEvent>;
+/** Export-bounded usage fact; custom bounded metric names remain supported. */
+declare const HostUsageEvent: z.ZodObject<{
+    id: z.ZodString;
+    workspaceId: z.ZodString;
+    accountId: z.ZodString;
+    quantity: z.ZodNumber;
+    occurredAt: z.ZodString;
+    recordedAt: z.ZodString;
+    exportedToBillingAt: z.ZodNullable<z.ZodString>;
+    subjectId: z.ZodNullable<z.ZodString>;
+    eventType: z.ZodString;
+    unit: z.ZodString;
+    sourceResourceType: z.ZodNullable<z.ZodString>;
+    sourceResourceId: z.ZodNullable<z.ZodString>;
+    idempotencyKey: z.ZodString;
+    billingProviderEventId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type HostUsageEvent = z.infer<typeof HostUsageEvent>;
+/**
+ * One immutable, bounded session-event snapshot from the transactional host
+ * outbox. Cross-session cursor order is stable but deliberately non-causal;
+ * within a session, `event.sequence` remains authoritative and monotonic.
+ */
+declare const HostEventExport: z.ZodObject<{
+    event: z.ZodObject<{
+        id: z.ZodString;
+        workspaceId: z.ZodString;
+        sessionId: z.ZodString;
+        sequence: z.ZodNumber;
+        payload: z.ZodDefault<z.ZodUnknown>;
+        occurredAt: z.ZodString;
+        turnId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        turnGeneration: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        turnAttemptId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        duplicateOfEventId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        type: z.ZodString;
+        clientEventId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        turnAssociation: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        duplicateReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    initiator: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            service: "service";
+            subject: "subject";
+        }>;
+        subjectId: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    initiatorContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    origin: z.ZodNullable<z.ZodEnum<{
+        user: "user";
+        scheduled_task: "scheduled_task";
+        api: "api";
+        goal: "goal";
+        system: "system";
+        compaction: "compaction";
+    }>>;
+    schemaRevision: z.ZodLiteral<"2026-07-host-export-v1">;
+    cursor: z.ZodString;
+    idempotencyKey: z.ZodString;
+    accountId: z.ZodString;
+    workspaceId: z.ZodString;
+    rootSessionId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type HostEventExport = z.infer<typeof HostEventExport>;
+/** One exact, idempotency-keyed usage fact from the same ordered outbox. */
+declare const HostUsageExport: z.ZodObject<{
+    usage: z.ZodObject<{
+        id: z.ZodString;
+        workspaceId: z.ZodString;
+        accountId: z.ZodString;
+        quantity: z.ZodNumber;
+        occurredAt: z.ZodString;
+        recordedAt: z.ZodString;
+        exportedToBillingAt: z.ZodNullable<z.ZodString>;
+        subjectId: z.ZodNullable<z.ZodString>;
+        eventType: z.ZodString;
+        unit: z.ZodString;
+        sourceResourceType: z.ZodNullable<z.ZodString>;
+        sourceResourceId: z.ZodNullable<z.ZodString>;
+        idempotencyKey: z.ZodString;
+        billingProviderEventId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    initiator: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            service: "service";
+            subject: "subject";
+        }>;
+        subjectId: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    initiatorContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    origin: z.ZodNullable<z.ZodEnum<{
+        user: "user";
+        scheduled_task: "scheduled_task";
+        api: "api";
+        goal: "goal";
+        system: "system";
+        compaction: "compaction";
+    }>>;
+    schemaRevision: z.ZodLiteral<"2026-07-host-export-v1">;
+    cursor: z.ZodString;
+    accountId: z.ZodString;
+    workspaceId: z.ZodString;
+    sessionId: z.ZodNullable<z.ZodString>;
+    rootSessionId: z.ZodNullable<z.ZodString>;
+    turnId: z.ZodNullable<z.ZodString>;
+    turnAttemptId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type HostUsageExport = z.infer<typeof HostUsageExport>;
+declare const HostEventExportBatch: z.ZodObject<{
+    schemaRevision: z.ZodLiteral<"2026-07-host-export-v1">;
+    consumerId: z.ZodString;
+    leaseToken: z.ZodString;
+    checkpoint: z.ZodString;
+    throughCursor: z.ZodString;
+    events: z.ZodArray<z.ZodObject<{
+        event: z.ZodObject<{
+            id: z.ZodString;
+            workspaceId: z.ZodString;
+            sessionId: z.ZodString;
+            sequence: z.ZodNumber;
+            payload: z.ZodDefault<z.ZodUnknown>;
+            occurredAt: z.ZodString;
+            turnId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            turnGeneration: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            turnAttemptId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            duplicateOfEventId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            type: z.ZodString;
+            clientEventId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            turnAssociation: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            duplicateReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>;
+        initiator: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                service: "service";
+                subject: "subject";
+            }>;
+            subjectId: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        initiatorContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        origin: z.ZodNullable<z.ZodEnum<{
+            user: "user";
+            scheduled_task: "scheduled_task";
+            api: "api";
+            goal: "goal";
+            system: "system";
+            compaction: "compaction";
+        }>>;
+        schemaRevision: z.ZodLiteral<"2026-07-host-export-v1">;
+        cursor: z.ZodString;
+        idempotencyKey: z.ZodString;
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        rootSessionId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type HostEventExportBatch = z.infer<typeof HostEventExportBatch>;
+declare const HostUsageExportBatch: z.ZodObject<{
+    schemaRevision: z.ZodLiteral<"2026-07-host-export-v1">;
+    consumerId: z.ZodString;
+    leaseToken: z.ZodString;
+    checkpoint: z.ZodString;
+    throughCursor: z.ZodString;
+    events: z.ZodArray<z.ZodObject<{
+        usage: z.ZodObject<{
+            id: z.ZodString;
+            workspaceId: z.ZodString;
+            accountId: z.ZodString;
+            quantity: z.ZodNumber;
+            occurredAt: z.ZodString;
+            recordedAt: z.ZodString;
+            exportedToBillingAt: z.ZodNullable<z.ZodString>;
+            subjectId: z.ZodNullable<z.ZodString>;
+            eventType: z.ZodString;
+            unit: z.ZodString;
+            sourceResourceType: z.ZodNullable<z.ZodString>;
+            sourceResourceId: z.ZodNullable<z.ZodString>;
+            idempotencyKey: z.ZodString;
+            billingProviderEventId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        initiator: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                service: "service";
+                subject: "subject";
+            }>;
+            subjectId: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        initiatorContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        origin: z.ZodNullable<z.ZodEnum<{
+            user: "user";
+            scheduled_task: "scheduled_task";
+            api: "api";
+            goal: "goal";
+            system: "system";
+            compaction: "compaction";
+        }>>;
+        schemaRevision: z.ZodLiteral<"2026-07-host-export-v1">;
+        cursor: z.ZodString;
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        sessionId: z.ZodNullable<z.ZodString>;
+        rootSessionId: z.ZodNullable<z.ZodString>;
+        turnId: z.ZodNullable<z.ZodString>;
+        turnAttemptId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type HostUsageExportBatch = z.infer<typeof HostUsageExportBatch>;
+/**
+ * Optional embedded-host sinks. Delivery is at least once: the same batch may
+ * be repeated after a process dies between sink success and checkpoint commit,
+ * so sinks must deduplicate by event/usage idempotency key.
+ */
+type HostEventSink = {
+    consumerId: HostExportConsumerId;
+    deliverEvents: (batch: HostEventExportBatch) => Promise<void>;
+};
+type HostUsageSink = {
+    consumerId: HostExportConsumerId;
+    deliverUsage: (batch: HostUsageExportBatch) => Promise<void>;
+};
+declare const SESSION_EVENT_TYPE_MAX_BYTES = 256;
+declare const SESSION_EVENT_CLIENT_EVENT_ID_MAX_BYTES: number;
+declare const SESSION_EVENT_TURN_ASSOCIATION_MAX_BYTES = 64;
+declare const SESSION_EVENT_DUPLICATE_REASON_MAX_BYTES: number;
+declare const SESSION_EVENT_ENVELOPE_MAX_BYTES: number;
+type BoundSessionEventOptions = {
+    surface?: SessionEventBoundarySurface;
+    maxBytes?: number;
+};
+/**
+ * Canonical lossy projection for a complete session event. Payload bounds alone
+ * are insufficient: a malformed retained row can also carry an oversized type,
+ * client id, or duplicate diagnostic. Keep cursor/UUID identity intact, bound
+ * every free-form envelope string, and assert the exact final JSON envelope.
+ */
+declare function boundSessionEvent(event: SessionEvent, options?: BoundSessionEventOptions): SessionEvent;
 declare const SessionQueueMutationResponse: z.ZodObject<{
+    receipt: z.ZodObject<{
+        id: z.ZodString;
+        action: z.ZodString;
+        operationKey: z.ZodString;
+        targetSessionId: z.ZodNullable<z.ZodString>;
+        targetTurnId: z.ZodNullable<z.ZodString>;
+        appliedControlRevision: z.ZodNullable<z.ZodNumber>;
+        appliedQueueVersion: z.ZodNullable<z.ZodNumber>;
+        appliedTurnVersion: z.ZodNullable<z.ZodNumber>;
+        appliedDraftRevision: z.ZodNullable<z.ZodNumber>;
+        createdAt: z.ZodString;
+    }, z.core.$strip>;
     snapshot: z.ZodObject<{
         version: z.ZodNumber;
-        controlState: z.ZodEnum<{
-            paused: "paused";
-            active: "active";
-        }>;
-        controlGeneration: z.ZodNumber;
-        workspaceInferenceState: z.ZodEnum<{
-            paused: "paused";
-            active: "active";
-        }>;
-        workspaceInferenceGeneration: z.ZodNumber;
-        workspaceRunExceptionGeneration: z.ZodNullable<z.ZodNumber>;
+        effectiveControl: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                paused: "paused";
+            }>;
+            controlVersion: z.ZodNumber;
+            controlEtag: z.ZodString;
+            directState: z.ZodEnum<{
+                active: "active";
+                paused: "paused";
+            }>;
+            primaryBlocker: z.ZodNullable<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    workspace: "workspace";
+                    session: "session";
+                }>;
+                sessionId: z.ZodOptional<z.ZodString>;
+                displayName: z.ZodString;
+                actor: z.ZodNullable<z.ZodString>;
+                reason: z.ZodNullable<z.ZodString>;
+                changedAt: z.ZodNullable<z.ZodString>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+            additionalBlockerCount: z.ZodNumber;
+            blockers: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    workspace: "workspace";
+                    session: "session";
+                }>;
+                sessionId: z.ZodOptional<z.ZodString>;
+                displayName: z.ZodString;
+                actor: z.ZodNullable<z.ZodString>;
+                reason: z.ZodNullable<z.ZodString>;
+                changedAt: z.ZodNullable<z.ZodString>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+            resumeOptions: z.ZodArray<z.ZodObject<{
+                scope: z.ZodEnum<{
+                    workspace: "workspace";
+                    session: "session";
+                    selected: "selected";
+                }>;
+                targetId: z.ZodOptional<z.ZodString>;
+                selectedStateAfter: z.ZodEnum<{
+                    active: "active";
+                    paused: "paused";
+                }>;
+                remainingPrimaryBlocker: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        workspace: "workspace";
+                        session: "session";
+                    }>;
+                    sessionId: z.ZodOptional<z.ZodString>;
+                    displayName: z.ZodString;
+                    actor: z.ZodNullable<z.ZodString>;
+                    reason: z.ZodNullable<z.ZodString>;
+                    changedAt: z.ZodNullable<z.ZodString>;
+                    revision: z.ZodNumber;
+                }, z.core.$strip>>;
+                impactCopy: z.ZodString;
+            }, z.core.$strip>>;
+            override: z.ZodNullable<z.ZodObject<{
+                rootSessionId: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+            settlement: z.ZodNullable<z.ZodObject<{
+                state: z.ZodLiteral<"stopping">;
+                attemptCount: z.ZodNumber;
+                interruptionPendingCount: z.ZodNumber;
+                quiescencePendingCount: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        stoppingPreviousAttempt: z.ZodBoolean;
         items: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             workspaceId: z.ZodString;
@@ -6086,6 +8677,7 @@ declare const SessionQueueMutationResponse: z.ZodObject<{
                 cancelled: "cancelled";
                 completed: "completed";
                 superseded: "superseded";
+                withdrawn_for_edit: "withdrawn_for_edit";
             }>;
             source: z.ZodEnum<{
                 user: "user";
@@ -6108,6 +8700,11 @@ declare const SessionQueueMutationResponse: z.ZodObject<{
                     gitlab: "gitlab";
                     azure_devops: "azure_devops";
                 }>>;
+                credentialBindingId: z.ZodOptional<z.ZodString>;
+                access: z.ZodOptional<z.ZodEnum<{
+                    read: "read";
+                    write: "write";
+                }>>;
                 repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
                 installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
                 projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
@@ -6156,6 +8753,15 @@ declare const SessionQueueMutationResponse: z.ZodObject<{
             executionGeneration: z.ZodNumber;
             activeAttemptId: z.ZodNullable<z.ZodString>;
             lineage: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            initiator: z.ZodObject<{
+                subjectId: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+                kind: z.ZodEnum<{
+                    service: "service";
+                    subject: "subject";
+                }>;
+            }, z.core.$strip>;
+            initiatorContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
             cancelledBy: z.ZodNullable<z.ZodString>;
             cancelReason: z.ZodNullable<z.ZodString>;
             startedAt: z.ZodNullable<z.ZodString>;
@@ -6164,238 +8770,149 @@ declare const SessionQueueMutationResponse: z.ZodObject<{
             updatedAt: z.ZodString;
         }, z.core.$strip>>;
     }, z.core.$strip>;
-    events: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        workspaceId: z.ZodString;
-        sessionId: z.ZodString;
-        sequence: z.ZodNumber;
-        type: z.ZodEnum<{
-            "session.created": "session.created";
-            "session.status.changed": "session.status.changed";
-            "session.requiresAction": "session.requiresAction";
-            "session.context.compaction.requested": "session.context.compaction.requested";
-            "session.context.compacted": "session.context.compacted";
-            "session.context.compaction.skipped": "session.context.compaction.skipped";
-            "session.context.cleared": "session.context.cleared";
-            "user.message": "user.message";
-            "user.pause": "user.pause";
-            "user.approvalDecision": "user.approvalDecision";
-            "turn.queued": "turn.queued";
-            "turn.started": "turn.started";
-            "turn.completed": "turn.completed";
-            "turn.failed": "turn.failed";
-            "turn.cancelled": "turn.cancelled";
-            "turn.superseded": "turn.superseded";
-            "turn.recovery.requested": "turn.recovery.requested";
-            "turn.capacity_waiting": "turn.capacity_waiting";
-            "agent.message.delta": "agent.message.delta";
-            "agent.message.completed": "agent.message.completed";
-            "agent.reasoning.delta": "agent.reasoning.delta";
-            "agent.toolCall.created": "agent.toolCall.created";
-            "agent.toolCall.output": "agent.toolCall.output";
-            "agent.model.usage": "agent.model.usage";
-            "tool.auth_needed": "tool.auth_needed";
-            "agent.updated": "agent.updated";
-            "rig.setup.started": "rig.setup.started";
-            "rig.setup.completed": "rig.setup.completed";
-            "rig.setup.skipped": "rig.setup.skipped";
-            "rig.setup.failed": "rig.setup.failed";
-            "sandbox.operation.started": "sandbox.operation.started";
-            "sandbox.operation.completed": "sandbox.operation.completed";
-            "sandbox.operation.failed": "sandbox.operation.failed";
-            "sandbox.command.output.delta": "sandbox.command.output.delta";
-            "artifact.created": "artifact.created";
-            "goal.set": "goal.set";
-            "goal.updated": "goal.updated";
-            "goal.completed": "goal.completed";
-            "goal.paused": "goal.paused";
-            "goal.resumed": "goal.resumed";
-            "goal.cleared": "goal.cleared";
-            "goal.continuation": "goal.continuation";
-            "system.update.pending": "system.update.pending";
-            "system.update.delivered": "system.update.delivered";
-            "session.control.paused": "session.control.paused";
-            "session.control.resumed": "session.control.resumed";
-            "session.control.steer_requested": "session.control.steer_requested";
-            "workspace.inference.paused": "workspace.inference.paused";
-            "workspace.inference.resumed": "workspace.inference.resumed";
-            "session.queue.prompt.cancelled": "session.queue.prompt.cancelled";
-            "session.queue.history": "session.queue.history";
-            "turn.event.rejected_late": "turn.event.rejected_late";
-            "memory.saved": "memory.saved";
-            "memory.corrected": "memory.corrected";
-            "stream.url.rotated": "stream.url.rotated";
-            "stream.opened": "stream.opened";
-            "stream.closed": "stream.closed";
-            "stream.revoked": "stream.revoked";
-            "recording.started": "recording.started";
-            "recording.available": "recording.available";
-            "recording.failed": "recording.failed";
-            "fs.changed": "fs.changed";
-            "git.changed": "git.changed";
-            "terminal.pty.started": "terminal.pty.started";
-            "terminal.pty.output.delta": "terminal.pty.output.delta";
-            "terminal.pty.exited": "terminal.pty.exited";
-            "session.title_set": "session.title_set";
-            "codex.account.switched": "codex.account.switched";
-            "codex.credential.selected": "codex.credential.selected";
-            "codex.capacity.waiting": "codex.capacity.waiting";
-            "codex.capacity.resumed": "codex.capacity.resumed";
-            "codex.capacity.superseded": "codex.capacity.superseded";
-            "sandbox.box.created": "sandbox.box.created";
-            "sandbox.box.lost": "sandbox.box.lost";
-            "sandbox.box.terminated": "sandbox.box.terminated";
-            "sandbox.box.snapshot": "sandbox.box.snapshot";
-            "sandbox.env.drift": "sandbox.env.drift";
-            "session.route.reconciled": "session.route.reconciled";
-            "workspace.revision.captured": "workspace.revision.captured";
-            "workspace.revision.degraded": "workspace.revision.degraded";
-            "machine.op.failed": "machine.op.failed";
-            "machine.op.recovered": "machine.op.recovered";
-            "machine.link.lost": "machine.link.lost";
-            "machine.link.restored": "machine.link.restored";
-            "machine.runner.restarted": "machine.runner.restarted";
+    draft: z.ZodOptional<z.ZodObject<{
+        revision: z.ZodNumber;
+        text: z.ZodString;
+        resources: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"repository">;
+            uri: z.ZodString;
+            ref: z.ZodString;
+            mountPath: z.ZodOptional<z.ZodString>;
+            subpath: z.ZodOptional<z.ZodString>;
+            provider: z.ZodOptional<z.ZodEnum<{
+                github: "github";
+                gitlab: "gitlab";
+                azure_devops: "azure_devops";
+            }>>;
+            credentialBindingId: z.ZodOptional<z.ZodString>;
+            access: z.ZodOptional<z.ZodEnum<{
+                read: "read";
+                write: "write";
+            }>>;
+            repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            connectionId: z.ZodOptional<z.ZodString>;
+            githubInstallationId: z.ZodOptional<z.ZodNumber>;
+            githubRepositoryId: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"file">;
+            fileId: z.ZodString;
+            mountPath: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "kind">>;
+        tools: z.ZodArray<z.ZodObject<{
+            kind: z.ZodLiteral<"mcp">;
+            id: z.ZodString;
+            optional: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        model: z.ZodString;
+        reasoningEffort: z.ZodEnum<{
+            none: "none";
+            minimal: "minimal";
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
         }>;
-        payload: z.ZodDefault<z.ZodUnknown>;
-        occurredAt: z.ZodString;
-        clientEventId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turnId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turnGeneration: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        turnAttemptId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turnAssociation: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-            current: "current";
-            late_rejected: "late_rejected";
-            duplicate: "duplicate";
-        }>>>;
-        duplicateOfEventId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        duplicateReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        sourceTurnId: z.ZodNullable<z.ZodString>;
+        sourceTurnVersion: z.ZodNullable<z.ZodNumber>;
+        updatedAt: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>>;
-    shouldWake: z.ZodBoolean;
 }, z.core.$strip>;
 type SessionQueueMutationResponse = z.infer<typeof SessionQueueMutationResponse>;
 declare const SessionControlResponse: z.ZodObject<{
-    operationId: z.ZodString;
-    event: z.ZodObject<{
+    receipt: z.ZodObject<{
         id: z.ZodString;
-        workspaceId: z.ZodString;
-        sessionId: z.ZodString;
-        sequence: z.ZodNumber;
-        type: z.ZodEnum<{
-            "session.created": "session.created";
-            "session.status.changed": "session.status.changed";
-            "session.requiresAction": "session.requiresAction";
-            "session.context.compaction.requested": "session.context.compaction.requested";
-            "session.context.compacted": "session.context.compacted";
-            "session.context.compaction.skipped": "session.context.compaction.skipped";
-            "session.context.cleared": "session.context.cleared";
-            "user.message": "user.message";
-            "user.pause": "user.pause";
-            "user.approvalDecision": "user.approvalDecision";
-            "turn.queued": "turn.queued";
-            "turn.started": "turn.started";
-            "turn.completed": "turn.completed";
-            "turn.failed": "turn.failed";
-            "turn.cancelled": "turn.cancelled";
-            "turn.superseded": "turn.superseded";
-            "turn.recovery.requested": "turn.recovery.requested";
-            "turn.capacity_waiting": "turn.capacity_waiting";
-            "agent.message.delta": "agent.message.delta";
-            "agent.message.completed": "agent.message.completed";
-            "agent.reasoning.delta": "agent.reasoning.delta";
-            "agent.toolCall.created": "agent.toolCall.created";
-            "agent.toolCall.output": "agent.toolCall.output";
-            "agent.model.usage": "agent.model.usage";
-            "tool.auth_needed": "tool.auth_needed";
-            "agent.updated": "agent.updated";
-            "rig.setup.started": "rig.setup.started";
-            "rig.setup.completed": "rig.setup.completed";
-            "rig.setup.skipped": "rig.setup.skipped";
-            "rig.setup.failed": "rig.setup.failed";
-            "sandbox.operation.started": "sandbox.operation.started";
-            "sandbox.operation.completed": "sandbox.operation.completed";
-            "sandbox.operation.failed": "sandbox.operation.failed";
-            "sandbox.command.output.delta": "sandbox.command.output.delta";
-            "artifact.created": "artifact.created";
-            "goal.set": "goal.set";
-            "goal.updated": "goal.updated";
-            "goal.completed": "goal.completed";
-            "goal.paused": "goal.paused";
-            "goal.resumed": "goal.resumed";
-            "goal.cleared": "goal.cleared";
-            "goal.continuation": "goal.continuation";
-            "system.update.pending": "system.update.pending";
-            "system.update.delivered": "system.update.delivered";
-            "session.control.paused": "session.control.paused";
-            "session.control.resumed": "session.control.resumed";
-            "session.control.steer_requested": "session.control.steer_requested";
-            "workspace.inference.paused": "workspace.inference.paused";
-            "workspace.inference.resumed": "workspace.inference.resumed";
-            "session.queue.prompt.cancelled": "session.queue.prompt.cancelled";
-            "session.queue.history": "session.queue.history";
-            "turn.event.rejected_late": "turn.event.rejected_late";
-            "memory.saved": "memory.saved";
-            "memory.corrected": "memory.corrected";
-            "stream.url.rotated": "stream.url.rotated";
-            "stream.opened": "stream.opened";
-            "stream.closed": "stream.closed";
-            "stream.revoked": "stream.revoked";
-            "recording.started": "recording.started";
-            "recording.available": "recording.available";
-            "recording.failed": "recording.failed";
-            "fs.changed": "fs.changed";
-            "git.changed": "git.changed";
-            "terminal.pty.started": "terminal.pty.started";
-            "terminal.pty.output.delta": "terminal.pty.output.delta";
-            "terminal.pty.exited": "terminal.pty.exited";
-            "session.title_set": "session.title_set";
-            "codex.account.switched": "codex.account.switched";
-            "codex.credential.selected": "codex.credential.selected";
-            "codex.capacity.waiting": "codex.capacity.waiting";
-            "codex.capacity.resumed": "codex.capacity.resumed";
-            "codex.capacity.superseded": "codex.capacity.superseded";
-            "sandbox.box.created": "sandbox.box.created";
-            "sandbox.box.lost": "sandbox.box.lost";
-            "sandbox.box.terminated": "sandbox.box.terminated";
-            "sandbox.box.snapshot": "sandbox.box.snapshot";
-            "sandbox.env.drift": "sandbox.env.drift";
-            "session.route.reconciled": "session.route.reconciled";
-            "workspace.revision.captured": "workspace.revision.captured";
-            "workspace.revision.degraded": "workspace.revision.degraded";
-            "machine.op.failed": "machine.op.failed";
-            "machine.op.recovered": "machine.op.recovered";
-            "machine.link.lost": "machine.link.lost";
-            "machine.link.restored": "machine.link.restored";
-            "machine.runner.restarted": "machine.runner.restarted";
+        action: z.ZodString;
+        operationKey: z.ZodString;
+        targetSessionId: z.ZodNullable<z.ZodString>;
+        targetTurnId: z.ZodNullable<z.ZodString>;
+        appliedControlRevision: z.ZodNullable<z.ZodNumber>;
+        appliedQueueVersion: z.ZodNullable<z.ZodNumber>;
+        appliedTurnVersion: z.ZodNullable<z.ZodNumber>;
+        appliedDraftRevision: z.ZodNullable<z.ZodNumber>;
+        createdAt: z.ZodString;
+    }, z.core.$strip>;
+    effectiveControl: z.ZodObject<{
+        state: z.ZodEnum<{
+            active: "active";
+            paused: "paused";
         }>;
-        payload: z.ZodDefault<z.ZodUnknown>;
-        occurredAt: z.ZodString;
-        clientEventId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turnId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turnGeneration: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        turnAttemptId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        turnAssociation: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-            current: "current";
-            late_rejected: "late_rejected";
-            duplicate: "duplicate";
-        }>>>;
-        duplicateOfEventId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        duplicateReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        controlVersion: z.ZodNumber;
+        controlEtag: z.ZodString;
+        directState: z.ZodEnum<{
+            active: "active";
+            paused: "paused";
+        }>;
+        primaryBlocker: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                workspace: "workspace";
+                session: "session";
+            }>;
+            sessionId: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodString;
+            actor: z.ZodNullable<z.ZodString>;
+            reason: z.ZodNullable<z.ZodString>;
+            changedAt: z.ZodNullable<z.ZodString>;
+            revision: z.ZodNumber;
+        }, z.core.$strip>>;
+        additionalBlockerCount: z.ZodNumber;
+        blockers: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                workspace: "workspace";
+                session: "session";
+            }>;
+            sessionId: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodString;
+            actor: z.ZodNullable<z.ZodString>;
+            reason: z.ZodNullable<z.ZodString>;
+            changedAt: z.ZodNullable<z.ZodString>;
+            revision: z.ZodNumber;
+        }, z.core.$strip>>;
+        resumeOptions: z.ZodArray<z.ZodObject<{
+            scope: z.ZodEnum<{
+                workspace: "workspace";
+                session: "session";
+                selected: "selected";
+            }>;
+            targetId: z.ZodOptional<z.ZodString>;
+            selectedStateAfter: z.ZodEnum<{
+                active: "active";
+                paused: "paused";
+            }>;
+            remainingPrimaryBlocker: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    workspace: "workspace";
+                    session: "session";
+                }>;
+                sessionId: z.ZodOptional<z.ZodString>;
+                displayName: z.ZodString;
+                actor: z.ZodNullable<z.ZodString>;
+                reason: z.ZodNullable<z.ZodString>;
+                changedAt: z.ZodNullable<z.ZodString>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+            impactCopy: z.ZodString;
+        }, z.core.$strip>>;
+        override: z.ZodNullable<z.ZodObject<{
+            rootSessionId: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strip>>;
+        settlement: z.ZodNullable<z.ZodObject<{
+            state: z.ZodLiteral<"stopping">;
+            attemptCount: z.ZodNumber;
+            interruptionPendingCount: z.ZodNumber;
+            quiescencePendingCount: z.ZodNumber;
+        }, z.core.$strip>>;
     }, z.core.$strip>;
-    controlState: z.ZodEnum<{
-        paused: "paused";
-        active: "active";
-    }>;
-    controlGeneration: z.ZodNumber;
-    expectedActiveTurnId: z.ZodNullable<z.ZodString>;
-    expectedExecutionGeneration: z.ZodNullable<z.ZodNumber>;
-    expectedAttemptId: z.ZodNullable<z.ZodString>;
-    deliveryEventId: z.ZodNullable<z.ZodString>;
-    shouldSignalControl: z.ZodBoolean;
-    shouldWake: z.ZodBoolean;
+    interruptionCount: z.ZodNumber;
+    wakeCount: z.ZodNumber;
 }, z.core.$strip>;
 type SessionControlResponse = z.infer<typeof SessionControlResponse>;
 declare const CreateSessionRequest: z.ZodPreprocess<z.ZodObject<{
+    requestedSessionId: z.ZodOptional<z.ZodString>;
     initialMessage: z.ZodString;
+    turnInstructions: z.ZodOptional<z.ZodString>;
     instructions: z.ZodOptional<z.ZodString>;
     resources: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"repository">;
@@ -6408,6 +8925,11 @@ declare const CreateSessionRequest: z.ZodPreprocess<z.ZodObject<{
             gitlab: "gitlab";
             azure_devops: "azure_devops";
         }>>;
+        credentialBindingId: z.ZodOptional<z.ZodString>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            write: "write";
+        }>>;
         repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
         installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
         projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
@@ -6508,17 +9030,212 @@ declare const CreateSessionRequest: z.ZodPreprocess<z.ZodObject<{
         cacheToolsList: z.ZodOptional<z.ZodBoolean>;
         requireApproval: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
         headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        connectionRef: z.ZodOptional<z.ZodObject<{
+            connectionId: z.ZodOptional<z.ZodString>;
+            provider: z.ZodOptional<z.ZodString>;
+            providerDomain: z.ZodString;
+            kind: z.ZodOptional<z.ZodEnum<{
+                oauth2: "oauth2";
+                api_key: "api_key";
+                app_install: "app_install";
+                delegated: "delegated";
+            }>>;
+            scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            resource: z.ZodOptional<z.ZodString>;
+            selectedResources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodLiteral<"repository">;
+            }, z.core.$strict>>>;
+            subjectScope: z.ZodOptional<z.ZodEnum<{
+                subject: "subject";
+                workspace: "workspace";
+            }>>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>>;
     sandbox: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"shared">, z.ZodLiteral<"new">, z.ZodObject<{
         groupId: z.ZodString;
     }, z.core.$strip>]>>;
 }, z.core.$strip>>;
 type CreateSessionRequest = z.infer<typeof CreateSessionRequest>;
+declare const HumanInputQuestionKind: z.ZodEnum<{
+    text: "text";
+    single_select: "single_select";
+    multi_select: "multi_select";
+}>;
+type HumanInputQuestionKind = z.infer<typeof HumanInputQuestionKind>;
+declare const HumanInputOption: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+type HumanInputOption = z.infer<typeof HumanInputOption>;
+declare const HumanInputQuestion: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        text: "text";
+        single_select: "single_select";
+        multi_select: "multi_select";
+    }>;
+    prompt: z.ZodString;
+    label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    helpText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    options: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    allowOther: z.ZodDefault<z.ZodBoolean>;
+    validation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        minLength: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        maxLength: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        minSelections: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        maxSelections: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type HumanInputQuestion = z.infer<typeof HumanInputQuestion>;
+declare const HumanInputRequestStatus: z.ZodEnum<{
+    cancelled: "cancelled";
+    expired: "expired";
+    pending: "pending";
+    answered: "answered";
+    skipped: "skipped";
+}>;
+type HumanInputRequestStatus = z.infer<typeof HumanInputRequestStatus>;
+declare const RequestHumanInputToolInput: z.ZodObject<{
+    questions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            text: "text";
+            single_select: "single_select";
+            multi_select: "multi_select";
+        }>;
+        prompt: z.ZodString;
+        label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        helpText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        options: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        allowOther: z.ZodDefault<z.ZodBoolean>;
+        validation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            minLength: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            maxLength: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            minSelections: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            maxSelections: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    allowSkip: z.ZodDefault<z.ZodBoolean>;
+    expiresInSeconds: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+type RequestHumanInputToolInput = z.infer<typeof RequestHumanInputToolInput>;
+declare const HumanInputAnswer: z.ZodObject<{
+    questionId: z.ZodString;
+    values: z.ZodArray<z.ZodString>;
+    other: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+type HumanInputAnswer = z.infer<typeof HumanInputAnswer>;
+declare const HumanInputResponse: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    outcome: z.ZodLiteral<"answered">;
+    answers: z.ZodArray<z.ZodObject<{
+        questionId: z.ZodString;
+        values: z.ZodArray<z.ZodString>;
+        other: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    outcome: z.ZodLiteral<"skipped">;
+}, z.core.$strip>, z.ZodObject<{
+    outcome: z.ZodLiteral<"expired">;
+}, z.core.$strip>, z.ZodObject<{
+    outcome: z.ZodLiteral<"cancelled">;
+}, z.core.$strip>], "outcome">;
+type HumanInputResponse = z.infer<typeof HumanInputResponse>;
+declare const SubmitHumanInputResponseRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    outcome: z.ZodLiteral<"answered">;
+    answers: z.ZodArray<z.ZodObject<{
+        questionId: z.ZodString;
+        values: z.ZodArray<z.ZodString>;
+        other: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    outcome: z.ZodLiteral<"skipped">;
+}, z.core.$strip>], "outcome">;
+type SubmitHumanInputResponseRequest = z.infer<typeof SubmitHumanInputResponseRequest>;
+declare const SessionHumanInputRequest: z.ZodObject<{
+    id: z.ZodString;
+    workspaceId: z.ZodString;
+    sessionId: z.ZodString;
+    turnId: z.ZodString;
+    turnGeneration: z.ZodNumber;
+    creationAttemptId: z.ZodString;
+    toolCallId: z.ZodString;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        expired: "expired";
+        pending: "pending";
+        answered: "answered";
+        skipped: "skipped";
+    }>;
+    questions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            text: "text";
+            single_select: "single_select";
+            multi_select: "multi_select";
+        }>;
+        prompt: z.ZodString;
+        label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        helpText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        options: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        allowOther: z.ZodDefault<z.ZodBoolean>;
+        validation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            minLength: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            maxLength: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            minSelections: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            maxSelections: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    allowSkip: z.ZodBoolean;
+    response: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        outcome: z.ZodLiteral<"answered">;
+        answers: z.ZodArray<z.ZodObject<{
+            questionId: z.ZodString;
+            values: z.ZodArray<z.ZodString>;
+            other: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        outcome: z.ZodLiteral<"skipped">;
+    }, z.core.$strip>, z.ZodObject<{
+        outcome: z.ZodLiteral<"expired">;
+    }, z.core.$strip>, z.ZodObject<{
+        outcome: z.ZodLiteral<"cancelled">;
+    }, z.core.$strip>], "outcome">>;
+    respondedBy: z.ZodNullable<z.ZodString>;
+    respondedAt: z.ZodNullable<z.ZodString>;
+    expiresAt: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+type SessionHumanInputRequest = z.infer<typeof SessionHumanInputRequest>;
+/**
+ * Extract the stable approval identity used by both durable admission and
+ * runtime resume. Serialized SDK interruptions may place it on the wrapper or
+ * its raw item; malformed entries fail closed instead of inventing an id.
+ */
+declare function approvalIdentifier(value: unknown): string | null;
 declare const ClientSessionEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"user.message">;
     clientEventId: z.ZodOptional<z.ZodString>;
     payload: z.ZodObject<{
         text: z.ZodString;
+        turnInstructions: z.ZodOptional<z.ZodString>;
         resources: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
             kind: z.ZodLiteral<"repository">;
             uri: z.ZodString;
@@ -6530,6 +9247,11 @@ declare const ClientSessionEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 gitlab: "gitlab";
                 azure_devops: "azure_devops";
             }>>;
+            credentialBindingId: z.ZodOptional<z.ZodString>;
+            access: z.ZodOptional<z.ZodEnum<{
+                read: "read";
+                write: "write";
+            }>>;
             repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
             installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
             projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
@@ -6555,6 +9277,8 @@ declare const ClientSessionEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
             high: "high";
             xhigh: "xhigh";
         }>>;
+        controlEtag: z.ZodOptional<z.ZodString>;
+        expectedDraftRevision: z.ZodOptional<z.ZodNumber>;
         mcpCredentialUpdates: z.ZodOptional<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             headers: z.ZodRecord<z.ZodString, z.ZodString>;
@@ -6571,10 +9295,27 @@ declare const ClientSessionEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }>;
         message: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"user.humanInputResponse">;
+    clientEventId: z.ZodOptional<z.ZodString>;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        response: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            outcome: z.ZodLiteral<"answered">;
+            answers: z.ZodArray<z.ZodObject<{
+                questionId: z.ZodString;
+                values: z.ZodArray<z.ZodString>;
+                other: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            outcome: z.ZodLiteral<"skipped">;
+        }, z.core.$strip>], "outcome">;
+    }, z.core.$strip>;
 }, z.core.$strip>], "type">;
 type ClientSessionEvent = z.infer<typeof ClientSessionEvent>;
 declare const SteerSessionMessageRequest: z.ZodObject<{
     text: z.ZodString;
+    turnInstructions: z.ZodOptional<z.ZodString>;
     resources: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"repository">;
         uri: z.ZodString;
@@ -6586,6 +9327,11 @@ declare const SteerSessionMessageRequest: z.ZodObject<{
             gitlab: "gitlab";
             azure_devops: "azure_devops";
         }>>;
+        credentialBindingId: z.ZodOptional<z.ZodString>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            write: "write";
+        }>>;
         repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
         installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
         projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
@@ -6612,8 +9358,8 @@ declare const SteerSessionMessageRequest: z.ZodObject<{
         xhigh: "xhigh";
     }>>;
     clientEventId: z.ZodOptional<z.ZodString>;
-    expectedControlGeneration: z.ZodOptional<z.ZodNumber>;
-    expectedWorkspaceInferenceGeneration: z.ZodOptional<z.ZodNumber>;
+    controlEtag: z.ZodOptional<z.ZodString>;
+    expectedDraftRevision: z.ZodOptional<z.ZodNumber>;
     mcpCredentialUpdates: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         headers: z.ZodRecord<z.ZodString, z.ZodString>;
@@ -6628,8 +9374,10 @@ declare const SteerSessionMessageResponse: z.ZodObject<{
         sequence: z.ZodNumber;
         type: z.ZodEnum<{
             "session.created": "session.created";
+            "session.event.envelope_omitted": "session.event.envelope_omitted";
             "session.status.changed": "session.status.changed";
             "session.requiresAction": "session.requiresAction";
+            "session.humanInput.requested": "session.humanInput.requested";
             "session.context.compaction.requested": "session.context.compaction.requested";
             "session.context.compacted": "session.context.compacted";
             "session.context.compaction.skipped": "session.context.compaction.skipped";
@@ -6637,6 +9385,7 @@ declare const SteerSessionMessageResponse: z.ZodObject<{
             "user.message": "user.message";
             "user.pause": "user.pause";
             "user.approvalDecision": "user.approvalDecision";
+            "user.humanInputResponse": "user.humanInputResponse";
             "turn.queued": "turn.queued";
             "turn.started": "turn.started";
             "turn.completed": "turn.completed";
@@ -6652,6 +9401,7 @@ declare const SteerSessionMessageResponse: z.ZodObject<{
             "agent.toolCall.output": "agent.toolCall.output";
             "agent.model.usage": "agent.model.usage";
             "tool.auth_needed": "tool.auth_needed";
+            "credential.auth_needed": "credential.auth_needed";
             "agent.updated": "agent.updated";
             "rig.setup.started": "rig.setup.started";
             "rig.setup.completed": "rig.setup.completed";
@@ -6676,6 +9426,7 @@ declare const SteerSessionMessageResponse: z.ZodObject<{
             "session.control.steer_requested": "session.control.steer_requested";
             "workspace.inference.paused": "workspace.inference.paused";
             "workspace.inference.resumed": "workspace.inference.resumed";
+            "session.queue.changed": "session.queue.changed";
             "session.queue.prompt.cancelled": "session.queue.prompt.cancelled";
             "session.queue.history": "session.queue.history";
             "turn.event.rejected_late": "turn.event.rejected_late";
@@ -6743,6 +9494,7 @@ declare const SteerSessionMessageResponse: z.ZodObject<{
             cancelled: "cancelled";
             completed: "completed";
             superseded: "superseded";
+            withdrawn_for_edit: "withdrawn_for_edit";
         }>;
         source: z.ZodEnum<{
             user: "user";
@@ -6765,6 +9517,11 @@ declare const SteerSessionMessageResponse: z.ZodObject<{
                 gitlab: "gitlab";
                 azure_devops: "azure_devops";
             }>>;
+            credentialBindingId: z.ZodOptional<z.ZodString>;
+            access: z.ZodOptional<z.ZodEnum<{
+                read: "read";
+                write: "write";
+            }>>;
             repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
             installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
             projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
@@ -6813,6 +9570,15 @@ declare const SteerSessionMessageResponse: z.ZodObject<{
         executionGeneration: z.ZodNumber;
         activeAttemptId: z.ZodNullable<z.ZodString>;
         lineage: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        initiator: z.ZodObject<{
+            subjectId: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            kind: z.ZodEnum<{
+                service: "service";
+                subject: "subject";
+            }>;
+        }, z.core.$strip>;
+        initiatorContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         cancelledBy: z.ZodNullable<z.ZodString>;
         cancelReason: z.ZodNullable<z.ZodString>;
         startedAt: z.ZodNullable<z.ZodString>;
@@ -6832,8 +9598,10 @@ declare const SessionBusMessage: z.ZodObject<{
         sequence: z.ZodNumber;
         type: z.ZodEnum<{
             "session.created": "session.created";
+            "session.event.envelope_omitted": "session.event.envelope_omitted";
             "session.status.changed": "session.status.changed";
             "session.requiresAction": "session.requiresAction";
+            "session.humanInput.requested": "session.humanInput.requested";
             "session.context.compaction.requested": "session.context.compaction.requested";
             "session.context.compacted": "session.context.compacted";
             "session.context.compaction.skipped": "session.context.compaction.skipped";
@@ -6841,6 +9609,7 @@ declare const SessionBusMessage: z.ZodObject<{
             "user.message": "user.message";
             "user.pause": "user.pause";
             "user.approvalDecision": "user.approvalDecision";
+            "user.humanInputResponse": "user.humanInputResponse";
             "turn.queued": "turn.queued";
             "turn.started": "turn.started";
             "turn.completed": "turn.completed";
@@ -6856,6 +9625,7 @@ declare const SessionBusMessage: z.ZodObject<{
             "agent.toolCall.output": "agent.toolCall.output";
             "agent.model.usage": "agent.model.usage";
             "tool.auth_needed": "tool.auth_needed";
+            "credential.auth_needed": "credential.auth_needed";
             "agent.updated": "agent.updated";
             "rig.setup.started": "rig.setup.started";
             "rig.setup.completed": "rig.setup.completed";
@@ -6880,6 +9650,7 @@ declare const SessionBusMessage: z.ZodObject<{
             "session.control.steer_requested": "session.control.steer_requested";
             "workspace.inference.paused": "workspace.inference.paused";
             "workspace.inference.resumed": "workspace.inference.resumed";
+            "session.queue.changed": "session.queue.changed";
             "session.queue.prompt.cancelled": "session.queue.prompt.cancelled";
             "session.queue.history": "session.queue.history";
             "turn.event.rejected_late": "turn.event.rejected_late";
@@ -6953,6 +9724,61 @@ declare const GitHubRepository: z.ZodObject<{
     accountType: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
 type GitHubRepository = z.infer<typeof GitHubRepository>;
+declare const GitHubRepositoryScope: z.ZodEnum<{
+    all: "all";
+    selected: "selected";
+}>;
+type GitHubRepositoryScope = z.infer<typeof GitHubRepositoryScope>;
+declare const GitHubInstallationBinding: z.ZodObject<{
+    installationId: z.ZodNumber;
+    accountLogin: z.ZodNullable<z.ZodString>;
+    accountType: z.ZodNullable<z.ZodString>;
+    repositoryScope: z.ZodEnum<{
+        all: "all";
+        selected: "selected";
+    }>;
+    repositoryCount: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+type GitHubInstallationBinding = z.infer<typeof GitHubInstallationBinding>;
+declare const GitHubAppInfo: z.ZodObject<{
+    configured: z.ZodBoolean;
+    appId: z.ZodNullable<z.ZodString>;
+    clientId: z.ZodNullable<z.ZodString>;
+    appSlug: z.ZodNullable<z.ZodString>;
+    installUrl: z.ZodNullable<z.ZodString>;
+    linkUrl: z.ZodNullable<z.ZodString>;
+    installations: z.ZodArray<z.ZodObject<{
+        installationId: z.ZodNumber;
+        accountLogin: z.ZodNullable<z.ZodString>;
+        accountType: z.ZodNullable<z.ZodString>;
+        repositoryScope: z.ZodEnum<{
+            all: "all";
+            selected: "selected";
+        }>;
+        repositoryCount: z.ZodNumber;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    missing: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type GitHubAppInfo = z.infer<typeof GitHubAppInfo>;
+declare const GitHubRepositoriesResponse: z.ZodObject<{
+    repositories: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        installationId: z.ZodNumber;
+        fullName: z.ZodString;
+        name: z.ZodString;
+        private: z.ZodBoolean;
+        htmlUrl: z.ZodString;
+        cloneUrl: z.ZodString;
+        defaultBranch: z.ZodString;
+        accountLogin: z.ZodString;
+        accountType: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type GitHubRepositoriesResponse = z.infer<typeof GitHubRepositoriesResponse>;
 declare const ClientAuthConfig: z.ZodDiscriminatedUnion<[z.ZodObject<{
     mode: z.ZodLiteral<"none">;
 }, z.core.$strip>, z.ZodObject<{
@@ -7633,8 +10459,19 @@ declare const ClientModel: z.ZodObject<{
     contextWindowTokens: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 type ClientModel = z.infer<typeof ClientModel>;
+/**
+ * Exact public HTTP protocol revision spoken by this release train.
+ *
+ * This is deliberately independent from a deployment SHA: API and web may roll
+ * at different instants, while incompatible request shapes must never cross
+ * that rollout boundary. Mutating clients send this value in
+ * `x-opengeni-api-contract`; the API rejects any other value before routing.
+ */
+declare const OPENGENI_API_CONTRACT_REVISION: "2026-07-turn-instructions-v1";
+declare const OPENGENI_API_CONTRACT_HEADER: "x-opengeni-api-contract";
 declare const ClientConfig: z.ZodObject<{
     deploymentRevision: z.ZodString;
+    apiContractRevision: z.ZodLiteral<"2026-07-turn-instructions-v1">;
     serverVersion: z.ZodOptional<z.ZodString>;
     defaultModel: z.ZodString;
     allowedModels: z.ZodArray<z.ZodString>;
@@ -7729,4 +10566,4 @@ declare function evaluateWorkspaceModelPolicy(policy: WorkspaceModelPolicyContra
     modelId: string;
 }): WorkspaceModelPolicyVerdict;
 
-export { AccessContext, AccessGrant, AccountGrant, AccountRole, AcknowledgeStreamRequest, AcknowledgeStreamResponse, AddDocumentRequest, AddWorkspaceMemberRequest, type AdmitRunInput, ApiKey, AttachViewerRequest, BillingBalance, BillingMode, CAPABILITY_DESCRIPTORS, CLEARED_RUN_STATE_BLOB, CLEARED_RUN_STATE_MARKER, CancelSessionQueueItemRequest, CapabilityCatalogAuthKind, CapabilityCatalogItem, CapabilityCatalogResponse, CapabilityCatalogTier, type CapabilityDescriptor, CapabilityInstallation, CapabilityInstallationStatus, CapabilityKind, CapabilityPack, CapabilityPackConnector, CapabilityPackConnectorAuthModel, CapabilityPackKnowledge, CapabilityPackScheduledTaskTemplate, CapabilityPackSkill, CapabilityPackSkillFile, CapabilityRuntime, CapabilitySource, CapabilityUnavailableReason, ClearSessionContextRequest, ClientAuthConfig, ClientConfig, ClientModel, ClientSessionEvent, CompactSessionContextRequest, CompactSessionContextResult, CompleteFileUploadResponse, ConnectionCredentialBundle, type ConnectionCredentialsPort, ConnectionKind, ConnectionMetadata, ConnectionResponse, ConnectionStatus, CreateApiKeyRequest, CreateApiKeyResponse, CreateCapabilityCatalogItemRequest, CreateCheckoutRequest, CreateCheckoutResponse, CreateConnectionRequest, CreateDocumentBaseRequest, CreateFileUploadRequest, CreateFileUploadResponse, CreateKnowledgeMemoryRequest, CreateRigRequest, CreateScheduledTaskRequest, CreateSessionRequest, CreateSocialConnectionRequest, CreateSocialPostRequest, CreateVariableSetRequest, CreateWorkspaceEnvironmentRequest, CreateWorkspaceRequest, DESKTOP_STREAM_PORT, DelegatedAccessTokenPayload, DeviceEnrollmentApproveRequest, DeviceEnrollmentApproveResponse, DeviceEnrollmentDenyRequest, DeviceEnrollmentDenyResponse, DeviceEnrollmentLookupMachine, DeviceEnrollmentLookupRequest, DeviceEnrollmentLookupResponse, DeviceEnrollmentPollRequest, DeviceEnrollmentPollResponse, DeviceEnrollmentStartRequest, DeviceEnrollmentStartResponse, DeviceEnrollmentState, DiscoverMcpCapabilitiesResponse, Document, DocumentBase, DocumentSearchMode, DocumentSearchRequest, DocumentSearchResult, DocumentStatus, EnableCapabilityRequest, EnablePackRequest, EnrollTokenExchangeRequest, EnrollTokenExchangeResponse, EnrollTokenPayload, EnrollmentArch, EnrollmentBearerPayload, EnrollmentCredentialsResponse, EnrollmentOs, EnrollmentSummary, EntitlementDecision, EntitlementValue, Entitlements, EntitlementsMode, type EntitlementsPort, ErrorCode, ErrorEnvelope, FileAsset, FileDownloadUrlResponse, FileResourceRef, FileStatus, FileUploadStatus, FsChangeKind, FsChangedPayload, FsDeleteRequest, FsDeleteResponse, FsEncoding, FsListRequest, FsListResponse, FsMkdirRequest, FsMkdirResponse, FsMoveRequest, FsMoveResponse, FsNodeType, FsReadRequest, FsReadResponse, FsTreeNode, FsWriteRequest, FsWriteResponse, GetWorkspaceCaptureFileResponse, GetWorkspaceCaptureResponse, GitChangedPayload, GitCommit, GitCredentialProvider, GitCredentialRepositoryRef, type GitCredentials, type GitCredentialsRequest, GitDiffHunk, GitDiffLine, GitDiffLineType, GitDiffRequest, GitDiffResponse, GitFileDiff, GitFileStatus, GitFileStatusCode, type GitHubAppApiPort, GitHubAppManifestCreate, type GitHubInstallationSummary, GitHubRepository, GitLogRequest, GitLogResponse, GitShowRequest, GitShowResponse, GitStatusRequest, GitStatusResponse, GoalSpec, type HealthResponse, IntegrationClientMetadata, KnowledgeMemory, KnowledgeMemoryKind, KnowledgeMemorySearchRequest, KnowledgeMemoryStatus, KnowledgeSourceKind, KnowledgeSourceRef, LimitAction, LimitDecision, LineageNode, ListConnectionsResponse, ListEnrollmentsResponse, ListWorkspaceMembersResponse, MachineKind, MachineMetricsSeriesResponse, MachineState, MachineView, MachinesResponse, ManagedAccount, MarketingDailyAnalysisTaskRequest, McpServerConnectionRef, MetricSample, MintEnrollTokenRequest, MintEnrollTokenResponse, OAuthStartRequest, OAuthStartResponse, PackInstallation, PackInstallationStatus, Permission, type PortExposureKind, ProductAccessMode, ProposeRigChangeRequest, PtyCloseRequest, PtyOpenRequest, PtyOpenResponse, PtyResizeRequest, PtyWriteRequest, ReasoningEffort, RecordingAvailablePayload, RecordingCodec, RecordingContentType, RecordingFailedPayload, RecordingFailedReason, RecordingMode, RecordingStartedPayload, RegisterCapabilityPackRequest, RelayTokenPayload, RepositoryResourceRef, ResourceRef, ResourceRefConflictError, RevokeEnrollmentResponse, Rig, RigChange, RigChangeKind, RigChangeStatus, RigChangeVerification, RigCheck, RigCheckResult, RigDefinitionEditPayload, RigSetupAppendPayload, RigVerificationHealth, RigVersion, SandboxBackend, SandboxCapabilityName, SandboxCommandOutputDeltaPayload, SandboxOs, type SandboxSecrets, type SandboxSecretsRequest, ScheduledTask, ScheduledTaskAgentConfig, ScheduledTaskOverlapPolicy, ScheduledTaskRun, ScheduledTaskRunMode, ScheduledTaskRunStatus, ScheduledTaskScheduleSpec, ScheduledTaskStatus, ScheduledTaskTriggerType, Session, SessionBusMessage, SessionCapabilities, SessionControlRequest, SessionControlResponse, SessionControlState, SessionEvent, SessionEventType, SessionGoal, SessionGoalCreatedBy, SessionGoalPausedReason, SessionGoalStatus, SessionLineageResponse, SessionListResponse, SessionMcpCredentialUpdateInput, SessionMcpServerInput, SessionMcpServerMetadata, SessionQueueMutationResponse, SessionQueueSnapshot, SessionStatus, SessionStructuredCapabilities, type SessionSummary, SessionSystemUpdate, SessionSystemUpdateKind, SessionSystemUpdateState, SessionTurn, SessionTurnSource, SessionTurnStatus, SetVariableSetVariableRequest, SetWorkspaceDefaultRigRequest, SetWorkspaceEnvironmentVariableRequest, SocialConnection, SocialConnectionStatus, SocialPost, SocialProvider, StaticUsageLimits, SteerSessionMessageRequest, SteerSessionMessageResponse, StreamClosedPayload, StreamOpenedPayload, StreamRevokedPayload, StreamTokenPayload, StreamUrlRotatedPayload, SwapActiveSandboxRequest, SwapActiveSandboxResponse, SystemUpdateClassification, TERMINAL_STREAM_PORT, TerminalExecRequest, TerminalExecResponse, TerminalPtyExitedPayload, TerminalPtyOutputDeltaPayload, TerminalPtyStartedPayload, ToolAuthNeededPayload, ToolRef, TriggerScheduledTaskRequest, UpdateConnectionRequest, UpdateKnowledgeMemoryRequest, UpdateRigRequest, UpdateScheduledTaskRequest, UpdateSessionGoalRequest, UpdateSessionPinRequest, UpdateSessionRequest, UpdateVariableSetRequest, UpdateWorkspaceEnvironmentRequest, UpdateWorkspaceMemberRequest, UpdateWorkspaceModelPolicyRequest, UpdateWorkspaceRequest, UpdateWorkspaceSettingsRequest, UsageEvent, UsageEventType, UsageLimitsMode, VariableSet, VariableSetVariableMetadata, VariableSetVariableName, ViewerHeartbeatRequest, ViewerHeartbeatResponse, ViewerHolder, Workspace, WorkspaceCaptureDegradedReason, WorkspaceCaptureFile, WorkspaceCaptureManifest, WorkspaceCaptureRepo, WorkspaceCaptureSignedUrl, WorkspaceCaptureStats, WorkspaceEnvironment, WorkspaceEnvironmentVariableMetadata, WorkspaceInferenceControlRequest, WorkspaceInferenceControlResponse, WorkspaceInferenceState, WorkspaceMember, WorkspaceMemorySearchMode, WorkspaceMemorySearchRequest, WorkspaceMemorySearchResponse, WorkspaceMemorySearchResult, type WorkspaceModelPolicyContract, type WorkspaceModelPolicyVerdict, WorkspaceRegisteredPack, WorkspaceRevisionCapturedPayload, WorkspaceRevisionDegradedPayload, type WorkspaceSettings, WorkspaceSettingsSchema, evaluateWorkspaceModelPolicy, isClearedRunStateBlob, mergeResourceRefs, mergeToolRefs, prefixedMcpToolName, reasoningEffortForMetadata, resolveWorkspaceMemoryEnabled, resourceIdentityKey, signDelegatedAccessToken, signEnrollToken, signEnrollmentBearer, signRelayToken, signStreamToken, stableJson, verifyDelegatedAccessToken, verifyEnrollToken, verifyEnrollmentBearer, verifyRelayToken, verifyStreamToken };
+export { AccessContext, AccessGrant, AccountGrant, AccountRole, AcknowledgeStreamRequest, AcknowledgeStreamResponse, AddDocumentRequest, AddWorkspaceMemberRequest, type AdmitRunInput, ApiKey, AttachViewerRequest, type AuthorizeSessionInput, BillingBalance, BillingMode, type BoundSessionEventOptions, type BoundSessionEventPayloadOptions, type BoundWorkspaceControlEventOptions, CAPABILITY_DESCRIPTORS, CLEARED_RUN_STATE_BLOB, CLEARED_RUN_STATE_MARKER, CapabilityCatalogAuthKind, CapabilityCatalogItem, CapabilityCatalogResponse, CapabilityCatalogTier, type CapabilityDescriptor, CapabilityInstallation, CapabilityInstallationStatus, CapabilityKind, CapabilityPack, CapabilityPackConnector, CapabilityPackConnectorAuthModel, CapabilityPackKnowledge, CapabilityPackScheduledTaskTemplate, CapabilityPackSkill, CapabilityPackSkillFile, CapabilityRuntime, CapabilitySource, CapabilityUnavailableReason, ClearSessionContextRequest, ClientAuthConfig, ClientConfig, ClientModel, ClientSessionEvent, CompactSessionContextRequest, CompactSessionContextResult, CompleteFileUploadResponse, ComposerDraft, ConnectionCredentialBundle, type ConnectionCredentialsPort, ConnectionKind, ConnectionMetadata, ConnectionResponse, ConnectionStatus, CreateApiKeyRequest, CreateApiKeyResponse, CreateCapabilityCatalogItemRequest, CreateCheckoutRequest, CreateCheckoutResponse, CreateConnectionRequest, CreateDocumentBaseRequest, CreateFileUploadRequest, CreateFileUploadResponse, CreateKnowledgeMemoryRequest, CreateRigRequest, CreateScheduledTaskRequest, CreateSessionRequest, CreateSessionResponse, CreateSocialConnectionRequest, CreateSocialPostRequest, CreateVariableSetRequest, CreateWorkspaceEnvironmentRequest, CreateWorkspaceRequest, CredentialAuthNeededPayload, type CredentialAuthNeededReason, DESKTOP_STREAM_PORT, DelegatedAccessTokenPayload, DeleteSessionQueueItemRequest, DeviceEnrollmentApproveRequest, DeviceEnrollmentApproveResponse, DeviceEnrollmentDenyRequest, DeviceEnrollmentDenyResponse, DeviceEnrollmentLookupMachine, DeviceEnrollmentLookupRequest, DeviceEnrollmentLookupResponse, DeviceEnrollmentPollRequest, DeviceEnrollmentPollResponse, DeviceEnrollmentStartRequest, DeviceEnrollmentStartResponse, DeviceEnrollmentState, DiscoverMcpCapabilitiesResponse, Document, DocumentBase, DocumentSearchMode, DocumentSearchRequest, DocumentSearchResult, DocumentStatus, EditSessionQueueItemRequest, EffectiveControlBlocker, EffectiveControlResumeOption, EffectiveSessionControl, EnableCapabilityRequest, EnablePackRequest, EnrollTokenExchangeRequest, EnrollTokenExchangeResponse, EnrollTokenPayload, EnrollmentArch, EnrollmentBearerPayload, EnrollmentCredentialsResponse, EnrollmentOs, EnrollmentSummary, EntitlementDecision, EntitlementValue, Entitlements, EntitlementsMode, type EntitlementsPort, ErrorCode, ErrorEnvelope, FileAsset, FileDownloadUrlResponse, FileResourceRef, FileStatus, FileUploadStatus, FsChangeKind, FsChangedPayload, FsDeleteRequest, FsDeleteResponse, FsEncoding, FsListRequest, FsListResponse, FsMkdirRequest, FsMkdirResponse, FsMoveRequest, FsMoveResponse, FsNodeType, FsReadRequest, FsReadResponse, FsTreeNode, FsWriteRequest, FsWriteResponse, GetWorkspaceCaptureFileResponse, GetWorkspaceCaptureResponse, GitChangedPayload, GitCommit, GitCredentialBindingId, GitCredentialProvider, GitCredentialRepositoryRef, type GitCredentials, type GitCredentialsRequest, GitDiffHunk, GitDiffLine, GitDiffLineType, GitDiffRequest, GitDiffResponse, GitFileDiff, GitFileStatus, GitFileStatusCode, type GitHubAppApiPort, GitHubAppInfo, GitHubAppManifestCreate, GitHubInstallationBinding, type GitHubInstallationSummary, GitHubRepositoriesResponse, GitHubRepository, type GitHubRepositoryPermissions, GitHubRepositoryScope, type GitHubUserInstallationAccess, type GitHubUserRepositoryAccess, GitLogRequest, GitLogResponse, GitRepositoryAccess, GitShowRequest, GitShowResponse, GitStatusRequest, GitStatusResponse, GoalSpec, type HealthResponse, HostEventExport, HostEventExportBatch, type HostEventSink, HostExportConsumerId, HostExportCursor, HostExportInitiator, HostExportInitiatorContext, HostSessionEvent, HostUsageEvent, HostUsageExport, HostUsageExportBatch, type HostUsageSink, HumanInputAnswer, HumanInputOption, HumanInputQuestion, HumanInputQuestionKind, HumanInputRequestStatus, HumanInputResponse, IntegrationClientMetadata, KnowledgeMemory, KnowledgeMemoryKind, KnowledgeMemorySearchRequest, KnowledgeMemoryStatus, KnowledgeSourceKind, KnowledgeSourceRef, LimitAction, LimitDecision, LineageNode, ListConnectionsResponse, ListEnrollmentsResponse, ListWorkspaceMembersResponse, MachineKind, MachineMetricsSeriesResponse, MachineState, MachineView, MachinesResponse, ManagedAccount, MarketingDailyAnalysisTaskRequest, McpConnectionResourceScope, type McpCredentialAuthNeededReason, type McpCredentialResolution, type McpCredentialsRequest, McpServerConnectionRef, MetricSample, MintEnrollTokenRequest, MintEnrollTokenResponse, MoveSessionQueueItemRequest, OAuthStartRequest, OAuthStartResponse, OPENGENI_API_CONTRACT_HEADER, OPENGENI_API_CONTRACT_REVISION, OPENGENI_HOST_EXPORT_SCHEMA_REVISION, PackInstallation, PackInstallationStatus, Permission, type PortExposureKind, ProductAccessMode, ProposeRigChangeRequest, PtyCloseRequest, PtyOpenRequest, PtyOpenResponse, PtyResizeRequest, PtyWriteRequest, ReasoningEffort, RecordingAvailablePayload, RecordingCodec, RecordingContentType, RecordingFailedPayload, RecordingFailedReason, RecordingMode, RecordingStartedPayload, RegisterCapabilityPackRequest, RelayTokenPayload, RepositoryResourceRef, RequestHumanInputToolInput, type ResolveSessionAuthorizationListScopeInput, type ResolveSessionEventTypeFiltersInput, ResourceMountPathError, ResourceRef, ResourceRefConflictError, RevokeEnrollmentResponse, Rig, RigChange, RigChangeKind, RigChangeStatus, RigChangeVerification, RigCheck, RigCheckResult, RigDefinitionEditPayload, RigSetupAppendPayload, RigVerificationHealth, RigVersion, type RunCredentialAuthNeeded, type RunCredentialFile, type RunCredentialRedaction, type RunCredentialsRequest, type RunCredentialsResolution, SESSION_AUTHORIZATION_LIST_SCOPE_MAX_IDS, SESSION_EVENT_CLIENT_EVENT_ID_MAX_BYTES, SESSION_EVENT_DUPLICATE_REASON_MAX_BYTES, SESSION_EVENT_ENVELOPE_MAX_BYTES, SESSION_EVENT_PAYLOAD_MAX_BYTES, SESSION_EVENT_RAW_DELTA_TYPES, SESSION_EVENT_SEMANTIC_CLASS_TYPES, SESSION_EVENT_TURN_ASSOCIATION_MAX_BYTES, SESSION_EVENT_TYPE_MAX_BYTES, SESSION_OPERATION_KEY_MAX_CHARS, SandboxBackend, SandboxCapabilityName, SandboxCommandOutputDeltaPayload, SandboxOs, type SandboxSecrets, type SandboxSecretsRequest, SaveComposerDraftRequest, ScheduledTask, ScheduledTaskAgentConfig, ScheduledTaskOverlapPolicy, ScheduledTaskRun, ScheduledTaskRunMode, ScheduledTaskRunStatus, ScheduledTaskScheduleSpec, ScheduledTaskStatus, ScheduledTaskTriggerType, ServiceTurnInitiator, ServiceTurnInitiatorContext, Session, SessionAuthorizationActor, SessionAuthorizationDecision, SessionAuthorizationListScope, SessionAuthorizationOperation, type SessionAuthorizationPort, SessionAuthorizationSurface, SessionAuthorizationTarget, SessionBusMessage, SessionCapabilities, SessionCommandReceipt, SessionControlRequest, SessionControlResponse, SessionControlState, SessionEvent, type SessionEventBoundarySurface, type SessionEventJsonMeasurement, type SessionEventMediaPreview, SessionEventPayloadMode, type SessionEventPayloadTruncation, SessionEventReadDirection, SessionEventReadMode, SessionEventSemanticClass, SessionEventType, SessionGoal, SessionGoalCreatedBy, SessionGoalPausedReason, SessionGoalStatus, SessionHumanInputRequest, SessionLineageResponse, SessionListResponse, SessionMcpCredentialUpdateInput, SessionMcpServerInput, SessionMcpServerMetadata, SessionQueueMutationResponse, SessionQueueSnapshot, SessionStatus, SessionStructuredCapabilities, type SessionSummary, SessionSystemUpdate, SessionSystemUpdateKind, SessionSystemUpdatePayload, SessionSystemUpdateState, SessionTurn, SessionTurnSource, SessionTurnStatus, SetVariableSetVariableRequest, SetWorkspaceDefaultRigRequest, SetWorkspaceEnvironmentVariableRequest, SocialConnection, SocialConnectionStatus, SocialPost, SocialProvider, StaticUsageLimits, SteerSessionMessageRequest, SteerSessionMessageResponse, SteerSessionQueueItemRequest, StreamClosedPayload, StreamOpenedPayload, StreamRevokedPayload, StreamTokenPayload, StreamUrlRotatedPayload, SubmitHumanInputResponseRequest, SwapActiveSandboxRequest, SwapActiveSandboxResponse, SystemUpdateClassification, TERMINAL_STREAM_PORT, TerminalExecRequest, TerminalExecResponse, TerminalPtyExitedPayload, TerminalPtyOutputDeltaPayload, TerminalPtyStartedPayload, ToolAuthNeededPayload, ToolRef, TranscriptionErrorCode, TranscriptionEvent, TranscriptionResultMetadata, TranscriptionSpeaker, TranscriptionTimeSpan, TranscriptionWord, TriggerScheduledTaskRequest, TurnInitiator, TurnInitiatorContext, UNATTRIBUTED_LEGACY_INITIATOR_SUBJECT_ID, UpdateConnectionRequest, UpdateKnowledgeMemoryRequest, UpdateRigRequest, UpdateScheduledTaskRequest, UpdateSessionGoalRequest, UpdateSessionPinRequest, UpdateSessionRequest, UpdateVariableSetRequest, UpdateWorkspaceEnvironmentRequest, UpdateWorkspaceMemberRequest, UpdateWorkspaceModelPolicyRequest, UpdateWorkspaceRequest, UpdateWorkspaceSettingsRequest, UsageEvent, UsageEventType, UsageLimitsMode, VariableSet, VariableSetVariableMetadata, VariableSetVariableName, ViewerHeartbeatRequest, ViewerHeartbeatResponse, ViewerHolder, WORKSPACE_CONTROL_ACTOR_MAX_BYTES, WORKSPACE_CONTROL_EVENT_MAX_BYTES, WORKSPACE_CONTROL_REASON_MAX_BYTES, Workspace, WorkspaceCaptureDegradedReason, WorkspaceCaptureFile, WorkspaceCaptureManifest, WorkspaceCaptureRepo, WorkspaceCaptureSignedUrl, WorkspaceCaptureStats, type WorkspaceControlBoundarySurface, WorkspaceControlEvent, WorkspaceControlEventTruncation, WorkspaceEnvironment, WorkspaceEnvironmentVariableMetadata, WorkspaceInferenceControlRequest, WorkspaceInferenceControlResponse, WorkspaceInferenceState, WorkspaceMember, WorkspaceMemorySearchMode, WorkspaceMemorySearchRequest, WorkspaceMemorySearchResponse, WorkspaceMemorySearchResult, type WorkspaceModelPolicyContract, type WorkspaceModelPolicyVerdict, WorkspaceRegisteredPack, WorkspaceRevisionCapturedPayload, WorkspaceRevisionDegradedPayload, type WorkspaceSettings, WorkspaceSettingsSchema, WorkspaceTranscriptionPolicy, WorkspaceTranscriptionTarget, approvalIdentifier, approximateSessionEventTokens, assertUniqueResourceMountPaths, boundSessionEvent, boundSessionEventPayload, boundWorkspaceControlEvent, defaultRepositoryMountPath, evaluateWorkspaceModelPolicy, gitCredentialBindingIdForRepository, gitCredentialProviderForRepository, isClearedRunStateBlob, measureSessionEventJson, mergeResourceRefs, mergeToolRefs, normalizeRepositorySubpath, normalizeResourceMountPath, prefixedMcpToolName, reasoningEffortForMetadata, resolveSessionEventTypeFilters, resolveWorkspaceMemoryEnabled, resourceIdentityKey, resourceMountPath, resourceMountPathCollisionKey, sessionEventJsonBytes, sessionEventMediaPreview, sessionEventMediaPreviewFromDataUrl, sessionEventPayloadTruncation, signDelegatedAccessToken, signEnrollToken, signEnrollmentBearer, signRelayToken, signStreamToken, stableJson, verifyDelegatedAccessToken, verifyEnrollToken, verifyEnrollmentBearer, verifyRelayToken, verifyStreamToken, workspaceControlUtf8Bytes };