@electric-ax/agents-server-conformance-tests 0.1.6 → 0.1.8

package/dist/index.js

@@ -4,10 +4,30 @@ import { createServer } from "node:http";
 import { Shape, ShapeStream } from "@electric-sql/client";
 import { execFile } from "node:child_process";
 
+//#region src/url.ts
+function appendPathToUrl(baseUrl, path) {
+	const base = new URL(baseUrl);
+	const pathUrl = new URL(path, `http://electric-agents.local`);
+	const basePath = base.pathname === `/` ? `` : base.pathname.replace(/\/+$/, ``);
+	const suffix = pathUrl.pathname.startsWith(`/`) ? pathUrl.pathname : `/${pathUrl.pathname}`;
+	const target = new URL(base);
+	target.pathname = `${basePath}${suffix}`;
+	target.search = ``;
+	target.hash = pathUrl.hash;
+	base.searchParams.forEach((value, key) => {
+		target.searchParams.append(key, value);
+	});
+	pathUrl.searchParams.forEach((value, key) => {
+		target.searchParams.append(key, value);
+	});
+	return target.toString();
+}
+
+//#endregion
 //#region src/electric-agents-dsl.ts
 async function fetchShapeRows(baseUrl, table) {
 	const stream = new ShapeStream({
-		url: `${baseUrl}/_electric/electric/v1/shape`,
+		url: appendPathToUrl(baseUrl, `/_electric/electric/v1/shape`),
 		params: { table },
 		subscribe: false
 	});
@@ -30,10 +50,8 @@ function toServerEntityTypeRegistration(registration) {
 		...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;
+	if (registration.inbox_schemas) body.inbox_schemas = registration.inbox_schemas;
+	if (registration.state_schemas) body.state_schemas = registration.state_schemas;
 	return body;
 }
 function normalizeWebhookPayload(body) {
@@ -174,7 +192,7 @@ var ServeEndpointReceiver = class {
 	}
 };
 async function electricAgentsFetch$1(baseUrl, path, opts = {}) {
-	return fetch(`${baseUrl}${routeControlPlanePath$1(path)}`, {
+	return fetch(appendPathToUrl(baseUrl, routeControlPlanePath$1(path)), {
 		...opts,
 		headers: {
 			"content-type": `application/json`,
@@ -193,7 +211,7 @@ function isEntityStreamPath$1(pathname) {
 	return segments.length >= 3 && (lastSegment === `main` || lastSegment === `error`);
 }
 function subscriptionEndpoint$1(baseUrl, id) {
-	return `${baseUrl}/__ds/subscriptions/${encodeURIComponent(id)}`;
+	return appendPathToUrl(baseUrl, `/__ds/subscriptions/${encodeURIComponent(id)}`);
 }
 function subscriptionPattern$1(pattern) {
 	return pattern.replace(/^\/+/, ``);
@@ -353,8 +371,8 @@ var ElectricAgentsScenario = class {
 		this.steps.push({
 			kind: `amendSchemas`,
 			name,
-			input_schemas: schemas.input_schemas,
-			output_schemas: schemas.output_schemas
+			inbox_schemas: schemas.inbox_schemas,
+			state_schemas: schemas.state_schemas
 		});
 		return this;
 	}
@@ -422,7 +440,7 @@ var ElectricAgentsScenario = class {
 			typeName,
 			instanceId,
 			args: opts?.args,
-			code: `SCHEMA_VALIDATION_ERROR`,
+			code: `SCHEMA_VALIDATION_FAILED`,
 			status: 422
 		});
 		return this;
@@ -432,7 +450,7 @@ var ElectricAgentsScenario = class {
 			kind: `expectSendSchemaError`,
 			payload,
 			messageType: opts?.type ?? `default`,
-			code: `SCHEMA_VALIDATION_ERROR`,
+			code: `SCHEMA_VALIDATION_FAILED`,
 			status: 422
 		});
 		return this;
@@ -442,7 +460,7 @@ var ElectricAgentsScenario = class {
 			kind: `expectWriteSchemaError`,
 			payload,
 			eventType: opts?.type ?? `default`,
-			code: `SCHEMA_VALIDATION_ERROR`,
+			code: `SCHEMA_VALIDATION_FAILED`,
 			status: 422
 		});
 		return this;
@@ -654,7 +672,13 @@ async function executeStep(ctx, step) {
 			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` });
+			const res = await electricAgentsFetch$1(ctx.baseUrl, `${entityUrl}/signal`, {
+				method: `POST`,
+				body: JSON.stringify({
+					signal: `SIGKILL`,
+					reason: `Killed by conformance test`
+				})
+			});
 			expect(res.status).toBe(200);
 			ctx.history.push({
 				type: `entity_killed`,
@@ -665,7 +689,7 @@ async function executeStep(ctx, step) {
 		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`);
+			const res = await fetch(appendPathToUrl(ctx.baseUrl, `${streamPath}?offset=0000000000000000_0000000000000000`));
 			if (res.status === 200) {
 				const text = await res.text();
 				const messages = text ? JSON.parse(text) : [];
@@ -806,8 +830,8 @@ async function executeStep(ctx, step) {
 		}
 		case `amendSchemas`: {
 			const body = {};
-			if (step.input_schemas) body.inbox_schemas = step.input_schemas;
-			if (step.output_schemas) body.state_schemas = step.output_schemas;
+			if (step.inbox_schemas) body.inbox_schemas = step.inbox_schemas;
+			if (step.state_schemas) body.state_schemas = step.state_schemas;
 			const res = await electricAgentsFetch$1(ctx.baseUrl, `/_electric/entity-types/${step.name}/schemas`, {
 				method: `PATCH`,
 				body: JSON.stringify(body)
@@ -1171,8 +1195,8 @@ function checkStreamPathsMatchEntityUrl(history) {
 /**
 * 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
+* running/idle → killed is valid (at kill time)
+* killed → running is NOT valid
 * Soundness: Sound | Completeness: Incomplete (only checks observed status reads)
 */
 function checkStatusTransitionsValid(history) {
@@ -1181,7 +1205,7 @@ function checkStatusTransitionsValid(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`) expect(event.status, `Safety: entity ${event.entityUrl} transitioned from stopped to ${event.status}`).toBe(`stopped`);
+			if (prev === `killed`) expect(event.status, `Safety: entity ${event.entityUrl} transitioned from killed to ${event.status}`).toBe(`killed`);
 			lastStatus.set(event.entityUrl, event.status);
 		}
 	}
@@ -1300,17 +1324,17 @@ function enabledElectricAgentsActions(model) {
 * Next relation — pure state transition for the model.
 * The real server execution happens separately in the property test.
 */
-function applyElectricAgentsAction(model, action, targetIdx) {
+function applyElectricAgentsAction(model, action, targetIdx, opts) {
 	switch (action) {
 		case `register_type`: {
 			const typeNum = model.entityTypes.length;
 			return {
 				...model,
 				entityTypes: [...model.entityTypes, {
-					name: `prop-type-${typeNum}`,
+					name: opts?.typeName ?? `prop-type-${typeNum}`,
 					hasCreationSchema: false,
-					hasInputSchemas: false,
-					hasOutputSchemas: false
+					hasInboxSchemas: false,
+					hasStateSchemas: false
 				}]
 			};
 		}
@@ -1357,7 +1381,7 @@ function applyElectricAgentsAction(model, action, targetIdx) {
 			const e = entities[targetIdx];
 			entities[targetIdx] = {
 				...e,
-				status: `stopped`
+				status: `killed`
 			};
 			return {
 				...model,
@@ -1468,7 +1492,7 @@ function checkStateProtocolInvariants(events) {
 //#endregion
 //#region src/cli-dsl.ts
 function subscriptionEndpoint(baseUrl, id) {
-	return `${baseUrl}/__ds/subscriptions/${encodeURIComponent(id)}`;
+	return appendPathToUrl(baseUrl, `/__ds/subscriptions/${encodeURIComponent(id)}`);
 }
 function subscriptionPattern(pattern) {
 	return pattern.replace(/^\/+/, ``);
@@ -1617,7 +1641,7 @@ var CliScenario = class {
 		try {
 			for (const step of this.steps) switch (step.kind) {
 				case `setupType`: {
-					const res = await fetch(`${this.baseUrl}/_electric/entity-types`, {
+					const res = await fetch(appendPathToUrl(this.baseUrl, `/_electric/entity-types`), {
 						method: `POST`,
 						headers: { "content-type": `application/json` },
 						body: JSON.stringify(step.registration)
@@ -1746,7 +1770,7 @@ function startNoopReceiver() {
 //#endregion
 //#region src/electric-agents-tests.ts
 async function electricAgentsFetch(baseUrl, path, opts = {}) {
-	return fetch(`${baseUrl}${routeControlPlanePath(path)}`, {
+	return fetch(appendPathToUrl(baseUrl, routeControlPlanePath(path)), {
 		...opts,
 		headers: {
 			"content-type": `application/json`,
@@ -1767,7 +1791,7 @@ function isEntityStreamPath(pathname) {
 async function pollEntityStatus(baseUrl, entityUrl, statuses, timeoutMs = 8e3) {
 	const deadline = Date.now() + timeoutMs;
 	while (Date.now() < deadline) {
-		const res = await fetch(`${baseUrl}${routeControlPlanePath(entityUrl)}`);
+		const res = await fetch(appendPathToUrl(baseUrl, routeControlPlanePath(entityUrl)));
 		expect(res.status).toBe(200);
 		const entity = await res.json();
 		if (statuses.includes(String(entity.status))) return entity;
@@ -1782,13 +1806,13 @@ function runElectricAgentsConformanceTests(config) {
 			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` });
+			const mainRes = await fetch(appendPathToUrl(ctx.baseUrl, ctx.currentEntityStreams.main), { method: `HEAD` });
 			expect(mainRes.status).toBe(200);
-			const errorRes = await fetch(`${ctx.baseUrl}${ctx.currentEntityStreams.error}`, { method: `HEAD` });
+			const errorRes = await fetch(appendPathToUrl(ctx.baseUrl, ctx.currentEntityStreams.error), { method: `HEAD` });
 			expect(errorRes.status).toBe(200);
 		}).run());
 		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`)}`, {
+			const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`/unregistered/entity-1`)), {
 				method: `PUT`,
 				headers: { "content-type": `application/json` },
 				body: JSON.stringify({})
@@ -1830,7 +1854,7 @@ function runElectricAgentsConformanceTests(config) {
 			creation_schema: { type: `object` }
 		}).spawn(`webhook-ctx-agent`, `entity-1`).send({ ping: true }).expectWebhook().expectEntityContext({ type: `webhook-ctx-agent` }).respondDone().run());
 		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`)}`, {
+			const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`/nonexistent-type/nonexistent-id/send`)), {
 				method: `POST`,
 				headers: { "content-type": `application/json` },
 				body: JSON.stringify({ payload: {} })
@@ -1878,8 +1902,8 @@ function runElectricAgentsConformanceTests(config) {
 				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) => {
-				expect(ctx.lastListResult.every((e) => e.status === `stopped`)).toBe(true);
+			}).spawn(`status-filter-agent`, `entity-1`).spawn(`status-filter-agent`, `entity-2`).kill().list({ status: `killed` }).custom(async (ctx) => {
+				expect(ctx.lastListResult.every((e) => e.status === `killed`)).toBe(true);
 			}).list({ status: `running` }).custom(async (ctx) => {
 				expect(ctx.lastListResult.every((e) => [`running`, `idle`].includes(e.status))).toBe(true);
 			}).run();
@@ -1894,7 +1918,7 @@ function runElectricAgentsConformanceTests(config) {
 			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());
+		}).spawn(`kill-test-agent`, `entity-1`).kill().expectStatus(`killed`).expectSendError(`NOT_RUNNING`, 409).run());
 		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`,
@@ -1903,8 +1927,9 @@ function runElectricAgentsConformanceTests(config) {
 			const msgs = ctx.lastStreamMessages;
 			const msgReceived = msgs.find((m) => m.type === `inbox`);
 			expect(msgReceived.value?.payload).toEqual({ before: `kill` });
-			const stopped = msgs.find((m) => m.type === `entity_stopped`);
-			expect(stopped).toBeDefined();
+			const signal = msgs.find((m) => m.type === `signal`);
+			expect(signal).toBeDefined();
+			expect(signal.value?.signal).toBe(`SIGKILL`);
 		}).run());
 		test.skip(`multiple entities under same subscription`, () => {
 			let firstEntityUrl = null;
@@ -1918,7 +1943,10 @@ function runElectricAgentsConformanceTests(config) {
 			}).spawn(`multi-test-worker`, `entity-2`).custom(async (ctx) => {
 				secondEntityUrl = ctx.currentEntityUrl;
 			}).custom(async (ctx) => {
-				const res = await electricAgentsFetch(ctx.baseUrl, firstEntityUrl, { method: `DELETE` });
+				const res = await electricAgentsFetch(ctx.baseUrl, `${firstEntityUrl}/signal`, {
+					method: `POST`,
+					body: JSON.stringify({ signal: `SIGKILL` })
+				});
 				expect(res.status).toBe(200);
 				ctx.history.push({
 					type: `entity_killed`,
@@ -1940,8 +1968,8 @@ function runElectricAgentsConformanceTests(config) {
 			description: `Test entity type for E2E lifecycle`,
 			creation_schema: { type: `object` }
 		}).spawn(`e2e-test-agent`, `entity-1`).expectStatus(`running`).send({ task: `do-something` }).expectWebhook().expectEntityContext({ type: `e2e-test-agent` }).respondDone().readStream().expectStreamContains(`inbox`).kill().custom(async (ctx) => {
-			const entity = await pollEntityStatus(ctx.baseUrl, ctx.currentEntityUrl, [`stopped`]);
-			expect(entity.status).toBe(`stopped`);
+			const entity = await pollEntityStatus(ctx.baseUrl, ctx.currentEntityUrl, [`killed`]);
+			expect(entity.status).toBe(`killed`);
 		}).expectSendError(`NOT_RUNNING`, 409).run());
 	});
 	describe(`Electric Agents Entity Type Registration`, () => {
@@ -1952,12 +1980,12 @@ function runElectricAgentsConformanceTests(config) {
 				type: `object`,
 				properties: { name: { type: `string` } }
 			},
-			input_schemas: { query: {
+			inbox_schemas: { query: {
 				type: `object`,
 				properties: { text: { type: `string` } },
 				required: [`text`]
 			} },
-			output_schemas: { result: {
+			state_schemas: { result: {
 				type: `object`,
 				properties: { answer: { type: `string` } }
 			} }
@@ -1993,7 +2021,7 @@ function runElectricAgentsConformanceTests(config) {
 					type: `object`,
 					properties: { x: { type: `number` } }
 				},
-				input_schemas: { ping: {
+				inbox_schemas: { ping: {
 					type: `object`,
 					properties: { msg: { type: `string` } }
 				} }
@@ -2019,7 +2047,7 @@ function runElectricAgentsConformanceTests(config) {
 				description: `First registration`,
 				creation_schema: { type: `object` }
 			}).custom(async (ctx) => {
-				const res = await fetch(`${ctx.baseUrl}/_electric/entity-types`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, `/_electric/entity-types`), {
 					method: `POST`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({
@@ -2036,7 +2064,7 @@ function runElectricAgentsConformanceTests(config) {
 			}).run();
 		});
 		test(`register rejects missing required fields`, () => electricAgents(config.baseUrl).custom(async (ctx) => {
-			const res = await fetch(`${ctx.baseUrl}/_electric/entity-types`, {
+			const res = await fetch(appendPathToUrl(ctx.baseUrl, `/_electric/entity-types`), {
 				method: `POST`,
 				headers: { "content-type": `application/json` },
 				body: JSON.stringify({})
@@ -2081,7 +2109,7 @@ function runElectricAgentsConformanceTests(config) {
 			}).expectSpawnSchemaError(typeName, `bad-entity-1`, { args: { invalid: true } }).run();
 		});
 		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`)}`, {
+			const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`/nonexistent/should-fail`)), {
 				method: `PUT`,
 				headers: { "content-type": `application/json` },
 				body: JSON.stringify({})
@@ -2100,7 +2128,7 @@ function runElectricAgentsConformanceTests(config) {
 			}).spawn(typeName, `parent-entity`).custom(async (ctx) => {
 				parentUrl = ctx.currentEntityUrl;
 			}).custom(async (ctx) => {
-				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`/${typeName}/child-entity`)}`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`/${typeName}/child-entity`)), {
 					method: `PUT`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({ parent: parentUrl })
@@ -2127,7 +2155,7 @@ function runElectricAgentsConformanceTests(config) {
 				description: `Type for orphan spawn test`,
 				creation_schema: { type: `object` }
 			}).custom(async (ctx) => {
-				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`/${typeName}/orphan-entity`)}`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`/${typeName}/orphan-entity`)), {
 					method: `PUT`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({ parent: `/nonexistent/parent` })
@@ -2148,7 +2176,7 @@ function runElectricAgentsConformanceTests(config) {
 				color: `blue`,
 				count: `42`
 			} }).custom(async (ctx) => {
-				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(ctx.currentEntityUrl)}`);
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(ctx.currentEntityUrl)));
 				const entity = await res.json();
 				const tags = entity.tags;
 				expect(tags.color).toBe(`blue`);
@@ -2162,7 +2190,7 @@ function runElectricAgentsConformanceTests(config) {
 				name: typeName,
 				description: `Type with string-only tags`
 			}).custom(async (ctx) => {
-				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`/${typeName}/should-fail`)}`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`/${typeName}/should-fail`)), {
 					method: `PUT`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({ tags: { wrong: 123 } })
@@ -2176,20 +2204,20 @@ function runElectricAgentsConformanceTests(config) {
 				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 res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(ctx.currentEntityUrl)));
 				const entity = await res.json();
 				expect(entity.tags).toEqual({});
 			}).run();
 		});
 	});
 	describe(`Electric Agents Schema Validation Gates`, () => {
-		test(`send validates input_schemas (C11)`, () => {
+		test(`send validates inbox_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`,
+				description: `Type with inbox schemas`,
 				creation_schema: { type: `object` },
-				input_schemas: { query: {
+				inbox_schemas: { query: {
 					type: `object`,
 					properties: { text: { type: `string` } },
 					required: [`text`]
@@ -2200,9 +2228,9 @@ function runElectricAgentsConformanceTests(config) {
 			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`,
+				description: `Type with strict inbox schemas`,
 				creation_schema: { type: `object` },
-				input_schemas: { query: {
+				inbox_schemas: { query: {
 					type: `object`,
 					properties: { text: { type: `string` } },
 					required: [`text`]
@@ -2213,30 +2241,30 @@ function runElectricAgentsConformanceTests(config) {
 			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`,
+				description: `Type with defined inbox schemas`,
 				creation_schema: { type: `object` },
-				input_schemas: { query: {
+				inbox_schemas: { query: {
 					type: `object`,
 					properties: { text: { type: `string` } },
 					required: [`text`]
 				} }
 			}).spawn(typeName, `entity-1`).expectSendUnknownType({ text: `hi` }, { type: `unknown_type` }).run();
 		});
-		test(`send without type when no input_schemas accepts any`, () => {
+		test(`send without type when no inbox_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`,
+				description: `Type without inbox schemas`,
 				creation_schema: { type: `object` }
 			}).spawn(typeName, `entity-1`).send({ anything: `goes` }).expectWebhook().respondDone().run();
 		});
-		test(`send with empty input_schemas rejects all`, () => {
+		test(`send with empty inbox_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`,
+				description: `Type with empty inbox schemas`,
 				creation_schema: { type: `object` },
-				input_schemas: {}
+				inbox_schemas: {}
 			}).spawn(typeName, `entity-1`).expectSendUnknownType({ text: `anything` }, { type: `some_type` }).run();
 		});
 		test.skip(`write appends event to entity stream`, () => {
@@ -2245,7 +2273,7 @@ function runElectricAgentsConformanceTests(config) {
 				name: typeName,
 				description: `Type for write test`,
 				creation_schema: { type: `object` },
-				output_schemas: { research_result: {
+				state_schemas: { research_result: {
 					type: `object`,
 					properties: { findings: {
 						type: `array`,
@@ -2254,13 +2282,13 @@ function runElectricAgentsConformanceTests(config) {
 				} }
 			}).spawn(typeName, `entity-1`).write({ findings: [`test`] }, { type: `research_result` }).readStream().expectStreamContains(`research_result`).run();
 		});
-		test.skip(`write validates output_schemas (C12)`, () => {
+		test.skip(`write validates state_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`,
+				description: `Type with strict state schemas`,
 				creation_schema: { type: `object` },
-				output_schemas: { result: {
+				state_schemas: { result: {
 					type: `object`,
 					properties: { value: { type: `number` } },
 					required: [`value`]
@@ -2271,19 +2299,19 @@ function runElectricAgentsConformanceTests(config) {
 			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`,
+				description: `Type with defined state schemas`,
 				creation_schema: { type: `object` },
-				output_schemas: { result: {
+				state_schemas: { result: {
 					type: `object`,
 					properties: { value: { type: `number` } }
 				} }
 			}).spawn(typeName, `entity-1`).expectWriteUnknownType({ data: `test` }, { type: `unknown_event` }).run();
 		});
-		test.skip(`write without type when no output_schemas accepts any`, () => {
+		test.skip(`write without type when no state_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`,
+				description: `Type without state schemas`,
 				creation_schema: { type: `object` }
 			}).spawn(typeName, `entity-1`).write({ anything: `goes` }).run();
 		});
@@ -2296,7 +2324,7 @@ function runElectricAgentsConformanceTests(config) {
 			}).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`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, `${ctx.currentEntityUrl}/main`), {
 					method: `POST`,
 					headers: writeHeaders,
 					body: JSON.stringify({
@@ -2350,7 +2378,7 @@ function runElectricAgentsConformanceTests(config) {
 			}).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`)}`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`${ctx.currentEntityUrl}/tags/owner`)), {
 					method: `POST`,
 					headers: tagHeaders,
 					body: JSON.stringify({ value: 123 })
@@ -2370,7 +2398,7 @@ function runElectricAgentsConformanceTests(config) {
 			}).custom(async (ctx) => {
 				const tagHeaders = {};
 				if (ctx.currentWriteToken) tagHeaders.authorization = `Bearer ${ctx.currentWriteToken}`;
-				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`${ctx.currentEntityUrl}/tags/priority`)}`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`${ctx.currentEntityUrl}/tags/priority`)), {
 					method: `DELETE`,
 					headers: tagHeaders
 				});
@@ -2403,12 +2431,12 @@ function runElectricAgentsConformanceTests(config) {
 				name: typeName,
 				description: `Type for schema amendment`,
 				creation_schema: { type: `object` },
-				input_schemas: { query: {
+				inbox_schemas: { query: {
 					type: `object`,
 					properties: { text: { type: `string` } },
 					required: [`text`]
 				} }
-			}).amendSchemas(typeName, { input_schemas: { command: {
+			}).amendSchemas(typeName, { inbox_schemas: { command: {
 				type: `object`,
 				properties: { action: { type: `string` } },
 				required: [`action`]
@@ -2420,13 +2448,13 @@ function runElectricAgentsConformanceTests(config) {
 				name: typeName,
 				description: `Type for schema conflict test`,
 				creation_schema: { type: `object` },
-				input_schemas: { query: {
+				inbox_schemas: { query: {
 					type: `object`,
 					properties: { text: { type: `string` } },
 					required: [`text`]
 				} }
 			}).custom(async (ctx) => {
-				const res = await fetch(`${ctx.baseUrl}/_electric/entity-types/${typeName}/schemas`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, `/_electric/entity-types/${typeName}/schemas`), {
 					method: `PATCH`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({ inbox_schemas: { query: {
@@ -2443,13 +2471,13 @@ function runElectricAgentsConformanceTests(config) {
 				name: typeName,
 				description: `Type for revision pinning test`,
 				creation_schema: { type: `object` },
-				input_schemas: { query: {
+				inbox_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`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, `/_electric/entity-types/${typeName}/schemas`), {
 					method: `PATCH`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({ inbox_schemas: { new_command: {
@@ -2459,7 +2487,7 @@ function runElectricAgentsConformanceTests(config) {
 				});
 				expect(res.status).toBe(200);
 			}).custom(async (ctx) => {
-				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`${ctx.currentEntityUrl}/send`)}`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`${ctx.currentEntityUrl}/send`)), {
 					method: `POST`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({
@@ -2490,7 +2518,7 @@ function runElectricAgentsConformanceTests(config) {
 			};
 			await receiver.start(manifest);
 			try {
-				const res = await fetch(`${ctx.baseUrl}/_electric/entity-types`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, `/_electric/entity-types`), {
 					method: `POST`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({
@@ -2539,7 +2567,6 @@ function runElectricAgentsConformanceTests(config) {
 				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: [],
@@ -2547,21 +2574,21 @@ function runElectricAgentsConformanceTests(config) {
 					nextEntityNum: 0
 				};
 				let entityCounter = 0;
+				let typeCounter = 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 typeNum = typeCounter++;
 							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`);
+							model = applyElectricAgentsAction(model, `register_type`, void 0, { typeName });
 							break;
 						}
 						case `delete_type`: {
@@ -2569,14 +2596,13 @@ function runElectricAgentsConformanceTests(config) {
 							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);
+							scenario.deleteType(model.entityTypes[deleteIdx].name);
 							model = applyElectricAgentsAction(model, `delete_type`);
 							break;
 						}
 						case `spawn`: {
-							if (registeredTypeNames.length === 0) break;
-							const typeName = registeredTypeNames[0];
+							if (model.entityTypes.length === 0) break;
+							const typeName = model.entityTypes[0].name;
 							const instanceId = `entity-${entityCounter++}`;
 							scenario.spawn(typeName, instanceId);
 							scenario.custom(async (ctx) => {
@@ -2621,7 +2647,10 @@ function runElectricAgentsConformanceTests(config) {
 							scenario.custom(async (ctx) => {
 								const url = entityUrls[targetIdx];
 								if (!url) return;
-								const res = await electricAgentsFetch(ctx.baseUrl, url, { method: `DELETE` });
+								const res = await electricAgentsFetch(ctx.baseUrl, `${url}/signal`, {
+									method: `POST`,
+									body: JSON.stringify({ signal: `SIGKILL` })
+								});
 								expect(res.status).toBe(200);
 								ctx.history.push({
 									type: `entity_killed`,
@@ -2995,7 +3024,10 @@ function runElectricAgentsConformanceTests(config) {
 					description: `test`
 				})
 			});
-			const res = await electricAgentsFetch(config.baseUrl, `/${typeName}/nonexistent-id-12345`, { method: `DELETE` });
+			const res = await electricAgentsFetch(config.baseUrl, `/${typeName}/nonexistent-id-12345/signal`, {
+				method: `POST`,
+				body: JSON.stringify({ signal: `SIGKILL` })
+			});
 			expect(res.status).toBe(404);
 			const body = await res.json();
 			expect(body.error.code).toBe(`NOT_FOUND`);
@@ -3064,7 +3096,7 @@ function runElectricAgentsConformanceTests(config) {
 				name: `rev-multi-agent-${id}`,
 				description: `Test multi-revision pinning`,
 				creation_schema: { type: `object` },
-				input_schemas: { greet: {
+				inbox_schemas: { greet: {
 					type: `object`,
 					properties: { name: { type: `string` } },
 					required: [`name`]
@@ -3105,7 +3137,7 @@ function runElectricAgentsConformanceTests(config) {
 			}).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` } } })
+					body: JSON.stringify({ inbox_schemas: { msg: { type: `object` } } })
 				});
 				expect(res.status).toBe(404);
 			}).run();
@@ -3181,7 +3213,7 @@ function runElectricAgentsConformanceTests(config) {
 				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`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, `${ctx.currentEntityUrl}/main`), {
 					method: `POST`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({
@@ -3201,7 +3233,7 @@ function runElectricAgentsConformanceTests(config) {
 				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`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, `${ctx.currentEntityUrl}/main`), {
 					method: `POST`,
 					headers: {
 						"content-type": `application/json`,
@@ -3234,7 +3266,7 @@ function runElectricAgentsConformanceTests(config) {
 				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`)}`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`${ctx.currentEntityUrl}/tags/key`)), {
 					method: `POST`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({ value: `value` })
@@ -3259,7 +3291,7 @@ function runElectricAgentsConformanceTests(config) {
 				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`)}`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`${ctx.currentEntityUrl}/send`)), {
 					method: `POST`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({ payload: `hi` })
@@ -3274,7 +3306,7 @@ function runElectricAgentsConformanceTests(config) {
 				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)}`);
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(ctx.currentEntityUrl)));
 				expect(res.status).toBe(200);
 				const entity = await res.json();
 				expect(entity.write_token).toBeUndefined();
@@ -3344,7 +3376,7 @@ function runCliConformanceTests(config) {
 				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}`)}`);
+				const res = await fetch(appendPathToUrl(baseUrl, routeControlPlanePath(`/cli-spawn-type/${id}`)));
 				expect(res.status).toBe(200);
 				const entity = await res.json();
 				expect([`running`, `idle`]).toContain(entity.status);
@@ -3387,11 +3419,11 @@ function runCliConformanceTests(config) {
 				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}`)}`);
+				const res = await fetch(appendPathToUrl(baseUrl, routeControlPlanePath(`/cli-send-type/${id}`)));
 				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 streamRes = await fetch(appendPathToUrl(baseUrl, `${streams.main}?offset=0000000000000000_0000000000000000`));
 				const events = await streamRes.json();
 				expect(events.length).toBeGreaterThanOrEqual(1);
 				const msgEvent = events.find((e) => e.type === `inbox`);
@@ -3411,7 +3443,7 @@ function runCliConformanceTests(config) {
 				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}`)}`);
+				const res = await fetch(appendPathToUrl(baseUrl, routeControlPlanePath(`/cli-inspect-etype/${id}`)));
 				expect(res.status).toBe(200);
 				const entity = await res.json();
 				expect([`running`, `idle`]).toContain(entity.status);
@@ -3428,8 +3460,8 @@ function runCliConformanceTests(config) {
 				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`]);
-				expect(entity.status).toBe(`stopped`);
+				const entity = await pollEntityStatus(baseUrl, `/cli-kill-type/${id}`, [`killed`]);
+				expect(entity.status).toBe(`killed`);
 			}).run();
 		}, 15e3);
 		test(`kill nonexistent entity fails`, async () => {
@@ -3443,13 +3475,13 @@ function runCliConformanceTests(config) {
 				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}`)}`);
+				const res = await fetch(appendPathToUrl(baseUrl, routeControlPlanePath(`/cli-lifecycle-type/${id}`)));
 				expect(res.status, `entity should exist after spawn`).toBe(200);
 				const entity = await res.json();
 				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`]);
-				expect(entity.status).toBe(`stopped`);
+				const entity = await pollEntityStatus(baseUrl, `/cli-lifecycle-type/${id}`, [`killed`]);
+				expect(entity.status).toBe(`killed`);
 			}).exec(`ps`, `--status`, `running`).expectExitCode(0).expectStdoutNot(new RegExp(id)).run();
 		}, 15e3);
 		test(`send to stopped entity fails`, async () => {
@@ -3474,7 +3506,7 @@ function runCliConformanceTests(config) {
 }
 function runMockAgentTests(config) {
 	async function spawnEntity(baseUrl, typeName, instanceId) {
-		const res = await fetch(`${baseUrl}${routeControlPlanePath(`/${encodeURIComponent(typeName)}/${encodeURIComponent(instanceId)}`)}`, {
+		const res = await fetch(appendPathToUrl(baseUrl, routeControlPlanePath(`/${encodeURIComponent(typeName)}/${encodeURIComponent(instanceId)}`)), {
 			method: `PUT`,
 			headers: { "content-type": `application/json` },
 			body: JSON.stringify({})
@@ -3483,7 +3515,7 @@ function runMockAgentTests(config) {
 		return await res.json();
 	}
 	async function sendMessage(baseUrl, entityUrl, text) {
-		const res = await fetch(`${baseUrl}${routeControlPlanePath(`${entityUrl}/send`)}`, {
+		const res = await fetch(appendPathToUrl(baseUrl, routeControlPlanePath(`${entityUrl}/send`)), {
 			method: `POST`,
 			headers: { "content-type": `application/json` },
 			body: JSON.stringify({ payload: { text } })
@@ -3493,11 +3525,11 @@ function runMockAgentTests(config) {
 	async function pollForAgentResponse(baseUrl, entityUrl, timeoutMs = 1e4) {
 		const start = Date.now();
 		while (Date.now() - start < timeoutMs) {
-			const entityRes = await fetch(`${baseUrl}${routeControlPlanePath(entityUrl)}`);
+			const entityRes = await fetch(appendPathToUrl(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 streamRes = await fetch(appendPathToUrl(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;
@@ -3550,11 +3582,11 @@ function runMockAgentCliTests(config) {
 		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}`)}`);
+				const res = await fetch(appendPathToUrl(baseUrl, routeControlPlanePath(`/chat/${id}`)));
 				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 streamRes = await fetch(appendPathToUrl(baseUrl, `${streams.main}?offset=0000000000000000_0000000000000000`));
 				const events = await streamRes.json();
 				expect(events.some((e) => e.type === `run`), `stream should contain run events from agent`).toBe(true);
 				expect(events.some((e) => e.type === `text`), `stream should contain text events from agent`).toBe(true);
@@ -3564,11 +3596,11 @@ function runMockAgentCliTests(config) {
 		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}`)}`);
+				const res = await fetch(appendPathToUrl(baseUrl, routeControlPlanePath(`/chat/${id}`)));
 				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 streamRes = await fetch(appendPathToUrl(baseUrl, `${streams.main}?offset=0000000000000000_0000000000000000`));
 				const events = await streamRes.json();
 				const hasRunComplete = events.some((e) => e.type === `run` && e.headers?.operation === `update`);
 				expect(hasRunComplete, `mock agent should have written run completion event`).toBe(true);