@ellipsis-dev/sdk 0.2.3 → 0.4.0

package/dist/{types-CNx-q_eN.d.ts → types-CtTRS9eJ.d.ts}

@@ -1,4 +1,39 @@
 interface paths {
+    '/v1/reviews': {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List Reviews */
+        get: operations['list_reviews_v1_reviews_get'];
+        put?: never;
+        /** Create Review */
+        post: operations['create_review_v1_reviews_post'];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    '/v1/reviews/{review_id}': {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get Review */
+        get: operations['get_review_v1_reviews__review_id__get'];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     '/v1/sessions/{session_id}': {
         parameters: {
             query?: never;
@@ -87,6 +122,458 @@ interface paths {
 }
 interface components {
     schemas: {
+        /** AgentConfig */
+        AgentConfig: {
+            /** @default {} */
+            budget: components['schemas']['AgentConfigBudget'];
+            /**
+             * @default {
+             *       "model": "claude-opus-5",
+             *       "system": ""
+             *     }
+             */
+            claude: components['schemas']['AgentConfigClaude'];
+            /**
+             * @default {
+             *       "enabled": true,
+             *       "ide": true,
+             *       "interactive": true,
+             *       "metadata": {
+             *         "annotations": {},
+             *         "labels": []
+             *       },
+             *       "version": "v1"
+             *     }
+             */
+            ellipsis: components['schemas']['AgentConfigEllipsis'];
+            /**
+             * Mcp Servers
+             * @default []
+             */
+            mcp_servers: (string | components['schemas']['AgentConfigMcpServer'])[];
+            /**
+             * @default {
+             *       "compute": {},
+             *       "github": {},
+             *       "hooks": {},
+             *       "image": {},
+             *       "ports": [
+             *         3000,
+             *         5173,
+             *         8000,
+             *         8080
+             *       ],
+             *       "repositories": [],
+             *       "variables": []
+             *     }
+             */
+            sandbox: components['schemas']['AgentConfigSandbox'];
+            /**
+             * Skills
+             * @default []
+             */
+            skills: components['schemas']['AgentConfigSkill'][];
+            structured_output?: components['schemas']['AgentConfigStructuredOutput'] | null;
+            /** Trigger */
+            trigger?: (components['schemas']['AgentConfigCronTrigger'] | components['schemas']['AgentConfigReactTrigger'] | components['schemas']['AgentConfigMentionTrigger']) | null;
+        };
+        /** AgentConfigBudget */
+        AgentConfigBudget: {
+            /** Day */
+            day?: number | null;
+            /** Month */
+            month?: number | null;
+            /** Session */
+            session?: number | null;
+            /** Week */
+            week?: number | null;
+        };
+        /** AgentConfigClaude */
+        AgentConfigClaude: {
+            effort?: components['schemas']['EffortLevel'] | null;
+            /** Fallback Model */
+            fallback_model?: string | null;
+            /** Max Turns */
+            max_turns?: number | null;
+            /**
+             * Model
+             * @default claude-opus-5
+             */
+            model: string;
+            settings?: components['schemas']['AgentConfigSettingsRef'] | null;
+            /**
+             * System
+             * @default
+             */
+            system: string | components['schemas']['AgentConfigSystemFileRef'] | (string | components['schemas']['AgentConfigSystemFileRef'])[];
+        };
+        /**
+         * AgentConfigCompute
+         * @description Sandbox compute sizing. Every field is optional; None inherits the
+         *     platform default (1 vCPU / 4096 MiB / 3600s — see DEFAULT_MODAL_* in
+         *     models/ellipsis/sandboxes/sandbox.py). 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.
+         *
+         *     `timeout` is the max wall-clock the agent may run before the sandbox is
+         *     killed, 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.
+         *
+         *     Compute is billed on the requested allocation over the sandbox's
+         *     wall-clock lifetime, so a bigger/longer box costs proportionally more.
+         */
+        AgentConfigCompute: {
+            /** Cpu */
+            cpu?: number | null;
+            /** Memory */
+            memory?: string | components['schemas']['AgentConfigMemorySize'] | null;
+            /** Timeout */
+            timeout?: string | components['schemas']['AgentConfigDuration'] | null;
+        };
+        /** AgentConfigCronTrigger */
+        AgentConfigCronTrigger: {
+            /** Schedule */
+            schedule: string;
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: 'cron';
+        };
+        /**
+         * AgentConfigDuration
+         * @description A duration as explicit units, summed. Set any of `hours`/`minutes`/
+         *     `seconds` (at least one). The alternative to the `30m`-style shorthand
+         *     string wherever a duration is accepted.
+         */
+        AgentConfigDuration: {
+            /** Hours */
+            hours?: number | null;
+            /** Minutes */
+            minutes?: number | null;
+            /** Seconds */
+            seconds?: number | null;
+        };
+        /**
+         * AgentConfigEllipsis
+         * @description The Ellipsis product namespace for a config file: which schema this is
+         *     (`version`), the human-facing identity (`name`/`description`), freeform
+         *     organizational `metadata`, whether the agent is `enabled`, and the two
+         *     human-access flags (`interactive`/`ide`). The presence of a top-level
+         *     `ellipsis:` mapping is what marks a YAML file as an Ellipsis agent config (vs
+         *     arbitrary YAML that merely lives under a config directory) — see
+         *     `yaml_is_ellipsis_config`.
+         *
+         *     `enabled`/`interactive`/`ide` are agent behavior, not freeform metadata, so
+         *     they stay inside the config `sha` (only `metadata` is sha-excluded).
+         *     `interactive` and `ide` are sibling human-access flags: `interactive` lets a
+         *     human `agent session connect` to a live session (CLI relay); `ide` lets a
+         *     human open an editor / a port URL into the sandbox. Neither decides whether a
+         *     session is ephemeral or durable — that is the trigger's job.
+         */
+        AgentConfigEllipsis: {
+            /** Description */
+            description?: string | null;
+            /**
+             * Enabled
+             * @default true
+             */
+            enabled: boolean;
+            /**
+             * Ide
+             * @default true
+             */
+            ide: boolean;
+            /**
+             * Interactive
+             * @default true
+             */
+            interactive: boolean;
+            /**
+             * @default {
+             *       "annotations": {},
+             *       "labels": []
+             *     }
+             */
+            metadata: components['schemas']['AgentConfigMetadata'];
+            /** Name */
+            name?: string | null;
+            /**
+             * Version
+             * @default v1
+             */
+            version: string;
+        };
+        /**
+         * AgentConfigMcpServer
+         * @description One built-in MCP server this agent opts into by name (`linear`/`slack`).
+         *     This is a name reference over the connected built-in set, NOT a custom-server
+         *     definition — there is no command/url/headers shape (that was the old,
+         *     removed field, and Ellipsis does not support bring-your-own MCP servers).
+         *     It only matters when the named integration is set to `opt_in` inclusion; an
+         *     integration in the default `all_sessions` mode is added regardless.
+         */
+        AgentConfigMcpServer: {
+            /** Name */
+            name: string;
+        };
+        /**
+         * AgentConfigMemorySize
+         * @description A memory size as explicit units, summed (binary: 1GB = 1024MB = 1024MiB).
+         *     Set any of `gb`/`mb` (at least one). The alternative to the `8GB`-style
+         *     shorthand string.
+         */
+        AgentConfigMemorySize: {
+            /** Gb */
+            gb?: number | null;
+            /** Mb */
+            mb?: number | null;
+        };
+        /**
+         * AgentConfigMentionPlatform
+         * @description The surface an @ellipsis mention can come from.
+         * @enum {string}
+         */
+        AgentConfigMentionPlatform: 'github' | 'slack' | 'linear';
+        /** AgentConfigMentionTrigger */
+        AgentConfigMentionTrigger: {
+            /**
+             * Platforms
+             * @default []
+             */
+            platforms: components['schemas']['AgentConfigMentionPlatform'][];
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: 'mention';
+        };
+        /** AgentConfigMetadata */
+        AgentConfigMetadata: {
+            /**
+             * Annotations
+             * @default {}
+             */
+            annotations: {
+                [key: string]: string;
+            };
+            /**
+             * Labels
+             * @default []
+             */
+            labels: string[];
+        };
+        /** AgentConfigReactTrigger */
+        AgentConfigReactTrigger: {
+            code_review?: components['schemas']['ReactCodeReview'] | null;
+            issue?: components['schemas']['ReactIssue'] | null;
+            linear_issue?: components['schemas']['ReactLinearIssue'] | null;
+            pull_request?: components['schemas']['ReactPullRequest'] | null;
+            push?: components['schemas']['ReactPush'] | null;
+            sentry?: components['schemas']['ReactSentry'] | null;
+            slack_channel?: components['schemas']['ReactSlackChannel'] | null;
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: 'react';
+        };
+        /** AgentConfigRepository */
+        AgentConfigRepository: {
+            /** Name */
+            name: string;
+            /** Owner */
+            owner?: string | null;
+            /** Ref */
+            ref?: string | null;
+        };
+        /**
+         * AgentConfigSandbox
+         * @description Everything about the sandbox the agent runs in: which `repositories` are
+         *     cloned into it, which environment `variables` it gets, its `compute` sizing,
+         *     how its `image` is customized, and lifecycle `hooks`.
+         *
+         *     Each `variables` entry names a variable to inject; with an inline `value` it
+         *     is hardcoded, without one it is resolved from the customer's sandbox-variables
+         *     store. Only the named variables reach this agent; the rest of the customer's
+         *     stored variables never do. This is how a config brings in the config and
+         *     credentials a custom CLI needs.
+         */
+        AgentConfigSandbox: {
+            /** @default {} */
+            compute: components['schemas']['AgentConfigCompute'];
+            /** @default {} */
+            github: components['schemas']['AgentConfigSandboxGithub'];
+            /** @default {} */
+            hooks: components['schemas']['AgentConfigSandboxHooks'];
+            /** @default {} */
+            image: components['schemas']['AgentConfigSandboxImage'];
+            /**
+             * Ports
+             * @default [
+             *       3000,
+             *       5173,
+             *       8000,
+             *       8080
+             *     ]
+             */
+            ports: number[];
+            /**
+             * Repositories
+             * @default []
+             */
+            repositories: components['schemas']['AgentConfigRepository'][];
+            /**
+             * Variables
+             * @default []
+             */
+            variables: components['schemas']['AgentConfigSandboxVariable'][];
+        };
+        /**
+         * AgentConfigSandboxGithub
+         * @description 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.
+         *
+         *     By default the token carries the installation's full permissions, scoped to
+         *     the repositories in the sandbox. `permissions` narrows what it may do:
+         *     the string `read_only` grants read access to contents, issues, metadata and
+         *     pull requests; a map requests explicit levels per GitHub App permission
+         *     scope (e.g. `{contents: read, pull_requests: write}`) and may never exceed
+         *     what the installation granted. `repositories` narrows which repos the token
+         *     can touch to a subset, 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
+         *     exceed it.
+         */
+        AgentConfigSandboxGithub: {
+            /** Permissions */
+            permissions?: 'read_only' | {
+                [key: string]: string;
+            } | null;
+            /** Repositories */
+            repositories?: string[] | null;
+        };
+        /**
+         * AgentConfigSandboxHooks
+         * @description Shell scripts run at points in the sandbox lifecycle, each as the sandbox
+         *     user with the sandbox's environment variables available. A non-zero exit
+         *     fails the run (exit_status = LIFECYCLE_HOOK_FAILED) and is not retried.
+         *
+         *     `post_start` runs after the container starts, before any repo is cloned —
+         *     repo-independent setup (authenticate a CLI, e.g. `doppler setup`). On Modal
+         *     the repo is baked into the image so it is incidentally present, but
+         *     `post_start` must not depend on repo contents (that's `post_clone`).
+         *
+         *     `post_clone` runs after all repos are cloned/checked out, before the agent —
+         *     repo-dependent setup (`pip install -r requirements.txt`, codegen).
+         *
+         *     Hooks run on every run and their output is never cached. A dependency
+         *     install whose result should be reused across runs belongs in `image.setup`
+         *     (baked into the cached image) instead; keep hooks for per-run work — e.g.
+         *     anything that touches run-scoped credentials.
+         */
+        AgentConfigSandboxHooks: {
+            /** Post Clone */
+            post_clone?: string | null;
+            /** Post Start */
+            post_start?: string | null;
+        };
+        /**
+         * AgentConfigSandboxImage
+         * @description How to customize the container image the agent runs in. The customer
+         *     contributes appended layers (`dockerfile_append`) and a build-time script
+         *     (`setup`) only — Ellipsis owns FROM / base tooling / entrypoint / user.
+         *     Today only inline bodies are supported; a file reference (resolved at the
+         *     run's SHA) will come later.
+         *
+         *     The split: `dockerfile_append` runs when the image is assembled, before any
+         *     repo exists — toolchain installs (a package manager binary, apt packages).
+         *     `setup` runs at image-build time *after* the configured repositories are
+         *     checked out, and its output is captured by the filesystem snapshot that
+         *     becomes the cached image — dependency installs (`poetry install`,
+         *     `npm install`), so later runs start with deps already on disk. Neither runs
+         *     per run; that's `hooks.post_start` / `hooks.post_clone`.
+         */
+        AgentConfigSandboxImage: {
+            /** Dockerfile Append */
+            dockerfile_append?: string | null;
+            /** Setup */
+            setup?: string | null;
+        };
+        /**
+         * AgentConfigSandboxVariable
+         * @description One environment variable injected into the agent's sandbox.
+         *
+         *     `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 customer's sandbox-variables store (dashboard
+         *     / `PUT /sandboxes/variables`) 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.
+         */
+        AgentConfigSandboxVariable: {
+            /** Name */
+            name: string;
+            /** Value */
+            value?: string | null;
+        };
+        /**
+         * AgentConfigSettingsRef
+         * @description 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.
+         */
+        AgentConfigSettingsRef: {
+            /** Path */
+            path: string;
+            repository?: components['schemas']['AgentConfigRepository'] | null;
+        };
+        /**
+         * AgentConfigSkill
+         * @description One config-declared Claude Code skill: a repository directory containing
+         *     a SKILL.md, resolved at run start and installed at the sandbox's personal
+         *     skill level (`~/.claude/skills/<basename(path)>/`). This is how a config
+         *     brings in skills its cloned repositories don't provide — cross-repo refs
+         *     (an org-wide skills repo), public third-party repos, and repo-less runs.
+         *     Skills under a cloned repo's own `.claude/skills/` load by themselves and
+         *     don't need an entry here.
+         */
+        AgentConfigSkill: {
+            /** Path */
+            path: string;
+            repository?: components['schemas']['AgentConfigRepository'] | null;
+        };
+        /** AgentConfigStructuredOutput */
+        AgentConfigStructuredOutput: {
+            /** Json Schema */
+            json_schema: {
+                [key: string]: unknown;
+            };
+            /**
+             * Type
+             * @default json_schema
+             * @constant
+             */
+            type: 'json_schema';
+        };
+        /** AgentConfigSystemFileRef */
+        AgentConfigSystemFileRef: {
+            /** File */
+            file: string;
+        };
         /**
          * AgentSessionExitStatus
          * @description Why a terminal agent session ended — a finer-grained reason than `status`.
@@ -356,6 +843,55 @@ interface components {
          * @enum {string}
          */
         BudgetSource: 'system' | 'account' | 'config' | 'run';
+        /**
+         * CreateReviewRequest
+         * @description Two targets, distinguished by which fields are present: an existing PR
+         *     (`pull_request_number`) or a pushed branch (`branch` + `sha`, the local
+         *     path — the platform finds-or-creates the draft PR).
+         */
+        CreateReviewRequest: {
+            /** Branch */
+            branch?: string | null;
+            /** Budget */
+            budget?: number | null;
+            config?: components['schemas']['AgentConfig'] | null;
+            /** Config Id */
+            config_id?: string | null;
+            /** Config Override */
+            config_override?: {
+                [key: string]: unknown;
+            } | null;
+            /** Config Override Yaml */
+            config_override_yaml?: string | null;
+            /**
+             * Metadata
+             * @default {}
+             */
+            metadata: {
+                [key: string]: string;
+            };
+            /** Model */
+            model?: string | null;
+            /** Owner */
+            owner: string;
+            /**
+             * Post
+             * @default true
+             */
+            post: boolean;
+            /** Pull Request Number */
+            pull_request_number?: number | null;
+            /** Repo */
+            repo: string;
+            /**
+             * @default {
+             *       "kind": "incremental"
+             *     }
+             */
+            scope: components['schemas']['ReviewScope'];
+            /** Sha */
+            sha?: string | null;
+        };
         /**
          * DefaultResolution
          * @description How a session that arrived with no explicit config source resolved its
@@ -366,6 +902,11 @@ interface components {
          * @enum {string}
          */
         DefaultResolution: 'repo_default' | 'account_default' | 'none';
+        /**
+         * EffortLevel
+         * @enum {string}
+         */
+        EffortLevel: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
         /**
          * ExecutionStatus
          * @description Per-execution status ladder (was AgentProcessStatus). Distinct from the
@@ -374,6 +915,65 @@ interface components {
          * @enum {string}
          */
         ExecutionStatus: 'running' | 'failed' | 'done';
+        /**
+         * Finding
+         * @description One parsed finding (shape v1). Line anchors are file line numbers on
+         *     `side` (RIGHT = the new file, LEFT = the old file — a finding on deleted
+         *     code).
+         */
+        Finding: {
+            /** @default not_commentable */
+            anchor: components['schemas']['FindingAnchor'];
+            /**
+             * Category
+             * @default other
+             */
+            category: string;
+            /** Claim */
+            claim: string;
+            /** Confidence */
+            confidence?: number | null;
+            /** End Line */
+            end_line: number;
+            /**
+             * Evidence
+             * @default
+             */
+            evidence: string;
+            /**
+             * Extra
+             * @default {}
+             */
+            extra: {
+                [key: string]: unknown;
+            };
+            /** In Scope */
+            in_scope?: boolean | null;
+            /** Path */
+            path: string;
+            /**
+             * Severity
+             * @default 3
+             */
+            severity: number;
+            /**
+             * Side
+             * @default RIGHT
+             */
+            side: string;
+            /** Snapped From */
+            snapped_from?: [number, number] | null;
+            /** Start Line */
+            start_line: number;
+            /** Suggested Fix */
+            suggested_fix?: string | null;
+        };
+        /**
+         * FindingAnchor
+         * @description Where a finding's line anchor landed relative to the PR diff.
+         * @enum {string}
+         */
+        FindingAnchor: 'valid' | 'snapped' | 'not_commentable';
         /**
          * GithubAccountSnippet
          * @description Sometimes the GitHub API returns a user of github (can include bots)
@@ -406,6 +1006,21 @@ interface components {
          * @enum {string}
          */
         Harness: 'claude_code';
+        /**
+         * IssueAction
+         * @enum {string}
+         */
+        IssueAction: 'opened' | 'closed' | 'commented';
+        /**
+         * LinearIssueAction
+         * @enum {string}
+         */
+        LinearIssueAction: 'opened';
+        /** ListReviewsResponse */
+        ListReviewsResponse: {
+            /** Reviews */
+            reviews: components['schemas']['Review'][];
+        };
         /** ListSessionExecutionsResponse */
         ListSessionExecutionsResponse: {
             /** Executions */
@@ -435,34 +1050,6 @@ interface components {
             /** Turns */
             turns: components['schemas']['AgentTurn'][];
         };
-        /** ModelTokensInfo */
-        ModelTokensInfo: {
-            /**
-             * Cache Creation Input Tokens
-             * @default 0
-             */
-            cache_creation_input_tokens: number;
-            /**
-             * Cache Read Input Tokens
-             * @default 0
-             */
-            cache_read_input_tokens: number;
-            /**
-             * Cost Usd
-             * @default 0
-             */
-            cost_usd: number;
-            /**
-             * Input Tokens
-             * @default 0
-             */
-            input_tokens: number;
-            /**
-             * Output Tokens
-             * @default 0
-             */
-            output_tokens: number;
-        };
         /**
          * ParentKind
          * @description How a session relates to its predecessor (parent_agent_session_id) —
@@ -484,6 +1071,169 @@ interface components {
          * @enum {string}
          */
         PromptBlockedReason: 'mention_surface' | 'ephemeral_trigger' | 'non_interactive' | 'closed' | 'laptop';
+        /**
+         * PullRequestAction
+         * @enum {string}
+         */
+        PullRequestAction: 'opened' | 'pushed' | 'merged' | 'closed' | 'review_submitted' | 'commented';
+        /**
+         * ReactAudience
+         * @description Who may trigger a react surface, classified on the stable entity author
+         *     (the pusher for `push`). The set is include minus exclude: an author matches
+         *     iff they are in the include set (`users`/`bots`) AND not in an exclude set.
+         *
+         *     `users`/`bots` each accept `True` (all humans / all bots), a list of logins,
+         *     or `[]`/`False` (none). Logins are resolved to account ids at save time.
+         */
+        ReactAudience: {
+            /**
+             * Bots
+             * @default false
+             */
+            bots: string[] | boolean;
+            /**
+             * Exclude Bots
+             * @default []
+             */
+            exclude_bots: string[];
+            /**
+             * Exclude Users
+             * @default []
+             */
+            exclude_users: string[];
+            /**
+             * Users
+             * @default true
+             */
+            users: string[] | boolean;
+        };
+        /**
+         * ReactCodeReview
+         * @description Action-less: reviews the unreviewed delta (watermark...head) on every head
+         *     advance of a matched PR, never re-commenting reviewed lines. Its entity is
+         *     the pull request; it reuses the `pull_request` filter set minus `on`.
+         */
+        ReactCodeReview: {
+            /**
+             * Base
+             * @default []
+             */
+            base: string[];
+            /** Draft */
+            draft?: boolean | null;
+            for?: components['schemas']['ReactAudience'];
+            /**
+             * Head
+             * @default []
+             */
+            head: string[];
+            /**
+             * Labels
+             * @default []
+             */
+            labels: string[];
+            /**
+             * Paths
+             * @default []
+             */
+            paths: string[];
+            /**
+             * Repositories
+             * @default []
+             */
+            repositories: string[];
+        };
+        /** ReactIssue */
+        ReactIssue: {
+            for?: components['schemas']['ReactAudience'];
+            /**
+             * Labels
+             * @default []
+             */
+            labels: string[];
+            /** On */
+            on: components['schemas']['IssueAction'][];
+            /**
+             * Repositories
+             * @default []
+             */
+            repositories: string[];
+        };
+        /** ReactLinearIssue */
+        ReactLinearIssue: {
+            for?: components['schemas']['ReactAudience'];
+            /**
+             * On
+             * @default [
+             *       "opened"
+             *     ]
+             */
+            on: components['schemas']['LinearIssueAction'][];
+        };
+        /** ReactPullRequest */
+        ReactPullRequest: {
+            /**
+             * Base
+             * @default []
+             */
+            base: string[];
+            /** Draft */
+            draft?: boolean | null;
+            for?: components['schemas']['ReactAudience'];
+            /**
+             * Head
+             * @default []
+             */
+            head: string[];
+            /**
+             * Labels
+             * @default []
+             */
+            labels: string[];
+            /** On */
+            on: components['schemas']['PullRequestAction'][];
+            /**
+             * Paths
+             * @default []
+             */
+            paths: string[];
+            /**
+             * Repositories
+             * @default []
+             */
+            repositories: string[];
+        };
+        /** ReactPush */
+        ReactPush: {
+            /**
+             * Branch
+             * @default []
+             */
+            branch: string[];
+            for?: components['schemas']['ReactAudience'];
+            /**
+             * Paths
+             * @default []
+             */
+            paths: string[];
+            /**
+             * Repositories
+             * @default []
+             */
+            repositories: string[];
+        };
+        /** ReactSentry */
+        ReactSentry: {
+            /** On */
+            on: components['schemas']['SentryAction'][];
+            /**
+             * Projects
+             * @default []
+             */
+            projects: string[];
+        };
+        /** ReactSlackChannel */
+        ReactSlackChannel: Record<string, never>;
         /**
          * RecordSource
          * @description `session_records.source` — the client render switch. `lifecycle` rows are
@@ -492,6 +1242,129 @@ interface components {
          * @enum {string}
          */
         RecordSource: 'lifecycle' | 'claude_code';
+        /**
+         * ResolvedReviewScope
+         * @description The range a minted review actually covers, read back off the (possibly
+         *     doctored) PR so it can never disagree with what the session was handed.
+         */
+        ResolvedReviewScope: {
+            /** Empty */
+            empty: boolean;
+            /** Head */
+            head: string;
+            kind: components['schemas']['ReviewScopeKind'];
+            /** Watermark */
+            watermark: string | null;
+        };
+        /**
+         * Review
+         * @description One review = one `code_review` session over one range. `id` IS the
+         *     session id, so `/v1/sessions/{id}/stream`, `/records`, `/ide`, and stop all
+         *     work on it unchanged.
+         *
+         *     `review_body`, `findings`, and `counters` come from the
+         *     `code_review_outbox` row, which only exists after finalize — while a review
+         *     runs they are null/[]/null with `status: "running"`. That is why a client
+         *     streams the session and then re-GETs the review, the same two-step
+         *     `agent asset get` uses.
+         */
+        Review: {
+            /** Completed At */
+            completed_at?: string | null;
+            /**
+             * Cost Millicents
+             * @default 0
+             */
+            cost_millicents: number;
+            counters?: components['schemas']['ReviewCounters'] | null;
+            /** Created At */
+            created_at?: string | null;
+            /**
+             * Findings
+             * @default []
+             */
+            findings: components['schemas']['Finding'][];
+            /** Id */
+            id: string;
+            /** Post Error */
+            post_error?: string | null;
+            /** Posted Review Id */
+            posted_review_id?: number | null;
+            pull_request: components['schemas']['ReviewPullRequest'];
+            repository: components['schemas']['ReviewRepository'];
+            /** Review Body */
+            review_body?: string | null;
+            scope: components['schemas']['ResolvedReviewScope'];
+            /** Status */
+            status: string;
+            /** Trigger */
+            trigger: string;
+        };
+        /**
+         * ReviewCounters
+         * @description Parser and anchor reliability for one review, straight off the outbox
+         *     row. `parser_version` records which parser rules produced the findings, so
+         *     a parser change can re-parse from the raw files offline.
+         */
+        ReviewCounters: {
+            /** N Anchor Valid */
+            n_anchor_valid: number;
+            /** N Coerced */
+            n_coerced: number;
+            /** N Dropped */
+            n_dropped: number;
+            /** N Not Commentable */
+            n_not_commentable: number;
+            /** N Parsed */
+            n_parsed: number;
+            /** N Raw Lines */
+            n_raw_lines: number;
+            /** N Snapped */
+            n_snapped: number;
+            /** Parser Version */
+            parser_version: string;
+        };
+        /** ReviewPullRequest */
+        ReviewPullRequest: {
+            /**
+             * Manufactured
+             * @default false
+             */
+            manufactured: boolean;
+            /** Number */
+            number: number;
+            /** Url */
+            url: string;
+        };
+        /** ReviewRepository */
+        ReviewRepository: {
+            /** Id */
+            id: number;
+            /** Name */
+            name: string;
+            /** Owner */
+            owner: string;
+        };
+        /**
+         * ReviewScope
+         * @description Which range to review. `watermark`/`head` pin it explicitly (the
+         *     harness's `--watermark`/`--head` promoted to the API — the doctored-PR path
+         *     that lets you evaluate a reviewer over a historical range). Values are SHAs
+         *     only; resolving a 1-based commit index stays a CLI/pyscript nicety.
+         */
+        ReviewScope: {
+            /** Head */
+            head?: string | null;
+            /** @default incremental */
+            kind: components['schemas']['ReviewScopeKind'];
+            /** Watermark */
+            watermark?: string | null;
+        };
+        /**
+         * ReviewScopeKind
+         * @enum {string}
+         */
+        ReviewScopeKind: 'incremental' | 'full';
         /**
          * RunStatus
          * @description What the current (or most recent) execution is doing (backs `run`).
@@ -513,6 +1386,11 @@ interface components {
             /** Message */
             message: string;
         };
+        /**
+         * SentryAction
+         * @enum {string}
+         */
+        SentryAction: 'issue_alert' | 'metric_alert';
         /** SessionExecutionWire */
         SessionExecutionWire: {
             /** Agent Session Id */
@@ -712,7 +1590,19 @@ interface components {
             /** Status */
             status: string | null;
         };
-        /** TokensInfo */
+        /**
+         * TokensInfo
+         * @description Token/cost usage, per record (one API call's counts, aggregate fields at
+         *     their zero defaults) or aggregated per execution/session
+         *     (compute_spend_from_records derives num_turns and cost_usd).
+         *
+         *     Strict on purpose: this is our own persisted schema, so an unknown key is a
+         *     writer bug (the num_turns=0 bug shipped because a Claude Code usage dict
+         *     validated leniently against this model, silently zeroing every
+         *     non-overlapping field). Legacy keys were dropped from persisted blobs by
+         *     the 2026-07-26 tokens_info migration; per-model usage lives on
+         *     `execution.model_usage` (CC's modelUsage, verbatim).
+         */
         TokensInfo: {
             /**
              * Cache Creation Input Tokens
@@ -729,11 +1619,6 @@ interface components {
              * @default 0
              */
             cost_usd: number;
-            /**
-             * Initial System Prompt Tokens
-             * @default 0
-             */
-            initial_system_prompt_tokens: number;
             /**
              * Input Tokens
              * @default 0
@@ -749,46 +1634,6 @@ interface components {
              * @default 0
              */
             output_tokens: number;
-            /**
-             * Per Model
-             * @default {}
-             */
-            per_model: {
-                [key: string]: components['schemas']['ModelTokensInfo'];
-            };
-            /**
-             * Per Turn
-             * @default []
-             */
-            per_turn: components['schemas']['TurnTokensInfo'][];
-            /**
-             * Thinking Tokens
-             * @default 0
-             */
-            thinking_tokens: number;
-        };
-        /** TurnTokensInfo */
-        TurnTokensInfo: {
-            /**
-             * Cache Creation Input Tokens
-             * @default 0
-             */
-            cache_creation_input_tokens: number;
-            /**
-             * Cache Read Input Tokens
-             * @default 0
-             */
-            cache_read_input_tokens: number;
-            /**
-             * Input Tokens
-             * @default 0
-             */
-            input_tokens: number;
-            /**
-             * Output Tokens
-             * @default 0
-             */
-            output_tokens: number;
         };
         /** ValidationError */
         ValidationError: {
@@ -816,6 +1661,112 @@ interface components {
     pathItems: never;
 }
 interface operations {
+    list_reviews_v1_reviews_get: {
+        parameters: {
+            query?: {
+                owner?: string | null;
+                repo?: string | null;
+                pull_request_number?: number | null;
+                pull_request_id?: string | null;
+                status?: components['schemas']['AgentSessionStatus'] | null;
+                limit?: number;
+            };
+            header?: {
+                'user-agent'?: string | null;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['ListReviewsResponse'];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['HTTPValidationError'];
+                };
+            };
+        };
+    };
+    create_review_v1_reviews_post: {
+        parameters: {
+            query?: never;
+            header?: {
+                'user-agent'?: string | null;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                'application/json': components['schemas']['CreateReviewRequest'];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['Review'];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['HTTPValidationError'];
+                };
+            };
+        };
+    };
+    get_review_v1_reviews__review_id__get: {
+        parameters: {
+            query?: never;
+            header?: {
+                'user-agent'?: string | null;
+            };
+            path: {
+                review_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['Review'];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['HTTPValidationError'];
+                };
+            };
+        };
+    };
     get_agent_session_v1_sessions__session_id__get: {
         parameters: {
             query?: never;
@@ -1228,32 +2179,25 @@ interface SessionRecordWire {
     tokens_info: TokensInfo | null;
     tools: string[] | null;
 }
+/**
+ * Token/cost usage, per record (one API call's counts, aggregate fields at
+ * their zero defaults) or aggregated per execution/session
+ * (compute_spend_from_records derives num_turns and cost_usd).
+ *
+ * Strict on purpose: this is our own persisted schema, so an unknown key is a
+ * writer bug (the num_turns=0 bug shipped because a Claude Code usage dict
+ * validated leniently against this model, silently zeroing every
+ * non-overlapping field). Legacy keys were dropped from persisted blobs by
+ * the 2026-07-26 tokens_info migration; per-model usage lives on
+ * `execution.model_usage` (CC's modelUsage, verbatim).
+ */
 interface TokensInfo {
     cache_creation_input_tokens: number;
     cache_read_input_tokens: number;
     cost_usd: number;
-    initial_system_prompt_tokens: number;
     input_tokens: number;
     num_turns: number;
     output_tokens: number;
-    per_model: {
-        [k: string]: ModelTokensInfo;
-    };
-    per_turn: TurnTokensInfo[];
-    thinking_tokens: number;
-}
-interface ModelTokensInfo {
-    cache_creation_input_tokens: number;
-    cache_read_input_tokens: number;
-    cost_usd: number;
-    input_tokens: number;
-    output_tokens: number;
-}
-interface TurnTokensInfo {
-    cache_creation_input_tokens: number;
-    cache_read_input_tokens: number;
-    input_tokens: number;
-    output_tokens: number;
 }
 /**
  * LWW snapshot of the enriched public session (§4.1) — the only way
@@ -1311,5 +2255,13 @@ type AgentTurn = components['schemas']['AgentTurn'];
 type AgentTurnStatus = components['schemas']['AgentTurnStatus'];
 type ListSessionExecutionsResponse = components['schemas']['ListSessionExecutionsResponse'];
 type SessionExecutionWire = components['schemas']['SessionExecutionWire'];
+type CreateReviewRequest = components['schemas']['CreateReviewRequest'];
+type Review = components['schemas']['Review'];
+type ListReviewsResponse = components['schemas']['ListReviewsResponse'];
+type ReviewScope = components['schemas']['ReviewScope'];
+type ReviewScopeKind = components['schemas']['ReviewScopeKind'];
+type ResolvedReviewScope = components['schemas']['ResolvedReviewScope'];
+type ReviewCounters = components['schemas']['ReviewCounters'];
+type Finding = components['schemas']['Finding'];
 
-export type { AgentSessionWire as A, BudgetSource as B, TurnTokensInfo as C, DefaultResolution as D, ErrorFrame as E, components as F, GithubAccountSnippet as G, Harness as H, paths as I, ListSessionRecordsResponse as L, ModelTokensInfo as M, ParentKind as P, RecordsAppendFrame as R, SessionMessageWire as S, TokensInfo as T, ListSessionTurnsResponse as a, ListSessionExecutionsResponse as b, AgentSessionExitStatus as c, AgentSessionPr as d, AgentSessionSource as e, AgentSessionStatus as f, AgentTurn as g, AgentTurnStatus as h, AttributionType as i, DeltaFrame as j, DoneFrame as k, GithubAccountType as l, HeartbeatFrame as m, PromptBlockedReason as n, SendSessionMessageRequest as o, SessionExecutionWire as p, SessionFrame as q, SessionLiveness as r, SessionMessageStatus as s, SessionPrompting as t, SessionRecordWire as u, SessionState as v, SessionStreamFrame as w, SessionSurface as x, SnapshotFrame as y, StreamFrame as z };
+export type { AgentSessionWire as A, BudgetSource as B, CreateReviewRequest as C, DefaultResolution as D, ErrorFrame as E, Finding as F, GithubAccountSnippet as G, Harness as H, SessionRecordWire as I, SessionState as J, SessionStreamFrame as K, ListSessionRecordsResponse as L, SessionSurface as M, SnapshotFrame as N, StreamFrame as O, ParentKind as P, components as Q, Review as R, SessionMessageWire as S, TokensInfo as T, paths as U, ListSessionTurnsResponse as a, ListSessionExecutionsResponse as b, ListReviewsResponse as c, AgentSessionExitStatus as d, AgentSessionPr as e, AgentSessionSource as f, AgentSessionStatus as g, AgentTurn as h, AgentTurnStatus as i, AttributionType as j, DeltaFrame as k, DoneFrame as l, GithubAccountType as m, HeartbeatFrame as n, PromptBlockedReason as o, RecordsAppendFrame as p, ResolvedReviewScope as q, ReviewCounters as r, ReviewScope as s, ReviewScopeKind as t, SendSessionMessageRequest as u, SessionExecutionWire as v, SessionFrame as w, SessionLiveness as x, SessionMessageStatus as y, SessionPrompting as z };