@ellipsis-dev/sdk 0.30.0 → 0.32.0

package/dist/index.d.ts

@@ -1,21 +1,25 @@
-import { c as components } from './types-DrPhhfOb.js';
-export { A as AgentConfig, a as AgentIdentity, b as AttributionType, B as BudgetConfig, C as ClaudeAssistantEvent, d as ClaudeAssistantMessage, e as ClaudeConfig, f as ClaudeConversationResetEvent, g as ClaudeNativeEvent, h as ClaudeNativeSessionRecord, i as ClaudeNativeUsage, j as ClaudeRateLimitEvent, k as ClaudeRateLimitInfo, l as ClaudeResultEvent, m as ClaudeSessionRecord, n as ClaudeSystemEvent, o as ClaudeUserEvent, p as ClaudeUserMessage, q as CodexAgentMessage, r as CodexAgentMessageItem, s as CodexAppServerError, t as CodexAppServerEvent, u as CodexAppServerItem, v as CodexAppServerNotification, w as CodexAppServerSessionRecord, x as CodexCommandExecution, y as CodexCommandExecutionItem, z as CodexConfig, D as CodexContextCompaction, E as CodexEffortLevel, F as CodexErrorEvent, G as CodexErrorItem, H as CodexErrorParams, I as CodexEvent, J as CodexFileChange, K as CodexFileChangeItem, L as CodexFileUpdate, M as CodexItem, N as CodexItemCompleted, O as CodexItemCompletedEvent, P as CodexItemParams, Q as CodexItemStarted, R as CodexItemStartedEvent, S as CodexItemUpdatedEvent, T as CodexLocalImageInput, U as CodexMcpToolCall, V as CodexMcpToolCallAppContext, W as CodexMcpToolCallError, X as CodexMcpToolCallItem, Y as CodexMcpToolCallResult, Z as CodexPlan, _ as CodexReasoning, $ as CodexReasoningItem, a0 as CodexSessionRecord, a1 as CodexTextInput, a2 as CodexThread, a3 as CodexThreadStarted, a4 as CodexThreadStartedEvent, a5 as CodexThreadStartedParams, a6 as CodexThreadTokenUsage, a7 as CodexTodoListItem, a8 as CodexTokenUsageBreakdown, a9 as CodexTokenUsageParams, aa as CodexTokenUsageUpdated, ab as CodexTurn, ac as CodexTurnCompleted, ad as CodexTurnCompletedEvent, ae as CodexTurnError, af as CodexTurnFailedEvent, ag as CodexTurnParams, ah as CodexTurnStarted, ai as CodexTurnStartedEvent, aj as CodexUsage, ak as CodexUserInput, al as CodexUserMessage, am as CodexWebSearch, an as CodexWebSearchItem, ao as ComputeConfig, ap as ComputeConfig1, aq as ConfigMetadata, ar as ConversationState, as as CreateReviewRequest, at as CronTrigger, au as DeltaFrame, av as DoneFrame, aw as Duration, ax as EffortLevel, ay as EllipsisGrant, az as EllipsisPermissions, aA as EnvironmentBaseBuild, aB as EnvironmentConfig, aC as EnvironmentHooks, aD as EnvironmentHooks1, aE as EnvironmentScript, aF as EnvironmentSource, aG as EnvironmentVariable, aH as ErrorFrame, aI as ExecutionResult, aJ as Finding, aK as GithubAccountFilter, aL as GithubAccountSelector, aM as GithubAccountSnippet, aN as GithubAccountType, aO as GithubIssueEvent, aP as GithubPermissions, aQ as GithubPullRequestEvent, aR as GithubPushEvent, aS as HandlerService, aT as HeartbeatFrame, aU as InputContract, aV as IssueAction, aW as LegacyAssistantPayload, aX as LegacyNativeUsage, aY as LegacyResultPayload, aZ as Level, a_ as LifecycleSessionRecord, a$ as LinearIssueAction, b0 as LinearIssueEvent, b1 as McpRemoteServer, b2 as McpServerRef, b3 as McpStdioServer, b4 as MemorySize, b5 as MessageDeliveredPayload, b6 as MessageDeliveredRecord, b7 as MessageReceivedPayload, b8 as MessageReceivedRecord, b9 as MessageRequeuedPayload, ba as MessageRequeuedRecord, bb as OutboxCollectedPayload, bc as OutboxCollectedRecord, bd as OutputConfig, be as PermissionsConfig, bf as PermissionsConfig1, bg as PlatformSessionRecord, bh as PromptBlockedReason, bi as PullRequestAction, bj as ReactIssue, bk as ReactLinearIssue, bl as ReactPullRequest, bm as ReactPush, bn as ReactSentry, bo as ReactSlackChannel, bp as ReactTrigger, bq as RecordsAppendFrame, br as RepositoryFilter, bs as RepositoryRef, bt as ResolvedReviewScope, bu as Review, bv as ReviewConfiguration, bw as ReviewCounters, bx as ReviewFinding, by as ReviewRequester, bz as ReviewScope, bA as ReviewScopeKind, bB as ReviewStage, bC as ReviewedCommit, bD as ReviewsListResponse, bE as SandboxOutputPayload, bF as SandboxOutputRecord, bG as SandboxPhasePayload, bH as SandboxPhaseRecord, bI as SandboxReadyPayload, bJ as SandboxReadyRecord, bK as SandboxStartingPayload, bL as SandboxStartingRecord, bM as SdkAssistantRecord, bN as SdkCacheCreation, bO as SdkContentBlock, bP as SdkRateLimitRecord, bQ as SdkRecord, bR as SdkResultRecord, bS as SdkServerToolResultBlock, bT as SdkServerToolUseBlock, bU as SdkSystemRecord, bV as SdkTextBlock, bW as SdkThinkingBlock, bX as SdkToolResultBlock, bY as SdkToolUseBlock, bZ as SdkUserRecord, b_ as SendSessionMessageRequest, b$ as SentryAction, c0 as SentryAlertEvent, c1 as Session, c2 as Session1, c3 as SessionAgent, c4 as SessionArchived, c5 as SessionAttribution, c6 as SessionCancelledPayload, c7 as SessionCancelledRecord, c8 as SessionClosedPayload, c9 as SessionClosedRecord, ca as SessionConfig, cb as SessionCost, cc as SessionEnvironment, cd as SessionEventActor, ce as SessionExecution, cf as SessionExecutionResult, cg as SessionExecutionsListResponse, ch as SessionExitStatus, ci as SessionFrame, cj as SessionGit, ck as SessionGitCommit, cl as SessionGitFile, cm as SessionGitPr, cn as SessionGitRepo, co as SessionHandler, cp as SessionIdlePayload, cq as SessionIdleRecord, cr as SessionLifecycle, cs as SessionLifecycleStatus, ct as SessionMessage, cu as SessionMessageImage, cv as SessionMessageResponse, cw as SessionMessageStatus, cx as SessionParent, cy as SessionPrompting, cz as SessionRecord, cA as SessionRecordsListResponse, cB as SessionResponse, cC as SessionResumedPayload, cD as SessionResumedRecord, cE as SessionRetryingPayload, cF as SessionRetryingRecord, cG as SessionScheduledPayload, cH as SessionScheduledRecord, cI as SessionSource, cJ as SessionStartingPayload, cK as SessionStartingRecord, cL as SessionStopped, cM as SessionStreamFrame, cN as SessionSummary, cO as SessionTimestamps, cP as SessionTokens, cQ as SessionsListResponse, cR as SettingsRef, cS as SkillRef, cT as SlackChannelCreatedEvent, cU as SlackMessageEvent, cV as SnapshotFrame, cW as StreamFrame, cX as TokensInfo, cY as TurnCompletedPayload, cZ as TurnCompletedRecord, c_ as TurnFailedPayload, c$ as TurnFailedRecord, d0 as TurnStartedPayload, d1 as TurnStartedRecord, d2 as UnknownSessionRecord, d3 as UpdateSessionRequest, d4 as paths } from './types-DrPhhfOb.js';
+import { c as components } from './types-DjY1VcOe.js';
+export { A as AgentConfig, a as AgentIdentity, b as AttributionType, B as BudgetConfig, C as CheckRunAction, d as ClaudeAssistantEvent, e as ClaudeAssistantMessage, f as ClaudeConfig, g as ClaudeConversationResetEvent, h as ClaudeNativeEvent, i as ClaudeNativeSessionRecord, j as ClaudeNativeUsage, k as ClaudeRateLimitEvent, l as ClaudeRateLimitInfo, m as ClaudeResultEvent, n as ClaudeSessionRecord, o as ClaudeSystemEvent, p as ClaudeUserEvent, q as ClaudeUserMessage, r as CodexAgentMessage, s as CodexAgentMessageItem, t as CodexAppServerError, u as CodexAppServerEvent, v as CodexAppServerItem, w as CodexAppServerNotification, x as CodexAppServerSessionRecord, y as CodexCommandExecution, z as CodexCommandExecutionItem, D as CodexConfig, E as CodexContextCompaction, F as CodexEffortLevel, G as CodexErrorEvent, H as CodexErrorItem, I as CodexErrorParams, J as CodexEvent, K as CodexFileChange, L as CodexFileChangeItem, M as CodexFileUpdate, N as CodexItem, O as CodexItemCompleted, P as CodexItemCompletedEvent, Q as CodexItemParams, R as CodexItemStarted, S as CodexItemStartedEvent, T as CodexItemUpdatedEvent, U as CodexLocalImageInput, V as CodexMcpToolCall, W as CodexMcpToolCallAppContext, X as CodexMcpToolCallError, Y as CodexMcpToolCallItem, Z as CodexMcpToolCallResult, _ as CodexPlan, $ as CodexReasoning, a0 as CodexReasoningItem, a1 as CodexSessionRecord, a2 as CodexTextInput, a3 as CodexThread, a4 as CodexThreadStarted, a5 as CodexThreadStartedEvent, a6 as CodexThreadStartedParams, a7 as CodexThreadTokenUsage, a8 as CodexTodoListItem, a9 as CodexTokenUsageBreakdown, aa as CodexTokenUsageParams, ab as CodexTokenUsageUpdated, ac as CodexTurn, ad as CodexTurnCompleted, ae as CodexTurnCompletedEvent, af as CodexTurnError, ag as CodexTurnFailedEvent, ah as CodexTurnParams, ai as CodexTurnStarted, aj as CodexTurnStartedEvent, ak as CodexUsage, al as CodexUserInput, am as CodexUserMessage, an as CodexWebSearch, ao as CodexWebSearchItem, ap as ComputeConfig, aq as ComputeConfig1, ar as ConfigMetadata, as as CronTrigger, at as DeltaFrame, au as DoneFrame, av as Duration, aw as EffortLevel, ax as EllipsisGrant, ay as EllipsisPermissions, az as EnvironmentBaseBuild, aA as EnvironmentConfig, aB as EnvironmentHooks, aC as EnvironmentHooks1, aD as EnvironmentOutputPayload, aE as EnvironmentOutputRecord, aF as EnvironmentPhasePayload, aG as EnvironmentPhaseRecord, aH as EnvironmentReadyPayload, aI as EnvironmentReadyRecord, aJ as EnvironmentScript, aK as EnvironmentSource, aL as EnvironmentVariable, aM as ErrorFrame, aN as GithubAccountFilter, aO as GithubAccountSelector, aP as GithubAccountSnippet, aQ as GithubAccountType, aR as GithubCheckRunEvent, aS as GithubIssueEvent, aT as GithubPermissions, aU as GithubPullRequestEvent, aV as GithubPushEvent, aW as GithubReleaseEvent, aX as HandlerService, aY as HeartbeatFrame, aZ as InputContract, a_ as IssueAction, a$ as LegacyAssistantPayload, b0 as LegacyNativeUsage, b1 as LegacyResultPayload, b2 as Level, b3 as LifecycleSessionRecord, b4 as LinearIssueAction, b5 as LinearIssueEvent, b6 as McpRemoteServer, b7 as McpServerRef, b8 as McpStdioServer, b9 as MemorySize, ba as MessageDeliveredPayload, bb as MessageDeliveredRecord, bc as MessageReceivedPayload, bd as MessageReceivedRecord, be as MessageRequeuedPayload, bf as MessageRequeuedRecord, bg as OutputConfig, bh as PermissionsConfig, bi as PermissionsConfig1, bj as PlatformSessionRecord, bk as PromptBlockedReason, bl as PullRequestAction, bm as ReactCheckRun, bn as ReactIssue, bo as ReactLinearIssue, bp as ReactPullRequest, bq as ReactPush, br as ReactRelease, bs as ReactSentry, bt as ReactSlackChannel, bu as ReactTrigger, bv as RecordsAppendFrame, bw as ReleaseAction, bx as RepositoryFilter, by as RepositoryRef, bz as Review, bA as ReviewComment, bB as ReviewConfig, bC as ReviewConfigsListResponse, bD as ReviewPullRequest, bE as ReviewPullRequestAuthor, bF as ReviewReviewer, bG as ReviewSummary, bH as ReviewsListResponse, bI as SdkAssistantRecord, bJ as SdkCacheCreation, bK as SdkContentBlock, bL as SdkRateLimitRecord, bM as SdkRecord, bN as SdkResultRecord, bO as SdkServerToolResultBlock, bP as SdkServerToolUseBlock, bQ as SdkSystemRecord, bR as SdkTextBlock, bS as SdkThinkingBlock, bT as SdkToolResultBlock, bU as SdkToolUseBlock, bV as SdkUserRecord, bW as SendSessionMessageRequest, bX as SentryAction, bY as SentryAlertEvent, bZ as Session, b_ as Session1, b$ as SessionAgent, c0 as SessionArchived, c1 as SessionAttribution, c2 as SessionClosedPayload, c3 as SessionClosedRecord, c4 as SessionConfig, c5 as SessionConversation, c6 as SessionConversationConfig, c7 as SessionCost, c8 as SessionCost1, c9 as SessionEnvironment, ca as SessionEventActor, cb as SessionFrame, cc as SessionGit, cd as SessionGitCommit, ce as SessionGitFile, cf as SessionGitPr, cg as SessionGitRepo, ch as SessionHandler, ci as SessionMessage, cj as SessionMessageImage, ck as SessionMessageResponse, cl as SessionMessageStatus, cm as SessionOutput, cn as SessionParent, co as SessionPrompting, cp as SessionRecord, cq as SessionRecordsListResponse, cr as SessionResponse, cs as SessionSource, ct as SessionState, cu as SessionStopped, cv as SessionStreamFrame, cw as SessionSummary, cx as SessionTokens, cy as SessionTokens1, cz as SessionTurn, cA as SessionTurnResponse, cB as SessionTurnsListResponse, cC as SessionsListResponse, cD as SettingsRef, cE as SkillRef, cF as SlackChannelCreatedEvent, cG as SlackMessageEvent, cH as SnapshotFrame, cI as StreamFrame, cJ as TokensInfo, cK as TurnEndedPayload, cL as TurnEndedRecord, cM as TurnReason, cN as TurnStartedPayload, cO as TurnStartedRecord, cP as TurnStatus, cQ as UnknownSessionRecord, cR as UpdateSessionRequest, cS as paths } from './types-DjY1VcOe.js';
 
 /**
  * Frames on /v1/sessions/stream, /v1/agents/stream and /v1/vm-executions/{id}/stream. Ignore unknown frame types.
  */
 type CollectionStreamFrame = SessionListStreamMessage | AgentListStreamMessage | CollectionStreamHeartbeat | SandboxSnapshotFrame | SandboxUpdateFrame;
 /**
- * An agent session: one conversation with an agent, from trigger to
- * terminal state. Returned by `GET /v1/sessions/{id}` and carried by the
- * session stream's `session`/`snapshot` frames — REST and stream never
- * disagree about what a session looks like.
+ * An agent session: one conversation with an agent. Returned by
+ * `GET /v1/sessions/{id}` and carried by the session stream's
+ * `session`/`snapshot` frames; REST and stream never disagree about what a
+ * session looks like.
  */
 type Session = {
     /**
      * The agent the session was started from, or null for a raw session started with POST /v1/sessions.
      */
     agent: SessionAgent | null;
+    /**
+     * When and by whom the session was archived; null when unarchived. Archiving does not stop or close a session.
+     */
+    archived: SessionArchived | null;
     attribution: SessionAttribution;
     /**
      * The spend budget enforced for this session, in US dollars, after resolving defaults and ceilings.
@@ -29,12 +33,17 @@ type Session = {
      * Codex input and native options. Set exactly one of claude_code or codex.
      */
     codex: CodexConfig | null;
+    conversation: SessionConversation;
     cost: SessionCost;
+    /**
+     * When the session was created.
+     */
+    created_at: string;
     environment: SessionEnvironment;
     /**
      * The typed external event that started the session; null for direct and scheduled starts.
      */
-    event: (GithubPullRequestEvent | GithubIssueEvent | GithubPushEvent | LinearIssueEvent | SlackMessageEvent | SlackChannelCreatedEvent | SentryAlertEvent) | null;
+    event: (GithubPullRequestEvent | GithubIssueEvent | GithubPushEvent | GithubCheckRunEvent | GithubReleaseEvent | LinearIssueEvent | SlackMessageEvent | SlackChannelCreatedEvent | SentryAlertEvent) | null;
     /**
      * What the session did to git, one entry per repository in its workspace: the commit and branch it sits on, per-file line counts for its uncommitted changes, and the pull requests it opened. Null if nothing was ever captured.
      */
@@ -47,7 +56,6 @@ type Session = {
      * Unique identifier of the session.
      */
     id: string;
-    lifecycle: SessionLifecycle;
     /**
      * Caller-supplied metadata key-value pairs.
      */
@@ -55,9 +63,9 @@ type Session = {
         [k: string]: string;
     };
     /**
-     * The structured-output exit contract for this session.
+     * The session's structured output: the `json_schema` the agent must satisfy and, once a turn has submitted it, the `result`.
      */
-    output: OutputConfig | null;
+    output: SessionOutput | null;
     /**
      * The predecessor session this session continues; null when there is none.
      */
@@ -73,6 +81,14 @@ type Session = {
      */
     summary: SessionSummary | null;
     tokens: SessionTokens;
+    /**
+     * The turn in progress, or the latest one when none is running. Null until the session has a message. Wait on it: the message you sent is answered when the turn with your message's `turn_id` reaches a final status.
+     */
+    turn: SessionTurn | null;
+    /**
+     * When the session was last updated.
+     */
+    updated_at: string;
 } & ({
     claude_code: {
         [k: string]: unknown;
@@ -107,7 +123,14 @@ type SessionConfig = {
      * Codex input and native options. Set exactly one of claude_code or codex.
      */
     codex: CodexConfig | null;
+    conversation: SessionConversationConfig;
     environment: string | EnvironmentConfig;
+    /**
+     * Arbitrary string key/value metadata stored on every session.
+     */
+    metadata: {
+        [k: string]: string;
+    };
     output: OutputConfig | null;
     permissions: PermissionsConfig;
     skills: SkillRef[];
@@ -134,23 +157,44 @@ type GithubAccountFilter = {
     exclude: string[];
     include: string[] | boolean;
 } | boolean | string[];
-type IssueAction = 'opened' | 'closed' | 'commented';
+/**
+ * What a completed check run did. `failed` covers the conclusions that
+ * mean the check did not pass on its own merits (`failure`, `timed_out`); a
+ * cancelled, skipped, neutral or stale check is not a failure and never
+ * fires (see FAILED_CHECK_RUN_CONCLUSIONS).
+ */
+type CheckRunAction = 'failed';
 type RepositoryFilter = {
     exclude: string[];
     include: string[];
 } | string[];
+type IssueAction = 'opened' | 'closed' | 'commented';
 type LinearIssueAction = 'opened';
 type PullRequestAction = 'opened' | 'pushed' | 'merged' | 'closed' | 'review_submitted' | 'commented';
+/**
+ * What happened to a GitHub release. `published` is the one moment a
+ * release becomes visible: a release or prerelease published directly, or a
+ * draft published later. Edits, deletions, and unpublishes never fire.
+ */
+type ReleaseAction = 'published';
 type SentryAction = 'issue_alert' | 'metric_alert';
-type AttributionType = 'github_user' | 'linear_user' | 'slack_user' | 'api_key';
 type GithubAccountType = 'User' | 'Organization' | 'Bot' | 'Mannequin';
+type AttributionType = 'github_user' | 'linear_user' | 'slack_user' | 'api_key';
+/**
+ * Why direct prompting is refused. Absent when prompting is allowed.
+ */
+type PromptBlockedReason = 'mention_surface' | 'non_interactive' | 'harness_single_turn' | 'budget_exhausted' | 'closed';
+/**
+ * `open` while the session can take messages; `closed` is permanent.
+ */
+type SessionState = 'open' | 'closed';
 /**
  * How a session's environment was chosen. None (the field is nullable)
  * when the config carried an inline environment block and no resolution ran —
  * an inline environment is not a reference, so there is nothing to record.
  *
  * Not derivable from the row: `environment_id` says WHICH environment, not
- * how it was chosen, and is null for the built-in basic sandbox.
+ * how it was chosen, and is null for the built-in basic environment.
  */
 type EnvironmentSource = 'request' | 'agent' | 'repo_default' | 'account_default' | 'platform_default';
 /**
@@ -158,25 +202,17 @@ type EnvironmentSource = 'request' | 'agent' | 'repo_default' | 'account_default
  */
 type HandlerService = 'slack' | 'github' | 'linear' | 'sentry';
 /**
- * Whether the conversation is open or permanently closed. Open does not imply direct messages are permitted.
- */
-type ConversationState = 'open' | 'closed';
-/**
- * Why the last execution ended; completed also includes parking an open conversation.
+ * Where the session came from (e.g. react, web, api, cli, mention, cron).
  */
-type SessionExitStatus = 'completed' | 'budget_hit' | 'payment_required' | 'tool_call_failed' | 'lifecycle_hook_failed' | 'missing_repo_access' | 'missing_token_permissions' | 'missing_sandbox_variables' | 'blocked' | 'contact_email_required' | 'cancelled' | 'interrupted' | 'error' | 'stopped';
+type SessionSource = 'react' | 'code_review' | 'web' | 'api' | 'cli' | 'mention' | 'cron';
 /**
- * Why direct prompting is refused. Absent when prompting is allowed.
+ * Why a turn failed or was cancelled. Null on every other outcome.
  */
-type PromptBlockedReason = 'mention_surface' | 'ephemeral_trigger' | 'non_interactive' | 'harness_single_turn' | 'closed';
+type TurnReason = 'error' | 'tool_call_failed' | 'budget_hit' | 'payment_required' | 'blocked' | 'contact_email_required' | 'lifecycle_hook_failed' | 'missing_repo_access' | 'missing_token_permissions' | 'missing_environment_variables' | 'missing_github_integration' | 'agent_unavailable' | 'upstream_unavailable' | 'unsupported_configuration' | 'execution_disabled' | 'interrupted';
 /**
- * Canonical current activity. working means a turn is in progress; waiting means the worker is warm and awaiting input; idle means parked. A failed, stopped, or cancelled execution may leave an open conversation.
+ * Where the turn is.
  */
-type SessionLifecycleStatus = 'scheduled' | 'starting' | 'working' | 'waiting' | 'retrying' | 'idle' | 'closed' | 'failed' | 'stopped' | 'cancelled';
-/**
- * Where the session came from (e.g. react, web, api, cli, mention, cron).
- */
-type SessionSource = 'react' | 'web' | 'api' | 'cli' | 'mention' | 'cron';
+type TurnStatus = 'pending' | 'running' | 'completed' | 'failed' | 'stopped' | 'cancelled';
 /**
  * Which writer owns this agent. "github" agents are defined by a file in a repository and are changed by editing that file; "api" agents have no file and are changed through this API.
  */
@@ -187,7 +223,7 @@ type ConfigManagedBy = 'github' | 'api';
  * Rides on `Sandbox.cache_tier` and the sandbox_ready lifecycle record.
  */
 type SandboxCacheTier = 'exact' | 'incremental' | 'full';
-type SandboxSource = 'cli' | 'web_ui' | 'ingest_pull_request_job_run' | 'session' | 'image_refresh' | 'test' | 'script';
+type SandboxSource = 'session' | 'image_refresh' | 'environment_check' | 'test' | 'script';
 type SandboxStatus = 'scheduled' | 'building' | 'running' | 'released' | 'terminating' | 'terminated' | 'failed';
 type SandboxType = 'claude_code';
 interface SessionListStreamMessage {
@@ -203,7 +239,7 @@ interface SessionListStreamMessage {
 interface SessionAgent {
     config: AgentConfig;
     /**
-     * Identifier of the saved agent this session's snapshot was taken from. Null for a routing-file agent, a code-review stage agent, or the built-in mention agent, which have no saved agent behind them. Points at the agent as it exists now, which may have changed since.
+     * Identifier of the saved agent this session's snapshot was taken from. Null for a routing-file agent or the built-in mention agent, which have no saved agent behind them. Points at the agent as it exists now, which may have changed since.
      */
     id: string | null;
 }
@@ -225,9 +261,7 @@ interface AgentConfig {
  * config directory) — see `yaml_is_ellipsis_config`.
  *
  * `enabled` is agent behavior, not freeform metadata, so it stays inside
- * the config `sha` (only `metadata` is sha-excluded). Whether a session
- * accepts messages is a per-run choice (POST /v1/sessions `interactive`),
- * not a config one.
+ * the config `sha` (only `metadata` is sha-excluded).
  */
 interface AgentIdentity {
     description: string | null;
@@ -248,15 +282,24 @@ interface ConfigMetadata {
  * when it happens; this is what goes in).
  *
  * `json_schema` validates customer data sent as `input` to
- * `POST /v1/agents/{id}/sessions` and stored as `session.input`.
- * Invocations require input when a schema is declared. React agents
- * cannot declare schemas: the platform defines their event payloads.
+ * `POST /v1/agents/{id}/sessions` (the dashboard and the CLI start
+ * through the same door) and stored as `session.input`. An on-demand
+ * start requires input when a schema is declared. A trigger fires
+ * without it: a cron fire has no payload and a react fire carries the
+ * platform-shaped event, so an agent may declare a schema alongside
+ * either trigger and the schema governs only its on-demand starts.
  *
  * `message` is the initial-message template: exact `{{path}}` substitution
- * over the caller payload (or, on a react agent, over the surface's
- * published fields), no conditionals/loops/filters. Refs are validated at
- * deploy time against the governing field set (see AgentConfig's
- * `_check_input`).
+ * over the payload the session has (the caller payload on an on-demand
+ * start, the surface's published fields on a react fire, the empty
+ * object on a cron fire), no conditionals/loops/filters. Refs are
+ * validated at deploy time against every governing field set (see
+ * AgentConfig's `_check_input`): the caller schema's paths, the react
+ * surface's published fields, and both when the agent has a react trigger
+ * and a schema, so one template renders fully on either door (declare the
+ * surface's field names in the schema). Omit `message` to let each door
+ * render its default. An unresolved ref renders as the empty string (a
+ * cron fire, an optional field the payload omitted).
  */
 interface InputContract {
     json_schema: {
@@ -264,10 +307,26 @@ interface InputContract {
     } | null;
     message: string | null;
 }
+/**
+ * A saved agent's spend limits: the per-session cap plus its total spend
+ * over the trailing 1, 7, and 28 days.
+ */
 interface BudgetConfig {
+    /**
+     * The most the agent may spend over the last day, in US dollars.
+     */
     day: number | null;
+    /**
+     * The most the agent may spend over the last 28 days, in US dollars.
+     */
     month: number | null;
+    /**
+     * The most one session may spend, in US dollars.
+     */
     session: number | null;
+    /**
+     * The most the agent may spend over the last 7 days, in US dollars.
+     */
     week: number | null;
 }
 /**
@@ -277,20 +336,21 @@ interface ClaudeConfig {
     effort: EffortLevel | null;
     fallback_model: string | null;
     max_turns: number | null;
-    model: string | null;
     /**
-     * The initial user message, passed verbatim. Omit to start an interactive session idle.
+     * The model the session runs on: an alias or canonical id from the models table. Required.
+     */
+    model: string;
+    /**
+     * The initial user message, passed verbatim. Omit to start an interactive session with no turn, waiting for a message.
      */
     prompt: string | null;
     settings: SettingsRef | null;
 }
 /**
- * A config-declared Claude Code settings.json, resolved at run start and
- * passed to `claude --settings <path>`. That is the CLI settings tier — BELOW
- * Ellipsis's managed-settings.json floor — so it customizes behavior (model
- * permissions, includeCoAuthoredBy, statusLine, ...) but can never weaken a
- * security setting. Lets a team point the cloud agent at the same settings file
- * they already use with Claude Code locally instead of re-encoding it as YAML.
+ * A Claude Code settings.json read from a repository and applied to the
+ * session. It adds permission rules and other Claude Code settings; rules the
+ * platform sets stay in force. Supported models list `settings` in
+ * `/v1/account/models`.
  */
 interface SettingsRef {
     path: string;
@@ -303,30 +363,39 @@ interface RepositoryRef {
 }
 /**
  * Native options supported by the current Codex adapter.
- *
- * Options and capabilities expand only when their runtime behavior is tested.
- * Unknown options are rejected instead of silently ignored.
  */
 interface CodexConfig {
     /**
      * Reasoning effort for every turn. Omit to use the model default.
      */
     effort: CodexEffortLevel | null;
+    /**
+     * The model the session runs on: a Responses-capable id from the models table. Required.
+     */
     model: string;
     /**
-     * The initial user message, passed verbatim. Omit to start an interactive session idle.
+     * The initial user message, passed verbatim. Omit to start an interactive session with no turn, waiting for a message.
      */
     prompt: string | null;
 }
 /**
- * Everything about the environment (the sandbox) the agent runs in: which
+ * Conversation settings for a session, set on a saved agent or sent when starting a session or running an agent.
+ */
+interface SessionConversationConfig {
+    /**
+     * Whether the session stays open after its first turn. Defaults to true; false runs once and requires a prompt. Requires the model's interactive capability when true. Direct message acceptance is reported separately in conversation.prompting.
+     */
+    interactive: boolean;
+}
+/**
+ * Everything about the environment the agent runs in: which
  * `repositories` are cloned into it, which environment `variables` it gets,
  * its `compute` sizing, and lifecycle `hooks`.
  * What the agent may *do* from that environment is the top-level
  * `permissions:` block, not this one.
  *
  * Each `variables` entry names a variable to inject; with an inline `value` it
- * is hardcoded, without one it is resolved from the account's sandbox-secrets
+ * is hardcoded, without one it is resolved from the account's secrets
  * store. Only the named variables reach this agent; the rest of the account's
  * stored variables never do. This is how a config brings in the config and
  * credentials a custom CLI needs.
@@ -339,26 +408,24 @@ interface EnvironmentConfig {
     variables: EnvironmentVariable[];
 }
 /**
- * Sandbox compute sizing. Every field is optional; None inherits the
- * platform default (2 vCPU / 4096 MiB / 3600s — see DEFAULT_SANDBOX_* in
- * models/ellipsis/vms/vm_execution.py). A resolved value outside the platform
- * bounds fails validation loudly (a sync error on the config) rather than
- * being clamped silently.
+ * Environment compute sizing. Every field is optional; an omitted field
+ * inherits the platform default (2 vCPU / 4096 MiB / 3600s). A resolved value
+ * outside the platform bounds fails validation loudly (a sync error on the
+ * config) rather than being clamped silently.
  *
  * `memory` and `timeout` each accept a shorthand string ("8GB", "30m") or an
  * explicit units object ({gb: 8}, {minutes: 30}); the `memory_mib` /
  * `timeout_seconds` properties resolve either form to the canonical integer
- * the sandbox driver consumes.
+ * the environment is sized with.
  *
- * `timeout` is the max wall-clock the agent may run before its execution is
- * stopped, capped at 1h (MAX_SANDBOX_TIMEOUT_SECONDS — equal to the default, so
- * today the knob only shortens a session; the cap matches the 1-hour validity
- * of the sandbox's GitHub token). The worker's lease/visibility heartbeat
- * ceiling is derived from that cap, so a run at the max stays owned by its
- * worker for its whole life.
+ * `timeout` is the max wall-clock the agent may run in one environment before
+ * it is stopped, capped at 1h (equal to the default, so today the knob only
+ * shortens a session; the cap matches the 1-hour validity of the session's
+ * GitHub token).
  *
- * Compute currently uses a temporary flat one-cent amount per allocated
- * execution, subject to the account's existing free-compute exemptions.
+ * Compute currently uses a temporary flat one-cent amount each time an
+ * environment is started for a session, subject to the account's existing
+ * free-compute exemptions.
  */
 interface ComputeConfig {
     cpu: number | null;
@@ -387,8 +454,8 @@ interface Duration {
 /**
  * Environment lifecycle scripts, in order: build_base, after_checkout,
  * before_start. The first two produce reusable snapshots; before_start runs
- * before an agent starts or resumes its session. Scripts run as the sandbox
- * user in /sandbox. A nonzero exit fails the session.
+ * before an agent starts or resumes its session. Scripts run as the environment's
+ * user in the workspace directory `/sandbox`. A nonzero exit fails the session.
  *
  * Legacy post_start/post_clone scripts remain supported for existing configs;
  * both run after workspace preparation, before the agent starts or resumes.
@@ -396,11 +463,11 @@ interface Duration {
  */
 interface EnvironmentHooks {
     /**
-     * Prepare the requested source revision after Ellipsis checks out all repositories, before saving the prepared sandbox. Skipped when that prepared sandbox is reused.
+     * Prepare the requested source revision after Ellipsis checks out all repositories, before saving the prepared environment. Skipped when that prepared environment is reused.
      */
     after_checkout: EnvironmentScript | string | null;
     /**
-     * Run before the agent starts or resumes a session, after the sandbox is ready. This hook is not cached and adds to session startup time.
+     * Run before the agent starts or resumes a session, after the environment is ready. This hook is not cached and adds to session startup time.
      */
     before_start: EnvironmentScript | string | null;
     /**
@@ -417,11 +484,12 @@ interface EnvironmentHooks {
     post_start: string | null;
 }
 /**
- * An inline shell script run as the sandbox user, with /sandbox as cwd.
+ * An inline shell script run as the environment's user, with the workspace
+ * directory `/sandbox` as cwd.
  */
 interface EnvironmentScript {
     /**
-     * Shell script to run in /sandbox.
+     * Shell script to run in the workspace directory `/sandbox`.
      */
     run: string;
 }
@@ -430,30 +498,29 @@ interface EnvironmentScript {
  */
 interface EnvironmentBaseBuild {
     /**
-     * Exact files relative to /sandbox, including the repository name. Only these files are available during build_base and their contents and modes determine reuse. Omit to use all repositories and invalidate on any source change; [] means no repository files.
+     * Exact files relative to the workspace directory `/sandbox`, including the repository name. Only these files are available during build_base and their contents and modes determine reuse. Omit to use all repositories and invalidate on any source change; [] means no repository files.
      */
     inputs: string[] | null;
     /**
-     * Shell script to run in /sandbox.
+     * Shell script to run in the workspace directory `/sandbox`.
      */
     run: string;
 }
 /**
- * One built-in MCP server this agent opts into by name (`linear`/`slack`).
+ * One built-in MCP server this agent attaches by name (`linear`/`slack`).
  * A name reference over the connected built-in set — the platform manages the
- * server's transport and credentials. It only matters when the named
- * integration is set to `opt_in` inclusion; an integration in the default
- * `all_sessions` mode is added regardless. For a server the platform does not
- * provide, define it instead (`McpStdioServer` /
- * `McpRemoteServer`).
+ * server's transport and credentials. A session gets a built-in server only
+ * when its config names it here or the session started from that server's
+ * own surface. For a server the platform does not provide, define it instead
+ * (`McpStdioServer` / `McpRemoteServer`).
  */
 interface McpServerRef {
     name: string;
 }
 /**
  * A bring-your-own stdio MCP server: the harness spawns `command` inside
- * the sandbox and speaks JSON-RPC over its stdin/stdout. The command must be
- * runnable in the sandbox image — install its runtime via `hooks.build_base` /
+ * the environment and speaks JSON-RPC over its stdin/stdout. The command must
+ * be runnable in the environment image — install its runtime via `hooks.build_base` /
  * `hooks.after_checkout` if the managed environment lacks it.
  *
  * `env` values may embed `${NAME}` references, resolved at run time from the
@@ -470,7 +537,7 @@ interface McpStdioServer {
 }
 /**
  * A bring-your-own remote MCP server: the harness talks HTTP to `url`.
- * Nothing runs in the sandbox image. `headers` carry static auth (e.g.
+ * Nothing runs in the environment image. `headers` carry static auth (e.g.
  * `Authorization: Bearer ${TOKEN}`); values may embed `${NAME}` secret
  * references, resolved at run time from the account's secrets store.
  */
@@ -482,11 +549,11 @@ interface McpRemoteServer {
     url: string;
 }
 /**
- * One environment variable injected into the agent's sandbox.
+ * One environment variable injected into the session's environment.
  *
  * `value`, when set, is a literal injected as-is — use it for non-secret
  * config (LOG_LEVEL, an API base URL). When `value` is omitted the value is
- * resolved at run time from the account's sandbox-secrets store (dashboard
+ * resolved at run time from the account's secrets store (dashboard
  * / `PUT /v1/secrets`) by `name`, so a secret can be injected without
  * ever putting it in the config file. Either way the variable only reaches
  * agents that name it.
@@ -505,18 +572,18 @@ interface OutputConfig {
 }
 /**
  * What the agent is allowed to touch, per credential the platform mints
- * into its sandbox. Distinct from `environment:`, which is where the agent
- * runs; this is what it may do from there.
+ * into its session's environment. Distinct from `environment:`, which is
+ * where the agent runs; this is what it may do from there.
  *
- * `ellipsis` scopes the sandbox's Ellipsis API token
- * (`ELLIPSIS_API_TOKEN`, what the in-sandbox `agent` CLI authenticates
- * with). `true` / the string `all` (the default) grant the full sandbox
- * ceiling — everything a sandbox token can ever do. A map narrows it per
+ * `ellipsis` scopes the session's Ellipsis API token (`ELLIPSIS_API_TOKEN`,
+ * what the `ellipsis` CLI running inside the session authenticates with).
+ * `true` / the string `all` (the default) grant the full session token
+ * ceiling — everything a session token can ever do. A map narrows it per
  * resource (see `EllipsisPermissions`); the minted token carries
  * the intersection, so a config can only ever reduce access. `false` fails
  * validation — an agent with no API token cannot report its own progress.
  *
- * `github` scopes the sandbox's GitHub installation token (`GH_TOKEN`) —
+ * `github` scopes the session's GitHub installation token (`GH_TOKEN`) —
  * see `GithubPermissions`. GitHub enforces it at mint time.
  */
 interface PermissionsConfig {
@@ -527,16 +594,16 @@ interface PermissionsConfig {
  * `permissions.ellipsis` as a map: resource → level | grant | list of
  * grants. Levels are hierarchical (read < write < delete), so `write`
  * includes `read`. An unlisted resource is denied. The whole block is
- * intersected with the platform's sandbox ceiling at token mint — it can
- * narrow what a sandbox token may do, never exceed it.
+ * intersected with the platform's session token ceiling at token mint — it can
+ * narrow what a session token may do, never exceed it.
  */
 interface EllipsisPermissions {
     [k: string]: Level | EllipsisGrant | (Level | EllipsisGrant)[];
 }
 /**
  * One grant entry: a level, optionally narrowed to instances whose
- * natural key (a file's name, a memory's path, a secret's name, a config's
- * name, a session's id) matches any of the `match` globs.
+ * natural key (a file's name, a secret's name, a config's name, a session's
+ * id) matches any of the `match` globs.
  */
 interface EllipsisGrant {
     level: Level;
@@ -544,8 +611,8 @@ interface EllipsisGrant {
 }
 /**
  * The agent's GitHub access: the scope of the installation token minted for
- * its sandbox — the credential `git`, `gh`, and the GitHub MCP server
- * authenticate with.
+ * its session's environment — the credential `git` and `gh` authenticate
+ * with.
  *
  * By default the token carries the installation's full permissions on all of
  * the installation's repositories. `permissions` narrows what it may do:
@@ -556,7 +623,7 @@ interface EllipsisGrant {
  * the listed repos, by name (they must belong to the installation).
  *
  * Restriction is enforced by GitHub, not by Ellipsis: the token itself is
- * minted with the reduced scope, so nothing running in the sandbox can
+ * minted with the reduced scope, so nothing running in the environment can
  * exceed it.
  */
 interface GithubPermissions {
@@ -574,36 +641,86 @@ interface SkillRef {
     path: string;
     repository: RepositoryRef | null;
 }
+/**
+ * A schedule: `schedule` is a five-field cron expression in UTC.
+ *
+ * `enabled: false` pauses the trigger and keeps its definition: the schedule
+ * stops firing while the agent stays live for on-demand starts and open
+ * sessions keep taking follow-ups (`ellipsis.enabled: false` pauses the
+ * whole file instead). Re-enabling resumes at the next scheduled time; runs
+ * missed while paused are not made up.
+ */
 interface CronTrigger {
+    enabled: boolean;
     schedule: string;
     type: 'cron';
 }
+/**
+ * An event trigger: exactly one surface block names the events to match.
+ *
+ * `enabled: false` pauses the trigger and keeps its definition: events stop
+ * matching while the agent stays live for on-demand starts and open
+ * sessions keep taking follow-ups (`ellipsis.enabled: false` pauses the
+ * whole file instead).
+ */
 interface ReactTrigger {
+    check_run: ReactCheckRun | null;
+    enabled: boolean;
     issue: ReactIssue | null;
     linear_issue: ReactLinearIssue | null;
     pull_request: ReactPullRequest | null;
     push: ReactPush | null;
+    release: ReactRelease | null;
     sentry: ReactSentry | null;
     slack_channel: ReactSlackChannel | null;
     type: 'react';
 }
-interface ReactIssue {
+/**
+ * A CI/CD check completing on a commit — a `check_run` from GitHub
+ * Actions or any other app that reports checks. `names` narrows to the check
+ * runs whose name matches (exact, or a prefix ending in `*`); `branch` is the
+ * check suite's head branch. The `for:` audience is the commit's author (the
+ * pull request author when the check is attached to one), never the CI app
+ * that completed the check — a check run's sender is always a bot.
+ *
+ * Delivery needs the Ellipsis GitHub App's `checks` permission on the
+ * installation; without it GitHub sends no check events and the webhook
+ * handler refuses the ones it does see.
+ */
+interface ReactCheckRun {
+    branch: string[];
     for: GithubAccountSelector;
-    labels: string[];
-    on: IssueAction[];
+    names: string[];
+    on: CheckRunAction[];
     repositories: RepositoryFilter;
 }
 /**
  * A selector of GitHub accounts — the `for:` audience gate on react
- * surfaces and code review pipelines, classified on the stable entity author
- * (the pusher for `push`, the PR author for a review). `users` selects human
+ * surfaces, classified on the stable entity author (the pusher for `push`,
+ * the PR author for a pull request). `users` selects human
  * accounts, `bots` selects bot accounts; each is a `GithubAccountFilter`
  * (include minus exclude, with bare bool/list shorthand).
+ *
+ * `teams` narrows further to members of any of the listed GitHub teams of
+ * the installation's organization, by slug (`platform` for
+ * `@org/platform`). It applies on top of `users`: the author must pass the
+ * users filter AND belong to a listed team. A bot is never a team member,
+ * so a selector with `teams` never admits one. Membership is resolved live
+ * at match time (see `TriggerEventContext.is_author_team_member`), and the
+ * config sync refuses a team that does not exist when the file is
+ * accepted.
  */
 interface GithubAccountSelector {
     bots: GithubAccountFilter;
+    teams: string[];
     users: GithubAccountFilter;
 }
+interface ReactIssue {
+    for: GithubAccountSelector;
+    labels: string[];
+    on: IssueAction[];
+    repositories: RepositoryFilter;
+}
 interface ReactLinearIssue {
     for: GithubAccountSelector;
     on: LinearIssueAction[];
@@ -624,6 +741,21 @@ interface ReactPush {
     paths: string[];
     repositories: RepositoryFilter;
 }
+/**
+ * A GitHub release being published — a release or prerelease published
+ * directly, or a draft published later. `tag` narrows to the release tags
+ * that match (exact, or a prefix ending in `*`, so `v*`); `prerelease`
+ * selects prereleases or full releases, like `draft` on pull requests. The
+ * `for:` audience is the release's author, which for a release cut by CI is
+ * a bot and needs `bots` to opt in.
+ */
+interface ReactRelease {
+    for: GithubAccountSelector;
+    on: ReleaseAction[];
+    prerelease: boolean | null;
+    repositories: RepositoryFilter;
+    tag: string[];
+}
 interface ReactSentry {
     on: SentryAction[];
     projects: string[];
@@ -631,21 +763,17 @@ interface ReactSentry {
 interface ReactSlackChannel {
 }
 /**
- * The principal this session is attributed to.
+ * When the session was archived and the GitHub user who archived it.
  */
-interface SessionAttribution {
-    /**
-     * Identifier of the principal the session is attributed to.
-     */
-    id: string | null;
+interface SessionArchived {
     /**
-     * Kind of principal the session is attributed to (e.g. a GitHub user or an API key).
+     * When the session was archived.
      */
-    type: AttributionType | null;
+    at: string;
     /**
-     * The GitHub user the session is attributed to, resolved at read time. Null when the attribution is not a GitHub user.
+     * The GitHub user who archived the session; null if unknown or unavailable.
      */
-    user: GithubAccountSnippet | null;
+    by: GithubAccountSnippet | null;
 }
 /**
  * Sometimes the GitHub API returns a user of github (can include bots)
@@ -658,14 +786,56 @@ interface GithubAccountSnippet {
     avatar_url: string;
     id: number;
     login: string;
+    name: string | null;
     type: GithubAccountType;
 }
 /**
- * What the session cost, in millicents, broken down by leg and carrying its own total.
+ * The principal this session is attributed to.
+ */
+interface SessionAttribution {
+    /**
+     * Identifier of the principal the session is attributed to.
+     */
+    id: string | null;
+    /**
+     * Kind of principal the session is attributed to (e.g. a GitHub user or an API key).
+     */
+    type: AttributionType | null;
+    /**
+     * The GitHub user the session is attributed to, resolved at read time. Null when the attribution is not a GitHub user.
+     */
+    user: GithubAccountSnippet | null;
+}
+/**
+ * Whether the session can take more messages, and whether an agent is warm to answer one.
+ */
+interface SessionConversation {
+    /**
+     * Whether the session stays open after its first turn.
+     */
+    interactive: boolean;
+    prompting: SessionPrompting;
+    state: SessionState;
+    /**
+     * Whether an agent is ready to answer the next message right away. When false, the next message first prepares an environment, which takes longer. A hint only; clients need no logic on it.
+     */
+    warm: boolean;
+}
+/**
+ * The session's policy for direct messages. Caller authorization and message validation are checked separately.
+ */
+interface SessionPrompting {
+    blocked_reason: PromptBlockedReason | null;
+    detail: string | null;
+    enabled: boolean;
+    surface_name: string | null;
+}
+/**
+ * What the session has cost so far, in millicents, broken down by leg and carrying its own total.
  */
 interface SessionCost {
     /**
-     * Sandbox CPU spend in millicents.
+     * CPU spend in millicents.
      */
     cpu: number;
     /**
@@ -677,7 +847,7 @@ interface SessionCost {
      */
     llm: number;
     /**
-     * Sandbox memory spend in millicents.
+     * Memory spend in millicents.
      */
     memory: number;
     /**
@@ -692,7 +862,7 @@ interface SessionEnvironment {
     compute: ComputeConfig1;
     hooks: EnvironmentHooks1;
     /**
-     * Identifier of the saved environment the session's config resolved. Null for an inline environment block or the built-in basic sandbox.
+     * Identifier of the saved environment the session's config resolved. Null for an inline environment block or the built-in basic environment.
      */
     id: string | null;
     mcp_servers: (string | McpServerRef | McpStdioServer | McpRemoteServer)[];
@@ -704,26 +874,24 @@ interface SessionEnvironment {
     variables: EnvironmentVariable[];
 }
 /**
- * Sandbox compute sizing. Every field is optional; None inherits the
- * platform default (2 vCPU / 4096 MiB / 3600s — see DEFAULT_SANDBOX_* in
- * models/ellipsis/vms/vm_execution.py). A resolved value outside the platform
- * bounds fails validation loudly (a sync error on the config) rather than
- * being clamped silently.
+ * Environment compute sizing. Every field is optional; an omitted field
+ * inherits the platform default (2 vCPU / 4096 MiB / 3600s). A resolved value
+ * outside the platform bounds fails validation loudly (a sync error on the
+ * config) rather than being clamped silently.
  *
  * `memory` and `timeout` each accept a shorthand string ("8GB", "30m") or an
  * explicit units object ({gb: 8}, {minutes: 30}); the `memory_mib` /
  * `timeout_seconds` properties resolve either form to the canonical integer
- * the sandbox driver consumes.
+ * the environment is sized with.
  *
- * `timeout` is the max wall-clock the agent may run before its execution is
- * stopped, capped at 1h (MAX_SANDBOX_TIMEOUT_SECONDS — equal to the default, so
- * today the knob only shortens a session; the cap matches the 1-hour validity
- * of the sandbox's GitHub token). The worker's lease/visibility heartbeat
- * ceiling is derived from that cap, so a run at the max stays owned by its
- * worker for its whole life.
+ * `timeout` is the max wall-clock the agent may run in one environment before
+ * it is stopped, capped at 1h (equal to the default, so today the knob only
+ * shortens a session; the cap matches the 1-hour validity of the session's
+ * GitHub token).
  *
- * Compute currently uses a temporary flat one-cent amount per allocated
- * execution, subject to the account's existing free-compute exemptions.
+ * Compute currently uses a temporary flat one-cent amount each time an
+ * environment is started for a session, subject to the account's existing
+ * free-compute exemptions.
  */
 interface ComputeConfig1 {
     cpu: number | null;
@@ -733,8 +901,8 @@ interface ComputeConfig1 {
 /**
  * Environment lifecycle scripts, in order: build_base, after_checkout,
  * before_start. The first two produce reusable snapshots; before_start runs
- * before an agent starts or resumes its session. Scripts run as the sandbox
- * user in /sandbox. A nonzero exit fails the session.
+ * before an agent starts or resumes its session. Scripts run as the environment's
+ * user in the workspace directory `/sandbox`. A nonzero exit fails the session.
  *
  * Legacy post_start/post_clone scripts remain supported for existing configs;
  * both run after workspace preparation, before the agent starts or resumes.
@@ -742,11 +910,11 @@ interface ComputeConfig1 {
  */
 interface EnvironmentHooks1 {
     /**
-     * Prepare the requested source revision after Ellipsis checks out all repositories, before saving the prepared sandbox. Skipped when that prepared sandbox is reused.
+     * Prepare the requested source revision after Ellipsis checks out all repositories, before saving the prepared environment. Skipped when that prepared environment is reused.
      */
     after_checkout: EnvironmentScript | string | null;
     /**
-     * Run before the agent starts or resumes a session, after the sandbox is ready. This hook is not cached and adds to session startup time.
+     * Run before the agent starts or resumes a session, after the environment is ready. This hook is not cached and adds to session startup time.
      */
     before_start: EnvironmentScript | string | null;
     /**
@@ -798,8 +966,30 @@ interface GithubPushEvent {
     type: 'github.push';
     url: string;
 }
+interface GithubCheckRunEvent {
+    action: CheckRunAction;
+    actor: SessionEventActor | null;
+    branch: string | null;
+    conclusion: string | null;
+    head_sha: string;
+    name: string;
+    pull_request_number: number | null;
+    repository: string;
+    type: 'github.check_run';
+    url: string;
+}
+interface GithubReleaseEvent {
+    action: ReleaseAction;
+    actor: SessionEventActor | null;
+    name: string | null;
+    prerelease: boolean;
+    repository: string;
+    tag: string;
+    type: 'github.release';
+    url: string;
+}
 interface LinearIssueEvent {
-    action: LinearIssueAction | 'commented';
+    action: LinearIssueAction | ('commented' | 'delegated');
     actor: SessionEventActor | null;
     identifier: string | null;
     number: number;
@@ -841,8 +1031,8 @@ interface SessionGit {
     repos: SessionGitRepo[];
 }
 /**
- * One checkout in the session's sandbox and everything the session did to
- * it, split by whether it survived the sandbox.
+ * One checkout in the session's environment and everything the session did
+ * to it, split by whether it survived the environment.
  */
 interface SessionGitRepo {
     commits: SessionGitCommit[];
@@ -856,7 +1046,7 @@ interface SessionGitRepo {
 }
 /**
  * One commit the session created in this repo (everything past the
- * provisioning checkout's sha), captured from the sandbox rather than the
+ * provisioning checkout's sha), captured from the environment rather than the
  * transcript so it stays correct through amends, rebases, and commits made by
  * scripts. The repo is the parent object, so it is not repeated here.
  */
@@ -908,135 +1098,169 @@ interface SessionHandler {
     sha: string;
 }
 /**
- * The session's activity, conversation state, messaging policy, outcomes, and timestamps.
+ * Structured output on the wire: the contract and, when a turn has
+ * submitted one, the payload. `result` is None while the session runs and
+ * when no turn submitted anything; it is the agent's own JSON, in the
+ * shape of `json_schema`.
  */
-interface SessionLifecycle {
+interface SessionOutput {
     /**
-     * When and by whom the session was archived; null when unarchived. Archiving does not stop or close a session.
+     * JSON Schema the agent's result must satisfy.
      */
-    archived: SessionArchived | null;
-    conversation: ConversationState;
+    json_schema: {
+        [k: string]: unknown;
+    };
     /**
-     * Explanation of the current status, when applicable.
+     * The payload the agent submitted, or null until a turn submits one.
      */
-    detail: string | null;
+    result: {
+        [k: string]: unknown;
+    } | null;
+}
+/**
+ * The predecessor session this session continues.
+ */
+interface SessionParent {
     /**
-     * Whether the session stays open after its first turn.
+     * Identifier of the predecessor session this session continues, if any.
      */
-    interactive: boolean;
+    session_id: string | null;
+}
+/**
+ * What the session may touch, per minted credential.
+ */
+interface PermissionsConfig1 {
+    ellipsis: (true | 'all') | EllipsisPermissions;
+    github: GithubPermissions;
+}
+/**
+ * A live one-line summary of what the session is doing, refreshed
+ * every few steps while it runs.
+ */
+interface SessionSummary {
     /**
-     * The last finished execution's outcome, retained across resumes; null until an outcome has been recorded.
+     * When this summary line was generated. Null on summaries written before generation time was tracked.
      */
-    last_execution_result: SessionExecutionResult | null;
-    prompting: SessionPrompting;
-    status: SessionLifecycleStatus;
+    created_at: string | null;
     /**
-     * When and by whom a stop was requested; null when no stop is pending for this execution.
+     * One-line description of what the session is doing.
      */
-    stopped: SessionStopped | null;
-    timestamps: SessionTimestamps;
+    description: string;
 }
 /**
- * When the session was archived and the GitHub user who archived it.
+ * The tokens the session spent and the model they went to. `total` includes the prompt-cache lanes.
  */
-interface SessionArchived {
+interface SessionTokens {
     /**
-     * When the session was archived.
+     * Tokens written to the prompt cache.
      */
-    at: string;
+    cache_creation: number;
     /**
-     * The GitHub user who archived the session; null if unknown or unavailable.
+     * Tokens read from the prompt cache.
      */
-    by: GithubAccountSnippet | null;
-}
-/**
- * Outcome of the last finished execution, retained across subsequent resumes.
- *
- * An execution spans a start or resume through parking or termination, and may
- * contain several turns. Admission failures also produce a result, even when
- * provisioning never starts.
- */
-interface SessionExecutionResult {
-    completion_reason: SessionExitStatus;
+    cache_read: number;
     /**
-     * Human-readable explanation of that outcome.
+     * Input tokens used.
      */
-    detail: string | null;
+    input: number;
+    /**
+     * The model the token counts are attributed to.
+     */
+    model: string;
+    /**
+     * Output tokens used.
+     */
+    output: number;
+    /**
+     * Total tokens consumed, INCLUDING the prompt-cache reads and writes — the same basis the token cost is priced on.
+     */
+    total: number;
 }
 /**
- * The session's policy for direct messages. Caller authorization and message validation are checked separately.
+ * One message and the agent's answer to it. A turn is `pending` from the
+ * moment its message is received until the agent starts on it, `running`
+ * while the agent works, then `completed`, `failed`, `stopped`, or
+ * `cancelled`.
  */
-interface SessionPrompting {
-    blocked_reason: PromptBlockedReason | null;
+interface SessionTurn {
+    cost: SessionCost1;
+    /**
+     * When the turn's message was received.
+     */
+    created_at: string;
+    /**
+     * A human-readable explanation of a failed, stopped, or cancelled turn.
+     */
     detail: string | null;
-    enabled: boolean;
-    surface_name: string | null;
-}
-/**
- * When a stop was requested and the GitHub user who requested it.
- */
-interface SessionStopped {
     /**
-     * When a stop was requested.
+     * When the turn reached its final status.
      */
-    at: string;
+    ended_at: string | null;
     /**
-     * The GitHub user who stopped the session, resolved at read time. Null if the user is unknown or unavailable.
+     * Unique identifier of the turn.
      */
-    by: GithubAccountSnippet | null;
-}
-interface SessionTimestamps {
+    id: string;
     /**
-     * When the session was created.
+     * Position in the session, starting at 0.
      */
-    created_at: string;
+    index: number;
     /**
-     * When the session last showed agent activity.
+     * Why the turn failed or was cancelled; null on every other status.
      */
-    last_activity_at: string | null;
+    reason: TurnReason | null;
     /**
-     * When the session last received a message.
+     * When the agent started on the message.
      */
-    last_message_at: string | null;
+    started_at: string | null;
+    status: TurnStatus;
     /**
-     * When the session was last updated.
+     * When and by whom a stop was requested; null when none was.
      */
-    updated_at: string;
+    stopped: SessionStopped | null;
+    tokens: SessionTokens1;
 }
 /**
- * The predecessor session this session continues.
+ * What the turn cost so far, in millicents, broken down by leg.
  */
-interface SessionParent {
+interface SessionCost1 {
     /**
-     * Identifier of the predecessor session this session continues, if any.
+     * CPU spend in millicents.
      */
-    session_id: string | null;
-}
-/**
- * What the session may touch, per minted credential.
- */
-interface PermissionsConfig1 {
-    ellipsis: (true | 'all') | EllipsisPermissions;
-    github: GithubPermissions;
+    cpu: number;
+    /**
+     * Platform fee in millicents.
+     */
+    fee: number;
+    /**
+     * LLM spend in millicents.
+     */
+    llm: number;
+    /**
+     * Memory spend in millicents.
+     */
+    memory: number;
+    /**
+     * The grand total in millicents: llm + cpu + memory + fee.
+     */
+    total: number;
 }
 /**
- * A live one-line summary of what the session is working on, refreshed
- * every few steps while it runs.
+ * When a stop was requested and the GitHub user who requested it.
  */
-interface SessionSummary {
+interface SessionStopped {
     /**
-     * When this summary line was generated. Null on summaries written before generation time was tracked.
+     * When a stop was requested.
      */
-    created_at: string | null;
+    at: string;
     /**
-     * One-line description of what the session is working on.
+     * The GitHub user who stopped the session, resolved at read time. Null if the user is unknown or unavailable.
      */
-    description: string;
+    by: GithubAccountSnippet | null;
 }
 /**
- * The tokens the session spent and the model they went to. `total` includes the prompt-cache lanes.
+ * The tokens the turn spent and the model they went to.
  */
-interface SessionTokens {
+interface SessionTokens1 {
     /**
      * Tokens written to the prompt cache.
      */
@@ -1138,7 +1362,7 @@ interface AgentConfig1 {
 /**
  * Identifies the file a GitHub-sourced agent is synced from.
  *
- * Keyed on the repository ID (not owner/name) so repository and org renames
+ * Identified by the repository ID (not owner/name) so repository and org renames
  * don't orphan the config; resolve display names from gh_repositories at
  * read time.
  */
@@ -1186,8 +1410,8 @@ interface VMExecutionResponse {
 /**
  * Environment lifecycle scripts, in order: build_base, after_checkout,
  * before_start. The first two produce reusable snapshots; before_start runs
- * before an agent starts or resumes its session. Scripts run as the sandbox
- * user in /sandbox. A nonzero exit fails the session.
+ * before an agent starts or resumes its session. Scripts run as the environment's
+ * user in the workspace directory `/sandbox`. A nonzero exit fails the session.
  *
  * Legacy post_start/post_clone scripts remain supported for existing configs;
  * both run after workspace preparation, before the agent starts or resumes.
@@ -1195,11 +1419,11 @@ interface VMExecutionResponse {
  */
 interface EnvironmentHooks2 {
     /**
-     * Prepare the requested source revision after Ellipsis checks out all repositories, before saving the prepared sandbox. Skipped when that prepared sandbox is reused.
+     * Prepare the requested source revision after Ellipsis checks out all repositories, before saving the prepared environment. Skipped when that prepared environment is reused.
      */
     after_checkout: EnvironmentScript | string | null;
     /**
-     * Run before the agent starts or resumes a session, after the sandbox is ready. This hook is not cached and adds to session startup time.
+     * Run before the agent starts or resumes a session, after the environment is ready. This hook is not cached and adds to session startup time.
      */
     before_start: EnvironmentScript | string | null;
     /**
@@ -1253,7 +1477,7 @@ declare class Page<ItemT, ResponseT extends CursorResponse> implements AsyncIter
 }
 
 type S$1 = components['schemas'];
-declare const TERMINAL_STATUSES: ReadonlySet<string>;
+declare function isTurnFinal(status: string): boolean;
 interface SessionsApi {
     get(sessionId: string): Promise<S$1['SessionResponse']>;
     stop(sessionId: string): Promise<S$1['SessionResponse']>;
@@ -1262,26 +1486,25 @@ interface SessionsApi {
         images?: S$1['ImageAttachment'][];
         idempotency_key?: string | null;
     }): Promise<S$1['SessionMessageResponse']>;
-    records(sessionId: string, options?: {
-        cursor?: string;
-        limit?: number;
-    }): Promise<unknown>;
+    turns: {
+        get(sessionId: string, turnId: string): Promise<S$1['SessionTurnResponse']>;
+    };
 }
-declare function isSettled(session: S$1['Session']): boolean;
 declare class SessionHandle {
     private readonly sessions;
     readonly id: string;
     session: S$1['Session'];
+    turnId: string | null;
     constructor(sessions: SessionsApi, session: S$1['Session']);
     refresh(): Promise<S$1['Session']>;
     wait(options?: {
         timeoutMs?: number;
         pollIntervalMs?: number;
-    }): Promise<S$1['Session']>;
+    }): Promise<S$1['SessionTurn'] | null>;
     send(message: string, options?: {
         images?: S$1['ImageAttachment'][];
         idempotencyKey?: string;
-    }): Promise<S$1['SessionMessage']>;
+    }): Promise<S$1['SessionMessageResponse']>;
     stop(): Promise<S$1['Session']>;
 }
 
@@ -1321,7 +1544,7 @@ declare class EllipsisAccountApiKeys {
      * Required permissions: write:tokens.
      * API key: Requires a CLI user token belonging to an account administrator.
      * CLI user token: Requires an account administrator.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     create(options: {
@@ -1333,7 +1556,7 @@ declare class EllipsisAccountApiKeys {
      * Required permissions: read:tokens.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     list(): Promise<S['ListApiKeysResponse']>;
@@ -1345,7 +1568,7 @@ declare class EllipsisAccountApiKeys {
      * Required permissions: delete:tokens.
      * API key: Requires a CLI user token belonging to an account administrator.
      * CLI user token: Requires an account administrator.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     revoke(api_key_id: string): Promise<S['TokenRevokedResponse']>;
@@ -1364,7 +1587,7 @@ declare class EllipsisAccountBillingAutoRecharge {
      * Required permissions: read:account.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     get(): Promise<S['AutoRechargeSettings']>;
@@ -1373,7 +1596,7 @@ declare class EllipsisAccountBillingAutoRecharge {
      *
      * Set your automatic credit recharge policy.
      *
-     * Requires a human account administrator; API keys and sandbox tokens
+     * Requires a human account administrator; API keys and session tokens
      * cannot change this policy. Supply enabled explicitly. Saving amounts
      * with enabled=false keeps recharge off; enabling requires a saved card.
      * A recharge buys amount_cents of credit and charges the platform fee
@@ -1382,7 +1605,7 @@ declare class EllipsisAccountBillingAutoRecharge {
      * Required permissions: write:account.
      * API key: Requires a CLI user token belonging to an account administrator.
      * CLI user token: Requires an account administrator.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     set(options: {
@@ -1407,7 +1630,7 @@ declare class EllipsisAccountBilling {
      * Required permissions: write:account.
      * API key: Requires a CLI user token belonging to an account administrator.
      * CLI user token: Requires an account administrator.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     cardSetup(): Promise<S['BillingCheckout']>;
@@ -1424,7 +1647,7 @@ declare class EllipsisAccountBilling {
      * Required permissions: write:account.
      * API key: Requires a CLI user token belonging to an account administrator.
      * CLI user token: Requires an account administrator.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     checkout(options: {
@@ -1441,7 +1664,7 @@ declare class EllipsisAccountBilling {
      * Required permissions: write:account.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     claimSignupCredit(): Promise<S['BillingStatus']>;
@@ -1453,7 +1676,7 @@ declare class EllipsisAccountBilling {
      * Required permissions: read:account.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     feeSchedule(): Promise<S['FeeScheduleResponse']>;
@@ -1468,7 +1691,7 @@ declare class EllipsisAccountBilling {
      * Required permissions: read:account.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     grants(): Promise<S['CreditGrantsResponse']>;
@@ -1483,7 +1706,7 @@ declare class EllipsisAccountBilling {
      * Required permissions: read:account.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     purchase(checkout_id: string): Promise<S['CreditPurchaseReceipt']>;
@@ -1498,7 +1721,7 @@ declare class EllipsisAccountBilling {
      * Required permissions: read:account.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     purchaseOptions(): Promise<S['CreditPurchaseOptions']>;
@@ -1508,13 +1731,13 @@ declare class EllipsisAccountBilling {
      * Explain whether your account can start sessions.
      *
      * Uses the same account gate as session admission, including credit,
-     * contact email, and personal Claude subscription eligibility. Scoped
+     * contact email, and personal subscription eligibility. Scoped
      * spend limits are reported separately by /v1/account/budget.
      *
      * Required permissions: read:account.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     status(): Promise<S['BillingStatus']>;
@@ -1528,18 +1751,16 @@ declare class EllipsisAccountModels {
      * List selectable agent models.
      *
      * Grouped by manufacturer and model family, newest versions first
-     * within each family, with the organization's default model
-     * flagged (`is_default_agent_model`: the `default_model` of
-     * `GET /v1/account/settings`).
+     * within each family.
      *
      * Reads the same registry as the dashboard's rate table, so a
      * client's model picker can never drift from what's offered. The
-     * selectable set is global; only the flag is account-scoped.
+     * selectable set is global.
      *
      * Required permissions: read:templates.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     list(): Promise<S['ModelsListResponse']>;
@@ -1557,7 +1778,7 @@ declare class EllipsisAccountNotifications {
      * Required permissions: write:account.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     testEmail(options: {
@@ -1575,7 +1796,7 @@ declare class EllipsisAccountOnboarding {
      * Required permissions: read:account.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     get(): Promise<S['AccountOnboardingResponse']>;
@@ -1588,122 +1809,23 @@ declare class EllipsisAccountOnboarding {
      * Saving use cases requires a valid organization work email and at
      * least one choice. When Other is the only choice, describe it.
      * Personal accounts save a null work email. This does not change the
-     * billing contact email. Sandbox credentials cannot update answers.
+     * billing contact email. Session tokens cannot update answers.
      * Supplying an organization work email requires a human user and sends
      * a Slack Connect invitation. Slack failures do not undo saved answers.
      *
      * Required permissions: write:account.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     update(options?: {
+        finished?: boolean;
         other_use_case?: string | null;
         use_cases?: (S['AccountOnboardingUseCase'])[];
         work_email?: string | null;
     }): Promise<S['AccountOnboardingResponse']>;
 }
-declare class EllipsisAccountProvidersAnthropic {
-    private readonly transport;
-    constructor(transport: Transport);
-    /**
-     * Delete Anthropic Config
-     *
-     * Required permissions: delete:account.
-     * API key: Supported.
-     * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
-     * Higher permission levels include lower levels: read < write < delete.
-     */
-    delete(): Promise<void>;
-    /**
-     * Get Anthropic Config
-     *
-     * Required permissions: read:account.
-     * API key: Supported.
-     * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
-     * Higher permission levels include lower levels: read < write < delete.
-     */
-    get(): Promise<S['AnthropicConfigResponse']>;
-    /**
-     * Put Anthropic Config
-     *
-     * Required permissions: write:account.
-     * API key: Supported.
-     * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
-     * Higher permission levels include lower levels: read < write < delete.
-     */
-    set(options: {
-        api_key: string;
-    }): Promise<S['AnthropicConfigResponse']>;
-    /**
-     * Validate Anthropic Config
-     *
-     * Required permissions: write:account.
-     * API key: Supported.
-     * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
-     * Higher permission levels include lower levels: read < write < delete.
-     */
-    validate(): Promise<S['ValidateAnthropicConfigResponse']>;
-}
-declare class EllipsisAccountProvidersBedrock {
-    private readonly transport;
-    constructor(transport: Transport);
-    /**
-     * Delete Bedrock Config
-     *
-     * Required permissions: delete:account.
-     * API key: Supported.
-     * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
-     * Higher permission levels include lower levels: read < write < delete.
-     */
-    delete(): Promise<void>;
-    /**
-     * Get Bedrock Config
-     *
-     * Required permissions: read:account.
-     * API key: Supported.
-     * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
-     * Higher permission levels include lower levels: read < write < delete.
-     */
-    get(): Promise<S['BedrockConfigResponse']>;
-    /**
-     * Put Bedrock Config
-     *
-     * Required permissions: write:account.
-     * API key: Supported.
-     * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
-     * Higher permission levels include lower levels: read < write < delete.
-     */
-    set(options: {
-        model_map: Record<string, string>;
-        region: string;
-        role_arn: string;
-    }): Promise<S['BedrockConfigResponse']>;
-    /**
-     * Validate Bedrock Config
-     *
-     * Required permissions: write:account.
-     * API key: Supported.
-     * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
-     * Higher permission levels include lower levels: read < write < delete.
-     */
-    validate(): Promise<S['ValidateBedrockConfigResponse']>;
-}
-declare class EllipsisAccountProviders {
-    private readonly transport;
-    readonly anthropic: EllipsisAccountProvidersAnthropic;
-    readonly bedrock: EllipsisAccountProvidersBedrock;
-    constructor(transport: Transport);
-}
 declare class EllipsisAccountSettings {
     private readonly transport;
     constructor(transport: Transport);
@@ -1712,14 +1834,14 @@ declare class EllipsisAccountSettings {
      *
      * Get the organization settings.
      *
-     * Session model and budget defaults, code review and mention behavior,
-     * analytics, retention, and notification contacts. PATCH replaces
-     * supplied sections; PUT preserves its model-and-budget-only behavior.
+     * Session budget ceiling, mention behavior, analytics,
+     * retention, and notification contacts. PATCH replaces
+     * supplied sections; PUT sets the budget ceiling only.
      *
      * Required permissions: read:defaults.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     get(): Promise<S['AccountSettings']>;
@@ -1728,43 +1850,37 @@ declare class EllipsisAccountSettings {
      *
      * Set the organization settings.
      *
-     * Replaces both: `default_model` accepts an alias or canonical id
-     * and is stored canonical, and cannot be cleared (it is the only
-     * default a session's model resolves against);
      * `budget_ceiling.session` is in US dollars, at most the platform
      * ceiling, and null clears it.
-     * Refused for sandbox tokens (potentially prompt-injected code must
-     * not repoint the organization's defaults).
+     * Refused for session tokens (potentially prompt-injected code must
+     * not raise the organization's ceiling).
      *
      * Required permissions: write:defaults.
      * API key: Requires a CLI user token belonging to an account administrator.
      * CLI user token: Requires an account administrator.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
-    set(options: {
+    set(options?: {
         budget_ceiling?: S['BudgetCeiling'];
-        default_model: string;
     }): Promise<S['OrganizationSettings']>;
     /**
      * Patch Account Settings
      *
      * Replace supplied settings sections without changing omitted sections.
      *
-     * Changes to model or budget defaults require a GitHub administrator.
+     * Changes to the budget ceiling require a GitHub administrator.
      *
      * Required permissions: write:defaults.
-     * API key: Cannot set budget_ceiling, default_model to a non-null value; those changes require a CLI user token belonging to an account administrator.
-     * CLI user token: Requires an account administrator when setting budget_ceiling, default_model to a non-null value.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * API key: Cannot set budget_ceiling to a non-null value; those changes require a CLI user token belonging to an account administrator.
+     * CLI user token: Requires an account administrator when setting budget_ceiling to a non-null value.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     update(options?: {
-        analytics?: S['AnalyticsSettings'] | null;
+        analytics?: S['AnalyticsSettings-Input'] | null;
         budget_ceiling?: S['BudgetCeiling'] | null;
-        code_review?: S['CodeReviewSettings'] | null;
-        data_retention?: S['DataRetentionSettings'] | null;
-        default_model?: string | null;
+        data_retention?: S['DataRetentionSettings-Input'] | null;
         notifications?: S['NotificationSettings'] | null;
     }): Promise<S['AccountSettings']>;
 }
@@ -1775,7 +1891,6 @@ declare class EllipsisAccount {
     readonly models: EllipsisAccountModels;
     readonly notifications: EllipsisAccountNotifications;
     readonly onboarding: EllipsisAccountOnboarding;
-    readonly providers: EllipsisAccountProviders;
     readonly settings: EllipsisAccountSettings;
     constructor(transport: Transport);
     /**
@@ -1788,7 +1903,7 @@ declare class EllipsisAccount {
      * Required permissions: read:account.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     activity(): Promise<S['AccountActivity']>;
@@ -1798,7 +1913,7 @@ declare class EllipsisAccount {
      * Required permissions: read:account.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     auditLog(): Promise<S['AccountAuditLogResponse']>;
@@ -1816,7 +1931,7 @@ declare class EllipsisAccount {
      * Required permissions: read:account.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     budget(): Promise<S['BudgetSummary']>;
@@ -1826,11 +1941,11 @@ declare class EllipsisAccount {
      * Required permissions: write:account.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     update(options?: {
-        can_start_job_runs?: boolean | null;
+        can_start_sessions?: boolean | null;
         contact_email?: string | null;
     }): Promise<S['AccountResponse']>;
     /**
@@ -1842,14 +1957,14 @@ declare class EllipsisAccount {
      * preserved. Set policy.developer_defaults to null to disable developer
      * limits. Null override windows inherit their default. API keys use
      * their stable ID, not their secret. Changes apply to the next paid
-     * request, including sessions already running. API keys and sandbox
-     * credentials cannot edit budgets. The session ceiling remains at
+     * request, including sessions already running. API keys and session
+     * tokens cannot edit budgets. The session ceiling remains at
      * /account/settings; purchasing credits is separate from budget policy.
      *
      * Required permissions: write:defaults.
      * API key: Requires a CLI user token belonging to an account administrator.
      * CLI user token: Requires an account administrator.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     updateBudget(options?: {
@@ -1863,14 +1978,14 @@ declare class EllipsisAccount {
      *
      * Omit period_start for the current UTC month; select a period returned
      * in billing_periods to view history. Credit debits are distinct from
-     * rated token usage through BYOK, customer Bedrock, or a developer's
-     * Claude subscription. Rated usage estimates are not provider invoices.
+     * rated token usage through a developer's Claude or Codex
+     * subscription. Rated usage estimates are not provider invoices.
      * Pending and unresolved requests identify missing measurements.
      *
      * Required permissions: read:account.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     usage(options?: {
@@ -1892,7 +2007,7 @@ declare class EllipsisAgents {
      * Required permissions: write:configs.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -1911,7 +2026,7 @@ declare class EllipsisAgents {
      * Required permissions: write:configs.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -1924,7 +2039,7 @@ declare class EllipsisAgents {
      * Required permissions: read:configs.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -1942,7 +2057,7 @@ declare class EllipsisAgents {
      * Required permissions: write:configs.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -1958,7 +2073,7 @@ declare class EllipsisAgents {
      * Required permissions: read:configs.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -1977,7 +2092,7 @@ declare class EllipsisAgents {
      * Required permissions: read:configs.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -1985,30 +2100,40 @@ declare class EllipsisAgents {
     /**
      * Start Agent Session
      *
-     * Invoke an agent.
+     * Start an agent session.
      *
-     * Runs a certified agent with its configured instructions, model,
-     * environment, permissions, skills, and budget, and returns
-     * the session it started. The session runs once and does not accept
-     * follow-up messages. If the agent declares input.json_schema,
-     * send only `input` for its initial message. Otherwise send a non-empty
-     * `prompt`, which becomes the initial message verbatim. Both fields
-     * together, neither field, and input that renders an empty message are
-     * rejected with 422. An optional `budget` lowers the session cap;
-     * `metadata` tags the session. Codex invocations are not supported.
+     * Starts a session from the agent's saved `session` settings and
+     * returns it. The body takes the fields of POST /v1/sessions, all
+     * optional: each field you send replaces the agent's value for that
+     * field, and each field you leave out keeps it. `metadata` is merged
+     * into the agent's key by key, and a `null` value removes a key.
+     * Other lists and maps, and `environment`, are replaced whole;
+     * naming the other harness replaces the agent's. An empty body starts
+     * the agent as written. If the agent declares input.json_schema, send
+     * `input`; its rendered message is added after the prompt. A run-once
+     * session needs a prompt or `input` from the agent or the request, or
+     * the call is a 400.
      *
      * Required permissions: write:sessions.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
-    run(agent_id: string, options?: {
-        budget?: number | null;
+    start(agent_id: string, options?: {
+        budget?: S['RunBudget'] | null;
+        claude_code?: S['ClaudeOverrides'] | null;
+        codex?: S['CodexOverrides'] | null;
+        conversation?: S['SessionConversationConfig-Input'];
+        environment?: string | S['EnvironmentConfig-Input'] | null;
+        force_rebuild?: boolean;
+        images?: (S['ImageAttachment'])[];
         input?: Record<string, unknown> | null;
-        metadata?: Record<string, string>;
-        prompt?: string | null;
+        metadata?: Record<string, string | null>;
+        output?: S['OutputConfig'] | null;
+        permissions?: S['PermissionsConfig-Input'] | null;
+        skills?: (S['SkillRef-Input'])[] | null;
     }): Promise<S['SessionResponse']>;
     /**
      * Get Agents Stream Ticket
@@ -2016,7 +2141,7 @@ declare class EllipsisAgents {
      * Required permissions: read:configs.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -2033,7 +2158,7 @@ declare class EllipsisAgents {
      * Required permissions: write:configs.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -2051,7 +2176,7 @@ declare class EllipsisAgents {
      * Required permissions: write:configs.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -2072,7 +2197,7 @@ declare class EllipsisAlerts {
      * Required permissions: write:alerts.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     dismiss(alert_id: string): Promise<S['AlertResponse']>;
@@ -2086,7 +2211,7 @@ declare class EllipsisAlerts {
      * Required permissions: read:alerts.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     get(alert_id: string): Promise<S['AlertResponse']>;
@@ -2103,7 +2228,7 @@ declare class EllipsisAlerts {
      * Required permissions: read:alerts.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     list(options?: {
@@ -2132,7 +2257,7 @@ declare class EllipsisAnalytics {
      * Required permissions: read:account.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     metrics(options?: {
@@ -2155,7 +2280,7 @@ declare class EllipsisAnalytics {
      * Required permissions: read:account.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     pullRequests(options?: {
@@ -2170,7 +2295,7 @@ declare class EllipsisAnalytics {
     /**
      * Get Analytics Reviews
      *
-     * Return code-review analytics.
+     * Return pull request review analytics.
      *
      * account_type scopes reviewers (bot|user|all) — e.g. "what apps
      * review the most PRs?" is the reviewer facets here with
@@ -2180,7 +2305,7 @@ declare class EllipsisAnalytics {
      * Required permissions: read:account.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     reviews(options?: {
@@ -2241,7 +2366,7 @@ declare class EllipsisEnvironments {
      * Required permissions: write:environments.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     create(options: {
@@ -2261,7 +2386,7 @@ declare class EllipsisEnvironments {
      * Required permissions: delete:environments.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     delete(environment_id: string): Promise<void>;
@@ -2273,7 +2398,7 @@ declare class EllipsisEnvironments {
      * Required permissions: read:environments.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     get(environment_id: string): Promise<S['EnvironmentResponse']>;
@@ -2285,7 +2410,7 @@ declare class EllipsisEnvironments {
      * Required permissions: read:environments.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     list(): Promise<S['EnvironmentsListResponse']>;
@@ -2302,108 +2427,13 @@ declare class EllipsisEnvironments {
      * Required permissions: write:environments.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     update(environment_id: string, options: {
         environment: S['EnvironmentDocument-Input'];
     }): Promise<S['EnvironmentResponse']>;
 }
-declare class EllipsisFiles {
-    private readonly transport;
-    constructor(transport: Transport);
-    /**
-     * Create File
-     *
-     * Upload a file that outlives the sandbox.
-     *
-     * v1: PNG images only, base64 in the JSON body, 10 MiB cap. The
-     * primary caller is the in-sandbox `agent file upload` CLI (an
-     * agent persisting a screenshot to link on a PR), but all
-     * credential types work. Returns the org-membership-gated
-     * dashboard URL so callers never hard-code URL shapes.
-     *
-     * Required permissions: write:files.
-     * API key: Supported.
-     * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
-     * Higher permission levels include lower levels: read < write < delete.
-     * Grant match patterns can further restrict access to individual resources.
-     */
-    create(options: {
-        content_type: string;
-        data_b64: string;
-        filename: string;
-    }): Promise<S['CreateFileResponse']>;
-    /**
-     * Delete File
-     *
-     * Delete a file.
-     *
-     * A foreign, missing, or already-deleted id is an
-     * indistinguishable 404, so ids can't be enumerated. Sandbox
-     * tokens get a 403 (a sandbox token sits next to
-     * potentially-untrusted code and must not be able to destroy the
-     * account's files — uploading is fine, destruction is not); API
-     * keys and user tokens may delete.
-     *
-     * Required permissions: delete:files.
-     * API key: Supported.
-     * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
-     * Higher permission levels include lower levels: read < write < delete.
-     * Grant match patterns can further restrict access to individual resources.
-     */
-    delete(file_id: string): Promise<void>;
-    /**
-     * Get File
-     *
-     * Return one file's metadata and download link.
-     *
-     * Includes the gated dashboard URL and a short-lived presigned
-     * `download_url`, plus the owning account's GitHub login.
-     *
-     * Signed-in dashboard users are checked against the file's owning
-     * account, regardless of their selected organization. API keys,
-     * CLI user tokens, and sandbox tokens remain restricted to their
-     * own account. Missing, deleted, and inaccessible files return 404.
-     *
-     * To fetch the bytes locally, call this and then GET download_url
-     * immediately — the JSON API never carries the file. The CLI's
-     * `agent file get` wraps exactly that two-step.
-     *
-     * Required permissions: read:files.
-     * API key: Supported.
-     * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
-     * Higher permission levels include lower levels: read < write < delete.
-     * Grant match patterns can further restrict access to individual resources.
-     */
-    get(file_id: string): Promise<S['GetFileResponse']>;
-    /**
-     * List Files
-     *
-     * List uploaded files, newest first.
-     *
-     * Metadata only by default. Set include_download_urls=true to get
-     * a download_urls map keyed by file id for thumbnails or batch
-     * downloads. URLs expire within about a minute. session_id scopes
-     * the list to one session's uploads.
-     *
-     * Required permissions: read:files.
-     * API key: Supported.
-     * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
-     * Higher permission levels include lower levels: read < write < delete.
-     * Grant match patterns can further restrict access to individual resources.
-     */
-    list(options?: {
-        session_id?: string | null;
-        limit?: number;
-        cursor?: string | null;
-        include_download_urls?: boolean;
-    }): Promise<Page<S['File'], S['FilesListResponse']>>;
-}
 declare class EllipsisHandlers {
     private readonly transport;
     constructor(transport: Transport);
@@ -2418,12 +2448,12 @@ declare class EllipsisHandlers {
      * state without fetching GitHub or triggering synchronization.
      *
      * Requires configs:read; scoped grants match handlers/{service}.
-     * Sandbox credentials with that grant may read handlers.
+     * Session tokens with that grant may read handlers.
      *
      * Required permissions: read:configs.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -2434,8 +2464,8 @@ declare class EllipsisHandlers {
      * Return session counts and accumulated spend for a saved handler.
      *
      * Filters only by session creation time. Omitted bounds include all
-     * history. Counts use the current conversation outcome, so an idle
-     * session remains active. Spend includes the selected sessions' full
+     * history. Counts use the current turn and conversation state, so an open
+     * conversation awaiting another message remains active. Spend includes the selected sessions' full
      * accumulated cost, including activity after the creation-time window.
      * Only sessions carrying this exact saved handler id are counted;
      * legacy sessions without handler provenance are excluded.
@@ -2445,12 +2475,12 @@ declare class EllipsisHandlers {
      * Those windows use usage timestamps and are independent of start/end.
      *
      * Requires configs:read matching handlers/{service} and unrestricted
-     * sessions:read. Sandbox tokens with both grants may read metrics.
+     * sessions:read. Session tokens with both grants may read metrics.
      *
      * Required permissions: read:sessions, read:configs.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -2476,7 +2506,7 @@ declare class EllipsisIntegrationsGithub {
      * Required permissions: read:integrations.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     members(): Promise<S['GithubMembersListResponse']>;
@@ -2488,7 +2518,7 @@ declare class EllipsisIntegrationsGithub {
      * Required permissions: read:integrations.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     repos(): Promise<S['GithubRepositoriesListResponse']>;
@@ -2498,7 +2528,7 @@ declare class EllipsisIntegrationsGithub {
      * Required permissions: write:integrations.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     uninstall(options: {
@@ -2514,7 +2544,7 @@ declare class EllipsisIntegrationsLinear {
      * Required permissions: delete:integrations.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     delete(): Promise<S['AccountActionResponse']>;
@@ -2526,7 +2556,7 @@ declare class EllipsisIntegrationsLinear {
      * Required permissions: read:integrations.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     teams(): Promise<S['LinearTeamsListResponse']>;
@@ -2536,11 +2566,10 @@ declare class EllipsisIntegrationsLinear {
      * Required permissions: write:integrations.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     updateSettings(options: {
-        mcp_inclusion?: S['McpInclusionMode'] | null;
         teams: (S['LinearTeamUpdate'])[];
     }): Promise<S['AccountActionResponse']>;
 }
@@ -2553,7 +2582,7 @@ declare class EllipsisIntegrationsSentry {
      * Required permissions: delete:integrations.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     delete(integration_id: string): Promise<S['AccountActionResponse']>;
@@ -2565,7 +2594,7 @@ declare class EllipsisIntegrationsSentry {
      * Required permissions: read:integrations.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     organizations(): Promise<S['SentryOrganizationsListResponse']>;
@@ -2582,7 +2611,7 @@ declare class EllipsisIntegrationsSlack {
      * Required permissions: read:integrations.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     channels(): Promise<S['SlackChannelsListResponse']>;
@@ -2592,7 +2621,7 @@ declare class EllipsisIntegrationsSlack {
      * Required permissions: write:integrations.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     createOperationsChannel(): Promise<S['SlackChannel']>;
@@ -2602,7 +2631,7 @@ declare class EllipsisIntegrationsSlack {
      * Required permissions: delete:integrations.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     delete(): Promise<S['AccountActionResponse']>;
@@ -2615,22 +2644,10 @@ declare class EllipsisIntegrationsSlack {
      * Required permissions: read:integrations.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     members(): Promise<S['SlackMembersListResponse']>;
-    /**
-     * Update Slack Settings
-     *
-     * Required permissions: write:integrations.
-     * API key: Supported.
-     * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
-     * Higher permission levels include lower levels: read < write < delete.
-     */
-    updateSettings(options: {
-        mcp_inclusion: S['McpInclusionMode'];
-    }): Promise<S['AccountActionResponse']>;
 }
 declare class EllipsisIntegrations {
     private readonly transport;
@@ -2648,182 +2665,46 @@ declare class EllipsisIntegrations {
      * config can learn which repositories, channels, teams, and
      * organizations it may name before POST /agents.
      *
-     * Available to all credential types including sandbox tokens: the
+     * Available to all credential types including session tokens: the
      * responses never include OAuth tokens or any other secret.
      *
      * Required permissions: read:integrations.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     list(): Promise<S['GetIntegrationsResponse']>;
 }
-declare class EllipsisMemories {
+declare class EllipsisReviewsConfigs {
     private readonly transport;
     constructor(transport: Transport);
     /**
-     * Create Memory
-     *
-     * Save a memory for future agent sessions.
-     *
-     * Memories are durable lessons shared across the whole
-     * organization — conventions, past decisions, known gotchas that an
-     * agent cannot derive from the repository itself. One concise fact
-     * per memory; the description is what a reader sees in the index.
-     *
-     * Creating never overwrites: a path that already exists is a 409, so
-     * correcting an existing memory is an explicit edit.
-     *
-     * Required permissions: write:memories.
-     * API key: Supported.
-     * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
-     * Higher permission levels include lower levels: read < write < delete.
-     * Grant match patterns can further restrict access to individual resources.
-     */
-    create(options: {
-        content: string;
-        description: string;
-        path: string;
-    }): Promise<S['MemoryResponse']>;
-    /**
-     * Delete Memory
-     *
-     * Delete a memory that is no longer true.
-     *
-     * Available to every credential type, agents included — a wrong
-     * memory is worse than a missing one. The deleted content is kept in
-     * the memory's history for forensics, not for an undo API.
-     *
-     * Required permissions: delete:memories.
-     * API key: Supported.
-     * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
-     * Higher permission levels include lower levels: read < write < delete.
-     * Grant match patterns can further restrict access to individual resources.
-     */
-    delete(memory_id: string, options?: {
-        if_sha256?: string | null;
-    }): Promise<void>;
-    /**
-     * Edit Memory
-     *
-     * Correct an existing memory in place.
-     *
-     * Pass description, content, or both. This never creates a memory (an
-     * unknown id is a 404) and never moves one — the path is immutable, so
-     * relocating a memory is a delete plus a create.
-     *
-     * Pass `if_sha256` (from a previous read) to make a concurrent write
-     * a 409 instead of silently overwriting it.
-     *
-     * Required permissions: write:memories.
-     * API key: Supported.
-     * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
-     * Higher permission levels include lower levels: read < write < delete.
-     * Grant match patterns can further restrict access to individual resources.
-     */
-    edit(memory_id: string, options?: {
-        content?: string | null;
-        description?: string | null;
-        if_sha256?: string | null;
-    }): Promise<S['MemoryResponse']>;
-    /**
-     * Get Memory
-     *
-     * Read one memory's full content.
-     *
-     * The id comes from the index returned by listing memories.
-     *
-     * Required permissions: read:memories.
-     * API key: Supported.
-     * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
-     * Higher permission levels include lower levels: read < write < delete.
-     * Grant match patterns can further restrict access to individual resources.
-     */
-    get(memory_id: string): Promise<S['MemoryResponse']>;
-    /**
-     * List Memories
-     *
-     * List the organization's memories as a readable index.
+     * List Review Configs
      *
-     * Returns the memories rendered as a markdown index (one line per
-     * memory, carrying its id, path, and description) plus the same
-     * entries structured, each with every field except `content`. Read
-     * the index, then fetch the ids whose content you want.
+     * List code review configs: every kind: code_review file synced from a repository, newest first.
      *
-     * Required permissions: read:memories.
+     * Required permissions: read:reviews.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
-     * Grant match patterns can further restrict access to individual resources.
      */
-    list(options?: {
-        prefix?: string | null;
-    }): Promise<S['MemoriesListResponse']>;
+    list(): Promise<S['ReviewConfigsListResponse']>;
 }
 declare class EllipsisReviews {
     private readonly transport;
+    readonly configs: EllipsisReviewsConfigs;
     constructor(transport: Transport);
-    /**
-     * List Review Configs
-     *
-     * Required permissions: read:reviews.
-     * API key: Supported.
-     * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
-     * Higher permission levels include lower levels: read < write < delete.
-     */
-    configs(): Promise<S['GetCodeReviewConfigsResponse']>;
-    /**
-     * Create Review
-     *
-     * Run a code review on demand.
-     *
-     * Reviews an open pull request. Which pipeline runs is not a
-     * parameter: it resolves from the repository's files exactly as
-     * it does for a push, so an on-demand review never disagrees with
-     * the automatic one.
-     *
-     * A review is one pipeline run over one commit range, with one
-     * agent session per stage: `review.id` is the run id, and
-     * `stages[].session_id` is where a client streams
-     * (/sessions/{id}/stream on a stage session), since the review
-     * itself is a pipeline rather than one process.
-     *
-     * Required permissions: write:reviews.
-     * API key: Supported.
-     * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
-     * Higher permission levels include lower levels: read < write < delete.
-     */
-    create(options: {
-        owner: string;
-        post?: boolean;
-        pull_request_number: number;
-        repo: string;
-        scope?: S['ReviewScope'];
-    }): Promise<S['Review']>;
     /**
      * Get Review
      *
-     * Return one review with findings and outcome.
-     *
-     * Includes its scope, the per-stage sessions, the parsed findings,
-     * the finding counters, and the posting outcome.
-     *
-     * Findings only exist after a stage session finalizes — a running
-     * review honestly reports [] / null, which is why a client
-     * streams a stage session and then re-fetches the review.
+     * Get a code review: its reviewers and every comment they returned, posted or held back.
      *
      * Required permissions: read:reviews.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     get(review_id: string): Promise<S['Review']>;
@@ -2832,29 +2713,21 @@ declare class EllipsisReviews {
      *
      * List code reviews, newest first.
      *
-     * `findings` and `configuration` are omitted (counters only). Each
-     * filter is a set: repeat `repository`, `pull_request_number`, or
-     * `status` to match any of several values. `start` and `end` bound
-     * the review's creation time.
-     *
-     * Webhook-created reviews appear here too, so this answers "show
-     * me every review on this PR".
-     *
      * Required permissions: read:reviews.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     list(options?: {
-        repository?: (string)[];
-        pull_request_number?: (number)[];
-        status?: (S['CodeReviewRunStatus'])[];
+        repository?: (string)[] | null;
+        pull_request_number?: (number)[] | null;
+        status?: (S['CodeReviewStatus'])[] | null;
         start?: string | null;
         end?: string | null;
         limit?: number;
         cursor?: string | null;
-    }): Promise<Page<S['Review'], S['ReviewsListResponse']>>;
+    }): Promise<Page<S['ReviewSummary'], S['ReviewsListResponse']>>;
 }
 declare class EllipsisSecrets {
     private readonly transport;
@@ -2864,13 +2737,13 @@ declare class EllipsisSecrets {
      *
      * Delete a secret by name.
      *
-     * Refused for sandbox tokens; mutations require an API key or
+     * Refused for session tokens; mutations require an API key or
      * user token.
      *
      * Required permissions: delete:secrets.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -2886,7 +2759,7 @@ declare class EllipsisSecrets {
      * Required permissions: read:secrets.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -2897,14 +2770,14 @@ declare class EllipsisSecrets {
      * Upsert secrets.
      *
      * Returns only the secrets this call wrote, names and timestamps
-     * only — values are write-only. Refused for sandbox tokens (held by
-     * potentially-untrusted in-sandbox code); mutations require an
-     * API key or user token.
+     * only — values are write-only. Refused for session tokens (held by
+     * potentially-untrusted code running inside a session); mutations
+     * require an API key or user token.
      *
      * Required permissions: write:secrets.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -2912,8 +2785,46 @@ declare class EllipsisSecrets {
         secrets: (S['SecretInput'])[];
     }): Promise<S['SecretsListResponse']>;
 }
+declare class EllipsisSessionsTurns {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Get Session Turn
+     *
+     * Return one turn.
+     *
+     * Poll this after sending a message: the message is answered when
+     * the turn's status is completed, failed, stopped, or cancelled.
+     *
+     * Required permissions: read:sessions.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
+     */
+    get(session_id: string, turn_id: string): Promise<S['SessionTurnResponse']>;
+    /**
+     * Get Session Turns
+     *
+     * Return the session's turns and messages, oldest first.
+     *
+     * One turn per message: pending until the agent starts on it,
+     * running while it works, then completed, failed, stopped, or
+     * cancelled.
+     *
+     * Required permissions: read:sessions.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
+     */
+    list(session_id: string): Promise<S['SessionTurnsListResponse']>;
+}
 declare class EllipsisSessions {
     private readonly transport;
+    readonly turns: EllipsisSessionsTurns;
     constructor(transport: Transport);
     /**
      * Get Session Analytics
@@ -2922,16 +2833,16 @@ declare class EllipsisSessions {
      *
      * Token lanes use the request's saved rates. Content attribution
      * apportions input/cache spend by text size, counting carried context
-     * on every request. It is an estimate, not a tool execution fee.
+     * on every request. It is an estimate, not a tool call fee.
      * Only the latest 200 retained request bodies are inspected; missing
      * or unsupported context remains explicitly unattributed. No raw
-     * prompts or tool results are returned. Sandbox tokens may read only
+     * prompts or tool results are returned. Session tokens may read only
      * their own session's analytics.
      *
      * Required permissions: read:sessions.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own session.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own session.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -2942,15 +2853,15 @@ declare class EllipsisSessions {
      * Return the session's uncommitted changes as a patch.
      *
      * One unified-diff section per changed file, captured from the
-     * sandbox's working tree when the session ended. The per-file
+     * environment's working tree when the session ended. The per-file
      * counts ride on the session itself (`git.repos[].files`); this
      * is the text behind them. Empty when the tree was clean. A
-     * sandbox token may read only its own session's diff.
+     * session token may read only its own session's diff.
      *
      * Required permissions: read:sessions.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own session.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own session.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -2961,7 +2872,7 @@ declare class EllipsisSessions {
      * Download the complete session history.
      *
      * The complete, ordered history of the session (agent output, tool calls, thinking,
-     * lifecycle events, sandbox output, message events) as an ordered
+     * lifecycle events, environment output, message events) as an ordered
      * manifest of presigned segment URLs.
      *
      * Segments are gzip members: download in order and concatenate
@@ -2972,37 +2883,19 @@ declare class EllipsisSessions {
      * Required permissions: read:sessions.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
     download(session_id: string): Promise<S['GetSessionLogResponse']>;
-    /**
-     * List Session Executions
-     *
-     * Return the session's execution attempts, oldest first.
-     *
-     * Includes the selected harness, model, resolved instructions, initial
-     * query, and common result summary. Complete native outputs remain in
-     * the session's records. Internal launch options and checkpoint storage
-     * references are excluded.
-     *
-     * Required permissions: read:sessions.
-     * API key: Supported.
-     * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
-     * Higher permission levels include lower levels: read < write < delete.
-     * Grant match patterns can further restrict access to individual resources.
-     */
-    executions(session_id: string): Promise<S['SessionExecutionsListResponse']>;
     /**
      * Get Session
      *
      * Return one session.
      *
-     * The public wire shape — the same shape the stream's session
-     * frames carry, with attribution, stop, and archive actors resolved
-     * at read time.
+     * The public wire shape, the same shape the stream's session frames
+     * carry, with attribution, stop, and archive actors resolved at read
+     * time. `turn` is the turn in progress or the latest one.
      *
      * The heavy near-static blobs (config snapshot, input/output)
      * live on the detail endpoints, not here.
@@ -3010,7 +2903,7 @@ declare class EllipsisSessions {
      * Required permissions: read:sessions.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -3026,7 +2919,7 @@ declare class EllipsisSessions {
      * Required permissions: read:sessions.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -3036,15 +2929,16 @@ declare class EllipsisSessions {
      *
      * Append transcript lines to a session's record.
      *
-     * The in-sandbox tailer for interactive sessions.
+     *             The transcript tailer running inside the session's environment, for
+     * interactive sessions.
      *
-     * A sandbox token may only push its own session's transcript.
-     * Idempotent by transcript line uuid; tolerant of malformed lines.
+     *             A session token may only push its own session's transcript.
+     *             Idempotent by transcript line uuid; tolerant of malformed lines.
      *
      * Required permissions: write:sessions.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own session.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own session.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -3064,7 +2958,7 @@ declare class EllipsisSessions {
      * Required permissions: read:sessions.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -3081,34 +2975,30 @@ declare class EllipsisSessions {
         author_id?: number | null;
         repo?: string | null;
         unfinished?: boolean;
-        exclude_code_review?: boolean;
     }): Promise<Page<S['Session'], S['SessionsListResponse']>>;
     /**
-     * Get Session Output
+     * Get Session Metrics
      *
-     * Return the session's typed output.
+     * List the CPU, memory, swap, and disk readings of every VM the
+     * session ran on, oldest first.
      *
-     * The payload the agent submitted through its config-declared
-     * output.json_schema, as the raw JSON body with no envelope. 404
-     * while the session is still running (poll GET /v1/sessions/{id}),
-     * when the agent declares no output block, or when no execution
-     * produced output.
+     * A reading is taken every 5 seconds while the session runs.
      *
      * Required permissions: read:sessions.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own session.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
-    output(session_id: string): Promise<Record<string, unknown>>;
+    metrics(session_id: string): Promise<S['VMMetricsResponse']>;
     /**
      * Get Session Records
      *
      * Return the session's stored transcript records, oldest first.
      *
      * Pagination is opt-in (cursor/limit); a bare call returns the
-     * full retained transcript. Available to sandbox tokens too: an
+     * full retained transcript. Available to session tokens too: an
      * agent answering "did X look into Y?" needs to read the sessions
      * it finds, and any org member sees the same transcript in the
      * dashboard.
@@ -3116,7 +3006,7 @@ declare class EllipsisSessions {
      * Required permissions: read:sessions.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -3130,7 +3020,7 @@ declare class EllipsisSessions {
      * Required permissions: read:sessions.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -3144,7 +3034,7 @@ declare class EllipsisSessions {
         agent_id?: (string)[] | null;
         session_ids?: (string)[] | null;
         repo?: (string)[] | null;
-        status?: (S['SessionLifecycleStatus'])[] | null;
+        status?: (S['TurnStatus'])[] | null;
         start?: string | null;
         end?: string | null;
         limit?: number;
@@ -3154,15 +3044,14 @@ declare class EllipsisSessions {
      *
      * Send a message to a session.
      *
-     * 409 for react/cron, non-interactive, and closed sessions.
-     * Returns the created message so the caller can track it by id; a
-     * retried send with the same idempotency_key returns the original
-     * message.
+     * 409 for mention, non-interactive, closed, and out-of-budget
+     * sessions. Returns the created message and its turn; a retried send
+     * with the same idempotency_key returns the original ones.
      *
      * Required permissions: write:sessions.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -3177,7 +3066,7 @@ declare class EllipsisSessions {
      * Required permissions: read:sessions.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -3188,50 +3077,51 @@ declare class EllipsisSessions {
      * Start a cloud agent session.
      *
      * The daily driver: a prompt, optionally where to run it
-     * (`environment`) and the run's own settings, in the AgentConfig
+     * (`environment`) and the session's own settings, in the AgentConfig
      * vocabulary. What you send is what runs: omit `environment` and the
-     * session runs in the built-in basic sandbox. A missing model or
+     * session runs in the built-in basic environment. A missing model or
      * budget comes from the organization's settings, so
      * `{"claude_code": {"prompt": "..."}}` is a complete request.
      * Set exactly one of `claude_code` or `codex`. Its `prompt` is the
-     * first message; omit the prompt and the session starts idle, waiting for
-     * one. 400 when `lifecycle.interactive` is false and there is no prompt, or
-     * when `budget` exceeds the organization's per-session ceiling. To
-     * run a saved agent, use POST /v1/agents/{agent_id}/sessions.
+     * first message; omit the prompt and the session starts with no
+     * turn, waiting for one. 400 when `conversation.interactive` is false
+     * and there is no prompt, or when `budget.session` exceeds the
+     * organization's per-session ceiling. To start a session from a saved
+     * agent, use POST /v1/agents/{agent_id}/sessions.
      *
      * Required permissions: write:sessions.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
     start(options?: {
-        budget?: number | null;
+        budget?: S['RunBudget'] | null;
         claude_code?: S['ClaudeConfig-Input'] | null;
         codex?: S['CodexConfig-Input'] | null;
+        conversation?: S['SessionConversationConfig-Input'];
         environment?: string | S['EnvironmentConfig-Input'] | null;
         force_rebuild?: boolean;
         images?: (S['ImageAttachment'])[];
-        lifecycle?: S['SessionLifecycleConfig'];
         metadata?: Record<string, string>;
         output?: S['OutputConfig'] | null;
         permissions?: S['PermissionsConfig-Input'] | null;
-        repositories?: (string)[] | null;
         skills?: (S['SkillRef-Input'])[] | null;
     }): Promise<S['SessionResponse']>;
     /**
      * Stop Session
      *
-     * Stop an in-flight session and return it.
+     * Stop the turn in progress and return the session.
      *
-     * stopped_by is recorded only when the caller's credential maps
-     * to a GitHub account.
+     * The turn ends `stopped`; the conversation stays open. 409 when no
+     * turn is pending or running. The stopping user is recorded only
+     * when the caller's credential maps to a GitHub account.
      *
      * Required permissions: write:sessions.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -3242,7 +3132,7 @@ declare class EllipsisSessions {
      * Required permissions: read:sessions.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -3263,7 +3153,7 @@ declare class EllipsisSessions {
      * Required permissions: write:sessions.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      * Grant match patterns can further restrict access to individual resources.
      */
@@ -3284,7 +3174,7 @@ declare class EllipsisSupportSlack {
      * Required permissions: write:account.
      * API key: Requires a CLI user token.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     create(options: {
@@ -3297,7 +3187,7 @@ declare class EllipsisSupportSlack {
      * Required permissions: read:account.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     get(): Promise<void>;
@@ -3307,7 +3197,7 @@ declare class EllipsisSupportSlack {
      * Required permissions: write:account.
      * API key: Requires a CLI user token.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     invite(options: {
@@ -3331,7 +3221,7 @@ declare class EllipsisTemplates {
      * Required permissions: read:templates.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     get(template_id: string): Promise<S['AgentTemplate']>;
@@ -3346,7 +3236,7 @@ declare class EllipsisTemplates {
      * Required permissions: read:templates.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
      * Higher permission levels include lower levels: read < write < delete.
      */
     list(): Promise<S['AgentTemplatesListResponse']>;
@@ -3365,7 +3255,7 @@ declare class EllipsisUserSubscriptionTokens {
      * Required permissions: delete:user.
      * API key: Requires a CLI user token.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     delete(provider: S['SubscriptionProvider']): Promise<void>;
@@ -3380,7 +3270,7 @@ declare class EllipsisUserSubscriptionTokens {
      * Required permissions: read:user.
      * API key: Requires a CLI user token.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     get(provider: S['SubscriptionProvider']): Promise<S['SubscriptionToken']>;
@@ -3396,7 +3286,7 @@ declare class EllipsisUserSubscriptionTokens {
      * Required permissions: read:user.
      * API key: Requires a CLI user token.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     list(): Promise<S['SubscriptionTokensListResponse']>;
@@ -3414,7 +3304,7 @@ declare class EllipsisUserSubscriptionTokens {
      * Required permissions: write:user.
      * API key: Requires a CLI user token.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     set(provider: S['SubscriptionProvider'], options: {
@@ -3434,7 +3324,7 @@ declare class EllipsisUserSubscriptionTokens {
      * Required permissions: read:user.
      * API key: Requires a CLI user token.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     usage(provider: S['SubscriptionProvider']): Promise<S['SubscriptionUsageResponse']>;
@@ -3453,7 +3343,7 @@ declare class EllipsisUserSubscriptionTokens {
      * Required permissions: write:user.
      * API key: Requires a CLI user token.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     verify(provider: S['SubscriptionProvider']): Promise<S['VerifySubscriptionTokenResponse']>;
@@ -3467,7 +3357,7 @@ declare class EllipsisUserTokens {
      * Required permissions: read:user.
      * API key: Requires a CLI user token.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     list(): Promise<S['ListUserTokensResponse']>;
@@ -3477,7 +3367,7 @@ declare class EllipsisUserTokens {
      * Required permissions: delete:user.
      * API key: Requires a CLI user token.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     revoke(token_id: string): Promise<S['TokenRevokedResponse']>;
@@ -3497,7 +3387,7 @@ declare class EllipsisVmExecutions {
      * Required permissions: read:environments.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own sandbox.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own sandbox.
      * Higher permission levels include lower levels: read < write < delete.
      */
     get(vm_execution_id: string): Promise<S['VMExecutionResponse']>;
@@ -3507,7 +3397,7 @@ declare class EllipsisVmExecutions {
      * Required permissions: read:environments.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own sandbox.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own sandbox.
      * Higher permission levels include lower levels: read < write < delete.
      */
     list(): Promise<void>;
@@ -3517,7 +3407,7 @@ declare class EllipsisVmExecutions {
      * Required permissions: read:environments.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own sandbox.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own sandbox.
      * Higher permission levels include lower levels: read < write < delete.
      */
     streamTicket(vm_execution_id: string): Promise<S['StreamTicketResponse']>;
@@ -3533,7 +3423,7 @@ declare class EllipsisVmImages {
      * Required permissions: read:environments.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     get(image_id: string): Promise<S['VMImageResponse']>;
@@ -3547,7 +3437,7 @@ declare class EllipsisVmImages {
      * Required permissions: read:environments.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     list(options?: {
@@ -3566,7 +3456,7 @@ declare class EllipsisVms {
      * Required permissions: read:environments.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own VM.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own VM.
      * Higher permission levels include lower levels: read < write < delete.
      */
     get(vm_id: string): Promise<S['VM']>;
@@ -3580,13 +3470,30 @@ declare class EllipsisVms {
      * Required permissions: read:environments.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own VM.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own VM.
      * Higher permission levels include lower levels: read < write < delete.
      */
     list(options?: {
         limit?: number;
         offset?: number;
     }): Promise<S['VMListResponse']>;
+    /**
+     * List Vm Metrics
+     *
+     * List a VM's CPU, memory, swap, and disk readings, oldest first.
+     *
+     * A reading is taken every 5 seconds while a session runs on the VM.
+     *
+     * Required permissions: read:environments.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own VM.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    metrics(vm_id: string, options?: {
+        start?: string | null;
+        end?: string | null;
+    }): Promise<S['VMMetricsResponse']>;
 }
 declare class EllipsisWebhooksDeliveries {
     private readonly transport;
@@ -3602,7 +3509,7 @@ declare class EllipsisWebhooksDeliveries {
      * Required permissions: read:webhooks.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     get(delivery_id: string): Promise<S['WebhookDeliveryResponse']>;
@@ -3617,7 +3524,7 @@ declare class EllipsisWebhooksDeliveries {
      * Required permissions: read:webhooks.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     list(options?: {
@@ -3647,7 +3554,7 @@ declare class EllipsisWebhooks {
      * Required permissions: write:webhooks.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     create(options: {
@@ -3666,7 +3573,7 @@ declare class EllipsisWebhooks {
      * Required permissions: delete:webhooks.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     delete(webhook_id: string): Promise<void>;
@@ -3678,7 +3585,7 @@ declare class EllipsisWebhooks {
      * Required permissions: read:webhooks.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     get(webhook_id: string): Promise<S['WebhookResponse']>;
@@ -3690,7 +3597,7 @@ declare class EllipsisWebhooks {
      * Required permissions: read:webhooks.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     list(): Promise<S['WebhooksListResponse']>;
@@ -3707,7 +3614,7 @@ declare class EllipsisWebhooks {
      * Required permissions: write:webhooks.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     ping(webhook_id: string): Promise<void>;
@@ -3723,7 +3630,7 @@ declare class EllipsisWebhooks {
      * Required permissions: write:webhooks.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Session token: Not supported by session tokens, even with permissions.ellipsis enabled.
      * Higher permission levels include lower levels: read < write < delete.
      */
     update(webhook_id: string, options: {
@@ -3740,10 +3647,8 @@ declare class Ellipsis {
     readonly analytics: EllipsisAnalytics;
     readonly auth: EllipsisAuth;
     readonly environments: EllipsisEnvironments;
-    readonly files: EllipsisFiles;
     readonly handlers: EllipsisHandlers;
     readonly integrations: EllipsisIntegrations;
-    readonly memories: EllipsisMemories;
     readonly reviews: EllipsisReviews;
     readonly secrets: EllipsisSecrets;
     readonly sessions: EllipsisSessions;
@@ -3760,10 +3665,12 @@ declare class Ellipsis {
      *
      * Return the identity behind the caller's credential.
      *
-     * Required permissions: read:account.
+     * Any valid credential may call this; no permission grant is needed.
+     *
+     * Required permissions: none; any valid credential.
      * API key: Supported.
      * CLI user token: Supported.
-     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Session token: Requires the ellipsis:api scope; no permissions.ellipsis grant is needed.
      * Higher permission levels include lower levels: read < write < delete.
      */
     identity(): Promise<S['Identity']>;
@@ -3801,4 +3708,4 @@ declare class RateLimitError extends APIError {
 declare class ServerError extends APIError {
 }
 
-export { APIError, type AgentListStreamMessage, AuthenticationError, type CollectionStreamFrame, type CollectionStreamHeartbeat, ConflictError, DEFAULT_BASE_URL, Ellipsis, EllipsisError, ForbiddenError, NotFoundError, Page, RateLimitError, type SandboxSnapshotFrame, type SandboxUpdateFrame, ServerError, SessionHandle, type SessionListStreamMessage, TERMINAL_STATUSES, Transport, TransportError, type TransportOptions, UnprocessableError, components, isSettled };
+export { APIError, type AgentListStreamMessage, AuthenticationError, type CollectionStreamFrame, type CollectionStreamHeartbeat, ConflictError, DEFAULT_BASE_URL, Ellipsis, EllipsisError, ForbiddenError, NotFoundError, Page, RateLimitError, type SandboxSnapshotFrame, type SandboxUpdateFrame, ServerError, SessionHandle, type SessionListStreamMessage, Transport, TransportError, type TransportOptions, UnprocessableError, components, isTurnFinal };