@evolvingmachines/evolve 0.0.55-project-sable.20260916.db0bc0bb

package/dist/types-DlpTxdR_.d.cts

@@ -0,0 +1,4777 @@
+/**
+ * Public types for the hosted evaluations API — datasets, jobs, trials, agents.
+ *
+ * THE VOCABULARY IS THE WIRE'S. Every field on a wire-shaped object below is
+ * spelled exactly as spec/openapi.yaml spells it (snake_case), so the spec
+ * reads as the SDK's own field reference and nothing is ever lost in a casing
+ * translation. The only camelCase keys are the four frozen historical spots
+ * the spec names: the page envelope (`items`/`nextCursor`/`hasMore`), the job
+ * body's `trials.byStatus`, the compare response's `taskMatrix`, and the error
+ * envelope (`retryAfterSec`/`requestId`). That freeze is a WIRE law, not a
+ * property-name law: both SDKs send and receive those keys camelCase, this SDK
+ * also exposes them verbatim, and the Python SDK maps them to snake_case
+ * attributes (`next_cursor`/`has_more`/`by_status`/`task_matrix`,
+ * `retry_after_sec`/`request_id`). SDK-side controls that never touch the
+ * wire — client config, delivery options, callbacks — stay
+ * TypeScript-idiomatic camelCase.
+ */
+/** Configuration for the datasets() / agents() / jobs() / trials() factories */
+interface HostedClientConfig {
+    /** API key (default: process.env.EVOLVE_API_KEY) */
+    apiKey?: string;
+    /** API base URL override (default: the Evolve dashboard API) */
+    baseUrl?: string;
+}
+/**
+ * ONE page shape for every collection on this surface — top level or nested.
+ *
+ * `nextCursor` means one thing everywhere: pass it back as the next call's
+ * `cursor` for the next page, and `null` means there is no next page. It never
+ * echoes where you already are, so a poller can always tell it has caught up.
+ * The three envelope keys are frozen verbatim on the wire.
+ */
+interface Page<T> {
+    items: T[];
+    nextCursor: string | null;
+    hasMore: boolean;
+}
+/**
+ * A value you can `await`, with the rest of the promise surface attached.
+ *
+ * The dual-use handles below were `PromiseLike` alone, which is enough for
+ * `await` and nothing else — so `client.list().catch(...)` was a compile error
+ * two lines after `await client.list()` compiled fine, and `.finally()` for a
+ * spinner was unavailable. A handle that is 90% of a promise is worse than one
+ * that is none of it, because the missing 10% is only discovered at the call
+ * site that needed it.
+ *
+ * `then`/`catch`/`finally` all return real Promises, so anything chained off a
+ * handle behaves exactly like promise code from that point on.
+ */
+interface Awaitable<T> extends PromiseLike<T> {
+    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<T>;
+}
+/** Cursor + page-size options, accepted by every paged call */
+interface PageOptions {
+    /** Max items per page */
+    limit?: number;
+    /** Cursor from a previous page's nextCursor */
+    cursor?: string;
+}
+/**
+ * Job lifecycle status (wire values, as the API emits them).
+ * Terminal: COMPLETED, CANCELLED, FAILED.
+ */
+type JobStatus = "QUEUED" | "RUNNING" | "CANCELLING" | "COMPLETED" | "CANCELLED" | "FAILED";
+/**
+ * Trial status law: a valid reward (including 0) = SCORED; verifier crash or
+ * out-of-domain reward = SCORING_ERROR (never a fabricated zero);
+ * INFRASTRUCTURE_ERROR: the trial was lost before a result was recorded;
+ * BUDGET: a budget above the trial's own cap refused it — the account's
+ * credits, the organization's monthly budget, or the platform's global stop
+ * — at the platform's pre-boot wallet check (nothing was started) or mid-run;
+ * `exception_info.exception_type` is `ApiUsageLimitError`, the message
+ * carries the subject (`user:`, `team:`, `other:`) right after the
+ * `[agent-phase:budget_exhausted]` stage prefix every agent-phase failure
+ * detail carries; never retried
+ * automatically, resume once the budget is raised (a hosted extension —
+ * Harbor has no wallet); INDETERMINATE: the platform cannot tell whether the
+ * trial completed.
+ *
+ * A runtime value (not only a type), like TRIAL_ARTIFACT_STREAMS, so the CLI
+ * can validate a `--status` filter against this list instead of a second copy.
+ */
+declare const TRIAL_STATUSES: readonly ["QUEUED", "RUNNING", "SCORING", "SCORED", "SCORING_ERROR", "INFRASTRUCTURE_ERROR", "BUDGET", "INDETERMINATE", "CANCELLED"];
+/** One trial lifecycle status — see TRIAL_STATUSES for the law. */
+type TrialStatus = (typeof TRIAL_STATUSES)[number];
+/**
+ * Sandbox provider a hosted job runs on. Named `EvalSandboxProvider` to avoid
+ * colliding with the core SDK's `SandboxProvider` (the sandbox-abstraction
+ * interface). A runtime value for the same reason as TRIAL_STATUSES: the CLI
+ * validates `-e/--env` against it.
+ */
+declare const EVAL_SANDBOX_PROVIDERS: readonly ["e2b", "daytona", "modal"];
+/** One sandbox provider — see EVAL_SANDBOX_PROVIDERS. */
+type EvalSandboxProvider = (typeof EVAL_SANDBOX_PROVIDERS)[number];
+/**
+ * The list scopes — Harbor's `--scope` on `harbor hub job list` (their
+ * cli/hub.py list_jobs_cmd: my | shared | all). `my` is what you created;
+ * `shared` is what your organizations' other members created — every row the
+ * per-id doors already open for you that is not your own. Harbor's `all`
+ * adds public rows; nothing hosted is public, so the server refuses it and
+ * the CLI refuses it at the keyboard. A runtime value for the same reason as
+ * TRIAL_STATUSES: the CLI validates `--scope` against it.
+ */
+declare const JOB_LIST_SCOPES: readonly ["my", "shared"];
+/** One list scope — see JOB_LIST_SCOPES. */
+type JobListScope = (typeof JOB_LIST_SCOPES)[number];
+/**
+ * An analysis's own lifecycle ladder — lowercase, the object's Harbor
+ * dialect (spec TrialAnalysis.status). A runtime value so the CLI validates
+ * `analysis list --status` against it instead of a second copy.
+ */
+declare const ANALYSIS_STATUSES: readonly ["queued", "running", "completed", "failed"];
+/** One analysis status — see ANALYSIS_STATUSES. */
+type AnalysisStatus = (typeof ANALYSIS_STATUSES)[number];
+/**
+ * A task quality check's own lifecycle ladder — derived from its tasks
+ * (spec Check.status): `queued` while no task started, `running` while any
+ * task is still queued or running and one has started, `completed` once
+ * every task settled. A check never fails as a whole (each task carries its
+ * own typed failure). A runtime value so the CLI validates `check list
+ * --status` against it instead of a second copy.
+ */
+declare const CHECK_STATUSES: readonly ["queued", "running", "completed"];
+/** One check status — see CHECK_STATUSES. */
+type CheckStatus = (typeof CHECK_STATUSES)[number];
+/**
+ * Which lane a settled trial's `agent_result.cost_usd` came from. Only
+ * `"measured"` is final. `"measured_provisional"` is a real gateway reading
+ * taken inside its asynchronous spend flush — an honest floor a deferred pass
+ * later confirms or raises into `"measured"`. `"assumed_cap"` means nobody
+ * measured this trial: the figure it carries is zero, a placeholder and never
+ * the cap (the platform under-bills rather than publish an invented number),
+ * replaced when a real reading lands. Read anything but `"measured"` as not
+ * yet final.
+ */
+type SpendSource = "measured" | "measured_provisional" | "assumed_cap";
+/**
+ * THE ONE-HOME USAGE READING — "what has this run's meter said so far", money
+ * and tokens from the SAME gateway spend-log records so the two can never
+ * describe different sets of requests. Served under the one key `usage`, with
+ * these exact keys, by the trial surfaces and the managed-agents session
+ * surfaces alike. While the run is alive the platform's own poll raises the
+ * numbers (~30s cadence over a gateway that batches its logs late), so a
+ * polling reader sees them tick; once settled, the settled figures replace
+ * the live ones under the same keys. The whole object is null when the meter
+ * has never answered — never a fabricated zero.
+ */
+interface UsageReading {
+    /**
+     * True while every number is a LOWER BOUND that can still grow — the run is
+     * alive, or its settled lane is not yet confirmed. False = settled; the
+     * reading will not move again.
+     */
+    provisional: boolean;
+    /**
+     * Metered model spend so far, USD. Null = the money was never measured
+     * (which a trial's `spend_source` lane `assumed_cap` states; the token
+     * fields beside it may still carry real readings).
+     */
+    spent_usd: number | null;
+    /** Prompt tokens so far, INCLUDING the cached share and the cache-write share. */
+    input_tokens: number | null;
+    /** The cached share of `input_tokens` (read from the provider's prompt cache). */
+    cached_input_tokens: number | null;
+    /**
+     * The share of `input_tokens` WRITTEN to the provider's prompt cache.
+     * Anthropic bills it at a premium above the plain input price, so it is
+     * the fourth count `spent_usd` needs to be reproducible from the tokens;
+     * providers without a cache-write price report 0. Null when the meter
+     * never answered — and on a run settled before the platform recorded this
+     * share (an older server omits the key), where the three counts beside it
+     * stay real: null is never a fabricated 0.
+     */
+    cache_write_tokens: number | null;
+    /** Completion tokens so far. */
+    output_tokens: number | null;
+    /** When this reading was taken — show its age, never the figure alone. */
+    as_of: string | null;
+}
+/** Where a trial's verifier executed: inside the agent's environment, or a separate one */
+type VerifierEnvironmentMode = "shared" | "separate";
+/**
+ * Which step a RUNNING trial is in, so a polling caller can tell a slow build
+ * from a slow agent — RUNNING alone cannot.
+ */
+type AttemptPhase = "prepare" | "build" | "boot" | "install" | "agent" | "verify" | "persist";
+/**
+ * Trial count histogram by status. EVERY status is present, zeros included, so
+ * a status bar can be drawn straight off the response without hardcoding the
+ * enum and discovering a new status only when a bar goes missing.
+ */
+type TrialCounts = Record<TrialStatus, number>;
+/**
+ * The one "how many" shape: a total plus the zeros-included histogram.
+ * `byStatus` is one of the four frozen camelCase wire keys.
+ */
+interface TrialStatusTally {
+    total: number;
+    byStatus: TrialCounts;
+}
+/** A resolved dataset reference as echoed on job bodies. */
+interface DatasetRef {
+    name: string;
+    version: string;
+}
+/**
+ * One dataset a job runs, with per-dataset task filters. `task_names` and
+ * `exclude_task_names` are glob patterns; `n_tasks` caps the task count AFTER
+ * filtering. A bare `name` resolves to the active version (`no_active_version`
+ * when none).
+ */
+interface DatasetSelector {
+    /** Catalog dataset name. */
+    name: string;
+    /** Pin a version; omitted, the active version is used. */
+    version?: string;
+    /** Include filter — glob patterns over task names. */
+    task_names?: string[];
+    /** Exclude filter — glob patterns over task names. */
+    exclude_task_names?: string[];
+    /** Cap the task count after filters are applied. */
+    n_tasks?: number;
+}
+/**
+ * One agent arm of a job: an agent (built-in or registered) plus a model. A
+ * model is always required; the server applies no default.
+ *
+ * `version` pins an agent version; omitted, the platform resolves the latest
+ * supported (`agent_version_not_found` when a pin cannot resolve). The version
+ * that actually RAN is recorded on every trial as `agent_info.version`.
+ *
+ * `reasoning_effort` is the platform extension: declared effort, PART OF THE
+ * ARM'S IDENTITY like the agent, the model and the version pin — the same
+ * agent and model at "low" and at "high" are two systems, and they
+ * de-duplicate separately. Accepted values are published by /api/meta; an
+ * effort the agent cannot apply is refused at creation, never recorded and
+ * silently dropped.
+ */
+interface AgentArmInput {
+    /** Agent name — a built-in or one registered under /api/agents. */
+    name: string;
+    model_name: string;
+    version?: string | null;
+    reasoning_effort?: string | null;
+    /**
+     * Agent kwargs, Harbor's `--ak` channel and wire shape. The one key this
+     * platform delivers is `config`: an INLINE JSON object converted into the
+     * harness's native settings document inside the sandbox (the CLI resolves
+     * `--ak config=<path>` to the file's parsed content before sending — the
+     * server never reads a client path). The user document is the base;
+     * platform routing is stamped on top. Part of the arm's identity: the same
+     * agent+model with two configs are two arms.
+     *
+     * Server acceptance is typed, never silent: an unrecognized kwarg key is
+     * `agent_kwarg_unsupported`, `config` for an agent without native-config
+     * support (see /api/meta `supports_config`) is `agent_config_unsupported`,
+     * and a config key touching billing, base URLs, routing, or env is
+     * `agent_config_key_refused`.
+     */
+    kwargs?: Record<string, unknown> | null;
+    /**
+     * Named agent-settings preset for this arm: `no-internet` (vendor
+     * server-side web tools off — Claude settings deny WebSearch/WebFetch,
+     * Codex `-c web_search=disabled`) or `pinned-context` (one fixed effective
+     * context window). A platform-authored bundle delivered through the same
+     * channel as `kwargs.config`, stamped ON TOP of the user document — normal
+     * users tick a box and never learn what `--ak` is. Part of the arm's
+     * identity: the same agent+model with and without a preset are two arms.
+     *
+     * Acceptance is typed, never silent: an unknown preset name is
+     * `invalid_input`, and a known preset on an agent whose /api/meta entry
+     * does not list it under `presets` is `agent_preset_unsupported` — a
+     * preset the platform cannot guarantee is refused, never half-applied.
+     * Enforcement is harness configuration, exactly as Harbor delivers it.
+     */
+    preset?: string | null;
+    /**
+     * Skill references mounted into every run of this arm — Harbor's
+     * trial-config shape: a list of source strings (models/trial/config.py:81).
+     * Accepted forms: `skills.sh/<owner>/<repo>[/<skill>]`, `org/repo[@ref]`,
+     * an https git URL (optionally `/tree/<ref>/<subdir>`), `upload:<id>`
+     * naming a skill uploaded to the platform, or `name:<skill-name>` — the
+     * caller's moving name pointer, resolved SERVER-SIDE at creation to its
+     * current record and pinned as that record's `upload:<id>` (an unknown
+     * name is the typed `skill_name_not_found`). The SDK passes the string
+     * through — no client-side resolution. Local filesystem paths are a
+     * CLIENT-side convenience only — the CLI uploads the folder first and sends
+     * the `upload:<id>` handle; the server refuses raw paths.
+     *
+     * Git references are PINNED at job creation (the exact commit resolved
+     * once, recorded, and used by every trial), so a moving branch can never
+     * make two trials of one job run different skill content. Part of the
+     * arm's identity: the same agent and model with different skills are two
+     * arms.
+     */
+    skills?: string[] | null;
+}
+/**
+ * Provenance of one skill an arm's runs actually mounted — Harbor's
+ * AgentSkillLock vocabulary (models/job/lock.py:141): name, source reference,
+ * content digest, and for git-backed skills the repo URL and exact commit.
+ */
+interface SkillLock {
+    name: string;
+    /** The pinned reference the content came from. */
+    source: string;
+    /** Content digest, Harbor's recipe: "sha256:<hex>". */
+    digest: string;
+    git_url: string | null;
+    git_commit_id: string | null;
+}
+/** One agent arm as echoed on job bodies (requested pin; null = took the latest). */
+interface AgentArm {
+    name: string;
+    model_name: string;
+    version: string | null;
+    reasoning_effort: string | null;
+    /** The arm's agent kwargs as accepted; null when none were declared. */
+    kwargs: Record<string, unknown> | null;
+    /** The arm's named settings preset; null when none was declared. */
+    preset: string | null;
+    /** The arm's skill references, pinned spelling. Empty = no skills. */
+    skills: string[];
+    /**
+     * What actually mounted, one lock per skill — stamped when the arm's first
+     * trial resolves its skills; null until then (and stays null on a job whose
+     * trials never ran).
+     */
+    skill_locks: SkillLock[] | null;
+}
+/**
+ * Provenance of a derived job. `action: "regrade"` = verifier-only re-run of
+ * the source; `action: "resume"` (platform extension) = new job over the
+ * source's failed and stopped trials; `action: "retry"` = manual retry — new
+ * job over caller-SELECTED source trials (explicit ids, failed-only, or the
+ * whole job). `type` is always "hub" on this hosted surface.
+ */
+interface SourceJob {
+    action: "regrade" | "resume" | "retry";
+    type: "hub";
+    job_id: string;
+}
+/**
+ * Auto-retry policy input — Harbor's RetryConfig vocabulary verbatim. Only
+ * trials that settle INFRASTRUCTURE_ERROR are ever considered; the
+ * include/exclude sets refine within that class by exception name, exclude
+ * taking precedence (Harbor's rule). Every omitted field takes Harbor's own
+ * default, with ONE named deviation: `max_retries` omitted takes the
+ * PLATFORM fleet default (published as `limits.job.default_max_retries` on
+ * GET /api/meta; 2 unless the operator tuned it) rather than Harbor's 0 —
+ * infrastructure errors on a hosted fleet retry automatically. Send
+ * `max_retries: 0` to turn retries off. Each attempt carries the job's FULL
+ * per-trial spend cap, and `worst_case_spend_usd` states the
+ * (max_retries + 1) product outright.
+ */
+interface RetryConfigInput {
+    /** Maximum automatic retries per trial (0-10). Omitted = fleet default; 0 = off. */
+    max_retries?: number;
+    /**
+     * Exception types to retry on. Null, omitted, or the empty array = no
+     * filter — Harbor's include check treats the empty set exactly like None,
+     * so `[]` never means "retry nothing".
+     */
+    include_exceptions?: string[] | null;
+    /**
+     * Exception types to NOT retry on; wins over include_exceptions. Omitted =
+     * Harbor's default non-retryable set (AgentTimeoutError,
+     * VerifierTimeoutError, RewardFileNotFoundError, RewardFileEmptyError,
+     * VerifierOutputParseError, ApiUsageLimitError, AgentSafetyRefusalError,
+     * AgentAuthenticationError, ModelNotFoundError). An EXPLICIT null is
+     * DIFFERENT from omitting: null turns exclusions off entirely — everything
+     * the include set admits is retried, the default set included — exactly
+     * Harbor's None (their exclude check is guarded by
+     * `if exclude_exceptions and ...`, so None disables it).
+     */
+    exclude_exceptions?: string[] | null;
+    /** Multiplier for exponential backoff wait time (default 1.0). */
+    wait_multiplier?: number;
+    /** Minimum wait in seconds between retries (default 1.0). */
+    min_wait_sec?: number;
+    /** Maximum wait in seconds between retries (default 60.0; Harbor's field, no ceiling). */
+    max_wait_sec?: number;
+}
+/**
+ * The RESOLVED auto-retry policy a job runs under, echoed on every job body —
+ * the caller's values or the defaults of the day, resolved at create and
+ * stored. Backoff between attempts is Harbor's formula:
+ * min(min_wait_sec x wait_multiplier^attempt, max_wait_sec).
+ */
+interface RetryConfig {
+    max_retries: number;
+    include_exceptions: string[] | null;
+    exclude_exceptions: string[];
+    wait_multiplier: number;
+    min_wait_sec: number;
+    max_wait_sec: number;
+}
+/**
+ * One analysis criterion — Harbor's RubricCriterion verbatim (their
+ * cli/quality_checker/models.py `{name, description, guidance}`). The name
+ * becomes the key of the matching entry in `checks`; the guidance is what the
+ * analyzer agent is instructed with.
+ */
+interface RubricCriterion {
+    /**
+     * Criterion identifier, snake_case (it keys the result's `checks` object).
+     * The platform's default rubrics name seven criteria for analyze and eleven for check.
+     */
+    name: string;
+    /** What the criterion evaluates, one sentence. */
+    description: string;
+    /**
+     * Evaluation guidance handed to the analyzer agent — what evidence to read
+     * and what PASS / FAIL / NOT_APPLICABLE / UNKNOWN mean for this criterion.
+     */
+    guidance: string;
+}
+/**
+ * An analysis rubric — Harbor's Rubric shape (`{criteria: [...]}`, their
+ * cli/quality_checker/models.py). The criteria set is FROZEN into each
+ * analysis at enqueue: the stored result is validated against exactly this
+ * set, a missing or extra criterion is a stored typed failure, never a
+ * partial pass.
+ */
+interface Rubric {
+    criteria: RubricCriterion[];
+}
+/**
+ * Trace-analysis configuration — Harbor's `harbor analyze` vocabulary (their
+ * cli/analyze.py: `--model`, `--rubric`, `--prompt`). PRESENCE of this object is the
+ * switch: on `JobCreate.analyze` it arms the embedded trigger (each trial is
+ * analyzed server-side right after it settles; CANCELLED trials are skipped);
+ * as the body of `POST /api/jobs/{jobId}/analyze` it configures that manual
+ * wave. `{}` is legal and means "all defaults":
+ * openrouter/deepseek/deepseek-v4.1-flash at its per-model effort (high)
+ * over the platform's default analyze rubric (seven criteria, score_is_earned
+ * first) and its default prompt body.
+ *
+ * The analyzer always runs the claude-code harness (Harbor's default analyze
+ * agent) in its own sealed sandbox — on the provider `sandbox_provider`
+ * names, or the platform's analysis default when it names none; its spend is
+ * capped per analysis and metered as its own line, never blended into the
+ * trial's own bill.
+ *
+ * Which trials, and how wide, are Harbor's own analyze options with their
+ * exact names — `n_concurrent` (`-n/--n-concurrent`), `passing` / `failing`,
+ * `n_trials` (`-l/--n-trials`; their cli/analyze.py:278-290). All omitted
+ * is every analyzable trial, as wide as the organization's
+ * `max_concurrent_analyses` allows. Harbor's `-a/--agent`, `--job-name`,
+ * `-o/--jobs-dir`, `-k/--n-attempts` and the local-runner kwargs are not
+ * on this surface; the contract (`AnalyzeConfigInput` in spec/openapi.yaml)
+ * records each with its reason.
+ */
+interface AnalyzeConfigInput {
+    /**
+     * Model the analyzer agent runs — Harbor's `--model`. The default is
+     * openrouter/deepseek/deepseek-v4.1-flash on this platform's claude
+     * roster (DeepSeek V4.1 Flash served through OpenRouter, at its default
+     * effort high — the owner's ruling 2026-09-10: far more parallel capacity
+     * through OpenRouter's provider pool than one pinned Fireworks host) — a
+     * recorded deviation from Harbor's default analyze model (their
+     * cli/analyze.py `claude-haiku-4-5`): analysis is input-dominated, and
+     * this is the roster's intelligence-per-input-dollar pick; `glm-5.3-flash`
+     * (at max, the effort its published scores use) and `haiku` stay on the
+     * roster as alternatives, `glm-5.3` to escalate, and the same model on
+     * its Fireworks route, `fireworks/deepseek-v4.1-flash`, is a further
+     * option (the OpenRouter id stays the default). The value speaks
+     * the same vocabulary as `agents[].model_name`: either advertised
+     * spelling is accepted and stored AS GIVEN (the default is the roster
+     * alias), the wire id is resolved only when the analyzer runs, and every
+     * stored analysis serves the spelling it was created under. Must be on
+     * the claude roster (`GET /api/meta`, `agents[].models`); anything else
+     * is refused at accept (`invalid_input`, roster in the message).
+     */
+    model_name?: string;
+    rubric?: Rubric;
+    /**
+     * The analyzer's prompt template — the TEXT of Harbor's `-p/--prompt <file>`
+     * ("Prompt file for the evaluator agent. Uses built-in default if not
+     * specified.", their cli/analyze.py:252-255). It REPLACES the platform's
+     * default body as the body of the analyzer's
+     * instruction and is rendered with the same three tokens (`{trial_path}`,
+     * `{task_section}`, `{criteria_guidance}`): the three tokens are
+     * substituted, an unknown `{token}` renders empty, `{{` and `}}` write a
+     * literal brace, and any other brace text is left as written (Harbor's
+     * Python renderer would render it empty, convert it or raise there —
+     * `{ x }` empty, `{x!r}` quoted, `{"a": 1}` an error); the output contract (write
+     * `analysis.json` matching the rubric's schema) is appended after it exactly
+     * as Harbor appends it, so a custom prompt can never opt out of the
+     * deliverable. Stored AS GIVEN and FROZEN into each analysis the config
+     * enqueues, like the rubric. Omitted = the built-in prompt (`null` on the
+     * resolved echo and on the analysis). Present, it must be non-empty plain
+     * text (no NUL character) of ANY length — stored whole, never truncated
+     * (no invented number, owner 2026-09-13). The CLI reads the file for
+     * you: `evolve analyze -p prompt.txt`.
+     */
+    prompt?: string;
+    /**
+     * Reasoning effort the analyzer runs at — the platform's `agents[].
+     * reasoning_effort` vocabulary applied to the analyzer, which IS the
+     * claude harness: the accepted values are `GET /api/meta`'s
+     * `analyze.reasoning_efforts`, an unknown value is refused
+     * `invalid_input` exactly as an arm's is. Omitted, the PER-MODEL default
+     * applies (`analyze.models[].default_reasoning_effort`: high on
+     * openrouter/deepseek/deepseek-v4.1-flash, the default model — DeepSeek's
+     * own documented default, the owner's ruling 2026-09-10; max on
+     * glm-5.3-flash — the platform's ruling 2026-09-08, the effort its
+     * published scores use; the claude harness default elsewhere). The
+     * effort is always passed to the analyzer explicitly and
+     * recorded on the analysis (`TrialAnalysis.reasoning_effort`). A hosted
+     * extension: Harbor's analyze has no effort option; this is the run
+     * door's existing platform vocabulary applied to analyze.
+     */
+    reasoning_effort?: string;
+    /**
+     * The provider whose sandbox the analyzer boots — the job lineup, the same
+     * vocabulary as `JobCreate.sandbox_provider` and held to the same rule: an
+     * unknown value is refused `invalid_input` naming the lineup. Stored as
+     * given and honored wherever this config enqueues an analysis — every
+     * embedded analysis of the job, or the manual wave this body configures.
+     * Omitted, the platform's analysis default applies at each enqueue
+     * (daytona unless the operator retuned the fleet) — the value the resolved
+     * `AnalyzeConfig.sandbox_provider` echo reports.
+     */
+    sandbox_provider?: EvalSandboxProvider;
+    /**
+     * How many of this wave's analyses run at once — Harbor's
+     * `-n/--n-concurrent` ("Max concurrent trial analyses", their
+     * cli/analyze.py:278-280). Bounded by the organization's
+     * `max_concurrent_analyses` at every claim: the job never holds more
+     * than the smaller of the two RUNNING fleet-wide. Omitted, the
+     * organization's ceiling alone bounds the wave (its fleet default is 60,
+     * fifteen times Harbor's own default of 4) and the resolved echo reads `null`. An integer in
+     * `[1, 150]`; anything else is refused `invalid_input` naming
+     * `analyze.n_concurrent`.
+     */
+    n_concurrent?: number;
+    /**
+     * Analyze only the passing trials — Harbor's `--passing` ("Only analyze
+     * passing trials (reward=1.0)", their cli/analyze.py:282-284): a trial
+     * passes when it is SCORED with a primary reward of exactly 1. Mutually
+     * exclusive with `failing`: both true is refused `invalid_input` —
+     * Harbor's own "Cannot use both --passing and --failing".
+     */
+    passing?: boolean;
+    /**
+     * Analyze only the failing trials — Harbor's `--failing` ("Only analyze
+     * failing trials (reward<1.0 or exception)", their cli/analyze.py:285-287):
+     * every analyzable trial that is not passing — a reward below 1 or none,
+     * and every error status. CANCELLED trials are never analyzed under
+     * either filter.
+     */
+    failing?: boolean;
+    /**
+     * At most this many trials get an analysis — Harbor's `-l/--n-trials`
+     * ("Max trials to analyze", their cli/analyze.py:288-290), applied AFTER
+     * the reward filter: on the manual wave the first `n_trials` matching
+     * trials in the job's trial order; on the embedded trigger the first
+     * `n_trials` matching trials to settle. An integer of at least 1;
+     * anything else is refused `invalid_input` naming `analyze.n_trials`.
+     */
+    n_trials?: number;
+}
+/**
+ * The RESOLVED trace-analysis policy — the caller's values or the defaults of
+ * the day, resolved at accept and stored, so the record always states the
+ * policy it executes (same law as RetryConfig). Echoed on the job body when
+ * the job was created with `analyze`; each analysis additionally carries the
+ * exact policy IT ran under (`Trial.analysis.model_name` / `.rubric` /
+ * `.prompt`), which a later manual re-analysis may have changed.
+ */
+interface AnalyzeConfig {
+    model_name: string;
+    rubric: Rubric;
+    /** The caller's prompt template as stored; null = the platform's default analyze body. */
+    prompt: string | null;
+    /**
+     * The effort this policy's analyses run at. Named at create it is served
+     * as stored; when the create named none, this echoes the per-model
+     * default of the day for `model_name` — the value the next enqueue under
+     * this policy stamps (the same nuance as `sandbox_provider` below).
+     */
+    reasoning_effort: string;
+    /**
+     * The provider this policy's analyses run on. Named at create it is served
+     * as stored, forever. When the create named none, this echoes the
+     * platform's analysis default OF THE DAY — the value the next enqueue
+     * under this policy would stamp — because that default is an operator
+     * fleet knob, resolved where an analysis is actually enqueued rather than
+     * baked into the stored policy (the one deliberate nuance to the
+     * resolved-at-accept law above, stated so the echo is never read as
+     * history).
+     */
+    sandbox_provider: EvalSandboxProvider;
+    /**
+     * The per-job width this policy's analyses are claimed under
+     * (`AnalyzeConfigInput.n_concurrent`, as stored); null = none named, the
+     * organization's `max_concurrent_analyses` alone bounds the wave.
+     */
+    n_concurrent: number | null;
+    /** The reward filter as stored; both `passing` and `failing` false = every analyzable trial. */
+    passing: boolean;
+    failing: boolean;
+    /** The trial cap as stored (`AnalyzeConfigInput.n_trials`); null = no cap. */
+    n_trials: number | null;
+}
+/** The job-creation body — POST /api/jobs. */
+interface JobCreate {
+    /** User-facing label; server-generated when omitted. */
+    job_name?: string;
+    datasets: DatasetSelector[];
+    agents: AgentArmInput[];
+    /** Attempts per task per agent arm (default 1, max 100). */
+    n_attempts?: number;
+    /** Parallel trials across the job (default 4, max 16). */
+    n_concurrent_trials?: number;
+    /**
+     * Per-trial spend cap in USD, minted onto each trial's gateway key — the
+     * platform's ONLY spend enforcement (there is no job-wide budget). Omitted,
+     * the server applies its published default ($200 unless the operator tuned
+     * it); the response echoes the RESOLVED cap either way, and states the
+     * resulting worst case for the job as a whole.
+     */
+    max_trial_spend_usd?: number;
+    /** Sandbox provider to run on (optional; server default: `daytona`). */
+    sandbox_provider?: EvalSandboxProvider;
+    /** Auto-retry policy (Harbor RetryConfig grammar); omitted = the fleet defaults. */
+    retry?: RetryConfigInput;
+    /**
+     * Trace-analysis policy (Harbor's `harbor analyze` vocabulary). PRESENCE
+     * arms the embedded trigger: each trial is analyzed server-side right after
+     * it settles (CANCELLED trials are skipped — withdrawn work is not billed
+     * an uninvited analysis). `{}` means "analyze with all defaults"; omitted
+     * means no embedded analysis — `jobs().analyze()` remains the manual door.
+     */
+    analyze?: AnalyzeConfigInput;
+    /**
+     * Multiplier for task timeouts — Harbor's `--timeout-multiplier`, all five
+     * fields flat on this body exactly as Harbor's JobConfig carries them. The
+     * worker multiplies each TASK-DECLARED timeout at the point that phase's
+     * timeout is armed; the task itself is never rewritten, so the same task
+     * runs unstretched in every other job. Values below 1 shrink, as in
+     * Harbor. Every multiplier must be a finite number greater than 0 —
+     * Harbor's own rule and nothing more; no ceiling of the platform's — and
+     * a zero, negative or non-finite value is refused with a typed
+     * `invalid_input` naming the rule, never silently clamped. The one real
+     * bound is the runtime's timer ceiling (2,147,483,647 ms, about 24.86
+     * days — Node sets a longer timer to 1 ms): every selected task's
+     * declared timeout x its phase's effective multiplier is checked at
+     * create and a product past it is refused `invalid_input` on the field
+     * that set the multiplier, naming the task, the phase, the product and
+     * the source. Default 1.0.
+     */
+    timeout_multiplier?: number;
+    /** Multiplier for the agent execution timeout (overrides timeout_multiplier). */
+    agent_timeout_multiplier?: number;
+    /** Multiplier for the verifier timeout (overrides timeout_multiplier). */
+    verifier_timeout_multiplier?: number;
+    /** Multiplier for the agent setup timeout (overrides timeout_multiplier). */
+    agent_setup_timeout_multiplier?: number;
+    /** Multiplier for the environment build timeout (overrides timeout_multiplier). */
+    environment_build_timeout_multiplier?: number;
+    /**
+     * Env injected into every agent run — a pass-through slot: the client sends
+     * it verbatim and the server owns acceptance (refused where unsupported,
+     * never silently dropped).
+     */
+    agent_env?: Record<string, string>;
+    /**
+     * Env injected into every verifier run — same pass-through contract. The
+     * hosted platform honors exactly two keys, Harbor rewardkit's per-run judge
+     * override (their `--ve` mechanism): `REWARDKIT_JUDGE` overwrites the
+     * rubric's `[judge].judge` field and `REWARDKIT_MODEL` overwrites its
+     * `[judge].model` field when the judge is an agent. Both are delivered into
+     * the verifier environment in both verifier modes, over any task-declared
+     * value of the same name; any other key is refused at create.
+     */
+    verifier_env?: Record<string, string>;
+    /**
+     * Env secrets to deliver into every agent run — REFERENCES to the
+     * caller's own stored env secrets, plus INLINE entries ({name, value,
+     * delivery, label?, as?}) whose values are saved into the vault as
+     * normal env secrets first and then pinned like any other reference
+     * (WIRE LAW: the stored job never contains a value; a (name, label)
+     * collision splits on proof — a byte-equal restatement of the stored
+     * row, same value and delivery, attaches it so retries of the same
+     * request converge, while a different value or delivery is the typed
+     * `secret_exists` refusal — attach by reference or pick a label, never
+     * a silent overwrite). References are resolved at
+     * create and pinned: an omitted `label` takes the 'default'-labeled row
+     * when one exists (the single row when exactly one exists), and a bare
+     * name matching several labels with no 'default' is the typed
+     * `secret_ambiguous` refusal naming the labels — a job never guesses
+     * which secret it runs with. `as` renames the env var inside the
+     * sandbox; names the trial contract owns (the EVOLVE_ prefix,
+     * gateway/vendor key slots, the judge-override pair) are refused.
+     * DELIVERY MODES: every stored env secret carries `delivery` —
+     * 'brokered' (the value never enters any sandbox; the managed-agents
+     * egress-proxy machinery) or 'direct' (the raw value is placed in the
+     * sandbox environment). Eval trials deliver exactly the DIRECT mode:
+     * the value enters the trial env and is scrubbed at the credential seal,
+     * before hidden tests enter. Attaching a brokered secret is the typed
+     * `secret_brokered_unsupported` refusal at create — never a silent
+     * downgrade.
+     */
+    secrets?: Array<JobSecretRef | JobSecretInline>;
+}
+/**
+ * One attached env secret: a reference to a stored secret of the caller's,
+ * by name and optional label, with an optional in-sandbox rename. The same
+ * {name, label?, as?} shape as the managed-agents lane's ManagedSecretRef,
+ * resolved by the same server-side law.
+ */
+interface JobSecretRef {
+    /** The stored secret's name (env-var-shaped; the EVOLVE_ prefix is reserved). */
+    name: string;
+    /** Which labeled row of that name; omitted = 'default' resolution law. */
+    label?: string;
+    /** Env var the value lands under in the sandbox (default: the name). */
+    as?: string;
+}
+/**
+ * One INLINE env secret on a job create — the convenience door into the
+ * same vault, not a second wire shape for values: the value is saved as a
+ * normal env secret first (delivery as stated, `label` defaulting to
+ * 'default') and the job then stores only the reference. A (name, label)
+ * identity that is already a stored row splits on proof: a byte-equal
+ * restatement (same value, same delivery) attaches that row — retries of
+ * the same request converge — while a different value or delivery is the
+ * typed `secret_exists` refusal (409); `delivery: 'brokered'` refuses as
+ * `secret_brokered_unsupported` until eval trials can broker.
+ */
+interface JobSecretInline {
+    /** Same grammar and reserved-name law as JobSecretRef.name. */
+    name: string;
+    /** The secret value to vault (at most 190 bytes). Never stored on the job. */
+    value: string;
+    /** The saved secret's delivery mode — REQUIRED, no silent default. */
+    delivery: "brokered" | "direct";
+    /** The labeled row to claim in the vault (default 'default'). */
+    label?: string;
+    /** Same in-sandbox rename law as JobSecretRef.as. */
+    as?: string;
+}
+/** Body of POST /api/jobs/{jobId}/resume. */
+interface ResumeRequest {
+    /**
+     * Which failures to resume, matched against
+     * `exception_info.exception_type`. Omitted, the default set is
+     * ["ScoringError", "InfrastructureError", "ApiUsageLimitError",
+     * "IncompleteTrialError"] plus
+     * stopped trials (settled CANCELLED, exception type "CancelledError")
+     * and still-QUEUED trials of a cancelled source.
+     */
+    filter_error_types?: string[];
+}
+/**
+ * Body of POST /api/jobs/{jobId}/retry — the selection, `trial_ids` XOR
+ * `failed_only`. Omitted (or `{}`) selects every trial of the (terminal)
+ * job; passing both fields is a contradiction the server refuses (400).
+ */
+interface RetryRequest {
+    /**
+     * Exactly these trials of the source job, all-or-nothing: an unknown id
+     * refuses the whole request (`trial_not_found`). Each named trial must be
+     * settled — SCORED, SCORING_ERROR, INFRASTRUCTURE_ERROR, BUDGET,
+     * INDETERMINATE, or CANCELLED (`trial_not_settled` otherwise) — but the JOB may still be
+     * running: a settled trial's facts are final. Duplicates are deduplicated.
+     */
+    trial_ids?: string[];
+    /**
+     * Select the source's failed trials only (SCORING_ERROR,
+     * INFRASTRUCTURE_ERROR, BUDGET, INDETERMINATE). Stopped (CANCELLED) and scored
+     * trials are not failures — name them in `trial_ids`, or use resume for
+     * stopped work.
+     */
+    failed_only?: boolean;
+}
+/**
+ * Optional filter narrowing which trials a job-level regrade re-runs.
+ * Omitted, every regradable trial is regraded.
+ */
+interface RegradeRequest {
+    statuses?: TrialStatus[];
+    /** Restrict to one task's trials. */
+    task_name?: string;
+}
+/**
+ * Per-(agent, model, dataset) statistics. The evals key format is
+ * `{agent}__{model}__{dataset}` — the dataset ref is always the LAST `__`
+ * segment, which is where Harbor-compatible readers recover it — with the
+ * platform extension of an `__{effort}` segment inserted BEFORE the dataset
+ * when a declared reasoning effort is part of the arm identity:
+ * `{agent}__{model}__{effort}__{dataset}`.
+ */
+interface AgentDatasetStats {
+    /** Trials that produced a rewards map — rewarded, not merely settled. */
+    n_trials?: number;
+    /** Trials carrying `exception_info` — indeterminate and cancelled included. */
+    n_errors?: number;
+    /**
+     * Metric results (a mean entry per arm today: the primary reward averaged
+     * over EVERY trial of the group, unrewarded trials counting 0); open objects.
+     */
+    metrics?: Record<string, unknown>[];
+    /**
+     * pass@k for this group — the standard unbiased estimator
+     * `1 - C(n-c, k)/C(n, k)` per task, averaged over the group's tasks. Keys
+     * are k as strings (JSON object keys always are), values in [0,1]. The k set
+     * is the powers of two and the multiples of five up to the group's sparsest
+     * task's attempt count, so k=1 is never present and a single-attempt job
+     * answers `{}`. An attempt that produced no reward counts as a FAILED
+     * attempt, never an excluded one.
+     *
+     * `{}` means the group cannot answer: its rewards are not binary, no
+     * eligible k exists, or attempts are still in flight (the statistic appears
+     * once every attempt of the group has settled). `passAtK(job)` reads this
+     * field into sorted numeric points.
+     */
+    pass_at_k?: Record<string, number>;
+    /** reward key -> reward value -> trial identifiers. */
+    reward_stats?: Record<string, Record<string, string[]>>;
+    /** exception type -> trial identifiers. */
+    exception_stats?: Record<string, string[]>;
+}
+/**
+ * Aggregate statistics of a job. Progress counters, token totals, and measured
+ * cost. The `n_*` counters are CUMULATIVE, Harbor-style: errored trials are a
+ * subset of completed, cancelled a subset of errored — a cancelled trial
+ * counts in all three. The disjoint per-status breakdown rides
+ * `Job.trials.byStatus`. `cost_usd` is what the trials actually spent so far —
+ * reporting, never a gate (enforcement is the per-trial cap).
+ */
+interface JobStats {
+    /** Cumulative: every trial that produced a result — errored and cancelled included. */
+    n_completed_trials?: number;
+    /** Cumulative: every completed trial carrying `exception_info`, cancelled included. */
+    n_errored_trials?: number;
+    n_running_trials?: number;
+    n_pending_trials?: number;
+    /** A subset of `n_errored_trials`. */
+    n_cancelled_trials?: number;
+    n_retries?: number;
+    /** Keyed `{agent}__{model}__{dataset}` — dataset ref last, optional effort segment before it. */
+    evals?: Record<string, AgentDatasetStats>;
+    /** Total input tokens (cache included); null until recorded. */
+    n_input_tokens?: number | null;
+    n_cache_tokens?: number | null;
+    n_output_tokens?: number | null;
+    /**
+     * Measured spend across settled trials — the WHOLE model bill, agent and
+     * judge together; null before any settled.
+     */
+    cost_usd?: number | null;
+    /**
+     * Sum of the job's per-trial GPU compute ESTIMATES (each trial's
+     * `gpu_cost.estimate_usd`) — a SEPARATE labeled figure, never merged into
+     * `cost_usd` (metered model spend). Null when no trial of the job carries
+     * an estimate; a real $0 (a GPU trial that provably never booted a
+     * sandbox) keeps the sum non-null. Absent on servers predating the field.
+     */
+    gpu_cost_usd?: number | null;
+    /**
+     * The judge share of `cost_usd`, itemized: what the trials' verifier-phase
+     * judge keys spent. 0 for a job with no judge-enabled tasks; null before
+     * anything settled, like `cost_usd`.
+     */
+    judge_cost_usd?: number | null;
+    /**
+     * HOW MANY SETTLED TRIALS `cost_usd` CANNOT ACCOUNT FOR — trials whose
+     * `spend_source` lane is `assumed_cap`, meaning nobody ever measured their
+     * gateway spend. Such a trial stores 0, and the job total is the sum of its
+     * trials, so each one folds a zero in and `cost_usd` comes out LOWER than
+     * what was really spent. A plain count, never null: before anything settles
+     * it is honestly 0, where `cost_usd` is null. It is a FLOOR — a
+     * retried-away attempt's lineage snapshot keeps no spend-source column, so
+     * an earlier attempt nobody measured cannot be counted here. Absent on
+     * servers predating the field.
+     */
+    n_unmeasured_trials?: number;
+    /**
+     * The judge half of the same fact, itemized the way `judge_cost_usd`
+     * itemizes `cost_usd`: trials that ran a judge whose spend was never
+     * measured (`judge_spend_source` `assumed_cap`). 0 on jobs with no
+     * judge-enabled tasks.
+     */
+    n_unmeasured_judge_trials?: number;
+    /**
+     * Aggregate of the job's trace analyses; null when no trial of this job has
+     * ever been analyzed. Never a fabricated empty object — absence of analysis
+     * is stated as null, here and on each trial.
+     */
+    analysis?: JobAnalysisStats | null;
+}
+/**
+ * The job-level analysis aggregate — Harbor's job `analysis.json` is a flat
+ * list of per-trial results (their analyze/models.py AnalyzeReport); each
+ * trial's own result rides `Trial.analysis`, and this object aggregates them.
+ * LATEST-per-trial: a re-analyzed trial contributes only its newest analysis,
+ * matching Harbor, where a re-run overwrites the trial directory's
+ * `analysis.json`.
+ */
+interface JobAnalysisStats {
+    /** Trials whose latest analysis produced a valid result. */
+    n_completed: number;
+    /**
+     * Trials whose latest analysis is a stored typed failure (invalid result,
+     * or an infrastructure failure of the analyzer run).
+     */
+    n_failed: number;
+    /** Trials whose latest analysis is still queued or running. */
+    n_pending: number;
+    /**
+     * Measured spend of the LATEST analyses summed — the analyzer's own metered
+     * line, never part of `stats.cost_usd`. Null when no analysis recorded
+     * measured spend (mirrors Harbor's estimated_total_cost_usd, which is None
+     * when nothing was recorded).
+     */
+    cost_usd: number | null;
+    /**
+     * Per-criterion outcome tally over the completed latest analyses, keyed by
+     * criterion name. Criteria are whatever the contributing rubrics named —
+     * after a re-analysis under a different rubric, keys from both may appear,
+     * each counting only analyses that carried it.
+     */
+    checks: Record<string, {
+        n_pass: number;
+        n_fail: number;
+        n_not_applicable: number;
+        n_unknown: number;
+    }>;
+}
+/**
+ * GPU COMPUTE ESTIMATE of one trial — present on settled GPU trials only,
+ * null on every other trial. The estimate is the trial's MEASURED
+ * agent-sandbox lifetime multiplied by a versioned, source-dated rate-card
+ * row (the provider's public list price per GPU-second, times `gpu_count`).
+ * A SEPARATE labeled figure by law: never merged into
+ * `agent_result.cost_usd`, which is metered model spend. Exactly one of
+ * `estimate_usd` / `unpriced_reason` is set — an unmeasurable lifetime (a
+ * reaped run) or a request that let the provider choose the device (`any`,
+ * or several candidates) states its reason instead of a guessed number, and
+ * a GPU trial that provably never booted a sandbox carries a real
+ * `estimate_usd: 0`.
+ *
+ * WHICH DEVICE IS PRICED: the type the provider reported pinned to the box
+ * (`attached_gpu_type`) when it reported one, else the ONE type the create
+ * request carried (`resolved_gpu_types`: modal reserves exactly the task's
+ * first spelling; daytona receives the task's types in its own names, in
+ * order, and pins the first with capacity). The three provenance fields
+ * make the choice auditable; records priced under `rate_card.version` 1
+ * predate them and serve `declared_gpu_types` as the single spelling they
+ * kept, the other two null.
+ */
+interface TrialGpuCost {
+    /** The estimate, USD, micro-dollar resolution. Null exactly when `unpriced_reason` is set. */
+    estimate_usd: number | null;
+    /** Why no estimate exists. Null exactly when `estimate_usd` is set. */
+    unpriced_reason: string | null;
+    provider: EvalSandboxProvider;
+    /**
+     * The rate card's billing name the rate was looked up under (e.g. `H100`):
+     * the attached type when reported, else the one type the request carried.
+     * Null when no single device type is known.
+     */
+    gpu_type: string | null;
+    /** The task's own `gpu_types` list, verbatim; null when it named none (any type). */
+    declared_gpu_types: string[] | null;
+    /**
+     * What the create request carried for the provider, in the provider's
+     * spelling: modal's one reservation, daytona's ordered candidates. Null
+     * when no constraint travelled, and on rate-card v1 records.
+     */
+    resolved_gpu_types: string[] | null;
+    /** The device type the provider reported pinned to the box; null when none was reported. */
+    attached_gpu_type: string | null;
+    gpu_count: number;
+    /** Measured sandbox lifetime, fractional seconds; null when unmeasured. */
+    duration_sec: number | null;
+    /** The applied list price per GPU per second; null when no rate applied. */
+    rate_usd_per_gpu_sec: number | null;
+    /** Which card priced this trial: version, provider pricing page, and the date it was read. */
+    rate_card: {
+        version: number;
+        source: string | null;
+        source_date: string | null;
+    };
+    /** Observed sandbox birth (ISO); null when unmeasured. */
+    measured_from: string | null;
+    /** Observed sandbox end (ISO); null when unmeasured. */
+    measured_to: string | null;
+}
+/** One pass@k number: the estimate over `k` attempts. */
+interface PassAtKPoint {
+    /** How many attempts the estimate is over — always 2 or more. */
+    k: number;
+    /** Probability that k attempts contain at least one success, in [0,1]. */
+    value: number;
+}
+/** One evals group's pass@k curve, ready to plot or print. */
+interface PassAtKGroup {
+    /** The `stats.evals` key these numbers belong to. */
+    evals_key: string;
+    /** Ascending by k; never empty (a group with no numbers is not returned). */
+    points: PassAtKPoint[];
+}
+/**
+ * Read a job's pass@k out of `stats.evals`, as numbers instead of the wire's
+ * string keys. Groups that cannot answer (empty `pass_at_k` — non-binary
+ * rewards, no eligible k, or attempts still in flight) are left out entirely,
+ * so an empty array means "this job has no pass@k to show", and the shape is
+ * the same whether the job is running or finished.
+ *
+ * Pure reading: no request is made, nothing is recomputed. The numbers are the
+ * platform's, and the same ones the job's download archive carries.
+ */
+declare function passAtK(job: Job): PassAtKGroup[];
+/**
+ * Provenance of an UPLOADED job (`jobs().upload()`) — what the archive's own
+ * record files said about themselves: the job id its result.json carried and
+ * the job_name its config.json carried (each null when the file did not state
+ * one — never fabricated), plus when the platform ingested it. The
+ * platform-minted row ids replace the archive's ids everywhere else on the
+ * surface; these fields are where the originals remain readable. Null on
+ * every job this platform executed; non-null marks a terminal RECORD — resume,
+ * retry and regrade refuse it (`job_uploaded`), analyze works on it unchanged.
+ */
+interface UploadProvenance {
+    original_job_id: string | null;
+    original_job_name: string | null;
+    uploaded_at: string;
+    /**
+     * The job-level sum of the trials' `upload.reported_agent_result` figures
+     * — the uploader's own claims aggregated once at ingest, REPORTED like
+     * their per-trial parts and never entering the platform-metered fields
+     * (`stats.cost_usd` and the token stats stay null for an uploaded job).
+     * Each total sums the trials that reported that field and is null when
+     * none did (a zero would be a claim); `n_trials_reporting` counts the
+     * trials that carried any reported figure, against the job's
+     * `n_total_trials` — the honesty note for a partially reporting archive.
+     * Null only on jobs ingested before this field existed.
+     */
+    reported_totals: {
+        cost_usd: number | null;
+        n_input_tokens: number | null;
+        n_cache_tokens: number | null;
+        n_output_tokens: number | null;
+        n_trials_reporting: number;
+    } | null;
+    /**
+     * One row per task of the uploaded job, in archive order (spec
+     * JobTaskLink): how many of its trials linked to a stored task — and so
+     * analyze with the task folder in `/app/task` — to which dataset version,
+     * and why the rest did not. Null only on jobs ingested before the link
+     * law existed (not backfillable, never guessed).
+     */
+    task_links: JobTaskLink[] | null;
+}
+/**
+ * How an uploaded trial was linked to a stored task — the ONE rule the
+ * ingest ran for its job (spec TaskLinkedBy): `dataset_flag` (the `-d`
+ * dataset, by task name — the override), `job_dataset_record` (the job's
+ * own config.json named a dataset the caller can see; linked by Harbor's
+ * task hash inside it), `task_hash` (nothing named; exactly one visible
+ * dataset carries the hash), or `none` (not linked — `TaskLinkReason` says
+ * why).
+ */
+declare const TASK_LINKED_BY: readonly ["dataset_flag", "job_dataset_record", "task_hash", "none"];
+type TaskLinkedBy = (typeof TASK_LINKED_BY)[number];
+/**
+ * Why an uploaded trial was NOT linked to a stored task (spec
+ * TaskLinkReason) — its analyses run without the task folder:
+ * `hash_mismatch` (the named dataset holds the task name, but with different
+ * bytes), `task_not_in_dataset` (the named version holds neither the name
+ * nor the hash), `no_dataset_named` (nothing named and no lock digest —
+ * nothing to match on), `dataset_ambiguous` (the same bytes are published in
+ * two or more datasets; `candidates` names them, `-d` decides),
+ * `no_hash_match` (no visible task carries the trial's digest),
+ * `no_task_digest` (a dataset was named but the trial's archive carries no
+ * lock digest; a name alone never links without `-d`).
+ */
+declare const TASK_LINK_REASONS: readonly ["hash_mismatch", "task_not_in_dataset", "no_dataset_named", "dataset_ambiguous", "no_hash_match", "no_task_digest"];
+type TaskLinkReason = (typeof TASK_LINK_REASONS)[number];
+/**
+ * How THIS uploaded trial linked to a stored task, or why not (spec
+ * TrialTaskLink). A linked trial names its `dataset` and `version`; an
+ * unlinked one carries `link_reason`. `task_digest` is the trial's own
+ * lock.json `task.digest` when its archive carried one (Harbor's
+ * `sha256:<hex>`); `candidates` the `name@version` refs an ambiguous hash
+ * matched ([] otherwise).
+ */
+interface TrialTaskLink {
+    linked_by: TaskLinkedBy;
+    /** Set exactly when `linked_by` is `none`. */
+    link_reason: TaskLinkReason | null;
+    dataset: string | null;
+    version: string | null;
+    task_digest: string | null;
+    candidates: string[];
+}
+/**
+ * One task of an uploaded job, rolled up (spec JobTaskLink): its trial
+ * count, how many linked (`n_linked` analyze with the task folder,
+ * `n_unlinked` without), the rule that linked them, the `name@version` refs
+ * they linked to (sorted; normally one), the unlinked trials per reason, and
+ * the refs an ambiguous hash matched.
+ */
+interface JobTaskLink {
+    /** The platform task key (the leaf of a registry-qualified name). */
+    task_name: string;
+    n_trials: number;
+    n_linked: number;
+    n_unlinked: number;
+    /** The job's link rule when any trial of the task linked, else `none`. */
+    linked_by: TaskLinkedBy;
+    datasets: string[];
+    /** Unlinked trials per `TaskLinkReason`. */
+    link_reasons: Partial<Record<TaskLinkReason, number>>;
+    candidates: string[];
+}
+/**
+ * The deletion receipt of `DELETE /api/jobs/{jobId}`: what was destroyed.
+ * The contract's own minimal shape — Harbor's hub delete answers no wire
+ * body, so there was no shape to mirror. `trials_deleted` counts the trial
+ * rows destroyed with the job (their trace events, attempts and stored
+ * trace objects went with them); `analyses_deleted` the trial-analysis
+ * rows, their stored analyzer streams included.
+ */
+interface JobDeleteResult {
+    /** The deleted job. */
+    job_id: string;
+    trials_deleted: number;
+    analyses_deleted: number;
+}
+/**
+ * Why a job FAILED — deliberately NOT under the key `error`, which on this
+ * surface always means "this request failed". `if (body.error) throw` stays
+ * correct on a healthy 200 read of a failed job.
+ */
+interface JobFailure {
+    /** `job_execution_failed` when the runner recorded no code. */
+    code: string;
+    message: string;
+}
+/**
+ * One dataset of a job whose selection excluded tasks that FAILED to build
+ * (the partial-publish model). `note` is the sentence to show, and the
+ * structured fields beside it are the same fact for a UI: `n_tasks_selected`
+ * is how many READY tasks the caller's filters matched BEFORE any `n_tasks`
+ * cap, `n_tasks_ran` how many the job actually ran from this dataset (fewer
+ * than `n_tasks_selected` only under an `n_tasks` cap), and
+ * `n_tasks_failed_to_build` what the filters would have taken but the build
+ * lost. Uncapped, the note reads "ran N of M tasks — K failed to build" with
+ * M = n_tasks_selected + K; capped it reads "selection matched M tasks:
+ * K failed to build: …; ran R (n_tasks cap)" — the run was short for two
+ * separate reasons and the sentence keeps them apart. `failed_task_names`
+ * names every one, sorted; the reasons live on the dataset's `failed_tasks`
+ * and the per-task build route (datasets().getTaskBuild()). (Jobs recorded
+ * before `n_tasks_selected` existed answer it as `n_tasks_ran` — read as
+ * uncapped.)
+ */
+interface JobBuildExclusion {
+    dataset: DatasetRef;
+    n_tasks_ran: number;
+    n_tasks_selected: number;
+    n_tasks_failed_to_build: number;
+    failed_task_names: string[];
+    note: string;
+}
+/**
+ * THE job body — the same shape from create, get, list items, cancel, resume,
+ * and regrade responses; no field appears on some responses and not others.
+ */
+interface Job {
+    id: string;
+    /** User-facing label. */
+    job_name: string;
+    status: JobStatus;
+    /** The resolved dataset references this job ran. */
+    datasets: DatasetRef[];
+    agents: AgentArm[];
+    n_attempts: number;
+    n_concurrent_trials: number;
+    /** The resolved per-trial cap every trial key was minted with. */
+    max_trial_spend_usd: number;
+    /**
+     * The most this job can cost: every trial spending its whole cap on every
+     * attempt the retry policy allows — cap x trials x (retry.max_retries + 1),
+     * since each attempt is minted its own full cap. Stated outright — the
+     * per-trial cap is the only enforcement, so the product is the number
+     * someone approving a 500-trial run actually needs to see.
+     */
+    worst_case_spend_usd: number;
+    /** The RESOLVED auto-retry policy this job runs under. */
+    retry: RetryConfig;
+    /**
+     * The resolved embedded-analysis policy the job was created with; null when
+     * the create named none (a later manual `analyze()` does not rewrite it —
+     * the job row states what the CREATE asked for, each analysis states what
+     * IT ran under). Always null on a regrade job.
+     */
+    analyze: AnalyzeConfig | null;
+    /**
+     * The RESOLVED timeout multipliers this job's phases arm under — Harbor's
+     * five flat JobConfig fields, echoed on every job body. The global one is
+     * always a number (1.0 when the create request named none); each phase
+     * field is null when not overridden, meaning the global applies.
+     */
+    timeout_multiplier: number;
+    agent_timeout_multiplier: number | null;
+    verifier_timeout_multiplier: number | null;
+    agent_setup_timeout_multiplier: number | null;
+    environment_build_timeout_multiplier: number | null;
+    /**
+     * Where this job's trials execute. Null exactly on an UPLOADED job
+     * (`upload` non-null): an ingested record never executed on any platform
+     * sandbox, and naming a provider would be an execution claim. Never null
+     * on a job this platform ran.
+     */
+    sandbox_provider: EvalSandboxProvider | null;
+    /** Entity cardinality only — things with no status of their own. */
+    counts: {
+        agents: number;
+        tasks: number;
+    };
+    /**
+     * THE RESULTS-HONESTY LABEL of the partial-publish model: one entry per
+     * dataset of this job whose selection excluded tasks that FAILED to build
+     * — a whole-dataset (or glob) run over a partially built version runs the
+     * READY tasks, and this field is where the job says so plainly instead of
+     * silently truncating. Always present; empty when nothing was excluded
+     * (every selected dataset fully built, or every failed task was already
+     * outside the caller's own filters). Recorded at create and immutable;
+     * derived jobs (resume/retry) answer empty — their honesty lives on the
+     * source job.
+     */
+    build_exclusions: JobBuildExclusion[];
+    n_total_trials: number;
+    /** The zeros-included 8-status histogram, beside the coarser counters in `stats`. */
+    trials: TrialStatusTally;
+    stats: JobStats;
+    /** Why the job FAILED, or null. Never the key `error` — see JobFailure. */
+    failure: JobFailure | null;
+    /** Empty for an original job. */
+    source_jobs: SourceJob[];
+    /** Derived: any source_jobs entry with action "regrade". */
+    is_regrade: boolean;
+    /**
+     * The upload provenance echo — null for every job this platform executed,
+     * non-null only on a job ingested by jobs().upload(). See UploadProvenance.
+     */
+    upload: UploadProvenance | null;
+    /** True only on a response that replayed an existing job for an Idempotency-Key. */
+    idempotent_replay: boolean;
+    started_at: string;
+    updated_at: string;
+    /** Null while the job is live. */
+    finished_at: string | null;
+}
+/**
+ * A phase's wall-clock as a start/stop pair (never a duration). Either bound
+ * is null while the phase has not reached it.
+ */
+interface TimingInfo {
+    started_at: string | null;
+    finished_at: string | null;
+}
+interface ModelInfo {
+    name: string;
+    /** Null means "not specified", never "unknown provider". */
+    provider?: string | null;
+}
+/**
+ * The agent that ran a trial. `version` is the version actually RESOLVED and
+ * used (null until resolved) — the requested pin lives on the job's
+ * `agents[].version`. `reasoning_effort` is the platform's arm-identity
+ * extension.
+ */
+interface AgentInfo {
+    name: string;
+    version: string | null;
+    model_info: ModelInfo;
+    reasoning_effort?: string | null;
+}
+/**
+ * What the agent phase produced and consumed. `n_input_tokens` includes cache
+ * tokens. `cost_usd` is the settled spend (see `spend_source` on the trial for
+ * which lane it came from, and whether it is final). `metadata` carries open
+ * per-run detail:
+ * the harness bundle digest and runtime, the network mode the trial ran under
+ * and where that decision came from, and any harness-reported usage detail.
+ */
+interface AgentResult {
+    n_input_tokens?: number | null;
+    n_cache_tokens?: number | null;
+    n_output_tokens?: number | null;
+    /** Null until the trial has executed; null never means $0. */
+    cost_usd?: number | null;
+    /** Reserved for token-level rollout detail; null today. */
+    rollout_details?: Record<string, unknown>[] | null;
+    metadata?: Record<string, unknown> | null;
+}
+/**
+ * What the verifier phase's LLM judge consumed — the judge half of a trial's
+ * model bill. A judge-enabled task's verifier holds a DISTINCT short-lived
+ * gateway key (scoped to the requested credential's model family only, minted
+ * at verify start, revoked after scoring; judge model selection itself is
+ * Harbor-exact — the rubric names the model, or rewardkit's own library
+ * default applies), and these figures are that key's spend and tokens as the platform
+ * measured them at the gateway — never anything the verifier reported about
+ * itself. `cost_usd` is the judge share alone; `agent_result.cost_usd` stays
+ * the agent's, and the trial's whole bill is the sum. See `judge_spend_source`
+ * on the trial for which lane the figure is in.
+ */
+interface JudgeResult {
+    n_input_tokens?: number | null;
+    n_cache_tokens?: number | null;
+    n_output_tokens?: number | null;
+    /** Null until measured; null never means $0. */
+    cost_usd?: number | null;
+}
+/**
+ * One place a verdict rests on. `where` names a step_id in the trajectory, a
+ * file and line, or a command; `quote` is the exact text found there. The
+ * page links each entry to the record; a reader verifies by eye — nothing
+ * verifies the quotes mechanically.
+ */
+interface AnalysisEvidence {
+    where: string;
+    quote: string;
+}
+/**
+ * One criterion's verdict — Harbor's QualityCheckModel (their
+ * cli/quality_checker/models.py `{explanation, outcome}`) extended by the
+ * platform's result schema: a fourth outcome, `unknown`, for a criterion the
+ * record cannot decide (`not_applicable` keeps Harbor's meaning, no subject),
+ * and the `evidence` list — at least one entry behind a `pass` or a `fail`;
+ * `not_applicable` and `unknown` may carry none. Results stored before the
+ * evidence field existed serve an empty list.
+ */
+interface AnalysisCheck {
+    outcome: "pass" | "fail" | "not_applicable" | "unknown";
+    /** The analyzer's reasoning, in plain words, opening with a few words that name what it found. */
+    explanation: string;
+    evidence: AnalysisEvidence[];
+}
+/**
+ * The derived label of an analysis — computed by the platform from the
+ * outcomes when the result is stored, never asked from the model. Null until
+ * completed, and null on a completed analysis whose rubric is not the
+ * default one (a custom rubric carries its per-criterion outcomes and no
+ * label). Precedence: `flagged` on a fail of score_is_earned,
+ * score_is_correct, task_was_fair or report_is_truthful; else `env_fault` on
+ * a fail of environment_worked; else `unclear` on an unknown of any of those
+ * five, or a not_applicable of score_is_earned or score_is_correct; else
+ * `clean`.
+ */
+type AnalysisLabel = "flagged" | "env_fault" | "unclear" | "clean";
+/**
+ * The derived label of a task check — computed the same way. `has_a_problem`
+ * on a fail of any criterion; else `unclear` on an unknown of any of the six
+ * file-based criteria; else `no_problem_found`. Null under a custom rubric.
+ */
+type CheckLabel = "has_a_problem" | "unclear" | "no_problem_found";
+/**
+ * Why an analysis FAILED — a stored typed failure, never a silent absence and
+ * never a fake pass. NOT under the key `error` for the same reason JobFailure
+ * is not.
+ */
+interface AnalysisFailure {
+    /**
+     * Which part failed: `invalid_result` (the analyzer ran but its
+     * analysis.json failed validation — the message preserves every validator
+     * reason, one per line; a run cut by its budget is `timeout` instead),
+     * `inputs` (the trial tree or task content could not be assembled),
+     * `timeout` (the analyzer's run budget ran out with no valid analysis.json
+     * — the file missing, or a partial one that failed validation, its reasons
+     * in the message — never re-run: a timeout is deterministic; the message
+     * names the budget, the seconds used and the exit code), or an
+     * infrastructure stage of the analyzer run (`mint_key`, `boot`,
+     * `harness_install`, `agent`, `artifact_read`, `lease_expired`, ...).
+     */
+    phase: string;
+    message: string;
+}
+/**
+ * One trace analysis of a trial. The result half is Harbor's AnalyzeResult
+ * shape (their analyze/models.py: `summary`, `checks` keyed by criterion,
+ * `estimated_cost_usd`; the enclosing trial is Harbor's `trial_name`), its
+ * checks extended by the result schema (four outcomes, an evidence list); the
+ * rest is provenance — which model and rubric THIS analysis ran under, its
+ * lifecycle status, and its typed failure when it failed.
+ *
+ * `estimated_cost_usd` is the analyzer agent's OWN metered spend (its sealed
+ * sandbox runs on its own capped gateway key) — its own line, never part of
+ * the trial's `agent_result.cost_usd` or the job's `stats.cost_usd`; the job
+ * aggregate is `stats.analysis.cost_usd`. Null when nothing was measured,
+ * never a fabricated 0.
+ */
+interface TrialAnalysis {
+    id: string;
+    /**
+     * Provenance: the analyzed trial, its job, and its task. Redundant on
+     * `Trial.analysis` (the trial is the enclosing object) and the whole point
+     * of a `analyses().list()` row, where nothing else says which run the
+     * verdict judged. Harbor's `trial_name` names the same thing by directory.
+     */
+    trial_id: string;
+    job_id: string;
+    task_name: string;
+    /**
+     * Lifecycle of this analysis. Every non-terminal analysis reaches
+     * `completed` or `failed`; a worker death mid-run is reaped to a typed
+     * `failed`, never left `running` forever.
+     */
+    status: AnalysisStatus;
+    model_name: string;
+    /**
+     * The reasoning effort THIS analysis ran at — passed to the analyzer
+     * explicitly, so it is what the model was asked for. Null only on
+     * analyses recorded before the effort was stamped.
+     */
+    reasoning_effort: string | null;
+    rubric: Rubric;
+    /**
+     * The prompt template THIS analysis ran under, frozen at enqueue
+     * (`AnalyzeConfigInput.prompt`); null = the platform's default analyze body.
+     */
+    prompt: string | null;
+    /**
+     * 3–5 sentence overview of what happened during the trial (the default
+     * output section's summary contract). Null until completed.
+     */
+    summary: string | null;
+    /**
+     * One entry per rubric criterion, keys exactly the rubric's criterion names
+     * (the frozen-criteria law). Null until completed.
+     */
+    checks: Record<string, AnalysisCheck> | null;
+    /** The derived label (AnalysisLabel states the rule); null until completed, and null under a custom rubric. */
+    label: AnalysisLabel | null;
+    estimated_cost_usd: number | null;
+    /**
+     * The analyzer's one-home usage reading — the SAME object, same keys, the
+     * trial and session surfaces serve, built from the analyzer's OWN gateway
+     * records. Present and ticking while the analysis runs — a mid-run reading
+     * is a lagging LOWER BOUND, always `provisional: true` — and settled by
+     * the same read that writes `estimated_cost_usd`, which stays Harbor's
+     * word for the FINAL figure. Null = the meter never answered, never zero.
+     * Absent on servers predating the field.
+     */
+    usage?: UsageReading | null;
+    /**
+     * How many analyzer attempts this analysis has made: 1, or 2 when the
+     * bounded automatic re-run fired. An analyzer run that completes without
+     * producing a valid analysis.json (the missing file included) is re-run
+     * at most once — same model, same frozen rubric, fresh sandbox — and a
+     * second failure of that class settles `failed` with phase
+     * `invalid_result`, both attempts recorded. A run cut by its budget is
+     * not that class: it settles `failed` with phase `timeout` at once and is
+     * never re-run. Infrastructure failures never auto re-run. When the
+     * re-run fired, `estimated_cost_usd` and the token totals cover BOTH
+     * attempts. Absent on servers predating the field.
+     */
+    attempts?: number;
+    /** Non-null exactly when status is `failed`. */
+    failure: AnalysisFailure | null;
+    /** When this analysis was enqueued. */
+    created_at: string;
+    /** When it settled; null while queued or running. */
+    finished_at: string | null;
+}
+/**
+ * The verifier's rewards map. The primary-reward convention: the value under
+ * the key "reward"; else, when exactly one key exists, that value; else no
+ * primary reward. Zero is a reward.
+ */
+interface VerifierResult {
+    rewards?: Record<string, number> | null;
+}
+/**
+ * Why a trial failed, when it did. `exception_type` is one of the platform's
+ * stable failure names (ScoringError, InfrastructureError, ApiUsageLimitError,
+ * CancelledError, IncompleteTrialError) — but filter with `Trial.status`,
+ * which is the primary key for failure classes; this is the detail.
+ */
+interface ExceptionInfo {
+    exception_type: string;
+    /** Truncated to 2000 chars on list rows; full on the detail route. */
+    exception_message: string;
+    /** Empty when the platform recorded no traceback. */
+    exception_traceback?: string;
+    occurred_at: string;
+}
+/**
+ * What ONE step of a multi-step task produced. Present on
+ * `Trial.step_results`, one entry per step the trial actually RAN, in execution
+ * order — a trial that stopped early (a step raised, or its `min_reward` was
+ * not met) carries only the steps that ran, because the ones after an abort did
+ * not happen.
+ *
+ * `verifier_result` null means this step produced no verifier result at all (it
+ * crashed, the step aborted before reaching it, or verification was disabled);
+ * a result whose `rewards` is null means the verifier ran and produced no
+ * reward map. The distinction decides the trial's reward: the mean strategy
+ * excludes a step with no result from its denominator, but counts a result with
+ * no rewards as zero.
+ *
+ * `agent_result` is null when no per-step spend was measured — never a
+ * per-step $0.
+ */
+interface StepResult {
+    step_name?: string;
+    agent_result?: AgentResult | null;
+    verifier_result?: VerifierResult | null;
+    exception_info?: ExceptionInfo | null;
+    agent_execution?: TimingInfo | null;
+    verifier?: TimingInfo | null;
+}
+/**
+ * The ONE public trial shape, shared verbatim by list rows and the detail
+ * route (detail returns `exception_info.exception_message` untruncated — the
+ * only documented difference). A trial id is globally addressable; `job_id` is
+ * the reverse pointer.
+ *
+ * Execution facts (`sandbox_provider`, `verifier_environment_mode`,
+ * `agent_result.cost_usd`, `spend_source`) are null until the trial has
+ * actually executed: a QUEUED or CANCELLED trial never ran, so null means
+ * "did not run" and never zero.
+ */
+interface Trial {
+    id: string;
+    job_id: string;
+    task_name: string;
+    /** The dataset this trial's task came from. */
+    source: string;
+    agent_info: AgentInfo;
+    /** Attempt index within the arm (1..n_attempts). */
+    attempt: number;
+    status: TrialStatus;
+    /**
+     * Convenience primary reward derived from `verifier_result.rewards` by the
+     * primary-reward convention. Zero is a reward; null means the trial did not
+     * score.
+     */
+    reward: number | null;
+    verifier_result: VerifierResult | null;
+    exception_info: ExceptionInfo | null;
+    agent_result: AgentResult | null;
+    /**
+     * The judge share of the trial's bill, itemized. Null when no judge ever
+     * ran — the task requested no judge credential, or the trial never reached
+     * its verify phase. Null never means "$0 of judging".
+     */
+    judge_result?: JudgeResult | null;
+    /**
+     * The trial's LATEST trace analysis; null when the trial has never been
+     * analyzed — never a fabricated empty object. A re-analysis (same job,
+     * different rubric or model) replaces what this field serves, matching
+     * Harbor, where a re-run overwrites the trial directory's analysis.json;
+     * earlier analyses stay stored as the audit record.
+     */
+    analysis?: TrialAnalysis | null;
+    environment_setup: TimingInfo | null;
+    agent_setup: TimingInfo | null;
+    agent_execution: TimingInfo | null;
+    /**
+     * The verifier COMMAND window — the graded command alone, and not the work
+     * that prepared it. On a SHARED-mode trial the preparation that runs first
+     * is reported beside this pair as `shared_verify_setup`. Read this pair
+     * against `verifier_timeout_sec` and nothing else.
+     */
+    verifier: TimingInfo | null;
+    /**
+     * How long the trial sat claimable before a worker began it. It ends at the
+     * run's beginning, which is APPROXIMATELY — not exactly — where
+     * `environment_setup` starts, so never treat the two pairs as adjacent. The
+     * open bound is when the row became claimable, which for a retried trial is
+     * its backoff deadline rather than its creation: this never bills the
+     * attempt that failed before it.
+     */
+    queue_wait: TimingInfo | null;
+    /**
+     * The harness bundle resolve, NESTED inside `environment_setup`. A miss that
+     * actually BUILT also carries the publish upload back to the shared bundle
+     * store, which the building caller waits out inside this window — a trial
+     * that joined someone else's build, or hydrated the bytes from that store,
+     * pays neither. Read with `harness_bundle_cache_hit`.
+     */
+    harness_bundle: TimingInfo | null;
+    /**
+     * The provider image/snapshot/template ensure, also NESTED inside
+     * `environment_setup` and excluding the boot that follows it. Near-zero on
+     * modal BY DESIGN — modal pre-builds nothing, so the real pull-and-cache
+     * happens provider-side when the box is created — so never compare it across
+     * providers raw.
+     */
+    image_prepare: TimingInfo | null;
+    /**
+     * What a SHARED-mode verify did BEFORE its command — the judge key mint, the
+     * rewardkit bundle resolve and upload, the test-file uploads, the env write.
+     * It ends exactly where `verifier` begins, and the two never overlap.
+     * Null on separate-mode trials, on multi-step trials (which verify per step
+     * and report no trial-level verifier window), and on anything that settled
+     * before the pair was recorded — never a zero-length pair standing in for
+     * "did not happen".
+     */
+    shared_verify_setup: TimingInfo | null;
+    /**
+     * True when the bundle resolve served bytes already on the worker. False
+     * covers every path that had to produce them — a shared-store hydrate, a
+     * builder run, or joining another trial's in-flight build. Null is
+     * unrecorded (a trial older than these timers, or one whose resolve failed),
+     * never "miss".
+     */
+    harness_bundle_cache_hit: boolean | null;
+    /**
+     * Per-step results for a multi-step task, in execution order. Null on every
+     * single-step trial — "this trial has no steps", never "it ran zero of
+     * them". A trial that stopped early carries only the steps that ran.
+     */
+    step_results: StepResult[] | null;
+    /** Which lane `agent_result.cost_usd` came from — see SpendSource; only "measured" is final. */
+    spend_source: SpendSource | null;
+    /**
+     * Which lane `judge_result.cost_usd` is in — the same three-lane vocabulary
+     * as `spend_source`, same rules. Null exactly when `judge_result` is null:
+     * no judge ever ran.
+     */
+    judge_spend_source?: SpendSource | null;
+    /**
+     * A mid-run LOWER BOUND on spend, never the trial's cost. Only ever climbs
+     * while the trial runs, and is CLEARED when the trial settles — on a
+     * terminal trial read `agent_result.cost_usd` and `spend_source`; those are
+     * the settled truth. Null is "no reading yet", never $0.
+     */
+    live_spent_usd: number | null;
+    /** When that reading was taken — show its age, never the figure alone. */
+    live_spend_at: string | null;
+    /**
+     * THE ONE-HOME USAGE READING: spend so far plus the token breakdown from
+     * the same gateway records, `provisional` saying whether the numbers can
+     * still grow — present and ticking while the trial runs, settled once the
+     * lane is `measured`. The overlapping fields (`agent_result` tokens,
+     * `live_spent_usd`, `spend_source`) remain for their existing readers; this
+     * is where a client reads the whole answer at once, with the same keys the
+     * managed-agents session surfaces serve. Null = the meter never answered,
+     * never zero. Absent on servers predating the field.
+     */
+    usage?: UsageReading | null;
+    /**
+     * The cap THIS trial's gateway key carried — history, which can differ from
+     * the job's current cap for rows settled before a change.
+     */
+    max_trial_spend_usd: number | null;
+    sandbox_provider: EvalSandboxProvider | null;
+    /**
+     * Present when this trial's task declared GPUs the job's stamped provider
+     * could not allocate, so the trial ran on modal instead: `from` is the
+     * job's request, `to` where the boxes actually ran, `reason` the refusing
+     * provider's own sentence. Null on every other trial; absent on servers
+     * predating the field.
+     */
+    sandbox_provider_degrade?: {
+        from: EvalSandboxProvider;
+        to: EvalSandboxProvider;
+        reason: string;
+    } | null;
+    /**
+     * GPU compute ESTIMATE — measured sandbox lifetime x the platform's
+     * versioned, source-dated rate card (see TrialGpuCost). Present on settled
+     * GPU trials only; null on every other trial, and never merged into
+     * `agent_result.cost_usd`. Absent on servers predating the field.
+     */
+    gpu_cost?: TrialGpuCost | null;
+    /** Provider id of the box the agent executed in; null when none booted. */
+    sandbox_id: string | null;
+    /** The separate verifier box; null in shared mode or when never reached. */
+    verifier_sandbox_id: string | null;
+    verifier_environment_mode: VerifierEnvironmentMode | null;
+    /**
+     * Which step a RUNNING trial is in, so a polling caller can tell a slow
+     * build from a slow agent. Null when the trial is not mid-phase.
+     */
+    attempt_phase: AttemptPhase | null;
+    /**
+     * Automatic retries this trial consumed (0 = never retried). The trial
+     * body always shows the LATEST attempt; `retries` holds the lineage.
+     */
+    n_retries: number;
+    /**
+     * Attempt lineage: earlier attempts whose failure was retried away, oldest
+     * first. The final attempt's outcome is the trial body itself and is not
+     * repeated here; a never-retried trial answers [].
+     */
+    retries: TrialRetry[];
+    /** Reference to the agent session/trace, when recorded. */
+    session_ref: string | null;
+    /**
+     * Provenance of an UPLOADED trial (its job's `upload` is non-null): the
+     * identity and reported figures the archive's own record files carried.
+     * Null for every trial this platform executed. An uploaded trial keeps
+     * its execution facts (`sandbox_provider`, `agent_result`, `usage`,
+     * `spend_source`) null forever — this platform's meter never saw the run;
+     * the archive's own figures live under `upload.reported_agent_result` and
+     * nowhere else.
+     */
+    upload: TrialUploadProvenance | null;
+    started_at: string | null;
+    finished_at: string | null;
+}
+/**
+ * What the uploaded archive said about THIS trial: its own ids, the full
+ * task name verbatim, and the uploader's own usage figures. REPORTED means
+ * exactly that — `reported_agent_result` is the archive's claim, served for
+ * the reader; it never populates the platform-metered fields
+ * (`agent_result`, `usage`, `spend_source`), which stay null because this
+ * platform's meter never saw the run.
+ */
+interface TrialUploadProvenance {
+    /** The archive trial result.json's own `id`; null when it stated none. */
+    original_trial_id: string | null;
+    /** The archive's own `trial_name` (the trial directory). */
+    original_trial_name: string;
+    /**
+     * The archive's task name VERBATIM — possibly registry-qualified
+     * (`org/name`); the trial's `task_name` serves the parsed leaf.
+     */
+    original_task_name: string;
+    /**
+     * The uploaded `agent_result`'s own token and cost figures, or null when
+     * the archive carried none. Uploader-reported, never platform-measured.
+     */
+    reported_agent_result: {
+        n_input_tokens: number | null;
+        n_cache_tokens: number | null;
+        n_output_tokens: number | null;
+        cost_usd: number | null;
+    } | null;
+    /**
+     * How this trial linked to a stored task, or why not. Null only on trials
+     * ingested before the link law existed (not backfillable, never guessed).
+     */
+    link: TrialTaskLink | null;
+}
+/**
+ * One retired attempt of a trial — the terminal facts preserved when the
+ * auto-retry scheduler put the trial back on the queue. Its `cost_usd` is
+ * REAL money the job total includes; the trial's own `agent_result.cost_usd`
+ * carries only the final attempt's.
+ */
+interface TrialRetry {
+    /** 1-based dispatch number within this trial. */
+    attempt_number: number;
+    exception_info: ExceptionInfo;
+    /** What THIS attempt spent; null when nothing was recorded. */
+    cost_usd: number | null;
+    /** When the attempt was claimed. */
+    started_at: string | null;
+    /** When its failure settled (and the retry was scheduled). */
+    settled_at: string | null;
+}
+/** Per-id outcome of POST /api/trials/stop; every requested id appears in exactly one list. */
+interface StopResponse {
+    /** Trials killed and settled by this request, with their settled rows. */
+    stopped: Trial[];
+    /**
+     * Trace analyses killed and settled by this request, with their settled
+     * rows (`failed`, failure phase `stopped`). Always served; a separate list
+     * because `stopped` is an array of Trial.
+     */
+    stopped_analyses: TrialAnalysis[];
+    /** Ids that were already terminal; untouched. */
+    already_terminal: string[];
+    /** Ids that do not exist or are not the caller's. */
+    not_found: string[];
+}
+/**
+ * One parsed trace event of a trial's transcript. `seq` orders the stream and
+ * is the paging cursor. `data` is the harness-native payload, deliberately
+ * open — with ONE typed member: a `usage` event whose `data.update.source`
+ * is `"gateway"` is the platform's gateway meter speaking (GatewayUsageEvent,
+ * `gatewayUsageOf` reads it), and it is the ONLY usage line that carries
+ * tokens and money a client may show. A harness's own `usage` line (no
+ * `source`) stays in the stream as the raw record and is never rendered as
+ * tokens or cost. Once a trial is terminal its gateway lines follow the last
+ * harness row with `seq` at or past GATEWAY_TRACE_SEQ_BASE.
+ */
+interface TraceEvent {
+    /** Monotonic sequence number (the resume position). */
+    seq: number;
+    type: string;
+    data: Record<string, unknown>;
+}
+/**
+ * THE GATEWAY METER'S PER-CALL LINE (spec GatewayUsageEvent): one model call
+ * as the LiteLLM gateway priced and recorded it. `promptTokens` INCLUDES the
+ * cached and cache-written shares (the same law as UsageReading.input_tokens);
+ * `cachedTokens` is the cached share; the cache-write and reasoning counts
+ * ride `extra` under the gateway's own names. `costUsd` is the gateway's
+ * `response_cost` — no client prices anything.
+ */
+interface GatewayUsage {
+    sessionUpdate: "usage";
+    scope: "call";
+    source: "gateway";
+    /** LiteLLM's own id for the call. */
+    callId: string;
+    /** The gateway's status word for the call (`success` / `failure`). */
+    status: string | null;
+    startedAt: string | null;
+    endedAt: string | null;
+    /** When the platform stored the call. */
+    receivedAt: string;
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        cachedTokens: number;
+        costUsd: number;
+        extra: {
+            cache_write_tokens: number;
+            reasoning_tokens?: number;
+        };
+    };
+}
+/** The `data` of a gateway usage TraceEvent: the call's start instant and model beside the update. */
+interface GatewayUsageEvent {
+    timestamp: string | null;
+    model: string | null;
+    update: GatewayUsage;
+}
+/**
+ * The seq band a terminal trial's gateway lines ride on the trace-parsed
+ * stream — a MIRROR of the server's constant (swarm_dashboard
+ * lib/gateway-calls.ts GATEWAY_TRACE_SEQ_BASE); the transcript readers below
+ * synthesize the same band for an analysis's or a task check's calls.
+ */
+declare const GATEWAY_TRACE_SEQ_BASE = 1000000000;
+/**
+ * The gateway meter's usage on a trace event, or null: null for a harness's
+ * own usage line (no `source`) and for every other event. THE ONE test a
+ * renderer applies before it shows tokens or money from a trace.
+ */
+declare function gatewayUsageOf(event: Pick<TraceEvent, "data">): GatewayUsage | null;
+/**
+ * One page of a trial's trace — trials().trace().
+ *
+ * Same envelope as every other collection, and nextCursor means the same
+ * thing: pass it back as { cursor } for the next page, and NULL MEANS CAUGHT
+ * UP. To resume a poll later, keep the last event's `seq` and pass it as
+ * { cursor } — the trace's cursor IS its position in the seq timeline.
+ */
+type TraceEventPage = Page<TraceEvent>;
+/** How many of the trials behind an aggregate were SCORED (means cover SCORED only). */
+interface CompareCoverage {
+    scored: number;
+    total: number;
+}
+/**
+ * One (task, job) cell. `status` is a TrialStatus when every trial in the cell
+ * shares it, "MIXED" when they differ, "MISSING" when the job has no trials
+ * for the task.
+ */
+interface CompareCell {
+    job_id: string;
+    status: TrialStatus | "MIXED" | "MISSING";
+    /** Mean reward over the cell's SCORED trials; null when none. Zero is a reward. */
+    mean_reward: number | null;
+    coverage: CompareCoverage;
+}
+/** One matrix row of jobs().compare(): a task across the compared jobs */
+interface CompareTaskRow {
+    task_name: string;
+    /** True when the jobs' cells differ in status or reward for this task */
+    disagreement: boolean;
+    /** Cells in the caller's job-id order */
+    cells: CompareCell[];
+}
+/** Per-job aggregate of jobs().compare() */
+interface CompareJobAggregate {
+    id: string;
+    datasets: DatasetRef[];
+    status: JobStatus;
+    /** Mean reward over SCORED trials only; null when none. Zero is a reward. */
+    mean_reward: number | null;
+    coverage: CompareCoverage;
+    cost_usd: number;
+    agents: AgentArm[];
+    started_at: string;
+}
+/**
+ * Result of jobs().compare([ids]): per-job aggregates plus a per-task matrix
+ * (disagreement rows first). `taskMatrix` is a frozen camelCase wire key.
+ */
+interface CompareResponse {
+    /** Aggregates in the caller's id order */
+    jobs: CompareJobAggregate[];
+    taskMatrix: CompareTaskRow[];
+}
+/** Fields every job event carries, whatever its type. */
+interface JobEventBase {
+    /** Monotonic sequence number (SSE id; the Last-Event-ID resume position) */
+    seq: number;
+}
+/** The job's resolved creation inputs, echoed so a watcher that joined late knows what it is watching. */
+interface JobCreatedData {
+    datasets: DatasetRef[];
+    task_count: number;
+    agents: AgentArm[];
+    n_attempts: number;
+    n_concurrent_trials: number;
+    max_trial_spend_usd: number;
+    sandbox_provider: EvalSandboxProvider;
+    trial_count: number;
+    /** The resolved auto-retry policy the job runs under. */
+    retry: RetryConfig;
+    /**
+     * The resolved timeout multipliers (the same five flat fields the job body
+     * echoes); events older than the feature replay as every phase at 1.0.
+     */
+    timeout_multiplier: number;
+    agent_timeout_multiplier: number | null;
+    verifier_timeout_multiplier: number | null;
+    agent_setup_timeout_multiplier: number | null;
+    environment_build_timeout_multiplier: number | null;
+}
+interface JobCancellingData {
+    job_id: string;
+    /** Queued trials cancelled outright by the request */
+    cancelled_trials: number;
+    /** Trials still in flight, winding down before the job settles */
+    active_trials: number;
+}
+interface JobCancelledData {
+    job_id: string;
+    /** Total queued trials cancelled across the request and the settle */
+    cancelled_trials: number;
+}
+interface TrialRunningData {
+    trial_id: string;
+    task_name: string;
+}
+interface TrialScoringData {
+    trial_id: string;
+    /** Bytes of agent stdout retained for the failure detail */
+    captured_bytes?: number;
+}
+/**
+ * A mid-run spend sample landed on a still-live trial. Emitted only when the
+ * reading actually updated a RUNNING/SCORING row, so a poll that raced the
+ * settle never fires one. The token sums come from the same ledger aggregation
+ * that produced the money figure, present only when the sample carried them —
+ * an older event replays without them.
+ */
+interface TrialSpendData {
+    trial_id: string;
+    task_name: string;
+    /** The same lagging lower bound as Trial.live_spent_usd — not the trial's cost */
+    live_spent_usd: number;
+    /** Input tokens so far; includes cache tokens */
+    n_input_tokens?: number;
+    /** Cached input tokens so far (a subset of n_input_tokens) */
+    n_cache_tokens?: number;
+    /** Output tokens so far */
+    n_output_tokens?: number;
+}
+/**
+ * A trial reached a terminal status. `reward` is present only on the scored
+ * path; `exception_type` and `exception_message` only on a failure (a cancel
+ * carries `exception_type` alone — see `exception_message`); `attempt_phase`
+ * appears when the settle happened mid-phase (worker death), which is exactly
+ * when knowing the phase is worth having.
+ */
+interface TrialSettledData {
+    trial_id: string;
+    task_name: string;
+    status: TrialStatus;
+    /** Zero is a reward; absent means the trial did not score. */
+    reward?: number | null;
+    exception_type?: string;
+    /**
+     * The failure in its own words — the same text the trial's
+     * `exception_info.exception_message` holds at settle time (a later
+     * auto-retry verdict is appended to the trial's copy, never to this
+     * frame's). Present only on a failure, beside `exception_type`. Two settled
+     * frames carry `exception_type` alone: a cancel (`CancelledError` — stopped,
+     * not failed; no words are stored) and an event recorded before this field
+     * existed.
+     */
+    exception_message?: string;
+    attempt_phase?: AttemptPhase | null;
+}
+/**
+ * The auto-retry policy put a failed trial back on the queue. Follows the
+ * `trial.settled` of the failure it retries — a watcher that treats
+ * `trial.settled` as final must check for a following `trial.retrying` on
+ * the same trial. The trial runs again no earlier than `delay_sec` from
+ * this event.
+ */
+interface TrialRetryingData {
+    trial_id: string;
+    task_name: string;
+    /** Which retry this is (1-based). */
+    retry: number;
+    /** The policy's budget, for "retry 2/3" displays. */
+    max_retries: number;
+    /** The backoff applied before the trial is claimable again. */
+    delay_sec: number;
+    /** The exception name the adjudication ran under. */
+    exception_type: string;
+}
+/**
+ * The CLASS of infrastructure fault the auto-retry circuit breaker compares
+ * on — resolved from the trial's typed failure phase, never from message
+ * text (spec `InfraFailureSignature`). `sandbox_death`: the box ceased to
+ * exist while a run still owed it. `provider_create_failure`: the box never
+ * came up. `stream_disconnect`: the run's event stream ended without the
+ * harness ever speaking. `exec_chdir_failure`: the container exec never
+ * started the harness at all (the OCI runtime refused its working directory).
+ */
+type InfraFailureSignature = "sandbox_death" | "provider_create_failure" | "stream_disconnect" | "exec_chdir_failure";
+/**
+ * The auto-retry circuit breaker refused a retry the policy would otherwise
+ * have run: `consecutive` infrastructure failures of the same `signature` in
+ * a row. Follows the `trial.settled` of the failure that tripped it, in the
+ * place a `trial.retrying` would have taken — the trial stays terminal
+ * (INFRASTRUCTURE_ERROR), its own `exception_info.exception_message` gains
+ * the verdict after the failure's words, and `retries_unused` of
+ * `max_retries` are never spent. Every key is present on every frame.
+ */
+interface TrialRetryCircuitBrokenData {
+    trial_id: string;
+    task_name: string;
+    signature: InfraFailureSignature;
+    /** Same-signature failures in a row; the breaker trips at two. */
+    consecutive: number;
+    /**
+     * The typed failure phase the signature was resolved from (`sandbox_died`,
+     * `sandbox_boot`, `harness_crash`, …) — the archive's `x_evolve.failurePhase`,
+     * not the `attempt_phase` vocabulary.
+     */
+    failure_phase: string;
+    /** The policy's budget. */
+    max_retries: number;
+    /** How much of `max_retries` the break left unspent (at least one). */
+    retries_unused: number;
+    /**
+     * The last failure in its own words, as it was settled — the text its
+     * `trial.settled` frame carried, before the trial's own copy gained the
+     * breaker's verdict. `null` only on a frame recorded before the words rode it.
+     */
+    exception_message: string | null;
+}
+/**
+ * One server-sent event from jobs().watch(), as a DISCRIMINATED UNION on
+ * `type` and ONLY on `type`: several event types carry identically shaped
+ * payloads (`job.running` and `job.completed` are both `{job_id}`), so payload
+ * shape can never route a reader — the `type` constant does. Switching on
+ * `type` narrows `data`.
+ *
+ * job.failed is declared terminal by the event stream and by this SDK, but NO
+ * SERVER PATH EMITS IT today. It stays in the union because both consumers
+ * treat it as terminal — the payload is fixed now so a client written today
+ * parses it when it first appears. Treat it as RESERVED rather than expected.
+ */
+type JobEvent = (JobEventBase & {
+    type: "job.created";
+    data: JobCreatedData;
+}) | (JobEventBase & {
+    type: "job.running";
+    data: {
+        job_id: string;
+    };
+}) | (JobEventBase & {
+    type: "job.cancelling";
+    data: JobCancellingData;
+}) | (JobEventBase & {
+    type: "job.cancelled";
+    data: JobCancelledData;
+}) | (JobEventBase & {
+    type: "job.completed";
+    data: {
+        job_id: string;
+    };
+}) | (JobEventBase & {
+    type: "job.failed";
+    data: {
+        job_id: string;
+    };
+}) | (JobEventBase & {
+    type: "trial.running";
+    data: TrialRunningData;
+}) | (JobEventBase & {
+    type: "trial.scoring";
+    data: TrialScoringData;
+}) | (JobEventBase & {
+    type: "trial.spend";
+    data: TrialSpendData;
+}) | (JobEventBase & {
+    type: "trial.settled";
+    data: TrialSettledData;
+}) | (JobEventBase & {
+    type: "trial.retrying";
+    data: TrialRetryingData;
+}) | (JobEventBase & {
+    type: "trial.retry_circuit_broken";
+    data: TrialRetryCircuitBrokenData;
+});
+/**
+ * The handle returned by jobs().watch(). It is both:
+ * - a promise for the final Job — `await client.watch(id)` resolves once
+ *   the job reaches a terminal status (the original form); and
+ * - an async iterable of events — `for await (const event of client.watch(id))`
+ *   yields each JobEvent and completes on the terminal event.
+ *
+ * Pick one form per call: both drive the same underlying SSE stream, so a
+ * single handle should not be awaited and iterated at once.
+ */
+interface JobWatch extends Awaitable<Job>, AsyncIterable<JobEvent> {
+}
+/** Cursor page of jobs (newest first) */
+type JobPage = Page<Job>;
+/**
+ * The handle returned by jobs().list(). Both:
+ * - a promise for a single JobPage — `await client.list({ limit })`
+ *   returns one page (the original form); and
+ * - an async iterable — `for await (const item of client.list())` walks every
+ *   job across cursor pages, fetching the next page for you.
+ */
+interface JobList extends Awaitable<JobPage>, AsyncIterable<Job> {
+}
+/** Cursor page of trace analyses (newest first) */
+type AnalysisPage = Page<TrialAnalysis>;
+/**
+ * The handle returned by analyses().list(). Both a promise for one page and
+ * an async iterable across cursor pages, like every other list handle.
+ */
+interface AnalysisList extends Awaitable<AnalysisPage>, AsyncIterable<TrialAnalysis> {
+}
+/** Cursor page of task quality checks (newest first) */
+type CheckPage = Page<Check>;
+/** The handle returned by checks().list() — one page on await, every page on for-await. */
+interface CheckList extends Awaitable<CheckPage>, AsyncIterable<Check> {
+}
+/**
+ * One task's rollup within a job: its trial tally, mean reward over SCORED
+ * trials, and measured cost. Sits between the job body and the trial list so
+ * a caller need not fetch every trial to see which tasks are dragging.
+ */
+interface JobTaskRollup {
+    task_name: string;
+    /** The dataset the task came from. */
+    source: string;
+    trials: TrialStatusTally;
+    /** Mean over SCORED trials only; null when none. Zero is a reward. */
+    mean_reward: number | null;
+    /** Measured spend across the task's settled trials. */
+    cost_usd: number | null;
+    /**
+     * The task's LATEST quality check among the checks you may read that ran
+     * on a dataset version this job spans (`checks().create({ source: {
+     * dataset } })`); null = never checked. The job page's CHECK tab reads it.
+     */
+    check: TaskCheck | null;
+}
+/** Cursor page of per-task rollups */
+type JobTaskRollupPage = Page<JobTaskRollup>;
+/**
+ * The handle returned by jobs().tasks(). Both a promise for one page and an
+ * async iterable across cursor pages, like every other list handle.
+ */
+interface JobTaskRollupList extends Awaitable<JobTaskRollupPage>, AsyncIterable<JobTaskRollup> {
+}
+/** Cursor page of trials */
+type TrialPage = Page<Trial>;
+/**
+ * The handle returned by jobs().trials(). Both:
+ * - a promise for a single TrialPage — `await client.trials(id, { limit })`
+ *   returns one page (the original form); and
+ * - an async iterable — `for await (const trial of client.trials(id))` walks
+ *   every trial across cursor pages, fetching the next page for you.
+ */
+interface TrialList extends Awaitable<TrialPage>, AsyncIterable<Trial> {
+}
+/**
+ * Dataset version lifecycle state (wire values). Terminal: READY, FAILED,
+ * ARCHIVED. RECEIVING sits before the walk (register-first): the corpus is
+ * still uploading through its resumable session — the row exists so the
+ * publish is visible from the first byte, and moves to IMPORTING when the
+ * upload completes and the publish is accepted.
+ */
+type DatasetVersionState = "DRAFT" | "RECEIVING" | "IMPORTING" | "BUILDING" | "READY" | "FAILED" | "ARCHIVED";
+/** One dataset.toml author: a name, and an email when the manifest gives one. */
+interface DatasetManifestAuthor {
+    name: string;
+    email: string | null;
+}
+/**
+ * The metadata half of the Harbor dataset.toml manifest a version imported
+ * under. The full manifest additionally pins per-task/per-file content
+ * digests — verified server-side at import (a mismatch FAILS the import,
+ * `manifest_digest_mismatch`) and readable in the retained package; the wire
+ * carries identity + metadata.
+ */
+interface DatasetManifestMetadata {
+    /** The manifest's own dataset name, Harbor `org/name` format. */
+    name: string;
+    /** The manifest's `[dataset].version`; null when it declares none. */
+    version: string | null;
+    description: string;
+    authors: DatasetManifestAuthor[];
+    keywords: string[];
+    /**
+     * How many `[[tasks]]` refs the manifest listed (duplicates included,
+     * Harbor's task_count). Null on rows stored before the count was recorded.
+     */
+    task_count: number | null;
+}
+/**
+ * A version published from a git repository (`git_url` + `git_ref`): the
+ * repository, the ref exactly as requested, the RESOLVED commit the clone
+ * landed on (for an annotated tag, the peeled commit — never the tag
+ * object), and the repository subfolder the corpus was read from.
+ */
+interface DatasetVersionGitSource {
+    kind: "git";
+    /**
+     * The repository this version was imported from, userinfo (an embedded
+     * token) stripped; null only when the stored url cannot be parsed.
+     */
+    git_url: string | null;
+    /** The ref the import was asked for, exactly as requested: a sha, a tag, or (legacy rows) a branch. */
+    ref: string;
+    /** The commit the corpus was actually read from — the resolved sha, peeled for an annotated tag. */
+    commit: string;
+    /** The repository subfolder the corpus was read from; null = repository root. */
+    path: string | null;
+}
+/**
+ * A version published from an UPLOADED archive — the multipart `archive`
+ * part, which is what `publish({ source: { directory } })` and the CLI's
+ * `--dir` send. No locator: the bytes came from the client.
+ */
+interface DatasetVersionArchiveSource {
+    kind: "archive";
+    /** `sha256:<hex>` over the uploaded tarball's bytes. */
+    digest: string;
+}
+/** A version published from a fetched tarball (`archive_url`). */
+interface DatasetVersionArchiveUrlSource {
+    kind: "archive_url";
+    /** The public https url the corpus tarball was fetched from, as given. */
+    archive_url: string;
+    /** `sha256:<hex>` over the fetched tarball's bytes. */
+    digest: string;
+}
+/** A version published from a Harbor hub package (`hub_package`). */
+interface DatasetVersionHubSource {
+    kind: "hub_package";
+    /** The package reference as given — `org/name` or `org/name@ref` (Harbor's reference grammar). */
+    hub_package: string;
+    /**
+     * `sha256:<hex>` — the hub's content hash over the task file set (Harbor's
+     * recipe), the immutable hub version the import was pinned to, whatever
+     * the reference's tag points at today.
+     */
+    digest: string;
+}
+/**
+ * What one version was imported from — the LOCATOR the publish named (what
+ * you would pass to publish the same source again) and the IDENTITY the
+ * import resolved it to — one shape per publish kind, discriminated on
+ * `kind` in the publish request's own vocabulary. Served on EVERY version
+ * whatever its state: a version whose build FAILED can never become the
+ * active version, so this is where its imported bytes stay observable.
+ * Every `digest` is spelled `sha256:<hex>`; a git `commit` is a bare sha.
+ */
+type DatasetVersionSource = DatasetVersionGitSource | DatasetVersionArchiveSource | DatasetVersionArchiveUrlSource | DatasetVersionHubSource;
+/**
+ * One task's own terminal build state inside a published version — the
+ * per-task member of the DatasetVersionState family (the partial-publish
+ * model). Every task of a settled build is exactly one of these; there is no
+ * per-task "building" state on the wire, because outcomes are recorded only
+ * when the version settles.
+ */
+type TaskBuildState = "READY" | "FAILED";
+/**
+ * Why one task FAILED its independent build — the ONE failure grammar for
+ * every step: parse-level refusals (schema/capability) and build-level
+ * failures (image build, mirror, compose resolution, image-config read,
+ * skills verification) speak it identically.
+ */
+interface TaskBuildFailure {
+    /**
+     * Typed reason. Parse refusals record `task_parse_failed`; build steps
+     * record the builder's own family (`image_build_failed`,
+     * `builder_unavailable`, `image_push_failed`, ...). Open set — render the
+     * string; branch on `step` for coarse grouping.
+     */
+    code: string;
+    /**
+     * The build step that failed: `parse`, `image-build`, `image-config`,
+     * `skills-verify`, `compose-resolve`, `image-mirror`, or `store`.
+     */
+    step: string;
+    /** The failure sentence, naming the task's own defect. */
+    message: string;
+    /**
+     * Bounded tail of the failing step's build log (the failing line and its
+     * neighbourhood). Served by the per-task build route; list surfaces omit
+     * it. Null when the step produced no log to excerpt (a parse refusal's
+     * message IS the whole story).
+     */
+    excerpt?: string | null;
+}
+/**
+ * One task's build outcome inside one published version — the failure-detail
+ * read (datasets().getTaskBuild()). READY tasks answer too (failure and log
+ * pointer null), so a poller needs no negative-space reasoning.
+ */
+interface TaskBuild {
+    task_name: string;
+    state: TaskBuildState;
+    /** The typed reason WITH the failing-step excerpt; null on READY. */
+    failure: TaskBuildFailure | null;
+    /**
+     * Pointer to the FULL build log of the failing step
+     * (`cloudwatch://<group>/<stream>` for image builds), for operators and
+     * support tooling. Null when the failing step kept no separate log (parse
+     * refusals), and on READY tasks.
+     */
+    build_log_ref: string | null;
+}
+/**
+ * One failed task on the dataset detail's `failed_tasks` list: the compact
+ * typed reason. The failing-step excerpt and build-log pointer live on the
+ * per-task build route (datasets().getTaskBuild()).
+ */
+interface DatasetFailedTask {
+    task_name: string;
+    failure: TaskBuildFailure;
+}
+/** One immutable version of a dataset — one shape on every surface */
+interface DatasetVersion {
+    version: string;
+    state: DatasetVersionState;
+    created_at: string;
+    /**
+     * The READY (runnable) tasks of this version. Under the partial-publish
+     * model this is what a whole-dataset job runs.
+     */
+    task_count: number;
+    /**
+     * Tasks of the published corpus that FAILED their independent build and
+     * are therefore not runnable in this version (the partial-publish model).
+     * 0 on a fully built version — and on servers that predate the field. The
+     * names and reasons are on the dataset detail's `failed_tasks`; the full
+     * per-task detail (excerpt + build-log pointer) answers at
+     * datasets().getTaskBuild(). Fixing one is a re-publish — versions are
+     * immutable.
+     */
+    n_failed_tasks: number;
+    /**
+     * The dataset.toml identity/metadata this version imported under. Null when
+     * the corpus carried no manifest, and on servers that predate the field —
+     * absence is "nothing to report", never a crash.
+     */
+    manifest: DatasetManifestMetadata | null;
+    /**
+     * What THIS version was imported from, per publish kind (`kind`: git /
+     * archive / archive_url / hub_package). Null when the platform recorded
+     * nothing readable (a seeded directory, a pre-provenance row, or a fetched
+     * archive_url / hub_package row whose locator was never stored), and on
+     * servers that predate the field — absence is "nothing to report", never a
+     * fabricated value.
+     */
+    source: DatasetVersionSource | null;
+}
+/**
+ * One provider's verdict for a task: runnable there, refused with the
+ * limitation named (e.g. a multi-container task on a provider that cannot
+ * host its services, or declared resources above the provider's ceiling), or
+ * — GPU tasks only — runnable via a recorded DEGRADE: `ok: true` with
+ * `degrades_to: "modal"` means a job stamped on this provider still runs the
+ * task, on modal, and the trial records the same fact as
+ * `sandbox_provider_degrade`; `reason` then carries this provider's own
+ * sentence for why it could not serve the GPUs itself.
+ */
+type TaskProviderVerdict = {
+    ok: true;
+    degrades_to?: "modal";
+    reason?: string;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * A typed, non-fatal fact recorded about an ACCEPTED task — not a refusal
+ * (the task imports and runs) and not a failure (nothing failed): a recorded
+ * degrade the platform states where the publisher reads it.
+ *
+ * `tests_dockerfile_not_built`: the task ships a tests/Dockerfile the verifier
+ * does not build, because upstream never would on its shape — the separate
+ * verifier's effective environment pins a docker_image (Harbor boots it
+ * as-is), or the verifier is shared and runs inside the agent box; a
+ * dependency the recipe would install must already be in the image the
+ * verifier boots. `message` is the platform's own sentence, naming the shape.
+ */
+interface TaskNote {
+    code: "tests_dockerfile_not_built";
+    message: string;
+}
+/** Public task fields only — instructions, environments, and tests never leave the server */
+interface Task {
+    task_name: string;
+    agent_timeout_sec: number;
+    verifier_timeout_sec: number;
+    /**
+     * GPUs the task declares (task.toml [environment] gpus — Harbor's field
+     * honored verbatim). 0 = a CPU task. Absent on servers predating the field
+     * — treat as 0.
+     */
+    gpus?: number;
+    /**
+     * Acceptable GPU types (e.g. ["H100"]), Harbor semantics: null means ANY
+     * type is acceptable. Always null when gpus is 0.
+     */
+    gpu_types?: string[] | null;
+    /**
+     * Where the task can run, per sandbox provider. Advisory for planning a
+     * job's provider choice — creating a job whose tasks include one refused on
+     * the chosen provider is rejected with the same reason, so nothing is ever
+     * spent on a trial that cannot execute.
+     */
+    providers: Record<EvalSandboxProvider, TaskProviderVerdict>;
+    /**
+     * Typed, non-fatal facts recorded about the task at import (TaskNote).
+     * [] when there is nothing to say — every task imported before the notes
+     * existed, and every task on a server predating the field.
+     */
+    notes: TaskNote[];
+}
+/**
+ * The active version's git PROVENANCE — git_url + the requested ref + the
+ * resolved commit + the repository subfolder — plus, for a ref that can move,
+ * the WATCH: where the ref points now versus what the version was built from,
+ * the data behind a "new version available" badge. Null when the active
+ * version did not come from a git remote (an uploaded tarball, a seeded
+ * corpus, a pre-provenance row); null is never "up to date". A version pinned
+ * to a commit sha serves the provenance with the watch at rest (latest_commit
+ * / checked_at / error null, moved false) — nothing checks a pin. Nothing
+ * here imports anything — a new version is always a row you create (or
+ * `auto_import` creates).
+ */
+interface UpstreamStatus {
+    /**
+     * The repository the active version was imported from, with any userinfo
+     * (an embedded token) stripped; null only when the stored url cannot be
+     * parsed. Absent on a pre-provenance server.
+     */
+    git_url?: string | null;
+    /** The ref the active version was imported from, exactly as requested. */
+    ref: string;
+    /** The commit the active version was built from (the resolved sha). */
+    current_commit: string;
+    /**
+     * The repository subfolder the corpus was read from; null = repository
+     * root. Absent on a pre-provenance server.
+     */
+    path?: string | null;
+    /** Where the ref points upstream now; null when the last check failed. */
+    latest_commit: string | null;
+    /**
+     * The newest commit a local version already exists for, whether or not it
+     * is the active one; null before any import recorded one. Absent on an
+     * older server.
+     */
+    acked_commit?: string | null;
+    /** True when upstream has moved off the built-from commit. Branch on this. */
+    moved: boolean;
+    /** Reserved; always null today. */
+    behind_by: number | null;
+    /** When the cached answer was taken; null before the first check. */
+    checked_at: string | null;
+    /** Why the last check failed. Show "could not check", not "up to date". */
+    error: string | null;
+    /** Whether a moved upstream automatically imports a new version. */
+    auto_import: boolean;
+}
+/**
+ * A dataset in the catalog.
+ *
+ * list() returns the summary fields; get() additionally populates versions,
+ * selected_version, tasks, created_at, and updated_at.
+ */
+interface Dataset {
+    name: string;
+    title: string | null;
+    description: string | null;
+    /** The active version, or null when none is active (bare-name job refs refuse). */
+    active_version: DatasetVersion | null;
+    /**
+     * The dataset's NEWEST version row (newest created_at first, id as the
+     * tiebreak) — active or not.
+     *
+     * This is what makes a publish observable BEFORE it lands: a first
+     * publish walks IMPORTING -> BUILDING here while `active_version` is
+     * still null — the importer itself flips the finished build to READY and,
+     * on an owner-stamped dataset, promotes it to the active version in the
+     * same transaction. It can also hold a version that never landed (a
+     * FAILED build), so it is NOT a substitute for `active_version`: a
+     * bare-name job ref still resolves the active version and refuses
+     * without one.
+     *
+     * Null when the dataset has no version rows at all — and also null when
+     * talking to a server older than this field.
+     */
+    latest_version: DatasetVersion | null;
+    /** All versions, newest first (get() only) */
+    versions?: DatasetVersion[];
+    /** The version whose tasks are listed below (get() only) */
+    selected_version?: DatasetVersion | null;
+    /**
+     * One page of the selected version's tasks (get() only). Paged like every
+     * other collection: a SWE-bench-scale dataset has thousands of tasks, so
+     * pass { limit, cursor } to get() and follow nextCursor.
+     */
+    tasks?: Page<Task>;
+    /**
+     * The selected version's tasks that FAILED their independent build (get()
+     * only; the partial-publish model). Always present on the detail body —
+     * empty on a fully built version. Ordered by task name and capped at the
+     * task page limit; `n_failed_tasks` on the version object is always the
+     * exact count. Each entry carries the typed reason; the failing-step
+     * excerpt and build-log pointer live on datasets().getTaskBuild().
+     */
+    failed_tasks?: DatasetFailedTask[];
+    upstream: UpstreamStatus | null;
+    /** get() only */
+    created_at?: string;
+    /** get() only */
+    updated_at?: string;
+}
+/** Body of datasets().update() — the only settable dataset field. */
+interface DatasetPatch {
+    /** Automatically import a new version when the upstream git ref moves. */
+    upstream_auto_import: boolean;
+}
+/**
+ * A dataset's active version resolved to a runnable shape.
+ *
+ * Unlike Dataset, `version` and `tasks` are non-optional: datasets()
+ * .getActive() throws NoActiveVersionError when there is no active version,
+ * so callers never branch on a missing active version.
+ */
+interface ActiveDataset {
+    name: string;
+    title: string | null;
+    description: string | null;
+    /** The active version (always present) */
+    active_version: DatasetVersion;
+    /** The active version string (identical to active_version.version) */
+    version: string;
+    /** One page of the active version's tasks */
+    tasks: Page<Task>;
+    /** All versions, newest first */
+    versions: DatasetVersion[];
+    created_at: string;
+    updated_at: string;
+}
+/** Cursor page of datasets */
+type DatasetPage = Page<Dataset>;
+/** Dual-use handle from datasets().list(): await one page, or iterate them all */
+interface DatasetList extends Awaitable<DatasetPage>, AsyncIterable<Dataset> {
+}
+/**
+ * Source for datasets().publish(): a git repository pinned to a ref, a local
+ * corpus directory (tarred deterministically on the client and uploaded), a
+ * PUBLIC https tarball URL the server fetches itself, or a PUBLIC Harbor hub
+ * package the server resolves and fetches — the last two move zero client
+ * bytes.
+ *
+ * A UNION, not five optional fields: `{}` and two-branches-at-once are
+ * compile errors rather than a 400 the caller discovers at run time, and
+ * `?: never` on the absent branches' keys is what rejects the excess property
+ * through a variable. `git_ref` is REQUIRED on the git branch — an unpinned
+ * import is not reproducible.
+ */
+type DatasetSource = {
+    /**
+     * A git repository URL. https:// only — the import runs on a worker with
+     * no ssh client, so ssh:// and git@ remotes are refused at validation.
+     * For a private repository, put a token in the https url.
+     */
+    git_url: string;
+    /**
+     * A PINNED ref, required: a full 40-hex commit sha, or a tag (the
+     * server resolves it to its commit at accept time, stores the sha, and
+     * verifies the tag still points there at import). A branch name is
+     * refused with `unpinned_git_ref` — an unpinned import is not
+     * reproducible — and the refusal's details carry the commit the branch
+     * points at right now, the pin to use instead.
+     */
+    git_ref: string;
+    /**
+     * Optional repository SUBFOLDER holding the corpus (POSIX path relative
+     * to the repository root, e.g. "datasets/my-swe"). The server imports
+     * only that folder, fetched via git sparse checkout. Ambiguity is
+     * refused rather than interpreted: no absolute paths, no "." / ".." or
+     * empty segments, no backslashes, whitespace, pattern characters, or
+     * ".git" segments — and a path that is not a directory at the pinned
+     * ref fails the import loudly instead of landing a 0-task version.
+     */
+    git_path?: string;
+    directory?: never;
+    archive_url?: never;
+    hub_package?: never;
+} | {
+    /** A local standard-layout corpus directory — tarred + gzipped and uploaded. */
+    directory: string;
+    git_url?: never;
+    git_ref?: never;
+    git_path?: never;
+    archive_url?: never;
+    hub_package?: never;
+} | {
+    /**
+     * A PUBLIC https URL to a gzipped corpus tarball — the SERVER fetches
+     * it, so no bytes leave this machine. Public sources only: credentials
+     * in the URL are refused (authenticated sources are a planned
+     * follow-up) and the host must be publicly resolvable. The fetched
+     * bytes pass the same validation and size caps as an uploaded archive.
+     * `name` and `version` are required with this source.
+     */
+    archive_url: string;
+    git_url?: never;
+    git_ref?: never;
+    git_path?: never;
+    directory?: never;
+    hub_package?: never;
+} | {
+    /**
+     * A PUBLIC Harbor hub package reference, `org/name[@ref]` in Harbor's
+     * own grammar — no ref (or `latest`) is the latest tag, a number is a
+     * revision, `sha256:<64 hex>` is a digest, anything else is a tag. The
+     * server resolves it when the publish is accepted and the worker
+     * fetches BY the resolved digest, so a tag moved after the 202 can
+     * never deliver different bytes. A task package imports as a one-task
+     * dataset; a dataset package fetches every digest-pinned member; both
+     * are digest-verified against the hub's own pins. `name` defaults to
+     * the package's short name and `version` to its resolved revision. A
+     * missing or private package is refused `hub_package_not_found`; an
+     * unreachable hub is `hub_unreachable` (502) — retry the publish.
+     */
+    hub_package: string;
+    git_url?: never;
+    git_ref?: never;
+    git_path?: never;
+    directory?: never;
+    archive_url?: never;
+};
+/** Input for datasets().preflight() — the dry-run half of publish. */
+interface PreflightDatasetInput {
+    /**
+     * A local standard-layout corpus directory. Only its METADATA moves: the
+     * client walks the corpus shape (a single task directory, a tasks/ subdir,
+     * or a root of task directories — the import's own reading), collects each
+     * task's task.toml plus the optional dataset.toml manifest, and posts
+     * kilobytes of JSON. The corpus bytes themselves never leave the machine.
+     */
+    source: {
+        directory: string;
+    };
+}
+/**
+ * One task's dry-run verdict. `ok: true` means no task.toml-decidable import
+ * guard would refuse the task — never "this task will import"; the checks a
+ * toml alone cannot decide are named in DatasetPreflight.deferred and the
+ * real publish stays the authority. `ok: false` carries the importer's own
+ * refusal sentence, exactly what a real import of this task would say.
+ */
+interface PreflightTaskVerdict {
+    /** The task directory's basename. */
+    name: string;
+    ok: boolean;
+    /** metadata.task_id, or its directory-name fallback. */
+    task_key: string;
+    /** Present with ok true: the recorded Harbor schema_version. */
+    schema_version?: string;
+    /**
+     * Present with ok true: verdict per sandbox provider over the
+     * toml-declared requirements (GPU, sizing, network) — the same
+     * adjudication the published dataset's task stamps use, with the
+     * compose/image-command halves deferred to the import.
+     */
+    providers?: Record<EvalSandboxProvider, TaskProviderVerdict>;
+    /**
+     * Present with ok true: the typed task notes a task.toml alone decides —
+     * today `tests_dockerfile_not_built` for a separate verifier whose
+     * effective environment pins a docker_image (the image is booted as-is and
+     * tests/ is never built, upstream semantics), worded conditionally because
+     * the door never sees whether the tests tree ships a Dockerfile. [] when
+     * there is nothing to say; absent on servers predating the field.
+     */
+    notes?: TaskNote[];
+    /** Present with ok false: the importer's refusal sentence. */
+    reason?: string;
+}
+/** An import guard the pre-flight cannot run, and what it reads instead. */
+interface PreflightDeferredCheck {
+    name: string;
+    reads: string;
+}
+/** The dataset.toml manifest's dry-run verdict (null when none was sent). */
+interface PreflightManifestVerdict {
+    ok: boolean;
+    /** Present with ok true: [dataset].name (Harbor org/name). */
+    name?: string;
+    /** Present with ok true: the catalog-facing half of the name. */
+    short_name?: string;
+    /** Present with ok true: [dataset].version, null when it declares none. */
+    version?: string | null;
+    /** Present with ok true: unique (name, digest) task entries. */
+    task_count?: number;
+    /** Present with ok false: the import's manifest refusal sentence. */
+    reason?: string;
+}
+/**
+ * The dry-run answer of POST /api/datasets/preflight. Nothing was written to
+ * produce it: `checks` names the guards that ran, `deferred` the import
+ * guards a task.toml alone cannot decide.
+ */
+interface DatasetPreflight {
+    /** The pinned parser revision that judged (e.g. "harbor-import/14"). */
+    importer_version: string;
+    checks: string[];
+    deferred: PreflightDeferredCheck[];
+    manifest: PreflightManifestVerdict | null;
+    tasks: PreflightTaskVerdict[];
+    tasks_total: number;
+    tasks_ok: number;
+    tasks_refused: number;
+}
+/** Input for datasets().publish() */
+interface PublishDatasetInput {
+    source: DatasetSource;
+    /**
+     * Catalog dataset name the version lands under (created or extended).
+     * Optional when a `directory` source carries a dataset.toml manifest — the
+     * server derives the name from the manifest (the short segment of its
+     * `org/name`) — and for a `hub_package` source, which defaults to the
+     * package's short name. Always required for a git or `archive_url` source,
+     * whose corpus the server only fetches after the publish is accepted.
+     */
+    name?: string;
+    /**
+     * Version label for the new immutable version. Optional when a `directory`
+     * source's dataset.toml declares `[dataset].version` and for a
+     * `hub_package` source (defaults to the resolved hub revision number);
+     * required otherwise.
+     */
+    version?: string;
+}
+/** Options for datasets().publish() */
+interface PublishDatasetOptions {
+    /**
+     * Called as the archive's bytes go onto the wire (a `directory` source
+     * only — a git source uploads nothing). `sentBytes` counts archive bytes
+     * whose write the transport confirmed flushed; `totalBytes` is the
+     * archive's size. Client-side by construction: the stream itself is the
+     * measurement, no server call is made. Fires per flushed chunk — throttle
+     * in the renderer, not here.
+     */
+    onUploadProgress?: (sentBytes: number, totalBytes: number) => void;
+    /**
+     * Register-first: called ONCE, the moment the resumable door's session
+     * open pre-creates the import (before any corpus byte moves), with the
+     * import id the eventual 202 will carry. A watcher may attach to it right
+     * away — `datasets().watchImport(importId)`, or `evolve dataset watch`
+     * from any machine. Never called on the single-request door (nothing is
+     * registered: the upload IS the request), on a fetched source, or when
+     * the server registered nothing (an existing name@version, or an older
+     * server).
+     */
+    onRegistered?: (importId: string) => void;
+}
+/**
+ * Dataset import status.
+ *
+ * The SAME four words a job uses, deliberately: a status chip rendering both
+ * never carries a translation table. Terminal: "COMPLETED" (the corpus landed
+ * as a dataset version; runnable once activated) and "FAILED".
+ */
+type DatasetImportStatus = "QUEUED" | "RUNNING" | "COMPLETED" | "FAILED";
+/** Structured failure detail for a FAILED import. */
+interface DatasetImportFailure {
+    /** Stable machine-readable cause; "import_failed" when none was recorded. */
+    code: string;
+    /** What went wrong, e.g. "2/113 task(s) failed to parse" */
+    message: string;
+    /** Per-task parse/validation failures, when the corpus was reachable */
+    failures?: {
+        task_name: string;
+        error: string;
+    }[];
+}
+/**
+ * Non-fatal but consequential import outcome. A version whose warnings include
+ * `no_solutions_archived` permanently lacks its reference-solution record —
+ * the record operator verification tooling reads, never a gate. The version
+ * still publishes, activates, and runs; the warning makes the permanent gap
+ * visible instead of silent.
+ *
+ * `tasks_failed_to_build` is the partial-publish model's warning: the import
+ * COMPLETED (the version is READY — at least one task built) but some tasks
+ * FAILED their independent build and are not runnable in this version. The
+ * names and typed reasons are on the dataset detail's `failed_tasks`; fixing
+ * them is a re-publish (immutable versions).
+ *
+ * `tests_dockerfile_not_built` names the READY tasks that ship a
+ * tests/Dockerfile the verifier never builds — their verifier image is pinned,
+ * or shared (upstream semantics: Harbor boots the pinned image as-is and never
+ * builds tests/ on that shape). Not an absence and not a failure: a recorded
+ * degrade. Each such task carries the same fact as a `tests_dockerfile_not_built`
+ * note on the dataset detail (Task.notes).
+ */
+interface ImportWarning {
+    code: "solutions_archiving_disabled" | "no_solutions_archived" | "partial_solutions_archived" | "tasks_failed_to_build" | "tests_dockerfile_not_built";
+    message?: string;
+}
+/**
+ * An asynchronous publish. Self-describing: every response names the
+ * dataset@version being imported — the 202 from publish(), getImport(), and
+ * listImports() all return this same shape, so a caller can render the row it
+ * just created without a follow-up read.
+ */
+/**
+ * The five phases of a publish, in the order they run (spec ImportPhaseName):
+ * extracting (archive fetched and unpacked, or the git source cloned),
+ * parsing (every task directory parsed, manifest gate included), building
+ * (the image pool — Dockerfile build contexts and compose-service
+ * resolutions), copying (upstream images mirrored into the platform
+ * registry), verifying (storability census, solutions archive, the task
+ * transaction, and the registry read-back before READY).
+ */
+type ImportPhase = "extracting" | "parsing" | "building" | "copying" | "verifying";
+/** One phase of the import timeline (spec ImportPhaseProgress). */
+interface ImportPhaseProgress {
+    name: ImportPhase;
+    started_at: string;
+    /**
+     * Absent while the phase runs — and stays absent forever on the phase a
+     * FAILED import died in, which is how a reader finds where it died.
+     */
+    completed_at?: string;
+    /**
+     * Units settled so far — task dirs (parsing), image-pool units (building),
+     * unique images (copying), surviving tasks (verifying). Failures count as
+     * settled; extracting has no unit and stays 0/0.
+     */
+    done: number;
+    total: number;
+    /**
+     * Of `done`, the units whose bytes already lived in the platform registry
+     * (content-addressed hit — nothing copied). Image phases only.
+     */
+    banked?: number;
+}
+/**
+ * Live progress of a publish (spec DatasetImportProgress) — written by the
+ * build worker at phase boundaries and coarse intervals, never per-second.
+ * On a terminal import it is the settled record: all five phases with
+ * wall-clock timestamps, the final image counts, and the publish's CodeBuild
+ * copy-build minutes.
+ */
+interface DatasetImportProgress {
+    /** What the import is doing now (the last entry of `phases`). */
+    phase: ImportPhase;
+    /** When the claimed run began on the worker — explicit, never derived. */
+    started_at: string;
+    phases: ImportPhaseProgress[];
+    /**
+     * The publish's cumulative image economics: `built` and `mirrored` are
+     * fresh pushes this publish paid for; `banked` counts images that already
+     * existed in the registry.
+     */
+    images: {
+        built: number;
+        mirrored: number;
+        banked: number;
+    };
+    /**
+     * The publish's promotion fan-out meter: CodeBuild copy builds started and
+     * their billed minutes. 0/0 on a fully banked re-publish.
+     */
+    codebuild: {
+        copy_builds: number;
+        billed_minutes: number;
+    };
+}
+interface DatasetImport {
+    /** Import job id */
+    id: string;
+    status: DatasetImportStatus;
+    /**
+     * The register-first marker: true exactly while the corpus is still
+     * uploading through its resumable session — the import is QUEUED and
+     * cannot proceed without the client — and false from the moment the
+     * publish is accepted. Absent on servers predating register-first.
+     */
+    receiving?: boolean;
+    /** Catalog dataset name the import creates or extends */
+    name: string;
+    /** Version label of the imported version */
+    version: string;
+    /**
+     * Why the import FAILED; null otherwise. Named `failure`, never `error` —
+     * see JobFailure.
+     */
+    failure: DatasetImportFailure | null;
+    /** Non-fatal but consequential outcomes — see ImportWarning. */
+    warnings: ImportWarning[];
+    /**
+     * Live progress of the build — null until the worker's first report (a
+     * QUEUED import, an older server, and every import that predates
+     * progress). On a terminal import it is the settled five-phase record.
+     */
+    progress: DatasetImportProgress | null;
+    /** Number of tasks parsed, once counted */
+    task_count?: number;
+    created_at?: string;
+    updated_at?: string;
+}
+/** Cursor page of dataset imports */
+type DatasetImportPage = Page<DatasetImport>;
+/** Dual-use handle from datasets().listImports(): await one page, or iterate them all */
+interface DatasetImportList extends Awaitable<DatasetImportPage>, AsyncIterable<DatasetImport> {
+}
+/**
+ * Where a registered agent's executables came from: an install script run in a
+ * throwaway builder sandbox, or a tarball uploaded from a local directory.
+ * Echoed on every response; the SDK never guesses it.
+ */
+type AgentSource = "install_script" | "tarball";
+/**
+ * A private agent registered by the caller. Once registered, its `name` is
+ * usable in job `agents[].name` exactly like a built-in ("claude", "codex",
+ * ...). Private to its owner: another user's name reads as `agent_not_found`,
+ * never as a permission error — existence is never leaked.
+ */
+interface Agent {
+    /** The name to put in job agents[].name */
+    name: string;
+    /** How the executables were produced */
+    source: AgentSource;
+    /** The command run headless with `sh -c` at the task working directory */
+    run_command: string;
+    /**
+     * Caller-declared env injected at RUN time only. It may not override the run
+     * contract's own keys — the server rejects that at registration with
+     * `agent_invalid_env`.
+     */
+    env: Record<string, string>;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * The two sources a registered agent's executables can come from. A union, not
+ * two optional fields — see DatasetSource for why `?: never` is load-bearing
+ * rather than decorative.
+ */
+type AgentSourceInput = {
+    /**
+     * The install script itself (not a path). It runs in a throwaway builder
+     * sandbox that has internet and ZERO secrets, so everything it fetches
+     * must be publicly fetchable, and it must leave executables in
+     * `$PREFIX/bin`.
+     */
+    install_script: string;
+    directory?: never;
+} | {
+    /**
+     * A local directory holding the agent — tarred + gzipped and uploaded.
+     * Same build rules as an install script.
+     */
+    directory: string;
+    install_script?: never;
+};
+/**
+ * Input for agents().create(): a name, a run command, and EXACTLY ONE source.
+ * The source half is a union, so omitting both or passing both is a compile
+ * error rather than a 400 the caller discovers at run time.
+ */
+type AgentInput = AgentSourceInput & {
+    /** Agent name; also the value used later in job agents[].name */
+    name: string;
+    /** Command run headless with `sh -c` at the task working directory */
+    run_command: string;
+    /** Env injected at RUN time only; may not override the run contract's keys */
+    env?: Record<string, string>;
+};
+/**
+ * An agent upsert body. Same shape as AgentInput minus `name`, which the
+ * upsert takes as its first argument — the name is the resource identity, not
+ * a field of it.
+ */
+type AgentUpsertInput = AgentSourceInput & {
+    /** Command run headless with `sh -c` at the task working directory */
+    run_command: string;
+    /** Env injected at RUN time only; may not override the run contract's keys */
+    env?: Record<string, string>;
+};
+/** Cursor page of registered agents */
+type AgentPage = Page<Agent>;
+/** Dual-use handle from agents().list(): await one page, or iterate them all */
+interface AgentList extends Awaitable<AgentPage>, AsyncIterable<Agent> {
+}
+/** Options for jobs().start() and resume() */
+interface StartJobOptions {
+    /**
+     * Idempotency-Key header value: retries with the same key return the
+     * original job (idempotent_replay: true) instead of creating a new one.
+     */
+    idempotencyKey?: string;
+}
+/** Options for jobs().list() (default page 50, max 200) */
+interface ListJobsOptions extends PageOptions {
+    /** Server-side free-text filter over job name and dataset names. */
+    search?: string;
+    /**
+     * Visibility scope (Harbor's `--scope`): `my` — jobs you created, the
+     * server's default; `shared` — your organizations' jobs that teammates
+     * created. See JOB_LIST_SCOPES.
+     */
+    scope?: JobListScope;
+}
+/** Options for analyses().list() (default page 50, max 200) */
+interface ListAnalysesOptions extends PageOptions {
+    /** Visibility scope, exactly as on jobs().list(). */
+    scope?: JobListScope;
+    /** Only analyses of this job's trials. */
+    job?: string;
+    /** Only analyses in these statuses (the object's own lowercase ladder). */
+    status?: AnalysisStatus[];
+}
+/** Options for checks().list() (default page 50, max 200) */
+interface ListChecksOptions extends PageOptions {
+    /** Visibility scope, exactly as on jobs().list(): `my` (the default) or `shared`. */
+    scope?: JobListScope;
+    /** Only checks in these statuses (the check's own ladder, CHECK_STATUSES). */
+    status?: CheckStatus[];
+}
+/** Options for jobs().tasks() (default page 50, max 200) */
+interface ListJobTasksOptions extends PageOptions {
+}
+/** Options for jobs().trials() (default page 50, max 200) */
+interface ListTrialsOptions extends PageOptions {
+    /** Only trials in these statuses (e.g. the failures behind a resume decision) */
+    status?: TrialStatus[];
+    /** Only one dataset's trials — exact match on the trial's `source`. */
+    dataset?: string;
+}
+/** Options for datasets().list() (default page 50, max 200) */
+interface ListDatasetsOptions extends PageOptions {
+    /** Server-side free-text filter over name and description. */
+    search?: string;
+}
+/** Options for agents().list() (default page 50, max 200) */
+interface ListAgentsOptions extends PageOptions {
+}
+/** Options for datasets().get() / getActive(): pages the TASK list (default 200, max 500) */
+interface GetDatasetOptions extends PageOptions {
+}
+/** Options for datasets().listImports() */
+interface ListImportsOptions extends PageOptions {
+    /** Only imports in this status */
+    status?: DatasetImportStatus;
+    /** Only imports of this dataset name */
+    dataset?: string;
+}
+/** Options for trials().trace() and traceEvents() */
+interface TraceOptions extends PageOptions {
+    /**
+     * Resume position: events with seq strictly greater than this cursor (omit =
+     * from the beginning). A trace cursor IS a seq, so to resume a poll later
+     * pass the last event's `seq` here as a string.
+     */
+    cursor?: string;
+    /** Max events per page (server default: 200, max: 1000) */
+    limit?: number;
+    /** Only events of exactly this type. */
+    type?: string;
+    /**
+     * Only events whose type or serialized content matches this
+     * case-insensitive POSIX regex (a plain string is a plain substring —
+     * grep's own grammar). An invalid pattern is the server's typed
+     * `invalid_input` refusal.
+     */
+    grep?: string;
+    /**
+     * Only the last N MATCHING events — a floor on the seq timeline, after
+     * which cursor paging proceeds normally, oldest-first.
+     */
+    tail?: number;
+}
+/** Options for jobs().grep() */
+interface GrepJobOptions extends PageOptions {
+    /** Only search events of exactly this type. */
+    type?: string;
+}
+/**
+ * One trial's slice of a job-wide grep (jobs().grep()): the EXACT number of
+ * matching events plus the first few of them — the platform caps the sample
+ * (at 5), the count never truncates. The full match list of one trial is
+ * trials().trace() with the same pattern as { grep }.
+ */
+interface JobGrepGroup {
+    trial_id: string;
+    /** The trial's task, for orientation; null only when the task row is gone. */
+    task_name: string | null;
+    match_count: number;
+    events: TraceEvent[];
+}
+/** One page of a job-wide grep, ordered by trial id. */
+type JobGrepPage = Page<JobGrepGroup>;
+/**
+ * One stored file of a trial's tree (trials().files()), named by its
+ * prefix-relative path — the same path trials().file() reads.
+ */
+interface TrialFile {
+    path: string;
+    size_bytes: number;
+}
+/** One page of a trial's stored file tree, sorted by path. */
+type TrialFilePage = Page<TrialFile>;
+/** Options for trials().files() (default page 200, max 1000) */
+interface ListTrialFilesOptions extends PageOptions {
+}
+/**
+ * Byte range for trials().file() — inclusive positions, the wire's
+ * `Range: bytes=start-end` grammar: { start } alone reads to the end,
+ * { suffix } alone reads the last N bytes.
+ */
+interface TrialFileRange {
+    start?: number;
+    end?: number;
+    /** The last N bytes (mutually exclusive with start/end). */
+    suffix?: number;
+}
+/** Options for datasets().watchImport() */
+interface WatchImportOptions {
+    /** Called on every observed import status change (including the first status seen) */
+    onStatus?: (datasetImport: DatasetImport) => void;
+    /**
+     * Called on every observed change of the import's live `progress` — a
+     * phase boundary, or new counts inside a phase. The server writes progress
+     * at phase boundaries and coarse intervals (never per-second), so this
+     * fires at that cadence, under the same poll (and the same 429-tolerant
+     * posture) as `onStatus`. Never called while `progress` is null.
+     */
+    onProgress?: (progress: DatasetImportProgress, datasetImport: DatasetImport) => void;
+    /**
+     * Called on every observed change of the imported VERSION's state during
+     * the watch's settle phase — normally the single confirming READY read
+     * (COMPLETED means the version is READY under build-then-READY), or the
+     * walk to READY/ARCHIVED/FAILED against a mid-deploy older server.
+     * `dataset` is the detail read the observation came from: its
+     * `active_version` says whether the settled version is now the one a bare
+     * dataset name resolves to.
+     */
+    onVersion?: (version: DatasetVersion, dataset: Dataset) => void;
+    /** Abort the watch (rejects with the abort reason) */
+    signal?: AbortSignal;
+    /** Poll interval between polls (default: 2000ms) */
+    pollIntervalMs?: number;
+    /**
+     * Backstop bound on the settle phase — how long past import COMPLETED the
+     * watch may wait for the version to settle before refusing with
+     * ImportSettleError("settle_timeout") (default: 30 minutes). Normally
+     * unused (COMPLETED means READY); it bounds the wait against a mid-deploy
+     * older server, and the error carries the last observed state.
+     */
+    settleTimeoutMs?: number;
+}
+/** Options for jobs().watchAnalysis() */
+interface WatchAnalysisOptions {
+    /**
+     * Called on every observed change of the job's analysis tally (including
+     * the first non-null one seen), with the job body the observation came
+     * from.
+     */
+    onStats?: (job: Job) => void;
+    /** Abort the watch (rejects with the abort reason) */
+    signal?: AbortSignal;
+    /**
+     * Initial poll interval (default: 2000ms). Doubles while the tally stands
+     * still, up to the 30-s ceiling the job watch's reconnect uses, and
+     * returns to this value on every tally change.
+     */
+    pollIntervalMs?: number;
+}
+/** Options for jobs().watch() */
+interface WatchJobOptions {
+    /** Called for every event (replayed + live) */
+    onEvent?: (event: JobEvent) => void;
+    /** Abort the watch (rejects with the abort reason) */
+    signal?: AbortSignal;
+    /** Initial reconnect backoff (default: 1000ms; doubles up to maxReconnectDelayMs) */
+    reconnectDelayMs?: number;
+    /** Backoff ceiling (default: 30000ms) */
+    maxReconnectDelayMs?: number;
+}
+/** Delivery options for datasets().download() */
+interface DownloadDatasetOptions {
+    /** Directory to save the package into (returns the file path) */
+    to?: string;
+    /** Return the raw response stream instead of a Buffer */
+    stream?: boolean;
+}
+/** Delivery options for jobs().download() — and for checks().download() / analyses().download(), the same three shapes. */
+interface DownloadJobOptions {
+    /** Directory to save the archive into (returns the file path) */
+    to?: string;
+    /** Return the raw response stream instead of a Buffer */
+    stream?: boolean;
+}
+/** Options for jobs().upload() */
+interface UploadJobOptions {
+    /**
+     * "name" or "name@version" of a published dataset — links the uploaded
+     * trials to that version's tasks by task name (a bare name resolves to the
+     * active version). Matched trials analyze against the real task content;
+     * unmatched or unhinted trials analyze through the task-not-available
+     * branch, exactly Harbor's fallback for a trial without a local task
+     * directory. Resolved at ingest: a hint the caller cannot use fails the
+     * import typed (the job-create vocabulary).
+     */
+    dataset?: string;
+    /**
+     * Client-side upload progress: `(sentBytes, totalBytes)` over the
+     * archive's bytes as the stream flushes them — the same reading
+     * datasets().publish() hands out (PublishDatasetOptions.onUploadProgress).
+     * Not called for an `archive_url` source (no bytes ride the request).
+     */
+    onUploadProgress?: (sentBytes: number, totalBytes: number) => void;
+    /**
+     * Register-first: called once with the import id BEFORE the first byte
+     * moves when the archive rides the resumable session door (over the
+     * 256 MiB switch), so a watcher may attach — `jobs().watchImport(id)`,
+     * `evolve job import <id> --watch` — while the transfer runs. The SAME id
+     * upload() resolves with. Not called on the single-POST path, where the
+     * id exists only once the 202 lands.
+     */
+    onRegistered?: (importId: string) => void;
+}
+/**
+ * Where a job import's archive came from (spec JobImportSource): the
+ * uploaded bytes by their sha256, or the public https URL the worker
+ * downloads. `hub` — Harbor's own hub job source (`SourceJobConfig(type=
+ * "hub", job_id=...)`) — is RESERVED: the union carries the word so the arm
+ * is additive when it lands; no door accepts it yet.
+ */
+type JobImportSource = {
+    type: "archive";
+    sha256: string;
+} | {
+    type: "archive_url";
+    url: string;
+} | {
+    type: "hub";
+    job_id: string;
+};
+/**
+ * The four phases of a job ingest, in the order the worker runs them:
+ * fetching (the archive from the store, or the URL download), extracting,
+ * validating (every gate before any row), ingesting (the rows and the
+ * trace-artifact stores).
+ */
+type JobImportPhaseName = "fetching" | "extracting" | "validating" | "ingesting";
+/** One phase of a job import's timeline (spec JobImportProgress.phases[]). */
+interface JobImportPhaseProgress {
+    name: JobImportPhaseName;
+    started_at: string;
+    /** Absent while the phase runs — and forever, on the phase a FAILED import died in. */
+    completed_at?: string;
+}
+/**
+ * The worker's own statement of where a job ingest stands (spec
+ * JobImportProgress), written at phase boundaries only. On a terminal
+ * import it is the settled record.
+ */
+interface JobImportProgress {
+    phase: JobImportPhaseName;
+    started_at: string;
+    phases: JobImportPhaseProgress[];
+}
+/**
+ * Why a job import FAILED (spec JobImportFailure). The codes are the ones
+ * the upload door once answered synchronously — `invalid_archive`,
+ * `upload_too_large`, `not_a_job_dir`, `job_already_uploaded` (details name
+ * `existing_job_id`), the dataset-hint codes, `invalid_trial` (details
+ * name the `trial`) — plus the platform's own `import_failed` and
+ * `import_lease_expired`. A trial over a physical per-trial bound is not a
+ * failure: it is skipped (JobImportSkippedTrial) and the import
+ * completes.
+ */
+interface JobImportFailure {
+    code: string;
+    message: string;
+    details?: Record<string, unknown>;
+}
+/**
+ * One trial a job import LEFT OUT, typed (spec JobImportSkippedTrial): the
+ * failure-envelope grammar plus the trial directory it names.
+ * `trial_too_large` is the one cause, every bound physical and named in
+ * the message: the named `file` is a verbatim artifact over what the
+ * store's single PutObject can land (S3's 5 GiB), or
+ * `agent/trajectory.json` — with the `agent/` home tree counted in — would
+ * cost more heap to parse than the worker can still commit at that moment
+ * (V8's live reading; its structure counted from the bytes, never parsed),
+ * or the `agent/` tree alone (`file` spelled `agent/`) is over that
+ * reading; `details` carry the `bytes` measured and the `max_bytes`
+ * reading. The rest of the archive lands; a skipped trial contributes
+ * nothing to the job.
+ */
+interface JobImportSkippedTrial {
+    trial: string;
+    code: "trial_too_large";
+    message: string;
+    details?: {
+        file: string;
+        bytes: number;
+        max_bytes: number;
+    };
+}
+/**
+ * An accepted job upload, from the 202 to a COMPLETED Job or a typed FAILED
+ * — what jobs().upload() resolves with and jobs().getImport()/watchImport()
+ * read. Same four status words a dataset import speaks.
+ */
+interface JobImport {
+    id: string;
+    status: DatasetImportStatus;
+    /**
+     * Register-first: true exactly while the archive is still arriving
+     * through its resumable session (QUEUED, not yet claimable), false from
+     * the 202 on.
+     */
+    receiving: boolean;
+    /** Null while a session is still receiving (nothing is stored yet). */
+    source: JobImportSource | null;
+    /** The `dataset` hint as given (`name` or `name@version`), or null. */
+    dataset: string | null;
+    /**
+     * The ingested Job, from COMPLETED on — read it with jobs().get(). Null
+     * again if that job was deleted (delete-then-reupload): the import stays
+     * COMPLETED and honest.
+     */
+    job_id: string | null;
+    /** Trials the ingested job carries, from COMPLETED on (Harbor's own spelling). */
+    n_trials_uploaded: number | null;
+    /**
+     * Trials the ingest left out, typed, from COMPLETED on — 0 when none
+     * (Harbor's own spelling). Null until COMPLETED.
+     */
+    n_trials_skipped: number | null;
+    /** One entry per skipped trial, in archive order, from COMPLETED on ([] when none). Null until COMPLETED. */
+    skipped_trials: JobImportSkippedTrial[] | null;
+    /**
+     * The ingested job's per-task task-linkage roll-up — the same rows the
+     * job serves as `upload.task_links`, read from the job, so a watcher
+     * learns from the import alone which tasks will analyze with their task
+     * folder and why the rest will not. Null until COMPLETED, null again when
+     * the job is gone (like `job_id`), and null on a job ingested before the
+     * link law existed.
+     */
+    task_links: JobTaskLink[] | null;
+    failure: JobImportFailure | null;
+    /** Null until the worker's first report (a QUEUED import). */
+    progress: JobImportProgress | null;
+    created_at?: string;
+    updated_at?: string;
+}
+/** Cursor page of job imports */
+type JobImportPage = Page<JobImport>;
+/** Dual-use handle from jobs().listImports(): await one page, or iterate them all */
+interface JobImportList extends Awaitable<JobImportPage>, AsyncIterable<JobImport> {
+}
+/** Options for jobs().listImports() */
+interface ListJobImportsOptions extends PageOptions {
+    /** Only imports in this status */
+    status?: DatasetImportStatus;
+}
+/** Options for jobs().watchImport() */
+interface WatchJobImportOptions {
+    /** Called on every observed import status change (including the first status seen, and the receiving flip). */
+    onStatus?: (jobImport: JobImport) => void;
+    /**
+     * Called on every observed change of the import's live `progress` — a
+     * phase boundary; the server writes at that cadence. Never called while
+     * `progress` is null.
+     */
+    onProgress?: (progress: JobImportProgress, jobImport: JobImport) => void;
+    /** Poll interval in ms (default 2000) */
+    pollIntervalMs?: number;
+    /** Abort the watch (throws AbortError-shaped Error) */
+    signal?: AbortSignal;
+}
+/** Client for the shared dataset catalog */
+interface DatasetsClient {
+    /**
+     * List datasets with their active versions (cursor-paged). Await the
+     * result for one page, or `for await` it to walk the whole catalog.
+     */
+    list(options?: ListDatasetsOptions): DatasetList;
+    /**
+     * Get one dataset: all versions + one page of the selected version's tasks.
+     * ref is "name" (active version's tasks) or "name@version"; { limit, cursor }
+     * page the tasks.
+     */
+    get(ref: string, options?: GetDatasetOptions): Promise<Dataset>;
+    /**
+     * Get a dataset's active version resolved to a runnable shape: unlike
+     * get(), `version` and `tasks` are guaranteed present. Throws
+     * NoActiveVersionError when the dataset has no active version. Use get()
+     * for the full multi-version detail with optional fields.
+     */
+    getActive(name: string, options?: GetDatasetOptions): Promise<ActiveDataset>;
+    /**
+     * The failure-detail read of the partial-publish model: one task's own
+     * build outcome inside one published version — its state (READY or
+     * FAILED), the typed failure WITH the failing-step excerpt, and the full
+     * build-log pointer. The dataset detail's `failed_tasks` carries the
+     * compact reasons for every failed task; this call is where the excerpt
+     * and the log pointer live, one task at a time.
+     *
+     * `ref` must pin the version: "name@version" (the outcome is a fact about
+     * one immutable version, so there is no active-version reading to guess).
+     * A task the build has not settled — or a name the corpus never contained
+     * — answers 404 `task_not_found`.
+     */
+    getTaskBuild(ref: string, taskName: string): Promise<TaskBuild>;
+    /**
+     * Pre-flight a local corpus BEFORE publishing (dry run): collect only the
+     * metadata files (each task's task.toml + the optional dataset.toml —
+     * kilobytes), run the import's own toml-decidable guards and per-provider
+     * capability stamps server-side, and answer per-task verdicts with the
+     * importer's would-refuse sentences. Nothing is written and no corpus
+     * byte moves. `evolve dataset publish --dir` runs this automatically;
+     * `evolve dataset check <dir>` is the standalone verb.
+     */
+    preflight(input: PreflightDatasetInput): Promise<DatasetPreflight>;
+    /**
+     * Publish a dataset version (asynchronous server-side import) from a git
+     * source pinned to a ref, or a local corpus directory. Returns immediately;
+     * poll with getImport()/watchImport().
+     */
+    publish(input: PublishDatasetInput, options?: PublishDatasetOptions): Promise<DatasetImport>;
+    /** Get an import job's status (failure, warnings, and task_count when available) */
+    getImport(id: string): Promise<DatasetImport>;
+    /**
+     * Watch a publish to its settled end: poll getImport() until the import is
+     * terminal, then confirm the version against the dataset detail. Under
+     * build-then-READY, COMPLETED means the version is READY — the build
+     * settled with at least one task ready (the partial-publish model; each
+     * provider builds its boot artifact lazily at the first trial) and, on an
+     * owner-stamped dataset,
+     * already active — so the settle phase is normally the single confirming
+     * read; against a mid-deploy older server it keeps polling until the
+     * version reaches READY, ARCHIVED, or FAILED. A failed build rides the
+     * returned import's `failure`. Throws ImportSettleError("settle_timeout")
+     * when settleTimeoutMs elapses before the version settles.
+     */
+    watchImport(id: string, options?: WatchImportOptions): Promise<DatasetImport>;
+    /**
+     * List the caller's own imports, newest first (cursor-paged). This is how
+     * you find an import again after losing the id publish() returned. Await
+     * for one page, or `for await` to walk them all. { status } filters on the
+     * import vocabulary; { dataset } narrows to one dataset name.
+     */
+    listImports(options?: ListImportsOptions): DatasetImportList;
+    /**
+     * Download the ORIGINAL corpus package one of your own dataset versions was
+     * published from — the gzipped tarball you uploaded, or, for a git publish,
+     * the checked-out tree packed at import time. `ref` is "name" (the active
+     * version's package) or "name@version".
+     *
+     * OWNER ONLY. This is the one call that returns task files, and it returns
+     * them only to the account that owns the dataset; a platform-curated dataset
+     * has no owner, so nobody can download it. Someone else's dataset is a plain
+     * not-found, never a 403.
+     *
+     * The server verifies the stored bytes against their recorded sha256 before
+     * sending anything and echoes the digest; the client re-checks the digest
+     * and the Content-Length, so a successful call is byte-identical to what was
+     * published. A version published before packages were retained has none
+     * (`package_not_retained`, distinct from "not found").
+     *
+     * Default: Buffer. { to } saves into a directory and returns the file path.
+     * { stream: true } returns the raw response stream.
+     */
+    download(ref: string): Promise<Buffer>;
+    download(ref: string, options: {
+        to: string;
+    }): Promise<string>;
+    download(ref: string, options: {
+        stream: true;
+    }): Promise<ReadableStream<Uint8Array>>;
+    download(ref: string, options?: DownloadDatasetOptions): Promise<Buffer | string | ReadableStream<Uint8Array>>;
+    /**
+     * Update dataset settings. The only settable field is
+     * `upstream_auto_import`: automatically import a new version when the
+     * dataset's upstream git ref moves. Refused (upstream_not_watchable) when
+     * the dataset has no moving git ref to follow, and dataset_not_owned on a
+     * platform-curated dataset. Returns the updated dataset.
+     */
+    update(name: string, patch: DatasetPatch): Promise<Dataset>;
+    /**
+     * Activate a READY version you own: bare-name job references resolve to it
+     * from then on. A publish activates its own version when it lands, so this
+     * verb is for re-pointing the default — a rollback to an older READY
+     * version, or choosing between several. Refused with `version_not_ready`
+     * while the publish is still building and `version_not_activatable` for a
+     * FAILED or ARCHIVED version, which can never be activated.
+     */
+    activate(name: string, version: string): Promise<Dataset>;
+    /**
+     * Delete a dataset you own, with every version, task, and archived
+     * solution. Refused (dataset_in_use) while any job still references it — a
+     * dataset is never deleted out from under a job that measured against it,
+     * and `err.details.sampleJobIds` names the jobs blocking it. A platform
+     * dataset is refused with dataset_not_owned; a name you cannot see is a
+     * plain not-found.
+     */
+    delete(name: string): Promise<void>;
+}
+/** Client for the caller's own private (bring-your-own) agents */
+interface AgentsClient {
+    /**
+     * Register a private agent. Provide either an install script
+     * (`{ install_script }`) or a local directory (`{ directory }`), never both.
+     * The name is then usable in job `agents[].name` like a built-in.
+     */
+    create(input: AgentInput): Promise<Agent>;
+    /**
+     * List the caller's registered agents (cursor-paged). Await the result for
+     * one page, or `for await` it to walk them all.
+     */
+    list(options?: ListAgentsOptions): AgentList;
+    /** Get one registered agent by name */
+    get(name: string): Promise<Agent>;
+    /** Delete a registered agent. Past jobs keep their recorded agent. */
+    delete(name: string): Promise<void>;
+    /**
+     * Register or replace an agent in ONE call, under the name you give.
+     *
+     * Use this instead of delete()+create() to change an existing registration:
+     * the pair leaves a window where the agent does not exist, and anything
+     * naming it in that window fails for a change that was only ever meant to be
+     * an edit. This is a full replacement, not a patch — every field comes from
+     * this call, and an omitted `env` becomes empty.
+     */
+    upsert(name: string, input: AgentUpsertInput): Promise<Agent>;
+}
+/**
+ * One skill uploaded to the platform. Immutable content: the digest is the
+ * identity (Harbor's skill digest recipe over the folder), and jobs reference
+ * it as `upload:<id>` in `agents[].skills`.
+ */
+interface SkillUpload {
+    id: string;
+    /** Folder name = the name the harness sees when mounted. */
+    name: string;
+    /** Content digest, "sha256:<hex>" — Harbor's recipe. */
+    digest: string;
+    size_bytes: number;
+    /** First heading / description line lifted from SKILL.md, or null. */
+    description: string | null;
+    /** The `upload:<id>` reference to put in `agents[].skills`. */
+    ref: string;
+    created_at: string;
+}
+type SkillUploadPage = Page<SkillUpload>;
+interface SkillUploadList extends Awaitable<SkillUploadPage>, AsyncIterable<SkillUpload> {
+}
+interface ListSkillsOptions extends PageOptions {
+}
+/** Client for platform-stored skills (uploads referenced as `upload:<id>`). */
+interface SkillsClient {
+    /**
+     * Upload a local skill folder (must contain SKILL.md, or be a root whose
+     * child directories each contain SKILL.md — Harbor's discovery law; a root
+     * uploads each child as its own skill and resolves to the full list).
+     * Re-uploading identical content under the same name answers the existing
+     * record — uploads are content-addressed, never duplicated. A skill NAME
+     * is a moving pointer: every upload makes its record the name's current
+     * one (different content = new record, pointer moves; old records keep
+     * their immutable `upload:<id>` handles), and `name:<skill-name>` in
+     * `agents[].skills` resolves through it at job create.
+     */
+    upload(directory: string): Promise<SkillUpload[]>;
+    /** List the caller's uploaded skills (cursor-paged). */
+    list(options?: ListSkillsOptions): SkillUploadList;
+    /**
+     * Get one uploaded skill, including its SKILL.md text. Takes a record id,
+     * or `name:<skill-name>` — the moving name pointer, answered with its
+     * CURRENT record (unknown names are the typed `skill_name_not_found`).
+     */
+    get(id: string): Promise<SkillUpload & {
+        skill_md: string | null;
+    }>;
+    /**
+     * Delete an uploaded skill. Refused while a non-terminal job references it;
+     * finished jobs keep their recorded locks either way.
+     */
+    delete(id: string): Promise<void>;
+}
+/** Client for hosted jobs */
+interface JobsClient {
+    /**
+     * Start a job over one or more catalog datasets. Each dataset selector may
+     * carry glob task filters; every agent arm must name a model. Supports
+     * Idempotency-Key.
+     */
+    start(input: JobCreate, options?: StartJobOptions): Promise<Job>;
+    /** Get one job */
+    get(id: string): Promise<Job>;
+    /**
+     * List the caller's jobs, newest first (cursor-paged). Await the
+     * result for one page, or `for await` it to walk every job across
+     * cursor pages transparently.
+     */
+    list(options?: ListJobsOptions): JobList;
+    /**
+     * List a job's trials (cursor-paged; { status } filters, e.g. to
+     * the failed trials). Await the result for one page, or `for await` it to
+     * walk every trial across cursor pages transparently.
+     */
+    trials(id: string, options?: ListTrialsOptions): TrialList;
+    /**
+     * Per-task rollup of a job (cursor-paged): one row per distinct task with
+     * its trial tally, mean reward, and cost. Sits between the job body and
+     * the trial list so a caller need not fetch every trial to see which
+     * tasks are dragging.
+     */
+    tasks(id: string, options?: ListJobTasksOptions): JobTaskRollupList;
+    /**
+     * Watch a job's event stream (SSE). Replays from the beginning,
+     * resumes with Last-Event-ID on reconnect (exponential backoff), and
+     * finishes on the terminal event.
+     *
+     * The returned handle is dual-use: `await client.watch(id)` resolves with the
+     * final Job, or `for await (const event of client.watch(id))` iterates
+     * the events. The `onEvent` callback still fires in both forms.
+     */
+    watch(id: string, options?: WatchJobOptions): JobWatch;
+    /** Request cancellation. Idempotent; a terminal job is a no-op. */
+    cancel(id: string): Promise<Job>;
+    /**
+     * Resume a terminal job: a NEW linked job holding fresh trials for the
+     * source's failed and stopped work (`source_jobs` records
+     * `action: "resume"`); the source is never mutated.
+     * `request.filter_error_types` selects which failures to resume by
+     * `exception_info.exception_type`; omitted, the default set includes
+     * stopped trials. Supports Idempotency-Key.
+     */
+    resume(id: string, request?: ResumeRequest, options?: StartJobOptions): Promise<Job>;
+    /**
+     * MANUAL retry: a NEW linked job holding fresh trials for caller-SELECTED
+     * trials of the source (`source_jobs` records `action: "retry"`); the
+     * source is never mutated. The request selects — `trial_ids` XOR
+     * `failed_only`, omitted = every trial of the (terminal) job. Retry
+     * differs from resume on purpose: resume answers "finish what broke",
+     * retry answers "run THESE again" — a scored trial is a legitimate target.
+     * In trial_ids mode the job may still be running; each named trial must be
+     * settled. Supports Idempotency-Key (fingerprint over the RESOLVED
+     * selection, namespaced to this verb).
+     */
+    retry(id: string, request?: RetryRequest, options?: StartJobOptions): Promise<Job>;
+    /**
+     * Regrade a terminal job: re-run the verifier of every REGRADABLE trial
+     * against its recorded inputs, in fresh separate verifier boxes. The agent
+     * phase is never re-run and the source trials are never modified. THE
+     * RESPONSE IS A JOB — a regrade is an ordinary job whose `source_jobs`
+     * records `action: "regrade"` and whose `is_regrade` is true; view it with
+     * get(). `request` narrows the set by statuses and/or task.
+     */
+    regrade(id: string, request?: RegradeRequest): Promise<Job>;
+    /**
+     * Analyze a terminal job's trial traces (rubric-driven, Harbor's `harbor
+     * analyze`), server-side: for each trial the analyzer agent reads the
+     * trial's Harbor-shape tree plus its original task and rules every rubric
+     * criterion, storing the result on the trial (`Trial.analysis`) and the
+     * aggregate on the job (`stats.analysis`). THE RESPONSE IS THE JOB, its
+     * analyses enqueued, and it returns AT ONCE — `stats.analysis.n_pending`
+     * counts the queued batch; analyses are not a separate resource. Follow
+     * them with watchAnalysis(), or poll the job's trials. This is also the
+     * RE-analysis path: calling again (same job, different rubric or model)
+     * runs a fresh wave once the previous one has settled. `request` omitted
+     * (or `{}`) means the defaults: openrouter/deepseek/deepseek-v4.1-flash
+     * at its per-model effort over the platform's default analyze rubric.
+     * CANCELLED trials
+     * are never analyzed.
+     */
+    analyze(id: string, request?: AnalyzeConfigInput): Promise<Job>;
+    /**
+     * Follow a job's analysis wave to its settled end: polls the job until
+     * `stats.analysis` reports nothing pending, and resolves with the final
+     * Job — the interval doubling from `pollIntervalMs` while the tally
+     * stands still (30-s ceiling, the job watch's own) and resetting on every
+     * change. `onStats` fires on every observed change of the analysis tally
+     * (including the first one seen). Per-trial results then ride the job's
+     * trials (`Trial.analysis`). A null tally is tolerated and watched
+     * through — it is the enqueue race right after an accepted analyze() —
+     * so on a job that was NEVER analyzed this polls indefinitely: call it
+     * after analyze(), as `evolve analyze --watch` does. It is the MANUAL wave's
+     * companion, not the embedded trigger's: on a still-RUNNING job created
+     * with `analyze`, `n_pending` can touch 0 between trial settles, so the
+     * watch can return before every trial has been analyzed.
+     */
+    watchAnalysis(id: string, options?: WatchAnalysisOptions): Promise<Job>;
+    /**
+     * Side-by-side comparison of 2-10 owned jobs: per-job
+     * aggregates plus a per-task matrix with disagreement rows first.
+     */
+    compare(ids: string[]): Promise<CompareResponse>;
+    /**
+     * Download a terminal job's results as one .tar.gz in the standard
+     * job-directory layout (deterministic bytes): extracts to `job-<id>/` with
+     * config.json, lock.json, result.json (stats incl. pass_at_k) and job.log,
+     * and per trial its config.json, lock.json, result.json (step_results on
+     * multi-step trials), trial.log, agent/trajectory.json (the normalized
+     * ATIF trajectory), the harness stdout stream at Harbor's tee name for the
+     * harness (agent/claude-code.txt, agent/codex.txt, ...), agent/stderr.log,
+     * agent/trace-parsed.jsonl, the captured agent home at its real names
+     * (agent/.claude/, agent/.claude.json, agent/.codex/, agent/.kimi-code/, …)
+     * with the capture record agent/agent-home.json beside it and Harbor's own
+     * copies of the subtrees its adapters keep (agent/sessions/,
+     * agent/qwen-sessions/, agent/opencode/),
+     * verifier/test-stdout.txt, verifier/reward.json, the raw
+     * verifier/reward.txt (only when the grader wrote one),
+     * steps/<name>/verifier/reward.json (multi-step trials only),
+     * exception.txt, and artifacts/ with its always-present manifest.json —
+     * absent artifacts are absent files. Default: Buffer — verified against
+     * the response's Content-Length and, when the server states one, its
+     * digest. { to } saves to a directory (temp-then-rename, same
+     * verification) and returns the file path. { stream: true } returns the
+     * raw response stream, the one shape the caller must verify themselves.
+     */
+    download(id: string): Promise<Buffer>;
+    download(id: string, options: {
+        to: string;
+    }): Promise<string>;
+    download(id: string, options: {
+        stream: true;
+    }): Promise<ReadableStream<Uint8Array>>;
+    download(id: string, options?: DownloadJobOptions): Promise<Buffer | string | ReadableStream<Uint8Array>>;
+    /**
+     * Upload a Harbor job directory for ingest as a first-class TERMINAL job
+     * — Harbor's `harbor upload` in reverse, taking their CLI's own input (a
+     * `job_dir` with result.json + config.json at its root, one subdirectory
+     * per trial; the same gate applies here, client-side, with their refusal
+     * sentences). `source` is that directory — packed to a TEMPORARY FILE on
+     * disk with the same deterministic packer every upload route here uses,
+     * never into memory — or a ready-packed `.tar.gz` of one, streamed
+     * byte-for-byte (the platform's own download() produces exactly this
+     * format); or `{ archive_url }`, a public https URL of the archive the
+     * server fetches itself (no bytes ride the request). Archives over
+     * 256 MiB ride the resumable session door automatically (a dropped link
+     * resumes from the last acknowledged chunk), exactly as datasets().publish()
+     * does; the switch is invisible.
+     *
+     * THE RESPONSE IS THE JOB IMPORT, not the job: the door only moves the
+     * archive into storage and answers 202; a worker ingests it off the
+     * request path and settles the import COMPLETED (`job_id` names the
+     * created Job — COMPLETED on creation, a record not a run: resume, retry
+     * and regrade refuse it `job_uploaded`; analyze() works on it unchanged)
+     * or FAILED with a typed `failure` (the same codes the door once answered
+     * synchronously — `not_a_job_dir`, `invalid_trial`, `job_already_uploaded`
+     * naming the existing job, ...). Follow it with watchImport(). `dataset`
+     * links the uploaded trials to a published dataset version by task name.
+     * The one ceiling on an archive is what the object store can land
+     * (`GET /api/meta` `limits.uploads.job_archive_bytes`, published with
+     * its source) — no trial-count, per-file or per-tree cap exists (no
+     * invented number, owner 2026-09-13).
+     */
+    upload(source: string | {
+        archive_url: string;
+    }, options?: UploadJobOptions): Promise<JobImport>;
+    /** One job import by id — owner-only (`job_import_not_found`, 404, for anyone else's). */
+    getImport(id: string): Promise<JobImport>;
+    /**
+     * Watch a job import to its terminal state — COMPLETED (read the Job at
+     * `job_id`) or FAILED (`failure` says why). Polls getImport() at
+     * `pollIntervalMs` (default 2 s); a 429/503 mid-watch is a delay, not an
+     * outcome. `onStatus` fires on every observed status change (the
+     * receiving flip included); `onProgress` on every observed change of the
+     * worker's phase record.
+     */
+    watchImport(id: string, options?: WatchJobImportOptions): Promise<JobImport>;
+    /**
+     * List your own job imports, newest first (cursor-paged): await one page,
+     * or for-await to walk them all. This is how an import id is found again
+     * after the one upload() returned was lost.
+     */
+    listImports(options?: ListJobImportsOptions): JobImportList;
+    /**
+     * Permanently delete one of your jobs — trials, trace events, analyses and
+     * every stored trace object included (Harbor's `harbor hub job delete`:
+     * "Permanently delete Hub jobs you own, including their trials"). Works on
+     * uploaded and native jobs alike; deleting an uploaded job frees its
+     * duplicate lock, so delete-then-reupload is the replace path.
+     *
+     * CREATOR-ONLY: org members may operate a job (cancel, retry), never
+     * destroy its record — a member who did not create it is refused
+     * (`org_forbidden`, 403). TERMINAL ONLY — never a delete under a live
+     * worker: a QUEUED/RUNNING/CANCELLING job refuses `job_not_terminal`
+     * (409; cancel first), a queued or running analysis wave refuses
+     * `analysis_already_running` (409), and a live regrade derived from this
+     * job refuses `job_not_terminal` with the regrade jobs to wait for in
+     * `details.regrade_job_ids`. A regrade job id is itself not deletable
+     * here (`job_not_found`, 404) — a regrade's results are deleted from the
+     * traces surface. What stays: regrade JOB rows and `source_jobs` history,
+     * which keep naming the deleted id; the model gateway's own ledger
+     * remains the billing truth.
+     *
+     * The response is the receipt: what was destroyed, counted.
+     */
+    delete(id: string): Promise<JobDeleteResult>;
+    /**
+     * Grep the parsed trace of EVERY trial of the job in one server-side pass.
+     * `q` is the trace filter's grammar: a case-insensitive POSIX regex over
+     * each event's type and serialized content, where a plain string is a
+     * plain substring. Items are per-trial groups (exact count + the first few
+     * matching events), ordered by trial id; page with { cursor }. An empty
+     * page means no matches anywhere — a normal answer.
+     */
+    grep(id: string, q: string, options?: GrepJobOptions): Promise<JobGrepPage>;
+}
+/**
+ * The trace route's `?stream=` selectors, in the contract's own order —
+ * `trace-parsed` (the parsed event trace, the same answer as omitting
+ * `stream`) followed by the raw-artifact vocabulary. `trace-atif` is the
+ * SERVED normalized trajectory (Harbor's ATIF v1.7); `trajectory` is a
+ * DIFFERENT artifact — the harness's own native session file, in the
+ * vocabulary ahead of its server wave (the server answers not-found for it
+ * until that wave lands). A runtime value (not only a type) so a drift gate
+ * can hold it to the spec's enum, and the CLI can build its `--stream`
+ * validation from the same list instead of a second copy.
+ */
+declare const TRIAL_ARTIFACT_STREAMS: readonly ["trace-parsed", "verifier", "trace-stdout", "trace-stderr", "trace-atif", "trajectory", "agent-home"];
+/** One `?stream=` selector on the trace route. */
+type TrialArtifactStream = (typeof TRIAL_ARTIFACT_STREAMS)[number];
+/** Client for globally addressable trials — no job id in any signature */
+interface TrialsClient {
+    /**
+     * Get one trial by its globally addressable id. The body carries `job_id`
+     * as the reverse pointer; `exception_info.exception_message` is untruncated
+     * here, unlike list rows.
+     */
+    get(trialId: string): Promise<Trial>;
+    /** Get one page of a trial's trace; resume with { cursor: page.nextCursor } */
+    trace(trialId: string, options?: TraceOptions): Promise<TraceEventPage>;
+    /**
+     * Iterate a trial's trace events, fetching pages under the hood until
+     * the currently available trace is drained. Resume later by passing the
+     * last seen seq as { cursor }.
+     */
+    traceEvents(trialId: string, options?: TraceOptions): AsyncIterableIterator<TraceEvent>;
+    /**
+     * One RAW trace artifact, by the trace route's ?stream= selector.
+     * "verifier" | "trace-stdout" | "trace-stderr" answer the log text;
+     * "trace-atif" answers the normalized trajectory — Harbor's ATIF v1.7
+     * document as JSON text, built server-side from the stored parsed trace
+     * (the same document jobs.download() places at Harbor's own path
+     * agent/trajectory.json); "trajectory" is the reserved harness-native
+     * session file, refused not-found by the server until its wave lands;
+     * "agent-home" answers the utf8 TEXT VIEW of the CLI's captured home
+     * (subagent transcripts included), keyed by sandbox path: a file that is
+     * not UTF-8 text is left out and named in the capture record that rides
+     * the same map as "/agent-home.json"; a home over the server's whole-read
+     * ceiling is refused 413 invalid_input (param "format") — this SDK has no
+     * bytes door for the home, the job archive (jobs().download) carries it
+     * whole. Null = never stored
+     * (a normal answer, not an error). "trace-parsed" is not an
+     * artifact — the parsed event trace rides trace()/traceEvents().
+     */
+    artifact(trialId: string, stream: Exclude<TrialArtifactStream, "trace-parsed" | "agent-home">): Promise<string | null>;
+    artifact(trialId: string, stream: "agent-home"): Promise<Record<string, string> | null>;
+    /**
+     * Regrade one settled trial: re-run its verifier against its recorded
+     * inputs in a fresh separate verifier box. Refused
+     * (regrade_source_ineligible) for shared-mode or pre-persistence trials.
+     * THE RESPONSE IS A JOB — a one-trial regrade job with `source_jobs`
+     * recording the provenance.
+     */
+    regrade(trialId: string): Promise<Job>;
+    /**
+     * Run ONE settled trial again. THE RESPONSE IS A JOB — a one-trial retry
+     * job inheriting the source job's config, with `source_jobs` recording
+     * `action: "retry"`; the source trial is immutable. The same operation as
+     * jobs.retry(jobId, {trial_ids: [trialId]}) — one selection rule, one
+     * fingerprint — kept as its own door because the trial is what you are
+     * holding. The source JOB may still be running; the trial must be settled
+     * (`trial_not_settled` otherwise). Supports Idempotency-Key.
+     */
+    retry(trialId: string, options?: StartJobOptions): Promise<Job>;
+    /**
+     * Stop selected in-flight trials without cancelling their job: each trial's
+     * sandbox is killed and the trial is settled with its spend read from the
+     * gateway. Ids may be eval trials and trace analyses, freely mixed — what
+     * each id is gets resolved server-side; a stopped analysis settles `failed`
+     * (failure phase `stopped`) and is reported under `stopped_analyses`. Only
+     * the caller's own work; ids belonging to someone else are reported in
+     * `not_found` (existence is never leaked). Idempotent — already-terminal
+     * ids are reported as such and left untouched.
+     */
+    stop(trialIds: string[]): Promise<StopResponse>;
+    /**
+     * List the trial's ENTIRE stored file tree — the read-only-filesystem law:
+     * session files, verifier log, raw agent streams, live chunks, everything
+     * the platform stored, as {path, size_bytes} rows sorted by path. Read any
+     * row with file(). An empty page is a normal answer.
+     */
+    files(trialId: string, options?: ListTrialFilesOptions): Promise<TrialFilePage>;
+    /**
+     * RAW BYTES of one stored file, by the path files() names — byte fidelity,
+     * no translation. `range` reads a slice ({ start, end } inclusive,
+     * { start } to the end, or { suffix } for the last N bytes) so a huge log
+     * tails without shipping whole. A path the tree does not hold surfaces as
+     * the API's typed 404.
+     */
+    file(trialId: string, path: string, range?: TrialFileRange): Promise<Buffer>;
+}
+/**
+ * The stored artifacts an analysis run OWNS under its own id — the analyzer's
+ * raw process streams and its session home (the executor stores exactly these
+ * three at settle). A runtime value like TRIAL_ARTIFACT_STREAMS, for the same
+ * reason: the CLI builds its `--stream` validation from this list instead of
+ * a second copy. `verifier` and `trace-atif` are deliberately NOT members: an
+ * analysis never has them, and the server refuses them typed rather than
+ * answering a null that would read as "not stored".
+ */
+declare const ANALYSIS_ARTIFACT_STREAMS: readonly ["trace-stdout", "trace-stderr", "agent-home"];
+/** One stored-artifact selector of an analysis run. */
+type AnalysisArtifactStream = (typeof ANALYSIS_ARTIFACT_STREAMS)[number];
+/** Options for analyses().transcript(). */
+interface AnalysisTranscriptOptions {
+    /**
+     * Skip the first N events — the feed's own resume grammar ("everything
+     * after the N events I already hold"). An analysis's seqs are allocated
+     * densely from 0, so N is also the seq the returned events start at.
+     * A non-negative integer; anything else is refused client-side.
+     */
+    since?: number;
+}
+/**
+ * One analysis run's transcript: the ANALYZER's own parsed events — never the
+ * analyzed trial's agent trace — plus the identity facts the feed serves
+ * around them. Unlike a trial's trace there is no server-side paging: one
+ * read answers everything after `since`, and `total` counts ALL stored rows,
+ * so `events.length < total` with `since: 0` can only mean rows arrived
+ * between count and read (a live analysis).
+ */
+interface AnalysisTranscript {
+    id: string;
+    /** The trial this analysis read — the walk back to the analyzed work. */
+    analyzed_trial_id: string | null;
+    /** The analyzed trial's job. */
+    job_id: string | null;
+    /** The analyzed task's key. */
+    task_name: string | null;
+    /** The model the analyzer ran. */
+    model_name: string | null;
+    /** Where the ANALYZER's own box ran — never the analyzed arm's. */
+    sandbox_provider: string | null;
+    sandbox_id: string | null;
+    /** True once the analysis has settled (completed or failed). */
+    is_ended: boolean;
+    /** ALL stored rows for this analysis, independent of `since`. */
+    total: number;
+    /**
+     * The events after `since`, in TraceEvent shape. The feed serves the bare
+     * parsed payloads; `seq` is synthesized as since+index (sound because seqs
+     * are dense from 0) and `type` by the viewer's own one extraction.
+     */
+    events: TraceEvent[];
+    /**
+     * The gateway meter's per-call lines for the analyzer's key (spec
+     * GatewayUsageEvent), in time order, as `usage` TraceEvents with `seq` in
+     * the gateway band (GATEWAY_TRACE_SEQ_BASE + index). Served whole on every
+     * read: they ride beside `events`, never inside the seq timeline.
+     */
+    gateway_calls: TraceEvent[];
+    /**
+     * The server's write instant of each event's row, one per entry of
+     * `events`, index-aligned (the contract's SessionTranscript.storedAt):
+     * present on every row-served page (an empty page carries an empty list),
+     * absent when the transcript was served from its file, where no write
+     * instant exists. It places the gateway meter's calls under the harness's
+     * steps for harnesses whose lines carry no clock of their own (codex, kimi,
+     * qwen); a reader that does not place calls needs nothing from it.
+     */
+    stored_at?: string[];
+}
+/**
+ * Client for analysis runs — the analyzer's own transcript, verdict document,
+ * and stored artifacts, all globally addressable by analysis id.
+ *
+ * DELIBERATELY OFF-CONTRACT: these three reads ride the dashboard's traces
+ * feed (`/api/traces/trials/{id}/events` and `…/artifacts`), which is NOT in
+ * spec/openapi.yaml — `traces` is outside the prefixes the platform's drift
+ * gate walks (swarm_dashboard `__tests__/api/spec-drift-gate.test.ts`
+ * CONTRACT_PREFIXES), and the one precedent for a transcript door living
+ * off-contract is that gate's RUNTIME_INTERNAL_ROUTES: `api/sessions/[id]/
+ * events`, the session transcript feed, is enumerated there by recorded
+ * exemption — both SDKs' sessions client reads it (`sessions().transcript()`
+ * / `events()`), and its `gatewayCalls` shape is named in the contract's
+ * GatewayUsageEvent prose, not as an operation. RECORDED TENSION: whether
+ * that feed and this one join the contract as operations (spec + both SDK
+ * shadows) is an open ruling, not something settled here. The contract-side
+ * verdict stays where it always was — `Trial.analysis` on the trial body;
+ * this client adds the reads the contract does not carry today.
+ */
+interface AnalysesClient {
+    /**
+     * Every analysis you may read, newest first (cursor-paged) — the catalog
+     * of trace-analysis runs, `GET /api/analyses`. Each row is the wire's
+     * TrialAnalysis carrying the trial, job, and task it judged, so a
+     * headless round is list → get each. `{ scope, job, status }` narrow it;
+     * await the handle for one page, or `for await` it to walk every page.
+     * Every row listed under either scope resolves on every read: the per-run
+     * doors open to the job's creator and to every member of its organization,
+     * the law jobs().get() and trials().get() follow. An id you may not read
+     * answers exactly as one that does not exist — `analysis_not_found` (404)
+     * from `get`, `artifact` and `download`; `transcript` alone rides the
+     * feed's species-blind events door, which answers `trial_not_found`.
+     */
+    list(options?: ListAnalysesOptions): AnalysisList;
+    /**
+     * The verdict document — the wire's TrialAnalysis, statuses and typed
+     * failure included, for EVERY analysis (not only completed ones). The same
+     * object the analyzed trial serves as `Trial.analysis` when this analysis
+     * is its latest; this door answers for earlier analyses too.
+     */
+    get(analysisId: string): Promise<TrialAnalysis>;
+    /**
+     * The analyzer's own transcript (see AnalysisTranscript). An id the feed
+     * resolves to a trial or a regrade — the route answers those first —
+     * refuses with an error naming the species rather than handing back the
+     * wrong run's events.
+     */
+    transcript(analysisId: string, options?: AnalysisTranscriptOptions): Promise<AnalysisTranscript>;
+    /**
+     * One stored artifact by selector: the analyzer's raw stdout/stderr answer
+     * the text, "agent-home" the sandbox-path → text map of its session home.
+     * Null = never stored (a normal answer, not an error): a QUEUED analysis,
+     * or one whose box died before the settle stored anything. Like
+     * transcript(), an id the feed resolves to a trial or a regrade refuses
+     * with an error — the feed's stored selectors would answer for either
+     * species, so the analysis-only ?what=analysis door is resolved first and
+     * the wrong run's bytes are never served.
+     */
+    artifact(analysisId: string, stream: Exclude<AnalysisArtifactStream, "agent-home">): Promise<string | null>;
+    artifact(analysisId: string, stream: "agent-home"): Promise<Record<string, string> | null>;
+    /**
+     * Download the analysis run as Harbor's WRAPPER-trial folder in one
+     * `.tar.gz` (`GET /api/analyses/{analysisId}/download` — on the
+     * contract, unlike the three feed reads above). The archive extracts to
+     * one directory named as Harbor names the wrapper trial
+     * (`analyze-<analyzed trial dir>__<7 chars>/`): config.json, lock.json,
+     * result.json, trial.log, exception.txt (an infrastructure failure only),
+     * agent/claude-code.txt (Harbor's tee name for claude-code),
+     * agent/stderr.log, agent/trace-parsed.jsonl, the captured home at its
+     * real names with agent/agent-home.json beside it and Harbor's copy at
+     * agent/sessions/, verifier/{test-stdout.txt,reward.txt,reward.json}
+     * when the validator ruled (reward 1 = a valid analysis.json, 0 = it was
+     * refused), and artifacts/manifest.json with artifacts/analysis.json (the
+     * validated {summary, checks}) on a completed run — absent artifacts are
+     * absent files; data the platform does not hold is left out, never
+     * faked. Same three delivery shapes and the same integrity checks as
+     * jobs().download(). 404 `analysis_not_found` for an id you cannot read;
+     * 409 `analysis_not_terminal` while the run is queued or running.
+     */
+    download(analysisId: string): Promise<Buffer>;
+    download(analysisId: string, options: {
+        to: string;
+    }): Promise<string>;
+    download(analysisId: string, options: {
+        stream: true;
+    }): Promise<ReadableStream<Uint8Array>>;
+    download(analysisId: string, options?: DownloadJobOptions): Promise<Buffer | string | ReadableStream<Uint8Array>>;
+}
+/**
+ * Task-check configuration — Harbor's `harbor check` vocabulary (their
+ * cli/analyze.py:84-148 check_command), the spec's `CheckConfigInput`. The
+ * rubric-agent trio is the analyze door's, under the same rules
+ * (`AnalyzeConfigInput` states them; refusals name `check.*`): `model_name`
+ * (Harbor's check default is `claude-sonnet-4-6`; this platform's is the
+ * analyzer's `openrouter/deepseek/deepseek-v4.1-flash` — one roster, one
+ * default for both rubric
+ * agents, a recorded deviation), `rubric` (the default is the platform's
+ * check rubric, eleven criteria), and
+ * `prompt` (the TEXT of Harbor's `-p/--prompt` file, replacing the platform's
+ * default check body and rendered with `{task_path}`, `{file_tree}`,
+ * `{criteria_guidance}`; the output contract is appended after it exactly
+ * as Harbor appends it). `reasoning_effort` and `sandbox_provider` are the
+ * platform's two hosted knobs, exactly as on the analyze door.
+ *
+ * Which tasks, and how wide, are Harbor's own check options with their
+ * exact names: `n_concurrent` (`-n/--n-concurrent`), `include_task_names`
+ * (`-i/--include-task-name`, repeatable glob), `exclude_task_names`
+ * (`-x/--exclude-task-name`), `n_tasks` (`-l/--n-tasks`) — applied in
+ * checker.py's order (:132-138: include, exclude, then the cap) over the
+ * sorted task directory names, Python fnmatch globs against the NAME.
+ * Harbor's `-a/--agent`, `--job-name`, `-o/--jobs-dir`, `-k/--n-attempts`
+ * and the local-runner kwargs are not on this surface; the contract records
+ * each with its reason.
+ */
+interface CheckConfigInput {
+    /** Model the checker agent runs (Harbor's `-m/--model`); must be on the claude roster (`GET /api/meta`). */
+    model_name?: string;
+    /** The rubric (Harbor's `-r/--rubric` file as its `{criteria}` object); default: the platform's check rubric (eleven criteria). */
+    rubric?: Rubric;
+    /** The prompt template — the TEXT of Harbor's `-p/--prompt` file. */
+    prompt?: string;
+    /** Reasoning effort the checker runs at (the arms' vocabulary; a hosted extension). */
+    reasoning_effort?: string;
+    /** The provider whose sandbox the checker boots (a hosted extension; the job lineup). */
+    sandbox_provider?: EvalSandboxProvider;
+    /** How many of this check's tasks run at once — Harbor's `-n/--n-concurrent`; beneath the organization's `max_concurrent_analyses`. */
+    n_concurrent?: number;
+    /** Only check task directories whose name matches one of these globs — Harbor's `-i`, repeatable. */
+    include_task_names?: string[];
+    /** Skip task directories whose name matches one of these globs — Harbor's `-x`, repeatable. */
+    exclude_task_names?: string[];
+    /** At most this many task directories, after the globs — Harbor's `-l/--n-tasks`. */
+    n_tasks?: number;
+}
+/**
+ * What checks().create() takes: WHERE the tasks are, plus the
+ * CheckConfigInput knobs. Two sources, one at a time:
+ *
+ *   { directory } — a local directory (one task directory, or a directory of
+ *                   task directories: Harbor's `PATH`, tarred and streamed
+ *                   from disk; a directory only, as Harbor's check is — their
+ *                   checker.py:125-130 refuses any PATH that is not one; no
+ *                   ready-packed archive form).
+ *   { dataset }   — a PUBLISHED dataset, `name` (its active version) or
+ *                   `name@version` — the hosted form, a recorded deviation
+ *                   (Harbor's check takes a local path only): the checker
+ *                   reads the version's retained task package, and the job
+ *                   page's CHECK tab lists these checks by task. Nothing is
+ *                   uploaded.
+ */
+interface CreateCheckInput extends CheckConfigInput {
+    source: {
+        directory: string;
+    } | {
+        dataset: string;
+    };
+    /** Client-side upload progress (sent bytes, total bytes), from the stream itself. Directory source only. */
+    onUploadProgress?: (sentBytes: number, totalBytes: number) => void;
+}
+/**
+ * What was checked, by identity (spec CheckSource) — two forms told apart by
+ * `type`: `archive` (the uploaded tar's sha256 and compressed `bytes`;
+ * `dataset` null) or `dataset` (the resolved `name@version` and the sha256
+ * of the version's retained task package; `bytes` null — a package's size is
+ * not a recorded fact, so the wire invents none).
+ */
+interface CheckSource {
+    type: "archive" | "dataset";
+    /** SHA-256 of the archive as uploaded, or of the version's retained task package. */
+    sha256: string;
+    /** The archive's compressed size on the archive form; null on the dataset form. */
+    bytes: number | null;
+    /** The resolved `name@version` on the dataset form; null on the archive form. */
+    dataset: string | null;
+}
+/**
+ * One task's quality check — Harbor's QualityCheckResult shape (their
+ * cli/quality_checker/models.py:31-35: `task_name`, `checks` keyed by
+ * criterion, `cost_usd`), its checks extended by the result schema and the
+ * derived `label` and `executed` beside them, plus the hosted provenance: its own id, the check
+ * it belongs to, its lifecycle (the analysis ladder's four lowercase words),
+ * the bounded attempt count, and a typed `failure` in place of Harbor's
+ * `error` string (the TrialAnalysis rule).
+ *
+ * `checks` is the FLAT object the platform's validate.py accepts (one key per
+ * rubric criterion, each `{outcome, explanation, evidence}`, four outcome
+ * words — no summary; analyze has
+ * one, check does not). `cost_usd` is the checker agent's OWN metered spend;
+ * null when nothing was measured, never a fabricated 0.
+ */
+interface TaskCheck {
+    id: string;
+    check_id: string;
+    /** The task directory's name (Harbor's task_name). */
+    task_name: string;
+    /** `queued` | `running` | `completed` | `failed` — the analysis ladder, on a task check. */
+    status: AnalysisStatus;
+    /** One entry per rubric criterion, keys exactly the frozen criteria. Null until completed. */
+    checks: Record<string, AnalysisCheck> | null;
+    /** The derived label (CheckLabel states the rule); null until completed, and null under a custom rubric. */
+    label: CheckLabel | null;
+    /**
+     * Whether the box ran the task's environment: true when none of the five
+     * run-based criteria (reference_solution_is_valid,
+     * verifier_rejects_non_solutions, environment_builds_and_runs,
+     * verification_is_stable, limits_allow_the_task) is unknown, so a
+     * reading-only `no_problem_found` is never mistaken for a run. Null
+     * exactly when `label` is null.
+     */
+    executed: boolean | null;
+    cost_usd: number | null;
+    /** 1, or 2 when the one automatic re-run fired (a run that produced no valid check-result.json, the missing file included, is re-run once — the analyze verb's hosted rule; a run cut by its budget is not that class: it settles `failed` with phase `timeout` at once and is never re-run). */
+    attempts: number;
+    /** Non-null exactly when status is `failed`. */
+    failure: AnalysisFailure | null;
+    created_at: string;
+    /** When it settled; null while queued or running. */
+    finished_at: string | null;
+}
+/**
+ * One task quality check — Harbor's CheckReport (`results`, and `cost_usd`
+ * its `total_cost_usd`: the sum of measured task costs, null when none was
+ * measured) plus the hosted record: the run's own id and lifecycle
+ * (CheckStatus), its source, and the policy every task ran under, frozen at
+ * accept.
+ */
+interface Check {
+    id: string;
+    status: CheckStatus;
+    source: CheckSource;
+    model_name: string;
+    /** The effort every task's checker ran at — named at create, or the model's default, resolved at accept. */
+    reasoning_effort: string;
+    rubric: Rubric;
+    /** The prompt template as stored; null = the platform's default check body. */
+    prompt: string | null;
+    sandbox_provider: EvalSandboxProvider;
+    /** Harbor's -n as stored; null = the organization's ceiling alone. */
+    n_concurrent: number | null;
+    /** The include globs as stored; empty = no include filter. */
+    include_task_names: string[];
+    /** The exclude globs as stored; empty = no exclude filter. */
+    exclude_task_names: string[];
+    /** Harbor's -l/--n-tasks as stored; null = no cap. */
+    n_tasks: number | null;
+    /** One entry per task directory checked, sorted by task name. */
+    results: TaskCheck[];
+    cost_usd: number | null;
+    created_at: string;
+    /** When the last task settled; null until every task has. */
+    finished_at: string | null;
+}
+/** Options for checks().watch() */
+interface WatchCheckOptions {
+    /** Called on every observed change of the check's per-task statuses, with the check body the observation came from. */
+    onProgress?: (check: Check) => void;
+    /** Abort the watch (rejects with the abort reason) */
+    signal?: AbortSignal;
+    /** Initial poll interval (default: 2000ms); doubles while nothing changes, up to 30 s, and snaps back on every change. */
+    pollIntervalMs?: number;
+}
+/**
+ * One task check's transcript: the CHECKER's own parsed events plus the
+ * identity facts the feed serves around them — the AnalysisTranscript's
+ * shape (its docs state the read grammar: no server-side paging, `total`
+ * counts ALL stored rows, `since` resumes), with the check record and the
+ * dataset ref in place of the analyzed trial and its job.
+ */
+interface TaskCheckTranscript {
+    id: string;
+    /** The check record (Harbor's CheckReport) this task's result belongs to. */
+    check_id: string | null;
+    /** The resolved `name@version` when the check came from a published dataset; null for an uploaded archive. */
+    dataset: string | null;
+    /** The checked task's name. */
+    task_name: string | null;
+    /** The model the checker ran. */
+    model_name: string | null;
+    /** Where the CHECKER's own box ran. */
+    sandbox_provider: string | null;
+    sandbox_id: string | null;
+    /** True once the task check has settled (completed or failed). */
+    is_ended: boolean;
+    /** ALL stored rows for this task check, independent of `since`. */
+    total: number;
+    events: TraceEvent[];
+    /** The gateway meter's per-call lines for the checker's key (the AnalysisTranscript's field, same law). */
+    gateway_calls: TraceEvent[];
+    /** The server's write instant of each event's row, one per entry of `events`, index-aligned (the AnalysisTranscript's field, same law); absent when the transcript was served from its file. */
+    stored_at?: string[];
+}
+/**
+ * Client for task quality checks — Harbor's `harbor check <PATH>`, hosted
+ * (`POST /api/checks`, `GET /api/checks`, `GET /api/checks/{checkId}`).
+ * Created via the standalone `checks()` factory; requires EVOLVE_API_KEY
+ * (or `{ apiKey }` in config).
+ *
+ * `create()` uploads the task directory (or the directory of task
+ * directories), or names a published dataset, and returns AT ONCE with the
+ * accepted Check — one `results` entry per task, each `queued` — exactly as
+ * Harbor's hosted launch submits and returns; `watch()` is the follow, a
+ * separate poll on purpose. The task bytes are never modified: Harbor's own
+ * rule for its check.
+ *
+ * EACH TASK'S RESULT IS A RUN OF ITS OWN, read like an analysis run (owner
+ * ruling 2026-09-09): `task()`, `transcript()` and `artifact()` take the
+ * TASK CHECK id (`Check.results[].id`) and ride the same off-contract feed
+ * doors AnalysesClient's reads ride (its doc records the tension), under the
+ * check's own access law — the creator and the owning organization's
+ * members; an id you may not read is 404 `trial_not_found`, the code every
+ * door a task check rides speaks (the feed's ?what=analysis selector alone
+ * answers `analysis_not_found`).
+ */
+interface ChecksClient {
+    /** Upload a task directory (or a directory of them), or name a published dataset, and start the check. Returns the accepted Check (202). */
+    create(input: CreateCheckInput): Promise<Check>;
+    /** The check with its per-task results — for every status. 404 `check_not_found` for an id you cannot read. */
+    get(checkId: string): Promise<Check>;
+    /** Every check you may read, newest first (cursor-paged); `{ scope, status }` narrow it. */
+    list(options?: ListChecksOptions): CheckList;
+    /** Poll a check until every task settled; resolves with the final Check. */
+    watch(checkId: string, options?: WatchCheckOptions): Promise<Check>;
+    /**
+     * One task's result by TASK CHECK id — the wire's TaskCheck for every
+     * status, typed failure included; the same document the feed downloads
+     * as check-result.json (Harbor's name for the checker's deliverable). A
+     * trial, regrade or analysis id refuses typed at the door, never answering
+     * with another run's document.
+     */
+    task(taskCheckId: string): Promise<TaskCheck>;
+    /** The checker's own transcript (see TaskCheckTranscript); a wrong-species id refuses with the species named. */
+    transcript(taskCheckId: string, options?: AnalysisTranscriptOptions): Promise<TaskCheckTranscript>;
+    /**
+     * One stored artifact by selector — the checker's raw stdout/stderr, or
+     * "agent-home" as the sandbox-path → text map of its session home (the
+     * analysis run's own three selectors). Null = never stored, a normal
+     * answer; a wrong-species id refuses (the ?what=task-check door is
+     * resolved first, so another run's bytes are never served).
+     */
+    artifact(taskCheckId: string, stream: Exclude<AnalysisArtifactStream, "agent-home">): Promise<string | null>;
+    artifact(taskCheckId: string, stream: "agent-home"): Promise<Record<string, string> | null>;
+    /**
+     * Download in one `.tar.gz` (`GET /api/checks/{checkId}/download`, on
+     * the contract) EITHER the whole check — pass the CHECK id: the archive
+     * extracts to `check-<id>/`, Harbor's check job folder, with
+     * `check_report.json` (their CheckReport: `results`, one per task —
+     * task_name, the flat checks, cost_usd, error — plus total_cost_usd) and
+     * one wrapper-trial folder per task check, named as Harbor names a trial
+     * (`check-<task>__<7 chars>/`) — OR one task check's folder alone: pass
+     * the TASK CHECK id (`Check.results[].id`). Each folder is Harbor's
+     * TrialPaths for the checker's run: config.json, lock.json, result.json,
+     * trial.log, exception.txt (an infrastructure failure only),
+     * agent/claude-code.txt, agent/stderr.log, agent/trace-parsed.jsonl, the
+     * captured home at its real names with agent/agent-home.json and Harbor's
+     * copy at agent/sessions/, verifier/{test-stdout.txt,reward.txt,
+     * reward.json} when the validator ruled (reward 1 = a valid
+     * check-result.json, 0 = it was refused), artifacts/manifest.json and
+     * artifacts/check-result.json (the validated flat checks) on a completed
+     * run — absent artifacts are absent files; data the platform does not
+     * hold is left out, never faked. Same three delivery shapes and integrity
+     * checks as jobs().download(). An id that is neither a check nor a task
+     * check you can read is 404 `check_not_found` naming both forms; an
+     * unsettled check or task check is 409 `check_not_terminal`.
+     */
+    download(id: string): Promise<Buffer>;
+    download(id: string, options: {
+        to: string;
+    }): Promise<string>;
+    download(id: string, options: {
+        stream: true;
+    }): Promise<ReadableStream<Uint8Array>>;
+    download(id: string, options?: DownloadJobOptions): Promise<Buffer | string | ReadableStream<Uint8Array>>;
+}
+/** A key descriptor. The secret is never returned. */
+interface ApiKey {
+    id: string;
+    label: string | null;
+    created_at: string;
+    last_used_at: string | null;
+}
+/** Who the caller is and the key they used. */
+interface AuthStatus {
+    user_id: string;
+    email: string | null;
+    key: ApiKey;
+}
+/** Client for caller identity. */
+interface AuthClient {
+    /** Identify the caller and the API key in use. */
+    status(): Promise<AuthStatus>;
+}
+/** The caller's role in an organization: owner manages, member reads and runs. */
+type OrgRole = "owner" | "member";
+/** An organization the caller belongs to (`GET /api/orgs` item; Harbor's `auth org list` row). */
+interface Organization {
+    org_id: string;
+    /** URL-safe handle, globally unique — the `<slug>` every org verb takes. */
+    slug: string;
+    display_name: string;
+    /** True for the auto-created personal org — the invisible default owner of everything created without naming an org. */
+    personal: boolean;
+    /** The CALLER'S role; present when the read implies membership. */
+    role?: OrgRole;
+    created_at: string;
+}
+/**
+ * An organization's ceilings, every one EFFECTIVE — the value the platform
+ * administrator set, else the fleet default. `0` means paused: creates are
+ * refused `quota_exceeded`, queued work waits. Set only from the platform
+ * administrator's dashboard session; the SDK reads them.
+ */
+interface OrgQuota {
+    /** Trials running at once (RUNNING or SCORING); work beyond it waits. */
+    max_concurrent_trials: number;
+    /** Trials waiting in the queue — the one refusal (`quota_exceeded`) on job create. */
+    max_queued_trials: number;
+    /** Dataset imports a worker holds at once; further imports wait. */
+    max_concurrent_imports: number;
+    /** Rubric-agent runs in flight at once fleet-wide — trace analyses AND task quality checks under ONE count; further runs of either kind wait. */
+    max_concurrent_analyses: number;
+    /** Managed-agent sessions open at once (recorded and read back; not yet enforced by the box-create doors). */
+    max_concurrent_sessions: number;
+    /** Model spend allowed this UTC calendar month (the gateway's window, reset on the 1st), USD; null = no monthly budget. */
+    monthly_budget_usd: number | null;
+    /** Sandboxes of this organization in flight on e2b at once — trials, trace analyses, regrade verifiers and managed sessions together; work beyond it waits; 0 pauses the organization on that provider; fleet default = the platform's own e2b ceiling. */
+    max_concurrent_sandboxes_e2b: number;
+    /** The same ceiling on daytona: the organization's sandboxes in flight there at once; work beyond it waits; 0 pauses the organization on daytona; fleet default = the platform's own daytona ceiling. */
+    max_concurrent_sandboxes_daytona: number;
+    /** The same ceiling on modal: the organization's sandboxes in flight there at once; work beyond it waits; 0 pauses the organization on modal; fleet default = the platform's own modal ceiling. */
+    max_concurrent_sandboxes_modal: number;
+}
+/** The live load beside the ceilings — what `evolve auth org show` prints as N/M. */
+interface OrgUsage {
+    in_flight_trials: number;
+    queued_trials: number;
+    in_flight_imports: number;
+    /** Rubric-agent runs RUNNING now — trace analyses AND task quality checks, the one count `max_concurrent_analyses` bounds. */
+    in_flight_analyses: number;
+    /** Sessions not yet ended; always 0 on a shared org (sessions carry no organization). */
+    active_sessions: number;
+    /**
+     * The gateway's own month-to-date meter for the organization — the number
+     * `monthly_budget_usd` is enforced against (UTC calendar month, reset on the
+     * 1st) — as the platform last copied it. null = no copy the platform may
+     * serve (never copied, or the month rolled and the gateway has not reset
+     * yet); never 0 for "unknown".
+     */
+    month_spend_usd: number | null;
+    /** When the gateway answered the copy above (ISO 8601); null exactly when `month_spend_usd` is. */
+    month_spend_as_of: string | null;
+}
+/** One organization in depth (`GET /api/orgs/{org}`): the row, the member count, its quota and usage. */
+interface OrganizationDetail extends Organization {
+    member_count: number;
+    quota: OrgQuota;
+    usage: OrgUsage;
+}
+/**
+ * Client for the caller's organizations — the read pair. Creating, renaming,
+ * deleting, members and invite links are served by the API and stay outside
+ * the SDK until a wave asks for them; quotas are set only from the platform
+ * administrator's dashboard session, so no SDK method could ever set one.
+ */
+interface OrgsClient {
+    /** Every organization the caller belongs to, personal first (`GET /api/orgs`). */
+    list(): Promise<Organization[]>;
+    /** One organization by slug (or id): role, member count, quota, usage (`GET /api/orgs/{org}`). */
+    get(org: string): Promise<OrganizationDetail>;
+}
+/**
+ * Every error code the hosted API can return, as a closed list.
+ *
+ * This exists so a typo cannot compile. `err.code === "insufficient_creidts"`
+ * used to typecheck (code was `string`) and then silently never match, which is
+ * the worst shape a bug can take: the branch looks handled and never runs.
+ *
+ * It mirrors the ErrorCode enum in spec/openapi.yaml and is published verbatim
+ * at GET /api/meta as `error_codes`. A server newer than this SDK may send a
+ * code that is not listed here — `EvolveApiError.code` widens to string for
+ * exactly that case, so an unknown code is still readable, just not narrowable.
+ *
+ * Held to the spec by hosted-error-codes.json at the package root, the
+ * checked-in copy both SDKs assert against; the list drifted silently before
+ * that file existed. Adding a code means editing the spec, that file, this
+ * list, and the Python pair.
+ */
+declare const HOSTED_ERROR_CODES: readonly ["missing_authorization", "invalid_api_key", "read_only_key", "credential_service_unavailable", "rate_limited", "insufficient_credits", "quota_exceeded", "invalid_json", "invalid_input", "invalid_limit", "invalid_status", "invalid_visibility", "invalid_cursor", "invalid_after", "invalid_format", "invalid_ids", "invalid_multipart", "idempotency_key_reused", "dataset_not_found", "dataset_version_not_found", "dataset_name_taken", "dataset_in_use", "dataset_not_owned", "dataset_import_in_progress", "upstream_not_watchable", "no_active_version", "version_not_ready", "version_not_activatable", "unknown_task_names", "no_tasks", "task_not_found", "task_failed_to_build", "upload_session_not_found", "upload_offset_mismatch", "upload_chunk_digest_mismatch", "upload_incomplete", "upload_archive_digest_mismatch", "upload_session_failed", "too_many_concurrent_upload_chunks", "agent_not_found", "agent_name_taken", "agent_name_reserved", "agent_invalid_name", "agent_source_required", "agent_source_conflict", "agent_invalid_env", "agent_too_large", "agent_limit_reached", "skill_not_found", "skill_name_not_found", "skill_ref_invalid", "skill_unresolvable", "skill_invalid", "skill_in_use", "skill_too_large", "skill_limit_reached", "too_many_concurrent_skill_uploads", "secret_not_found", "secret_ambiguous", "secret_brokered_unsupported", "secret_exists", "secret_not_attached", "agent_version_not_found", "agent_version_unresolvable", "agent_kwarg_unsupported", "agent_config_unsupported", "agent_config_key_refused", "agent_preset_unsupported", "provider_unsupported", "job_not_found", "job_not_terminal", "no_failed_trials", "trial_not_found", "trial_not_settled", "concurrent_update", "regrade_source_ineligible", "no_regradable_trials", "invalid_rubric", "analysis_already_running", "analysis_not_found", "analysis_not_terminal", "check_not_found", "check_not_terminal", "no_checkable_tasks", "too_many_concurrent_check_uploads", "no_analyzable_trials", "not_a_job_dir", "invalid_trial", "trial_too_large", "upload_too_large", "job_uploaded", "job_already_uploaded", "too_many_concurrent_job_uploads", "job_import_not_found", "import_not_found", "import_too_large", "too_many_concurrent_imports", "invalid_archive", "unpinned_git_ref", "hub_package_not_found", "hub_unreachable", "package_not_retained", "package_corrupt", "package_missing", "too_many_concurrent_package_downloads", "org_not_found", "org_slug_taken", "org_forbidden", "org_personal_immutable", "org_last_owner", "org_in_use", "org_member_not_found", "invite_not_found", "invite_invalid", "internal_error"];
+/** One of the API's stable error codes. */
+type HostedErrorCode = (typeof HOSTED_ERROR_CODES)[number];
+/** True when `value` is a code this SDK version knows about (narrowing guard). */
+declare function isHostedErrorCode(value: unknown): value is HostedErrorCode;
+/** A closed vocabulary a client renders, with the members that end it. */
+interface StatusVocabulary {
+    values: string[];
+    /** Members after which nothing more happens — a watcher may stop here. */
+    terminal: string[];
+}
+/**
+ * The `effort_support` vocabulary, published as a runtime list so the drift
+ * gate can hold this union to the contract's enum — and so a client can
+ * narrow an unknown string. The server serves exactly these members.
+ */
+declare const AGENT_EFFORT_SUPPORT_VALUES: readonly ["level", "binary", "none"];
+/** What an agent does with `agents[].reasoning_effort` — see AgentCapability. */
+type AgentEffortSupport = (typeof AGENT_EFFORT_SUPPORT_VALUES)[number];
+/** One model alias an agent offers, for a picker's option list. */
+interface AgentModelOption {
+    alias: string;
+    model_id: string;
+    description: string | null;
+}
+/** One built-in agent's declared capabilities. */
+interface AgentCapability {
+    name: string;
+    /** false = registered but the agent phase must refuse it, with `reason` set. */
+    runnable: boolean;
+    /** Why not, when `runnable` is false. Null otherwise. */
+    reason: string | null;
+    /**
+     * What the evolve SDK runs when no model is named. This API REQUIRES an
+     * explicit model (limits.job.model_required), so treat it as the sensible
+     * pre-selection for a picker — the server never fills it in for you.
+     */
+    default_model: string | null;
+    /** Known model aliases for this agent — the picker's option list. */
+    models: AgentModelOption[];
+    /**
+     * What this agent does with `agents[].reasoning_effort`:
+     *   'level'   the value reaches the agent CLI as a level
+     *   'binary'  thinking on/off only — a level outside
+     *             limits.job.binary_effort_values is refused at create
+     *   'none'    no effort input at all; naming one is refused at create
+     * Published so a builder greys the control out instead of discovering the
+     * refusal after a POST.
+     */
+    effort_support: AgentEffortSupport;
+    /** The pinned default stored when a create request omits the effort; null for 'none'. */
+    default_effort: string | null;
+    /** Whether job agents[].version may pin this agent. */
+    version_pinnable: boolean;
+    /**
+     * Whether job `agents[].kwargs.config` reaches this agent — native
+     * agent-settings support (Harbor's SUPPORTS_CONFIG). Declaring a config for
+     * an agent without it is refused `agent_config_unsupported`.
+     */
+    supports_config?: boolean;
+    /**
+     * The named settings presets this agent can guarantee (`no-internet`,
+     * `pinned-context`). Declaring `agents[].preset` outside this list is
+     * refused `agent_preset_unsupported`. Absent on older servers = none
+     * advertised.
+     */
+    presets?: string[];
+    /**
+     * Newest published version, for a "your pin is out of date" badge. Null
+     * means "not known right now", never "up to date".
+     */
+    latest_version?: string | null;
+}
+/** One sandbox provider, its ceilings, and what it refuses. */
+interface ProviderCapability {
+    name: string;
+    default: boolean;
+    sizing: {
+        max_cpus: number;
+        max_memory_mb: number;
+        max_storage_mb: number;
+        storage: "sized" | "fixed";
+    };
+    /**
+     * GPU capability of this provider for eval boxes right now. When
+     * `supported` is false, `degrades_to` names where a GPU job stamped here
+     * actually runs (modal) and `reason` is the same sentence the trial
+     * records; daytona's answer comes from a live org-quota probe that fails
+     * closed, and `source` says whether it was measured ('live-quota') or is
+     * the conservative fallback. Absent on servers predating the field.
+     */
+    gpus?: {
+        supported: boolean;
+        /** Per-container allocation ceiling; import refuses tasks above it. */
+        max_gpus: number;
+        degrades_to?: "modal";
+        reason?: string;
+        source?: "live-quota" | "fallback" | "provider-constant";
+    };
+    refuses: {
+        capability: string;
+        reason: string;
+    }[];
+}
+/**
+ * One managed sandbox door and whether this deployment serves it — a
+ * different question from ProviderCapability, which is about the eval lane.
+ * A managed sandbox is one the caller drives directly holding nothing but an
+ * Evolve key.
+ */
+interface ManagedProviderCapability {
+    name: string;
+    /**
+     * The operator config this door reads is present. NOT a health check: it
+     * says nothing about whether the pass-through behind the door is deployed
+     * or the credential behind it is valid.
+     */
+    configured: boolean;
+    /** Config this door reads, so an operator sees what to set. */
+    requires_config: string[];
+    /** The subset of `requires_config` missing right now — empty when configured. */
+    missing_config: string[];
+    /** A full SDK agent session can run on this door. */
+    agent_sessions: boolean;
+    /** Why not, when `agent_sessions` is false. Null otherwise. */
+    agent_sessions_reason: string | null;
+}
+/**
+ * The capability document: everything a client would otherwise hardcode.
+ *
+ * Public and cacheable — no API key needed, so a signed-out page can populate
+ * its own agent picker. `schema_version` bumps when a FIELD changes meaning,
+ * never when a value changes.
+ */
+interface CapabilityDocument {
+    schema_version: number;
+    /** Built-in agents and their declared capabilities. */
+    agents: AgentCapability[];
+    /** Rules a bring-your-own agent registration must satisfy. */
+    agent_registration: {
+        name_pattern: string;
+        max_name_length: number;
+        max_run_command_length: number;
+        max_install_script_length: number;
+        max_env_entries: number;
+        max_per_user: number;
+        max_upload_bytes: number;
+        /** Built-in names a registration may not reuse. */
+        reserved_names: string[];
+        /** Env keys the platform owns; declaring one is refused at registration. */
+        reserved_env_keys: string[];
+    };
+    sandbox_providers: ProviderCapability[];
+    /**
+     * Fleet-wide cap on concurrently in-flight trials of GPU-declaring tasks
+     * (platform-paid GPU compute). Queued GPU trials past the cap wait for a
+     * slot. Absent on servers predating the field.
+     */
+    gpu_concurrency_cap?: number;
+    /** The managed doors this deployment serves, and what each can carry. */
+    managed_providers: ManagedProviderCapability[];
+    /** Constraints that hold on EVERY provider. */
+    platform_constraints: {
+        capability: string;
+        reason: string;
+    }[];
+    network_modes: string[];
+    /** Every status vocabulary on the surface, with terminal members. */
+    statuses: {
+        job: StatusVocabulary;
+        trial: StatusVocabulary;
+        import: StatusVocabulary;
+        dataset_version: StatusVocabulary;
+    };
+    /**
+     * The trace analyzer's roster and defaults: the model an omitted
+     * `analyze.model_name` takes, the efforts `analyze.reasoning_effort`
+     * accepts (the claude harness's — the analyzer IS that harness), and
+     * every roster model with the effort an omitted `reasoning_effort` takes
+     * for it. Absent on servers predating the field.
+     */
+    analyze?: {
+        default_model: string;
+        reasoning_efforts: string[];
+        models: {
+            alias: string;
+            model_id: string;
+            default_reasoning_effort: string;
+        }[];
+    };
+    limits: {
+        /**
+         * What a client must know to send a good job: the concurrency bound
+         * and the fleet defaults. No fan-out ceiling is published because none
+         * exists (no invented number, owner 2026-09-13): `n_attempts`, the
+         * agent count, the trial matrix, `retry.max_retries` and every timeout
+         * multiplier are unbounded, as in Harbor.
+         */
+        job: {
+            n_concurrent_trials: {
+                default: number;
+                max: number;
+            };
+            default_max_trial_spend_usd: number;
+            /**
+             * Applied to retry.max_retries when a create request omits it — the
+             * auto-retry fleet default (Harbor's local default is 0; here
+             * infrastructure errors retry automatically).
+             */
+            default_max_retries: number;
+            default_sandbox_provider: string;
+            default_sizing: {
+                cpus: number;
+                memory_mb: number;
+                storage_mb: number;
+            };
+            /** Every agent must name a model; the server applies no default. */
+            model_required: boolean;
+            /**
+             * Phase wall-clocks a task INHERITS when its own config declares none —
+             * a task that declares its own always wins, so these fill in rather than
+             * cap. Published because nothing else here says how long a trial may run.
+             */
+            default_agent_timeout_sec: number;
+            default_verifier_timeout_sec: number;
+            /** Values agents[].reasoning_effort accepts, and the one an omitted effort takes. */
+            reasoning_efforts: string[];
+            default_reasoning_effort: string;
+        };
+        compare: {
+            min_ids: number;
+            max_ids: number;
+        };
+        pagination: {
+            collections: {
+                default: number;
+                max: number;
+            };
+            dataset_tasks: {
+                default: number;
+                max: number;
+            };
+            trace_events: {
+                default: number;
+                max: number;
+            };
+        };
+        /**
+         * The ONE physical ceiling on an uploaded dataset, job or check archive
+         * — what the object store can land (S3's 10,000 parts of the store
+         * move's part size; the local store's free disk in local mode) —
+         * published with its source. No archive cap, trial-count cap, per-file
+         * or per-tree cap of the platform's exists (owner 2026-09-13).
+         */
+        uploads: {
+            dataset_archive_bytes: number;
+            /** The same ceiling, for a job archive. */
+            job_archive_bytes: number;
+            /** Where the archive ceiling was read from — S3's multipart limits, or the local store's statfs reading. */
+            archive_bytes_source: string;
+            agent_tarball_bytes: number;
+            /** Compressed cap on one uploaded skill tarball (`skill_too_large` past it). */
+            skill_archive_bytes: number;
+            /** Uploaded-skill records one caller may hold (`skill_limit_reached` past it). */
+            skill_uploads_per_user: number;
+        };
+        dataset_names: {
+            pattern: string;
+            max_name_length: number;
+            max_version_length: number;
+            max_git_url_length: number;
+            max_git_ref_length: number;
+            max_git_path_length: number;
+        };
+        /** How many items an error MESSAGE names before "and N more". */
+        max_items_named_in_error_message: number;
+    };
+    /** The ImportWarning codes the platform can attach to an import. */
+    import_warning_codes: string[];
+    /** The closed error-code union, enumerated at runtime. */
+    error_codes: string[];
+}
+
+export { type AnalysisList as $, type AgentInput as A, type AgentDatasetStats as B, type Check as C, type DatasetVersion as D, type AgentEffortSupport as E, type AgentInfo as F, type GatewayUsageEvent as G, type HostedErrorCode as H, type AgentList as I, type JobCreate as J, type AgentModelOption as K, type AgentPage as L, type AgentResult as M, type AgentSource as N, type OrgsClient as O, type PublishDatasetInput as P, type AgentSourceInput as Q, type Rubric as R, type SkillsClient as S, type Trial as T, type UsageReading as U, type AgentUpsertInput as V, type AnalysisArtifactStream as W, type AnalysisCheck as X, type AnalysisEvidence as Y, type AnalysisFailure as Z, type AnalysisLabel as _, type TrialAnalysis as a, type JobImportPhaseProgress as a$, type AnalysisPage as a0, type AnalysisStatus as a1, type AnalysisTranscript as a2, type AnalysisTranscriptOptions as a3, type AnalyzeConfig as a4, type AnalyzeConfigInput as a5, type ApiKey as a6, type AttemptPhase as a7, type AuthStatus as a8, type Awaitable as a9, type DownloadJobOptions as aA, EVAL_SANDBOX_PROVIDERS as aB, type Agent as aC, type ModelInfo as aD, type EvalSandboxProvider as aE, type StepResult as aF, type ExceptionInfo as aG, GATEWAY_TRACE_SEQ_BASE as aH, type GatewayUsage as aI, type GetDatasetOptions as aJ, type GrepJobOptions as aK, HOSTED_ERROR_CODES as aL, type ImportPhase as aM, type ImportPhaseProgress as aN, type ImportWarning as aO, type InfraFailureSignature as aP, JOB_LIST_SCOPES as aQ, type JobAnalysisStats as aR, type JobDeleteResult as aS, type JobFailure as aT, type JobGrepGroup as aU, type JobGrepPage as aV, type JobImport as aW, type JobImportFailure as aX, type JobImportList as aY, type JobImportPage as aZ, type JobImportPhaseName as a_, CHECK_STATUSES as aa, type CheckLabel as ab, type CompareCell as ac, type CompareCoverage as ad, type CompareJobAggregate as ae, type CompareResponse as af, type CompareTaskRow as ag, type Dataset as ah, type DatasetImportFailure as ai, type DatasetImportList as aj, type DatasetImportPage as ak, type DatasetImportStatus as al, type DatasetList as am, type DatasetPage as an, type DatasetPatch as ao, type DatasetPreflight as ap, type DatasetRef as aq, type DatasetSelector as ar, type DatasetSource as as, type DatasetVersionArchiveSource as at, type DatasetVersionArchiveUrlSource as au, type DatasetVersionGitSource as av, type DatasetVersionHubSource as aw, type DatasetVersionSource as ax, type DatasetVersionState as ay, type DownloadDatasetOptions as az, type DatasetImport as b, type TimingInfo as b$, type JobImportProgress as b0, type JobImportSkippedTrial as b1, type JobImportSource as b2, type JobList as b3, type JobListScope as b4, type JobPage as b5, type JobStats as b6, type JobStatus as b7, type JobTaskLink as b8, type JobTaskRollup as b9, type PreflightManifestVerdict as bA, type PreflightTaskVerdict as bB, type ProviderCapability as bC, type PublishDatasetOptions as bD, type RegradeRequest as bE, type ResumeRequest as bF, type RetryRequest as bG, type RubricCriterion as bH, type SkillLock as bI, type SkillUpload as bJ, type SkillUploadList as bK, type SkillUploadPage as bL, type SourceJob as bM, type SpendSource as bN, type StartJobOptions as bO, type StatusVocabulary as bP, type StopResponse as bQ, TASK_LINKED_BY as bR, TASK_LINK_REASONS as bS, TRIAL_ARTIFACT_STREAMS as bT, TRIAL_STATUSES as bU, type Task as bV, type TaskCheckTranscript as bW, type TaskLinkReason as bX, type TaskLinkedBy as bY, type TaskNote as bZ, type TaskProviderVerdict as b_, type JobTaskRollupList as ba, type JobTaskRollupPage as bb, type JobWatch as bc, type JudgeResult as bd, type ListAgentsOptions as be, type ListAnalysesOptions as bf, type ListDatasetsOptions as bg, type ListImportsOptions as bh, type ListJobImportsOptions as bi, type ListJobTasksOptions as bj, type ListJobsOptions as bk, type ListSkillsOptions as bl, type ListTrialFilesOptions as bm, type ListTrialsOptions as bn, type ManagedProviderCapability as bo, type OrgQuota as bp, type OrgRole as bq, type OrgUsage as br, type Organization as bs, type OrganizationDetail as bt, type Page as bu, type PageOptions as bv, type PassAtKGroup as bw, type PassAtKPoint as bx, type PreflightDatasetInput as by, type PreflightDeferredCheck as bz, type JobEvent as c, type TraceEventPage as c0, type TraceOptions as c1, type TrialArtifactStream as c2, type TrialCounts as c3, type TrialFile as c4, type TrialFilePage as c5, type TrialFileRange as c6, type TrialGpuCost as c7, type TrialList as c8, type TrialPage as c9, type TrialStatus as ca, type TrialStatusTally as cb, type TrialTaskLink as cc, type TrialUploadProvenance as cd, type UploadJobOptions as ce, type UploadProvenance as cf, type UpstreamStatus as cg, type VerifierEnvironmentMode as ch, type VerifierResult as ci, type WatchAnalysisOptions as cj, type WatchImportOptions as ck, type WatchJobImportOptions as cl, type WatchJobOptions as cm, gatewayUsageOf as cn, isHostedErrorCode as co, passAtK as cp, type DatasetFailedTask as d, type DatasetImportProgress as e, type JobSecretInline as f, type JobSecretRef as g, type TraceEvent as h, type Job as i, type TaskCheck as j, type DatasetsClient as k, type AgentsClient as l, type JobsClient as m, type TrialsClient as n, type AnalysesClient as o, type ChecksClient as p, type CapabilityDocument as q, type HostedClientConfig as r, type AuthClient as s, AGENT_EFFORT_SUPPORT_VALUES as t, ANALYSIS_ARTIFACT_STREAMS as u, ANALYSIS_STATUSES as v, type ActiveDataset as w, type AgentArm as x, type AgentArmInput as y, type AgentCapability as z };