@evolvingmachines/evolve 0.0.65 → 0.0.67-train-harness-wave-2026-09-25.20260926.e00a8a6d

package/spec/openapi.yaml

@@ -101,9 +101,9 @@ info:
       directory and runs it as a new local Harbor job
       (their src/harbor/analyze/analyzer.py `run_analyze`). Here analysis is
       a NATIVE capability of the platform — the worker runs the same
-      analyzer (claude-code over the trial's Harbor-shape tree plus its
-      task, rubric-driven, `analysis.json` validated criterion-for-
-      criterion) server-side, and the result is stored and served on the
+      analyzer (the chosen agent, claude-code by default, over the trial's
+      Harbor-shape tree plus its task, rubric-driven, `analysis.json`
+      validated criterion-for-criterion) server-side, and the result is stored and served on the
       trial body (`Trial.analysis`) instead of written into a local
       directory. Two named deviations from Harbor's shape: (1) server-side
       execution — no wrapper job appears anywhere on this surface; the
@@ -111,8 +111,8 @@ info:
       `JobCreate.analyze` runs the analyzer per trial as each trial settles,
       which Harbor has no equivalent of (their analyze is always a manual
       follow-up command; `POST /api/jobs/{jobId}/analyze` is that manual
-      verb here). Vocabulary is Harbor's: `model_name`, rubric criteria
-      `{name, description, guidance}` (their cli/analyze.py `--model` /
+      verb here). Vocabulary is Harbor's: `agent`, `model_name`, rubric criteria
+      `{name, description, guidance}` (their cli/analyze.py `--agent` / `--model` /
       `--rubric`, cli/quality_checker/models.py RubricCriterion), result
       `{summary, checks{outcome, explanation}, estimated_cost_usd}` (their
       analyze/models.py AnalyzeResult). Selection and width are Harbor's
@@ -132,7 +132,7 @@ info:
       own record: the caller uploads the task directory (or a directory of
       task directories) as one archive (`POST /api/checks`, multipart —
       `archive` + `config`), the worker runs the SAME checker per task
-      (claude-code over the task's byte-sacred tree, the platform's default
+      (the chosen agent, claude-code by default, over the task's byte-sacred tree, the platform's default
       check prompt and rubric rendered through Harbor's own tokens,
       `check-result.json` validated criterion for criterion) server-side,
       and the report is served as the `Check`
@@ -145,7 +145,7 @@ info:
       `claude-sonnet-4-6` (one roster, one default for both rubric agents);
       and the platform's `reasoning_effort` and `sandbox_provider` beside
       Harbor's knobs, exactly as on `AnalyzeConfigInput`. Vocabulary is
-      Harbor's: `model_name`, `rubric`, `prompt` (their cli/analyze.py:88-
+      Harbor's: `agent`, `model_name`, `rubric`, `prompt` (their cli/analyze.py:88-
       103), `n_concurrent` (:117-119), `include_task_names` /
       `exclude_task_names` / `n_tasks` (:121-131; fnmatch globs and the cap
       of checker.py:132-138), result `{task_name, checks{outcome,
@@ -1459,9 +1459,11 @@ paths:
                 │   │                    at Harbor's own tee name for the
                 │   │                    harness (claude-code.txt, codex.txt,
                 │   │                    gemini-cli.txt, qwen-code.txt,
-                │   │                    kimi-code.txt, opencode.txt;
-                │   │                    droid.txt, and stdout.log for a
-                │   │                    harness Harbor has no name for)
+                │   │                    kimi-code.txt, opencode.txt, pi.txt,
+                │   │                    antigravity-stream.jsonl; droid.txt,
+                │   │                    prime-agent.txt, dsh.txt, zcode.txt, and
+                │   │                    stdout.log for a harness Harbor has
+                │   │                    no name for)
                 │   ├── stderr.log       the harness process's stderr stream,
                 │   │                    when stored
                 │   ├── trace-parsed.jsonl  the parsed event trace, one
@@ -1801,9 +1803,9 @@ paths:
       summary: Analyze a job's trial traces (rubric-driven)
       description: |
         Runs Harbor-style trace analysis over a terminal job's trials,
-        server-side: for each trial the analyzer agent (claude-code, in its
-        own sandbox, under the network Harbor's analyze wrapper task gives
-        it — open by default) reads the trial's Harbor-shape tree plus its
+        server-side: for each trial the analyzer agent (`agent`, claude-code
+        by default, in its own sandbox, under the network Harbor's analyze
+        wrapper task gives it — open by default) reads the trial's Harbor-shape tree plus its
         original task and rules every rubric criterion, storing
         `{summary, checks, estimated_cost_usd}` on the trial
         (`Trial.analysis`) and the aggregate on the job
@@ -1823,7 +1825,7 @@ paths:
         `max_concurrent_analyses`).
 
         An analyzer run that completes without a valid `analysis.json` is
-        automatically re-run at most once (fresh sandbox, same model and
+        automatically re-run at most once (fresh sandbox, same agent, model and
         rubric); the analysis object's `attempts` records how far the
         ladder went. A run cut by its budget is not that class: it settles
         `failed` with phase `timeout` at once and is never re-run — a
@@ -4994,8 +4996,8 @@ paths:
       description: |
         The resolved policy an empty `AnalyzeConfigInput` falls back to — the
         five knobs every analysis that names none is stamped with:
-        `model_name`, `rubric` (the platform's analyze rubric, the seven
-        criteria `AnalyzeConfigInput` lists), `prompt` (the built-in analyze
+        `model_name`, `rubric` (the platform's default analyze rubric),
+        `prompt` (the built-in analyze
         body, as the TEMPLATE a caller's own `prompt` replaces — with its
         `{trial_path}`, `{task_section}` and `{criteria_guidance}` slots
         unrendered; the output section Harbor appends is not part of it),
@@ -5692,8 +5694,8 @@ paths:
 
             analyze-<trial>__<7>/
             ├── config.json              TrialConfig, partial: the wrapper
-            │                            task's name, the agent (claude-code,
-            │                            the model), and under `x_evolve`
+            │                            task's name, the agent (its Harbor
+            │                            name, the model), and under `x_evolve`
             │                            the frozen policy — rubric, prompt,
             │                            reasoning_effort — plus the analyzed
             │                            trial/job/task and the provider
@@ -5721,13 +5723,15 @@ paths:
             │                            validator (an infrastructure phase)
             ├── agent/
             │   ├── claude-code.txt      the analyzer's stdout stream at
-            │   │                        Harbor's own tee name for claude-code
+            │   │                        Harbor's own tee name for its agent
+            │   │                        (claude-code.txt, codex.txt, …)
             │   ├── stderr.log           its stderr, when stored
             │   ├── trace-parsed.jsonl   the run's parsed event trace
             │   ├── .claude/ …           the captured home at its real names,
             │   ├── agent-home.json      the capture record beside it
-            │   └── sessions/ …          Harbor's own copy of the .claude/
-            │                            subtree (claude_code.py:482)
+            │   └── sessions/ …          Harbor's own copies of the home, as
+            │                            on a trial (claude: the .claude/
+            │                            subtree, claude_code.py:482)
             ├── verifier/                ONLY when the validator ruled —
             │   │                        completed, or failed `invalid_result`
             │   ├── test-stdout.txt      the validator's printed reasons
@@ -5804,8 +5808,8 @@ paths:
         gzipped tarball (`archive`), or a published dataset is named
         instead (`dataset`, the hosted form; `CheckRequest.dataset` states
         the deviation and its reason), and for each task directory it holds
-        the checker agent (claude-code, Harbor's own check agent, in its own
-        sandbox, under the network Harbor's check wrapper task gives it —
+        the checker agent (`agent`, claude-code by default — Harbor's own
+        check agent — in its own sandbox, under the network Harbor's check wrapper task gives it —
         open by default) reads EVERY file of the task and rules every rubric
         criterion `pass`, `fail`, `not_applicable` or `unknown` with a
         rationale and the evidence behind it, writing `check-result.json`
@@ -5835,8 +5839,8 @@ paths:
         refusal answers. The `config`
         part is the JSON `CheckConfigInput`; absent or
         `{}` means the defaults (openrouter/deepseek/deepseek-v4.1-flash at its
-        per-model effort, the platform's default check rubric — eleven
-        criteria, `CheckConfigInput.rubric` names them).
+        per-model effort, the platform's default check rubric, served by
+        `GET /api/checks/defaults`).
 
         The task bytes are never modified and never land anywhere but the
         checker's sandbox and the platform's rows: Harbor's own rule ("Do
@@ -5973,8 +5977,8 @@ paths:
       description: |
         The resolved policy an empty `CheckConfigInput` falls back to — the
         five knobs the create door stamps on every check that names none:
-        `model_name`, `rubric` (the platform's check rubric, the eleven
-        criteria `CheckConfigInput` lists), `prompt` (the built-in check
+        `model_name`, `rubric` (the platform's default check rubric),
+        `prompt` (the built-in check
         body, as the TEMPLATE a caller's own `prompt` replaces — with its
         `{task_path}`, `{file_tree}` and `{criteria_guidance}` slots
         unrendered; the output section Harbor appends is not part of it),
@@ -12318,13 +12322,10 @@ components:
           pattern: '^[a-z][a-z0-9_]*$'
           description: >
             Criterion identifier, snake_case (it keys the result's `checks`
-            object). The platform's default analyze rubric names seven
-            (score_is_earned, score_is_correct, task_was_fair,
-            environment_worked, ended_by_its_own_decision,
-            report_is_truthful, worked_as_for_a_real_user) and its default
-            check rubric eleven (CheckConfigInput lists them); the derived
-            labels read those names, and a rubric with other names carries
-            no label.
+            object). The platform's default rubrics are served by
+            `GET /api/analyses/defaults` and `GET /api/checks/defaults`; the
+            platform reads no criterion name — a run's result is its
+            per-criterion table under whatever names its rubric carries.
         description:
           type: string
           minLength: 1
@@ -12362,7 +12363,7 @@ components:
       type: object
       description: |
         Trace-analysis configuration — Harbor's `harbor analyze` vocabulary
-        (their cli/analyze.py: `--model`, `--rubric`, `--prompt`). PRESENCE of this
+        (their cli/analyze.py: `--agent`, `--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 — withdrawn work is not billed an
@@ -12370,17 +12371,17 @@ components:
         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 (the seven criteria
-        `RubricCriterion.name` lists; Harbor's own analyze-rubric.toml
-        still runs when passed as `rubric`, and carries no label).
-
-        The analyzer always runs the claude-code harness (Harbor's default
-        analyze agent) in its own sandbox, under the network Harbor's
-        analyze wrapper task gives it (open by default; the model door is
-        unchanged) — 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.
+        the platform's default analyze rubric (served by
+        `GET /api/analyses/defaults`; Harbor's own analyze-rubric.toml
+        still runs when passed as `rubric`).
+
+        The analyzer runs the agent `agent` names (claude, Harbor's own
+        default claude-code, when it names none) in its own sandbox, under
+        the network Harbor's analyze wrapper task gives it (open by default;
+        the model door is unchanged) — 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`
@@ -12396,9 +12397,7 @@ components:
         takes it; on `JobCreate.analyze` the trials do not exist yet.
 
         Harbor's other analyze options, and why they are not here:
-        `-a/--agent` — the analyzer harness is claude-code, fixed (the
-        instruction templates, the roster check and the sandbox policy are
-        written against it); `--job-name` and `-o/--jobs-dir` — a hosted
+        `--job-name` and `-o/--jobs-dir` — a hosted
         analysis attaches to its source job and is served on that job's
         trials, so there is no wrapper job to name and no directory to
         write; `-k/--n-attempts` (k analyses per trial) — deferred: each
@@ -12413,6 +12412,21 @@ components:
         (task quality checks, their cli/analyze.py:126-137) and are not
         adopted here.
       properties:
+        agent:
+          type: string
+          default: claude
+          description: >
+            The agent the analyzer runs on — Harbor's `-a/--agent` (their
+            cli/analyze.py:258, default claude-code), named in the
+            `agents[].name` vocabulary (claude, not claude-code) so one set
+            of names covers arms and reviewers: any built-in agent
+            `analyze.agents` lists on `GET /api/meta`. `model_name` must be
+            on this agent's roster and `reasoning_effort` must be one it
+            accepts; with an agent whose roster lacks the default model,
+            `model_name` is required. A registered (bring-your-own) agent
+            is not accepted. Anything else is refused `invalid_input`
+            naming `analyze.agent`. Stored as given and frozen into each
+            analysis (`TrialAnalysis.agent`).
         model_name:
           type: string
           default: openrouter/deepseek/deepseek-v4.1-flash
@@ -12435,9 +12449,10 @@ components:
             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`, also
-            `analyze.models`); anything else is refused at accept
-            (`invalid_input`, roster in the message).
+            the agent's roster (`GET /api/meta`, `analyze.agents[].models`);
+            anything else is refused at accept (`invalid_input`, roster in
+            the message) — including the default model on an agent whose
+            roster lacks it, which then says `model_name` is required.
         rubric:
           $ref: '#/components/schemas/Rubric'
         prompt:
@@ -12475,20 +12490,22 @@ components:
           type: string
           description: >
             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
-            `analyze.reasoning_efforts` on `GET /api/meta` (the claude
-            agent's `effort_support` is `level`, so the whole list), and an
-            unknown value is refused `invalid_input` with the same sentence
-            an arm's is (`analyze.reasoning_effort must be one of: ...`).
+            `agents[].reasoning_effort` vocabulary applied to the analyzer's
+            agent, held to that agent's own rule exactly as an arm on it:
+            the accepted values are `analyze.agents[].reasoning_efforts` on
+            `GET /api/meta` (claude's `effort_support` is `level`, so the
+            whole list; an agent that takes none, gemini, accepts none), and
+            a refused value answers `invalid_input` with the same sentence
+            an arm's does (`analyze.reasoning_effort must be one of: ...`).
             Omitted, the PER-MODEL default applies —
-            `analyze.models[].default_reasoning_effort`: `high` on
+            `analyze.agents[].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 (`agents[].default_effort`) on every
-            other roster model. Whatever resolves is passed to the analyzer
+            2026-09-08, the effort its published scores use), on any agent
+            that can honor them; the agent's own default
+            (`agents[].default_effort`) on every other roster model; none
+            on an agent that takes none. Whatever resolves is passed to the analyzer
             EXPLICITLY on every call — never left to a provider's default —
             and recorded as `TrialAnalysis.reasoning_effort`. A hosted
             extension, recorded as such: Harbor's `harbor analyze` has no
@@ -12605,11 +12622,14 @@ components:
         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` /
+        (`Trial.analysis.agent` / `.model_name` / `.rubric` / `.prompt` /
         `.reasoning_effort`), which a later manual re-analysis may have
         changed.
-      required: [model_name, rubric, prompt, reasoning_effort, sandbox_provider, n_concurrent, passing, failing, n_trials, trial_ids]
+      required: [agent, model_name, rubric, prompt, reasoning_effort, sandbox_provider, n_concurrent, passing, failing, n_trials, trial_ids]
       properties:
+        agent:
+          type: string
+          description: The agent this policy's analyses run on — as named, or the default (claude).
         model_name:
           type: string
         rubric:
@@ -12621,14 +12641,15 @@ components:
             null = the built-in prompt (the platform's default analyze body).
         reasoning_effort:
           x-wave: 3
-          type: string
+          type: [string, 'null']
           description: >
             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, for the same reason: the default is a
-            platform table, resolved where an analysis is enqueued).
+            per-model default of the day for `model_name` on `agent` — the
+            value the next enqueue under this policy stamps (the same nuance
+            as `sandbox_provider` below, for the same reason: the default is
+            a platform table, resolved where an analysis is enqueued). Null
+            when the agent takes no effort.
         sandbox_provider:
           allOf:
             - $ref: '#/components/schemas/SandboxProvider'
@@ -13967,6 +13988,7 @@ components:
         - name
         - status
         - source
+        - agent
         - model_name
         - reasoning_effort
         - sandbox_provider
@@ -13995,11 +14017,14 @@ components:
         source:
           $ref: '#/components/schemas/CheckSource'
           description: What was checked; the row's DATASETS cell (the dataset form's `name@version`; an archive shows as an archive with its sha256).
+        agent:
+          type: string
+          description: The checker's agent, as Check.agent.
         model_name:
           type: string
           description: The checker's model; the row's AGENTS cell, shown like an arm with its effort under it.
         reasoning_effort:
-          type: string
+          type: [string, 'null']
           description: The effort every task's checker ran at, as Check.reasoning_effort.
         sandbox_provider:
           allOf:
@@ -14786,8 +14811,7 @@ components:
         AnalyzeResult (their analyze/models.py: `summary`, `checks` keyed
         by criterion, `estimated_cost_usd`; `trial_name` is the enclosing
         trial) with each check carrying the platform's evidence list and
-        fourth outcome (AnalysisCheck), plus the derived `label`; the rest
-        is provenance — which model, rubric and prompt THIS analysis ran
+        fourth outcome (AnalysisCheck); the rest is provenance — which agent, model, rubric and prompt 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
@@ -14801,13 +14825,13 @@ components:
         - job_id
         - task_name
         - status
+        - agent
         - model_name
         - reasoning_effort
         - rubric
         - prompt
         - summary
         - checks
-        - label
         - estimated_cost_usd
         - failure
         - created_at
@@ -14846,6 +14870,12 @@ components:
             `not_applicable` are their exact words) and the ladder follows
             its object's dialect; the UI capitalizes on render, and nothing
             ever compares this ladder's words against another ladder's.
+        agent:
+          type: string
+          description: >
+            The agent THIS analysis ran on (`AnalyzeConfigInput.agent`, or
+            the default claude); every analysis from before the choice
+            existed ran on claude and says so.
         model_name:
           type: string
         reasoning_effort:
@@ -14855,8 +14885,8 @@ components:
             The reasoning effort THIS analysis ran at — passed to the
             analyzer explicitly, so it is what the model was asked for
             (`AnalyzeConfigInput.reasoning_effort`, or the per-model
-            default). Null only on analyses recorded before the effort was
-            stamped; never a guessed value.
+            default). Null when its agent takes no effort, or on analyses
+            recorded before the effort was stamped; never a guessed value.
         rubric:
           $ref: '#/components/schemas/Rubric'
         prompt:
@@ -14878,24 +14908,6 @@ components:
             criterion names (the frozen-criteria law). Null until completed.
           additionalProperties:
             $ref: '#/components/schemas/AnalysisCheck'
-        label:
-          type: [string, 'null']
-          enum: [flagged, env_fault, unclear, clean, null]
-          description: >
-            The derived label — computed by the platform from the outcomes
-            when the result is stored, never asked from the model, so it is
-            the same rule for every analysis and can never contradict the
-            checks. The rule reads the default analyze rubric's criteria,
-            precedence in this order: `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 (the agent never
-            acted) or score_is_correct (no reward exists); else `clean`.
-            ended_by_its_own_decision and worked_as_for_a_real_user never
-            change it. 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.
         estimated_cost_usd:
           type: [number, 'null']
         usage:
@@ -15029,21 +15041,16 @@ components:
       type: object
       description: |
         Task-check configuration — Harbor's `harbor check` vocabulary
-        (their cli/analyze.py:84-148 check_command). The three rubric-agent
+        (their cli/analyze.py:84-148 check_command). The four rubric-agent
         knobs are the analyze door's, with the SAME rules and refusals
         (`AnalyzeConfigInput` states them; the param prefix here is
-        `check.`): `model_name` (`-m/--model`; Harbor's check default is
+        `check.`): `agent` (`-a/--agent`, :100; default claude, Harbor's
+        claude-code), `model_name` (`-m/--model`; Harbor's check default is
         `claude-sonnet-4-6`, :101-103 — this platform's is the analyzer's
         `openrouter/deepseek/deepseek-v4.1-flash`, one roster and one default for both rubric
         agents, a recorded deviation), `rubric` (`-r/--rubric`; the default
-        is the platform's check rubric, eleven criteria:
-        instruction_is_sufficient, tests_match_the_instruction,
-        verifier_is_correct, no_answer_leakage, grader_is_out_of_reach,
-        reference_solution_is_valid, verifier_rejects_non_solutions,
-        environment_builds_and_runs, verification_is_stable,
-        limits_allow_the_task, task_is_solvable — the derived `label` and
-        `executed` read them, and a rubric with other names carries
-        neither; Harbor's own default-rubric.toml still runs when passed),
+        is the platform's check rubric, served by `GET /api/checks/defaults`;
+        Harbor's own default-rubric.toml still runs when passed),
         `prompt` (`-p/--prompt`, the file's TEXT: it replaces the built-in
         check prompt, in Harbor's check.txt slot, and is rendered with
         `{task_path}`, `{file_tree}`, `{criteria_guidance}` — checker.py:
@@ -15064,10 +15071,9 @@ components:
         matched against the directory NAME.
 
         Harbor's other check options, and why they are not here: the same
-        list as the analyze door's — `-a/--agent` (the checker is
-        claude-code, fixed), `--job-name` and `-o/--jobs-dir` (a hosted
-        check is its own record, no wrapper job to name and no directory
-        to write), `-k/--n-attempts` (the one hosted auto re-run replaces
+        list as the analyze door's — `-o/--jobs-dir` (a hosted check is its
+        own record, no directory to write; `--job-name` is `name`),
+        `-k/--n-attempts` (the one hosted auto re-run replaces
         it; see `TaskCheck.attempts`), `-c/--config`, `--ak`, `--ae`,
         `--ek` (local-runner knobs with no hosted meaning), `-q` (a client
         rendering option, not a wire field).
@@ -15080,6 +15086,10 @@ components:
             The caller's name for the check — Harbor's `--job-name` on
             `harbor check` (cli/analyze.py:138). Omitted, the accept
             timestamp in Harbor's own shape, `YYYY-MM-DD__HH-MM-SS` (UTC).
+        agent:
+          type: string
+          default: claude
+          description: The agent the checker runs on — the analyze door's `agent`, same rule.
         model_name:
           type: string
           default: openrouter/deepseek/deepseek-v4.1-flash
@@ -15152,8 +15162,7 @@ components:
         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 record: its own
+        schema, plus the hosted record: its own
         id, the check it belongs to, its lifecycle (the analysis ladder's
         four lowercase words — Harbor's dialect), the bounded attempt count,
         and a typed `failure` in place of Harbor's `error` string (the
@@ -15163,11 +15172,10 @@ components:
         (Harbor's check-task-template/tests/validate.py extended by the
         result schema): one key per rubric criterion, each an AnalysisCheck
         `{outcome, explanation, evidence}` — no summary (a check has none;
-        analyze does). `label` and `executed` are derived from it when the
-        result is stored. `cost_usd` is the checker agent's OWN metered
+        analyze does). `cost_usd` is the checker agent's OWN metered
         spend on its capped key; null when nothing was measured, never a
         fabricated 0.
-      required: [id, check_id, task_name, status, checks, label, executed, cost_usd, attempts, failure, created_at, finished_at]
+      required: [id, check_id, task_name, status, checks, cost_usd, attempts, failure, created_at, finished_at]
       properties:
         id:
           type: string
@@ -15186,30 +15194,6 @@ components:
           description: One entry per rubric criterion, keys exactly the frozen criteria. Null until completed.
           additionalProperties:
             $ref: '#/components/schemas/AnalysisCheck'
-        label:
-          type: [string, 'null']
-          enum: [has_a_problem, unclear, no_problem_found, null]
-          description: >
-            The derived label — computed by the platform from the outcomes
-            when the result is stored, never asked from the model. The rule
-            reads the default check rubric's criteria, precedence in this
-            order: `has_a_problem` on a fail of any criterion; else
-            `unclear` on an unknown of any of the six file-based criteria
-            (instruction_is_sufficient, tests_match_the_instruction,
-            verifier_is_correct, no_answer_leakage, grader_is_out_of_reach,
-            task_is_solvable); else `no_problem_found`. Null until
-            completed, and null on a completed check whose rubric is not
-            the default one — a custom rubric carries its per-criterion
-            outcomes and no label.
-        executed:
-          type: [boolean, 'null']
-          description: >
-            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.
         cost_usd:
           type: [number, 'null']
         attempts:
@@ -15268,6 +15252,7 @@ components:
         - name
         - status
         - source
+        - agent
         - model_name
         - reasoning_effort
         - rubric
@@ -15294,11 +15279,14 @@ components:
           enum: [queued, running, completed]
         source:
           $ref: '#/components/schemas/CheckSource'
+        agent:
+          type: string
+          description: The agent every task's checker ran on — named at create, or the default (claude); every check from before the choice existed ran on claude.
         model_name:
           type: string
         reasoning_effort:
-          type: string
-          description: The effort every task's checker ran at — named at create, or the model's default, resolved at accept and stamped.
+          type: [string, 'null']
+          description: The effort every task's checker ran at — named at create, or the model's default on the agent, resolved at accept and stamped; null when the agent takes none.
         rubric:
           $ref: '#/components/schemas/Rubric'
         prompt:
@@ -15352,8 +15340,10 @@ components:
         echoes for a job created with `analyze: {}`, except `prompt`, which
         `AnalyzeConfig` serves as null (the built-in body) and this serves as
         that body's template text.
-      required: [model_name, rubric, prompt, reasoning_effort, sandbox_provider]
+      required: [agent, model_name, rubric, prompt, reasoning_effort, sandbox_provider]
       properties:
+        agent:
+          type: string
         model_name:
           type: string
         rubric:
@@ -15365,8 +15355,8 @@ components:
             `AnalyzeConfigInput.prompt` to run the default body explicitly,
             or edit it from here.
         reasoning_effort:
-          type: string
-          description: The effort the default model runs at when the config names none.
+          type: [string, 'null']
+          description: The effort the default model runs at on the default agent when the config names none; null if that agent takes none.
         sandbox_provider:
           allOf:
             - $ref: '#/components/schemas/SandboxProvider'
@@ -15379,8 +15369,10 @@ components:
         a check created with no config, except `prompt`, which `Check`
         serves as null (the built-in body) and this serves as that body's
         template text.
-      required: [model_name, rubric, prompt, reasoning_effort, sandbox_provider]
+      required: [agent, model_name, rubric, prompt, reasoning_effort, sandbox_provider]
       properties:
+        agent:
+          type: string
         model_name:
           type: string
         rubric:
@@ -15392,8 +15384,8 @@ components:
             `CheckConfigInput.prompt` to run the default body explicitly,
             or edit it from here.
         reasoning_effort:
-          type: string
-          description: The effort the default model runs at when the config names none.
+          type: [string, 'null']
+          description: The effort the default model runs at on the default agent when the config names none; null if that agent takes none.
         sandbox_provider:
           allOf:
             - $ref: '#/components/schemas/SandboxProvider'
@@ -18394,34 +18386,46 @@ components:
           x-wave: 3
           type: object
           description: >
-            The trace analyzer's roster and defaults: the model an omitted
-            `AnalyzeConfigInput.model_name` takes, the efforts
-            `AnalyzeConfigInput.reasoning_effort` accepts (the claude
-            harness's — the analyzer IS that harness), and every roster
+            The rubric agents' roster and defaults (the analyzer's and the
+            checker's alike): the agents `AnalyzeConfigInput.agent` and
+            `CheckConfigInput.agent` accept and the one an omitted agent
+            takes, the model an omitted `model_name` takes, and per agent
+            the efforts its `reasoning_effort` accepts and every roster
             model with the effort an omitted `reasoning_effort` takes for
             it. Published because the effort changes what an analysis costs
             and how it reads, and a client comparing two waves must know
             what "omitted" meant in each.
-          required: [default_model, reasoning_efforts, models]
+          required: [default_agent, default_model, agents]
           properties:
+            default_agent:
+              type: string
             default_model:
               type: string
-            reasoning_efforts:
-              type: array
-              items:
-                type: string
-            models:
+            agents:
               type: array
               items:
                 type: object
-                required: [alias, model_id, default_reasoning_effort]
+                required: [name, reasoning_efforts, models]
                 properties:
-                  alias:
-                    type: string
-                  model_id:
-                    type: string
-                  default_reasoning_effort:
+                  name:
                     type: string
+                  reasoning_efforts:
+                    type: array
+                    description: Empty for an agent that takes no effort.
+                    items:
+                      type: string
+                  models:
+                    type: array
+                    items:
+                      type: object
+                      required: [alias, model_id, default_reasoning_effort]
+                      properties:
+                        alias:
+                          type: string
+                        model_id:
+                          type: string
+                        default_reasoning_effort:
+                          type: [string, 'null']
         agent_registration:
           type: object
           description: Rules a bring-your-own agent registration must satisfy.