runbios-sdk 0.2.17 → 0.2.18-dev.271

package/dist/types.d.ts

@@ -8,13 +8,13 @@ export interface BiOSConfig {
     orgId?: string;
     /** Workspace ID. Optional when using API keys (resolved from the key). Can override for multi-workspace keys. */
     workspaceId?: string;
-    /** Base URL for the API. Falls back to the RUNBIOS_BASE_URL environment variable (legacy: BIOS_BASE_URL), then the canonical https://api.runbios.ai hostname. */
+    /** Base URL for the API. Falls back to the RUNBIOS_BASE_URL environment variable (legacy: BIOS_BASE_URL), then the canonical https://api-dev.runbios.ai hostname. */
     baseUrl?: string;
     /** Request timeout in milliseconds. Defaults to 30000. */
     timeout?: number;
     /** Default per-deployment inference key. Can be overridden per inference call. */
     inferenceKey?: string;
-    /** Inference base URL. Defaults to baseUrl, then https://api.runbios.ai. */
+    /** Inference base URL. Defaults to baseUrl, then https://api-dev.runbios.ai. */
     inferenceBaseUrl?: string;
     /** End-to-end inference timeout in milliseconds. Defaults to 15 minutes. */
     inferenceTimeout?: number;
@@ -461,21 +461,6 @@ export interface DatasetRegisterHFParams {
     columnMapping?: Record<string, DatasetTrainingField>;
     importMode?: 'auto' | 'reference' | 'materialize';
 }
-/** Parameters for registering a curated Conscious Loop set as a dataset. */
-export interface DatasetRegisterLoopParams {
-    /** The Conscious Loop dataset to register. */
-    loopDatasetId: string;
-    /** Defaults to `loop-<first 8 of the loop id>`. */
-    name?: string;
-    /**
-     * Which rows to take. Defaults to `all`, because the loop already split the
-     * set by TIME and re-splitting a deliberate split throws that decision away.
-     * Register `train` and `holdout` separately to score a training job against
-     * the loop's own held-back rows; both can exist at once.
-     */
-    split?: 'all' | 'train' | 'holdout';
-    workspaceId?: string;
-}
 /** Parameters for searching HuggingFace Hub datasets. */
 export interface DatasetHubSearchParams {
     /** Search query. */
@@ -2344,7 +2329,12 @@ export interface LoopMessage {
     name?: string;
 }
 export interface LoopCaptureParams {
-    /** The source being recorded. Must be enabled first, or nothing is stored. */
+    /**
+     * The source being recorded. Must be switched on, or nothing is stored. A
+     * pipeline's own tag (`pipeline.own_tag`) is a source its create switched
+     * on, stamping that tag, so sending there reaches the pipeline with no
+     * further setup; any other source is switched on with `setConfig`.
+     */
     deployment_id: string;
     model: string;
     messages: LoopMessage[];
@@ -2362,6 +2352,12 @@ export interface LoopCaptureParams {
     completion_tokens?: number;
     latency_ms?: number;
     metadata?: Record<string, unknown>;
+    /**
+     * Tags for this conversation, on top of the ones its source stamps. A
+     * pipeline trains on every sample carrying any of its tags, so this is how
+     * one conversation reaches another pipeline too. At most 32 in all.
+     */
+    labels?: string[];
 }
 export interface LoopCaptureResult {
     captured: boolean;
@@ -2369,7 +2365,6 @@ export interface LoopCaptureResult {
     trace_id?: string;
     /** Set when something was removed before the record was written. */
     redacted?: boolean;
-    download_url?: string;
     /** Why nothing was stored, e.g. `capture_disabled`, `not_sampled`. */
     reason?: string;
 }
@@ -2554,8 +2549,8 @@ export interface LoopSignalParams {
     /**
      * Which training pipeline this feedback feeds, named in the SAME call.
      *
-     * A build rule selects conversations by label and a training rule trains from
-     * that build rule, so a label IS the pipeline a conversation goes down.
+     * A pipeline trains on the conversations carrying its tags, so a label IS
+     * the pipeline a conversation goes down.
      * Putting one on used to need a second request after this one — and that
      * second request is the one that gets skipped, by a script that handles the
      * 201 and moves on, by a retry that succeeds here and fails there, by an
@@ -2622,6 +2617,18 @@ export interface LoopTraceListParams {
     model?: string;
     /** `captured` (our model's own behaviour) or `imported` (a file somebody brought). */
     origin?: 'captured' | 'imported';
+    /**
+     * Only the conversations one pipeline's selection covers -- any of its tags
+     * -- reviewed or not. The other filters narrow it further.
+     */
+    pipeline?: string;
+    /**
+     * Only the conversations whose deciding verdict is this feedback: `good`
+     * (accepted), `bad` (rejected) or `corrected` (edited, or gold).
+     */
+    signal?: 'good' | 'bad' | 'corrected';
+    /** Only the conversations nobody has given feedback on yet. */
+    unsignalled?: boolean;
 }
 export interface LoopTraceListResponse {
     traces: LoopTrace[];
@@ -2629,69 +2636,6 @@ export interface LoopTraceListResponse {
     limit: number;
     offset: number;
 }
-export interface LoopDatasetCreateParams {
-    name: string;
-    method: LoopMethod;
-    deployment_id?: string;
-    from?: string;
-    to?: string;
-    /** Narrow to one slice. A label with children selects them too. */
-    label?: string;
-    /**
-     * Take this many of what the filters matched. Which ones is arbitrary but
-     * REPEATABLE: the same conversations always give the same slice, so two
-     * builds of one spec describe the same set.
-     */
-    sample?: number;
-    /** Holds back your most recent work, not a random slice. 0-50. */
-    holdout_percent?: number;
-    max_items?: number;
-    /**
-     * Named dimensions, ANDed with each other and with `label`:
-     * `{ category: 'billing', language: 'es' }`. This is what turns one captured
-     * corpus into a different dataset for every task somebody trains for.
-     */
-    attributes?: Record<string, string>;
-    /** Only the conversations nobody has described yet. */
-    unlabelled?: boolean;
-    /** Only what ONE model answered — the filter distillation is made of. */
-    model?: string;
-    /** `captured` (our model's own behaviour) or `imported` (a file somebody brought). */
-    origin?: 'captured' | 'imported';
-}
-export interface LoopDataset {
-    id: string;
-    workspace_id: string;
-    name: string;
-    method: LoopMethod;
-    status: string;
-    spec: Record<string, unknown>;
-    item_count: number;
-    considered_count: number;
-    /** Why rows were left out, by reason. */
-    rejected_counts: Record<string, number>;
-    holdout_count: number;
-    holdout_cutoff: string | null;
-    created_by: string | null;
-    created_at: string;
-    completed_at: string | null;
-    download_url: string;
-}
-export interface LoopDatasetListParams {
-    method?: LoopMethod;
-    limit?: number;
-    offset?: number;
-}
-export interface LoopDatasetItem {
-    id: number;
-    trace_id: string;
-    split: 'train' | 'holdout';
-    payload: Record<string, unknown>;
-    dedup_key: string;
-    created_at: string;
-    /** The conversation this row was built from. */
-    trace_url: string;
-}
 export interface LoopConfig {
     deployment_id: string;
     workspace_id: string;
@@ -2701,42 +2645,8 @@ export interface LoopConfig {
     enabled_by: string | null;
     enabled_at: string | null;
     updated_at: string;
-    auto_grade: boolean;
-}
-export interface LoopBuildRuleParams {
-    name: string;
-    method: string;
-    /**
-     * How many rows reviewed SINCE THE LAST BUILD must exist before this fires
-     * again. Minimum 100, and 100 when absent. Counting the whole corpus instead
-     * would fire the rule every interval forever, because a total that has
-     * crossed a threshold stays across it.
-     */
-    min_new_rows?: number;
-    enabled?: boolean;
-    /** The same selection `createDataset` takes, replayed verbatim. */
-    spec?: LoopDatasetCreateParams;
-}
-export interface LoopBuildRule {
-    id: string;
-    workspace_id: string;
-    name: string;
-    method: string;
-    spec: Record<string, unknown>;
-    min_new_rows: number;
-    enabled: boolean;
-    last_built_at: string | null;
-    last_dataset_id: string | null;
-    /**
-     * Why the rule did not fire last time it was checked. A rule quiet because
-     * it is waiting looks exactly like one quiet because it is broken; this is
-     * the difference.
-     */
-    last_reason: string | null;
-    last_checked_at: string | null;
-    created_by: string | null;
-    created_at: string;
-    updated_at: string;
+    /** Tags stamped, server side, on every conversation captured from this source. */
+    tags: string[];
 }
 export interface LoopConfigParams {
     enabled: boolean;
@@ -2744,365 +2654,109 @@ export interface LoopConfigParams {
     /** Deterministic per conversation, so turns are never split. 0 < rate <= 1. */
     sample_rate?: number;
     /**
-     * Continuous rule-based scoring for this source. OMITTED MEANS UNCHANGED:
-     * a caller saving retention must not switch grading off for a workspace
-     * that turned it on.
-     */
-    auto_grade?: boolean;
-}
-/** One thing a judge scores, separately from the others. */
-export interface LoopJudgeDimension {
-    key: string;
-    description?: string;
-}
-/** Which slice of the corpus a judge is responsible for. */
-export interface LoopJudgeSelection {
-    label?: string;
-    deployment_id?: string;
-    from?: string;
-    to?: string;
-    sample?: number;
-    /** Skip conversations that already carry a judge verdict. */
-    only_unscored?: boolean;
-}
-export interface LoopJudge {
-    id: string;
-    workspace_id: string;
-    name: string;
-    instructions: string;
-    dimensions: LoopJudgeDimension[];
-    selection: LoopJudgeSelection;
-    model: string | null;
-    write_gold: boolean;
-    enabled: boolean;
-    /** The platform's agent runs this judge, on the workspace's own serverless account. */
-    auto: boolean;
-    /**
-     * Was automatic when the agent was turned off. Turning the agent back on
-     * restores exactly these judges.
-     */
-    auto_paused: boolean;
-    /**
-     * Why the last turn-on did NOT restore this judge. Null is the ordinary
-     * state. Set when the resume declined to make it automatic because the model
-     * it names is not one the serving gateway will route — handing it back would
-     * buy a run that fails every conversation. It stays paused, so pointing it at
-     * a model that routes and turning the agent on again brings it back.
-     */
-    auto_pause_reason: string | null;
-    created_by: string | null;
-    created_at: string;
-    updated_at: string;
-}
-export interface LoopJudgeParams {
-    name: string;
-    instructions: string;
-    dimensions: LoopJudgeDimension[];
-    selection?: LoopJudgeSelection;
-    model?: string;
-    /**
-     * Let this judge write the answer that should have been given, not just a
-     * score. Off by default: a reference answer written by a model and then
-     * trained on is distillation, which is a decision you make deliberately.
-     */
-    write_gold?: boolean;
-    enabled?: boolean;
-    /**
-     * Hand the running of this judge to the platform's agent: new conversations
-     * in its slice are scored as they arrive, one model call each, on THIS
-     * WORKSPACE'S OWN serverless account (the agent spends through a managed key
-     * of yours, "Conscious Loop" in your key list). Requires `model`. Off, you
-     * run the model yourself with startRun / takeWork / postVerdicts.
-     */
-    auto?: boolean;
-}
-/** One pass of one rubric over one slice. */
-export interface LoopJudgeRun {
-    id: string;
-    judge_id: string;
-    judge_name?: string;
-    /**
-     * `abandoned` is a run you opened and never drained: nothing was scored on
-     * it for a week and items were still waiting. Nothing is deleted and posting
-     * verdicts to it still works and still closes it as done. It exists so that
-     * `open` keeps meaning "somebody is working on this".
-     *
-     * `stopped` is a run somebody closed on purpose before it finished, with
-     * `stopRun`. Separate from `done` because a run that covered three of forty
-     * conversations did not finish its work: every score it recorded is kept
-     * either way, and reading one as the other overstates what was evaluated.
-     */
-    status: 'open' | 'done' | 'abandoned' | 'stopped';
-    instructions: string;
-    dimensions: LoopJudgeDimension[];
-    model: string | null;
-    selected: number;
-    scored: number;
-    failed: number;
-    /** Who drains it: your own code ('caller') or the platform's agent ('platform'). */
-    runner: 'caller' | 'platform';
-    /** The agent's last complaint about this run, or null while it is working. */
-    last_error: string | null;
-    last_activity_at: string | null;
-    created_by: string | null;
-    created_at: string;
-    finished_at: string | null;
-}
-/** The workspace's managed serverless key the agent spends through. Never the secret. */
-export interface LoopAgentCredential {
-    workspace_id: string;
-    key_id: string;
-    key_prefix: string;
-    created_by: string | null;
-    created_at: string;
-    updated_at: string;
-    last_used_at: string | null;
-    last_error: string | null;
-    revoked_at: string | null;
-    /**
-     * The most the agent's key may spend on model calls in a calendar month,
-     * in cents. `null` = no cap (the default): the agent can spend up to the
-     * workspace's serverless balance. Once reached, the agent's model calls
-     * are refused until next month and its runs pause with that reason.
+     * Tags stamped on every conversation captured from this source, so live
+     * traffic reaches the pipelines they feed. Omitted means unchanged; [] clears.
      */
-    monthly_spend_cap_cents: number | null;
-}
-export interface LoopAgentStatus {
-    /** An agent can exist in this environment at all. */
-    available: boolean;
-    /** Which piece is missing when it cannot. */
-    reason: string;
-    /** A worker has checked in within the last minute. */
-    online: boolean;
-    agent: {
-        seen_at: string;
-        passes: number;
-        judge_items: number;
-        samples: number;
-    } | null;
-    credential: LoopAgentCredential | null;
-    open_judge_runs: number;
-    open_sample_runs: number;
-    auto_judges: number;
-}
-export interface LoopSampleSelection extends LoopJudgeSelection {
-    /** Skip conversations that already have alternatives. */
-    only_unsampled?: boolean;
-}
-export interface LoopSampleRunParams {
-    /** The model that writes the alternatives. For distillation, the teacher. */
-    model: string;
-    /** Alternatives per conversation, 1-8. Default 4. */
-    n?: number;
-    /** 0-2. Default 0.8; 0 makes every sample the same answer. */
-    temperature?: number;
-    /** 16-8192. Default 1024. */
-    max_tokens?: number;
-    /** Score each sample with this judge as it is written. */
-    judge_id?: string;
-    selection?: LoopSampleSelection;
-}
-/** "Write N alternatives to each conversation in this slice, and score them." */
-export interface LoopSampleRun {
-    id: string;
-    workspace_id: string;
-    model: string;
-    n: number;
-    temperature: number;
-    max_tokens: number;
-    judge_id: string | null;
-    judge_name: string | null;
-    selection: LoopSampleSelection;
-    status: 'open' | 'done';
-    selected: number;
-    done: number;
-    failed: number;
-    samples: number;
-    last_error: string | null;
-    last_activity_at: string | null;
-    created_by: string | null;
-    created_at: string;
-    finished_at: string | null;
-}
-/**
- * One conversation to score, already rendered into the prompt to send.
- *
- * Send `prompt` as-is. Assembling it yourself is how two callers end up giving
- * the same rubric different instructions, and two judges given different
- * instructions are not one judge.
- */
-export interface LoopJudgeWorkItem {
-    trace_id: string;
-    messages: Array<{
-        role: string;
-        content?: string;
-    }>;
-    answer: string;
-    prompt: string;
-}
-export interface LoopJudgeWork {
-    run: LoopJudgeRun;
-    items: LoopJudgeWorkItem[];
-    remaining: number;
-}
-export type LoopJudgeRunItemStatus = 'pending' | 'scored' | 'failed';
-/** What happened to one conversation in one run. */
-export interface LoopJudgeRunItem {
-    trace_id: string;
-    status: LoopJudgeRunItemStatus;
-    /**
-     * Why this one could not be scored, as the caller reported it. This is where
-     * a wrong model name or a refused key shows up; null for anything that is
-     * not failed.
-     */
-    error: string | null;
-    scored_at: string | null;
-}
-export interface LoopJudgeRunItems {
-    run: LoopJudgeRun;
-    items: LoopJudgeRunItem[];
-    /** True when the page ended before the run did. */
-    has_more: boolean;
-    /** Where to carry on from. Present only when `has_more`. */
-    next_offset?: number;
-}
-/** One scored conversation going back. */
-export interface LoopJudgeVerdict {
-    trace_id: string;
-    /** One score per dimension the rubric asked for, each between 0 and 1. */
-    scores?: Record<string, number>;
-    /** Your own combination of them. Left out, the plain mean is used. */
-    overall?: number;
-    reason?: string;
-    /** Only stored if the judge was created with `write_gold`. */
-    gold?: string;
-    /** Mark an item you could not score, instead of dropping it silently. */
-    error?: string;
-}
-export interface LoopJudgeVerdictResult {
-    run: LoopJudgeRun;
-    recorded: number;
-    failed: number;
-    rejected: Array<{
-        trace_id: string;
-        error: string;
-    }>;
+    tags?: string[];
 }
+/** GET /api/loop/stats: counts for the workspace. */
 export interface LoopStats {
     traces: number;
     signalled_traces: number;
     signals: number;
     by_verdict: Record<string, number>;
     by_source: Record<string, number>;
-    datasets: number;
-    /** Upper bounds: deduplication runs when a set is built. */
-    ready: Record<LoopMethod, number>;
-}
-export interface LoopCandidateParams {
-    completion?: string;
-    /** An alternative that is itself a tool call. */
-    tool_calls?: LoopToolCall[];
-    /** Which model produced this alternative. The teacher, when distilling. */
-    model?: string;
-    model_version?: string;
-    /** Unscored alternatives cannot pair -- a missing score is not a low one. */
-    score?: number;
-    /** Required alongside a score: human | verifier | judge | behavioural. */
-    score_source?: LoopSource;
-    reason?: string;
-    metadata?: Record<string, unknown>;
-}
-export interface LoopCandidate {
-    id: string;
-    trace_id: string;
-    model: string | null;
-    model_version: string | null;
-    completion: string;
-    tool_calls?: LoopToolCall[];
-    score: number | null;
-    score_source: LoopSource | null;
-    reason: string | null;
-    metadata: Record<string, unknown>;
-    created_at: string;
-}
-/**
- * The deterministic checks a grader can perform.
- *
- * `matches_gold` is the one kind with no expected value of its own: it
- * compares each answer to the gold answer recorded on that same conversation
- * (or the human correction when there is no gold), scores sampled
- * alternatives against the same gold, and is NOT APPLIED to a conversation
- * that carries neither, so it never marks down an unlabelled answer.
- */
-export type LoopGraderKind = 'matches_gold' | 'exact_match' | 'contains' | 'regex' | 'json_valid' | 'numeric' | 'tool_called';
-export interface LoopGraderConfig {
-    expected?: string;
-    /** Every phrase that must appear. */
-    required?: string[];
-    /** Phrases that must not. On their own these are passed by silence. */
-    forbidden?: string[];
-    pattern?: string;
-    /** Keys the answer must carry, for `json_valid`. */
-    keys?: string[];
     /**
-     * How far from `expected` still counts, for `numeric`. For `matches_gold`,
-     * how far from the gold answer still counts when both are bare numbers.
+     * How many samples a pipeline could train on now: the ones marked good or
+     * corrected. A pipeline trains SFT only, so this is the one count. An upper
+     * bound: duplicates, the held-back set and conversations too long to train
+     * on come out of it when an attempt trains.
      */
-    tolerance?: number;
-    /** The function that must have been called, for `tool_called`. */
-    function?: string;
-    case_sensitive?: boolean;
+    ready: {
+        sft: number;
+    };
 }
-export interface LoopGraderParams {
+/** One pipeline a conversation falls inside (GET /api/loop/traces/{id}/pipelines). */
+export interface LoopTracePipeline {
+    /** The pipeline's id: `getPipeline(rule_id)`, the Pipeline's own `rule_id`. */
+    rule_id: string;
+    /** The pipeline's name. */
     name: string;
-    kind: LoopGraderKind;
-    config: LoopGraderConfig;
-    /** The multiplier. Twice as important, twice the weight. Must exceed zero. */
-    weight?: number;
-    enabled?: boolean;
-    /** Limit the rule to one capture source. Omit to apply it everywhere. */
-    deployment_id?: string;
-    /**
-     * Aim the rule at one slice of the corpus. A master group covers its
-     * children. Outside that slice the rule is NOT APPLIED, rather than failed,
-     * so it stays out of the score entirely. Omit to apply it everywhere.
-     */
-    label?: string;
-}
-export interface LoopGrader extends LoopGraderParams {
-    id: string;
-    workspace_id: string;
-    weight: number;
+    /** Whether the pipeline is switched on. A paused one still selects the conversation. */
     enabled: boolean;
-    created_by: string | null;
+}
+export interface LoopTracePipelinesResponse {
+    /** Live pipelines whose tags select this conversation. Empty is a real answer. */
+    pipelines: LoopTracePipeline[];
+    /** Being selected is not being trained on; this sentence says so. */
+    note: string;
+}
+export interface LoopMetricsHistoryParams {
+    /** One pipeline's id. Absent, every attempt in the workspace. */
+    rule_id?: string;
+    /** Most recent attempts to return: 200 when absent, at most 500. */
+    limit?: number;
+    /** Days of feedback counts: 90 when absent, at most 365. */
+    days?: number;
+}
+/** One attempt, and the comparison it produced if it produced one. */
+export interface LoopMetricPoint {
+    run_id: string;
+    seq: number;
+    rule_id: string | null;
+    rule_name: string | null;
+    state: TrainingRunState;
+    verdict: TrainingVerdict | null;
+    decision: TrainingDecision | null;
     created_at: string;
-    updated_at: string;
+    finished_at: string | null;
+    train_rows: number | null;
+    holdout_rows: number | null;
+    billed_training_cents: number;
+    billed_candidate_cents: number;
+    spent_eval_cents: number;
+    benchmark_spent_cents: number;
+    evaluation_id: string | null;
+    rows_scored: number | null;
+    rows_failed: number | null;
+    wins: number | null;
+    losses: number | null;
+    ties: number | null;
+    win_rate: number | null;
+    incumbent_mean: number | null;
+    candidate_mean: number | null;
+    mean_delta: number | null;
+    judge_incumbent_mean: number | null;
+    judge_candidate_mean: number | null;
+    trainer_eval_loss: number | null;
+    /** The bar this attempt had to clear, frozen with its report. */
+    promote_margin: number | null;
+    promote_min_win_rate: number | null;
+    checkpoint_id: string | null;
+    checkpoint_step: number | null;
+    attempt_no: number | null;
+    /** The version this attempt became; null for every attempt that did not. */
+    version_no: number | null;
+    base_model_id: string | null;
+    model_family: string | null;
+    base_model_revision: string | null;
+    train_type: string | null;
+    trigger: string;
+    recipe_note: string | null;
+    recipe_of_version: number | null;
 }
-export interface LoopGraderResult {
-    grader_id: string;
-    name: string;
-    kind: string;
-    weight: number;
-    passed: boolean;
-    score: number;
-    /** What happened, in words -- "failed" alone sends you to read the rule. */
-    detail: string;
-    /** The rule had no opinion. Excluded from the score rather than counted 0. */
-    skipped: boolean;
-}
-export interface LoopGradeReport {
-    /** Weighted mean over the rules that applied, 0 to 1. */
-    score: number;
-    results: LoopGraderResult[];
-    /** The denominator. 1.0 from one rule is not 1.0 from six. */
-    applied: number;
-    skipped: number;
-}
-export interface LoopGradeResult {
-    report: LoopGradeReport;
-    /** Null when no rule applied, because no verdict was invented. */
-    signal_id: string | null;
-    candidates_graded: number;
+/** One day of feedback, counted by verdict. The workspace's, whatever rule_id says. */
+export interface LoopSignalDay {
+    day: string;
+    total: number;
+    by_verdict: Record<string, number>;
+}
+export interface LoopMetricsHistory {
+    /** Oldest first, so a chart reads left to right. */
+    runs: LoopMetricPoint[];
+    signals: LoopSignalDay[];
+    /** True when older attempts exist beyond `limit`. */
+    truncated: boolean;
 }
 export interface LoopLabel {
     label: string;
@@ -3144,8 +2798,6 @@ export interface LoopLabelCount {
     traces: number;
     key: string;
 }
-export type TrainingCadence = 'none' | 'daily' | 'weekly';
-export type TrainingCombinator = 'and' | 'or';
 /** What answers the customer's traffic today, and therefore what promotion re-points. */
 export type ServingKind = 'serverless_slug' | 'deployment';
 export type TrainingRulePausedReason = 'consent_invalid' | 'insufficient_funds' | 'authorizer_not_member' | 'model_not_trainable' | 'platform_capacity'
@@ -3157,45 +2809,6 @@ export type TrainingRulePausedReason = 'consent_invalid' | 'insufficient_funds'
  * wrong; the platform team enables training, then a member saves the rule.
  */
  | 'training_not_enabled';
-/**
- * How a training rule trains, on the wire of the automatic-training routes.
- *
- * DELIBERATELY NOT {@link TrainingMethod}. That union -- 'sft' | 'pt' -- is
- * training-service's, and the two services enumerate different things: a
- * training job can be a plain pre-training run, and a training rule cannot,
- * while a rule may ask for preference training and a job asks for that through
- * a different field. The values here are the loop service's own constants
- * (TrainingMethodSFT / TrainingMethodRLHF in
- * services/loop-service/cmd/training_types.go), which is what these routes
- * accept and return. Sharing the training-service union here advertised 'pt',
- * which this service refuses, and made 'rlhf', which it returns, unspellable.
- *
- * `rlhf_type` stays a plain string on purpose: the platform refuses it until
- * capabilities enable preference training, and an SDK union would have to be
- * republished to keep up with a server-side capability flag.
- */
-export type LoopTrainingMethod = 'sft' | 'rlhf';
-/**
- * What a rule's stored `train_type` may READ as.
- *
- * Still three, and deliberately: the column has always allowed `full`, so a
- * rule created before standing rules were narrowed to adapters can still come
- * back carrying it. Narrowing the response type would make this SDK
- * misrepresent a row that really exists.
- */
-export type TrainType = 'lora' | 'qlora' | 'full';
-/**
- * What a rule may be SET to, which is narrower.
- *
- * loop-service refuses `full` on preflight, create and update for a standing
- * rule: a rule trains unattended and on repeat, and a full fine-tune rewrites
- * every weight instead of adding a small adapter, so it cannot be compared or
- * rolled back cheaply. Typing the request as the wider set handed callers a
- * value guaranteed to come back a 400. One-off full fine-tunes are unaffected
- * — they are a different API.
- */
-export type RuleTrainType = 'lora' | 'qlora';
-export type GradersScope = 'source' | 'all' | 'none';
 /**
  * Why a run fired. `variant` is a recipe variant: the pipeline had nothing new
  * to learn, so it trained the same base model on the same conversations with
@@ -3226,7 +2839,6 @@ export type EvaluationItemStatus = 'pending' | 'working' | 'done' | 'failed';
 export type EvaluationWinner = 'candidate' | 'incumbent' | 'tie';
 /** Typed warning codes. Each surface renders its own plain sentence. */
 export type EvaluationWarningCode = 'holdout_too_small' | 'judge_unreliable' | 'graders_not_applied' | 'many_failures' | 'no_judge' | 'judge_labelled_training_rows' | 'capture_source_moved';
-export type ConsentVia = 'console' | 'api_key' | 'sdk' | 'mcp';
 /** A function an assistant turn asked to invoke. `arguments` is JSON-encoded. */
 export interface TrainingToolCall {
     id?: string;
@@ -3251,386 +2863,6 @@ export interface TrainingRuleServing {
     /** Set only when kind is 'deployment'. */
     deployment_id: string | null;
 }
-/** One rung of a ranked GPU ladder. The provider is the neutral public brand. */
-export interface TrainingGPURung {
-    gpu_type: string;
-    gpu_count: number;
-    provider: string;
-    region: string;
-    tier: string;
-}
-/** The consent object: one standing instruction to train, judge and possibly promote. */
-export interface TrainingRule {
-    id: string;
-    workspace_id: string;
-    build_rule_id: string;
-    name: string;
-    enabled: boolean;
-    /** Why the platform stopped firing this rule. Waiting must not look like broken. */
-    paused_reason: TrainingRulePausedReason | null;
-    cadence: TrainingCadence;
-    cadence_hour_utc: number;
-    cadence_weekday: number | null;
-    combinator: TrainingCombinator;
-    min_new_rows: number | null;
-    /** Spreads firings across the hour so every daily rule does not land on one minute. */
-    jitter_seconds: number;
-    next_due_at: string | null;
-    last_checked_at: string | null;
-    last_fired_at: string | null;
-    last_run_id: string | null;
-    /** Rendered verbatim: "waiting: ...", "due, but ...", "fired: run 7 from ...". */
-    last_reason: string | null;
-    serving: TrainingRuleServing;
-    model_id: string;
-    /** A 40-hex commit, pinned when the rule is saved. */
-    model_revision: string;
-    training_method: LoopTrainingMethod;
-    /** Refused by the platform until capabilities enable preference training. */
-    rlhf_type: string | null;
-    train_type: TrainType;
-    config: Record<string, unknown>;
-    train_gpu_priorities: TrainingGPURung[];
-    train_max_price_hour_cents: number;
-    deploy_gpu_priorities: TrainingGPURung[];
-    deploy_max_price_hour_cents: number;
-    training_ceiling_cents: number;
-    candidate_ceiling_cents: number;
-    /** A dollar figure, never a call count. */
-    eval_ceiling_cents: number;
-    monthly_ceiling_cents: number | null;
-    eval_judge_id: string | null;
-    eval_judge_model: string | null;
-    eval_graders_scope: GradersScope;
-    eval_max_rows: number;
-    eval_max_tokens: number;
-    min_holdout_rows: number;
-    /**
-     * How many versions this pipeline may make, 1 to 10 (five unless changed).
-     * A version is a trained model whose comparison was reported having scored
-     * at least one conversation, or one a member put live; a run that failed,
-     * was cancelled or compared nothing is not one and does not count. At the
-     * limit the pipeline stops, and a manual run is refused with
-     * `409 VERSION_LIMIT_REACHED`, until the limit is raised.
-     */
-    max_versions: number;
-    /**
-     * Try other training recipes when there is nothing new to learn.
-     *
-     * MONEY-BEARING. When on, a pipeline that has made at least one version, and
-     * has nothing reviewed since it that adds anything new to train on (nothing
-     * reviewed at all, or only reviews -- thumbs-down with no correction, say --
-     * that give it no row the last version's set lacked), trains the same base
-     * model on the same conversations with ONE setting changed, and that model
-     * takes over only if it beats what serves the app, like any other version.
-     * Each try is a full paid run inside the rule's per-run ceilings and its
-     * monthly limit, so changing this in EITHER direction changes the terms: the
-     * rule stops firing until the member accepts them again. False unless
-     * somebody turned it on.
-     */
-    explore_recipes: boolean;
-    /**
-     * The standing benchmark replayed on every run of this rule, beside the
-     * per-run comparison and never instead of it. Null is the ordinary state.
-     *
-     * Set with `setTrainingRuleBenchmark`, not by an update to the rule: it is a
-     * decision to replay a fixed set on every future run, and it has refusals of
-     * its own. It raises no amount, so it does not invalidate consent.
-     */
-    benchmark_id: string | null;
-    /**
-     * Whether that benchmark DECIDES the verdict, or only reports a number.
-     *
-     * False for every rule that has not asked, which is the point of it being
-     * separate from `benchmark_id`. Attaching a benchmark means "replay this
-     * fixed set on every run and put the score on the report"; it does not mean
-     * "let that score overrule the comparison this rule was built on".
-     *
-     * When it is on it cuts both ways. A run whose held-out split came up short
-     * can be decided at all -- before this, such a run trained a model, billed a
-     * GPU and could never promote -- and a candidate that wins on fresh
-     * conversations while losing ground on the fixed set is refused.
-     */
-    benchmark_decides: boolean;
-    /**
-     * How many of the benchmark's pinned conversations must have scored before
-     * it may decide anything. A replay that got through four of its forty has
-     * not measured the new model.
-     */
-    benchmark_min_rows: number;
-    /**
-     * The bar on the replay's own candidate-minus-incumbent delta. Like-for-like
-     * WITHIN one replay -- both models, same pinned rows, same frozen judge, one
-     * pass -- and not comparable between runs.
-     */
-    benchmark_min_delta: number;
-    auto_promote: boolean;
-    promote_margin: number;
-    promote_min_win_rate: number;
-    /** A gate, not a badge. */
-    min_judge_agreement: number;
-    review_window_hours: number;
-    candidate_boot_deadline_minutes: number;
-    keep_candidate_warm_minutes: number;
-    /** The member whose wallet pays, and the identity every peer call is stamped with. */
-    authorized_by: string;
-    terms_version: string;
-    revision: number;
-    /** Equal to revision only while the consent is current. */
-    accepted_revision: number;
-    accepted_at: string | null;
-    deleted_at: string | null;
-    created_at: string;
-    updated_at: string;
-}
-/** One append-only record of a member agreeing to spend, with the words they read. */
-export interface TrainingRuleConsent {
-    id: number;
-    rule_id: string;
-    workspace_id: string;
-    revision: number;
-    terms_version: string;
-    terms_text: string;
-    snapshot: Record<string, unknown>;
-    accepted_by: string;
-    accepted_via: ConsentVia;
-    accepted_at: string;
-}
-export interface TrainingRulePreflightRefusal {
-    stage: string;
-    code: string;
-    message: string;
-}
-/** One key that cannot follow a cutover, named so the caller can say which. */
-export interface TrainingRuleKeyRef {
-    key_id: string;
-    prefix: string;
-    name: string;
-}
-export interface TrainingRuleKeyCheck {
-    keys_missing_deployments_read: TrainingRuleKeyRef[];
-}
-/** The side-effect-free estimate, and the exact sentence the member will accept. */
-export interface TrainingRulePreflight {
-    valid: boolean;
-    model_revision: string;
-    worst_hourly_training_cents: number;
-    worst_hourly_candidate_cents: number;
-    max_training_hours: number;
-    max_candidate_hours: number;
-    /** Informational. The fence on evaluation is the dollar ceiling, never this. */
-    eval_calls_max: number;
-    training_ceiling_cents: number;
-    candidate_ceiling_cents: number;
-    eval_ceiling_cents: number;
-    warnings: string[];
-    refusals: TrainingRulePreflightRefusal[];
-    /**
-     * Every peer the platform could not reach on this pass, one entry each, in
-     * the same `{stage, code, message}` shape as a refusal.
-     *
-     * A warning, not a refusal: an unreachable peer judged nothing, so it never
-     * refuses a save. It is still why the rule cannot fire — both
-     * `worst_hourly_*` come back `0` — so `valid` is `false`. Key a "cannot
-     * save" state on this when `refusals` is empty; the same sentences are also
-     * in `warnings`, so render one or the other.
-     *
-     * Key it on THIS, not on `model_revision`. A degraded pass echoes back the
-     * `model_revision` the request carried rather than emptying it, so
-     * `if (!model_revision)` is false on exactly the passes it was meant to
-     * catch. Use `unreachable.length > 0`, or `/^[0-9a-f]{40}$/`.
-     */
-    unreachable: TrainingRulePreflightRefusal[];
-    key_check: TrainingRuleKeyCheck;
-    terms_text: string;
-    terms_version: string;
-    /**
-     * The machines the hourly amounts are per hour of: the ladders the platform
-     * chose when the request left them empty, or the caller's own echoed back
-     * unchanged. An amount per hour means nothing without knowing what it is per
-     * hour of, so show these beside the estimate before anyone accepts it.
-     */
-    train_gpu_priorities: TrainingGPURung[];
-    deploy_gpu_priorities: TrainingGPURung[];
-}
-export interface TrainingRuleBuildSpec {
-    method: string;
-    spec: Record<string, unknown>;
-}
-/**
- * The editable half of a build rule.
- *
- * Deliberately not `LoopBuildRuleParams`: that type requires `name` and
- * `method`, which the PUT route does not accept, so an edit written against it
- * would have to resend two fields the platform ignores and a caller could not
- * tell that changing them did nothing.
- */
-export interface LoopBuildRuleUpdateParams {
-    enabled?: boolean;
-    /** Rows reviewed SINCE THE LAST BUILD before this fires again. Minimum 100. */
-    min_new_rows?: number;
-    /** The same selection `createDataset` takes, replayed verbatim. */
-    spec?: LoopDatasetCreateParams;
-}
-/**
- * `?` means absent: leave that part of the sentence alone. `null` is only
- * allowed where the column is nullable and clearing it is a real edit, and it
- * is spelled out field by field rather than applied to the whole object.
- */
-export interface TrainingRuleTriggerInput {
-    cadence?: TrainingCadence;
-    cadence_hour_utc?: number;
-    /** null drops the weekday, which is what a weekly rule moved to daily needs. */
-    cadence_weekday?: number | null;
-    combinator?: TrainingCombinator;
-    /**
-     * Conversations reviewed since the last version before the rule fires on
-     * rows. At least 100. null removes the row floor, leaving the schedule as the
-     * only trigger.
-     */
-    min_new_rows?: number | null;
-    /** 1 to 10. Absent leaves it as it is; absent on a create means five. */
-    max_versions?: number;
-    /**
-     * See {@link TrainingRule.explore_recipes}: every variant it allows is a
-     * full paid run, so changing it -- on OR off -- is a money-bearing edit that
-     * pauses the rule, and it makes no version of any kind, until the new terms
-     * are accepted. Turning it off to save money stops the pipeline too, until
-     * somebody accepts again. It sits beside `max_versions`
-     * because both say when the pipeline makes another version. Absent leaves
-     * it as it is; absent on a create means off.
-     */
-    explore_recipes?: boolean;
-}
-export interface TrainingRuleTrainingInput {
-    model_id?: string;
-    model_revision?: string;
-    training_method?: LoopTrainingMethod;
-    /**
-     * A plain string, refused by the platform until capabilities enable
-     * preference training. null clears it, which is what moving a rule back to
-     * plain supervised training means.
-     */
-    rlhf_type?: string | null;
-    train_type?: RuleTrainType;
-    config?: Record<string, unknown>;
-    train_gpu_priorities?: TrainingGPURung[];
-    train_max_price_hour_cents?: number;
-}
-export interface TrainingRuleDeployInput {
-    deploy_gpu_priorities?: TrainingGPURung[];
-    deploy_max_price_hour_cents?: number;
-    context_length?: number;
-    quant?: string;
-    serving_config?: Record<string, unknown>;
-    hf_integration_id?: string;
-}
-export interface TrainingRuleMoneyInput {
-    training_ceiling_cents?: number;
-    candidate_ceiling_cents?: number;
-    eval_ceiling_cents?: number;
-    /** null removes the monthly cap. Absent leaves it exactly where it stands. */
-    monthly_ceiling_cents?: number | null;
-    /**
-     * The most held-back conversations one comparison scores, 10 to 500 and
-     * never below `min_holdout_rows`. Absent on a create means 100.
-     */
-    eval_max_rows?: number;
-}
-export interface TrainingRuleEvaluationInput {
-    /** null removes the judge from this rule. */
-    judge_id?: string | null;
-    /** null drops the override, returning to the judge's own advisory model. */
-    judge_model?: string | null;
-    graders_scope?: GradersScope;
-    /**
-     * The fewest held-back conversations that may decide a comparison. At least
-     * 20, and 20 when absent on a create. A set that would hold back fewer is
-     * not built.
-     */
-    min_holdout_rows?: number;
-    eval_max_tokens?: number;
-}
-export interface TrainingRulePromotionInput {
-    auto_promote?: boolean;
-    promote_margin?: number;
-    promote_min_win_rate?: number;
-    min_judge_agreement?: number;
-    review_window_hours?: number;
-    keep_candidate_warm_minutes?: number;
-}
-/**
- * The version of the terms the member read and accepted.
- *
- * Send back the `terms_version` the preflight returned. The SDK deliberately
- * ships no constant for it: a pinned version in a published package goes stale
- * the moment the platform revises the terms, and the value a member consented
- * to has to be the one they were actually shown.
- */
-export interface TrainingRuleAcceptTerms {
-    terms_version: string;
-}
-/** The create body without the yes. The preflight route takes exactly this. */
-export interface TrainingRulePreflightRequest {
-    workspace_id?: string;
-    name?: string;
-    /** Exactly one of build_rule_id and build is given. */
-    build_rule_id?: string;
-    build?: TrainingRuleBuildSpec;
-    trigger?: TrainingRuleTriggerInput;
-    serving?: TrainingRuleServing;
-    training?: TrainingRuleTrainingInput;
-    deploy?: TrainingRuleDeployInput;
-    money?: TrainingRuleMoneyInput;
-    evaluation?: TrainingRuleEvaluationInput;
-    promotion?: TrainingRulePromotionInput;
-    enabled?: boolean;
-}
-export interface TrainingRuleCreateRequest extends TrainingRulePreflightRequest {
-    /** Absent is a refusal, not a default. */
-    accept_terms?: TrainingRuleAcceptTerms;
-    /**
-     * The standing benchmark this rule replays, set here so it applies to the
-     * rule's FIRST run.
-     *
-     * A rule can fire within seconds of being created, and every step of a run
-     * reads the benchmark off the rule as it stood at that moment. Attaching one
-     * afterwards with `setTrainingRuleBenchmark` applies from the next run and
-     * says nothing about the first, which is the run somebody is watching.
-     *
-     * Refused on the same terms the attach route refuses it: `404` when it is not
-     * this workspace's, `409 BENCHMARK_RETIRED` when it has been retired. Use
-     * `setTrainingRuleBenchmark` to change or remove it later; it is not on the
-     * preflight body and not on the update body.
-     */
-    benchmark_id?: string;
-    /**
-     * And whether that benchmark decides, for the same reason `benchmark_id` is
-     * here: run 1 reads its gate off the snapshot it freezes, and a gate applied
-     * by a second call lands after run 1 has been decided without it.
-     *
-     * `400 BENCHMARK_GATE_HAS_NO_SET` when it is true with no benchmark,
-     * `400 BENCHMARK_GATE_NEEDS_MIN_ROWS` when it is true with no floor.
-     */
-    benchmark_decides?: boolean;
-    /** Cannot exceed the set's size: `400 BENCHMARK_GATE_UNREACHABLE`. */
-    benchmark_min_rows?: number;
-    /** Zero -- the default -- means "must not lose ground". */
-    benchmark_min_delta?: number;
-}
-export interface TrainingRuleUpdateRequest extends TrainingRulePreflightRequest {
-    expected_revision?: number;
-    accept_terms?: TrainingRuleAcceptTerms;
-}
-export interface TrainingRuleConsentRequest {
-    terms_version: string;
-    revision: number;
-}
-export interface TrainingRuleListParams {
-    enabled?: boolean;
-    limit?: number;
-    offset?: number;
-}
 export interface TrainingRunPromoteRequest {
     expected_revision?: number;
     /** Required to promote an inconclusive comparison. */
@@ -3706,12 +2938,23 @@ export interface TrainingRun {
     checkpoint_id: string | null;
     checkpoint_step: number | null;
     /**
-     * Which version of the pipeline this run produced. Null for a run that is
-     * not a version: one that failed, was cancelled, or whose comparison scored
-     * nothing, and that nobody put live. `seq` counts attempts; this counts
-     * models that competed, plus any a member promoted without a comparison.
+     * Which attempt of its pipeline this run is: 1, 2, 3 ... as runs are made.
+     * Null only for a run from before attempts were numbered that ended before
+     * it competed.
+     */
+    attempt_no: number | null;
+    /**
+     * Which version of the pipeline this run became. Set only when it was put
+     * live -- promoted by the pipeline's rule or by a member -- as the previous
+     * highest plus one; null for every attempt that did not become the live
+     * model. A rollback renumbers nothing.
      */
     version_no: number | null;
+    /** The base model this run trained, and that model's family. */
+    base_model_id: string | null;
+    model_family: string | null;
+    /** Machine time the run held (training job plus comparison machine); null until known. */
+    gpu_seconds: number | null;
     training_eval_loss: number | null;
     candidate_deployment_id: string | null;
     candidate_name: string | null;
@@ -3767,8 +3010,13 @@ export interface TrainingRunSummary {
     error_code: string | null;
     /** See TrainingRun.error_next_step. On the list row too: the Runs table is where a failure is first seen. */
     error_next_step: string | null;
+    /** See TrainingRun.attempt_no. */
+    attempt_no: number | null;
     /** See TrainingRun.version_no. */
     version_no: number | null;
+    /** See TrainingRun.base_model_id and model_family. */
+    base_model_id: string | null;
+    model_family: string | null;
     verdict: TrainingVerdict | null;
     decision: TrainingDecision | null;
     train_rows: number | null;
@@ -3835,15 +3083,6 @@ export interface EvaluationDimensionScore {
     candidate: number;
     delta: number;
 }
-export interface EvaluationGraderScore {
-    grader_id: string;
-    name: string;
-    incumbent: number;
-    candidate: number;
-    delta: number;
-    /** A grader that applied to four rows has not measured anything. */
-    items_applied: number;
-}
 export interface EvaluationWarning {
     code: EvaluationWarningCode;
     message: string;
@@ -3896,7 +3135,6 @@ export interface Evaluation {
     judge_instructions: string | null;
     judge_dimensions: EvaluationJudgeDimension[];
     judge_system_prompt: string | null;
-    grader_ids: string[];
     decoding: EvaluationDecoding;
     rows_selected: number;
     rows_scored: number;
@@ -3911,11 +3149,7 @@ export interface Evaluation {
     mean_delta: number | null;
     judge_incumbent_mean: number | null;
     judge_candidate_mean: number | null;
-    grader_incumbent_mean: number | null;
-    grader_candidate_mean: number | null;
-    grader_items_applied: number;
     per_dimension: EvaluationDimensionScore[];
-    per_grader: EvaluationGraderScore[];
     judge_agreement: JudgeAgreement | null;
     /** Informational: there is no incumbent counterpart to compare it against. */
     trainer_eval_loss: number | null;
@@ -3935,7 +3169,6 @@ export interface Evaluation {
 export interface EvaluationItemSide {
     completion: string | null;
     tool_calls: TrainingToolCall[] | null;
-    grader: Record<string, unknown> | null;
     judge: Record<string, unknown> | null;
     score: number | null;
     model_version: string | null;
@@ -3960,34 +3193,18 @@ export interface EvaluationItem {
     status: EvaluationItemStatus;
     error: string | null;
 }
+/**
+ * Which pairs to read: the ones the attempt won (`candidate`), the ones the
+ * version serving today won (`serving`; stored on the item as `incumbent`),
+ * or the ties.
+ */
+export type EvaluationItemWinnerFilter = 'candidate' | 'serving' | 'tie';
 export interface EvaluationItemListParams {
-    winner?: EvaluationWinner;
-    /** Capped at 100 by the service. */
+    winner?: EvaluationItemWinnerFilter;
+    /** 50 when absent; at most 200. */
     limit?: number;
     offset?: number;
 }
-export interface JudgeAgreementParams {
-    /** RFC 3339. Narrows the window the agreement is computed over. */
-    from?: string;
-    to?: string;
-}
-/** Which model, whose words, how much. The cap is pushed to the workspace key. */
-export interface AgentSettings {
-    workspace_id: string;
-    default_model: string | null;
-    judge_system_prompt: string | null;
-    sampler_system_prompt: string | null;
-    eval_monthly_cap_cents: number | null;
-    updated_by: string | null;
-    updated_at: string;
-}
-/** Absent leaves a setting alone; a present null returns it to the platform default. */
-export interface AgentSettingsRequest {
-    default_model?: string | null;
-    judge_system_prompt?: string | null;
-    sampler_system_prompt?: string | null;
-    eval_monthly_cap_cents?: number | null;
-}
 /** A re-pointable public handle. Promotion is one row write here. */
 export interface InferenceAlias {
     workspace_id: string;
@@ -4012,8 +3229,11 @@ export interface InferenceAliasRequest {
  * after it, and a delete throws the series away.
  */
 export type BenchmarkStatus = 'active' | 'retired';
-/** Where the pinned conversations are copied from. Read once, at creation. */
-export type BenchmarkSourceKind = 'traces' | 'dataset';
+/**
+ * Where the pinned conversations are copied from. Read once, at creation.
+ * Always `traces`: the conversations named in `trace_ids`.
+ */
+export type BenchmarkSourceKind = 'traces';
 /**
  * The life of one replay.
  *
@@ -4139,7 +3359,12 @@ export interface BenchmarkRun {
 export interface BenchmarkHistoryPoint {
     benchmark_run_id: string;
     run_id: string;
+    /** Counts every run in the workspace; label points with attempt_no and version. */
     run_seq: number;
+    /** The attempt of its pipeline this point measured. */
+    attempt_no: number | null;
+    /** The version that attempt became; null when it did not become one. */
+    version: number | null;
     rule_id: string | null;
     rule_name: string | null;
     created_at: string;
@@ -4151,12 +3376,15 @@ export interface BenchmarkHistoryPoint {
     status: BenchmarkRunStatus;
     status_reason: string | null;
 }
-/** Where the conversations are copied FROM. Read once, at creation, never again. */
+/**
+ * Where the conversations are copied FROM. Read once, at creation, never again.
+ * A benchmark pins conversations by id; to make one from a file, import it
+ * (`importRows`, with no tag, so it never trains a pipeline) and pin the
+ * `trace_ids` the import returns.
+ */
 export interface BenchmarkSource {
     kind: BenchmarkSourceKind;
-    trace_ids?: string[];
-    dataset_id?: string;
-    split?: string;
+    trace_ids: string[];
 }
 /**
  * The pin: 20 to 200 conversations, and a judge with a rubric to measure them.
@@ -4165,15 +3393,16 @@ export interface BenchmarkSource {
  * Pinning 47 of the 50 somebody chose is the set being wrong from the first
  * day, and they would never find out.
  */
+/**
+ * A name and the conversations, nothing else. The platform freezes the judge
+ * and the model it scores on, gives both models the comparison's own answer
+ * length, and sets what one replay may spend; none of that is sent (the
+ * service refuses `judge_id`, `judge_model`, `max_tokens` and
+ * `per_run_ceiling_cents` by name).
+ */
 export interface BenchmarkCreateParams {
     name: string;
-    judge_id: string;
     source: BenchmarkSource;
-    /** Absent uses the judge's own model, and absent that the workspace default. */
-    judge_model?: string;
-    /** What both models are given to answer in. A shorter answer is a different answer. */
-    max_tokens?: number;
-    per_run_ceiling_cents: number;
 }
 export interface BenchmarkListParams {
     status?: BenchmarkStatus;
@@ -4181,11 +3410,12 @@ export interface BenchmarkListParams {
     offset?: number;
 }
 export interface BenchmarkItemListParams {
-    /** Capped at 100 by the service. */
+    /** 50 when absent; at most 200. */
     limit?: number;
     offset?: number;
 }
 export interface BenchmarkHistoryParams {
+    /** 50 when absent; at most 200. */
     limit?: number;
     offset?: number;
 }
@@ -4194,77 +3424,96 @@ export interface BenchmarkRetireParams {
     reason?: string;
 }
 /**
- * Attach a benchmark to a rule, detach it with a present null, or move the bar
- * it decides on.
- *
- * ABSENT IS "LEAVE IT", PRESENT IS "MAKE IT THIS", and that applies to every
- * field here. This is the route that attaches a benchmark AND the route that
- * moves its bar a month later, so a call naming only `benchmark_id` must not
- * reset a floor somebody chose, and a call naming only `benchmark_min_delta`
- * must not detach the set.
- *
- * Detaching is the one exception: a present null `benchmark_id` clears
- * `benchmark_decides` with it, because a gate with nothing behind it is a
- * verdict waiting on a measurement that will never come. Asking for both in
- * one request -- null id and `benchmark_decides: true` -- is refused rather
- * than resolved, because either resolution is a guess about which half you
- * meant.
- */
-export interface TrainingRuleBenchmarkRequest {
-    benchmark_id?: string | null;
-    benchmark_decides?: boolean;
-    benchmark_min_rows?: number;
-    benchmark_min_delta?: number;
-}
-/**
- * The machine codes `runTrainingRule` can be refused with. Each is the
- * platform declining to start a paid run it would only refuse a minute later,
- * so each is said in front of the caller rather than left for the rule's
- * `last_reason` to explain after they have stopped looking.
+ * The machine codes `runPipeline` (train now) can be refused with: every one
+ * the run route answers (the SDK's tests read them off the service). Each is
+ * the platform declining to start a paid attempt it would only refuse a minute
+ * later, so each is said in front of the caller.
  *
- * - `CONSENT_REQUIRED` (409): the terms changed and nobody accepted them.
- * - `RULE_PAUSED` (409): the rule is switched off or the platform stopped it.
- * - `RUN_ACTIVE` (409): one run at a time, so two cannot race to promote.
+ * - `NOT_ENOUGH_SAMPLES` (422): fewer samples than the next attempt needs.
+ *   The body carries `have` and `need`. Train now skips the schedule, never
+ *   the minimum.
+ * - `PIPELINE_NEEDS_SAVE` (409): the pipeline's settings changed without a
+ *   pipeline save since; save them (saving is the authorization) and train
+ *   again.
+ * - `RULE_PAUSED` (409): the pipeline is switched off or the platform paused
+ *   it (`paused_reason` says why).
+ * - `RUN_ACTIVE` (409): one attempt at a time, so two cannot race to promote.
  * - `VERSION_LIMIT_REACHED` (409): the pipeline has made `max_versions`
- *   versions. Raise the limit or start a new pipeline.
- * - `MONTHLY_LIMIT_REACHED` (409): the most this month's runs can have cost
- *   plus the most one more run may cost would pass `monthly_ceiling_cents`.
- *   The body carries the figures:
+ *   versions. Raise the limit or remove it.
+ * - `MONTHLY_LIMIT_REACHED` (409): the most this month's attempts can have
+ *   cost plus the most one more may cost would pass the pipeline's internal
+ *   monthly limit. The body carries the figures:
  *   see {@link TrainingRuleMonthlyLimitRefusal}.
- * - `AGENT_OFF` (409): the workspace's Conscious Loop agent is not turned on.
- *   Every comparison runs under the agent's key, so a run started without one
- *   would pay for training and could not be compared. Turn it on in Agent
- *   settings, then run the rule.
- * - `NOT_ENOUGH_ROWS` (422): too few reviewed or held-out conversations, with
- *   `train_rows`, `holdout_rows` and the `floor` it needed.
- */
-export type TrainingRuleRunRefusalCode = 'CONSENT_REQUIRED' | 'RULE_PAUSED' | 'RUN_ACTIVE' | 'VERSION_LIMIT_REACHED' | 'MONTHLY_LIMIT_REACHED' | 'AGENT_OFF' | 'NOT_ENOUGH_ROWS';
-/**
- * The machine codes a SAVE of a training rule is refused with when the
- * preflight it runs refuses: `createTrainingRule`, an `updateTrainingRule`
- * that switches a rule on or into preference training or carries
- * `accept_terms`, and `consentTrainingRule`. Every other preflight refusal is
- * a `400` carrying the peer's own sentence; `preflightTrainingRule` answers
- * `200` with the same codes in `refusals`.
+ * - `SCORING_CAPPED` (409): the key the comparison runs under is at its
+ *   monthly cap, so what this attempt trained could not be scored. The body
+ *   carries `resumes_at`, when the cap lifts (the next UTC month, or sooner
+ *   if the key's cap is raised).
+ * - `AGENT_COULD_NOT_START` (503): the key every comparison is scored with is
+ *   missing or was refused, and train now could not renew it just then.
+ *   Nothing was started. Press train now again in a minute.
+ * - `AGENT_OFF` (409): scoring could not run: that key was still unusable
+ *   after train now renewed it, so no attempt was started. Press train now
+ *   again in a minute. Nothing in the pipeline's settings causes it, so
+ *   saving the pipeline does not clear it.
  *
- * - `TRAINING_NOT_ENABLED` (409): training is in beta and this organisation
- *   does not hold the grant. Nothing is saved and nothing in the request can
- *   lift it, so do not retry: ask the platform team to enable training for
- *   the organisation. It is answered ahead of every other refusal. A rule that
- *   meets it at fire time is paused `training_not_enabled` instead (see
- *   {@link TrainingRulePausedReason}).
- * - `METHOD_NOT_ENABLED` (422): a training method the platform has not enabled.
- * - `CEILING_TOO_LOW` (422): a ceiling cannot buy the minimum hours at the
- *   accepted price cap.
+ * Only the last two clear on their own within a minute, and
+ * `MONTHLY_LIMIT_REACHED` and `SCORING_CAPPED` once their date has passed;
+ * retrying any other one unchanged gets the same answer.
  */
-export type TrainingRuleSaveRefusalCode = 'TRAINING_NOT_ENABLED' | 'METHOD_NOT_ENABLED' | 'CEILING_TOO_LOW';
+export type TrainingRuleRunRefusalCode = 'NOT_ENOUGH_SAMPLES' | 'PIPELINE_NEEDS_SAVE' | 'RULE_PAUSED' | 'RUN_ACTIVE' | 'VERSION_LIMIT_REACHED' | 'MONTHLY_LIMIT_REACHED' | 'SCORING_CAPPED' | 'AGENT_COULD_NOT_START' | 'AGENT_OFF';
 /**
- * The machine codes `deleteDataset` can be refused with.
+ * The machine codes saving a pipeline (`createPipeline` or `updatePipeline`)
+ * can be refused with: every one the two routes answer beyond a malformed
+ * body (400, which names the field). The SDK's tests read them off the
+ * service. Nothing is saved when any of them is answered.
  *
- * - `DATASET_IN_USE` (409): a training run was trained on this set, so it is
- *   kept as the record of what that run learned from.
+ * The name and tags:
+ * - `PIPELINE_NAME_TAKEN` (409): another pipeline in the workspace has the
+ *   name, a deleted one included. Choose another name.
+ * - `OWN_TAG_TAKEN` (409): another pipeline already owns the tag this name
+ *   makes. Choose another name.
+ *
+ * An edit only:
+ * - `REVISION_MISMATCH` (409): `expected_revision` is not the pipeline's
+ *   revision any more. Read it again and resend.
+ * - `RUN_ACTIVE` (409): the model cannot change while an attempt is running.
+ * - `NOT_A_SIMPLE_PIPELINE` (409): a tag, use case or challenger edit on a
+ *   pipeline created before pipelines had them; its other settings can
+ *   still change.
+ *
+ * The model and when to train:
+ * - `MODEL_NOT_TRAINABLE` (422): `model.id` or `challenger_model.id` is not a
+ *   model `listModels` offers, or the challenger is the model itself.
+ * - `MIN_SAMPLES_TOO_LOW` (422): `train_when.min_samples` is under the floor
+ *   `listModels` returns as `floors.new_samples`.
+ * - `NO_GPU_FITS` (422): no machines can train or serve the model right now.
+ * - `MODEL_REVISION_UNAVAILABLE` (422): the model could not be pinned to an
+ *   exact revision because the training service did not answer. Try again
+ *   once it does.
+ * - `NO_JUDGE_MODEL` (422): no model the workspace can call is able to score
+ *   the attempts, so none could ever be measured.
+ * - `PROMOTION_POLICY_UNKNOWN`, `PROMOTION_K_REQUIRED`,
+ *   `PROMOTION_K_UNREACHABLE`, `PROMOTION_POLICY_NEEDS_BENCHMARK` (422): the
+ *   promotion policy is not one of the six, `k_of_n` came without `k`, `k`
+ *   is more than the measurements the pipeline takes, or the policy needs a
+ *   benchmark the pipeline does not have yet.
+ *
+ * The platform:
+ * - `TRAINING_NOT_ENABLED` (409): training is in beta and this organisation
+ *   does not hold the grant. Nothing in the request can lift it, so do not
+ *   retry: ask the platform team to enable training for the organisation. A
+ *   pipeline that meets it at fire time is paused `training_not_enabled`
+ *   instead (see {@link TrainingRulePausedReason}).
+ * - `METHOD_NOT_ENABLED` (422): the platform has switched off the training
+ *   method pipelines train with.
+ * - `CEILING_TOO_LOW` (422): the platform's own runaway limits cannot cover
+ *   the machines it chose for the model. Nothing in the request sets them.
+ * - `MODELS_UNAVAILABLE`, `GPU_OPTIONS_UNAVAILABLE`, `AGENT_COULD_NOT_START`
+ *   (503): a service the save needs (the model list, the machine list, or
+ *   the key every comparison is scored with) did not answer just then. Try
+ *   again in a minute.
  */
-export type LoopDatasetDeleteRefusalCode = 'DATASET_IN_USE';
+export type TrainingRuleSaveRefusalCode = 'PIPELINE_NAME_TAKEN' | 'OWN_TAG_TAKEN' | 'REVISION_MISMATCH' | 'RUN_ACTIVE' | 'NOT_A_SIMPLE_PIPELINE' | 'MODEL_NOT_TRAINABLE' | 'MIN_SAMPLES_TOO_LOW' | 'NO_GPU_FITS' | 'MODEL_REVISION_UNAVAILABLE' | 'NO_JUDGE_MODEL' | 'PROMOTION_POLICY_UNKNOWN' | 'PROMOTION_K_REQUIRED' | 'PROMOTION_K_UNREACHABLE' | 'PROMOTION_POLICY_NEEDS_BENCHMARK' | 'TRAINING_NOT_ENABLED' | 'METHOD_NOT_ENABLED' | 'CEILING_TOO_LOW' | 'MODELS_UNAVAILABLE' | 'GPU_OPTIONS_UNAVAILABLE' | 'AGENT_COULD_NOT_START';
 /**
  * The body of a manual run refused `409 MONTHLY_LIMIT_REACHED`, as
  * `ApiError.body` carries it.
@@ -4293,7 +3542,7 @@ export interface TrainingRuleMonthlyLimitRefusal {
     resumes_at: string;
 }
 /** The most versions a pipeline may be set to make (loop-service maxVersionsCeiling). */
-export declare const PIPELINE_MAX_VERSIONS_CEILING = 10;
+export declare const PIPELINE_MAX_VERSIONS_CEILING = 100;
 /**
  * What a pipeline is doing. `needs_review` and `needs_funds` are a finished
  * version waiting on the MEMBER -- a decision, or a top-up -- which is not the
@@ -4305,18 +3554,29 @@ export declare const PIPELINE_MAX_VERSIONS_CEILING = 10;
  */
 export type PipelineStatus = 'running' | 'needs_review' | 'needs_funds' | 'waiting' | 'paused' | 'complete';
 /**
- * The run in flight. It is not a version until its comparison is reported
- * having scored at least one conversation, or a member puts it live.
+ * The attempt in flight. It is not a version until it is put live -- by the
+ * pipeline's promotion rule or by a member.
  */
 export interface PipelineActiveRun {
     run_id: string;
+    /** Its attempt number within the pipeline. */
+    attempt: number | null;
+    /** Why it was made; see {@link PipelineAttempt.trigger}. */
+    trigger: PipelineAttemptTrigger;
+    /** The base model it trains, and that model's family. */
+    base_model_id: string | null;
+    model_family: string | null;
     state: TrainingRunState;
     since: string;
-    /**
-     * The version number it will take if it becomes one: if its comparison
-     * scores something, or if a member promotes it anyway.
-     */
+    /** When the attempt was made. */
+    started_at: string;
+    /** Machine time it has held so far; null until known. */
+    gpu_seconds: number | null;
+    /** What it has been billed so far, in cents. */
+    cost_cents: number;
+    /** The version number it will take if it is put live. */
     will_be_version: number;
+    /** Always null: nothing in flight is a version yet. */
     version_no: number | null;
     last_reason: string | null;
     last_error: string | null;
@@ -4332,20 +3592,29 @@ export interface PipelineActiveRun {
     recipe_note: string | null;
 }
 /**
- * One version: a trained model whose comparison scored at least one
- * conversation, or one a member put live without one. The second kind has
- * `rows_scored` 0 and `win_rate` null, and may be the champion.
+ * One version: an attempt that was put live -- promoted by the pipeline's
+ * rule or by a member. Only winners are versions, numbered v1, v2, ... in the
+ * order they went live; numbers only go up and a rollback renumbers nothing.
  */
 export interface PipelineVersion {
     version: number;
     run_id: string;
+    /** The attempt that became this version. */
+    attempt: number | null;
+    /** The base model it was trained from, and that model's family. */
+    base_model_id: string | null;
+    model_family: string | null;
     seq: number;
     state: TrainingRunState;
     verdict: TrainingVerdict | null;
     decision: TrainingDecision | null;
     decided_at: string | null;
+    /** True for the version the app is served by today (the same as `is_champion`). */
+    is_live: boolean;
     /** True for the version the app is served by today. */
     is_champion: boolean;
+    /** When it was first put live. */
+    promoted_at: string | null;
     checkpoint_id: string | null;
     train_rows: number | null;
     holdout_rows: number | null;
@@ -4379,6 +3648,8 @@ export interface PipelineVersion {
      * not what it did.
      */
     cost_includes_candidate_ceiling: boolean;
+    /** Machine time the attempt held (training and comparison); null when unknown. */
+    gpu_seconds: number | null;
     created_at: string;
     /**
      * When this version's head-to-head started. The champion it faced is the
@@ -4403,42 +3674,129 @@ export interface PipelineVersion {
     finished_at: string | null;
 }
 /**
- * A training rule seen as the series of versions it produces: which exist,
- * which one serves, whether each beat the one before it, and what happens
- * next. READ-ONLY: every decision stays on the route that owns it (promote,
- * reject and roll back on the run; the version limit on the rule).
+ * A pipeline: one use case, and the series of versions it produces -- which
+ * exist, which one serves, whether each beat the one before it, and what
+ * happens next. READ-ONLY: every decision stays on the route that owns it
+ * (promote, reject and roll back on the attempt; the version limit is set by
+ * editing the pipeline).
  */
 /**
- * Whether a pipeline can make a recipe variant next, and when it cannot, which
- * reason -- each is a different next step.
- *
- * - `off`: explore_recipes is off.
- * - `waiting_for_v1`: on, but a variant varies a version and there is none yet.
- * - `available`: on, with `recipe_variants_left` untried variants that fit.
- * - `no_slots`: untried variants fit (`recipe_variants_left` > 0), but every
- *   version slot is made or taken by the run in flight. Raise `max_versions`
- *   (or, at 10, start a new pipeline) and one can run. Only when variants are
- *   left: a service that reports `no_slots` with `recipe_variants_left` of 0
- *   means `all_tried`, and raising the limit starts nothing.
- * - `all_tried`: every variant that fits has been tried on the conversations
- *   it has now, whether or not a version slot is free. Raising `max_versions`
- *   does not start one; new reviews bring the next version.
- * - `none_fit`: no variant fits this rule's training settings.
+ * Why an attempt was made: new data (`data`, a recipe variant included), the
+ * schedule (`schedule`), a member's train-now (`manual`), or the challenger
+ * model trained on the same data as the attempt before it (`challenger`).
+ */
+export type PipelineAttemptTrigger = 'data' | 'schedule' | 'manual' | 'challenger';
+/** What became of an attempt. */
+export type PipelineAttemptOutcome = 'became_version' | 'not_better' | 'inconclusive' | 'stopped' | 'failed' | 'running' | 'waiting_for_review';
+/** One attempt: every training run a pipeline makes, winner or not. */
+export interface PipelineAttempt {
+    attempt: number;
+    run_id: string;
+    state: TrainingRunState;
+    trigger: PipelineAttemptTrigger;
+    base_model_id: string | null;
+    model_family: string | null;
+    outcome: PipelineAttemptOutcome;
+    /** The version it became, when it became one. */
+    version: number | null;
+    created_at: string;
+    finished_at: string | null;
+    gpu_seconds: number | null;
+    /** As the versions are priced once it has ended; as recorded so far while it runs. */
+    cost_cents: number;
+    verdict: TrainingVerdict | null;
+    win_rate: number | null;
+    evaluation_id: string | null;
+    /** Its last sentence. */
+    reason: string | null;
+}
+/** A model and the exact commit of it. */
+export interface PipelineModelRef {
+    id: string;
+    revision: string;
+}
+/**
+ * When a new version takes over. `holdout` (the default) when it wins on the
+ * held-back set; `all`, `primary`, `k_of_n` (with `k`) and `weighted` also
+ * weigh the pipeline's benchmarks; `manual` never on its own.
+ */
+export interface PipelinePromotion {
+    policy: 'holdout' | 'all' | 'primary' | 'k_of_n' | 'weighted' | 'manual';
+    k: number | null;
+}
+/** A pipeline's schedule, UTC: every day at an hour, or every week on a weekday at an hour. */
+export interface PipelineSchedule {
+    every: 'day' | 'week';
+    /** 0 (Sunday) to 6, for `week`; null for `day`. */
+    weekday: number | null;
+    hour_utc: number;
+}
+/**
+ * When a pipeline trains: at least `min_samples` new samples AND, when there
+ * is one, at its scheduled slot. A null schedule trains as soon as the minimum
+ * is met.
+ */
+export interface PipelineTrainWhen {
+    min_samples: number;
+    schedule: PipelineSchedule | null;
+}
+/** What is held back beyond max(50, 5% of the data): a larger percent, or a count. */
+export interface PipelineHoldout {
+    percent: number;
+    count: number | null;
+    min_rows: number;
+}
+/**
+ * How far the data is from the next version. `first_version`: `needed` usable
+ * rows v1 trains on. `new_rows`: `needed` usable rows the last version's set
+ * did not have. `have`, `short` and `message` are measured on the detail only.
  */
-export type PipelineRecipeExploration = 'off' | 'waiting_for_v1' | 'available' | 'no_slots' | 'all_tried' | 'none_fit';
+export interface PipelineMinimums {
+    basis: 'first_version' | 'new_rows';
+    needed: number;
+    have: number | null;
+    short: number | null;
+    message: string | null;
+}
 export interface Pipeline {
     rule_id: string;
     rule_name: string;
     enabled: boolean;
-    /** The limit the member set, 1 to 10. */
-    max_versions: number;
+    /** The settings revision an edit sends back as `expected_revision`. */
+    revision: number;
+    /** The limit the member set, 1 to 100, or null for none. */
+    max_versions: number | null;
     /** Versions made so far. At `max_versions` the pipeline stops. */
     versions_made: number;
+    /** What the pipeline is for, in the member's words. Empty on a pipeline created before pipelines had a use case. */
+    use_case: string;
+    /** The tag imports into this pipeline are given. Null on a pipeline created before pipelines had a tag of their own. */
+    own_tag: string | null;
+    /** A conversation carrying ANY of these tags is this pipeline's data. */
+    tags: string[];
+    /**
+     * A second base model trained on the same data after each attempt; it
+     * becomes the next version only if it beats the live one. `revision` is the
+     * commit the server pinned.
+     */
+    challenger_model: PipelineModelRef | null;
+    /** `sft` today; `kto`, `dpo` and `grpo` cannot be chosen yet. */
+    training_type: string;
+    /** How each version starts: `fresh`, a new adapter over the pinned base trained on all accepted data. */
+    version_base: string;
+    train_when: PipelineTrainWhen;
+    promotion: PipelinePromotion;
+    holdout: PipelineHoldout;
+    /** Rows the next version holds back and never trains on. Detail only; null on the list. */
+    holdout_size: number | null;
+    minimums: PipelineMinimums;
     /** The pinned base every version is a fresh adapter over, which is what makes their scores comparable. */
     base_model_id: string;
     base_model_revision: string;
     train_type: string;
-    /** Null when what serves is not a version of this pipeline. */
+    /** The version serving now; null when what serves is not a version of this pipeline. */
+    live_version: number | null;
+    /** The same number under its older name. */
     champion_version: number | null;
     /** The name the app calls. It does not change when a version is promoted. */
     serving_name: string;
@@ -4469,17 +3827,6 @@ export interface Pipeline {
      * until somebody does.
      */
     needs_consent: boolean;
-    /** The rule's explore_recipes, as it stands. */
-    explore_recipes: boolean;
-    /**
-     * How many recipe variants that fit this rule's settings have not yet been
-     * tried on the conversations the pipeline has now. Not capped by the free
-     * version slots; 0 while exploration is off or when no variant fits. A count
-     * is not a reason: read `recipe_exploration` for whether one can run next.
-     */
-    recipe_variants_left: number;
-    /** Whether the next recipe variant can be tried, and if not, why. */
-    recipe_exploration: PipelineRecipeExploration;
     /** The rule's monthly limit. Null means it has none. */
     monthly_ceiling_cents: number | null;
     /**
@@ -4496,24 +3843,10 @@ export interface Pipeline {
      */
     month_spent_cents: number;
     active_run: PipelineActiveRun | null;
+    /** Winners only, v1 first. */
     versions: PipelineVersion[];
-}
-export interface TrainingRuleListResponse {
-    rules: TrainingRule[];
-    total: number;
-}
-export interface TrainingRuleResponse {
-    rule: TrainingRule;
-    recent_runs: TrainingRunSummary[];
-    /** What this rule's runs have cost at most this UTC calendar month; see {@link Pipeline.month_spent_cents}. */
-    month_spent_cents: number;
-    judge_agreement: JudgeAgreement | null;
-}
-export interface TrainingRuleMutationResponse {
-    rule: TrainingRule;
-    /** The rule will not fire again until someone confirms the new amounts. */
-    consent_required: boolean;
-    preflight: TrainingRulePreflight | null;
+    /** Every attempt, attempt 1 first. */
+    attempts: PipelineAttempt[];
 }
 export interface TrainingRuleDeleteResponse {
     deleted: boolean;
@@ -4552,9 +3885,6 @@ export interface EvaluationItemsResponse {
     items: EvaluationItem[];
     total: number;
 }
-export interface AgentSettingsResponse {
-    settings: AgentSettings;
-}
 export interface InferenceAliasListResponse {
     aliases: InferenceAlias[];
 }
@@ -4578,14 +3908,234 @@ export interface BenchmarkHistoryResponse {
     points: BenchmarkHistoryPoint[];
     total: number;
 }
+export interface PipelineListParams {
+    /** How many of the newest pipelines to skip: the page after one that started at N starts at N + its length. */
+    offset?: number;
+}
 export interface PipelineListResponse {
     /** The newest pipelines first, at most the service's page (100). */
     pipelines: Pipeline[];
     /** Every pipeline in the workspace, including any not returned. */
     total: number;
-    /** More pipelines exist than were returned; the rest are reached through `listTrainingRules`. */
+    /** More pipelines exist after this page. */
     truncated: boolean;
 }
 export interface PipelineResponse {
     pipeline: Pipeline;
 }
+/**
+ * The body of `POST /api/loop/pipelines` and (every field optional)
+ * `PUT /api/loop/pipelines/{id}`. Everything else -- the machines, the money,
+ * the adapter, the held-back set, the consent -- the platform decides; a field
+ * not listed here is refused by name. See the loop-service README, "Simple
+ * pipelines".
+ */
+export interface PipelineWriteRequest {
+    workspace_id?: string;
+    /** Required on a create. The pipeline's own tag is this name made into a tag. */
+    name?: string;
+    use_case?: string;
+    /** A model from {@link LoopModel}, by id. The server pins its revision. */
+    model?: {
+        id: string;
+    };
+    /** A second model to train on the same data; null removes it. */
+    challenger_model?: {
+        id: string;
+    } | null;
+    /** More tags whose conversations the pipeline trains on. On an edit the list replaces the old one. */
+    tags?: string[];
+    /** At least `min_samples` new samples (250 and up for SFT) AND, when set, the schedule. */
+    train_when?: {
+        min_samples?: number;
+        schedule?: {
+            every: 'day' | 'week';
+            weekday?: number;
+            hour_utc: number;
+        } | null;
+    };
+    promotion?: {
+        policy: PipelinePromotion['policy'];
+        k?: number;
+    };
+    /** 1 to 100, or null for no limit (the default). Counts versions, not attempts. */
+    max_versions?: number | null;
+    enabled?: boolean;
+    /** An edit's compare-and-set. */
+    expected_revision?: number;
+}
+/** What a pipeline create, edit or train-now answers. */
+export interface PipelineMutationResponse {
+    pipeline: Pipeline;
+}
+/** One base model a pipeline can train (`GET /api/loop/models`). */
+export interface LoopModel {
+    /** The repository id a pipeline body names in `model.id`. */
+    id: string;
+    name: string;
+    author: string;
+    family: string;
+    /** Total parameters, in billions. */
+    params_b: number;
+    /** Verified end to end on the platform for training and serving. */
+    recommended: boolean;
+}
+/** The floors a new pipeline is held to, in samples (`GET /api/loop/models`). */
+export interface PipelineFloors {
+    /** Samples a new pipeline's first attempt needs: training rows plus the held-back set. */
+    first_version_samples: number;
+    /** `train_when.min_samples`' default and floor. */
+    new_samples: number;
+}
+export interface LoopModelsResponse {
+    models: LoopModel[];
+    floors: PipelineFloors;
+}
+/** The promotion rule as the API reads it back. */
+export interface PromotionPolicyState {
+    policy: string;
+    /** Under k_of_n, how many measurements must improve; null otherwise. */
+    k: number | null;
+    updated_at: string | null;
+    updated_by: string | null;
+}
+/** One benchmark on a pipeline's list, attached now or once. */
+export interface RuleBenchmark {
+    benchmark_id: string;
+    name: string;
+    benchmark_status: string;
+    item_count: number;
+    items_digest: string;
+    /** False for a benchmark this pipeline stopped using; its history stays. */
+    attached: boolean;
+    /** 1 is the primary; null once removed. */
+    priority: number | null;
+    primary: boolean;
+    added_at: string;
+    added_by: string | null;
+    removed_at: string | null;
+    removed_by: string | null;
+}
+/** What every `/api/loop/pipelines/{id}/benchmarks` route answers. */
+export interface PipelineBenchmarksResponse {
+    rule_id: string;
+    promotion_policy: PromotionPolicyState;
+    /** Attached ones in priority order, then removed ones, newest first. */
+    benchmarks: RuleBenchmark[];
+}
+/** `POST /api/loop/pipelines/{id}/benchmarks`. */
+export interface PipelineBenchmarkAttachParams {
+    benchmark_id: string;
+    /** Where it goes on the list, 1 first. Absent puts it last. */
+    priority?: number;
+}
+/** `PUT /api/loop/pipelines/{id}/benchmarks/{benchmark_id}`. */
+export interface PipelineBenchmarkMoveParams {
+    /** 1 makes it the primary. */
+    priority: number;
+}
+/** A benchmark any version of this pipeline was, or is now, measured on. */
+export interface CompareBenchmark {
+    benchmark_id: string;
+    name: string;
+    benchmark_status: string;
+    items_digest: string;
+    attached: boolean;
+    priority: number | null;
+    added_at: string | null;
+    removed_at: string | null;
+}
+/** One version on one benchmark. `why` says why there is no score. */
+export interface VersionBenchmarkScore {
+    benchmark_id: string;
+    /** `scored`, `no_score`, or `not_measured` (the benchmark was added after this version). */
+    state: string;
+    benchmark_run_id: string | null;
+    replay_status: string | null;
+    candidate_score: number | null;
+    incumbent_score: number | null;
+    score_delta: number | null;
+    rows_scored: number | null;
+    rows_total: number | null;
+    items_digest: string | null;
+    comparable: boolean;
+    why: string | null;
+}
+/** One measurement a promotion rule weighed. */
+export interface PromotionMeasurement {
+    kind: string;
+    benchmark_id: string | null;
+    benchmark_name: string | null;
+    benchmark_run_id: string | null;
+    items_digest: string | null;
+    priority: number | null;
+    weight: number;
+    delta: number | null;
+    outcome: string;
+    reason: string;
+}
+/** What a version's promotion rule decided, and on which numbers. */
+export interface PromotionOutcome {
+    policy: string;
+    k: number | null;
+    verdict: string;
+    decided_by: string;
+    reason: string;
+    auto_promote_allowed: boolean;
+    weighted_delta: number | null;
+    measurements: PromotionMeasurement[];
+}
+/** One version with every measurement it has. */
+export interface VersionScores {
+    version: number;
+    run_id: string;
+    /** The attempt that became this version, and the base model it trained. */
+    attempt: number | null;
+    base_model_id: string | null;
+    model_family: string | null;
+    state: string;
+    verdict: string | null;
+    decision: string | null;
+    compared_at: string | null;
+    holdout: {
+        rows_scored: number | null;
+        win_rate: number | null;
+        mean_delta: number | null;
+    };
+    /** One entry per entry of the response's `benchmarks`, in the same order. */
+    benchmarks: VersionBenchmarkScore[];
+    promotion: PromotionOutcome | null;
+}
+/** Version b against version a on one benchmark. `delta` is b minus a. */
+export interface VersionScoreDifference {
+    benchmark_id: string;
+    a_score: number | null;
+    b_score: number | null;
+    delta: number | null;
+    comparable: boolean;
+    why: string | null;
+}
+/** `GET /api/loop/pipelines/{id}/versions/compare`. */
+export interface VersionCompareResponse {
+    rule_id: string;
+    promotion_policy: PromotionPolicyState;
+    benchmarks: CompareBenchmark[];
+    versions: VersionScores[];
+    a: number | null;
+    b: number | null;
+    differences: VersionScoreDifference[];
+}
+/** Which two versions to set side by side, by VERSION number (v1 is 1). */
+export interface VersionCompareParams {
+    a?: number;
+    b?: number;
+}
+/**
+ * `POST /api/loop/pipelines/{id}/import`: the import body, `source` optional.
+ * `default_feedback: 'good'` records every answered row without a verdict of
+ * its own as a good example to learn from.
+ */
+export type PipelineImportParams = Omit<LoopImportParams, 'source'> & {
+    source?: string;
+    default_feedback?: 'good';
+};