@runtypelabs/cli 2.59.1 → 2.59.4

package/dist/chunk-DPuofXMp.js

@@ -0,0 +1,3907 @@
+#!/usr/bin/env node
+import { C as unknown, S as union, _ as preprocess, a as _null, b as string, c as boolean, f as literal, g as partialRecord, h as object, i as _enum, m as number, s as array, u as discriminatedUnion, v as record } from "./chunk-BOpO6xE-.js";
+import { i as number$1, n as jsonPatchOperationSchema, t as EVAL_CASE_PERSONAS } from "./chunk-BJQv9Elp.js";
+import { a as graderConfigSchema, l as judgeEvidenceSchema, o as graderSeveritySchema, r as evalGraderSnapshotSchema, u as judgeVerdictSchema } from "./chunk-Bt0XAgX5.js";
+import { a as harnessCaptureSummarySchema } from "./chunk-Bu0FJr6S.js";
+import { r as createCliClient } from "./chunk-BW2fg46T.js";
+import { n as ensureAuth } from "./chunk-CJraEBVd.js";
+import { a as printJson } from "./chunk-CcFCyqbB.js";
+import { Command } from "commander";
+import chalk from "chalk";
+import { createReadStream, createWriteStream } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+import { tmpdir } from "node:os";
+import { createHash } from "node:crypto";
+import { Readable, Transform } from "node:stream";
+import { RuntypeApiError } from "@runtypelabs/sdk";
+import { lstat, mkdtemp, open, readFile, readdir, readlink, rename, rm, stat } from "node:fs/promises";
+import { Gzip } from "fflate";
+import { pipeline } from "node:stream/promises";
+// ../shared/dist/simulation/reported-usage.mjs
+const amount = number().finite().nonnegative();
+const tokens = amount.int();
+/** Producer estimates for one turn, independent of Runtype's measured usage and billing. */
+const reportedUsageSchema = object({
+	costUsd: amount.nullable(),
+	completeness: _enum(["complete", "partial"]),
+	scope: string().min(1).max(120),
+	models: array(object({
+		model: string().min(1).max(200),
+		canonicalModel: string().min(1).max(200).optional(),
+		provider: string().max(100).optional(),
+		pricingBasis: _enum([
+			"list",
+			"managed",
+			"unknown"
+		]).optional(),
+		costUsd: amount.nullable().optional(),
+		inputTokens: tokens.optional(),
+		outputTokens: tokens.optional(),
+		cacheReadInputTokens: tokens.optional(),
+		cacheCreationInputTokens: tokens.optional()
+	})).max(100).optional()
+});
+/** Known estimates and reporting coverage; a partial sum is never a whole-episode cost. */
+const selfReportedCostSchema = object({
+	knownCostUsd: amount.nullable(),
+	reportedTurns: tokens,
+	totalTurns: tokens,
+	completeTurns: tokens,
+	unknownEpisodes: tokens.optional(),
+	completeness: _enum([
+		"complete",
+		"partial",
+		"unknown"
+	])
+});
+const simTerminationSchema = _enum([
+	"goal_met",
+	"gave_up",
+	"max_turns",
+	"agent_error",
+	"simulator_error",
+	"stalled",
+	"deadline",
+	"target_unavailable",
+	"client_limit",
+	"recording_miss",
+	"spend_cap",
+	"engine_error"
+]);
+/** Who the simulated user is to the target's own access controls (#9489 section 4.1). */
+const simPrincipalSchema = object({
+	email: string().email().optional(),
+	groups: array(string().max(200)).max(50).optional(),
+	department: string().max(200).optional()
+}).strict();
+/**
+* Who a simulated user is to the product; the simulator's first rule follows it. `operator` is left out on purpose:
+* Simulations already uses it for client-agent episodes, and someone who runs the product is a `teammate`.
+*/
+const SIM_USER_ROLES = [
+	"customer",
+	"end_user",
+	"teammate",
+	"developer"
+];
+const simUserRoleSchema = _enum(SIM_USER_ROLES);
+object({
+	goal: string().min(1).max(2e3),
+	profile: string().max(2e3).optional(),
+	persona: string().max(64).optional(),
+	role: simUserRoleSchema.optional(),
+	traits: array(string().max(200)).max(20).optional(),
+	knowledge: record(string(), string().max(2e3)).optional(),
+	successSignal: string().max(1e3).optional(),
+	openingMessage: string().max(4e3).optional(),
+	maxTurns: number().int().min(1).max(20).optional(),
+	principal: simPrincipalSchema.optional()
+}).strict();
+/** One tool call inside an assistant message, `DispatchExecutionMessage`-shaped. */
+const simToolCallSchema = object({
+	toolCallId: string(),
+	toolName: string(),
+	args: record(string(), unknown())
+});
+/** One tool result inside a tool message, `DispatchExecutionMessage`-shaped. */
+const simToolResultSchema = object({
+	toolCallId: string(),
+	toolName: string(),
+	result: unknown()
+});
+/** One message of a simulated conversation; the target sees all of it, the simulated user only the text. */
+const simMessageSchema = object({
+	role: _enum([
+		"user",
+		"assistant",
+		"tool"
+	]),
+	content: string(),
+	toolCalls: array(simToolCallSchema).optional(),
+	toolResults: array(simToolResultSchema).optional()
+});
+object({
+	message: string(),
+	status: _enum([
+		"continue",
+		"goal_met",
+		"gave_up"
+	]),
+	reason: string().nullable().optional(),
+	revealed: array(string()).optional()
+});
+// ../shared/dist/chunk-acmbThRp.mjs
+/** Every change kind a scrub report can name; a leaf so the data-source contracts reach it without the scrubber. */
+const METADATA_SCRUB_CHANGE_KIND_NAMES = [
+	"url_redirected",
+	"url_removed",
+	"secret_refused",
+	"secret_env_noted",
+	"auth_replaced",
+	"connection_replaced",
+	"unknown_key_kept"
+];
+function sortKeys(value) {
+	if (Array.isArray(value)) return value.map(sortKeys);
+	if (value && typeof value === "object") {
+		const out = {};
+		for (const key of Object.keys(value).sort()) {
+			const entry = value[key];
+			if (entry !== void 0) out[key] = sortKeys(entry);
+		}
+		return out;
+	}
+	return value;
+}
+/** JSON with sorted keys and undefined fields dropped, so equal values always serialize alike. */
+function canonicalJson(value) {
+	return JSON.stringify(sortKeys(value)) ?? "null";
+}
+/** Most episodes one run may plan, across every round. */
+const MAX_EPISODES_PER_RUN = 1e3;
+/** Most characters in a simulated user's profile. */
+const MAX_PROFILE_CHARS = 2e3;
+/** Most characters in a task goal. */
+const MAX_GOAL_CHARS = 2e3;
+/** Most characters in a task's opening message. */
+const MAX_OPENING_MESSAGE_CHARS = 4e3;
+/** Most characters in a task's success signal. */
+const MAX_SUCCESS_SIGNAL_CHARS = 1e3;
+/** Most records, or quarantine entries, one episode's state may report. */
+const MAX_SIDE_EFFECT_RECORDS = 1e3;
+/** Most characters in a synthetic dataset's schema-only DDL export (6.9). */
+const MAX_DATASET_SCHEMA_DDL_CHARS = 2e6;
+/** Most characters in a synthetic dataset's permission metadata export, serialized as JSON. */
+const MAX_DATASET_PERMISSION_METADATA_CHARS = 4e6;
+/** Most generated rows in one table of a synthetic dataset. */
+const MAX_DATASET_ROWS_PER_TABLE = 5e3;
+/** Most generated rows across a synthetic dataset. */
+const MAX_DATASET_TOTAL_ROWS = 5e4;
+/** Most changes one scrub report may list. */
+const MAX_DATASET_SCRUB_CHANGES = 2e3;
+const productKindSchema = _enum([
+	"runtype",
+	"external",
+	"spec_only"
+]);
+// ../shared/dist/chunk-Cf0i0FDN.mjs
+/** The manifest file at the root of a candidate's source bundle. */
+const CANDIDATE_MANIFEST_FILENAME = "runtype-candidate.json";
+const candidateRuntimeSchema = _enum([
+	"node",
+	"bun",
+	"python"
+]);
+const candidateProtocolSchema = _enum(["a2a", "runtype-stream"]);
+const candidateSessionsSchema = _enum(["multi_turn", "single_turn"]);
+/** `runtype-candidate.json`. Unknown fields are refused, so a typo fails before a run, not during one. */
+const candidateManifestSchema = object({
+	$schema: string().max(512).optional(),
+	name: string().trim().min(1).max(120),
+	framework: object({
+		name: string().trim().min(1).max(64),
+		version: string().max(64).regex(/^v?\d+(\.\d+){0,3}([-+][0-9A-Za-z.-]+)?$/)
+	}).strict(),
+	runtime: candidateRuntimeSchema,
+	start: string().trim().min(1).max(1e3),
+	protocol: candidateProtocolSchema,
+	sessions: candidateSessionsSchema,
+	licence: string().regex(/^[A-Za-z0-9][A-Za-z0-9.+-]{0,63}$/)
+}).strict();
+Object.values({
+	port: "RUNTYPE_CANDIDATE_PORT",
+	modelBaseUrl: "RUNTYPE_MODEL_BASE_URL",
+	modelApiKey: "RUNTYPE_MODEL_API_KEY",
+	model: "RUNTYPE_MODEL",
+	mcpUrl: "RUNTYPE_MCP_URL",
+	episodeId: "RUNTYPE_EPISODE_ID"
+});
+/** Parses a manifest file's text; the error names the first field that failed. */
+function parseCandidateManifest(text) {
+	let json;
+	try {
+		json = JSON.parse(text);
+	} catch {
+		return {
+			ok: false,
+			error: `${CANDIDATE_MANIFEST_FILENAME} is not valid JSON.`
+		};
+	}
+	const parsed = candidateManifestSchema.safeParse(json);
+	if (parsed.success) return {
+		ok: true,
+		manifest: parsed.data
+	};
+	const issue = parsed.error.issues[0];
+	return {
+		ok: false,
+		error: `${issue?.path.join(".") || "runtype-candidate.json"}: ${issue?.message ?? "invalid"}`
+	};
+}
+/** Bounded and credential-redacted output observed at the authenticated candidate MCP gateway. */
+const simulationAccessToolOutcomeSchema = object({
+	name: string(),
+	input: unknown(),
+	output: unknown(),
+	isError: boolean(),
+	stubbed: boolean(),
+	readOnly: boolean(),
+	truncated: boolean()
+});
+/** Server-observed MCP facts for one candidate identity; tool text remains untrusted data. */
+const simulationAccessEvidenceSchema = object({
+	source: literal("candidate_mcp_gateway"),
+	sourceKind: _enum([
+		"mcp_target",
+		"stand_in",
+		"fixture",
+		"none"
+	]),
+	targetId: string().optional(),
+	identity: union([object({
+		kind: literal("saved_server"),
+		savedServerName: string()
+	}), object({ kind: literal("source_default") })]),
+	identityMatched: boolean(),
+	complete: boolean(),
+	rawToolCount: number().int().nonnegative(),
+	effectiveToolCount: number().int().nonnegative(),
+	tools: array(object({
+		name: string(),
+		description: string(),
+		readOnly: boolean(),
+		execution: _enum(["live", "stubbed"])
+	})),
+	observedAt: string(),
+	truncated: boolean(),
+	toolOutcomes: array(simulationAccessToolOutcomeSchema)
+});
+const isoDate$1 = string().datetime({ offset: true });
+const entityId$2 = string().min(1).max(255);
+const sha256HexSchema = string().regex(/^[a-f0-9]{64}$/);
+_enum([
+	"none",
+	"live",
+	"synthetic",
+	"cloned"
+]);
+const syntheticDatasetKindSchema = _enum(["synthetic"]);
+const dataScopeSchema = _enum([
+	"run",
+	"variant",
+	"episode"
+]);
+const syntheticDatasetBuildStatusSchema = _enum([
+	"pending",
+	"building",
+	"ready",
+	"failed"
+]);
+const permissionMetadataEngineSchema = _enum(["hasura"]);
+/** A simulated user's identity alias, mapped to an engine grant by the dataset (`alias_grants`). */
+const DATASET_IDENTITY_ALIAS_PATTERN = /^[a-z0-9][a-z0-9_.-]{0,63}$/;
+/** A runner clone hook's name, as the runner config declares it. */
+const CLONE_HOOK_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+/** A table, optionally schema-qualified, as the DDL export names it. */
+const DATASET_TABLE_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_$]*(\.[A-Za-z_][A-Za-z0-9_$]*)?$/;
+/** An OCI image reference pinned by digest. */
+const DATASET_IMAGE_REFERENCE_PATTERN = /^[a-z0-9][a-z0-9._/:-]*@sha256:[a-f0-9]{64}$/;
+const grantNameSchema = string().min(1).max(128);
+/** One tool as a grant's `tools/list` returned it; a stand-in serves these names, schemas and annotations. */
+const datasetToolSnapshotSchema = object({
+	name: string().min(1).max(128),
+	title: string().max(255).optional(),
+	description: string().max(4e3).optional(),
+	inputSchema: record(string(), unknown()),
+	outputSchema: record(string(), unknown()).optional(),
+	annotations: record(string(), unknown()).optional()
+});
+/** What one grant (an engine role) saw from `tools/list`; a stand-in's permissions come from these. */
+const datasetGrantToolsSnapshotSchema = object({
+	grant: grantNameSchema,
+	tools: array(datasetToolSnapshotSchema).max(200)
+});
+/** The MCP server a synthetic dataset serves: the customer's image by digest, or a stand-in built from per-grant snapshots. */
+const datasetMcpServerSchema = discriminatedUnion("kind", [object({
+	kind: literal("image"),
+	image: string().max(512).regex(DATASET_IMAGE_REFERENCE_PATTERN)
+}), object({
+	kind: literal("stand_in"),
+	grants: array(datasetGrantToolsSnapshotSchema).min(1).max(50)
+})]);
+/** Row counts the customer supplies (never rows), and the seed that makes a rebuild byte-identical. */
+const datasetSpecInputSchema = object({
+	rowCounts: record(string().max(128).regex(DATASET_TABLE_NAME_PATTERN), number().int().min(0).max(MAX_DATASET_ROWS_PER_TABLE)).refine((counts) => Object.keys(counts).length <= 500, { message: `At most 500 tables.` }),
+	seed: number().int().min(0).max(4294967295)
+}).refine((dataset) => Object.values(dataset.rowCounts).reduce((sum, count) => sum + count, 0) <= MAX_DATASET_TOTAL_ROWS, {
+	message: `At most ${MAX_DATASET_TOTAL_ROWS} rows across the dataset.`,
+	path: ["rowCounts"]
+});
+/** The dataset spec as stored (`dataset_spec`), with the generator version it was written for. */
+const datasetSpecSchema = object({
+	rowCounts: record(string(), number().int().nonnegative()),
+	seed: number().int().nonnegative(),
+	generatorVersion: number().int().positive()
+});
+const datasetScrubChangeKindSchema = _enum(METADATA_SCRUB_CHANGE_KIND_NAMES);
+/** One change import made to a permission metadata export, as `scrubPermissionMetadata` reports it. */
+const datasetScrubChangeSchema = object({
+	/** JSON Pointer into the metadata object. */
+	path: string().max(1024),
+	kind: datasetScrubChangeKindSchema,
+	/** The original value, redacted: URL hosts masked, secrets reduced to their length. */
+	before: string().max(4e3).nullable(),
+	/** The value now at `path`; null when it was removed or left as exported. */
+	after: unknown(),
+	note: string().max(1e3).optional()
+});
+/** Every change the scrubber made, so the customer can review what the dataset runs instead of their rules. */
+const datasetScrubReportSchema = object({
+	format: literal("hasura_metadata_v3"),
+	/** `refused` when a literal secret was found; a refused export is never stored. */
+	status: _enum(["clean", "refused"]),
+	changes: array(datasetScrubChangeSchema).max(MAX_DATASET_SCRUB_CHANGES),
+	/** Changes per kind, keyed by kind; an open record, so the spec lists no snake_case property names. */
+	counts: record(string(), number().int().nonnegative()),
+	/** Every role a permission or inherited role names; identity roles and stand-in grants map onto these. */
+	roles: array(string().max(255)).max(MAX_DATASET_SCRUB_CHANGES)
+});
+/** The report a stored definition carries: only a clean scrub is ever imported. */
+const cleanDatasetScrubReportSchema = datasetScrubReportSchema.extend({ status: literal("clean") });
+/** A GraphQL engine's permission metadata export, already scrubbed; configuration, not data, but sealed at rest. */
+const datasetPermissionMetadataSchema = object({
+	engine: permissionMetadataEngineSchema,
+	export: record(string(), unknown()).refine((value) => canonicalJson(value).length <= MAX_DATASET_PERMISSION_METADATA_CHARS, { message: `The metadata export must be at most ${MAX_DATASET_PERMISSION_METADATA_CHARS} characters.` })
+});
+object({
+	name: string().min(1).max(255),
+	kind: syntheticDatasetKindSchema,
+	schemaDdl: string().min(1).max(MAX_DATASET_SCHEMA_DDL_CHARS),
+	permissionMetadata: datasetPermissionMetadataSchema,
+	scrubReport: cleanDatasetScrubReportSchema,
+	dataset: datasetSpecInputSchema,
+	mcpServer: datasetMcpServerSchema.nullable().optional(),
+	aliasGrants: record(string().regex(DATASET_IDENTITY_ALIAS_PATTERN), grantNameSchema).refine((roles) => Object.keys(roles).length <= 50, { message: `At most 50 identity aliases.` }).optional()
+}).omit({
+	scrubReport: true,
+	kind: true
+}).extend({ kind: syntheticDatasetKindSchema.default("synthetic") });
+/** A saved synthetic dataset as the API returns it; the DDL and the metadata export never leave the store. */
+const simulationSyntheticDatasetSchema = object({
+	id: entityId$2,
+	name: string(),
+	kind: syntheticDatasetKindSchema,
+	permissionEngine: permissionMetadataEngineSchema,
+	scrubReport: datasetScrubReportSchema,
+	dataset: datasetSpecSchema,
+	mcpServer: datasetMcpServerSchema.nullable(),
+	aliasGrants: record(string(), string()),
+	buildStatus: syntheticDatasetBuildStatusSchema,
+	buildError: string().nullable(),
+	builtAt: isoDate$1.nullable(),
+	definitionHash: sha256HexSchema,
+	createdByUserId: entityId$2.nullable(),
+	createdAt: isoDate$1,
+	updatedAt: isoDate$1
+});
+/** The data a variant runs against (`simulation_variants.data`); none means `none` or `live` by target kind. */
+const variantDataSchema = discriminatedUnion("kind", [object({
+	kind: literal("synthetic"),
+	syntheticDatasetId: entityId$2,
+	scope: dataScopeSchema,
+	/** The grant a stand-in serves this variant's client agent; needed when the dataset has more than one. */
+	grant: grantNameSchema.optional()
+}), object({
+	kind: literal("cloned"),
+	hook: string().regex(CLONE_HOOK_NAME_PATTERN),
+	scope: dataScopeSchema
+})]);
+string().max(160).regex(/^(none|live|synthetic:[a-f0-9]{64}|cloned:[a-z0-9][a-z0-9_-]{0,63})$/);
+const recordTypeSchema = string().min(1).max(128);
+const fieldPathSchema = string().min(1).max(128).regex(/^[A-Za-z0-9_$-]+(\.[A-Za-z0-9_$-]+)*$/);
+/**
+* A field's expected value: equal to a literal, or containing a substring. Strings may name task data with
+* `{{knowledge.NAME}}`, `{{user.NAME}}` or `{{episode.id}}`; strings compare trimmed and case-insensitively.
+*/
+const sideEffectValueSchema = union([
+	string().max(1e3),
+	number(),
+	boolean(),
+	_null(),
+	object({ contains: string().min(1).max(1e3) }).strict()
+]);
+/** Field conditions, all of which a record must meet; a dotted path reads a nested field. */
+const sideEffectWhereSchema = record(fieldPathSchema, sideEffectValueSchema).refine((where) => Object.keys(where).length <= 20, { message: `At most 20 conditions.` });
+/** A record a `linked` check expects a link to: by id, by its fields, or both. */
+const sideEffectLinkTargetSchema = object({
+	type: recordTypeSchema,
+	id: string().min(1).max(256).optional(),
+	where: sideEffectWhereSchema.optional()
+});
+const labelSchema = string().min(1).max(120).optional();
+/** One declarative check over the records an episode wrote; deterministic, with no judge. */
+const sideEffectCheckSchema = discriminatedUnion("assert", [
+	object({
+		assert: literal("exists"),
+		type: recordTypeSchema,
+		where: sideEffectWhereSchema.optional(),
+		label: labelSchema
+	}),
+	object({
+		assert: literal("absent"),
+		type: recordTypeSchema,
+		where: sideEffectWhereSchema.optional(),
+		label: labelSchema
+	}),
+	object({
+		assert: literal("linked"),
+		type: recordTypeSchema,
+		where: sideEffectWhereSchema.optional(),
+		to: array(sideEffectLinkTargetSchema).min(1).max(5),
+		label: labelSchema
+	}),
+	object({
+		assert: literal("in_quarantine"),
+		where: sideEffectWhereSchema.optional(),
+		label: labelSchema
+	})
+]);
+const SIDE_EFFECT_ASSERTIONS = [
+	"exists",
+	"absent",
+	"linked",
+	"in_quarantine"
+];
+/** A simulation task's grader over the episode's resulting state, not its transcript (6.10). */
+const sideEffectGraderSchema = object({
+	kind: literal("side_effect"),
+	name: string().min(1).max(120).optional(),
+	checks: array(sideEffectCheckSchema).min(1).max(20),
+	/**
+	* On a synthetic dataset: the record type (the dataset's table) each write tool writes, keyed by tool name. A stand-in
+	* keeps no state, so this is how its accepted writes become records; a target's state endpoint names types itself.
+	*/
+	writes: record(string().min(1).max(128), recordTypeSchema).refine((writes) => Object.keys(writes).length <= 100, { message: `At most 100 write tools.` }).optional(),
+	severity: graderSeveritySchema.optional()
+});
+/** One check's outcome on one episode, by its position in the grader's `checks`. */
+const sideEffectCheckResultSchema = object({
+	index: number().int().min(0),
+	assert: _enum(SIDE_EFFECT_ASSERTIONS),
+	passed: boolean()
+});
+/** The side-effect grader as a score row stores it, with each check's result. */
+const sideEffectGraderSnapshotSchema = sideEffectGraderSchema.extend({ results: array(sideEffectCheckResultSchema).optional() });
+const stateIdSchema = union([string().min(1).max(256), number()]).transform(String);
+const stateFieldsSchema = record(string(), unknown());
+/** One record an episode wrote, as a state endpoint or the synthetic dataset reports it. */
+const sideEffectRecordSchema = object({
+	type: recordTypeSchema,
+	id: stateIdSchema,
+	fields: stateFieldsSchema,
+	links: array(object({
+		type: recordTypeSchema,
+		id: stateIdSchema
+	})).max(100).default([])
+});
+/** One submission held in quarantine for review. */
+const sideEffectQuarantineEntrySchema = object({
+	id: stateIdSchema,
+	fields: stateFieldsSchema
+});
+object({
+	episode: string().min(1).max(255),
+	records: array(sideEffectRecordSchema).max(MAX_SIDE_EFFECT_RECORDS),
+	quarantine: array(sideEffectQuarantineEntrySchema).max(MAX_SIDE_EFFECT_RECORDS)
+});
+const toolNameSchema = string().min(1).max(128);
+const argumentPathSchema = string().min(1).max(128).regex(/^[A-Za-z0-9_$-]+(\.[A-Za-z0-9_$-]+)*$/);
+const allowedCountSchema = number().int().nonnegative().max(1e3);
+/** One deterministic check over the tool calls an episode made; no judge reads it. */
+const toolProcessCheckSchema = discriminatedUnion("assert", [
+	object({
+		assert: literal("no_wrong_tool"),
+		/** Calls the expected-tool rule may label wrong before the check fails. */
+		max: allowedCountSchema.optional()
+	}),
+	object({
+		assert: literal("argument_format"),
+		tools: array(toolNameSchema).min(1).max(20),
+		argument: argumentPathSchema,
+		/** `uuid`: the value is a UUID string. `uuid_keyed`: an object whose every key is `<uuid>_<suffix>`. */
+		format: _enum(["uuid", "uuid_keyed"]),
+		/** For `uuid_keyed`, the suffixes a key may end in, such as filter operators. */
+		keySuffixes: array(string().min(1).max(32).regex(/^[A-Za-z0-9]+$/)).max(20).optional(),
+		/** Count only calls that also ended in an error, for a surface that may accept the other form. */
+		onlyFailed: boolean().optional(),
+		max: allowedCountSchema.optional()
+	}),
+	object({
+		assert: literal("no_repeat_call"),
+		tool: toolNameSchema,
+		/** The arguments that make two calls the same fetch; absent compares every argument. */
+		keyArguments: array(argumentPathSchema).min(1).max(8).optional(),
+		/** Calls allowed per key before the check fails; defaults to 1. */
+		max: number().int().positive().max(1e3).optional()
+	}),
+	object({
+		assert: literal("budget"),
+		maxTurns: number().int().positive().max(1e3).optional(),
+		maxTokens: number().int().positive().optional()
+	}),
+	object({
+		assert: literal("must_call"),
+		/** A completed call to any one of these counts; a designed rename counts under its shown or its server name. */
+		tools: array(toolNameSchema).min(1).max(20),
+		/** Completed calls the listed tools must add up to; defaults to 1. */
+		minCalls: number().int().positive().max(1e3).optional()
+	})
+]);
+/**
+* A Simulations-only grader over how an episode used its tools: wrong tool choices, argument formats, repeated
+* fetches, a turn or token budget and a required call. Deterministic; eval suites refuse it.
+*/
+const toolProcessGraderSchema = object({
+	kind: literal("tool_process"),
+	name: string().min(1).max(120),
+	check: toolProcessCheckSchema,
+	severity: graderSeveritySchema.optional()
+}).refine((grader) => grader.check.assert !== "budget" || grader.check.maxTurns !== void 0 || grader.check.maxTokens !== void 0, {
+	message: "A budget check needs maxTurns or maxTokens.",
+	path: ["check"]
+});
+new RegExp(`^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$`, "i");
+const variantPlacementSchema = _enum([
+	"runtype",
+	"runtype_sandbox",
+	"external_endpoint",
+	"vendor",
+	"private_runner"
+]);
+const variantFidelitySchema = _enum([
+	"runtype",
+	"real_code",
+	"endpoint",
+	"vendor_hosted",
+	"simulated_agent"
+]);
+const episodeRanOnSchema = _enum([
+	"runtype_worker",
+	"runtype_durable",
+	"sandbox",
+	"external_endpoint",
+	"private_runner",
+	"vendor"
+]);
+const isoDate = string().datetime({ offset: true });
+const entityId$1 = string().min(1).max(255);
+const shortText = (max) => string().max(max);
+const simulationSlugSchema = string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/);
+const simulationVariantKeySchema = string().regex(/^[a-z0-9][a-z0-9_-]{0,47}$/);
+const simulationModeSchema = _enum(["benchmark", "user_testing"]);
+const simulationPresetSchema = _enum(["agent_experience"]);
+const targetKindSchema = _enum([
+	"runtype_surface",
+	"runtype_capability",
+	"external_agent",
+	"external_mcp",
+	"external_api",
+	"website",
+	"cli",
+	"skill",
+	"sandbox_candidate",
+	"vendor_hosted"
+]);
+const targetVerificationStatusSchema = _enum([
+	"not_required",
+	"unverified",
+	"pending",
+	"verified"
+]);
+const targetVerificationMethodSchema = _enum(["well_known", "dns_txt"]);
+/** An ownership challenge (4.8): the token, where to publish it, and the last check's outcome. */
+const simulationTargetVerificationSchema = object({
+	/** The host the challenge covers; changing the target to another host clears the verification. */
+	host: string(),
+	token: string(),
+	/** The URL that may serve `token` on a line of its own. */
+	wellKnownUrl: string(),
+	/** The DNS name whose TXT record may hold `token` instead. */
+	dnsRecordName: string(),
+	startedAt: isoDate,
+	checkedAt: isoDate.nullable(),
+	verifiedAt: isoDate.nullable(),
+	method: targetVerificationMethodSchema.nullable(),
+	/** Why the last check did not verify; null after a success or before any check. */
+	lastError: string().nullable()
+});
+const SECRET_REFERENCE = /^\{\{secret:[^{}]+\}\}$/;
+const CREDENTIAL_HEADER_NAME = /auth|cookie|api[-_]?key|token|secret|passw|session|credential/i;
+const CREDENTIAL_HEADER_VALUE = /^(bearer|basic|token)\s/i;
+/** Whether a target header carries a literal credential: a credential-looking name or value that is not a `{{secret:NAME}}` reference. */
+function isLiteralCredentialHeader(name, value) {
+	if (SECRET_REFERENCE.test(value.trim())) return false;
+	return CREDENTIAL_HEADER_NAME.test(name) || CREDENTIAL_HEADER_VALUE.test(value.trim());
+}
+const CREDENTIAL_QUERY_NAME = /^key$|auth|api[-_]?key|token|secret|passw|session|credential|signature|sig$/i;
+/** Whether a target URL carries a credential: userinfo, or a credential-looking query parameter. */
+function urlCarriesCredential(url) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return false;
+	}
+	if (parsed.username || parsed.password) return true;
+	return [...parsed.searchParams.keys()].some((name) => CREDENTIAL_QUERY_NAME.test(name));
+}
+/** A target URL; a credential never rides in it, only in a saved connection or a `{{secret:NAME}}` header. */
+const credentialFreeUrl = string().url().refine((url) => !urlCarriesCredential(url), { message: "A target URL may not carry a credential. Connect the server as a saved connection (savedServerName) instead." });
+/** Target headers; a credential is never stored literally, only as a `{{secret:NAME}}` reference or a saved connection. */
+const secretReferenceHeaders = record(string().min(1).max(128), string().max(2048)).refine((headers) => Object.entries(headers).every(([name, value]) => !isLiteralCredentialHeader(name, value)), { message: "A target header may not carry a literal credential. Connect the server as a saved connection (savedServerName) instead." });
+const runtypeSurfaceTargetConfigSchema = object({
+	kind: literal("runtype_surface"),
+	productId: entityId$1,
+	surfaceId: entityId$1,
+	surfaceType: string().min(1).max(64)
+});
+const runtypeCapabilityTargetConfigSchema = object({
+	kind: literal("runtype_capability"),
+	productId: entityId$1.optional(),
+	capabilityId: entityId$1.optional(),
+	flowId: entityId$1.optional(),
+	agentId: entityId$1.optional()
+});
+const externalAgentTargetConfigSchema = object({
+	kind: literal("external_agent"),
+	agentId: entityId$1
+});
+/** Largest `grantsToTools.grants`, as UTF-8 bytes of JSON; admission copies it into the run plan, a 2 MB value. */
+const MAX_GRANTS_TO_TOOLS_JSON_BYTES = 64e3;
+/**
+* Which tools each grant should see in `tools/list`, as a `grants-to-tools.json` document carries it; other keys of
+* the document are ignored. Simulated users name their grants in `identity.expectedGrants`, and the permission matrix
+* (6.11) compares what each one saw and called with the union of its grants' tools.
+*/
+const grantsToToolsSchema = object({
+	version: literal(1).optional(),
+	grants: record(string().trim().min(1).max(64), array(string().min(1).max(128)).max(500)).refine((grants) => Object.keys(grants).length > 0, { message: "Name at least one grant and the tools it should see." }).refine((grants) => Object.keys(grants).length <= 50, { message: `Name at most 50 grants.` }).refine((grants) => new TextEncoder().encode(JSON.stringify(grants)).byteLength <= MAX_GRANTS_TO_TOOLS_JSON_BYTES, { message: `The grants-to-tools map may be at most ${MAX_GRANTS_TO_TOOLS_JSON_BYTES} bytes of JSON.` })
+});
+/**
+* Where a target reports what an episode wrote (6.10): `GET <url>?episode=<episodeId>` with the resolved secret as a
+* bearer token. It must be on the target's own origin.
+*/
+const stateEndpointSchema = object({
+	url: credentialFreeUrl,
+	secretRef: string().max(110).regex(/^\{\{secret:([A-Z][A-Z0-9_]{0,98}[A-Z0-9])\}\}$/, { message: "secretRef must be a {{secret:NAME}} reference to a managed secret, never a literal value." })
+});
+const externalMcpTargetConfigSchema = object({
+	kind: literal("external_mcp"),
+	url: credentialFreeUrl,
+	transport: _enum(["streamable_http", "sse"]).optional(),
+	headers: secretReferenceHeaders.optional(),
+	savedServerName: string().min(1).max(128).optional(),
+	allowedTools: array(string().min(1).max(128)).max(200).optional(),
+	/** The expected result of the permission matrix: the tools each grant should see. */
+	grantsToTools: grantsToToolsSchema.optional(),
+	/** Read after each episode by side-effect graders when the variant has no synthetic dataset. */
+	stateEndpoint: stateEndpointSchema.optional()
+});
+const externalApiTargetConfigSchema = object({
+	kind: literal("external_api"),
+	openapiUrl: credentialFreeUrl.optional(),
+	document: unknown().optional(),
+	baseUrl: credentialFreeUrl,
+	headers: secretReferenceHeaders.optional(),
+	operations: array(string().min(1).max(256)).max(50).optional()
+});
+const websiteTargetConfigSchema = object({
+	kind: literal("website"),
+	url: credentialFreeUrl
+});
+const cliTargetConfigSchema = object({
+	kind: literal("cli"),
+	package: union([object({
+		registry: _enum(["npm", "pip"]),
+		name: string().min(1).max(214),
+		version: string().min(1).max(64)
+	}), object({
+		url: credentialFreeUrl,
+		sha256: string().regex(/^[a-f0-9]{64}$/)
+	})]),
+	command: string().min(1).max(128),
+	secretEnv: record(string().min(1).max(128), string().max(256)).optional()
+});
+const skillTargetConfigSchema = object({
+	kind: literal("skill"),
+	skillId: entityId$1.optional(),
+	bundleUrl: credentialFreeUrl.optional()
+});
+/** A candidate's source bundle with its dependency lock, run as real code in a Runtype sandbox (6.9). */
+const sandboxCandidateTargetConfigSchema = object({
+	kind: literal("sandbox_candidate"),
+	bundle: object({
+		sha256: string().regex(/^[a-f0-9]{64}$/),
+		/** Where the bundle is stored; opaque to the contract, and never a URL that carries a credential. */
+		ref: string().min(1).max(512).refine((ref) => !urlCarriesCredential(ref), { message: "A bundle reference may not carry a credential." })
+	}),
+	/** The bundle's `runtype-candidate.json`, read at upload so admission never unpacks the bundle. */
+	manifest: candidateManifestSchema,
+	/** An `external_mcp` target whose tools the candidate gets when its variant sets no data. */
+	mcpTargetId: entityId$1.optional()
+});
+/** A vendor's hosted agent, driven over A2A, pinned to a version where the vendor allows it. */
+const vendorHostedTargetConfigSchema = object({
+	kind: literal("vendor_hosted"),
+	vendor: string().min(1).max(64),
+	protocol: literal("a2a"),
+	url: credentialFreeUrl,
+	headers: secretReferenceHeaders.optional(),
+	version: string().min(1).max(64).optional()
+});
+/** One member per target kind; secrets are references only. */
+const targetConfigSchema = discriminatedUnion("kind", [
+	runtypeSurfaceTargetConfigSchema,
+	runtypeCapabilityTargetConfigSchema,
+	externalAgentTargetConfigSchema,
+	externalMcpTargetConfigSchema,
+	externalApiTargetConfigSchema,
+	websiteTargetConfigSchema,
+	cliTargetConfigSchema,
+	skillTargetConfigSchema,
+	sandboxCandidateTargetConfigSchema,
+	vendorHostedTargetConfigSchema
+]);
+/** Whether the operator host records a target's tool answers for replay, and for how long it keeps them (D1). */
+const targetRecordingSchema = object({
+	enabled: boolean(),
+	retentionDays: number().int().min(1).max(365)
+});
+const exchangeRecordingModeSchema = _enum([
+	"off",
+	"shape-only",
+	"full"
+]);
+/** One target's recording policy as admission froze it into the run plan. */
+const frozenTargetRecordingSchema = object({
+	mode: exchangeRecordingModeSchema,
+	retentionDays: number().int().min(0).max(365)
+});
+/** A saved target, as the API returns it. */
+const simulationTargetSchema = object({
+	id: entityId$1,
+	name: string().min(1).max(255),
+	kind: targetKindSchema,
+	config: targetConfigSchema,
+	productId: entityId$1.nullable(),
+	surfaceId: entityId$1.nullable(),
+	flowId: entityId$1.nullable(),
+	agentId: entityId$1.nullable(),
+	originHost: string().nullable(),
+	verificationStatus: targetVerificationStatusSchema,
+	/** The ownership challenge once one is started; absent on a target built in memory. */
+	verification: simulationTargetVerificationSchema.nullable().optional(),
+	/** Additive: absent on targets saved before recording existed, which record nothing. */
+	recording: targetRecordingSchema.optional(),
+	createdByUserId: entityId$1.nullable(),
+	createdAt: isoDate,
+	updatedAt: isoDate
+});
+const variantRoleSchema = _enum([
+	"baseline",
+	"candidate",
+	"comparison"
+]);
+const variantSourceSchema = _enum([
+	"manual",
+	"grid",
+	"optimizer"
+]);
+/** A capability id, or `*` for every capability the variant reaches. */
+const capabilityRef = union([literal("*"), entityId$1]);
+const modelVariantChangeSchema = object({
+	kind: literal("model"),
+	capabilityId: capabilityRef,
+	stepId: string().min(1).max(255).optional(),
+	model: string().min(1).max(255)
+});
+const samplingVariantChangeSchema = object({
+	kind: literal("sampling"),
+	capabilityId: capabilityRef,
+	temperature: number().min(0).max(2).optional(),
+	maxTokens: number().int().positive().max(1e6).optional(),
+	reasoning: union([boolean(), record(string(), unknown())]).optional()
+});
+const instructionsVariantChangeSchema = object({
+	kind: literal("instructions"),
+	capabilityId: entityId$1,
+	mode: _enum(["replace", "append"]),
+	text: string().min(1).max(2e4)
+});
+const loopVariantChangeSchema = object({
+	kind: literal("loop"),
+	capabilityId: entityId$1,
+	maxTurns: number().int().positive().max(200).optional(),
+	maxCost: number().positive().optional(),
+	enableReflection: boolean().optional(),
+	toolSearch: boolean().optional()
+});
+const toolsVariantChangeSchema = object({
+	kind: literal("tools"),
+	capabilityId: entityId$1,
+	add: array(entityId$1).max(50).optional(),
+	remove: array(entityId$1).max(50).optional()
+});
+const flowStepsVariantChangeSchema = object({
+	kind: literal("flowSteps"),
+	capabilityId: entityId$1,
+	ops: array(jsonPatchOperationSchema).min(1).max(100)
+});
+const surfaceRoutingVariantChangeSchema = object({
+	kind: literal("surfaceRouting"),
+	surfaceId: entityId$1,
+	routerModel: string().min(1).max(255).optional(),
+	routerPrompt: string().max(2e4).optional(),
+	enabledCapabilityIds: array(entityId$1).max(100).optional(),
+	orchestratorCapabilityId: entityId$1.nullable().optional()
+});
+const frameworkVariantChangeSchema = object({
+	kind: literal("framework"),
+	capabilityId: entityId$1,
+	agentId: entityId$1
+});
+const clientModelVariantChangeSchema = object({
+	kind: literal("clientModel"),
+	model: string().min(1).max(255)
+});
+/** A JSON Schema property as a tool lists it; open beyond the fields an overlay edits. */
+const toolSchemaPropertySchema = object({
+	type: string().optional(),
+	description: string().optional(),
+	enum: array(union([
+		string(),
+		number(),
+		boolean()
+	])).optional(),
+	default: unknown().optional(),
+	examples: array(unknown()).optional()
+}).passthrough();
+const errorMatchSchema = union([object({ code: string().min(1).max(128) }), object({ pattern: string().min(1).max(512) })]);
+/** One deterministic step of a response mapping; paths are dot paths into the tool's answer. */
+const shapeOpSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("pick"),
+		paths: array(string().min(1)).min(1).max(64)
+	}),
+	object({
+		kind: literal("rename"),
+		from: string().min(1),
+		to: string().min(1)
+	}),
+	object({
+		kind: literal("flatten"),
+		path: string().min(1)
+	}),
+	object({
+		kind: literal("drop"),
+		paths: array(string().min(1)).min(1).max(64)
+	}),
+	object({
+		kind: literal("truncate"),
+		path: string().min(1),
+		maxItems: number().int().positive().max(1e4).optional(),
+		maxChars: number().int().positive().max(1e6).optional()
+	}),
+	object({
+		kind: literal("count"),
+		path: string().min(1),
+		as: string().min(1)
+	}),
+	object({
+		kind: literal("map"),
+		path: string().min(1),
+		pick: array(string().min(1)).min(1).max(64).optional(),
+		rename: record(string(), string()).optional()
+	})
+]);
+/** A read a shape script needs, answered from a recording (or a live read-only call) before the script runs. */
+const shapeLookupSchema = object({
+	as: string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(64),
+	tool: string().min(1),
+	arguments: record(string(), unknown())
+});
+/**
+* A response mapping: a list of shape steps, or a script run in a sandboxed Dynamic Worker (D4). A script is a
+* transform body (`return ...`) over `result`, `args`, `profile` and `lookups`, each lookup keyed by its `as`.
+*/
+const shapeTransformSchema = discriminatedUnion("kind", [object({
+	kind: literal("ops"),
+	ops: array(shapeOpSchema).min(1).max(64)
+}), object({
+	kind: literal("script"),
+	code: string().min(1).max(32768),
+	lookups: array(shapeLookupSchema).max(4).optional()
+})]);
+/** The designed error an `error_design` operation returns; text fields are templates over the real error. */
+const errorEnvelopeSchema = object({
+	class: _enum([
+		"transient",
+		"permanent",
+		"userInput",
+		"notFound"
+	]),
+	message: string().min(1).max(2e3),
+	reason: string().max(2e3).optional(),
+	recoverySteps: array(string().min(1).max(500)).max(8).default([]),
+	retryAfterSeconds: number().int().nonnegative().optional(),
+	suggestionsFrom: object({
+		tool: string().min(1),
+		arguments: record(string(), unknown())
+	}).optional()
+});
+/** The definition an `add_tool` operation lists, as `tools/list` would show it. */
+const addToolDefinitionSchema = object({
+	name: string().min(1).max(128),
+	description: string().max(4e3),
+	inputSchema: record(string(), unknown()),
+	outputSchema: record(string(), unknown()).optional(),
+	annotations: record(string(), unknown()).optional()
+});
+/** How an added tool answers: other tools through the ladder, or the mini-agent grounded on recordings (D4, D5). */
+const addToolImplementationSchema = discriminatedUnion("kind", [object({
+	kind: literal("composite"),
+	steps: array(object({
+		tool: string().min(1),
+		arguments: record(string(), unknown())
+	})).min(1).max(8),
+	shape: shapeTransformSchema.optional()
+}), object({
+	kind: literal("synthesized"),
+	grounding: array(string().min(1)).min(1).max(8),
+	worldFacts: array(string().min(1).max(2e3)).max(32).optional()
+})]);
+/** One operation of a `tool_surface` overlay ("Agent experience", "Tool-surface overlays"). */
+const toolSurfaceOpSchema = discriminatedUnion("op", [
+	object({
+		op: literal("rename"),
+		tool: string().min(1),
+		name: string().min(1).max(128)
+	}),
+	object({
+		op: literal("describe"),
+		tool: string().min(1),
+		description: string().max(4e3)
+	}),
+	object({
+		op: literal("schema"),
+		tool: string().min(1),
+		properties: record(string(), toolSchemaPropertySchema).optional(),
+		required: array(string()).optional()
+	}),
+	object({
+		op: literal("hide"),
+		tool: string().min(1)
+	}),
+	object({
+		op: literal("preset"),
+		tool: string().min(1),
+		name: string().min(1).max(128),
+		description: string().max(4e3).optional(),
+		fixed: record(string(), unknown())
+	}),
+	object({
+		op: literal("error_rewrite"),
+		tool: string().min(1),
+		match: errorMatchSchema,
+		message: string().min(1).max(2e3)
+	}),
+	object({
+		op: literal("shape"),
+		tool: string().min(1),
+		transform: shapeTransformSchema
+	}),
+	object({
+		op: literal("paginate"),
+		tool: string().min(1),
+		style: literal("cursor"),
+		limitField: string().min(1),
+		itemsPath: string().min(1),
+		defaultLimit: number().int().positive().max(1e3)
+	}),
+	object({
+		op: literal("error_design"),
+		tool: string().min(1),
+		match: errorMatchSchema,
+		envelope: errorEnvelopeSchema
+	}),
+	object({
+		op: literal("accept_identifier"),
+		tool: string().min(1),
+		field: string().min(1),
+		resolveVia: object({
+			tool: string().min(1),
+			queryField: string().min(1),
+			idField: string().min(1),
+			labelFields: array(string().min(1)).min(1).max(8)
+		}),
+		thresholds: object({
+			single: number().min(0).max(1).default(.9),
+			candidate: number().min(0).max(1).default(.5),
+			maxOptions: number().int().positive().max(20).default(5)
+		}).default({
+			single: .9,
+			candidate: .5,
+			maxOptions: 5
+		})
+	}),
+	object({
+		op: literal("add_tool"),
+		tool: string().min(1),
+		definition: addToolDefinitionSchema,
+		implementation: addToolImplementationSchema
+	}).refine((value) => value.tool === value.definition.name, {
+		message: "tool must equal definition.name",
+		path: ["tool"]
+	})
+]);
+const TOOL_SURFACE_OPS = [
+	"rename",
+	"describe",
+	"schema",
+	"hide",
+	"preset",
+	"error_rewrite",
+	"shape",
+	"paginate",
+	"error_design",
+	"accept_identifier",
+	"add_tool"
+];
+/** Operations that change what a tool answers, not only what it lists; the rest are request-side (D4). */
+const FUTURE_STATE_OPS = [
+	"shape",
+	"paginate",
+	"error_design",
+	"accept_identifier",
+	"add_tool"
+];
+new Set(FUTURE_STATE_OPS);
+/** Where a proposed overlay came from ("Overlay proposals"): never sent to a target, kept so a person can check it. */
+const toolSurfaceProvenanceSchema = object({
+	proposer: _enum(["rules", "model"]),
+	runId: entityId$1,
+	episodeIds: array(entityId$1).max(50),
+	scenarioIds: array(entityId$1).max(50),
+	rows: array(object({
+		table: _enum([
+			"tools",
+			"errors",
+			"confusion",
+			"never_discovered"
+		]),
+		tool: string().max(128),
+		detail: string().max(500)
+	})).max(50),
+	reasons: array(object({
+		tool: string().max(128),
+		op: _enum(TOOL_SURFACE_OPS),
+		text: string().max(1e3),
+		/** The tool-design checklist row the operation satisfies (D7). */
+		checklistRow: number().int().positive().optional(),
+		/** The trace signal that motivated the operation, such as "high retry rate". */
+		signal: string().max(200).optional()
+	})).max(50),
+	/** The touched tools as the server listed them during the run, which the diff and the patch read. */
+	tools: array(object({
+		name: string().max(128),
+		description: string().max(4e3),
+		inputSchema: record(string(), unknown())
+	})).max(50),
+	/** The server's error text each rewrite replaces, by `tool:match`. */
+	errors: record(string().max(300), string().max(500)).optional()
+});
+const toolSurfaceVariantChangeSchema = object({
+	kind: literal("tool_surface"),
+	capabilityId: entityId$1.optional(),
+	targetId: entityId$1.optional(),
+	/** A short name for the overlay, such as "Clearer descriptions and errors". */
+	label: string().min(1).max(120).optional(),
+	ops: array(toolSurfaceOpSchema).min(1).max(200),
+	provenance: toolSurfaceProvenanceSchema.optional()
+});
+const helpTextVariantChangeSchema = object({
+	kind: literal("help_text"),
+	targetId: entityId$1.optional(),
+	commandPath: array(string().min(1).max(64)).max(8),
+	helpText: string().min(1).max(2e4)
+});
+const aliasVariantChangeSchema = object({
+	kind: literal("alias"),
+	targetId: entityId$1.optional(),
+	commandPath: array(string().min(1).max(64)).min(1).max(8),
+	realCommandPath: array(string().min(1).max(64)).min(1).max(8),
+	fixedArgs: array(string().max(256)).max(32).optional()
+});
+/** Every change kind a variant may carry (2.1); the last three are overlays ("Agent experience"). */
+const variantChangeSchema = discriminatedUnion("kind", [
+	modelVariantChangeSchema,
+	samplingVariantChangeSchema,
+	instructionsVariantChangeSchema,
+	loopVariantChangeSchema,
+	toolsVariantChangeSchema,
+	flowStepsVariantChangeSchema,
+	surfaceRoutingVariantChangeSchema,
+	frameworkVariantChangeSchema,
+	clientModelVariantChangeSchema,
+	toolSurfaceVariantChangeSchema,
+	helpTextVariantChangeSchema,
+	aliasVariantChangeSchema
+]);
+const overlayKindSchema = _enum([
+	"proxy",
+	"materialized",
+	"shim"
+]);
+const toolPolicySchema = _enum([
+	"live",
+	"recorded",
+	"simulated"
+]);
+/** A policy per tool name, with `*` for every tool not named. */
+const variantToolPolicySchema = record(string().min(1), toolPolicySchema);
+/** Replay matching: argument keys that may differ between a call and a recording without changing the answer. */
+const variantReplaySchema = object({
+	answerNeutralKeys: array(string().min(1)).max(32).default([]),
+	/** False turns rung 6 off for a `simulated` design: a call no recording answers gets the stub, never a model call. */
+	synthesize: boolean().optional()
+});
+/** A saved variant, as the API returns it. */
+const simulationVariantSchema = object({
+	id: entityId$1,
+	simulationId: entityId$1,
+	runId: entityId$1.nullable(),
+	key: simulationVariantKeySchema,
+	label: string().min(1).max(255),
+	role: variantRoleSchema,
+	targetId: entityId$1,
+	changes: array(variantChangeSchema),
+	changesHash: string(),
+	clientModel: string().nullable(),
+	source: variantSourceSchema,
+	parentVariantId: entityId$1.nullable(),
+	/** Where the variant's target code runs (6.1). */
+	placement: variantPlacementSchema,
+	fidelity: variantFidelitySchema,
+	/** The data the variant runs against; null runs in the target kind's world (`TARGET_KIND_WORLDS`). */
+	data: variantDataSchema.nullable(),
+	/** Additive: absent means every tool is `live`. */
+	toolPolicy: variantToolPolicySchema.optional(),
+	replay: variantReplaySchema.optional(),
+	archivedAt: isoDate.nullable(),
+	createdAt: isoDate
+});
+const simulationDefinitionSourceSchema = _enum([
+	"manual",
+	"generated",
+	"from_conversation",
+	"agent",
+	"authored"
+]);
+/** A reference to what a generated user or task was drawn from. */
+const simulationSourceRefSchema = object({
+	kind: _enum([
+		"spec",
+		"capability",
+		"surface",
+		"conversation",
+		"execution",
+		"tools_list",
+		"help",
+		"homepage"
+	]),
+	id: string().max(255).optional(),
+	label: string().max(255).optional()
+});
+/** A simulated user's preset: an eval-case persona, or `adversarial_submitter` (6.12), which only Simulations has. */
+const SIMULATED_USER_PRESETS = [
+	EVAL_CASE_PERSONAS[0].id,
+	...EVAL_CASE_PERSONAS.slice(1).map((persona) => persona.id),
+	"adversarial_submitter"
+];
+const simulatedUserPresetSchema = _enum(SIMULATED_USER_PRESETS);
+const simulatedUserRelationshipSchema = _enum(SIM_USER_ROLES);
+/** What a simulated user carries about themselves (email, groups, department); an eval case calls it `principal`. */
+const simulatedUserAttributesSchema = simPrincipalSchema;
+/**
+* A simulated user's own sign-in on an external MCP target: a saved MCP connection of the organization, used in place
+* of the target's connection for this user's episodes, and the grants that member is expected to hold.
+*/
+const simulatedUserIdentitySchema = object({
+	savedServerName: string().trim().min(1).max(128),
+	expectedGrants: array(string().trim().min(1).max(64)).max(20)
+});
+/** What a person authors about a simulated user. */
+const simulatedUserDefinitionSchema = object({
+	slug: simulationSlugSchema,
+	name: string().min(1).max(255),
+	profile: string().max(MAX_PROFILE_CHARS),
+	preset: simulatedUserPresetSchema.nullable().optional(),
+	relationship: simulatedUserRelationshipSchema.nullable().optional(),
+	traits: array(shortText(200)).max(20).optional(),
+	knowledge: record(string().min(1).max(128), shortText(2e3)).optional(),
+	attributes: simulatedUserAttributesSchema.nullable().optional(),
+	identity: simulatedUserIdentitySchema.nullable().optional(),
+	productId: entityId$1.nullable().optional(),
+	source: simulationDefinitionSourceSchema.optional(),
+	sourceRefs: array(simulationSourceRefSchema).max(20).optional()
+});
+/** A saved simulated user. Never call it a persona: Persona is the chat widget. */
+const simulatedUserSchema = object({
+	id: entityId$1,
+	slug: simulationSlugSchema,
+	name: string(),
+	profile: string(),
+	preset: string().nullable(),
+	relationship: simulatedUserRelationshipSchema.nullable(),
+	traits: array(string()),
+	knowledge: record(string(), string()),
+	attributes: simulatedUserAttributesSchema.nullable(),
+	identity: simulatedUserIdentitySchema.nullable(),
+	productId: entityId$1.nullable(),
+	source: simulationDefinitionSourceSchema,
+	sourceRefs: array(simulationSourceRefSchema),
+	createdByUserId: entityId$1.nullable(),
+	createdAt: isoDate,
+	updatedAt: isoDate
+});
+const episodeShapeSchema = _enum([
+	"conversation",
+	"tool_use",
+	"any"
+]);
+/** A task's expected-tool hint; a hint always wins over the tool-choice judge. */
+const expectedToolsSchema = object({
+	tools: array(string().min(1).max(128)).min(1).max(50),
+	ordered: boolean().optional(),
+	avoid: array(string().min(1).max(128)).max(50).optional()
+});
+/**
+* The injection grader (6.12, read side): a task that carries it fails an episode whose agent calls a tool in
+* `expectedTools.avoid`, or puts the episode's canary in a tool call's arguments or a reply. Simulations only.
+*/
+const injectionGraderSchema = object({
+	kind: literal("injection"),
+	/** Text added to tool results the client agent reads, with `{{episode.canary}}` filled in; absent plants none. */
+	plant: object({
+		/** The tool whose results carry it; absent means every read-only tool. */
+		tool: string().min(1).max(128).optional(),
+		text: string().min(1).max(2e3)
+	}).optional(),
+	/** Tools whose arguments may carry the planted text, such as a submission tool; a canary there is no leak. */
+	passThroughTools: array(string().min(1).max(128)).max(20).optional()
+});
+const injectionCanaryPlaceSchema = _enum(["tool_args", "reply"]);
+/** What an injection grader found on one episode; names only, so it survives `metrics` retention. */
+const injectionFindingsSchema = object({
+	canaryIn: array(injectionCanaryPlaceSchema),
+	avoidedTools: array(string())
+});
+/** The injection grader as a score row stores it: its config, with what it found stamped at grade time. */
+const injectionGraderSnapshotSchema = injectionGraderSchema.extend({ findings: injectionFindingsSchema.optional() });
+/** A task's grader: an eval grader, or a Simulations-only injection, side-effect or tool-process grader. */
+const simulationTaskGraderSchema = union([
+	graderConfigSchema,
+	injectionGraderSchema,
+	sideEffectGraderSchema,
+	toolProcessGraderSchema
+]);
+/** A grader as an episode's score row stores it. */
+const simulationGraderSnapshotSchema = union([
+	evalGraderSnapshotSchema,
+	injectionGraderSnapshotSchema,
+	sideEffectGraderSnapshotSchema,
+	toolProcessGraderSchema
+]);
+/** What a person authors about a task. */
+const simulationTaskDefinitionSchema = object({
+	slug: simulationSlugSchema,
+	name: string().min(1).max(255),
+	goal: string().min(1).max(MAX_GOAL_CHARS),
+	openingMessage: string().max(MAX_OPENING_MESSAGE_CHARS).nullable().optional(),
+	successSignal: string().max(MAX_SUCCESS_SIGNAL_CHARS).nullable().optional(),
+	knowledge: record(string().min(1).max(128), shortText(2e3)).optional(),
+	maxTurns: number().int().min(1).max(20).nullable().optional(),
+	graders: array(simulationTaskGraderSchema).max(20).optional(),
+	category: string().max(64).nullable().optional(),
+	tags: array(string().min(1).max(64)).max(20).optional(),
+	episodeShape: episodeShapeSchema.optional(),
+	expectedTools: expectedToolsSchema.nullable().optional(),
+	productId: entityId$1.nullable().optional(),
+	source: simulationDefinitionSourceSchema.optional(),
+	sourceRefs: array(simulationSourceRefSchema).max(20).optional()
+});
+/** A saved task. */
+const simulationTaskSchema = object({
+	id: entityId$1,
+	slug: simulationSlugSchema,
+	name: string(),
+	goal: string(),
+	openingMessage: string().nullable(),
+	successSignal: string().nullable(),
+	knowledge: record(string(), string()),
+	maxTurns: number().int().nullable(),
+	graders: array(simulationTaskGraderSchema),
+	category: string().nullable(),
+	tags: array(string()),
+	episodeShape: episodeShapeSchema,
+	expectedTools: expectedToolsSchema.nullable(),
+	productId: entityId$1.nullable(),
+	source: simulationDefinitionSourceSchema,
+	sourceRefs: array(simulationSourceRefSchema),
+	createdByUserId: entityId$1.nullable(),
+	createdAt: isoDate,
+	updatedAt: isoDate
+});
+/** One simulated user paired with one task, inside one simulation. */
+const simulationScenarioSchema = object({
+	id: entityId$1,
+	simulationId: entityId$1,
+	simulatedUserId: entityId$1,
+	taskId: entityId$1,
+	weight: number().int().min(1).max(100),
+	enabled: boolean()
+});
+/** Who acknowledged that a run may call tools with real side effects (0.4). */
+const liveToolsAcknowledgementSchema = object({
+	tools: array(string().min(1).max(255)).max(200),
+	actorUserId: entityId$1,
+	at: isoDate
+});
+const SEARCH_STRATEGIES = [
+	"none",
+	"grid",
+	"successive_halving"
+];
+const SIMULATION_OBJECTIVES = ["success_then_cost", "success_then_latency"];
+const BASELINE_SOURCES = ["published", "draft"];
+const simulationDataRetentionSchema = _enum(["transcripts", "metrics"]);
+/** A simulation's settings as stored; every field is optional and `resolveSimulationSettings` fills the rest. */
+const simulationSettingsSchema = object({
+	trials: number().int().min(1).max(10).optional(),
+	maxTurns: number().int().min(1).max(20).optional(),
+	simulatedUserModel: string().min(1).max(255).optional(),
+	judge: object({ model: string().min(1).max(255).optional() }).optional(),
+	clientModel: string().min(1).max(255).optional(),
+	/** Above `MAX_CONCURRENCY` only a run with no live upstream accepts it; admission refuses it for any other. */
+	concurrency: number().int().min(1).max(24).optional(),
+	budget: object({
+		maxSpendUsd: number().positive().max(1e4).optional(),
+		maxEpisodes: number().int().positive().max(MAX_EPISODES_PER_RUN).optional()
+	}).optional(),
+	search: object({
+		strategy: _enum(SEARCH_STRATEGIES),
+		eta: number().int().min(2).max(4).optional(),
+		maxRounds: number().int().min(1).max(3).optional()
+	}).optional(),
+	objective: _enum(SIMULATION_OBJECTIVES).optional(),
+	baselineSource: _enum(BASELINE_SOURCES).optional(),
+	liveToolsAcknowledgement: liveToolsAcknowledgementSchema.nullable().optional(),
+	regression: object({
+		passRateDropPoints: number().min(0).max(100).optional(),
+		costPerSuccessRisePct: number().min(0).max(1e3).optional(),
+		latencyRisePct: number().min(0).max(1e3).optional()
+	}).optional(),
+	preset: simulationPresetSchema.nullable().optional(),
+	dataRetention: simulationDataRetentionSchema.optional(),
+	transcriptRetentionDays: number().int().min(1).max(30).optional(),
+	/** The largest share of synthesized tool answers a future design may carry and still be "Recommended" (D6). */
+	synthesizedShareThreshold: number().min(0).max(1).optional()
+});
+/** A saved simulation. Every simulation belongs to a product (the product rule). */
+const simulationSchema = object({
+	id: entityId$1,
+	productId: entityId$1,
+	slug: simulationSlugSchema,
+	name: string(),
+	description: string().nullable(),
+	mode: simulationModeSchema,
+	settings: simulationSettingsSchema,
+	baselineVariantId: entityId$1.nullable(),
+	enabled: boolean(),
+	createdByUserId: entityId$1.nullable(),
+	createdAt: isoDate,
+	updatedAt: isoDate
+});
+const simulationRunStatusSchema = _enum([
+	"queued",
+	"running",
+	"completed",
+	"failed",
+	"cancelled",
+	"budget_exhausted"
+]);
+const simulationRunExecutorSchema = _enum(["durable_object", "inline"]);
+const simulationRunTriggerSchema = _enum([
+	"manual",
+	"schedule",
+	"api",
+	"cli",
+	"mcp",
+	"optimizer"
+]);
+const simulationEpisodeStatusSchema = _enum([
+	"queued",
+	"running",
+	"completed",
+	"failed",
+	"skipped",
+	"cancelled"
+]);
+const episodeLeftOutReasonSchema = _enum([
+	"simulated_user_broke",
+	"spend_cap",
+	"engine_error"
+]);
+_enum(["didnt_run"]);
+const isolationLevelSchema = _enum([
+	"guaranteed",
+	"verified",
+	"unverifiable",
+	"live_tools"
+]);
+const layerKindSchema = _enum([
+	"surface",
+	"capability",
+	"implementation",
+	"tool",
+	"model",
+	"framework",
+	"clientModel"
+]);
+/**
+* A tool call's outcome class (6.11): `ok`, `denied` (a permission refusal), `not_found` (an unknown-tool refusal),
+* `invalid` (its arguments were refused) or `failed` (any other error, transport included).
+*/
+const TOOL_CALL_OUTCOMES = [
+	"ok",
+	"denied",
+	"not_found",
+	"invalid",
+	"failed"
+];
+const servedBySchema = _enum([
+	"live",
+	"recorded",
+	"transformed",
+	"composite",
+	"synthesized",
+	"stub",
+	"rejected",
+	"fault"
+]);
+/** Calls per ladder rung; a rung with no calls is absent. */
+const servedByCountsSchema = partialRecord(servedBySchema, number().int().nonnegative());
+/** One tool call as the tool layer records it ("Agent experience", "Per-call facts in the tool layer"). */
+const toolCallFactsSchema = object({
+	callId: string().optional(),
+	callIndex: number().int().nonnegative(),
+	shownName: string(),
+	serverTool: string().nullable(),
+	argumentErrors: array(object({
+		path: string(),
+		code: string()
+	})),
+	errorKey: string().nullable(),
+	errorOrigin: _enum([
+		"server",
+		"overlay",
+		"transport"
+	]).nullable(),
+	retryOf: number().int().nonnegative().nullable(),
+	intendedTool: string().nullable(),
+	intendedSource: _enum(["hint", "judge"]).nullable(),
+	durationMs: number().nonnegative().nullable(),
+	/** Answered with a fixed reply and never sent: a write tool on a run without the live-tools acknowledgement. */
+	stubbed: boolean().optional(),
+	/** The server annotated the tool `readOnlyHint: true`; the expected-tool rule never calls such a call wrong. */
+	readOnly: boolean().optional(),
+	/** The normalized error text behind `errorKey`, at most 200 characters. */
+	errorText: string().max(200).nullable().optional(),
+	/** The JSON-RPC error code or HTTP status the failure carried, when it carried one. */
+	errorCode: string().max(64).nullable().optional(),
+	/** A later call in the episode succeeded on this tool or on the intended one; set by tool-choice grading. */
+	recoveredLater: boolean().optional(),
+	/** How the call ended, classified while its error text was at hand, so `metrics` retention keeps it. */
+	outcome: _enum(TOOL_CALL_OUTCOMES).optional(),
+	/** The target reported the call without saying whether it failed; it is neither a success nor a failure. */
+	resultUnknown: boolean().optional(),
+	/** The ladder rung that answered; absent on calls recorded before the ladder. */
+	servedBy: servedBySchema.optional(),
+	/** The recorded exchange this call replayed, or the row it wrote. */
+	exchangeId: string().nullable().optional(),
+	/** The answer came from a recording rather than a fresh upstream call. */
+	replayed: boolean().optional(),
+	/** A future-state operation failed on a live write's answer, so the server's answer was returned unshaped. */
+	designFailed: boolean().optional(),
+	/** The future-state operation that wrote this call's error envelope; absent when the error is the upstream's own. */
+	designedBy: _enum(FUTURE_STATE_OPS).optional(),
+	/** The synthesizer's answer failed its contract twice, so the call was answered with a stub (D5). */
+	synthesisFailed: boolean().optional(),
+	/** A recorded read answer that shows the values of the episode's own earlier accepted recorded writes (D3). */
+	writeOverlay: boolean().optional(),
+	/** No rung could answer the call under its policy, so it got a stub; a policy stub of a write never sets it. */
+	unanswered: boolean().optional(),
+	/** Why the synthesizer answered as it did, on a synthesized call; the review panel and the judge citation read it. */
+	rationale: string().max(500).optional(),
+	/** The frozen row of the suggestions the mini-agent filled into this call's designed error (D4); `exchangeId` stays the answer's. */
+	suggestionsExchangeId: string().nullable().optional()
+});
+/** What one target turn passed through, per layer; `toolCalls` is empty for targets with no per-call view. */
+const turnLayerFactsSchema = object({
+	harnessCapture: harnessCaptureSummarySchema.optional(),
+	reportedUsage: reportedUsageSchema.optional(),
+	turnIndex: number().int().nonnegative(),
+	surface: object({
+		surfaceId: string().nullable(),
+		surfaceType: string().nullable(),
+		routedCapabilityId: string().nullable(),
+		routerModel: string().nullable(),
+		routingMs: number().nullable()
+	}).nullable(),
+	capabilityId: string().nullable(),
+	implementation: object({
+		kind: _enum([
+			"agent",
+			"flow",
+			"external"
+		]),
+		id: string().nullable(),
+		/** The target's display name, for an `external` id the product cannot name, such as a sandbox candidate's. */
+		name: string().optional()
+	}).nullable(),
+	tools: array(object({
+		name: string(),
+		calls: number().int(),
+		errors: number().int()
+	})),
+	models: array(object({
+		model: string(),
+		calls: number().int(),
+		inputTokens: number().int(),
+		outputTokens: number().int(),
+		costUsd: number().nullable()
+	})),
+	framework: string().nullable(),
+	clientModel: string().nullable(),
+	latencyMs: number().nonnegative(),
+	errored: boolean(),
+	toolCalls: array(toolCallFactsSchema),
+	accessEvidence: simulationAccessEvidenceSchema.optional(),
+	/** Calls per ladder rung in this turn; absent on turns recorded before the ladder. */
+	servedBy: servedByCountsSchema.optional(),
+	/** The synthesizer's model calls this turn; overhead like the simulated user's, never the agent's own tokens. */
+	synthesis: object({
+		calls: number().int().nonnegative(),
+		inputTokens: number().int().nonnegative(),
+		outputTokens: number().int().nonnegative(),
+		costUsd: number().nonnegative()
+	}).optional()
+});
+const egressRefusalReasonSchema = _enum([
+	"internal_range",
+	"not_allowed",
+	"egress_off",
+	"misaddressed"
+]);
+/**
+* A sandbox candidate's refused egress over one episode. Only `egress_proxy` is the proxy's own record; from
+* `candidate_output` a refusal the candidate swallowed is missing, and `unread` means no record could be read.
+*/
+const episodeEgressSchema = object({
+	source: _enum([
+		"egress_proxy",
+		"candidate_output",
+		"unread"
+	]),
+	/** One row per host and reason; `reason` is null and `count` 1 when only the candidate's output named the host. */
+	refusals: array(object({
+		host: string(),
+		reason: egressRefusalReasonSchema.nullable(),
+		count: number()
+	})),
+	/** Refusals the proxy counted but did not keep, past its per-container limit. */
+	overflow: number()
+});
+/** One episode's measurements; target and client-agent cost are what a success costs, the rest is overhead. */
+const episodeMetricsSchema = object({
+	selfReportedCost: selfReportedCostSchema.optional(),
+	/** A checkpointed target turn could not be safely replayed; retained without error text. */
+	interruptedMidTurn: literal(true).optional(),
+	/** The episode ended `agent_error` because the client model's provider stalled after its retries; unscored. */
+	clientModelStall: literal(true).optional(),
+	/**
+	* The read a `recording_miss` episode stopped on, as the server tool and arguments a recording must hold for a
+	* repair to replay it. `arguments` is absent under the `metrics` data policy.
+	*/
+	recordingMiss: object({
+		tool: string(),
+		arguments: record(string(), unknown()).optional()
+	}).optional(),
+	/** Grading could not produce an episode score; retained without grader error text. */
+	scoringFailed: literal(true).optional(),
+	/** Scoring failed because no goal-judge attempt returned a valid verdict: the judge, not the episode, gave no verdict. */
+	goalJudgeModelError: literal(true).optional(),
+	turns: number().int().nonnegative(),
+	targetCostUsd: number().nullable(),
+	clientAgentCostUsd: number().nullable(),
+	simulatorCostUsd: number(),
+	/** The synthesizer's share of `simulatorCostUsd`; absent when no answer was synthesized. */
+	synthesizerCostUsd: number().nonnegative().optional(),
+	judgeCostUsd: number(),
+	inputTokens: number().int().nonnegative(),
+	outputTokens: number().int().nonnegative(),
+	totalLatencyMs: number().nonnegative(),
+	medianTurnLatencyMs: number().nullable(),
+	toolCalls: number().int().nonnegative(),
+	toolErrors: number().int().nonnegative(),
+	errors: number().int().nonnegative(),
+	unpricedModels: array(string()),
+	/** Additive: present only for a sandbox candidate whose container started. Evidence, never scored. */
+	egress: episodeEgressSchema.optional(),
+	/** False when an engine failure measured nothing: every number here is a placeholder, only `egress` holds. */
+	measured: literal(false).optional()
+});
+/** One row of a report layer table: one key under one variant. */
+const layerStatSchema = object({
+	layer: layerKindSchema,
+	key: string(),
+	/** A display name for `key` the report knows, such as a sandbox candidate target's; absent otherwise. */
+	label: string().optional(),
+	variantId: string(),
+	episodes: number().int().nonnegative(),
+	turns: number().int().nonnegative(),
+	calls: number().int().nonnegative(),
+	errors: number().int().nonnegative(),
+	passedEpisodes: number().int().nonnegative(),
+	validEpisodes: number().int().nonnegative(),
+	costUsd: number().nullable(),
+	p50LatencyMs: number().nullable()
+});
+/** The dry-run estimate (`estimateRun`); admission compares `costUsd.expected` with the cap. */
+const runEstimateSchema = object({
+	episodes: number().int().nonnegative(),
+	expectedTurnsPerEpisode: number().nonnegative(),
+	costUsd: object({
+		low: number(),
+		expected: number(),
+		high: number()
+	}),
+	breakdown: object({
+		targetUsd: number(),
+		simulatorUsd: number(),
+		judgeUsd: number(),
+		clientAgentUsd: number(),
+		/** The mini-agent's calls for tools a `simulated` design answers without a recording (D5); absent with none. */
+		synthesizerUsd: number().optional()
+	}),
+	basis: _enum([
+		"history",
+		"catalog",
+		"mixed"
+	]),
+	/** Why a `catalog` estimate read no run costs: too few priced runs yet, or every variant changes what users reach. */
+	catalogReason: _enum(["no_history", "changed"]).optional(),
+	unpricedModels: array(string()),
+	maxSpendUsd: number(),
+	overBudget: boolean()
+});
+/** One episode an inline run has started and not finished, with the agent turns it has completed so far. */
+const simulationActiveEpisodeSchema = object({
+	episodeId: string(),
+	variantId: string(),
+	variantKey: string(),
+	scenarioId: string(),
+	trial: number().int().nonnegative(),
+	turnsCompleted: number().int().nonnegative()
+});
+/** A saved run with its counters. */
+const simulationRunSchema = object({
+	id: entityId$1,
+	simulationId: entityId$1,
+	trigger: simulationRunTriggerSchema,
+	scheduleId: string().nullable(),
+	actorUserId: entityId$1.nullable(),
+	status: simulationRunStatusSchema,
+	/** `inline` runs only while a client calls `advanceSimulationRun`, as the dashboard does while the run is open. */
+	executor: simulationRunExecutorSchema,
+	planFingerprint: string().nullable(),
+	estimate: runEstimateSchema.nullable(),
+	maxSpendUsd: number(),
+	spentUsd: number(),
+	episodesPlanned: number().int(),
+	episodesCompleted: number().int(),
+	episodesFailed: number().int(),
+	episodesSkipped: number().int(),
+	round: number().int(),
+	startedAt: isoDate.nullable(),
+	completedAt: isoDate.nullable(),
+	error: string().nullable(),
+	createdAt: isoDate,
+	/**
+	* An active inline run's started, unfinished episodes, from its saved turn checkpoints; absent for a run the
+	* Durable Object executes and for a run that has finished.
+	*/
+	activeEpisodes: array(simulationActiveEpisodeSchema).optional()
+});
+/** A saved episode, without its transcript. */
+const simulationEpisodeSchema = object({
+	id: entityId$1,
+	runId: entityId$1,
+	variantId: entityId$1,
+	scenarioId: entityId$1.nullable(),
+	simulatedUserId: entityId$1.nullable(),
+	taskId: entityId$1.nullable(),
+	trialIndex: number().int().nonnegative(),
+	round: number().int().nonnegative(),
+	status: simulationEpisodeStatusSchema,
+	termination: simTerminationSchema.nullable(),
+	turns: number().int().nonnegative(),
+	passed: boolean().nullable(),
+	score: number().nullable(),
+	/** Why the episode is left out of pass rates; null when it counts. */
+	leftOutReason: episodeLeftOutReasonSchema.nullable(),
+	isolation: isolationLevelSchema.nullable(),
+	overlay: overlayKindSchema.nullable(),
+	/** ADR 0031 D8's placement, the variant's fidelity and the world it ran in; null on episodes written before them. */
+	ranOn: episodeRanOnSchema.nullable(),
+	fidelity: variantFidelitySchema.nullable(),
+	worldKey: string().nullable(),
+	metrics: episodeMetricsSchema.nullable(),
+	/** Calls per ladder rung over every turn (D3), for the served-by filter; absent when no call was stamped. */
+	servedBy: servedByCountsSchema.optional(),
+	executionIds: array(string()),
+	conversationId: string().nullable(),
+	startedAt: isoDate.nullable(),
+	completedAt: isoDate.nullable(),
+	error: string().nullable()
+});
+/** A redacted episode transcript with the simulated-user facts it was produced under. */
+const simulationEpisodeTranscriptSchema = object({
+	messages: array(simMessageSchema),
+	revealedKeys: record(string(), number().int()),
+	simulatedUserModel: string().nullable(),
+	simulatedUserPromptVersion: number().int().nullable(),
+	judgePromptVersion: number().int().nullable(),
+	expiresAt: isoDate.nullable()
+});
+/** One grader's outcome on one episode; mirrors `eval_case_scores`. */
+const simulationEpisodeScoreSchema = object({
+	id: entityId$1,
+	episodeId: entityId$1,
+	runId: entityId$1,
+	graderIndex: number().int().nonnegative(),
+	grader: simulationGraderSnapshotSchema,
+	passed: boolean(),
+	score: number().nullable(),
+	reasoning: string().nullable(),
+	verdict: judgeVerdictSchema.nullable(),
+	evidence: array(judgeEvidenceSchema).nullable(),
+	outputExcerpt: string().nullable(),
+	error: string().nullable(),
+	costUsd: number().nullable(),
+	durationMs: number().int().nullable(),
+	judgeModel: string().nullable(),
+	humanVerdict: _enum(["agree", "disagree"]).nullable()
+});
+const simulationVerdictSchema = _enum([
+	"better",
+	"worse",
+	"no_clear_difference"
+]);
+/** A point estimate with its 95% interval. */
+const estimateIntervalSchema = object({
+	estimate: number(),
+	low: number(),
+	high: number()
+});
+/** One count per termination, in `SIM_TERMINATIONS` order; a list, because the values are snake_case. */
+const terminationCountsSchema = array(object({
+	termination: simTerminationSchema,
+	count: number().int()
+}));
+/** One variant's row in the report's variant table. */
+const reportVariantSummarySchema = object({
+	selfReportedCost: selfReportedCostSchema.optional(),
+	variantId: string(),
+	key: string(),
+	label: string(),
+	role: variantRoleSchema,
+	clientModel: string().nullable(),
+	episodes: number().int(),
+	validEpisodes: number().int(),
+	passedEpisodes: number().int(),
+	simulatedUserBrokeEpisodes: number().int(),
+	targetUnavailableEpisodes: number().int().optional(),
+	clientLimitEpisodes: number().int().optional(),
+	/** Episodes that ended `recording_miss`: a `recorded` policy met a call with no recording. Unscored. */
+	recordingMissEpisodes: number().int().nonnegative().optional(),
+	/** Recorded read answers the read-your-writes overlay patched (`ToolCallFacts.writeOverlay`); absent when none. */
+	writeOverlayAnswers: number().int().nonnegative().optional(),
+	/** Episodes that ended `agent_error` on a client-model provider stall (`metrics.clientModelStall`). Unscored. */
+	clientModelStallEpisodes: number().int().nonnegative().optional(),
+	scoringFailedEpisodes: number().int().optional(),
+	/** Episodes that ended `spend_cap`: the variant's share of the run budget refused its model calls. Unscored. */
+	spendCapEpisodes: number().int().optional(),
+	/** Episodes that ended `engine_error`: the simulation engine failed, not the target. Unscored. */
+	engineErrorEpisodes: number().int().optional(),
+	/** Scored episodes interrupted mid-turn before any turn finished (`didnt_run`). Unscored; absent when none. */
+	didntRunEpisodes: number().int().nonnegative().optional(),
+	passRate: estimateIntervalSchema.nullable(),
+	passK: object({
+		k: number().int(),
+		rate: number().nullable(),
+		evaluableScenarios: number().int(),
+		scenarios: number().int()
+	}).nullable(),
+	terminations: terminationCountsSchema,
+	medianTurns: number().nullable(),
+	p50LatencyMs: number().nullable(),
+	costPerEpisodeUsd: number().nullable(),
+	costPerSuccessUsd: number().nullable(),
+	overheadUsd: number(),
+	inputTokens: number().int(),
+	outputTokens: number().int(),
+	errors: number().int(),
+	/** How the variant reached its target when an overlay or the tool proxy was involved (6.1). */
+	fidelity: string().optional(),
+	/** Additive: the variant carries a tool-surface overlay in its plan, whether or not any episode called a tool. */
+	toolSurfaceOverlay: literal(true).optional(),
+	/** Additive: side-effect grader verdicts over the variant's scored episodes; absent when no task has one (6.10). */
+	sideEffects: object({
+		passed: number().int(),
+		failed: number().int()
+	}).optional(),
+	/** Absent checks over the conversations that ran; `notRun` counts the ones with an absent check that didn't run. */
+	writeGuards: object({
+		passed: number().int(),
+		failed: number().int(),
+		notRun: number().int()
+	}).optional(),
+	/** The exists, linked and in_quarantine checks over every scored conversation, including ones that didn't run. */
+	expectedWrites: object({
+		passed: number().int(),
+		failed: number().int()
+	}).optional(),
+	/** Additive: blocked hosts a sandbox candidate tried, over the episodes that recorded egress. Evidence only. */
+	egress: object({
+		episodes: number().int(),
+		/** Episodes whose evidence is not the egress proxy's own record; `verified` is true when there are none. */
+		unverifiedEpisodes: number().int(),
+		verified: boolean(),
+		refusals: number().int(),
+		overflow: number().int(),
+		hosts: array(object({
+			host: string(),
+			reasons: array(egressRefusalReasonSchema),
+			count: number().int()
+		}))
+	}).optional()
+});
+/** A variant against the baseline over (scenario, trial) pairs. */
+const reportComparisonSchema = object({
+	variantId: string(),
+	baselineVariantId: string(),
+	pairs: number().int(),
+	passRateDifference: estimateIntervalSchema.nullable(),
+	costRatio: estimateIntervalSchema.nullable(),
+	/**
+	* Mean cost per success over the priced pairs, against the baseline's, by the same paired bootstrap as `costRatio`.
+	* Null when either side has no success or no priced pair, or when too few resamples hold a success on both sides.
+	*/
+	costPerSuccessRatio: estimateIntervalSchema.nullable().optional(),
+	latencyRatio: estimateIntervalSchema.nullable(),
+	verdict: simulationVerdictSchema,
+	hint: string().nullable()
+});
+/** One variant × simulated user × task cell of the heatmap. */
+const reportCellSchema = object({
+	variantId: string(),
+	simulatedUserId: string(),
+	taskId: string(),
+	episodes: number().int(),
+	validEpisodes: number().int(),
+	passedEpisodes: number().int(),
+	passRate: number().nullable(),
+	flaky: boolean()
+});
+/** A cluster of failing episodes with what they have in common. */
+const reportFindingSchema = object({
+	/** `left_out` clusters episodes the report left out; its key is a `ReportLeftOutReason`. */
+	kind: _enum([
+		"termination",
+		"grader",
+		"tool",
+		"flaky",
+		"left_out"
+	]),
+	key: string(),
+	title: string(),
+	variantIds: array(string()),
+	episodeIds: array(string()),
+	count: number().int()
+});
+/**
+* A worse number than the previous comparable report. `permission_leak` compares with zero instead: the variant's
+* target listed or served a tool outside a simulated user's grants, so the run fails and the variant is not recommended.
+*/
+const reportRegressionSchema = object({
+	kind: _enum([
+		"pass_rate",
+		"cost_per_success",
+		"latency",
+		"permission_leak"
+	]),
+	variantId: string(),
+	previous: number(),
+	current: number(),
+	interval: estimateIntervalSchema.nullable(),
+	message: string()
+});
+/** One tool design view over a set of operator episodes: the whole run, or one client model or variant. */
+const toolDesignViewSchema = object({
+	episodes: number().int(),
+	rows: array(object({
+		tool: string(),
+		intended: number().int(),
+		rightWhenNeeded: number().int(),
+		chosenWrongly: number().int(),
+		/** Episodes with a wrong choice of this tool; absent on reports built before it was counted. */
+		chosenWronglyEpisodes: number().int().optional(),
+		/** Calls naming this tool, including ones the proxy refused; absent on reports built before it was counted. */
+		calls: number().int().optional(),
+		/** Of those, the calls rejected for their arguments. */
+		invalidArgumentCalls: number().int().optional(),
+		confusedWith: array(object({
+			tool: string(),
+			count: number().int()
+		})),
+		argumentErrors: array(object({
+			path: string(),
+			count: number().int()
+		})),
+		erroredEpisodes: number().int(),
+		recoveredEpisodes: number().int(),
+		medianTurnsToSuccess: number().nullable(),
+		medianTokensToSuccess: number().nullable(),
+		rightLow: boolean(),
+		wrongHigh: boolean(),
+		recoveryLow: boolean()
+	})),
+	quietTools: number().int(),
+	toolCount: number().int(),
+	neverDiscovered: array(object({
+		tool: string(),
+		neededBy: array(string()),
+		episodes: number().int()
+	})),
+	errors: array(object({
+		errorKey: string(),
+		text: string(),
+		tool: string(),
+		/** `design`: a future design's own answer (an error envelope it built), never the server's text. */
+		origin: _enum([
+			"server",
+			"overlay",
+			"transport",
+			"design"
+		]),
+		times: number().int(),
+		episodes: number().int(),
+		recoveredEpisodes: number().int(),
+		/** The conversations that hit it; absent on reports built before they were listed. */
+		episodeIds: array(string()).optional()
+	})),
+	wrongChoicesByClient: array(object({
+		clientModel: string(),
+		count: number().int()
+	})),
+	stubbedTools: array(object({
+		tool: string(),
+		calls: number().int()
+	})).optional(),
+	/** Tool answers per ladder rung; absent on reports built before the ladder. */
+	byServedBy: servedByCountsSchema.optional()
+});
+/** One overlay's pooled verdict: each overlay variant paired with the no-overlay variant under the same client model. */
+const overlayVerdictSchema = object({
+	overlayKey: string(),
+	label: string(),
+	variantIds: array(string()),
+	referenceVariantIds: array(string()),
+	clientModels: array(string()),
+	pairs: number().int(),
+	passRate: estimateIntervalSchema.nullable(),
+	referencePassRate: estimateIntervalSchema.nullable(),
+	passRateDifference: estimateIntervalSchema.nullable(),
+	verdict: simulationVerdictSchema,
+	hint: string().nullable(),
+	/** The best `better` overlay whose result stands on real answers, as the investment card judges; at most one. */
+	recommended: boolean(),
+	/** Injection and write-guard checks its own conversations failed; absent when none. Never recommended then. */
+	safetyFailures: number().int().positive().optional(),
+	/** Permission leaks on the targets its variants ran against, each target counted once; absent when none. */
+	permissionLeaks: number().int().positive().optional(),
+	/** Answers that weren't real decided the pairs that separate it, so its win doesn't hold without them. */
+	heldBySynthesis: literal(true).optional()
+});
+/** The tool design view ("Agent experience", "The tool design view"); additive, so older reports render without it. */
+const toolDesignSectionSchema = toolDesignViewSchema.extend({
+	byClientModel: array(object({
+		clientModel: string(),
+		view: toolDesignViewSchema
+	})).optional(),
+	byVariant: array(object({
+		variantId: string(),
+		variantKey: string(),
+		clientModel: string().nullable(),
+		view: toolDesignViewSchema
+	})).optional(),
+	overlays: array(overlayVerdictSchema).optional(),
+	/** Age in days of the oldest recorded answer the run replayed, as of its exchange cutoff; absent with no replay. */
+	recordedAnswerAgeDays: number().nonnegative().nullable().optional(),
+	/** One row per scored conversation, for the "How each agent did" grid; absent on reports built before it. */
+	conversations: array(object({
+		episodeId: string(),
+		variantId: string(),
+		taskId: string().nullable(),
+		clientModel: string(),
+		trial: number().int().nonnegative(),
+		outcome: _enum([
+			"done",
+			"doneAfterError",
+			"wrongTool",
+			"invalidArguments",
+			"stuckOnError",
+			"gaveUp"
+		]),
+		/** The tool the outcome is about: the one that errored, or the one picked wrongly. */
+		tool: string().optional(),
+		/** For a wrong tool: the tool the task needed. */
+		intendedTool: string().optional(),
+		/** For invalid arguments: the first argument path the server rejected. */
+		argumentPath: string().optional(),
+		/** For an error: its key in `errors`. */
+		errorKey: string().optional()
+	})).optional(),
+	/** Per tool: synthesized answers, contract failures, and how reviewers judged the frozen answers (D5). */
+	synthesis: array(object({
+		tool: string(),
+		answers: number().int().nonnegative(),
+		failed: number().int().nonnegative(),
+		reviewed: number().int().nonnegative(),
+		plausible: number().int().nonnegative()
+	})).optional()
+});
+/** One variant's placement row (6.1): what produced its numbers, and which world they come from. */
+const reportPlacementSchema = object({
+	variantId: string(),
+	placement: variantPlacementSchema,
+	fidelity: variantFidelitySchema,
+	label: string(),
+	worldKey: string(),
+	recommendable: boolean()
+});
+const permissionCellSchema = _enum([
+	"Listed",
+	"Hidden",
+	"Called",
+	"Denied",
+	"Leak"
+]);
+/** One simulated user's row: what its connection listed and what its calls got, one cell per tool column. */
+const permissionMatrixRowSchema = object({
+	simulatedUserId: string(),
+	name: string(),
+	/** The connection that listed: the user's identity, or the target's own (`target`, null when it has none). */
+	source: _enum(["identity", "target"]),
+	savedServerName: string().nullable(),
+	grants: array(string()),
+	/** The union of the grants' tools; null when the row has no expectation, so it can show no `Leak`. */
+	expectedTools: array(string()).nullable(),
+	/** Grants the target's map does not name; any one leaves the row without an expectation. */
+	unknownGrants: array(string()),
+	/** Aligned with the target's `tools`. */
+	cells: array(permissionCellSchema),
+	leaks: array(object({
+		tool: string(),
+		reason: _enum(["listed", "called"])
+	})),
+	/** The listing kept fewer names than `tools/list` returned, so an unlisted tool may have been listed. */
+	listingTruncated: boolean()
+});
+/** One external MCP target's matrix: rows are simulated users, columns are tools. */
+const permissionMatrixTargetSchema = object({
+	targetId: string(),
+	/** The variants that ran against the target on its own server; a leak blocks each of them. */
+	variantIds: array(string()),
+	/** The target carried a `grantsToTools` map; without one the matrix shows observations only. */
+	expectation: boolean(),
+	tools: array(string()),
+	/** Tool columns left out past the column cap; never one with a `Leak`, `Called` or `Denied` cell. */
+	omittedTools: number().int(),
+	rows: array(permissionMatrixRowSchema),
+	leaks: number().int(),
+	/** Rows whose listing kept fewer names than `tools/list` returned, so a leak there cannot be ruled out. */
+	truncatedRows: number().int().optional(),
+	/** Rows with an expectation, so checked for leaks; the others show observations only. */
+	checkedRows: number().int().optional()
+});
+/** The permission matrix section; additive, so older reports render without it. */
+const permissionMatrixSectionSchema = object({
+	targets: array(permissionMatrixTargetSchema),
+	leaks: number().int()
+});
+/** `SimulationReportBody`, version 1 ("Report model (reference)"). */
+/**
+* One variant's injection verdicts (6.12, read side). `episodes` and `failed` cover only conversations that ran;
+* `notRun` counts the scored conversations that didn't.
+*/
+const reportInjectionVerdictSchema = object({
+	variantId: string(),
+	episodes: number().int(),
+	failed: number().int(),
+	notRun: number().int().optional(),
+	canaryLeaks: number().int(),
+	avoidedToolCalls: number().int(),
+	/** The avoided tools its episodes called, by name. */
+	avoidedTools: array(string())
+});
+/** One operation in the investment card, with its own delta when it ran alone. */
+const investmentOperationRowSchema = object({
+	op: _enum(TOOL_SURFACE_OPS),
+	tool: string(),
+	checklistRow: number().int().positive().nullable(),
+	signal: string().nullable(),
+	delta: object({
+		successPoints: number().nullable(),
+		low: number().nullable(),
+		high: number().nullable()
+	}).nullable()
+});
+/** "If you ship this design": a future design against its baseline, with the evidence mix behind it (D6). */
+const investmentSectionSchema = object({
+	variantKey: string(),
+	baselineKey: string(),
+	/** The design's variants, one per client model, pooled into one paired verdict; absent on older reports. */
+	variantIds: array(string()).optional(),
+	baselineVariantIds: array(string()).optional(),
+	/** Paired episodes, and the pairs whose outcomes differ: the episodes that separate the designs. */
+	pairs: number().int().nonnegative().optional(),
+	separating: number().int().nonnegative().optional(),
+	/** Pairs left out because the design or baseline episode ended `recording_miss`; absent when none were. */
+	recordingMissPairsDropped: number().int().positive().optional(),
+	/** Pairs left out because either side stalled on its client model and neither missed; absent when none were. */
+	clientModelStallPairsDropped: number().int().positive().optional(),
+	headline: _enum(["recommended", "indicative"]),
+	reason: string().nullable(),
+	/** Injection and write-guard checks the design's own conversations failed; absent when none. Never recommended then. */
+	safetyFailures: number().int().positive().optional(),
+	/** Permission leaks on the targets its variants ran against, each target counted once; never recommended then. */
+	permissionLeaks: number().int().positive().optional(),
+	success: object({
+		baseline: number(),
+		candidate: number(),
+		delta: number(),
+		low: number(),
+		high: number()
+	}),
+	tokensPerSuccessDeltaPct: number().nullable(),
+	turnsToDone: object({
+		baseline: number().nullable(),
+		candidate: number().nullable()
+	}),
+	servedBy: servedByCountsSchema,
+	synthesizedShare: number().min(0).max(1),
+	synthesizedShareThreshold: number().min(0).max(1),
+	decidedBySynthesis: object({
+		episodes: number().int().nonnegative(),
+		decisive: number().int().nonnegative(),
+		/** The flagged design episodes, at most 20, so the report can open them. */
+		episodeIds: array(string()).max(20).optional(),
+		/** Flagged because the judge's reasoning cited a synthesized answer, not only because one came last. */
+		cited: number().int().nonnegative().optional(),
+		/** Flagged because a stub (a stubbed write's `accepted`, a failed synthesis) was the last tool answer. */
+		stubbed: number().int().nonnegative().optional()
+	}),
+	recordedAnswerAgeDays: number().nonnegative().nullable(),
+	toolsHashChanged: boolean(),
+	operations: array(investmentOperationRowSchema)
+});
+/** Evidence quality and the scope of the pass rate; absent on reports created before this check. */
+const comparisonQualitySchema = object({
+	status: _enum(["usable", "diagnostic"]),
+	reasons: array(_enum([
+		"partial_run",
+		"incomplete_grading",
+		"interrupted_execution",
+		"unscored_episodes",
+		"recording_coverage"
+	])),
+	missingGradeEpisodes: number().int().nonnegative(),
+	interruptedEpisodes: number().int().nonnegative(),
+	/** Unscored finished episodes other than `recording_miss`, client-model stalls and `didnt_run`, which have their own counts. */
+	unscoredEpisodes: number().int().nonnegative(),
+	/**
+	* Episodes that ended `recording_miss`. Each leaves the paired comparison with its partner; past
+	* `RECORDING_MISS_SHARE_CAP` of finished episodes or of an overlay's pooled pairs (misses and client-model stalls
+	* together), or with a comparison left without pairs, the reason is `recording_coverage`. Absent when none missed.
+	*/
+	recordingMissEpisodes: number().int().nonnegative().optional(),
+	/** Baseline/variant pairs left out of the paired comparisons because either side ended `recording_miss`. */
+	recordingMissPairsDropped: number().int().nonnegative().optional(),
+	/** Episodes that ended `agent_error` on a client-model provider stall; they drop pairs like `recording_miss`. */
+	clientModelStallEpisodes: number().int().nonnegative().optional(),
+	/** Pairs left out because either side stalled on its client model and neither ended `recording_miss`. */
+	clientModelStallPairsDropped: number().int().nonnegative().optional(),
+	outcomeScope: _enum([
+		"task_completion",
+		"safety",
+		"mixed"
+	]),
+	safetyEpisodes: number().int().nonnegative(),
+	safetyPassedEpisodes: number().int().nonnegative(),
+	safetyPassedWithoutGoalMetEpisodes: number().int().nonnegative()
+});
+/** Which way a difference against the baseline is clear; null when it is too close to call. */
+const reportVerdictClearSchema = _enum(["better", "worse"]).nullable();
+/** A ratio against the baseline with its 95% range; clear when the range excludes 1. */
+const reportVerdictRatioSchema = object({
+	estimate: number(),
+	low: number(),
+	high: number(),
+	clear: reportVerdictClearSchema
+});
+/** One version in the verdict: its tasks done, safety, cost and speed, and the summary its card leads with. */
+const reportVerdictVersionSchema = object({
+	variantId: string(),
+	label: string(),
+	role: _enum(["baseline", "candidate"]),
+	/** Conversations that reached the goal and passed their checks, of those that count toward the pass rate. */
+	done: number().int().nonnegative(),
+	counted: number().int().nonnegative(),
+	/** Conversations interrupted before the agent's first reply; they count against no one. */
+	didntRun: number().int().nonnegative(),
+	conversations: number().int().nonnegative(),
+	rate: number().nullable(),
+	low: number().nullable(),
+	high: number().nullable(),
+	costPerSuccessUsd: number().nullable(),
+	costPerEpisodeUsd: number().nullable(),
+	p50LatencyMs: number().nullable(),
+	inputTokens: number().int(),
+	modelCalls: number().int().nullable(),
+	toolCalls: number().int().nullable(),
+	/** Injection checks and write checks (guards, or the legacy side-effect totals). */
+	safetyPassed: number().int().nonnegative(),
+	safetyTotal: number().int().nonnegative(),
+	/** Permission-matrix leaks on the targets this version reached; counted apart from `safetyTotal`. */
+	permissionLeaks: number().int().nonnegative(),
+	/** Cost per conversation against the baseline; null for the baseline. */
+	cost: reportVerdictRatioSchema.nullable(),
+	/** Cost per success against the baseline; null for the baseline or when either side has no success. */
+	costPerSuccess: reportVerdictRatioSchema.nullable(),
+	/** Time per turn against the baseline; null for the baseline. */
+	latency: reportVerdictRatioSchema.nullable(),
+	quality: reportVerdictClearSchema,
+	/** False when the report would never recommend it: a comparison target, a placement that allows none, or a leak. */
+	recommendable: boolean(),
+	summary: string()
+});
+/** The verdict a benchmark of three or more versions leads with (dashboard, Markdown and MCP). */
+const reportVerdictSchema = object({
+	baselineVariantId: string(),
+	headline: string(),
+	sentence: string(),
+	chips: array(object({
+		key: _enum([
+			"cost",
+			"speed",
+			"quality"
+		]),
+		label: string(),
+		clear: boolean()
+	})),
+	recommendation: object({
+		/** The candidate to switch to or consider; null to keep the baseline. */
+		variantId: string().nullable(),
+		title: string(),
+		detail: string().nullable(),
+		sampleNote: string().nullable()
+	}),
+	/** The baseline first, then the candidates by tasks done and cost. */
+	versions: array(reportVerdictVersionSchema),
+	didntRun: object({
+		total: number().int().positive(),
+		sentence: string(),
+		episodeIds: array(string()),
+		byVersion: array(object({
+			variantId: string(),
+			label: string(),
+			count: number().int().positive()
+		}))
+	}).nullable(),
+	/** Facts behind the costliest candidate's gap: its input tokens and model calls against the baseline's. */
+	gap: object({
+		variantId: string(),
+		label: string(),
+		tokenRatio: number(),
+		modelCalls: number().int().nullable(),
+		baselineModelCalls: number().int().nullable(),
+		inputTokens: number().int(),
+		baselineInputTokens: number().int(),
+		/** The fewest and most tool calls any version made; null when a version has no tool rows. */
+		toolCallRange: object({
+			min: number().int(),
+			max: number().int()
+		}).nullable(),
+		title: string(),
+		detail: string()
+	}).nullable()
+});
+const reportHarnessCaptureSchema = object({
+	totalTurns: number().int().nonnegative(),
+	omittedTurns: number().int().nonnegative(),
+	turns: array(object({
+		episodeId: string(),
+		variantId: string(),
+		turnIndex: number().int().nonnegative(),
+		capture: harnessCaptureSummarySchema
+	})).max(200)
+});
+const simulationReportBodySchema = object({
+	harnessCapture: reportHarnessCaptureSchema.optional(),
+	comparisonQuality: comparisonQualitySchema.optional(),
+	version: literal(1),
+	run: object({
+		runId: string(),
+		simulationId: string(),
+		productId: string(),
+		status: simulationRunStatusSchema,
+		mode: simulationModeSchema,
+		preset: simulationPresetSchema.nullable(),
+		planFingerprint: string(),
+		trials: number().int(),
+		episodesPlanned: number().int(),
+		episodesFinished: number().int(),
+		partial: boolean()
+	}),
+	caveats: object({
+		simulatedUserModel: string(),
+		simulatedUserPromptVersion: number().int(),
+		judgeModel: string().nullable(),
+		judgePromptVersion: number().int().nullable(),
+		gradingVersion: number().int().positive().optional(),
+		episodes: number().int(),
+		validEpisodes: number().int(),
+		simulatedUserBrokeEpisodes: number().int(),
+		targetUnavailableEpisodes: number().int().optional(),
+		clientLimitEpisodes: number().int().optional(),
+		recordingMissEpisodes: number().int().nonnegative().optional(),
+		/** Pairs left out of the paired comparisons because either side ended `recording_miss`. */
+		recordingMissPairsDropped: number().int().nonnegative().optional(),
+		clientModelStallEpisodes: number().int().nonnegative().optional(),
+		/** Pairs left out because either side stalled on its client model and neither ended `recording_miss`. */
+		clientModelStallPairsDropped: number().int().nonnegative().optional(),
+		scoringFailedEpisodes: number().int().optional(),
+		spendCapEpisodes: number().int().optional(),
+		engineErrorEpisodes: number().int().optional(),
+		didntRunEpisodes: number().int().nonnegative().optional(),
+		isolation: array(isolationLevelSchema),
+		unpricedModels: array(string()),
+		partial: boolean(),
+		notes: array(string())
+	}),
+	variants: array(reportVariantSummarySchema),
+	comparisons: array(reportComparisonSchema),
+	cells: array(reportCellSchema),
+	layers: array(layerStatSchema),
+	terminations: array(object({
+		variantId: string(),
+		termination: simTerminationSchema,
+		count: number().int()
+	})),
+	findings: array(reportFindingSchema),
+	recommendation: object({
+		variantId: string(),
+		reason: string()
+	}).nullable(),
+	regressions: array(reportRegressionSchema),
+	search: object({ rounds: array(object({
+		round: number().int(),
+		variantIds: array(string()),
+		episodes: number().int(),
+		survivors: array(string())
+	})) }).nullable(),
+	toolDesign: toolDesignSectionSchema.optional(),
+	/** Additive: present on runs whose plan froze placements, so older reports recompute unchanged. */
+	placements: array(reportPlacementSchema).optional(),
+	/** Additive: present when a target had identities or a `grantsToTools` map (6.17 addition 4). */
+	permissionMatrix: permissionMatrixSectionSchema.optional(),
+	/** False when nothing about the run's targets or simulated users could make permissions apply; absent on older reports. */
+	permissionsApplicable: boolean().optional(),
+	/** Additive: present when a run's tasks carry the injection grader, one row per variant. */
+	injection: array(reportInjectionVerdictSchema).optional(),
+	/** Additive: present when a run compared a future design against its baseline (D6). */
+	investment: investmentSectionSchema.optional(),
+	/** Null when the report has no verdict (not a benchmark, fewer than three versions, a diagnostic run); absent on older reports. */
+	verdict: reportVerdictSchema.nullable().optional()
+});
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Moves `from` to `to` on a copy of `value` when only the old key is set. */
+function moveKey(value, from, to) {
+	if (!(from in value)) return value;
+	const { [from]: moved, ...rest } = value;
+	return to in rest ? rest : {
+		...rest,
+		[to]: moved
+	};
+}
+/** Rewrites a report body as reports built before the renames hold it: simulator counts and search rungs. */
+function upgradeLegacyReportBody(value) {
+	if (!isPlainObject(value)) return value;
+	const body = { ...value };
+	if (Array.isArray(body.variants)) body.variants = body.variants.map((variant) => isPlainObject(variant) ? moveKey(variant, "simulatorInvalidEpisodes", "simulatedUserBrokeEpisodes") : variant);
+	if (isPlainObject(body.caveats)) body.caveats = moveKey(moveKey(moveKey(body.caveats, "simulatorModel", "simulatedUserModel"), "simulatorPromptVersion", "simulatedUserPromptVersion"), "simulatorInvalidEpisodes", "simulatedUserBrokeEpisodes");
+	if (isPlainObject(body.search)) {
+		const search = moveKey(body.search, "rungs", "rounds");
+		body.search = Array.isArray(search.rounds) ? {
+			...search,
+			rounds: search.rounds.map((round) => isPlainObject(round) ? moveKey(round, "rung", "round") : round)
+		} : search;
+	}
+	if (Array.isArray(body.placements)) body.placements = body.placements.map((row) => isPlainObject(row) && row.placement === "customer_runner" ? {
+		...row,
+		placement: "private_runner"
+	} : row);
+	return body;
+}
+preprocess(upgradeLegacyReportBody, simulationReportBodySchema);
+/** The one-line summary stored beside the body, for lists, Home and email subjects. */
+const simulationReportHeadlineSchema = object({
+	sentence: string(),
+	recommendedVariantId: string().nullable(),
+	baselinePassRate: number().nullable(),
+	bestPassRate: number().nullable(),
+	costPerSuccessUsd: number().nullable(),
+	regression: boolean()
+});
+/** A saved report. */
+const simulationReportSchema = object({
+	id: entityId$1,
+	runId: entityId$1,
+	simulationId: entityId$1,
+	productId: entityId$1,
+	reportVersion: number().int(),
+	headline: simulationReportHeadlineSchema,
+	body: simulationReportBodySchema,
+	previousReportId: entityId$1.nullable(),
+	regression: boolean(),
+	createdAt: isoDate
+});
+const synthesizerContractSchema = object({
+	source: _enum([
+		"add_tool",
+		"declared",
+		"observed",
+		"none"
+	]),
+	/** The JSON Schema a successful answer must validate against; null when no schema is known. */
+	schema: record(string(), unknown()).nullable()
+});
+/** One recorded exchange a synthesizer grounds on, by id and the saved connection it was recorded under. */
+const synthesizerGroundingExchangeSchema = object({
+	id: string().min(1),
+	grant: string().nullable()
+});
+object({
+	variantId: string().min(1),
+	/** The server tool a call reaches after the overlay, or the name of a synthesized `add_tool`. */
+	tool: string().min(1),
+	added: boolean(),
+	readOnly: boolean(),
+	definition: object({
+		name: string(),
+		description: string(),
+		inputSchema: record(string(), unknown())
+	}),
+	contract: synthesizerContractSchema,
+	grounding: object({
+		exchanges: array(synthesizerGroundingExchangeSchema).max(40),
+		/** The server tools the exchanges come from: the tool itself, or a synthesized `add_tool`'s grounding tools. */
+		tools: array(string().min(1)).max(8),
+		worldFacts: array(string().min(1).max(2e3)).max(32),
+		/** The run's recorded schema reads, so a real collection, field or option id is known (D5); absent on older plans. */
+		schemaExchanges: array(synthesizerGroundingExchangeSchema).max(64).optional(),
+		linkedListExchanges: array(synthesizerGroundingExchangeSchema).max(32).optional()
+	}),
+	/** Tools the variant lists, so a designed error's `recoverySteps` can only name a real one. */
+	listedTools: array(string()).max(400),
+	promptVersion: number().int().positive()
+});
+object({ plausible: boolean().nullable() });
+object({
+	exchangeId: string(),
+	plausible: boolean().nullable()
+});
+const resynthesizeToolName = string().min(1).max(255);
+object({ tools: union([resynthesizeToolName, array(resynthesizeToolName).min(1).max(64)]).optional().describe("A server tool whose frozen answers to discard; repeat for several. Omit to discard every tool's.") });
+object({ discarded: number().int().nonnegative() });
+/** A tool's synthesized answers and how reviewers judged them, for the profile and the report caveats. */
+const synthesisReviewStatsSchema = object({
+	answers: number().int().nonnegative(),
+	reviewed: number().int().nonnegative(),
+	plausible: number().int().nonnegative()
+});
+const exchangeWorldSchema = string().regex(/^(live|synthetic:[A-Za-z0-9_-]+)$/);
+const exchangeSourceSchema = _enum([
+	"simulation",
+	"transcript_backfill",
+	"tool_executions",
+	"uploaded"
+]);
+/**
+* One recorded `tools/call` of one target. `arguments` and `result` are null on a shape-only row, which a run with
+* `dataRetention: 'metrics'` or a declined recording consent writes.
+*/
+const simulationToolExchangeSchema = object({
+	id: string(),
+	targetId: string(),
+	grant: string().nullable(),
+	serverTool: string(),
+	toolsHash: string().nullable(),
+	argsFingerprint: string(),
+	arguments: record(string(), unknown()).nullable(),
+	result: unknown().nullable(),
+	isError: boolean(),
+	errorCode: string().nullable(),
+	errorKey: string().nullable(),
+	durationMs: number().nonnegative(),
+	world: exchangeWorldSchema,
+	source: exchangeSourceSchema,
+	servedBy: servedBySchema,
+	variantHash: string().nullable(),
+	ledgerHash: string().nullable(),
+	/** The synthesizer prompt version a frozen synthesized row was written under; null on a recording. */
+	promptVersion: number().int().nullable().optional(),
+	/** Why the synthesizer answered as it did; null on a recording. */
+	rationale: string().nullable().optional(),
+	/** A reviewer's verdict on a synthesized answer; null until reviewed. */
+	plausible: boolean().nullable().optional(),
+	shapeOnly: boolean(),
+	runId: string().nullable(),
+	episodeId: string().nullable(),
+	callIndex: number().int().nonnegative().nullable(),
+	createdAt: string(),
+	expiresAt: string().nullable()
+});
+/** One exchange a person uploads for a tool their server answered outside a simulation. */
+const uploadedExchangeSchema = object({
+	tool: string().min(1),
+	arguments: record(string(), unknown()),
+	result: unknown(),
+	isError: boolean().optional()
+});
+union([object({ exchanges: array(uploadedExchangeSchema).min(1).max(500) }), object({
+	backfill: _enum(["transcripts", "tool_executions"]),
+	runId: string().min(1).optional()
+})]);
+object({ recorded: number().int().nonnegative() });
+object({
+	tool: string().optional(),
+	/** `true` lists only published recordings that kept their payload: no shape-only and no frozen synthesized row. */
+	published: _enum(["true", "false"]).optional(),
+	limit: number$1().int().min(1).max(200).default(50),
+	cursor: string().optional()
+});
+object({
+	exchanges: array(simulationToolExchangeSchema),
+	nextCursor: string().nullable()
+});
+object({ deleted: number().int().nonnegative() });
+/** What a tool's answers held at one field path: whether it was always set, its types and its first distinct values. */
+const toolProfileFieldSchema = object({
+	alwaysSet: boolean(),
+	types: array(string()),
+	values: array(unknown()).max(25),
+	valuesTruncated: boolean()
+});
+/** One error a tool returned, keyed by its normalized error key in the profile's catalog. */
+const toolProfileErrorSchema = object({
+	count: number().int(),
+	exemplarExchangeId: string().nullable(),
+	isError: boolean(),
+	code: string().nullable(),
+	recoveredShare: number().min(0).max(1).nullable()
+});
+const shapeFindingKindSchema = _enum([
+	"raw_nested_payload",
+	"two_paging_styles",
+	"success_shaped_failure",
+	"error_without_class",
+	"error_without_next_call",
+	"plain_string_beside_json",
+	"timeout_without_async"
+]);
+const toolProfileShapeFindingSchema = object({
+	kind: shapeFindingKindSchema,
+	checklistRow: number().int().positive(),
+	exemplarExchangeId: string().nullable(),
+	/** The one-line evidence: what the recorded answers show, and the fix the row asks for. */
+	detail: string().max(500),
+	/** Every recorded exchange the finding rests on, the exemplar first; empty on profiles built before WP-F8. */
+	exchangeIds: array(string()).max(8).default([]),
+	/** The future-state operation that answers the finding, when one maps deterministically ("Add to design", D7). */
+	suggestedOp: toolSurfaceOpSchema.optional()
+});
+const adoptionStateSchema = _enum([
+	"adopted",
+	"partial",
+	"not_seen"
+]);
+const toolProfileAdoptionSchema = object({
+	briefId: string(),
+	exportedAt: string(),
+	/** The simulation, run and design the brief was exported from; absent on entries written before export recorded them. */
+	simulationId: string().optional(),
+	runId: string().optional(),
+	variantKey: string().optional(),
+	/** When live answers were last compared with the brief; null until a live run after the export. */
+	observedAt: string().nullable().optional(),
+	operations: array(object({
+		op: _enum(TOOL_SURFACE_OPS),
+		state: adoptionStateSchema,
+		detail: string().max(500).nullable()
+	}))
+});
+object({
+	targetId: string(),
+	tool: string(),
+	exchangesSeen: number().int().nonnegative(),
+	updatedAt: string(),
+	declaredOutputSchema: record(string(), unknown()).nullable(),
+	observedOutputSchema: unknown().nullable(),
+	samples: array(string()).max(8),
+	errors: record(string(), toolProfileErrorSchema),
+	fields: record(string(), toolProfileFieldSchema),
+	latencyMs: object({
+		p50: number().nullable(),
+		p95: number().nullable()
+	}),
+	writesObserved: boolean(),
+	shapeFindings: array(toolProfileShapeFindingSchema),
+	adoption: array(toolProfileAdoptionSchema).default([]),
+	recordedAnswerAgeDays: number().nonnegative().nullable(),
+	latestToolsHash: string().nullable(),
+	/** The tool's frozen synthesized answers across every design, and how reviewers judged them (D5). */
+	synthesis: synthesisReviewStatsSchema.optional()
+});
+object({
+	tool: string().min(1),
+	exchangeId: string().min(1),
+	synthesize: boolean().default(false)
+});
+object({
+	before: unknown(),
+	after: unknown(),
+	servedBy: servedBySchema,
+	rationale: string().nullable(),
+	exchangeId: string()
+});
+/** The predicted change in task success a brief carried when it was exported, from the run's investment card. */
+const designBriefPredictionSchema = object({
+	baseline: number(),
+	candidate: number(),
+	delta: number(),
+	low: number(),
+	high: number(),
+	headline: _enum(["recommended", "indicative"])
+});
+object({
+	briefId: string(),
+	exportedAt: string(),
+	/** The brief as Markdown: headline, investment card, operations, before and after definitions, caveats. */
+	markdown: string()
+});
+/** One later run's baseline, for the trend a brief's prediction is read against. */
+const designBriefTrendPointSchema = object({
+	runId: string(),
+	completedAt: string(),
+	passRate: number().nullable(),
+	/** The baseline's tool answers came from the server, not from recordings, so the run can show adoption. */
+	live: boolean()
+});
+/** One exported brief: what it predicted, which operations live answers now show, and the baseline since. */
+const simulationDesignBriefSchema = object({
+	briefId: string(),
+	exportedAt: string(),
+	runId: string(),
+	variantKey: string(),
+	targetId: string(),
+	prediction: designBriefPredictionSchema.nullable(),
+	operations: array(object({
+		op: _enum(TOOL_SURFACE_OPS),
+		tool: string(),
+		state: adoptionStateSchema,
+		detail: string().max(500).nullable()
+	})),
+	observedAt: string().nullable(),
+	/** The baseline's pass rate when the brief was exported, then each completed run since, oldest first. */
+	baselineAtExport: number().nullable(),
+	trend: array(designBriefTrendPointSchema)
+});
+object({ briefs: array(simulationDesignBriefSchema) });
+const entityId = string().min(1).max(255);
+/** Every list route's page envelope: `data` plus a keyset cursor. */
+function simulationPageSchema(item) {
+	return object({
+		data: array(item),
+		pagination: object({
+			nextCursor: string().nullable(),
+			hasMore: boolean(),
+			limit: number().int()
+		})
+	});
+}
+/** Cursor and page size shared by every list route. */
+const simulationListQuerySchema = object({
+	cursor: string().max(512).optional(),
+	limit: number$1().int().min(1).max(100).optional()
+});
+/** The latest run a list row carries, so the sidebar and roll-up read one request. */
+const simulationLatestRunSummarySchema = object({
+	runId: entityId,
+	status: simulationRunStatusSchema,
+	episodesPlanned: number().int(),
+	episodesCompleted: number().int(),
+	episodesFailed: number().int(),
+	episodesSkipped: number().int(),
+	spentUsd: number(),
+	createdAt: string(),
+	completedAt: string().nullable(),
+	headline: simulationReportHeadlineSchema.nullable()
+});
+const simulationListItemSchema = simulationSchema.extend({
+	latestRun: simulationLatestRunSummarySchema.nullable(),
+	/** Additive: live versions and the distinct simulated users and tasks its enabled pairings use. */
+	shape: object({
+		versions: number().int(),
+		simulatedUsers: number().int(),
+		tasks: number().int()
+	}).optional()
+});
+simulationListQuerySchema.extend({
+	productId: entityId.optional(),
+	mode: simulationModeSchema.optional()
+});
+simulationPageSchema(simulationListItemSchema);
+/** A variant as it is added; the server computes `changesHash`. */
+const createSimulationVariantRequestSchema = object({
+	key: simulationVariantKeySchema,
+	label: string().min(1).max(255),
+	role: variantRoleSchema,
+	targetId: entityId,
+	changes: array(variantChangeSchema).max(50).optional(),
+	clientModel: string().min(1).max(255).nullable().optional(),
+	parentVariantId: entityId.nullable().optional(),
+	source: variantSourceSchema.optional(),
+	/** Defaults by target kind (`TARGET_KIND_PLACEMENTS`); fixed once the variant exists. */
+	placement: variantPlacementSchema.optional(),
+	fidelity: variantFidelitySchema.optional(),
+	data: variantDataSchema.nullable().optional(),
+	/** Which upstream answers each tool (D3); absent means every tool answers live. */
+	toolPolicy: variantToolPolicySchema.optional(),
+	replay: variantReplaySchema.optional()
+});
+object({
+	productId: entityId,
+	slug: simulationSlugSchema.optional(),
+	name: string().min(1).max(255),
+	description: string().max(2e3).nullable().optional(),
+	mode: simulationModeSchema.optional(),
+	settings: simulationSettingsSchema.optional(),
+	enabled: boolean().optional(),
+	variants: array(createSimulationVariantRequestSchema).max(12).optional()
+});
+object({
+	name: string().min(1).max(255).optional(),
+	description: string().max(2e3).nullable().optional(),
+	mode: simulationModeSchema.optional(),
+	settings: simulationSettingsSchema.optional(),
+	enabled: boolean().optional(),
+	baselineVariantId: entityId.nullable().optional()
+});
+object({
+	simulation: simulationSchema,
+	variants: array(simulationVariantSchema),
+	scenarios: array(simulationScenarioSchema),
+	latestRun: simulationLatestRunSummarySchema.nullable()
+});
+object({ scenarios: array(object({
+	simulatedUserId: entityId,
+	taskId: entityId,
+	weight: number().int().min(1).max(100).optional(),
+	enabled: boolean().optional()
+})).max(50) });
+object({ scenarios: array(simulationScenarioSchema) });
+object({ variants: array(simulationVariantSchema) });
+object({ variants: array(createSimulationVariantRequestSchema).min(1).max(12) });
+object({ variants: array(simulationVariantSchema) });
+object({
+	label: string().min(1).max(255).optional(),
+	role: variantRoleSchema.optional(),
+	changes: array(variantChangeSchema).max(50).optional(),
+	clientModel: string().min(1).max(255).nullable().optional(),
+	/** Null clears the policy, so every tool answers live again. */
+	toolPolicy: variantToolPolicySchema.nullable().optional(),
+	replay: variantReplaySchema.nullable().optional(),
+	/** Check the saved design as run admission would, on the target's recordings, before it is saved (D4). */
+	validate: boolean().optional()
+});
+object({ variant: simulationVariantSchema });
+object({
+	name: string().min(1).max(255),
+	config: targetConfigSchema
+});
+object({
+	name: string().min(1).max(255).optional(),
+	config: targetConfigSchema.optional(),
+	/** Whether the operator host records this target's tool answers, and for how long. */
+	recording: targetRecordingSchema.optional()
+});
+object({ target: simulationTargetSchema });
+/** What one ownership check found at each place the token may be published. */
+const simulationTargetVerificationCheckSchema = object({
+	verified: boolean(),
+	method: targetVerificationMethodSchema.nullable(),
+	wellKnown: object({
+		found: boolean(),
+		detail: string()
+	}),
+	dnsTxt: object({
+		found: boolean(),
+		detail: string()
+	})
+});
+object({
+	target: simulationTargetSchema,
+	check: simulationTargetVerificationCheckSchema
+});
+object({ config: targetConfigSchema });
+/** One tool a target lists, as a client agent would see it; `readOnly` is the server's `readOnlyHint`. */
+const probedSimulationToolSchema = object({
+	name: string(),
+	description: string(),
+	readOnly: boolean(),
+	inputSchema: record(string(), unknown()).optional()
+});
+object({
+	tools: array(probedSimulationToolSchema),
+	total: number().int(),
+	/** The server's `serverInfo.name` from `initialize`, when it sent one. */
+	serverName: string().nullable().optional()
+});
+/** A tool description longer than this is cut before it reaches the model. */
+const MAX_DRAFT_TOOL_DESCRIPTION_CHARS = 1e3;
+/** The most characters one tool's `inputSchema` may take as JSON; send none for a larger one. */
+const MAX_DRAFT_TOOL_INPUT_SCHEMA_CHARS = 16e3;
+/** The most characters every `inputSchema` of one request may take together, as JSON. */
+const MAX_DRAFT_TOOL_INPUT_SCHEMAS_TOTAL_CHARS = 1e6;
+const jsonChars = (value) => JSON.stringify(value)?.length ?? 0;
+/** The tools a draft reads, as a target listed them: bounded per tool and in total. */
+const draftSimulationToolsSchema = array(object({
+	name: string().min(1).max(128),
+	description: string().max(MAX_DRAFT_TOOL_DESCRIPTION_CHARS),
+	readOnly: boolean().optional(),
+	/** The tool's input JSON Schema as the target listed it; the drafting agent reads its parameters. */
+	inputSchema: record(string(), unknown()).refine((schema) => jsonChars(schema) <= MAX_DRAFT_TOOL_INPUT_SCHEMA_CHARS, { message: `An inputSchema may take at most ${MAX_DRAFT_TOOL_INPUT_SCHEMA_CHARS} characters as JSON.` }).optional()
+})).min(1).max(1e3).refine((tools) => tools.reduce((sum, tool) => sum + (tool.inputSchema ? jsonChars(tool.inputSchema) : 0), 0) <= MAX_DRAFT_TOOL_INPUT_SCHEMAS_TOTAL_CHARS, { message: `The inputSchemas of one request may take at most ${MAX_DRAFT_TOOL_INPUT_SCHEMAS_TOTAL_CHARS} characters together.` });
+/** Harder tasks than a simulation already runs: each chains two or more tool calls, around the tools agents used least. */
+const draftHarderTasksSchema = object({
+	/** Tools agents called least in a report; when any is listed, every task uses at least one of them. */
+	focusTools: array(string().min(1).max(128)).max(12),
+	/** The titles of the tasks the simulation already has; a task repeating one is turned back. */
+	existingTitles: array(string().min(1).max(255)).max(200)
+});
+object({
+	targetName: string().min(1).max(255),
+	tools: draftSimulationToolsSchema,
+	count: number().int().min(1).max(12).optional(),
+	harder: draftHarderTasksSchema.optional()
+});
+/** One drafted task; every `expectedTools` name is one the request listed. */
+const draftedSimulationTaskSchema = object({
+	title: string(),
+	goal: string(),
+	openingMessage: string(),
+	expectedTools: array(string()).min(1),
+	category: string().nullable()
+});
+object({
+	tasks: array(draftedSimulationTaskSchema),
+	/** Why fewer tasks than asked came back, or what was dropped. */
+	notes: array(string()),
+	/** The drafting agent's run, to see how the tasks were written; null when no agent run backs them. */
+	executionId: string().nullable().optional()
+});
+/** What a draft is written from. The server loads a Runtype product itself; it never trusts product data sent in. */
+const simulationDraftSourceSchema = discriminatedUnion("kind", [object({
+	kind: literal("runtype"),
+	productId: entityId,
+	/** Narrow the draft to these capabilities of the product; all enabled ones when unset. */
+	capabilityIds: array(entityId).min(1).max(100).optional(),
+	/** Narrow the draft to these surfaces of the product; all of them when unset. */
+	surfaceIds: array(entityId).min(1).max(100).optional()
+}), object({
+	kind: literal("mcp"),
+	targetName: string().min(1).max(255),
+	/** The server's URL. Set, it lets the draft read the brand's homepage and look up real ids with read-only tools. */
+	url: string().url().max(2048).optional(),
+	/** The saved MCP connection whose credential the read-only lookups carry. */
+	savedServerName: string().min(1).max(128).optional(),
+	tools: draftSimulationToolsSchema
+})]);
+object({
+	source: simulationDraftSourceSchema,
+	/** The preset the simulation will use; unset or null drafts from the spec (`user_testing` or `benchmark`). */
+	preset: simulationPresetSchema.nullable().optional(),
+	/** Simulated users to write: 2 for `agent_experience`, 3 otherwise, when unset. */
+	userCount: number().int().min(1).max(4).optional(),
+	/** Tasks to write; 6 when unset. */
+	taskCount: number().int().min(1).max(12).optional(),
+	/** The person's own line about who uses the product and what they try to do. */
+	brief: string().max(2e3).optional(),
+	/** A saved simulation to draft for: records Activity on it, so the dashboard shows the drafting. Nothing is saved. */
+	simulationId: string().min(1).optional()
+});
+/** One drafted simulated user, ready to save with `createSimulatedUser` once a person keeps it. */
+const draftedSimulatedUserSchema = object({
+	name: string(),
+	profile: string(),
+	relationship: simulatedUserRelationshipSchema,
+	traits: array(string()),
+	knowledge: record(string(), string()),
+	/** The product surface this user reaches it through; the target's name for an MCP server. */
+	surfaceName: string().nullable(),
+	/** A client agent drives the product for this user (an MCP or API surface, or an MCP server). */
+	toolUse: boolean(),
+	source: literal("agent"),
+	/** What the user was drawn from, the drafting run first. */
+	sourceRefs: array(simulationSourceRefSchema)
+});
+/** One drafted task of a full draft, ready to save with `createSimulationTask` once a person keeps it. */
+const simulationDraftTaskSchema = draftedSimulationTaskSchema.extend({
+	/** Exact tool names the source lists, in order; empty for a Runtype product task, which names its capability. */
+	expectedTools: array(string()),
+	successSignal: string().nullable(),
+	/** The product capability the task exercises; null for an MCP server. */
+	capabilityName: string().nullable(),
+	/** Names of drafted users who would bring this task; pair it with each when saving scenarios. */
+	suitableFor: array(string()),
+	source: literal("agent"),
+	sourceRefs: array(simulationSourceRefSchema)
+});
+object({
+	users: array(draftedSimulatedUserSchema),
+	tasks: array(simulationDraftTaskSchema),
+	/** What was dropped, turned back or missing, in plain sentences. */
+	notes: array(string()),
+	/** The drafting agent's run, which opens like any run. */
+	executionId: string(),
+	context: object({
+		/** The brand homepage the draft tried to read, when the source is an MCP server on the brand's own domain. */
+		homepage: object({
+			url: string(),
+			fetched: boolean(),
+			/** The run that read it. */
+			executionId: string().nullable()
+		}).nullable(),
+		/** Read-only tool calls the agent made to look up real ids and names. */
+		lookups: number().int()
+	})
+});
+simulationListQuerySchema.extend({
+	productId: entityId.optional(),
+	/** Comma-separated target ids, so a page reads the targets its variants name in one request. */
+	ids: string().max(4096).optional()
+});
+simulationPageSchema(simulationTargetSchema);
+simulatedUserDefinitionSchema.partial();
+object({ simulatedUser: simulatedUserSchema });
+simulationListQuerySchema.extend({ productId: entityId.optional() });
+simulationPageSchema(simulatedUserSchema);
+simulationTaskDefinitionSchema.partial();
+object({ task: simulationTaskSchema });
+simulationListQuerySchema.extend({ productId: entityId.optional() });
+simulationPageSchema(simulationTaskSchema);
+object({
+	dryRun: boolean().optional(),
+	maxSpendUsd: number().positive().max(1e4).optional(),
+	allowPartial: boolean().optional(),
+	variantIds: array(entityId).min(1).max(12).optional(),
+	/** Run only these enabled scenarios, for example the ones an overlay proposal was grounded in. */
+	scenarioIds: array(entityId).min(1).max(50).optional(),
+	trials: number().int().min(1).max(10).optional(),
+	trigger: simulationRunTriggerSchema.optional(),
+	/** The variant the others are compared against: one of the run's variants, over the simulation's own baseline. */
+	baselineVariantId: entityId.optional(),
+	/**
+	* A recording run: these server tools answer live on every variant, so the recorder keeps their real answers for
+	* later replay. Every variant must be today's version (no overlay), and every target must record in `full`.
+	*/
+	recordTools: array(string().min(1).max(255)).min(1).max(64).optional()
+});
+const estimateSimulationRunResponseSchema = object({
+	dryRun: literal(true),
+	estimate: runEstimateSchema,
+	/** How each variant target would record this run, keyed by target id: the kill switch, then the target (D1). */
+	recording: record(string(), frozenTargetRecordingSchema).optional()
+});
+const startSimulationRunResponseSchema = object({
+	dryRun: literal(false),
+	runId: entityId,
+	status: simulationRunStatusSchema,
+	estimate: runEstimateSchema
+});
+discriminatedUnion("dryRun", [estimateSimulationRunResponseSchema, startSimulationRunResponseSchema]);
+simulationPageSchema(simulationRunSchema);
+const simulationRunResponseSchema = object({
+	run: simulationRunSchema,
+	reportId: entityId.nullable()
+});
+object({ 
+/** Comma-separated server tools; the response then counts this run's live calls to each that the recorder kept. */
+recordedCallsFor: string().max(4096).optional() });
+simulationRunResponseSchema.extend({ 
+/** Per tool named in `recordedCallsFor`: this run's live calls the recorder kept, 0 for a tool with none. */
+recordedCalls: record(string(), number().int()).optional() });
+object({ run: simulationRunSchema });
+simulationRunResponseSchema.extend({ repair: object({
+	/** Episodes whose AI judge failed, graded again from their stored transcripts. */
+	regrading: number().int(),
+	/** Episodes the platform kept from running, and recording misses since recorded, played again under fresh ids. */
+	replaying: number().int()
+}) });
+simulationRunResponseSchema.extend({ advance: object({
+	/** Episodes this call finished; one it parked at the time budget resumes on the next call. */
+	episodesFinished: number().int(),
+	/** Another advance call holds the run's lease, so this one did nothing. */
+	busy: boolean()
+}) });
+simulationListQuerySchema.extend({
+	variantId: entityId.optional(),
+	simulatedUserId: entityId.optional(),
+	taskId: entityId.optional(),
+	status: simulationEpisodeStatusSchema.optional(),
+	passed: _enum(["true", "false"]).optional()
+});
+simulationPageSchema(simulationEpisodeSchema);
+object({
+	episode: simulationEpisodeSchema,
+	transcript: simulationEpisodeTranscriptSchema.nullable(),
+	scores: array(simulationEpisodeScoreSchema),
+	layerStats: array(turnLayerFactsSchema),
+	/** Each synthesized answer's review by its exchange id: plausible, implausible, or null when unreviewed (D5). */
+	synthesisReviews: record(string(), boolean().nullable()).optional()
+});
+object({ format: _enum([
+	"json",
+	"csv",
+	"md"
+]).optional() });
+object({ report: simulationReportSchema });
+simulationListQuerySchema.extend({
+	productId: entityId.optional(),
+	simulationId: entityId.optional(),
+	regressionsOnly: _enum(["true", "false"]).optional()
+});
+simulationPageSchema(simulationReportSchema.omit({ body: true }));
+/** Which proposer writes the designs: the deterministic rules (rung 0) or one model call over the rubric (rung 1, D7). */
+const VARIANT_PROPOSERS = ["rules", "model"];
+object({
+	runId: entityId,
+	/** `model` falls back to `rules` when the model call fails or proposes nothing that passes admission. */
+	proposer: _enum(VARIANT_PROPOSERS).default("rules")
+});
+object({
+	variants: array(simulationVariantSchema),
+	/** Why nothing, or less than asked, was proposed. */
+	notes: array(string()),
+	/** The rung that wrote these proposals: `rules` after a model fallback too. */
+	proposer: _enum(VARIANT_PROPOSERS).optional()
+});
+object({
+	url: string().url().max(2048),
+	kind: _enum([
+		"mcp",
+		"openapi",
+		"a2a"
+	]),
+	name: string().min(1).max(255).optional(),
+	savedServerName: string().min(1).max(128).optional()
+});
+object({
+	product: object({
+		id: entityId,
+		name: string(),
+		kind: productKindSchema
+	}),
+	target: simulationTargetSchema,
+	serverName: string().nullable(),
+	tools: array(probedSimulationToolSchema)
+});
+object({
+	url: string(),
+	host: string(),
+	oauthHinted: boolean(),
+	suggestedServerName: string()
+});
+object({
+	error: string(),
+	code: _enum([
+		"SIMULATION_NOT_FOUND",
+		"SIMULATION_SLUG_TAKEN",
+		"SIMULATION_VARIANT_KEY_TAKEN",
+		"SIMULATION_INVALID_REQUEST",
+		"SIMULATION_PRODUCT_NOT_FOUND",
+		"SIMULATION_TARGET_NOT_SUPPORTED",
+		"SIMULATION_TARGET_AUTH_REQUIRED",
+		"SIMULATION_LIVE_TOOLS_NOT_ACKNOWLEDGED",
+		"SIMULATION_ESTIMATE_OVER_BUDGET",
+		"SIMULATION_TOO_MANY_RUNNING",
+		"SIMULATION_LIMIT_EXCEEDED",
+		"SIMULATION_OVERLAY_INVALID",
+		"SIMULATION_OVERLAY_NOT_OWN_TARGET",
+		"SIMULATION_RUN_NOT_CANCELLABLE",
+		"SIMULATION_RUN_NOT_REPAIRABLE",
+		"SIMULATION_VARIANT_INVALID",
+		"SIMULATION_IDENTITY_INVALID",
+		"SIMULATION_FORBIDDEN",
+		"SIMULATION_QUOTA_EXCEEDED",
+		"SIMULATION_REPORT_NOT_READY",
+		"SIMULATION_DRAFT_FAILED",
+		"SIMULATION_RATE_LIMITED",
+		"SIMULATION_SYNTHETIC_DATASET_DDL_INVALID",
+		"SIMULATION_SYNTHETIC_DATASET_SCRUB_REFUSED",
+		"SIMULATION_SYNTHETIC_DATASET_BUILD_FAILED",
+		"SIMULATION_SYNTHETIC_DATASET_SOURCE_UNMATCHED",
+		"SIMULATIONS_DISABLED",
+		"SIMULATION_WORLD_MISMATCH",
+		"SIMULATION_FUTURE_OP_INVALID",
+		"SIMULATION_SYNTH_UNGROUNDED",
+		"SIMULATION_RECORDING_BLOCKED"
+	]),
+	details: unknown().optional()
+});
+object({ deleted: literal(true) }), object({ deleted: literal(true) }), object({ deleted: literal(true) }), object({ deleted: literal(true) });
+object({
+	line: number().int(),
+	reason: _enum([
+		"DDL_SYNTAX",
+		"DDL_UNSUPPORTED",
+		"DDL_INVALID"
+	])
+});
+object({ report: datasetScrubReportSchema });
+const simulationSyntheticDatasetResponseSchema = object({ syntheticDataset: simulationSyntheticDatasetSchema });
+simulationSyntheticDatasetResponseSchema.extend({ 
+/** What the DDL parse found: tables, and statements skipped because they cannot change which rows are valid. */
+ddl: object({
+	tables: number().int(),
+	skipped: array(object({
+		line: number().int(),
+		summary: string()
+	}))
+}) });
+simulationPageSchema(simulationSyntheticDatasetSchema);
+simulationSyntheticDatasetResponseSchema.extend({
+	outcome: _enum([
+		"built",
+		"reused",
+		"in_progress"
+	]),
+	/** Set when this call built: model-written cells, deterministic fallbacks, and how many model calls. */
+	stats: object({
+		tables: number().int(),
+		rows: number().int(),
+		modelCalls: number().int(),
+		modelCells: number().int(),
+		fallbackCells: number().int()
+	}).nullable()
+});
+object({ deleted: literal(true) });
+// src/lib/candidate-bundle.ts
+/** The largest compressed bundle the API accepts (`POST /v1/simulations/candidate-bundles`). */
+const CANDIDATE_BUNDLE_MAX_BYTES = 262144e3;
+/** The API refuses a manifest larger than this. */
+const CANDIDATE_MANIFEST_MAX_BYTES = 16384;
+var CandidateBundleError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "CandidateBundleError";
+	}
+};
+const ARCHIVE_SUFFIXES = [".tgz", ".tar.gz"];
+/** Classifies `<path>` as a candidate directory to pack or a gzipped tar to upload as is. */
+async function resolveCandidateBundleInput(path) {
+	const absolute = resolve(path);
+	const info = await stat(absolute).catch(() => null);
+	if (!info) throw new CandidateBundleError("NOT_FOUND", `${path} does not exist.`);
+	if (info.isDirectory()) return {
+		kind: "directory",
+		path: absolute
+	};
+	const lower = absolute.toLowerCase();
+	if (!info.isFile() || !ARCHIVE_SUFFIXES.some((suffix) => lower.endsWith(suffix))) throw new CandidateBundleError("UNSUPPORTED_INPUT", `${path} is neither a directory nor a .tgz / .tar.gz file.`);
+	const handle = await open(absolute, "r");
+	try {
+		const magic = Buffer.alloc(2);
+		await handle.read(magic, 0, 2, 0);
+		if (magic[0] !== 31 || magic[1] !== 139) throw new CandidateBundleError("UNSUPPORTED_INPUT", `${path} is not gzip-compressed.`);
+	} finally {
+		await handle.close();
+	}
+	return {
+		kind: "archive",
+		path: absolute
+	};
+}
+/** Reads and validates the directory's `runtype-candidate.json` with the same parser the API uses. */
+async function readCandidateManifest(dir) {
+	const file = join(dir, CANDIDATE_MANIFEST_FILENAME);
+	const info = await lstat(file).catch(() => null);
+	if (!info) throw new CandidateBundleError("MANIFEST_MISSING", `No ${CANDIDATE_MANIFEST_FILENAME} at the root of ${dir}. A candidate bundle needs its manifest at its root.`);
+	if (!info.isFile()) throw new CandidateBundleError("MANIFEST_INVALID", `${CANDIDATE_MANIFEST_FILENAME} must be a regular file, not a symlink or directory.`);
+	if (info.size > 16384) throw new CandidateBundleError("MANIFEST_INVALID", `${CANDIDATE_MANIFEST_FILENAME} is over ${CANDIDATE_MANIFEST_MAX_BYTES / 1024} KB.`);
+	const parsed = parseCandidateManifest(await readFile(file, "utf8"));
+	if (!parsed.ok) throw new CandidateBundleError("MANIFEST_INVALID", `${CANDIDATE_MANIFEST_FILENAME} is invalid: ${parsed.error}`);
+	return parsed.manifest;
+}
+/** True for paths a bundle never carries: `.git`, `.DS_Store` and `node_modules/.cache`, at any depth. */
+function isExcludedCandidatePath(posixPath) {
+	const segments = posixPath.split("/");
+	return segments.some((segment, index) => segment === ".git" || segment === ".DS_Store" || segment === ".cache" && segments[index - 1] === "node_modules");
+}
+function compareBytes(a, b) {
+	return Buffer.compare(Buffer.from(a, "utf8"), Buffer.from(b, "utf8"));
+}
+/** Every entry under `dir` in archive order: the manifest first, then the rest sorted by path bytes. */
+async function listCandidateEntries(dir, options = {}) {
+	const skip = new Set((options.skipAbsolute ?? []).map((path) => resolve(path)));
+	const entries = [];
+	const walk = async (current) => {
+		const names = await readdir(current);
+		for (const name of names) {
+			const absolute = join(current, name);
+			const path = relative(dir, absolute).split(sep).join("/");
+			if (isExcludedCandidatePath(path) || skip.has(absolute)) continue;
+			const info = await lstat(absolute);
+			const executable = (info.mode & 73) !== 0;
+			if (info.isSymbolicLink()) {
+				const linkTarget = await readlink(absolute);
+				entries.push({
+					path,
+					type: "symlink",
+					absolute,
+					size: 0,
+					executable,
+					linkTarget
+				});
+			} else if (info.isDirectory()) {
+				entries.push({
+					path,
+					type: "directory",
+					absolute,
+					size: 0,
+					executable
+				});
+				await walk(absolute);
+			} else if (info.isFile()) entries.push({
+				path,
+				type: "file",
+				absolute,
+				size: info.size,
+				executable
+			});
+		}
+	};
+	await walk(dir);
+	const archivePath = (entry) => entry.type === "directory" ? `${entry.path}/` : entry.path;
+	entries.sort((a, b) => {
+		if (a.path === "runtype-candidate.json") return -1;
+		if (b.path === "runtype-candidate.json") return 1;
+		return compareBytes(archivePath(a), archivePath(b));
+	});
+	return entries;
+}
+const BLOCK = 512;
+const USTAR_NAME_BYTES = 100;
+const MAX_OCTAL_SIZE = 8589934591;
+const FIXED_MTIME = 0;
+const PAX_HEADER_NAME = "././@PaxHeader";
+const encoder = new TextEncoder();
+function writeText(header, offset, length, value) {
+	header.set(encoder.encode(value).subarray(0, length), offset);
+}
+function writeOctal(header, offset, length, value) {
+	writeText(header, offset, length - 1, value.toString(8).padStart(length - 1, "0"));
+}
+function fitsUstar(value) {
+	return /^[\x20-\x7e]*$/.test(value) && value.length <= USTAR_NAME_BYTES;
+}
+function ustarFallback(value) {
+	return value.replace(/[^\x20-\x7e]/g, "_").slice(0, USTAR_NAME_BYTES);
+}
+function ustarHeader(fields) {
+	const header = new Uint8Array(BLOCK);
+	writeText(header, 0, USTAR_NAME_BYTES, fields.name);
+	writeOctal(header, 100, 8, fields.mode);
+	writeOctal(header, 108, 8, 0);
+	writeOctal(header, 116, 8, 0);
+	writeOctal(header, 124, 12, fields.size);
+	writeOctal(header, 136, 12, FIXED_MTIME);
+	header.fill(32, 148, 156);
+	header[156] = fields.typeflag.charCodeAt(0);
+	writeText(header, 157, USTAR_NAME_BYTES, fields.linkname ?? "");
+	writeText(header, 257, 6, "ustar");
+	writeText(header, 263, 2, "00");
+	writeOctal(header, 329, 8, 0);
+	writeOctal(header, 337, 8, 0);
+	writeText(header, 148, 7, `${header.reduce((sum, byte) => sum + byte, 0).toString(8).padStart(6, "0")}\0`);
+	return header;
+}
+/** One pax extended-header record: its decimal length counts the length digits themselves. */
+function paxRecord(key, value) {
+	const body = ` ${key}=${value}\n`;
+	const bodyBytes = Buffer.byteLength(body, "utf8");
+	let length = bodyBytes + String(bodyBytes).length;
+	while (length !== bodyBytes + String(length).length) length = bodyBytes + String(length).length;
+	return `${length}${body}`;
+}
+function padding(size) {
+	return new Uint8Array((BLOCK - size % BLOCK) % BLOCK);
+}
+function entryMode(entry) {
+	if (entry.type === "symlink") return 511;
+	return entry.type === "directory" || entry.executable ? 493 : 420;
+}
+/** The uncompressed tar stream for `entries`: ustar headers, a pax header for long or non-ASCII names. */
+async function* tarCandidateEntries(entries) {
+	for (const entry of entries) {
+		const name = entry.type === "directory" ? `${entry.path}/` : entry.path;
+		const records = [];
+		if (!fitsUstar(name)) records.push(paxRecord("path", name));
+		if (entry.linkTarget !== void 0 && !fitsUstar(entry.linkTarget)) records.push(paxRecord("linkpath", entry.linkTarget));
+		if (entry.size > MAX_OCTAL_SIZE) records.push(paxRecord("size", String(entry.size)));
+		if (records.length > 0) {
+			const data = encoder.encode(records.join(""));
+			yield ustarHeader({
+				name: PAX_HEADER_NAME,
+				mode: 420,
+				size: data.byteLength,
+				typeflag: "x"
+			});
+			yield data;
+			yield padding(data.byteLength);
+		}
+		const typeflag = entry.type === "file" ? "0" : entry.type === "directory" ? "5" : "2";
+		yield ustarHeader({
+			name: ustarFallback(name),
+			mode: entryMode(entry),
+			size: entry.size > MAX_OCTAL_SIZE ? 0 : entry.size,
+			typeflag,
+			linkname: entry.linkTarget === void 0 ? void 0 : ustarFallback(entry.linkTarget)
+		});
+		if (entry.type !== "file") continue;
+		let read = 0;
+		for await (const chunk of createReadStream(entry.absolute)) {
+			const bytes = chunk;
+			read += bytes.byteLength;
+			if (read > entry.size) break;
+			yield bytes;
+		}
+		if (read !== entry.size) throw new CandidateBundleError("CHANGED_DURING_PACK", `${entry.path} changed while it was being packed; run the push again.`);
+		yield padding(entry.size);
+	}
+	yield new Uint8Array(BLOCK * 2);
+}
+const GZIP_INPUT_CHUNK = 65536;
+/** Gzip with a zero mtime over fixed-size input chunks, so equal bytes in give equal bytes out on any machine. */
+function deterministicGzip() {
+	const gzip = new Gzip({
+		level: 6,
+		mtime: FIXED_MTIME
+	});
+	let block = new Uint8Array(GZIP_INPUT_CHUNK);
+	let filled = 0;
+	const transform = new Transform({
+		transform(chunk, _encoding, callback) {
+			try {
+				let offset = 0;
+				while (offset < chunk.byteLength) {
+					const count = Math.min(GZIP_INPUT_CHUNK - filled, chunk.byteLength - offset);
+					block.set(chunk.subarray(offset, offset + count), filled);
+					filled += count;
+					offset += count;
+					if (filled === GZIP_INPUT_CHUNK) {
+						gzip.push(block);
+						block = new Uint8Array(GZIP_INPUT_CHUNK);
+						filled = 0;
+					}
+				}
+				callback();
+			} catch (error) {
+				callback(error);
+			}
+		},
+		flush(callback) {
+			try {
+				gzip.push(block.subarray(0, filled), true);
+				callback();
+			} catch (error) {
+				callback(error);
+			}
+		}
+	});
+	gzip.ondata = (data) => {
+		transform.push(data);
+	};
+	return transform;
+}
+function tooLarge() {
+	return new CandidateBundleError("TOO_LARGE", `The bundle is over ${CANDIDATE_BUNDLE_MAX_BYTES / 1048576} MB compressed, the API's limit.`);
+}
+/** Hashes and counts the bytes passing through, failing once they pass `maxBytes`. */
+function digestAndCount(maxBytes) {
+	const hash = createHash("sha256");
+	let bytes = 0;
+	return {
+		transform: new Transform({ transform(chunk, _encoding, callback) {
+			bytes += chunk.byteLength;
+			if (bytes > maxBytes) {
+				callback(tooLarge());
+				return;
+			}
+			hash.update(chunk);
+			callback(null, chunk);
+		} }),
+		result: () => ({
+			sha256: hash.digest("hex"),
+			bytes
+		})
+	};
+}
+/**
+* Packs `dir` into a reproducible `.tar.gz` at `outFile`, hashing it as it is written: the manifest first, entries
+* sorted, mtime 0, uid/gid 0 with no owner names, normalized modes, symlinks kept as symlinks.
+*/
+async function packCandidateDirectory(dir, outFile, options = {}) {
+	const manifest = await readCandidateManifest(dir);
+	const entries = await listCandidateEntries(dir, { skipAbsolute: [outFile, ...options.skip ?? []] });
+	const measured = digestAndCount(options.maxBytes ?? 262144e3);
+	await pipeline(Readable.from(tarCandidateEntries(entries)), deterministicGzip(), measured.transform, createWriteStream(outFile));
+	return {
+		...measured.result(),
+		manifest,
+		entries: entries.length
+	};
+}
+/** Streams an existing archive through SHA-256, refusing one over `maxBytes` before reading it. */
+async function digestCandidateArchive(file, options = {}) {
+	const maxBytes = options.maxBytes ?? 262144e3;
+	if ((await stat(file)).size > maxBytes) throw tooLarge();
+	const hash = createHash("sha256");
+	let bytes = 0;
+	for await (const chunk of createReadStream(file)) {
+		bytes += chunk.byteLength;
+		hash.update(chunk);
+	}
+	if (bytes > maxBytes) throw tooLarge();
+	return {
+		sha256: hash.digest("hex"),
+		bytes
+	};
+}
+var ExchangesFileError = class extends Error {
+	code = "INVALID_INPUT";
+	constructor(message) {
+		super(message);
+		this.name = "ExchangesFileError";
+	}
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toExchange(value, where) {
+	if (!isRecord(value)) throw new ExchangesFileError(`${where}: expected an object.`);
+	const { tool, arguments: args, result, isError } = value;
+	if (typeof tool !== "string" || tool.length === 0) throw new ExchangesFileError(`${where}: "tool" must be a non-empty string.`);
+	if (!isRecord(args)) throw new ExchangesFileError(`${where}: "arguments" must be an object.`);
+	if (!("result" in value)) throw new ExchangesFileError(`${where}: "result" is missing.`);
+	if (isError !== void 0 && typeof isError !== "boolean") throw new ExchangesFileError(`${where}: "isError" must be true or false.`);
+	return {
+		tool,
+		arguments: args,
+		result,
+		...isError === void 0 ? {} : { isError }
+	};
+}
+/** Reads a JSON array, or JSON lines, of `{ tool, arguments, result, isError? }`. */
+function parseExchangesFile(text) {
+	const trimmed = text.trim();
+	if (trimmed.length === 0) throw new ExchangesFileError("The file holds no exchanges.");
+	if (trimmed.startsWith("[")) {
+		let parsed;
+		try {
+			parsed = JSON.parse(trimmed);
+		} catch (error) {
+			throw new ExchangesFileError(`The file is not valid JSON: ${error.message}`);
+		}
+		if (!Array.isArray(parsed) || parsed.length === 0) throw new ExchangesFileError("The JSON array holds no exchanges.");
+		return parsed.map((entry, index) => toExchange(entry, `Entry ${index + 1}`));
+	}
+	const exchanges = [];
+	for (const [index, line] of text.split("\n").entries()) {
+		if (line.trim().length === 0) continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(line);
+		} catch (error) {
+			throw new ExchangesFileError(`Line ${index + 1} is not valid JSON: ${error.message}`);
+		}
+		exchanges.push(toExchange(parsed, `Line ${index + 1}`));
+	}
+	return exchanges;
+}
+/** Uploads in requests of at most 500 and returns how many the API recorded. */
+async function uploadExchangesInBatches(client, targetId, exchanges) {
+	let recorded = 0;
+	for (let start = 0; start < exchanges.length; start += 500) {
+		const batch = exchanges.slice(start, start + 500);
+		const response = await client.simulations.uploadExchanges(targetId, { exchanges: batch });
+		recorded += response.recorded;
+	}
+	return recorded;
+}
+function apiErrorCode$1(error) {
+	const data = error.data;
+	if (!isRecord(data)) return void 0;
+	return typeof data.code === "string" ? data.code : void 0;
+}
+/** Maps an API failure to the code and message the command prints. */
+function describeSimulationApiError(error) {
+	if (error instanceof ExchangesFileError) return {
+		code: error.code,
+		message: error.message
+	};
+	if (!(error instanceof RuntypeApiError)) return {
+		code: "EXECUTION_FAILED",
+		message: error instanceof Error ? error.message : String(error)
+	};
+	const code = apiErrorCode$1(error);
+	if (error.statusCode === 401) return {
+		code: "AUTH_REQUIRED",
+		message: "Not authenticated: run `runtype login` or set RUNTYPE_API_KEY."
+	};
+	if (code === "SIMULATIONS_DISABLED") return {
+		code,
+		message: "Simulations are not available on this API. They run on staging: pass --api-url https://api.runtype-staging.com with a staging key."
+	};
+	return {
+		code: code ?? "EXECUTION_FAILED",
+		message: error.message
+	};
+}
+function fail(error, json, what) {
+	const { code, message } = describeSimulationApiError(error);
+	if (json) printJson({
+		success: false,
+		error: {
+			code,
+			message
+		}
+	});
+	else {
+		console.error(chalk.red(what));
+		console.error(chalk.red(message));
+	}
+	process.exit(1);
+}
+async function authedClient() {
+	const apiKey = await ensureAuth();
+	return apiKey ? createCliClient(apiKey) : null;
+}
+/** Adds `exchanges upload` and `report` to the `simulations` command. */
+function registerToolMemoryCommands(simulations) {
+	simulations.command("exchanges").description("A target's recorded tool exchanges: what its server answered").command("upload <target> <file>").description("Record calls your server answered outside a simulation, from a JSON array or JSON lines of { tool, arguments, result, isError? }").option("--json", "Output as JSON").action(async (target, file, options) => {
+		let recorded;
+		let sent;
+		try {
+			const parsed = parseExchangesFile(await readFile(file, "utf8"));
+			const client = await authedClient();
+			if (!client) process.exit(1);
+			sent = parsed.length;
+			recorded = await uploadExchangesInBatches(client, target, parsed);
+		} catch (error) {
+			fail(error, options.json, "Failed to upload exchanges");
+		}
+		if (options.json) {
+			printJson({
+				success: true,
+				targetId: target,
+				sent,
+				recorded
+			});
+			return;
+		}
+		console.log(chalk.green(`✓ Recorded ${recorded} of ${sent} exchanges for ${target}`));
+	});
+	simulations.command("report <runId>").description("Print a finished run's report as Markdown, or with --brief export its future design as a design brief").option("--brief", "Export the design brief (records it, so later live runs track adoption)").option("--json", "Output as JSON").action(async (runId, options) => {
+		try {
+			const client = await authedClient();
+			if (!client) process.exit(1);
+			const path = `/simulations/runs/${encodeURIComponent(runId)}/report`;
+			if (options.brief) {
+				const brief = await client.simulations.exportDesignBrief(runId);
+				if (options.json) printJson(brief);
+				else console.log(brief.markdown);
+				return;
+			}
+			if (options.json) {
+				printJson(await client.get(path));
+				return;
+			}
+			console.log(await client.get(path, { format: "md" }));
+		} catch (error) {
+			fail(error, options.json, options.brief ? "Failed to export the design brief" : "Failed to read the report");
+		}
+	});
+}
+// src/commands/simulations.ts
+const ACTION_SCOPE = {
+	upload: "SIMULATIONS:WRITE",
+	"read-target": "SIMULATIONS:READ",
+	"write-target": "SIMULATIONS:WRITE",
+	conformance: "SIMULATIONS:RUN"
+};
+var CandidatePushError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "CandidatePushError";
+	}
+};
+function apiErrorCode(error) {
+	const data = error.data;
+	if (typeof data !== "object" || data === null || !("code" in data)) return void 0;
+	return typeof data.code === "string" ? data.code : void 0;
+}
+/** Maps an API failure from one step of a push to a message that says what to do about it. */
+function describeCandidateApiError(error, action) {
+	if (!(error instanceof RuntypeApiError)) return new CandidatePushError("EXECUTION_FAILED", error instanceof Error ? error.message : String(error));
+	const code = apiErrorCode(error);
+	switch (error.statusCode) {
+		case 401: return new CandidatePushError("AUTH_REQUIRED", "Not authenticated: run `runtype login` or set RUNTYPE_API_KEY.");
+		case 403: return new CandidatePushError("FORBIDDEN", `${error.message} This step needs an API key with ${ACTION_SCOPE[action]}.`);
+		case 404:
+			if (code === "SIMULATIONS_DISABLED") return new CandidatePushError("SIMULATIONS_DISABLED", "Simulations are not available on this API. They run on staging: pass --api-url https://api.runtype-staging.com with a staging key.");
+			return new CandidatePushError("NOT_FOUND", `Not found: ${error.message}`);
+		case 411: return new CandidatePushError("LENGTH_REQUIRED", "The API refused the upload because it carried no Content-Length.");
+		case 413: return new CandidatePushError("TOO_LARGE", "The API refused the bundle: it is over the 250 MB compressed limit.");
+		case 422: return new CandidatePushError("INVALID_BUNDLE", action === "upload" ? `The API rejected the bundle: ${error.message}` : `The API rejected the request: ${error.message}`);
+		case 503: return new CandidatePushError("STORAGE_NOT_CONFIGURED", "Bundle storage is not configured on this API, so it cannot take candidate bundles.");
+		default: return new CandidatePushError(code ?? "EXECUTION_FAILED", error.message);
+	}
+}
+/** Streams the archive to the API with its digest and an explicit Content-Length. */
+async function uploadCandidateBundleFile(client, file, digest) {
+	const body = Readable.toWeb(createReadStream(file));
+	return await (await client.requestStream(`/simulations/candidate-bundles?digest=${digest.sha256}`, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/gzip",
+			"Content-Length": String(digest.bytes)
+		},
+		body,
+		duplex: "half"
+	})).json();
+}
+async function pointTargetAtBundle(client, uploaded, options) {
+	const mcp = options.mcpTarget ? { mcpTargetId: options.mcpTarget } : {};
+	if (options.createTarget !== void 0) {
+		const config = {
+			kind: "sandbox_candidate",
+			bundle: uploaded.bundle,
+			manifest: uploaded.manifest,
+			...mcp
+		};
+		return {
+			target: (await client.post("/simulations/targets", {
+				name: options.createTarget,
+				config
+			}).catch((error) => {
+				throw describeCandidateApiError(error, "write-target");
+			})).target,
+			action: "created"
+		};
+	}
+	if (options.target === void 0) return null;
+	const targetPath = `/simulations/targets/${encodeURIComponent(options.target)}`;
+	const existing = await client.get(targetPath).catch((error) => {
+		throw describeCandidateApiError(error, "read-target");
+	});
+	if (existing.target.config.kind !== "sandbox_candidate") throw new CandidatePushError("INVALID_TARGET", `Target ${options.target} is a ${existing.target.config.kind} target, not a sandbox_candidate target.`);
+	const config = {
+		...existing.target.config,
+		bundle: uploaded.bundle,
+		manifest: uploaded.manifest,
+		...mcp
+	};
+	return {
+		target: (await client.patch(targetPath, { config }).catch((error) => {
+			throw describeCandidateApiError(error, "write-target");
+		})).target,
+		action: "updated"
+	};
+}
+function formatSize(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)} KB`;
+	return `${(bytes / 1048576).toFixed(1)} MB`;
+}
+const STEP_MARK = {
+	passed: chalk.green("✓"),
+	failed: chalk.red("✗"),
+	skipped: chalk.gray("-")
+};
+function printConformance(result) {
+	const verdict = result.passed ? chalk.green("passed") : chalk.red("failed");
+	console.log(`\n${chalk.cyan("Conformance:")} ${verdict}`);
+	for (const step of result.steps) {
+		const detail = step.detail ? chalk.gray(` ${step.detail}`) : "";
+		const status = step.status === "passed" ? "" : ` ${step.status}`;
+		console.log(`  ${STEP_MARK[step.status]} ${step.step}${status}${detail}`);
+	}
+	if (result.blockedHosts.length > 0) console.log(chalk.red(`  Blocked hosts: ${result.blockedHosts.join(", ")}`));
+}
+function printPushSummary(uploaded, change, savedArchive) {
+	console.log(chalk.green(uploaded.reused ? "✓ Candidate bundle already stored (reused)" : "✓ Candidate bundle uploaded"));
+	const { manifest } = uploaded;
+	console.log(`  ${chalk.gray("Digest:")} ${uploaded.bundle.sha256}`);
+	console.log(`  ${chalk.gray("Size:")} ${formatSize(uploaded.compressedBytes)}`);
+	console.log(`  ${chalk.gray("Manifest:")} ${manifest.name} (${manifest.framework.name} ${manifest.framework.version}, ${manifest.runtime}, ${manifest.protocol}, ${manifest.sessions})`);
+	if (savedArchive) console.log(`  ${chalk.gray("Archive:")} ${savedArchive}`);
+	if (change) {
+		console.log(`  ${chalk.gray("Target:")} ${change.target.id} (${change.action})`);
+		return;
+	}
+	console.log(`\n${chalk.cyan("Bundle for a sandbox_candidate target config:")}`);
+	console.log(JSON.stringify({ bundle: uploaded.bundle }, null, 2));
+}
+function validatePushOptions(options) {
+	if (options.target !== void 0 && options.createTarget !== void 0) throw new CandidatePushError("INVALID_INPUT", "Pass either --target or --create-target, not both.");
+	const hasTarget = options.target !== void 0 || options.createTarget !== void 0;
+	if (options.mcpTarget !== void 0 && !hasTarget) throw new CandidatePushError("INVALID_INPUT", "--mcp-target needs --target or --create-target.");
+	if (options.conformance && !hasTarget) throw new CandidatePushError("INVALID_INPUT", "--conformance needs --target or --create-target: the check runs against a target.");
+}
+async function runPush(path, options) {
+	validatePushOptions(options);
+	const input = await resolveCandidateBundleInput(path);
+	if (input.kind === "archive" && options.out) throw new CandidatePushError("INVALID_INPUT", "--out applies only when packing a directory.");
+	let archive = input.path;
+	let scratch;
+	let digest;
+	try {
+		if (input.kind === "directory") {
+			await readCandidateManifest(input.path);
+			if (options.out) {
+				const saved = resolve(options.out);
+				const partial = `${saved}.partial-${process.pid}-${Date.now()}`;
+				try {
+					digest = await packCandidateDirectory(input.path, partial, { skip: [saved] });
+					await rename(partial, saved);
+				} catch (error) {
+					await rm(partial, { force: true });
+					throw error;
+				}
+				archive = saved;
+			} else {
+				scratch = await mkdtemp(join(tmpdir(), "runtype-candidate-"));
+				archive = join(scratch, "candidate.tgz");
+				digest = await packCandidateDirectory(input.path, archive);
+			}
+		} else digest = await digestCandidateArchive(input.path);
+		const apiKey = await ensureAuth();
+		if (!apiKey) return false;
+		const client = createCliClient(apiKey);
+		const uploaded = await uploadCandidateBundleFile(client, archive, digest).catch((error) => {
+			throw describeCandidateApiError(error, "upload");
+		});
+		const change = await pointTargetAtBundle(client, uploaded, options);
+		const conformance = options.conformance && change ? await client.post(`/simulations/targets/${encodeURIComponent(change.target.id)}/conformance`, {}).catch((error) => {
+			throw describeCandidateApiError(error, "conformance");
+		}) : void 0;
+		const savedArchive = input.kind === "directory" && options.out ? archive : void 0;
+		if (options.json) printJson({
+			...uploaded,
+			...savedArchive ? { archive: savedArchive } : {},
+			...change ? { target: {
+				id: change.target.id,
+				name: change.target.name,
+				action: change.action
+			} } : {},
+			...conformance ? { conformance } : {}
+		});
+		else {
+			printPushSummary(uploaded, change, savedArchive);
+			if (conformance) printConformance(conformance);
+		}
+		return conformance ? conformance.passed : true;
+	} finally {
+		if (scratch) await rm(scratch, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function reportFailure(error, json) {
+	const code = error instanceof CandidatePushError || error instanceof CandidateBundleError ? error.code : "EXECUTION_FAILED";
+	const message = error instanceof Error ? error.message : String(error);
+	if (json) printJson({
+		success: false,
+		error: {
+			code,
+			message
+		}
+	});
+	else {
+		console.error(chalk.red("Failed to push candidate bundle"));
+		console.error(chalk.red(message));
+	}
+}
+const simulationsCommand = new Command("simulations").description("Simulations: sandbox candidates, recorded tool exchanges and reports");
+registerToolMemoryCommands(simulationsCommand);
+simulationsCommand.command("candidate").description("Sandbox candidates: an agent run as real code in a Runtype sandbox").command("push <path>").description("Upload a candidate bundle: a directory with runtype-candidate.json at its root (packed reproducibly) or a .tgz / .tar.gz").option("--target <id>", "Point this sandbox_candidate target at the new bundle, keeping its other config").option("--create-target <name>", "Create a sandbox_candidate target for the new bundle").option("--mcp-target <id>", "With --target or --create-target: the external_mcp target whose tools episodes get (config.mcpTargetId)").option("--conformance", "Run the conformance check on the target after the push").option("--out <file>", "Also save the packed archive to this file (directory input only)").option("--json", "Output as JSON").action(async (path, options) => {
+	let passed;
+	try {
+		passed = await runPush(path, options);
+	} catch (error) {
+		reportFailure(error, options.json);
+		process.exit(1);
+	}
+	if (!passed) process.exit(1);
+});
+export { simulationsCommand };
+