@tangle-network/sandbox-cli 0.21.23 → 0.21.25

package/dist/graph-viewer/workspace-model-Ewf17pTW.js

@@ -0,0 +1,1541 @@
+import { D as ee, E as te, g as ne, j as re, k as ie, m as ae, n as oe, p as e } from "./run-receipt-Bvi4-KVM.js";
+import { z as t } from "zod";
+//#region src/workspace/run-execution.ts
+var se = t.object({
+	alive: t.boolean(),
+	lastActivityAt: t.string().nullable(),
+	failedAttempts: t.number(),
+	settleKind: t.string().nullable(),
+	endingError: t.object({
+		name: t.string(),
+		message: t.string()
+	}).nullable(),
+	lastAttempt: t.object({
+		error: t.string().nullable(),
+		classification: t.string().nullable(),
+		madeProgress: t.boolean().nullable().optional(),
+		retryInMs: t.number().nullable().optional(),
+		at: t.string().nullable().optional()
+	}).nullable(),
+	diagnoses: t.array(t.object({
+		id: t.string(),
+		title: t.string().optional(),
+		fix: t.string()
+	})),
+	diagnosisError: t.string().nullable().optional(),
+	resume: t.object({
+		status: t.enum([
+			"preserved",
+			"unavailable",
+			"unknown"
+		]),
+		command: t.string().nullable(),
+		reason: t.string().nullable()
+	}),
+	runnerTail: t.string().nullable().optional()
+}), n = t.iso.datetime({ offset: !0 }), r = t.number().nullable(), i = t.string().regex(/^[0-9a-f]{64}$/), a = t.object({
+	runId: t.string().optional(),
+	nodeId: t.string().nullable().optional(),
+	code: t.string(),
+	detail: t.string()
+}).catchall(t.unknown()), o = t.object({
+	ms: t.number().nonnegative().nullable(),
+	tokens: t.number().nonnegative().nullable(),
+	listUsd: r
+}), s = t.number().nonnegative().nullable(), ce = t.object({
+	seat: t.string(),
+	provider: t.string().nullable(),
+	model: t.string().nullable(),
+	startedAt: n,
+	endedAt: n.nullable().optional(),
+	reason: t.string().nullable().optional(),
+	seatWeeks: s,
+	seatWeeksKnown: t.boolean()
+}).catchall(t.unknown()), c = t.object({
+	paidUsd: r,
+	subscriptionUsd: r,
+	apiUsd: r,
+	sandboxUsd: r,
+	routerUsd: r,
+	costBasisUsd: r,
+	listUsd: r,
+	tokens: t.object({
+		input: t.number().nonnegative(),
+		output: t.number().nonnegative(),
+		cacheRead: t.number().nonnegative(),
+		cacheWrite: t.number().nonnegative()
+	}).nullable(),
+	sandboxHours: t.number().nonnegative().nullable(),
+	seatWeeks: s.optional(),
+	seatWeeksKnown: t.boolean().optional(),
+	bySeat: t.array(t.object({
+		seat: t.string(),
+		provider: t.string().nullable(),
+		model: t.string().nullable(),
+		seatWeeks: s,
+		known: t.boolean()
+	}).catchall(t.unknown())).optional(),
+	paidKnown: t.boolean(),
+	subscriptionKnown: t.boolean(),
+	listKnown: t.boolean().optional(),
+	sources: t.array(t.string()),
+	byCategory: t.array(o.extend({ category: t.string() })).optional(),
+	waste: t.array(o.extend({ dimension: t.string() })).optional(),
+	byModel: t.array(t.object({
+		model: t.string(),
+		paidUsd: r,
+		listUsd: r,
+		subscriptionUsd: r,
+		apiUsd: r,
+		sandboxUsd: r,
+		tokens: t.number().nonnegative().nullable(),
+		agents: t.number().int().nonnegative()
+	}).catchall(t.unknown())).optional(),
+	gaps: t.array(a),
+	apiEquivalentUsd: r.optional(),
+	billing: t.object({
+		placement: t.string(),
+		seat: t.string().nullable(),
+		billedUsd: r,
+		basis: t.string().nullable().optional()
+	}).catchall(t.unknown()).nullable().optional()
+}).catchall(t.unknown()), l = t.object({
+	status: t.enum([
+		"ready",
+		"building",
+		"missing",
+		"failed",
+		"archived"
+	]),
+	digest: i.nullable(),
+	builtAt: n.nullable(),
+	reason: t.string().nullable(),
+	capture: t.object({
+		complete: t.number().int().nonnegative(),
+		lossy: t.number().int().nonnegative(),
+		absent: t.number().int().nonnegative()
+	}).nullable()
+}).catchall(t.unknown()), u = t.enum([
+	"running",
+	"winner",
+	"no-winner",
+	"stalled",
+	"failed",
+	"driver-failed",
+	"abandoned",
+	"no-record",
+	"unknown"
+]), le = t.object({
+	id: t.string(),
+	name: t.string(),
+	capUsd: r,
+	spentUsd: r,
+	final: t.boolean()
+}).catchall(t.unknown()), d = [
+	"failed",
+	"smoke",
+	"archived"
+], f = t.enum(d), p = t.object({
+	at: t.string().nullable(),
+	source: t.string(),
+	lines: t.array(t.string()),
+	solved: t.string().nullable(),
+	settle: t.object({
+		kind: t.string().nullable(),
+		reason: t.string().nullable()
+	}).catchall(t.unknown()).nullable().optional()
+}).catchall(t.unknown()), m = t.object({
+	id: t.string(),
+	group: t.string(),
+	kind: t.enum([
+		"run",
+		"version",
+		"search"
+	]),
+	play: t.string(),
+	location: t.object({
+		kind: t.enum([
+			"dir",
+			"archive",
+			"none"
+		]),
+		path: t.string().nullable()
+	}),
+	format: t.string(),
+	state: u,
+	reason: t.string().nullable(),
+	startedAt: n.nullable(),
+	settledAt: n.nullable(),
+	durationMs: t.number().nonnegative().nullable(),
+	nodes: t.number().int().nonnegative().nullable(),
+	depth: t.number().int().nonnegative().nullable(),
+	harnesses: t.array(t.string()),
+	models: t.array(t.string()),
+	keys: t.array(le),
+	spend: c,
+	record: l,
+	inputDigest: t.string().nullable(),
+	predecessor: t.string().nullable(),
+	supersedes: t.string().nullable(),
+	versions: t.object({
+		count: t.number().int().nonnegative(),
+		latest: t.string(),
+		states: t.record(t.string(), t.number())
+	}).nullable(),
+	hidden: f.nullable().optional(),
+	purpose: t.string().nullable().optional(),
+	purposeBasis: t.string().nullable().optional(),
+	findings: t.object({
+		results: t.number().int(),
+		claims: t.number().int()
+	}).catchall(t.unknown()).nullable().optional(),
+	forkedFrom: t.string().nullable().optional(),
+	lostHours: t.number().optional(),
+	playCheck: p.nullable().optional(),
+	check: ee.nullable().optional(),
+	ending: t.object({
+		name: t.string(),
+		state: t.string().nullable().optional(),
+		at: n.nullable().optional(),
+		reason: t.string().nullable().optional()
+	}).catchall(t.unknown()).nullable().optional(),
+	deliverables: t.array(t.object({
+		id: t.string().nullable(),
+		path: t.string(),
+		present: t.boolean().nullable().optional(),
+		href: t.string()
+	}).catchall(t.unknown())).optional(),
+	receipt: t.object({
+		tag: t.string(),
+		status: t.string().nullable(),
+		href: t.string()
+	}).catchall(t.unknown()).nullable().optional()
+}).catchall(t.unknown()), h = t.object({
+	runId: t.string(),
+	schema: t.string().nullable(),
+	digest: t.string().nullable(),
+	source: t.object({
+		path: t.string(),
+		sha256: i
+	}).catchall(t.unknown()),
+	objective: t.string().nullable(),
+	instruction: t.string().nullable(),
+	completion: t.string().nullable(),
+	knowledge: t.string().nullable(),
+	acceptance: t.record(t.string(), t.unknown()).nullable(),
+	budget: t.record(t.string(), t.unknown()).nullable(),
+	continuation: t.record(t.string(), t.unknown()).nullable(),
+	profile: t.object({
+		name: t.string().nullable(),
+		version: t.string().nullable(),
+		digest: t.string().regex(/^sha256:[0-9a-f]{64}$/).nullable(),
+		harness: t.string().nullable(),
+		model: t.string().nullable(),
+		reasoningEffort: t.string().nullable(),
+		credentialSource: t.string().nullable(),
+		tools: t.array(t.string()),
+		skills: t.array(t.string()),
+		systemPromptSha256: t.string().nullable(),
+		systemPrompt: t.string().nullable().optional(),
+		instructions: t.array(t.string()).optional()
+	}).catchall(t.unknown()).nullable(),
+	files: t.array(t.object({
+		path: t.string(),
+		bytes: t.number().int().nonnegative(),
+		sha256: i
+	}).catchall(t.unknown()))
+}).catchall(t.unknown()), ue = t.object({
+	label: t.string(),
+	polarity: t.enum([
+		"good",
+		"bad",
+		"neutral",
+		"unknown"
+	])
+}), de = t.object({
+	schema: t.literal("agent-workspace.plays.v1"),
+	builtAt: n,
+	plays: t.array(t.object({
+		id: t.string(),
+		title: t.string(),
+		program: t.string().nullable(),
+		line: t.string().nullable(),
+		playBasis: t.string(),
+		noProgram: t.boolean().optional(),
+		state: t.string().nullable(),
+		latestRun: t.object({
+			id: t.string(),
+			startedAt: n.nullable(),
+			state: u
+		}).nullable(),
+		best: t.string().nullable().optional(),
+		standing: t.object({
+			status: t.string().nullable().optional(),
+			sentence: t.string().nullable().optional(),
+			best: t.record(t.string(), t.unknown()).nullable().optional(),
+			bestEver: t.record(t.string(), t.unknown()).nullable().optional(),
+			lastEnding: t.object({
+				runId: t.string().nullable().optional(),
+				run: t.string().nullable().optional(),
+				word: t.string().nullable().optional(),
+				glyph: t.string().nullable().optional(),
+				at: t.string().nullable().optional()
+			}).catchall(t.unknown()).nullable().optional(),
+			cost: t.object({
+				apiEquivalentUsd: t.number().nullable().optional(),
+				provenance: t.string().nullable().optional(),
+				priced: t.number().nullable().optional(),
+				started: t.number().nullable().optional()
+			}).catchall(t.unknown()).nullable().optional(),
+			view: ie.nullable().optional()
+		}).catchall(t.unknown()).nullable().optional(),
+		runCount: t.number().int().nonnegative(),
+		counts: t.object({
+			shown: t.number().int().nonnegative(),
+			smoke: t.number().int().nonnegative(),
+			failed: t.number().int().nonnegative(),
+			archived: t.number().int().nonnegative()
+		}).optional(),
+		hidden: f.nullable().optional(),
+		spend: c,
+		headline: t.record(t.string(), ue)
+	}).catchall(t.unknown())),
+	frontiers: t.array(t.object({
+		id: t.string(),
+		asOf: t.string().nullable(),
+		statement: t.string().nullable(),
+		banked: t.number(),
+		next: t.number()
+	})).optional(),
+	runs: t.array(t.object({
+		id: t.string(),
+		play: t.string(),
+		program: t.string().nullable(),
+		state: t.string(),
+		startedAt: n.nullable(),
+		activeAt: n.nullable(),
+		reason: t.string().nullable(),
+		stopCause: t.string().nullable(),
+		hidden: f.nullable(),
+		apiEquivalentUsd: r.optional(),
+		apiEquivalentProvenance: t.string().nullable().optional()
+	})).optional()
+}).catchall(t.unknown()), g = [
+	"supersedes",
+	"continues",
+	"retry",
+	"version",
+	"fork"
+], _ = t.object({
+	method: t.literal("scientific"),
+	dimension: t.literal("claim-review"),
+	status: t.enum([
+		"decided",
+		"unresolved",
+		"stale"
+	]),
+	label: t.string().nullable().optional(),
+	confidence: t.union([t.number(), t.string()]).nullable().optional(),
+	claim: t.string(),
+	subject: t.object({
+		pageSha256: t.string(),
+		claimId: t.string(),
+		pagePath: t.string().optional()
+	}).catchall(t.unknown()),
+	rerun: t.object({
+		status: t.string(),
+		command: t.string().nullable().optional(),
+		output: t.string().nullable().optional(),
+		description: t.string().nullable().optional()
+	}).catchall(t.unknown()).optional(),
+	priorArt: t.object({
+		status: t.string(),
+		summary: t.string().nullable().optional(),
+		references: t.array(t.object({
+			title: t.string(),
+			url: t.string(),
+			resolvesClaim: t.string().optional()
+		}).catchall(t.unknown()))
+	}).catchall(t.unknown()).optional(),
+	rationale: t.string().nullable().optional(),
+	source: t.union([t.string(), t.record(t.string(), t.unknown())]).nullable().optional(),
+	sourceRef: t.string().nullable().optional(),
+	reviewer: t.object({
+		identity: t.string().optional(),
+		kind: t.string().nullable().optional(),
+		lane: t.string().nullable().optional(),
+		provider: t.string().nullable().optional(),
+		harness: t.string().nullable().optional(),
+		model: t.string().nullable().optional(),
+		servedModel: t.string().nullable().optional()
+	}).catchall(t.unknown()).nullable().optional()
+}).catchall(t.unknown()), v = t.object({
+	id: t.string(),
+	kind: t.string(),
+	title: t.string(),
+	url: t.string().nullable().optional(),
+	at: t.string().nullable().optional(),
+	status: t.string().nullable().optional(),
+	session: t.object({
+		harness: t.string().nullable().optional(),
+		model: t.string().nullable().optional(),
+		label: t.string().nullable().optional()
+	}).catchall(t.unknown()).nullable().optional(),
+	cites: t.array(t.object({
+		pageSha256: t.string(),
+		claimId: t.string().nullable().optional(),
+		reviewer: t.string().nullable().optional()
+	}).catchall(t.unknown()))
+}).catchall(t.unknown()), y = t.object({
+	changed: t.number().int().nullable(),
+	added: t.number().int().nullable(),
+	deleted: t.number().int().nullable(),
+	insertions: t.number().int().nullable(),
+	deletions: t.number().int().nullable(),
+	paths: t.array(t.object({
+		status: t.string().nullable(),
+		path: t.string().nullable()
+	}).catchall(t.unknown()))
+}).catchall(t.unknown()), b = t.object({
+	model: t.string().nullable(),
+	provider: t.string().nullable(),
+	reasoningEffort: t.string().nullable(),
+	harness: t.string().nullable(),
+	profile: t.string().nullable(),
+	version: t.string().nullable()
+}).catchall(t.unknown()), x = t.object({
+	from: t.string(),
+	to: t.string(),
+	at: n.nullable(),
+	why: t.object({
+		reason: t.string().nullable(),
+		at: n.nullable(),
+		source: t.string().nullable()
+	}).catchall(t.unknown()).nullable(),
+	root: t.object({
+		from: b.nullable(),
+		to: b.nullable(),
+		moved: t.array(t.string())
+	}).catchall(t.unknown()),
+	knowledge: t.object({
+		seed: t.string().nullable(),
+		files: t.number().int().nullable(),
+		bytes: t.number().int().nullable(),
+		knowledgeRunId: t.string().nullable()
+	}).catchall(t.unknown()),
+	inheritedTags: t.array(t.string()),
+	sourceCommit: t.string().nullable(),
+	forkCommit: t.string().nullable(),
+	files: y.nullable(),
+	profiles: t.array(t.object({
+		commit: t.string().nullable(),
+		subject: t.string().nullable(),
+		role: t.string().nullable(),
+		status: t.string().nullable(),
+		parent: t.string().nullable(),
+		digest: t.string().nullable(),
+		reason: t.string().nullable()
+	}).catchall(t.unknown()))
+}).catchall(t.unknown()), S = t.object({
+	id: t.string(),
+	tag: t.string(),
+	at: n,
+	commit: t.string().nullable(),
+	run: t.string(),
+	agent: t.string().nullable(),
+	declaredBy: t.string().nullable(),
+	previous: t.object({
+		tag: t.string().nullable(),
+		run: t.string().nullable(),
+		commit: t.string().nullable()
+	}).catchall(t.unknown()).nullable(),
+	changes: y.nullable(),
+	deliverables: t.array(t.string()).nullable(),
+	score: t.object({
+		exact: t.tuple([t.number(), t.number()]).nullable(),
+		heldOut: t.tuple([t.number(), t.number()]).nullable(),
+		judge: t.number().nullable(),
+		blockers: t.number().nullable(),
+		complete: t.boolean(),
+		scoredAt: n.nullable()
+	}).catchall(t.unknown()).nullable()
+}).catchall(t.unknown()), C = t.object({
+	runId: t.string(),
+	play: t.string(),
+	program: t.string().nullable(),
+	state: t.string().nullable(),
+	startedAt: t.string().nullable(),
+	at: t.string().nullable(),
+	agentLabel: t.string().nullable(),
+	kind: t.string(),
+	title: t.string().nullable(),
+	text: t.string(),
+	class: t.string().nullable(),
+	ledger: t.boolean(),
+	sha256: t.string(),
+	artifacts: t.array(t.object({
+		path: t.string(),
+		storePath: t.string(),
+		href: t.string()
+	})).optional(),
+	reviews: t.array(_).optional(),
+	review: t.enum([
+		"wrong",
+		"new",
+		"reproduction",
+		"known",
+		"unverifiable",
+		"pending"
+	]).optional(),
+	...ae
+}).catchall(t.unknown()), fe = t.object({
+	schema: t.literal("agent-workspace.play.v1"),
+	id: t.string(),
+	title: t.string(),
+	program: t.string().nullable(),
+	line: t.string().nullable(),
+	playBasis: t.string(),
+	noProgram: t.boolean().optional(),
+	charter: t.string().nullable(),
+	frontier: t.object({
+		statement: t.string().nullable(),
+		target: t.string().nullable(),
+		asOf: t.string().nullable(),
+		banked: t.unknown(),
+		ruledOut: t.unknown(),
+		next: t.unknown()
+	}).catchall(t.unknown()).nullable(),
+	input: h.nullable(),
+	runs: t.array(m),
+	lineage: t.object({
+		nodes: t.array(t.object({
+			runId: t.string(),
+			state: u,
+			record: l
+		}).catchall(t.unknown())),
+		edges: t.array(t.object({
+			from: t.string(),
+			to: t.string(),
+			kind: t.enum(g)
+		}).catchall(t.unknown())),
+		forks: t.array(x).optional(),
+		releases: t.array(S).optional(),
+		deliverables: t.array(t.object({
+			id: t.string(),
+			kind: t.string().nullable(),
+			path: t.string()
+		}).catchall(t.unknown())).optional()
+	}),
+	spend: c,
+	assessments: t.array(t.object({
+		runId: t.string(),
+		dimension: t.string(),
+		label: t.string(),
+		polarity: t.enum([
+			"good",
+			"bad",
+			"neutral",
+			"unknown"
+		]),
+		status: t.string(),
+		method: t.string().optional(),
+		calibrated: t.boolean().nullable().optional()
+	}).catchall(t.unknown())),
+	gaps: t.array(a),
+	best: t.string().nullable().optional(),
+	findings: t.array(C).optional(),
+	...ne
+}).catchall(t.unknown()), pe = c.extend({
+	segments: t.array(ce).optional(),
+	sandboxes: t.array(t.object({
+		id: t.string(),
+		usd: r,
+		costBasisUsd: r,
+		hours: t.number().nonnegative().nullable()
+	}).catchall(t.unknown())),
+	account: t.object({
+		kind: t.enum([
+			"subscription",
+			"router",
+			"unknown"
+		]),
+		rateLimit: t.object({
+			window: t.string().nullable(),
+			utilization: t.number().nullable(),
+			status: t.string().nullable(),
+			at: n.nullable()
+		}).nullable()
+	}).catchall(t.unknown())
+}), w = t.object({
+	path: t.string(),
+	bytes: t.number().int().nonnegative().nullable(),
+	sha256: i.nullable(),
+	kind: t.string().optional(),
+	href: t.string().nullable()
+}).catchall(t.unknown()), T = t.object({
+	sequence: t.number().int(),
+	phase: t.string(),
+	final: t.boolean(),
+	generatedAt: n.nullable(),
+	headline: t.string().nullable(),
+	answer: t.object({
+		text: t.string(),
+		confidence: t.string().nullable(),
+		why: t.string().nullable().optional(),
+		fromSequence: t.number().int().nullable().optional()
+	}).catchall(t.unknown()).nullable(),
+	changed: t.array(t.string()),
+	team: t.array(t.object({
+		node: t.string(),
+		label: t.string().nullable(),
+		state: t.string().nullable(),
+		model: t.string().nullable(),
+		usd: r,
+		lastActiveAt: n.nullable(),
+		doing: t.string().nullable()
+	}).catchall(t.unknown())),
+	risks: t.array(t.object({
+		severity: t.string().nullable(),
+		kind: t.string().nullable(),
+		risk: t.string(),
+		evidence: t.string().nullable(),
+		source: t.string().nullable()
+	}).catchall(t.unknown())),
+	links: t.object({
+		latest: t.string().nullable(),
+		brief: t.string().nullable(),
+		gist: t.string().nullable()
+	}).catchall(t.unknown()),
+	spend: t.object({
+		runUsd: r,
+		provenance: t.string().nullable(),
+		clause: t.string().nullable().optional(),
+		harnessListUsd: r.optional(),
+		sinceLastBriefUsd: r.optional()
+	}).catchall(t.unknown()).optional()
+}).catchall(t.unknown()), E = t.object({
+	stage: t.string().nullable().optional(),
+	reached: t.number().nullable().optional(),
+	of: t.number().nullable().optional(),
+	workloads: t.object({
+		passed: t.number(),
+		total: t.number()
+	}).nullable().optional(),
+	value: t.number().nullable().optional()
+}).catchall(t.unknown()), D = t.object({
+	at: t.string().nullable().optional(),
+	tag: t.string().nullable().optional(),
+	line: t.string().nullable().optional(),
+	stage: t.string().nullable().optional(),
+	solved: t.boolean().nullable().optional(),
+	verdict: t.string().nullable().optional(),
+	score: E.nullable().optional(),
+	uncalibratedPass: t.boolean().optional()
+}).catchall(t.unknown()), O = t.object({
+	schema: t.literal("discovery.run-progress"),
+	runId: t.string(),
+	generatedAt: n,
+	phase: t.string(),
+	final: t.boolean(),
+	startedAt: n.nullable(),
+	spend: t.object({
+		runUsd: r,
+		provenance: t.string().nullable()
+	}).catchall(t.unknown()),
+	files: t.number().int().nonnegative(),
+	agents: t.array(t.object({
+		node: t.string(),
+		label: t.string(),
+		status: t.string(),
+		parent: t.string().nullable().optional(),
+		depth: t.number().int().nullable().optional(),
+		observed: t.boolean().optional(),
+		lastActiveAt: n.nullable().optional(),
+		startedAt: n.nullable(),
+		endedAt: n.nullable(),
+		usd: r,
+		usdEstimated: t.boolean(),
+		model: t.string().nullable()
+	}).catchall(t.unknown())),
+	briefs: t.array(t.object({
+		sequence: t.number().int(),
+		at: n,
+		runUsd: r,
+		files: t.number().int().nullable(),
+		final: t.boolean()
+	}).catchall(t.unknown())),
+	samples: t.array(t.object({
+		at: n,
+		runUsd: r,
+		files: t.number().int().nonnegative(),
+		working: t.number().int().nonnegative(),
+		sequence: t.number().int().optional()
+	}).catchall(t.unknown())),
+	sources: t.record(t.string(), n.nullable()).optional(),
+	blocker: e.nullable().optional(),
+	endBlocker: e.nullable().optional(),
+	outcome: t.object({
+		solved: t.boolean().nullable(),
+		checkedAt: n.nullable(),
+		firstFailingLine: t.string().nullable(),
+		stage: t.string().nullable(),
+		tag: t.string().nullable(),
+		lastStreamAt: n.nullable(),
+		minutesSinceLastStream: t.number().nullable(),
+		checkWait: t.object({
+			tag: t.string().nullable(),
+			publishedAt: n.nullable(),
+			since: n.nullable(),
+			reason: t.string().nullable()
+		}).catchall(t.unknown()).nullable().optional(),
+		solvedLabel: t.string().nullable().optional(),
+		goalAudit: t.object({
+			verdict: t.enum([
+				"consistent",
+				"contradiction",
+				"unaudited"
+			]).nullable(),
+			at: n.nullable()
+		}).catchall(t.unknown()).nullable().optional(),
+		latestCheck: D.nullable().optional(),
+		gate: D.nullable().optional(),
+		score: E.extend({
+			at: t.string().nullable().optional(),
+			tag: t.string().nullable().optional(),
+			source: t.string().nullable().optional()
+		}).nullable().optional(),
+		disputes: t.array(te).optional()
+	}).catchall(t.unknown()).nullable().optional()
+}).catchall(t.unknown()), k = t.object({
+	status: t.enum([
+		"pending",
+		"complete",
+		"partial",
+		"failed"
+	]),
+	generatedAt: n.nullable(),
+	settle: t.object({
+		kind: t.string(),
+		reason: t.string().nullable()
+	}).catchall(t.unknown()).nullable(),
+	summary: t.string().nullable(),
+	deliverables: t.array(t.object({
+		id: t.string(),
+		kind: t.string().nullable(),
+		path: t.string().nullable(),
+		bar: t.string().nullable(),
+		present: t.boolean().nullable(),
+		bytes: t.number().int().nonnegative().nullable(),
+		url: t.string().nullable()
+	}).catchall(t.unknown())),
+	verdicts: t.array(t.object({
+		id: t.string(),
+		statement: t.string(),
+		verdict: t.string(),
+		evidence: t.string()
+	}).catchall(t.unknown())),
+	judges: t.array(t.object({
+		category: t.string(),
+		score: t.number().nullable(),
+		max: t.number().nullable(),
+		calibrated: t.boolean().nullable(),
+		summary: t.string()
+	}).catchall(t.unknown())),
+	links: t.object({
+		report: t.string().nullable(),
+		dossier: t.string().nullable(),
+		gist: t.string().nullable()
+	}).catchall(t.unknown()),
+	cost: t.object({
+		readoutUsd: r,
+		runUsd: r
+	}).catchall(t.unknown()),
+	error: t.string().nullable(),
+	charts: t.array(t.object({
+		id: t.string(),
+		title: t.string().nullable(),
+		unit: t.string().nullable(),
+		kind: t.string().nullable(),
+		caption: t.string().nullable(),
+		width: t.number().int().nullable(),
+		height: t.number().int().nullable(),
+		href: t.string()
+	}).catchall(t.unknown())).optional()
+}).catchall(t.unknown()), A = t.object({
+	at: n,
+	by: t.string(),
+	target: t.object({
+		kind: t.enum([
+			"run",
+			"deliverable",
+			"file"
+		]),
+		id: t.string()
+	}),
+	category: t.string(),
+	score: t.number().int().min(0).max(100).nullable(),
+	decision: t.literal("take").optional(),
+	comment: t.string(),
+	scale: t.string()
+}).catchall(t.unknown()), j = t.object({
+	panel: t.string(),
+	persona: t.string(),
+	overall: t.number().nullable(),
+	decision: t.string().nullable(),
+	verdict: t.string().nullable(),
+	scores: t.record(t.string(), t.object({
+		score: t.number().nullable(),
+		band: t.string().nullable(),
+		competence: t.string().nullable(),
+		why: t.string().nullable()
+	}).catchall(t.unknown()))
+}).catchall(t.unknown()), M = t.object({
+	id: t.string(),
+	question: t.string().nullable(),
+	status: t.enum(["answered", "failed"]),
+	score: t.number().min(0).max(100).nullable(),
+	verdict: t.string().nullable(),
+	quotes: t.array(t.object({
+		agent: t.string().nullable(),
+		quote: t.string(),
+		citation: t.string().nullable()
+	}).catchall(t.unknown())),
+	suggestions: t.array(t.string()),
+	citations: t.object({
+		total: t.number().int().nullable(),
+		resolved: t.number().int().nullable()
+	}).catchall(t.unknown()),
+	failure: t.string().nullable()
+}).catchall(t.unknown()), N = t.object({
+	phase: t.enum(["running", "settled"]),
+	final: t.boolean(),
+	generatedAt: n.nullable(),
+	goal: t.string().nullable(),
+	requester: t.string().nullable(),
+	model: t.string().nullable(),
+	sessions: t.object({
+		read: t.number().int().nullable(),
+		nodes: t.number().int().nullable(),
+		unreadable: t.array(t.object({
+			node: t.string().nullable(),
+			reason: t.string().nullable()
+		}).catchall(t.unknown())),
+		unreadableCount: t.number().int()
+	}).catchall(t.unknown()),
+	questions: t.array(M),
+	cost: t.object({
+		usd: t.number().nullable(),
+		kind: t.string().nullable()
+	}).catchall(t.unknown())
+}).catchall(t.unknown()), P = t.object({
+	declared: t.object({
+		source: t.enum(["deliverable-check", "run-input"]),
+		field: t.string(),
+		path: t.string().nullable(),
+		description: t.string().nullable()
+	}).catchall(t.unknown()).nullable(),
+	status: t.enum([
+		"none-declared",
+		"delivered",
+		"not-delivered",
+		"unknown"
+	]),
+	checkedAt: n.nullable(),
+	files: t.array(w),
+	rootOutput: w.nullable(),
+	readout: k.nullable().optional(),
+	brief: T.nullable().optional(),
+	fallback: t.object({
+		source: t.string(),
+		sequence: t.number().int(),
+		generatedAt: n.nullable(),
+		headline: t.string().nullable(),
+		answer: t.string().nullable(),
+		url: t.string().nullable()
+	}).catchall(t.unknown()).nullable().optional(),
+	grades: t.object({
+		latest: t.array(A),
+		count: t.number().int()
+	}).optional(),
+	panel: t.array(j).optional(),
+	traceReview: N.nullable().optional()
+}).catchall(t.unknown()), F = t.object({
+	path: t.string(),
+	agent: t.string().nullable(),
+	agentLabel: t.string().nullable(),
+	at: t.string().nullable(),
+	kind: t.string(),
+	title: t.string(),
+	summary: t.string(),
+	answer: t.string().nullable().optional(),
+	class: t.string().nullable(),
+	verdict: t.string().nullable(),
+	versions: t.number().int(),
+	uncaptured: t.boolean(),
+	bytes: t.number().int(),
+	sha256: t.string(),
+	artifacts: t.array(t.object({
+		path: t.string(),
+		storePath: t.string(),
+		href: t.string()
+	})).optional(),
+	reviews: t.array(_).optional()
+}).catchall(t.unknown()), I = t.object({
+	schema: t.literal("agent-workspace.findings.v1"),
+	items: t.array(F),
+	total: t.number().int(),
+	links: t.array(t.object({
+		from: t.string(),
+		to: t.string()
+	})).optional(),
+	publications: t.array(v).optional(),
+	agents: t.array(t.object({
+		agent: t.string().nullable(),
+		label: t.string().nullable(),
+		pages: t.number().int(),
+		bytes: t.number().int(),
+		kinds: t.record(t.string(), t.number()),
+		lastWords: t.object({
+			at: t.string().nullable(),
+			text: t.string()
+		}).optional()
+	}).catchall(t.unknown())),
+	sources: t.object({
+		citations: t.array(t.object({
+			kind: t.string(),
+			id: t.string(),
+			mentions: t.number().int(),
+			agents: t.array(t.string()),
+			pages: t.number().int(),
+			citedBy: t.array(t.string()).optional()
+		}).catchall(t.unknown())),
+		webSearches: t.array(t.object({
+			at: t.string().nullable(),
+			agent: t.string().nullable(),
+			label: t.string().nullable(),
+			query: t.string()
+		}).catchall(t.unknown())),
+		webFetches: t.array(t.object({
+			at: t.string().nullable(),
+			agent: t.string().nullable(),
+			label: t.string().nullable(),
+			url: t.string()
+		}).catchall(t.unknown())),
+		knowledgeReads: t.number().int(),
+		knowledgeSearches: t.number().int()
+	}).catchall(t.unknown()),
+	stop: t.object({
+		kind: t.string().nullable(),
+		reason: t.string().nullable(),
+		attempts: t.number().int().nullable(),
+		firstFailure: t.string().nullable(),
+		lastCause: t.string().nullable(),
+		limits: t.array(t.object({
+			at: t.string().nullable(),
+			agent: t.string().nullable(),
+			label: t.string().nullable(),
+			limit: t.string(),
+			text: t.string()
+		}).catchall(t.unknown()))
+	}).catchall(t.unknown())
+}).catchall(t.unknown()), me = t.object({
+	schema: t.literal("agent-workspace.findings-feed.v1"),
+	builtAt: t.string(),
+	since: t.string(),
+	runs: t.object({
+		considered: t.number().int(),
+		withFindings: t.number().int(),
+		results: t.number().int(),
+		claims: t.number().int(),
+		pending: t.number().int().optional()
+	}).catchall(t.unknown()),
+	items: t.array(C),
+	shown: t.object({
+		items: t.number().int(),
+		byReview: t.record(t.string(), t.number().int())
+	}).optional()
+}).catchall(t.unknown()), he = t.object({
+	schema: t.literal("agent-workspace.run.v1"),
+	receipt: oe.nullable().optional(),
+	run: m,
+	input: h.nullable(),
+	spend: c.extend({ nodes: t.record(t.string(), pe) }),
+	versions: t.array(m),
+	live: t.object({
+		mirrorAt: n.nullable(),
+		polling: t.boolean()
+	}),
+	finalOutput: P.nullable().optional(),
+	findings: I.nullable().optional(),
+	progress: O.nullable().optional(),
+	execution: se.optional(),
+	view: re.optional()
+}).catchall(t.unknown()), L = t.string().regex(/^sha256:[0-9a-f]{64}$/), R = t.object({
+	bytes: t.number().int().nonnegative(),
+	sha256: t.string()
+}).catchall(t.unknown()), z = [
+	"authored",
+	"replaced",
+	"revision",
+	"treatment"
+], B = ["recorded", "inferred"], V = t.union([
+	t.object({
+		status: t.literal("unknown"),
+		reason: t.string()
+	}).catchall(t.unknown()),
+	t.object({
+		status: t.literal("known"),
+		source: t.literal("readout"),
+		path: t.string(),
+		generatedAt: t.string().nullable(),
+		judges: t.array(t.object({
+			category: t.string(),
+			score: t.number().nullable(),
+			max: t.number(),
+			calibrated: t.boolean()
+		}).catchall(t.unknown())),
+		verdicts: t.array(t.object({
+			id: t.string(),
+			verdict: t.string()
+		}).catchall(t.unknown()))
+	}).catchall(t.unknown()),
+	t.object({
+		status: t.literal("known"),
+		source: t.literal("version-judge"),
+		score: t.number().nullable(),
+		judgeDigest: t.string().nullable(),
+		ledger: t.string()
+	}).catchall(t.unknown())
+]), H = t.object({
+	mean: t.number(),
+	units: t.number().int()
+}).catchall(t.unknown()).nullable().optional(), ge = t.object({
+	searchId: t.string(),
+	kind: t.string().nullable().optional(),
+	runId: t.string().nullable().optional(),
+	nodeId: t.string().nullable().optional(),
+	registeredAt: t.string().nullable().optional(),
+	scores: t.object({
+		train: H,
+		selection: H,
+		test: H
+	}).catchall(t.unknown()).nullable().optional(),
+	cost: t.object({
+		usd: t.number().nullable(),
+		cells: t.number().nullable().optional(),
+		unknownCells: t.number().nullable().optional()
+	}).catchall(t.unknown()).nullable().optional(),
+	decisions: t.array(t.object({
+		status: t.string(),
+		reason: t.string().nullable().optional(),
+		rule: t.string().nullable().optional(),
+		at: t.string().nullable().optional(),
+		basis: t.object({
+			against: t.string().nullable().optional(),
+			split: t.string(),
+			pairs: t.number(),
+			delta: t.number(),
+			interval: t.array(t.number()).nullable().optional(),
+			method: t.string().nullable().optional()
+		}).catchall(t.unknown()).nullable().optional()
+	}).catchall(t.unknown())).optional()
+}).catchall(t.unknown()), U = t.object({
+	runId: t.string(),
+	role: t.string(),
+	builtAt: t.string().nullable().optional(),
+	burden: t.object({ total: t.number() }).catchall(t.unknown()),
+	blockers: t.object({
+		total: t.number(),
+		bySeverity: t.record(t.string(), t.number()),
+		byClass: t.record(t.string(), t.number())
+	}).catchall(t.unknown()),
+	regressions: t.number(),
+	rework: t.number(),
+	expectations: t.object({
+		status: t.string(),
+		owned: t.number(),
+		met: t.number(),
+		partial: t.number(),
+		missing: t.number()
+	}).catchall(t.unknown()),
+	milestones: t.object({
+		count: t.number(),
+		done: t.number(),
+		medianMs: t.number().nullable()
+	}).catchall(t.unknown()),
+	cost: t.object({
+		acceptedPages: t.number(),
+		perAcceptedPage: t.object({
+			usd: t.number(),
+			outputTokens: t.number(),
+			complete: t.boolean()
+		}).catchall(t.unknown()).nullable(),
+		unmeasuredNodes: t.number()
+	}).catchall(t.unknown())
+}).catchall(t.unknown()), _e = t.object({
+	id: t.string(),
+	severity: t.string(),
+	class: t.string(),
+	owners: t.array(t.string()),
+	basis: t.string(),
+	writers: t.array(t.string()).optional(),
+	pages: t.array(t.string()).optional(),
+	raisedAt: t.string().nullable().optional(),
+	source: t.string(),
+	summary: t.string(),
+	resolves: t.string().optional()
+}).catchall(t.unknown()), W = t.object({
+	role: t.string(),
+	digests: t.array(t.string()),
+	harness: t.string().nullable().optional(),
+	model: t.string().nullable().optional(),
+	nodes: t.number(),
+	milestones: t.object({
+		count: t.number(),
+		done: t.number(),
+		medianMs: t.number().nullable(),
+		items: t.array(t.object({
+			nodeId: t.string(),
+			label: t.string().nullable(),
+			status: t.string().nullable(),
+			ms: t.number().nullable()
+		}).catchall(t.unknown()))
+	}).catchall(t.unknown()),
+	expectations: t.object({
+		status: t.string(),
+		owned: t.number(),
+		met: t.number(),
+		partial: t.number(),
+		missing: t.number(),
+		reason: t.string().optional(),
+		source: t.string().optional()
+	}).catchall(t.unknown()),
+	blockers: t.object({
+		total: t.number(),
+		bySeverity: t.record(t.string(), t.number()),
+		byClass: t.record(t.string(), t.object({
+			count: t.number(),
+			weight: t.number(),
+			ids: t.array(t.string())
+		}).catchall(t.unknown())),
+		items: t.array(_e)
+	}).catchall(t.unknown()),
+	regressions: t.array(t.object({
+		tag: t.string(),
+		from: t.string(),
+		checks: t.array(t.string()),
+		share: t.number()
+	}).catchall(t.unknown())),
+	rework: t.object({
+		cycles: t.number(),
+		items: t.array(t.object({
+			id: t.string(),
+			cycles: t.number()
+		}).catchall(t.unknown()))
+	}).catchall(t.unknown()),
+	cost: t.object({
+		usd: t.number().nullable(),
+		measuredNodes: t.number(),
+		unmeasuredNodes: t.array(t.string()),
+		acceptedPages: t.number(),
+		acceptedAt: t.string().nullable(),
+		perAcceptedPage: t.object({
+			usd: t.number(),
+			outputTokens: t.number(),
+			complete: t.boolean()
+		}).catchall(t.unknown()).nullable()
+	}).catchall(t.unknown()),
+	burden: t.object({
+		total: t.number(),
+		blockers: t.number(),
+		regressions: t.number(),
+		expectations: t.number(),
+		rework: t.number()
+	}).catchall(t.unknown())
+}).catchall(t.unknown()), G = t.object({
+	available: t.boolean(),
+	reason: t.string().optional(),
+	runId: t.string().optional(),
+	builtAt: t.string().optional(),
+	best: t.object({ tag: t.string() }).catchall(t.unknown()).nullable().optional(),
+	classes: t.record(t.string(), t.number()).optional(),
+	regressions: t.array(t.object({
+		tag: t.string(),
+		from: t.string(),
+		checks: t.array(t.string()),
+		infrastructure: t.boolean(),
+		shares: t.record(t.string(), t.number())
+	}).catchall(t.unknown())).optional(),
+	edits: t.array(t.object({
+		operationId: t.string(),
+		role: t.string(),
+		digest: t.string().nullable(),
+		markers: t.array(t.string()),
+		deliveredAt: t.string().nullable(),
+		effect: t.string(),
+		adopted: t.object({
+			nodeId: t.string(),
+			label: t.string().nullable(),
+			at: t.string().nullable()
+		}).catchall(t.unknown()).nullable(),
+		measured: t.object({
+			label: t.string(),
+			before: t.object({
+				critiques: t.number(),
+				blockers: t.number(),
+				perCritique: t.number().nullable()
+			}),
+			after: t.object({
+				critiques: t.number(),
+				blockers: t.number(),
+				perCritique: t.number().nullable()
+			})
+		}).catchall(t.unknown()).nullable().optional()
+	}).catchall(t.unknown())).optional(),
+	roles: t.array(W).optional()
+}).catchall(t.unknown()), K = t.object({
+	role: t.string(),
+	target: t.string().nullable().optional(),
+	rules: t.array(t.object({
+		id: t.string(),
+		label: t.string().optional(),
+		text: t.string(),
+		check: t.string().optional(),
+		weight: t.number().optional(),
+		evidence: t.array(t.object({
+			source: t.string(),
+			blocker: t.string().optional(),
+			severity: t.string().optional(),
+			raisedAt: t.string().nullable().optional(),
+			note: t.string().optional()
+		}).catchall(t.unknown()))
+	}).catchall(t.unknown())),
+	budget: t.object({
+		before: t.number(),
+		after: t.number(),
+		limit: t.number()
+	}).catchall(t.unknown()).nullable().optional(),
+	evidenceLabel: t.string().nullable().optional(),
+	replay: t.object({
+		decision: t.string(),
+		reason: t.string().nullable().optional(),
+		lift: t.number().nullable().optional(),
+		liftInterval: t.object({
+			low: t.number(),
+			high: t.number()
+		}).catchall(t.unknown()).nullable().optional(),
+		checksFell: t.array(t.string()).optional(),
+		library: t.string().optional(),
+		tieBreak: t.string().nullable().optional(),
+		source: t.string().optional()
+	}).catchall(t.unknown()).nullable().optional(),
+	source: t.string().optional()
+}).catchall(t.unknown()), ve = t.object({
+	kind: t.string(),
+	at: t.string().nullable().optional(),
+	runId: t.string().nullable().optional(),
+	nodeId: t.string().nullable().optional(),
+	label: t.string().nullable().optional(),
+	outcome: t.object({
+		status: t.string().nullable().optional(),
+		usd: t.number().nullable().optional(),
+		metered: t.boolean().optional()
+	}).catchall(t.unknown()).nullable().optional()
+}).catchall(t.unknown()), ye = t.object({
+	version: t.literal("research-contract-v2"),
+	commit: t.string(),
+	components: t.array(t.object({
+		id: t.string(),
+		commit: t.string(),
+		message: t.string()
+	}))
+}).catchall(t.unknown()), q = t.object({
+	digest: L,
+	short: t.string(),
+	name: t.string().nullable(),
+	description: t.string().nullable(),
+	version: t.string().nullable(),
+	play: t.string().nullable(),
+	kind: t.enum([
+		"root",
+		"spawned",
+		"proposed",
+		"proposal"
+	]),
+	model: t.object({
+		id: t.string().nullable(),
+		provider: t.string().nullable(),
+		reasoningEffort: t.string().nullable()
+	}),
+	harness: t.string().nullable(),
+	tools: t.array(t.string()),
+	systemPrompt: t.string().nullable(),
+	instructions: t.array(t.string()),
+	files: t.array(R.extend({ path: t.string() })),
+	skills: t.array(R.extend({ name: t.string() })),
+	author: t.discriminatedUnion("kind", [
+		t.object({
+			kind: t.literal("operator"),
+			registration: t.string().nullable()
+		}).catchall(t.unknown()),
+		t.object({
+			kind: t.literal("node"),
+			runId: t.string(),
+			nodeId: t.string(),
+			profileDigest: t.string().nullable()
+		}).catchall(t.unknown()),
+		t.object({
+			kind: t.literal("proposer"),
+			name: t.string(),
+			source: t.string().nullable()
+		}).catchall(t.unknown()),
+		t.object({
+			kind: t.literal("readout"),
+			runId: t.string(),
+			readout: t.string().nullable(),
+			source: t.string()
+		}).catchall(t.unknown())
+	]),
+	createdIn: t.string().nullable(),
+	createdAt: t.string().nullable(),
+	label: t.string().nullable(),
+	budget: t.record(t.string(), t.number()).nullable(),
+	parents: t.array(t.object({
+		digest: L,
+		relation: t.enum(z),
+		basis: t.enum(B),
+		primary: t.boolean(),
+		evidence: t.array(t.object({
+			source: t.string(),
+			note: t.string()
+		}).catchall(t.unknown())),
+		level: t.enum(["within-run", "across-run"]).optional(),
+		events: t.array(ve).optional()
+	}).catchall(t.unknown())),
+	runs: t.array(t.object({
+		runId: t.string(),
+		nodeIds: t.array(t.string()),
+		outcome: t.string().nullable(),
+		run: t.object({
+			state: t.string().nullable(),
+			reason: t.string().nullable()
+		}).catchall(t.unknown()),
+		score: V,
+		contract: ye.nullable().optional().catch(null)
+	}).catchall(t.unknown())),
+	searches: t.array(ge).optional(),
+	scorecards: t.array(U).optional(),
+	edit: K.nullable().optional()
+}).catchall(t.unknown()), J = t.object({
+	searchId: t.string(),
+	kind: t.string().nullable().optional(),
+	runId: t.string().nullable().optional(),
+	policy: t.record(t.string(), t.unknown()).nullable().optional(),
+	ranking: t.string().nullable().optional(),
+	openedAt: t.string().nullable().optional(),
+	closedAt: t.string().nullable().optional(),
+	closeReason: t.string().nullable().optional(),
+	claim: t.object({
+		decision: t.string(),
+		reason: t.string().nullable().optional(),
+		selected: t.string().nullable().optional(),
+		finalists: t.array(t.object({
+			digest: t.string(),
+			promote: t.boolean().nullable().optional(),
+			test: t.object({
+				pairs: t.number(),
+				delta: t.number(),
+				low: t.number(),
+				high: t.number()
+			}).catchall(t.unknown()).nullable().optional()
+		}).catchall(t.unknown())).optional()
+	}).catchall(t.unknown()).nullable().optional(),
+	curve: t.array(t.object({
+		at: t.string(),
+		usd: t.number(),
+		unknownCost: t.number().nullable().optional(),
+		versions: t.number().int(),
+		best: t.object({
+			digest: t.string(),
+			score: t.number()
+		}).catchall(t.unknown()).nullable()
+	}).catchall(t.unknown())).optional()
+}).catchall(t.unknown()), Y = t.object({
+	digest: t.string(),
+	complete: t.boolean().optional(),
+	versions: t.array(t.string()).optional(),
+	rows: t.array(t.object({
+		field: t.string(),
+		text: t.string(),
+		introducedBy: t.string().nullable()
+	}).catchall(t.unknown()))
+}).catchall(t.unknown()), X = t.object({
+	op: t.enum([
+		" ",
+		"+",
+		"-",
+		"@"
+	]),
+	text: t.string()
+}), Z = t.object({
+	path: t.string(),
+	bytes: t.number().int().nonnegative(),
+	sha256: t.string()
+}).catchall(t.unknown()), Q = t.discriminatedUnion("kind", [
+	t.object({
+		field: t.string(),
+		kind: t.literal("value"),
+		from: t.string().nullable(),
+		to: t.string().nullable()
+	}),
+	t.object({
+		field: t.string(),
+		kind: t.literal("set"),
+		added: t.array(t.string()),
+		removed: t.array(t.string()),
+		kept: t.number().int().nonnegative()
+	}),
+	t.object({
+		field: t.string(),
+		kind: t.literal("text"),
+		added: t.number().int().nonnegative(),
+		removed: t.number().int().nonnegative(),
+		lines: t.array(X)
+	}),
+	t.object({
+		field: t.string(),
+		kind: t.literal("files"),
+		added: t.array(Z),
+		removed: t.array(Z),
+		changed: t.array(t.object({
+			path: t.string(),
+			from: t.string(),
+			to: t.string(),
+			added: t.number().int().nonnegative(),
+			removed: t.number().int().nonnegative(),
+			lines: t.array(X)
+		}))
+	})
+]), $ = t.object({
+	from: L,
+	to: L,
+	relation: t.enum(z),
+	basis: t.enum(B),
+	identical: t.boolean(),
+	fields: t.array(Q),
+	scoreDelta: t.discriminatedUnion("status", [t.object({
+		status: t.literal("unknown"),
+		reason: t.string()
+	}).catchall(t.unknown()), t.object({
+		status: t.literal("known"),
+		source: t.enum(["readout", "version-judge"]),
+		categories: t.array(t.object({
+			category: t.string(),
+			from: t.number().nullable(),
+			to: t.number().nullable(),
+			delta: t.number().nullable(),
+			calibrated: t.boolean()
+		})),
+		note: t.string()
+	}).catchall(t.unknown())])
+}).catchall(t.unknown()), be = t.object({
+	schema: t.literal("discovery-lab.profile-graph"),
+	play: t.string(),
+	builtAt: t.string(),
+	nodes: t.array(q),
+	diffs: t.record(t.string(), $),
+	searches: t.array(J).optional(),
+	blame: t.record(t.string(), Y).optional(),
+	scorecards: t.record(t.string(), G).optional()
+}).catchall(t.unknown()), xe = t.object({
+	id: t.string(),
+	tier: t.string(),
+	pass: t.boolean(),
+	value: t.unknown().optional(),
+	evidence: t.string().optional(),
+	error: t.string().optional()
+}).catchall(t.unknown()), Se = t.object({
+	kind: t.literal("agent-workspace.version-graph"),
+	runId: t.string(),
+	available: t.boolean(),
+	reason: t.string().optional(),
+	refsDigest: t.string().nullable().optional(),
+	builtAt: t.string().optional(),
+	roles: G.optional(),
+	rule: t.string().optional(),
+	lanes: t.array(t.object({
+		id: t.string(),
+		label: t.string(),
+		kind: t.string(),
+		head: t.string(),
+		director: t.string().nullable(),
+		commits: t.number()
+	}).catchall(t.unknown())).default([]),
+	commits: t.array(t.object({
+		id: t.string(),
+		parents: t.array(t.string()),
+		at: t.string(),
+		subject: t.string(),
+		lane: t.string(),
+		kind: t.string(),
+		files: t.array(t.object({
+			status: t.string(),
+			path: t.string()
+		})),
+		author: t.object({
+			id: t.string().nullable(),
+			label: t.string(),
+			name: t.string()
+		}).catchall(t.unknown()),
+		director: t.string().nullable(),
+		model: t.string().nullable(),
+		spendUsd: t.number().nullable(),
+		trace: t.object({
+			node: t.string().nullable(),
+			trace: t.string().nullable(),
+			session: t.string().nullable()
+		}).nullable(),
+		spawned: t.string().optional(),
+		profileDigest: t.string().optional(),
+		body: t.string()
+	}).catchall(t.unknown())).default([]),
+	tags: t.array(t.object({
+		name: t.string(),
+		commit: t.string(),
+		at: t.string().nullable(),
+		by: t.string().nullable(),
+		message: t.string(),
+		attempts: t.number(),
+		score: t.object({
+			complete: t.boolean(),
+			scoredAt: t.string().nullable(),
+			set: t.object({
+				source: t.string().nullable(),
+				digest: t.string().nullable()
+			}).catchall(t.unknown()).nullable(),
+			vector: t.object({
+				exact: t.tuple([t.number(), t.number()]),
+				heldOut: t.tuple([t.number(), t.number()]),
+				blockers: t.number().nullable(),
+				judge: t.number().nullable()
+			}),
+			results: t.array(xe)
+		}).nullable(),
+		best: t.boolean(),
+		flags: t.array(t.object({
+			kind: t.string(),
+			tag: t.string(),
+			from: t.string(),
+			checks: t.array(t.string())
+		}).catchall(t.unknown()))
+	}).catchall(t.unknown())).default([]),
+	best: t.string().nullable().optional(),
+	flags: t.array(t.object({
+		kind: t.string(),
+		tag: t.string(),
+		from: t.string(),
+		checks: t.array(t.string())
+	}).catchall(t.unknown())).default([])
+}).catchall(t.unknown());
+//#endregion
+export { W as A, N as B, V as C, k as D, v as E, G as F, m as I, _ as L, U as M, he as N, l as O, O as P, c as R, z as S, T, Se as V, Y as _, I as a, be as b, d as c, j as d, p as f, B as g, de as h, me as i, K as j, S as k, A as l, h as m, P as n, x as o, fe as p, F as r, a as s, C as t, g as u, Q as v, J as w, q as x, $ as y, M as z };