cohorte 2.10.1 → 3.0.0-dev.1

package/dist/chunks/src-s7YRvk0t.mjs

@@ -0,0 +1,2116 @@
+import { t as canonicalJson } from "./canonical-C8UxeEmB.mjs";
+import { B as ErrorInfo, C as PhaseRunId, D as SurfaceId, E as SpecId, O as ToolCallId, S as IsoInstant, T as Sha256, V as JsonValueSchema, _ as CommandId, b as FindingId, d as ModelRef, f as MonetaryCost, g as ArtifactId, h as ApprovalId, i as Redaction, l as AuthMode, m as AgentId, n as QuotaInfo, o as err, p as ThinkingLevel, r as TokenUsage, s as ok, t as BudgetCounters, u as ModelCapability, v as EffectId, w as RunId, y as EventId } from "./src-Cu3TxNob.mjs";
+import { Type } from "typebox";
+import { Compile } from "typebox/compile";
+//#region ../../packages/protocol/src/open-enum.ts
+/** The keyword a PUBLISHED schema carries instead of `enum`: the values this version knows, as documentation. */
+const OPEN_ENUM_KEYWORD = "x-cohorte-known";
+const checked = (values, what) => {
+	if (values.length === 0) throw new RangeError(`${what}: at least one value is required`);
+	if (new Set(values).size !== values.length) throw new RangeError(`${what}: duplicate value in [${values.join(", ")}]`);
+	return [...values];
+};
+/**
+* OPEN enums (values may be added in a minor): strict compile -> enum [...known];
+* published schema -> { type: 'string', 'x-cohorte-known': [...] } (compile.ts does the rewrite).
+* The authored form carries BOTH keywords: `enum` is what the writer-side validator enforces, the marker is what
+* tells the generator that this enum, unlike a closed one, must lose its `enum` when published.
+*/
+function OpenEnum(known, opts = {}) {
+	const values = checked(known, "OpenEnum");
+	return Type.Unsafe({
+		type: "string",
+		enum: values,
+		[OPEN_ENUM_KEYWORD]: [...values],
+		...opts
+	});
+}
+/** A CLOSED string enum: adding a value is a MAJOR. One `enum` keyword rather than an `anyOf` of constants. */
+function ClosedEnum(values, opts = {}) {
+	return Type.Unsafe({
+		type: "string",
+		enum: checked(values, "ClosedEnum"),
+		...opts
+	});
+}
+/** The known values of an authored or published open enum; undefined for anything else. */
+function knownValuesOf(schema) {
+	if (typeof schema !== "object" || schema === null) return void 0;
+	const known = schema[OPEN_ENUM_KEYWORD];
+	return Array.isArray(known) && known.every((value) => typeof value === "string") ? known : void 0;
+}
+const PipelineProfile = OpenEnum([
+	"feature",
+	"bugfix",
+	"review"
+]);
+const ACTIVE_PIPELINE_STATES = [
+	"BRAINSTORM",
+	"SPEC",
+	"PREFLIGHT",
+	"BUILD",
+	"TEST",
+	"REVIEW",
+	"FIX",
+	"SHIP"
+];
+/** spec 11.1 + the two states spec 10.1 names */
+const SUSPENDED_STATES = [
+	"PAUSED",
+	"WAITING_APPROVAL",
+	"AUTH_REQUIRED",
+	"QUOTA_EXCEEDED"
+];
+/** FAILED: recoverable checkpoint (spec 24). BLOCKED: human inspection mandatory. */
+const HALTED_STATES = ["FAILED", "BLOCKED"];
+const TERMINAL_STATES = ["COMPLETED", "CANCELLED"];
+const PIPELINE_STATES = [
+	"IDLE",
+	...ACTIVE_PIPELINE_STATES,
+	...SUSPENDED_STATES,
+	...HALTED_STATES,
+	...TERMINAL_STATES
+];
+const ActivePipelineState = ClosedEnum(ACTIVE_PIPELINE_STATES);
+ClosedEnum(SUSPENDED_STATES);
+const HaltedState = ClosedEnum(HALTED_STATES);
+ClosedEnum(TERMINAL_STATES);
+const PipelineState = ClosedEnum(PIPELINE_STATES);
+const TransitionReason = ClosedEnum([
+	"start",
+	"ready",
+	"built",
+	"tests-pass",
+	"tests-fail",
+	"review-approved",
+	"review-findings",
+	"review-delivered",
+	"fixed",
+	"shipped",
+	"needs-human",
+	"approval-resolved",
+	"pause-command",
+	"resume-command",
+	"cancel-command",
+	"retry-command",
+	"skip-command",
+	"auth-required",
+	"auth-restored",
+	"quota-exceeded",
+	"quota-reset",
+	"stop-rule",
+	"security-violation",
+	"unexpected-error"
+]);
+const StopReason = ClosedEnum([
+	"review-clean",
+	"iteration-limit",
+	"budget-exhausted",
+	"timeout",
+	"identical-failure",
+	"no-progress",
+	"policy-violation",
+	"approval-required",
+	"unexpected-repo-change",
+	"runtime-incompatible",
+	"auth-required",
+	"quota-exceeded",
+	"paused",
+	"cancelled",
+	"agent-dead",
+	"unreviewed",
+	"internal-error",
+	"check-environment"
+]);
+const AgentState = ClosedEnum([
+	"declared",
+	"planned",
+	"spawning",
+	"running",
+	"waiting",
+	"paused",
+	"completed",
+	"failed",
+	"retrying",
+	"escalated",
+	"cancelled"
+]);
+const NodeStatus = ClosedEnum([
+	"pending",
+	"running",
+	"completed",
+	"failed",
+	"paused",
+	"waiting-approval",
+	"cancelled",
+	"skipped",
+	"blocked"
+]);
+/** The eleven roles of spec 8, and `verifier`: the id is reserved, the adversarial cross-check is off in V3.0 (2.9). */
+const COHORTE_ROLES = [
+	"discoverer",
+	"brainstormer",
+	"architect",
+	"spec-author",
+	"implementer",
+	"tester",
+	"reviewer",
+	"security-reviewer",
+	"fixer",
+	"release-manager",
+	"reconciler",
+	"verifier"
+];
+OpenEnum(COHORTE_ROLES);
+/** Closed: for data Cohorte itself authors and switches over (the escalation ladder). */
+const KnownCohorteRole = ClosedEnum(COHORTE_ROLES);
+const Severity = ClosedEnum([
+	"critical",
+	"major",
+	"minor",
+	"info"
+]);
+const Actor = Type.Object({
+	kind: ClosedEnum([
+		"human",
+		"client",
+		"system"
+	]),
+	id: Type.String(),
+	transport: OpenEnum(["cli"])
+});
+const GuardOutcome = Type.Object({
+	id: Type.String(),
+	ok: Type.Boolean(),
+	detail: Type.Optional(Type.String())
+});
+const StopRecord = Type.Object({
+	reason: StopReason,
+	detail: Type.String(),
+	resumable: Type.Boolean(),
+	resumeRequires: Type.Optional(OpenEnum([
+		"approval",
+		"auth-login",
+		"quota-reset",
+		"budget-raise",
+		"human-ack",
+		"repo-repair",
+		"reinstall-pinned-version",
+		"environment-repair"
+	]))
+});
+const EscalationStep = Type.Union([
+	Type.Object({
+		kind: Type.Literal("model-tier"),
+		role: KnownCohorteRole,
+		from: ModelCapability,
+		to: ModelCapability
+	}),
+	Type.Object({
+		kind: Type.Literal("role"),
+		from: KnownCohorteRole,
+		to: KnownCohorteRole
+	}),
+	Type.Object({ kind: Type.Literal("human") })
+]);
+/** Data: used by config AND by `escalation.applied`. Defaults: sameFailureCount 2, maxPerRun 2. */
+const EscalationPolicy = Type.Object({
+	sameFailureCount: Type.Integer({ minimum: 1 }),
+	ladder: Type.Array(EscalationStep),
+	maxPerRun: Type.Integer({ minimum: 0 })
+});
+/**
+* DESIGN 2.3.3. Declared HERE and re-exported by refs.ts: CheckResult needs it, and refs.ts needs the states and the
+* profile of this file. Schemas are values, so an import cycle between the two files would read a const before it is set.
+*/
+const ArtifactRef = Type.Object({
+	artifactId: ArtifactId,
+	kind: OpenEnum([
+		"diff",
+		"file",
+		"log",
+		"report",
+		"agent-output",
+		"transcript",
+		"context",
+		"prompt",
+		"patch"
+	]),
+	path: Type.String(),
+	sha256: Sha256,
+	bytes: Type.Integer({ minimum: 0 })
+});
+const CheckResult = Type.Object({
+	name: Type.String(),
+	status: ClosedEnum([
+		"passed",
+		"failed",
+		"errored",
+		"skipped"
+	]),
+	argv: Type.Array(Type.String()),
+	exitCode: Type.Optional(Type.Integer()),
+	durationMs: Type.Number({ minimum: 0 }),
+	treeDigest: Type.String(),
+	output: Type.Optional(ArtifactRef)
+});
+//#endregion
+//#region ../../packages/protocol/src/agent-output.ts
+const AGENT_OUTPUT_MAX_SUMMARY = 2e3;
+const confidence = () => Type.Number({
+	minimum: 0,
+	maximum: 1
+});
+const lineNumber = () => Type.Integer({ minimum: 1 });
+const Finding = Type.Object({
+	/** assigned by Cohorte */
+	id: Type.Optional(FindingId),
+	severity: Severity,
+	kind: ClosedEnum([
+		"spec-violation",
+		"security",
+		"quality",
+		"complexity",
+		"check-failure"
+	]),
+	rule: Type.String(),
+	location: Type.Optional(Type.Object({
+		file: Type.String(),
+		line: Type.Optional(lineNumber()),
+		endLine: Type.Optional(lineNumber()),
+		symbol: Type.Optional(Type.String())
+	})),
+	reproduction: Type.Optional(Type.String()),
+	expected: Type.String(),
+	actual: Type.String(),
+	confidence: confidence(),
+	suggestedFix: Type.Optional(Type.String()),
+	scope: ClosedEnum(["in-scope", "deferred"]),
+	outOfScopeReason: Type.Optional(Type.String())
+});
+const AgentOutput = Type.Object({
+	status: ClosedEnum([
+		"completed",
+		"failed",
+		"blocked",
+		"needs-input"
+	]),
+	summary: Type.String({ maxLength: AGENT_OUTPUT_MAX_SUMMARY }),
+	artifacts: Type.Array(Type.Object({
+		path: Type.String(),
+		kind: ClosedEnum([
+			"diff",
+			"file",
+			"test",
+			"report",
+			"contract"
+		]),
+		/** ignored; Cohorte recomputes. A plain string on purpose: a wrong digest from a model must not fail its output. */
+		sha256: Type.Optional(Type.String())
+	})),
+	findings: Type.Array(Finding, { maxItems: 30 }),
+	/** claims; TEST is the truth */
+	checks: Type.Array(Type.Object({
+		name: Type.String(),
+		status: ClosedEnum([
+			"passed",
+			"failed",
+			"skipped",
+			"not-run"
+		]),
+		command: Type.Optional(Type.String())
+	})),
+	questions: Type.Array(Type.String()),
+	confidence: confidence(),
+	assumptions: Type.Optional(Type.Array(Type.Object({
+		gap: Type.String(),
+		decision: Type.String()
+	}))),
+	remediationAddressed: Type.Optional(Type.Array(Type.Object({
+		findingId: Type.String(),
+		how: Type.String()
+	})))
+});
+const count$4 = () => Type.Integer({ minimum: 0 });
+/** Computed by core, never read from a model (2.9 rule 5). */
+const ReviewResult = Type.Object({
+	verdict: ClosedEnum([
+		"approved",
+		"findings",
+		"needs-human"
+	]),
+	kept: Type.Array(Finding),
+	refuted: Type.Array(Finding),
+	deferred: Type.Array(Finding),
+	needsInvestigation: Type.Array(Finding),
+	blocking: count$4(),
+	blockingItems: Type.Array(Type.String()),
+	/** sha256(items)[0:16]; '' when there is nothing to fix */
+	fingerprint: Type.String({ pattern: "^(?:[0-9a-f]{16})?$" }),
+	unreviewed: Type.Array(SurfaceId),
+	clean: Type.Boolean(),
+	counts: Type.Object({
+		critical: count$4(),
+		major: count$4(),
+		minor: count$4(),
+		info: count$4()
+	})
+});
+//#endregion
+//#region ../../packages/protocol/src/refs.ts
+const count$3 = () => Type.Integer({ minimum: 0 });
+const PhaseRef = Type.Object({
+	phaseRunId: PhaseRunId,
+	state: ActivePipelineState,
+	iteration: count$3()
+});
+/** `role` is a plain string here (DESIGN 2.3.3): a reader must be able to show an agent whose role it does not know. */
+const AgentRef = Type.Object({
+	agentId: AgentId,
+	role: Type.String(),
+	surface: Type.Optional(SurfaceId),
+	incarnation: count$3(),
+	attempt: count$3()
+});
+/** R8: optional wherever it appears, and opaque. A client never needs it. */
+const RuntimeRef = Type.Object({
+	runtime: Type.String(),
+	version: Type.String(),
+	sessionId: Type.String(),
+	transcriptRef: Type.String()
+});
+const FileTouch = Type.Object({
+	/** worktree-relative, POSIX */
+	path: Type.String(),
+	op: ClosedEnum([
+		"read",
+		"create",
+		"modify",
+		"delete"
+	]),
+	beforeSha256: Type.Optional(Sha256),
+	afterSha256: Type.Optional(Sha256),
+	bytes: Type.Optional(count$3())
+});
+const SandboxReport = Type.Object({
+	level: OpenEnum(["L0-process", "L1-os"]),
+	backend: OpenEnum([
+		"none",
+		"seatbelt",
+		"bubblewrap"
+	]),
+	filesystem: OpenEnum([
+		"enforced",
+		"partial",
+		"advisory"
+	]),
+	network: OpenEnum([
+		"enforced-off",
+		"partial",
+		"unenforced"
+	])
+});
+const RunPlan = Type.Object({
+	profile: PipelineProfile,
+	runtime: Type.Object({
+		id: Type.String(),
+		version: Type.String()
+	}),
+	/** 2.10.1: WHO consented to every security-loosening key of the project file */
+	trust: Type.Object({
+		policySha256: Sha256,
+		loosenedKeys: Type.Array(Type.String()),
+		grantedBy: OpenEnum([
+			"none-needed",
+			"user-config",
+			"cli-flag",
+			"trust-record"
+		])
+	}),
+	models: Type.Array(Type.Object({
+		role: Type.String(),
+		requested: ModelRef,
+		thinking: ThinkingLevel,
+		authMode: AuthMode,
+		billing: ClosedEnum(["plan-limits", "metered"]),
+		reason: Type.String()
+	})),
+	apiBillingEnabled: Type.Boolean(),
+	/** non-empty => the plan printed to the human names per-token billing */
+	meteredProviders: Type.Array(Type.String()),
+	sandbox: SandboxReport,
+	sandboxRequire: ClosedEnum(["native", "best-effort"]),
+	brainIsolation: ClosedEnum(["os", "process"]),
+	budgets: Type.Object({
+		run: BudgetCounters,
+		perPhase: BudgetCounters,
+		perAgent: BudgetCounters,
+		perProvider: Type.Record(Type.String(), BudgetCounters),
+		perTool: Type.Record(Type.String(), BudgetCounters)
+	}),
+	network: Type.Object({ provisioning: Type.Boolean() }),
+	promptOverrides: Type.Array(Type.String()),
+	unattended: Type.Boolean()
+});
+/** R6 — everything a human needs without reading a transcript */
+const ApprovalRequest = Type.Object({
+	approvalId: ApprovalId,
+	kind: OpenEnum([
+		"tool",
+		"shared-path",
+		"ship",
+		"budget",
+		"loop-stalled",
+		"contract-change",
+		"spec-not-ready",
+		"review-leftovers",
+		"unowned-path",
+		"api-billing",
+		"blocked-ack",
+		"provision-network"
+	]),
+	agent: Type.Optional(AgentRef),
+	phase: Type.Optional(PhaseRef),
+	tool: Type.Optional(Type.String()),
+	/** sealed */
+	args: Type.Optional(JsonValueSchema),
+	affectedPaths: Type.Array(Type.String()),
+	/** sealed; agent-controlled text: clients MUST render it through the sanitiser of 2.3.6 */
+	preview: Type.Object({
+		kind: ClosedEnum([
+			"diff",
+			"command",
+			"text"
+		]),
+		text: Type.String()
+	}),
+	/** only for the `approval_request` tool: the answers the agent offered; `approve.answer` must be one of them */
+	options: Type.Optional(Type.Array(Type.String())),
+	ruleId: Type.String(),
+	reason: Type.String(),
+	asks: Type.Array(Type.Object({
+		stage: Type.String(),
+		ruleId: Type.String(),
+		reason: Type.String()
+	})),
+	allowedDecisions: Type.Array(ClosedEnum([
+		"allow-once",
+		"allow-for-run",
+		"deny"
+	])),
+	/** what the decision is bound to (4.5): the target's beforeSha256 (write/patch) or the slot's treeDigest (command) */
+	preStateSha256: Type.Optional(Sha256),
+	expiresAt: Type.Optional(IsoInstant),
+	unattended: ClosedEnum(["deny", "wait"]),
+	/** literal "cohorte approve <id>" */
+	cli: Type.String()
+});
+const ResumeReport = Type.Object({
+	takeover: Type.Boolean(),
+	hostId: Type.String(),
+	fencingToken: count$3(),
+	locks: Type.Object({
+		rebuilt: Type.Array(Type.String()),
+		conflicts: Type.Array(Type.String())
+	}),
+	orphans: Type.Array(Type.Object({
+		agentId: Type.Optional(AgentId),
+		incarnation: Type.Optional(count$3()),
+		pid: count$3(),
+		kind: ClosedEnum(["brain", "command"]),
+		killed: Type.Boolean()
+	})),
+	worktrees: Type.Array(Type.Object({
+		slot: Type.String(),
+		path: Type.String(),
+		verdict: OpenEnum([
+			"ok",
+			"re-added",
+			"ledger-explained",
+			"quarantined-reset",
+			"unexplained-change",
+			"missing-branch"
+		])
+	})),
+	effects: Type.Array(Type.Object({
+		effectId: EffectId,
+		kind: Type.String(),
+		replayClass: ClosedEnum([
+			"idempotent",
+			"verifiable",
+			"at-most-once"
+		]),
+		verdict: OpenEnum([
+			"done",
+			"failed",
+			"re-executed",
+			"in-doubt",
+			"compensated"
+		])
+	})),
+	approvalsCarried: Type.Array(ApprovalId),
+	commandsApplied: Type.Array(CommandId),
+	inDoubt: Type.Array(EffectId),
+	/** 4.5 parked path */
+	approvedReplays: Type.Array(Type.Object({
+		approvalId: ApprovalId,
+		toolCallId: ToolCallId,
+		outcome: OpenEnum([
+			"executed",
+			"binding-changed",
+			"denied-by-gate"
+		])
+	}))
+});
+const Durability = ClosedEnum(["durable", "ephemeral"]);
+const EnvelopeBase = Type.Object({
+	protocolVersion: Type.Literal("1.0"),
+	eventId: EventId,
+	/** durable: own gapless per-run sequence (1..n). ephemeral: sequence of the last COMMITTED durable event when it is STAMPED */
+	sequence: Type.Integer({ minimum: 0 }),
+	/** durable: 0. ephemeral: 1.. after that durable sequence */
+	sub: Type.Integer({ minimum: 0 }),
+	durability: Durability,
+	timestamp: IsoInstant,
+	runId: RunId,
+	/** narrowed per event */
+	type: Type.String({ minLength: 1 }),
+	source: ClosedEnum([
+		"cohorte",
+		"runtime",
+		"client",
+		"human"
+	]),
+	phase: Type.Optional(PhaseRef),
+	agent: Type.Optional(AgentRef),
+	/** eventId or commandId that caused this event */
+	causationId: Type.Optional(Type.String()),
+	/** one line, sealed; EventWriter replaces control characters by U+FFFD BEFORE validation */
+	summary: Type.String({
+		maxLength: 200,
+		pattern: "^[^\\u0000-\\u001f\\u007f-\\u009f]*$"
+	}),
+	severity: ClosedEnum([
+		"info",
+		"success",
+		"warning",
+		"error",
+		"progress"
+	]),
+	/** narrowed per event */
+	payload: Type.Unknown(),
+	redactions: Type.Array(Redaction)
+});
+/** Total order of a stream. */
+function compareOrder(a, b) {
+	return a.sequence - b.sequence || a.sub - b.sub;
+}
+//#endregion
+//#region ../../packages/protocol/src/compile.ts
+const SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
+const SCHEMA_MAPS = /* @__PURE__ */ new Set([
+	"properties",
+	"patternProperties",
+	"$defs",
+	"definitions",
+	"dependentSchemas"
+]);
+const SCHEMA_LISTS = /* @__PURE__ */ new Set([
+	"anyOf",
+	"oneOf",
+	"prefixItems"
+]);
+const SCHEMA_SINGLES = /* @__PURE__ */ new Set([
+	"items",
+	"additionalItems",
+	"additionalProperties",
+	"unevaluatedProperties",
+	"unevaluatedItems",
+	"not",
+	"if",
+	"then",
+	"else",
+	"contains",
+	"propertyNames"
+]);
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** TypeBox keeps its own bookkeeping under non-enumerable or `~`-prefixed keys: a JSON round trip leaves the JSON Schema. */
+const plain = (schema) => JSON.parse(JSON.stringify(schema));
+/** Post-order map over every SCHEMA of a document: `post` sees a node whose sub-schemas are already mapped. */
+function mapSchemas(node, post, closable = true) {
+	if (!isObject(node)) return node;
+	const out = {};
+	for (const [keyword, value] of Object.entries(node)) if (SCHEMA_MAPS.has(keyword) && isObject(value)) out[keyword] = Object.fromEntries(Object.entries(value).map(([name, member]) => [name, mapSchemas(member, post)]));
+	else if ((SCHEMA_LISTS.has(keyword) || keyword === "items") && Array.isArray(value)) out[keyword] = value.map((member) => mapSchemas(member, post));
+	else if (keyword === "allOf" && Array.isArray(value)) out[keyword] = value.map((member) => mapSchemas(member, post, false));
+	else if (SCHEMA_SINGLES.has(keyword) && isObject(value)) out[keyword] = mapSchemas(value, post);
+	else out[keyword] = value;
+	return post(out, closable);
+}
+function rewrite(node, mode) {
+	return mapSchemas(node, (out, closable) => {
+		if (mode === "open") {
+			if (out.additionalProperties === false) delete out.additionalProperties;
+			if (knownValuesOf(out) !== void 0) delete out.enum;
+		} else if (closable && isObject(out.properties) && !("additionalProperties" in out)) out.additionalProperties = false;
+		return out;
+	});
+}
+/**
+* TypeBox inlines a `Type.Cyclic` at EVERY use as `{ $defs: { X: { $id: 'X', … } }, $ref: 'X' }`. Its own compiler
+* accepts the repetition; a second implementation (ajv) refuses two schemas with one `$id` in one document, and the
+* published schema exists for second implementations (AC-07). So a published DOCUMENT carries each such definition
+* once, under the root `$defs`, without its `$id`, and every reference becomes a pointer. Two different definitions
+* under one name are an authoring error, never merged. The result is a whole document: embed authored schemas in a
+* bigger one, not published ones (their pointers are relative to the root).
+*/
+function hoistDefinitions(document) {
+	const hoisted = {};
+	const hoist = (name, definition) => {
+		const { $id: _id, ...body } = definition;
+		const found = hoisted[name];
+		if (found !== void 0 && JSON.stringify(found) !== JSON.stringify(body)) throw new TypeError(`two different definitions are named ${JSON.stringify(name)} in one published schema`);
+		hoisted[name] = body;
+	};
+	const lifted = mapSchemas(document, (out) => {
+		if (!isObject(out.$defs)) return out;
+		const kept = {};
+		for (const [name, member] of Object.entries(out.$defs)) if (isObject(member) && member.$id === name) hoist(name, member);
+		else kept[name] = member;
+		if (Object.keys(kept).length > 0) out.$defs = kept;
+		else delete out.$defs;
+		return out;
+	});
+	if (!isObject(lifted) || Object.keys(hoisted).length === 0) return lifted;
+	const own = isObject(lifted.$defs) ? lifted.$defs : {};
+	for (const name of Object.keys(hoisted)) if (name in own) throw new TypeError(`two different definitions are named ${JSON.stringify(name)} in one published schema`);
+	return mapSchemas({
+		...lifted,
+		$defs: {
+			...own,
+			...hoisted
+		}
+	}, (out) => {
+		if (typeof out.$ref === "string" && Object.hasOwn(hoisted, out.$ref)) out.$ref = `#/$defs/${out.$ref}`;
+		return out;
+	});
+}
+/** Writer side. Closes every object that declares `properties`, whether or not its author remembered to. */
+function toStrictSchema(schema) {
+	return rewrite(plain(schema), "strict");
+}
+function validatorOf(jsonSchema) {
+	const compiled = Compile(jsonSchema);
+	return (value) => {
+		if (compiled.Check(value)) return ok(value);
+		const issues = [];
+		for (const issue of compiled.Errors(value)) issues.push({
+			path: issue.instancePath,
+			keyword: issue.keyword,
+			message: issue.message
+		});
+		return err(issues);
+	};
+}
+const strictCache = /* @__PURE__ */ new WeakMap();
+/** The STRICT validator of any authored schema: commands, documents, agent output. Compiled once per schema object. */
+function compileSchema(schema) {
+	let found = strictCache.get(schema);
+	if (!found) {
+		found = validatorOf(toStrictSchema(schema));
+		strictCache.set(schema, found);
+	}
+	return found;
+}
+const rowOf = (events, type) => {
+	if (!Object.hasOwn(events, type)) throw new RangeError(`no event type ${JSON.stringify(type)} in this catalogue`);
+	return events[type];
+};
+/** Writer side: the payload of one event type, unknown keys rejected. Generic over the table, so a catalogue only adds rows. */
+function compileStrict(events, type) {
+	return compileSchema(rowOf(events, type).payload);
+}
+/**
+* The properties that make a base envelope the envelope of ONE row: the discriminant, the narrowed body and whatever
+* the row pins (an event pins its durability). Shared by the strict and the open form, so the two cannot disagree.
+*/
+function narrowed(base, discriminant, type, body, bodySchema, pinned) {
+	if (!isObject(base) || !isObject(base.properties)) throw new TypeError("an envelope schema must be an object schema");
+	const properties = {
+		...base.properties,
+		[discriminant]: { const: type },
+		[body]: bodySchema
+	};
+	for (const [name, value] of Object.entries(pinned)) properties[name] = { const: value };
+	return {
+		...base,
+		properties
+	};
+}
+const envelopeCache = /* @__PURE__ */ new WeakMap();
+/** Writer side: the WHOLE envelope of one event type — closed, its `type` and its durability pinned by the table. */
+function compileStrictEnvelope(events, type) {
+	const row = rowOf(events, type);
+	let perTable = envelopeCache.get(events);
+	if (!perTable) {
+		perTable = /* @__PURE__ */ new Map();
+		envelopeCache.set(events, perTable);
+	}
+	let found = perTable.get(type);
+	if (!found) {
+		found = validatorOf(narrowed(toStrictSchema(EnvelopeBase), "type", type, "payload", toStrictSchema(row.payload), { durability: row.durability }));
+		perTable.set(type, found);
+	}
+	return found;
+}
+/**
+* The published form of a table of types: the open base envelope, then a `oneOf` with one branch per KNOWN type and a
+* catch-all branch for the types of a later minor. Exactly one branch matches any envelope, because the base requires
+* the discriminant. Used for events here and for commands in commands.ts.
+*/
+function toOpenTableSchema(options) {
+	const base = rewrite(plain(options.base), "open");
+	if (!isObject(base)) throw new TypeError("an envelope schema must be an object schema");
+	const known = options.rows.map((row) => row.type);
+	const branches = options.rows.map((row) => {
+		const branch = narrowed({ properties: {} }, options.discriminant, row.type, options.body, rewrite(plain(row.body), "open"), row.pinned ?? {});
+		return {
+			title: row.type,
+			...branch
+		};
+	});
+	branches.push({
+		title: "a type added by a later minor version: readers MUST ignore it",
+		properties: { [options.discriminant]: { not: { enum: known } } }
+	});
+	return hoistDefinitions({
+		$schema: SCHEMA_DIALECT,
+		$id: options.$id,
+		title: options.title,
+		...base,
+		oneOf: branches
+	});
+}
+/** Generator side of DESIGN 2.3.2, over any events table. */
+function toOpenJsonSchema(events, options = {}) {
+	return toOpenTableSchema({
+		$id: options.$id ?? "https://cohorte.dev/schemas/3/events.schema.json",
+		title: options.title ?? "Cohorte Protocol event envelope",
+		base: EnvelopeBase,
+		discriminant: "type",
+		body: "payload",
+		rows: Object.entries(events).map(([type, row]) => ({
+			type,
+			body: row.payload,
+			pinned: { durability: row.durability }
+		}))
+	});
+}
+/** The exact signatures of DESIGN 2.3.2, bound to one table: `bindCatalogue(EVENTS)` is all a catalogue has to write. */
+function bindCatalogue(events) {
+	return {
+		compileStrict: (type) => compileStrict(events, type),
+		compileStrictEnvelope: (type) => compileStrictEnvelope(events, type),
+		toOpenJsonSchema: () => toOpenJsonSchema(events)
+	};
+}
+//#endregion
+//#region ../../packages/protocol/src/events/declare.ts
+const durable = (payload) => ({
+	payload,
+	durability: "durable"
+});
+const ephemeral = (payload) => ({
+	payload,
+	durability: "ephemeral"
+});
+const count$2 = () => Type.Integer({ minimum: 0 });
+const milliseconds = () => Type.Number({ minimum: 0 });
+/** `{ ref; sha; treeDigest }`: what a review looked at, and what an approval of it is bound to. */
+const ReviewRef = Type.Object({
+	ref: Type.String(),
+	sha: Type.String(),
+	treeDigest: Type.String()
+});
+const REPLAY_CLASSES = [
+	"idempotent",
+	"verifiable",
+	"at-most-once"
+];
+//#endregion
+//#region ../../packages/protocol/src/events/agent.ts
+const AGENT_STATE_CHANGE_REASONS = [
+	"planned",
+	"spawned",
+	"tool-wait",
+	"approval-wait",
+	"quota-wait",
+	"peer-wait",
+	"paused",
+	"resumed",
+	"completed",
+	"failed",
+	"cancelled",
+	"retry",
+	"escalation",
+	"recovery",
+	"park",
+	"pause-expiry"
+];
+const MESSAGE_ROLES = [
+	"assistant",
+	"user",
+	"tool-result"
+];
+const MESSAGE_CHANNELS = [
+	"text",
+	"thinking",
+	"tool-input"
+];
+const MESSAGE_STOPS = [
+	"stop",
+	"length",
+	"tool-use",
+	"error",
+	"aborted"
+];
+const MESSAGE_DELIVERIES = ["steer", "follow-up"];
+const MESSAGE_DELTA_MAX_LENGTH = 8192;
+/**
+* R9. The shapes of the context manifest (DESIGN 2.2.4), declared here a second time: protocol imports no other
+* package than base (C4). Exported because `inspect { kind: 'context' }` returns this payload as it is.
+*/
+const ContextBuiltPayload = Type.Object({
+	agent: AgentRef,
+	manifestSha256: Sha256,
+	tokenEstimate: count$2(),
+	tokenLimit: count$2(),
+	entries: Type.Array(Type.Object({
+		id: Type.String(),
+		tier: ClosedEnum([
+			"system",
+			"doctrine",
+			"data",
+			"task",
+			"prior-results"
+		]),
+		trust: ClosedEnum([
+			"cohorte",
+			"human",
+			"untrusted-repository",
+			"agent-output"
+		]),
+		source: Type.Object({
+			kind: ClosedEnum([
+				"asset",
+				"project-file",
+				"artifact",
+				"event-summary",
+				"inline"
+			]),
+			ref: Type.String()
+		}),
+		sha256: Sha256,
+		bytes: count$2(),
+		tokenEstimate: count$2()
+	})),
+	reductions: Type.Array(Type.Object({
+		entryId: Type.String(),
+		strategy: ClosedEnum([
+			"excerpt",
+			"outline",
+			"summary-with-refs",
+			"dropped"
+		]),
+		fromBytes: count$2(),
+		toBytes: count$2()
+	})),
+	exclusions: Type.Array(Type.Object({
+		pattern: Type.String(),
+		reason: ClosedEnum([
+			"secret",
+			"outside-scope",
+			"size",
+			"binary"
+		])
+	})),
+	manifest: ArtifactRef
+});
+const AGENT_EVENTS = {
+	"agent.declared": durable(Type.Object({
+		agent: AgentRef,
+		parentAgentId: Type.Optional(AgentId),
+		owner: Type.String(),
+		ownedPaths: Type.Array(Type.String()),
+		grantsDigest: Sha256,
+		requestedModel: ModelRef,
+		thinking: ThinkingLevel,
+		routingReason: Type.String(),
+		budget: BudgetCounters
+	})),
+	"agent.spawned": durable(Type.Object({
+		agent: AgentRef,
+		worktree: Type.Optional(Type.Object({
+			slot: Type.String(),
+			path: Type.String(),
+			branch: Type.String(),
+			baseSha: Type.String()
+		})),
+		tools: Type.Array(Type.String()),
+		systemPromptSha256: Sha256,
+		effectiveSystemPromptSha256: Sha256,
+		authMode: AuthMode,
+		isolation: SandboxReport,
+		runtimeRef: Type.Optional(RuntimeRef)
+	})),
+	"agent.started": durable(Type.Object({
+		agent: AgentRef,
+		taskSha256: Sha256
+	})),
+	"agent.state.changed": durable(Type.Object({
+		agent: AgentRef,
+		from: AgentState,
+		to: AgentState,
+		reason: OpenEnum(AGENT_STATE_CHANGE_REASONS),
+		pausedAt: Type.Optional(ClosedEnum(["tool-boundary", "model-boundary"])),
+		attemptConsumed: Type.Boolean()
+	})),
+	"agent.completed": durable(Type.Object({
+		agent: AgentRef,
+		status: AgentOutput.properties.status,
+		summary: Type.String(),
+		confidence: Type.Number({
+			minimum: 0,
+			maximum: 1
+		}),
+		output: ArtifactRef,
+		artifacts: Type.Array(ArtifactRef),
+		findings: count$2(),
+		questions: Type.Array(Type.String()),
+		usage: BudgetCounters
+	})),
+	"agent.failed": durable(Type.Object({
+		agent: AgentRef,
+		error: ErrorInfo,
+		willRetry: Type.Boolean(),
+		nextIncarnation: Type.Optional(count$2())
+	})),
+	"agent.turn.started": ephemeral(Type.Object({ turn: count$2() })),
+	"agent.turn.completed": durable(Type.Object({
+		turn: count$2(),
+		toolCalls: count$2()
+	})),
+	/** R1 */
+	"agent.message.started": ephemeral(Type.Object({
+		messageId: Type.String(),
+		role: ClosedEnum(MESSAGE_ROLES)
+	})),
+	"agent.message.delta": ephemeral(Type.Object({
+		messageId: Type.String(),
+		channel: ClosedEnum(MESSAGE_CHANNELS),
+		contentIndex: count$2(),
+		delta: Type.String({ maxLength: MESSAGE_DELTA_MAX_LENGTH })
+	})),
+	"agent.message.completed": durable(Type.Object({
+		messageId: Type.String(),
+		role: ClosedEnum(MESSAGE_ROLES),
+		preview: Type.String({ maxLength: 512 }),
+		textSha256: Sha256,
+		bytes: count$2(),
+		stop: Type.Optional(ClosedEnum(MESSAGE_STOPS))
+	})),
+	/** the runtime took a `send` (host note, nudge, or `agent.send`) into its queue */
+	"agent.message.accepted": durable(Type.Object({
+		agent: AgentRef,
+		messageId: Type.String(),
+		delivery: ClosedEnum(MESSAGE_DELIVERIES)
+	})),
+	/** non-fatal runtime diagnostics (unmapped stop reason, stale auth snapshot, degraded capability); `message` is sealed */
+	"runtime.warning": durable(Type.Object({
+		agent: Type.Optional(AgentRef),
+		code: Type.String(),
+		message: Type.String()
+	})),
+	"model.requested": durable(Type.Object({
+		requestId: Type.String(),
+		model: ModelRef,
+		expectedAuthMode: AuthMode,
+		contextSha256: Type.Optional(Sha256),
+		attempt: count$2()
+	})),
+	"model.responded": durable(Type.Object({
+		requestId: Type.String(),
+		requestedModel: ModelRef,
+		effectiveModel: Type.Object({
+			provider: Type.String(),
+			model: Type.String(),
+			api: Type.Optional(Type.String()),
+			baseUrl: Type.Optional(Type.String())
+		}),
+		authMode: AuthMode,
+		authSource: ClosedEnum([
+			"oauth",
+			"api-key",
+			"none"
+		]),
+		status: ClosedEnum(["ok", "error"]),
+		httpStatus: Type.Optional(Type.Integer({
+			minimum: 100,
+			maximum: 599
+		})),
+		durationMs: milliseconds(),
+		tokens: TokenUsage,
+		monetaryCost: MonetaryCost,
+		quota: QuotaInfo,
+		attempt: count$2(),
+		error: Type.Optional(ErrorInfo)
+	})),
+	"context.built": durable(ContextBuiltPayload),
+	"escalation.applied": durable(Type.Object({
+		agent: AgentRef,
+		step: EscalationStep,
+		because: Type.String()
+	}))
+};
+const Lock = Type.Object({
+	scope: ClosedEnum([
+		"project",
+		"zone",
+		"run",
+		"integration",
+		"slot"
+	]),
+	key: Type.String(),
+	mode: ClosedEnum(["shared", "exclusive"]),
+	owner: Type.String(),
+	fencingToken: Type.Optional(count$2())
+});
+const GIT_EVENTS = {
+	"git.worktree.created": durable(Type.Object({
+		slot: Type.String(),
+		path: Type.String(),
+		branch: Type.String(),
+		baseSha: Type.String(),
+		effectId: EffectId
+	})),
+	"git.worktree.provisioned": durable(Type.Object({
+		slot: Type.String(),
+		lockfileSha256: Sha256,
+		network: Type.Boolean(),
+		effectId: EffectId
+	})),
+	"git.worktree.quarantined": durable(Type.Object({
+		slot: Type.String(),
+		resetTo: Type.String(),
+		patch: ArtifactRef,
+		compensated: Type.Array(EffectId)
+	})),
+	"git.worktree.removed": durable(Type.Object({
+		slot: Type.String(),
+		path: Type.String()
+	})),
+	"git.commit.created": durable(Type.Object({
+		slot: Type.String(),
+		branch: Type.String(),
+		sha: Type.String(),
+		kind: ClosedEnum(["result", "checkpoint"]),
+		treeDigest: Type.String(),
+		paths: Type.Array(Type.String()),
+		effectId: EffectId
+	})),
+	"git.merge.completed": durable(Type.Object({
+		from: Type.String(),
+		into: Type.String(),
+		mergeSha: Type.String(),
+		treeDigest: Type.String(),
+		effectId: EffectId
+	})),
+	"git.merge.conflicted": durable(Type.Object({
+		from: Type.String(),
+		into: Type.String(),
+		files: Type.Array(Type.String())
+	})),
+	"repo.change.detected": durable(Type.Object({
+		slot: Type.String(),
+		expected: Type.String(),
+		actual: Type.String(),
+		files: Type.Array(FileTouch)
+	})),
+	"lock.acquired": durable(Lock),
+	"lock.released": durable(Lock),
+	"lock.stolen": durable(Lock)
+};
+//#endregion
+//#region ../../packages/protocol/src/commands.ts
+/** `inspect { kind: 'artifact' }`: default 1 MiB, cap 3 MiB, so the document stays under a 4 MiB one-shot client. */
+const INSPECT_ARTIFACT_DEFAULT_BYTES = 1048576;
+const INSPECT_ARTIFACT_MAX_BYTES = 3145728;
+const count$1 = () => Type.Integer({ minimum: 0 });
+const COMMAND_AUTH_SCHEMES = ["hmac-sha256"];
+/**
+* Scheme-neutral, so an asymmetric signature (ADR-0022 "Revisit") is a MINOR. V3.0: value = hex
+* HMAC-SHA256(projectKey, canonicalCommandBody(envelope)). An unknown scheme VALIDATES under the open schema:
+* refusing it (`security/command-auth-invalid`) is the host's job, not the parser's.
+*/
+const CommandAuth = Type.Object({
+	scheme: OpenEnum(COMMAND_AUTH_SCHEMES),
+	value: Type.String({ minLength: 1 })
+});
+const StartPayload = Type.Object({
+	profile: PipelineProfile,
+	spec: Type.Optional(Type.Union([Type.Object({ id: SpecId }), Type.Object({ path: Type.String() })])),
+	reviewTarget: Type.Optional(Type.Union([
+		Type.Object({ ref: Type.String() }),
+		Type.Object({
+			base: Type.String(),
+			head: Type.String()
+		}),
+		Type.Object({ runId: RunId })
+	])),
+	withFix: Type.Optional(Type.Boolean()),
+	phases: Type.Optional(Type.Array(ActivePipelineState)),
+	/** keyed by role */
+	modelOverrides: Type.Optional(Type.Record(Type.String(), ModelRef)),
+	runtime: Type.Optional(Type.String()),
+	fakeScript: Type.Optional(Type.String()),
+	unattended: Type.Boolean(),
+	budgets: Type.Optional(BudgetCounters),
+	sandboxRequire: Type.Optional(ClosedEnum(["native", "best-effort"])),
+	/** 2.10.1: `--trust-project-config` travels in the SIGNED start command, so the host's re-check sees the consent the CLI saw */
+	consent: Type.Optional(Type.Object({
+		policySha256: Sha256,
+		via: Type.Literal("cli-flag")
+	}))
+});
+const InspectPayload = Type.Object({ target: Type.Union([
+	Type.Object({
+		kind: Type.Literal("agent"),
+		agentId: AgentId
+	}),
+	Type.Object({
+		kind: Type.Literal("context"),
+		agentId: AgentId,
+		incarnation: count$1()
+	}),
+	Type.Object({
+		kind: Type.Literal("approval"),
+		approvalId: ApprovalId
+	}),
+	Type.Object({
+		kind: Type.Literal("effect"),
+		effectId: EffectId
+	}),
+	Type.Object({ kind: Type.Literal("snapshot") }),
+	Type.Object({ kind: Type.Literal("locks") }),
+	Type.Object({
+		kind: Type.Literal("diff"),
+		surface: Type.Optional(SurfaceId)
+	}),
+	Type.Object({
+		kind: Type.Literal("artifact"),
+		artifactId: ArtifactId,
+		maxBytes: Type.Optional(Type.Integer({
+			minimum: 1,
+			maximum: INSPECT_ARTIFACT_MAX_BYTES,
+			default: INSPECT_ARTIFACT_DEFAULT_BYTES
+		})),
+		offset: Type.Optional(count$1())
+	})
+]) });
+const reader = (payload, route) => ({
+	payload,
+	route,
+	authenticated: false,
+	emitsResultEvent: false
+});
+const mutating = (payload, route) => ({
+	payload,
+	route: route ?? "inbox",
+	authenticated: true,
+	emitsResultEvent: true
+});
+const COMMANDS = {
+	start: mutating(StartPayload, "start"),
+	/** no runId => ProjectStatusDocument (R4 "current pipeline") */
+	status: reader(Type.Object({ runId: Type.Optional(RunId) }), "direct-read"),
+	inspect: reader(InspectPayload, "direct-read"),
+	tail: reader(Type.Object({
+		sinceSequence: Type.Optional(count$1()),
+		replay: Type.Optional(count$1()),
+		follow: Type.Boolean(),
+		ephemeral: Type.Boolean()
+	}), "direct-read"),
+	pause: mutating(Type.Object({ reason: Type.Optional(Type.String()) })),
+	resume: mutating(Type.Object({
+		acknowledge: Type.Optional(Type.Literal("blocked-inspected")),
+		raiseBudgets: Type.Optional(BudgetCounters),
+		takeover: Type.Optional(Type.Boolean())
+	})),
+	cancel: mutating(Type.Object({
+		reason: Type.Optional(Type.String()),
+		keepWorktrees: Type.Boolean()
+	})),
+	approve: mutating(Type.Object({
+		approvalId: ApprovalId,
+		scope: ClosedEnum(["once", "run"]),
+		/** required when the request carries `options`; must be one of them; echoed in the tool result */
+		answer: Type.Optional(Type.String()),
+		note: Type.Optional(Type.String())
+	})),
+	deny: mutating(Type.Object({
+		approvalId: ApprovalId,
+		note: Type.Optional(Type.String())
+	})),
+	retry: mutating(Type.Object({ target: Type.Union([Type.Object({
+		kind: Type.Literal("phase"),
+		state: Type.Optional(ActivePipelineState)
+	}), Type.Object({
+		kind: Type.Literal("agent"),
+		agentId: AgentId
+	})]) })),
+	/** only if policy.skip lists that phase */
+	skip: mutating(Type.Object({
+		phase: ActivePipelineState,
+		justification: Type.String({ minLength: 1 })
+	})),
+	/** admin; rejected unless policy.admin.runTool; still goes through the full gate chain */
+	"run-tool": mutating(Type.Object({
+		agentId: Type.Optional(AgentId),
+		tool: Type.String({ minLength: 1 }),
+		input: JsonValueSchema,
+		justification: Type.String({ minLength: 1 })
+	})),
+	/** V3.0: 'plan' only */
+	reconcile: reader(Type.Object({ mode: ClosedEnum(["plan", "apply"]) }), "cli-local"),
+	shutdown: mutating(Type.Object({ graceMs: count$1() })),
+	/** R11: optional, policy.steer.enabled, default false */
+	"agent.send": mutating(Type.Object({
+		agentId: AgentId,
+		text: Type.String(),
+		delivery: ClosedEnum(["steer", "follow-up"])
+	}))
+};
+const COMMAND_TYPES = Object.keys(COMMANDS);
+Type.Object({
+	protocolVersion: Type.Literal("1.0"),
+	/** client-generated; THE idempotency key. Same id + same body = same outcome; same id + other body = conflict/command-id-reuse */
+	commandId: CommandId,
+	/** narrowed per command */
+	type: Type.String({ minLength: 1 }),
+	runId: Type.Optional(RunId),
+	issuedAt: IsoInstant,
+	actor: Actor,
+	/** optimistic guard: reject if the run moved past this sequence */
+	expectedSequence: Type.Optional(count$1()),
+	/** narrowed per command */
+	payload: Type.Unknown(),
+	auth: Type.Optional(CommandAuth)
+});
+/**
+* The envelope MINUS `auth`, as canonical JSON: exactly what the authenticator covers, and the only thing `security`
+* ever sees of a command (it signs bytes, not envelopes). Key order never matters; every other field does.
+*/
+function canonicalCommandBody(envelope) {
+	const { auth: _auth, ...body } = envelope;
+	return canonicalJson(body);
+}
+/** Controller exit codes. 4 is not an error: the inbox is durable, the command is accepted but still pending at `--wait` expiry. */
+const CONTROLLER_EXIT_CODES = {
+	completed: 0,
+	usage: 2,
+	rejected: 3,
+	pending: 4
+};
+//#endregion
+//#region ../../packages/protocol/src/events/governance.ts
+const APPROVAL_DECISIONS = [
+	"allow-once",
+	"allow-for-run",
+	"deny",
+	"expired",
+	"superseded"
+];
+const BUDGET_LEVELS = [
+	"run",
+	"phase",
+	"agent",
+	"provider",
+	"tool"
+];
+const BUDGET_THRESHOLDS = [
+	50,
+	80,
+	100
+];
+const BUDGET_COUNTER_NAMES = [
+	"tokens",
+	"modelRequests",
+	"toolCalls",
+	"wallClockMs",
+	"retries",
+	"fixRounds",
+	"contextTokens",
+	"concurrentAgents",
+	"estimatedQuotaPercent"
+];
+const AUTH_REQUIRED_CAUSES = [
+	"absent",
+	"expired",
+	"refresh-failed",
+	"revoked",
+	"entitlement",
+	"mode-mismatch",
+	"ambient-source"
+];
+const RETRY_TARGET_KINDS = [
+	"agent",
+	"model-request",
+	"tool",
+	"phase"
+];
+const BudgetScope = Type.Object({
+	level: ClosedEnum(BUDGET_LEVELS),
+	id: Type.String()
+});
+/** A MINOR may add commands (2.3.2), so the `type` a command event names is open on the wire. */
+const CommandTypeName = OpenEnum(COMMAND_TYPES);
+/** Exported because `inspect { kind: 'approval' }` returns this payload as the decision (R6). */
+const ApprovalResolvedPayload = Type.Object({
+	approvalId: ApprovalId,
+	decision: ClosedEnum(APPROVAL_DECISIONS),
+	actor: Actor,
+	commandId: Type.Optional(CommandId),
+	/** the authenticator of the approve / deny command, copied so that the decision stays verifiable from the journal */
+	commandAuth: Type.Optional(CommandAuth),
+	grantId: Type.Optional(Type.String()),
+	/** one of `ApprovalRequest.options` */
+	answer: Type.Optional(Type.String()),
+	note: Type.Optional(Type.String())
+});
+const GOVERNANCE_EVENTS = {
+	/** R6 */
+	"approval.requested": durable(ApprovalRequest),
+	"approval.resolved": durable(ApprovalResolvedPayload),
+	/** coalesced: thresholds + at most 1 per 5 s per scope */
+	"budget.updated": durable(Type.Object({
+		scope: BudgetScope,
+		consumed: BudgetCounters,
+		limit: BudgetCounters,
+		threshold: Type.Optional(Type.Unsafe({
+			type: "integer",
+			enum: [...BUDGET_THRESHOLDS]
+		}))
+	})),
+	"budget.exceeded": durable(Type.Object({
+		scope: BudgetScope,
+		counter: ClosedEnum(BUDGET_COUNTER_NAMES),
+		limit: Type.Number({ minimum: 0 }),
+		consumed: Type.Number({ minimum: 0 })
+	})),
+	/** on change only */
+	"quota.updated": durable(Type.Object({
+		provider: Type.String(),
+		authMode: AuthMode,
+		quota: QuotaInfo
+	})),
+	"auth.required": durable(Type.Object({
+		provider: Type.String(),
+		cause: ClosedEnum(AUTH_REQUIRED_CAUSES),
+		cli: Type.String()
+	})),
+	"retry.scheduled": durable(Type.Object({
+		target: Type.Object({
+			kind: ClosedEnum(RETRY_TARGET_KINDS),
+			id: Type.String()
+		}),
+		attempt: count$2(),
+		maxAttempts: count$2(),
+		delayMs: milliseconds(),
+		cause: ErrorInfo
+	})),
+	/** `actor` as normalised by the host (2.6.7). An accepted command was authenticated: `authVerified` has one value. */
+	"command.accepted": durable(Type.Object({
+		commandId: CommandId,
+		type: CommandTypeName,
+		actor: Actor,
+		authVerified: Type.Literal(true),
+		scheme: OpenEnum(COMMAND_AUTH_SCHEMES)
+	})),
+	"command.completed": durable(Type.Object({
+		commandId: CommandId,
+		type: CommandTypeName,
+		result: JsonValueSchema
+	})),
+	"command.rejected": durable(Type.Object({
+		commandId: CommandId,
+		type: CommandTypeName,
+		error: ErrorInfo
+	}))
+};
+const RUN_EVENTS = {
+	"pipeline.started": durable(Type.Object({
+		profile: PipelineProfile,
+		tableVersion: count$2(),
+		spec: Type.Object({
+			id: SpecId,
+			sha256: Sha256,
+			kind: ClosedEnum([
+				"feature",
+				"patch",
+				"review"
+			])
+		}),
+		snapshotDigest: Sha256,
+		runtime: Type.Object({
+			id: Type.String(),
+			version: Type.String(),
+			pinDigest: Type.String()
+		}),
+		plan: RunPlan,
+		base: Type.Object({
+			branch: Type.String(),
+			sha: Type.String()
+		}),
+		integrationBranch: Type.String(),
+		cohorteVersion: Type.String(),
+		hostId: Type.String()
+	})),
+	"pipeline.completed": durable(Type.Object({
+		stop: StopRecord,
+		integration: Type.Object({
+			branch: Type.String(),
+			headSha: Type.String(),
+			treeDigest: Type.String()
+		}),
+		totals: Type.Object({
+			usage: BudgetCounters,
+			tokens: TokenUsage,
+			monetaryCost: MonetaryCost,
+			fixRounds: count$2(),
+			durationMs: milliseconds()
+		})
+	})),
+	"pipeline.failed": durable(Type.Object({
+		state: HaltedState,
+		error: ErrorInfo,
+		stop: StopRecord,
+		checkpointSequence: count$2()
+	})),
+	"run.state.changed": durable(Type.Object({
+		transitionId: Type.String(),
+		defId: Type.String(),
+		tableVersion: count$2(),
+		from: PipelineState,
+		to: PipelineState,
+		reason: TransitionReason,
+		actor: Actor,
+		guards: Type.Array(GuardOutcome),
+		idempotencyKey: Type.String(),
+		resumeTo: Type.Optional(ActivePipelineState),
+		stop: Type.Optional(StopRecord)
+	})),
+	"run.paused": durable(Type.Object({
+		commandId: Type.Optional(CommandId),
+		parkedAgents: Type.Array(AgentId),
+		inFlightEffects: Type.Array(EffectId)
+	})),
+	"run.resumed": durable(Type.Object({
+		commandId: Type.Optional(CommandId),
+		mode: ClosedEnum([
+			"unpause",
+			"recovery",
+			"retry"
+		]),
+		report: ResumeReport
+	})),
+	"run.cancelled": durable(Type.Object({
+		commandId: Type.Optional(CommandId),
+		reason: Type.String(),
+		cancelledAgents: Type.Array(AgentId),
+		worktreesKept: Type.Boolean()
+	})),
+	"run.host.attached": durable(Type.Object({
+		hostId: Type.String(),
+		pid: count$2(),
+		cohorteVersion: Type.String(),
+		fencingToken: count$2(),
+		takeover: Type.Boolean()
+	})),
+	"run.host.detached": durable(Type.Object({
+		hostId: Type.String(),
+		cause: ClosedEnum([
+			"exit",
+			"signal",
+			"lease-lost",
+			"shutdown-command",
+			"fatal"
+		])
+	})),
+	"phase.started": durable(Type.Object({
+		phase: PhaseRef,
+		contractId: Type.String(),
+		/** PhaseContract.version (DESIGN 2.5.2): a number */
+		contractVersion: count$2(),
+		planned: Type.Array(Type.Object({
+			agentId: AgentId,
+			role: Type.String(),
+			surface: Type.Optional(SurfaceId)
+		})),
+		budget: BudgetCounters
+	})),
+	"phase.completed": durable(Type.Object({
+		phase: PhaseRef,
+		outcome: ClosedEnum([
+			"passed",
+			"failed",
+			"needs-human",
+			"skipped"
+		]),
+		outputs: Type.Array(ArtifactRef),
+		checks: Type.Array(CheckResult),
+		durationMs: milliseconds()
+	})),
+	"check.started": durable(Type.Object({
+		name: Type.String(),
+		argv: Type.Array(Type.String()),
+		slot: Type.String()
+	})),
+	"check.completed": durable(CheckResult),
+	error: durable(Type.Object({
+		error: ErrorInfo,
+		fatal: Type.Boolean()
+	})),
+	"checkpoint.created": durable(Type.Object({
+		atSequence: count$2(),
+		snapshotSha256: Sha256,
+		chainHash: Type.String(),
+		chainMac: Type.String(),
+		cause: ClosedEnum([
+			"phase-boundary",
+			"interval",
+			"pause",
+			"shutdown",
+			"pre-effect",
+			"fatal"
+		])
+	}))
+};
+//#endregion
+//#region ../../packages/protocol/src/documents.ts
+const count = () => Type.Integer({ minimum: 0 });
+const documentVersion = () => Type.Literal(1);
+const protocolVersion = () => Type.Literal("1.0");
+const BILLING = ["plan-limits", "metered"];
+const ApprovalView = Type.Object({
+	approvalId: ApprovalId,
+	kind: Type.String(),
+	agentId: Type.Optional(AgentId),
+	/** sealed */
+	what: Type.String({ maxLength: 512 }),
+	since: IsoInstant,
+	expiresAt: Type.Optional(IsoInstant),
+	cli: Type.String()
+});
+const AgentNode = Type.Object({
+	agentId: AgentId,
+	role: Type.String(),
+	surface: Type.Optional(SurfaceId),
+	label: Type.String(),
+	status: NodeStatus,
+	lifecycle: AgentState,
+	attempt: count(),
+	incarnation: count(),
+	model: Type.Object({
+		requested: ModelRef,
+		effective: Type.Optional(Type.Object({
+			provider: Type.String(),
+			model: Type.String()
+		}))
+	}),
+	authMode: Type.Optional(AuthMode),
+	worktree: Type.Optional(Type.String()),
+	usage: BudgetCounters,
+	summary: Type.Optional(Type.String()),
+	lastError: Type.Optional(ErrorInfo),
+	pendingApproval: Type.Optional(ApprovalId),
+	/** R8: optional and opaque */
+	runtimeRef: Type.Optional(RuntimeRef)
+});
+const PhaseNode = Type.Object({
+	state: ActivePipelineState,
+	label: Type.String(),
+	status: NodeStatus,
+	runs: Type.Array(Type.Object({
+		phaseRunId: PhaseRunId,
+		iteration: count(),
+		status: NodeStatus,
+		startedAt: Type.Optional(IsoInstant),
+		endedAt: Type.Optional(IsoInstant),
+		outcome: Type.Optional(Type.String()),
+		agents: Type.Array(AgentNode),
+		checks: Type.Array(CheckResult)
+	}))
+});
+const RunNode = Type.Object({
+	runId: RunId,
+	profile: PipelineProfile,
+	title: Type.String(),
+	spec: Type.Object({
+		id: SpecId,
+		kind: Type.String(),
+		sha256: Sha256
+	}),
+	state: PipelineState,
+	status: NodeStatus,
+	since: IsoInstant,
+	resumeTo: Type.Optional(ActivePipelineState),
+	stop: Type.Optional(StopRecord),
+	lastError: Type.Optional(ErrorInfo),
+	iteration: Type.Object({
+		fixRounds: count(),
+		maxFixRounds: count(),
+		reviewRounds: count()
+	}),
+	host: Type.Object({
+		hostId: Type.Optional(Type.String()),
+		alive: Type.Boolean(),
+		heartbeatAt: Type.Optional(IsoInstant),
+		pid: Type.Optional(count())
+	}),
+	git: Type.Object({
+		base: Type.Object({
+			branch: Type.String(),
+			sha: Type.String()
+		}),
+		integrationBranch: Type.String(),
+		integrationHead: Type.Optional(Type.String()),
+		approvedTreeDigest: Type.Optional(Type.String())
+	}),
+	plan: RunPlan,
+	snapshotDigest: Sha256,
+	startedAt: IsoInstant,
+	endedAt: Type.Optional(IsoInstant)
+});
+/** `cohorte status <run> --json`, `inspect { kind: 'snapshot' }`, and the first line of every stream (R2). */
+const RunSnapshotDocument = Type.Object({
+	documentVersion: documentVersion(),
+	protocolVersion: protocolVersion(),
+	cohorteVersion: Type.String(),
+	generatedAt: IsoInstant,
+	lastSequence: count(),
+	run: RunNode,
+	/** table order for the profile, not-yet-run phases as 'pending' */
+	phases: Type.Array(PhaseNode),
+	approvals: Type.Object({
+		pending: Type.Array(ApprovalView),
+		resolved: count()
+	}),
+	budgets: Type.Array(Type.Object({
+		scope: Type.Object({
+			level: Type.String(),
+			id: Type.String()
+		}),
+		consumed: BudgetCounters,
+		limit: BudgetCounters
+	})),
+	usage: Type.Object({
+		tokens: TokenUsage,
+		monetaryCost: MonetaryCost,
+		byProvider: Type.Array(Type.Object({
+			provider: Type.String(),
+			authMode: AuthMode,
+			billing: ClosedEnum(BILLING),
+			tokens: TokenUsage,
+			quota: QuotaInfo,
+			accountLabel: Type.Optional(Type.String())
+		}))
+	}),
+	locks: Type.Array(Type.Object({
+		scope: Type.String(),
+		key: Type.String(),
+		mode: Type.String()
+	})),
+	inDoubtEffects: Type.Array(EffectId)
+});
+/**
+* One row of `ProjectStatusDocument.runs`: a PROJECTION of `RunSnapshotDocument.run`, never a second definition.
+*
+* KEEP THE EXPLICIT ANNOTATION. Biome 2.5.14 overflows its stack when it has to INFER the type of this pick, in every
+* file that names the const, and then exits 0 having linted nothing (docs/v3/requests/U0.02.md R1).
+*/
+const ProjectRunSummary = Type.Unsafe(Type.Pick(RunNode, [
+	"runId",
+	"profile",
+	"title",
+	"state",
+	"status",
+	"since",
+	"startedAt",
+	"endedAt",
+	"stop"
+]));
+/** `cohorte status --json` without a run: the "current pipeline" of R4. */
+const ProjectStatusDocument = Type.Object({
+	documentVersion: documentVersion(),
+	protocolVersion: protocolVersion(),
+	project: Type.Object({
+		id: Type.String(),
+		root: Type.String()
+	}),
+	runs: Type.Array(ProjectRunSummary),
+	pendingApprovals: Type.Array(ApprovalView)
+});
+/** spec 17.1 "diffs"; `cohorte diff --json`. A patch is fetched with `inspect { kind: 'artifact' }`. */
+const RunDiffDocument = Type.Object({
+	documentVersion: documentVersion(),
+	runId: RunId,
+	base: Type.Object({
+		branch: Type.String(),
+		sha: Type.String()
+	}),
+	head: Type.Object({
+		branch: Type.String(),
+		sha: Type.String(),
+		treeDigest: Type.String()
+	}),
+	surfaces: Type.Array(Type.Object({
+		surface: Type.Union([Type.Literal("shared"), SurfaceId]),
+		files: Type.Array(FileTouch),
+		stat: Type.Object({
+			added: count(),
+			removed: count()
+		}),
+		patch: ArtifactRef
+	}))
+});
+/**
+* The artifact window is capped in BYTES by the command (`maxBytes` <= INSPECT_ARTIFACT_MAX_BYTES). `content` is
+* those bytes as utf8 (never more characters than bytes) or as base64 (4 characters per 3 bytes): the base64 length
+* of the byte cap bounds both.
+*/
+const INSPECT_ARTIFACT_MAX_CONTENT_LENGTH = 4 * Math.ceil(INSPECT_ARTIFACT_MAX_BYTES / 3);
+const inspectHeader = () => ({
+	documentVersion: documentVersion(),
+	protocolVersion: protocolVersion(),
+	runId: RunId,
+	lastSequence: count()
+});
+/** Keyed by the published file name: `schemas/<name>.schema.json` (DESIGN 7.5 AC-07 lists them). */
+const DOCUMENTS = {
+	"run-state": RunSnapshotDocument,
+	"project-status": ProjectStatusDocument,
+	inspect: Type.Union([
+		Type.Object({
+			...inspectHeader(),
+			kind: Type.Literal("agent"),
+			agent: AgentNode,
+			grantsDigest: Sha256,
+			tools: Type.Array(Type.String()),
+			incarnations: Type.Array(Type.Object({
+				n: count(),
+				state: Type.String(),
+				startedAt: Type.Optional(IsoInstant),
+				endedAt: Type.Optional(IsoInstant),
+				stop: Type.Optional(Type.String()),
+				reason: Type.Optional(Type.String())
+			}))
+		}),
+		Type.Object({
+			...inspectHeader(),
+			kind: Type.Literal("context"),
+			agentId: AgentId,
+			incarnation: count(),
+			context: ContextBuiltPayload
+		}),
+		Type.Object({
+			...inspectHeader(),
+			kind: Type.Literal("approval"),
+			request: ApprovalRequest,
+			status: Type.String(),
+			decision: Type.Optional(ApprovalResolvedPayload)
+		}),
+		Type.Object({
+			...inspectHeader(),
+			kind: Type.Literal("effect"),
+			effect: Type.Object({
+				effectId: EffectId,
+				kind: Type.String(),
+				replayClass: Type.String(),
+				state: Type.String(),
+				toolCallId: Type.Optional(ToolCallId),
+				slot: Type.Optional(Type.String()),
+				request: JsonValueSchema,
+				result: Type.Optional(JsonValueSchema),
+				error: Type.Optional(ErrorInfo)
+			})
+		}),
+		Type.Object({
+			...inspectHeader(),
+			kind: Type.Literal("snapshot"),
+			document: RunSnapshotDocument
+		}),
+		Type.Object({
+			...inspectHeader(),
+			kind: Type.Literal("locks"),
+			locks: Type.Array(Type.Object({
+				scope: Type.String(),
+				key: Type.String(),
+				mode: Type.String(),
+				owner: Type.String(),
+				leaseExpiresAt: IsoInstant
+			}))
+		}),
+		Type.Object({
+			...inspectHeader(),
+			kind: Type.Literal("diff"),
+			diff: RunDiffDocument
+		}),
+		Type.Object({
+			...inspectHeader(),
+			kind: Type.Literal("artifact"),
+			artifact: ArtifactRef,
+			offset: count(),
+			bytes: Type.Integer({
+				minimum: 0,
+				maximum: INSPECT_ARTIFACT_MAX_BYTES
+			}),
+			truncated: Type.Boolean(),
+			encoding: ClosedEnum(["utf8", "base64"]),
+			/** sealed at write time */
+			content: Type.String({ maxLength: INSPECT_ARTIFACT_MAX_CONTENT_LENGTH })
+		})
+	]),
+	"run-diff": RunDiffDocument,
+	"command-result": Type.Object({
+		documentVersion: documentVersion(),
+		commandId: CommandId,
+		/** open on the wire: a MINOR may add commands */
+		type: OpenEnum(COMMAND_TYPES),
+		status: ClosedEnum([
+			"completed",
+			"rejected",
+			"pending"
+		]),
+		result: Type.Optional(JsonValueSchema),
+		error: Type.Optional(ErrorInfo),
+		lastSequence: Type.Optional(count())
+	}),
+	"doctor-report": Type.Object({
+		documentVersion: documentVersion(),
+		cohorteVersion: Type.String(),
+		generatedAt: IsoInstant,
+		ok: Type.Boolean(),
+		checks: Type.Array(Type.Object({
+			id: Type.String(),
+			status: OpenEnum([
+				"ok",
+				"warning",
+				"error",
+				"skipped"
+			]),
+			summary: Type.String(),
+			detail: Type.Optional(Type.String()),
+			remediation: Type.Optional(Type.String())
+		})),
+		sandbox: JsonValueSchema,
+		runtimeCapabilities: JsonValueSchema
+	}),
+	"auth-status": Type.Object({
+		documentVersion: documentVersion(),
+		generatedAt: IsoInstant,
+		runtime: Type.Object({
+			id: Type.String(),
+			version: Type.String()
+		}),
+		providers: Type.Array(Type.Object({
+			provider: Type.String(),
+			state: Type.String(),
+			subscription: Type.Boolean(),
+			billing: ClosedEnum([...BILLING, "unknown"]),
+			source: Type.Optional(Type.String()),
+			accountLabel: Type.Optional(Type.String()),
+			accountLabelNote: Type.Optional(Type.String()),
+			caveat: Type.Optional(Type.String()),
+			checkedAt: IsoInstant
+		}))
+	})
+};
+Object.keys(DOCUMENTS);
+//#endregion
+//#region ../../packages/protocol/src/events/stream.ts
+const STREAM_EVENTS = {
+	/** synthetic first line of every stream: a late client gets this, then the durable events after `lastSequence` */
+	snapshot: ephemeral(Type.Object({
+		document: RunSnapshotDocument,
+		lastSequence: count$2()
+	})),
+	/** every 15 s on `--follow` */
+	heartbeat: ephemeral(Type.Object({
+		hostAlive: Type.Boolean(),
+		lastSequence: count$2()
+	}))
+};
+//#endregion
+//#region ../../packages/protocol/src/events/tool.ts
+const TOOL_DENIAL_STAGES = [
+	"liveness",
+	"schema",
+	"capability",
+	"path",
+	"command",
+	"network",
+	"budget",
+	"approval"
+];
+const TOOL_REJECTION_CAUSES = [
+	"unknown-tool",
+	"invalid-input",
+	"output-truncated"
+];
+const TOOL_DECISIONS = [
+	"allow",
+	"allow-once",
+	"allow-for-run"
+];
+const FINDING_DISPOSITIONS = [
+	"kept",
+	"refuted",
+	"deferred",
+	"needs-investigation",
+	"duplicate"
+];
+const FileAccess = Type.Object({
+	toolCallId: ToolCallId,
+	file: FileTouch,
+	diffStat: Type.Optional(Type.Object({
+		added: count$2(),
+		removed: count$2()
+	}))
+});
+const TOOL_EVENTS = {
+	/** `args` is sealed */
+	"tool.requested": durable(Type.Object({
+		toolCallId: ToolCallId,
+		tool: Type.String(),
+		args: JsonValueSchema,
+		argsSha256: Sha256
+	})),
+	"tool.denied": durable(Type.Object({
+		toolCallId: ToolCallId,
+		tool: Type.String(),
+		stage: OpenEnum(TOOL_DENIAL_STAGES),
+		ruleId: Type.String(),
+		reason: Type.String(),
+		overridable: Type.Boolean(),
+		evaluatedRules: Type.Array(Type.String()),
+		approvalId: Type.Optional(ApprovalId)
+	})),
+	/**
+	* The ENGINE refused the call before the host saw it: no `toolCallId`, no gate, no rule ids — which is why it is
+	* not a `tool.denied`. `message` is sealed.
+	*/
+	"tool.rejected": durable(Type.Object({
+		engineToolCallId: Type.Optional(Type.String()),
+		tool: Type.String(),
+		cause: OpenEnum(TOOL_REJECTION_CAUSES),
+		message: Type.String()
+	})),
+	"tool.started": durable(Type.Object({
+		toolCallId: ToolCallId,
+		tool: Type.String(),
+		effectId: EffectId,
+		decision: ClosedEnum(TOOL_DECISIONS),
+		ruleId: Type.String(),
+		grantId: Type.Optional(Type.String()),
+		normalizedArgs: JsonValueSchema,
+		replayClass: ClosedEnum(REPLAY_CLASSES),
+		sandbox: SandboxReport,
+		/** marks a host-side replay of an approved call (4.5) */
+		replayOfApproval: Type.Optional(ApprovalId)
+	})),
+	"tool.progress": ephemeral(Type.Object({
+		toolCallId: ToolCallId,
+		text: Type.Optional(Type.String()),
+		bytes: Type.Optional(count$2())
+	})),
+	"tool.completed": durable(Type.Object({
+		toolCallId: ToolCallId,
+		tool: Type.String(),
+		effectId: EffectId,
+		isError: Type.Boolean(),
+		exitCode: Type.Optional(Type.Integer()),
+		signal: Type.Optional(Type.String()),
+		timedOut: Type.Boolean(),
+		durationMs: milliseconds(),
+		/** time the runtime waited for the host, from the delivery of the call */
+		waitedMs: milliseconds(),
+		output: Type.Object({
+			sha256: Sha256,
+			bytes: count$2(),
+			truncated: Type.Boolean(),
+			preview: Type.String(),
+			artifact: Type.Optional(ArtifactRef)
+		}),
+		filesTouched: Type.Array(FileTouch),
+		/** hits dropped by output filtering (2.7) */
+		filteredPaths: Type.Optional(count$2()),
+		replayed: Type.Boolean()
+	})),
+	"file.read": durable(FileAccess),
+	"file.written": durable(FileAccess),
+	"file.changed": durable(Type.Object({
+		slot: Type.String(),
+		files: Type.Array(FileTouch),
+		detectedBy: ClosedEnum(["post-command-scan", "ledger-audit"]),
+		attributedTo: Type.Optional(ToolCallId)
+	})),
+	"review.started": durable(Type.Object({
+		phase: PhaseRef,
+		reviewRef: ReviewRef,
+		surfaces: Type.Array(SurfaceId),
+		reviewers: Type.Array(AgentId)
+	})),
+	"review.finding": durable(Type.Object({
+		finding: Finding,
+		reviewer: AgentRef,
+		disposition: ClosedEnum(FINDING_DISPOSITIONS)
+	})),
+	"review.completed": durable(Type.Object({
+		verdict: ReviewResult.properties.verdict,
+		blocking: count$2(),
+		blockingItems: Type.Array(Type.String()),
+		fingerprint: ReviewResult.properties.fingerprint,
+		unreviewed: Type.Array(SurfaceId),
+		counts: ReviewResult.properties.counts,
+		clean: Type.Boolean()
+	})),
+	"review.approved": durable(Type.Object({
+		reviewRef: ReviewRef,
+		waivers: Type.Array(Type.Object({
+			findingId: FindingId,
+			approvalId: ApprovalId
+		}))
+	}))
+};
+//#endregion
+//#region ../../packages/protocol/src/catalogue.ts
+const EVENTS = {
+	...RUN_EVENTS,
+	...AGENT_EVENTS,
+	...TOOL_EVENTS,
+	...GOVERNANCE_EVENTS,
+	...GIT_EVENTS,
+	...STREAM_EVENTS
+};
+Object.keys(EVENTS).filter((type) => EVENTS[type].durability === "durable");
+const isEventType = (type) => Object.hasOwn(EVENTS, type);
+const isDurableEventType = (type) => isEventType(type) && EVENTS[type].durability === "durable";
+/**
+* `compileStrict(type)`, `compileStrictEnvelope(type)` and `toOpenJsonSchema()` with the exact signatures of
+* DESIGN 2.3.2, bound to EVENTS. The functions of the same names in compile.ts are generic over a table.
+*/
+const catalogue = bindCatalogue(EVENTS);
+//#endregion
+export { compileSchema as a, AgentOutput as c, EscalationPolicy as d, HALTED_STATES as f, ClosedEnum as g, TERMINAL_STATES as h, canonicalCommandBody as i, ACTIVE_PIPELINE_STATES as l, SUSPENDED_STATES as m, isDurableEventType as n, toStrictSchema as o, PipelineProfile as p, CONTROLLER_EXIT_CODES as r, compareOrder as s, catalogue as t, ActivePipelineState as u };
+
+//# sourceMappingURL=src-s7YRvk0t.mjs.map