@agentcomms/events-daemon 0.0.0-stage → 0.17.0

package/dist/b3-contract-DFxcHY0I.mjs

@@ -0,0 +1,2486 @@
+import { a as number, c as unknown, o as strictObject, s as string, t as McpServer } from "./mcp-DXXb3Vv3-B0sHZfig.mjs";
+import { a as EventDomainError, c as JUDGE_KIND_LOCAL_ENDPOINT, f as validateLocalEndpoint, g as parseIpLiteral, h as assertApprovedAddressSet, l as JUDGE_KIND_TYPESAFE, n as canonicalWebhookTarget, o as JUDGE_KINDS } from "./webhook-target-DyDTwWhV.mjs";
+import { createHash, randomBytes } from "node:crypto";
+import { chmod, lstat, mkdir, open, readFile, realpath, rm, writeFile } from "node:fs/promises";
+import { createConnection } from "node:net";
+import { CommsError, ERROR_REGISTRY, canonicalDisclosureBinding, canonicalJson, isCommsError, neutralise, resolvePaths, sha256Hex } from "@agentcomms/core";
+import { constants } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { TEST_CLOUD_EVENT, canonicaliseAgenticCondition, canonicaliseCondition, catalogueEntry, compileMapping, isJsonValue, parsePointer, validateCloudEventType } from "@agentcomms/events";
+//#region src/network/error-sink.ts
+/**
+* Keeps an owned network resource from turning a later transport error into an uncaught exception.
+* Operation-specific listeners still translate errors into their own result while they are active.
+*/
+function installErrorSink(resource) {
+	resource.on("error", () => void 0);
+	return resource;
+}
+//#endregion
+//#region src/runtime/paths.ts
+const DIRECTORY_MODE = 448;
+const FILE_MODE = 384;
+var EventPathError = class extends Error {
+	code;
+	path;
+	constructor(code, path) {
+		super(`Event state path is not safe: ${path}`);
+		this.name = "EventPathError";
+		this.code = code;
+		this.path = path;
+	}
+};
+const nodePathIo = {
+	mkdir,
+	lstat,
+	chmod,
+	open,
+	async isReparsePoint() {
+		return false;
+	},
+	async isCurrentUserOnly() {
+		return false;
+	}
+};
+function eventPaths(stateDir) {
+	const root = join(stateDir, "events");
+	return {
+		stateDir,
+		root,
+		database: join(root, "events.sqlite"),
+		databaseWal: join(root, "events.sqlite-wal"),
+		databaseShm: join(root, "events.sqlite-shm"),
+		lock: join(root, "events.lock"),
+		socketDir: join(root, "socket"),
+		controlSocket: join(root, "socket", "control.sock"),
+		controlToken: join(root, "control.token"),
+		instance: join(root, "instance.json"),
+		secretsDir: join(root, "secrets")
+	};
+}
+async function ensureEventPaths(paths, options = {}) {
+	const io = options.io ?? nodePathIo;
+	const platform = options.platform ?? process.platform;
+	await ensureOwnerOnlyDirectory(paths.stateDir, {
+		io,
+		platform
+	});
+	await ensureOwnerOnlyDirectory(paths.root, {
+		io,
+		platform
+	});
+	return paths;
+}
+/** Creates and verifies the private directory that contains the Unix control socket. */
+async function ensureEventSocketDirectory(paths, options = {}) {
+	const io = options.io ?? nodePathIo;
+	const platform = options.platform ?? process.platform;
+	await ensureOwnerOnlyDirectory(paths.socketDir, {
+		io,
+		platform
+	});
+}
+async function ensureOwnerOnlyFile(path, options = {}) {
+	const io = options.io ?? nodePathIo;
+	const platform = options.platform ?? process.platform;
+	let exists = true;
+	try {
+		await io.lstat(path);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+		exists = false;
+	}
+	if (!exists) {
+		const noFollow = platform === "win32" ? 0 : constants.O_NOFOLLOW;
+		try {
+			await (await io.open(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | noFollow, FILE_MODE)).close();
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+		}
+	}
+	await verifyOwnerOnly(path, {
+		io,
+		platform,
+		kind: "file"
+	});
+}
+async function ensureOwnerOnlyDirectory(path, options) {
+	await options.io.mkdir(path, {
+		recursive: true,
+		mode: DIRECTORY_MODE
+	});
+	await verifyOwnerOnly(path, {
+		...options,
+		kind: "directory"
+	});
+}
+async function verifyOwnerOnly(path, options) {
+	const info = await options.io.lstat(path);
+	if (info.isSymbolicLink()) throw new EventPathError("EVENT_PATH_LINK", path);
+	if (await options.io.isReparsePoint?.(path) === true) throw new EventPathError("EVENT_PATH_REPARSE_POINT", path);
+	if (options.kind === "directory" && !info.isDirectory()) throw new EventPathError("EVENT_PATH_TYPE", path);
+	if (options.kind === "file" && !info.isFile()) throw new EventPathError("EVENT_PATH_TYPE", path);
+	if (options.platform === "win32") {
+		if (await options.io.isCurrentUserOnly?.(path) !== true) throw new EventPathError("EVENT_PATH_PERMISSIONS", path);
+		return;
+	}
+	if ((info.mode & 63) !== 0) throw new EventPathError("EVENT_PATH_PERMISSIONS", path);
+}
+//#endregion
+//#region src/control/endpoint.ts
+const nodeEndpointIo = {
+	lstat,
+	realpath
+};
+/** The longest Unix socket path the platform's `sun_path` holds, in bytes, leaving room for its terminating NUL. */
+function maxSocketPathBytes(platform = process.platform) {
+	return platform === "linux" || platform === "android" ? 107 : 103;
+}
+/** The control endpoint for this state directory. */
+function controlEndpoint(paths, platform = process.platform) {
+	if (platform !== "win32") return paths.controlSocket;
+	return `\\\\.\\pipe\\agent-communications-events-${createHash("sha256").update(paths.root).digest("hex")}`;
+}
+/** Refuses on a platform where the control boundary D12 requires cannot be built. */
+function assertControlSupported(platform = process.platform) {
+	if (platform !== "win32") return;
+	throw new CommsError("CONFIG", "the local event service does not run on Windows in this release", {
+		hint: "Its control channel needs a named pipe that only your Windows account can open, which Node cannot create. Run it on macOS or Linux for now.",
+		details: { reason: "WINDOWS_CONTROL_UNAVAILABLE" }
+	});
+}
+function refused(reason, path, message) {
+	return new CommsError("CONFIG", message, {
+		hint: "Pin a private state directory with --state-dir, one only your account can reach, and run it again.",
+		details: {
+			reason,
+			path
+		}
+	});
+}
+function currentUid(options) {
+	const uid = options.uid ?? (typeof process.getuid === "function" ? process.getuid() : void 0);
+	if (uid === void 0) throw new CommsError("CONFIG", "this platform reports no user id for the local event service to check");
+	return uid;
+}
+/** The socket path fits the platform's limit, or a named refusal — never a silently truncated path. */
+function assertSocketPathFits(socketPath, platform = process.platform) {
+	const bytes = Buffer.byteLength(socketPath, "utf8");
+	if (bytes <= maxSocketPathBytes(platform)) return;
+	throw new CommsError("CONFIG", `the local event control socket path is ${bytes} bytes; this system allows ${maxSocketPathBytes(platform)}`, {
+		hint: "Pin a shorter state directory with --state-dir and run it again.",
+		details: {
+			reason: "SOCKET_PATH_TOO_LONG",
+			bytes,
+			limit: maxSocketPathBytes(platform)
+		}
+	});
+}
+/**
+* The socket directory is a real directory owned by this uid with mode 0700, and every ancestor is owned by this uid
+* or root and is either not writable by others or sticky — so nobody else can reach, rename or replace it.
+*/
+async function verifyPrivateSocketDirectory(paths, options = {}) {
+	assertControlSupported(options.platform ?? process.platform);
+	const io = options.io ?? nodeEndpointIo;
+	const uid = currentUid(options);
+	const directory = paths.socketDir;
+	const info = await statOrRefuse(io, directory);
+	if (info.isSymbolicLink() || !info.isDirectory()) throw refused("SOCKET_DIRECTORY_NOT_DIRECTORY", directory, "the local event socket directory is not a directory");
+	if (info.uid !== uid) throw refused("SOCKET_DIRECTORY_OWNER", directory, "the local event socket directory belongs to another user");
+	if ((info.mode & 511) !== 448) throw refused("SOCKET_DIRECTORY_MODE", directory, "the local event socket directory is reachable by other users");
+	for (let ancestor = await io.realpath(dirname(directory));; ancestor = dirname(ancestor)) {
+		const parent = await statOrRefuse(io, ancestor);
+		if (parent.uid !== uid && parent.uid !== 0) throw refused("SOCKET_ANCESTOR_OWNER", ancestor, "a directory above the local event socket belongs to another user");
+		if ((parent.mode & 18) !== 0 && (parent.mode & 512) === 0) throw refused("SOCKET_ANCESTOR_WRITABLE", ancestor, "a directory above the local event socket can be changed by other users");
+		if (dirname(ancestor) === ancestor) break;
+	}
+}
+/** The socket itself is this uid's, mode 0600, and a socket — checked by a client before it sends the token. */
+async function verifyControlSocket(socketPath, options = {}) {
+	const io = options.io ?? nodeEndpointIo;
+	const uid = currentUid(options);
+	const info = await statOrRefuse(io, socketPath);
+	if (info.isSymbolicLink() || !info.isSocket()) throw refused("SOCKET_NOT_SOCKET", socketPath, "the local event control endpoint is not a socket");
+	if (info.uid !== uid) throw refused("SOCKET_OWNER", socketPath, "the local event control socket belongs to another user");
+	if ((info.mode & 63) !== 0) throw refused("SOCKET_MODE", socketPath, "the local event control socket is reachable by other users");
+}
+async function statOrRefuse(io, path) {
+	try {
+		return await io.lstat(path);
+	} catch (error) {
+		if (error.code === "ENOENT") throw new CommsError("NOT_FOUND", "the local event service is not running", { hint: "Start the local event service in a terminal before requesting its runtime controls." });
+		throw error;
+	}
+}
+//#endregion
+//#region src/control/instance.ts
+function tokenFingerprint(token) {
+	return createHash("sha256").update(token).digest("hex");
+}
+function newInstanceRecord(endpoint, token) {
+	return {
+		instanceId: randomBytes(16).toString("hex"),
+		pid: process.pid,
+		processStart: `${process.pid}:${Math.trunc(process.uptime() * 1e3)}`,
+		endpoint,
+		tokenFingerprint: tokenFingerprint(token)
+	};
+}
+async function mayRecoverStaleInstance(check) {
+	if (!await check.ownershipMatches(check.record)) return false;
+	if (await check.isProcessLive(check.record)) return false;
+	return !await check.authenticatedProbe(check.record);
+}
+async function readInstance(paths) {
+	let text;
+	try {
+		text = await readFile(paths.instance, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+	try {
+		const parsed = JSON.parse(text);
+		if (!isInstanceRecord(parsed)) throw new Error("invalid local event instance record");
+		return parsed;
+	} catch {
+		throw new Error(`invalid local event instance record ${basename(paths.instance)}`);
+	}
+}
+async function writeInstance(paths, record) {
+	await writeFile(paths.instance, `${JSON.stringify(record)}\n`, {
+		encoding: "utf8",
+		mode: 384
+	});
+	await chmod(paths.instance, 384);
+}
+async function removeInstance(paths, instanceId) {
+	if ((await readInstance(paths))?.instanceId === instanceId) await rm(paths.instance, { force: true });
+}
+async function processIsLive(record) {
+	try {
+		process.kill(record.pid, 0);
+		return true;
+	} catch (error) {
+		return error.code !== "ESRCH";
+	}
+}
+function isInstanceRecord(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const record = value;
+	return typeof record.instanceId === "string" && /^[0-9a-f]{32}$/.test(record.instanceId) && typeof record.pid === "number" && Number.isInteger(record.pid) && record.pid > 0 && typeof record.processStart === "string" && record.processStart.length > 0 && typeof record.endpoint === "string" && record.endpoint.length > 0 && typeof record.tokenFingerprint === "string" && /^[0-9a-f]{64}$/.test(record.tokenFingerprint);
+}
+//#endregion
+//#region src/control/protocol.ts
+const CONTROL_PROTOCOL_VERSIONS = [1];
+function controlFailure(code, message, hint) {
+	return {
+		ok: false,
+		error: {
+			code,
+			message,
+			...hint === void 0 ? {} : { hint },
+			retryable: false
+		}
+	};
+}
+function negotiateVersion(clientVersions, serverVersions = CONTROL_PROTOCOL_VERSIONS) {
+	const shared = clientVersions.filter((version) => Number.isSafeInteger(version) && serverVersions.includes(version));
+	if (shared.length === 0) return {
+		ok: false,
+		code: "PROTOCOL_UNSUPPORTED"
+	};
+	return {
+		ok: true,
+		version: Math.max(...shared)
+	};
+}
+function malformed() {
+	return /* @__PURE__ */ new Error("malformed local control frame");
+}
+function encodeControlFrame(value) {
+	const payload = new TextEncoder().encode(JSON.stringify(value));
+	if (payload.byteLength > 65536) throw new Error("local control frame is too large");
+	const frame = new Uint8Array(4 + payload.byteLength);
+	new DataView(frame.buffer).setUint32(0, payload.byteLength, false);
+	frame.set(payload, 4);
+	return frame;
+}
+/** Decodes exactly one complete length-prefixed control frame. */
+function decodeControlFrame(frame) {
+	if (frame.byteLength < 4) throw malformed();
+	const length = new DataView(frame.buffer, frame.byteOffset, frame.byteLength).getUint32(0, false);
+	if (length > 65536) throw new Error("local control frame is too large");
+	if (frame.byteLength !== length + 4) throw malformed();
+	try {
+		return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(frame.subarray(4)));
+	} catch {
+		throw malformed();
+	}
+}
+/** Incrementally separates complete frames without buffering an unbounded peer payload. */
+var ControlFrameReader = class {
+	#buffer = /* @__PURE__ */ new Uint8Array();
+	push(chunk) {
+		let buffered = this.#buffer;
+		let offset = 0;
+		const values = [];
+		while (offset < chunk.byteLength || buffered.byteLength >= 4) {
+			if (buffered.byteLength < 4) {
+				const remainingHeader = 4 - buffered.byteLength;
+				const take = Math.min(remainingHeader, chunk.byteLength - offset);
+				buffered = append(buffered, chunk.subarray(offset, offset + take));
+				offset += take;
+				if (buffered.byteLength < 4) break;
+			}
+			const length = new DataView(buffered.buffer, buffered.byteOffset, buffered.byteLength).getUint32(0, false);
+			if (length > 65536) throw new Error("local control frame is too large");
+			const frameLength = length + 4;
+			if (buffered.byteLength < frameLength) {
+				const take = Math.min(frameLength - buffered.byteLength, chunk.byteLength - offset);
+				buffered = append(buffered, chunk.subarray(offset, offset + take));
+				offset += take;
+				if (buffered.byteLength < frameLength) break;
+			}
+			values.push(decodeControlFrame(buffered.subarray(0, frameLength)));
+			buffered = buffered.subarray(frameLength);
+		}
+		this.#buffer = buffered.slice();
+		return values;
+	}
+};
+function append(first, second) {
+	const joined = new Uint8Array(first.byteLength + second.byteLength);
+	joined.set(first);
+	joined.set(second, first.byteLength);
+	return joined;
+}
+function isControlHello(value) {
+	if (!isRecord$3(value) || !isRecord$3(value.hello)) return false;
+	const { supportedVersions, token, client } = value.hello;
+	return Array.isArray(supportedVersions) && supportedVersions.length > 0 && supportedVersions.length <= 8 && supportedVersions.every((version) => Number.isSafeInteger(version)) && typeof token === "string" && token.length === 64 && isRecord$3(client) && typeof client.name === "string" && client.name.length > 0 && client.name.length <= 128;
+}
+function isControlRequest(value) {
+	if (!isRecord$3(value)) return false;
+	return Number.isSafeInteger(value.version) && typeof value.requestId === "string" && value.requestId.length > 0 && value.requestId.length <= 128 && typeof value.session === "string" && value.session.length > 0 && value.session.length <= 256 && typeof value.operation === "string" && value.operation.length > 0 && value.operation.length <= 128 && isRecord$3(value.args);
+}
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/control/client.ts
+var EventControlClient = class {
+	#paths;
+	#clientName;
+	constructor(options = {}) {
+		this.#paths = eventPaths(options.stateDir ?? resolvePaths().stateDir);
+		this.#clientName = options.clientName ?? "events-cli";
+	}
+	async request(operation, args = {}) {
+		assertControlSupported();
+		const record = await readInstance(this.#paths);
+		if (!record) throw notRunning();
+		await verifyOwnEndpoint(this.#paths, record);
+		const token = await readToken(this.#paths, record);
+		try {
+			return await requestControl(record, token, this.#clientName, operation, args);
+		} catch (error) {
+			if (isMissingOwner(error)) throw notRunning();
+			throw error;
+		}
+	}
+};
+/** Proves the instance names this state directory's own private socket, before any token is sent to it. */
+async function verifyOwnEndpoint(paths, record) {
+	if (record.endpoint !== controlEndpoint(paths)) throw notRunning();
+	await verifyPrivateSocketDirectory(paths);
+	await verifyControlSocket(record.endpoint);
+}
+async function probeControl(paths, record, token) {
+	try {
+		await verifyOwnEndpoint(paths, record);
+		await requestControl(record, token, "events-owner-probe", "status", {});
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function requestControl(record, token, clientName, operation, args) {
+	const socket = await connect(record.endpoint);
+	try {
+		const hello = await exchange(socket, { hello: {
+			supportedVersions: CONTROL_PROTOCOL_VERSIONS,
+			token,
+			client: { name: clientName }
+		} });
+		if (!hello.ok || hello.version === void 0 || hello.session === void 0) throw controlError(hello);
+		const reply = await exchange(socket, {
+			version: hello.version,
+			requestId: randomBytes(16).toString("base64url"),
+			session: hello.session,
+			operation,
+			args
+		});
+		if (!reply.ok) throw controlError(reply);
+		return reply.data;
+	} finally {
+		socket.end();
+	}
+}
+async function readToken(paths, record) {
+	let token;
+	try {
+		token = (await readFile(paths.controlToken, "utf8")).trim();
+	} catch (error) {
+		if (error.code === "ENOENT") throw notRunning();
+		throw error;
+	}
+	if (!/^[0-9a-f]{64}$/.test(token) || tokenFingerprint(token) !== record.tokenFingerprint) throw notRunning();
+	return token;
+}
+function connect(endpoint) {
+	return new Promise((resolve, reject) => {
+		const socket = createConnection(endpoint);
+		installErrorSink(socket);
+		socket.once("connect", () => {
+			socket.off("error", reject);
+			resolve(socket);
+		});
+		socket.once("error", reject);
+	});
+}
+function exchange(socket, value) {
+	return new Promise((resolve, reject) => {
+		const reader = new ControlFrameReader();
+		const onData = (chunk) => {
+			try {
+				const frame = reader.push(chunk)[0];
+				if (frame === void 0) return;
+				cleanup();
+				resolve(frame);
+			} catch (error) {
+				cleanup();
+				reject(error);
+			}
+		};
+		const onError = (error) => {
+			cleanup();
+			reject(error);
+		};
+		const cleanup = () => {
+			socket.off("data", onData);
+			socket.off("error", onError);
+		};
+		socket.on("data", onData);
+		socket.once("error", onError);
+		socket.write(encodeControlFrame(value));
+	});
+}
+function controlError(reply) {
+	if (!reply.ok) {
+		const options = {
+			...reply.error.hint === void 0 ? {} : { hint: reply.error.hint },
+			...reply.error.details === void 0 ? {} : { details: reply.error.details }
+		};
+		const code = reply.error.code;
+		if (code === "PROTOCOL_UNSUPPORTED") return new CommsError("CONFIG", reply.error.message, options);
+		if (Object.hasOwn(ERROR_REGISTRY, code)) return new CommsError(code, reply.error.message, options);
+		return new CommsError("BAD_DATA", reply.error.message, options);
+	}
+	return new CommsError("BAD_DATA", "local control hello was malformed");
+}
+function notRunning() {
+	return new CommsError("NOT_FOUND", "the local event service is not running", { hint: "Start the local event service in a terminal before requesting its runtime controls." });
+}
+function isMissingOwner(error) {
+	const code = error?.code;
+	return code === "ECONNREFUSED" || code === "ENOENT" || code === "ECONNRESET";
+}
+//#endregion
+//#region src/operations/approval-view.ts
+/** Returns the daemon-authoritative preview and fresh challenge; it never claims an approval. */
+async function approvalView(approvalId, digest, options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("approvalView", {
+		approvalId,
+		digest
+	});
+}
+//#endregion
+//#region src/operations/catalogue.ts
+/** Lists the held Phase A catalogue through the owner without opening event SQLite in a client. */
+async function catalogueList(options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("catalogue-list");
+}
+/** Shows one selectable catalogue definition through the owner. */
+async function catalogueShow(type, options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("catalogue-show", { type });
+}
+//#endregion
+//#region src/operations/deliveries.ts
+async function deliveriesList(options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("deliveriesList");
+}
+async function retryDelivery(deliveryId, options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("retryDelivery", { deliveryId });
+}
+async function dropDelivery(deliveryId, options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("dropDelivery", { deliveryId });
+}
+async function heldList(options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("heldList");
+}
+/** Terminal/app-only operation; Task 5 intentionally provides no MCP adapter. */
+async function decideHeld(decisionId, decision, options = {}) {
+	return new EventControlClient({
+		stateDir: options.stateDir,
+		clientName: "interactive-terminal"
+	}).request("decideHeld", {
+		decisionId,
+		decision
+	});
+}
+//#endregion
+//#region src/operations/disable-all.ts
+async function disableAll(options = {}) {
+	return await new EventControlClient({ stateDir: options.stateDir }).request("disable-all");
+}
+//#endregion
+//#region src/domain/activation-failure-codes.ts
+/** Codes persisted by the activation writers. Database rows from older or damaged state are not trusted as codes. */
+const ACTIVATION_FAILURE = {
+	ACCOUNT_REMOVED: "ACCOUNT_REMOVED",
+	APPROVAL_ABSENT: "APPROVAL_ABSENT",
+	APPROVAL_BINDING_DRIFT: "APPROVAL_BINDING_DRIFT",
+	AUTHORIZATION_REVOKED: "AUTHORIZATION_REVOKED",
+	COMPLETION_TIMEOUT: "COMPLETION_TIMEOUT",
+	STALE_GENERATION: "STALE_GENERATION",
+	STALE_POINTER: "STALE_POINTER"
+};
+const ACTIVATION_FAILURE_CODES = Object.values(ACTIVATION_FAILURE);
+const ACTIVATION_FAILURE_CODE_SET = new Set(ACTIVATION_FAILURE_CODES);
+function isActivationFailureCode(value) {
+	return typeof value === "string" && ACTIVATION_FAILURE_CODE_SET.has(value);
+}
+[...ACTIVATION_FAILURE_CODES];
+/**
+* The transport binding mirrors the root `additionalProperties: false` in doctor-v1.schema.json. Keeping this at
+* the production projection boundary makes an accidental diagnostic field fail closed before CLI or MCP can render
+* it; nested fields are constructed from closed object literals in the projection below that boundary.
+*/
+const DOCTOR_REPORT_V1_KEYS = [
+	"schemaVersion",
+	"owner",
+	"switch",
+	"lineages",
+	"superseded",
+	"points",
+	"awaitingReapproval",
+	"activationIntents",
+	"sources",
+	"recovery",
+	"judgeBoundary",
+	"whatsapp"
+];
+function assertDoctorReportV1(report) {
+	if (Object.keys(report).some((key) => !DOCTOR_REPORT_V1_KEYS.includes(key))) throw new Error("doctor-v1 report is closed");
+	return report;
+}
+const DOCTOR_REPORT_V2_KEYS = [
+	"schemaVersion",
+	"owner",
+	"switch",
+	"lineages",
+	"superseded",
+	"points",
+	"awaitingReapproval",
+	"activationIntents",
+	"sources",
+	"recovery",
+	"judgeBoundary",
+	"judge",
+	"whatsapp"
+];
+function assertDoctorReportV2(report) {
+	if (Object.keys(report).some((key) => !DOCTOR_REPORT_V2_KEYS.includes(key))) throw new Error("doctor-v2 report is closed");
+	return report;
+}
+async function doctor(options = {}) {
+	return await new EventControlClient({ stateDir: options.stateDir }).request("doctor");
+}
+//#endregion
+//#region src/operations/enable-all.ts
+/** The disclosure approval/activation route lands with the immutable activation work in Batch 3. */
+async function enableAll(options = {}) {
+	return await new EventControlClient({ stateDir: options.stateDir }).request("enable-all");
+}
+//#endregion
+//#region src/operations/judges.ts
+function request(operation, args, options) {
+	return new EventControlClient({ stateDir: options.stateDir }).request(operation, args);
+}
+function judgesList(options = {}) {
+	return request("judgesList", {}, options);
+}
+function addJudge(document, options = {}) {
+	return request("addJudge", { document }, options);
+}
+function updateJudge(document, options = {}) {
+	return request("updateJudge", { document }, options);
+}
+function removeJudge(judgeId, options = {}) {
+	return request("removeJudge", { judgeId }, options);
+}
+function judgeTest(judgeId, version, options = {}) {
+	return request("judgeTest", {
+		judgeId,
+		version
+	}, options);
+}
+function budgetShow(options = {}) {
+	return request("budgetShow", {}, options);
+}
+function updateBudget(document, options = {}) {
+	return request("updateBudget", { document }, options);
+}
+function judgeKindsList(options = {}) {
+	return request("judgeKindsList", {}, options);
+}
+function enableJudgeKind(kind, options = {}) {
+	return request("enableJudgeKind", { kind }, options);
+}
+function disableJudgeKind(kind, options = {}) {
+	return request("disableJudgeKind", { kind }, options);
+}
+function judgeModelStatus(options = {}) {
+	return request("judgeModelStatus", {}, options);
+}
+function removeJudgeModel(options = {}) {
+	return request("removeJudgeModel", {}, options);
+}
+//#endregion
+//#region src/operations/pause.ts
+async function pause(options = {}) {
+	return await new EventControlClient({ stateDir: options.stateDir }).request("pause");
+}
+async function resume(options = {}) {
+	return await new EventControlClient({ stateDir: options.stateDir }).request("resume");
+}
+//#endregion
+//#region src/operations/rule-test.ts
+/** Calls the owner-local deterministic catalogue test; neither this operation nor its caller can supply event bytes. */
+async function ruleTest(document, catalogue, options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("ruleTest", {
+		document,
+		catalogue
+	});
+}
+/** Retained projections stay behind the owner boundary and are intentionally a human-only capability. */
+async function ruleTestRetained(eventId, ruleId, ruleVersion, options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("ruleTestRetained", {
+		eventId,
+		ruleId,
+		ruleVersion
+	});
+}
+//#endregion
+//#region src/operations/rules.ts
+async function rulesList(options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("rules-list");
+}
+async function ruleShow(ruleId, options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("rule-show", { ruleId });
+}
+async function createRule(document, options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("rule-create", { document });
+}
+async function updateRule(document, options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("rule-update", { document });
+}
+async function enableRule(ruleId, version, options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("rule-enable", {
+		ruleId,
+		version
+	});
+}
+async function disableRule(ruleId, options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("rule-disable", { ruleId });
+}
+async function removeRule(ruleId, options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("rule-remove", { ruleId });
+}
+//#endregion
+//#region src/operations/sources.ts
+async function sourcesList(options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("sources-list");
+}
+async function sourceShow(source, options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("source-show", { source });
+}
+//#endregion
+//#region src/runtime/sqlite.ts
+/** The oldest Node the event daemon runs on. Stated in `engines`, and checked before the module is imported. */
+const MIN_NODE = "22.16.0";
+function parts(version) {
+	return version.replace(/^v/, "").split(/[.-]/).slice(0, 3).map((part) => Number.parseInt(part, 10) || 0);
+}
+/** Whether `version` (default: this Node's) is `MIN_NODE` or newer. */
+function nodeSupportsSqlite(version = process.versions.node) {
+	const have = parts(version);
+	const need = parts(MIN_NODE);
+	for (let index = 0; index < 3; index += 1) if ((have[index] ?? 0) !== (need[index] ?? 0)) return (have[index] ?? 0) > (need[index] ?? 0);
+	return true;
+}
+/** Refuses to go on under a Node too old for its SQLite, saying which Node it is and what it needs. */
+function requireSupportedNode(version = process.versions.node) {
+	if (nodeSupportsSqlite(version)) return;
+	throw new CommsError("CONFIG", `the local event service needs Node ${MIN_NODE} or newer, and this is Node ${version}`, {
+		hint: `It keeps its state in Node's own SQLite, which Node ${MIN_NODE} is the first to have complete. Install a newer Node — the current 22 or 24 release — and run it again.`,
+		details: {
+			reason: "NODE_TOO_OLD",
+			node: version,
+			needs: MIN_NODE
+		}
+	});
+}
+let loaded = null;
+function loadSqlite() {
+	try {
+		requireSupportedNode();
+	} catch (error) {
+		return Promise.reject(error);
+	}
+	if (!loaded) {
+		loaded = (async () => {
+			const original = process.emitWarning;
+			process.emitWarning = function filtered(warning, ...rest) {
+				if ((typeof warning === "string" ? warning : warning.message).includes("SQLite is an experimental feature")) return;
+				return original.call(process, warning, ...rest);
+			};
+			try {
+				return await import("node:sqlite");
+			} catch (error) {
+				throw new CommsError("CONFIG", `this Node (${process.versions.node}) has no usable built-in SQLite`, {
+					hint: `The local event service needs Node ${MIN_NODE} or newer, run without flags that turn built-in modules off.`,
+					cause: error
+				});
+			} finally {
+				process.emitWarning = original;
+			}
+		})();
+		loaded.catch(() => {
+			loaded = null;
+		});
+	}
+	return loaded;
+}
+//#endregion
+//#region src/operations/status.ts
+/** Reports an owner through its authenticated control boundary, without opening its SQLite database in the client. */
+async function status(options = {}) {
+	requireSupportedNode();
+	try {
+		return await new EventControlClient({ stateDir: options.stateDir }).request("status");
+	} catch (error) {
+		if (isCommsError(error) && error.code === "NOT_FOUND") return { owner: "not-running" };
+		throw error;
+	}
+}
+//#endregion
+//#region src/operations/stop.ts
+/** Requests a clean foreground-owner shutdown through the authenticated local control protocol. */
+async function stop(options = {}) {
+	return await new EventControlClient({ stateDir: options.stateDir }).request("stop");
+}
+//#endregion
+//#region src/operations/subscribers.ts
+async function subscribersList(options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("subscribersList");
+}
+async function addSubscriber(document, options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("addSubscriber", { document });
+}
+async function updateSubscriber(document, options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("updateSubscriber", { document });
+}
+async function removeSubscriber(subscriberId, options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("removeSubscriber", { subscriberId });
+}
+//#endregion
+//#region src/operations/target-test.ts
+/** The owner constructs the fixed synthetic payload; callers name only the exact immutable target version. */
+async function targetTest(targetId, targetVersion, options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("targetTest", {
+		targetId,
+		targetVersion
+	});
+}
+//#endregion
+//#region src/operations/targets.ts
+async function targetsList(options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("targets-list");
+}
+async function addTarget(document, options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("target-add", { document });
+}
+async function updateTarget(document, options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("target-update", { document });
+}
+async function removeTarget(targetId, options = {}) {
+	return new EventControlClient({ stateDir: options.stateDir }).request("target-remove", { targetId });
+}
+//#endregion
+//#region src/version.ts
+/** The package version, read from package.json at build time. */
+const VERSION = "0.17.0";
+//#endregion
+//#region src/mcp/server.ts
+function reply(data) {
+	const structured = JSON.parse(JSON.stringify(data));
+	return {
+		structuredContent: structured,
+		content: [{
+			type: "text",
+			text: JSON.stringify(structured)
+		}]
+	};
+}
+/** Creates the local event service's deliberately content-free MCP surface. */
+async function createEventsMcpServer(options = {}) {
+	const server = new McpServer({
+		name: "agent-events",
+		version: VERSION
+	});
+	const b3 = (operation, args, throughOwner) => options.b3Registrar === void 0 ? throughOwner() : options.b3Registrar.owner.handle({
+		operation,
+		args
+	});
+	server.registerTool("events_status", {
+		title: "Local event service status",
+		description: "Reports whether the local event service has an owner.",
+		inputSchema: {},
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async () => reply(await status({ stateDir: options.stateDir })));
+	const runtimeTool = (name, title, description, operation, annotations) => {
+		server.registerTool(name, {
+			title,
+			description,
+			inputSchema: {},
+			annotations: {
+				readOnlyHint: false,
+				openWorldHint: false,
+				...annotations
+			}
+		}, async () => reply(await operation(options)));
+	};
+	runtimeTool("events_stop", "Stop local event owner", "Requests a clean stop from the local owner.", stop, {
+		destructiveHint: true,
+		idempotentHint: true
+	});
+	runtimeTool("events_pause", "Pause local event work", "Pauses polling, evaluation and delivery claims without purging state.", pause, {
+		destructiveHint: false,
+		idempotentHint: true
+	});
+	runtimeTool("events_resume", "Resume local event work", "Resumes work retained by an operational pause.", resume, {
+		destructiveHint: false,
+		idempotentHint: true
+	});
+	runtimeTool("events_disable_all", "Disable all local event work", "Disables collection, advances the global generation and purges B1 work.", disableAll, {
+		destructiveHint: true,
+		idempotentHint: true
+	});
+	runtimeTool("events_enable_all", "Prepare global enablement", "Reports that a standing disclosure approval is required before enablement.", enableAll, {
+		destructiveHint: false,
+		idempotentHint: true
+	});
+	runtimeTool("events_doctor", "Local event service doctor", "Reports content-free lineage, retry, recovery, judge authority, hold-clock and protocol health.", doctor, {
+		destructiveHint: false,
+		idempotentHint: true
+	});
+	const controlTool = (name, title, description, inputSchema, operation, destructiveHint = false) => {
+		server.registerTool(name, {
+			title,
+			description,
+			inputSchema,
+			annotations: {
+				readOnlyHint: !destructiveHint,
+				destructiveHint,
+				idempotentHint: !destructiveHint,
+				openWorldHint: false
+			}
+		}, async (args) => reply(await operation(args)));
+	};
+	/** B3 selectors are closed: an omitted field is not permission to smuggle an approval-flow selector or a document. */
+	const strictControlTool = (name, title, description, inputSchema, operation, destructiveHint = false) => {
+		server.registerTool(name, {
+			title,
+			description,
+			inputSchema: strictObject(inputSchema),
+			annotations: {
+				readOnlyHint: !destructiveHint,
+				destructiveHint,
+				idempotentHint: !destructiveHint,
+				openWorldHint: false
+			}
+		}, async (args) => reply(await operation(args)));
+	};
+	strictControlTool("events_catalogue_list", "List local event catalogue", "Lists selectable local event definitions.", {}, () => catalogueList(options));
+	strictControlTool("events_approval_view", "View pending disclosure approval", "Returns the daemon-authoritative preview and fresh challenge without claiming it.", {
+		approvalId: string().min(1),
+		digest: string().min(1)
+	}, (args) => approvalView(args.approvalId, args.digest, options));
+	strictControlTool("events_rule_test", "Test a rule with a catalogue example", "Locally evaluates one selectable catalogue example without provider or judge I/O.", {
+		document: unknown(),
+		catalogue: strictObject({
+			type: string().min(1),
+			version: number().int().positive(),
+			exampleIndex: number().int().min(0)
+		})
+	}, (args) => ruleTest(args.document, args.catalogue, options));
+	server.registerTool("events_target_test", {
+		title: "Test one active target",
+		description: "Sends the fixed synthetic event only to one exact active target version.",
+		inputSchema: strictObject({
+			targetId: string().min(1),
+			targetVersion: number().int().positive()
+		}),
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: false,
+			openWorldHint: true
+		}
+	}, async (args) => reply(await targetTest(args.targetId, args.targetVersion, options)));
+	strictControlTool("events_subscribers_list", "List subscribers", "Lists immutable subscriber metadata.", {}, () => subscribersList(options));
+	strictControlTool("events_subscriber_add", "Add subscriber", "Creates one immutable subscriber version.", { document: unknown() }, (args) => addSubscriber(args.document, options), true);
+	strictControlTool("events_subscriber_update", "Update subscriber", "Creates one replacement immutable subscriber version.", { document: unknown() }, (args) => updateSubscriber(args.document, options), true);
+	strictControlTool("events_subscriber_remove", "Remove subscriber", "Revokes every live version of one subscriber and closes its streams.", { subscriberId: string().min(1) }, (args) => removeSubscriber(args.subscriberId, options), true);
+	strictControlTool("events_judges_list", "List judges", "Lists content-free immutable judge metadata.", {}, () => judgesList(options));
+	strictControlTool("events_judge_add", "Add judge", "Creates an immutable, initially inactive judge version.", { document: unknown() }, (args) => b3("addJudge", { document: args.document }, () => addJudge(args.document, options)), true);
+	strictControlTool("events_judge_update", "Update judge", "Creates an immutable replacement judge version.", { document: unknown() }, (args) => b3("updateJudge", { document: args.document }, () => updateJudge(args.document, options)), true);
+	strictControlTool("events_judge_remove", "Remove judge", "Removes every live immutable version of one judge.", { judgeId: string().min(1) }, (args) => b3("removeJudge", { judgeId: args.judgeId }, () => removeJudge(args.judgeId, options)), true);
+	strictControlTool("events_judge_test", "Test judge", "Tests one active exact judge version with the daemon-fixed synthetic event.", {
+		judgeId: string().min(1),
+		version: number().int().positive()
+	}, (args) => judgeTest(args.judgeId, args.version, options));
+	strictControlTool("events_budget_show", "Show budget", "Lists immutable judge budgets and the active singleton.", {}, () => budgetShow(options));
+	strictControlTool("events_budget_update", "Update budget", "Creates a pending immutable global budget and prepares its approval.", { document: unknown() }, (args) => b3("updateBudget", { document: args.document }, () => updateBudget(args.document, options)), true);
+	strictControlTool("events_judge_kinds_list", "List judge kinds", "Lists disabled/enabled judge kinds and the typed Laya E2 seam.", {}, () => judgeKindsList(options));
+	strictControlTool("events_judge_kind_enable", "Enable judge kind", "Prepares, but never approves or claims, judge-kind enablement.", { kind: string().min(1) }, (args) => b3("enableJudgeKind", { kind: args.kind }, () => enableJudgeKind(args.kind, options)), true);
+	strictControlTool("events_judge_kind_disable", "Disable judge kind", "Immediately disables one available judge kind; Laya remains typed E2-unavailable.", { kind: string().min(1) }, (args) => {
+		const kind = args.kind;
+		return b3("disableJudgeKind", { kind }, () => disableJudgeKind(kind, options));
+	}, true);
+	strictControlTool("events_judge_model_status", "Judge model status", "Returns the typed Phase-E2 unavailable result.", {}, () => judgeModelStatus(options));
+	strictControlTool("events_judge_model_remove", "Remove judge model", "Returns the typed Phase-E2 unavailable result.", {}, () => removeJudgeModel(options), true);
+	strictControlTool("events_deliveries_list", "List deliveries", "Lists content-free delivery metadata.", {}, () => deliveriesList(options));
+	strictControlTool("events_delivery_retry", "Retry delivery", "Retries one exact retryable delivery.", { deliveryId: string().min(1) }, (args) => retryDelivery(args.deliveryId, options), true);
+	strictControlTool("events_delivery_drop", "Drop delivery", "Drops one exact dead-letter delivery and its retained payload.", { deliveryId: string().min(1) }, (args) => dropDelivery(args.deliveryId, options), true);
+	strictControlTool("events_held_list", "List held decisions", "Lists content-free held-decision metadata; only a terminal/app may resolve one.", {}, () => heldList(options));
+	controlTool("events_catalogue_show", "Show local event definition", "Shows one selectable local event definition.", { type: string() }, (args) => catalogueShow(args.type, options));
+	controlTool("events_sources_list", "List event sources", "Lists configured local event sources.", {}, () => sourcesList(options));
+	controlTool("events_source_show", "Show event source", "Shows one configured local event source.", { source: string() }, (args) => sourceShow(args.source, options));
+	controlTool("events_rules_list", "List event rules", "Lists immutable local event rule versions.", {}, () => rulesList(options));
+	controlTool("events_rule_show", "Show event rule", "Shows immutable versions of one event rule.", { ruleId: string() }, (args) => ruleShow(args.ruleId, options));
+	controlTool("events_rule_create", "Create inert event rule", "Creates an inert immutable event rule version.", { document: unknown() }, (args) => createRule(args.document, options), true);
+	controlTool("events_rule_update", "Update event rule", "Creates another inert immutable event rule version.", { document: unknown() }, (args) => updateRule(args.document, options), true);
+	controlTool("events_rule_enable", "Prepare event rule enablement", "Prepares the standing disclosure for a rule version.", {
+		ruleId: string(),
+		version: number().int().positive()
+	}, (args) => enableRule(args.ruleId, args.version, options), true);
+	controlTool("events_rule_disable", "Disable event rule", "Immediately disables the active event rule.", { ruleId: string() }, (args) => disableRule(args.ruleId, options), true);
+	controlTool("events_rule_remove", "Remove event rule", "Immediately removes the active event rule.", { ruleId: string() }, (args) => removeRule(args.ruleId, options), true);
+	controlTool("events_targets_list", "List event targets", "Lists immutable local event target versions.", {}, () => targetsList(options));
+	controlTool("events_target_add", "Add inert event target", "Creates an inert immutable dry-run target.", { document: unknown() }, (args) => addTarget(args.document, options), true);
+	controlTool("events_target_update", "Update event target", "Creates another inert immutable dry-run target version.", { document: unknown() }, (args) => updateTarget(args.document, options), true);
+	controlTool("events_target_remove", "Remove event target", "Revokes every live version of a dry-run target.", { targetId: string() }, (args) => removeTarget(args.targetId, options), true);
+	return {
+		server,
+		async connectStdio() {
+			const { StdioServerTransport } = await import("./stdio-CD7QQBAh.mjs");
+			await server.connect(new StdioServerTransport());
+		}
+	};
+}
+//#endregion
+//#region src/domain/judges.ts
+const TYPESAFE_SYSTEM_ONE_ENDPOINT = "https://api.typesafe.ai/v1/systemone";
+const JUDGE_BUDGET_ID = "judge-budget";
+/** Provider record: docs/superpowers/plans/2026-10-10-events-phase-e-provider-record.md, read 2026-10-10. */
+const APPROVED_TYPESAFE_MODELS = ["jev-1.13.0"];
+/** Phase E's closed registry. The lifecycle module owns the literal vocabulary; this registry owns its availability. */
+const JUDGE_KIND_DEFINITIONS = [
+	{
+		kind: JUDGE_KINDS[0],
+		availability: "available"
+	},
+	{
+		kind: JUDGE_KINDS[1],
+		availability: "unavailable",
+		unavailableCode: "E2_REQUIRED"
+	},
+	{
+		kind: JUDGE_KINDS[2],
+		availability: "available"
+	}
+];
+function fail$3(message, code = "VERSION_DOCUMENT_INVALID") {
+	throw new EventDomainError(code, message);
+}
+function record$1(value, name) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return fail$3(`${name} is an object`);
+	try {
+		return JSON.parse(canonicalJson(value));
+	} catch {
+		return fail$3(`${name} is canonical JSON`);
+	}
+}
+function exactKeys$1(value, keys, name) {
+	const found = Object.keys(value).sort();
+	const wanted = [...keys].sort();
+	if (found.length !== wanted.length || found.some((key, index) => key !== wanted[index])) fail$3(`${name} has exactly its canonical fields`);
+}
+function text$1(value, name) {
+	if (typeof value !== "string" || value.length === 0) return fail$3(`${name} is a non-empty string`);
+	return value;
+}
+function positiveInteger$2(value, name) {
+	if (!Number.isSafeInteger(value) || value < 1) return fail$3(`${name} is a positive safe integer`);
+	return value;
+}
+function protocol(value, name) {
+	if (value.protocol === "noul") {
+		exactKeys$1(value, ["protocol"], name);
+		return { protocol: "noul" };
+	}
+	if (value.protocol !== "json-score") return fail$3(`${name} has protocol noul or json-score`);
+	exactKeys$1(value, ["protocol", "scorePointer"], name);
+	const scorePointer = text$1(value.scorePointer, `${name} scorePointer`);
+	const parsed = parsePointer(scorePointer);
+	if (!parsed.ok || parsed.value.includes("*")) return fail$3(`${name} scorePointer is one concrete JSON Pointer`);
+	return {
+		protocol: "json-score",
+		scorePointer
+	};
+}
+function identity(value, name) {
+	return {
+		judgeId: text$1(value.judgeId, `${name} id`),
+		version: positiveInteger$2(value.version, `${name} version`)
+	};
+}
+function localAddress(value) {
+	if (!Array.isArray(value) || value.length !== 1) return fail$3("a local judge approvedAddressSet has one exact literal");
+	const entry = text$1(value[0], "a local judge approvedAddressSet entry");
+	try {
+		assertApprovedAddressSet([entry]);
+		return [parseIpLiteral(entry).address];
+	} catch {
+		return fail$3("a local judge approvedAddressSet has one valid literal");
+	}
+}
+/** The one canonical, immutable judge document form. E2's laya seam is recognised but intentionally unavailable. */
+function canonicalJudge(value) {
+	const judge = record$1(value, "a judge document");
+	const kind = judge.kind;
+	if (!JUDGE_KINDS.includes(kind)) return fail$3("a judge document has a known judge kind");
+	if (kind === "laya") return fail$3("laya is unavailable until E2", "E2_REQUIRED");
+	if (kind === "typesafe") {
+		exactKeys$1(judge, [
+			"judgeId",
+			"version",
+			"kind",
+			"provider",
+			"model",
+			"endpoint",
+			"promptTemplate",
+			"protocol"
+		], "a typesafe judge document");
+		if (judge.provider !== "typesafe") return fail$3("a typesafe judge names the TypeSafe Jev adapter");
+		if (!APPROVED_TYPESAFE_MODELS.includes(judge.model)) return fail$3("a typesafe judge names one concrete model listed in the provider record");
+		if (judge.endpoint !== "https://api.typesafe.ai/v1/systemone") return fail$3("a typesafe judge has its fixed System One endpoint");
+		if (protocol({ protocol: judge.protocol }, "a typesafe judge document").protocol !== "noul") return fail$3("a typesafe judge uses the noul protocol");
+		return {
+			...identity(judge, "a typesafe judge"),
+			kind: JUDGE_KIND_TYPESAFE,
+			provider: JUDGE_KIND_TYPESAFE,
+			model: judge.model,
+			endpoint: TYPESAFE_SYSTEM_ONE_ENDPOINT,
+			promptTemplate: text$1(judge.promptTemplate, "a typesafe judge prompt template"),
+			protocol: "noul"
+		};
+	}
+	const localProtocol = protocol(judge.protocol === "json-score" ? {
+		protocol: judge.protocol,
+		scorePointer: judge.scorePointer
+	} : { protocol: judge.protocol }, "a local judge document");
+	exactKeys$1(judge, localProtocol.protocol === "json-score" ? [
+		"judgeId",
+		"version",
+		"kind",
+		"provider",
+		"model",
+		"endpoint",
+		"approvedAddressSet",
+		"promptTemplate",
+		"protocol",
+		"scorePointer"
+	] : [
+		"judgeId",
+		"version",
+		"kind",
+		"provider",
+		"model",
+		"endpoint",
+		"approvedAddressSet",
+		"promptTemplate",
+		"protocol"
+	], "a local judge document");
+	const approvedAddressSet = localAddress(judge.approvedAddressSet);
+	const endpoint = text$1(judge.endpoint, "a local judge endpoint");
+	try {
+		const local = validateLocalEndpoint(endpoint, approvedAddressSet);
+		if (local.url.search !== "") return fail$3("a local judge endpoint has no query");
+		return {
+			...identity(judge, "a local judge"),
+			kind: JUDGE_KIND_LOCAL_ENDPOINT,
+			provider: text$1(judge.provider, "a local judge provider"),
+			model: text$1(judge.model, "a local judge model"),
+			endpoint: local.url.href,
+			approvedAddressSet,
+			promptTemplate: text$1(judge.promptTemplate, "a local judge prompt template"),
+			...localProtocol
+		};
+	} catch (error) {
+		if (error instanceof EventDomainError) throw error;
+		return fail$3("a local judge has a literal loopback endpoint and its exact approved address");
+	}
+}
+function limits(value, name) {
+	const limit = record$1(value, name);
+	exactKeys$1(limit, [
+		"callsPerRollingHour",
+		"inputTokensPerRolling30Days",
+		"concurrency"
+	], name);
+	return {
+		callsPerRollingHour: positiveInteger$2(limit.callsPerRollingHour, `${name} callsPerRollingHour`),
+		inputTokensPerRolling30Days: positiveInteger$2(limit.inputTokensPerRolling30Days, `${name} inputTokensPerRolling30Days`),
+		concurrency: positiveInteger$2(limit.concurrency, `${name} concurrency`)
+	};
+}
+/** The singleton's complete global and per-provider rolling ceilings, with no implicit defaults. */
+function canonicalJudgeBudget(value) {
+	const budget = record$1(value, "a judge budget document");
+	exactKeys$1(budget, [
+		"budgetId",
+		"version",
+		"global",
+		"providers"
+	], "a judge budget document");
+	if (budget.budgetId !== "judge-budget") return fail$3(`a judge budget id is ${JUDGE_BUDGET_ID}`);
+	if (!Array.isArray(budget.providers)) return fail$3("judge budget providers are an array");
+	const providers = budget.providers.map((entry) => {
+		const provider = record$1(entry, "a judge provider budget");
+		exactKeys$1(provider, [
+			"provider",
+			"callsPerRollingHour",
+			"inputTokensPerRolling30Days",
+			"concurrency"
+		], "a judge provider budget");
+		return {
+			provider: text$1(provider.provider, "a judge provider id"),
+			callsPerRollingHour: positiveInteger$2(provider.callsPerRollingHour, "a judge provider budget callsPerRollingHour"),
+			inputTokensPerRolling30Days: positiveInteger$2(provider.inputTokensPerRolling30Days, "a judge provider budget inputTokensPerRolling30Days"),
+			concurrency: positiveInteger$2(provider.concurrency, "a judge provider budget concurrency")
+		};
+	});
+	if ([...providers].sort((left, right) => left.provider < right.provider ? -1 : left.provider > right.provider ? 1 : 0).some((entry, index) => entry.provider !== providers[index]?.provider) || new Set(providers.map((entry) => entry.provider)).size !== providers.length) return fail$3("judge budget providers are sorted and duplicate-free");
+	return {
+		budgetId: JUDGE_BUDGET_ID,
+		version: positiveInteger$2(budget.version, "a judge budget version"),
+		global: limits(budget.global, "a global judge budget"),
+		providers
+	};
+}
+/** The closed kind registry lookup, including E2's intentionally unavailable laya slot. */
+function judgeKindDefinition(kind) {
+	const definition = JUDGE_KIND_DEFINITIONS.find((candidate) => candidate.kind === kind);
+	if (definition === void 0) return fail$3("a judge kind has a registry definition");
+	return definition;
+}
+/** Canonicalises one inert kind-enablement version; no pointer or availability change happens here. */
+function canonicalJudgeKindEnablement(value) {
+	const enablement = record$1(value, "a judge-kind document");
+	if (!JUDGE_KINDS.includes(enablement.kind)) return fail$3("a judge-kind document has a known judge kind");
+	const kind = enablement.kind;
+	if (judgeKindDefinition(kind).availability === "unavailable") return fail$3("laya is unavailable until E2", "E2_REQUIRED");
+	const id = `judge-kind:${kind}`;
+	if (enablement.id !== id) return fail$3(`a judge-kind document id is ${id}`);
+	if (kind === "typesafe") {
+		exactKeys$1(enablement, [
+			"id",
+			"kind",
+			"version",
+			"endpoint"
+		], "a typesafe judge-kind document");
+		if (enablement.endpoint !== "https://api.typesafe.ai/v1/systemone") return fail$3("a typesafe judge-kind document has the fixed System One endpoint");
+		return {
+			id: "judge-kind:typesafe",
+			kind: JUDGE_KIND_TYPESAFE,
+			version: positiveInteger$2(enablement.version, "a judge-kind version"),
+			endpoint: TYPESAFE_SYSTEM_ONE_ENDPOINT
+		};
+	}
+	exactKeys$1(enablement, [
+		"id",
+		"kind",
+		"version"
+	], "a local-endpoint judge-kind document");
+	return {
+		id: "judge-kind:local-endpoint",
+		kind: JUDGE_KIND_LOCAL_ENDPOINT,
+		version: positiveInteger$2(enablement.version, "a judge-kind version")
+	};
+}
+//#endregion
+//#region src/domain/source-options.ts
+function fail$2(message) {
+	throw new EventDomainError("VERSION_DOCUMENT_INVALID", message);
+}
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function exactKeys(value, keys, name) {
+	if (Object.keys(value).find((key) => !keys.includes(key)) !== void 0) fail$2(`${name} has a field it does not define`);
+	for (const key of keys) if (!Object.hasOwn(value, key)) fail$2(`${name} has a ${key} field`);
+}
+function compareUtf8(left, right) {
+	const leftBytes = new TextEncoder().encode(left);
+	const rightBytes = new TextEncoder().encode(right);
+	const length = Math.min(leftBytes.byteLength, rightBytes.byteLength);
+	for (let index = 0; index < length; index += 1) {
+		const difference = (leftBytes[index] ?? 0) - (rightBytes[index] ?? 0);
+		if (difference !== 0) return difference;
+	}
+	return leftBytes.byteLength - rightBytes.byteLength;
+}
+function canonicalIds(value, name) {
+	if (!Array.isArray(value) || value.length === 0 || !value.every((entry) => typeof entry === "string" && entry !== "")) return fail$2(`${name} is a non-empty id array`);
+	const ids = [...value];
+	for (let index = 1; index < ids.length; index += 1) if (compareUtf8(ids[index - 1], ids[index]) >= 0) return fail$2(`${name} is duplicate-free and sorted by raw UTF-8 bytes`);
+	return ids;
+}
+function canonicalLabels(value) {
+	if (value === "inbox" || value === "any") return value;
+	const labels = canonicalIds(value, "Gmail label ids");
+	if (labels.includes("INBOX")) return fail$2("the Gmail INBOX selector is written as labels: inbox");
+	return labels;
+}
+/** Validates the Gmail source shape without silently reordering an authority-bound label array. */
+function normaliseGmailSourceOptions(value) {
+	if (!isRecord$2(value) || value.channel !== "gmail") return fail$2("a Gmail source option names the Gmail channel");
+	exactKeys(value, [
+		"channel",
+		"labels",
+		"includeSpamTrash"
+	], "a Gmail source option");
+	if (typeof value.includeSpamTrash !== "boolean") return fail$2("Gmail includeSpamTrash is a boolean");
+	return {
+		channel: "gmail",
+		labels: canonicalLabels(value.labels),
+		includeSpamTrash: value.includeSpamTrash
+	};
+}
+/** Validates the Phase-D Slack source shape, retaining only canonical conversation ids. */
+function normaliseSlackSourceOptions(value) {
+	if (!isRecord$2(value) || value.channel !== "slack") return fail$2("a Slack source option names the Slack channel");
+	exactKeys(value, ["channel", "conversations"], "a Slack source option");
+	return {
+		channel: "slack",
+		conversations: canonicalIds(value.conversations, "Slack conversations")
+	};
+}
+/** Validates Resend's fixed-order, non-empty event-kind set. */
+function normaliseResendSourceOptions(value) {
+	if (!isRecord$2(value) || value.channel !== "resend") return fail$2("a Resend source option names the Resend channel");
+	exactKeys(value, ["channel", "kinds"], "a Resend source option");
+	if (!Array.isArray(value.kinds) || value.kinds.length === 0) return fail$2("Resend kinds are a non-empty array");
+	const kinds = [...value.kinds];
+	if (!kinds.every((kind) => kind === "received" || kind === "status")) return fail$2("Resend kinds are received and status");
+	const expected = [...new Set(kinds)].sort((left, right) => left === "received" ? -1 : right === "received" ? 1 : 0);
+	if (expected.length !== kinds.length || expected.some((kind, index) => kind !== kinds[index])) return fail$2("Resend kinds are duplicate-free and ordered received, status");
+	return {
+		channel: "resend",
+		kinds
+	};
+}
+/** Validates the raw WhatsApp chat selector; JIDs stay raw authority-bound strings. */
+function normaliseWhatsAppSourceOptions(value) {
+	if (!isRecord$2(value) || value.channel !== "whatsapp") return fail$2("a WhatsApp source option names the WhatsApp channel");
+	exactKeys(value, ["channel", "chats"], "a WhatsApp source option");
+	return {
+		channel: "whatsapp",
+		chats: value.chats === "all-allowed" ? "all-allowed" : canonicalIds(value.chats, "WhatsApp chats")
+	};
+}
+/** D4's closed four-channel source-options union. */
+function normaliseSourceOptions(value) {
+	if (!isRecord$2(value)) return fail$2("a source option is an object");
+	switch (value.channel) {
+		case "gmail": return normaliseGmailSourceOptions(value);
+		case "slack": return normaliseSlackSourceOptions(value);
+		case "resend": return normaliseResendSourceOptions(value);
+		case "whatsapp": return normaliseWhatsAppSourceOptions(value);
+		default: return fail$2("a source option has a known channel");
+	}
+}
+function labelSet(options) {
+	if (options.labels === "any") return null;
+	return new Set(options.labels === "inbox" ? ["INBOX"] : options.labels);
+}
+function classifySubset(before, after) {
+	const previous = new Set(before);
+	const next = new Set(after);
+	if (previous.size === next.size && [...previous].every((value) => next.has(value))) return "same";
+	return [...next].every((value) => previous.has(value)) ? "tightening" : "loosening";
+}
+/** D2's field-by-field Gmail narrowing rule. Any additive change keeps the whole edit a loosening. */
+function classifyGmailSourceOptionChange(before, after) {
+	const previous = normaliseGmailSourceOptions(before);
+	const next = normaliseGmailSourceOptions(after);
+	if (previous.labels === next.labels && previous.includeSpamTrash === next.includeSpamTrash) return "same";
+	if (previous.labels === "any") {
+		if (next.labels === "any") return previous.includeSpamTrash === next.includeSpamTrash ? "same" : next.includeSpamTrash ? "loosening" : "tightening";
+		return !previous.includeSpamTrash && next.includeSpamTrash ? "loosening" : "tightening";
+	}
+	if (next.labels === "any") return "loosening";
+	const previousLabels = labelSet(previous);
+	const nextLabels = labelSet(next);
+	const added = [...nextLabels].some((label) => !previousLabels.has(label));
+	const removed = [...previousLabels].some((label) => !nextLabels.has(label));
+	const spamLoosened = !previous.includeSpamTrash && next.includeSpamTrash;
+	const spamTightened = previous.includeSpamTrash && !next.includeSpamTrash;
+	if (added || spamLoosened) return "loosening";
+	if (removed || spamTightened) return "tightening";
+	return "same";
+}
+/** D2/D4's one source-option classifier; different source variants can never become a derived edge. */
+function classifySourceOptionChange(before, after) {
+	const previous = normaliseSourceOptions(before);
+	const next = normaliseSourceOptions(after);
+	if (previous.channel !== next.channel) return fail$2("source options for a derived edit name the same channel");
+	switch (previous.channel) {
+		case "gmail": return classifyGmailSourceOptionChange(previous, next);
+		case "slack":
+			if (next.channel !== "slack") return fail$2("source options for a derived edit name the same channel");
+			return classifySubset(previous.conversations, next.conversations);
+		case "resend":
+			if (next.channel !== "resend") return fail$2("source options for a derived edit name the same channel");
+			return classifySubset(previous.kinds, next.kinds);
+		case "whatsapp":
+			if (next.channel !== "whatsapp") return fail$2("source options for a derived edit name the same channel");
+			if (previous.chats === "all-allowed") return next.chats === "all-allowed" ? "same" : "tightening";
+			if (next.chats === "all-allowed") return "loosening";
+			return classifySubset(previous.chats, next.chats);
+	}
+}
+//#endregion
+//#region src/domain/sse-subscriber.ts
+function fail$1(message) {
+	throw new EventDomainError("VERSION_DOCUMENT_INVALID", message);
+}
+function record(value, name) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return fail$1(`${name} is an object`);
+	try {
+		return JSON.parse(canonicalJson(value));
+	} catch {
+		return fail$1(`${name} is canonical JSON`);
+	}
+}
+function text(value, name) {
+	if (typeof value !== "string" || value.length === 0) return fail$1(`${name} is a non-empty string`);
+	return value;
+}
+function positiveInteger$1(value, name) {
+	if (!Number.isSafeInteger(value) || value < 1) return fail$1(`${name} is a positive safe integer`);
+	return value;
+}
+function canonicalOrigin(value) {
+	const origin = text(value, "an SSE allowed Origin");
+	let parsed;
+	try {
+		parsed = new URL(origin);
+	} catch {
+		return fail$1("an SSE allowed Origin is a URL origin");
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.origin !== origin) return fail$1("an SSE allowed Origin is an exact http or https origin");
+	return origin;
+}
+/** Canonicalises listener authority, exact browser origins and replay retention; bearer bytes are absent. */
+function canonicalSseSubscriber(value) {
+	const subscriber = record(value, "an SSE subscriber document");
+	if (subscriber.kind !== "sse") return fail$1("an SSE subscriber document has kind sse");
+	const authority = record(subscriber.authority, "an SSE subscriber authority");
+	const host = text(authority.host, "an SSE subscriber authority host");
+	if (host !== "127.0.0.1" && host !== "::1") return fail$1("an SSE subscriber authority host is literal loopback");
+	const origins = Array.isArray(subscriber.origins) ? subscriber.origins.map(canonicalOrigin) : fail$1("SSE allowed Origins are an array");
+	if (origins.length === 0 || new Set(origins).size !== origins.length || [...origins].sort().some((origin, index) => origin !== origins[index])) return fail$1("SSE allowed Origins are non-empty, sorted and duplicate-free");
+	const retentionMs = positiveInteger$1(subscriber.retentionMs, "SSE replay retention");
+	if (retentionMs > 6048e5) return fail$1("SSE replay retention is at most seven days");
+	const port = positiveInteger$1(authority.port, "an SSE subscriber authority port");
+	if (port > 65535) return fail$1("an SSE subscriber authority port is at most 65535");
+	return {
+		subscriberId: text(subscriber.subscriberId, "an SSE subscriber id"),
+		version: positiveInteger$1(subscriber.version, "an SSE subscriber version"),
+		kind: "sse",
+		authority: {
+			host,
+			port
+		},
+		origins,
+		retentionMs
+	};
+}
+/** Canonicalises a target's immutable binding to an SSE subscriber version. */
+function canonicalSseTarget(value) {
+	const target = record(value, "an SSE target document");
+	if (target.kind !== "sse") return fail$1("an SSE target document has kind sse");
+	if (target.representation !== "plain" && target.representation !== "enveloped") return fail$1("an SSE target representation is plain or enveloped");
+	return {
+		targetId: text(target.targetId, "an SSE target id"),
+		version: positiveInteger$1(target.version, "an SSE target version"),
+		kind: "sse",
+		subscriberId: text(target.subscriberId, "an SSE target subscriber id"),
+		subscriberVersion: positiveInteger$1(target.subscriberVersion, "an SSE target subscriber version"),
+		representation: target.representation
+	};
+}
+/** Maps an exact target/subscriber binding to Task 2's closed delivery union. */
+function sseDeliveryTarget(input) {
+	return {
+		kind: "sse",
+		targetId: input.targetId,
+		targetVersion: input.version,
+		subscriberId: input.subscriber.subscriberId,
+		subscriberVersion: input.subscriber.version,
+		representation: input.representation
+	};
+}
+//#endregion
+//#region src/domain/activation-documents.ts
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function fail(message, code = "VERSION_DOCUMENT_INVALID") {
+	throw new EventDomainError(code, message);
+}
+function requiredText(value, name) {
+	if (typeof value !== "string" || value.length === 0) return fail(`${name} is a non-empty string`);
+	return value;
+}
+function positiveInteger(value, name) {
+	if (!Number.isSafeInteger(value) || value < 1) return fail(`${name} is a positive safe integer`);
+	return value;
+}
+function cloneJsonRecord(value, name) {
+	if (!isRecord$1(value)) return fail(`${name} is a JSON object`);
+	try {
+		return JSON.parse(canonicalJson(value));
+	} catch {
+		return fail(`${name} is canonical JSON`);
+	}
+}
+function canonicalJsonValue(value, name) {
+	if (!isJsonValue(value)) return fail(`${name} is a JSON value`);
+	try {
+		return JSON.parse(canonicalJson(value));
+	} catch {
+		return fail(`${name} is canonical JSON`);
+	}
+}
+function compareText(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function canonicalStringSet(value, name) {
+	if (!Array.isArray(value) || value.length === 0) return fail(`${name} is a non-empty array`);
+	const values = value.map((entry) => requiredText(entry, name));
+	const sorted = [...new Set(values)].sort(compareText);
+	if (sorted.length !== values.length) return fail(`${name} has no duplicate values`);
+	return sorted;
+}
+/** The canonical immutable target document — stored, and embedded in every rule that names it. */
+function canonicalTarget(value) {
+	const target = cloneJsonRecord(value, "a target document");
+	switch (target.kind) {
+		case "dry-run": {
+			const retentionMs = positiveInteger(target.retentionMs, "a dry-run retention");
+			if (retentionMs > 864e5) return fail("a dry-run retention is at most 24 hours");
+			return {
+				targetId: requiredText(target.targetId, "a target id"),
+				version: positiveInteger(target.version, "a target version"),
+				kind: "dry-run",
+				retentionMs
+			};
+		}
+		case "webhook": return canonicalWebhookTarget(target);
+		case "sse": return canonicalSseTarget(target);
+		default: return fail("a target document has a known kind");
+	}
+}
+/** The one canonical form of a subscriber version — stored, and embedded in every rule that names it. */
+function canonicalSubscriber(value) {
+	const subscriber = cloneJsonRecord(value, "a subscriber document");
+	if (subscriber.kind !== "sse") return fail("a subscriber document has a known kind");
+	return canonicalSseSubscriber(subscriber);
+}
+function canonicalRetention(value) {
+	const retention = cloneJsonRecord(value, "rule retention");
+	const result = {
+		ingestMs: positiveInteger(retention.ingestMs, "ingest retention"),
+		holdMs: positiveInteger(retention.holdMs, "hold retention"),
+		deliveryMs: positiveInteger(retention.deliveryMs, "delivery retention"),
+		dryrunMs: positiveInteger(retention.dryrunMs, "dry-run retention"),
+		sseReplayMs: positiveInteger(retention.sseReplayMs, "SSE replay retention"),
+		deadLetterMs: positiveInteger(retention.deadLetterMs, "dead-letter retention"),
+		decisionMetadataMs: positiveInteger(retention.decisionMetadataMs, "decision metadata retention")
+	};
+	if (result.holdMs > result.ingestMs) return fail("hold retention cannot outlive ingest retention");
+	if (result.dryrunMs > 864e5) return fail("dry-run retention is at most 24 hours");
+	return result;
+}
+function canonicalRuleSource(value) {
+	const source = cloneJsonRecord(value, "rule source");
+	const options = normaliseSourceOptions(source.options);
+	if (source.channel !== options.channel) return fail("rule source channel and source options channel agree");
+	const accountIds = canonicalStringSet(source.accountIds, "rule account ids");
+	switch (options.channel) {
+		case "gmail": return {
+			channel: "gmail",
+			accountIds,
+			options
+		};
+		case "slack": return {
+			channel: "slack",
+			accountIds,
+			options
+		};
+		case "resend": return {
+			channel: "resend",
+			accountIds,
+			options
+		};
+		case "whatsapp": return {
+			channel: "whatsapp",
+			accountIds,
+			options
+		};
+	}
+}
+/** Validates a Phase-D full rule shape and returns its canonical data-only form. */
+function canonicalFullRuleDocument(value) {
+	const rule = cloneJsonRecord(value, "a rule document");
+	const source = canonicalRuleSource(rule.source);
+	const event = cloneJsonRecord(rule.event, "rule event");
+	const eventType = requiredText(event.type, "an event type");
+	if (eventType === TEST_CLOUD_EVENT.type || eventType === "io.agentcomms.control.installation-reset.v1") return fail("operational, test and reset controls are not selectable rule event types", "EVENT_TYPE_NOT_SELECTABLE");
+	const eventVersion = positiveInteger(event.version, "an event version");
+	const definition = catalogueEntry(eventType, eventVersion);
+	if (!definition.ok) return fail(definition.issues[0]?.message ?? "the event type is not selectable", definition.issues[0]?.code);
+	if (!eventType.startsWith(`${source.channel}.`)) return fail("a rule event type belongs to its source channel", "SOURCE_CHANNEL_UNSUPPORTED");
+	const condition = canonicaliseCondition(definition.value, rule.condition);
+	if (!condition.ok) return fail(condition.issues[0]?.message ?? "the rule condition is not valid");
+	let agentic;
+	if (rule.agentic !== void 0) {
+		const canonical = canonicaliseAgenticCondition(definition.value, condition.value, rule.agentic);
+		if (!canonical.ok) return fail(canonical.issues[0]?.message ?? "the rule agentic condition is not valid");
+		agentic = {
+			...canonical.value,
+			judge: canonicalJudge(canonical.value.judge)
+		};
+	}
+	const mapping = canonicalJsonValue(rule.mapping, "rule mapping");
+	const compiledMapping = compileMapping(definition.value, mapping);
+	if (!compiledMapping.ok) return fail(compiledMapping.issues[0]?.message ?? "the rule mapping is not valid");
+	const targets = Array.isArray(rule.targets) ? rule.targets.map(canonicalTarget) : fail("rule targets are an array");
+	if (targets.length === 0) return fail("a B1 rule has at least one dry-run target");
+	const subscribers = Array.isArray(rule.subscribers) ? rule.subscribers.map(canonicalSubscriber) : fail("rule subscribers are an array");
+	for (const target of targets) {
+		if (target.kind !== "sse") continue;
+		if (subscribers.find((subscriber) => subscriber.subscriberId === target.subscriberId && subscriber.version === target.subscriberVersion) === void 0) return fail("an SSE target embeds its exact subscriber version");
+	}
+	const judges = Array.isArray(rule.judges) ? rule.judges.map(canonicalJudge) : fail("rule judges are an array");
+	if (judges.length !== 0) return fail("rule judges are represented only by the optional agentic sibling");
+	let cloudEventType;
+	if (rule.cloudEventType !== void 0) {
+		const chosen = validateCloudEventType(rule.cloudEventType);
+		if (!chosen.ok) return fail(chosen.issues[0]?.message ?? "the rule cloudEventType is not valid");
+		cloudEventType = chosen.value;
+	}
+	return {
+		ruleId: requiredText(rule.ruleId, "a rule id"),
+		version: positiveInteger(rule.version, "a rule version"),
+		source,
+		event: {
+			type: eventType,
+			version: eventVersion
+		},
+		condition: condition.value,
+		...agentic === void 0 ? {} : { agentic },
+		mapping,
+		...cloudEventType === void 0 ? {} : { cloudEventType },
+		targets,
+		subscribers,
+		judges,
+		deliveryRateCap: positiveInteger(rule.deliveryRateCap, "rule delivery rate cap"),
+		retention: canonicalRetention(rule.retention)
+	};
+}
+function canonicalEnableAll(value) {
+	const document = cloneJsonRecord(value, "an enable-all document");
+	if (!Array.isArray(document.ruleVersions)) return fail("enable-all rule versions are an array");
+	const sorted = [...document.ruleVersions.map((entry) => {
+		const row = cloneJsonRecord(entry, "an enable-all rule version");
+		return {
+			ruleId: requiredText(row.ruleId, "an enable-all rule id"),
+			ruleVersion: positiveInteger(row.ruleVersion, "an enable-all rule version")
+		};
+	})].sort((left, right) => compareText(left.ruleId, right.ruleId) || left.ruleVersion - right.ruleVersion);
+	for (let index = 1; index < sorted.length; index += 1) {
+		const previous = sorted[index - 1];
+		const current = sorted[index];
+		if (previous.ruleId === current.ruleId && previous.ruleVersion === current.ruleVersion) return fail("enable-all rule versions are duplicate-free");
+	}
+	return {
+		documentVersion: 1,
+		kind: "enable-all",
+		switchGeneration: Number.isSafeInteger(document.switchGeneration) && document.switchGeneration >= 0 ? document.switchGeneration : fail("an enable-all switch generation is a non-negative safe integer"),
+		ruleVersions: sorted
+	};
+}
+/** Validates exactly one v1 activation document and normalises only D2's unordered enable-all list. */
+function normaliseActivationDocument(value) {
+	const document = cloneJsonRecord(value, "an activation document");
+	if (document.documentVersion !== 1) return fail("an activation document has documentVersion 1");
+	if (Object.hasOwn(document, "versions")) return fail("activation-document versions are derived, never supplied");
+	switch (document.kind) {
+		case "rule": return {
+			documentVersion: 1,
+			kind: "rule",
+			rule: canonicalFullRuleDocument(document.rule)
+		};
+		case "judge-budget": return {
+			documentVersion: 1,
+			kind: "judge-budget",
+			budget: canonicalJudgeBudget(document.budget)
+		};
+		case "judge-kind": return {
+			documentVersion: 1,
+			kind: "judge-kind",
+			enablement: canonicalJudgeKindEnablement(document.enablement)
+		};
+		case "enable-all": return canonicalEnableAll(document);
+		default: return fail("an activation document has a known kind");
+	}
+}
+/** Core's recursively key-sorted canonical JSON for a complete v1 activation document. */
+function canonicalActivationDocument(document) {
+	return canonicalJson(normaliseActivationDocument(document));
+}
+/** The lowercase SHA-256 disclosure digest of one canonical activation document. */
+function activationDocumentDigest(document) {
+	return sha256Hex(canonicalActivationDocument(document));
+}
+function compareVersions(left, right) {
+	return compareText(left.kind, right.kind) || compareText(left.id, right.id) || left.version - right.version;
+}
+function derivedVersions(document) {
+	switch (document.kind) {
+		case "rule": return [
+			{
+				kind: "rule",
+				id: document.rule.ruleId,
+				version: document.rule.version
+			},
+			...document.rule.targets.map((target) => ({
+				kind: "target",
+				id: target.targetId,
+				version: target.version
+			})),
+			...document.rule.subscribers.map((subscriber) => ({
+				kind: "subscriber",
+				id: subscriber.subscriberId,
+				version: subscriber.version
+			})),
+			...document.rule.agentic === void 0 ? [] : [{
+				kind: "judge",
+				id: document.rule.agentic.judge.judgeId,
+				version: document.rule.agentic.judge.version
+			}]
+		];
+		case "judge-budget": return [{
+			kind: "judge-budget",
+			id: document.budget.budgetId,
+			version: document.budget.version
+		}];
+		case "judge-kind": return [{
+			kind: "judge-kind",
+			id: document.enablement.kind,
+			version: document.enablement.version
+		}];
+		case "enable-all": return document.ruleVersions.map((rule) => ({
+			kind: "rule",
+			id: rule.ruleId,
+			version: rule.ruleVersion
+		}));
+	}
+}
+/** Derives, rather than accepts, the exact core standing-disclosure binding for an activation intent. */
+function disclosureBindingFor(activationIntentId, input) {
+	const document = normaliseActivationDocument(input);
+	const versions = derivedVersions(document).sort(compareVersions);
+	for (let index = 1; index < versions.length; index += 1) if (compareVersions(versions[index - 1], versions[index]) === 0) return fail("an activation document cannot derive duplicate disclosure versions");
+	return canonicalDisclosureBinding({
+		activationIntentId: requiredText(activationIntentId, "an activation intent id"),
+		activationKind: document.kind,
+		digest: sha256Hex(canonicalJson(document)),
+		versions
+	});
+}
+//#endregion
+//#region src/runtime/control-operation-registry.ts
+/**
+* The owner control protocol's complete wire vocabulary. Capability rows deliberately name operation *functions*,
+* while authenticated control frames name these wires. The owner dispatcher, contract schema and vectors consume this
+* one registry instead of recreating either vocabulary at a protocol boundary.
+*/
+const OWNER_CONTROL_WIRE_OPERATIONS = [
+	{
+		capabilityOperation: "status",
+		wireOperation: "status",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "stop",
+		wireOperation: "stop",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "pause",
+		wireOperation: "pause",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "resume",
+		wireOperation: "resume",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "disableAll",
+		wireOperation: "disable-all",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "enableAll",
+		wireOperation: "enable-all",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "doctor",
+		wireOperation: "doctor",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "catalogueList",
+		wireOperation: "catalogue-list",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "catalogueShow",
+		wireOperation: "catalogue-show",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "sourcesList",
+		wireOperation: "sources-list",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "sourceShow",
+		wireOperation: "source-show",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "rulesList",
+		wireOperation: "rules-list",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "ruleShow",
+		wireOperation: "rule-show",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "createRule",
+		wireOperation: "rule-create",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "updateRule",
+		wireOperation: "rule-update",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "enableRule",
+		wireOperation: "rule-enable",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "disableRule",
+		wireOperation: "rule-disable",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "removeRule",
+		wireOperation: "rule-remove",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "targetsList",
+		wireOperation: "targets-list",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "addTarget",
+		wireOperation: "target-add",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "updateTarget",
+		wireOperation: "target-update",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "removeTarget",
+		wireOperation: "target-remove",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "approve",
+		wireOperation: "approve",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "approvalView",
+		wireOperation: "approvalView",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "ruleTest",
+		wireOperation: "ruleTest",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "ruleTestRetained",
+		wireOperation: "ruleTestRetained",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "targetTest",
+		wireOperation: "targetTest",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "targetResume",
+		wireOperation: "targetResume",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "subscribersList",
+		wireOperation: "subscribersList",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "addSubscriber",
+		wireOperation: "addSubscriber",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "updateSubscriber",
+		wireOperation: "updateSubscriber",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "removeSubscriber",
+		wireOperation: "removeSubscriber",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "judgesList",
+		wireOperation: "judgesList",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "addJudge",
+		wireOperation: "addJudge",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "updateJudge",
+		wireOperation: "updateJudge",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "removeJudge",
+		wireOperation: "removeJudge",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "judgeTest",
+		wireOperation: "judgeTest",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "budgetShow",
+		wireOperation: "budgetShow",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "updateBudget",
+		wireOperation: "updateBudget",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "judgeKindsList",
+		wireOperation: "judgeKindsList",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "enableJudgeKind",
+		wireOperation: "enableJudgeKind",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "disableJudgeKind",
+		wireOperation: "disableJudgeKind",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "judgeModelStatus",
+		wireOperation: "judgeModelStatus",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "removeJudgeModel",
+		wireOperation: "removeJudgeModel",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "deliveriesList",
+		wireOperation: "deliveriesList",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "retryDelivery",
+		wireOperation: "retryDelivery",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "dropDelivery",
+		wireOperation: "dropDelivery",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "heldList",
+		wireOperation: "heldList",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "decideHeld",
+		wireOperation: "decideHeld",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "targetSecretCreate",
+		wireOperation: "targetSecretCreate",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "targetSecretRotate",
+		wireOperation: "targetSecretRotate",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "targetUrlSet",
+		wireOperation: "targetUrlSet",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "subscriberTokenCreate",
+		wireOperation: "subscriberTokenCreate",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "subscriberTokenRotate",
+		wireOperation: "subscriberTokenRotate",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "judgeKeySet",
+		wireOperation: "judgeKeySet",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "judgeKeyRotate",
+		wireOperation: "judgeKeyRotate",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "migrateSecrets",
+		wireOperation: "migrateSecrets",
+		desktopCallable: true,
+		family: "b3"
+	},
+	{
+		capabilityOperation: "dryrunList",
+		wireOperation: "dryrun-list",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "dryrunShow",
+		wireOperation: "dryrun-show",
+		desktopCallable: true,
+		family: "owner"
+	},
+	{
+		capabilityOperation: "approveChallenge",
+		wireOperation: "approve-challenge",
+		desktopCallable: false,
+		family: "owner"
+	}
+];
+/** The owner switch reads its case labels from the registry above; it introduces no second wire vocabulary. */
+const OWNER_CONTROL_WIRES = Object.freeze(Object.fromEntries(OWNER_CONTROL_WIRE_OPERATIONS.flatMap(({ capabilityOperation, wireOperation }) => capabilityOperation === void 0 ? [] : [[capabilityOperation, wireOperation]])));
+const OWNER_CONTROL_WIRE_OPERATION_SET = new Set(OWNER_CONTROL_WIRE_OPERATIONS.map(({ wireOperation }) => wireOperation));
+const B3_CONTROL_WIRE_OPERATION_SET = new Set(OWNER_CONTROL_WIRE_OPERATIONS.filter((entry) => entry.family === "b3").map(({ wireOperation }) => wireOperation));
+function isOwnerControlWireOperation(value) {
+	return OWNER_CONTROL_WIRE_OPERATION_SET.has(value);
+}
+function isB3ControlWireOperation(value) {
+	return B3_CONTROL_WIRE_OPERATION_SET.has(value);
+}
+//#endregion
+//#region src/operations/b3-contract.ts
+/**
+* The data-only promise B3 makes before any public B3 registration exists. Task 5 consumes these rows when it wires
+* Commander and MCP; Task 9 adds the language-neutral schema and vectors without changing their vocabulary.
+*/
+const B3_EXCEPTION_REASON_SECRET = "secret material must never enter model input or output; the person completes this operation at the terminal or app.";
+/** C may replace this only after the daemon verifies its future non-forgeable secret-window capability. */
+const B3_SECRET_TERMINAL_ORIGIN = "interactive-terminal";
+Object.freeze(["both", "exception"]);
+/**
+* The complete set of daemon capabilities a desktop control client can invoke. `run` and the MCP-server entry
+* point are deliberately absent: they start processes rather than call a running owner's control protocol. The
+* contract drift test derives this set from capabilities.json, which is the repository-wide authority.
+*/
+const B3_DESKTOP_CONTROL_OPERATIONS = Object.freeze(OWNER_CONTROL_WIRE_OPERATIONS.filter((entry) => entry.desktopCallable).map(({ wireOperation }) => wireOperation));
+const both = (id, cli, mcp, operation) => ({
+	id,
+	cli,
+	mcp,
+	operation,
+	status: "both"
+});
+const exception = (id, cli, operation, reason, secret) => ({
+	id,
+	cli,
+	mcp: null,
+	operation,
+	status: "exception",
+	reason,
+	...secret ? { secret } : {}
+});
+const B3_CAPABILITIES = Object.freeze([
+	both("events-daemon.approval.view", "approval view <approval-id> --digest <digest>", "events_approval_view", "approvalView"),
+	both("events-daemon.rule.test", "rule test <document> <catalogue-example>", "events_rule_test", "ruleTest"),
+	exception("events-daemon.rule.test-retained", "rule test-retained <event-id> --rule <rule-id> --version <n>", "ruleTestRetained", "Retained sender content may be selected only by a person outside model context."),
+	both("events-daemon.target.test", "target test <target-id> --version <n>", "events_target_test", "targetTest"),
+	exception("events-daemon.target.resume", "target resume <target-id> --version <n>", "targetResume", "A person, not model context, decides to reopen a degraded target reset barrier."),
+	both("events-daemon.subscribers.list", "subscribers list", "events_subscribers_list", "subscribersList"),
+	both("events-daemon.subscriber.add", "subscriber add <document>", "events_subscriber_add", "addSubscriber"),
+	both("events-daemon.subscriber.update", "subscriber update <document>", "events_subscriber_update", "updateSubscriber"),
+	both("events-daemon.subscriber.remove", "subscriber remove <subscriber-id>", "events_subscriber_remove", "removeSubscriber"),
+	both("events-daemon.judges.list", "judges list", "events_judges_list", "judgesList"),
+	both("events-daemon.judge.add", "judge add <document>", "events_judge_add", "addJudge"),
+	both("events-daemon.judge.update", "judge update <document>", "events_judge_update", "updateJudge"),
+	both("events-daemon.judge.remove", "judge remove <judge-id>", "events_judge_remove", "removeJudge"),
+	both("events-daemon.judge.test", "judge test <judge-id> --version <n>", "events_judge_test", "judgeTest"),
+	both("events-daemon.budget.show", "budget show", "events_budget_show", "budgetShow"),
+	both("events-daemon.budget.update", "budget update <document>", "events_budget_update", "updateBudget"),
+	both("events-daemon.judge-kinds.list", "judge kinds list", "events_judge_kinds_list", "judgeKindsList"),
+	both("events-daemon.judge-kind.enable", "judge kind enable <kind>", "events_judge_kind_enable", "enableJudgeKind"),
+	both("events-daemon.judge-kind.disable", "judge kind disable <kind>", "events_judge_kind_disable", "disableJudgeKind"),
+	both("events-daemon.judge-model.status", "judge model status", "events_judge_model_status", "judgeModelStatus"),
+	both("events-daemon.judge-model.remove", "judge model remove", "events_judge_model_remove", "removeJudgeModel"),
+	both("events-daemon.deliveries.list", "deliveries list", "events_deliveries_list", "deliveriesList"),
+	both("events-daemon.delivery.retry", "delivery retry <delivery-id>", "events_delivery_retry", "retryDelivery"),
+	both("events-daemon.delivery.drop", "delivery drop <delivery-id>", "events_delivery_drop", "dropDelivery"),
+	both("events-daemon.held.list", "held list", "events_held_list", "heldList"),
+	exception("events-daemon.held.decide", "held decide <decision-id> <accept|reject>", "decideHeld", "A held model decision can be resolved only by a person at terminal/app, never by model context."),
+	exception("events-daemon.target-secret.create", "target secret create <target-id> --version <n>", "targetSecretCreate", B3_EXCEPTION_REASON_SECRET, true),
+	exception("events-daemon.target-secret.rotate", "target secret rotate <target-id> --version <n>", "targetSecretRotate", B3_EXCEPTION_REASON_SECRET, true),
+	exception("events-daemon.target-url.set", "target url set <target-id> (--predecessor-version <n> | --draft <inert-target-document>) --new-version <n>", "targetUrlSet", B3_EXCEPTION_REASON_SECRET, true),
+	exception("events-daemon.subscriber-token.create", "subscriber token create <subscriber-id> --version <n>", "subscriberTokenCreate", B3_EXCEPTION_REASON_SECRET, true),
+	exception("events-daemon.subscriber-token.rotate", "subscriber token rotate <subscriber-id> --version <n>", "subscriberTokenRotate", B3_EXCEPTION_REASON_SECRET, true),
+	exception("events-daemon.judge-key.set", "judge key set <judge-id> --version <n>", "judgeKeySet", B3_EXCEPTION_REASON_SECRET, true),
+	exception("events-daemon.judge-key.rotate", "judge key rotate <judge-id> --version <n>", "judgeKeyRotate", B3_EXCEPTION_REASON_SECRET, true),
+	exception("events-daemon.secrets.migrate", "secrets migrate --to keychain|file", "migrateSecrets", B3_EXCEPTION_REASON_SECRET, true)
+]);
+const B3_SECRET_OPERATIONS = new Set(B3_CAPABILITIES.filter((capability) => capability.secret === true).map(({ operation }) => operation));
+/** The owner accepts only the B3 operation vocabulary that its future CLI/MCP registrars may expose. */
+function isB3ControlOperation(value) {
+	return isB3ControlWireOperation(value);
+}
+function isB3SecretOperation(value) {
+	return B3_SECRET_OPERATIONS.has(value);
+}
+const B3_APPROVAL_VIEW_VARIANTS = Object.freeze([
+	"READY",
+	"STALE_APPROVAL",
+	"DIGEST_MISMATCH",
+	"CHALLENGE_EXPIRED"
+]);
+Object.freeze(["accept", "reject"]);
+Object.freeze(["file", "keychain"]);
+Object.freeze(["terminal-approval", "app-approval-screen"]);
+const B3_JUDGE_UNAVAILABLE_VARIANTS = Object.freeze([{
+	code: "E_REQUIRED",
+	phase: "E"
+}, {
+	code: "E2_REQUIRED",
+	phase: "E2"
+}]);
+Object.freeze(["unavailable"]);
+Object.freeze([{
+	kind: "held-list",
+	decisions: []
+}]);
+Object.freeze([{
+	kind: "unavailable",
+	code: "HOLDS_UNAVAILABLE",
+	phase: "E"
+}]);
+Object.freeze([{
+	kind: "unavailable",
+	code: "APP_SECRET_CAPABILITY_UNAVAILABLE"
+}]);
+Object.freeze(["running", "not-running"]);
+Object.freeze([
+	"pending",
+	"pending-completion",
+	"completed",
+	"failed",
+	"cancelled"
+]);
+Object.freeze([
+	"rule",
+	"judge-budget",
+	"judge-kind",
+	"enable-all"
+]);
+Object.freeze([
+	"rule",
+	"judge-budget",
+	"judge-kind",
+	"enable-all"
+]);
+Object.freeze([
+	"rule",
+	"target",
+	"subscriber",
+	"judge",
+	"judge-budget",
+	"judge-kind"
+]);
+Object.freeze(["delivery-retried", "delivery-dropped"]);
+Object.freeze(["not-evaluated"]);
+Object.freeze([
+	"matched",
+	"condition-false",
+	"mapping-rejected"
+]);
+Object.freeze(["plain", "enveloped"]);
+/** Runtime coverage source: a desktop wire has exactly one result branch and vector. */
+const B3_CONTROL_V1_RESULT_OPERATIONS = B3_DESKTOP_CONTROL_OPERATIONS;
+/** The stable data-only error vocabulary; messages and provider detail deliberately do not cross this contract. */
+const B3_CONTROL_ERROR_CODES = Object.freeze([
+	"USAGE",
+	"BAD_DATA",
+	"APPROVAL_VOID",
+	"NOT_FOUND",
+	"CONFIG"
+]);
+const B3_CONTROL_V1_SCHEMA_VERSION = "b3-control-v1";
+/** Kept beside the union so a TypeScript change cannot silently leave the language-neutral schema/vector set behind. */
+const B3_CONTROL_V1_OPERATION_SPECS = Object.freeze(B3_DESKTOP_CONTROL_OPERATIONS.map((operation) => ({
+	operation,
+	desktopCallable: true,
+	secret: B3_SECRET_OPERATIONS.has(operation)
+})));
+/** E owns this gate; B3 records the obligation without pretending a temporary fixture proves future build/shipping. */
+const B3_CONTROL_V1_SUCCESSOR_REQUIREMENT = "E imports its real code and this contract, lands the build/ship negative gate before any owner registration or callable judge, and requires B3 merged.";
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+new Set(B3_DESKTOP_CONTROL_OPERATIONS);
+Object.freeze({
+	status: [
+		"owner",
+		"enabled",
+		"paused",
+		"switchGeneration",
+		"activationIntents"
+	],
+	stop: ["stopping"],
+	pause: [
+		"enabled",
+		"paused",
+		"switchGeneration"
+	],
+	resume: [
+		"enabled",
+		"paused",
+		"switchGeneration"
+	],
+	"disable-all": [
+		"enabled",
+		"paused",
+		"switchGeneration"
+	],
+	"enable-all": [
+		"intentId",
+		"approvalId",
+		"binding",
+		"kind",
+		"status",
+		"replacementOfVersion"
+	],
+	"catalogue-show": [
+		"type",
+		"version",
+		"channel"
+	],
+	"source-show": ["source", "accounts"],
+	"rule-create": [
+		"id",
+		"kind",
+		"objectId",
+		"version",
+		"document",
+		"digest",
+		"state"
+	],
+	"rule-update": [
+		"id",
+		"kind",
+		"objectId",
+		"version",
+		"document",
+		"digest",
+		"state"
+	],
+	"rule-enable": [
+		"intentId",
+		"approvalId",
+		"binding",
+		"kind",
+		"status",
+		"replacementOfVersion"
+	],
+	"rule-disable": ["ruleId", "disabled"],
+	"rule-remove": ["ruleId", "disabled"],
+	"target-add": [
+		"id",
+		"kind",
+		"objectId",
+		"version",
+		"document",
+		"digest",
+		"state"
+	],
+	"target-update": [
+		"id",
+		"kind",
+		"objectId",
+		"version",
+		"document",
+		"digest",
+		"state"
+	],
+	"target-remove": ["targetId", "removed"],
+	approve: [
+		"intentId",
+		"status",
+		"usedAt"
+	],
+	ruleTest: [
+		"agentic",
+		"outcome",
+		"rendered"
+	],
+	ruleTestRetained: [
+		"agentic",
+		"outcome",
+		"rendered"
+	],
+	targetTest: [
+		"attempts",
+		"targetId",
+		"targetVersion"
+	],
+	targetResume: ["id", "resetEpoch"],
+	addSubscriber: [
+		"id",
+		"kind",
+		"objectId",
+		"version",
+		"document",
+		"digest",
+		"state"
+	],
+	updateSubscriber: [
+		"id",
+		"kind",
+		"objectId",
+		"version",
+		"document",
+		"digest",
+		"state"
+	],
+	removeSubscriber: ["subscriberId", "removed"],
+	retryDelivery: [
+		"kind",
+		"deliveryId",
+		"nextAt"
+	],
+	dropDelivery: ["kind", "deliveryId"],
+	"dryrun-show": [
+		"deliveryId",
+		"ruleId",
+		"ruleVersion",
+		"targetId",
+		"targetVersion",
+		"eventId",
+		"accountId",
+		"deliveredAt",
+		"expiresAt",
+		"record"
+	]
+});
+/**
+* The terminal and desktop fixture boundary. This formats only daemon-authored identifiers and a canonical, neutralised
+* preview representation; it never consumes a secret operation or claims the approval.
+*/
+function renderB3ApprovalPreviewV1(value) {
+	if (!isRecord(value) || typeof value.kind !== "string" || !B3_APPROVAL_VIEW_VARIANTS.includes(value.kind)) throw new TypeError("an approval preview has an unknown B3 v1 variant");
+	if (value.kind !== "READY") return {
+		kind: value.kind,
+		structured: {},
+		terminal: `Approval view: ${value.kind}`
+	};
+	if (typeof value.approvalId !== "string" || typeof value.digest !== "string" || !isRecord(value.challenge) || typeof value.challenge.approvalId !== "string" || typeof value.challenge.digest !== "string" || typeof value.challenge.challenge !== "string" || typeof value.challenge.expiresAt !== "number") throw new TypeError("a ready approval preview is malformed");
+	normaliseActivationDocument(value.preview);
+	return {
+		kind: "READY",
+		structured: {
+			approvalId: value.approvalId,
+			digest: value.digest,
+			preview: value.preview,
+			challenge: {
+				approvalId: value.challenge.approvalId,
+				digest: value.challenge.digest,
+				challenge: value.challenge.challenge,
+				expiresAt: value.challenge.expiresAt
+			}
+		},
+		terminal: [
+			`Approval ${value.approvalId}`,
+			`Digest ${value.digest}`,
+			`Preview ${neutralise(canonicalJson(value.preview)).text}`,
+			`Challenge ${value.challenge.challenge}`,
+			`Expires ${new Date(value.challenge.expiresAt).toISOString()}`
+		].join("\n")
+	};
+}
+/** No desktop, secret value, network client or judge implementation crosses this boundary. */
+const B3_CONTROL_CONTRACT = Object.freeze({
+	version: B3_CONTROL_V1_SCHEMA_VERSION,
+	capabilities: B3_CAPABILITIES,
+	approvalView: B3_APPROVAL_VIEW_VARIANTS,
+	judgeUnavailable: B3_JUDGE_UNAVAILABLE_VARIANTS
+});
+//#endregion
+export { createRule as $, assertSocketPathFits as $t, normaliseWhatsAppSourceOptions as A, deliveriesList as At, removeTarget as B, ControlFrameReader as Bt, canonicalSseSubscriber as C, assertDoctorReportV1 as Ct, normaliseResendSourceOptions as D, isActivationFailureCode as Dt, normaliseGmailSourceOptions as E, ACTIVATION_FAILURE as Et, canonicalJudgeBudget as F, catalogueShow as Ft, removeSubscriber as G, negotiateVersion as Gt, updateTarget as H, encodeControlFrame as Ht, canonicalJudgeKindEnablement as I, approvalView as It, stop as J, processIsLive as Jt, subscribersList as K, mayRecoverStaleInstance as Kt, judgeKindDefinition as L, EventControlClient as Lt, JUDGE_BUDGET_ID as M, heldList as Mt, JUDGE_KIND_DEFINITIONS as N, retryDelivery as Nt, normaliseSlackSourceOptions as O, disableAll as Ot, canonicalJudge as P, catalogueList as Pt, sourcesList as Q, assertControlSupported as Qt, createEventsMcpServer as R, probeControl as Rt, normaliseActivationDocument as S, enableAll as St, classifySourceOptionChange as T, doctor as Tt, targetTest as U, isControlHello as Ut, targetsList as V, controlFailure as Vt, addSubscriber as W, isControlRequest as Wt, loadSqlite as X, removeInstance as Xt, status as Y, readInstance as Yt, sourceShow as Z, writeInstance as Zt, activationDocumentDigest as _, judgesList as _t, B3_CONTROL_V1_OPERATION_SPECS as a, ensureOwnerOnlyFile as an, updateRule as at, canonicalTarget as b, updateBudget as bt, B3_CONTROL_V1_SUCCESSOR_REQUIREMENT as c, pause as ct, B3_SECRET_TERMINAL_ORIGIN as d, budgetShow as dt, controlEndpoint as en, disableRule as et, isB3ControlOperation as f, disableJudgeKind as ft, isOwnerControlWireOperation as g, judgeTest as gt, OWNER_CONTROL_WIRES as h, judgeModelStatus as ht, B3_CONTROL_ERROR_CODES as i, ensureEventSocketDirectory as in, rulesList as it, APPROVED_TYPESAFE_MODELS as j, dropDelivery as jt, normaliseSourceOptions as k, decideHeld as kt, B3_DESKTOP_CONTROL_OPERATIONS as l, resume as lt, renderB3ApprovalPreviewV1 as m, judgeKindsList as mt, B3_CAPABILITIES as n, verifyPrivateSocketDirectory as nn, removeRule as nt, B3_CONTROL_V1_RESULT_OPERATIONS as o, eventPaths as on, ruleTest as ot, isB3SecretOperation as p, enableJudgeKind as pt, updateSubscriber as q, newInstanceRecord as qt, B3_CONTROL_CONTRACT as r, ensureEventPaths as rn, ruleShow as rt, B3_CONTROL_V1_SCHEMA_VERSION as s, installErrorSink as sn, ruleTestRetained as st, B3_APPROVAL_VIEW_VARIANTS as t, verifyControlSocket as tn, enableRule as tt, B3_JUDGE_UNAVAILABLE_VARIANTS as u, addJudge as ut, canonicalFullRuleDocument as v, removeJudge as vt, sseDeliveryTarget as w, assertDoctorReportV2 as wt, disclosureBindingFor as x, updateJudge as xt, canonicalSubscriber as y, removeJudgeModel as yt, addTarget as z, CONTROL_PROTOCOL_VERSIONS as zt };