@cat-factory/contracts 0.151.0 → 0.152.1

package/dist/entities.d.ts

@@ -242,18 +242,23 @@ export declare const blockSchema: v.ObjectSchema<{
      */
     readonly technical: v.OptionalSchema<v.NullableSchema<v.BooleanSchema<undefined>, undefined>, undefined>;
     /**
-     * Ids of curated best-practice prompt fragments selected for this block. Their
-     * bodies are composed into the agent system prompt at run time. The catalog
-     * itself lives in @cat-factory/prompt-fragments and is served separately.
+     * Ids of curated best-practice prompt fragments selected for this block — the block's OWN,
+     * authoritative selection. On a TASK this is what the engine folds into its `code-aware` /
+     * `doc-aware` steps (the enclosing service's fragments are NOT re-unioned at run time), seeded
+     * from the service at creation and then freely add/removable per task. Their bodies are composed
+     * into the agent system prompt at run time; the catalog itself lives in
+     * @cat-factory/prompt-fragments (+ the tenant library) and is served separately.
      */
     readonly fragmentIds: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
     /**
-     * Service-level (frame-only): ids of the best-practice / guideline prompt fragments
-     * selected as this service's programming standards (drawn from the universal pool in
-     * @cat-factory/prompt-fragments). At run time the execution engine folds their bodies
-     * into the system prompt of every agent under this service that carries the
-     * `code-aware` trait. Seeded from the workspace default on new services; absent ⇒ no
-     * service-level fragments (only the block's own `fragmentIds` apply).
+     * Service-level (frame-only): ids of the best-practice / guideline prompt fragments selected as
+     * this service's programming standards (drawn from the universal pool in
+     * @cat-factory/prompt-fragments). They serve two roles: (1) they SEED a new task's own
+     * `fragmentIds` at creation (materialised onto the task, which owns its selection from then on —
+     * an existing task is NOT retroactively updated when this list later changes; a new fragment is
+     * picked up by adding it to the task by hand), and (2) at run time the engine folds them into the
+     * frame's OWN `code-aware` runs (e.g. `blueprints`). Seeded from the workspace default on new
+     * services; a task does not re-read them at run time.
      */
     readonly serviceFragmentIds: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
     /**
@@ -1252,3922 +1257,6 @@ export declare const pipelineSchema: v.ObjectSchema<{
 }, undefined>;
 export type Pipeline = v.InferOutput<typeof pipelineSchema>;
 export type PipelineAvailability = NonNullable<Pipeline['availability']>;
-export declare const decisionSchema: v.ObjectSchema<{
-    readonly id: v.StringSchema<undefined>;
-    readonly question: v.StringSchema<undefined>;
-    readonly options: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-    readonly chosen: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-}, undefined>;
-export type Decision = v.InferOutput<typeof decisionSchema>;
-/** One entry of a running step's todo list — its label and current status. */
-export declare const stepSubtaskItemSchema: v.ObjectSchema<{
-    /** The task's human-readable subject, as the agent wrote it. */
-    readonly label: v.StringSchema<undefined>;
-    readonly status: v.PicklistSchema<["pending", "in_progress", "completed"], undefined>;
-}, undefined>;
-export type StepSubtaskItem = v.InferOutput<typeof stepSubtaskItemSchema>;
-/**
- * Live subtask counts for a running step, reported by the container agent from
- * the coding tool's own todo list (e.g. "3/8 done, 1 in progress"). Present only
- * while an async job is in flight and the agent maintains a todo list; the board
- * renders it as a finer-grained progress indicator than `progress` alone.
- *
- * `items` carries the individual todo entries (label + status) so a zoomed-in
- * card can render the actual task list, not just the count. It is optional — an
- * older agent/poll that only reported counts, or the simpler `todos[].done`
- * fallback shape, still validates without it.
- */
-export declare const stepSubtasksSchema: v.ObjectSchema<{
-    readonly completed: v.NumberSchema<undefined>;
-    readonly inProgress: v.NumberSchema<undefined>;
-    readonly total: v.NumberSchema<undefined>;
-    readonly items: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-        /** The task's human-readable subject, as the agent wrote it. */
-        readonly label: v.StringSchema<undefined>;
-        readonly status: v.PicklistSchema<["pending", "in_progress", "completed"], undefined>;
-    }, undefined>, undefined>, undefined>;
-}, undefined>;
-export type StepSubtasks = v.InferOutput<typeof stepSubtasksSchema>;
-/**
- * One GitHub-review-style comment left on a specific block or item of an agent's
- * proposal — either by a human reviewing an approval gate, or by a quality
- * companion (e.g. the Spec Reviewer) grading a structured output. `quotedSource`
- * is the verbatim raw markdown of the block the comment targets (sliced from the
- * proposal by its source line range), so a "request changes" re-run can quote the
- * agent's own text back to it rather than a re-rendered approximation. It is
- * OPTIONAL because a comment may instead anchor to a structured item via
- * {@link anchorId} (e.g. a spec requirement / acceptance-criterion id), where the
- * reviewed output is rendered as discrete items rather than free prose and there is
- * no quoted source range — the shape a companion returns.
- */
-export declare const stepReviewCommentSchema: v.ObjectSchema<{
-    /**
-     * Verbatim raw-markdown source of the commented prose block. Optional: a comment
-     * may instead anchor to a structured item via {@link anchorId}, where there is no
-     * prose source to quote.
-     */
-    readonly quotedSource: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    /**
-     * 0-based source line range [start, end) of the commented prose block, for
-     * best-effort re-anchoring. Optional: a comment may instead anchor to a structured
-     * item via {@link anchorId} (e.g. a spec requirement/acceptance-criterion id), where
-     * there is no prose line range.
-     */
-    readonly srcStart: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-    readonly srcEnd: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-    /**
-     * Stable id of the structured item the comment targets (e.g. a spec
-     * requirement/criterion id), when the reviewed output is rendered as structured
-     * items rather than free prose. Absent for prose-range comments.
-     */
-    readonly anchorId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    /** The reviewer's note on this block / item. */
-    readonly body: v.StringSchema<undefined>;
-}, undefined>;
-export type StepReviewComment = v.InferOutput<typeof stepReviewCommentSchema>;
-/**
- * The standardized, stored verdict a quality companion produced for an output it
- * graded — shared by every companion site (the pipeline companion step and the
- * requirements-rework gate). The raw model response is {@link companionAssessmentSchema}
- * (rating + summary + comments); this is the persisted, self-describing record of how
- * that assessment was applied: the `rating`, the `threshold` it was judged against,
- * whether it `passed`, and the `feedback` surfaced to the human / fed into a rework.
- */
-export declare const companionVerdictSchema: v.ObjectSchema<{
-    /** Overall quality of the graded output (0..1, higher = better). */
-    readonly rating: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>;
-    /** The quality bar the rating had to reach to pass. */
-    readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>;
-    /** Whether the rating met the threshold. */
-    readonly passed: v.BooleanSchema<undefined>;
-    /** The companion's challenge / justification (its assessment summary). */
-    readonly feedback: v.StringSchema<undefined>;
-}, undefined>;
-export type CompanionVerdict = v.InferOutput<typeof companionVerdictSchema>;
-/**
- * A human approval gate raised after a step whose pipeline marked it
- * `requiresApproval`. Unlike a {@link Decision} (which an agent raises and which
- * re-runs the same step on resolution), an approval gate fires once the step has
- * already produced its `proposal`; approving advances the run (carrying the —
- * possibly edited — proposal forward as context), requesting changes re-runs the
- * same step with the human's `feedback` (+ per-block `comments`), and rejecting
- * stops the run entirely (a terminal `rejected` failure the board can retry).
- */
-export declare const stepApprovalSchema: v.ObjectSchema<{
-    /** Unique id of this gate; the durable run parks on it like a decision. */
-    readonly id: v.StringSchema<undefined>;
-    /** `pending` while awaiting the human; terminal `approved`/`rejected`; `changes_requested` re-runs the step. */
-    readonly status: v.PicklistSchema<["pending", "approved", "changes_requested", "rejected"], undefined>;
-    /** The agent's output the human is reviewing (editable before approval). */
-    readonly proposal: v.StringSchema<undefined>;
-    /** When changes were requested, the human's freeform guidance fed into the re-run. */
-    readonly feedback: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    /** When changes were requested, per-block review comments fed into the re-run. */
-    readonly comments: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-        /**
-         * Verbatim raw-markdown source of the commented prose block. Optional: a comment
-         * may instead anchor to a structured item via {@link anchorId}, where there is no
-         * prose source to quote.
-         */
-        readonly quotedSource: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        /**
-         * 0-based source line range [start, end) of the commented prose block, for
-         * best-effort re-anchoring. Optional: a comment may instead anchor to a structured
-         * item via {@link anchorId} (e.g. a spec requirement/acceptance-criterion id), where
-         * there is no prose line range.
-         */
-        readonly srcStart: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-        readonly srcEnd: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-        /**
-         * Stable id of the structured item the comment targets (e.g. a spec
-         * requirement/criterion id), when the reviewed output is rendered as structured
-         * items rather than free prose. Absent for prose-range comments.
-         */
-        readonly anchorId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        /** The reviewer's note on this block / item. */
-        readonly body: v.StringSchema<undefined>;
-    }, undefined>, undefined>, undefined>;
-}, undefined>;
-export type StepApproval = v.InferOutput<typeof stepApprovalSchema>;
-/**
- * The agent flows that produce an "agent run" (a container-backed job whose
- * lifecycle, progress and failure the board surfaces uniformly):
- *   - `bootstrap`  — a "bootstrap repo" run that scaffolds/adapts a new repo.
- *   - `execution`  — a task pipeline run that implements a board task.
- *   - `env-config-repair` — a coding agent that repairs an environment-provider
- *     config file in an existing repo (no board block; surfaced on the infra window).
- */
-export declare const agentRunKindSchema: v.PicklistSchema<["bootstrap", "execution", "env-config-repair"], undefined>;
-export type AgentRunKind = v.InferOutput<typeof agentRunKindSchema>;
-/**
- * How an agent run faulted, so the board can classify the failure (and hint
- * whether a retry is likely to help). The union spans both flows; a given flow
- * only ever produces a subset:
- *   - `preflight`        — rejected before dispatch (repo missing/not empty, not connected). [bootstrap]
- *   - `dispatch`         — the container accept-request itself failed (HTTP / network). [bootstrap]
- *   - `evicted`          — the container vanished mid-run (eviction/crash). Retrying spins a fresh one.
- *   - `timeout`          — a container watchdog fired (inactivity or max-duration).
- *   - `agent`            — the agent / git push reported a failure.
- *   - `job_failed`       — an async container job came back failed. [execution]
- *   - `rejected`         — a human rejected a gated proposal, stopping the run. [execution]
- *   - `cancelled`        — the user (or an orphan sweep) explicitly stopped the run.
- *   - `unknown`          — anything not otherwise classified.
- */
-export declare const agentFailureKindSchema: v.PicklistSchema<["preflight", "dispatch", "environment", "evicted", "timeout", "agent", "job_failed", "rejected", "companion_rejected", "stalled", "cancelled", "unknown"], undefined>;
-export type AgentFailureKind = v.InferOutput<typeof agentFailureKindSchema>;
-/**
- * Structured diagnostics captured when an agent run fails, stored on the run and
- * surfaced on the board so a crash isn't just a one-line message. The container's
- * stdout/stderr can't always be pulled into this record (an evicted container is
- * gone), so for `evicted`/`timeout` failures the `hint` points at where to look.
- */
-export declare const agentFailureSchema: v.ObjectSchema<{
-    readonly kind: v.PicklistSchema<["preflight", "dispatch", "environment", "evicted", "timeout", "agent", "job_failed", "rejected", "companion_rejected", "stalled", "cancelled", "unknown"], undefined>;
-    /** Human-readable summary (mirrors the run's `error` for back-compat). */
-    readonly message: v.StringSchema<undefined>;
-    /** Extended detail when available (the harness's reason, an HTTP body, …). */
-    readonly detail: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    /** Where to look next (e.g. "check the container logs for this job id"). */
-    readonly hint: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    /**
-     * Optional machine-readable cause code so the SPA can render precise, actionable guidance
-     * without string-matching the prose `message`/`detail` (the failure analogue of a
-     * {@link ConflictReason}). Kind-scoped: an `environment` failure carries an
-     * {@link EnvironmentFailureReason} (e.g. `deploy_runner_unwired`). Absent when the cause has
-     * no client-specific handling.
-     */
-    readonly reason: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    /** Epoch ms the failure was recorded. */
-    readonly occurredAt: v.NumberSchema<undefined>;
-    /** Last subtask counts seen before the failure, for context (null if none). */
-    readonly lastSubtasks: v.NullableSchema<v.ObjectSchema<{
-        readonly completed: v.NumberSchema<undefined>;
-        readonly inProgress: v.NumberSchema<undefined>;
-        readonly total: v.NumberSchema<undefined>;
-        readonly items: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-            /** The task's human-readable subject, as the agent wrote it. */
-            readonly label: v.StringSchema<undefined>;
-            readonly status: v.PicklistSchema<["pending", "in_progress", "completed"], undefined>;
-        }, undefined>, undefined>, undefined>;
-    }, undefined>, undefined>;
-    /**
-     * Index of the pipeline step that was in flight when the run failed (the run's
-     * `currentStep` at fail time), so the per-attempt failure trail can be attributed to a
-     * specific step — the step-detail overlay filters its "execution history" to the failures
-     * recorded for that step. Absent on a bootstrap failure (no steps) and on legacy records.
-     */
-    readonly stepIndex: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-}, undefined>;
-export type AgentFailure = v.InferOutput<typeof agentFailureSchema>;
-/**
- * A SUCCESSFUL step attempt whose output a restart later superseded — the positive
- * complement of {@link agentFailureSchema}. When a run is restarted from a step, that
- * step and every later one are reset and their `output` dropped; the ones that had
- * already succeeded are recorded here so the step-detail overlay's "execution history"
- * surfaces what a superseded attempt PRODUCED, not only the errors. Attributed to a
- * `stepIndex` exactly like a failure, and rides in the run's `detail` JSON (no column).
- */
-export declare const priorStepOutputSchema: v.ObjectSchema<{
-    /** Index of the pipeline step that produced this output (see {@link agentFailureSchema} `stepIndex`). */
-    readonly stepIndex: v.NumberSchema<undefined>;
-    /** Epoch ms the superseded attempt finished (its `finishedAt`, else when it was recorded). */
-    readonly occurredAt: v.NumberSchema<undefined>;
-    /** The attempt's prose/JSON output, clipped to a stored-size bound when {@link truncated}. */
-    readonly output: v.StringSchema<undefined>;
-    /** Whether {@link output} was clipped because the original exceeded the per-entry size bound. */
-    readonly truncated: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-}, undefined>;
-export type PriorStepOutput = v.InferOutput<typeof priorStepOutputSchema>;
-/**
- * State a polling **gate** step carries (today `ci` and `conflicts`). A gate is
- * special (like a `deployer` step): it is NOT itself an LLM/container agent. It
- * runs a programmatic precheck against a provider (CI check runs / PR mergeability)
- * for the PR head commit and only escalates to a helper container agent (`ci-fixer`
- * / `conflict-resolver`) on a negative verdict, looping until the precheck passes or
- * the attempt budget is spent. Which gate a step is comes from its `agentKind`, so it
- * is not duplicated here. See the engine's `GateDefinition` registry.
- *   - `phase: 'checking'` — running the precheck / waiting for the provider.
- *   - `phase: 'working'`  — a helper agent is in flight (tracked via the step's
- *                           `jobId`); on completion the gate returns to `checking`.
- */
-/** One failing check the CI gate's precheck saw, flattened for display. */
-export declare const gateFailingCheckSchema: v.ObjectSchema<{
-    readonly name: v.StringSchema<undefined>;
-    /** GitHub conclusion (e.g. `failure`, `timed_out`), or null when not reported. */
-    readonly conclusion: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    /**
-     * The check run's GitHub web URL (`html_url`), so the UI can link straight to the
-     * failed run's logs. Null when GitHub didn't report one.
-     */
-    readonly url: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    /**
-     * The repo (owner/name) this check belongs to, on a MULTI-REPO block — so the UI can group
-     * failing checks by service. Absent on a single-repo block (there is only the own repo).
-     */
-    readonly repo: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-}, undefined>;
-export type GateFailingCheck = v.InferOutput<typeof gateFailingCheckSchema>;
-/**
- * One helper-agent attempt the gate dispatched (a ci-fixer / conflict-resolver run),
- * recorded when the job finishes so the UI can show what each attempt tried and how it
- * ended — detail that used to be discarded the moment the gate re-probed.
- */
-export declare const gateAttemptSchema: v.ObjectSchema<{
-    /** 1-based attempt number (matches `attempts` at the time the helper was dispatched). */
-    readonly attempt: v.NumberSchema<undefined>;
-    /** Epoch ms when the helper job finished. */
-    readonly at: v.NumberSchema<undefined>;
-    /**
-     * How the helper job ended:
-     *   - `completed` — the container finished (it may or may not have fully fixed the
-     *     issue; the gate's next precheck is the source of truth, and `summary` carries
-     *     the agent's own account, e.g. which files it left conflicting).
-     *   - `failed`    — the job errored / was evicted without finishing.
-     */
-    readonly outcome: v.PicklistSchema<["completed", "failed"], undefined>;
-    /** The PR head commit the helper worked against, when known. */
-    readonly headSha: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    /**
-     * The fixing instructions handed to the helper for this round — the failing-check
-     * summary the CI gate fed the `ci-fixer`, the conflict reason / human-review comments
-     * the other gates fed their fixer. Stashed at dispatch and recorded with the attempt so
-     * the run-detail UI can show WHAT each round was asked to fix (not only that a round
-     * happened) — the gate analogue of the Tester attempt's `concerns`. Null when the gate
-     * hands its fixer no textual instructions (the conflicts gate: GitHub reports mergeability
-     * as a single bit and the harness leaves the conflict markers for the resolver).
-     */
-    readonly instructions: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    /**
-     * Structured failing checks handed to this attempt's helper (the CI gate's red check runs
-     * behind {@link instructions}), snapshotted at dispatch so each attempt shows the checks it
-     * set out to fix. Absent for the conflicts gate (no file-level detail) and when the round
-     * carried no structured checks.
-     */
-    readonly failingChecks: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-        readonly name: v.StringSchema<undefined>;
-        /** GitHub conclusion (e.g. `failure`, `timed_out`), or null when not reported. */
-        readonly conclusion: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-        /**
-         * The check run's GitHub web URL (`html_url`), so the UI can link straight to the
-         * failed run's logs. Null when GitHub didn't report one.
-         */
-        readonly url: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        /**
-         * The repo (owner/name) this check belongs to, on a MULTI-REPO block — so the UI can group
-         * failing checks by service. Absent on a single-repo block (there is only the own repo).
-         */
-        readonly repo: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>, undefined>, undefined>, undefined>;
-    /** The helper's own summary (or the failure reason), naming what it did / what remains. */
-    readonly summary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-}, undefined>;
-export type GateAttempt = v.InferOutput<typeof gateAttemptSchema>;
-export declare const gateStepStateSchema: v.ObjectSchema<{
-    readonly phase: v.PicklistSchema<["checking", "working"], undefined>;
-    /** How many helper-agent attempts have been dispatched so far. */
-    readonly attempts: v.NumberSchema<undefined>;
-    /** Ceiling on attempts, resolved from the task's merge preset at step start. */
-    readonly maxAttempts: v.NumberSchema<undefined>;
-    /** The PR head commit being gated, once resolved (the own-service PR on a multi-repo block). */
-    readonly headSha: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    /**
-     * Per-PR head commits for a MULTI-REPO block (service-connections phase 4), keyed by repo
-     * full name (owner/name) — own-service PR plus each peer-service PR. Set by the CI /
-     * conflicts gates whose precheck aggregates across every PR the task opened. Absent for a
-     * single-repo block (the scalar {@link headSha} is the only head).
-     */
-    readonly headShas: v.OptionalSchema<v.NullableSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>, undefined>;
-    /**
-     * The repo the conflicts gate's most recent `fail` verdict found conflicted, so the
-     * single-repo conflict-resolver is dispatched at THAT repo (own-service or a peer) rather
-     * than always the own-service one. Absent ⇒ the own-service repo. Only the conflicts gate
-     * sets it (the CI-fixer runs across all repos, so the CI gate leaves it undefined).
-     */
-    readonly conflictTarget: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly repo: v.StringSchema<undefined>;
-        readonly frameId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        readonly branch: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * The most recent precheck verdict, so the UI can show why the gate is looping
-     * (failing → a helper is fixing) vs idle-passing. Set on every probe.
-     */
-    readonly lastVerdict: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["pass", "pending", "fail"], undefined>, undefined>, undefined>;
-    /**
-     * Human-readable summary of the latest failing precheck (the failing CI checks /
-     * the conflict reason) — the conclusion detail that used to be fed only to the
-     * helper agent and then discarded. Carried across the helper dispatch so the
-     * window keeps showing what is being fixed. Null when the last probe passed.
-     */
-    readonly lastFailureSummary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    /**
-     * Structured failing checks behind {@link lastFailureSummary} for the CI gate, so
-     * the UI can list each red check by name + conclusion. Absent for the conflicts
-     * gate (GitHub reports no file-level detail) and when the last probe passed.
-     */
-    readonly failingChecks: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-        readonly name: v.StringSchema<undefined>;
-        /** GitHub conclusion (e.g. `failure`, `timed_out`), or null when not reported. */
-        readonly conclusion: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-        /**
-         * The check run's GitHub web URL (`html_url`), so the UI can link straight to the
-         * failed run's logs. Null when GitHub didn't report one.
-         */
-        readonly url: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        /**
-         * The repo (owner/name) this check belongs to, on a MULTI-REPO block — so the UI can group
-         * failing checks by service. Absent on a single-repo block (there is only the own repo).
-         */
-        readonly repo: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>, undefined>, undefined>, undefined>;
-    /**
-     * The fixing instructions handed to the most-recently dispatched helper (the failing-check
-     * summary / conflict reason / human fix prompt), stashed at dispatch so the attempt recorded
-     * when that helper's job settles can carry WHAT the round was asked to fix onto its
-     * {@link gateAttemptSchema} entry. Transient bookkeeping — the durable per-round history lives
-     * on {@link attemptLog}. Null when the gate hands its fixer no textual instructions.
-     */
-    readonly lastDispatchedInstructions: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    /**
-     * Epoch ms of the release marker for a time-windowed gate (post-release-health) — the
-     * moment it began watching the deployed release. The gate keeps polling `pending`
-     * until this + the preset's watch window has elapsed (then a clean run passes) or a
-     * monitor/SLO regresses (then it escalates to the on-call agent). Absent for the
-     * CI/conflicts gates.
-     */
-    readonly watchSince: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-    /**
-     * The watch-window length (minutes) for a time-windowed gate (post-release-health),
-     * resolved from the task's merge preset ONCE on first entry (alongside `maxAttempts`)
-     * so the probe doesn't re-load the block + re-resolve the preset on every poll. Absent
-     * for the CI/conflicts gates.
-     */
-    readonly watchWindowMinutes: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-    /**
-     * The regressed signals captured when the post-release-health gate escalated to the
-     * on-call agent, so the agent's completion handler can build the `release_regression`
-     * notification + incident enrichment from the SAME evidence the agent investigated
-     * — rather than re-reading Datadog (a third round-trip that could also disagree with
-     * what the agent saw if the window moved). Absent for the CI/conflicts gates.
-     */
-    readonly regressedSignals: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-        readonly kind: v.PicklistSchema<["monitor", "slo"], undefined>;
-        readonly id: v.StringSchema<undefined>;
-        readonly name: v.StringSchema<undefined>;
-        readonly state: v.PicklistSchema<["ok", "warn", "alert", "no_data"], undefined>;
-        readonly detail: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>, undefined>, undefined>, undefined>;
-    /**
-     * Append-only history of the helper-agent attempts this gate dispatched (ci-fixer /
-     * conflict-resolver runs), each recorded when its job finished. Lets the UI show what
-     * every attempt tried and how it ended, instead of only a bare `attempts` count.
-     * Absent for the post-release-health gate (its on-call helper is resolved specially).
-     */
-    readonly attemptLog: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-        /** 1-based attempt number (matches `attempts` at the time the helper was dispatched). */
-        readonly attempt: v.NumberSchema<undefined>;
-        /** Epoch ms when the helper job finished. */
-        readonly at: v.NumberSchema<undefined>;
-        /**
-         * How the helper job ended:
-         *   - `completed` — the container finished (it may or may not have fully fixed the
-         *     issue; the gate's next precheck is the source of truth, and `summary` carries
-         *     the agent's own account, e.g. which files it left conflicting).
-         *   - `failed`    — the job errored / was evicted without finishing.
-         */
-        readonly outcome: v.PicklistSchema<["completed", "failed"], undefined>;
-        /** The PR head commit the helper worked against, when known. */
-        readonly headSha: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        /**
-         * The fixing instructions handed to the helper for this round — the failing-check
-         * summary the CI gate fed the `ci-fixer`, the conflict reason / human-review comments
-         * the other gates fed their fixer. Stashed at dispatch and recorded with the attempt so
-         * the run-detail UI can show WHAT each round was asked to fix (not only that a round
-         * happened) — the gate analogue of the Tester attempt's `concerns`. Null when the gate
-         * hands its fixer no textual instructions (the conflicts gate: GitHub reports mergeability
-         * as a single bit and the harness leaves the conflict markers for the resolver).
-         */
-        readonly instructions: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        /**
-         * Structured failing checks handed to this attempt's helper (the CI gate's red check runs
-         * behind {@link instructions}), snapshotted at dispatch so each attempt shows the checks it
-         * set out to fix. Absent for the conflicts gate (no file-level detail) and when the round
-         * carried no structured checks.
-         */
-        readonly failingChecks: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-            readonly name: v.StringSchema<undefined>;
-            /** GitHub conclusion (e.g. `failure`, `timed_out`), or null when not reported. */
-            readonly conclusion: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-            /**
-             * The check run's GitHub web URL (`html_url`), so the UI can link straight to the
-             * failed run's logs. Null when GitHub didn't report one.
-             */
-            readonly url: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            /**
-             * The repo (owner/name) this check belongs to, on a MULTI-REPO block — so the UI can group
-             * failing checks by service. Absent on a single-repo block (there is only the own repo).
-             */
-            readonly repo: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        }, undefined>, undefined>, undefined>, undefined>;
-        /** The helper's own summary (or the failure reason), naming what it did / what remains. */
-        readonly summary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, undefined>, undefined>;
-    /**
-     * The number of approving reviews the PR had at the last probe, so the UI can show
-     * "1 / N approvals". The "required" side is derived from {@link requiredApprovingReviewCount}
-     * via the same `max(1, …)` floor the gate applies (see review.logic.ts) rather than persisted
-     * a second time. Absent for the other gates.
-     */
-    readonly lastApprovals: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-    /**
-     * The raw branch-protection required-approving-review count, cached after the FIRST probe
-     * resolves it so subsequent polls skip the static protection read (branch protection is repo
-     * config, not PR activity — re-reading it every poll over a multi-day review only burns GitHub
-     * rate budget). The UI's displayed "required" count is `max(1, this)` (the gate's effective
-     * floor). Absent for the other gates.
-     */
-    readonly requiredApprovingReviewCount: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-    /**
-     * The GraphQL ids of the review threads the gate just handed the `fixer`, stashed at
-     * dispatch so the helper-completion hook can post a reply + RESOLVE exactly those threads
-     * on GitHub before the next probe reads them. Absent for the other gates.
-     */
-    readonly pendingThreadIds: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>;
-    /**
-     * Epoch ms of the newest plain PR comment the gate has already handed the `fixer`. Plain
-     * conversation comments (unlike review threads) can't be "resolved" on GitHub, so they are
-     * tracked by timestamp: a comment newer than this is outstanding; the dispatch advances it to
-     * the batch max. A reviewer's later comment (newer timestamp) re-opens the work. Absent for
-     * the other gates.
-     */
-    readonly lastAddressedCommentAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-    /**
-     * The grace window (minutes) the human-review gate waits after the latest review comment
-     * before dispatching the fixer, resolved from the task's merge preset ONCE on first entry
-     * (alongside `maxAttempts`) so the probe doesn't re-resolve the preset every poll. Absent
-     * for the other gates.
-     */
-    readonly humanReviewGraceMinutes: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-    /**
-     * A human-initiated freeform fix request parked on the gate (an in-app prompt). Consumed at
-     * the top of the next `evaluateGate` pass, which dispatches the fixer with these instructions
-     * folded in — bypassing the grace window. Absent for the other gates.
-     */
-    readonly pendingFix: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly instructions: v.StringSchema<undefined>;
-        readonly at: v.NumberSchema<undefined>;
-    }, undefined>, undefined>, undefined>;
-}, undefined>;
-export type GateStepState = v.InferOutput<typeof gateStepStateSchema>;
-/**
- * State a `tester` step carries while it runs the Tester → Fixer loop. Unlike `ci`,
- * the gate's own work IS a container job (the Tester); on a withheld greenlight the
- * engine loops a `fixer` container agent and re-tests.
- *   - `phase: 'testing'` — a Tester job is in flight (tracked via the step's `jobId`).
- *   - `phase: 'fixing'`  — a Fixer job is in flight; on completion the step returns to
- *                          `testing` and a fresh Tester job is dispatched.
- */
-/**
- * One round of the Tester→Fixer loop, recorded when a `fixer` job finishes so the test
- * window can show what each fixer attempt set out to fix and how it ended — the analogue of
- * a polling gate's {@link gateAttemptSchema}, since a fixer run is otherwise an opaque
- * sub-job with no surface of its own (only a bare `attempts` count).
- */
-export declare const testerAttemptSchema: v.ObjectSchema<{
-    /** 1-based fixer round (matches `attempts` after the fixer for this round was dispatched). */
-    readonly attempt: v.NumberSchema<undefined>;
-    /** Epoch ms when the fixer job finished. */
-    readonly at: v.NumberSchema<undefined>;
-    /** Whether the fixer container finished (`completed`) or errored/was evicted (`failed`). */
-    readonly outcome: v.PicklistSchema<["completed", "failed"], undefined>;
-    /** The fixer's own summary (or the failure reason), naming what it changed / what failed. */
-    readonly summary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    /**
-     * The concerns the fixer was handed for this round (from the Tester report that withheld
-     * its greenlight), so the window can show WHAT each round tried to address — not only that
-     * a round happened.
-     */
-    readonly concerns: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-        readonly title: v.StringSchema<undefined>;
-        readonly detail: v.StringSchema<undefined>;
-        readonly severity: v.PicklistSchema<["low", "medium", "high", "critical"], undefined>;
-    }, undefined>, undefined>, undefined>, undefined>;
-}, undefined>;
-export type TesterAttempt = v.InferOutput<typeof testerAttemptSchema>;
-export declare const testerStepStateSchema: v.ObjectSchema<{
-    readonly phase: v.PicklistSchema<["testing", "fixing"], undefined>;
-    /** How many `fixer` attempts have been dispatched so far. */
-    readonly attempts: v.NumberSchema<undefined>;
-    /** Ceiling on fixer attempts, resolved from the task's merge preset at step start. */
-    readonly maxAttempts: v.NumberSchema<undefined>;
-    /** The most recent Tester report (what was tested, outcomes, concerns, greenlight). */
-    readonly lastReport: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-        readonly greenlight: v.BooleanSchema<undefined>;
-        readonly summary: v.StringSchema<undefined>;
-        readonly tested: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-        readonly outcomes: v.ArraySchema<v.ObjectSchema<{
-            readonly name: v.StringSchema<undefined>;
-            readonly status: v.PicklistSchema<["passed", "failed", "skipped"], undefined>;
-            readonly detail: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        }, undefined>, undefined>;
-        readonly concerns: v.ArraySchema<v.ObjectSchema<{
-            readonly title: v.StringSchema<undefined>;
-            readonly detail: v.StringSchema<undefined>;
-            readonly severity: v.PicklistSchema<["low", "medium", "high", "critical"], undefined>;
-        }, undefined>, undefined>;
-        readonly environment: v.OptionalSchema<v.PicklistSchema<["local", "ephemeral"], undefined>, undefined>;
-        readonly screenshots: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-            readonly view: v.StringSchema<undefined>;
-            readonly artifactId: v.StringSchema<undefined>;
-            readonly hash: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            readonly width: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-            readonly height: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-            readonly referenceArtifactId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        readonly abort: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly reason: v.StringSchema<undefined>;
-        }, undefined>, undefined>, undefined>;
-    }, undefined>, v.TransformAction<{
-        greenlight: boolean;
-        summary: string;
-        tested: string[];
-        outcomes: {
-            name: string;
-            status: "failed" | "passed" | "skipped";
-            detail?: string | undefined;
-        }[];
-        concerns: {
-            title: string;
-            detail: string;
-            severity: "critical" | "high" | "low" | "medium";
-        }[];
-        environment?: "ephemeral" | "local" | undefined;
-        screenshots?: {
-            view: string;
-            artifactId: string;
-            hash?: string | undefined;
-            width?: number | undefined;
-            height?: number | undefined;
-            referenceArtifactId?: string | undefined;
-        }[] | undefined;
-        abort?: {
-            reason: string;
-        } | null | undefined;
-    }, {
-        greenlight: boolean;
-        summary: string;
-        tested: string[];
-        outcomes: {
-            name: string;
-            status: "failed" | "passed" | "skipped";
-            detail?: string | undefined;
-        }[];
-        concerns: {
-            title: string;
-            detail: string;
-            severity: "critical" | "high" | "low" | "medium";
-        }[];
-        environment?: "ephemeral" | "local" | undefined;
-        screenshots?: {
-            view: string;
-            artifactId: string;
-            hash?: string | undefined;
-            width?: number | undefined;
-            height?: number | undefined;
-            referenceArtifactId?: string | undefined;
-        }[] | undefined;
-        abort?: {
-            reason: string;
-        } | null | undefined;
-    }>]>, undefined>, undefined>;
-    /**
-     * Append-only history of the `fixer` rounds this Tester step looped through, each recorded
-     * when its job finished. Lets the test window surface an inspectable timeline of the fixer
-     * attempts (what each addressed, how it ended) instead of only a bare `attempts` count.
-     */
-    readonly attemptLog: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-        /** 1-based fixer round (matches `attempts` after the fixer for this round was dispatched). */
-        readonly attempt: v.NumberSchema<undefined>;
-        /** Epoch ms when the fixer job finished. */
-        readonly at: v.NumberSchema<undefined>;
-        /** Whether the fixer container finished (`completed`) or errored/was evicted (`failed`). */
-        readonly outcome: v.PicklistSchema<["completed", "failed"], undefined>;
-        /** The fixer's own summary (or the failure reason), naming what it changed / what failed. */
-        readonly summary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        /**
-         * The concerns the fixer was handed for this round (from the Tester report that withheld
-         * its greenlight), so the window can show WHAT each round tried to address — not only that
-         * a round happened.
-         */
-        readonly concerns: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-            readonly title: v.StringSchema<undefined>;
-            readonly detail: v.StringSchema<undefined>;
-            readonly severity: v.PicklistSchema<["low", "medium", "high", "critical"], undefined>;
-        }, undefined>, undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, undefined>, undefined>;
-    /**
-     * The most recent in-container docker-compose dependency stand-up record (local-infra
-     * tester): whether the dependencies came up and the captured (redacted, bounded)
-     * `docker compose up` logs. Refreshed on each Tester round (it stands the infra up anew),
-     * so the test window can surface WHY local infra failed to come up — the failure-class
-     * artifact the orchestrator-side provisioning logs can't see. Absent for ephemeral /
-     * no-infra runs. See {@link testerInfraSetupSchema}.
-     */
-    readonly infraSetup: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly started: v.BooleanSchema<undefined>;
-        readonly composePath: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        readonly at: v.NumberSchema<undefined>;
-        readonly durationMs: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-        readonly logs: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        readonly error: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-}, undefined>;
-export type TesterStepState = v.InferOutput<typeof testerStepStateSchema>;
-/**
- * One test quality-control companion verdict, recorded per QC evaluation of a Tester
- * report (in order; newest last). `adequate` is the QC's judgement that the report is
- * complete enough to conclude testing / go to the fixer; when false, `gaps` lists the
- * concrete things the Tester still needs to exercise and `feedback` is the prose the
- * Tester is handed on its re-run.
- */
-export declare const testerQualityVerdictSchema: v.ObjectSchema<{
-    /** Whether the report is complete/coherent enough to proceed (no QC re-run needed). */
-    readonly adequate: v.BooleanSchema<undefined>;
-    /** The QC's prose challenge / justification, folded into the Tester's re-run context. */
-    readonly feedback: v.StringSchema<undefined>;
-    /** Concrete coverage gaps the Tester must still address (empty when adequate). */
-    readonly gaps: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-    /** Epoch ms the verdict was produced. */
-    readonly at: v.NumberSchema<undefined>;
-    /** The model that produced the verdict, for transparency. */
-    readonly model: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-}, undefined>;
-export type TesterQualityVerdict = v.InferOutput<typeof testerQualityVerdictSchema>;
-/**
- * Live test quality-control loop state carried on a run's Tester step, copied from the
- * pipeline's per-step {@link testerQualityConfigSchema} at run start. The QC companion reads
- * each Tester report BEFORE the greenlight/fixer decision; when the report is inadequate and
- * `attempts < maxAttempts` it loops the Tester (folding the prior report + `feedback` in),
- * bounded independently of the fixer budget. `verdicts` records each evaluation for the UI.
- */
-export declare const testerQualityStepStateSchema: v.ObjectSchema<{
-    /** Whether the QC companion is active on this Tester step (the builder toggle). */
-    readonly enabled: v.BooleanSchema<undefined>;
-    /** How many QC-driven Tester re-runs have been dispatched so far. */
-    readonly attempts: v.OptionalSchema<v.NumberSchema<undefined>, 0>;
-    /** Ceiling on QC-driven re-runs, from the task's merge preset (`maxTesterQualityIterations`). */
-    readonly maxAttempts: v.NumberSchema<undefined>;
-    /** Optional estimate gating copied from the pipeline; evaluated against the block estimate. */
-    readonly gating: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly enabled: v.BooleanSchema<undefined>;
-        readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-        readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-        readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-        readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["run", "skip"], undefined>, "run">;
-    }, undefined>, undefined>, undefined>;
-    /** One verdict per QC evaluation, in order (newest last). Empty before the first grade. */
-    readonly verdicts: v.ArraySchema<v.ObjectSchema<{
-        /** Whether the report is complete/coherent enough to proceed (no QC re-run needed). */
-        readonly adequate: v.BooleanSchema<undefined>;
-        /** The QC's prose challenge / justification, folded into the Tester's re-run context. */
-        readonly feedback: v.StringSchema<undefined>;
-        /** Concrete coverage gaps the Tester must still address (empty when adequate). */
-        readonly gaps: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-        /** Epoch ms the verdict was produced. */
-        readonly at: v.NumberSchema<undefined>;
-        /** The model that produced the verdict, for transparency. */
-        readonly model: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    }, undefined>, undefined>;
-    /** Set true once the QC budget was spent with the report still judged inadequate. */
-    readonly exceeded: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-}, undefined>;
-export type TesterQualityStepState = v.InferOutput<typeof testerQualityStepStateSchema>;
-/**
- * The compact ephemeral-environment view a `human-test` gate carries on its step, so the
- * dedicated window can surface the live URL/status without a second fetch. The full record
- * (with encrypted access creds) lives in the `environments` table; this is the non-secret
- * projection. Null in degraded manual mode (no env provider wired) or after the human
- * destroys the env from the gate.
- */
-/**
- * The compact, non-secret projection of the ephemeral environment a run's step is
- * associated with — its lifecycle state, public URL, TTL, and (when failed) the
- * exact provider error. Surfaced in a run's details (esp. the Tester step) so the
- * env's spinning-up / running / shut-down / errored state is visible without a
- * second fetch. The full record (with encrypted creds) lives in the `environments`
- * table. {@link humanTestEnvironmentSchema} is the human-test gate's subset of this.
- */
-export declare const runEnvironmentSchema: v.ObjectSchema<{
-    /** The `environments` row id (lets a window fetch access creds / re-poll status). */
-    readonly id: v.StringSchema<undefined>;
-    /** The provisioned public URL (null while still provisioning). */
-    readonly url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    /** The environment lifecycle status; see {@link environmentStatusSchema}. */
-    readonly status: v.PicklistSchema<["provisioning", "ready", "failed", "expired", "tearing_down", "torn_down"], undefined>;
-    /** Epoch ms the environment expires (TTL), when known. */
-    readonly expiresAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-    /** The verbatim provider error when the environment failed/expired, else null. */
-    readonly lastError: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    /**
-     * The service's declared provision type this environment was stood up for
-     * (`kubernetes` | `docker-compose` | `custom` | `infraless`), recorded at provision
-     * time so a run's details show exactly what was provisioned. Null for legacy rows /
-     * pre-resolution.
-     */
-    readonly provisionType: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["kubernetes", "docker-compose", "custom", "infraless"], undefined>, undefined>, undefined>;
-    /**
-     * The resolved engine that handled the provisioning (`local-docker` | `local-k3s` |
-     * `remote-kubernetes` | `remote-custom` | `none`), surfaced in run details alongside the
-     * environment state. Null for legacy rows / pre-resolution.
-     */
-    readonly engine: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["local-docker", "local-k3s", "remote-kubernetes", "remote-custom", "none"], undefined>, undefined>, undefined>;
-}, undefined>;
-export type RunEnvironment = v.InferOutput<typeof runEnvironmentSchema>;
-/**
- * The lifecycle status of the per-run container backing a container agent step:
- * `starting` (dispatching / cold-booting), `up` (running the agent's job),
- * `errored` (the container failed to start, was evicted, or its job faulted), and
- * `destroyed` (the run's container has been reclaimed). The SPA additionally derives
- * `destroyed` for a finished run's container steps (the container is reclaimed as a
- * unit when the run terminates), so the backend only ever persists the first three.
- */
-export declare const runContainerStatusSchema: v.PicklistSchema<["starting", "up", "errored", "destroyed"], undefined>;
-export type RunContainerStatus = v.InferOutput<typeof runContainerStatusSchema>;
-/**
- * The compact, non-secret projection of the per-run container a container agent step
- * runs in, so a run's details can show WHAT the container is doing and WHERE it lives
- * instead of a step's "spinning up container…" badge vanishing into a blank "working"
- * state once the container is up. Populated by the engine across the dispatch + poll
- * lifecycle of an async (container) step; only ever set on container-backed steps.
- */
-export declare const runContainerSchema: v.ObjectSchema<{
-    /** The container lifecycle status; see {@link runContainerStatusSchema}. */
-    readonly status: v.PicklistSchema<["starting", "up", "errored", "destroyed"], undefined>;
-    /**
-     * The coarse phase the agent's job is in while the container is `up` (`clone` →
-     * `agent` → `push`, seeded `starting`), forwarded from the harness. Lets the details
-     * distinguish "still preparing the checkout" from "the agent is making calls". Absent
-     * until the first poll, or when the runner doesn't report a phase.
-     */
-    readonly phase: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    /** Provider container/runner id (Cloudflare DO id, docker container id), when known. */
-    readonly id: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    /** A reachable address for the running container (the local docker host URL), when one exists. */
-    readonly url: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-}, undefined>;
-export type RunContainer = v.InferOutput<typeof runContainerSchema>;
-/** The web-search backend a run's container searches through, when search is available. */
-export declare const webSearchProviderSchema: v.PicklistSchema<["brave", "searxng"], undefined>;
-export type WebSearchProvider = v.InferOutput<typeof webSearchProviderSchema>;
-/**
- * Narrow a free-text stored value (a telemetry `provider` column, which is plain TEXT) back
- * to the {@link WebSearchProvider} union, or null when it isn't one. The single source of
- * truth both telemetry stores use to map their rows, so the union is defined once.
- */
-export declare function isWebSearchProvider(value: unknown): value is WebSearchProvider;
-/**
- * Whether a container agent had web search available for its run, and — when it did —
- * which upstream backend served it (resolved backend-side at dispatch from the run's
- * account keys, else the deployment default). Surfaced on a container step so the run
- * details can say "Web search: SearXNG" vs "Web search: unavailable"; it is a static
- * dispatch-time fact, NOT gated by prompt-recording telemetry (the performed queries
- * are — see the agent-search-query observability sink). `provider` is null when search
- * was unavailable.
- */
-export declare const webSearchAvailabilitySchema: v.ObjectSchema<{
-    readonly available: v.BooleanSchema<undefined>;
-    readonly provider: v.NullableSchema<v.PicklistSchema<["brave", "searxng"], undefined>, undefined>;
-}, undefined>;
-export type WebSearchAvailability = v.InferOutput<typeof webSearchAvailabilitySchema>;
-/**
- * The TERMINAL per-frame outcome of one environment a `deployer` step provisioned during a
- * multi-env fan-out (the task's own service frame + every involved-service frame): `ready`
- * (a live env, `url` set), `failed` (the provision broke, `error` carries the cause), or
- * `skipped` (the frame is `infraless`, nothing stood up). The IN-FLIGHT frame is not recorded
- * here — it lives on `step.jobId`/`step.deployFrameId` until it settles. See
- * {@link pipelineStepSchema.entries.deployEnvs}.
- */
-export declare const deployEnvStateSchema: v.ObjectSchema<{
-    readonly status: v.PicklistSchema<["ready", "failed", "skipped"], undefined>;
-    /** The provisioned URL for a `ready` env (absent for `failed`/`skipped`). */
-    readonly url: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    /** The verbatim provider error for a `failed` env. */
-    readonly error: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-}, undefined>;
-export type DeployEnvState = v.InferOutput<typeof deployEnvStateSchema>;
-/** Per-frame deploy outcomes keyed by service-frame block id; see {@link deployEnvStateSchema}. */
-export declare const deployEnvsSchema: v.RecordSchema<v.StringSchema<undefined>, v.ObjectSchema<{
-    readonly status: v.PicklistSchema<["ready", "failed", "skipped"], undefined>;
-    /** The provisioned URL for a `ready` env (absent for `failed`/`skipped`). */
-    readonly url: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    /** The verbatim provider error for a `failed` env. */
-    readonly error: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-}, undefined>, undefined>;
-export type DeployEnvs = v.InferOutput<typeof deployEnvsSchema>;
-export declare const humanTestEnvironmentSchema: v.ObjectSchema<{
-    /** The `environments` row id, so the window can fetch access creds / re-poll status. */
-    readonly id: v.StringSchema<undefined>;
-    /** The provisioned public URL the human tests against (null while still provisioning). */
-    readonly url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    /** The environment lifecycle status; see {@link environmentStatusSchema}. */
-    readonly status: v.PicklistSchema<["provisioning", "ready", "failed", "expired", "tearing_down", "torn_down"], undefined>;
-    /** Epoch ms the environment expires (TTL), when known. */
-    readonly expiresAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-}, undefined>;
-export type HumanTestEnvironment = v.InferOutput<typeof humanTestEnvironmentSchema>;
-/**
- * One round of human-driven remediation on a `human-test` gate: the human wrote findings and
- * asked for a fix (helper `fixer`), or pulled main and hit a conflict (helper
- * `conflict-resolver`). Appended when the round opens and stamped with its outcome once the
- * helper job settles, so the window can show the full history of what was asked and how it ended.
- */
-export declare const humanTestRoundSchema: v.ObjectSchema<{
-    /** The kind of round — a findings-driven fix or a pull-main-with-conflicts resolve. */
-    readonly kind: v.PicklistSchema<["fix", "pull-main"], undefined>;
-    /** The human's findings prompt (fix), or a one-line note for the pull-main round. */
-    readonly findings: v.StringSchema<undefined>;
-    /** The helper container kind this round dispatched (`fixer` / `conflict-resolver`). */
-    readonly helperKind: v.StringSchema<undefined>;
-    /** The helper job's id while it ran, for cross-referencing the run timeline. */
-    readonly jobId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    /** How the helper ended once its job settled. Absent while still in flight. */
-    readonly outcome: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["completed", "failed"], undefined>, undefined>, undefined>;
-    /** Epoch ms the round opened (the human clicked Request fix / Pull main). */
-    readonly at: v.NumberSchema<undefined>;
-}, undefined>;
-export type HumanTestRound = v.InferOutput<typeof humanTestRoundSchema>;
-/**
- * State a `human-test` gate carries while it runs. Unlike a polling gate (`ci`/`conflicts`)
- * there is no programmatic verdict — the HUMAN is the verdict — so the step spins up an
- * ephemeral environment, parks for a person to validate it, and on demand dispatches the same
- * helpers the other gates use (the Tester's `fixer` for findings; the `conflict-resolver` for a
- * conflicting pull-main). Phases:
- *   - `provisioning`        — an environment is being stood up (the driver polls until ready).
- *   - `awaiting_human`      — parked: the human tests the env and confirms / requests a fix / etc.
- *   - `fixing`              — a `fixer` job (from the human's findings) is in flight.
- *   - `resolving_conflicts` — a `conflict-resolver` job (from a conflicting pull-main) is in flight.
- *   - `passed`             — the human confirmed; the env is torn down and the run advances.
- */
-export declare const humanTestStepStateSchema: v.ObjectSchema<{
-    readonly phase: v.PicklistSchema<["provisioning", "awaiting_human", "fixing", "resolving_conflicts", "passed"], undefined>;
-    /** The live ephemeral environment (null in degraded manual mode / after destroy). */
-    readonly environment: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        /** The `environments` row id, so the window can fetch access creds / re-poll status. */
-        readonly id: v.StringSchema<undefined>;
-        /** The provisioned public URL the human tests against (null while still provisioning). */
-        readonly url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-        /** The environment lifecycle status; see {@link environmentStatusSchema}. */
-        readonly status: v.PicklistSchema<["provisioning", "ready", "failed", "expired", "tearing_down", "torn_down"], undefined>;
-        /** Epoch ms the environment expires (TTL), when known. */
-        readonly expiresAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Why no environment was auto-provisioned — set in degraded manual mode (no env provider
-     * wired, or provisioning errored) so the window can explain it and let the human test
-     * against the PR branch manually. Absent when an env was provisioned.
-     */
-    readonly degradedReason: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    /** How many helper (fixer / conflict-resolver) attempts have been dispatched so far. */
-    readonly attempts: v.NumberSchema<undefined>;
-    /** Ceiling on helper attempts, resolved from the task's merge preset (`ciMaxAttempts`). */
-    readonly maxAttempts: v.NumberSchema<undefined>;
-    /** The PR head commit being tested, when known. */
-    readonly headSha: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    /** Append-only history of fix / pull-main rounds; see {@link humanTestRoundSchema}. */
-    readonly rounds: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-        /** The kind of round — a findings-driven fix or a pull-main-with-conflicts resolve. */
-        readonly kind: v.PicklistSchema<["fix", "pull-main"], undefined>;
-        /** The human's findings prompt (fix), or a one-line note for the pull-main round. */
-        readonly findings: v.StringSchema<undefined>;
-        /** The helper container kind this round dispatched (`fixer` / `conflict-resolver`). */
-        readonly helperKind: v.StringSchema<undefined>;
-        /** The helper job's id while it ran, for cross-referencing the run timeline. */
-        readonly jobId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        /** How the helper ended once its job settled. Absent while still in flight. */
-        readonly outcome: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["completed", "failed"], undefined>, undefined>, undefined>;
-        /** Epoch ms the round opened (the human clicked Request fix / Pull main). */
-        readonly at: v.NumberSchema<undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Transient action the human requested while the gate is parked — recorded on the parked
-     * step and consumed by the durable driver when it re-enters the gate (the analogue of
-     * `pendingIncorporation` on a requirements gate). Cleared once the driver acts on it.
-     */
-    readonly pendingAction: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly type: v.PicklistSchema<["confirm", "request-fix", "pull-main", "recreate"], undefined>;
-        /** The findings prompt for a `request-fix` action. */
-        readonly findings: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-}, undefined>;
-export type HumanTestStepState = v.InferOutput<typeof humanTestStepStateSchema>;
-/**
- * One actual-vs-reference pairing the visual-confirmation gate shows the human: a logical
- * view, the screenshot the UI tester captured of it (`actualArtifactId`), and the reference
- * design image for the same view when one was uploaded (`referenceArtifactId`). Either side
- * may be absent (a captured view with no reference, or a reference whose view wasn't captured).
- */
-export declare const visualConfirmPairSchema: v.ObjectSchema<{
-    readonly view: v.StringSchema<undefined>;
-    readonly actualArtifactId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    readonly referenceArtifactId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-}, undefined>;
-export type VisualConfirmPair = v.InferOutput<typeof visualConfirmPairSchema>;
-/** One human-requested fix round on a visual-confirmation gate (dispatches the `fixer`). */
-export declare const visualConfirmRoundSchema: v.ObjectSchema<{
-    readonly findings: v.StringSchema<undefined>;
-    readonly helperKind: v.StringSchema<undefined>;
-    readonly jobId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    readonly outcome: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["completed", "failed"], undefined>, undefined>, undefined>;
-    readonly at: v.NumberSchema<undefined>;
-}, undefined>;
-export type VisualConfirmRound = v.InferOutput<typeof visualConfirmRoundSchema>;
-/**
- * State a `visual-confirmation` gate carries while it runs. Like `human-test` there is no
- * programmatic verdict — a HUMAN reviews the UI tester's screenshots against the uploaded
- * reference designs and approves, or requests a fix (which dispatches the `fixer` and then
- * re-captures via the UI tester). Phases:
- *   - `awaiting_human`— parked: the human reviews actual-vs-reference and approves / requests a fix.
- *   - `fixing`        — a `fixer` job (from the human's findings) is in flight.
- *   - `approved`      — the human approved; the run advances.
- *
- * (A dedicated `capturing` phase for an auto re-run of the UI tester after a fix is deferred
- * until that loop is wired — see the visual-confirmation handover doc — so it is intentionally
- * absent from the picklist rather than carried as dead state.)
- */
-export declare const visualConfirmStepStateSchema: v.ObjectSchema<{
-    readonly phase: v.PicklistSchema<["awaiting_human", "fixing", "approved"], undefined>;
-    /** The actual-vs-reference pairs the human reviews, refreshed on each (re)capture. */
-    readonly pairs: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-        readonly view: v.StringSchema<undefined>;
-        readonly actualArtifactId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        readonly referenceArtifactId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /** Set when no screenshots could be gathered (no UI tester ran / no storage) — manual mode. */
-    readonly degradedReason: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    /** How many fixer attempts have been dispatched so far. */
-    readonly attempts: v.NumberSchema<undefined>;
-    /** Ceiling on fixer attempts, resolved from the task's merge preset (`ciMaxAttempts`). */
-    readonly maxAttempts: v.NumberSchema<undefined>;
-    /** Append-only history of fix rounds; see {@link visualConfirmRoundSchema}. */
-    readonly rounds: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-        readonly findings: v.StringSchema<undefined>;
-        readonly helperKind: v.StringSchema<undefined>;
-        readonly jobId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        readonly outcome: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["completed", "failed"], undefined>, undefined>, undefined>;
-        readonly at: v.NumberSchema<undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Transient action the human requested while parked — consumed by the durable driver
-     * when it re-enters the gate. Cleared once acted on.
-     */
-    readonly pendingAction: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly type: v.PicklistSchema<["approve", "request-fix", "recapture"], undefined>;
-        /** The findings prompt for a `request-fix` action. */
-        readonly findings: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-}, undefined>;
-export type VisualConfirmStepState = v.InferOutput<typeof visualConfirmStepStateSchema>;
-/**
- * Per-step LLM observability rollup: a compact aggregate over every model call the
- * step's container made, recorded by the LLM proxy and summed by the engine for the
- * board. It surfaces, at a glance, token usage, how close the step ran to its
- * output-token limit (truncation), the latency split between transport/proxy
- * overhead and actual model execution, and any errors/warnings. The full per-call
- * detail (prompts + responses) is fetched on demand for the drill-down panel.
- * Absent when the observability sink is not wired.
- */
-export declare const stepMetricsSchema: v.ObjectSchema<{
-    /** Number of model calls recorded for this step. */
-    readonly calls: v.NumberSchema<undefined>;
-    /** Sum of prompt (input) tokens across the step's calls. */
-    readonly promptTokens: v.NumberSchema<undefined>;
-    /**
-     * Sum of prompt tokens served from the provider's prefix cache. A subset of
-     * promptTokens on OpenAI/DeepSeek, but on Anthropic cache reads are reported
-     * separately from input tokens, so this can exceed promptTokens. 0 on a cache-less
-     * flavour (Workers AI); the metrics bar shows the cached split when present. Absent ⇒
-     * unknown (older snapshot).
-     */
-    readonly cachedPromptTokens: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-    /** Sum of completion (output) tokens across the step's calls. */
-    readonly completionTokens: v.NumberSchema<undefined>;
-    /** Largest single completion the model produced (closest approach to the limit). */
-    readonly peakCompletionTokens: v.NumberSchema<undefined>;
-    /** The output ceiling in effect (max requested `max_tokens`), or null when unknown. */
-    readonly maxOutputTokens: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
-    /** Calls cut short by the output limit (`finish_reason === 'length'`). */
-    readonly truncatedCalls: v.NumberSchema<undefined>;
-    /** Sum of model execution time (ms) — the "actual prompt/tool execution" slice. */
-    readonly upstreamMs: v.NumberSchema<undefined>;
-    /** Sum of transport/proxy overhead (ms) — the interim-layer cost. */
-    readonly overheadMs: v.NumberSchema<undefined>;
-    /** Calls that failed (non-2xx / refused / in-process error). */
-    readonly errors: v.NumberSchema<undefined>;
-    /** Successful calls that warned (truncated or content-filtered). */
-    readonly warnings: v.NumberSchema<undefined>;
-}, undefined>;
-export type StepMetrics = v.InferOutput<typeof stepMetricsSchema>;
-export declare const pipelineStepSchema: v.ObjectSchema<{
-    /**
-     * Id of the execution run (the {@link executionInstanceSchema} `id`) this step
-     * belongs to — surfaced on every step so a lone step in a log line or a detail view
-     * can name its run, for easier debugging. A projection that always equals the parent
-     * instance's `id`: stamped from the enclosing instance when the run is read or
-     * emitted, not persisted independently. Absent only on steps not yet round-tripped.
-     */
-    readonly runId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    readonly agentKind: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-    readonly state: v.PicklistSchema<["pending", "working", "waiting_decision", "done"], undefined>;
-    readonly progress: v.NumberSchema<undefined>;
-    /** LLM observability rollup for this step; see {@link stepMetricsSchema}. */
-    readonly metrics: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        /** Number of model calls recorded for this step. */
-        readonly calls: v.NumberSchema<undefined>;
-        /** Sum of prompt (input) tokens across the step's calls. */
-        readonly promptTokens: v.NumberSchema<undefined>;
-        /**
-         * Sum of prompt tokens served from the provider's prefix cache. A subset of
-         * promptTokens on OpenAI/DeepSeek, but on Anthropic cache reads are reported
-         * separately from input tokens, so this can exceed promptTokens. 0 on a cache-less
-         * flavour (Workers AI); the metrics bar shows the cached split when present. Absent ⇒
-         * unknown (older snapshot).
-         */
-        readonly cachedPromptTokens: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-        /** Sum of completion (output) tokens across the step's calls. */
-        readonly completionTokens: v.NumberSchema<undefined>;
-        /** Largest single completion the model produced (closest approach to the limit). */
-        readonly peakCompletionTokens: v.NumberSchema<undefined>;
-        /** The output ceiling in effect (max requested `max_tokens`), or null when unknown. */
-        readonly maxOutputTokens: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
-        /** Calls cut short by the output limit (`finish_reason === 'length'`). */
-        readonly truncatedCalls: v.NumberSchema<undefined>;
-        /** Sum of model execution time (ms) — the "actual prompt/tool execution" slice. */
-        readonly upstreamMs: v.NumberSchema<undefined>;
-        /** Sum of transport/proxy overhead (ms) — the interim-layer cost. */
-        readonly overheadMs: v.NumberSchema<undefined>;
-        /** Calls that failed (non-2xx / refused / in-process error). */
-        readonly errors: v.NumberSchema<undefined>;
-        /** Successful calls that warned (truncated or content-filtered). */
-        readonly warnings: v.NumberSchema<undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Live gate state while a polling gate step (`ci` / `conflicts`) runs its
-     * precheck-or-escalate loop; see {@link gateStepStateSchema}. The gate kind is
-     * `agentKind`.
-     */
-    readonly gate: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly phase: v.PicklistSchema<["checking", "working"], undefined>;
-        /** How many helper-agent attempts have been dispatched so far. */
-        readonly attempts: v.NumberSchema<undefined>;
-        /** Ceiling on attempts, resolved from the task's merge preset at step start. */
-        readonly maxAttempts: v.NumberSchema<undefined>;
-        /** The PR head commit being gated, once resolved (the own-service PR on a multi-repo block). */
-        readonly headSha: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        /**
-         * Per-PR head commits for a MULTI-REPO block (service-connections phase 4), keyed by repo
-         * full name (owner/name) — own-service PR plus each peer-service PR. Set by the CI /
-         * conflicts gates whose precheck aggregates across every PR the task opened. Absent for a
-         * single-repo block (the scalar {@link headSha} is the only head).
-         */
-        readonly headShas: v.OptionalSchema<v.NullableSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>, undefined>;
-        /**
-         * The repo the conflicts gate's most recent `fail` verdict found conflicted, so the
-         * single-repo conflict-resolver is dispatched at THAT repo (own-service or a peer) rather
-         * than always the own-service one. Absent ⇒ the own-service repo. Only the conflicts gate
-         * sets it (the CI-fixer runs across all repos, so the CI gate leaves it undefined).
-         */
-        readonly conflictTarget: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly repo: v.StringSchema<undefined>;
-            readonly frameId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            readonly branch: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * The most recent precheck verdict, so the UI can show why the gate is looping
-         * (failing → a helper is fixing) vs idle-passing. Set on every probe.
-         */
-        readonly lastVerdict: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["pass", "pending", "fail"], undefined>, undefined>, undefined>;
-        /**
-         * Human-readable summary of the latest failing precheck (the failing CI checks /
-         * the conflict reason) — the conclusion detail that used to be fed only to the
-         * helper agent and then discarded. Carried across the helper dispatch so the
-         * window keeps showing what is being fixed. Null when the last probe passed.
-         */
-        readonly lastFailureSummary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        /**
-         * Structured failing checks behind {@link lastFailureSummary} for the CI gate, so
-         * the UI can list each red check by name + conclusion. Absent for the conflicts
-         * gate (GitHub reports no file-level detail) and when the last probe passed.
-         */
-        readonly failingChecks: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-            readonly name: v.StringSchema<undefined>;
-            /** GitHub conclusion (e.g. `failure`, `timed_out`), or null when not reported. */
-            readonly conclusion: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-            /**
-             * The check run's GitHub web URL (`html_url`), so the UI can link straight to the
-             * failed run's logs. Null when GitHub didn't report one.
-             */
-            readonly url: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            /**
-             * The repo (owner/name) this check belongs to, on a MULTI-REPO block — so the UI can group
-             * failing checks by service. Absent on a single-repo block (there is only the own repo).
-             */
-            readonly repo: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        }, undefined>, undefined>, undefined>, undefined>;
-        /**
-         * The fixing instructions handed to the most-recently dispatched helper (the failing-check
-         * summary / conflict reason / human fix prompt), stashed at dispatch so the attempt recorded
-         * when that helper's job settles can carry WHAT the round was asked to fix onto its
-         * {@link gateAttemptSchema} entry. Transient bookkeeping — the durable per-round history lives
-         * on {@link attemptLog}. Null when the gate hands its fixer no textual instructions.
-         */
-        readonly lastDispatchedInstructions: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        /**
-         * Epoch ms of the release marker for a time-windowed gate (post-release-health) — the
-         * moment it began watching the deployed release. The gate keeps polling `pending`
-         * until this + the preset's watch window has elapsed (then a clean run passes) or a
-         * monitor/SLO regresses (then it escalates to the on-call agent). Absent for the
-         * CI/conflicts gates.
-         */
-        readonly watchSince: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-        /**
-         * The watch-window length (minutes) for a time-windowed gate (post-release-health),
-         * resolved from the task's merge preset ONCE on first entry (alongside `maxAttempts`)
-         * so the probe doesn't re-load the block + re-resolve the preset on every poll. Absent
-         * for the CI/conflicts gates.
-         */
-        readonly watchWindowMinutes: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-        /**
-         * The regressed signals captured when the post-release-health gate escalated to the
-         * on-call agent, so the agent's completion handler can build the `release_regression`
-         * notification + incident enrichment from the SAME evidence the agent investigated
-         * — rather than re-reading Datadog (a third round-trip that could also disagree with
-         * what the agent saw if the window moved). Absent for the CI/conflicts gates.
-         */
-        readonly regressedSignals: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-            readonly kind: v.PicklistSchema<["monitor", "slo"], undefined>;
-            readonly id: v.StringSchema<undefined>;
-            readonly name: v.StringSchema<undefined>;
-            readonly state: v.PicklistSchema<["ok", "warn", "alert", "no_data"], undefined>;
-            readonly detail: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        }, undefined>, undefined>, undefined>, undefined>;
-        /**
-         * Append-only history of the helper-agent attempts this gate dispatched (ci-fixer /
-         * conflict-resolver runs), each recorded when its job finished. Lets the UI show what
-         * every attempt tried and how it ended, instead of only a bare `attempts` count.
-         * Absent for the post-release-health gate (its on-call helper is resolved specially).
-         */
-        readonly attemptLog: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-            /** 1-based attempt number (matches `attempts` at the time the helper was dispatched). */
-            readonly attempt: v.NumberSchema<undefined>;
-            /** Epoch ms when the helper job finished. */
-            readonly at: v.NumberSchema<undefined>;
-            /**
-             * How the helper job ended:
-             *   - `completed` — the container finished (it may or may not have fully fixed the
-             *     issue; the gate's next precheck is the source of truth, and `summary` carries
-             *     the agent's own account, e.g. which files it left conflicting).
-             *   - `failed`    — the job errored / was evicted without finishing.
-             */
-            readonly outcome: v.PicklistSchema<["completed", "failed"], undefined>;
-            /** The PR head commit the helper worked against, when known. */
-            readonly headSha: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            /**
-             * The fixing instructions handed to the helper for this round — the failing-check
-             * summary the CI gate fed the `ci-fixer`, the conflict reason / human-review comments
-             * the other gates fed their fixer. Stashed at dispatch and recorded with the attempt so
-             * the run-detail UI can show WHAT each round was asked to fix (not only that a round
-             * happened) — the gate analogue of the Tester attempt's `concerns`. Null when the gate
-             * hands its fixer no textual instructions (the conflicts gate: GitHub reports mergeability
-             * as a single bit and the harness leaves the conflict markers for the resolver).
-             */
-            readonly instructions: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            /**
-             * Structured failing checks handed to this attempt's helper (the CI gate's red check runs
-             * behind {@link instructions}), snapshotted at dispatch so each attempt shows the checks it
-             * set out to fix. Absent for the conflicts gate (no file-level detail) and when the round
-             * carried no structured checks.
-             */
-            readonly failingChecks: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-                readonly name: v.StringSchema<undefined>;
-                /** GitHub conclusion (e.g. `failure`, `timed_out`), or null when not reported. */
-                readonly conclusion: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-                /**
-                 * The check run's GitHub web URL (`html_url`), so the UI can link straight to the
-                 * failed run's logs. Null when GitHub didn't report one.
-                 */
-                readonly url: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                /**
-                 * The repo (owner/name) this check belongs to, on a MULTI-REPO block — so the UI can group
-                 * failing checks by service. Absent on a single-repo block (there is only the own repo).
-                 */
-                readonly repo: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            }, undefined>, undefined>, undefined>, undefined>;
-            /** The helper's own summary (or the failure reason), naming what it did / what remains. */
-            readonly summary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        }, undefined>, undefined>, undefined>, undefined>;
-        /**
-         * The number of approving reviews the PR had at the last probe, so the UI can show
-         * "1 / N approvals". The "required" side is derived from {@link requiredApprovingReviewCount}
-         * via the same `max(1, …)` floor the gate applies (see review.logic.ts) rather than persisted
-         * a second time. Absent for the other gates.
-         */
-        readonly lastApprovals: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-        /**
-         * The raw branch-protection required-approving-review count, cached after the FIRST probe
-         * resolves it so subsequent polls skip the static protection read (branch protection is repo
-         * config, not PR activity — re-reading it every poll over a multi-day review only burns GitHub
-         * rate budget). The UI's displayed "required" count is `max(1, this)` (the gate's effective
-         * floor). Absent for the other gates.
-         */
-        readonly requiredApprovingReviewCount: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-        /**
-         * The GraphQL ids of the review threads the gate just handed the `fixer`, stashed at
-         * dispatch so the helper-completion hook can post a reply + RESOLVE exactly those threads
-         * on GitHub before the next probe reads them. Absent for the other gates.
-         */
-        readonly pendingThreadIds: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>;
-        /**
-         * Epoch ms of the newest plain PR comment the gate has already handed the `fixer`. Plain
-         * conversation comments (unlike review threads) can't be "resolved" on GitHub, so they are
-         * tracked by timestamp: a comment newer than this is outstanding; the dispatch advances it to
-         * the batch max. A reviewer's later comment (newer timestamp) re-opens the work. Absent for
-         * the other gates.
-         */
-        readonly lastAddressedCommentAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-        /**
-         * The grace window (minutes) the human-review gate waits after the latest review comment
-         * before dispatching the fixer, resolved from the task's merge preset ONCE on first entry
-         * (alongside `maxAttempts`) so the probe doesn't re-resolve the preset every poll. Absent
-         * for the other gates.
-         */
-        readonly humanReviewGraceMinutes: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-        /**
-         * A human-initiated freeform fix request parked on the gate (an in-app prompt). Consumed at
-         * the top of the next `evaluateGate` pass, which dispatches the fixer with these instructions
-         * folded in — bypassing the grace window. Absent for the other gates.
-         */
-        readonly pendingFix: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly instructions: v.StringSchema<undefined>;
-            readonly at: v.NumberSchema<undefined>;
-        }, undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /** Live Tester→Fixer loop state while a `tester` step runs/fixes; see {@link testerStepStateSchema}. */
-    readonly test: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly phase: v.PicklistSchema<["testing", "fixing"], undefined>;
-        /** How many `fixer` attempts have been dispatched so far. */
-        readonly attempts: v.NumberSchema<undefined>;
-        /** Ceiling on fixer attempts, resolved from the task's merge preset at step start. */
-        readonly maxAttempts: v.NumberSchema<undefined>;
-        /** The most recent Tester report (what was tested, outcomes, concerns, greenlight). */
-        readonly lastReport: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-            readonly greenlight: v.BooleanSchema<undefined>;
-            readonly summary: v.StringSchema<undefined>;
-            readonly tested: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-            readonly outcomes: v.ArraySchema<v.ObjectSchema<{
-                readonly name: v.StringSchema<undefined>;
-                readonly status: v.PicklistSchema<["passed", "failed", "skipped"], undefined>;
-                readonly detail: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            }, undefined>, undefined>;
-            readonly concerns: v.ArraySchema<v.ObjectSchema<{
-                readonly title: v.StringSchema<undefined>;
-                readonly detail: v.StringSchema<undefined>;
-                readonly severity: v.PicklistSchema<["low", "medium", "high", "critical"], undefined>;
-            }, undefined>, undefined>;
-            readonly environment: v.OptionalSchema<v.PicklistSchema<["local", "ephemeral"], undefined>, undefined>;
-            readonly screenshots: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                readonly view: v.StringSchema<undefined>;
-                readonly artifactId: v.StringSchema<undefined>;
-                readonly hash: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                readonly width: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-                readonly height: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-                readonly referenceArtifactId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            }, undefined>, undefined>, undefined>;
-            readonly abort: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                readonly reason: v.StringSchema<undefined>;
-            }, undefined>, undefined>, undefined>;
-        }, undefined>, v.TransformAction<{
-            greenlight: boolean;
-            summary: string;
-            tested: string[];
-            outcomes: {
-                name: string;
-                status: "failed" | "passed" | "skipped";
-                detail?: string | undefined;
-            }[];
-            concerns: {
-                title: string;
-                detail: string;
-                severity: "critical" | "high" | "low" | "medium";
-            }[];
-            environment?: "ephemeral" | "local" | undefined;
-            screenshots?: {
-                view: string;
-                artifactId: string;
-                hash?: string | undefined;
-                width?: number | undefined;
-                height?: number | undefined;
-                referenceArtifactId?: string | undefined;
-            }[] | undefined;
-            abort?: {
-                reason: string;
-            } | null | undefined;
-        }, {
-            greenlight: boolean;
-            summary: string;
-            tested: string[];
-            outcomes: {
-                name: string;
-                status: "failed" | "passed" | "skipped";
-                detail?: string | undefined;
-            }[];
-            concerns: {
-                title: string;
-                detail: string;
-                severity: "critical" | "high" | "low" | "medium";
-            }[];
-            environment?: "ephemeral" | "local" | undefined;
-            screenshots?: {
-                view: string;
-                artifactId: string;
-                hash?: string | undefined;
-                width?: number | undefined;
-                height?: number | undefined;
-                referenceArtifactId?: string | undefined;
-            }[] | undefined;
-            abort?: {
-                reason: string;
-            } | null | undefined;
-        }>]>, undefined>, undefined>;
-        /**
-         * Append-only history of the `fixer` rounds this Tester step looped through, each recorded
-         * when its job finished. Lets the test window surface an inspectable timeline of the fixer
-         * attempts (what each addressed, how it ended) instead of only a bare `attempts` count.
-         */
-        readonly attemptLog: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-            /** 1-based fixer round (matches `attempts` after the fixer for this round was dispatched). */
-            readonly attempt: v.NumberSchema<undefined>;
-            /** Epoch ms when the fixer job finished. */
-            readonly at: v.NumberSchema<undefined>;
-            /** Whether the fixer container finished (`completed`) or errored/was evicted (`failed`). */
-            readonly outcome: v.PicklistSchema<["completed", "failed"], undefined>;
-            /** The fixer's own summary (or the failure reason), naming what it changed / what failed. */
-            readonly summary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            /**
-             * The concerns the fixer was handed for this round (from the Tester report that withheld
-             * its greenlight), so the window can show WHAT each round tried to address — not only that
-             * a round happened.
-             */
-            readonly concerns: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-                readonly title: v.StringSchema<undefined>;
-                readonly detail: v.StringSchema<undefined>;
-                readonly severity: v.PicklistSchema<["low", "medium", "high", "critical"], undefined>;
-            }, undefined>, undefined>, undefined>, undefined>;
-        }, undefined>, undefined>, undefined>, undefined>;
-        /**
-         * The most recent in-container docker-compose dependency stand-up record (local-infra
-         * tester): whether the dependencies came up and the captured (redacted, bounded)
-         * `docker compose up` logs. Refreshed on each Tester round (it stands the infra up anew),
-         * so the test window can surface WHY local infra failed to come up — the failure-class
-         * artifact the orchestrator-side provisioning logs can't see. Absent for ephemeral /
-         * no-infra runs. See {@link testerInfraSetupSchema}.
-         */
-        readonly infraSetup: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly started: v.BooleanSchema<undefined>;
-            readonly composePath: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly at: v.NumberSchema<undefined>;
-            readonly durationMs: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-            readonly logs: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly error: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Live test quality-control companion state on a `tester-api`/`tester-ui` step, copied
-     * from the pipeline's per-step `testerQuality` config at run start. Drives the QC loop that
-     * gates each Tester report for completeness before the greenlight/fixer decision. Absent
-     * for non-Tester steps / when the companion is disabled. See {@link testerQualityStepStateSchema}.
-     */
-    readonly testerQuality: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        /** Whether the QC companion is active on this Tester step (the builder toggle). */
-        readonly enabled: v.BooleanSchema<undefined>;
-        /** How many QC-driven Tester re-runs have been dispatched so far. */
-        readonly attempts: v.OptionalSchema<v.NumberSchema<undefined>, 0>;
-        /** Ceiling on QC-driven re-runs, from the task's merge preset (`maxTesterQualityIterations`). */
-        readonly maxAttempts: v.NumberSchema<undefined>;
-        /** Optional estimate gating copied from the pipeline; evaluated against the block estimate. */
-        readonly gating: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly enabled: v.BooleanSchema<undefined>;
-            readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-            readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-            readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-            readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["run", "skip"], undefined>, "run">;
-        }, undefined>, undefined>, undefined>;
-        /** One verdict per QC evaluation, in order (newest last). Empty before the first grade. */
-        readonly verdicts: v.ArraySchema<v.ObjectSchema<{
-            /** Whether the report is complete/coherent enough to proceed (no QC re-run needed). */
-            readonly adequate: v.BooleanSchema<undefined>;
-            /** The QC's prose challenge / justification, folded into the Tester's re-run context. */
-            readonly feedback: v.StringSchema<undefined>;
-            /** Concrete coverage gaps the Tester must still address (empty when adequate). */
-            readonly gaps: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-            /** Epoch ms the verdict was produced. */
-            readonly at: v.NumberSchema<undefined>;
-            /** The model that produced the verdict, for transparency. */
-            readonly model: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        }, undefined>, undefined>;
-        /** Set true once the QC budget was spent with the report still judged inadequate. */
-        readonly exceeded: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Live state of a `human-test` gate (ephemeral env + human validation loop); see
-     * {@link humanTestStepStateSchema}. Absent for every other step kind.
-     */
-    readonly humanTest: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly phase: v.PicklistSchema<["provisioning", "awaiting_human", "fixing", "resolving_conflicts", "passed"], undefined>;
-        /** The live ephemeral environment (null in degraded manual mode / after destroy). */
-        readonly environment: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            /** The `environments` row id, so the window can fetch access creds / re-poll status. */
-            readonly id: v.StringSchema<undefined>;
-            /** The provisioned public URL the human tests against (null while still provisioning). */
-            readonly url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-            /** The environment lifecycle status; see {@link environmentStatusSchema}. */
-            readonly status: v.PicklistSchema<["provisioning", "ready", "failed", "expired", "tearing_down", "torn_down"], undefined>;
-            /** Epoch ms the environment expires (TTL), when known. */
-            readonly expiresAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * Why no environment was auto-provisioned — set in degraded manual mode (no env provider
-         * wired, or provisioning errored) so the window can explain it and let the human test
-         * against the PR branch manually. Absent when an env was provisioned.
-         */
-        readonly degradedReason: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        /** How many helper (fixer / conflict-resolver) attempts have been dispatched so far. */
-        readonly attempts: v.NumberSchema<undefined>;
-        /** Ceiling on helper attempts, resolved from the task's merge preset (`ciMaxAttempts`). */
-        readonly maxAttempts: v.NumberSchema<undefined>;
-        /** The PR head commit being tested, when known. */
-        readonly headSha: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        /** Append-only history of fix / pull-main rounds; see {@link humanTestRoundSchema}. */
-        readonly rounds: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-            /** The kind of round — a findings-driven fix or a pull-main-with-conflicts resolve. */
-            readonly kind: v.PicklistSchema<["fix", "pull-main"], undefined>;
-            /** The human's findings prompt (fix), or a one-line note for the pull-main round. */
-            readonly findings: v.StringSchema<undefined>;
-            /** The helper container kind this round dispatched (`fixer` / `conflict-resolver`). */
-            readonly helperKind: v.StringSchema<undefined>;
-            /** The helper job's id while it ran, for cross-referencing the run timeline. */
-            readonly jobId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            /** How the helper ended once its job settled. Absent while still in flight. */
-            readonly outcome: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["completed", "failed"], undefined>, undefined>, undefined>;
-            /** Epoch ms the round opened (the human clicked Request fix / Pull main). */
-            readonly at: v.NumberSchema<undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * Transient action the human requested while the gate is parked — recorded on the parked
-         * step and consumed by the durable driver when it re-enters the gate (the analogue of
-         * `pendingIncorporation` on a requirements gate). Cleared once the driver acts on it.
-         */
-        readonly pendingAction: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly type: v.PicklistSchema<["confirm", "request-fix", "pull-main", "recreate"], undefined>;
-            /** The findings prompt for a `request-fix` action. */
-            readonly findings: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Live state of a `visual-confirmation` gate (screenshot review + fix loop); see
-     * {@link visualConfirmStepStateSchema}. Absent for every other step kind.
-     */
-    readonly visualConfirm: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly phase: v.PicklistSchema<["awaiting_human", "fixing", "approved"], undefined>;
-        /** The actual-vs-reference pairs the human reviews, refreshed on each (re)capture. */
-        readonly pairs: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-            readonly view: v.StringSchema<undefined>;
-            readonly actualArtifactId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly referenceArtifactId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /** Set when no screenshots could be gathered (no UI tester ran / no storage) — manual mode. */
-        readonly degradedReason: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        /** How many fixer attempts have been dispatched so far. */
-        readonly attempts: v.NumberSchema<undefined>;
-        /** Ceiling on fixer attempts, resolved from the task's merge preset (`ciMaxAttempts`). */
-        readonly maxAttempts: v.NumberSchema<undefined>;
-        /** Append-only history of fix rounds; see {@link visualConfirmRoundSchema}. */
-        readonly rounds: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-            readonly findings: v.StringSchema<undefined>;
-            readonly helperKind: v.StringSchema<undefined>;
-            readonly jobId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly outcome: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["completed", "failed"], undefined>, undefined>, undefined>;
-            readonly at: v.NumberSchema<undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * Transient action the human requested while parked — consumed by the durable driver
-         * when it re-enters the gate. Cleared once acted on.
-         */
-        readonly pendingAction: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly type: v.PicklistSchema<["approve", "request-fix", "recapture"], undefined>;
-            /** The findings prompt for a `request-fix` action. */
-            readonly findings: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * The ephemeral environment this step runs against (when the block has one), so a
-     * run's details can show its spinning-up / running / shut-down / errored state +
-     * the exact error. Populated by the engine for container/deployer steps from the
-     * block's live environment; see {@link runEnvironmentSchema}. The `human-test` gate
-     * keeps its own richer `humanTest.environment` and is not double-populated here.
-     */
-    readonly environment: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        /** The `environments` row id (lets a window fetch access creds / re-poll status). */
-        readonly id: v.StringSchema<undefined>;
-        /** The provisioned public URL (null while still provisioning). */
-        readonly url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-        /** The environment lifecycle status; see {@link environmentStatusSchema}. */
-        readonly status: v.PicklistSchema<["provisioning", "ready", "failed", "expired", "tearing_down", "torn_down"], undefined>;
-        /** Epoch ms the environment expires (TTL), when known. */
-        readonly expiresAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-        /** The verbatim provider error when the environment failed/expired, else null. */
-        readonly lastError: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        /**
-         * The service's declared provision type this environment was stood up for
-         * (`kubernetes` | `docker-compose` | `custom` | `infraless`), recorded at provision
-         * time so a run's details show exactly what was provisioned. Null for legacy rows /
-         * pre-resolution.
-         */
-        readonly provisionType: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["kubernetes", "docker-compose", "custom", "infraless"], undefined>, undefined>, undefined>;
-        /**
-         * The resolved engine that handled the provisioning (`local-docker` | `local-k3s` |
-         * `remote-kubernetes` | `remote-custom` | `none`), surfaced in run details alongside the
-         * environment state. Null for legacy rows / pre-resolution.
-         */
-        readonly engine: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["local-docker", "local-k3s", "remote-kubernetes", "remote-custom", "none"], undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /** Live subtask counts while an async (container) step runs; see {@link stepSubtasksSchema}. */
-    readonly subtasks: v.OptionalSchema<v.ObjectSchema<{
-        readonly completed: v.NumberSchema<undefined>;
-        readonly inProgress: v.NumberSchema<undefined>;
-        readonly total: v.NumberSchema<undefined>;
-        readonly items: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-            /** The task's human-readable subject, as the agent wrote it. */
-            readonly label: v.StringSchema<undefined>;
-            readonly status: v.PicklistSchema<["pending", "in_progress", "completed"], undefined>;
-        }, undefined>, undefined>, undefined>;
-    }, undefined>, undefined>;
-    /**
-     * The per-run container this async (container) step runs in — its lifecycle status
-     * (starting / up / errored), the agent's current phase (clone / agent / push), and
-     * the container's id + reachable URL once up. Lets a run's details surface what the
-     * container is doing and where it lives, so the board shows an explicit "Spinning up
-     * container…" → live-phase progression instead of a blank "working" state. Set the
-     * moment the job is dispatched (the dispatch blocks until the container accepts the
-     * job) and refined on each poll. Only ever set on async (container) steps; absent on
-     * non-container steps and steps not yet dispatched. See {@link runContainerSchema}.
-     */
-    readonly container: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        /** The container lifecycle status; see {@link runContainerStatusSchema}. */
-        readonly status: v.PicklistSchema<["starting", "up", "errored", "destroyed"], undefined>;
-        /**
-         * The coarse phase the agent's job is in while the container is `up` (`clone` →
-         * `agent` → `push`, seeded `starting`), forwarded from the harness. Lets the details
-         * distinguish "still preparing the checkout" from "the agent is making calls". Absent
-         * until the first poll, or when the runner doesn't report a phase.
-         */
-        readonly phase: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        /** Provider container/runner id (Cloudflare DO id, docker container id), when known. */
-        readonly id: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        /** A reachable address for the running container (the local docker host URL), when one exists. */
-        readonly url: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Whether web search was available to this container step, and which upstream backend
-     * served it. Set at dispatch (a static per-run fact resolved from the account's
-     * web-search keys, else the deployment default). Only ever set on async (container)
-     * steps; absent on non-container steps and steps not yet dispatched. Distinct from the
-     * telemetry-gated per-query log — this is always surfaced. See {@link webSearchAvailabilitySchema}.
-     */
-    readonly search: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly available: v.BooleanSchema<undefined>;
-        readonly provider: v.NullableSchema<v.PicklistSchema<["brave", "searxng"], undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    readonly decision: v.NullableSchema<v.ObjectSchema<{
-        readonly id: v.StringSchema<undefined>;
-        readonly question: v.StringSchema<undefined>;
-        readonly options: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-        readonly chosen: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>, undefined>;
-    /**
-     * Whether a human approval gate fires after this step completes. Copied from
-     * the pipeline's `gates` at run start; absent means no gate.
-     */
-    readonly requiresApproval: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-    /**
-     * The live approval gate for this step (see {@link stepApprovalSchema}). Set
-     * once the step's proposal is ready and `requiresApproval` is true; null/absent
-     * otherwise.
-     */
-    readonly approval: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        /** Unique id of this gate; the durable run parks on it like a decision. */
-        readonly id: v.StringSchema<undefined>;
-        /** `pending` while awaiting the human; terminal `approved`/`rejected`; `changes_requested` re-runs the step. */
-        readonly status: v.PicklistSchema<["pending", "approved", "changes_requested", "rejected"], undefined>;
-        /** The agent's output the human is reviewing (editable before approval). */
-        readonly proposal: v.StringSchema<undefined>;
-        /** When changes were requested, the human's freeform guidance fed into the re-run. */
-        readonly feedback: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        /** When changes were requested, per-block review comments fed into the re-run. */
-        readonly comments: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-            /**
-             * Verbatim raw-markdown source of the commented prose block. Optional: a comment
-             * may instead anchor to a structured item via {@link anchorId}, where there is no
-             * prose source to quote.
-             */
-            readonly quotedSource: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            /**
-             * 0-based source line range [start, end) of the commented prose block, for
-             * best-effort re-anchoring. Optional: a comment may instead anchor to a structured
-             * item via {@link anchorId} (e.g. a spec requirement/acceptance-criterion id), where
-             * there is no prose line range.
-             */
-            readonly srcStart: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-            readonly srcEnd: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-            /**
-             * Stable id of the structured item the comment targets (e.g. a spec
-             * requirement/criterion id), when the reviewed output is rendered as structured
-             * items rather than free prose. Absent for prose-range comments.
-             */
-            readonly anchorId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            /** The reviewer's note on this block / item. */
-            readonly body: v.StringSchema<undefined>;
-        }, undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Live state of a companion step that reviews a preceding producer step. Set when
-     * this step's `agentKind` is a companion kind. `threshold` is the quality bar the
-     * companion's latest rating (the last `verdicts` entry) must reach; `attempts`
-     * counts only the AUTOMATIC reworks performed, and once it reaches `maxAttempts` the
-     * step parks on the iteration-cap gate (`exceeded`) for a human rather than failing.
-     * A human "request changes" on the companion's gate also re-runs the producer but does
-     * NOT consume `attempts` (only the automatic loop is budgeted). Absent for non-companion steps.
-     */
-    readonly companion: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        /** The quality bar (0..1) the latest verdict's rating must reach; seeded from the pipeline. */
-        readonly threshold: v.NumberSchema<undefined>;
-        /** The automatic rework budget: once `attempts` reaches this the gate parks for a human (`exceeded`). */
-        readonly maxAttempts: v.NumberSchema<undefined>;
-        /**
-         * How many AUTOMATIC reworks the companion has driven so far (the producer is
-         * looped back once per failed verdict). Human "request changes" cycles are not
-         * counted. Defaults to 0; once it reaches `maxAttempts` the step parks on the
-         * iteration-cap gate (`exceeded`) — an "extra round" raises `maxAttempts` by one.
-         */
-        readonly attempts: v.OptionalSchema<v.NumberSchema<undefined>, 0>;
-        /**
-         * One standardized {@link companionVerdictSchema} per grading cycle, in order —
-         * the full sequence of correction iterations (the producer is re-run after each
-         * rejected verdict), including any human-driven ones. Empty before the first
-         * grade; the last entry is the latest.
-         */
-        readonly verdicts: v.ArraySchema<v.ObjectSchema<{
-            /** Overall quality of the graded output (0..1, higher = better). */
-            readonly rating: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>;
-            /** The quality bar the rating had to reach to pass. */
-            readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>;
-            /** Whether the rating met the threshold. */
-            readonly passed: v.BooleanSchema<undefined>;
-            /** The companion's challenge / justification (its assessment summary). */
-            readonly feedback: v.StringSchema<undefined>;
-        }, undefined>, undefined>;
-        /**
-         * Set true when the automatic rework budget (`maxAttempts`) was spent with the
-         * rating still below the bar: instead of failing the run, the step parks on its
-         * approval gate for a human to resolve via the shared iteration-cap surface
-         * (one more round / proceed anyway / stop & reset). Cleared once the human grants
-         * an extra round (the loop resumes). Absent until/unless the cap is hit.
-         */
-        readonly exceeded: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Live Follow-up companion state while a `coder` step runs/parks: the items the Coder
-     * streamed (loose ends / side-tasks / questions), whether the companion is enabled, and
-     * the send-back loop budget. Items accrue live as the harness streams them (the blinking
-     * companion); at the step's completion the engine parks the run while any item is
-     * `pending`, then loops the Coder for any `queued` follow-up / `answered` question. See
-     * {@link followUpsStepStateSchema}. Absent for non-`coder` steps / when the companion is off.
-     */
-    readonly followUps: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly enabled: v.BooleanSchema<undefined>;
-        readonly items: v.ArraySchema<v.ObjectSchema<{
-            readonly id: v.StringSchema<undefined>;
-            readonly kind: v.PicklistSchema<["follow_up", "question"], undefined>;
-            readonly title: v.StringSchema<undefined>;
-            readonly detail: v.StringSchema<undefined>;
-            readonly suggestedAction: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly status: v.PicklistSchema<["pending", "filed", "queued", "answered", "dismissed"], undefined>;
-            readonly answer: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly sentToCoder: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-            readonly ticketExternalId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly ticketUrl: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly createdAt: v.NumberSchema<undefined>;
-            readonly updatedAt: v.NumberSchema<undefined>;
-        }, undefined>, undefined>;
-        readonly loops: v.OptionalSchema<v.NumberSchema<undefined>, 0>;
-        readonly maxLoops: v.OptionalSchema<v.NumberSchema<undefined>, 3>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Live implementation-fork decision state while a `coder` step runs its optional
-     * two-phase flow: the proposer explore job (`proposing`), the human park
-     * (`awaiting_choice` / `answering`), the resolved choice (`chosen`), or one of the
-     * pass-through terminals (`single_path` / `skipped`). Created lazily by the engine
-     * when the phase activates — the config lives on the block + the risk policy, never
-     * on the step. Absent for non-`coder` steps / when the phase never activated. See
-     * {@link forkDecisionStepStateSchema}.
-     */
-    readonly forkDecision: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly status: v.PicklistSchema<["proposing", "awaiting_choice", "answering", "chosen", "single_path", "skipped"], undefined>;
-        readonly seamSummary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        readonly forks: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-            readonly id: v.StringSchema<undefined>;
-            readonly title: v.StringSchema<undefined>;
-            readonly summary: v.StringSchema<undefined>;
-            readonly approach: v.StringSchema<undefined>;
-            readonly tradeoffs: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-            readonly riskNotes: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly recommended: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-        }, undefined>, undefined>, readonly []>;
-        readonly singlePathReason: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        readonly chat: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-            readonly id: v.StringSchema<undefined>;
-            readonly role: v.PicklistSchema<["human", "assistant"], undefined>;
-            readonly text: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 4000, undefined>]>;
-            readonly createdAt: v.NumberSchema<undefined>;
-        }, undefined>, undefined>, readonly []>;
-        readonly maxChatTurns: v.OptionalSchema<v.NumberSchema<undefined>, 15>;
-        readonly chosen: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-            readonly forkId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly custom: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly note: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly at: v.NumberSchema<undefined>;
-        }, undefined>, v.CheckAction<{
-            forkId?: string | null | undefined;
-            custom?: string | null | undefined;
-            note?: string | null | undefined;
-            at: number;
-        }, "Provide exactly one of forkId or custom.">]>, undefined>, undefined>;
-        readonly model: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Live "Ralph loop" state carried on a `ralph` step: the persistent retry-until-done
-     * loop's iteration count, budget, validation command, and per-iteration history. Seeded
-     * from the block's per-task agent config at step start, then advanced each iteration by
-     * the engine's `RalphController`. Because it rides the run's persisted `detail` blob, both
-     * durable drivers + both stale-run sweepers re-drive a mid-loop run from exactly this
-     * state after a restart. Absent for non-`ralph` steps. See {@link ralphStepStateSchema}.
-     */
-    readonly ralph: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly phase: v.PicklistSchema<["iterating"], undefined>;
-        readonly attempts: v.NumberSchema<undefined>;
-        readonly maxIterations: v.NumberSchema<undefined>;
-        readonly validationCommand: v.StringSchema<undefined>;
-        readonly progressPath: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        readonly lastExitCode: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-        readonly lastValidationTail: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        readonly attemptLog: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-            readonly attempt: v.NumberSchema<undefined>;
-            readonly at: v.NumberSchema<undefined>;
-            readonly validationPassed: v.BooleanSchema<undefined>;
-            readonly exitCode: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-            readonly outputTail: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly summary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        }, undefined>, undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Transient re-entry marker carried on a parked `coder` step whose fork decision is
-     * `answering`: set when the human sends a chat message so the run is signalled to
-     * wake and the durable driver, on re-entering, runs the inline chat LLM and appends
-     * the assistant reply (the LLM work that must not block the HTTP request). Cleared
-     * once that async cycle completes. Documented beside `pendingIncorporation` /
-     * `pendingInterview`. Absent when no chat turn is pending.
-     */
-    readonly pendingForkChat: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly messageId: v.StringSchema<undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Live PR deep-review state carried on a `pr-reviewer` step: the sliced, severity-ordered
-     * findings the read-only reviewer produced, the human's curated selection, and how it was
-     * resolved. Recorded by the engine when the reviewer container job completes; the run then
-     * parks (`awaiting_selection`) for the human to select findings through the dedicated
-     * window and resolve. Absent for non-`pr-reviewer` steps. See {@link prReviewStepStateSchema}.
-     */
-    readonly prReview: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly status: v.PicklistSchema<["reviewing", "awaiting_selection", "fixing", "posting", "done", "skipped"], undefined>;
-        readonly summary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        readonly slices: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-            readonly id: v.StringSchema<undefined>;
-            readonly title: v.StringSchema<undefined>;
-            readonly rationale: v.StringSchema<undefined>;
-            readonly paths: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-        }, undefined>, undefined>, readonly []>;
-        readonly findings: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-            readonly id: v.StringSchema<undefined>;
-            readonly sliceId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly path: v.StringSchema<undefined>;
-            readonly line: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-            readonly side: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["LEFT", "RIGHT"], undefined>, undefined>, undefined>;
-            readonly severity: v.PicklistSchema<["blocker", "high", "medium", "low", "nit"], undefined>;
-            readonly category: v.PicklistSchema<["correctness", "security", "performance", "maintainability", "style", "test", "other"], undefined>;
-            readonly title: v.StringSchema<undefined>;
-            readonly detail: v.StringSchema<undefined>;
-            readonly suggestedFix: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        }, undefined>, undefined>, readonly []>;
-        readonly selectedFindingIds: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, readonly []>;
-        readonly resolution: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["finish", "fix", "post"], undefined>, undefined>, undefined>;
-        readonly prUrl: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        readonly model: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * The at-most-once driver marker for the PR-review "post" resolution: set when the human
-     * resolves a parked review with `post`, so the durable driver — on re-entry, off the HTTP
-     * request — publishes the selected findings as inline PR review comments (via
-     * `RepoFiles.createReview`) exactly once. Consumed (cleared + persisted) BEFORE the posting
-     * side effect so a Workflows retry/replay can't post the review twice. Cleared once posted.
-     */
-    readonly pendingPrReviewPost: v.OptionalSchema<v.NullableSchema<v.BooleanSchema<undefined>, undefined>, undefined>;
-    /**
-     * Transient rework feedback carried on a PRODUCER step while it is being re-run by
-     * a downstream companion (the analogue of an approval's `changes_requested`
-     * feedback for the automatic path). Folded into the agent's revision context on the
-     * re-run, then cleared. Absent when no companion rework is in flight.
-     */
-    readonly rework: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        /** The producer's previous proposal the companion challenged. */
-        readonly previousProposal: v.StringSchema<undefined>;
-        /** The companion's prose feedback driving the rework. */
-        readonly feedback: v.StringSchema<undefined>;
-        /** Optional per-item / per-block challenges to address. */
-        readonly comments: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-            /**
-             * Verbatim raw-markdown source of the commented prose block. Optional: a comment
-             * may instead anchor to a structured item via {@link anchorId}, where there is no
-             * prose source to quote.
-             */
-            readonly quotedSource: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            /**
-             * 0-based source line range [start, end) of the commented prose block, for
-             * best-effort re-anchoring. Optional: a comment may instead anchor to a structured
-             * item via {@link anchorId} (e.g. a spec requirement/acceptance-criterion id), where
-             * there is no prose line range.
-             */
-            readonly srcStart: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-            readonly srcEnd: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-            /**
-             * Stable id of the structured item the comment targets (e.g. a spec
-             * requirement/criterion id), when the reviewed output is rendered as structured
-             * items rather than free prose. Absent for prose-range comments.
-             */
-            readonly anchorId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            /** The reviewer's note on this block / item. */
-            readonly body: v.StringSchema<undefined>;
-        }, undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Transient incorporation intent carried on a parked `requirements-review` gate step.
-     * Set when the human answers the findings and asks to incorporate: the run is signalled
-     * to wake and the durable driver, on re-entering the gate, folds the answers into a
-     * document and re-reviews it (the LLM work that used to block the HTTP request). Cleared
-     * once that async cycle completes. `feedback` is the human's optional "do it differently"
-     * direction (a redo). Absent when no incorporation is pending.
-     */
-    readonly pendingIncorporation: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly feedback: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Transient recommendation intent carried on a parked `requirements-review` gate step.
-     * Set when the human asks the Requirement Writer to suggest answers for a batch of findings
-     * (or re-requests one): the run is signalled to wake and the durable driver, on re-entering
-     * the gate, runs the Writer per finding — filling in the `pending` placeholder
-     * recommendations — then re-parks (recommendations never advance the run). Cleared once that
-     * async batch completes. `itemIds` are the findings to recommend for; `note` steers the
-     * whole batch. Absent when no recommendation batch is pending.
-     */
-    readonly pendingRecommendation: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly itemIds: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-        readonly note: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Transient interview intent carried on a parked `initiative-interviewer` gate step. Set
-     * when the human has answered the planning questions and asked to continue (or proceed):
-     * the run is signalled to wake and the durable driver, on re-entering the gate, runs the
-     * interviewer LLM again against the answers — asking follow-ups (re-park) or synthesizing
-     * the goal/constraints brief and advancing. `proceed` skips any remaining questions.
-     * Cleared once that async re-entry completes. Absent when no continuation is pending.
-     */
-    readonly pendingInterview: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly proceed: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Consensus configuration for this step, copied from the pipeline's `consensus`
-     * array at run start. Present (with `enabled: true`) when this step should run
-     * through the multi-model consensus mechanism; read by the consensus executor
-     * (and to decide gating against the block estimate). Absent ⇒ standard agent.
-     * See {@link consensusStepConfigSchema}.
-     */
-    readonly consensus: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly enabled: v.BooleanSchema<undefined>;
-        readonly strategy: v.PicklistSchema<["specialist-panel", "debate", "ranked-voting"], undefined>;
-        readonly participants: v.ArraySchema<v.ObjectSchema<{
-            readonly id: v.StringSchema<undefined>;
-            readonly role: v.StringSchema<undefined>;
-            readonly systemFraming: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            readonly modelId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        }, undefined>, undefined>;
-        readonly synthesizerModelId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        readonly rounds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 5, undefined>]>, undefined>;
-        readonly gating: v.OptionalSchema<v.ObjectSchema<{
-            readonly enabled: v.BooleanSchema<undefined>;
-            readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-            readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-            readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-            readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["consensus", "standard"], undefined>, "consensus">;
-        }, undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Estimate-based gating for this step, copied from the pipeline's `gating` array at
-     * run start. When present (with `enabled: true`) the step is skipped at runtime unless
-     * the block's task estimate meets the threshold. Absent ⇒ always run. See
-     * {@link stepGatingSchema}.
-     */
-    readonly gating: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly enabled: v.BooleanSchema<undefined>;
-        readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-        readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-        readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-        readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["run", "skip"], undefined>, "run">;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Per-step options bag copied from the pipeline's `stepOptions` array at run start (see
-     * {@link stepOptionsSchema}). Absent ⇒ all defaults for this step. Read by the engine —
-     * e.g. the requirements-review gate consults `stepOptions.autoRecommend`.
-     */
-    readonly stepOptions: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        /**
-         * `requirements-review` only. When enabled (the default), the reviewer classifies each
-         * finding, and the ones it judges answerable from universal best-practice / the context
-         * already provided get a recommended answer AUTO-generated and offered as the finding's
-         * default answer (the human can override or dismiss it); findings that need a genuine
-         * business/product decision are left for the human. `false` disables the automation — the
-         * human answers (or manually requests recommendations for) every finding. Absent / `true`
-         * ⇒ enabled. Ignored on non-`requirements-review` steps.
-         */
-        readonly autoRecommend: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-        /**
-         * `skill` steps only. The id of the account-tier repo-sourced Claude Skill this step
-         * executes (`src:<sourceId>:<dirName>`; see `docs/initiatives/repo-skills.md`). The one
-         * generic `skill` agent kind is parametrized by THIS field — the picked skill's
-         * instructions + resources are resolved at dispatch and folded into the step (natively for
-         * the claude-code harness, as prompt + `.cat-context/skill/*` for Pi/codex). A `skill` step
-         * with no `skillId` has nothing to run and is rejected at pipeline save. Ignored on every
-         * other kind.
-         */
-        readonly skillId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * True when this step was skipped at runtime because its `gating` was not satisfied
-     * (the task estimate fell below the threshold). The step's `state` is `done` with no
-     * output; the UI renders it as "skipped (gated)". Absent ⇒ the step ran normally.
-     */
-    readonly skipped: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-    /**
-     * Set `true` on a `spec-writer` step that determined the task is purely technical and
-     * produced no business specs (its result's `noBusinessSpecs`). Recorded on the step so
-     * the spec-companion's convergence — the one point both signals coexist — can combine it
-     * with the companion's `technicalCorroborated` verdict to infer the block's `technical`
-     * label. Absent for every other kind / a writer that produced specs.
-     */
-    readonly noBusinessSpecs: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-    /**
-     * Set on a `spec-companion` step from its `technicalCorroborated` verdict (whether it
-     * agreed the task is purely technical). Recorded on the step — not just read off the
-     * live assessment — so the engine can infer the block's `technical` label both on the
-     * companion's automatic convergence AND on a human "proceed" past the iteration cap,
-     * where only the persisted step survives. Absent for every other kind / no opinion.
-     */
-    readonly technicalCorroborated: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-    /** Text the agent produced for this step (when LLM execution is enabled). */
-    readonly output: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    /**
-     * The structured JSON a registered CUSTOM kind's agent step returned (the generic
-     * manifest-driven `agent` dispatch's `custom` channel). Recorded so the SPA can render
-     * it in the `generic-structured` result view (and a post-op already consumed it
-     * server-side). Absent for built-in / prose kinds.
-     */
-    readonly custom: v.OptionalSchema<v.UnknownSchema, undefined>;
-    /** Identifier of the model that produced `output`, for transparency. */
-    readonly model: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    /**
-     * Ids of the prompt-fragment library entries that were folded into this step's
-     * system prompt — the manual selection on the block unioned with the relevance
-     * selector's pick. Recorded for observability and replay-stability; absent when
-     * the fragment-library module is not configured.
-     */
-    readonly selectedFragmentIds: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
-    /**
-     * The repo-sourced Claude Skill this step was PINNED to at dispatch (a `skill` step; see
-     * `docs/initiatives/repo-skills.md`). Recorded so a run executes a stable version of the
-     * skill even if its source resyncs mid-run, and so a later investigation knows exactly
-     * which skill (and at which commit / manifest blob) ran. `commit` is the source dir's head
-     * commit the resources were fetched at (null if the skill was never synced to a commit);
-     * `sha` is the `SKILL.md` blob sha. Absent for every non-`skill` step.
-     */
-    readonly skillVersion: v.OptionalSchema<v.ObjectSchema<{
-        readonly skillId: v.StringSchema<undefined>;
-        readonly commit: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-        readonly sha: v.StringSchema<undefined>;
-    }, undefined>, undefined>;
-    /**
-     * Identifier of an in-flight asynchronous agent job (a container run polled by
-     * the durable driver). Set while the step is dispatched-but-not-yet-finished so
-     * a Workflows replay re-attaches to the running job instead of starting a new
-     * one; cleared once the job's result is recorded.
-     */
-    readonly jobId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    /**
-     * Epoch ms the step first began executing (transitioned to `working`). Set once
-     * and never overwritten on subsequent state changes, so a re-run/replay keeps the
-     * original start. Absent until the step starts.
-     */
-    readonly startedAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-    /**
-     * Epoch ms the step finished (transitioned to `done`). With {@link startedAt}
-     * this yields the step's execution duration. Absent until the step completes.
-     */
-    readonly finishedAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-    /**
-     * Epoch ms the step parked on a human (an approval gate, a raised decision, or an
-     * iteration-cap gate), freezing its duration clock: while parked, elapsed time stops
-     * accruing — the symmetric counterpart of {@link finishedAt}'s terminal freeze, so a
-     * step waiting on input is not billed for the human's deliberation. Set once on park,
-     * cleared (null) when the step resumes working or finishes. Absent until first parked.
-     */
-    readonly pausedAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-    /**
-     * How many times this step's container was evicted/crashed and recovered by
-     * automatically re-dispatching a fresh container (bounded by
-     * `MAX_EVICTION_RECOVERIES`). Once spent, a further eviction fails the run as
-     * `evicted` rather than looping. Absent/0 until the first eviction.
-     */
-    readonly evictionRecoveries: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-    /**
-     * How many times this step's container was evicted by *transient infrastructure
-     * churn* — an event the runtime facade flags as not-a-crash (e.g. a deploy
-     * draining the sandbox) — and recovered by re-dispatching a fresh container.
-     * Counted separately from {@link evictionRecoveries} and bounded by a larger
-     * `MAX_TRANSIENT_EVICTION_RECOVERIES`, since such churn can recur several times in
-     * a short window, unlike a crash. Absent/0 until the first transient eviction.
-     */
-    readonly transientEvictionRecoveries: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-    /**
-     * The service-provisioning config a `deployer` step PINNED when it dispatched its async,
-     * container-backed deploy job, so the later poll/finalize maps the job against the same config
-     * the container was built from — NOT a fresh read of the service frame (which a person may have
-     * edited mid-flight, e.g. flipping it to `infraless`, which would otherwise fail a deploy whose
-     * container already succeeded). Absent for the synchronous raw-manifest path and the undeclared
-     * legacy single-connection path (re-resolution is harmless there). See {@link serviceProvisioningSchema}.
-     */
-    readonly deployProvisioning: v.OptionalSchema<v.ObjectSchema<{
-        readonly type: v.PicklistSchema<["kubernetes", "docker-compose", "custom", "infraless"], undefined>;
-        readonly manifestSource: v.OptionalSchema<v.VariantSchema<"type", [v.ObjectSchema<{
-            readonly type: v.LiteralSchema<"colocated", undefined>;
-            readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-            readonly renderer: v.OptionalSchema<v.PicklistSchema<["raw", "kustomize"], undefined>, undefined>;
-        }, undefined>, v.ObjectSchema<{
-            readonly type: v.LiteralSchema<"separate", undefined>;
-            readonly repo: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.RegexAction<string, "must be \"owner/repo\"">]>;
-            readonly ref: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>, undefined>;
-            readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-            readonly renderer: v.OptionalSchema<v.PicklistSchema<["raw", "kustomize"], undefined>, undefined>;
-        }, undefined>], undefined>, undefined>;
-        readonly composePath: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-        readonly localDevOnly: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-        readonly composeBuild: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-        readonly recipe: v.OptionalSchema<v.ObjectSchema<{
-            readonly composeFiles: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>, undefined>;
-            readonly composeProfiles: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>, undefined>;
-            readonly envFiles: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                readonly template: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-                readonly target: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-            }, undefined>, undefined>, undefined>;
-            readonly externalNetworks: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>, undefined>;
-            readonly sharedStackRefs: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>, undefined>;
-            readonly prerequisites: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                readonly check: v.PicklistSchema<["docker-daemon", "disk-space", "memory", "registry-auth", "tcp-reachable", "http-reachable", "mkcert-ca", "hosts-entries", "env-secrets-marker"], undefined>;
-                readonly params: v.OptionalSchema<v.ObjectSchema<{
-                    readonly minGib: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1024, undefined>]>, undefined>;
-                    readonly registry: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                    readonly host: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                    readonly port: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 65535, undefined>]>, undefined>;
-                    readonly url: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 2000, undefined>]>, undefined>;
-                    readonly expectStatus: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 100, undefined>, v.MaxValueAction<number, 599, undefined>]>, undefined>;
-                    readonly expectBodyContains: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                    readonly hostnames: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>, undefined>;
-                    readonly file: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                    readonly marker: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                }, undefined>, undefined>;
-                readonly required: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-                readonly remediation: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 4000, undefined>]>, undefined>;
-                readonly label: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-            }, undefined>, undefined>, undefined>;
-            readonly setupSteps: v.OptionalSchema<v.ArraySchema<v.VariantSchema<"kind", [v.ObjectSchema<{
-                readonly kind: v.LiteralSchema<"compose-exec", undefined>;
-                readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>;
-                readonly service: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
-                readonly command: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
-                readonly stdinFile: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                readonly user: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>;
-                readonly workdir: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly kind: v.LiteralSchema<"copy-file", undefined>;
-                readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>;
-                readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-                readonly to: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-                readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly kind: v.LiteralSchema<"wait-http", undefined>;
-                readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>;
-                readonly url: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 2000, undefined>]>;
-                readonly expectStatus: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 100, undefined>, v.MaxValueAction<number, 599, undefined>]>, undefined>;
-                readonly expectBodyContains: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                readonly intervalMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 250, undefined>, v.MaxValueAction<number, 60000, undefined>]>, undefined>;
-                readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly kind: v.LiteralSchema<"wait-file", undefined>;
-                readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>;
-                readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-                readonly service: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>;
-                readonly intervalMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 250, undefined>, v.MaxValueAction<number, 60000, undefined>]>, undefined>;
-                readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly kind: v.LiteralSchema<"host-command", undefined>;
-                readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>;
-                readonly command: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
-                readonly workdir: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-            }, undefined>], undefined>, undefined>, undefined>;
-            readonly healthGate: v.OptionalSchema<v.VariantSchema<"kind", [v.ObjectSchema<{
-                readonly kind: v.LiteralSchema<"compose-healthy", undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly kind: v.LiteralSchema<"http", undefined>;
-                readonly url: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 2000, undefined>]>;
-                readonly expectStatus: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 100, undefined>, v.MaxValueAction<number, 599, undefined>]>, undefined>;
-                readonly expectBodyContains: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                readonly intervalMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 250, undefined>, v.MaxValueAction<number, 60000, undefined>]>, undefined>;
-                readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly kind: v.LiteralSchema<"compose-exec", undefined>;
-                readonly service: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
-                readonly command: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
-                readonly intervalMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 250, undefined>, v.MaxValueAction<number, 60000, undefined>]>, undefined>;
-                readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-            }, undefined>], undefined>, undefined>;
-            readonly teardownSteps: v.OptionalSchema<v.ArraySchema<v.VariantSchema<"kind", [v.ObjectSchema<{
-                readonly kind: v.LiteralSchema<"compose-exec", undefined>;
-                readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>;
-                readonly service: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
-                readonly command: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
-                readonly stdinFile: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                readonly user: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>;
-                readonly workdir: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly kind: v.LiteralSchema<"copy-file", undefined>;
-                readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>;
-                readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-                readonly to: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-                readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly kind: v.LiteralSchema<"wait-http", undefined>;
-                readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>;
-                readonly url: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 2000, undefined>]>;
-                readonly expectStatus: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 100, undefined>, v.MaxValueAction<number, 599, undefined>]>, undefined>;
-                readonly expectBodyContains: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                readonly intervalMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 250, undefined>, v.MaxValueAction<number, 60000, undefined>]>, undefined>;
-                readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly kind: v.LiteralSchema<"wait-file", undefined>;
-                readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>;
-                readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-                readonly service: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>;
-                readonly intervalMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 250, undefined>, v.MaxValueAction<number, 60000, undefined>]>, undefined>;
-                readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly kind: v.LiteralSchema<"host-command", undefined>;
-                readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>;
-                readonly command: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
-                readonly workdir: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-            }, undefined>], undefined>, undefined>, undefined>;
-        }, undefined>, undefined>;
-        readonly manifestId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>, undefined>;
-        readonly manifestPath: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-        readonly images: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-            readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-            readonly newNameTemplate: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-            readonly newTagTemplate: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-            readonly digestTemplate: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-        }, undefined>, v.CheckAction<{
-            name: string;
-            newNameTemplate?: string | undefined;
-            newTagTemplate?: string | undefined;
-            digestTemplate?: string | undefined;
-        }, "an image override must set at least one of newNameTemplate, newTagTemplate, or digestTemplate.">, v.CheckAction<{
-            name: string;
-            newNameTemplate?: string | undefined;
-            newTagTemplate?: string | undefined;
-            digestTemplate?: string | undefined;
-        }, "newTagTemplate and digestTemplate are mutually exclusive on an image override.">]>, undefined>, undefined>;
-        readonly helmReleases: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-            readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-            readonly chart: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-            readonly repo: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 2000, undefined>]>, undefined>;
-            readonly version: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.RegexAction<string, "version must be a pinned semver (e.g. 1.2.3), not a floating tag like latest or ^1.0.">]>;
-            readonly namespaceTemplate: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-            readonly values: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
-            readonly set: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-                readonly valueTemplate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 2000, undefined>]>;
-            }, undefined>, undefined>, undefined>;
-            readonly valuesSecretRefs: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-                readonly secretRef: v.ObjectSchema<{
-                    readonly key: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>;
-                }, undefined>;
-            }, undefined>, undefined>, undefined>;
-            readonly scope: v.OptionalSchema<v.PicklistSchema<["per-environment", "shared"], undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        readonly secretInjections: v.OptionalSchema<v.ArraySchema<v.VariantSchema<"mode", [v.ObjectSchema<{
-            readonly mode: v.LiteralSchema<"secret", undefined>;
-            readonly secretName: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-            readonly secretType: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
-            readonly entries: v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-                readonly key: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 256, undefined>]>;
-                readonly secretRef: v.OptionalSchema<v.ObjectSchema<{
-                    readonly key: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>;
-                }, undefined>, undefined>;
-                readonly valueTemplate: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>]>, undefined>;
-            }, undefined>, v.CheckAction<{
-                key: string;
-                secretRef?: {
-                    key: string;
-                } | undefined;
-                valueTemplate?: string | undefined;
-            }, "a secret entry must set exactly one of secretRef or valueTemplate.">]>, undefined>;
-        }, undefined>, v.ObjectSchema<{
-            readonly mode: v.LiteralSchema<"generatorEnvFile", undefined>;
-            readonly envFilePath: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-            readonly entries: v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-                readonly key: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 256, undefined>]>;
-                readonly secretRef: v.OptionalSchema<v.ObjectSchema<{
-                    readonly key: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>;
-                }, undefined>, undefined>;
-                readonly valueTemplate: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>]>, undefined>;
-            }, undefined>, v.CheckAction<{
-                key: string;
-                secretRef?: {
-                    key: string;
-                } | undefined;
-                valueTemplate?: string | undefined;
-            }, "a secret entry must set exactly one of secretRef or valueTemplate.">]>, undefined>;
-        }, undefined>], undefined>, undefined>, undefined>;
-    }, undefined>, undefined>;
-    /**
-     * A `deployer` step fanning out over several service frames (the task's own frame + each
-     * involved-service frame; see the connections initiative) records each frame's TERMINAL
-     * outcome here, keyed by frame block id — so a durable replay knows which frames are already
-     * provisioned and only the remaining ones are dispatched. The in-flight frame is tracked by
-     * {@link deployFrameId} + {@link jobId} until it settles into this map. Absent for a
-     * single-frame deploy that never fanned out. See {@link deployEnvsSchema}.
-     */
-    readonly deployEnvs: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.ObjectSchema<{
-        readonly status: v.PicklistSchema<["ready", "failed", "skipped"], undefined>;
-        /** The provisioned URL for a `ready` env (absent for `failed`/`skipped`). */
-        readonly url: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        /** The verbatim provider error for a `failed` env. */
-        readonly error: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * The service FRAME the deployer step's currently in-flight deploy job ({@link jobId}) is
-     * provisioning, during a multi-env fan-out — so the poll/finalize maps the settled job onto the
-     * right frame's {@link deployEnvs} entry. Cleared once that frame settles; absent when no deploy
-     * job is in flight or the step never fanned out.
-     */
-    readonly deployFrameId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    /**
-     * The task's OWN (primary) service frame, pinned on the FIRST target resolution of a `deployer`
-     * fan-out and reused on every re-entry/replay. Keeps the primary classification STABLE against a
-     * mid-flight reparent (which would otherwise re-derive a different own frame and flip an
-     * own-service provisioning failure from terminal to a non-terminal peer failure — completing the
-     * run `done` despite a failed deploy). Absent until the first resolution / for a step that never
-     * fanned out.
-     */
-    readonly deployPrimaryFrameId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-}, undefined>;
-export type PipelineStep = v.InferOutput<typeof pipelineStepSchema>;
-export declare const executionStatusSchema: v.PicklistSchema<["running", "blocked", "done", "paused", "failed"], undefined>;
-export type ExecutionStatus = v.InferOutput<typeof executionStatusSchema>;
-/**
- * Per-run diagnostic context captured for AFTER-THE-FACT investigation of a run (esp. a
- * failure) — the "where/what did this run actually execute on" facts that were previously
- * spread across the DB (repo↔service↔installation joins), the harness transcript (model), or
- * lost entirely (which backend a step ran on). Stamped by the engine at dispatch and refined
- * on the first poll; it reflects the MOST RECENT container-step dispatch (the step most likely
- * relevant to a failure), not a per-step history. Rides in the run's `detail` JSON (no dedicated
- * column), like {@link ExecutionInstance.notes}/`frontendBindings`. Absent on legacy runs and on
- * runs with no container step (pure inline/gate pipelines). NEVER carries a token or secret.
- */
-export declare const runDiagnosticsSchema: v.ObjectSchema<{
-    /** Context of the most recent container-step dispatch. */
-    readonly lastDispatch: v.OptionalSchema<v.ObjectSchema<{
-        /** Index of the dispatched step within the pipeline. */
-        readonly stepIndex: v.NumberSchema<undefined>;
-        /** The step's agent kind (`coder`, `merger`, a custom kind, …). */
-        readonly agentKind: v.StringSchema<undefined>;
-        /** Resolved model ref `provider:model` (e.g. `anthropic:claude-opus-4-8`); null if unresolved. */
-        readonly model: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        /**
-         * Which runner backend the step actually ran on — the datum that distinguishes a native
-         * host-process run from a sandboxed container: `local-native` | `local-container` |
-         * `runner-pool` | `cloudflare-container`. Filled on the first poll (the transport reports
-         * it); absent until then or on an older runtime.
-         */
-        readonly executionBackend: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        /** The repo the step operated on. */
-        readonly repo: v.OptionalSchema<v.ObjectSchema<{
-            readonly owner: v.StringSchema<undefined>;
-            readonly name: v.StringSchema<undefined>;
-            /** The base branch the work branched from. */
-            readonly baseBranch: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            /** VCS provider (`github` | `gitlab`), resolved from the run's repo origin. */
-            readonly provider: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        }, undefined>, undefined>;
-        /** Epoch ms the dispatch was recorded. */
-        readonly at: v.NumberSchema<undefined>;
-    }, undefined>, undefined>;
-    /**
-     * The control-plane (orchestrator) host running the engine — NOT necessarily where the agent
-     * ran (a container step runs elsewhere; see `lastDispatch.executionBackend`). `platform` is the
-     * orchestrator's `process.platform` (e.g. `win32` pins a Windows local deployment — the class
-     * of host that surfaced the native-Windows git-auth break). Best-effort.
-     */
-    readonly host: v.OptionalSchema<v.ObjectSchema<{
-        readonly platform: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>, undefined>;
-}, undefined>;
-export type RunDiagnostics = v.InferOutput<typeof runDiagnosticsSchema>;
-export declare const executionInstanceSchema: v.ObjectSchema<{
-    readonly id: v.StringSchema<undefined>;
-    readonly blockId: v.StringSchema<undefined>;
-    readonly pipelineId: v.StringSchema<undefined>;
-    readonly pipelineName: v.StringSchema<undefined>;
-    readonly steps: v.ArraySchema<v.ObjectSchema<{
-        /**
-         * Id of the execution run (the {@link executionInstanceSchema} `id`) this step
-         * belongs to — surfaced on every step so a lone step in a log line or a detail view
-         * can name its run, for easier debugging. A projection that always equals the parent
-         * instance's `id`: stamped from the enclosing instance when the run is read or
-         * emitted, not persisted independently. Absent only on steps not yet round-tripped.
-         */
-        readonly runId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        readonly agentKind: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-        readonly state: v.PicklistSchema<["pending", "working", "waiting_decision", "done"], undefined>;
-        readonly progress: v.NumberSchema<undefined>;
-        /** LLM observability rollup for this step; see {@link stepMetricsSchema}. */
-        readonly metrics: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            /** Number of model calls recorded for this step. */
-            readonly calls: v.NumberSchema<undefined>;
-            /** Sum of prompt (input) tokens across the step's calls. */
-            readonly promptTokens: v.NumberSchema<undefined>;
-            /**
-             * Sum of prompt tokens served from the provider's prefix cache. A subset of
-             * promptTokens on OpenAI/DeepSeek, but on Anthropic cache reads are reported
-             * separately from input tokens, so this can exceed promptTokens. 0 on a cache-less
-             * flavour (Workers AI); the metrics bar shows the cached split when present. Absent ⇒
-             * unknown (older snapshot).
-             */
-            readonly cachedPromptTokens: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-            /** Sum of completion (output) tokens across the step's calls. */
-            readonly completionTokens: v.NumberSchema<undefined>;
-            /** Largest single completion the model produced (closest approach to the limit). */
-            readonly peakCompletionTokens: v.NumberSchema<undefined>;
-            /** The output ceiling in effect (max requested `max_tokens`), or null when unknown. */
-            readonly maxOutputTokens: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
-            /** Calls cut short by the output limit (`finish_reason === 'length'`). */
-            readonly truncatedCalls: v.NumberSchema<undefined>;
-            /** Sum of model execution time (ms) — the "actual prompt/tool execution" slice. */
-            readonly upstreamMs: v.NumberSchema<undefined>;
-            /** Sum of transport/proxy overhead (ms) — the interim-layer cost. */
-            readonly overheadMs: v.NumberSchema<undefined>;
-            /** Calls that failed (non-2xx / refused / in-process error). */
-            readonly errors: v.NumberSchema<undefined>;
-            /** Successful calls that warned (truncated or content-filtered). */
-            readonly warnings: v.NumberSchema<undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * Live gate state while a polling gate step (`ci` / `conflicts`) runs its
-         * precheck-or-escalate loop; see {@link gateStepStateSchema}. The gate kind is
-         * `agentKind`.
-         */
-        readonly gate: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly phase: v.PicklistSchema<["checking", "working"], undefined>;
-            /** How many helper-agent attempts have been dispatched so far. */
-            readonly attempts: v.NumberSchema<undefined>;
-            /** Ceiling on attempts, resolved from the task's merge preset at step start. */
-            readonly maxAttempts: v.NumberSchema<undefined>;
-            /** The PR head commit being gated, once resolved (the own-service PR on a multi-repo block). */
-            readonly headSha: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            /**
-             * Per-PR head commits for a MULTI-REPO block (service-connections phase 4), keyed by repo
-             * full name (owner/name) — own-service PR plus each peer-service PR. Set by the CI /
-             * conflicts gates whose precheck aggregates across every PR the task opened. Absent for a
-             * single-repo block (the scalar {@link headSha} is the only head).
-             */
-            readonly headShas: v.OptionalSchema<v.NullableSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>, undefined>;
-            /**
-             * The repo the conflicts gate's most recent `fail` verdict found conflicted, so the
-             * single-repo conflict-resolver is dispatched at THAT repo (own-service or a peer) rather
-             * than always the own-service one. Absent ⇒ the own-service repo. Only the conflicts gate
-             * sets it (the CI-fixer runs across all repos, so the CI gate leaves it undefined).
-             */
-            readonly conflictTarget: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                readonly repo: v.StringSchema<undefined>;
-                readonly frameId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                readonly branch: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            }, undefined>, undefined>, undefined>;
-            /**
-             * The most recent precheck verdict, so the UI can show why the gate is looping
-             * (failing → a helper is fixing) vs idle-passing. Set on every probe.
-             */
-            readonly lastVerdict: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["pass", "pending", "fail"], undefined>, undefined>, undefined>;
-            /**
-             * Human-readable summary of the latest failing precheck (the failing CI checks /
-             * the conflict reason) — the conclusion detail that used to be fed only to the
-             * helper agent and then discarded. Carried across the helper dispatch so the
-             * window keeps showing what is being fixed. Null when the last probe passed.
-             */
-            readonly lastFailureSummary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            /**
-             * Structured failing checks behind {@link lastFailureSummary} for the CI gate, so
-             * the UI can list each red check by name + conclusion. Absent for the conflicts
-             * gate (GitHub reports no file-level detail) and when the last probe passed.
-             */
-            readonly failingChecks: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-                readonly name: v.StringSchema<undefined>;
-                /** GitHub conclusion (e.g. `failure`, `timed_out`), or null when not reported. */
-                readonly conclusion: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-                /**
-                 * The check run's GitHub web URL (`html_url`), so the UI can link straight to the
-                 * failed run's logs. Null when GitHub didn't report one.
-                 */
-                readonly url: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                /**
-                 * The repo (owner/name) this check belongs to, on a MULTI-REPO block — so the UI can group
-                 * failing checks by service. Absent on a single-repo block (there is only the own repo).
-                 */
-                readonly repo: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            }, undefined>, undefined>, undefined>, undefined>;
-            /**
-             * The fixing instructions handed to the most-recently dispatched helper (the failing-check
-             * summary / conflict reason / human fix prompt), stashed at dispatch so the attempt recorded
-             * when that helper's job settles can carry WHAT the round was asked to fix onto its
-             * {@link gateAttemptSchema} entry. Transient bookkeeping — the durable per-round history lives
-             * on {@link attemptLog}. Null when the gate hands its fixer no textual instructions.
-             */
-            readonly lastDispatchedInstructions: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            /**
-             * Epoch ms of the release marker for a time-windowed gate (post-release-health) — the
-             * moment it began watching the deployed release. The gate keeps polling `pending`
-             * until this + the preset's watch window has elapsed (then a clean run passes) or a
-             * monitor/SLO regresses (then it escalates to the on-call agent). Absent for the
-             * CI/conflicts gates.
-             */
-            readonly watchSince: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-            /**
-             * The watch-window length (minutes) for a time-windowed gate (post-release-health),
-             * resolved from the task's merge preset ONCE on first entry (alongside `maxAttempts`)
-             * so the probe doesn't re-load the block + re-resolve the preset on every poll. Absent
-             * for the CI/conflicts gates.
-             */
-            readonly watchWindowMinutes: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-            /**
-             * The regressed signals captured when the post-release-health gate escalated to the
-             * on-call agent, so the agent's completion handler can build the `release_regression`
-             * notification + incident enrichment from the SAME evidence the agent investigated
-             * — rather than re-reading Datadog (a third round-trip that could also disagree with
-             * what the agent saw if the window moved). Absent for the CI/conflicts gates.
-             */
-            readonly regressedSignals: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-                readonly kind: v.PicklistSchema<["monitor", "slo"], undefined>;
-                readonly id: v.StringSchema<undefined>;
-                readonly name: v.StringSchema<undefined>;
-                readonly state: v.PicklistSchema<["ok", "warn", "alert", "no_data"], undefined>;
-                readonly detail: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            }, undefined>, undefined>, undefined>, undefined>;
-            /**
-             * Append-only history of the helper-agent attempts this gate dispatched (ci-fixer /
-             * conflict-resolver runs), each recorded when its job finished. Lets the UI show what
-             * every attempt tried and how it ended, instead of only a bare `attempts` count.
-             * Absent for the post-release-health gate (its on-call helper is resolved specially).
-             */
-            readonly attemptLog: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-                /** 1-based attempt number (matches `attempts` at the time the helper was dispatched). */
-                readonly attempt: v.NumberSchema<undefined>;
-                /** Epoch ms when the helper job finished. */
-                readonly at: v.NumberSchema<undefined>;
-                /**
-                 * How the helper job ended:
-                 *   - `completed` — the container finished (it may or may not have fully fixed the
-                 *     issue; the gate's next precheck is the source of truth, and `summary` carries
-                 *     the agent's own account, e.g. which files it left conflicting).
-                 *   - `failed`    — the job errored / was evicted without finishing.
-                 */
-                readonly outcome: v.PicklistSchema<["completed", "failed"], undefined>;
-                /** The PR head commit the helper worked against, when known. */
-                readonly headSha: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                /**
-                 * The fixing instructions handed to the helper for this round — the failing-check
-                 * summary the CI gate fed the `ci-fixer`, the conflict reason / human-review comments
-                 * the other gates fed their fixer. Stashed at dispatch and recorded with the attempt so
-                 * the run-detail UI can show WHAT each round was asked to fix (not only that a round
-                 * happened) — the gate analogue of the Tester attempt's `concerns`. Null when the gate
-                 * hands its fixer no textual instructions (the conflicts gate: GitHub reports mergeability
-                 * as a single bit and the harness leaves the conflict markers for the resolver).
-                 */
-                readonly instructions: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                /**
-                 * Structured failing checks handed to this attempt's helper (the CI gate's red check runs
-                 * behind {@link instructions}), snapshotted at dispatch so each attempt shows the checks it
-                 * set out to fix. Absent for the conflicts gate (no file-level detail) and when the round
-                 * carried no structured checks.
-                 */
-                readonly failingChecks: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-                    readonly name: v.StringSchema<undefined>;
-                    /** GitHub conclusion (e.g. `failure`, `timed_out`), or null when not reported. */
-                    readonly conclusion: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-                    /**
-                     * The check run's GitHub web URL (`html_url`), so the UI can link straight to the
-                     * failed run's logs. Null when GitHub didn't report one.
-                     */
-                    readonly url: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                    /**
-                     * The repo (owner/name) this check belongs to, on a MULTI-REPO block — so the UI can group
-                     * failing checks by service. Absent on a single-repo block (there is only the own repo).
-                     */
-                    readonly repo: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                }, undefined>, undefined>, undefined>, undefined>;
-                /** The helper's own summary (or the failure reason), naming what it did / what remains. */
-                readonly summary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            }, undefined>, undefined>, undefined>, undefined>;
-            /**
-             * The number of approving reviews the PR had at the last probe, so the UI can show
-             * "1 / N approvals". The "required" side is derived from {@link requiredApprovingReviewCount}
-             * via the same `max(1, …)` floor the gate applies (see review.logic.ts) rather than persisted
-             * a second time. Absent for the other gates.
-             */
-            readonly lastApprovals: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-            /**
-             * The raw branch-protection required-approving-review count, cached after the FIRST probe
-             * resolves it so subsequent polls skip the static protection read (branch protection is repo
-             * config, not PR activity — re-reading it every poll over a multi-day review only burns GitHub
-             * rate budget). The UI's displayed "required" count is `max(1, this)` (the gate's effective
-             * floor). Absent for the other gates.
-             */
-            readonly requiredApprovingReviewCount: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-            /**
-             * The GraphQL ids of the review threads the gate just handed the `fixer`, stashed at
-             * dispatch so the helper-completion hook can post a reply + RESOLVE exactly those threads
-             * on GitHub before the next probe reads them. Absent for the other gates.
-             */
-            readonly pendingThreadIds: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>;
-            /**
-             * Epoch ms of the newest plain PR comment the gate has already handed the `fixer`. Plain
-             * conversation comments (unlike review threads) can't be "resolved" on GitHub, so they are
-             * tracked by timestamp: a comment newer than this is outstanding; the dispatch advances it to
-             * the batch max. A reviewer's later comment (newer timestamp) re-opens the work. Absent for
-             * the other gates.
-             */
-            readonly lastAddressedCommentAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-            /**
-             * The grace window (minutes) the human-review gate waits after the latest review comment
-             * before dispatching the fixer, resolved from the task's merge preset ONCE on first entry
-             * (alongside `maxAttempts`) so the probe doesn't re-resolve the preset every poll. Absent
-             * for the other gates.
-             */
-            readonly humanReviewGraceMinutes: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-            /**
-             * A human-initiated freeform fix request parked on the gate (an in-app prompt). Consumed at
-             * the top of the next `evaluateGate` pass, which dispatches the fixer with these instructions
-             * folded in — bypassing the grace window. Absent for the other gates.
-             */
-            readonly pendingFix: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                readonly instructions: v.StringSchema<undefined>;
-                readonly at: v.NumberSchema<undefined>;
-            }, undefined>, undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /** Live Tester→Fixer loop state while a `tester` step runs/fixes; see {@link testerStepStateSchema}. */
-        readonly test: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly phase: v.PicklistSchema<["testing", "fixing"], undefined>;
-            /** How many `fixer` attempts have been dispatched so far. */
-            readonly attempts: v.NumberSchema<undefined>;
-            /** Ceiling on fixer attempts, resolved from the task's merge preset at step start. */
-            readonly maxAttempts: v.NumberSchema<undefined>;
-            /** The most recent Tester report (what was tested, outcomes, concerns, greenlight). */
-            readonly lastReport: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-                readonly greenlight: v.BooleanSchema<undefined>;
-                readonly summary: v.StringSchema<undefined>;
-                readonly tested: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-                readonly outcomes: v.ArraySchema<v.ObjectSchema<{
-                    readonly name: v.StringSchema<undefined>;
-                    readonly status: v.PicklistSchema<["passed", "failed", "skipped"], undefined>;
-                    readonly detail: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                }, undefined>, undefined>;
-                readonly concerns: v.ArraySchema<v.ObjectSchema<{
-                    readonly title: v.StringSchema<undefined>;
-                    readonly detail: v.StringSchema<undefined>;
-                    readonly severity: v.PicklistSchema<["low", "medium", "high", "critical"], undefined>;
-                }, undefined>, undefined>;
-                readonly environment: v.OptionalSchema<v.PicklistSchema<["local", "ephemeral"], undefined>, undefined>;
-                readonly screenshots: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                    readonly view: v.StringSchema<undefined>;
-                    readonly artifactId: v.StringSchema<undefined>;
-                    readonly hash: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                    readonly width: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-                    readonly height: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-                    readonly referenceArtifactId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                }, undefined>, undefined>, undefined>;
-                readonly abort: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                    readonly reason: v.StringSchema<undefined>;
-                }, undefined>, undefined>, undefined>;
-            }, undefined>, v.TransformAction<{
-                greenlight: boolean;
-                summary: string;
-                tested: string[];
-                outcomes: {
-                    name: string;
-                    status: "failed" | "passed" | "skipped";
-                    detail?: string | undefined;
-                }[];
-                concerns: {
-                    title: string;
-                    detail: string;
-                    severity: "critical" | "high" | "low" | "medium";
-                }[];
-                environment?: "ephemeral" | "local" | undefined;
-                screenshots?: {
-                    view: string;
-                    artifactId: string;
-                    hash?: string | undefined;
-                    width?: number | undefined;
-                    height?: number | undefined;
-                    referenceArtifactId?: string | undefined;
-                }[] | undefined;
-                abort?: {
-                    reason: string;
-                } | null | undefined;
-            }, {
-                greenlight: boolean;
-                summary: string;
-                tested: string[];
-                outcomes: {
-                    name: string;
-                    status: "failed" | "passed" | "skipped";
-                    detail?: string | undefined;
-                }[];
-                concerns: {
-                    title: string;
-                    detail: string;
-                    severity: "critical" | "high" | "low" | "medium";
-                }[];
-                environment?: "ephemeral" | "local" | undefined;
-                screenshots?: {
-                    view: string;
-                    artifactId: string;
-                    hash?: string | undefined;
-                    width?: number | undefined;
-                    height?: number | undefined;
-                    referenceArtifactId?: string | undefined;
-                }[] | undefined;
-                abort?: {
-                    reason: string;
-                } | null | undefined;
-            }>]>, undefined>, undefined>;
-            /**
-             * Append-only history of the `fixer` rounds this Tester step looped through, each recorded
-             * when its job finished. Lets the test window surface an inspectable timeline of the fixer
-             * attempts (what each addressed, how it ended) instead of only a bare `attempts` count.
-             */
-            readonly attemptLog: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-                /** 1-based fixer round (matches `attempts` after the fixer for this round was dispatched). */
-                readonly attempt: v.NumberSchema<undefined>;
-                /** Epoch ms when the fixer job finished. */
-                readonly at: v.NumberSchema<undefined>;
-                /** Whether the fixer container finished (`completed`) or errored/was evicted (`failed`). */
-                readonly outcome: v.PicklistSchema<["completed", "failed"], undefined>;
-                /** The fixer's own summary (or the failure reason), naming what it changed / what failed. */
-                readonly summary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                /**
-                 * The concerns the fixer was handed for this round (from the Tester report that withheld
-                 * its greenlight), so the window can show WHAT each round tried to address — not only that
-                 * a round happened.
-                 */
-                readonly concerns: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-                    readonly title: v.StringSchema<undefined>;
-                    readonly detail: v.StringSchema<undefined>;
-                    readonly severity: v.PicklistSchema<["low", "medium", "high", "critical"], undefined>;
-                }, undefined>, undefined>, undefined>, undefined>;
-            }, undefined>, undefined>, undefined>, undefined>;
-            /**
-             * The most recent in-container docker-compose dependency stand-up record (local-infra
-             * tester): whether the dependencies came up and the captured (redacted, bounded)
-             * `docker compose up` logs. Refreshed on each Tester round (it stands the infra up anew),
-             * so the test window can surface WHY local infra failed to come up — the failure-class
-             * artifact the orchestrator-side provisioning logs can't see. Absent for ephemeral /
-             * no-infra runs. See {@link testerInfraSetupSchema}.
-             */
-            readonly infraSetup: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                readonly started: v.BooleanSchema<undefined>;
-                readonly composePath: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                readonly at: v.NumberSchema<undefined>;
-                readonly durationMs: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-                readonly logs: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                readonly error: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            }, undefined>, undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * Live test quality-control companion state on a `tester-api`/`tester-ui` step, copied
-         * from the pipeline's per-step `testerQuality` config at run start. Drives the QC loop that
-         * gates each Tester report for completeness before the greenlight/fixer decision. Absent
-         * for non-Tester steps / when the companion is disabled. See {@link testerQualityStepStateSchema}.
-         */
-        readonly testerQuality: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            /** Whether the QC companion is active on this Tester step (the builder toggle). */
-            readonly enabled: v.BooleanSchema<undefined>;
-            /** How many QC-driven Tester re-runs have been dispatched so far. */
-            readonly attempts: v.OptionalSchema<v.NumberSchema<undefined>, 0>;
-            /** Ceiling on QC-driven re-runs, from the task's merge preset (`maxTesterQualityIterations`). */
-            readonly maxAttempts: v.NumberSchema<undefined>;
-            /** Optional estimate gating copied from the pipeline; evaluated against the block estimate. */
-            readonly gating: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                readonly enabled: v.BooleanSchema<undefined>;
-                readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-                readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-                readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-                readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["run", "skip"], undefined>, "run">;
-            }, undefined>, undefined>, undefined>;
-            /** One verdict per QC evaluation, in order (newest last). Empty before the first grade. */
-            readonly verdicts: v.ArraySchema<v.ObjectSchema<{
-                /** Whether the report is complete/coherent enough to proceed (no QC re-run needed). */
-                readonly adequate: v.BooleanSchema<undefined>;
-                /** The QC's prose challenge / justification, folded into the Tester's re-run context. */
-                readonly feedback: v.StringSchema<undefined>;
-                /** Concrete coverage gaps the Tester must still address (empty when adequate). */
-                readonly gaps: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-                /** Epoch ms the verdict was produced. */
-                readonly at: v.NumberSchema<undefined>;
-                /** The model that produced the verdict, for transparency. */
-                readonly model: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            }, undefined>, undefined>;
-            /** Set true once the QC budget was spent with the report still judged inadequate. */
-            readonly exceeded: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * Live state of a `human-test` gate (ephemeral env + human validation loop); see
-         * {@link humanTestStepStateSchema}. Absent for every other step kind.
-         */
-        readonly humanTest: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly phase: v.PicklistSchema<["provisioning", "awaiting_human", "fixing", "resolving_conflicts", "passed"], undefined>;
-            /** The live ephemeral environment (null in degraded manual mode / after destroy). */
-            readonly environment: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                /** The `environments` row id, so the window can fetch access creds / re-poll status. */
-                readonly id: v.StringSchema<undefined>;
-                /** The provisioned public URL the human tests against (null while still provisioning). */
-                readonly url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-                /** The environment lifecycle status; see {@link environmentStatusSchema}. */
-                readonly status: v.PicklistSchema<["provisioning", "ready", "failed", "expired", "tearing_down", "torn_down"], undefined>;
-                /** Epoch ms the environment expires (TTL), when known. */
-                readonly expiresAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-            }, undefined>, undefined>, undefined>;
-            /**
-             * Why no environment was auto-provisioned — set in degraded manual mode (no env provider
-             * wired, or provisioning errored) so the window can explain it and let the human test
-             * against the PR branch manually. Absent when an env was provisioned.
-             */
-            readonly degradedReason: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            /** How many helper (fixer / conflict-resolver) attempts have been dispatched so far. */
-            readonly attempts: v.NumberSchema<undefined>;
-            /** Ceiling on helper attempts, resolved from the task's merge preset (`ciMaxAttempts`). */
-            readonly maxAttempts: v.NumberSchema<undefined>;
-            /** The PR head commit being tested, when known. */
-            readonly headSha: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            /** Append-only history of fix / pull-main rounds; see {@link humanTestRoundSchema}. */
-            readonly rounds: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                /** The kind of round — a findings-driven fix or a pull-main-with-conflicts resolve. */
-                readonly kind: v.PicklistSchema<["fix", "pull-main"], undefined>;
-                /** The human's findings prompt (fix), or a one-line note for the pull-main round. */
-                readonly findings: v.StringSchema<undefined>;
-                /** The helper container kind this round dispatched (`fixer` / `conflict-resolver`). */
-                readonly helperKind: v.StringSchema<undefined>;
-                /** The helper job's id while it ran, for cross-referencing the run timeline. */
-                readonly jobId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                /** How the helper ended once its job settled. Absent while still in flight. */
-                readonly outcome: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["completed", "failed"], undefined>, undefined>, undefined>;
-                /** Epoch ms the round opened (the human clicked Request fix / Pull main). */
-                readonly at: v.NumberSchema<undefined>;
-            }, undefined>, undefined>, undefined>;
-            /**
-             * Transient action the human requested while the gate is parked — recorded on the parked
-             * step and consumed by the durable driver when it re-enters the gate (the analogue of
-             * `pendingIncorporation` on a requirements gate). Cleared once the driver acts on it.
-             */
-            readonly pendingAction: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                readonly type: v.PicklistSchema<["confirm", "request-fix", "pull-main", "recreate"], undefined>;
-                /** The findings prompt for a `request-fix` action. */
-                readonly findings: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            }, undefined>, undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * Live state of a `visual-confirmation` gate (screenshot review + fix loop); see
-         * {@link visualConfirmStepStateSchema}. Absent for every other step kind.
-         */
-        readonly visualConfirm: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly phase: v.PicklistSchema<["awaiting_human", "fixing", "approved"], undefined>;
-            /** The actual-vs-reference pairs the human reviews, refreshed on each (re)capture. */
-            readonly pairs: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                readonly view: v.StringSchema<undefined>;
-                readonly actualArtifactId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                readonly referenceArtifactId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            }, undefined>, undefined>, undefined>;
-            /** Set when no screenshots could be gathered (no UI tester ran / no storage) — manual mode. */
-            readonly degradedReason: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            /** How many fixer attempts have been dispatched so far. */
-            readonly attempts: v.NumberSchema<undefined>;
-            /** Ceiling on fixer attempts, resolved from the task's merge preset (`ciMaxAttempts`). */
-            readonly maxAttempts: v.NumberSchema<undefined>;
-            /** Append-only history of fix rounds; see {@link visualConfirmRoundSchema}. */
-            readonly rounds: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                readonly findings: v.StringSchema<undefined>;
-                readonly helperKind: v.StringSchema<undefined>;
-                readonly jobId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                readonly outcome: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["completed", "failed"], undefined>, undefined>, undefined>;
-                readonly at: v.NumberSchema<undefined>;
-            }, undefined>, undefined>, undefined>;
-            /**
-             * Transient action the human requested while parked — consumed by the durable driver
-             * when it re-enters the gate. Cleared once acted on.
-             */
-            readonly pendingAction: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-                readonly type: v.PicklistSchema<["approve", "request-fix", "recapture"], undefined>;
-                /** The findings prompt for a `request-fix` action. */
-                readonly findings: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            }, undefined>, undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * The ephemeral environment this step runs against (when the block has one), so a
-         * run's details can show its spinning-up / running / shut-down / errored state +
-         * the exact error. Populated by the engine for container/deployer steps from the
-         * block's live environment; see {@link runEnvironmentSchema}. The `human-test` gate
-         * keeps its own richer `humanTest.environment` and is not double-populated here.
-         */
-        readonly environment: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            /** The `environments` row id (lets a window fetch access creds / re-poll status). */
-            readonly id: v.StringSchema<undefined>;
-            /** The provisioned public URL (null while still provisioning). */
-            readonly url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-            /** The environment lifecycle status; see {@link environmentStatusSchema}. */
-            readonly status: v.PicklistSchema<["provisioning", "ready", "failed", "expired", "tearing_down", "torn_down"], undefined>;
-            /** Epoch ms the environment expires (TTL), when known. */
-            readonly expiresAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-            /** The verbatim provider error when the environment failed/expired, else null. */
-            readonly lastError: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            /**
-             * The service's declared provision type this environment was stood up for
-             * (`kubernetes` | `docker-compose` | `custom` | `infraless`), recorded at provision
-             * time so a run's details show exactly what was provisioned. Null for legacy rows /
-             * pre-resolution.
-             */
-            readonly provisionType: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["kubernetes", "docker-compose", "custom", "infraless"], undefined>, undefined>, undefined>;
-            /**
-             * The resolved engine that handled the provisioning (`local-docker` | `local-k3s` |
-             * `remote-kubernetes` | `remote-custom` | `none`), surfaced in run details alongside the
-             * environment state. Null for legacy rows / pre-resolution.
-             */
-            readonly engine: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["local-docker", "local-k3s", "remote-kubernetes", "remote-custom", "none"], undefined>, undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /** Live subtask counts while an async (container) step runs; see {@link stepSubtasksSchema}. */
-        readonly subtasks: v.OptionalSchema<v.ObjectSchema<{
-            readonly completed: v.NumberSchema<undefined>;
-            readonly inProgress: v.NumberSchema<undefined>;
-            readonly total: v.NumberSchema<undefined>;
-            readonly items: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                /** The task's human-readable subject, as the agent wrote it. */
-                readonly label: v.StringSchema<undefined>;
-                readonly status: v.PicklistSchema<["pending", "in_progress", "completed"], undefined>;
-            }, undefined>, undefined>, undefined>;
-        }, undefined>, undefined>;
-        /**
-         * The per-run container this async (container) step runs in — its lifecycle status
-         * (starting / up / errored), the agent's current phase (clone / agent / push), and
-         * the container's id + reachable URL once up. Lets a run's details surface what the
-         * container is doing and where it lives, so the board shows an explicit "Spinning up
-         * container…" → live-phase progression instead of a blank "working" state. Set the
-         * moment the job is dispatched (the dispatch blocks until the container accepts the
-         * job) and refined on each poll. Only ever set on async (container) steps; absent on
-         * non-container steps and steps not yet dispatched. See {@link runContainerSchema}.
-         */
-        readonly container: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            /** The container lifecycle status; see {@link runContainerStatusSchema}. */
-            readonly status: v.PicklistSchema<["starting", "up", "errored", "destroyed"], undefined>;
-            /**
-             * The coarse phase the agent's job is in while the container is `up` (`clone` →
-             * `agent` → `push`, seeded `starting`), forwarded from the harness. Lets the details
-             * distinguish "still preparing the checkout" from "the agent is making calls". Absent
-             * until the first poll, or when the runner doesn't report a phase.
-             */
-            readonly phase: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            /** Provider container/runner id (Cloudflare DO id, docker container id), when known. */
-            readonly id: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            /** A reachable address for the running container (the local docker host URL), when one exists. */
-            readonly url: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * Whether web search was available to this container step, and which upstream backend
-         * served it. Set at dispatch (a static per-run fact resolved from the account's
-         * web-search keys, else the deployment default). Only ever set on async (container)
-         * steps; absent on non-container steps and steps not yet dispatched. Distinct from the
-         * telemetry-gated per-query log — this is always surfaced. See {@link webSearchAvailabilitySchema}.
-         */
-        readonly search: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly available: v.BooleanSchema<undefined>;
-            readonly provider: v.NullableSchema<v.PicklistSchema<["brave", "searxng"], undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        readonly decision: v.NullableSchema<v.ObjectSchema<{
-            readonly id: v.StringSchema<undefined>;
-            readonly question: v.StringSchema<undefined>;
-            readonly options: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-            readonly chosen: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-        }, undefined>, undefined>;
-        /**
-         * Whether a human approval gate fires after this step completes. Copied from
-         * the pipeline's `gates` at run start; absent means no gate.
-         */
-        readonly requiresApproval: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-        /**
-         * The live approval gate for this step (see {@link stepApprovalSchema}). Set
-         * once the step's proposal is ready and `requiresApproval` is true; null/absent
-         * otherwise.
-         */
-        readonly approval: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            /** Unique id of this gate; the durable run parks on it like a decision. */
-            readonly id: v.StringSchema<undefined>;
-            /** `pending` while awaiting the human; terminal `approved`/`rejected`; `changes_requested` re-runs the step. */
-            readonly status: v.PicklistSchema<["pending", "approved", "changes_requested", "rejected"], undefined>;
-            /** The agent's output the human is reviewing (editable before approval). */
-            readonly proposal: v.StringSchema<undefined>;
-            /** When changes were requested, the human's freeform guidance fed into the re-run. */
-            readonly feedback: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            /** When changes were requested, per-block review comments fed into the re-run. */
-            readonly comments: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                /**
-                 * Verbatim raw-markdown source of the commented prose block. Optional: a comment
-                 * may instead anchor to a structured item via {@link anchorId}, where there is no
-                 * prose source to quote.
-                 */
-                readonly quotedSource: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                /**
-                 * 0-based source line range [start, end) of the commented prose block, for
-                 * best-effort re-anchoring. Optional: a comment may instead anchor to a structured
-                 * item via {@link anchorId} (e.g. a spec requirement/acceptance-criterion id), where
-                 * there is no prose line range.
-                 */
-                readonly srcStart: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-                readonly srcEnd: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-                /**
-                 * Stable id of the structured item the comment targets (e.g. a spec
-                 * requirement/criterion id), when the reviewed output is rendered as structured
-                 * items rather than free prose. Absent for prose-range comments.
-                 */
-                readonly anchorId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                /** The reviewer's note on this block / item. */
-                readonly body: v.StringSchema<undefined>;
-            }, undefined>, undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * Live state of a companion step that reviews a preceding producer step. Set when
-         * this step's `agentKind` is a companion kind. `threshold` is the quality bar the
-         * companion's latest rating (the last `verdicts` entry) must reach; `attempts`
-         * counts only the AUTOMATIC reworks performed, and once it reaches `maxAttempts` the
-         * step parks on the iteration-cap gate (`exceeded`) for a human rather than failing.
-         * A human "request changes" on the companion's gate also re-runs the producer but does
-         * NOT consume `attempts` (only the automatic loop is budgeted). Absent for non-companion steps.
-         */
-        readonly companion: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            /** The quality bar (0..1) the latest verdict's rating must reach; seeded from the pipeline. */
-            readonly threshold: v.NumberSchema<undefined>;
-            /** The automatic rework budget: once `attempts` reaches this the gate parks for a human (`exceeded`). */
-            readonly maxAttempts: v.NumberSchema<undefined>;
-            /**
-             * How many AUTOMATIC reworks the companion has driven so far (the producer is
-             * looped back once per failed verdict). Human "request changes" cycles are not
-             * counted. Defaults to 0; once it reaches `maxAttempts` the step parks on the
-             * iteration-cap gate (`exceeded`) — an "extra round" raises `maxAttempts` by one.
-             */
-            readonly attempts: v.OptionalSchema<v.NumberSchema<undefined>, 0>;
-            /**
-             * One standardized {@link companionVerdictSchema} per grading cycle, in order —
-             * the full sequence of correction iterations (the producer is re-run after each
-             * rejected verdict), including any human-driven ones. Empty before the first
-             * grade; the last entry is the latest.
-             */
-            readonly verdicts: v.ArraySchema<v.ObjectSchema<{
-                /** Overall quality of the graded output (0..1, higher = better). */
-                readonly rating: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>;
-                /** The quality bar the rating had to reach to pass. */
-                readonly threshold: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>;
-                /** Whether the rating met the threshold. */
-                readonly passed: v.BooleanSchema<undefined>;
-                /** The companion's challenge / justification (its assessment summary). */
-                readonly feedback: v.StringSchema<undefined>;
-            }, undefined>, undefined>;
-            /**
-             * Set true when the automatic rework budget (`maxAttempts`) was spent with the
-             * rating still below the bar: instead of failing the run, the step parks on its
-             * approval gate for a human to resolve via the shared iteration-cap surface
-             * (one more round / proceed anyway / stop & reset). Cleared once the human grants
-             * an extra round (the loop resumes). Absent until/unless the cap is hit.
-             */
-            readonly exceeded: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * Live Follow-up companion state while a `coder` step runs/parks: the items the Coder
-         * streamed (loose ends / side-tasks / questions), whether the companion is enabled, and
-         * the send-back loop budget. Items accrue live as the harness streams them (the blinking
-         * companion); at the step's completion the engine parks the run while any item is
-         * `pending`, then loops the Coder for any `queued` follow-up / `answered` question. See
-         * {@link followUpsStepStateSchema}. Absent for non-`coder` steps / when the companion is off.
-         */
-        readonly followUps: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly enabled: v.BooleanSchema<undefined>;
-            readonly items: v.ArraySchema<v.ObjectSchema<{
-                readonly id: v.StringSchema<undefined>;
-                readonly kind: v.PicklistSchema<["follow_up", "question"], undefined>;
-                readonly title: v.StringSchema<undefined>;
-                readonly detail: v.StringSchema<undefined>;
-                readonly suggestedAction: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                readonly status: v.PicklistSchema<["pending", "filed", "queued", "answered", "dismissed"], undefined>;
-                readonly answer: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                readonly sentToCoder: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-                readonly ticketExternalId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                readonly ticketUrl: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                readonly createdAt: v.NumberSchema<undefined>;
-                readonly updatedAt: v.NumberSchema<undefined>;
-            }, undefined>, undefined>;
-            readonly loops: v.OptionalSchema<v.NumberSchema<undefined>, 0>;
-            readonly maxLoops: v.OptionalSchema<v.NumberSchema<undefined>, 3>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * Live implementation-fork decision state while a `coder` step runs its optional
-         * two-phase flow: the proposer explore job (`proposing`), the human park
-         * (`awaiting_choice` / `answering`), the resolved choice (`chosen`), or one of the
-         * pass-through terminals (`single_path` / `skipped`). Created lazily by the engine
-         * when the phase activates — the config lives on the block + the risk policy, never
-         * on the step. Absent for non-`coder` steps / when the phase never activated. See
-         * {@link forkDecisionStepStateSchema}.
-         */
-        readonly forkDecision: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly status: v.PicklistSchema<["proposing", "awaiting_choice", "answering", "chosen", "single_path", "skipped"], undefined>;
-            readonly seamSummary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly forks: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                readonly id: v.StringSchema<undefined>;
-                readonly title: v.StringSchema<undefined>;
-                readonly summary: v.StringSchema<undefined>;
-                readonly approach: v.StringSchema<undefined>;
-                readonly tradeoffs: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-                readonly riskNotes: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                readonly recommended: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-            }, undefined>, undefined>, readonly []>;
-            readonly singlePathReason: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly chat: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                readonly id: v.StringSchema<undefined>;
-                readonly role: v.PicklistSchema<["human", "assistant"], undefined>;
-                readonly text: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 4000, undefined>]>;
-                readonly createdAt: v.NumberSchema<undefined>;
-            }, undefined>, undefined>, readonly []>;
-            readonly maxChatTurns: v.OptionalSchema<v.NumberSchema<undefined>, 15>;
-            readonly chosen: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-                readonly forkId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                readonly custom: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                readonly note: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                readonly at: v.NumberSchema<undefined>;
-            }, undefined>, v.CheckAction<{
-                forkId?: string | null | undefined;
-                custom?: string | null | undefined;
-                note?: string | null | undefined;
-                at: number;
-            }, "Provide exactly one of forkId or custom.">]>, undefined>, undefined>;
-            readonly model: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * Live "Ralph loop" state carried on a `ralph` step: the persistent retry-until-done
-         * loop's iteration count, budget, validation command, and per-iteration history. Seeded
-         * from the block's per-task agent config at step start, then advanced each iteration by
-         * the engine's `RalphController`. Because it rides the run's persisted `detail` blob, both
-         * durable drivers + both stale-run sweepers re-drive a mid-loop run from exactly this
-         * state after a restart. Absent for non-`ralph` steps. See {@link ralphStepStateSchema}.
-         */
-        readonly ralph: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly phase: v.PicklistSchema<["iterating"], undefined>;
-            readonly attempts: v.NumberSchema<undefined>;
-            readonly maxIterations: v.NumberSchema<undefined>;
-            readonly validationCommand: v.StringSchema<undefined>;
-            readonly progressPath: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly lastExitCode: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-            readonly lastValidationTail: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly attemptLog: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
-                readonly attempt: v.NumberSchema<undefined>;
-                readonly at: v.NumberSchema<undefined>;
-                readonly validationPassed: v.BooleanSchema<undefined>;
-                readonly exitCode: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-                readonly outputTail: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                readonly summary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            }, undefined>, undefined>, undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * Transient re-entry marker carried on a parked `coder` step whose fork decision is
-         * `answering`: set when the human sends a chat message so the run is signalled to
-         * wake and the durable driver, on re-entering, runs the inline chat LLM and appends
-         * the assistant reply (the LLM work that must not block the HTTP request). Cleared
-         * once that async cycle completes. Documented beside `pendingIncorporation` /
-         * `pendingInterview`. Absent when no chat turn is pending.
-         */
-        readonly pendingForkChat: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly messageId: v.StringSchema<undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * Live PR deep-review state carried on a `pr-reviewer` step: the sliced, severity-ordered
-         * findings the read-only reviewer produced, the human's curated selection, and how it was
-         * resolved. Recorded by the engine when the reviewer container job completes; the run then
-         * parks (`awaiting_selection`) for the human to select findings through the dedicated
-         * window and resolve. Absent for non-`pr-reviewer` steps. See {@link prReviewStepStateSchema}.
-         */
-        readonly prReview: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly status: v.PicklistSchema<["reviewing", "awaiting_selection", "fixing", "posting", "done", "skipped"], undefined>;
-            readonly summary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly slices: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                readonly id: v.StringSchema<undefined>;
-                readonly title: v.StringSchema<undefined>;
-                readonly rationale: v.StringSchema<undefined>;
-                readonly paths: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-            }, undefined>, undefined>, readonly []>;
-            readonly findings: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                readonly id: v.StringSchema<undefined>;
-                readonly sliceId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-                readonly path: v.StringSchema<undefined>;
-                readonly line: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-                readonly side: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["LEFT", "RIGHT"], undefined>, undefined>, undefined>;
-                readonly severity: v.PicklistSchema<["blocker", "high", "medium", "low", "nit"], undefined>;
-                readonly category: v.PicklistSchema<["correctness", "security", "performance", "maintainability", "style", "test", "other"], undefined>;
-                readonly title: v.StringSchema<undefined>;
-                readonly detail: v.StringSchema<undefined>;
-                readonly suggestedFix: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            }, undefined>, undefined>, readonly []>;
-            readonly selectedFindingIds: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, readonly []>;
-            readonly resolution: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["finish", "fix", "post"], undefined>, undefined>, undefined>;
-            readonly prUrl: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly model: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * The at-most-once driver marker for the PR-review "post" resolution: set when the human
-         * resolves a parked review with `post`, so the durable driver — on re-entry, off the HTTP
-         * request — publishes the selected findings as inline PR review comments (via
-         * `RepoFiles.createReview`) exactly once. Consumed (cleared + persisted) BEFORE the posting
-         * side effect so a Workflows retry/replay can't post the review twice. Cleared once posted.
-         */
-        readonly pendingPrReviewPost: v.OptionalSchema<v.NullableSchema<v.BooleanSchema<undefined>, undefined>, undefined>;
-        /**
-         * Transient rework feedback carried on a PRODUCER step while it is being re-run by
-         * a downstream companion (the analogue of an approval's `changes_requested`
-         * feedback for the automatic path). Folded into the agent's revision context on the
-         * re-run, then cleared. Absent when no companion rework is in flight.
-         */
-        readonly rework: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            /** The producer's previous proposal the companion challenged. */
-            readonly previousProposal: v.StringSchema<undefined>;
-            /** The companion's prose feedback driving the rework. */
-            readonly feedback: v.StringSchema<undefined>;
-            /** Optional per-item / per-block challenges to address. */
-            readonly comments: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                /**
-                 * Verbatim raw-markdown source of the commented prose block. Optional: a comment
-                 * may instead anchor to a structured item via {@link anchorId}, where there is no
-                 * prose source to quote.
-                 */
-                readonly quotedSource: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                /**
-                 * 0-based source line range [start, end) of the commented prose block, for
-                 * best-effort re-anchoring. Optional: a comment may instead anchor to a structured
-                 * item via {@link anchorId} (e.g. a spec requirement/acceptance-criterion id), where
-                 * there is no prose line range.
-                 */
-                readonly srcStart: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-                readonly srcEnd: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-                /**
-                 * Stable id of the structured item the comment targets (e.g. a spec
-                 * requirement/criterion id), when the reviewed output is rendered as structured
-                 * items rather than free prose. Absent for prose-range comments.
-                 */
-                readonly anchorId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                /** The reviewer's note on this block / item. */
-                readonly body: v.StringSchema<undefined>;
-            }, undefined>, undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * Transient incorporation intent carried on a parked `requirements-review` gate step.
-         * Set when the human answers the findings and asks to incorporate: the run is signalled
-         * to wake and the durable driver, on re-entering the gate, folds the answers into a
-         * document and re-reviews it (the LLM work that used to block the HTTP request). Cleared
-         * once that async cycle completes. `feedback` is the human's optional "do it differently"
-         * direction (a redo). Absent when no incorporation is pending.
-         */
-        readonly pendingIncorporation: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly feedback: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * Transient recommendation intent carried on a parked `requirements-review` gate step.
-         * Set when the human asks the Requirement Writer to suggest answers for a batch of findings
-         * (or re-requests one): the run is signalled to wake and the durable driver, on re-entering
-         * the gate, runs the Writer per finding — filling in the `pending` placeholder
-         * recommendations — then re-parks (recommendations never advance the run). Cleared once that
-         * async batch completes. `itemIds` are the findings to recommend for; `note` steers the
-         * whole batch. Absent when no recommendation batch is pending.
-         */
-        readonly pendingRecommendation: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly itemIds: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-            readonly note: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * Transient interview intent carried on a parked `initiative-interviewer` gate step. Set
-         * when the human has answered the planning questions and asked to continue (or proceed):
-         * the run is signalled to wake and the durable driver, on re-entering the gate, runs the
-         * interviewer LLM again against the answers — asking follow-ups (re-park) or synthesizing
-         * the goal/constraints brief and advancing. `proceed` skips any remaining questions.
-         * Cleared once that async re-entry completes. Absent when no continuation is pending.
-         */
-        readonly pendingInterview: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly proceed: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * Consensus configuration for this step, copied from the pipeline's `consensus`
-         * array at run start. Present (with `enabled: true`) when this step should run
-         * through the multi-model consensus mechanism; read by the consensus executor
-         * (and to decide gating against the block estimate). Absent ⇒ standard agent.
-         * See {@link consensusStepConfigSchema}.
-         */
-        readonly consensus: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly enabled: v.BooleanSchema<undefined>;
-            readonly strategy: v.PicklistSchema<["specialist-panel", "debate", "ranked-voting"], undefined>;
-            readonly participants: v.ArraySchema<v.ObjectSchema<{
-                readonly id: v.StringSchema<undefined>;
-                readonly role: v.StringSchema<undefined>;
-                readonly systemFraming: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                readonly modelId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            }, undefined>, undefined>;
-            readonly synthesizerModelId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            readonly rounds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 5, undefined>]>, undefined>;
-            readonly gating: v.OptionalSchema<v.ObjectSchema<{
-                readonly enabled: v.BooleanSchema<undefined>;
-                readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-                readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-                readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-                readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["consensus", "standard"], undefined>, "consensus">;
-            }, undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * Estimate-based gating for this step, copied from the pipeline's `gating` array at
-         * run start. When present (with `enabled: true`) the step is skipped at runtime unless
-         * the block's task estimate meets the threshold. Absent ⇒ always run. See
-         * {@link stepGatingSchema}.
-         */
-        readonly gating: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            readonly enabled: v.BooleanSchema<undefined>;
-            readonly minComplexity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-            readonly minRisk: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-            readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
-            readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["run", "skip"], undefined>, "run">;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * Per-step options bag copied from the pipeline's `stepOptions` array at run start (see
-         * {@link stepOptionsSchema}). Absent ⇒ all defaults for this step. Read by the engine —
-         * e.g. the requirements-review gate consults `stepOptions.autoRecommend`.
-         */
-        readonly stepOptions: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-            /**
-             * `requirements-review` only. When enabled (the default), the reviewer classifies each
-             * finding, and the ones it judges answerable from universal best-practice / the context
-             * already provided get a recommended answer AUTO-generated and offered as the finding's
-             * default answer (the human can override or dismiss it); findings that need a genuine
-             * business/product decision are left for the human. `false` disables the automation — the
-             * human answers (or manually requests recommendations for) every finding. Absent / `true`
-             * ⇒ enabled. Ignored on non-`requirements-review` steps.
-             */
-            readonly autoRecommend: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-            /**
-             * `skill` steps only. The id of the account-tier repo-sourced Claude Skill this step
-             * executes (`src:<sourceId>:<dirName>`; see `docs/initiatives/repo-skills.md`). The one
-             * generic `skill` agent kind is parametrized by THIS field — the picked skill's
-             * instructions + resources are resolved at dispatch and folded into the step (natively for
-             * the claude-code harness, as prompt + `.cat-context/skill/*` for Pi/codex). A `skill` step
-             * with no `skillId` has nothing to run and is rejected at pipeline save. Ignored on every
-             * other kind.
-             */
-            readonly skillId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * True when this step was skipped at runtime because its `gating` was not satisfied
-         * (the task estimate fell below the threshold). The step's `state` is `done` with no
-         * output; the UI renders it as "skipped (gated)". Absent ⇒ the step ran normally.
-         */
-        readonly skipped: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-        /**
-         * Set `true` on a `spec-writer` step that determined the task is purely technical and
-         * produced no business specs (its result's `noBusinessSpecs`). Recorded on the step so
-         * the spec-companion's convergence — the one point both signals coexist — can combine it
-         * with the companion's `technicalCorroborated` verdict to infer the block's `technical`
-         * label. Absent for every other kind / a writer that produced specs.
-         */
-        readonly noBusinessSpecs: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-        /**
-         * Set on a `spec-companion` step from its `technicalCorroborated` verdict (whether it
-         * agreed the task is purely technical). Recorded on the step — not just read off the
-         * live assessment — so the engine can infer the block's `technical` label both on the
-         * companion's automatic convergence AND on a human "proceed" past the iteration cap,
-         * where only the persisted step survives. Absent for every other kind / no opinion.
-         */
-        readonly technicalCorroborated: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-        /** Text the agent produced for this step (when LLM execution is enabled). */
-        readonly output: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        /**
-         * The structured JSON a registered CUSTOM kind's agent step returned (the generic
-         * manifest-driven `agent` dispatch's `custom` channel). Recorded so the SPA can render
-         * it in the `generic-structured` result view (and a post-op already consumed it
-         * server-side). Absent for built-in / prose kinds.
-         */
-        readonly custom: v.OptionalSchema<v.UnknownSchema, undefined>;
-        /** Identifier of the model that produced `output`, for transparency. */
-        readonly model: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        /**
-         * Ids of the prompt-fragment library entries that were folded into this step's
-         * system prompt — the manual selection on the block unioned with the relevance
-         * selector's pick. Recorded for observability and replay-stability; absent when
-         * the fragment-library module is not configured.
-         */
-        readonly selectedFragmentIds: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
-        /**
-         * The repo-sourced Claude Skill this step was PINNED to at dispatch (a `skill` step; see
-         * `docs/initiatives/repo-skills.md`). Recorded so a run executes a stable version of the
-         * skill even if its source resyncs mid-run, and so a later investigation knows exactly
-         * which skill (and at which commit / manifest blob) ran. `commit` is the source dir's head
-         * commit the resources were fetched at (null if the skill was never synced to a commit);
-         * `sha` is the `SKILL.md` blob sha. Absent for every non-`skill` step.
-         */
-        readonly skillVersion: v.OptionalSchema<v.ObjectSchema<{
-            readonly skillId: v.StringSchema<undefined>;
-            readonly commit: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-            readonly sha: v.StringSchema<undefined>;
-        }, undefined>, undefined>;
-        /**
-         * Identifier of an in-flight asynchronous agent job (a container run polled by
-         * the durable driver). Set while the step is dispatched-but-not-yet-finished so
-         * a Workflows replay re-attaches to the running job instead of starting a new
-         * one; cleared once the job's result is recorded.
-         */
-        readonly jobId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        /**
-         * Epoch ms the step first began executing (transitioned to `working`). Set once
-         * and never overwritten on subsequent state changes, so a re-run/replay keeps the
-         * original start. Absent until the step starts.
-         */
-        readonly startedAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-        /**
-         * Epoch ms the step finished (transitioned to `done`). With {@link startedAt}
-         * this yields the step's execution duration. Absent until the step completes.
-         */
-        readonly finishedAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-        /**
-         * Epoch ms the step parked on a human (an approval gate, a raised decision, or an
-         * iteration-cap gate), freezing its duration clock: while parked, elapsed time stops
-         * accruing — the symmetric counterpart of {@link finishedAt}'s terminal freeze, so a
-         * step waiting on input is not billed for the human's deliberation. Set once on park,
-         * cleared (null) when the step resumes working or finishes. Absent until first parked.
-         */
-        readonly pausedAt: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;
-        /**
-         * How many times this step's container was evicted/crashed and recovered by
-         * automatically re-dispatching a fresh container (bounded by
-         * `MAX_EVICTION_RECOVERIES`). Once spent, a further eviction fails the run as
-         * `evicted` rather than looping. Absent/0 until the first eviction.
-         */
-        readonly evictionRecoveries: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-        /**
-         * How many times this step's container was evicted by *transient infrastructure
-         * churn* — an event the runtime facade flags as not-a-crash (e.g. a deploy
-         * draining the sandbox) — and recovered by re-dispatching a fresh container.
-         * Counted separately from {@link evictionRecoveries} and bounded by a larger
-         * `MAX_TRANSIENT_EVICTION_RECOVERIES`, since such churn can recur several times in
-         * a short window, unlike a crash. Absent/0 until the first transient eviction.
-         */
-        readonly transientEvictionRecoveries: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-        /**
-         * The service-provisioning config a `deployer` step PINNED when it dispatched its async,
-         * container-backed deploy job, so the later poll/finalize maps the job against the same config
-         * the container was built from — NOT a fresh read of the service frame (which a person may have
-         * edited mid-flight, e.g. flipping it to `infraless`, which would otherwise fail a deploy whose
-         * container already succeeded). Absent for the synchronous raw-manifest path and the undeclared
-         * legacy single-connection path (re-resolution is harmless there). See {@link serviceProvisioningSchema}.
-         */
-        readonly deployProvisioning: v.OptionalSchema<v.ObjectSchema<{
-            readonly type: v.PicklistSchema<["kubernetes", "docker-compose", "custom", "infraless"], undefined>;
-            readonly manifestSource: v.OptionalSchema<v.VariantSchema<"type", [v.ObjectSchema<{
-                readonly type: v.LiteralSchema<"colocated", undefined>;
-                readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-                readonly renderer: v.OptionalSchema<v.PicklistSchema<["raw", "kustomize"], undefined>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly type: v.LiteralSchema<"separate", undefined>;
-                readonly repo: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.RegexAction<string, "must be \"owner/repo\"">]>;
-                readonly ref: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>, undefined>;
-                readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-                readonly renderer: v.OptionalSchema<v.PicklistSchema<["raw", "kustomize"], undefined>, undefined>;
-            }, undefined>], undefined>, undefined>;
-            readonly composePath: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-            readonly localDevOnly: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-            readonly composeBuild: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-            readonly recipe: v.OptionalSchema<v.ObjectSchema<{
-                readonly composeFiles: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>, undefined>;
-                readonly composeProfiles: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>, undefined>;
-                readonly envFiles: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                    readonly template: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-                    readonly target: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-                }, undefined>, undefined>, undefined>;
-                readonly externalNetworks: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>, undefined>;
-                readonly sharedStackRefs: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>, undefined>;
-                readonly prerequisites: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                    readonly check: v.PicklistSchema<["docker-daemon", "disk-space", "memory", "registry-auth", "tcp-reachable", "http-reachable", "mkcert-ca", "hosts-entries", "env-secrets-marker"], undefined>;
-                    readonly params: v.OptionalSchema<v.ObjectSchema<{
-                        readonly minGib: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1024, undefined>]>, undefined>;
-                        readonly registry: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                        readonly host: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                        readonly port: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 65535, undefined>]>, undefined>;
-                        readonly url: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 2000, undefined>]>, undefined>;
-                        readonly expectStatus: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 100, undefined>, v.MaxValueAction<number, 599, undefined>]>, undefined>;
-                        readonly expectBodyContains: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                        readonly hostnames: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>, undefined>;
-                        readonly file: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                        readonly marker: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                    }, undefined>, undefined>;
-                    readonly required: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-                    readonly remediation: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 4000, undefined>]>, undefined>;
-                    readonly label: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                }, undefined>, undefined>, undefined>;
-                readonly setupSteps: v.OptionalSchema<v.ArraySchema<v.VariantSchema<"kind", [v.ObjectSchema<{
-                    readonly kind: v.LiteralSchema<"compose-exec", undefined>;
-                    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>;
-                    readonly service: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
-                    readonly command: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
-                    readonly stdinFile: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                    readonly user: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>;
-                    readonly workdir: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                    readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-                }, undefined>, v.ObjectSchema<{
-                    readonly kind: v.LiteralSchema<"copy-file", undefined>;
-                    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>;
-                    readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-                    readonly to: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-                    readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-                }, undefined>, v.ObjectSchema<{
-                    readonly kind: v.LiteralSchema<"wait-http", undefined>;
-                    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>;
-                    readonly url: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 2000, undefined>]>;
-                    readonly expectStatus: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 100, undefined>, v.MaxValueAction<number, 599, undefined>]>, undefined>;
-                    readonly expectBodyContains: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                    readonly intervalMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 250, undefined>, v.MaxValueAction<number, 60000, undefined>]>, undefined>;
-                    readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-                }, undefined>, v.ObjectSchema<{
-                    readonly kind: v.LiteralSchema<"wait-file", undefined>;
-                    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>;
-                    readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-                    readonly service: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>;
-                    readonly intervalMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 250, undefined>, v.MaxValueAction<number, 60000, undefined>]>, undefined>;
-                    readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-                }, undefined>, v.ObjectSchema<{
-                    readonly kind: v.LiteralSchema<"host-command", undefined>;
-                    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>;
-                    readonly command: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
-                    readonly workdir: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                    readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-                }, undefined>], undefined>, undefined>, undefined>;
-                readonly healthGate: v.OptionalSchema<v.VariantSchema<"kind", [v.ObjectSchema<{
-                    readonly kind: v.LiteralSchema<"compose-healthy", undefined>;
-                }, undefined>, v.ObjectSchema<{
-                    readonly kind: v.LiteralSchema<"http", undefined>;
-                    readonly url: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 2000, undefined>]>;
-                    readonly expectStatus: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 100, undefined>, v.MaxValueAction<number, 599, undefined>]>, undefined>;
-                    readonly expectBodyContains: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                    readonly intervalMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 250, undefined>, v.MaxValueAction<number, 60000, undefined>]>, undefined>;
-                    readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-                }, undefined>, v.ObjectSchema<{
-                    readonly kind: v.LiteralSchema<"compose-exec", undefined>;
-                    readonly service: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
-                    readonly command: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
-                    readonly intervalMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 250, undefined>, v.MaxValueAction<number, 60000, undefined>]>, undefined>;
-                    readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-                }, undefined>], undefined>, undefined>;
-                readonly teardownSteps: v.OptionalSchema<v.ArraySchema<v.VariantSchema<"kind", [v.ObjectSchema<{
-                    readonly kind: v.LiteralSchema<"compose-exec", undefined>;
-                    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>;
-                    readonly service: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
-                    readonly command: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
-                    readonly stdinFile: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                    readonly user: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>;
-                    readonly workdir: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                    readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-                }, undefined>, v.ObjectSchema<{
-                    readonly kind: v.LiteralSchema<"copy-file", undefined>;
-                    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>;
-                    readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-                    readonly to: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-                    readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-                }, undefined>, v.ObjectSchema<{
-                    readonly kind: v.LiteralSchema<"wait-http", undefined>;
-                    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>;
-                    readonly url: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 2000, undefined>]>;
-                    readonly expectStatus: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 100, undefined>, v.MaxValueAction<number, 599, undefined>]>, undefined>;
-                    readonly expectBodyContains: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                    readonly intervalMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 250, undefined>, v.MaxValueAction<number, 60000, undefined>]>, undefined>;
-                    readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-                }, undefined>, v.ObjectSchema<{
-                    readonly kind: v.LiteralSchema<"wait-file", undefined>;
-                    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>;
-                    readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-                    readonly service: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>;
-                    readonly intervalMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 250, undefined>, v.MaxValueAction<number, 60000, undefined>]>, undefined>;
-                    readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-                }, undefined>, v.ObjectSchema<{
-                    readonly kind: v.LiteralSchema<"host-command", undefined>;
-                    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>]>;
-                    readonly command: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
-                    readonly workdir: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                    readonly timeoutMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1000, undefined>, v.MaxValueAction<number, 3600000, undefined>]>, undefined>;
-                }, undefined>], undefined>, undefined>, undefined>;
-            }, undefined>, undefined>;
-            readonly manifestId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>, undefined>;
-            readonly manifestPath: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-            readonly images: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-                readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-                readonly newNameTemplate: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                readonly newTagTemplate: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                readonly digestTemplate: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-            }, undefined>, v.CheckAction<{
-                name: string;
-                newNameTemplate?: string | undefined;
-                newTagTemplate?: string | undefined;
-                digestTemplate?: string | undefined;
-            }, "an image override must set at least one of newNameTemplate, newTagTemplate, or digestTemplate.">, v.CheckAction<{
-                name: string;
-                newNameTemplate?: string | undefined;
-                newTagTemplate?: string | undefined;
-                digestTemplate?: string | undefined;
-            }, "newTagTemplate and digestTemplate are mutually exclusive on an image override.">]>, undefined>, undefined>;
-            readonly helmReleases: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-                readonly chart: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-                readonly repo: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 2000, undefined>]>, undefined>;
-                readonly version: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.RegexAction<string, "version must be a pinned semver (e.g. 1.2.3), not a floating tag like latest or ^1.0.">]>;
-                readonly namespaceTemplate: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>, undefined>;
-                readonly values: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
-                readonly set: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                    readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-                    readonly valueTemplate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 2000, undefined>]>;
-                }, undefined>, undefined>, undefined>;
-                readonly valuesSecretRefs: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                    readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-                    readonly secretRef: v.ObjectSchema<{
-                        readonly key: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>;
-                    }, undefined>;
-                }, undefined>, undefined>, undefined>;
-                readonly scope: v.OptionalSchema<v.PicklistSchema<["per-environment", "shared"], undefined>, undefined>;
-            }, undefined>, undefined>, undefined>;
-            readonly secretInjections: v.OptionalSchema<v.ArraySchema<v.VariantSchema<"mode", [v.ObjectSchema<{
-                readonly mode: v.LiteralSchema<"secret", undefined>;
-                readonly secretName: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-                readonly secretType: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
-                readonly entries: v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-                    readonly key: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 256, undefined>]>;
-                    readonly secretRef: v.OptionalSchema<v.ObjectSchema<{
-                        readonly key: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>;
-                    }, undefined>, undefined>;
-                    readonly valueTemplate: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>]>, undefined>;
-                }, undefined>, v.CheckAction<{
-                    key: string;
-                    secretRef?: {
-                        key: string;
-                    } | undefined;
-                    valueTemplate?: string | undefined;
-                }, "a secret entry must set exactly one of secretRef or valueTemplate.">]>, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly mode: v.LiteralSchema<"generatorEnvFile", undefined>;
-                readonly envFilePath: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 500, undefined>]>;
-                readonly entries: v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-                    readonly key: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 256, undefined>]>;
-                    readonly secretRef: v.OptionalSchema<v.ObjectSchema<{
-                        readonly key: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>;
-                    }, undefined>, undefined>;
-                    readonly valueTemplate: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>]>, undefined>;
-                }, undefined>, v.CheckAction<{
-                    key: string;
-                    secretRef?: {
-                        key: string;
-                    } | undefined;
-                    valueTemplate?: string | undefined;
-                }, "a secret entry must set exactly one of secretRef or valueTemplate.">]>, undefined>;
-            }, undefined>], undefined>, undefined>, undefined>;
-        }, undefined>, undefined>;
-        /**
-         * A `deployer` step fanning out over several service frames (the task's own frame + each
-         * involved-service frame; see the connections initiative) records each frame's TERMINAL
-         * outcome here, keyed by frame block id — so a durable replay knows which frames are already
-         * provisioned and only the remaining ones are dispatched. The in-flight frame is tracked by
-         * {@link deployFrameId} + {@link jobId} until it settles into this map. Absent for a
-         * single-frame deploy that never fanned out. See {@link deployEnvsSchema}.
-         */
-        readonly deployEnvs: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.ObjectSchema<{
-            readonly status: v.PicklistSchema<["ready", "failed", "skipped"], undefined>;
-            /** The provisioned URL for a `ready` env (absent for `failed`/`skipped`). */
-            readonly url: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            /** The verbatim provider error for a `failed` env. */
-            readonly error: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        /**
-         * The service FRAME the deployer step's currently in-flight deploy job ({@link jobId}) is
-         * provisioning, during a multi-env fan-out — so the poll/finalize maps the settled job onto the
-         * right frame's {@link deployEnvs} entry. Cleared once that frame settles; absent when no deploy
-         * job is in flight or the step never fanned out.
-         */
-        readonly deployFrameId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        /**
-         * The task's OWN (primary) service frame, pinned on the FIRST target resolution of a `deployer`
-         * fan-out and reused on every re-entry/replay. Keeps the primary classification STABLE against a
-         * mid-flight reparent (which would otherwise re-derive a different own frame and flip an
-         * own-service provisioning failure from terminal to a non-terminal peer failure — completing the
-         * run `done` despite a failed deploy). Absent until the first resolution / for a step that never
-         * fanned out.
-         */
-        readonly deployPrimaryFrameId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>, undefined>;
-    readonly currentStep: v.NumberSchema<undefined>;
-    readonly status: v.PicklistSchema<["running", "blocked", "done", "paused", "failed"], undefined>;
-    /**
-     * Structured failure diagnostics when `status` is `failed`; absent/null
-     * otherwise. Lets a failed task surface the same failure banner + retry as a
-     * failed bootstrap (shared {@link agentFailureSchema}).
-     */
-    readonly failure: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
-        readonly kind: v.PicklistSchema<["preflight", "dispatch", "environment", "evicted", "timeout", "agent", "job_failed", "rejected", "companion_rejected", "stalled", "cancelled", "unknown"], undefined>;
-        /** Human-readable summary (mirrors the run's `error` for back-compat). */
-        readonly message: v.StringSchema<undefined>;
-        /** Extended detail when available (the harness's reason, an HTTP body, …). */
-        readonly detail: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-        /** Where to look next (e.g. "check the container logs for this job id"). */
-        readonly hint: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-        /**
-         * Optional machine-readable cause code so the SPA can render precise, actionable guidance
-         * without string-matching the prose `message`/`detail` (the failure analogue of a
-         * {@link ConflictReason}). Kind-scoped: an `environment` failure carries an
-         * {@link EnvironmentFailureReason} (e.g. `deploy_runner_unwired`). Absent when the cause has
-         * no client-specific handling.
-         */
-        readonly reason: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        /** Epoch ms the failure was recorded. */
-        readonly occurredAt: v.NumberSchema<undefined>;
-        /** Last subtask counts seen before the failure, for context (null if none). */
-        readonly lastSubtasks: v.NullableSchema<v.ObjectSchema<{
-            readonly completed: v.NumberSchema<undefined>;
-            readonly inProgress: v.NumberSchema<undefined>;
-            readonly total: v.NumberSchema<undefined>;
-            readonly items: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                /** The task's human-readable subject, as the agent wrote it. */
-                readonly label: v.StringSchema<undefined>;
-                readonly status: v.PicklistSchema<["pending", "in_progress", "completed"], undefined>;
-            }, undefined>, undefined>, undefined>;
-        }, undefined>, undefined>;
-        /**
-         * Index of the pipeline step that was in flight when the run failed (the run's
-         * `currentStep` at fail time), so the per-attempt failure trail can be attributed to a
-         * specific step — the step-detail overlay filters its "execution history" to the failures
-         * recorded for that step. Absent on a bootstrap failure (no steps) and on legacy records.
-         */
-        readonly stepIndex: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Failures from the run's PRIOR attempts, oldest→newest. Each retry/restart appends
-     * the then-current {@link failure} here and clears `failure` on the fresh attempt, so
-     * the top failure banner (keyed on `status === 'failed'`) disappears once the task is
-     * restarted while the full error trail stays viewable in the "previous errors" history.
-     * Absent/empty for a run that has never been failed-then-retried.
-     */
-    readonly failureHistory: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-        readonly kind: v.PicklistSchema<["preflight", "dispatch", "environment", "evicted", "timeout", "agent", "job_failed", "rejected", "companion_rejected", "stalled", "cancelled", "unknown"], undefined>;
-        /** Human-readable summary (mirrors the run's `error` for back-compat). */
-        readonly message: v.StringSchema<undefined>;
-        /** Extended detail when available (the harness's reason, an HTTP body, …). */
-        readonly detail: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-        /** Where to look next (e.g. "check the container logs for this job id"). */
-        readonly hint: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-        /**
-         * Optional machine-readable cause code so the SPA can render precise, actionable guidance
-         * without string-matching the prose `message`/`detail` (the failure analogue of a
-         * {@link ConflictReason}). Kind-scoped: an `environment` failure carries an
-         * {@link EnvironmentFailureReason} (e.g. `deploy_runner_unwired`). Absent when the cause has
-         * no client-specific handling.
-         */
-        readonly reason: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        /** Epoch ms the failure was recorded. */
-        readonly occurredAt: v.NumberSchema<undefined>;
-        /** Last subtask counts seen before the failure, for context (null if none). */
-        readonly lastSubtasks: v.NullableSchema<v.ObjectSchema<{
-            readonly completed: v.NumberSchema<undefined>;
-            readonly inProgress: v.NumberSchema<undefined>;
-            readonly total: v.NumberSchema<undefined>;
-            readonly items: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-                /** The task's human-readable subject, as the agent wrote it. */
-                readonly label: v.StringSchema<undefined>;
-                readonly status: v.PicklistSchema<["pending", "in_progress", "completed"], undefined>;
-            }, undefined>, undefined>, undefined>;
-        }, undefined>, undefined>;
-        /**
-         * Index of the pipeline step that was in flight when the run failed (the run's
-         * `currentStep` at fail time), so the per-attempt failure trail can be attributed to a
-         * specific step — the step-detail overlay filters its "execution history" to the failures
-         * recorded for that step. Absent on a bootstrap failure (no steps) and on legacy records.
-         */
-        readonly stepIndex: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Successful outputs from the run's PRIOR attempts that a restart discarded, oldest→newest —
-     * the positive complement of {@link failureHistory}. A restart-from-step resets the chosen
-     * step and every later one, dropping their `output`; those that had already SUCCEEDED are
-     * recorded here (attributed by `stepIndex`) so the step-detail overlay's execution history
-     * surfaces the successful outputs a restart superseded, not only the errors. Bounded in count
-     * and per-entry size so the run's `detail` JSON doesn't bloat. Absent/empty for a run never
-     * restarted past a completed step (a plain retry re-runs only unfinished steps, so it records
-     * nothing).
-     */
-    readonly outputHistory: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-        /** Index of the pipeline step that produced this output (see {@link agentFailureSchema} `stepIndex`). */
-        readonly stepIndex: v.NumberSchema<undefined>;
-        /** Epoch ms the superseded attempt finished (its `finishedAt`, else when it was recorded). */
-        readonly occurredAt: v.NumberSchema<undefined>;
-        /** The attempt's prose/JSON output, clipped to a stored-size bound when {@link truncated}. */
-        readonly output: v.StringSchema<undefined>;
-        /** Whether {@link output} was clipped because the original exceeded the per-entry size bound. */
-        readonly truncated: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Non-fatal advisories computed once at run start — today the frontend UI-test flow's
-     * resolved-binding notes ({@link buildFrontendRunNotes}: duplicate env vars, or a partial-live
-     * set of bound services where some fall back to WireMock). Mirrors the harness's own
-     * `buildInfraNotes` but surfaced on the RUN so the SPA renders it in the run/step detail
-     * (distinct from a `failure`, which aborts the run). Absent/empty when there is nothing to
-     * flag. Rides in the `detail` JSON column (no dedicated column), reflecting the start-time
-     * state even after the underlying envs change.
-     */
-    readonly notes: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
-    /**
-     * The frontend UI-test flow's backend bindings RESOLVED once at run start (env var → the bound
-     * service's live ephemeral URL, or absent ⇒ mocked; see {@link resolveFrontendBindings}). Stamped
-     * on the run so the SPA's run/step detail projects what the run ACTUALLY drove against — a frozen
-     * snapshot that stays truthful after the underlying envs are torn down, rather than re-resolving
-     * against current live state (which for a finished run could disagree with the co-located
-     * start-time {@link notes}). Rides in the `detail` JSON column; absent for a non-frontend run.
-     */
-    readonly frontendBindings: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-        readonly envVar: v.StringSchema<undefined>;
-        readonly serviceUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
-    /**
-     * Internal user id (`usr_*`) of whoever started this run (or retried it). Recorded
-     * so the individual-usage restricted mode can use the initiator's OWN personal
-     * subscription (e.g. Claude) for the run's steps — a personal credential is never
-     * shared, so only its owner's runs may use it. Absent for runs started without a
-     * signed-in user (auth-disabled/local dev) and for legacy runs.
-     */
-    readonly initiatedBy: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    /**
-     * Epoch-ms creation time, stamped when the run is first started. Gives a run a stable
-     * creation timestamp independent of when its first step actually starts (the public-API
-     * job view reports it as `createdAt`). Absent on legacy runs persisted before this field.
-     */
-    readonly createdAt: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-    /**
-     * Optimistic-concurrency token: a monotonic revision of the persisted run row,
-     * bumped on every write. Read back by the repository and used by
-     * `compareAndSwap` so a human-action write (resolve decision / approve /
-     * request changes) that raced another writer is detected and retried on fresh
-     * state instead of silently clobbering it. Defaults to 0 for a run that has
-     * never been persisted. The SPA's execution store also keys its monotonic
-     * reconcile on it, so a lagging snapshot refresh can't regress a run a live
-     * event already advanced.
-     */
-    readonly rev: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
-    /**
-     * After-the-fact investigation context — where/what the run's most recent container step
-     * executed on (backend, model, repo) plus the control-plane host. Rides in the `detail` JSON
-     * (see {@link runDiagnosticsSchema}); absent on legacy runs and pure inline pipelines.
-     */
-    readonly diagnostics: v.OptionalSchema<v.ObjectSchema<{
-        /** Context of the most recent container-step dispatch. */
-        readonly lastDispatch: v.OptionalSchema<v.ObjectSchema<{
-            /** Index of the dispatched step within the pipeline. */
-            readonly stepIndex: v.NumberSchema<undefined>;
-            /** The step's agent kind (`coder`, `merger`, a custom kind, …). */
-            readonly agentKind: v.StringSchema<undefined>;
-            /** Resolved model ref `provider:model` (e.g. `anthropic:claude-opus-4-8`); null if unresolved. */
-            readonly model: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-            /**
-             * Which runner backend the step actually ran on — the datum that distinguishes a native
-             * host-process run from a sandboxed container: `local-native` | `local-container` |
-             * `runner-pool` | `cloudflare-container`. Filled on the first poll (the transport reports
-             * it); absent until then or on an older runtime.
-             */
-            readonly executionBackend: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            /** The repo the step operated on. */
-            readonly repo: v.OptionalSchema<v.ObjectSchema<{
-                readonly owner: v.StringSchema<undefined>;
-                readonly name: v.StringSchema<undefined>;
-                /** The base branch the work branched from. */
-                readonly baseBranch: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                /** VCS provider (`github` | `gitlab`), resolved from the run's repo origin. */
-                readonly provider: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            }, undefined>, undefined>;
-            /** Epoch ms the dispatch was recorded. */
-            readonly at: v.NumberSchema<undefined>;
-        }, undefined>, undefined>;
-        /**
-         * The control-plane (orchestrator) host running the engine — NOT necessarily where the agent
-         * ran (a container step runs elsewhere; see `lastDispatch.executionBackend`). `platform` is the
-         * orchestrator's `process.platform` (e.g. `win32` pins a Windows local deployment — the class
-         * of host that surfaced the native-Windows git-auth break). Best-effort.
-         */
-        readonly host: v.OptionalSchema<v.ObjectSchema<{
-            readonly platform: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        }, undefined>, undefined>;
-    }, undefined>, undefined>;
-}, undefined>;
-export type ExecutionInstance = v.InferOutput<typeof executionInstanceSchema>;
 export declare const workspaceSchema: v.ObjectSchema<{
     readonly id: v.StringSchema<undefined>;
     readonly name: v.StringSchema<undefined>;