@electric-ax/agents-server-conformance-tests 0.1.2

package/dist/index.cjs

@@ -0,0 +1,3750 @@
+"use strict";
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const vitest = __toESM(require("vitest"));
+const fast_check = __toESM(require("fast-check"));
+const node_http = __toESM(require("node:http"));
+const __electric_sql_client = __toESM(require("@electric-sql/client"));
+const node_child_process = __toESM(require("node:child_process"));
+
+//#region src/electric-agents-dsl.ts
+async function fetchShapeRows(baseUrl, table) {
+	const stream = new __electric_sql_client.ShapeStream({
+		url: `${baseUrl}/_electric/electric/v1/shape`,
+		params: { table },
+		subscribe: false
+	});
+	const shape = new __electric_sql_client.Shape(stream);
+	const rows = await shape.rows;
+	return rows;
+}
+async function fetchEntitiesViaShape(baseUrl, filter) {
+	let entities = await fetchShapeRows(baseUrl, `entities`);
+	if (filter?.type) entities = entities.filter((e) => e.type === filter.type);
+	if (filter?.status) entities = entities.filter((e) => e.status === filter.status);
+	if (filter?.parent) entities = entities.filter((e) => e.parent === filter.parent);
+	return entities;
+}
+function toServerEntityTypeRegistration(registration) {
+	const body = {
+		name: registration.name,
+		description: registration.description,
+		...registration.creation_schema && { creation_schema: registration.creation_schema },
+		...registration.metadata_schema && { metadata_schema: registration.metadata_schema },
+		...registration.serve_endpoint && { serve_endpoint: registration.serve_endpoint }
+	};
+	const inboxSchemas = registration.inbox_schemas ?? registration.input_schemas;
+	const stateSchemas = registration.state_schemas ?? registration.output_schemas;
+	if (inboxSchemas) body.inbox_schemas = inboxSchemas;
+	if (stateSchemas) body.state_schemas = stateSchemas;
+	return body;
+}
+function normalizeWebhookPayload(body) {
+	const parsed = JSON.parse(body);
+	return {
+		consumer_id: String(parsed.consumer_id ?? parsed.consumerId ?? ``),
+		epoch: Number(parsed.epoch ?? 0),
+		wake_id: String(parsed.wake_id ?? parsed.wakeId ?? ``),
+		primary_stream: String(parsed.primary_stream ?? parsed.streamPath ?? ``),
+		streams: Array.isArray(parsed.streams) ? parsed.streams : [],
+		triggered_by: Array.isArray(parsed.triggered_by) ? parsed.triggered_by : Array.isArray(parsed.triggeredBy) ? parsed.triggeredBy : [],
+		callback: String(parsed.callback ?? ``),
+		token: String(parsed.token ?? parsed.claimToken ?? ``),
+		entity: parsed.entity,
+		trigger_event: parsed.trigger_event ?? parsed.triggerEvent
+	};
+}
+var WebhookReceiver = class {
+	server = null;
+	_url = null;
+	notifications = [];
+	waitResolvers = [];
+	consumedCount = 0;
+	async start() {
+		return new Promise((resolve, reject) => {
+			this.server = (0, node_http.createServer)((req, res) => {
+				this.handleRequest(req, res);
+			});
+			this.server.on(`error`, reject);
+			this.server.listen(0, `127.0.0.1`, () => {
+				const addr = this.server.address();
+				if (typeof addr === `object` && addr) this._url = `http://127.0.0.1:${addr.port}`;
+				resolve(this._url);
+			});
+		});
+	}
+	async stop() {
+		if (!this.server) return;
+		return new Promise((resolve) => {
+			this.server.closeAllConnections();
+			this.server.close(() => {
+				this.server = null;
+				this._url = null;
+				resolve();
+			});
+		});
+	}
+	get url() {
+		if (!this._url) throw new Error(`WebhookReceiver not started`);
+		return this._url;
+	}
+	handleRequest(req, res) {
+		const chunks = [];
+		req.on(`data`, (chunk) => chunks.push(chunk));
+		req.on(`end`, () => {
+			const body = Buffer.concat(chunks).toString(`utf-8`);
+			try {
+				const parsed = normalizeWebhookPayload(body);
+				const notification = {
+					body,
+					parsed,
+					resolve: (response) => {
+						res.writeHead(response.status, { "content-type": `application/json` });
+						res.end(response.body);
+					}
+				};
+				this.notifications.push(notification);
+				for (const waiter of this.waitResolvers) waiter();
+				this.waitResolvers = [];
+			} catch {
+				res.writeHead(400);
+				res.end(`Invalid JSON`);
+			}
+		});
+	}
+	async waitForNotification(timeoutMs = 1e4) {
+		const targetIdx = this.consumedCount;
+		this.consumedCount++;
+		if (this.notifications.length > targetIdx) return this.notifications[targetIdx];
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				reject(new Error(`Timed out waiting for webhook notification after ${timeoutMs}ms`));
+			}, timeoutMs);
+			const check = () => {
+				if (this.notifications.length > targetIdx) {
+					clearTimeout(timeout);
+					resolve(this.notifications[targetIdx]);
+				} else this.waitResolvers.push(check);
+			};
+			check();
+		});
+	}
+	async expectNoNotification(timeoutMs = 500) {
+		const startCount = this.notifications.length;
+		await new Promise((r) => setTimeout(r, timeoutMs));
+		(0, vitest.expect)(this.notifications.length).toBe(startCount);
+	}
+	get received() {
+		return this.notifications;
+	}
+};
+var ServeEndpointReceiver = class {
+	server = null;
+	_url = null;
+	manifest = null;
+	async start(manifest) {
+		this.manifest = manifest;
+		return new Promise((resolve, reject) => {
+			this.server = (0, node_http.createServer)((req, res) => {
+				this.handleRequest(req, res);
+			});
+			this.server.on(`error`, reject);
+			this.server.listen(0, `127.0.0.1`, () => {
+				const addr = this.server.address();
+				if (typeof addr === `object` && addr) this._url = `http://127.0.0.1:${addr.port}`;
+				resolve(this._url);
+			});
+		});
+	}
+	async stop() {
+		if (!this.server) return;
+		return new Promise((resolve) => {
+			this.server.closeAllConnections();
+			this.server.close(() => {
+				this.server = null;
+				this._url = null;
+				resolve();
+			});
+		});
+	}
+	get url() {
+		if (!this._url) throw new Error(`ServeEndpointReceiver not started`);
+		return this._url;
+	}
+	handleRequest(_req, res) {
+		res.writeHead(200, { "content-type": `application/json` });
+		res.end(JSON.stringify(this.manifest));
+	}
+};
+async function electricAgentsFetch$1(baseUrl, path, opts = {}) {
+	return fetch(`${baseUrl}${routeControlPlanePath$1(path)}`, {
+		...opts,
+		headers: {
+			"content-type": `application/json`,
+			...opts.headers
+		}
+	});
+}
+function routeControlPlanePath$1(path) {
+	const pathname = path.split(`?`, 1)[0];
+	if (pathname.startsWith(`/_electric/`) || isEntityStreamPath$1(pathname)) return path;
+	return `/_electric/entities${path}`;
+}
+function isEntityStreamPath$1(pathname) {
+	const segments = pathname.split(`/`).filter(Boolean);
+	const lastSegment = segments.at(-1);
+	return segments.length >= 3 && (lastSegment === `main` || lastSegment === `error`);
+}
+function subscriptionEndpoint$1(baseUrl, id) {
+	return `${baseUrl}/v1/stream-meta/subscriptions/${encodeURIComponent(id)}`;
+}
+function subscriptionPattern$1(pattern) {
+	return pattern.replace(/^\/+/, ``);
+}
+var ElectricAgentsScenario = class {
+	baseUrl;
+	steps = [];
+	_skipInvariants = false;
+	constructor(baseUrl) {
+		this.baseUrl = baseUrl;
+	}
+	subscription(pattern, id) {
+		this.steps.push({
+			kind: `subscription`,
+			pattern,
+			id
+		});
+		return this;
+	}
+	spawn(typeName, instanceId, opts) {
+		this.steps.push({
+			kind: `spawnTyped`,
+			typeName,
+			instanceId,
+			args: opts?.args,
+			tags: opts?.tags,
+			parent: opts?.parent,
+			initialMessage: opts?.initialMessage
+		});
+		return this;
+	}
+	send(payload, opts) {
+		this.steps.push({
+			kind: `send`,
+			payload,
+			from: opts.from,
+			type: opts.type
+		});
+		return this;
+	}
+	sendTo(url, payload, opts) {
+		this.steps.push({
+			kind: `sendTo`,
+			url,
+			payload,
+			from: opts.from
+		});
+		return this;
+	}
+	kill() {
+		this.steps.push({ kind: `kill` });
+		return this;
+	}
+	killUrl(url) {
+		this.steps.push({
+			kind: `killUrl`,
+			url
+		});
+		return this;
+	}
+	expectWebhook(opts) {
+		this.steps.push({
+			kind: `expectWebhook`,
+			opts
+		});
+		return this;
+	}
+	respondDone() {
+		this.steps.push({ kind: `respondDone` });
+		return this;
+	}
+	expectEntityContext(checks) {
+		this.steps.push({
+			kind: `expectEntityContext`,
+			checks
+		});
+		return this;
+	}
+	expectStatus(status) {
+		this.steps.push({
+			kind: `expectStatus`,
+			status
+		});
+		return this;
+	}
+	expectStreamContains(messageType) {
+		this.steps.push({
+			kind: `expectStreamContains`,
+			messageType
+		});
+		return this;
+	}
+	readStream(stream) {
+		this.steps.push({
+			kind: `readStream`,
+			stream
+		});
+		return this;
+	}
+	list(filter) {
+		this.steps.push({
+			kind: `list`,
+			filter
+		});
+		return this;
+	}
+	expectListCount(opts) {
+		this.steps.push({
+			kind: `expectListCount`,
+			...opts
+		});
+		return this;
+	}
+	expectListTotal(total) {
+		this.steps.push({
+			kind: `expectListTotal`,
+			total
+		});
+		return this;
+	}
+	registerType(registration) {
+		this.steps.push({
+			kind: `registerType`,
+			registration
+		});
+		return this;
+	}
+	expectTypeExists(name) {
+		this.steps.push({
+			kind: `expectTypeExists`,
+			name
+		});
+		return this;
+	}
+	inspectType(name) {
+		this.steps.push({
+			kind: `inspectType`,
+			name
+		});
+		return this;
+	}
+	deleteType(name) {
+		this.steps.push({
+			kind: `deleteType`,
+			name
+		});
+		return this;
+	}
+	expectTypeNotExists(name) {
+		this.steps.push({
+			kind: `expectTypeNotExists`,
+			name
+		});
+		return this;
+	}
+	amendSchemas(name, schemas) {
+		this.steps.push({
+			kind: `amendSchemas`,
+			name,
+			input_schemas: schemas.input_schemas,
+			output_schemas: schemas.output_schemas
+		});
+		return this;
+	}
+	listTypes() {
+		this.steps.push({ kind: `listTypes` });
+		return this;
+	}
+	registerTypeViaServe(registration) {
+		this.steps.push({
+			kind: `registerTypeViaServe`,
+			registration
+		});
+		return this;
+	}
+	write(payload, opts) {
+		this.steps.push({
+			kind: `write`,
+			payload,
+			eventType: opts?.type
+		});
+		return this;
+	}
+	writeStateProtocol(event) {
+		this.steps.push({
+			kind: `writeStateProtocol`,
+			event
+		});
+		return this;
+	}
+	expectStreamEvent(type, key, operation, valueCheck) {
+		this.steps.push({
+			kind: `expectStreamEvent`,
+			type,
+			key,
+			operation,
+			valueCheck
+		});
+		return this;
+	}
+	expectStreamEventCount(type, count) {
+		this.steps.push({
+			kind: `expectStreamEventCount`,
+			type,
+			count
+		});
+		return this;
+	}
+	setTags(tags) {
+		this.steps.push({
+			kind: `setTags`,
+			tags
+		});
+		return this;
+	}
+	expectTags(expected) {
+		this.steps.push({
+			kind: `expectTags`,
+			tags: expected
+		});
+		return this;
+	}
+	expectSpawnSchemaError(typeName, instanceId, opts) {
+		this.steps.push({
+			kind: `expectSpawnSchemaError`,
+			typeName,
+			instanceId,
+			args: opts?.args,
+			code: `SCHEMA_VALIDATION_ERROR`,
+			status: 422
+		});
+		return this;
+	}
+	expectSendSchemaError(payload, opts) {
+		this.steps.push({
+			kind: `expectSendSchemaError`,
+			payload,
+			messageType: opts.type ?? `default`,
+			code: `SCHEMA_VALIDATION_ERROR`,
+			status: 422
+		});
+		return this;
+	}
+	expectWriteSchemaError(payload, opts) {
+		this.steps.push({
+			kind: `expectWriteSchemaError`,
+			payload,
+			eventType: opts?.type ?? `default`,
+			code: `SCHEMA_VALIDATION_ERROR`,
+			status: 422
+		});
+		return this;
+	}
+	expectSendUnknownType(payload, opts) {
+		this.steps.push({
+			kind: `expectSendUnknownType`,
+			payload,
+			messageType: opts.type,
+			code: `UNKNOWN_MESSAGE_TYPE`,
+			status: 422
+		});
+		return this;
+	}
+	expectWriteUnknownType(payload, opts) {
+		this.steps.push({
+			kind: `expectWriteUnknownType`,
+			payload,
+			eventType: opts.type,
+			code: `UNKNOWN_EVENT_TYPE`,
+			status: 422
+		});
+		return this;
+	}
+	expectEntityPersisted() {
+		this.steps.push({ kind: `expectEntityPersisted` });
+		return this;
+	}
+	expectSpawnError(url, code, status) {
+		this.steps.push({
+			kind: `expectSpawnError`,
+			url,
+			code,
+			status
+		});
+		return this;
+	}
+	expectSendError(code, status) {
+		this.steps.push({
+			kind: `expectSendError`,
+			code,
+			status
+		});
+		return this;
+	}
+	custom(fn) {
+		this.steps.push({
+			kind: `custom`,
+			fn
+		});
+		return this;
+	}
+	wait(ms) {
+		this.steps.push({
+			kind: `wait`,
+			ms
+		});
+		return this;
+	}
+	skipInvariants() {
+		this._skipInvariants = true;
+		return this;
+	}
+	async run() {
+		const receiver = new WebhookReceiver();
+		await receiver.start();
+		const ctx = {
+			baseUrl: this.baseUrl,
+			receiver,
+			history: [],
+			subscriptions: [],
+			currentEntityUrl: null,
+			currentEntityStreams: null,
+			currentWriteToken: null,
+			notification: null,
+			lastListResult: null,
+			lastListTotal: null,
+			lastStreamMessages: null,
+			currentEntityType: null,
+			lastTypeResult: null,
+			lastTypeListResult: null,
+			serveReceiver: null
+		};
+		try {
+			for (const step of this.steps) await executeStep(ctx, step);
+			if (!this._skipInvariants) checkInvariants(ctx.history);
+			return ctx.history;
+		} finally {
+			for (const subscription of ctx.subscriptions) try {
+				await fetch(subscriptionEndpoint$1(ctx.baseUrl, subscription.id), { method: `DELETE` });
+			} catch {}
+			for (const n of receiver.received) try {
+				n.resolve({
+					status: 200,
+					body: JSON.stringify({ done: true })
+				});
+			} catch {}
+			await receiver.stop();
+			if (ctx.serveReceiver) await ctx.serveReceiver.stop();
+		}
+	}
+};
+async function executeStep(ctx, step) {
+	switch (step.kind) {
+		case `subscription`: {
+			const res = await fetch(subscriptionEndpoint$1(ctx.baseUrl, step.id), {
+				method: `PUT`,
+				headers: { "content-type": `application/json` },
+				body: JSON.stringify({
+					type: `webhook`,
+					pattern: subscriptionPattern$1(step.pattern),
+					webhook: { url: ctx.receiver.url }
+				})
+			});
+			(0, vitest.expect)(res.status).toBeLessThan(300);
+			ctx.subscriptions.push({
+				pattern: step.pattern,
+				id: step.id
+			});
+			ctx.history.push({
+				type: `subscription_created`,
+				pattern: step.pattern,
+				subscriptionId: step.id,
+				webhookUrl: ctx.receiver.url
+			});
+			break;
+		}
+		case `spawn`: throw new Error(`The old 'spawn' step is deprecated. Use 'spawnTyped' instead.`);
+		case `send`:
+		case `sendTo`: {
+			let entityUrl = ctx.currentEntityUrl;
+			if (step.kind === `sendTo`) entityUrl = step.url;
+			if (!entityUrl) throw new Error(`No current entity — did you spawn first?`);
+			const body = { payload: step.payload };
+			if (step.from) body.from = step.from;
+			const res = await electricAgentsFetch$1(ctx.baseUrl, `${entityUrl}/send`, {
+				method: `POST`,
+				body: JSON.stringify(body)
+			});
+			(0, vitest.expect)(res.status).toBe(204);
+			ctx.history.push({
+				type: `message_sent`,
+				entityUrl,
+				payload: step.payload,
+				from: step.from
+			});
+			break;
+		}
+		case `expectWebhook`: {
+			const timeoutMs = step.opts?.timeoutMs ?? 1e4;
+			const notification = await ctx.receiver.waitForNotification(timeoutMs);
+			(0, vitest.expect)(notification.parsed.consumer_id).toBeDefined();
+			(0, vitest.expect)(notification.parsed.epoch).toBeGreaterThan(0);
+			(0, vitest.expect)(notification.parsed.wake_id).toBeDefined();
+			ctx.notification = notification;
+			ctx.history.push({
+				type: `webhook_received`,
+				consumer_id: notification.parsed.consumer_id,
+				epoch: notification.parsed.epoch,
+				wake_id: notification.parsed.wake_id,
+				entity: notification.parsed.entity,
+				trigger_event: notification.parsed.trigger_event
+			});
+			break;
+		}
+		case `respondDone`: {
+			if (!ctx.notification) throw new Error(`No notification to respond to`);
+			ctx.notification.resolve({
+				status: 200,
+				body: JSON.stringify({ done: true })
+			});
+			ctx.history.push({
+				type: `webhook_responded`,
+				status: 200,
+				body: { done: true }
+			});
+			ctx.notification = null;
+			await new Promise((r) => setTimeout(r, 100));
+			break;
+		}
+		case `expectEntityContext`: {
+			if (!ctx.notification) throw new Error(`No notification — did you expectWebhook first?`);
+			const entity = ctx.notification.parsed.entity;
+			(0, vitest.expect)(entity, `Webhook payload must contain entity context`).toBeDefined();
+			(0, vitest.expect)(entity.url).toBeTruthy();
+			(0, vitest.expect)(entity.streams.main).toBeTruthy();
+			(0, vitest.expect)(entity.streams.error).toBeTruthy();
+			if (step.checks?.url) (0, vitest.expect)(entity.url).toBe(step.checks.url);
+			if (step.checks?.type) (0, vitest.expect)(entity.type).toBe(step.checks.type);
+			if (step.checks?.status) (0, vitest.expect)(entity.status).toBe(step.checks.status);
+			break;
+		}
+		case `expectStatus`: {
+			if (!ctx.currentEntityUrl) throw new Error(`No current entity`);
+			const res = await electricAgentsFetch$1(ctx.baseUrl, ctx.currentEntityUrl);
+			(0, vitest.expect)(res.status).toBe(200);
+			const entity = await res.json();
+			if (step.status === `running`) (0, vitest.expect)([`running`, `idle`]).toContain(entity.status);
+			else (0, vitest.expect)(entity.status).toBe(step.status);
+			ctx.history.push({
+				type: `entity_status_checked`,
+				entityUrl: ctx.currentEntityUrl,
+				status: entity.status
+			});
+			break;
+		}
+		case `kill`:
+		case `killUrl`: {
+			let entityUrl = ctx.currentEntityUrl;
+			if (step.kind === `killUrl`) entityUrl = step.url;
+			if (!entityUrl) throw new Error(`No current entity — did you spawn first?`);
+			const res = await electricAgentsFetch$1(ctx.baseUrl, entityUrl, { method: `DELETE` });
+			(0, vitest.expect)(res.status).toBe(200);
+			ctx.history.push({
+				type: `entity_killed`,
+				entityUrl
+			});
+			break;
+		}
+		case `readStream`: {
+			if (!ctx.currentEntityStreams) throw new Error(`No current entity streams`);
+			const streamPath = step.stream === `error` ? ctx.currentEntityStreams.error : ctx.currentEntityStreams.main;
+			const res = await fetch(`${ctx.baseUrl}${streamPath}?offset=0000000000000000_0000000000000000`);
+			if (res.status === 200) {
+				const text = await res.text();
+				const messages = text ? JSON.parse(text) : [];
+				ctx.lastStreamMessages = Array.isArray(messages) ? messages : [messages];
+				ctx.history.push({
+					type: `stream_read`,
+					path: streamPath,
+					messageCount: ctx.lastStreamMessages.length
+				});
+			} else {
+				ctx.lastStreamMessages = [];
+				ctx.history.push({
+					type: `stream_read`,
+					path: streamPath,
+					messageCount: 0
+				});
+			}
+			break;
+		}
+		case `expectStreamContains`: {
+			if (!ctx.lastStreamMessages) throw new Error(`No stream messages — did you readStream first?`);
+			const found = ctx.lastStreamMessages.some((m) => m.type === step.messageType);
+			(0, vitest.expect)(found, `Stream should contain message of type '${step.messageType}'`).toBe(true);
+			break;
+		}
+		case `list`: {
+			const entities = await fetchEntitiesViaShape(ctx.baseUrl, step.filter);
+			let result = entities;
+			if (step.filter?.offset !== void 0) result = result.slice(step.filter.offset);
+			if (step.filter?.limit !== void 0) result = result.slice(0, step.filter.limit);
+			ctx.lastListResult = result;
+			ctx.lastListTotal = entities.length;
+			ctx.history.push({
+				type: `entity_list_fetched`,
+				count: result.length,
+				filter: step.filter
+			});
+			break;
+		}
+		case `expectListCount`: {
+			if (!ctx.lastListResult) throw new Error(`No list result — did you list() first?`);
+			if (step.exact !== void 0) (0, vitest.expect)(ctx.lastListResult.length).toBe(step.exact);
+			if (step.min !== void 0) (0, vitest.expect)(ctx.lastListResult.length).toBeGreaterThanOrEqual(step.min);
+			if (step.max !== void 0) (0, vitest.expect)(ctx.lastListResult.length).toBeLessThanOrEqual(step.max);
+			break;
+		}
+		case `expectSpawnError`: {
+			const res = await electricAgentsFetch$1(ctx.baseUrl, step.url, {
+				method: `PUT`,
+				body: JSON.stringify({})
+			});
+			(0, vitest.expect)(res.status).toBe(step.status);
+			const body = await res.json();
+			(0, vitest.expect)(body.error.code).toBe(step.code);
+			ctx.history.push({
+				type: `spawn_rejected`,
+				url: step.url,
+				status: step.status,
+				code: step.code
+			});
+			break;
+		}
+		case `expectSendError`: {
+			if (!ctx.currentEntityUrl) throw new Error(`No current entity`);
+			const res = await electricAgentsFetch$1(ctx.baseUrl, `${ctx.currentEntityUrl}/send`, {
+				method: `POST`,
+				body: JSON.stringify({
+					from: `test`,
+					payload: { should: `fail` }
+				})
+			});
+			(0, vitest.expect)(res.status).toBe(step.status);
+			const body = await res.json();
+			(0, vitest.expect)(body.error.code).toBe(step.code);
+			ctx.history.push({
+				type: `send_rejected`,
+				entityUrl: ctx.currentEntityUrl,
+				status: step.status,
+				code: step.code
+			});
+			break;
+		}
+		case `expectListTotal`: {
+			if (ctx.lastListTotal === null) throw new Error(`No list total — did you list() first?`);
+			(0, vitest.expect)(ctx.lastListTotal).toBe(step.total);
+			break;
+		}
+		case `wait`: {
+			await new Promise((r) => setTimeout(r, step.ms));
+			break;
+		}
+		case `custom`: {
+			await step.fn(ctx);
+			break;
+		}
+		case `registerType`: {
+			const res = await electricAgentsFetch$1(ctx.baseUrl, `/_electric/entity-types`, {
+				method: `POST`,
+				body: JSON.stringify(toServerEntityTypeRegistration(step.registration))
+			});
+			(0, vitest.expect)(res.status).toBe(201);
+			const body = await res.json();
+			ctx.currentEntityType = step.registration.name;
+			ctx.history.push({
+				type: `entity_type_registered`,
+				name: step.registration.name,
+				revision: body.revision
+			});
+			break;
+		}
+		case `expectTypeExists`: {
+			const res = await electricAgentsFetch$1(ctx.baseUrl, `/_electric/entity-types/${step.name}`);
+			(0, vitest.expect)(res.status).toBe(200);
+			break;
+		}
+		case `inspectType`: {
+			const res = await electricAgentsFetch$1(ctx.baseUrl, `/_electric/entity-types/${step.name}`);
+			(0, vitest.expect)(res.status).toBe(200);
+			const body = await res.json();
+			ctx.lastTypeResult = body;
+			ctx.history.push({
+				type: `entity_type_inspected`,
+				name: step.name,
+				revision: body.revision
+			});
+			break;
+		}
+		case `deleteType`: {
+			const res = await electricAgentsFetch$1(ctx.baseUrl, `/_electric/entity-types/${step.name}`, { method: `DELETE` });
+			(0, vitest.expect)([200, 204]).toContain(res.status);
+			ctx.history.push({
+				type: `entity_type_deleted`,
+				name: step.name
+			});
+			break;
+		}
+		case `expectTypeNotExists`: {
+			const res = await electricAgentsFetch$1(ctx.baseUrl, `/_electric/entity-types/${step.name}`);
+			(0, vitest.expect)(res.status).toBe(404);
+			break;
+		}
+		case `amendSchemas`: {
+			const body = {};
+			if (step.input_schemas) body.inbox_schemas = step.input_schemas;
+			if (step.output_schemas) body.state_schemas = step.output_schemas;
+			const res = await electricAgentsFetch$1(ctx.baseUrl, `/_electric/entity-types/${step.name}/schemas`, {
+				method: `PATCH`,
+				body: JSON.stringify(body)
+			});
+			(0, vitest.expect)(res.status).toBe(200);
+			const result = await res.json();
+			ctx.history.push({
+				type: `entity_type_schemas_amended`,
+				name: step.name,
+				revision: result.revision
+			});
+			break;
+		}
+		case `listTypes`: {
+			ctx.lastTypeListResult = await fetchShapeRows(ctx.baseUrl, `entity_types`);
+			break;
+		}
+		case `registerTypeViaServe`: {
+			const receiver = new ServeEndpointReceiver();
+			await receiver.start(step.registration);
+			const res = await electricAgentsFetch$1(ctx.baseUrl, `/_electric/entity-types`, {
+				method: `POST`,
+				body: JSON.stringify({
+					name: step.registration.name,
+					serve_endpoint: receiver.url
+				})
+			});
+			(0, vitest.expect)(res.status).toBe(201);
+			const body = await res.json();
+			ctx.currentEntityType = step.registration.name;
+			ctx.serveReceiver = receiver;
+			ctx.history.push({
+				type: `entity_type_registered`,
+				name: step.registration.name,
+				revision: body.revision
+			});
+			break;
+		}
+		case `spawnTyped`: {
+			const body = {};
+			if (step.args) body.args = step.args;
+			if (step.tags) body.tags = step.tags;
+			if (step.parent) body.parent = step.parent;
+			if (step.initialMessage !== void 0) body.initialMessage = step.initialMessage;
+			const res = await electricAgentsFetch$1(ctx.baseUrl, `/${step.typeName}/${step.instanceId}`, {
+				method: `PUT`,
+				body: JSON.stringify(body)
+			});
+			(0, vitest.expect)(res.status).toBe(201);
+			const entity = await res.json();
+			ctx.currentEntityUrl = entity.url;
+			ctx.currentEntityStreams = entity.streams;
+			ctx.currentWriteToken = null;
+			ctx.history.push({
+				type: `entity_spawned`,
+				entityUrl: entity.url,
+				entityType: step.typeName,
+				status: entity.status,
+				streams: entity.streams,
+				parent: step.parent
+			});
+			break;
+		}
+		case `write`: {
+			if (!ctx.currentEntityUrl) throw new Error(`No current entity`);
+			const body = {
+				type: step.eventType ?? `default`,
+				key: `write-${ctx.history.length}`,
+				value: typeof step.payload === `object` && step.payload !== null ? step.payload : { data: step.payload },
+				headers: { operation: `insert` }
+			};
+			const writeHeaders = {};
+			if (ctx.currentWriteToken) writeHeaders[`authorization`] = `Bearer ${ctx.currentWriteToken}`;
+			const res = await electricAgentsFetch$1(ctx.baseUrl, `${ctx.currentEntityUrl}/main`, {
+				method: `POST`,
+				headers: writeHeaders,
+				body: JSON.stringify(body)
+			});
+			(0, vitest.expect)([200, 204]).toContain(res.status);
+			ctx.history.push({
+				type: `entity_write`,
+				entityUrl: ctx.currentEntityUrl,
+				eventType: step.eventType,
+				payload: step.payload
+			});
+			break;
+		}
+		case `writeStateProtocol`: {
+			const entityUrl = ctx.currentEntityUrl;
+			if (!entityUrl) throw new Error(`No current entity for writeStateProtocol`);
+			const writeHeaders = {};
+			if (ctx.currentWriteToken) writeHeaders[`authorization`] = `Bearer ${ctx.currentWriteToken}`;
+			const res = await electricAgentsFetch$1(ctx.baseUrl, `${entityUrl}/main`, {
+				method: `POST`,
+				headers: writeHeaders,
+				body: JSON.stringify(step.event)
+			});
+			(0, vitest.expect)([200, 204]).toContain(res.status);
+			ctx.history.push({
+				type: `entity_write`,
+				entityUrl,
+				eventType: step.event.type,
+				payload: step.event
+			});
+			break;
+		}
+		case `expectStreamEvent`: {
+			if (!ctx.lastStreamMessages) throw new Error(`readStream() must be called first`);
+			const match = ctx.lastStreamMessages.find((e) => e.type === step.type && e.key === step.key && e.headers?.operation === step.operation);
+			(0, vitest.expect)(match).toBeDefined();
+			if (step.valueCheck && match) step.valueCheck(match.value ?? {});
+			break;
+		}
+		case `expectStreamEventCount`: {
+			if (!ctx.lastStreamMessages) throw new Error(`readStream() must be called first`);
+			const count = ctx.lastStreamMessages.filter((e) => e.type === step.type).length;
+			(0, vitest.expect)(count).toBe(step.count);
+			break;
+		}
+		case `setTags`: {
+			if (!ctx.currentEntityUrl) throw new Error(`No current entity`);
+			const tagHeaders = {};
+			if (ctx.currentWriteToken) tagHeaders[`authorization`] = `Bearer ${ctx.currentWriteToken}`;
+			for (const [key, value] of Object.entries(step.tags)) {
+				const res = await electricAgentsFetch$1(ctx.baseUrl, `${ctx.currentEntityUrl}/tags/${encodeURIComponent(key)}`, {
+					method: `POST`,
+					headers: tagHeaders,
+					body: JSON.stringify({ value })
+				});
+				(0, vitest.expect)(res.status).toBe(200);
+			}
+			ctx.history.push({
+				type: `tags_updated`,
+				entityUrl: ctx.currentEntityUrl,
+				tags: step.tags
+			});
+			break;
+		}
+		case `expectTags`: {
+			if (!ctx.currentEntityUrl) throw new Error(`No current entity`);
+			const res = await electricAgentsFetch$1(ctx.baseUrl, ctx.currentEntityUrl);
+			(0, vitest.expect)(res.status).toBe(200);
+			const entity = await res.json();
+			(0, vitest.expect)(entity.tags).toEqual(step.tags);
+			ctx.history.push({
+				type: `tags_checked`,
+				entityUrl: ctx.currentEntityUrl,
+				tags: step.tags
+			});
+			break;
+		}
+		case `expectSpawnSchemaError`: {
+			const body = {};
+			if (step.args) body.args = step.args;
+			const res = await electricAgentsFetch$1(ctx.baseUrl, `/${step.typeName}/${step.instanceId}`, {
+				method: `PUT`,
+				body: JSON.stringify(body)
+			});
+			(0, vitest.expect)(res.status).toBe(422);
+			const result = await res.json();
+			(0, vitest.expect)(result.error.code).toBe(`SCHEMA_VALIDATION_FAILED`);
+			ctx.history.push({
+				type: `spawn_schema_rejected`,
+				typeName: step.typeName,
+				instanceId: step.instanceId,
+				status: 422,
+				code: `SCHEMA_VALIDATION_FAILED`
+			});
+			break;
+		}
+		case `expectSendSchemaError`: {
+			if (!ctx.currentEntityUrl) throw new Error(`No current entity`);
+			const res = await electricAgentsFetch$1(ctx.baseUrl, `${ctx.currentEntityUrl}/send`, {
+				method: `POST`,
+				body: JSON.stringify({
+					type: step.messageType,
+					payload: step.payload
+				})
+			});
+			(0, vitest.expect)(res.status).toBe(422);
+			const result = await res.json();
+			(0, vitest.expect)(result.error.code).toBe(`SCHEMA_VALIDATION_FAILED`);
+			ctx.history.push({
+				type: `send_schema_rejected`,
+				entityUrl: ctx.currentEntityUrl,
+				messageType: step.messageType,
+				status: 422,
+				code: `SCHEMA_VALIDATION_FAILED`
+			});
+			break;
+		}
+		case `expectWriteSchemaError`: {
+			if (!ctx.currentEntityUrl) throw new Error(`No current entity`);
+			const writeHeaders = {};
+			if (ctx.currentWriteToken) writeHeaders[`authorization`] = `Bearer ${ctx.currentWriteToken}`;
+			const res = await electricAgentsFetch$1(ctx.baseUrl, `${ctx.currentEntityUrl}/main`, {
+				method: `POST`,
+				headers: writeHeaders,
+				body: JSON.stringify({
+					type: step.eventType,
+					key: `schema-test-${ctx.history.length}`,
+					value: typeof step.payload === `object` && step.payload !== null ? step.payload : { data: step.payload },
+					headers: { operation: `insert` }
+				})
+			});
+			(0, vitest.expect)(res.status).toBe(422);
+			const result = await res.json();
+			(0, vitest.expect)(result.error.code).toBe(`SCHEMA_VALIDATION_FAILED`);
+			ctx.history.push({
+				type: `write_schema_rejected`,
+				entityUrl: ctx.currentEntityUrl,
+				eventType: step.eventType,
+				status: 422,
+				code: `SCHEMA_VALIDATION_FAILED`
+			});
+			break;
+		}
+		case `expectSendUnknownType`: {
+			if (!ctx.currentEntityUrl) throw new Error(`No current entity`);
+			const res = await electricAgentsFetch$1(ctx.baseUrl, `${ctx.currentEntityUrl}/send`, {
+				method: `POST`,
+				body: JSON.stringify({
+					type: step.messageType,
+					payload: step.payload
+				})
+			});
+			(0, vitest.expect)(res.status).toBe(422);
+			const result = await res.json();
+			(0, vitest.expect)(result.error.code).toBe(`UNKNOWN_MESSAGE_TYPE`);
+			ctx.history.push({
+				type: `send_unknown_type_rejected`,
+				entityUrl: ctx.currentEntityUrl,
+				messageType: step.messageType,
+				status: 422,
+				code: `UNKNOWN_MESSAGE_TYPE`
+			});
+			break;
+		}
+		case `expectWriteUnknownType`: {
+			if (!ctx.currentEntityUrl) throw new Error(`No current entity`);
+			const writeHeaders = {};
+			if (ctx.currentWriteToken) writeHeaders[`authorization`] = `Bearer ${ctx.currentWriteToken}`;
+			const res = await electricAgentsFetch$1(ctx.baseUrl, `${ctx.currentEntityUrl}/main`, {
+				method: `POST`,
+				headers: writeHeaders,
+				body: JSON.stringify({
+					type: step.eventType,
+					key: `unknown-type-test-${ctx.history.length}`,
+					value: typeof step.payload === `object` && step.payload !== null ? step.payload : { data: step.payload },
+					headers: { operation: `insert` }
+				})
+			});
+			(0, vitest.expect)(res.status).toBe(422);
+			const result = await res.json();
+			(0, vitest.expect)(result.error.code).toBe(`UNKNOWN_EVENT_TYPE`);
+			ctx.history.push({
+				type: `write_unknown_type_rejected`,
+				entityUrl: ctx.currentEntityUrl,
+				eventType: step.eventType,
+				status: 422,
+				code: `UNKNOWN_EVENT_TYPE`
+			});
+			break;
+		}
+		case `expectEntityPersisted`: {
+			if (!ctx.currentEntityUrl) throw new Error(`No current entity`);
+			const res = await electricAgentsFetch$1(ctx.baseUrl, ctx.currentEntityUrl);
+			(0, vitest.expect)(res.status).toBe(200);
+			ctx.history.push({
+				type: `entity_persisted_verified`,
+				entityUrl: ctx.currentEntityUrl
+			});
+			break;
+		}
+	}
+}
+function checkInvariants(history) {
+	checkSpawnPrecedesSend(history);
+	checkSpawnPrecedesKill(history);
+	checkNoSendAfterKill(history);
+	checkEntityContextOnWebhook(history);
+	checkStreamPathsMatchEntityUrl(history);
+	checkStatusTransitionsValid(history);
+	checkEntityTypeExistsBeforeSpawn(history);
+	checkSchemaValidationAtGates(history);
+	checkAdditiveSchemaEvolution(history);
+	checkRegistryStreamConsistency(history);
+	checkParentExists(history);
+	checkNoSpawnAfterTypeDeleted(history);
+	const spWrites = history.filter((e) => e.type === `state_protocol_write`);
+	for (const w of spWrites) {
+		const spw = w;
+		(0, vitest.expect)([
+			`run`,
+			`step`,
+			`text`,
+			`tool_call`,
+			`text_delta`
+		].includes(spw.eventType), `State Protocol write must have valid event type, got: ${spw.eventType}`).toBe(true);
+		(0, vitest.expect)(spw.key, `State Protocol write must have a key`).toBeTruthy();
+		(0, vitest.expect)(spw.entityUrl, `State Protocol write must reference an entity`).toBeTruthy();
+	}
+}
+/**
+* Spec S8 — Precedence: an entity must be spawned before messages can be sent to it.
+* ¬send W spawn — "spawn must happen before send"
+* Soundness: Sound | Completeness: Complete (within trace)
+*/
+function checkSpawnPrecedesSend(history) {
+	const spawned = new Set();
+	for (const event of history) {
+		if (event.type === `entity_spawned`) spawned.add(event.entityUrl);
+		if (event.type === `message_sent`) (0, vitest.expect)(spawned.has(event.entityUrl), `Precedence: message_sent to ${event.entityUrl} but entity was not spawned first`).toBe(true);
+	}
+}
+/**
+* Spec S9 — Precedence: an entity must be spawned before it can be killed.
+* Soundness: Sound | Completeness: Complete (within trace)
+*/
+function checkSpawnPrecedesKill(history) {
+	const spawned = new Set();
+	for (const event of history) {
+		if (event.type === `entity_spawned`) spawned.add(event.entityUrl);
+		if (event.type === `entity_killed`) (0, vitest.expect)(spawned.has(event.entityUrl), `Precedence: entity_killed ${event.entityUrl} but entity was not spawned first`).toBe(true);
+	}
+}
+/**
+* Spec S3 — Safety: no successful send after kill.
+* Once an entity is killed, message_sent should not appear for it.
+* (send_rejected is fine — that's the expected error path.)
+* Soundness: Sound | Completeness: Complete (within trace)
+*/
+function checkNoSendAfterKill(history) {
+	const killed = new Set();
+	for (const event of history) {
+		if (event.type === `entity_killed`) killed.add(event.entityUrl);
+		if (event.type === `message_sent`) (0, vitest.expect)(!killed.has(event.entityUrl), `Safety: message_sent to ${event.entityUrl} after it was killed`).toBe(true);
+	}
+}
+/**
+* Spec S6 — Safety: every webhook received while Electric Agents is enabled must contain
+* entity context (entity field in the payload).
+* Soundness: Sound | Completeness: Incomplete (only checks observed webhooks)
+*/
+function checkEntityContextOnWebhook(history) {
+	for (const event of history) if (event.type === `webhook_received`) {
+		(0, vitest.expect)(event.entity, `Safety: webhook_received must contain entity context`).toBeDefined();
+		(0, vitest.expect)(event.entity.url).toBeTruthy();
+	}
+}
+/**
+* Spec S5 — Structural: stream paths must match {entity.url}/main and {entity.url}/error.
+* Soundness: Sound | Completeness: Complete (within trace)
+*/
+function checkStreamPathsMatchEntityUrl(history) {
+	for (const event of history) if (event.type === `entity_spawned`) {
+		(0, vitest.expect)(event.streams.main).toBe(`${event.entityUrl}/main`);
+		(0, vitest.expect)(event.streams.error).toBe(`${event.entityUrl}/error`);
+	}
+}
+/**
+* Spec S4 — Safety: entity status transitions must be valid.
+* spawning → running is valid (at spawn time)
+* running/idle → stopped is valid (at kill time)
+* stopped → running is NOT valid
+* Soundness: Sound | Completeness: Incomplete (only checks observed status reads)
+*/
+function checkStatusTransitionsValid(history) {
+	const lastStatus = new Map();
+	for (const event of history) {
+		if (event.type === `entity_spawned`) lastStatus.set(event.entityUrl, event.status);
+		if (event.type === `entity_status_checked`) {
+			const prev = lastStatus.get(event.entityUrl);
+			if (prev === `stopped`) (0, vitest.expect)(event.status, `Safety: entity ${event.entityUrl} transitioned from stopped to ${event.status}`).toBe(`stopped`);
+			lastStatus.set(event.entityUrl, event.status);
+		}
+	}
+}
+/**
+* Spec R1 — Structural: every entity_spawned must be preceded by an
+* entity_type_registered event for the matching entity type.
+* Soundness: Sound | Completeness: Complete (within trace)
+*/
+function checkEntityTypeExistsBeforeSpawn(history) {
+	const registeredTypes = new Set();
+	for (const event of history) {
+		if (event.type === `entity_type_registered`) registeredTypes.add(event.name);
+		if (event.type === `entity_spawned` && event.entityType !== void 0) (0, vitest.expect)(registeredTypes.has(event.entityType), `Structural: entity_spawned for type '${event.entityType}' but no prior entity_type_registered event found`).toBe(true);
+	}
+}
+/**
+* Spec R2 — Safety: schema rejection events must carry the correct error code.
+* All schema rejection events (spawn/send/write) must have code SCHEMA_VALIDATION_FAILED.
+* Soundness: Sound | Completeness: Complete (within trace)
+*/
+function checkSchemaValidationAtGates(history) {
+	for (const event of history) if (event.type === `spawn_schema_rejected` || event.type === `send_schema_rejected` || event.type === `write_schema_rejected`) (0, vitest.expect)(event.code, `Safety: ${event.type} must have code SCHEMA_VALIDATION_FAILED, got '${event.code}'`).toBe(`SCHEMA_VALIDATION_FAILED`);
+}
+/**
+* Spec R3 — Additive-only schema evolution: entity_type_schemas_amended events
+* must not remove or rename schema keys that existed in the prior registration.
+* This checker works on the step inputs stored in history by tracking which
+* amendment steps appear in sequence. Since the history events for amendments
+* only record name and revision (not the actual schema keys), this invariant
+* verifies structural ordering — each amendment event must follow a registration
+* event. Full key-level checking would require schema contents in the event.
+* Soundness: Partial | Completeness: Incomplete (key contents not in history events)
+*
+* Note: The invariant verifies that every schema amendment is preceded by a
+* registration of the same type name, consistent with additive-only evolution.
+*/
+function checkAdditiveSchemaEvolution(history) {
+	const registeredTypes = new Set();
+	for (const event of history) {
+		if (event.type === `entity_type_registered`) registeredTypes.add(event.name);
+		if (event.type === `entity_type_schemas_amended`) (0, vitest.expect)(registeredTypes.has(event.name), `Additive evolution: entity_type_schemas_amended for '${event.name}' but no prior entity_type_registered event found`).toBe(true);
+	}
+}
+/**
+* Spec R4 — Registry stream consistency: every entity_spawned must refer to an
+* entity that has not already been killed, and stream URLs must follow the
+* convention {entity.url}/main and {entity.url}/error.
+* Soundness: Sound | Completeness: Complete (within trace)
+*/
+function checkRegistryStreamConsistency(history) {
+	const killedEntities = new Set();
+	for (const event of history) {
+		if (event.type === `entity_killed`) killedEntities.add(event.entityUrl);
+		if (event.type === `entity_spawned`) {
+			(0, vitest.expect)(!killedEntities.has(event.entityUrl), `Registry consistency: entity_spawned for ${event.entityUrl} but entity was already killed`).toBe(true);
+			(0, vitest.expect)(event.streams.main, `Registry consistency: entity ${event.entityUrl} streams.main must be ${event.entityUrl}/main`).toBe(`${event.entityUrl}/main`);
+			(0, vitest.expect)(event.streams.error, `Registry consistency: entity ${event.entityUrl} streams.error must be ${event.entityUrl}/error`).toBe(`${event.entityUrl}/error`);
+		}
+	}
+}
+/**
+* Spec R5 — Parent existence: if a spawned entity declares a parent, the
+* parent must have been spawned earlier in the trace and not yet killed.
+* Soundness: Sound | Completeness: Complete (within trace)
+*/
+function checkParentExists(history) {
+	const spawnedAlive = new Set();
+	for (const event of history) {
+		if (event.type === `entity_spawned`) {
+			if (event.parent) (0, vitest.expect)(spawnedAlive.has(event.parent), `Parent ${event.parent} must be spawned and alive before child ${event.entityUrl} is spawned`).toBe(true);
+			spawnedAlive.add(event.entityUrl);
+		}
+		if (event.type === `entity_killed`) spawnedAlive.delete(event.entityUrl);
+	}
+}
+/**
+* Spec R6 — No spawn after type deleted: every entity_spawned event must not
+* be preceded by an entity_type_deleted event for the same type name (unless
+* re-registered between the deletion and the spawn).
+* Soundness: Sound | Completeness: Complete (within trace)
+*/
+function checkNoSpawnAfterTypeDeleted(history) {
+	const deletedTypes = new Set();
+	for (const event of history) {
+		if (event.type === `entity_type_deleted`) deletedTypes.add(event.name);
+		if (event.type === `entity_type_registered`) deletedTypes.delete(event.name);
+		if (event.type === `entity_spawned` && event.entityType !== void 0) (0, vitest.expect)(!deletedTypes.has(event.entityType), `Safety: entity_spawned for type '${event.entityType}' after it was deleted without re-registration`).toBe(true);
+	}
+}
+/**
+* ENABLED predicate — determines which actions can fire from the current state.
+*
+* - register_type: always (up to a cap of 3 types)
+* - delete_type: when entity types exist and no running entities use them
+* - spawn: when at least one entity type is registered (up to a cap)
+* - send: when at least one entity is running
+* - kill: when at least one entity is running
+* - check_status: when at least one entity exists
+* - list: always
+*/
+function enabledElectricAgentsActions(model) {
+	const enabled = [`list`];
+	if (model.entityTypes.length < 3) enabled.push(`register_type`);
+	const runningTypeNames = new Set(model.entities.filter((e) => e.status === `running`).map((e) => e.typeName));
+	const deletableTypes = model.entityTypes.filter((t) => !runningTypeNames.has(t.name));
+	if (deletableTypes.length > 0) enabled.push(`delete_type`);
+	if (model.entityTypes.length > 0 && model.entities.length < 4) enabled.push(`spawn`);
+	const hasRunning = model.entities.some((e) => e.status === `running`);
+	if (hasRunning) enabled.push(`send`, `kill`, `check_status`);
+	const hasAny = model.entities.length > 0;
+	if (hasAny && !hasRunning) enabled.push(`check_status`);
+	return enabled;
+}
+/**
+* Next relation — pure state transition for the model.
+* The real server execution happens separately in the property test.
+*/
+function applyElectricAgentsAction(model, action, targetIdx) {
+	switch (action) {
+		case `register_type`: {
+			const typeNum = model.entityTypes.length;
+			return {
+				...model,
+				entityTypes: [...model.entityTypes, {
+					name: `prop-type-${typeNum}`,
+					hasCreationSchema: false,
+					hasInputSchemas: false,
+					hasOutputSchemas: false
+				}]
+			};
+		}
+		case `delete_type`: {
+			const runningTypeNames = new Set(model.entities.filter((e) => e.status === `running`).map((e) => e.typeName));
+			const deletable = model.entityTypes.filter((t) => !runningTypeNames.has(t.name));
+			if (deletable.length === 0) return model;
+			const toDelete = deletable[0];
+			return {
+				...model,
+				entityTypes: model.entityTypes.filter((t) => t.name !== toDelete.name)
+			};
+		}
+		case `spawn`: {
+			if (model.entityTypes.length === 0) return model;
+			const typeName = model.entityTypes[0].name;
+			return {
+				...model,
+				entities: [...model.entities, {
+					url: `/prop-placeholder/entity-${model.nextEntityNum}`,
+					typeName,
+					status: `running`,
+					messageCount: 0
+				}],
+				nextEntityNum: model.nextEntityNum + 1
+			};
+		}
+		case `send`: {
+			if (targetIdx === void 0) return model;
+			const entities = [...model.entities];
+			const e = entities[targetIdx];
+			entities[targetIdx] = {
+				...e,
+				messageCount: e.messageCount + 1
+			};
+			return {
+				...model,
+				entities
+			};
+		}
+		case `kill`: {
+			if (targetIdx === void 0) return model;
+			const entities = [...model.entities];
+			const e = entities[targetIdx];
+			entities[targetIdx] = {
+				...e,
+				status: `stopped`
+			};
+			return {
+				...model,
+				entities
+			};
+		}
+		case `check_status`:
+		case `list`: return model;
+	}
+}
+function electricAgents(baseUrl) {
+	return new ElectricAgentsScenario(baseUrl);
+}
+function checkStateProtocolInvariants(events) {
+	const stateProtocolEvents = events.filter((e) => e.type && e.key && e.headers);
+	if (stateProtocolEvents.length === 0) return;
+	const runs = new Map();
+	for (const e of stateProtocolEvents) {
+		if (e.type !== `run`) continue;
+		const key = e.key;
+		if (!runs.has(key)) runs.set(key, []);
+		runs.get(key).push(e);
+	}
+	for (const [key, evts] of runs) (0, vitest.expect)(evts[0].headers.operation, `E1: run ${key} must start with insert`).toBe(`insert`);
+	const steps = new Map();
+	for (const e of stateProtocolEvents) {
+		if (e.type !== `step`) continue;
+		const key = e.key;
+		if (!steps.has(key)) steps.set(key, []);
+		steps.get(key).push(e);
+	}
+	for (const [key, evts] of steps) (0, vitest.expect)(evts[0].headers.operation, `E2: step ${key} must start with insert`).toBe(`insert`);
+	const texts = new Map();
+	for (const e of stateProtocolEvents) {
+		if (e.type !== `text`) continue;
+		const key = e.key;
+		if (!texts.has(key)) texts.set(key, []);
+		texts.get(key).push(e);
+	}
+	for (const [key, evts] of texts) (0, vitest.expect)(evts[0].headers.operation, `E3: text ${key} must start with insert`).toBe(`insert`);
+	const toolCalls = new Map();
+	for (const e of stateProtocolEvents) {
+		if (e.type !== `tool_call`) continue;
+		const key = e.key;
+		if (!toolCalls.has(key)) toolCalls.set(key, []);
+		toolCalls.get(key).push(e);
+	}
+	for (const [key, evts] of toolCalls) {
+		(0, vitest.expect)(evts.length).toBeGreaterThanOrEqual(3);
+		(0, vitest.expect)(evts[0].headers.operation, `E4: tool_call ${key} must start with insert`).toBe(`insert`);
+		(0, vitest.expect)(evts[0].value?.status, `E4: tool_call ${key} insert must have status started`).toBe(`started`);
+		const statuses = evts.map((e) => e.value?.status);
+		const executingIdx = statuses.indexOf(`executing`);
+		(0, vitest.expect)(executingIdx, `E4: tool_call ${key} must have executing state`).toBeGreaterThan(0);
+		if (executingIdx > 1) (0, vitest.expect)(statuses[1], `E4: tool_call ${key} event after started must be args_complete if not executing`).toBe(`args_complete`);
+		const lastStatus = statuses[statuses.length - 1];
+		(0, vitest.expect)(lastStatus === `completed` || lastStatus === `failed`, `E4: tool_call ${key} must end with completed or failed, got ${lastStatus}`).toBe(true);
+		const toolNames = evts.map((e) => e.value?.tool_name).filter(Boolean);
+		if (toolNames.length > 0) {
+			const first = toolNames[0];
+			for (const tn of toolNames) (0, vitest.expect)(tn, `E4: tool_name must be consistent for ${key}`).toBe(first);
+		}
+	}
+	const textDeltas = stateProtocolEvents.filter((e) => e.type === `text_delta`);
+	for (const d of textDeltas) {
+		const key = d.key;
+		(0, vitest.expect)(key, `E5: text_delta key must contain ':'`).toContain(`:`);
+		const [parentKey, seqStr] = key.split(`:`);
+		(0, vitest.expect)(Number.isInteger(parseInt(seqStr, 10)), `E5: text_delta seq must be integer`).toBe(true);
+		const val = d.value;
+		if (val) (0, vitest.expect)(val.text_id, `E5: text_delta value.text_id must match parent key`).toBe(parentKey);
+	}
+	for (const [key, evts] of steps) {
+		for (const e of evts) {
+			const val = e.value;
+			(0, vitest.expect)(val?.step_number, `E6: step ${key} must have step_number`).toBeDefined();
+		}
+		const stepNumbers = evts.map((e) => e.value?.step_number).filter((n) => n !== void 0);
+		if (stepNumbers.length > 1) {
+			const first = stepNumbers[0];
+			for (const n of stepNumbers) (0, vitest.expect)(n, `E6: step_number must be consistent for ${key}`).toBe(first);
+		}
+	}
+	const deltasByParent = new Map();
+	for (const d of textDeltas) {
+		const key = d.key;
+		const [parentKey, seqStr] = key.split(`:`);
+		if (!deltasByParent.has(parentKey)) deltasByParent.set(parentKey, []);
+		deltasByParent.get(parentKey).push(parseInt(seqStr, 10));
+	}
+	for (const [parent, seqs] of deltasByParent) for (let i = 1; i < seqs.length; i++) (0, vitest.expect)(seqs[i], `E7: text_delta seq for ${parent} must be monotonically increasing`).toBeGreaterThan(seqs[i - 1]);
+	for (const [key, evts] of runs) {
+		const updates = evts.filter((e) => e.headers.operation === `update`);
+		for (const u of updates) {
+			const val = u.value;
+			if (val.status === `completed`) (0, vitest.expect)(val.finish_reason, `E8: run ${key} completion must have finish_reason`).toBeDefined();
+		}
+	}
+	for (const [key, evts] of steps) {
+		const updates = evts.filter((e) => e.headers.operation === `update`);
+		for (const u of updates) {
+			const val = u.value;
+			if (val.status === `completed`) (0, vitest.expect)(val.finish_reason, `E8: step ${key} completion must have finish_reason`).toBeDefined();
+		}
+	}
+}
+
+//#endregion
+//#region src/cli-dsl.ts
+function subscriptionEndpoint(baseUrl, id) {
+	return `${baseUrl}/v1/stream-meta/subscriptions/${encodeURIComponent(id)}`;
+}
+function subscriptionPattern(pattern) {
+	return pattern.replace(/^\/+/, ``);
+}
+var CliScenario = class {
+	baseUrl;
+	cliBin;
+	steps = [];
+	constructor(baseUrl, cliBin) {
+		this.baseUrl = baseUrl;
+		this.cliBin = cliBin;
+	}
+	/**
+	* Register an entity type via HTTP (setup, not a CLI test).
+	*/
+	setupType(registration) {
+		this.steps.push({
+			kind: `setupType`,
+			registration
+		});
+		return this;
+	}
+	/**
+	* Create a webhook subscription via HTTP (setup, not a CLI test).
+	*/
+	setupSubscription(pattern, id) {
+		this.steps.push({
+			kind: `setupSubscription`,
+			pattern,
+			id
+		});
+		return this;
+	}
+	/**
+	* Verify internal server state via direct API call.
+	* Provides an extra level of guarantee beyond CLI output.
+	*/
+	verifyApi(fn) {
+		this.steps.push({
+			kind: `verifyApi`,
+			fn
+		});
+		return this;
+	}
+	/**
+	* Execute a CLI command. Args are passed directly to the binary.
+	*/
+	exec(...args) {
+		this.steps.push({
+			kind: `exec`,
+			args
+		});
+		return this;
+	}
+	/**
+	* Assert stdout of the last exec matches a regex.
+	*/
+	expectStdout(pattern) {
+		this.steps.push({
+			kind: `expectStdout`,
+			pattern
+		});
+		return this;
+	}
+	/**
+	* Assert stdout of the last exec does NOT match a regex.
+	*/
+	expectStdoutNot(pattern) {
+		this.steps.push({
+			kind: `expectStdoutNot`,
+			pattern
+		});
+		return this;
+	}
+	/**
+	* Assert stdout contains exact text.
+	*/
+	expectStdoutContains(text) {
+		this.steps.push({
+			kind: `expectStdoutContains`,
+			text
+		});
+		return this;
+	}
+	/**
+	* Assert stderr of the last exec matches a regex.
+	*/
+	expectStderr(pattern) {
+		this.steps.push({
+			kind: `expectStderr`,
+			pattern
+		});
+		return this;
+	}
+	/**
+	* Assert exit code of the last exec.
+	*/
+	expectExitCode(code) {
+		this.steps.push({
+			kind: `expectExitCode`,
+			code
+		});
+		return this;
+	}
+	/**
+	* Parse stdout as JSON and run a check function.
+	*/
+	expectJson(check) {
+		this.steps.push({
+			kind: `expectJson`,
+			check
+		});
+		return this;
+	}
+	/**
+	* Custom assertion on the last exec result.
+	*/
+	custom(fn) {
+		this.steps.push({
+			kind: `custom`,
+			fn
+		});
+		return this;
+	}
+	/**
+	* Wait for a given number of milliseconds.
+	*/
+	wait(ms) {
+		this.steps.push({
+			kind: `wait`,
+			ms
+		});
+		return this;
+	}
+	/**
+	* Run all steps sequentially, returning the history.
+	*/
+	async run() {
+		const history = [];
+		let lastResult = {
+			stdout: ``,
+			stderr: ``,
+			exitCode: 0
+		};
+		const receiver = await startNoopReceiver();
+		try {
+			for (const step of this.steps) switch (step.kind) {
+				case `setupType`: {
+					const res = await fetch(`${this.baseUrl}/_electric/entity-types`, {
+						method: `POST`,
+						headers: { "content-type": `application/json` },
+						body: JSON.stringify(step.registration)
+					});
+					(0, vitest.expect)(res.ok, `setupType failed: ${res.status}`).toBe(true);
+					break;
+				}
+				case `setupSubscription`: {
+					const res = await fetch(subscriptionEndpoint(this.baseUrl, step.id), {
+						method: `PUT`,
+						headers: { "content-type": `application/json` },
+						body: JSON.stringify({
+							type: `webhook`,
+							pattern: subscriptionPattern(step.pattern),
+							webhook: { url: receiver.url }
+						})
+					});
+					(0, vitest.expect)(res.status, `setupSubscription failed: ${res.status}`).toBeLessThan(300);
+					break;
+				}
+				case `verifyApi`: {
+					await step.fn(this.baseUrl);
+					break;
+				}
+				case `exec`: {
+					lastResult = await execCli(this.cliBin, step.args, this.baseUrl);
+					history.push({
+						command: step.args,
+						stdout: lastResult.stdout,
+						stderr: lastResult.stderr,
+						exitCode: lastResult.exitCode
+					});
+					break;
+				}
+				case `expectStdout`: {
+					(0, vitest.expect)(lastResult.stdout, `stdout should match ${step.pattern}`).toMatch(step.pattern);
+					break;
+				}
+				case `expectStdoutNot`: {
+					(0, vitest.expect)(lastResult.stdout, `stdout should NOT match ${step.pattern}`).not.toMatch(step.pattern);
+					break;
+				}
+				case `expectStdoutContains`: {
+					(0, vitest.expect)(lastResult.stdout, `stdout should contain "${step.text}"`).toContain(step.text);
+					break;
+				}
+				case `expectStderr`: {
+					(0, vitest.expect)(lastResult.stderr, `stderr should match ${step.pattern}`).toMatch(step.pattern);
+					break;
+				}
+				case `expectExitCode`: {
+					if (lastResult.exitCode !== step.code) {
+						const detail = lastResult.stderr || lastResult.stdout || `(no output)`;
+						(0, vitest.expect)(lastResult.exitCode, `exit code should be ${step.code}, output: ${detail.slice(0, 200)}`).toBe(step.code);
+					}
+					break;
+				}
+				case `expectJson`: {
+					const parsed = JSON.parse(lastResult.stdout);
+					step.check(parsed);
+					break;
+				}
+				case `custom`: {
+					await step.fn(lastResult);
+					break;
+				}
+				case `wait`: {
+					await new Promise((resolve) => setTimeout(resolve, step.ms));
+					break;
+				}
+			}
+		} finally {
+			await receiver.close();
+		}
+		return history;
+	}
+};
+function execCli(bin, args, baseUrl) {
+	return new Promise((resolve) => {
+		(0, node_child_process.execFile)(`pnpm`, [
+			`exec`,
+			`tsx`,
+			bin,
+			...args
+		], {
+			env: {
+				...process.env,
+				ELECTRIC_AGENTS_URL: baseUrl,
+				ELECTRIC_AGENTS_IDENTITY: `test-user@test-host`
+			},
+			timeout: 3e4
+		}, (error, stdout, stderr) => {
+			resolve({
+				stdout: stdout.toString(),
+				stderr: stderr.toString(),
+				exitCode: error ? typeof error.code === `number` ? error.code : 1 : 0
+			});
+		});
+	});
+}
+function cliTest(baseUrl, cliBin) {
+	return new CliScenario(baseUrl, cliBin);
+}
+function startNoopReceiver() {
+	return new Promise((resolve) => {
+		const server = (0, node_http.createServer)((_req, res) => {
+			_req.on(`data`, () => {});
+			_req.on(`end`, () => {
+				res.writeHead(200, { "content-type": `application/json` });
+				res.end(JSON.stringify({ ok: true }));
+			});
+		});
+		server.listen(0, `127.0.0.1`, () => {
+			const addr = server.address();
+			if (!addr || typeof addr === `string`) throw new Error(`Failed to start noop receiver`);
+			resolve({
+				url: `http://127.0.0.1:${addr.port}`,
+				close: () => new Promise((res) => {
+					server.close(() => res());
+				})
+			});
+		});
+	});
+}
+
+//#endregion
+//#region src/electric-agents-tests.ts
+async function electricAgentsFetch(baseUrl, path, opts = {}) {
+	return fetch(`${baseUrl}${routeControlPlanePath(path)}`, {
+		...opts,
+		headers: {
+			"content-type": `application/json`,
+			...opts.headers
+		}
+	});
+}
+function routeControlPlanePath(path) {
+	const pathname = path.split(`?`, 1)[0];
+	if (pathname.startsWith(`/_electric/`) || isEntityStreamPath(pathname)) return path;
+	return `/_electric/entities${path}`;
+}
+function isEntityStreamPath(pathname) {
+	const segments = pathname.split(`/`).filter(Boolean);
+	const lastSegment = segments.at(-1);
+	return segments.length >= 3 && (lastSegment === `main` || lastSegment === `error`);
+}
+async function pollEntityStatus(baseUrl, entityUrl, statuses, timeoutMs = 8e3) {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		const res = await fetch(`${baseUrl}${routeControlPlanePath(entityUrl)}`);
+		(0, vitest.expect)(res.status).toBe(200);
+		const entity = await res.json();
+		if (statuses.includes(String(entity.status))) return entity;
+		await new Promise((resolve) => setTimeout(resolve, 100));
+	}
+	throw new Error(`Timed out waiting for ${entityUrl} to reach one of: ${statuses.join(`, `)}`);
+}
+function runElectricAgentsConformanceTests(config) {
+	(0, vitest.describe)(`Electric Agents Spawn`, () => {
+		(0, vitest.test)(`spawn creates entity and streams`, () => electricAgents(config.baseUrl).subscription(`/spawn-test-agent/**`, `spawn-test-sub`).registerType({
+			name: `spawn-test-agent`,
+			description: `Test entity type for spawn`,
+			creation_schema: { type: `object` }
+		}).spawn(`spawn-test-agent`, `entity-1`).expectStatus(`running`).custom(async (ctx) => {
+			const mainRes = await fetch(`${ctx.baseUrl}${ctx.currentEntityStreams.main}`, { method: `HEAD` });
+			(0, vitest.expect)(mainRes.status).toBe(200);
+			const errorRes = await fetch(`${ctx.baseUrl}${ctx.currentEntityStreams.error}`, { method: `HEAD` });
+			(0, vitest.expect)(errorRes.status).toBe(200);
+		}).run());
+		(0, vitest.test)(`spawn at unregistered type returns UNKNOWN_ENTITY_TYPE`, () => electricAgents(config.baseUrl).custom(async (ctx) => {
+			const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`/unregistered/entity-1`)}`, {
+				method: `PUT`,
+				headers: { "content-type": `application/json` },
+				body: JSON.stringify({})
+			});
+			(0, vitest.expect)(res.status).toBe(404);
+			const body = await res.json();
+			(0, vitest.expect)(body.error.code).toBe(`UNKNOWN_ENTITY_TYPE`);
+		}).skipInvariants().run());
+		(0, vitest.test)(`spawn rejects duplicate URL`, () => electricAgents(config.baseUrl).subscription(`/dup-test-agent/**`, `dup-test-sub`).registerType({
+			name: `dup-test-agent`,
+			description: `Test entity type for duplicate spawn`,
+			creation_schema: { type: `object` }
+		}).spawn(`dup-test-agent`, `entity-1`).expectSpawnError(`/dup-test-agent/entity-1`, `DUPLICATE_URL`, 409).run());
+		(0, vitest.test)(`spawn without type succeeds`, () => electricAgents(config.baseUrl).subscription(`/notype-test-agent/**`, `notype-test-sub`).registerType({
+			name: `notype-test-agent`,
+			description: `Test entity type for typeless spawn`,
+			creation_schema: { type: `object` }
+		}).spawn(`notype-test-agent`, `entity-1`).expectStatus(`running`).custom(async (ctx) => {
+			const res = await electricAgentsFetch(ctx.baseUrl, ctx.currentEntityUrl);
+			const entity = await res.json();
+			(0, vitest.expect)(entity.type).toBe(`notype-test-agent`);
+		}).run());
+	});
+	(0, vitest.describe)(`Electric Agents Send`, () => {
+		(0, vitest.test)(`send delivers State Protocol message event`, () => electricAgents(config.baseUrl).subscription(`/send-test-worker/**`, `send-test-sub`).registerType({
+			name: `send-test-worker`,
+			description: `Test entity type for send`,
+			creation_schema: { type: `object` }
+		}).spawn(`send-test-worker`, `entity-1`).send({ task: `hello` }, { from: `user-1` }).expectWebhook().respondDone().readStream().expectStreamContains(`message_received`).custom(async (ctx) => {
+			const envelope = ctx.lastStreamMessages.find((m) => m.type === `message_received`);
+			(0, vitest.expect)(envelope.type).toBe(`message_received`);
+			(0, vitest.expect)(envelope.key).toBeDefined();
+			(0, vitest.expect)(envelope.value?.from).toBe(`user-1`);
+			(0, vitest.expect)(envelope.value?.payload).toEqual({ task: `hello` });
+		}).run());
+		(0, vitest.test)(`send triggers webhook with entity context`, () => electricAgents(config.baseUrl).subscription(`/webhook-ctx-agent/**`, `webhook-ctx-sub`).registerType({
+			name: `webhook-ctx-agent`,
+			description: `Test entity type for webhook context`,
+			creation_schema: { type: `object` }
+		}).spawn(`webhook-ctx-agent`, `entity-1`).send({ ping: true }, { from: `test` }).expectWebhook().expectEntityContext({ type: `webhook-ctx-agent` }).respondDone().run());
+		(0, vitest.test)(`send to nonexistent entity returns 404`, () => electricAgents(config.baseUrl).custom(async (ctx) => {
+			const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`/nonexistent-type/nonexistent-id/send`)}`, {
+				method: `POST`,
+				headers: { "content-type": `application/json` },
+				body: JSON.stringify({
+					from: `test`,
+					payload: {}
+				})
+			});
+			(0, vitest.expect)(res.status).toBe(404);
+		}).skipInvariants().run());
+		(0, vitest.test)(`multiple sends preserve order in stream`, () => {
+			const id = Date.now();
+			return electricAgents(config.baseUrl).subscription(`/order-test-agent-${id}/**`, `order-test-sub-${id}`).registerType({
+				name: `order-test-agent-${id}`,
+				description: `Test entity type for ordering`,
+				creation_schema: { type: `object` }
+			}).spawn(`order-test-agent-${id}`, `entity-1`).send({ seq: 1 }, { from: `test` }).expectWebhook().respondDone().send({ seq: 2 }, { from: `test` }).expectWebhook().respondDone().send({ seq: 3 }, { from: `test` }).expectWebhook().respondDone().readStream().custom(async (ctx) => {
+				const msgs = ctx.lastStreamMessages.filter((m) => m.type === `message_received`);
+				(0, vitest.expect)(msgs.length).toBe(3);
+				for (let i = 0; i < 3; i++) (0, vitest.expect)(msgs[i].value?.payload).toEqual({ seq: i + 1 });
+			}).run();
+		});
+		(0, vitest.test)(`send without from is rejected`, () => electricAgents(config.baseUrl).subscription(`/nofrom-test-agent/**`, `nofrom-test-sub`).registerType({
+			name: `nofrom-test-agent`,
+			description: `Test entity type for send without from`,
+			creation_schema: { type: `object` }
+		}).spawn(`nofrom-test-agent`, `entity-1`).custom(async (ctx) => {
+			const res = await electricAgentsFetch(ctx.baseUrl, `${ctx.currentEntityUrl}/send`, {
+				method: `POST`,
+				body: JSON.stringify({ payload: { hello: true } })
+			});
+			(0, vitest.expect)(res.status).toBe(400);
+			const body = await res.json();
+			(0, vitest.expect)(body.error.code).toBe(`INVALID_REQUEST`);
+		}).run());
+	});
+	(0, vitest.describe)(`Electric Agents List`, () => {
+		(0, vitest.test)(`ps lists entities`, () => electricAgents(config.baseUrl).subscription(`/ps-test-worker/**`, `ps-test-worker-sub`).subscription(`/ps-test-agent/**`, `ps-test-agent-sub`).registerType({
+			name: `ps-test-worker`,
+			description: `Test worker type for ps`,
+			creation_schema: { type: `object` }
+		}).registerType({
+			name: `ps-test-agent`,
+			description: `Test agent type for ps`,
+			creation_schema: { type: `object` }
+		}).spawn(`ps-test-worker`, `entity-1`).spawn(`ps-test-agent`, `entity-2`).list().expectListCount({ min: 2 }).list({ type: `ps-test-agent` }).custom(async (ctx) => {
+			(0, vitest.expect)(ctx.lastListResult.every((e) => e.type === `ps-test-agent`)).toBe(true);
+		}).run());
+		(0, vitest.test)(`list with status filter`, () => {
+			return electricAgents(config.baseUrl).subscription(`/status-filter-agent/**`, `status-filter-sub`).registerType({
+				name: `status-filter-agent`,
+				description: `Test entity type for status filter`,
+				creation_schema: { type: `object` }
+			}).spawn(`status-filter-agent`, `entity-1`).spawn(`status-filter-agent`, `entity-2`).kill().list({ status: `stopped` }).custom(async (ctx) => {
+				(0, vitest.expect)(ctx.lastListResult.every((e) => e.status === `stopped`)).toBe(true);
+			}).list({ status: `running` }).custom(async (ctx) => {
+				(0, vitest.expect)(ctx.lastListResult.every((e) => [`running`, `idle`].includes(e.status))).toBe(true);
+			}).run();
+		});
+		(0, vitest.test)(`get nonexistent entity returns 404`, () => electricAgents(config.baseUrl).custom(async (ctx) => {
+			const res = await electricAgentsFetch(ctx.baseUrl, `/does-not-exist-type/does-not-exist`);
+			(0, vitest.expect)(res.status).toBe(404);
+		}).skipInvariants().run());
+	});
+	(0, vitest.describe)(`Electric Agents Kill`, () => {
+		(0, vitest.test)(`kill stops entity and rejects further sends`, () => electricAgents(config.baseUrl).subscription(`/kill-test-agent/**`, `kill-test-sub`).registerType({
+			name: `kill-test-agent`,
+			description: `Test entity type for kill`,
+			creation_schema: { type: `object` }
+		}).spawn(`kill-test-agent`, `entity-1`).kill().expectStatus(`stopped`).expectSendError(`NOT_RUNNING`, 409).run());
+		(0, vitest.test)(`stream data persists after kill`, () => electricAgents(config.baseUrl).subscription(`/kill-persist-agent/**`, `kill-persist-sub`).registerType({
+			name: `kill-persist-agent`,
+			description: `Test entity type for kill persistence`,
+			creation_schema: { type: `object` }
+		}).spawn(`kill-persist-agent`, `entity-1`).send({ before: `kill` }, { from: `test` }).expectWebhook().respondDone().kill().readStream().expectStreamContains(`message_received`).custom(async (ctx) => {
+			const msgs = ctx.lastStreamMessages;
+			const msgReceived = msgs.find((m) => m.type === `message_received`);
+			(0, vitest.expect)(msgReceived.value?.payload).toEqual({ before: `kill` });
+			const stopped = msgs.find((m) => m.type === `entity_stopped`);
+			(0, vitest.expect)(stopped).toBeDefined();
+		}).run());
+		vitest.test.skip(`multiple entities under same subscription`, () => {
+			let firstEntityUrl = null;
+			let secondEntityUrl = null;
+			return electricAgents(config.baseUrl).subscription(`/multi-test-worker/**`, `multi-test-sub`).registerType({
+				name: `multi-test-worker`,
+				description: `Test entity type for multi-entity`,
+				creation_schema: { type: `object` }
+			}).spawn(`multi-test-worker`, `entity-1`).custom(async (ctx) => {
+				firstEntityUrl = ctx.currentEntityUrl;
+			}).spawn(`multi-test-worker`, `entity-2`).custom(async (ctx) => {
+				secondEntityUrl = ctx.currentEntityUrl;
+			}).custom(async (ctx) => {
+				const res = await electricAgentsFetch(ctx.baseUrl, firstEntityUrl, { method: `DELETE` });
+				(0, vitest.expect)(res.status).toBe(200);
+				ctx.history.push({
+					type: `entity_killed`,
+					entityUrl: firstEntityUrl
+				});
+			}).custom(async (ctx) => {
+				const res1 = await electricAgentsFetch(ctx.baseUrl, firstEntityUrl);
+				const e1 = await res1.json();
+				(0, vitest.expect)(e1.status).toBe(`stopped`);
+				const res2 = await electricAgentsFetch(ctx.baseUrl, secondEntityUrl);
+				const e2 = await res2.json();
+				(0, vitest.expect)([`running`, `idle`]).toContain(e2.status);
+			}).run();
+		});
+	});
+	(0, vitest.describe)(`Electric Agents E2E`, () => {
+		(0, vitest.test)(`full lifecycle: spawn → send → webhook → read → kill`, () => electricAgents(config.baseUrl).subscription(`/e2e-test-agent/**`, `e2e-test-sub`).registerType({
+			name: `e2e-test-agent`,
+			description: `Test entity type for E2E lifecycle`,
+			creation_schema: { type: `object` }
+		}).spawn(`e2e-test-agent`, `entity-1`).expectStatus(`running`).send({ task: `do-something` }, { from: `user-1` }).expectWebhook().expectEntityContext({ type: `e2e-test-agent` }).respondDone().readStream().expectStreamContains(`message_received`).kill().custom(async (ctx) => {
+			const entity = await pollEntityStatus(ctx.baseUrl, ctx.currentEntityUrl, [`stopped`]);
+			(0, vitest.expect)(entity.status).toBe(`stopped`);
+		}).expectSendError(`NOT_RUNNING`, 409).run());
+	});
+	(0, vitest.describe)(`Electric Agents Entity Type Registration`, () => {
+		(0, vitest.test)(`register entity type`, () => electricAgents(config.baseUrl).subscription(`/reg-type-test/**`, `reg-type-test-sub`).registerType({
+			name: `reg-full-type-${Date.now()}`,
+			description: `A fully-specified entity type`,
+			creation_schema: {
+				type: `object`,
+				properties: { name: { type: `string` } }
+			},
+			input_schemas: { query: {
+				type: `object`,
+				properties: { text: { type: `string` } },
+				required: [`text`]
+			} },
+			output_schemas: { result: {
+				type: `object`,
+				properties: { answer: { type: `string` } }
+			} }
+		}).custom(async (ctx) => {
+			const typeEvents = ctx.history.filter((h) => h.type === `entity_type_registered`);
+			(0, vitest.expect)(typeEvents.length).toBeGreaterThanOrEqual(1);
+			const registered = typeEvents[0];
+			(0, vitest.expect)(registered.type).toBe(`entity_type_registered`);
+		}).run());
+		(0, vitest.test)(`list entity types`, () => {
+			const suffix = Date.now();
+			return electricAgents(config.baseUrl).subscription(`/list-types-test/**`, `list-types-sub`).registerType({
+				name: `list-type-a-${suffix}`,
+				description: `First type for listing`,
+				creation_schema: { type: `object` }
+			}).registerType({
+				name: `list-type-b-${suffix}`,
+				description: `Second type for listing`,
+				creation_schema: { type: `object` }
+			}).listTypes().custom(async (ctx) => {
+				(0, vitest.expect)(ctx.lastTypeListResult).toBeDefined();
+				const names = ctx.lastTypeListResult.map((t) => t.name);
+				(0, vitest.expect)(names).toContain(`list-type-a-${suffix}`);
+				(0, vitest.expect)(names).toContain(`list-type-b-${suffix}`);
+			}).run();
+		});
+		(0, vitest.test)(`inspect entity type`, () => {
+			const typeName = `inspect-type-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/inspect-type-test/**`, `inspect-type-sub`).registerType({
+				name: typeName,
+				description: `Type for inspection`,
+				creation_schema: {
+					type: `object`,
+					properties: { x: { type: `number` } }
+				},
+				input_schemas: { ping: {
+					type: `object`,
+					properties: { msg: { type: `string` } }
+				} }
+			}).inspectType(typeName).custom(async (ctx) => {
+				(0, vitest.expect)(ctx.lastTypeResult).toBeDefined();
+				(0, vitest.expect)(ctx.lastTypeResult.name).toBe(typeName);
+				(0, vitest.expect)(ctx.lastTypeResult.creation_schema).toBeDefined();
+				(0, vitest.expect)(ctx.lastTypeResult.inbox_schemas).toBeDefined();
+			}).run();
+		});
+		(0, vitest.test)(`delete entity type`, () => {
+			const typeName = `delete-type-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/delete-type-test/**`, `delete-type-sub`).registerType({
+				name: typeName,
+				description: `Type to be deleted`,
+				creation_schema: { type: `object` }
+			}).deleteType(typeName).expectTypeNotExists(typeName).run();
+		});
+		(0, vitest.test)(`register upserts duplicate name`, () => {
+			const typeName = `dup-type-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/dup-type-test/**`, `dup-type-sub`).registerType({
+				name: typeName,
+				description: `First registration`,
+				creation_schema: { type: `object` }
+			}).custom(async (ctx) => {
+				const res = await fetch(`${ctx.baseUrl}/_electric/entity-types`, {
+					method: `POST`,
+					headers: { "content-type": `application/json` },
+					body: JSON.stringify({
+						name: typeName,
+						description: `Duplicate registration`,
+						creation_schema: { type: `object` }
+					})
+				});
+				(0, vitest.expect)(res.status).toBe(201);
+				const body = await res.json();
+				(0, vitest.expect)(body.name).toBe(typeName);
+				(0, vitest.expect)(body.description).toBe(`Duplicate registration`);
+				(0, vitest.expect)(body.revision).toBe(2);
+			}).run();
+		});
+		(0, vitest.test)(`register rejects missing required fields`, () => electricAgents(config.baseUrl).custom(async (ctx) => {
+			const res = await fetch(`${ctx.baseUrl}/_electric/entity-types`, {
+				method: `POST`,
+				headers: { "content-type": `application/json` },
+				body: JSON.stringify({})
+			});
+			(0, vitest.expect)([400, 422]).toContain(res.status);
+		}).skipInvariants().run());
+		(0, vitest.test)(`register entity type without creation_schema`, () => {
+			const typeName = `minimal-type-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/minimal-type-test/**`, `minimal-type-sub`).registerType({
+				name: typeName,
+				description: `A minimal entity type with no schemas`
+			}).inspectType(typeName).custom(async (ctx) => {
+				(0, vitest.expect)(ctx.lastTypeResult).toBeDefined();
+				(0, vitest.expect)(ctx.lastTypeResult.name).toBe(typeName);
+				(0, vitest.expect)(ctx.lastTypeResult.description).toBe(`A minimal entity type with no schemas`);
+			}).run();
+		});
+	});
+	(0, vitest.describe)(`Electric Agents Typed Spawn`, () => {
+		(0, vitest.test)(`typed spawn validates creation_schema`, () => {
+			const typeName = `typed-spawn-valid-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `typed-spawn-sub`).registerType({
+				name: typeName,
+				description: `Type with creation schema`,
+				creation_schema: {
+					type: `object`,
+					properties: { topic: { type: `string` } },
+					required: [`topic`]
+				}
+			}).spawn(typeName, `entity-1`, { args: { topic: `CRDTs` } }).expectStatus(`running`).run();
+		});
+		(0, vitest.test)(`typed spawn rejects invalid args (C10)`, () => {
+			const typeName = `typed-spawn-invalid-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `typed-spawn-inv-sub`).registerType({
+				name: typeName,
+				description: `Type with strict creation schema`,
+				creation_schema: {
+					type: `object`,
+					properties: { topic: { type: `string` } },
+					required: [`topic`]
+				}
+			}).expectSpawnSchemaError(typeName, `bad-entity-1`, { args: { invalid: true } }).run();
+		});
+		(0, vitest.test)(`typed spawn at unregistered type returns UNKNOWN_ENTITY_TYPE (C9)`, () => electricAgents(config.baseUrl).custom(async (ctx) => {
+			const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`/nonexistent/should-fail`)}`, {
+				method: `PUT`,
+				headers: { "content-type": `application/json` },
+				body: JSON.stringify({})
+			});
+			(0, vitest.expect)(res.status).toBe(404);
+			const body = await res.json();
+			(0, vitest.expect)(body.error.code).toBe(`UNKNOWN_ENTITY_TYPE`);
+		}).skipInvariants().run());
+		(0, vitest.test)(`spawn with parent`, () => {
+			const typeName = `parent-spawn-${Date.now()}`;
+			let parentUrl = null;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `parent-spawn-sub`).registerType({
+				name: typeName,
+				description: `Type for parent-child test`,
+				creation_schema: { type: `object` }
+			}).spawn(typeName, `parent-entity`).custom(async (ctx) => {
+				parentUrl = ctx.currentEntityUrl;
+			}).custom(async (ctx) => {
+				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`/${typeName}/child-entity`)}`, {
+					method: `PUT`,
+					headers: { "content-type": `application/json` },
+					body: JSON.stringify({ parent: parentUrl })
+				});
+				(0, vitest.expect)(res.status).toBe(201);
+				const entity = await res.json();
+				ctx.currentEntityUrl = entity.url;
+				ctx.currentEntityStreams = entity.streams;
+				ctx.currentWriteToken = null;
+				ctx.history.push({
+					type: `entity_spawned`,
+					entityUrl: entity.url,
+					entityType: typeName,
+					status: entity.status,
+					streams: entity.streams,
+					parent: parentUrl
+				});
+			}).expectStatus(`running`).run();
+		});
+		(0, vitest.test)(`spawn with parent rejects missing parent`, () => {
+			const typeName = `orphan-spawn-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `orphan-spawn-sub`).registerType({
+				name: typeName,
+				description: `Type for orphan spawn test`,
+				creation_schema: { type: `object` }
+			}).custom(async (ctx) => {
+				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`/${typeName}/orphan-entity`)}`, {
+					method: `PUT`,
+					headers: { "content-type": `application/json` },
+					body: JSON.stringify({ parent: `/nonexistent/parent` })
+				});
+				(0, vitest.expect)([
+					400,
+					404,
+					422
+				]).toContain(res.status);
+			}).run();
+		});
+		(0, vitest.test)(`spawn with explicit tags sets tags`, () => {
+			const typeName = `tags-spawn-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `meta-spawn-sub`).registerType({
+				name: typeName,
+				description: `Type for tag spawn test`
+			}).spawn(typeName, `inst-1`, { tags: {
+				color: `blue`,
+				count: `42`
+			} }).custom(async (ctx) => {
+				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(ctx.currentEntityUrl)}`);
+				const entity = await res.json();
+				const tags = entity.tags;
+				(0, vitest.expect)(tags.color).toBe(`blue`);
+				(0, vitest.expect)(tags.count).toBe(`42`);
+			}).run();
+		});
+		(0, vitest.test)(`spawn rejects non-string tags`, () => {
+			const id = Date.now();
+			const typeName = `tags-invalid-spawn-${id}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `tags-invalid-spawn-sub-${id}`).registerType({
+				name: typeName,
+				description: `Type with string-only tags`
+			}).custom(async (ctx) => {
+				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`/${typeName}/should-fail`)}`, {
+					method: `PUT`,
+					headers: { "content-type": `application/json` },
+					body: JSON.stringify({ tags: { wrong: 123 } })
+				});
+				(0, vitest.expect)(res.status).toBe(400);
+			}).run();
+		});
+		(0, vitest.test)(`spawn without explicit tags defaults to empty tags`, () => {
+			const typeName = `tags-default-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `tags-default-sub`).registerType({
+				name: typeName,
+				description: `Type with default empty tags`
+			}).spawn(typeName, `entity-1`).custom(async (ctx) => {
+				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(ctx.currentEntityUrl)}`);
+				const entity = await res.json();
+				(0, vitest.expect)(entity.tags).toEqual({});
+			}).run();
+		});
+	});
+	(0, vitest.describe)(`Electric Agents Schema Validation Gates`, () => {
+		(0, vitest.test)(`send validates input_schemas (C11)`, () => {
+			const typeName = `send-schema-valid-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `send-schema-sub`).registerType({
+				name: typeName,
+				description: `Type with input schemas`,
+				creation_schema: { type: `object` },
+				input_schemas: { query: {
+					type: `object`,
+					properties: { text: { type: `string` } },
+					required: [`text`]
+				} }
+			}).spawn(typeName, `entity-1`).send({ text: `hello` }, {
+				from: `user`,
+				type: `query`
+			}).expectWebhook().respondDone().run();
+		});
+		(0, vitest.test)(`send rejects invalid typed message (C11)`, () => {
+			const typeName = `send-schema-inv-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `send-schema-inv-sub`).registerType({
+				name: typeName,
+				description: `Type with strict input schemas`,
+				creation_schema: { type: `object` },
+				input_schemas: { query: {
+					type: `object`,
+					properties: { text: { type: `string` } },
+					required: [`text`]
+				} }
+			}).spawn(typeName, `entity-1`).expectSendSchemaError({ invalid: true }, {
+				from: `user`,
+				type: `query`
+			}).run();
+		});
+		(0, vitest.test)(`send rejects unknown message type (C13)`, () => {
+			const typeName = `send-unknown-type-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `send-unknown-sub`).registerType({
+				name: typeName,
+				description: `Type with defined input schemas`,
+				creation_schema: { type: `object` },
+				input_schemas: { query: {
+					type: `object`,
+					properties: { text: { type: `string` } },
+					required: [`text`]
+				} }
+			}).spawn(typeName, `entity-1`).expectSendUnknownType({ text: `hi` }, {
+				from: `user`,
+				type: `unknown_type`
+			}).run();
+		});
+		(0, vitest.test)(`send without type when no input_schemas accepts any`, () => {
+			const typeName = `send-no-schemas-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `send-noschema-sub`).registerType({
+				name: typeName,
+				description: `Type without input schemas`,
+				creation_schema: { type: `object` }
+			}).spawn(typeName, `entity-1`).send({ anything: `goes` }, { from: `user` }).expectWebhook().respondDone().run();
+		});
+		(0, vitest.test)(`send with empty input_schemas rejects all`, () => {
+			const typeName = `send-empty-schemas-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `send-empty-sub`).registerType({
+				name: typeName,
+				description: `Type with empty input schemas`,
+				creation_schema: { type: `object` },
+				input_schemas: {}
+			}).spawn(typeName, `entity-1`).expectSendUnknownType({ text: `anything` }, {
+				from: `user`,
+				type: `some_type`
+			}).run();
+		});
+		vitest.test.skip(`write appends event to entity stream`, () => {
+			const typeName = `write-append-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `write-append-sub`).registerType({
+				name: typeName,
+				description: `Type for write test`,
+				creation_schema: { type: `object` },
+				output_schemas: { research_result: {
+					type: `object`,
+					properties: { findings: {
+						type: `array`,
+						items: { type: `string` }
+					} }
+				} }
+			}).spawn(typeName, `entity-1`).write({ findings: [`test`] }, { type: `research_result` }).readStream().expectStreamContains(`research_result`).run();
+		});
+		vitest.test.skip(`write validates output_schemas (C12)`, () => {
+			const typeName = `write-schema-inv-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `write-schema-sub`).registerType({
+				name: typeName,
+				description: `Type with strict output schemas`,
+				creation_schema: { type: `object` },
+				output_schemas: { result: {
+					type: `object`,
+					properties: { value: { type: `number` } },
+					required: [`value`]
+				} }
+			}).spawn(typeName, `entity-1`).expectWriteSchemaError({ wrong: `type` }, { type: `result` }).run();
+		});
+		vitest.test.skip(`write rejects unknown event type (C14)`, () => {
+			const typeName = `write-unknown-type-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `write-unknown-sub`).registerType({
+				name: typeName,
+				description: `Type with defined output schemas`,
+				creation_schema: { type: `object` },
+				output_schemas: { result: {
+					type: `object`,
+					properties: { value: { type: `number` } }
+				} }
+			}).spawn(typeName, `entity-1`).expectWriteUnknownType({ data: `test` }, { type: `unknown_event` }).run();
+		});
+		vitest.test.skip(`write without type when no output_schemas accepts any`, () => {
+			const typeName = `write-no-schemas-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `write-noschema-sub`).registerType({
+				name: typeName,
+				description: `Type without output schemas`,
+				creation_schema: { type: `object` }
+			}).spawn(typeName, `entity-1`).write({ anything: `goes` }).run();
+		});
+		vitest.test.skip(`write to stopped entity rejected`, () => {
+			const typeName = `write-stopped-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `write-stopped-sub`).registerType({
+				name: typeName,
+				description: `Type for stopped write test`,
+				creation_schema: { type: `object` }
+			}).spawn(typeName, `entity-1`).kill().custom(async (ctx) => {
+				const writeHeaders = { "content-type": `application/json` };
+				if (ctx.currentWriteToken) writeHeaders[`authorization`] = `Bearer ${ctx.currentWriteToken}`;
+				const res = await fetch(`${ctx.baseUrl}${ctx.currentEntityUrl}/main`, {
+					method: `POST`,
+					headers: writeHeaders,
+					body: JSON.stringify({
+						type: `test`,
+						key: `stopped-test`,
+						value: { should: `fail` },
+						headers: { operation: `insert` }
+					})
+				});
+				(0, vitest.expect)(res.status).toBe(409);
+			}).run();
+		});
+		vitest.test.skip(`write accepts State Protocol format (type/key/value/headers)`, () => {
+			const typeName = `sp-write-agent-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `sp-write-sub`).registerType({
+				name: typeName,
+				description: `Test State Protocol write format`
+			}).spawn(typeName, `sp-w-1`).writeStateProtocol({
+				type: `text`,
+				key: `msg-1`,
+				value: { status: `streaming` },
+				headers: { operation: `insert` }
+			}).readStream().custom(async (ctx) => {
+				const events = ctx.lastStreamMessages;
+				const textEvent = events.find((e) => e.type === `text` && e.key === `msg-1`);
+				(0, vitest.expect)(textEvent).toBeDefined();
+				(0, vitest.expect)(textEvent.value.status).toBe(`streaming`);
+				(0, vitest.expect)(textEvent.headers.operation).toBe(`insert`);
+			}).kill().run();
+		});
+		vitest.test.skip(`update tags`, () => {
+			const typeName = `tags-update-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `tags-update-sub`).registerType({
+				name: typeName,
+				description: `Type for tag update test`,
+				creation_schema: { type: `object` }
+			}).spawn(typeName, `entity-1`).setTags({
+				owner: `test-user`,
+				priority: `high`
+			}).expectTags({
+				owner: `test-user`,
+				priority: `high`
+			}).run();
+		});
+		vitest.test.skip(`tag write rejects non-string values`, () => {
+			const typeName = `tags-invalid-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `tags-invalid-sub`).registerType({
+				name: typeName,
+				description: `Type with string-only tags`,
+				creation_schema: { type: `object` }
+			}).spawn(typeName, `entity-1`).custom(async (ctx) => {
+				const tagHeaders = { "content-type": `application/json` };
+				if (ctx.currentWriteToken) tagHeaders[`authorization`] = `Bearer ${ctx.currentWriteToken}`;
+				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`${ctx.currentEntityUrl}/tags/owner`)}`, {
+					method: `POST`,
+					headers: tagHeaders,
+					body: JSON.stringify({ value: 123 })
+				});
+				(0, vitest.expect)(res.status).toBe(400);
+			}).run();
+		});
+		vitest.test.skip(`tag delete removes a key`, () => {
+			const typeName = `tags-delete-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `tags-delete-sub`).registerType({
+				name: typeName,
+				description: `Type for tag delete test`,
+				creation_schema: { type: `object` }
+			}).spawn(typeName, `entity-1`).setTags({
+				owner: `test-user`,
+				priority: `high`
+			}).custom(async (ctx) => {
+				const tagHeaders = {};
+				if (ctx.currentWriteToken) tagHeaders.authorization = `Bearer ${ctx.currentWriteToken}`;
+				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`${ctx.currentEntityUrl}/tags/priority`)}`, {
+					method: `DELETE`,
+					headers: tagHeaders
+				});
+				(0, vitest.expect)(res.status).toBe(200);
+			}).expectTags({ owner: `test-user` }).run();
+		});
+		vitest.test.skip(`tag writes merge by key`, () => {
+			const typeName = `tags-merge-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `tags-merge-sub`).registerType({
+				name: typeName,
+				description: `Type for tag merge test`,
+				creation_schema: { type: `object` }
+			}).spawn(typeName, `entity-1`).setTags({
+				key1: `value1`,
+				key2: `value2`
+			}).setTags({
+				key2: `updated`,
+				key3: `value3`
+			}).expectTags({
+				key1: `value1`,
+				key2: `updated`,
+				key3: `value3`
+			}).run();
+		});
+	});
+	(0, vitest.describe)(`Electric Agents Schema Evolution`, () => {
+		(0, vitest.test)(`amend schemas adds new message types`, () => {
+			const typeName = `amend-add-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `amend-add-sub`).registerType({
+				name: typeName,
+				description: `Type for schema amendment`,
+				creation_schema: { type: `object` },
+				input_schemas: { query: {
+					type: `object`,
+					properties: { text: { type: `string` } },
+					required: [`text`]
+				} }
+			}).amendSchemas(typeName, { input_schemas: { command: {
+				type: `object`,
+				properties: { action: { type: `string` } },
+				required: [`action`]
+			} } }).spawn(typeName, `entity-1`).send({ action: `do-it` }, {
+				from: `user`,
+				type: `command`
+			}).expectWebhook().respondDone().run();
+		});
+		(0, vitest.test)(`amend schemas rejects modifying existing keys (C16)`, () => {
+			const typeName = `amend-conflict-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `amend-conflict-sub`).registerType({
+				name: typeName,
+				description: `Type for schema conflict test`,
+				creation_schema: { type: `object` },
+				input_schemas: { query: {
+					type: `object`,
+					properties: { text: { type: `string` } },
+					required: [`text`]
+				} }
+			}).custom(async (ctx) => {
+				const res = await fetch(`${ctx.baseUrl}/_electric/entity-types/${typeName}/schemas`, {
+					method: `PATCH`,
+					headers: { "content-type": `application/json` },
+					body: JSON.stringify({ inbox_schemas: { query: {
+						type: `object`,
+						properties: { text: { type: `number` } }
+					} } })
+				});
+				(0, vitest.expect)(res.status).toBe(409);
+			}).run();
+		});
+		vitest.test.skip(`schema amendments apply to existing entities`, () => {
+			const typeName = `rev-pin-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `rev-pin-sub`).registerType({
+				name: typeName,
+				description: `Type for revision pinning test`,
+				creation_schema: { type: `object` },
+				input_schemas: { query: {
+					type: `object`,
+					properties: { text: { type: `string` } },
+					required: [`text`]
+				} }
+			}).spawn(typeName, `entity-1`).custom(async (ctx) => {
+				const res = await fetch(`${ctx.baseUrl}/_electric/entity-types/${typeName}/schemas`, {
+					method: `PATCH`,
+					headers: { "content-type": `application/json` },
+					body: JSON.stringify({ inbox_schemas: { new_command: {
+						type: `object`,
+						properties: { action: { type: `string` } }
+					} } })
+				});
+				(0, vitest.expect)(res.status).toBe(200);
+			}).custom(async (ctx) => {
+				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`${ctx.currentEntityUrl}/send`)}`, {
+					method: `POST`,
+					headers: { "content-type": `application/json` },
+					body: JSON.stringify({
+						type: `new_command`,
+						from: `user`,
+						payload: { action: `test` }
+					})
+				});
+				(0, vitest.expect)(res.status).toBe(204);
+			}).run();
+		});
+	});
+	(0, vitest.describe)(`Electric Agents Serve Endpoint`, () => {
+		(0, vitest.test)(`register type via serve endpoint`, () => {
+			const typeName = `serve-reg-${Date.now()}`;
+			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `serve-reg-sub`).registerTypeViaServe({
+				name: typeName,
+				description: `Type registered via serve endpoint`,
+				creation_schema: { type: `object` }
+			}).expectTypeExists(typeName).run();
+		});
+		(0, vitest.test)(`serve endpoint name mismatch rejected`, () => electricAgents(config.baseUrl).custom(async (ctx) => {
+			const receiver = new ServeEndpointReceiver();
+			const manifest = {
+				name: `foo`,
+				description: `Manifest says foo`,
+				creation_schema: { type: `object` }
+			};
+			await receiver.start(manifest);
+			try {
+				const res = await fetch(`${ctx.baseUrl}/_electric/entity-types`, {
+					method: `POST`,
+					headers: { "content-type": `application/json` },
+					body: JSON.stringify({
+						name: `bar`,
+						serve_endpoint: receiver.url
+					})
+				});
+				(0, vitest.expect)([
+					400,
+					409,
+					422
+				]).toContain(res.status);
+			} finally {
+				await receiver.stop();
+			}
+		}).skipInvariants().run());
+	});
+	(0, vitest.describe)(`Property-Based: Random Action Sequences`, () => {
+		const actionArb = fast_check.oneof({
+			weight: 15,
+			arbitrary: fast_check.constant(`register_type`)
+		}, {
+			weight: 5,
+			arbitrary: fast_check.constant(`delete_type`)
+		}, {
+			weight: 25,
+			arbitrary: fast_check.constant(`spawn`)
+		}, {
+			weight: 20,
+			arbitrary: fast_check.constant(`send`)
+		}, {
+			weight: 10,
+			arbitrary: fast_check.constant(`kill`)
+		}, {
+			weight: 5,
+			arbitrary: fast_check.constant(`check_status`)
+		}, {
+			weight: 5,
+			arbitrary: fast_check.constant(`list`)
+		});
+		(0, vitest.test)(`random action sequences preserve safety invariants`, async () => {
+			await fast_check.assert(fast_check.asyncProperty(fast_check.array(actionArb, {
+				minLength: 3,
+				maxLength: 12
+			}), async (actions) => {
+				const runId = `prop-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+				const baseUrl = config.baseUrl;
+				const entityUrls = [];
+				const registeredTypeNames = [];
+				const scenario = electricAgents(baseUrl);
+				let model = {
+					entityTypes: [],
+					entities: [],
+					nextEntityNum: 0
+				};
+				let entityCounter = 0;
+				for (const action of actions) {
+					const valid = enabledElectricAgentsActions(model);
+					if (!valid.includes(action)) continue;
+					switch (action) {
+						case `register_type`: {
+							const typeNum = model.entityTypes.length;
+							const typeName = `prop-type-${runId}-${typeNum}`;
+							registeredTypeNames.push(typeName);
+							scenario.subscription(`/${typeName}/**`, `prop-sub-${typeName}`);
+							scenario.registerType({
+								name: typeName,
+								description: `Property-based test type ${typeNum}`,
+								creation_schema: { type: `object` }
+							});
+							model = applyElectricAgentsAction(model, `register_type`);
+							break;
+						}
+						case `delete_type`: {
+							const runningModelTypeNames = new Set(model.entities.filter((e) => e.status === `running`).map((e) => e.typeName));
+							const deletableIndices = model.entityTypes.map((t, i) => !runningModelTypeNames.has(t.name) ? i : -1).filter((i) => i >= 0);
+							if (deletableIndices.length === 0) break;
+							const deleteIdx = deletableIndices[0];
+							scenario.deleteType(registeredTypeNames[deleteIdx]);
+							registeredTypeNames.splice(deleteIdx, 1);
+							model = applyElectricAgentsAction(model, `delete_type`);
+							break;
+						}
+						case `spawn`: {
+							if (registeredTypeNames.length === 0) break;
+							const typeName = registeredTypeNames[0];
+							const instanceId = `entity-${entityCounter++}`;
+							scenario.spawn(typeName, instanceId);
+							scenario.custom(async (ctx) => {
+								entityUrls.push(ctx.currentEntityUrl);
+							});
+							model = applyElectricAgentsAction(model, `spawn`);
+							break;
+						}
+						case `send`: {
+							const runningIdxs = model.entities.map((e, i) => e.status === `running` ? i : -1).filter((i) => i >= 0);
+							if (runningIdxs.length === 0) break;
+							const targetIdx = runningIdxs[Math.floor(Math.random() * runningIdxs.length)];
+							scenario.custom(async (ctx) => {
+								const url = entityUrls[targetIdx];
+								if (!url) return;
+								const res = await electricAgentsFetch(ctx.baseUrl, `${url}/send`, {
+									method: `POST`,
+									body: JSON.stringify({
+										from: `prop-test`,
+										payload: {
+											action: `prop-send`,
+											targetIdx
+										}
+									})
+								});
+								(0, vitest.expect)(res.status).toBe(204);
+								ctx.history.push({
+									type: `message_sent`,
+									entityUrl: url,
+									payload: {
+										action: `prop-send`,
+										targetIdx
+									},
+									from: `prop-test`
+								});
+							});
+							scenario.expectWebhook();
+							scenario.respondDone();
+							model = applyElectricAgentsAction(model, `send`, targetIdx);
+							break;
+						}
+						case `kill`: {
+							const runningIdxs = model.entities.map((e, i) => e.status === `running` ? i : -1).filter((i) => i >= 0);
+							if (runningIdxs.length === 0) break;
+							const targetIdx = runningIdxs[Math.floor(Math.random() * runningIdxs.length)];
+							scenario.custom(async (ctx) => {
+								const url = entityUrls[targetIdx];
+								if (!url) return;
+								const res = await electricAgentsFetch(ctx.baseUrl, url, { method: `DELETE` });
+								(0, vitest.expect)(res.status).toBe(200);
+								ctx.history.push({
+									type: `entity_killed`,
+									entityUrl: url
+								});
+							});
+							model = applyElectricAgentsAction(model, `kill`, targetIdx);
+							break;
+						}
+						case `check_status`: {
+							const anyIdx = model.entities.length > 0 ? 0 : -1;
+							if (anyIdx < 0) break;
+							const expectedStatus = model.entities[anyIdx].status;
+							scenario.custom(async (ctx) => {
+								const url = entityUrls[anyIdx];
+								if (!url) return;
+								const res = await electricAgentsFetch(ctx.baseUrl, url);
+								(0, vitest.expect)(res.status).toBe(200);
+								const entity = await res.json();
+								if (expectedStatus === `running`) (0, vitest.expect)([`running`, `idle`]).toContain(entity.status);
+								else (0, vitest.expect)(entity.status).toBe(expectedStatus);
+								ctx.history.push({
+									type: `entity_status_checked`,
+									entityUrl: url,
+									status: entity.status
+								});
+							});
+							model = applyElectricAgentsAction(model, `check_status`);
+							break;
+						}
+						case `list`: {
+							scenario.list();
+							model = applyElectricAgentsAction(model, `list`);
+							break;
+						}
+					}
+				}
+				const history = await scenario.run();
+				checkInvariants(history);
+			}), {
+				numRuns: 15,
+				endOnFailure: true
+			});
+		}, 3e4);
+	});
+	vitest.describe.skip(`Electric Agents - StreamDB Materialization`, () => {
+		(0, vitest.test)(`State Protocol events materialize with correct structure`, () => electricAgents(config.baseUrl).subscription(`/mat-test-agent/**`, `mat-test-sub`).registerType({
+			name: `mat-test-agent`,
+			description: `Test materialization`
+		}).spawn(`mat-test-agent`, `mat-1`).writeStateProtocol({
+			type: `run`,
+			key: `run-0`,
+			value: { status: `started` },
+			headers: { operation: `insert` }
+		}).writeStateProtocol({
+			type: `step`,
+			key: `step-0`,
+			value: {
+				status: `started`,
+				step_number: 1
+			},
+			headers: {
+				operation: `insert`,
+				model_provider: `anthropic`,
+				model_id: `claude-sonnet-4-5`
+			}
+		}).writeStateProtocol({
+			type: `text`,
+			key: `msg-0`,
+			value: { status: `streaming` },
+			headers: { operation: `insert` }
+		}).writeStateProtocol({
+			type: `text_delta`,
+			key: `msg-0:0`,
+			value: {
+				delta: `Hello `,
+				text_id: `msg-0`
+			},
+			headers: { operation: `insert` }
+		}).writeStateProtocol({
+			type: `text_delta`,
+			key: `msg-0:1`,
+			value: {
+				delta: `world`,
+				text_id: `msg-0`
+			},
+			headers: { operation: `insert` }
+		}).writeStateProtocol({
+			type: `text`,
+			key: `msg-0`,
+			value: { status: `completed` },
+			headers: { operation: `update` }
+		}).writeStateProtocol({
+			type: `step`,
+			key: `step-0`,
+			value: {
+				status: `completed`,
+				step_number: 1,
+				finish_reason: `stop`
+			},
+			headers: {
+				operation: `update`,
+				duration_ms: 1500,
+				token_input: 10,
+				token_output: 5
+			}
+		}).writeStateProtocol({
+			type: `run`,
+			key: `run-0`,
+			value: {
+				status: `completed`,
+				finish_reason: `stop`
+			},
+			headers: {
+				operation: `update`,
+				duration_ms: 2e3
+			}
+		}).readStream().custom(async (ctx) => {
+			const events = ctx.lastStreamMessages;
+			const spEvents = events.filter((e) => e.type && e.key && e.headers);
+			const runEvents = spEvents.filter((e) => e.type === `run`);
+			(0, vitest.expect)(runEvents.length).toBe(2);
+			(0, vitest.expect)(runEvents[0].headers.operation).toBe(`insert`);
+			(0, vitest.expect)(runEvents[1].headers.operation).toBe(`update`);
+			const stepEvents = spEvents.filter((e) => e.type === `step`);
+			(0, vitest.expect)(stepEvents.length).toBe(2);
+			(0, vitest.expect)(stepEvents[0].headers.operation).toBe(`insert`);
+			(0, vitest.expect)(stepEvents[1].headers.operation).toBe(`update`);
+			const textEvents = spEvents.filter((e) => e.type === `text`);
+			(0, vitest.expect)(textEvents.length).toBe(2);
+			(0, vitest.expect)(textEvents[0].headers.operation).toBe(`insert`);
+			(0, vitest.expect)(textEvents[1].headers.operation).toBe(`update`);
+			const deltas = spEvents.filter((e) => e.type === `text_delta`);
+			(0, vitest.expect)(deltas.length).toBe(2);
+			(0, vitest.expect)(deltas[0].key).toBe(`msg-0:0`);
+			(0, vitest.expect)(deltas[1].key).toBe(`msg-0:1`);
+			const completedText = textEvents.find((e) => e.headers.operation === `update`);
+			(0, vitest.expect)(completedText.value.status).toBe(`completed`);
+			checkStateProtocolInvariants(spEvents);
+		}).kill().run());
+		(0, vitest.test)(`tool call state machine follows started → executing → completed`, () => electricAgents(config.baseUrl).subscription(`/tc-mat-agent/**`, `tc-mat-sub`).registerType({
+			name: `tc-mat-agent`,
+			description: `Test tool call materialization`
+		}).spawn(`tc-mat-agent`, `tc-mat-1`).writeStateProtocol({
+			type: `run`,
+			key: `run-0`,
+			value: { status: `started` },
+			headers: { operation: `insert` }
+		}).writeStateProtocol({
+			type: `step`,
+			key: `step-0`,
+			value: {
+				status: `started`,
+				step_number: 1
+			},
+			headers: { operation: `insert` }
+		}).writeStateProtocol({
+			type: `tool_call`,
+			key: `tc-0`,
+			value: {
+				tool_name: `web_search`,
+				status: `started`
+			},
+			headers: { operation: `insert` }
+		}).writeStateProtocol({
+			type: `tool_call`,
+			key: `tc-0`,
+			value: {
+				tool_name: `web_search`,
+				status: `executing`
+			},
+			headers: { operation: `update` }
+		}).writeStateProtocol({
+			type: `tool_call`,
+			key: `tc-0`,
+			value: {
+				tool_name: `web_search`,
+				result: `Search results here`,
+				status: `completed`
+			},
+			headers: {
+				operation: `update`,
+				duration_ms: 500
+			}
+		}).readStream().custom(async (ctx) => {
+			const events = ctx.lastStreamMessages;
+			const tcEvents = events.filter((e) => e.type === `tool_call`);
+			(0, vitest.expect)(tcEvents.length).toBe(3);
+			(0, vitest.expect)(tcEvents[0].value.status).toBe(`started`);
+			(0, vitest.expect)(tcEvents[0].headers.operation).toBe(`insert`);
+			(0, vitest.expect)(tcEvents[1].value.status).toBe(`executing`);
+			(0, vitest.expect)(tcEvents[1].headers.operation).toBe(`update`);
+			(0, vitest.expect)(tcEvents[2].value.status).toBe(`completed`);
+			(0, vitest.expect)(tcEvents[2].headers.operation).toBe(`update`);
+			checkStateProtocolInvariants(events.filter((e) => e.type && e.key && e.headers));
+		}).kill().run());
+		(0, vitest.test)(`insert creates new entries, update modifies existing entries by key`, () => electricAgents(config.baseUrl).subscription(`/upsert-agent/**`, `upsert-sub`).registerType({
+			name: `upsert-agent`,
+			description: `Test insert/update semantics`
+		}).spawn(`upsert-agent`, `upsert-1`).writeStateProtocol({
+			type: `text`,
+			key: `msg-0`,
+			value: { status: `streaming` },
+			headers: { operation: `insert` }
+		}).writeStateProtocol({
+			type: `text`,
+			key: `msg-0`,
+			value: { status: `completed` },
+			headers: { operation: `update` }
+		}).writeStateProtocol({
+			type: `text`,
+			key: `msg-1`,
+			value: { status: `streaming` },
+			headers: { operation: `insert` }
+		}).readStream().custom(async (ctx) => {
+			const events = ctx.lastStreamMessages;
+			const textEvents = events.filter((e) => e.type === `text`);
+			(0, vitest.expect)(textEvents.length).toBe(3);
+			const keys = textEvents.map((e) => e.key);
+			(0, vitest.expect)(keys).toContain(`msg-0`);
+			(0, vitest.expect)(keys).toContain(`msg-1`);
+		}).kill().run());
+	});
+	(0, vitest.describe)(`Electric Agents - Tool Tests`, () => {
+		/** Extract text from the first content block of a tool result. */
+		function firstText(result) {
+			const block = result.content[0];
+			return block?.type === `text` && block.text ? block.text : ``;
+		}
+		(0, vitest.test)(`bash tool captures stdout and stderr`, async () => {
+			const { createBashTool } = await import(`../../agents-runtime/src/tools`);
+			const tool = createBashTool(`/tmp`);
+			const result = await tool.execute(`test-tc`, { command: `echo "hello" && echo "error" >&2` });
+			(0, vitest.expect)(firstText(result)).toContain(`hello`);
+			(0, vitest.expect)(firstText(result)).toContain(`error`);
+			(0, vitest.expect)(result.details.exitCode).toBe(0);
+		});
+		(0, vitest.test)(`bash tool enforces timeout`, async () => {
+			const { createBashTool } = await import(`../../agents-runtime/src/tools`);
+			const tool = createBashTool(`/tmp`);
+			const result = await tool.execute(`test-tc`, { command: `sleep 60` });
+			(0, vitest.expect)(result.details.timedOut).toBe(true);
+		}, 35e3);
+		(0, vitest.test)(`read_file rejects paths outside working directory`, async () => {
+			const { createReadFileTool } = await import(`../../agents-runtime/src/tools`);
+			const tool = createReadFileTool(`/tmp/test-workdir`);
+			const result = await tool.execute(`test-tc`, { path: `../../etc/passwd` });
+			(0, vitest.expect)(firstText(result)).toContain(`outside the working directory`);
+		});
+		(0, vitest.test)(`read_file rejects binary files`, async () => {
+			const { createReadFileTool } = await import(`../../agents-runtime/src/tools`);
+			const fs = await import(`node:fs/promises`);
+			const path = await import(`node:path`);
+			const dir = `/tmp/test-binary-${Date.now()}`;
+			await fs.mkdir(dir, { recursive: true });
+			const binPath = path.join(dir, `test.bin`);
+			await fs.writeFile(binPath, Buffer.from([
+				0,
+				1,
+				2,
+				255
+			]));
+			const tool = createReadFileTool(dir);
+			const result = await tool.execute(`test-tc`, { path: `test.bin` });
+			(0, vitest.expect)(firstText(result)).toContain(`binary file`);
+			await fs.rm(dir, { recursive: true });
+		});
+		(0, vitest.test)(`read_file rejects oversized files`, async () => {
+			const { createReadFileTool } = await import(`../../agents-runtime/src/tools`);
+			const fs = await import(`node:fs/promises`);
+			const path = await import(`node:path`);
+			const dir = `/tmp/test-size-${Date.now()}`;
+			await fs.mkdir(dir, { recursive: true });
+			const bigPath = path.join(dir, `big.txt`);
+			await fs.writeFile(bigPath, `x`.repeat(600 * 1024));
+			const tool = createReadFileTool(dir);
+			const result = await tool.execute(`test-tc`, { path: `big.txt` });
+			(0, vitest.expect)(firstText(result)).toContain(`too large`);
+			await fs.rm(dir, { recursive: true });
+		});
+		(0, vitest.test)(`web_search tool has correct interface`, async () => {
+			const { braveSearchTool } = await import(`../../agents-runtime/src/tools`);
+			(0, vitest.expect)(braveSearchTool.name).toBe(`web_search`);
+			(0, vitest.expect)(typeof braveSearchTool.execute).toBe(`function`);
+		});
+		(0, vitest.test)(`fetch_url tool has correct interface`, async () => {
+			const { fetchUrlTool } = await import(`../../agents-runtime/src/tools`);
+			(0, vitest.expect)(fetchUrlTool.name).toBe(`fetch_url`);
+			(0, vitest.expect)(typeof fetchUrlTool.execute).toBe(`function`);
+		});
+	});
+	(0, vitest.describe)(`Electric Agents Send — State Protocol Format`, () => {
+		(0, vitest.test)(`send() writes events in State Protocol format`, () => electricAgents(config.baseUrl).subscription(`/sp-send-worker/**`, `sp-send-sub`).registerType({
+			name: `sp-send-worker`,
+			description: `Test entity type for SP send format`,
+			creation_schema: { type: `object` }
+		}).spawn(`sp-send-worker`, `entity-1`).send({ text: `hello world` }, { from: `user-1` }).expectWebhook().respondDone().readStream().custom(async (ctx) => {
+			const events = ctx.lastStreamMessages;
+			const msgEvent = events.find((e) => e.type === `message_received`);
+			(0, vitest.expect)(msgEvent.type).toBe(`message_received`);
+			(0, vitest.expect)(msgEvent.key).toBeDefined();
+			(0, vitest.expect)(msgEvent.value?.from).toBe(`user-1`);
+			(0, vitest.expect)(msgEvent.value?.payload).toEqual({ text: `hello world` });
+			(0, vitest.expect)(msgEvent.headers).toBeDefined();
+		}).run());
+		(0, vitest.test)(`send() events pass State Protocol invariant checks`, () => electricAgents(config.baseUrl).subscription(`/sp-inv-worker/**`, `sp-inv-sub`).registerType({
+			name: `sp-inv-worker`,
+			description: `Test entity type for SP invariant checks`,
+			creation_schema: { type: `object` }
+		}).spawn(`sp-inv-worker`, `entity-1`).send({ text: `first` }, { from: `tester` }).expectWebhook().respondDone().send({ text: `second` }, { from: `tester` }).expectWebhook().respondDone().readStream().custom(async (ctx) => {
+			const events = ctx.lastStreamMessages;
+			const messageEvents = events.filter((ev) => ev.type === `message_received`);
+			(0, vitest.expect)(messageEvents.length).toBe(2);
+			checkStateProtocolInvariants(events);
+		}).run());
+		(0, vitest.test)(`multiple sends produce unique sequential keys`, () => {
+			const id = Date.now();
+			return electricAgents(config.baseUrl).subscription(`/sp-keys-agent-${id}/**`, `sp-keys-sub-${id}`).registerType({
+				name: `sp-keys-agent-${id}`,
+				description: `Test entity type for send key uniqueness`,
+				creation_schema: { type: `object` }
+			}).spawn(`sp-keys-agent-${id}`, `entity-1`).send({ seq: 1 }, { from: `test` }).expectWebhook().respondDone().send({ seq: 2 }, { from: `test` }).expectWebhook().respondDone().send({ seq: 3 }, { from: `test` }).expectWebhook().respondDone().readStream().custom(async (ctx) => {
+				const events = ctx.lastStreamMessages.filter((e) => e.type === `message_received`);
+				(0, vitest.expect)(events.length).toBe(3);
+				for (let i = 0; i < 3; i++) (0, vitest.expect)(events[i].value?.payload).toEqual({ seq: i + 1 });
+			}).run();
+		});
+	});
+	(0, vitest.describe)(`Electric Agents findLastUserMessage — State Protocol`, () => {
+		(0, vitest.test)(`send event is parseable by webhook handler`, () => {
+			const id = Date.now();
+			return electricAgents(config.baseUrl).subscription(`/flum-agent-${id}/**`, `flum-sub-${id}`).registerType({
+				name: `flum-agent-${id}`,
+				description: `Test send event format for webhook parsing`,
+				creation_schema: { type: `object` }
+			}).spawn(`flum-agent-${id}`, `entity-1`).send({ text: `test message for parsing` }, { from: `tester` }).expectWebhook().respondDone().readStream().custom(async (ctx) => {
+				const events = ctx.lastStreamMessages;
+				const msgEvent = events.find((e) => e.type === `message_received`);
+				(0, vitest.expect)(msgEvent).toBeDefined();
+				(0, vitest.expect)(msgEvent.value?.payload).toBeDefined();
+				const payload = msgEvent.value.payload;
+				(0, vitest.expect)(payload.text).toBe(`test message for parsing`);
+			}).run();
+		});
+		(0, vitest.test)(`stream events after send are all State Protocol format`, () => {
+			const id = Date.now();
+			return electricAgents(config.baseUrl).subscription(`/flum-all-agent-${id}/**`, `flum-all-sub-${id}`).registerType({
+				name: `flum-all-agent-${id}`,
+				description: `Test all events are SP format`,
+				creation_schema: { type: `object` }
+			}).spawn(`flum-all-agent-${id}`, `entity-1`).send({ text: `verify all SP` }, { from: `tester` }).expectWebhook().respondDone().readStream().custom(async (ctx) => {
+				const events = ctx.lastStreamMessages;
+				(0, vitest.expect)(events.length).toBeGreaterThanOrEqual(1);
+				const hasMsg = events.some((e) => e.type === `message_received`);
+				(0, vitest.expect)(hasMsg).toBe(true);
+				for (const ev of events) {
+					(0, vitest.expect)(ev.type, `every event must have type`).toBeDefined();
+					(0, vitest.expect)(ev.key, `SP events must have key`).toBeDefined();
+					(0, vitest.expect)(ev.headers, `SP events must have headers`).toBeDefined();
+				}
+			}).run();
+		});
+	});
+	(0, vitest.describe)(`Error Paths`, () => {
+		(0, vitest.test)(`kill nonexistent entity with registered type returns 404`, async () => {
+			const typeName = `kill-miss-${Date.now()}`;
+			await electricAgentsFetch(config.baseUrl, `/_electric/entity-types`, {
+				method: `POST`,
+				body: JSON.stringify({
+					name: typeName,
+					description: `test`
+				})
+			});
+			const res = await electricAgentsFetch(config.baseUrl, `/${typeName}/nonexistent-id-12345`, { method: `DELETE` });
+			(0, vitest.expect)(res.status).toBe(404);
+			const body = await res.json();
+			(0, vitest.expect)(body.error.code).toBe(`NOT_FOUND`);
+		});
+		vitest.test.skip(`kill already-stopped entity is idempotent`, () => {
+			const id = Date.now();
+			return electricAgents(config.baseUrl).subscription(`/kill-stopped-agent-${id}/**`, `kill-stopped-sub-${id}`).registerType({
+				name: `kill-stopped-agent-${id}`,
+				description: `Test killing stopped entity`,
+				creation_schema: { type: `object` }
+			}).spawn(`kill-stopped-agent-${id}`, `entity-1`).kill().custom(async (ctx) => {
+				const res = await electricAgentsFetch(ctx.baseUrl, ctx.currentEntityUrl, { method: `DELETE` });
+				(0, vitest.expect)(res.status).toBe(200);
+			}).run();
+		});
+		(0, vitest.test)(`send without payload is rejected`, async () => {
+			const id = Date.now();
+			await electricAgents(config.baseUrl).subscription(`/no-payload-agent-${id}/**`, `no-payload-sub-${id}`).registerType({
+				name: `no-payload-agent-${id}`,
+				description: `Test send without payload`,
+				creation_schema: { type: `object` }
+			}).spawn(`no-payload-agent-${id}`, `entity-1`).custom(async (ctx) => {
+				const res = await electricAgentsFetch(ctx.baseUrl, `${ctx.currentEntityUrl}/send`, {
+					method: `POST`,
+					body: JSON.stringify({ from: `tester` })
+				});
+				(0, vitest.expect)(res.status).toBe(400);
+				const body = await res.json();
+				(0, vitest.expect)(body.error.code).toBe(`INVALID_REQUEST`);
+			}).run();
+		});
+		(0, vitest.test)(`delete nonexistent entity type returns 404`, async () => {
+			const res = await electricAgentsFetch(config.baseUrl, `/_electric/entity-types/nonexistent-type-xyz`, { method: `DELETE` });
+			(0, vitest.expect)(res.status).toBe(404);
+		});
+		(0, vitest.test)(`delete entity type goes through state stream`, () => {
+			const id = Date.now();
+			return electricAgents(config.baseUrl).subscription(`/del-state-agent-${id}/**`, `del-state-sub-${id}`).registerType({
+				name: `del-state-agent-${id}`,
+				description: `Test delete via state stream`,
+				creation_schema: { type: `object` }
+			}).deleteType(`del-state-agent-${id}`).custom(async (ctx) => {
+				const res = await electricAgentsFetch(ctx.baseUrl, `/_electric/entity-types/del-state-agent-${id}`);
+				(0, vitest.expect)(res.status).toBe(404);
+			}).run();
+		});
+		(0, vitest.test)(`tag update on stopped entity is rejected without claim`, () => {
+			const id = Date.now();
+			return electricAgents(config.baseUrl).subscription(`/meta-stopped-agent-${id}/**`, `meta-stopped-sub-${id}`).registerType({
+				name: `meta-stopped-agent-${id}`,
+				description: `Test tag write on stopped entity`,
+				creation_schema: { type: `object` }
+			}).spawn(`meta-stopped-agent-${id}`, `entity-1`).kill().custom(async (ctx) => {
+				const res = await electricAgentsFetch(ctx.baseUrl, `${ctx.currentEntityUrl}/tags/key`, {
+					method: `POST`,
+					body: JSON.stringify({ value: `value` })
+				});
+				(0, vitest.expect)(res.status).toBe(401);
+			}).run();
+		});
+	});
+	(0, vitest.describe)(`Type Revision Edge Cases`, () => {
+		(0, vitest.test)(`existing entities accept schemas added across multiple amendments`, () => {
+			const id = Date.now();
+			return electricAgents(config.baseUrl).subscription(`/rev-multi-agent-${id}/**`, `rev-multi-sub-${id}`).registerType({
+				name: `rev-multi-agent-${id}`,
+				description: `Test multi-revision pinning`,
+				creation_schema: { type: `object` },
+				input_schemas: { greet: {
+					type: `object`,
+					properties: { name: { type: `string` } },
+					required: [`name`]
+				} }
+			}).spawn(`rev-multi-agent-${id}`, `entity-rev1`).custom(async (ctx) => {
+				const rev1EntityUrl = ctx.currentEntityUrl;
+				await electricAgentsFetch(ctx.baseUrl, `/_electric/entity-types/rev-multi-agent-${id}/schemas`, {
+					method: `PATCH`,
+					body: JSON.stringify({ inbox_schemas: { farewell: {
+						type: `object`,
+						properties: { reason: { type: `string` } },
+						required: [`reason`]
+					} } })
+				});
+				await electricAgentsFetch(ctx.baseUrl, `/_electric/entity-types/rev-multi-agent-${id}/schemas`, {
+					method: `PATCH`,
+					body: JSON.stringify({ inbox_schemas: { status: {
+						type: `object`,
+						properties: { active: { type: `boolean` } }
+					} } })
+				});
+				const res = await electricAgentsFetch(ctx.baseUrl, `${rev1EntityUrl}/send`, {
+					method: `POST`,
+					body: JSON.stringify({
+						from: `tester`,
+						payload: { reason: `bye` },
+						type: `farewell`
+					})
+				});
+				(0, vitest.expect)(res.status).toBe(204);
+			}).run();
+		});
+		(0, vitest.test)(`amend schemas on deleted type returns 404`, async () => {
+			const id = Date.now();
+			await electricAgents(config.baseUrl).subscription(`/amend-del-agent-${id}/**`, `amend-del-sub-${id}`).registerType({
+				name: `amend-del-agent-${id}`,
+				description: `Test amend on deleted type`,
+				creation_schema: { type: `object` }
+			}).deleteType(`amend-del-agent-${id}`).custom(async (ctx) => {
+				const res = await electricAgentsFetch(ctx.baseUrl, `/_electric/entity-types/amend-del-agent-${id}/schemas`, {
+					method: `PATCH`,
+					body: JSON.stringify({ input_schemas: { msg: { type: `object` } } })
+				});
+				(0, vitest.expect)(res.status).toBe(404);
+			}).run();
+		});
+	});
+	(0, vitest.describe)(`Concurrent Operations`, () => {
+		(0, vitest.test)(`sequential tag updates accumulate`, async () => {
+			const id = Date.now();
+			await electricAgents(config.baseUrl).subscription(`/seq-meta-agent-${id}/**`, `seq-meta-sub-${id}`).registerType({
+				name: `seq-meta-agent-${id}`,
+				description: `Test sequential tag updates`,
+				creation_schema: { type: `object` }
+			}).spawn(`seq-meta-agent-${id}`, `entity-1`).send({ trigger: `claim` }, { from: `test` }).expectWebhook().custom(async (ctx) => {
+				const notification = ctx.notification;
+				const claimRes = await fetch(notification.parsed.callback, {
+					method: `POST`,
+					headers: {
+						"content-type": `application/json`,
+						authorization: `Bearer ${notification.parsed.token}`
+					},
+					body: JSON.stringify({
+						epoch: notification.parsed.epoch,
+						wakeId: notification.parsed.wake_id
+					})
+				});
+				(0, vitest.expect)(claimRes.status).toBe(200);
+				const claim = await claimRes.json();
+				(0, vitest.expect)(claim.ok).toBe(true);
+				(0, vitest.expect)(claim.writeToken).toBeTruthy();
+				const tagHeaders = { authorization: `Bearer ${claim.writeToken}` };
+				const r1 = await electricAgentsFetch(ctx.baseUrl, `${ctx.currentEntityUrl}/tags/key1`, {
+					method: `POST`,
+					headers: tagHeaders,
+					body: JSON.stringify({ value: `value1` })
+				});
+				(0, vitest.expect)(r1.status).toBe(200);
+				const r2 = await electricAgentsFetch(ctx.baseUrl, `${ctx.currentEntityUrl}/tags/key2`, {
+					method: `POST`,
+					headers: tagHeaders,
+					body: JSON.stringify({ value: `value2` })
+				});
+				(0, vitest.expect)(r2.status).toBe(200);
+				const getRes = await electricAgentsFetch(ctx.baseUrl, ctx.currentEntityUrl);
+				const entity = await getRes.json();
+				(0, vitest.expect)(entity.tags.key1).toBe(`value1`);
+				(0, vitest.expect)(entity.tags.key2).toBe(`value2`);
+			}).respondDone().run();
+		});
+		(0, vitest.test)(`concurrent spawns under same type succeed`, async () => {
+			const id = Date.now();
+			await electricAgents(config.baseUrl).subscription(`/conc-spawn-agent-${id}/**`, `conc-spawn-sub-${id}`).registerType({
+				name: `conc-spawn-agent-${id}`,
+				description: `Test concurrent spawns`,
+				creation_schema: { type: `object` }
+			}).custom(async (ctx) => {
+				const results = await Promise.all(Array.from({ length: 5 }, (_, i) => electricAgentsFetch(ctx.baseUrl, `/conc-spawn-agent-${id}/concurrent-${i}`, {
+					method: `PUT`,
+					body: JSON.stringify({})
+				})));
+				for (const res of results) (0, vitest.expect)(res.status).toBe(201);
+				for (let i = 0; i < 5; i++) {
+					const res = await electricAgentsFetch(ctx.baseUrl, `/conc-spawn-agent-${id}/concurrent-${i}`);
+					(0, vitest.expect)(res.status).toBe(200);
+				}
+			}).run();
+		});
+	});
+	(0, vitest.describe)(`Electric Agents Auth Boundary`, () => {
+		(0, vitest.test)(`write to entity stream without token is rejected`, () => {
+			const id = Date.now();
+			return electricAgents(config.baseUrl).subscription(`/auth-notoken-agent-${id}/**`, `auth-notoken-sub-${id}`).registerType({
+				name: `auth-notoken-agent-${id}`,
+				description: `Test write without token`,
+				creation_schema: { type: `object` }
+			}).spawn(`auth-notoken-agent-${id}`, `entity-1`).custom(async (ctx) => {
+				const res = await fetch(`${ctx.baseUrl}${ctx.currentEntityUrl}/main`, {
+					method: `POST`,
+					headers: { "content-type": `application/json` },
+					body: JSON.stringify({
+						type: `default`,
+						key: `test-${Date.now()}`,
+						value: { data: `should-fail` },
+						headers: { operation: `insert` }
+					})
+				});
+				(0, vitest.expect)(res.status).toBe(401);
+			}).run();
+		});
+		(0, vitest.test)(`write to entity stream with wrong token is rejected`, () => {
+			const id = Date.now();
+			return electricAgents(config.baseUrl).subscription(`/auth-wrongtoken-agent-${id}/**`, `auth-wrongtoken-sub-${id}`).registerType({
+				name: `auth-wrongtoken-agent-${id}`,
+				description: `Test write with wrong token`,
+				creation_schema: { type: `object` }
+			}).spawn(`auth-wrongtoken-agent-${id}`, `entity-1`).custom(async (ctx) => {
+				const res = await fetch(`${ctx.baseUrl}${ctx.currentEntityUrl}/main`, {
+					method: `POST`,
+					headers: {
+						"content-type": `application/json`,
+						authorization: `Bearer wrong-token`
+					},
+					body: JSON.stringify({
+						type: `default`,
+						key: `test-${Date.now()}`,
+						value: { data: `should-fail` },
+						headers: { operation: `insert` }
+					})
+				});
+				(0, vitest.expect)(res.status).toBe(401);
+			}).run();
+		});
+		(0, vitest.test)(`spawn does not expose a public entity write token`, () => {
+			const id = Date.now();
+			return electricAgents(config.baseUrl).subscription(`/auth-goodtoken-agent-${id}/**`, `auth-goodtoken-sub-${id}`).registerType({
+				name: `auth-goodtoken-agent-${id}`,
+				description: `Test write with correct token`,
+				creation_schema: { type: `object` }
+			}).spawn(`auth-goodtoken-agent-${id}`, `entity-1`).custom(async (ctx) => {
+				(0, vitest.expect)(ctx.currentWriteToken).toBeNull();
+			}).run();
+		});
+		(0, vitest.test)(`tag update without token is rejected`, () => {
+			const id = Date.now();
+			return electricAgents(config.baseUrl).subscription(`/auth-meta-notoken-agent-${id}/**`, `auth-meta-notoken-sub-${id}`).registerType({
+				name: `auth-meta-notoken-agent-${id}`,
+				description: `Test tag update without token`,
+				creation_schema: { type: `object` }
+			}).spawn(`auth-meta-notoken-agent-${id}`, `entity-1`).custom(async (ctx) => {
+				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`${ctx.currentEntityUrl}/tags/key`)}`, {
+					method: `POST`,
+					headers: { "content-type": `application/json` },
+					body: JSON.stringify({ value: `value` })
+				});
+				(0, vitest.expect)(res.status).toBe(401);
+			}).run();
+		});
+		(0, vitest.test)(`spawn does not expose a public tag write token`, () => {
+			const id = Date.now();
+			return electricAgents(config.baseUrl).subscription(`/auth-meta-goodtoken-agent-${id}/**`, `auth-meta-goodtoken-sub-${id}`).registerType({
+				name: `auth-meta-goodtoken-agent-${id}`,
+				description: `Test tag update with correct token`,
+				creation_schema: { type: `object` }
+			}).spawn(`auth-meta-goodtoken-agent-${id}`, `entity-1`).custom(async (ctx) => {
+				(0, vitest.expect)(ctx.currentWriteToken).toBeNull();
+			}).run();
+		});
+		(0, vitest.test)(`send remains unauthenticated`, () => {
+			const id = Date.now();
+			return electricAgents(config.baseUrl).subscription(`/auth-send-noauth-agent-${id}/**`, `auth-send-noauth-sub-${id}`).registerType({
+				name: `auth-send-noauth-agent-${id}`,
+				description: `Test send without auth`,
+				creation_schema: { type: `object` }
+			}).spawn(`auth-send-noauth-agent-${id}`, `entity-1`).custom(async (ctx) => {
+				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`${ctx.currentEntityUrl}/send`)}`, {
+					method: `POST`,
+					headers: { "content-type": `application/json` },
+					body: JSON.stringify({
+						from: `tester`,
+						payload: `hi`
+					})
+				});
+				(0, vitest.expect)(res.status).toBe(204);
+			}).expectWebhook().respondDone().run();
+		});
+		(0, vitest.test)(`GET entity does not leak write_token`, () => {
+			const id = Date.now();
+			return electricAgents(config.baseUrl).subscription(`/auth-noleak-agent-${id}/**`, `auth-noleak-sub-${id}`).registerType({
+				name: `auth-noleak-agent-${id}`,
+				description: `Test GET does not leak write_token`,
+				creation_schema: { type: `object` }
+			}).spawn(`auth-noleak-agent-${id}`, `entity-1`).custom(async (ctx) => {
+				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(ctx.currentEntityUrl)}`);
+				(0, vitest.expect)(res.status).toBe(200);
+				const entity = await res.json();
+				(0, vitest.expect)(entity.write_token).toBeUndefined();
+				(0, vitest.expect)(entity.subscription_id).toBeUndefined();
+			}).run();
+		});
+		vitest.test.skip(`list entities does not leak write_token`, () => {
+			const id = Date.now();
+			return electricAgents(config.baseUrl).subscription(`/auth-listnoleak-agent-${id}/**`, `auth-listnoleak-sub-${id}`).registerType({
+				name: `auth-listnoleak-agent-${id}`,
+				description: `Test list does not leak write_token`,
+				creation_schema: { type: `object` }
+			}).spawn(`auth-listnoleak-agent-${id}`, `entity-1`).custom(async (ctx) => {
+				const entities = await fetchShapeRows(ctx.baseUrl, `entities`);
+				for (const entity of entities) {
+					(0, vitest.expect)(entity).not.toHaveProperty(`write_token`);
+					(0, vitest.expect)(entity).not.toHaveProperty(`subscription_id`);
+				}
+			}).run();
+		});
+		(0, vitest.test)(`write to non-entity stream requires no auth`, async () => {
+			const id = Date.now();
+			const streamPath = `/v1/stream/plain-stream-auth-test-${id}`;
+			const createRes = await fetch(`${config.baseUrl}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `initial data`
+			});
+			(0, vitest.expect)(createRes.status).toBe(201);
+			const writeRes = await fetch(`${config.baseUrl}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: ` more data`
+			});
+			(0, vitest.expect)([200, 204].includes(writeRes.status)).toBe(true);
+		});
+	});
+}
+function runCliConformanceTests(config) {
+	(0, vitest.describe)(`CLI — Entity Types`, () => {
+		(0, vitest.test)(`types lists registered types`, async () => {
+			await cliTest(config.baseUrl, config.cliBin).setupType({
+				name: `cli-types-test`,
+				description: `Type for CLI types test`
+			}).exec(`types`).expectExitCode(0).expectStdout(/cli-types-test/).expectStdout(/Type for CLI types test/).run();
+		});
+		(0, vitest.test)(`types inspect shows type details`, async () => {
+			await cliTest(config.baseUrl, config.cliBin).setupType({
+				name: `cli-inspect-type`,
+				description: `Type for CLI inspect test`
+			}).exec(`types`, `inspect`, `cli-inspect-type`).expectExitCode(0).expectStdout(/cli-inspect-type/).run();
+		});
+		(0, vitest.test)(`types inspect nonexistent type fails`, async () => {
+			await cliTest(config.baseUrl, config.cliBin).exec(`types`, `inspect`, `nonexistent-type-xyz`).expectExitCode(1).expectStderr(/Error/).run();
+		});
+		(0, vitest.test)(`types delete removes type`, async () => {
+			await cliTest(config.baseUrl, config.cliBin).setupType({
+				name: `cli-delete-type`,
+				description: `Type to delete`
+			}).exec(`types`, `delete`, `cli-delete-type`).expectExitCode(0).expectStdout(/Deleted/).exec(`types`).expectStdoutNot(/cli-delete-type/).run();
+		});
+	});
+	(0, vitest.describe)(`CLI — Spawn`, () => {
+		(0, vitest.test)(`spawn creates entity and reports URL`, async () => {
+			const id = `cli-spawn-${Date.now()}`;
+			await cliTest(config.baseUrl, config.cliBin).setupType({
+				name: `cli-spawn-type`,
+				description: `Type for CLI spawn test`
+			}).setupSubscription(`/cli-spawn-type/**`, `cli-spawn-sub`).exec(`spawn`, `/cli-spawn-type/${id}`).expectExitCode(0).expectStdout(/Spawned/).verifyApi(async (baseUrl) => {
+				const res = await fetch(`${baseUrl}${routeControlPlanePath(`/cli-spawn-type/${id}`)}`);
+				(0, vitest.expect)(res.status).toBe(200);
+				const entity = await res.json();
+				(0, vitest.expect)([`running`, `idle`]).toContain(entity.status);
+			}).run();
+		});
+		(0, vitest.test)(`spawn with --args passes arguments`, async () => {
+			const id = `cli-args-${Date.now()}`;
+			await cliTest(config.baseUrl, config.cliBin).setupType({
+				name: `cli-args-type`,
+				description: `Type for CLI args test`,
+				creation_schema: { type: `object` }
+			}).setupSubscription(`/cli-args-type/**`, `cli-args-sub`).exec(`spawn`, `/cli-args-type/${id}`, `--args`, `{"key":"value"}`).expectExitCode(0).expectStdout(/Spawned/).run();
+		});
+		(0, vitest.test)(`spawn unregistered type exits non-zero`, async () => {
+			await cliTest(config.baseUrl, config.cliBin).exec(`spawn`, `/nonexistent-type-xyz/some-id`).expectExitCode(1).custom((last) => {
+				(0, vitest.expect)(`${last.stdout}\n${last.stderr}`).toMatch(/Entity type "nonexistent-type-xyz" not found/);
+			}).run();
+		});
+	});
+	(0, vitest.describe)(`CLI — Process Listing (ps)`, () => {
+		(0, vitest.test)(`ps lists spawned entities`, async () => {
+			const id = `cli-ps-${Date.now()}`;
+			await cliTest(config.baseUrl, config.cliBin).setupType({
+				name: `cli-ps-type`,
+				description: `Type for CLI ps test`
+			}).setupSubscription(`/cli-ps-type/**`, `cli-ps-sub`).exec(`spawn`, `/cli-ps-type/${id}`).expectExitCode(0).exec(`ps`).expectExitCode(0).expectStdout(/cli-ps-type/).run();
+		});
+		(0, vitest.test)(`ps --type filters by entity type`, async () => {
+			const id = `cli-filter-${Date.now()}`;
+			await cliTest(config.baseUrl, config.cliBin).setupType({
+				name: `cli-filter-type`,
+				description: `Type for CLI filter test`
+			}).setupSubscription(`/cli-filter-type/**`, `cli-filter-sub`).exec(`spawn`, `/cli-filter-type/${id}`).expectExitCode(0).exec(`ps`, `--type`, `cli-filter-type`).expectExitCode(0).expectStdout(/cli-filter-type/).run();
+		});
+	});
+	(0, vitest.describe)(`CLI — Send`, () => {
+		(0, vitest.test)(`send delivers message and verifies stream`, async () => {
+			const id = `cli-send-${Date.now()}`;
+			await cliTest(config.baseUrl, config.cliBin).setupType({
+				name: `cli-send-type`,
+				description: `Type for CLI send test`
+			}).setupSubscription(`/cli-send-type/**`, `cli-send-sub`).exec(`spawn`, `/cli-send-type/${id}`).expectExitCode(0).exec(`send`, `/cli-send-type/${id}`, `hello world`).expectExitCode(0).expectStdout(/Message sent/).verifyApi(async (baseUrl) => {
+				const res = await fetch(`${baseUrl}${routeControlPlanePath(`/cli-send-type/${id}`)}`);
+				(0, vitest.expect)(res.status).toBe(200);
+				const entity = await res.json();
+				const streams = entity.streams;
+				const streamRes = await fetch(`${baseUrl}${streams.main}?offset=0000000000000000_0000000000000000`);
+				const events = await streamRes.json();
+				(0, vitest.expect)(events.length).toBeGreaterThanOrEqual(1);
+				const msgEvent = events.find((e) => e.type === `message_received`);
+				(0, vitest.expect)(msgEvent).toBeDefined();
+				const payload = msgEvent.value?.payload;
+				(0, vitest.expect)(payload.text).toBe(`hello world`);
+			}).run();
+		});
+		(0, vitest.test)(`send to nonexistent entity fails`, async () => {
+			await cliTest(config.baseUrl, config.cliBin).exec(`send`, `/nonexistent/entity`, `hello`).expectExitCode(1).expectStderr(/Error/).run();
+		});
+	});
+	(0, vitest.describe)(`CLI — Inspect`, () => {
+		(0, vitest.test)(`inspect shows entity details`, async () => {
+			const id = `cli-inspect-${Date.now()}`;
+			await cliTest(config.baseUrl, config.cliBin).setupType({
+				name: `cli-inspect-etype`,
+				description: `Type for CLI inspect test`
+			}).setupSubscription(`/cli-inspect-etype/**`, `cli-inspect-sub`).exec(`spawn`, `/cli-inspect-etype/${id}`).expectExitCode(0).exec(`inspect`, `/cli-inspect-etype/${id}`).expectExitCode(0).expectStdout(/running|idle/).verifyApi(async (baseUrl) => {
+				const res = await fetch(`${baseUrl}${routeControlPlanePath(`/cli-inspect-etype/${id}`)}`);
+				(0, vitest.expect)(res.status).toBe(200);
+				const entity = await res.json();
+				(0, vitest.expect)([`running`, `idle`]).toContain(entity.status);
+			}).run();
+		});
+		(0, vitest.test)(`inspect nonexistent entity fails`, async () => {
+			await cliTest(config.baseUrl, config.cliBin).exec(`inspect`, `/nonexistent/entity`).expectExitCode(1).expectStderr(/Error/).run();
+		});
+	});
+	(0, vitest.describe)(`CLI — Kill`, () => {
+		(0, vitest.test)(`kill stops a running entity`, async () => {
+			const id = `cli-kill-${Date.now()}`;
+			await cliTest(config.baseUrl, config.cliBin).setupType({
+				name: `cli-kill-type`,
+				description: `Type for CLI kill test`
+			}).setupSubscription(`/cli-kill-type/**`, `cli-kill-sub`).exec(`spawn`, `/cli-kill-type/${id}`).expectExitCode(0).exec(`kill`, `/cli-kill-type/${id}`).expectExitCode(0).expectStdout(/Killed/).verifyApi(async (baseUrl) => {
+				const entity = await pollEntityStatus(baseUrl, `/cli-kill-type/${id}`, [`stopped`]);
+				(0, vitest.expect)(entity.status).toBe(`stopped`);
+			}).run();
+		}, 15e3);
+		(0, vitest.test)(`kill nonexistent entity fails`, async () => {
+			await cliTest(config.baseUrl, config.cliBin).exec(`kill`, `/nonexistent/entity`).expectExitCode(1).expectStderr(/Error/).run();
+		});
+	});
+	(0, vitest.describe)(`CLI — Full Lifecycle`, () => {
+		(0, vitest.test)(`spawn → send → inspect → kill with API verification`, async () => {
+			const id = `cli-lifecycle-${Date.now()}`;
+			await cliTest(config.baseUrl, config.cliBin).setupType({
+				name: `cli-lifecycle-type`,
+				description: `Type for full lifecycle test`
+			}).setupSubscription(`/cli-lifecycle-type/**`, `cli-lifecycle-sub`).exec(`spawn`, `/cli-lifecycle-type/${id}`).expectExitCode(0).expectStdout(/Spawned/).verifyApi(async (baseUrl) => {
+				const res = await fetch(`${baseUrl}${routeControlPlanePath(`/cli-lifecycle-type/${id}`)}`);
+				(0, vitest.expect)(res.status, `entity should exist after spawn`).toBe(200);
+				const entity = await res.json();
+				(0, vitest.expect)([`running`, `idle`]).toContain(entity.status);
+			}).exec(`send`, `/cli-lifecycle-type/${id}`, `test message`).expectExitCode(0).expectStdout(/Message sent/).exec(`inspect`, `/cli-lifecycle-type/${id}`).expectExitCode(0).expectStdout(/running|idle/).exec(`kill`, `/cli-lifecycle-type/${id}`).expectExitCode(0).expectStdout(/Killed/).verifyApi(async (baseUrl) => {
+				const entity = await pollEntityStatus(baseUrl, `/cli-lifecycle-type/${id}`, [`stopped`]);
+				(0, vitest.expect)(entity.status).toBe(`stopped`);
+			}).exec(`ps`, `--status`, `running`).expectExitCode(0).expectStdoutNot(new RegExp(id)).run();
+		}, 15e3);
+		(0, vitest.test)(`send to stopped entity fails`, async () => {
+			const id = `cli-stopped-${Date.now()}`;
+			await cliTest(config.baseUrl, config.cliBin).setupType({
+				name: `cli-stopped-type`,
+				description: `Type for stopped entity test`
+			}).setupSubscription(`/cli-stopped-type/**`, `cli-stopped-sub`).exec(`spawn`, `/cli-stopped-type/${id}`).expectExitCode(0).exec(`kill`, `/cli-stopped-type/${id}`).expectExitCode(0).exec(`send`, `/cli-stopped-type/${id}`, `should fail`).expectExitCode(1).expectStderr(/Error/).run();
+		});
+	});
+	(0, vitest.describe)(`CLI — Usage Errors`, () => {
+		(0, vitest.test)(`no arguments shows usage`, async () => {
+			await cliTest(config.baseUrl, config.cliBin).exec().expectExitCode(1).run();
+		});
+		(0, vitest.test)(`spawn without arguments shows usage`, async () => {
+			await cliTest(config.baseUrl, config.cliBin).exec(`spawn`).expectExitCode(1).run();
+		});
+		(0, vitest.test)(`send without URL shows usage`, async () => {
+			await cliTest(config.baseUrl, config.cliBin).exec(`send`).expectExitCode(1).run();
+		});
+	});
+}
+function runMockAgentTests(config) {
+	async function spawnEntity(baseUrl, typeName, instanceId) {
+		const res = await fetch(`${baseUrl}${routeControlPlanePath(`/${encodeURIComponent(typeName)}/${encodeURIComponent(instanceId)}`)}`, {
+			method: `PUT`,
+			headers: { "content-type": `application/json` },
+			body: JSON.stringify({})
+		});
+		(0, vitest.expect)(res.ok, `spawn should succeed: ${res.status}`).toBe(true);
+		return await res.json();
+	}
+	async function sendMessage(baseUrl, entityUrl, text) {
+		const res = await fetch(`${baseUrl}${routeControlPlanePath(`${entityUrl}/send`)}`, {
+			method: `POST`,
+			headers: { "content-type": `application/json` },
+			body: JSON.stringify({
+				payload: { text },
+				from: `tester`
+			})
+		});
+		(0, vitest.expect)(res.ok || res.status === 204, `send should succeed: ${res.status}`).toBe(true);
+	}
+	async function pollForAgentResponse(baseUrl, entityUrl, timeoutMs = 1e4) {
+		const start = Date.now();
+		while (Date.now() - start < timeoutMs) {
+			const entityRes = await fetch(`${baseUrl}${routeControlPlanePath(entityUrl)}`);
+			if (!entityRes.ok) throw new Error(`Entity ${entityUrl} not found`);
+			const entity = await entityRes.json();
+			const streams = entity.streams;
+			const streamRes = await fetch(`${baseUrl}${streams.main}?offset=0000000000000000_0000000000000000`);
+			const events = await streamRes.json();
+			const hasRunComplete = events.some((e) => e.type === `run` && e.headers?.operation === `update`);
+			if (hasRunComplete) return events;
+			await new Promise((r) => setTimeout(r, 200));
+		}
+		throw new Error(`Agent did not respond within ${timeoutMs}ms`);
+	}
+	(0, vitest.describe)(`Mock Agent — End-to-End Pipeline`, () => {
+		(0, vitest.test)(`send message → mock agent writes State Protocol response`, async () => {
+			const id = `mock-e2e-${Date.now()}`;
+			const entityUrl = `/chat/${id}`;
+			await spawnEntity(config.baseUrl, `chat`, id);
+			await sendMessage(config.baseUrl, entityUrl, `Say hello`);
+			const events = await pollForAgentResponse(config.baseUrl, entityUrl);
+			const spEvents = events.filter((e) => e.type && e.key && e.headers);
+			(0, vitest.expect)(spEvents.some((e) => e.type === `run`)).toBe(true);
+			(0, vitest.expect)(spEvents.some((e) => e.type === `step`)).toBe(true);
+			(0, vitest.expect)(spEvents.some((e) => e.type === `text`)).toBe(true);
+			checkStateProtocolInvariants(spEvents);
+		}, 15e3);
+		(0, vitest.test)(`mock agent response contains expected text content`, async () => {
+			const id = `mock-text-${Date.now()}`;
+			const entityUrl = `/chat/${id}`;
+			await spawnEntity(config.baseUrl, `chat`, id);
+			await sendMessage(config.baseUrl, entityUrl, `What is 2+2?`);
+			const events = await pollForAgentResponse(config.baseUrl, entityUrl);
+			const textComplete = events.find((e) => e.type === `text` && e.headers?.operation === `update`);
+			(0, vitest.expect)(textComplete).toBeDefined();
+			const value = textComplete.value;
+			(0, vitest.expect)(value.status).toBe(`completed`);
+		}, 15e3);
+		(0, vitest.test)(`mock agent writes text deltas for streaming`, async () => {
+			const id = `mock-deltas-${Date.now()}`;
+			const entityUrl = `/chat/${id}`;
+			await spawnEntity(config.baseUrl, `chat`, id);
+			await sendMessage(config.baseUrl, entityUrl, `hello`);
+			const events = await pollForAgentResponse(config.baseUrl, entityUrl);
+			const deltas = events.filter((e) => e.type === `text_delta`);
+			(0, vitest.expect)(deltas.length).toBeGreaterThan(0);
+			for (const delta of deltas) {
+				const val = delta.value;
+				(0, vitest.expect)(val.delta).toBeDefined();
+				(0, vitest.expect)(typeof val.delta).toBe(`string`);
+			}
+		}, 15e3);
+	});
+}
+function runMockAgentCliTests(config) {
+	(0, vitest.describe)(`CLI — Mock Agent End-to-End`, () => {
+		(0, vitest.test)(`spawn → send → agent responds with State Protocol events`, async () => {
+			const id = `cli-mock-${Date.now()}`;
+			await cliTest(config.baseUrl, config.cliBin).exec(`spawn`, `/chat/${id}`).expectExitCode(0).expectStdout(/Spawned/).exec(`send`, `/chat/${id}`, `hello from CLI`).expectExitCode(0).expectStdout(/Message sent/).wait(3e3).verifyApi(async (baseUrl) => {
+				const res = await fetch(`${baseUrl}${routeControlPlanePath(`/chat/${id}`)}`);
+				(0, vitest.expect)(res.status, `entity should exist`).toBe(200);
+				const entity = await res.json();
+				const streams = entity.streams;
+				const streamRes = await fetch(`${baseUrl}${streams.main}?offset=0000000000000000_0000000000000000`);
+				const events = await streamRes.json();
+				(0, vitest.expect)(events.some((e) => e.type === `run`), `stream should contain run events from agent`).toBe(true);
+				(0, vitest.expect)(events.some((e) => e.type === `text`), `stream should contain text events from agent`).toBe(true);
+				checkStateProtocolInvariants(events.filter((e) => e.type && e.key && e.headers));
+			}).run();
+		}, 2e4);
+		(0, vitest.test)(`inspect shows entity after mock agent processes message`, async () => {
+			const id = `cli-inspect-mock-${Date.now()}`;
+			await cliTest(config.baseUrl, config.cliBin).exec(`spawn`, `/chat/${id}`).expectExitCode(0).exec(`send`, `/chat/${id}`, `test message`).expectExitCode(0).wait(3e3).exec(`inspect`, `/chat/${id}`).expectExitCode(0).expectStdout(/running|idle/).verifyApi(async (baseUrl) => {
+				const res = await fetch(`${baseUrl}${routeControlPlanePath(`/chat/${id}`)}`);
+				(0, vitest.expect)(res.status).toBe(200);
+				const entity = await res.json();
+				const streams = entity.streams;
+				const streamRes = await fetch(`${baseUrl}${streams.main}?offset=0000000000000000_0000000000000000`);
+				const events = await streamRes.json();
+				const hasRunComplete = events.some((e) => e.type === `run` && e.headers?.operation === `update`);
+				(0, vitest.expect)(hasRunComplete, `mock agent should have written run completion event`).toBe(true);
+			}).run();
+		}, 2e4);
+	});
+}
+
+//#endregion
+//#region src/mock-stream.ts
+function createMockStreamFn(text) {
+	return () => {
+		const partial = {
+			role: `assistant`,
+			stopReason: `stop`,
+			content: [],
+			api: `anthropic-messages`,
+			provider: `anthropic`,
+			model: `mock`,
+			usage: {
+				input: 10,
+				output: 5,
+				cacheRead: 0,
+				cacheWrite: 0,
+				totalTokens: 15,
+				cost: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					total: 0
+				}
+			},
+			timestamp: Date.now()
+		};
+		partial.content.push({
+			type: `text`,
+			text: ``
+		});
+		const events = [];
+		events.push({
+			type: `start`,
+			partial
+		});
+		events.push({
+			type: `text_start`,
+			contentIndex: 0,
+			partial
+		});
+		const chunks = text.match(/.{1,10}/g) ?? [text];
+		for (const chunk of chunks) {
+			const textContent$1 = partial.content[0];
+			if (textContent$1) textContent$1.text += chunk;
+			events.push({
+				type: `text_delta`,
+				contentIndex: 0,
+				delta: chunk,
+				partial
+			});
+		}
+		const textContent = partial.content[0];
+		events.push({
+			type: `text_end`,
+			contentIndex: 0,
+			content: textContent?.text ?? ``,
+			partial
+		});
+		events.push({
+			type: `done`,
+			reason: `stop`,
+			message: partial
+		});
+		let resolved = false;
+		let resolveResult;
+		const resultPromise = new Promise((res) => {
+			resolveResult = res;
+		});
+		const asyncIterable = {
+			[Symbol.asyncIterator]() {
+				let idx = 0;
+				return { async next() {
+					if (idx < events.length) {
+						const value = events[idx++];
+						if (!resolved && value.type === `done`) {
+							resolved = true;
+							resolveResult(value.message);
+						}
+						return {
+							value,
+							done: false
+						};
+					}
+					return {
+						value: void 0,
+						done: true
+					};
+				} };
+			},
+			result() {
+				return resultPromise;
+			}
+		};
+		return asyncIterable;
+	};
+}
+
+//#endregion
+exports.CliScenario = CliScenario
+exports.ElectricAgentsScenario = ElectricAgentsScenario
+exports.ServeEndpointReceiver = ServeEndpointReceiver
+exports.applyElectricAgentsAction = applyElectricAgentsAction
+exports.checkInvariants = checkInvariants
+exports.checkStateProtocolInvariants = checkStateProtocolInvariants
+exports.cliTest = cliTest
+exports.createMockStreamFn = createMockStreamFn
+exports.electricAgents = electricAgents
+exports.enabledElectricAgentsActions = enabledElectricAgentsActions
+exports.runCliConformanceTests = runCliConformanceTests
+exports.runElectricAgentsConformanceTests = runElectricAgentsConformanceTests
+exports.runMockAgentCliTests = runMockAgentCliTests
+exports.runMockAgentTests = runMockAgentTests