@kindgi/client 0.1.2 → 0.1.4-rc.0

package/dist/index.d.ts

@@ -218,8 +218,54 @@ export interface Page<T> {
  * The brand prevents mixing free-form strings with validated semver values.
  */
 export type Semver = Brand<string, "Semver">;
+/**
+ * Why the runtime registered a version of an agent or flow under another
+ * number than its definition names. Versions never change, so a deploy
+ * whose definition's version is registered already with other content
+ * registers the next free version in its line instead:
+ *
+ * - `pins-changed`: the definition's version is registered with other
+ *   pins (a block it uses has a new version);
+ * - `unpinned`: the definition's version was published before pins
+ *   existed, so it has none;
+ * - `version-taken`: the definition's version holds another definition;
+ * - `edited`: derived from an existing version with some data-block pins
+ *   swapped (an expert's edit), not from a definition at all.
+ */
+export type VersionDerivationReason = "pins-changed" | "unpinned" | "version-taken" | "edited";
+/** The version a version was registered in place of (or derived from), and why. */
+export interface VersionDerivation {
+	/** The version the definition names, or the one an edit derived from. */
+	readonly version: string;
+	readonly reason: VersionDerivationReason;
+	/** For an edit: a short label for the version (e.g. "warmer tone"). */
+	readonly label?: string;
+	/** For an edit: who made it (`user:<id>`, or the token for a key). */
+	readonly by?: string;
+}
 /** Terminal states are `completed`, `failed`, `cancelled`. */
 export type RunStatus = "pending" | "running" | "suspended" | "completed" | "failed" | "cancelled";
+/**
+ * The exact version of each block a flow version runs: its lockfile.
+ *
+ * A flow names its tools by id (a tool node's `ref`, a fanout branch's
+ * `handler`) and its agents by id, with an exact `config.version` or
+ * none. When a version of the flow is published, the runtime pins each
+ * tool, and each agent that names no version, to its latest version
+ * then, and every run of that flow version uses those versions. So a
+ * new tool or agent version reaches the flow only through a new flow
+ * version.
+ *
+ * Set by the runtime at publish, never authored. A flow version
+ * published before pins existed has none and binds the latest versions
+ * per run.
+ */
+export interface FlowPins {
+	/** Tool id → the exact version this flow version runs. */
+	readonly tools: Readonly<Record<string, string>>;
+	/** Agent id → the exact version its agent nodes that name none run. */
+	readonly agents: Readonly<Record<string, string>>;
+}
 /**
  * A path into the run's addressable state. Dot-separated segments, always
  * starting with a recognized root. Path syntax is deliberately narrow — no
@@ -928,6 +974,20 @@ export interface Flow {
 	 * `$end` edge (the lowest-id taken one when several fire).
 	 */
 	readonly output?: FlowOutputSpec;
+	/**
+	 * The exact tool and agent versions this flow version runs, resolved by
+	 * the runtime when the version was published (see `FlowPins`). Never
+	 * authored: `loadFlow` refuses it. Absent on a flow version published
+	 * before pins existed; it binds the latest versions per run.
+	 */
+	readonly pins?: FlowPins;
+	/** `flowPinsDigest(pins)`, recorded when the version was published. */
+	readonly pinsDigest?: string;
+	/**
+	 * Set by the runtime on a version a deploy registered under another
+	 * number than the definition's (see `VersionDerivation`). Never authored.
+	 */
+	readonly derivedFrom?: VersionDerivation;
 }
 /**
  * A flow's declared output: what the run returns, built from the
@@ -1172,6 +1232,29 @@ export interface ToolHitlRule {
 	readonly mode: ToolHitlMode;
 	readonly requiredRole?: ReviewerRole;
 }
+/**
+ * The exact version of each block an agent version runs: its lockfile.
+ *
+ * An agent names its tools by range (`{ id: 'acme.lookup', version:
+ * '^1.0.0' }`), like `package.json`. When a version of the agent is
+ * published, the runtime resolves each range once, and every run of that
+ * version uses the versions recorded here. So a new tool version reaches
+ * an agent only through a new agent version, and two runs of one agent
+ * version always run the same blocks.
+ *
+ * Set by the runtime at publish, never authored. A version published
+ * before pins existed has none and resolves its ranges per run.
+ */
+export interface AgentPins {
+	/** Tool id → the exact version this agent version runs. */
+	readonly tools: Readonly<Record<string, string>>;
+	/** Prompt block id → exact version. Empty until the agent references prompt blocks. */
+	readonly prompts: Readonly<Record<string, string>>;
+	/** Settings block id → exact version. Empty until the agent references settings blocks. */
+	readonly settings: Readonly<Record<string, string>>;
+}
+/** The version an agent version was registered in place of, and why. */
+export type AgentDerivation = VersionDerivation;
 type AgentId$1 = Brand<string, "AgentId">;
 /**
  * A single message inside a conversation. Persisted as a `Fact` in
@@ -1269,6 +1352,20 @@ export interface ToolRef {
 	readonly id: string;
 	readonly version: string;
 }
+/**
+ * A prompt block an agent's instructions come from: its id and a semver
+ * range, resolved like a tool's (`pickVersion`) and pinned when the
+ * agent version is published.
+ */
+export interface PromptRef {
+	readonly prompt: string;
+	readonly version: string;
+}
+/** A settings block an agent reads: its id and a semver range, pinned at publish. */
+export interface BlockRef {
+	readonly id: string;
+	readonly version: string;
+}
 /**
  * Per-agent behavior for multi-turn conversations. The agent chooses:
  *   - How many prior messages to load (`historyLimit`; unset = all).
@@ -1328,6 +1425,14 @@ export interface ConversationHitlPolicy {
 	 * (see `resolveEffectiveHitlPolicy`).
 	 */
 	readonly timeoutMs?: number;
+	/**
+	 * What happens when an approval's time runs out: it escalates one
+	 * reviewer tier, and at `admin` it expires (the turn fails with
+	 * `hitl-cancelled`). `'escalate'` is the only behavior today, and the
+	 * default; `'auto-approve'` and `'auto-reject'` are refused rather than
+	 * accepted and ignored.
+	 */
+	readonly onTimeout?: "escalate";
 }
 /**
  * Budgets guard a single agent turn. Every field is optional; unset
@@ -1405,8 +1510,13 @@ export interface Agent {
 	 * unresolved reference fails the turn at invoke time
 	 * (`model-invocation-failed` whose `cause` is the `missing-parameter`
 	 * render error), never a silent empty string.
+	 *
+	 * Or a prompt block, by range (`{ prompt: 'acme.intake-prompt',
+	 * version: '^1.0.0' }`): its template renders here instead, with the
+	 * parameters it declares, and the version that runs is pinned when the
+	 * agent version is published (`pins.prompts`).
 	 */
-	readonly instructions: string;
+	readonly instructions: string | PromptRef;
 	/**
 	 * Typed parameters the caller supplies at invoke time. The UI reads
 	 * this to build a "configure agent" form; the runtime validates each
@@ -1518,6 +1628,35 @@ export interface Agent {
 	 * A tenant's `tool-errors` policy can lower it. See `ToolErrorsSpec`.
 	 */
 	readonly toolErrors?: ToolErrorsSpec;
+	/**
+	 * The exact block versions this agent version runs, resolved by the
+	 * runtime when the version was published (see `AgentPins`). Never
+	 * authored: `defineAgent` doesn't take it. Absent on an agent defined
+	 * in code and on a version published before pins existed; its tool
+	 * ranges then resolve per run.
+	 */
+	readonly pins?: AgentPins;
+	/**
+	 * Settings blocks the agent reads, by range. Each block's values reach
+	 * its tools as `ToolContext.settings[<block id>]` and its templates as
+	 * `settings.<block id>.<key>`; the versions are pinned at publish
+	 * (`pins.settings`).
+	 */
+	readonly settings?: readonly BlockRef[];
+	/**
+	 * A settings block of model settings (`MODEL_SETTINGS_SCHEMA`:
+	 * `temperature`, `maxOutputTokens`) the turn's model calls use. Pinned
+	 * at publish with the other settings.
+	 */
+	readonly modelSettings?: BlockRef;
+	/** `pinsDigest(pins)`, recorded when the version was published. */
+	readonly pinsDigest?: string;
+	/**
+	 * Set by the runtime on a version it registered under another number
+	 * than the definition's, when a deploy couldn't register that number
+	 * as it was (see `AgentDerivation`). Never authored.
+	 */
+	readonly derivedFrom?: AgentDerivation;
 }
 /** A retrieved fact + the retrieval intent that pulled it. */
 export interface RetrievedFact {
@@ -1608,8 +1747,16 @@ export interface DefineAgentSpec {
 	 * The system prompt. Sent to the model with every turn as the
 	 * baseline instructions. Load-bearing — this is where you shape
 	 * the agent's behavior (persona, output format, tool-use policy).
+	 *
+	 * Or a prompt block by range (`{ prompt: 'acme.intake-prompt',
+	 * version: '^1.0.0' }`), whose template and parameters are used
+	 * instead; then `parameters` stays unset (the block declares them).
 	 */
-	readonly instructions: string;
+	readonly instructions: string | PromptRef;
+	/** Settings blocks the agent reads, by range (see `Agent.settings`). */
+	readonly settings?: readonly BlockRef[];
+	/** A model-settings block, by range (see `Agent.modelSettings`). */
+	readonly modelSettings?: BlockRef;
 	/**
 	 * Required capabilities the agent needs from a `ModelProvider`.
 	 * Typically one entry: `[{ needs: [{ feature: 'tool-use' }] }]`
@@ -1711,18 +1858,6 @@ export interface DefineAgentSpec {
 	/** Free-form tags for catalog filtering. Not interpreted by the runtime. */
 	readonly tags?: readonly string[];
 }
-export type Scope = {
-	readonly kind: "tenant";
-	readonly tenantId: TenantId;
-} | {
-	readonly kind: "org";
-	readonly tenantId: TenantId;
-	readonly orgId: OrgId;
-} | {
-	readonly kind: "project";
-	readonly tenantId: TenantId;
-	readonly projectId: ProjectId;
-};
 export type GuardrailSeverity = "info" | "warn" | "error" | "critical";
 /**
  * Actions the engine surfaces when a check fails. Open string — the
@@ -1816,6 +1951,11 @@ export interface ToolCompletedEvent {
 	readonly invocationId: string;
 	readonly output: unknown;
 	readonly durationMs: number;
+	/**
+	 * In a replay turn: whether the tool ran (`live`), the past run's result
+	 * was used (`recorded`), or the call was refused (`refused`).
+	 */
+	readonly replay?: "live" | "recorded" | "refused";
 }
 export interface ToolFailedEvent {
 	readonly kind: "tool.failed";
@@ -1856,6 +1996,43 @@ export interface TurnFailedEvent {
 	readonly errorCode: string;
 	readonly message: string;
 }
+/**
+ * Wire-body serialization for `Scope` values.
+ *
+ * The `Scope` type from `@kindgi/platform` carries `tenantId` because
+ * server-internal code (routes, bindings, storage adapters) needs it
+ * everywhere the tuple flows. On the HTTP wire body, however, tenantId
+ * is redundant: every route derives it authoritatively from the bearer
+ * and any mismatched value is rejected as
+ * `scope-mismatch 400`.
+ *
+ * Client callers rarely know their session tenantId ahead of time, and
+ * a placeholder value would trip the mismatch check.
+ * `scopeForBody(scope)` strips tenantId at the SDK boundary so request
+ * bodies carry only the fields the server actually reads off the wire
+ * (`kind` + `orgId`/`projectId`).
+ *
+ * Use this ONLY for request bodies. Query-string helpers (`scopeToQuery`)
+ * already omit tenantId by construction and don't need this shim.
+ */
+/**
+ * A scope, as the client takes it: the kind and its id. `tenantId` is
+ * optional. The API derives the tenant from the bearer token, so the
+ * client never sends it, and an app needn't know it. `@kindgi/platform`'s
+ * `Scope`, which carries one, fits here as well.
+ */
+export type ScopeRef = {
+	readonly kind: "tenant";
+	readonly tenantId?: string;
+} | {
+	readonly kind: "org";
+	readonly orgId: string;
+	readonly tenantId?: string;
+} | {
+	readonly kind: "project";
+	readonly projectId: string;
+	readonly tenantId?: string;
+};
 /** @unwired SDK-defined id for a schedule. */
 export type ScheduleId = Brand<string, "ScheduleId">;
 /** @unwired SDK-defined id for a model provider. */
@@ -2323,6 +2500,25 @@ export interface Approval {
 	readonly updatedAt: Timestamp;
 	readonly decidedAt?: Timestamp;
 	readonly expiresAt?: Timestamp;
+	/**
+	 * The reviewer's decision, once one is recorded. Absent while the
+	 * approval is open, and when it ended without one (it expired, or a
+	 * timeout escalated it).
+	 */
+	readonly decision?: ApprovalDecisionRecord;
+}
+/**
+ * Wire shape — matches `@kindgi/api/openapi.json#ApprovalDecisionRecord`.
+ * An approval's recorded decision: what the reviewer decided, why, and who.
+ */
+export interface ApprovalDecisionRecord {
+	readonly decision: ApprovalDecision;
+	/** Who decided, as an actor: `user:<userId>`, the reviewer's user (the Kindgi runtime always records it). */
+	readonly decidedBy?: string;
+	readonly reviewerId: ReviewerId;
+	readonly reviewerRoleAtDecision: ReviewerRole$1;
+	readonly decidedAt: Timestamp;
+	readonly rationale?: string;
 }
 /**
  * Wire shape — matches `@kindgi/api/openapi.json#ReviewDecision`. Decision row
@@ -2595,6 +2791,12 @@ export interface Conversation {
 	readonly agentVersion: string;
 	readonly title: string;
 	readonly participantId?: string;
+	/**
+	 * The project the conversation is in: the project of the run that
+	 * opened it, or `projectId` on open (the tenant's Default project when
+	 * omitted). Absent on conversations from before 0.1.3.
+	 */
+	readonly projectId?: string;
 	/** Structural scope (project id, matter id, etc.). */
 	readonly scope: Readonly<Record<string, unknown>>;
 	readonly status: ConversationStatus;
@@ -2612,6 +2814,11 @@ export interface Conversation {
 export interface OpenConversationInput {
 	readonly agentId: AgentId;
 	readonly agentVersion: string;
+	/**
+	 * Put the conversation in a project (one of the tenant's): lists filter
+	 * by it. Omitted: the tenant's Default project, as for a run.
+	 */
+	readonly projectId?: string;
 	readonly scope?: Readonly<Record<string, unknown>>;
 	readonly participantId?: string;
 	readonly title?: string;
@@ -2782,6 +2989,17 @@ export interface ProvenanceRecord {
 		readonly value: string;
 		readonly signedAt: Timestamp;
 	};
+	/**
+	 * Each model call's usage from the cost ledger, by the `callId` in its
+	 * `model-call` node's attributes. Joined when read: not part of the
+	 * signed DAG.
+	 */
+	readonly callUsage?: Readonly<Record<string, {
+		readonly usage: ModelCallTokens;
+		readonly costUsd?: number;
+		readonly durationMs?: number;
+		readonly servedModel?: string;
+	}>>;
 }
 /**
  * Wire shape for records surfaced by `GET /v1/provenance` (list). The
@@ -2799,6 +3017,8 @@ export interface ProvenanceRecordMetadata {
 		readonly version: string;
 	};
 	readonly signed: boolean;
+	/** The project of the record's run; absent on records from before 0.1.3. */
+	readonly projectId?: string;
 }
 /**
  * Wire shape of a signed export bundle envelope — matches
@@ -2818,6 +3038,8 @@ export interface ExportedProvenance {
 	readonly exportedAt: Timestamp;
 }
 export interface ProvenanceQueryFilter extends Filter {
+	/** Only one project's records (`kind: 'project'`), or every project's in an org (`kind: 'org'`). */
+	readonly scope?: ScopeRef;
 	readonly runId?: RunId;
 	readonly agentId?: AgentId;
 	/** ISO 8601 timestamp — server filters `createdAt > createdAfter`. */
@@ -2879,6 +3101,69 @@ export interface CostRecord {
 	readonly occurredAt: Timestamp;
 	readonly metrics?: Readonly<Record<string, unknown>>;
 	readonly attributes?: Readonly<Record<string, unknown>>;
+	/** The call's id; its provenance `model-call` node carries it too. */
+	readonly callId?: string;
+	readonly projectId?: ProjectId;
+	/** The root of the record's run tree (a flow run, for its agent turns). */
+	readonly rootRunId?: RunId;
+	readonly parentRunId?: RunId;
+	readonly agentVersion?: string;
+	/** The flow of the run tree's root. */
+	readonly flowId?: string;
+	/** The step that made the call, and the turn's step number. */
+	readonly nodeId?: string;
+	readonly step?: number;
+	/** What the call was for, beyond the turn's own model step (`guardrail-judge:<id>`). */
+	readonly purpose?: string;
+	/** The model actually called. */
+	readonly model?: string;
+	/** The exact model version the vendor reported. */
+	readonly servedModel?: string;
+	/** The router picked a fallback provider for the turn. */
+	readonly fallback?: boolean;
+	/** `ok`: the provider answered. `failed`: the call threw. */
+	readonly status?: "ok" | "failed";
+	readonly usage?: ModelCallTokens;
+	readonly durationMs?: number;
+	readonly finishReason?: string;
+	/** The vendor's id for the request. */
+	readonly providerRequestId?: string;
+	/** HTTP attempts the call took, the client's retries included. */
+	readonly attempts?: number;
+	readonly error?: {
+		readonly message: string;
+	};
+	/** The vendor's own usage object, as it reported it (only with `includeRawUsage`). */
+	readonly rawUsage?: {
+		readonly provider: string;
+		readonly model: string;
+		readonly usage: Readonly<Record<string, unknown>>;
+	};
+}
+/**
+ * A model call's tokens. `promptTokens` / `completionTokens` are the
+ * totals; `cacheReadTokens` / `cacheWriteTokens` are parts of
+ * `promptTokens`, `reasoningTokens` of `completionTokens`, present when
+ * the provider reports them.
+ */
+export interface ModelCallTokens {
+	readonly promptTokens: number;
+	readonly completionTokens: number;
+	readonly cacheReadTokens?: number;
+	readonly cacheWriteTokens?: number;
+	readonly reasoningTokens?: number;
+}
+/**
+ * Token sums of an aggregate. `prompt` / `completion` are the totals;
+ * `cacheRead` / `cacheWrite` are parts of `prompt`, `reasoning` of
+ * `completion` (`0` where providers didn't report them).
+ */
+export interface CostTokenTotals {
+	readonly prompt: number;
+	readonly completion: number;
+	readonly cacheRead: number;
+	readonly cacheWrite: number;
+	readonly reasoning: number;
 }
 /** @deprecated Renamed to `CostRecord` to match the wire. */
 export type UsageRecord = CostRecord;
@@ -2888,12 +3173,25 @@ export type UsageRecord = CostRecord;
  */
 export interface CostRecordFilter extends Filter {
 	readonly runId?: RunId;
+	/** With `runId`: also every run it started, at any depth. */
+	readonly includeDescendants?: boolean;
+	/** Every record of the run tree whose root is this run. */
+	readonly rootRunId?: RunId;
 	readonly agentId?: AgentId;
 	readonly conversationId?: ThreadId;
 	readonly category?: string;
 	readonly providerId?: ProviderId;
+	/** The model actually called. */
+	readonly model?: string;
+	/** The exact model version the vendor reported. */
+	readonly servedModel?: string;
+	/** Records in this scope: a project, or every project of an org. */
+	readonly scope?: ScopeRef;
 	readonly from?: Timestamp;
+	/** Exclusive. */
 	readonly to?: Timestamp;
+	/** Add each model call's `rawUsage`: the vendor's own usage object. */
+	readonly includeRawUsage?: boolean;
 }
 /** @deprecated Renamed to `CostRecordFilter` to match the wire. */
 export type UsageQueryFilter = CostRecordFilter;
@@ -2901,7 +3199,7 @@ export type UsageQueryFilter = CostRecordFilter;
  * Wire enum of dimensions callers can pass to `cost.aggregate` — matches
  * `@kindgi/api/openapi.json#CostGroupDimension`.
  */
-export type CostGroupDimension = "agentId" | "runId" | "category" | "providerId" | "day" | "month" | "tenant" | "conversationId";
+export type CostGroupDimension = "agentId" | "runId" | "category" | "providerId" | "day" | "month" | "tenant" | "conversationId" | "model" | "servedModel" | "projectId" | "orgId" | "rootRunId" | "flowId";
 /**
  * Wire shape for one aggregated bucket — matches
  * `@kindgi/api/openapi.json#CostAggregateGroup`.
@@ -2914,6 +3212,7 @@ export interface CostAggregateGroup {
 	readonly key: Readonly<Record<string, string | null>>;
 	readonly count: number;
 	readonly totalUsd: number;
+	readonly tokens: CostTokenTotals;
 }
 /**
  * Wire shape for `GET /v1/cost/aggregate` response — matches
@@ -2923,6 +3222,7 @@ export interface CostAggregateResult {
 	readonly groups: readonly CostAggregateGroup[];
 	readonly totalUsd: number;
 	readonly totalRecords: number;
+	readonly tokens: CostTokenTotals;
 	readonly timeRange: {
 		readonly from: Timestamp;
 		readonly to: Timestamp;
@@ -3374,7 +3674,7 @@ export interface RegisterMcpEndpointInput {
 	 */
 	readonly secretRef?: McpEndpointSecretRef;
 	/** The scope the endpoint is registered in; authorization checks it. */
-	readonly scope: Scope;
+	readonly scope: ScopeRef;
 }
 /**
  * @unwired SDK-defined event shapes; the API has no event emission or
@@ -3616,6 +3916,130 @@ export interface ClientOptions {
 	/** Overridable fetch impl for testing. Defaults to global `fetch`. */
 	readonly fetch?: typeof fetch;
 }
+/** The verdict of a judgment. */
+export type Verdict = "yes" | "no";
+/**
+ * Where a judge class applies: the whole tenant, one project, or one
+ * agent in a project. Matches `@kindgi/api/openapi.json#JudgeClassScope`.
+ */
+export type JudgeClassScope = {
+	readonly kind: "tenant";
+} | {
+	readonly kind: "project";
+	readonly projectId: string;
+} | {
+	readonly kind: "agent";
+	readonly projectId: string;
+	readonly agentId: string;
+};
+/** Matches `@kindgi/api/openapi.json#JudgeClass`. */
+export interface JudgeClass {
+	readonly id: string;
+	readonly tenantId: string;
+	readonly scope: JudgeClassScope;
+	/** The deployment's own word for the class: "expert", "user", "arbitrator". */
+	readonly name: string;
+	/** How much a judgment of this class counts, relative to the others (≥ 0). */
+	readonly weight: number;
+	readonly description?: string;
+	readonly createdAt: Timestamp;
+	readonly updatedAt: Timestamp;
+	/** Set when the class was retired. */
+	readonly unregisteredAt?: Timestamp;
+}
+/** Input for `POST /v1/judge-classes` per `#CreateJudgeClassBody`. */
+export interface CreateJudgeClassInput {
+	readonly scope: JudgeClassScope;
+	readonly name: string;
+	readonly weight: number;
+	readonly description?: string;
+}
+/** Input for `PATCH /v1/judge-classes/{judgeClassId}` per `#UpdateJudgeClassBody`. */
+export interface UpdateJudgeClassInput {
+	readonly weight?: number;
+	readonly description?: string;
+}
+/** What a judged run ran: an agent at a version, or a flow at a version. */
+export interface JudgedSubject {
+	readonly kind: "agent" | "flow";
+	readonly id: string;
+	readonly version: string;
+}
+/** The judged item of a run's output. */
+export interface JudgedItem {
+	/** Your stable id for the item, e.g. a matched case's id. */
+	readonly key: string;
+	/** Where the item is in the run's output, as a JSON Pointer (RFC 6901), e.g. `/matches/2`. */
+	readonly pointer?: string;
+	/** The item's position in a ranked list (0 = first). */
+	readonly rank?: number;
+}
+/** Who asserted a judgment: the authenticated caller, never a typed name. */
+export interface JudgmentAssertedBy {
+	readonly kind: "user" | "service";
+	readonly id: string;
+}
+/** Matches `@kindgi/api/openapi.json#Judgment`. */
+export interface Judgment {
+	readonly id: string;
+	readonly tenantId: string;
+	readonly projectId: string;
+	readonly runId: string;
+	readonly subject: JudgedSubject;
+	readonly item: JudgedItem;
+	readonly verdict: Verdict;
+	readonly reason?: string;
+	/** Absent when the judgment is unclassified (it counts with weight 1). */
+	readonly judgeClassId?: string;
+	readonly assertedBy: JudgmentAssertedBy;
+	/** An app's opaque id for its end user who judged, when it judged on their behalf. */
+	readonly participantId?: string;
+	readonly createdAt: Timestamp;
+	/** Set when the judgment was removed or superseded. */
+	readonly unregisteredAt?: Timestamp;
+	/** The judgment that replaced this one. */
+	readonly supersededBy?: string;
+}
+/**
+ * What a judged agent turn read besides its input, captured when it was
+ * first judged: the conversation before it and what its retrievals returned.
+ */
+export interface JudgedRunContext {
+	/** The conversation's messages before the turn, oldest first (at most the last 200). */
+	readonly history?: readonly unknown[];
+	/** Whether older messages were left out of `history`. */
+	readonly historyTruncated?: boolean;
+	/** What the turn's retrievals returned. */
+	readonly retrieved?: unknown;
+}
+/** The stored copy of a judged run's input and output. */
+export interface JudgedRunCopy {
+	readonly runId: string;
+	readonly subject: JudgedSubject;
+	readonly input: unknown;
+	/** Absent for runs judged before context was captured, and for flow runs. */
+	readonly context?: JudgedRunContext;
+	readonly output: unknown;
+	readonly capturedAt: Timestamp;
+}
+/** Matches `@kindgi/api/openapi.json#JudgmentWithCopies`. */
+export interface JudgmentWithCopies extends Judgment {
+	/** The run's input and output as they were when it was first judged. */
+	readonly run: JudgedRunCopy;
+	/** The judged item's value, when the judgment pointed at it. */
+	readonly itemValue?: unknown;
+}
+/** Input for `POST /v1/judgments` per `#CreateJudgmentBody`. */
+export interface CreateJudgmentInput {
+	readonly runId: string;
+	readonly item: JudgedItem;
+	readonly verdict: Verdict;
+	readonly reason?: string;
+	/** Optional. When given it must exist and apply to the run. */
+	readonly judgeClassId?: string;
+	/** Your opaque id for the end user who judged, when judging on their behalf. */
+	readonly participantId?: string;
+}
 /** Signature the resource clients call into. */
 export interface Transport {
 	/** Base URL, no trailing slash. */
@@ -3800,6 +4224,20 @@ declare namespace Schemas {
 	export type HealthResult = {
 		ok: true;
 	};
+	/**
+	 * Set on an agent's turn (an agent run, or the turn a flow's agent step started): the agent, the version that ran and the conversation. Absent on other runs, and on turns that ran before Kindgi 0.1.3.
+	 */
+	export type RunAgent = {
+		/**
+		 * The agent id.
+		 */
+		id: string;
+		/**
+		 * The agent version that ran (semver).
+		 */
+		version: string;
+		conversationId: string;
+	};
 	export type Run = {
 		/**
 		 * RunId.
@@ -3830,6 +4268,15 @@ declare namespace Schemas {
 		 * Set on a child run: the node in the parent run that started it.
 		 */
 		parentNodeId?: string;
+		agent?: RunAgent;
+		/**
+		 * Set on a replay run (an eval run re-running a past run): the run it replays.
+		 */
+		replayOf?: string;
+		/**
+		 * Set on a replay run: the eval run that started it.
+		 */
+		evalRunId?: string;
 		/**
 		 * Only in the response to `POST /v1/runs`, when the deployment issues public run tokens: a read-only token for this run (and its descendants) to hand to a browser, for `GET /v1/runs/{runId}/progress` and its stream.
 		 */
@@ -3938,6 +4385,15 @@ declare namespace Schemas {
 			 * Set on a child run: the node in the parent run that started it.
 			 */
 			parentNodeId?: string;
+			agent?: RunAgent;
+			/**
+			 * Set on a replay run (an eval run re-running a past run): the run it replays.
+			 */
+			replayOf?: string;
+			/**
+			 * Set on a replay run: the eval run that started it.
+			 */
+			evalRunId?: string;
 			/**
 			 * Only in the response to `POST /v1/runs`, when the deployment issues public run tokens: a read-only token for this run (and its descendants) to hand to a browser, for `GET /v1/runs/{runId}/progress` and its stream.
 			 */
@@ -4175,6 +4631,20 @@ declare namespace Schemas {
 	 */
 	export type ReviewerRole = "standard" | "senior" | "admin";
 	export type ApprovalStatus = "pending" | "assigned" | "in_review" | "approved" | "rejected" | "escalated" | "expired" | "withdrawn";
+	export type ApprovalDecisionRecord = {
+		decision: "approve" | "reject" | "escalate" | "withdraw";
+		/**
+		 * Who decided, as an actor: `user:<userId>`, the reviewer's user. The run's journal and provenance name the decider the same way. The Kindgi runtime always records it; a deployment whose HITL binding doesn't leaves it out.
+		 */
+		decidedBy?: string;
+		reviewerId: string;
+		/**
+		 * Reviewer role class. Hierarchy: standard < senior < admin.
+		 */
+		reviewerRoleAtDecision: "standard" | "senior" | "admin";
+		decidedAt: string;
+		rationale?: string;
+	};
 	export type Approval = {
 		id: string;
 		tenantId: string;
@@ -4200,6 +4670,7 @@ declare namespace Schemas {
 		updatedAt: string;
 		decidedAt?: string;
 		expiresAt?: string;
+		decision?: ApprovalDecisionRecord;
 	};
 	export type ReviewDecision = {
 		id: string;
@@ -4225,7 +4696,7 @@ declare namespace Schemas {
 		decision: "approve" | "reject" | "escalate" | "withdraw";
 		rationale?: string;
 		/**
-		 * Payload passed to the run waitpoint (`RunBinding.completeToken`) when the approval is linked to a suspended run and the decision is `approve` or `reject`.
+		 * Payload passed to the run waitpoint (`RunBinding.completeToken`) when the approval is linked to a suspended run and the decision is `approve` or `reject`. Refused (400 `bad-input`) for an agent's tool-call or session gate (`tool-call:pending`, `agent-turn:session-hitl-gate`): those resume on the decision alone.
 		 */
 		value?: unknown;
 	};
@@ -4352,68 +4823,457 @@ declare namespace Schemas {
 		nextCursor?: string;
 		hasMore: boolean;
 	};
-	export type PromptParameter = {
+	/**
+	 * Where a judge class applies: the whole tenant, one project, or one agent in a project.
+	 */
+	export type JudgeClassScope = {
+		kind: "tenant";
+	} | {
+		kind: "project";
+		projectId: string;
+	} | {
+		kind: "agent";
+		projectId: string;
+		agentId: string;
+	};
+	export type JudgeClass = {
+		id: string;
+		tenantId: string;
+		scope: JudgeClassScope;
+		/**
+		 * The deployment's own word for the class: "expert", "user", "arbitrator".
+		 */
 		name: string;
+		/**
+		 * How much a judgment of this class counts, relative to the others.
+		 */
+		weight: number;
 		description?: string;
-		type: "string" | "number" | "boolean" | "date";
-		required?: boolean;
+		createdAt: string;
+		updatedAt: string;
 		/**
-		 * Default value used when the caller omits this parameter.
+		 * Set when the class was retired.
 		 */
-		default?: unknown;
+		unregisteredAt?: string;
 	};
-	export type RetrievalIntent = {
-		types: Array<string>;
-		scope: "same-conversation" | "same-project" | "tenant";
-		limit?: number;
-		mode?: "keyword" | "semantic" | "both";
+	export type JudgeClassCollectionPage = {
+		data: Array<JudgeClass>;
+		/**
+		 * Opaque cursor. Treat as opaque on the client.
+		 */
+		nextCursor?: string;
+		hasMore: boolean;
 	};
-	export type ConversationPolicy = Partial<{
-		historyLimit: number;
-		autoCloseAfterInactiveSeconds: number;
-		hitlAfterTurns: number;
-	}>;
-	export type TurnBudget = Partial<{
-		maxSteps: number;
-		maxCostUsd: number;
-		maxWallMs: number;
+	export type CreateJudgeClassBody = {
+		scope: JudgeClassScope;
+		name: string;
+		weight: number;
+		description?: string;
+	};
+	export type UpdateJudgeClassBody = Partial<{
+		weight: number;
+		description: string;
 	}>;
+	export type UnregisterJudgeClassResult = {
+		judgeClassId: string;
+		unregistered: true;
+	};
 	/**
-	 * Capability declaration — see `@kindgi/capabilities`. Additional properties are permitted so new capability kinds do not require a wire change.
-	 */
-	export type Capability = Record<string, unknown>;
-	/**
-	 * Typed tool reference. `version` is a semver **range** (npm-style: `1.2.3` exact pin, `^1.2.3` compatible-updates, `~1.2.3` patch-updates-only, `>=1.0.0 <2.0.0` explicit range). Dispatch resolves the range to a concrete active version via `semver.maxSatisfying` at run start. No implicit "latest" — every tool ref names both id and range.
+	 * What a judged run ran: an agent at a version, or a flow at a version.
 	 */
-	export type ToolRef = {
+	export type JudgedSubject = {
+		kind: "agent" | "flow";
 		id: string;
 		version: string;
 	};
-	export type AgentOutputSpec = {
+	/**
+	 * The judged item of a run's output.
+	 */
+	export type JudgedItem = {
 		/**
-		 * JSON Schema (draft 2020-12) the final answer must match.
+		 * The caller's stable id for the item.
 		 */
-		schema: Record<string, unknown>;
+		key: string;
 		/**
-		 * A name for the output, shown to the model and in errors. Default `output`.
+		 * Where the item is in the run's output, as a JSON Pointer (RFC 6901), e.g. `/matches/2`. `""` is the whole output.
 		 */
-		name?: string;
+		pointer?: string;
 		/**
-		 * How many times the model is asked to repair an invalid answer. Default 1.
+		 * The item's position in a ranked list (0 = first).
 		 */
-		maxRepairs?: number;
+		rank?: number;
 	};
-	export type ToolErrorsSpec = Partial<{
+	/**
+	 * Who asserted a judgment: the authenticated caller, never a typed name.
+	 */
+	export type JudgmentAssertedBy = {
+		kind: "user" | "service";
 		/**
-		 * Failed calls sent back to the model per turn. Default 1.
+		 * A user id, or for a service token its token or session id.
 		 */
-		maxRetries: number;
+		id: string;
+	};
+	export type Judgment = {
+		id: string;
+		tenantId: string;
+		projectId: string;
+		runId: string;
+		subject: JudgedSubject;
+		item: JudgedItem;
+		verdict: "yes" | "no";
+		reason?: string;
 		/**
-		 * Which failures are sent back: arguments that don't fit the input schema (`invalid-arguments`), a tool the agent doesn't have (`unknown-tool`), a tool that ran and failed (`tool-error`). Default `invalid-arguments`, `unknown-tool`.
+		 * The judge class the judgment is recorded under. Absent when unclassified (counts with weight 1).
 		 */
-		retryOn: Array<"invalid-arguments" | "unknown-tool" | "tool-error">;
-	}>;
-	export type Agent = {
+		judgeClassId?: string;
+		assertedBy: JudgmentAssertedBy;
+		/**
+		 * The app's opaque id for its end user who judged, when an app judged on their behalf.
+		 */
+		participantId?: string;
+		createdAt: string;
+		/**
+		 * Set when the judgment was removed or superseded.
+		 */
+		unregisteredAt?: string;
+		/**
+		 * The judgment that replaced this one.
+		 */
+		supersededBy?: string;
+	};
+	/**
+	 * What a judged run needs besides its input to be replayed, captured when it was first judged. For an agent turn: the conversation before it, what its retrievals returned, and the decision at its session approval gate. For a flow run: its tool calls with their results.
+	 */
+	export type JudgedRunContext = Partial<{
+		/**
+		 * The conversation's messages before the turn, oldest first (at most the last 200).
+		 */
+		history: Array<unknown>;
+		/**
+		 * Whether older messages were left out of `history`.
+		 */
+		historyTruncated: boolean;
+		/**
+		 * What the turn's retrievals returned.
+		 */
+		retrieved: unknown;
+		/**
+		 * The reviewer's decision at the turn's session approval gate, when the turn waited on one. A replay of the turn follows it.
+		 */
+		sessionApproval: {
+			approved: boolean;
+			/**
+			 * The reviewer's reason for a rejection.
+			 */
+			rationale?: string;
+		};
+		/**
+		 * For a flow run: what it did, kept at its first judgment so it can be replayed. Every tool call it made with its result (at its tool nodes, in its agent steps' turns and in its sub-flows), at most 500, and its agent steps.
+		 */
+		flow: {
+			calls: Array<{
+				/**
+				 * The run that made it: the flow run, a sub-flow's, or an agent step's turn.
+				 */
+				runId: string;
+				/**
+				 * The tool node that made it, or the agent step whose turn did.
+				 */
+				nodeId?: string;
+				/**
+				 * The loop iteration, in a loop body.
+				 */
+				scope?: string;
+				toolId: string;
+				arguments?: unknown;
+				result?: unknown;
+			}>;
+			steps: Array<{
+				runId: string;
+				nodeId?: string;
+				scope?: string;
+				agentId: string;
+				agentVersion: string;
+				/**
+				 * What the step's turn retrieved.
+				 */
+				retrieved?: unknown;
+			}>;
+			/**
+			 * More calls were made than were kept.
+			 */
+			truncated?: boolean;
+		};
+	}>;
+	/**
+	 * The stored copy of a judged run's input and output, taken when it was first judged.
+	 */
+	export type JudgedRunCopy = {
+		runId: string;
+		subject: JudgedSubject;
+		input: unknown;
+		context?: JudgedRunContext;
+		output: unknown;
+		capturedAt: string;
+	};
+	/**
+	 * A judgment with the stored copies of what was judged.
+	 */
+	export type JudgmentWithCopies = Judgment & {
+		run: JudgedRunCopy;
+		/**
+		 * The judged item's value, when the judgment pointed at it.
+		 */
+		itemValue?: unknown;
+	};
+	export type JudgmentCollectionPage = {
+		data: Array<Judgment>;
+		/**
+		 * Opaque cursor. Treat as opaque on the client.
+		 */
+		nextCursor?: string;
+		hasMore: boolean;
+	};
+	export type CreateJudgmentBody = {
+		runId: string;
+		item: JudgedItem;
+		verdict: "yes" | "no";
+		reason?: string;
+		/**
+		 * Optional. When given it must exist and apply to the run.
+		 */
+		judgeClassId?: string;
+		/**
+		 * An app's opaque id for its end user, when judging on their behalf.
+		 */
+		participantId?: string;
+	};
+	export type UnregisterJudgmentResult = {
+		judgmentId: string;
+		unregistered: true;
+	};
+	/**
+	 * The judgments of one item of a case's output, summed up.
+	 */
+	export type JudgedItemSummary = {
+		key: string;
+		pointer?: string;
+		rank?: number;
+		/**
+		 * How many judgments said yes.
+		 */
+		yes: number;
+		/**
+		 * How many judgments said no.
+		 */
+		no: number;
+		/**
+		 * The weight behind "yes" (an unclassified judgment counts 1).
+		 */
+		yesWeight: number;
+		/**
+		 * The weight behind all judgments of the item.
+		 */
+		totalWeight: number;
+		/**
+		 * The reasons given, newest first.
+		 */
+		reasons: Array<{
+			verdict: "yes" | "no";
+			reason: string;
+		}>;
+	};
+	/**
+	 * One case of a `judged` eval suite: a copy of a judged run with its items' judgments summed up.
+	 */
+	export type JudgedEvalCase = {
+		/**
+		 * The judged run's id.
+		 */
+		caseId: string;
+		subject: JudgedSubject;
+		input: unknown;
+		context?: JudgedRunContext;
+		output: unknown;
+		items: Array<JudgedItemSummary>;
+	};
+	export type JudgedEvalCaseCollectionPage = {
+		data: Array<JudgedEvalCase>;
+		/**
+		 * Opaque cursor. Treat as opaque on the client.
+		 */
+		nextCursor?: string;
+		hasMore: boolean;
+	};
+	/**
+	 * Name the agent (`agentId`) or the flow (`flowId`) whose judged runs to use.
+	 */
+	export type BuildJudgedSuiteBody = {
+		/**
+		 * Semver version to publish, e.g. `1.0.0`.
+		 */
+		version: string;
+		projectId: string;
+		agentId?: string;
+		/**
+		 * Needs `agentId`.
+		 */
+		agentVersion?: string;
+		flowId?: string;
+		/**
+		 * Runs first judged at or after this time.
+		 */
+		since?: string;
+		/**
+		 * Runs first judged before this time.
+		 */
+		until?: string;
+		/**
+		 * Count only judgments recorded under these judge classes.
+		 */
+		judgeClassIds?: Array<string>;
+		/**
+		 * Leave out runs with fewer counted judgments. Default 1.
+		 */
+		minJudgments?: number;
+		description?: string;
+	};
+	export type BuildJudgedSuiteResult = {
+		suiteId: string;
+		version: string;
+		kind: "judged";
+		caseCount: number;
+		/**
+		 * Whether more judged runs matched than the 1000 cases a set holds.
+		 */
+		truncated: boolean;
+	};
+	export type PromptParameter = {
+		name: string;
+		description?: string;
+		type: "string" | "number" | "boolean" | "date";
+		required?: boolean;
+		/**
+		 * Default value used when the caller omits this parameter.
+		 */
+		default?: unknown;
+	};
+	export type RetrievalIntent = {
+		types: Array<string>;
+		scope: "same-conversation" | "same-project" | "tenant";
+		limit?: number;
+		mode?: "keyword" | "semantic" | "both";
+	};
+	export type ConversationPolicy = Partial<{
+		historyLimit: number;
+		autoCloseAfterInactiveSeconds: number;
+		hitlAfterTurns: number;
+	}>;
+	export type TurnBudget = Partial<{
+		maxSteps: number;
+		maxCostUsd: number;
+		maxWallMs: number;
+	}>;
+	/**
+	 * Capability declaration — see `@kindgi/capabilities`. Additional properties are permitted so new capability kinds do not require a wire change.
+	 */
+	export type Capability = Record<string, unknown>;
+	/**
+	 * Typed tool reference. `version` is a semver **range** (npm-style: `1.2.3` exact pin, `^1.2.3` compatible-updates, `~1.2.3` patch-updates-only, `>=1.0.0 <2.0.0` explicit range). Dispatch resolves the range to a concrete active version via `semver.maxSatisfying` at run start. No implicit "latest" — every tool ref names both id and range.
+	 */
+	export type ToolRef = {
+		id: string;
+		version: string;
+	};
+	export type AgentOutputSpec = {
+		/**
+		 * JSON Schema (draft 2020-12) the final answer must match.
+		 */
+		schema: Record<string, unknown>;
+		/**
+		 * A name for the output, shown to the model and in errors. Default `output`.
+		 */
+		name?: string;
+		/**
+		 * How many times the model is asked to repair an invalid answer. Default 1.
+		 */
+		maxRepairs?: number;
+	};
+	export type ToolErrorsSpec = Partial<{
+		/**
+		 * Failed calls sent back to the model per turn. Default 1.
+		 */
+		maxRetries: number;
+		/**
+		 * Which failures are sent back: arguments that don't fit the input schema (`invalid-arguments`), a tool the agent doesn't have (`unknown-tool`), a tool that ran and failed (`tool-error`). Default `invalid-arguments`, `unknown-tool`.
+		 */
+		retryOn: Array<"invalid-arguments" | "unknown-tool" | "tool-error">;
+	}>;
+	/**
+	 * A prompt block an agent's instructions come from, by id and semver range.
+	 */
+	export type PromptRef = {
+		/**
+		 * The prompt block id.
+		 */
+		prompt: string;
+		/**
+		 * A semver range (`^1.0.0`, `1.2.0`).
+		 */
+		version: string;
+	};
+	/**
+	 * A settings block an agent reads, by id and semver range.
+	 */
+	export type BlockRef = {
+		/**
+		 * The settings block id.
+		 */
+		id: string;
+		/**
+		 * A semver range (`^1.0.0`, `1.2.0`).
+		 */
+		version: string;
+	};
+	/**
+	 * The exact block versions an agent version runs: its lockfile. Set by the runtime when the version is published, never in the publish body: each tool range resolves once to the version every run of that agent version uses, so a new tool version reaches the agent only through a new agent version. Absent on a version published before pins existed (its ranges resolve per run).
+	 */
+	export type AgentPins = {
+		/**
+		 * Tool id → exact version.
+		 */
+		tools: Record<string, string>;
+		/**
+		 * Prompt block id → exact version.
+		 */
+		prompts: Record<string, string>;
+		/**
+		 * Settings block id → exact version.
+		 */
+		settings: Record<string, string>;
+	};
+	/**
+	 * Set by the runtime on an agent or flow version a deploy registered in place of the definition's version, which was registered already with other pins or content (versions never change). Never in the publish body.
+	 */
+	export type VersionDerivation = {
+		/**
+		 * The version the definition names.
+		 */
+		version: string;
+		/**
+		 * `pins-changed`: a block it uses has a new version; `unpinned`: the definition's version was published before pins existed; `version-taken`: the definition's version holds another definition; `edited`: derived from `version` with some data-block pins swapped (`POST /v1/agents/{agentId}/versions`).
+		 */
+		reason: "pins-changed" | "unpinned" | "version-taken" | "edited";
+		/**
+		 * For `edited`: a short label for the version.
+		 */
+		label?: string;
+		/**
+		 * For `edited`: who derived it (`user:<id>`).
+		 */
+		by?: string;
+	};
+	export type Agent = {
 		/**
 		 * AgentId — dotted namespace (e.g. `acme.drafting`).
 		 */
@@ -4424,8 +5284,16 @@ declare namespace Schemas {
 		version: string;
 		name: string;
 		description?: string;
-		instructions: string;
+		/**
+		 * The system prompt (a Liquid template), or a prompt block by range whose template and parameters are used instead (pinned at publish, `pins.prompts`).
+		 */
+		instructions: string | PromptRef;
 		parameters?: Array<PromptParameter>;
+		/**
+		 * Settings blocks the agent reads, by range: tools read them as `ToolContext.settings['<id>']`, templates as `settings["<id>"]`. Pinned at publish (`pins.settings`).
+		 */
+		settings?: Array<BlockRef>;
+		modelSettings?: BlockRef;
 		capabilities: Array<Capability>;
 		tools: Array<ToolRef>;
 		retrieval: Array<RetrievalIntent>;
@@ -4443,6 +5311,75 @@ declare namespace Schemas {
 		tags?: Array<string>;
 		output?: AgentOutputSpec;
 		toolErrors?: ToolErrorsSpec;
+		pins?: AgentPins;
+		derivedFrom?: VersionDerivation;
+		/**
+		 * Present only on an unregistered version (`GET …/versions/{version}` reads those too). Unregister stops a version being chosen, not the pins that hold it: a new run naming it is refused, while a resumed run and a published version that pins it still run it.
+		 */
+		unregisteredAt?: string;
+		/**
+		 * Set by the runtime with `pins`: `sha256:<hex>` of the pins' canonical JSON (sorted keys, no whitespace). Two agent versions with the same digest run the same blocks.
+		 */
+		pinsDigest?: string;
+	};
+	/**
+	 * One pin that differs between two versions of an agent or a flow.
+	 */
+	export type PinChange = {
+		kind: "tool" | "prompt" | "setting" | "agent";
+		id: string;
+		/**
+		 * The earlier version's pin; absent when it had none.
+		 */
+		from?: string;
+		/**
+		 * The later version's pin; absent when it has none.
+		 */
+		to?: string;
+	};
+	/**
+	 * The data-block pins to swap, by block id → exact version. Only blocks the version already references; tool pins come from code.
+	 */
+	export type AgentPinSwaps = Partial<{
+		/**
+		 * Prompt block id → exact version.
+		 */
+		prompts: Record<string, string>;
+		/**
+		 * Settings block id → exact version.
+		 */
+		settings: Record<string, string>;
+	}>;
+	/**
+	 * Derive a new agent version from a pinned one with some data-block pins swapped: an expert's edit reaching an agent with no code change.
+	 */
+	export type DeriveAgentVersionBody = {
+		/**
+		 * The version to derive from (it must be pinned).
+		 */
+		from: string;
+		pins: AgentPinSwaps;
+		/**
+		 * A short label for the new version.
+		 */
+		label?: string;
+		/**
+		 * The agent's project, when the runtime doesn't record it on the version.
+		 */
+		projectId?: string;
+	};
+	/**
+	 * The exact tool and agent versions a flow version runs: its lockfile. Set by the runtime when the version is published, never in the publish body: each tool the flow runs, and each agent it runs at no named version, resolves once to its latest version then, which every run of that flow version uses. Absent on a version published before pins existed (it binds the latest versions per run).
+	 */
+	export type FlowPins = {
+		/**
+		 * Tool id → exact version.
+		 */
+		tools: Record<string, string>;
+		/**
+		 * Agent id → exact version, for agent nodes that name no version.
+		 */
+		agents: Record<string, string>;
 	};
 	/**
 	 * Full `defineAgent` spec. Validated server-side via `@kindgi/agents.defineAgent` — validation failures return `400 validation-failed` with the issue list under `details.issues`.
@@ -4456,8 +5393,16 @@ declare namespace Schemas {
 		 * Project this belongs to (its content scope). Required: missing, or not a project in the caller's tenant → `400 bad-input`.
 		 */
 		projectId: string;
-		instructions: string;
+		/**
+		 * The system prompt (a Liquid template), or a prompt block by range whose template and parameters are used instead (pinned at publish, `pins.prompts`).
+		 */
+		instructions: string | PromptRef;
 		parameters?: Array<PromptParameter>;
+		/**
+		 * Settings blocks the agent reads, by range: tools read them as `ToolContext.settings['<id>']`, templates as `settings["<id>"]`. Pinned at publish (`pins.settings`).
+		 */
+		settings?: Array<BlockRef>;
+		modelSettings?: BlockRef;
 		capabilities: Array<Capability>;
 		tools: Array<ToolRef>;
 		retrieval: Array<RetrievalIntent>;
@@ -4544,6 +5489,16 @@ declare namespace Schemas {
 		edges: Array<FlowEdge>;
 		maxParallelism?: number;
 		metadata?: Record<string, unknown>;
+		pins?: FlowPins;
+		/**
+		 * Set by the runtime with `pins`: `sha256:<hex>` of the pins' canonical JSON (sorted keys, no whitespace).
+		 */
+		pinsDigest?: string;
+		derivedFrom?: VersionDerivation;
+		/**
+		 * Present only on an unregistered version (`GET …/versions/{version}` reads those too). Unregister stops a version being chosen, not the pins that hold it: a new run naming it is refused, while a resumed run and a published version that pins it still run it.
+		 */
+		unregisteredAt?: string;
 	};
 	/**
 	 * Full flow definition. Validated server-side via `@kindgi/flow.loadFlow` — validation failures return `400 validation-failed` with the issue list under `details.issues`.
@@ -4925,6 +5880,10 @@ declare namespace Schemas {
 		agentVersion: string;
 		title: string;
 		participantId?: string;
+		/**
+		 * The project the conversation is in: the project of the run that opened it, or `projectId` on open (the tenant's Default project when omitted). Absent on conversations from before Kindgi 0.1.3; those are listed only without a scope.
+		 */
+		projectId?: string;
 		/**
 		 * Free-form scope object (currently `{ tenantId }` in tests; enterprises extend with `matterId`, `engagementId`, etc.).
 		 */
@@ -4969,6 +5928,10 @@ declare namespace Schemas {
 		 * Optional. Defaults to `"Untitled conversation"` when omitted.
 		 */
 		title?: string;
+		/**
+		 * The project the conversation is in; `GET /v1/conversations?scopeKind=project&scopeId=…` lists it. A project of the caller's tenant, else `400 bad-input`. Omitted: the tenant's Default project, as for a run.
+		 */
+		projectId?: string;
 		/**
 		 * Structural scope (project id, matter id, etc.). Treated opaquely by the runtime.
 		 */
@@ -5263,6 +6226,20 @@ declare namespace Schemas {
 		 */
 		signed: boolean;
 		createdAt: string;
+		/**
+		 * The project of the record's run. Absent on records from before Kindgi 0.1.3; those are listed only without a scope.
+		 */
+		projectId?: string;
+	};
+	/**
+	 * The call's tokens. `promptTokens` / `completionTokens` are the totals; `cacheReadTokens` / `cacheWriteTokens` are parts of `promptTokens`, `reasoningTokens` of `completionTokens`, present when the provider reports them.
+	 */
+	export type ModelCallTokens = {
+		promptTokens: number;
+		completionTokens: number;
+		cacheReadTokens?: number;
+		cacheWriteTokens?: number;
+		reasoningTokens?: number;
 	};
 	/**
 	 * Full provenance record including the DAG payload.
@@ -5307,6 +6284,15 @@ declare namespace Schemas {
 			signedAt: string;
 		};
 		createdAt: string;
+		/**
+		 * Each model call's usage from the cost ledger, by the `callId` in its `model-call` node's attributes. Joined when read: not part of the signed DAG. A signed export includes it, as it stood when signed.
+		 */
+		callUsage?: Record<string, {
+			usage: ModelCallTokens;
+			costUsd?: number;
+			durationMs?: number;
+			servedModel?: string;
+		}>;
 	};
 	export type ProvenanceCollectionPage = {
 		data: Array<ProvenanceRecordMetadata>;
@@ -5324,7 +6310,7 @@ declare namespace Schemas {
 		includeMessages?: boolean;
 	};
 	/**
-	 * Signed exportable bundle. `bundle` is base64 of the exact bytes that were signed (sorted-key canonical JSON, no whitespace); verifiers can pass those bytes directly to `verifyEd25519`. The bundle body itself includes `bundleSchemaVersion`, `runId`, `tenantId`, `dag: { nodes, edges }`, `messages?` (if requested), etc. See `canonicalization` for the deterministic serialization algorithm.
+	 * Signed exportable bundle. `bundle` is base64 of the exact bytes that were signed (sorted-key canonical JSON, no whitespace); verifiers can pass those bytes directly to `verifyEd25519`. The bundle body itself includes `bundleSchemaVersion`, `runId`, `tenantId`, `dag: { nodes, edges }`, `messages?` (if requested), `callUsage?` (the usage of the model calls, from the cost ledger), etc. See `canonicalization` for the deterministic serialization algorithm.
 	 */
 	export type ExportProvenanceResult = {
 		runId: string;
@@ -5333,7 +6319,7 @@ declare namespace Schemas {
 		 */
 		bundle: string;
 		/**
-		 * Semver for the shape of the bundle body. Currently `1.0.0`.
+		 * Semver for the shape of the bundle body. Currently `1.1.0`, which adds `callUsage`: each model call's usage from the cost ledger, by call id, as it stood when signed.
 		 */
 		bundleSchemaVersion: string;
 		algorithm: "ed25519";
@@ -5523,6 +6509,10 @@ declare namespace Schemas {
 		 * A fallback serves a capability only when no other provider satisfies it (e.g. `kindgi dev`'s scripted `dev-echo`); an agent turn routed to one carries a `fallback-provider` warning. Absent = `false`.
 		 */
 		fallback?: boolean;
+		/**
+		 * Bookkeeping, such as who manages the provider; the router ignores labels. At most 32 keys; a key is 1-63 lowercase letters and digits, with `.`, `-`, `_` or `/` inside; a value is at most 256 characters. The convention key `kindgi.com/managed-by` names the manager (`kindgi-dev`, `kindgi-deploy:<environment>`). Out of bounds: `400 invalid-provider`, reason `invalid-labels`.
+		 */
+		labels?: Record<string, string>;
 	};
 	export type ProviderCollectionPage = {
 		data: Array<ProviderMetadata>;
@@ -5719,7 +6709,13 @@ declare namespace Schemas {
 	export type GetMCPPromptResult = {
 		messages: Array<MCPPromptMessage>;
 	};
-	export type CostGroupDimension = "agentId" | "runId" | "category" | "providerId" | "day" | "month" | "tenant" | "conversationId";
+	export type CostGroupDimension = "agentId" | "runId" | "category" | "providerId" | "day" | "month" | "tenant" | "conversationId" | "model" | "servedModel" | "projectId" | "orgId" | "rootRunId" | "flowId";
+	/**
+	 * Why a model call failed (`status: failed`).
+	 */
+	export type ModelCallError = {
+		message: string;
+	};
 	export type CostRecord = {
 		id: string;
 		tenantId: string;
@@ -5746,6 +6742,76 @@ declare namespace Schemas {
 		 * Free-form filter/display tags — never counters.
 		 */
 		attributes?: Record<string, unknown>;
+		/**
+		 * A model call's id (`category` `llm.inference`); its provenance `model-call` node carries it too.
+		 */
+		callId?: string;
+		projectId?: string;
+		/**
+		 * The root of the record's run tree (a flow run, for its agent turns).
+		 */
+		rootRunId?: string;
+		parentRunId?: string;
+		agentVersion?: string;
+		/**
+		 * The flow of the run tree's root.
+		 */
+		flowId?: string;
+		/**
+		 * The step that made the call.
+		 */
+		nodeId?: string;
+		/**
+		 * The turn's step number.
+		 */
+		step?: number;
+		/**
+		 * What the call was for, beyond the turn's own model step: `guardrail-judge:<guardrail id>`.
+		 */
+		purpose?: string;
+		/**
+		 * The model actually called.
+		 */
+		model?: string;
+		/**
+		 * The exact model version the vendor reported (vendors alias).
+		 */
+		servedModel?: string;
+		/**
+		 * The router picked a fallback provider for the turn.
+		 */
+		fallback?: boolean;
+		/**
+		 * `ok`: the provider answered. `failed`: the call threw.
+		 */
+		status?: "ok" | "failed";
+		usage?: ModelCallTokens;
+		durationMs?: number;
+		finishReason?: string;
+		/**
+		 * The vendor's id for the request.
+		 */
+		providerRequestId?: string;
+		/**
+		 * HTTP attempts the call took, the client's retries included.
+		 */
+		attempts?: number;
+		error?: ModelCallError;
+		/**
+		 * The vendor's own usage object, exactly as it reported it. Only with `include=rawUsage`.
+		 */
+		rawUsage?: {
+			provider: string;
+			model: string;
+			usage: Record<string, unknown>;
+		};
+	};
+	export type CostTokenTotals = {
+		prompt: number;
+		completion: number;
+		cacheRead: number;
+		cacheWrite: number;
+		reasoning: number;
 	};
 	export type CostRecordCollectionPage = {
 		data: Array<CostRecord>;
@@ -5759,11 +6825,24 @@ declare namespace Schemas {
 		key: Record<string, string | null>;
 		count: number;
 		totalUsd: number;
+		tokens: CostTokenTotals;
 	};
 	export type CostAggregateResult = {
+		/**
+		 * The most expensive groups first (`totalUsd` descending, ties by key), at most `limit`.
+		 */
 		groups: Array<CostAggregateGroup>;
+		/**
+		 * How many groups there were before the `limit` cap. Absent from a runtime before 0.1.5.
+		 */
+		totalGroups?: number;
+		/**
+		 * `true` when there were more groups than `limit`: `groups` holds the most expensive ones, and `totalUsd` / `totalRecords` / `tokens` still cover every record. Absent from a runtime before 0.1.5.
+		 */
+		truncated?: boolean;
 		totalUsd: number;
 		totalRecords: number;
+		tokens: CostTokenTotals;
 		timeRange: {
 			from: string;
 			to: string;
@@ -5882,7 +6961,7 @@ declare namespace Schemas {
 		version: string;
 		wasTombstoned: boolean;
 	};
-	export type EvalKind = "accuracy" | "pairwise" | "regression" | "human-review" | "benchmark" | "custom";
+	export type EvalKind = "accuracy" | "pairwise" | "regression" | "human-review" | "benchmark" | "custom" | "judged";
 	export type EvalSuite = {
 		id: string;
 		tenantId: string;
@@ -5931,6 +7010,79 @@ declare namespace Schemas {
 		version: string;
 		wasTombstoned: boolean;
 	};
+	/**
+	 * `prompt`: a Liquid template an agent renders as its instructions. `settings`: a JSON object tools and templates read.
+	 */
+	export type BlockKind = "prompt" | "settings";
+	export type PromptBlockContent = {
+		/**
+		 * Liquid, rendered as an agent's instructions are (same parameters and auto-injected variables).
+		 */
+		template: string;
+		parameters?: Array<PromptParameter>;
+	};
+	export type SettingsBlockContent = {
+		/**
+		 * What tools read (`ToolContext.settings[<block id>]`) and templates read (`settings.<block id>.<key>`).
+		 */
+		values: Record<string, unknown>;
+		/**
+		 * JSON Schema (draft 2020-12) the values must satisfy. A later version's values must satisfy the latest version's schema too.
+		 */
+		schema?: Record<string, unknown>;
+	};
+	/**
+	 * A data block version: a prompt or settings, versioned like a tool (immutable versions, soft unregister). An agent version pins the block versions it uses when it is published. Belongs to one project and is authorized through it.
+	 */
+	export type Block = {
+		/**
+		 * Dotted lowercase id (e.g. `acme.intake-prompt`).
+		 */
+		id: string;
+		version: string;
+		kind: BlockKind;
+		description?: string;
+		/**
+		 * `PromptBlockContent` for a prompt, `SettingsBlockContent` for settings.
+		 */
+		content: PromptBlockContent | SettingsBlockContent;
+		projectId: string;
+		publishedAt: string;
+		/**
+		 * Present only on an unregistered version; agent versions that pin it still read it.
+		 */
+		unregisteredAt?: string;
+	};
+	export type BlockCollectionPage = {
+		data: Array<Block>;
+		nextCursor?: string;
+		hasMore: boolean;
+	};
+	export type PublishBlockBody = {
+		/**
+		 * Project this belongs to (its content scope). Required: missing, or not a project in the caller's tenant → `400 bad-input`.
+		 */
+		projectId: string;
+		id: string;
+		version: string;
+		kind: BlockKind;
+		description?: string;
+		content: PromptBlockContent | SettingsBlockContent;
+	};
+	export type PublishBlockResult = {
+		blockId: string;
+		version: string;
+	};
+	export type UnregisterBlockResult = {
+		blockId: string;
+		version: string;
+		unregistered: true;
+	};
+	export type ReinstateBlockResult = {
+		blockId: string;
+		version: string;
+		wasTombstoned: boolean;
+	};
 	export type EvalRunStatus = "pending" | "running" | "completed" | "failed" | "cancelled";
 	export type EvalRunAgentRef = {
 		agentId: string;
@@ -5940,6 +7092,30 @@ declare namespace Schemas {
 		flowId: string;
 		version?: string;
 	};
+	/**
+	 * What a comparison compares the candidate against: `'recorded'` (each case's recorded output, what was judged), a version (`{ agentId, version }`, replayed under the same rules), or the version live in a scope (`{ live: { projectId?, segments? } }`). Only `'recorded'` runs today; the others are refused when the run starts.
+	 */
+	export type EvalBaseline = "recorded" | {
+		agentId: string;
+		version: string;
+	} | {
+		live: Partial<{
+			projectId: string;
+			segments: Record<string, string>;
+		}>;
+	};
+	/**
+	 * A comparison eval run's settings (a `judged` suite).
+	 */
+	export type EvalComparison = {
+		baseline: EvalBaseline;
+		/**
+		 * Whether replayed reads use the past run's results when it has them (`recorded`), or run live.
+		 */
+		reads: "recorded" | "live";
+		repetitions: number;
+		k: number;
+	};
 	export type EvalRun = {
 		runId: string;
 		tenantId: string;
@@ -5953,11 +7129,12 @@ declare namespace Schemas {
 		startedAt: string;
 		completedAt?: string;
 		/**
-		 * Kind-specific opaque JSON. For `accuracy`, contains `{ passCount, totalCount, meanScore, perCase[] }`. Other kinds define their own shapes as their dispatchers ship.
+		 * Kind-specific opaque JSON. For `accuracy`, contains `{ passCount, totalCount, meanScore, perCase[] }`. For `judged` (a comparison), `{ summary, perCase[] }`: the summary has the baseline (the versions behind the recorded runs) and the candidate (`{ kind: "agent", agentId, version }` or `{ kind: "flow", flowId, version }`), the case counts (`cases`, `diverged`, `refusedWrites`, `errors`, and `stopped`: flow cases that stopped at a write the replay refused, left out of the metrics), the models that answered, and `metrics` (`weightedYesShare`, `judgedCoverage`, `weightedPrecisionAtK`, each `{ baseline, candidate, delta, n, weight, baselineN, baselineWeight, direction, k?, spread? }`); each case has its replay runs, the scores, the items kept, dropped and new, the tool calls with what happened to each, and `stopped` (what it would have done) when it stopped. Other kinds define their own shapes as their dispatchers ship.
 		 */
 		result?: Record<string, unknown>;
 		error?: string;
 		correlationId?: string;
+		comparison?: EvalComparison;
 	};
 	export type EvalRunCollectionPage = {
 		data: Array<EvalRun>;
@@ -5965,7 +7142,7 @@ declare namespace Schemas {
 		hasMore: boolean;
 	};
 	/**
-	 * Exactly one of `agentRef` or `flowRef` MUST be supplied. `dryRun: true` returns a plan preview without invoking the subject.
+	 * Exactly one of `agentRef` or `flowRef` MUST be supplied. `dryRun: true` returns a plan preview without invoking the subject. For a `judged` suite (a test set), the run is a comparison: `agentRef` or `flowRef` with its `version` is the candidate, replayed on each case without doing anything the past run didn't (a flow stops at a write the replay refuses); `baseline` (default `'recorded'`), `reads` (default `recorded`), `repetitions` (default 1) and `k` (default 10) set how.
 	 */
 	export type StartEvalRunBody = {
 		/**
@@ -5976,6 +7153,10 @@ declare namespace Schemas {
 		flowRef?: EvalRunFlowRef;
 		dryRun?: boolean;
 		correlationId?: string;
+		baseline?: EvalBaseline;
+		reads?: "recorded" | "live";
+		repetitions?: number;
+		k?: number;
 	};
 	export type StartEvalRunResult = {
 		runId: string;
@@ -6082,7 +7263,7 @@ declare namespace Schemas {
 		metadata?: Record<string, unknown>;
 	};
 	/**
-	 * Introspection of the caller's current authentication context. Always carries `tenantId` and `scopes` (empty for static bearer tokens), plus `userId` when the token carries one; session-token callers additionally see `sessionId`, `providerId`, and `expiresAt`. `user` is the caller's directory record, present when the deployment wires an identity directory and it knows the `userId`. `reviewerRole` is set when the token carries a reviewer role — clients can use it to gate reviewer-only UI (the approvals surface) without a second round trip.
+	 * Introspection of the caller's current authentication context. Always carries `tenantId` and `scopes` (empty for static bearer tokens), plus `userId` when the token carries one; session-token callers additionally see `sessionId`, `providerId`, and `expiresAt`. `user` is the caller's directory record, present when the deployment wires an identity directory and it knows the `userId`. `reviewerRole` is set when the caller is a reviewer — its token carries a reviewer role, or its user is a registered reviewer — so clients can gate reviewer-only UI (the approvals surface) without a second round trip.
 	 */
 	export type WhoamiResult = {
 		tenantId: string;
@@ -6147,16 +7328,48 @@ declare namespace Schemas {
 		agents: Array<{
 			id: string;
 			/**
-			 * Absent for guardrails, which have no version.
+			 * The version the agent is registered as.
 			 */
-			version?: string;
+			version: string;
+			/**
+			 * The version the agent's or flow's definition names, present when it differs from `version`: that version was registered already with other pins or content, and versions never change, so the deploy registered the next free version in its line (or an earlier deploy did).
+			 */
+			authoredVersion?: string;
+			/**
+			 * Why `version` differs from `authoredVersion`: `pins-changed` (a tool or agent it uses has a new version), `unpinned` (`authoredVersion` was published before pins existed), `version-taken` (`authoredVersion` is registered with other content).
+			 */
+			reason?: "pins-changed" | "unpinned" | "version-taken";
+			/**
+			 * `true`: this deploy registered `version`; `false`: an earlier deploy did.
+			 */
+			newVersion?: boolean;
+			/**
+			 * For `pins-changed`: the pins that differ from `authoredVersion`'s.
+			 */
+			pinChanges?: Array<PinChange>;
 		}>;
 		flows: Array<{
 			id: string;
 			/**
-			 * Absent for guardrails, which have no version.
+			 * The version the agent is registered as.
 			 */
-			version?: string;
+			version: string;
+			/**
+			 * The version the agent's or flow's definition names, present when it differs from `version`: that version was registered already with other pins or content, and versions never change, so the deploy registered the next free version in its line (or an earlier deploy did).
+			 */
+			authoredVersion?: string;
+			/**
+			 * Why `version` differs from `authoredVersion`: `pins-changed` (a tool or agent it uses has a new version), `unpinned` (`authoredVersion` was published before pins existed), `version-taken` (`authoredVersion` is registered with other content).
+			 */
+			reason?: "pins-changed" | "unpinned" | "version-taken";
+			/**
+			 * `true`: this deploy registered `version`; `false`: an earlier deploy did.
+			 */
+			newVersion?: boolean;
+			/**
+			 * For `pins-changed`: the pins that differ from `authoredVersion`'s.
+			 */
+			pinChanges?: Array<PinChange>;
 		}>;
 	};
 	export type DeploymentRecord = {
@@ -6917,6 +8130,14 @@ declare namespace Schemas {
 		 */
 		unregistered: boolean;
 	};
+	/**
+	 * The model calls of the run tree (this run and every run it started) that the cost ledger had recorded when this run finished: a child run still running then isn't in it. `calls` counts failed calls too. Absent when the runtime records no usage.
+	 */
+	export type RunTreeUsage = {
+		calls: number;
+		costUsd: number;
+		tokens: CostTokenTotals;
+	};
 	/**
 	 * A finished top-level run: its identity and outcome, never its input or output. Field names match `GET /v1/runs/{runId}`.
 	 */
@@ -6936,6 +8157,7 @@ declare namespace Schemas {
 		failureMessage: string | null;
 		createdAt: string;
 		completedAt: string;
+		usage?: RunTreeUsage;
 	};
 	export type RunFinishedEvent = {
 		/**
@@ -6997,9 +8219,9 @@ export declare const RunProgress: z.ZodObject<{
 	flowVersion: z.ZodString;
 	status: z.ZodEnum<{
 		pending: "pending";
+		failed: "failed";
 		running: "running";
 		completed: "completed";
-		failed: "failed";
 		cancelled: "cancelled";
 		suspended: "suspended";
 	}>;
@@ -7041,21 +8263,162 @@ declare const TrustedSigningKeyPage: z.ZodObject<{
 	nextCursor: z.ZodOptional<z.ZodString>;
 	hasMore: z.ZodBoolean;
 }, z.core.$strict>;
-export type RevokeSigningKeyResult = Schemas.RevokeSigningKeyResult;
-declare const RevokeSigningKeyResult: z.ZodObject<{
-	keyId: z.ZodString;
-	revoked: z.ZodBoolean;
-}, z.core.$strict>;
-export type MintPublicRunTokenBody = Schemas.MintPublicRunTokenBody;
-declare const MintPublicRunTokenBody: z.ZodObject<{
-	runIds: z.ZodArray<z.ZodString>;
-	expiresInSeconds: z.ZodOptional<z.ZodNumber>;
+export type RevokeSigningKeyResult = Schemas.RevokeSigningKeyResult;
+declare const RevokeSigningKeyResult: z.ZodObject<{
+	keyId: z.ZodString;
+	revoked: z.ZodBoolean;
+}, z.core.$strict>;
+export type MintPublicRunTokenBody = Schemas.MintPublicRunTokenBody;
+declare const MintPublicRunTokenBody: z.ZodObject<{
+	runIds: z.ZodArray<z.ZodString>;
+	expiresInSeconds: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type MintPublicRunTokenResult = Schemas.MintPublicRunTokenResult;
+declare const MintPublicRunTokenResult: z.ZodObject<{
+	token: z.ZodString;
+	expiresAt: z.ZodISODateTime;
+	runIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type JudgedEvalCase = Schemas.JudgedEvalCase;
+declare const JudgedEvalCase: z.ZodObject<{
+	caseId: z.ZodString;
+	subject: z.ZodObject<{
+		kind: z.ZodEnum<{
+			agent: "agent";
+			flow: "flow";
+		}>;
+		id: z.ZodString;
+		version: z.ZodString;
+	}, z.core.$strict>;
+	input: z.ZodUnknown;
+	context: z.ZodOptional<z.ZodObject<{
+		history: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+		historyTruncated: z.ZodOptional<z.ZodBoolean>;
+		retrieved: z.ZodOptional<z.ZodUnknown>;
+		sessionApproval: z.ZodOptional<z.ZodObject<{
+			approved: z.ZodBoolean;
+			rationale: z.ZodOptional<z.ZodString>;
+		}, z.core.$strict>>;
+		flow: z.ZodOptional<z.ZodObject<{
+			calls: z.ZodArray<z.ZodObject<{
+				runId: z.ZodString;
+				nodeId: z.ZodOptional<z.ZodString>;
+				scope: z.ZodOptional<z.ZodString>;
+				toolId: z.ZodString;
+				arguments: z.ZodOptional<z.ZodUnknown>;
+				result: z.ZodOptional<z.ZodUnknown>;
+			}, z.core.$strict>>;
+			steps: z.ZodArray<z.ZodObject<{
+				runId: z.ZodString;
+				nodeId: z.ZodOptional<z.ZodString>;
+				scope: z.ZodOptional<z.ZodString>;
+				agentId: z.ZodString;
+				agentVersion: z.ZodString;
+				retrieved: z.ZodOptional<z.ZodUnknown>;
+			}, z.core.$strict>>;
+			truncated: z.ZodOptional<z.ZodBoolean>;
+		}, z.core.$strict>>;
+	}, z.core.$strict>>;
+	output: z.ZodUnknown;
+	items: z.ZodArray<z.ZodObject<{
+		key: z.ZodString;
+		pointer: z.ZodOptional<z.ZodString>;
+		rank: z.ZodOptional<z.ZodNumber>;
+		yes: z.ZodNumber;
+		no: z.ZodNumber;
+		yesWeight: z.ZodNumber;
+		totalWeight: z.ZodNumber;
+		reasons: z.ZodArray<z.ZodObject<{
+			verdict: z.ZodEnum<{
+				yes: "yes";
+				no: "no";
+			}>;
+			reason: z.ZodString;
+		}, z.core.$strict>>;
+	}, z.core.$strict>>;
+}, z.core.$strict>;
+export type JudgedEvalCaseCollectionPage = Schemas.JudgedEvalCaseCollectionPage;
+declare const JudgedEvalCaseCollectionPage: z.ZodObject<{
+	data: z.ZodArray<z.ZodObject<{
+		caseId: z.ZodString;
+		subject: z.ZodObject<{
+			kind: z.ZodEnum<{
+				agent: "agent";
+				flow: "flow";
+			}>;
+			id: z.ZodString;
+			version: z.ZodString;
+		}, z.core.$strict>;
+		input: z.ZodUnknown;
+		context: z.ZodOptional<z.ZodObject<{
+			history: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+			historyTruncated: z.ZodOptional<z.ZodBoolean>;
+			retrieved: z.ZodOptional<z.ZodUnknown>;
+			sessionApproval: z.ZodOptional<z.ZodObject<{
+				approved: z.ZodBoolean;
+				rationale: z.ZodOptional<z.ZodString>;
+			}, z.core.$strict>>;
+			flow: z.ZodOptional<z.ZodObject<{
+				calls: z.ZodArray<z.ZodObject<{
+					runId: z.ZodString;
+					nodeId: z.ZodOptional<z.ZodString>;
+					scope: z.ZodOptional<z.ZodString>;
+					toolId: z.ZodString;
+					arguments: z.ZodOptional<z.ZodUnknown>;
+					result: z.ZodOptional<z.ZodUnknown>;
+				}, z.core.$strict>>;
+				steps: z.ZodArray<z.ZodObject<{
+					runId: z.ZodString;
+					nodeId: z.ZodOptional<z.ZodString>;
+					scope: z.ZodOptional<z.ZodString>;
+					agentId: z.ZodString;
+					agentVersion: z.ZodString;
+					retrieved: z.ZodOptional<z.ZodUnknown>;
+				}, z.core.$strict>>;
+				truncated: z.ZodOptional<z.ZodBoolean>;
+			}, z.core.$strict>>;
+		}, z.core.$strict>>;
+		output: z.ZodUnknown;
+		items: z.ZodArray<z.ZodObject<{
+			key: z.ZodString;
+			pointer: z.ZodOptional<z.ZodString>;
+			rank: z.ZodOptional<z.ZodNumber>;
+			yes: z.ZodNumber;
+			no: z.ZodNumber;
+			yesWeight: z.ZodNumber;
+			totalWeight: z.ZodNumber;
+			reasons: z.ZodArray<z.ZodObject<{
+				verdict: z.ZodEnum<{
+					yes: "yes";
+					no: "no";
+				}>;
+				reason: z.ZodString;
+			}, z.core.$strict>>;
+		}, z.core.$strict>>;
+	}, z.core.$strict>>;
+	nextCursor: z.ZodOptional<z.ZodString>;
+	hasMore: z.ZodBoolean;
+}, z.core.$strict>;
+export type BuildJudgedSuiteBody = Schemas.BuildJudgedSuiteBody;
+declare const BuildJudgedSuiteBody: z.ZodObject<{
+	version: z.ZodString;
+	projectId: z.ZodString;
+	agentId: z.ZodOptional<z.ZodString>;
+	agentVersion: z.ZodOptional<z.ZodString>;
+	flowId: z.ZodOptional<z.ZodString>;
+	since: z.ZodOptional<z.ZodISODateTime>;
+	until: z.ZodOptional<z.ZodISODateTime>;
+	judgeClassIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+	minJudgments: z.ZodOptional<z.ZodNumber>;
+	description: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
-export type MintPublicRunTokenResult = Schemas.MintPublicRunTokenResult;
-declare const MintPublicRunTokenResult: z.ZodObject<{
-	token: z.ZodString;
-	expiresAt: z.ZodISODateTime;
-	runIds: z.ZodArray<z.ZodString>;
+export type BuildJudgedSuiteResult = Schemas.BuildJudgedSuiteResult;
+declare const BuildJudgedSuiteResult: z.ZodObject<{
+	suiteId: z.ZodString;
+	version: z.ZodString;
+	kind: z.ZodLiteral<"judged">;
+	caseCount: z.ZodNumber;
+	truncated: z.ZodBoolean;
 }, z.core.$strict>;
 type Agent$1 = Schemas.Agent;
 declare const Agent$1: z.ZodObject<{
@@ -7063,7 +8426,13 @@ declare const Agent$1: z.ZodObject<{
 	version: z.ZodString;
 	name: z.ZodString;
 	description: z.ZodOptional<z.ZodString>;
-	instructions: z.ZodString;
+	instructions: z.ZodUnion<readonly [
+		z.ZodString,
+		z.ZodObject<{
+			prompt: z.ZodString;
+			version: z.ZodString;
+		}, z.core.$strict>
+	]>;
 	parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
 		name: z.ZodString;
 		description: z.ZodOptional<z.ZodString>;
@@ -7076,6 +8445,14 @@ declare const Agent$1: z.ZodObject<{
 		required: z.ZodOptional<z.ZodBoolean>;
 		default: z.ZodOptional<z.ZodUnknown>;
 	}, z.core.$strict>>>;
+	settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+		id: z.ZodString;
+		version: z.ZodString;
+	}, z.core.$strict>>>;
+	modelSettings: z.ZodOptional<z.ZodObject<{
+		id: z.ZodString;
+		version: z.ZodString;
+	}, z.core.$strict>>;
 	capabilities: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 	tools: z.ZodArray<z.ZodObject<{
 		id: z.ZodString;
@@ -7122,6 +8499,34 @@ declare const Agent$1: z.ZodObject<{
 			"unknown-tool": "unknown-tool";
 		}>>>;
 	}, z.core.$strict>>;
+	pins: z.ZodOptional<z.ZodObject<{
+		tools: z.ZodRecord<z.ZodString, z.ZodString>;
+		prompts: z.ZodRecord<z.ZodString, z.ZodString>;
+		settings: z.ZodRecord<z.ZodString, z.ZodString>;
+	}, z.core.$strict>>;
+	derivedFrom: z.ZodOptional<z.ZodObject<{
+		version: z.ZodString;
+		reason: z.ZodEnum<{
+			"pins-changed": "pins-changed";
+			unpinned: "unpinned";
+			"version-taken": "version-taken";
+			edited: "edited";
+		}>;
+		label: z.ZodOptional<z.ZodString>;
+		by: z.ZodOptional<z.ZodString>;
+	}, z.core.$strict>>;
+	unregisteredAt: z.ZodOptional<z.ZodISODateTime>;
+	pinsDigest: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type DeriveAgentVersionBody = Schemas.DeriveAgentVersionBody;
+declare const DeriveAgentVersionBody: z.ZodObject<{
+	from: z.ZodString;
+	pins: z.ZodObject<{
+		prompts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+		settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+	}, z.core.$strict>;
+	label: z.ZodOptional<z.ZodString>;
+	projectId: z.ZodOptional<z.ZodUUID>;
 }, z.core.$strict>;
 export type UnregisterAgentResult = Schemas.UnregisterAgentResult;
 declare const UnregisterAgentResult: z.ZodObject<{
@@ -7136,7 +8541,13 @@ declare const AgentCollectionPage: z.ZodObject<{
 		version: z.ZodString;
 		name: z.ZodString;
 		description: z.ZodOptional<z.ZodString>;
-		instructions: z.ZodString;
+		instructions: z.ZodUnion<readonly [
+			z.ZodString,
+			z.ZodObject<{
+				prompt: z.ZodString;
+				version: z.ZodString;
+			}, z.core.$strict>
+		]>;
 		parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
 			name: z.ZodString;
 			description: z.ZodOptional<z.ZodString>;
@@ -7149,6 +8560,14 @@ declare const AgentCollectionPage: z.ZodObject<{
 			required: z.ZodOptional<z.ZodBoolean>;
 			default: z.ZodOptional<z.ZodUnknown>;
 		}, z.core.$strict>>>;
+		settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+			id: z.ZodString;
+			version: z.ZodString;
+		}, z.core.$strict>>>;
+		modelSettings: z.ZodOptional<z.ZodObject<{
+			id: z.ZodString;
+			version: z.ZodString;
+		}, z.core.$strict>>;
 		capabilities: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 		tools: z.ZodArray<z.ZodObject<{
 			id: z.ZodString;
@@ -7195,6 +8614,24 @@ declare const AgentCollectionPage: z.ZodObject<{
 				"unknown-tool": "unknown-tool";
 			}>>>;
 		}, z.core.$strict>>;
+		pins: z.ZodOptional<z.ZodObject<{
+			tools: z.ZodRecord<z.ZodString, z.ZodString>;
+			prompts: z.ZodRecord<z.ZodString, z.ZodString>;
+			settings: z.ZodRecord<z.ZodString, z.ZodString>;
+		}, z.core.$strict>>;
+		derivedFrom: z.ZodOptional<z.ZodObject<{
+			version: z.ZodString;
+			reason: z.ZodEnum<{
+				"pins-changed": "pins-changed";
+				unpinned: "unpinned";
+				"version-taken": "version-taken";
+				edited: "edited";
+			}>;
+			label: z.ZodOptional<z.ZodString>;
+			by: z.ZodOptional<z.ZodString>;
+		}, z.core.$strict>>;
+		unregisteredAt: z.ZodOptional<z.ZodISODateTime>;
+		pinsDigest: z.ZodOptional<z.ZodString>;
 	}, z.core.$strict>>;
 	nextCursor: z.ZodOptional<z.ZodString>;
 	hasMore: z.ZodBoolean;
@@ -7233,6 +8670,7 @@ declare const ProviderMetadata: z.ZodObject<{
 	description: z.ZodOptional<z.ZodString>;
 	capabilityKind: z.ZodOptional<z.ZodString>;
 	fallback: z.ZodOptional<z.ZodBoolean>;
+	labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strict>;
 export type ProviderCollectionPage = Schemas.ProviderCollectionPage;
 declare const ProviderCollectionPage: z.ZodObject<{
@@ -7269,6 +8707,7 @@ declare const ProviderCollectionPage: z.ZodObject<{
 		description: z.ZodOptional<z.ZodString>;
 		capabilityKind: z.ZodOptional<z.ZodString>;
 		fallback: z.ZodOptional<z.ZodBoolean>;
+		labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 	}, z.core.$strict>>;
 	nextCursor: z.ZodOptional<z.ZodString>;
 	hasMore: z.ZodBoolean;
@@ -7308,6 +8747,7 @@ declare const RegisterProviderBody: z.ZodObject<{
 		description: z.ZodOptional<z.ZodString>;
 		capabilityKind: z.ZodOptional<z.ZodString>;
 		fallback: z.ZodOptional<z.ZodBoolean>;
+		labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 	}, z.core.$strict>;
 	adapter_id: z.ZodString;
 	secret_ref: z.ZodOptional<z.ZodObject<{
@@ -7370,6 +8810,7 @@ declare const EvalKind: z.ZodEnum<{
 	"human-review": "human-review";
 	benchmark: "benchmark";
 	custom: "custom";
+	judged: "judged";
 }>;
 export type EvalSuite = Schemas.EvalSuite;
 declare const EvalSuite: z.ZodObject<{
@@ -7383,6 +8824,7 @@ declare const EvalSuite: z.ZodObject<{
 		"human-review": "human-review";
 		benchmark: "benchmark";
 		custom: "custom";
+		judged: "judged";
 	}>;
 	description: z.ZodOptional<z.ZodString>;
 	spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -7400,6 +8842,7 @@ declare const EvalSuiteCollectionPage: z.ZodObject<{
 			"human-review": "human-review";
 			benchmark: "benchmark";
 			custom: "custom";
+			judged: "judged";
 		}>;
 		description: z.ZodOptional<z.ZodString>;
 		spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -7420,6 +8863,7 @@ declare const PublishEvalSuiteBody: z.ZodObject<{
 		"human-review": "human-review";
 		benchmark: "benchmark";
 		custom: "custom";
+		judged: "judged";
 	}>;
 	description: z.ZodOptional<z.ZodString>;
 	spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -7441,12 +8885,138 @@ declare const ReinstateEvalSuiteVersionResult: z.ZodObject<{
 	version: z.ZodString;
 	wasTombstoned: z.ZodBoolean;
 }, z.core.$strict>;
+export type BlockKind = Schemas.BlockKind;
+export declare const BlockKind: z.ZodEnum<{
+	prompt: "prompt";
+	settings: "settings";
+}>;
+export type Block = Schemas.Block;
+export declare const Block: z.ZodObject<{
+	id: z.ZodString;
+	version: z.ZodString;
+	kind: z.ZodEnum<{
+		prompt: "prompt";
+		settings: "settings";
+	}>;
+	description: z.ZodOptional<z.ZodString>;
+	content: z.ZodUnion<readonly [
+		z.ZodObject<{
+			template: z.ZodString;
+			parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+				name: z.ZodString;
+				description: z.ZodOptional<z.ZodString>;
+				type: z.ZodEnum<{
+					string: "string";
+					number: "number";
+					boolean: "boolean";
+					date: "date";
+				}>;
+				required: z.ZodOptional<z.ZodBoolean>;
+				default: z.ZodOptional<z.ZodUnknown>;
+			}, z.core.$strict>>>;
+		}, z.core.$strict>,
+		z.ZodObject<{
+			values: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+			schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+		}, z.core.$strict>
+	]>;
+	projectId: z.ZodUUID;
+	publishedAt: z.ZodISODateTime;
+	unregisteredAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type BlockCollectionPage = Schemas.BlockCollectionPage;
+declare const BlockCollectionPage: z.ZodObject<{
+	data: z.ZodArray<z.ZodObject<{
+		id: z.ZodString;
+		version: z.ZodString;
+		kind: z.ZodEnum<{
+			prompt: "prompt";
+			settings: "settings";
+		}>;
+		description: z.ZodOptional<z.ZodString>;
+		content: z.ZodUnion<readonly [
+			z.ZodObject<{
+				template: z.ZodString;
+				parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+					name: z.ZodString;
+					description: z.ZodOptional<z.ZodString>;
+					type: z.ZodEnum<{
+						string: "string";
+						number: "number";
+						boolean: "boolean";
+						date: "date";
+					}>;
+					required: z.ZodOptional<z.ZodBoolean>;
+					default: z.ZodOptional<z.ZodUnknown>;
+				}, z.core.$strict>>>;
+			}, z.core.$strict>,
+			z.ZodObject<{
+				values: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+				schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+			}, z.core.$strict>
+		]>;
+		projectId: z.ZodUUID;
+		publishedAt: z.ZodISODateTime;
+		unregisteredAt: z.ZodOptional<z.ZodISODateTime>;
+	}, z.core.$strict>>;
+	nextCursor: z.ZodOptional<z.ZodString>;
+	hasMore: z.ZodBoolean;
+}, z.core.$strict>;
+export type PublishBlockBody = Schemas.PublishBlockBody;
+declare const PublishBlockBody: z.ZodObject<{
+	projectId: z.ZodUUID;
+	id: z.ZodString;
+	version: z.ZodString;
+	kind: z.ZodEnum<{
+		prompt: "prompt";
+		settings: "settings";
+	}>;
+	description: z.ZodOptional<z.ZodString>;
+	content: z.ZodUnion<readonly [
+		z.ZodObject<{
+			template: z.ZodString;
+			parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+				name: z.ZodString;
+				description: z.ZodOptional<z.ZodString>;
+				type: z.ZodEnum<{
+					string: "string";
+					number: "number";
+					boolean: "boolean";
+					date: "date";
+				}>;
+				required: z.ZodOptional<z.ZodBoolean>;
+				default: z.ZodOptional<z.ZodUnknown>;
+			}, z.core.$strict>>>;
+		}, z.core.$strict>,
+		z.ZodObject<{
+			values: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+			schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+		}, z.core.$strict>
+	]>;
+}, z.core.$strict>;
+export type PublishBlockResult = Schemas.PublishBlockResult;
+export declare const PublishBlockResult: z.ZodObject<{
+	blockId: z.ZodString;
+	version: z.ZodString;
+}, z.core.$strict>;
+export type UnregisterBlockResult = Schemas.UnregisterBlockResult;
+export declare const UnregisterBlockResult: z.ZodObject<{
+	blockId: z.ZodString;
+	version: z.ZodString;
+	unregistered: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export type ReinstateBlockResult = Schemas.ReinstateBlockResult;
+export declare const ReinstateBlockResult: z.ZodObject<{
+	blockId: z.ZodString;
+	version: z.ZodString;
+	wasTombstoned: z.ZodBoolean;
+}, z.core.$strict>;
 export type EvalRunStatus = Schemas.EvalRunStatus;
 declare const EvalRunStatus: z.ZodEnum<{
 	pending: "pending";
+	failed: "failed";
 	running: "running";
 	completed: "completed";
-	failed: "failed";
 	cancelled: "cancelled";
 }>;
 export type EvalRun = Schemas.EvalRun;
@@ -7462,6 +9032,7 @@ declare const EvalRun: z.ZodObject<{
 		"human-review": "human-review";
 		benchmark: "benchmark";
 		custom: "custom";
+		judged: "judged";
 	}>;
 	agentRef: z.ZodOptional<z.ZodObject<{
 		agentId: z.ZodString;
@@ -7473,9 +9044,9 @@ declare const EvalRun: z.ZodObject<{
 	}, z.core.$strict>>;
 	status: z.ZodEnum<{
 		pending: "pending";
+		failed: "failed";
 		running: "running";
 		completed: "completed";
-		failed: "failed";
 		cancelled: "cancelled";
 	}>;
 	dryRun: z.ZodBoolean;
@@ -7484,6 +9055,27 @@ declare const EvalRun: z.ZodObject<{
 	result: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 	error: z.ZodOptional<z.ZodString>;
 	correlationId: z.ZodOptional<z.ZodString>;
+	comparison: z.ZodOptional<z.ZodObject<{
+		baseline: z.ZodUnion<readonly [
+			z.ZodLiteral<"recorded">,
+			z.ZodObject<{
+				agentId: z.ZodString;
+				version: z.ZodString;
+			}, z.core.$strict>,
+			z.ZodObject<{
+				live: z.ZodObject<{
+					projectId: z.ZodOptional<z.ZodString>;
+					segments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+				}, z.core.$strict>;
+			}, z.core.$strict>
+		]>;
+		reads: z.ZodEnum<{
+			recorded: "recorded";
+			live: "live";
+		}>;
+		repetitions: z.ZodNumber;
+		k: z.ZodNumber;
+	}, z.core.$strict>>;
 }, z.core.$strict>;
 export type EvalRunCollectionPage = Schemas.EvalRunCollectionPage;
 declare const EvalRunCollectionPage: z.ZodObject<{
@@ -7499,6 +9091,7 @@ declare const EvalRunCollectionPage: z.ZodObject<{
 			"human-review": "human-review";
 			benchmark: "benchmark";
 			custom: "custom";
+			judged: "judged";
 		}>;
 		agentRef: z.ZodOptional<z.ZodObject<{
 			agentId: z.ZodString;
@@ -7510,9 +9103,9 @@ declare const EvalRunCollectionPage: z.ZodObject<{
 		}, z.core.$strict>>;
 		status: z.ZodEnum<{
 			pending: "pending";
+			failed: "failed";
 			running: "running";
 			completed: "completed";
-			failed: "failed";
 			cancelled: "cancelled";
 		}>;
 		dryRun: z.ZodBoolean;
@@ -7521,6 +9114,27 @@ declare const EvalRunCollectionPage: z.ZodObject<{
 		result: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 		error: z.ZodOptional<z.ZodString>;
 		correlationId: z.ZodOptional<z.ZodString>;
+		comparison: z.ZodOptional<z.ZodObject<{
+			baseline: z.ZodUnion<readonly [
+				z.ZodLiteral<"recorded">,
+				z.ZodObject<{
+					agentId: z.ZodString;
+					version: z.ZodString;
+				}, z.core.$strict>,
+				z.ZodObject<{
+					live: z.ZodObject<{
+						projectId: z.ZodOptional<z.ZodString>;
+						segments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+					}, z.core.$strict>;
+				}, z.core.$strict>
+			]>;
+			reads: z.ZodEnum<{
+				recorded: "recorded";
+				live: "live";
+			}>;
+			repetitions: z.ZodNumber;
+			k: z.ZodNumber;
+		}, z.core.$strict>>;
 	}, z.core.$strict>>;
 	nextCursor: z.ZodOptional<z.ZodString>;
 	hasMore: z.ZodBoolean;
@@ -7538,6 +9152,25 @@ declare const StartEvalRunBody: z.ZodObject<{
 	}, z.core.$strict>>;
 	dryRun: z.ZodOptional<z.ZodBoolean>;
 	correlationId: z.ZodOptional<z.ZodString>;
+	baseline: z.ZodOptional<z.ZodUnion<readonly [
+		z.ZodLiteral<"recorded">,
+		z.ZodObject<{
+			agentId: z.ZodString;
+			version: z.ZodString;
+		}, z.core.$strict>,
+		z.ZodObject<{
+			live: z.ZodObject<{
+				projectId: z.ZodOptional<z.ZodString>;
+				segments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+			}, z.core.$strict>;
+		}, z.core.$strict>
+	]>>;
+	reads: z.ZodOptional<z.ZodEnum<{
+		recorded: "recorded";
+		live: "live";
+	}>>;
+	repetitions: z.ZodOptional<z.ZodNumber>;
+	k: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 export type StartEvalRunResult = Schemas.StartEvalRunResult;
 declare const StartEvalRunResult: z.ZodObject<{
@@ -7736,11 +9369,47 @@ declare const DeploymentRecord: z.ZodObject<{
 		}, z.core.$strict>>;
 		agents: z.ZodArray<z.ZodObject<{
 			id: z.ZodString;
-			version: z.ZodOptional<z.ZodString>;
+			version: z.ZodString;
+			authoredVersion: z.ZodOptional<z.ZodString>;
+			reason: z.ZodOptional<z.ZodEnum<{
+				"pins-changed": "pins-changed";
+				unpinned: "unpinned";
+				"version-taken": "version-taken";
+			}>>;
+			newVersion: z.ZodOptional<z.ZodBoolean>;
+			pinChanges: z.ZodOptional<z.ZodArray<z.ZodObject<{
+				kind: z.ZodEnum<{
+					tool: "tool";
+					prompt: "prompt";
+					agent: "agent";
+					setting: "setting";
+				}>;
+				id: z.ZodString;
+				from: z.ZodOptional<z.ZodString>;
+				to: z.ZodOptional<z.ZodString>;
+			}, z.core.$strict>>>;
 		}, z.core.$strict>>;
 		flows: z.ZodArray<z.ZodObject<{
 			id: z.ZodString;
-			version: z.ZodOptional<z.ZodString>;
+			version: z.ZodString;
+			authoredVersion: z.ZodOptional<z.ZodString>;
+			reason: z.ZodOptional<z.ZodEnum<{
+				"pins-changed": "pins-changed";
+				unpinned: "unpinned";
+				"version-taken": "version-taken";
+			}>>;
+			newVersion: z.ZodOptional<z.ZodBoolean>;
+			pinChanges: z.ZodOptional<z.ZodArray<z.ZodObject<{
+				kind: z.ZodEnum<{
+					tool: "tool";
+					prompt: "prompt";
+					agent: "agent";
+					setting: "setting";
+				}>;
+				id: z.ZodString;
+				from: z.ZodOptional<z.ZodString>;
+				to: z.ZodOptional<z.ZodString>;
+			}, z.core.$strict>>>;
 		}, z.core.$strict>>;
 	}, z.core.$strict>;
 }, z.core.$strict>;
@@ -7785,11 +9454,47 @@ declare const DeploymentCollectionPage: z.ZodObject<{
 			}, z.core.$strict>>;
 			agents: z.ZodArray<z.ZodObject<{
 				id: z.ZodString;
-				version: z.ZodOptional<z.ZodString>;
+				version: z.ZodString;
+				authoredVersion: z.ZodOptional<z.ZodString>;
+				reason: z.ZodOptional<z.ZodEnum<{
+					"pins-changed": "pins-changed";
+					unpinned: "unpinned";
+					"version-taken": "version-taken";
+				}>>;
+				newVersion: z.ZodOptional<z.ZodBoolean>;
+				pinChanges: z.ZodOptional<z.ZodArray<z.ZodObject<{
+					kind: z.ZodEnum<{
+						tool: "tool";
+						prompt: "prompt";
+						agent: "agent";
+						setting: "setting";
+					}>;
+					id: z.ZodString;
+					from: z.ZodOptional<z.ZodString>;
+					to: z.ZodOptional<z.ZodString>;
+				}, z.core.$strict>>>;
 			}, z.core.$strict>>;
 			flows: z.ZodArray<z.ZodObject<{
 				id: z.ZodString;
-				version: z.ZodOptional<z.ZodString>;
+				version: z.ZodString;
+				authoredVersion: z.ZodOptional<z.ZodString>;
+				reason: z.ZodOptional<z.ZodEnum<{
+					"pins-changed": "pins-changed";
+					unpinned: "unpinned";
+					"version-taken": "version-taken";
+				}>>;
+				newVersion: z.ZodOptional<z.ZodBoolean>;
+				pinChanges: z.ZodOptional<z.ZodArray<z.ZodObject<{
+					kind: z.ZodEnum<{
+						tool: "tool";
+						prompt: "prompt";
+						agent: "agent";
+						setting: "setting";
+					}>;
+					id: z.ZodString;
+					from: z.ZodOptional<z.ZodString>;
+					to: z.ZodOptional<z.ZodString>;
+				}, z.core.$strict>>>;
 			}, z.core.$strict>>;
 		}, z.core.$strict>;
 	}, z.core.$strict>>;
@@ -7848,9 +9553,9 @@ declare const ComplianceEvidence: z.ZodObject<{
 	outcome: z.ZodOptional<z.ZodEnum<{
 		succeeded: "succeeded";
 		escalated: "escalated";
+		failed: "failed";
 		allowed: "allowed";
 		denied: "denied";
-		failed: "failed";
 	}>>;
 	payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 	provenanceRef: z.ZodOptional<z.ZodObject<{
@@ -7892,9 +9597,9 @@ declare const ComplianceEvidenceCollectionPage: z.ZodObject<{
 		outcome: z.ZodOptional<z.ZodEnum<{
 			succeeded: "succeeded";
 			escalated: "escalated";
+			failed: "failed";
 			allowed: "allowed";
 			denied: "denied";
-			failed: "failed";
 		}>>;
 		payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 		provenanceRef: z.ZodOptional<z.ZodObject<{
@@ -8486,14 +10191,25 @@ declare const RunFinishedEvent: z.ZodObject<{
 			flowId: z.ZodString;
 			flowVersion: z.ZodString;
 			status: z.ZodEnum<{
-				completed: "completed";
 				failed: "failed";
+				completed: "completed";
 				cancelled: "cancelled";
 			}>;
 			dryRun: z.ZodBoolean;
 			failureMessage: z.ZodNullable<z.ZodString>;
 			createdAt: z.ZodISODateTime;
 			completedAt: z.ZodISODateTime;
+			usage: z.ZodOptional<z.ZodObject<{
+				calls: z.ZodNumber;
+				costUsd: z.ZodNumber;
+				tokens: z.ZodObject<{
+					prompt: z.ZodNumber;
+					completion: z.ZodNumber;
+					cacheRead: z.ZodNumber;
+					cacheWrite: z.ZodNumber;
+					reasoning: z.ZodNumber;
+				}, z.core.$strict>;
+			}, z.core.$strict>>;
 		}, z.core.$strict>;
 	}, z.core.$strict>;
 }, z.core.$strict>;
@@ -8518,14 +10234,25 @@ declare const WebhookEvent: z.ZodDiscriminatedUnion<[
 				flowId: z.ZodString;
 				flowVersion: z.ZodString;
 				status: z.ZodEnum<{
-					completed: "completed";
 					failed: "failed";
+					completed: "completed";
 					cancelled: "cancelled";
 				}>;
 				dryRun: z.ZodBoolean;
 				failureMessage: z.ZodNullable<z.ZodString>;
 				createdAt: z.ZodISODateTime;
 				completedAt: z.ZodISODateTime;
+				usage: z.ZodOptional<z.ZodObject<{
+					calls: z.ZodNumber;
+					costUsd: z.ZodNumber;
+					tokens: z.ZodObject<{
+						prompt: z.ZodNumber;
+						completion: z.ZodNumber;
+						cacheRead: z.ZodNumber;
+						cacheWrite: z.ZodNumber;
+						reasoning: z.ZodNumber;
+					}, z.core.$strict>;
+				}, z.core.$strict>>;
 			}, z.core.$strict>;
 		}, z.core.$strict>;
 		type: z.ZodLiteral<"run.finished">;
@@ -8560,14 +10287,25 @@ declare const WebhookDelivery: z.ZodObject<{
 					flowId: z.ZodString;
 					flowVersion: z.ZodString;
 					status: z.ZodEnum<{
-						completed: "completed";
 						failed: "failed";
+						completed: "completed";
 						cancelled: "cancelled";
 					}>;
 					dryRun: z.ZodBoolean;
 					failureMessage: z.ZodNullable<z.ZodString>;
 					createdAt: z.ZodISODateTime;
 					completedAt: z.ZodISODateTime;
+					usage: z.ZodOptional<z.ZodObject<{
+						calls: z.ZodNumber;
+						costUsd: z.ZodNumber;
+						tokens: z.ZodObject<{
+							prompt: z.ZodNumber;
+							completion: z.ZodNumber;
+							cacheRead: z.ZodNumber;
+							cacheWrite: z.ZodNumber;
+							reasoning: z.ZodNumber;
+						}, z.core.$strict>;
+					}, z.core.$strict>>;
 				}, z.core.$strict>;
 			}, z.core.$strict>;
 			type: z.ZodLiteral<"run.finished">;
@@ -8610,14 +10348,25 @@ declare const WebhookDeliveryCollectionPage: z.ZodObject<{
 						flowId: z.ZodString;
 						flowVersion: z.ZodString;
 						status: z.ZodEnum<{
-							completed: "completed";
 							failed: "failed";
+							completed: "completed";
 							cancelled: "cancelled";
 						}>;
 						dryRun: z.ZodBoolean;
 						failureMessage: z.ZodNullable<z.ZodString>;
 						createdAt: z.ZodISODateTime;
 						completedAt: z.ZodISODateTime;
+						usage: z.ZodOptional<z.ZodObject<{
+							calls: z.ZodNumber;
+							costUsd: z.ZodNumber;
+							tokens: z.ZodObject<{
+								prompt: z.ZodNumber;
+								completion: z.ZodNumber;
+								cacheRead: z.ZodNumber;
+								cacheWrite: z.ZodNumber;
+								reasoning: z.ZodNumber;
+							}, z.core.$strict>;
+						}, z.core.$strict>>;
 					}, z.core.$strict>;
 				}, z.core.$strict>;
 				type: z.ZodLiteral<"run.finished">;
@@ -8697,7 +10446,17 @@ export interface AgentVersionsClient {
 	 * @wire POST /v1/agents/:agentId/versions/:version/unregister
 	 */
 	unregister(agentId: AgentId, version: Semver, options?: MutationOptions): Promise<UnregisterAgentResult>;
+	/**
+	 * Derive a new version from a pinned one with some data-block pins
+	 * swapped (an expert's edit, no code change). Numbered the next free
+	 * patch after the agent's highest version. Needs `publish` on the agent.
+	 *
+	 * @wire POST /v1/agents/:agentId/versions
+	 */
+	derive(agentId: AgentId, input: DeriveAgentVersionInput, options?: MutationOptions): Promise<Agent$1>;
 }
+/** Body of `POST /v1/agents/{agentId}/versions`. */
+export type DeriveAgentVersionInput = DeriveAgentVersionBody;
 export interface ListAgentsFilter {
 	readonly limit?: number;
 	readonly cursor?: string;
@@ -8883,6 +10642,8 @@ export interface ApprovalFilter extends Omit<Filter<ApprovalStatus>, "status"> {
 	 * passing several is rejected client-side with `invalid-request`.
 	 */
 	readonly status?: ApprovalStatus;
+	/** Only one project's approvals (`kind: 'project'`), or every project's in an org (`kind: 'org'`). */
+	readonly scope?: ScopeRef;
 	/** Filter by required reviewer role. Caller must have rank ≥ value (else 403). */
 	readonly requiredRole?: ReviewerRole$1;
 	/** ISO 8601 timestamp — return approvals created strictly after this. */
@@ -9084,6 +10845,59 @@ export interface AuthProvidersClient {
 		readonly idempotencyKey?: string;
 	}): Promise<IdentityProviderUnregisterOutcome>;
 }
+export type BlockPage = BlockCollectionPage;
+/**
+ * The block fields of `POST /v1/blocks`. The project travels as
+ * `PublishBlockOptions.projectId`, so the input stays the block itself.
+ */
+export type PublishBlockInput = Omit<PublishBlockBody, "projectId">;
+export interface PublishBlockOptions {
+	/** The project the block belongs to. Its versions all stay there. */
+	readonly projectId: string;
+	readonly idempotencyKey?: string;
+}
+export interface ListBlocksFilter {
+	readonly limit?: number;
+	readonly cursor?: string;
+	readonly kind?: BlockKind;
+	/** Prefix match on the block id. */
+	readonly name?: string;
+	/** Only the blocks of this project, or of every project in this org. */
+	readonly scope?: ScopeRef;
+}
+export interface ListBlockVersionsFilter {
+	readonly limit?: number;
+	readonly cursor?: string;
+	/** Include unregistered versions, each with `unregisteredAt`. */
+	readonly includeTombstoned?: boolean;
+}
+export interface BlocksClient {
+	/**
+	 * Publish a block version into a project. Needs `write` on it.
+	 *
+	 * @wire POST /v1/blocks
+	 */
+	publish(input: PublishBlockInput, options: PublishBlockOptions): Promise<PublishBlockResult>;
+	/** @wire GET /v1/blocks */
+	list(filter?: ListBlocksFilter): Promise<BlockPage>;
+	/** @wire GET /v1/blocks/:blockId */
+	get(blockId: string): Promise<Block>;
+	readonly versions: BlockVersionsClient;
+}
+export interface BlockVersionsClient {
+	/** @wire GET /v1/blocks/:blockId/versions */
+	list(blockId: string, filter?: ListBlockVersionsFilter): Promise<BlockPage>;
+	/** @wire GET /v1/blocks/:blockId/versions/:version */
+	get(blockId: string, version: string): Promise<Block>;
+	/** @wire POST /v1/blocks/:blockId/versions/:version/unregister */
+	unregister(blockId: string, version: string, options?: {
+		readonly idempotencyKey?: string;
+	}): Promise<UnregisterBlockResult>;
+	/** @wire POST /v1/blocks/:blockId/versions/:version/reinstate */
+	reinstate(blockId: string, version: string, options?: {
+		readonly idempotencyKey?: string;
+	}): Promise<ReinstateBlockResult>;
+}
 /**
  * Capabilities resource — capability declarations + model router +
  * provider configuration.
@@ -9311,6 +11125,8 @@ export interface ConversationFilter extends Omit<Filter<ConversationStatus>, "st
 	 * passing several is rejected client-side with `invalid-request`.
 	 */
 	readonly status?: ConversationStatus;
+	/** Only one project's conversations (`kind: 'project'`), or every project's in an org (`kind: 'org'`). */
+	readonly scope?: ScopeRef;
 	readonly agent?: AgentId;
 	readonly participantId?: string;
 }
@@ -9333,8 +11149,10 @@ export interface CostClient {
 }
 export interface UsageClient {
 	/**
-	 * Paginated raw cost records. Filter by run, agent, conversation,
-	 * category, provider, and time window.
+	 * Paginated raw cost records: one per model call, with its model,
+	 * usage and what the vendor said about it. Filter by run (or a run
+	 * tree), scope, agent, conversation, category, provider, model and
+	 * time window.
 	 *
 	 * @wire `GET /v1/cost/records` — see
 	 *   `@kindgi/api/openapi.json#/paths/~1v1~1cost~1records/get`.
@@ -9346,26 +11164,25 @@ export interface UsageClient {
 	 * @wire `GET /v1/cost/records/{recordId}` — see
 	 *   `@kindgi/api/openapi.json#/paths/~1v1~1cost~1records~1{recordId}/get`.
 	 */
-	get(recordId: string): Promise<CostRecord>;
+	get(recordId: string, options?: {
+		readonly includeRawUsage?: boolean;
+	}): Promise<CostRecord>;
 	/**
-	 * Grouped aggregate — totals in USD, bucketed by requested dimensions
-	 * over the time window. Cheaper than paginating raw records for
-	 * dashboards.
+	 * Grouped aggregate — totals in USD and tokens, bucketed by requested
+	 * dimensions over the time window. Cheaper than paginating raw records
+	 * for dashboards. With `scope: { kind: 'org', orgId }`, one call sums
+	 * an org's spend across its projects.
 	 *
 	 * @wire `GET /v1/cost/aggregate` — see
 	 *   `@kindgi/api/openapi.json#/paths/~1v1~1cost~1aggregate/get`.
 	 */
 	summary(input: UsageSummaryInput): Promise<CostAggregateResult>;
 }
-export interface UsageSummaryInput {
+export interface UsageSummaryInput extends Omit<CostRecordFilter, "from" | "to" | "limit" | "cursor" | "includeRawUsage"> {
 	readonly from: Timestamp;
+	/** Exclusive. */
 	readonly to: Timestamp;
 	readonly groupBy?: readonly CostGroupDimension[];
-	readonly category?: string;
-	readonly providerId?: ProviderId;
-	readonly agentId?: AgentId;
-	readonly runId?: RunId;
-	readonly conversationId?: ThreadId;
 }
 export interface BudgetsClient {
 	/**
@@ -9459,19 +11276,19 @@ export interface EnvClient {
 	delete(input: EnvDeleteInput): Promise<EnvDeleteOutcome>;
 }
 export interface EnvListInput {
-	readonly scope: Scope;
+	readonly scope: ScopeRef;
 	readonly envName: EnvName;
 	readonly cursor?: Cursor;
 	readonly namePrefix?: string;
 	readonly limit?: number;
 }
 export interface EnvGetInput {
-	readonly scope: Scope;
+	readonly scope: ScopeRef;
 	readonly envName: EnvName;
 	readonly name: string;
 }
 export interface EnvSetInput {
-	readonly scope: Scope;
+	readonly scope: ScopeRef;
 	readonly envName: EnvName;
 	readonly name: string;
 	readonly value: string;
@@ -9479,12 +11296,12 @@ export interface EnvSetInput {
 	readonly tags?: Readonly<Record<string, string>>;
 }
 export interface EnvDeleteInput {
-	readonly scope: Scope;
+	readonly scope: ScopeRef;
 	readonly envName: EnvName;
 	readonly name: string;
 }
 export interface EnvRecord {
-	readonly scope: Scope;
+	readonly scope: ScopeRef;
 	readonly envName: EnvName;
 	readonly name: string;
 	readonly value: string;
@@ -9573,6 +11390,16 @@ export type PublishSuiteInput = Omit<PublishEvalSuiteBody, "projectId">;
 export type PublishSuiteResult = PublishEvalSuiteResult;
 export type UnregisterSuiteVersionResult = UnregisterEvalSuiteResult;
 export type ReinstateSuiteVersionResult = ReinstateEvalSuiteVersionResult;
+/** Body of `POST /v1/eval-suites/{suiteId}/versions/from-judgments`. */
+export type BuildFromJudgmentsInput = BuildJudgedSuiteBody;
+export type BuildFromJudgmentsResult = BuildJudgedSuiteResult;
+/** One case of a `judged` suite: a copy of a judged run with its items' judgments summed up. */
+export type SuiteCase = JudgedEvalCase;
+export type SuiteCasePage = JudgedEvalCaseCollectionPage;
+export interface ListSuiteCasesQuery {
+	readonly limit?: number;
+	readonly cursor?: string;
+}
 export interface PublishSuiteOptions {
 	/** Project the suite is published into. `POST /v1/eval-suites` requires it. */
 	readonly projectId: string;
@@ -9604,6 +11431,22 @@ export interface EvalSuitesClient {
 	list(filter?: ListSuitesFilter): Promise<SuitePage>;
 	/** @wire GET /v1/eval-suites/:suiteId */
 	get(suiteId: string): Promise<Suite>;
+	/**
+	 * Publish a `judged` suite version whose cases are copies of judged runs
+	 * of an agent or flow, with each item's judgments summed up. Needs
+	 * `admin` on `input.projectId`.
+	 *
+	 * @wire POST /v1/eval-suites/:suiteId/versions/from-judgments
+	 */
+	buildFromJudgments(suiteId: string, input: BuildFromJudgmentsInput, options?: {
+		readonly idempotencyKey?: string;
+	}): Promise<BuildFromJudgmentsResult>;
+	/**
+	 * The cases of a `judged` suite version, in stored order.
+	 *
+	 * @wire GET /v1/eval-suites/:suiteId/versions/:version/cases
+	 */
+	listCases(suiteId: string, version: string, query?: ListSuiteCasesQuery): Promise<SuiteCasePage>;
 	readonly versions: EvalSuiteVersionsClient;
 }
 export interface EvalSuiteVersionsClient {
@@ -9936,6 +11779,114 @@ export interface IdentityUsersClient {
 		readonly idempotencyKey?: string;
 	}): Promise<RevokeSessionsOutcome>;
 }
+/**
+ * Judge classes resource: the deployment's named kinds of judge
+ * ("expert", "user", ...), each with a weight, scoped to the tenant, a
+ * project, or an agent in a project.
+ */
+export interface JudgeClassesClient {
+	/**
+	 * Create a class. Names are unique among the live classes of a scope
+	 * (`409 judge-class-name-taken`).
+	 *
+	 * @wire `POST /v1/judge-classes` — see
+	 *   `@kindgi/api/openapi.json#/paths/~1v1~1judge-classes/post`.
+	 */
+	create(input: CreateJudgeClassInput, options?: {
+		readonly idempotencyKey?: string;
+	}): Promise<JudgeClass>;
+	/**
+	 * Live classes, newest first. `scope` narrows to one scope.
+	 *
+	 * @wire `GET /v1/judge-classes` — see
+	 *   `@kindgi/api/openapi.json#/paths/~1v1~1judge-classes/get`.
+	 */
+	list(filter?: JudgeClassFilter): Promise<Page<JudgeClass>>;
+	/**
+	 * One class, also a retired one (`unregisteredAt` set).
+	 *
+	 * @wire `GET /v1/judge-classes/{judgeClassId}` — see
+	 *   `@kindgi/api/openapi.json#/paths/~1v1~1judge-classes~1{judgeClassId}/get`.
+	 */
+	get(judgeClassId: string): Promise<JudgeClass>;
+	/**
+	 * Change a live class's weight or description.
+	 *
+	 * @wire `PATCH /v1/judge-classes/{judgeClassId}` — see
+	 *   `@kindgi/api/openapi.json#/paths/~1v1~1judge-classes~1{judgeClassId}/patch`.
+	 */
+	update(judgeClassId: string, input: UpdateJudgeClassInput, options?: {
+		readonly idempotencyKey?: string;
+	}): Promise<JudgeClass>;
+	/**
+	 * Retire a class: no new judgments may name it.
+	 *
+	 * @wire `POST /v1/judge-classes/{judgeClassId}/unregister` — see
+	 *   `@kindgi/api/openapi.json#/paths/~1v1~1judge-classes~1{judgeClassId}~1unregister/post`.
+	 */
+	unregister(judgeClassId: string, options?: {
+		readonly idempotencyKey?: string;
+	}): Promise<void>;
+}
+export interface JudgeClassFilter {
+	readonly limit?: number;
+	readonly cursor?: Cursor;
+	readonly scope?: JudgeClassScope;
+}
+/**
+ * Judgments resource: yes or no, with an optional reason, about one item
+ * of a finished run's output.
+ *
+ * Who judged comes from the token you call with, never from the input.
+ * Judging again as the same caller for the same run, item key and
+ * `participantId` supersedes the earlier judgment, which stays as history.
+ */
+export interface JudgmentsClient {
+	/**
+	 * Judge an item of a finished run.
+	 *
+	 * @wire `POST /v1/judgments` — see `@kindgi/api/openapi.json#/paths/~1v1~1judgments/post`.
+	 */
+	create(input: CreateJudgmentInput, options?: {
+		readonly idempotencyKey?: string;
+	}): Promise<Judgment>;
+	/**
+	 * Live judgments, newest first.
+	 *
+	 * @wire `GET /v1/judgments` — see `@kindgi/api/openapi.json#/paths/~1v1~1judgments/get`.
+	 */
+	list(filter?: JudgmentFilter): Promise<Page<Judgment>>;
+	/**
+	 * One judgment with the stored copies of what was judged.
+	 *
+	 * @wire `GET /v1/judgments/{judgmentId}` — see
+	 *   `@kindgi/api/openapi.json#/paths/~1v1~1judgments~1{judgmentId}/get`.
+	 */
+	get(judgmentId: string): Promise<JudgmentWithCopies>;
+	/**
+	 * Remove a judgment. Unknown ids fail with `404 judgment-not-found`.
+	 *
+	 * @wire `POST /v1/judgments/{judgmentId}/unregister` — see
+	 *   `@kindgi/api/openapi.json#/paths/~1v1~1judgments~1{judgmentId}~1unregister/post`.
+	 */
+	unregister(judgmentId: string, options?: {
+		readonly idempotencyKey?: string;
+	}): Promise<void>;
+}
+export interface JudgmentFilter {
+	readonly limit?: number;
+	readonly cursor?: Cursor;
+	readonly runId?: string;
+	readonly agentId?: string;
+	/** Needs `agentId`. */
+	readonly agentVersion?: string;
+	readonly flowId?: string;
+	readonly verdict?: Verdict;
+	readonly judgeClassId?: string;
+	readonly participantId?: string;
+	/** Narrow to a project (or org). */
+	readonly scope?: ScopeRef;
+}
 /**
  * MCP resource — Model Context Protocol interop.
  *
@@ -10742,10 +12693,18 @@ export interface RunJournalPage {
 export interface ListRunsFilter {
 	readonly limit?: number;
 	readonly cursor?: string;
+	/** Only one project's runs (`kind: 'project'`), or the runs of every project in an org (`kind: 'org'`). */
+	readonly scope?: ScopeRef;
 	/** Only the child runs of this run. */
 	readonly parentRunId?: RunId;
 	/** Only runs that are not a child of another run. */
 	readonly topLevel?: boolean;
+	/** Only this agent's turns, at any version (turns from before 0.1.3 don't name their agent). */
+	readonly agentId?: AgentId | string;
+	/** Replay runs (an eval run re-running a past run): `exclude` (the default) leaves them out, `include` lists them too, `only` lists just them. */
+	readonly replays?: "exclude" | "include" | "only";
+	/** Only the replay runs of this eval run (implies replays are included). */
+	readonly evalRunId?: string;
 	/** Include each run's `output` (omitted from lists by default). */
 	readonly includeOutput?: boolean;
 }
@@ -10792,11 +12751,20 @@ export interface ResumeRunInput {
 	readonly value?: unknown;
 	readonly idempotencyKey?: string;
 }
+/**
+ * The agent a run is a turn of (`@kindgi/api/openapi.json#RunAgent`):
+ * which agent, the version that ran, and the conversation.
+ */
+export interface RunAgent {
+	readonly id: string;
+	readonly version: string;
+	readonly conversationId: string;
+}
 /**
  * Wire shape — matches `@kindgi/api/openapi.json#Run`. Runs are
  * flow-native on the wire: an agent run executes as a flow on the
- * server, and the row reports that flow's `flowId` / `flowVersion`
- * rather than the `agentId`.
+ * server, and the row reports that flow's `flowId` / `flowVersion`;
+ * `agent` names the agent.
  */
 export interface Run {
 	readonly id: RunId;
@@ -10816,6 +12784,11 @@ export interface Run {
 	readonly parentRunId?: RunId;
 	/** Set on a child run: the node in the parent run that started it. */
 	readonly parentNodeId?: string;
+	/**
+	 * Set on an agent's turn (an agent run, or the turn a flow's agent step
+	 * started). Absent on other runs, and on turns from before 0.1.3.
+	 */
+	readonly agent?: RunAgent;
 }
 /**
  * What `runs.start` returns: the run, plus a public run token when the
@@ -10957,14 +12930,14 @@ export interface SecretRotationsClient {
 	}): AsyncIterable<unknown>;
 }
 export interface SecretRotationGetInput {
-	readonly scope: Scope;
+	readonly scope: ScopeRef;
 	readonly envName: EnvName;
 	readonly name: string;
 	readonly rotationId: string;
 }
 export type SecretRotationEventsInput = SecretRotationGetInput;
 export interface SecretListInput {
-	readonly scope: Scope;
+	readonly scope: ScopeRef;
 	readonly envName: EnvName;
 	readonly cursor?: Cursor;
 	readonly namePrefix?: string;
@@ -10972,25 +12945,25 @@ export interface SecretListInput {
 	readonly limit?: number;
 }
 export interface SecretGetInput {
-	readonly scope: Scope;
+	readonly scope: ScopeRef;
 	readonly envName: EnvName;
 	readonly name: string;
 }
 export interface SecretGetVersionInput {
-	readonly scope: Scope;
+	readonly scope: ScopeRef;
 	readonly envName: EnvName;
 	readonly name: string;
 	readonly versionId: number;
 }
 export interface SecretListVersionsInput {
-	readonly scope: Scope;
+	readonly scope: ScopeRef;
 	readonly envName: EnvName;
 	readonly name: string;
 	readonly cursor?: Cursor;
 	readonly limit?: number;
 }
 export interface SecretSetInput {
-	readonly scope: Scope;
+	readonly scope: ScopeRef;
 	readonly envName: EnvName;
 	readonly name: string;
 	readonly value: string;
@@ -11001,7 +12974,7 @@ export interface SecretSetInput {
 	readonly idempotencyKey?: string;
 }
 export interface SecretRotateInput {
-	readonly scope: Scope;
+	readonly scope: ScopeRef;
 	readonly envName: EnvName;
 	readonly name: string;
 	readonly newValue?: string;
@@ -11032,14 +13005,14 @@ export interface PollingOverrides {
 	readonly sleep?: (ms: number) => Promise<void>;
 }
 export interface SecretRevokeInput {
-	readonly scope: Scope;
+	readonly scope: ScopeRef;
 	readonly envName: EnvName;
 	readonly name: string;
 	readonly hard?: boolean;
 	readonly reason?: string;
 }
 export interface SecretRecord {
-	readonly scope: Scope;
+	readonly scope: ScopeRef;
 	readonly envName: EnvName;
 	readonly name: string;
 	readonly currentVersion: number;
@@ -11051,7 +13024,7 @@ export interface SecretRecord {
 	readonly rotationDueAt?: string;
 }
 export interface SecretVersionRecord {
-	readonly scope: Scope;
+	readonly scope: ScopeRef;
 	readonly envName: EnvName;
 	readonly name: string;
 	readonly versionId: number;
@@ -11826,7 +13799,11 @@ export interface KindgiClient {
 	readonly compliance: ComplianceClient;
 	readonly audit: AuditResourceClient;
 	readonly evalSuites: EvalSuitesClient;
+	/** Data blocks: versioned prompts and settings an agent version pins. */
+	readonly blocks: BlocksClient;
 	readonly evalRuns: EvalRunsClient;
+	readonly judgments: JudgmentsClient;
+	readonly judgeClasses: JudgeClassesClient;
 	readonly users: UsersClient;
 	readonly identity: IdentityClient;
 	readonly auth: AuthClient;