fix(app-control): bridge reads validator params from verification payload

Shaw · claude · Shaw · commit 7a8f31286450 · 2026-04-27T23:46:51.000-07:00
The orchestrator emits validator.params at the verification level
(sibling of the validator descriptor), not nested under validator.
The bridge's decoder previously looked at validator.params and so
silently dropped every event. Fixed and added unit coverage that
mirrors the real broadcast shape so future drift gets caught.

Also lands biome-formatting fixups.

Co-Authored-By: Claude Opus 4.7 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/plugins/plugin-app-control/typescript/src/actions/app-create.ts b/plugins/plugin-app-control/typescript/src/actions/app-create.ts
@@ -907,4 +907,3 @@ export async function hasPendingIntent(
 	const existing = await findExistingIntentTask(runtime, roomId);
 	return existing !== null;
 }
-
diff --git a/plugins/plugin-app-control/typescript/src/services/__tests__/verification-room-bridge.test.ts b/plugins/plugin-app-control/typescript/src/services/__tests__/verification-room-bridge.test.ts
@@ -0,0 +1,275 @@
+/**
+ * @module plugin-app-control/services/__tests__/verification-room-bridge
+ *
+ * Unit tests for VerificationRoomBridgeService.
+ *
+ * Covers:
+ *  - subscribes to SwarmCoordinator.subscribe on start
+ *  - filters out events with the wrong validator service or method
+ *  - filters out events without a verification.source === "custom-validator"
+ *  - filters out events without an originRoomId on the data payload
+ *  - posts a memory back into originRoomId for app pass / fail
+ *  - posts a memory back into originRoomId for plugin pass / fail
+ *  - logs and does not throw when the orchestrator service is missing
+ *  - unsubscribes on stop()
+ */
+
+import type { IAgentRuntime } from "@elizaos/core";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { VerificationRoomBridgeService } from "../verification-room-bridge.js";
+
+interface SwarmEventLike {
+	type: string;
+	sessionId: string;
+	timestamp: number;
+	data: unknown;
+}
+
+type Listener = (event: SwarmEventLike) => void;
+
+interface FakeCoordinator {
+	subscribe: ReturnType<typeof vi.fn>;
+	emit: (event: SwarmEventLike) => void;
+	listeners: Listener[];
+	unsubscribed: number;
+}
+
+/** Drain pending microtasks so async listener handlers run before assertions. */
+async function flushMicrotasks(): Promise<void> {
+	for (let i = 0; i < 8; i += 1) {
+		await Promise.resolve();
+	}
+}
+
+function createFakeCoordinator(): FakeCoordinator {
+	const listeners: Listener[] = [];
+	const coord: FakeCoordinator = {
+		subscribe: vi.fn((listener: Listener) => {
+			listeners.push(listener);
+			return () => {
+				const idx = listeners.indexOf(listener);
+				if (idx !== -1) listeners.splice(idx, 1);
+				coord.unsubscribed += 1;
+			};
+		}),
+		emit: (event: SwarmEventLike) => {
+			for (const l of listeners) l(event);
+		},
+		listeners,
+		unsubscribed: 0,
+	};
+	return coord;
+}
+
+function createRuntime(coordinator: FakeCoordinator | null): {
+	runtime: IAgentRuntime;
+	createMemory: ReturnType<typeof vi.fn>;
+} {
+	const createMemory = vi.fn(
+		async () => "00000000-0000-0000-0000-000000000000",
+	);
+	const runtime = {
+		agentId: "agent-1",
+		getService: vi.fn((name: string) =>
+			name === "SWARM_COORDINATOR" ? coordinator : null,
+		),
+		createMemory,
+	} as unknown as IAgentRuntime;
+	return { runtime, createMemory };
+}
+
+function passEvent(
+	originRoomId: string | undefined,
+	overrides?: Partial<{ method: string; appName: string; pluginName: string }>,
+): SwarmEventLike {
+	const method = overrides?.method ?? "verifyApp";
+	const params: Record<string, string> = {
+		workdir: "/tmp/wd",
+		profile: "full",
+	};
+	if (method === "verifyApp")
+		params.appName = overrides?.appName ?? "notes-app";
+	else params.pluginName = overrides?.pluginName ?? "plugin-notes";
+	return {
+		type: "task_complete",
+		sessionId: "s1",
+		timestamp: Date.now(),
+		data: {
+			reasoning: "validator pass",
+			verification: {
+				source: "custom-validator",
+				verdict: "pass",
+				validator: { service: "app-verification", method },
+				params,
+			},
+			originRoomId,
+			label: "create-app:notes-app",
+			workdir: "/tmp/wd",
+		},
+	};
+}
+
+function failEvent(originRoomId: string): SwarmEventLike {
+	return {
+		type: "escalation",
+		sessionId: "s1",
+		timestamp: Date.now(),
+		data: {
+			reason: "verification_failed",
+			summary: "Verification failed: tests=2 failed",
+			verifier: { service: "app-verification", method: "verifyApp" },
+			verification: {
+				source: "custom-validator",
+				verdict: "fail",
+				validator: { service: "app-verification", method: "verifyApp" },
+				params: { workdir: "/tmp/wd", appName: "notes-app", profile: "full" },
+			},
+			details: null,
+			retryCount: 3,
+			maxRetries: 3,
+			originRoomId,
+			label: "create-app:notes-app",
+			workdir: "/tmp/wd",
+		},
+	};
+}
+
+describe("VerificationRoomBridgeService", () => {
+	let coord: FakeCoordinator;
+
+	beforeEach(() => {
+		coord = createFakeCoordinator();
+	});
+
+	it("subscribes on start", async () => {
+		const { runtime } = createRuntime(coord);
+		await VerificationRoomBridgeService.start(runtime);
+		expect(coord.subscribe).toHaveBeenCalledTimes(1);
+	});
+
+	it("posts a memory into originRoomId on app pass", async () => {
+		const { runtime, createMemory } = createRuntime(coord);
+		await VerificationRoomBridgeService.start(runtime);
+		coord.emit(passEvent("room-42"));
+		await flushMicrotasks();
+		expect(createMemory).toHaveBeenCalledTimes(1);
+		const [memory, table] = createMemory.mock.calls[0] as [
+			{ roomId: string; content: { text: string; source: string } },
+			string,
+		];
+		expect(table).toBe("messages");
+		expect(memory.roomId).toBe("room-42");
+		expect(memory.content.source).toBe("verification-room-bridge");
+		expect(memory.content.text).toContain("notes-app");
+		expect(memory.content.text).toContain("built and verified");
+	});
+
+	it("posts a memory into originRoomId on plugin pass with reinject hint", async () => {
+		const { runtime, createMemory } = createRuntime(coord);
+		await VerificationRoomBridgeService.start(runtime);
+		coord.emit(
+			passEvent("room-42", {
+				method: "verifyPlugin",
+				pluginName: "plugin-notes",
+			}),
+		);
+		await flushMicrotasks();
+		expect(createMemory).toHaveBeenCalledTimes(1);
+		const [memory] = createMemory.mock.calls[0] as [
+			{ roomId: string; content: { text: string } },
+			string,
+		];
+		expect(memory.roomId).toBe("room-42");
+		expect(memory.content.text).toContain("plugin-notes");
+		expect(memory.content.text).toContain("reinject");
+	});
+
+	it("posts a fail message into originRoomId on escalation", async () => {
+		const { runtime, createMemory } = createRuntime(coord);
+		await VerificationRoomBridgeService.start(runtime);
+		coord.emit(failEvent("room-42"));
+		await flushMicrotasks();
+		expect(createMemory).toHaveBeenCalledTimes(1);
+		const [memory] = createMemory.mock.calls[0] as [
+			{ roomId: string; content: { text: string } },
+			string,
+		];
+		expect(memory.roomId).toBe("room-42");
+		expect(memory.content.text).toContain("verification failure");
+		expect(memory.content.text).toContain("3");
+	});
+
+	it("ignores events with no originRoomId", async () => {
+		const { runtime, createMemory } = createRuntime(coord);
+		await VerificationRoomBridgeService.start(runtime);
+		coord.emit(passEvent(undefined));
+		await flushMicrotasks();
+		expect(createMemory).not.toHaveBeenCalled();
+	});
+
+	it("ignores events from a different validator service", async () => {
+		const { runtime, createMemory } = createRuntime(coord);
+		await VerificationRoomBridgeService.start(runtime);
+		const evt: SwarmEventLike = {
+			type: "task_complete",
+			sessionId: "s1",
+			timestamp: Date.now(),
+			data: {
+				verification: {
+					source: "custom-validator",
+					verdict: "pass",
+					validator: { service: "some-other-service", method: "verifyApp" },
+					params: { workdir: "/tmp/wd", appName: "notes-app" },
+				},
+				originRoomId: "room-42",
+			},
+		};
+		coord.emit(evt);
+		await flushMicrotasks();
+		expect(createMemory).not.toHaveBeenCalled();
+	});
+
+	it("ignores task_complete events without verification metadata", async () => {
+		const { runtime, createMemory } = createRuntime(coord);
+		await VerificationRoomBridgeService.start(runtime);
+		const evt: SwarmEventLike = {
+			type: "task_complete",
+			sessionId: "s1",
+			timestamp: Date.now(),
+			data: { reasoning: "ok", originRoomId: "room-42" },
+		};
+		coord.emit(evt);
+		await flushMicrotasks();
+		expect(createMemory).not.toHaveBeenCalled();
+	});
+
+	it("ignores unrelated event types", async () => {
+		const { runtime, createMemory } = createRuntime(coord);
+		await VerificationRoomBridgeService.start(runtime);
+		const evt: SwarmEventLike = {
+			type: "task_status_changed",
+			sessionId: "s1",
+			timestamp: Date.now(),
+			data: { originRoomId: "room-42" },
+		};
+		coord.emit(evt);
+		await flushMicrotasks();
+		expect(createMemory).not.toHaveBeenCalled();
+	});
+
+	it("stays inert when SWARM_COORDINATOR is missing", async () => {
+		const { runtime, createMemory } = createRuntime(null);
+		const service = await VerificationRoomBridgeService.start(runtime);
+		expect(service).toBeInstanceOf(VerificationRoomBridgeService);
+		expect(createMemory).not.toHaveBeenCalled();
+	});
+
+	it("unsubscribes on stop()", async () => {
+		const { runtime } = createRuntime(coord);
+		const service = await VerificationRoomBridgeService.start(runtime);
+		expect(coord.listeners.length).toBe(1);
+		await service.stop();
+		expect(coord.listeners.length).toBe(0);
+		expect(coord.unsubscribed).toBe(1);
+	});
+});
diff --git a/plugins/plugin-app-control/typescript/src/services/verification-room-bridge.ts b/plugins/plugin-app-control/typescript/src/services/verification-room-bridge.ts
@@ -36,8 +36,7 @@ import { randomUUID } from "node:crypto";
 import type { IAgentRuntime, Memory, UUID } from "@elizaos/core";
 import { logger, Service } from "@elizaos/core";
 
-export const VERIFICATION_ROOM_BRIDGE_SERVICE_TYPE =
-	"verification-room-bridge";
+export const VERIFICATION_ROOM_BRIDGE_SERVICE_TYPE = "verification-room-bridge";
 
 const APP_VERIFICATION_SERVICE = "app-verification";
 const VERIFY_APP_METHOD = "verifyApp";
@@ -76,17 +75,24 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-function readString(record: Record<string, unknown>, key: string): string | undefined {
+function readString(
+	record: Record<string, unknown>,
+	key: string,
+): string | undefined {
 	const value = record[key];
-	return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+	return typeof value === "string" && value.trim().length > 0
+		? value
+		: undefined;
 }
 
 function readNumber(
 	record: Record<string, unknown>,
 	key: string,
 ): number | undefined {
 	const value = record[key];
-	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+	return typeof value === "number" && Number.isFinite(value)
+		? value
+		: undefined;
 }
 
 /**
@@ -118,10 +124,13 @@ function decodeEvent(event: SwarmEventLike): BridgeEventPayload | null {
 		return null;
 	}
 
-	const params = isRecord(validator.params) ? validator.params : null;
+	// Validator params live on the `verification` payload (sibling of the
+	// `validator` descriptor) — that's how swarm-decision-loop.ts emits them.
+	const params = isRecord(verification.params) ? verification.params : null;
 	if (!params) return null;
+	const method = validator.method;
 	const targetName =
-		validator.method === VERIFY_APP_METHOD
+		method === VERIFY_APP_METHOD
 			? readString(params, "appName")
 			: readString(params, "pluginName");
 	if (!targetName) return null;
@@ -135,7 +144,7 @@ function decodeEvent(event: SwarmEventLike): BridgeEventPayload | null {
 	return {
 		originRoomId,
 		verdict,
-		method: validator.method,
+		method,
 		targetName,
 		label: readString(event.data, "label"),
 		workdir: readString(event.data, "workdir"),

Original file line number	Diff line number	Diff line change
`@@ -907,4 +907,3 @@ export async function hasPendingIntent(`
`907`	`907`	`const existing = await findExistingIntentTask(runtime, roomId);`
`908`	`908`	`return existing !== null;`
`909`	`909`	`}`
`910`		`-`