a2a-exposed 0.8.16 → 0.8.18

package/worker/test/context-peer.test.ts

@@ -0,0 +1,290 @@
+// A context id is one conversation per peer. A client-supplied id this peer does not already hold
+// starts that peer's own conversation, whether or not another peer already uses the same string.
+// Run: npm test
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import worker from "../src/index.ts";
+import { d1 } from "./d1.ts";
+
+const BASE = "https://agent.example.com";
+
+function setup() {
+	const DB = d1(new URL("../migrations/", import.meta.url));
+	const env: any = {
+		DB, PUBLIC_URL: BASE, OWNER_TOKEN: "owner-secret", AGENT_NAME: "Test Inbox", WAKE_PRESET: "generic",
+		WAKE_DEBOUNCE_SECONDS: "3600", WAKE_WEBHOOK_URL: "https://hook.example.net/wake", WAKE_WEBHOOK_KEY: "hook-key",
+	};
+	const origFetch = globalThis.fetch;
+	globalThis.fetch = (async () => new Response("ok")) as typeof fetch;
+	const call = async (method: string, path: string, json?: unknown, auth = "Bearer owner-secret") => {
+		const headers: Record<string, string> = { authorization: auth, "content-type": "application/json", "cf-connecting-ip": "198.51.100.7" };
+		const pending: Promise<unknown>[] = [];
+		const res = await worker.fetch(new Request(BASE + path, { method, headers, body: json === undefined ? undefined : JSON.stringify(json) }) as any,
+			env, { waitUntil: (p: Promise<unknown>) => pending.push(p), passThroughOnException() {} } as any);
+		await Promise.allSettled(pending);
+		const text = await res.text();
+		let data: any = text;
+		try { data = text ? JSON.parse(text) : null; } catch { /* not json */ }
+		return { status: res.status, data, text };
+	};
+	const owner = (method: string, path: string, json?: unknown) => call(method, path, json);
+	const send = (token: string, text: string, contextId?: string, method = "message/send") => call("POST", "/", {
+		jsonrpc: "2.0", id: 1, method,
+		params: { message: { kind: "message", role: "user", messageId: crypto.randomUUID(), ...(contextId ? { contextId } : {}), parts: [{ kind: "text", text }] } },
+	}, `Bearer ${token}`);
+	return { DB, owner, send, call, restore: () => { globalThis.fetch = origFetch; } };
+}
+
+/** The 0.3 task, or the 1.0 `{ task }` wrapper, minus fields that are new on every call. */
+function opened(data: any) {
+	const task = data?.result?.kind === "task" || data?.result?.status ? data.result : data?.result?.task;
+	const history = Array.isArray(task?.history) ? task.history : [];
+	return {
+		contextId: task?.contextId,
+		state: task?.status?.state,
+		texts: history.map((m: { parts?: { text?: string }[] }) => (m.parts || []).map((p) => p.text || "").join("\n")),
+		roles: history.map((m: { role?: string }) => m.role),
+	};
+}
+
+function hides(body: string, secret: string) {
+	assert.equal(body.includes(secret), false);
+}
+
+test("a foreign contextId opens the caller's own conversation and does not reveal the other one", async (t) => {
+	const s = setup();
+	t.after(s.restore);
+	const ada = (await s.owner("POST", "/owner/peers", { label: "ada" })).data.token as string;
+	const bob = (await s.owner("POST", "/owner/peers", { label: "bob" })).data.token as string;
+	assert.match(ada, /^a2aow_/);
+	assert.match(bob, /^a2aow_/);
+	const pushToken = `pt_${crypto.randomUUID()}`;
+
+	const first = await s.send(ada, "y-one", "ctx-y");
+	assert.equal(first.status, 200);
+	assert.equal(first.data.result.contextId, "ctx-y");
+	const second = await s.send(ada, "y-two", "ctx-y");
+	assert.equal(second.status, 200);
+	assert.equal(second.data.result.contextId, "ctx-y");
+	const adaTask = second.data.result.id as string;
+	s.DB.db.prepare("UPDATE tasks SET push_configs_json = ? WHERE id = ?").run(JSON.stringify([{ id: "cfg-ada", url: "https://hooks.example.net/ada", token: pushToken, _version: "0.3" }]), adaTask);
+
+	const history = (from?: string) => s.owner("GET", `/owner/history/ctx-y${from ? `?from=${from}` : ""}`);
+	const beforeHist = await history("ada");
+	assert.equal(beforeHist.status, 200);
+	assert.deepEqual((beforeHist.data as { text: string; peer: string }[]).map((r) => [r.peer, r.text]), [["ada", "y-one"], ["ada", "y-two"]]);
+	const wake = (peer: string) => s.DB.db.prepare("SELECT context_id, peer, last_sent_ms, pending_json, pending_since_ms FROM wakes WHERE context_id = 'ctx-y' AND peer = ?").get(peer) as {
+		pending_json: string; peer: string; last_sent_ms: number; pending_since_ms: number;
+	} | undefined;
+	const beforeWake = wake("ada");
+	assert.equal(beforeWake?.peer, "ada");
+	const pending = JSON.parse(beforeWake!.pending_json);
+	assert.equal(pending.from, "ada");
+	assert.equal(pending.preview, "y-two");
+	assert.equal(pending.taskIds.includes(adaTask), true);
+
+	const listedForeign = await s.call("POST", "/", {
+		jsonrpc: "2.0", id: 1, method: "ListTasks", params: { contextId: "ctx-y", pageSize: 50 },
+	}, `Bearer ${bob}`);
+	const listedFresh = await s.call("POST", "/", {
+		jsonrpc: "2.0", id: 1, method: "ListTasks", params: { contextId: "ctx-never-seen", pageSize: 50 },
+	}, `Bearer ${bob}`);
+	assert.equal(listedForeign.status, 200);
+	assert.equal(listedFresh.status, 200);
+	assert.deepEqual(listedForeign.data.result, listedFresh.data.result);
+	assert.deepEqual(listedForeign.data.result, { tasks: [], nextPageToken: "", pageSize: 50, totalSize: 0 });
+	hides(listedForeign.text, "y-one");
+	hides(listedForeign.text, "y-two");
+	hides(listedForeign.text, pushToken);
+	hides(listedForeign.text, ada);
+
+	const foreign = await s.send(bob, "x-inject", "ctx-y");
+	const fresh = await s.send(bob, "x-inject", "ctx-new");
+	assert.equal(foreign.status, 200);
+	assert.equal(fresh.status, 200);
+	assert.equal(foreign.data.error, undefined);
+	assert.equal(fresh.data.error, undefined);
+	assert.deepEqual(opened(foreign.data), { contextId: "ctx-y", state: "submitted", texts: ["x-inject"], roles: ["user"] });
+	assert.deepEqual(opened(fresh.data), { contextId: "ctx-new", state: "submitted", texts: ["x-inject"], roles: ["user"] });
+	hides(foreign.text, "y-one");
+	hides(foreign.text, "y-two");
+	hides(foreign.text, pushToken);
+	hides(foreign.text, ada);
+	hides(foreign.text, bob);
+
+	const foreignV1 = await s.send(bob, "x-inject-v1", "ctx-y", "SendMessage");
+	assert.equal(foreignV1.status, 200);
+	assert.equal(foreignV1.data.result.task.contextId, "ctx-y");
+	assert.deepEqual((foreignV1.data.result.task.history || []).map((m: { parts: { text: string }[] }) => m.parts.map((p) => p.text).join("\n")), ["x-inject-v1"]);
+	hides(foreignV1.text, "y-one");
+	hides(foreignV1.text, pushToken);
+
+	const adaRows = await history("ada");
+	assert.deepEqual(adaRows.data, beforeHist.data);
+	assert.deepEqual(wake("ada"), beforeWake);
+	const db = s.DB.db;
+	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM tasks WHERE context_id = 'ctx-y' AND peer = 'ada'").get() as { n: number }).n, 2);
+	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM messages WHERE context_id = 'ctx-y' AND message_json LIKE '%y-one%'").get() as { n: number }).n, 1);
+	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM messages WHERE task_id = ? AND message_json LIKE '%x-inject%'").get(adaTask) as { n: number }).n, 0);
+	const bobWake = wake("bob");
+	assert.equal(bobWake?.peer, "bob");
+	assert.equal(JSON.parse(bobWake!.pending_json).from, "bob");
+	assert.equal(JSON.parse(bobWake!.pending_json).preview, "x-inject-v1");
+	assert.equal(JSON.parse(beforeWake!.pending_json).preview, "y-two");
+
+	const owners = db.prepare("SELECT peer FROM conversation_owners WHERE context_id = 'ctx-y' ORDER BY peer").all() as { peer: string }[];
+	assert.deepEqual(owners.map((r) => r.peer), ["ada", "bob"]);
+
+	const steal = await s.call("POST", "/", {
+		jsonrpc: "2.0", id: 1, method: "message/send",
+		params: { message: { kind: "message", role: "user", messageId: crypto.randomUUID(), taskId: adaTask, contextId: "ctx-y", parts: [{ kind: "text", text: "steal" }] } },
+	}, `Bearer ${bob}`);
+	assert.deepEqual(steal.data.error, { code: -32001, message: "Task not found" });
+	hides(steal.text, "y-one");
+	hides(steal.text, pushToken);
+	const got = await s.call("POST", "/", { jsonrpc: "2.0", id: 1, method: "tasks/get", params: { id: adaTask } }, `Bearer ${bob}`);
+	assert.deepEqual(got.data.error, { code: -32001, message: "Task not found" });
+	hides(got.text, pushToken);
+	hides(got.text, "y-two");
+
+	const follow = await s.send(ada, "y-three", "ctx-y");
+	assert.equal(follow.status, 200);
+	assert.equal(follow.data.result.contextId, "ctx-y");
+	assert.deepEqual(((await history("ada")).data as { text: string; peer: string }[]).map((r) => r.text), ["y-one", "y-two", "y-three"]);
+	assert.equal(((await history("ada")).data as { peer: string }[]).every((r) => r.peer === "ada"), true);
+	const bobOnly = (await history("bob")).data as { text: string; peer: string }[];
+	assert.deepEqual(bobOnly.map((r) => r.text), ["x-inject", "x-inject-v1"]);
+	assert.equal(bobOnly.every((r) => r.peer === "bob"), true);
+	const mixed = (await history()).data as { text: string; peer: string }[];
+	assert.deepEqual(mixed.map((r) => r.peer), ["ada", "ada", "bob", "bob", "ada"]);
+	const after = JSON.parse(wake("ada")!.pending_json);
+	assert.equal(after.from, "ada");
+	assert.equal(after.preview, "y-three");
+	assert.equal(String(after.preview).includes("x-inject"), false);
+
+	const adaInbox = await s.owner("GET", "/owner/inbox?context=ctx-y&from=ada&all=1");
+	const bobInbox = await s.owner("GET", "/owner/inbox?context=ctx-y&from=bob&all=1");
+	assert.equal((adaInbox.data as { from: string; text: string }[]).every((r) => r.from === "ada"), true);
+	assert.equal((bobInbox.data as { from: string; text: string }[]).every((r) => r.from === "bob"), true);
+	assert.equal((adaInbox.data as { text: string }[]).some((r) => r.text === "x-inject"), false);
+	assert.equal((bobInbox.data as { text: string }[]).some((r) => r.text === "y-one"), false);
+
+	const adaList = await s.call("POST", "/", { jsonrpc: "2.0", id: 1, method: "ListTasks", params: { contextId: "ctx-y" } }, `Bearer ${ada}`);
+	const bobList = await s.call("POST", "/", { jsonrpc: "2.0", id: 1, method: "ListTasks", params: { contextId: "ctx-y" } }, `Bearer ${bob}`);
+	assert.equal(adaList.data.result.totalSize, 3);
+	assert.equal(bobList.data.result.totalSize, 2);
+	assert.equal((adaList.data.result.tasks as { id: string }[]).some((t) => t.id === adaTask), true);
+	assert.equal((bobList.data.result.tasks as { id: string }[]).some((t) => t.id === adaTask), false);
+	hides(bobList.text, pushToken);
+	hides(bobList.text, "y-one");
+
+	const own = await s.send(bob, "x-own", "ctx-x");
+	assert.equal(own.status, 200);
+	assert.equal(own.data.result.contextId, "ctx-x");
+	const again = await s.send(bob, "x-again", "ctx-x");
+	assert.equal(again.status, 200);
+	assert.equal(again.data.result.contextId, "ctx-x");
+	const omitted = await s.send(bob, "x-omit");
+	assert.equal(omitted.status, 200);
+	assert.match(omitted.data.result.contextId, /^[0-9a-f-]{36}$/);
+	assert.equal(omitted.data.result.contextId === "ctx-y", false);
+	const bobHist = await s.owner("GET", "/owner/history/ctx-x?from=bob");
+	assert.deepEqual((bobHist.data as { text: string }[]).map((r) => r.text), ["x-own", "x-again"]);
+});
+
+test("an outbound row on the same context id is not joined into the other peer's task", async (t) => {
+	const s = setup();
+	t.after(s.restore);
+	const ada = (await s.owner("POST", "/owner/peers", { label: "ada" })).data.token as string;
+	const bob = (await s.owner("POST", "/owner/peers", { label: "bob" })).data.token as string;
+	const aliasText = "alias-outbound-secret";
+	await s.send(ada, "y-one", "ctx-y");
+	const db = s.DB.db;
+	db.prepare("INSERT INTO outbound (task_id, context_id, peer, sent_at, updates_json) VALUES ('out-1', 'ctx-y', 'alias', '2026-01-01T00:00:00.000Z', '[]')").run();
+	db.prepare("INSERT INTO history (context_id, ts, dir, peer, task_id, text) VALUES ('ctx-y', '2026-01-01T00:00:00.000Z', 'in', 'alias', 'out-1', ?)").run(aliasText);
+
+	const sent = await s.send(bob, "from-bob", "ctx-y");
+	assert.equal(sent.status, 200);
+	assert.deepEqual(opened(sent.data).texts, ["from-bob"]);
+	hides(sent.text, aliasText);
+	const bobHist = await s.owner("GET", "/owner/history/ctx-y?from=bob");
+	assert.equal((bobHist.data as { text: string }[]).some((r) => r.text === aliasText), false);
+	const adaHist = await s.owner("GET", "/owner/history/ctx-y?from=ada");
+	assert.equal((adaHist.data as { text: string }[]).some((r) => r.text === aliasText), false);
+	assert.deepEqual((adaHist.data as { text: string }[]).map((r) => r.text), ["y-one"]);
+	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM tasks WHERE context_id = 'ctx-y' AND peer = 'ada'").get() as { n: number }).n, 1);
+	assert.equal((db.prepare("SELECT text FROM history WHERE task_id = 'out-1'").get() as { text: string }).text, aliasText);
+});
+
+test("two peers can both open one unused contextId without sharing history or wakes", async (t) => {
+	const s = setup();
+	t.after(s.restore);
+	const ada = (await s.owner("POST", "/owner/peers", { label: "ada" })).data.token as string;
+	const bob = (await s.owner("POST", "/owner/peers", { label: "bob" })).data.token as string;
+	let arrived = 0;
+	let openGate = () => {};
+	const gate = new Promise<void>((resolve) => { openGate = resolve; });
+	const orig = s.DB.batch.bind(s.DB);
+	s.DB.batch = async (stmts: { __sql?: string }[]) => {
+		const claim = stmts.some((st) => typeof st.__sql === "string" && st.__sql.includes("INSERT INTO conversation_owners"));
+		if (!claim || arrived >= 2) return orig(stmts);
+		arrived++;
+		if (arrived === 2) openGate();
+		await gate;
+		return orig(stmts);
+	};
+	const [left, right] = await Promise.all([
+		s.send(ada, "from-ada", "ctx-race"),
+		s.send(bob, "from-bob", "ctx-race"),
+	]);
+	assert.equal(arrived, 2);
+	assert.equal(left.status, 200);
+	assert.equal(right.status, 200);
+	assert.equal(left.data.error, undefined);
+	assert.equal(right.data.error, undefined);
+	assert.equal(left.data.result.contextId, "ctx-race");
+	assert.equal(right.data.result.contextId, "ctx-race");
+	assert.deepEqual(opened(left.data).texts, ["from-ada"]);
+	assert.deepEqual(opened(right.data).texts, ["from-bob"]);
+	hides(left.text, "from-bob");
+	hides(right.text, "from-ada");
+	hides(left.text, bob);
+	hides(right.text, ada);
+
+	const db = s.DB.db;
+	const owners = db.prepare("SELECT peer FROM conversation_owners WHERE context_id = 'ctx-race' ORDER BY peer").all() as { peer: string }[];
+	assert.deepEqual(owners.map((r) => r.peer), ["ada", "bob"]);
+	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM tasks WHERE context_id = 'ctx-race'").get() as { n: number }).n, 2);
+	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM tasks WHERE context_id = 'ctx-race' AND peer = 'ada'").get() as { n: number }).n, 1);
+	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM tasks WHERE context_id = 'ctx-race' AND peer = 'bob'").get() as { n: number }).n, 1);
+	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM history WHERE context_id = 'ctx-race' AND peer = 'ada' AND text = 'from-bob'").get() as { n: number }).n, 0);
+	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM history WHERE context_id = 'ctx-race' AND peer = 'bob' AND text = 'from-ada'").get() as { n: number }).n, 0);
+	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM messages WHERE context_id = 'ctx-race' AND message_json LIKE '%from-ada%' AND message_json LIKE '%from-bob%'").get() as { n: number }).n, 0);
+	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM wakes WHERE context_id = 'ctx-race'").get() as { n: number }).n, 2);
+	const wakeRow = (peer: string) => db.prepare("SELECT pending_json, last_sent_ms FROM wakes WHERE context_id = 'ctx-race' AND peer = ?").get(peer) as { pending_json: string | null; last_sent_ms: number };
+	// The first message of a conversation is sent at once, so neither row is holding the other's text.
+	assert.equal(wakeRow("ada").pending_json, null);
+	assert.equal(wakeRow("bob").pending_json, null);
+	assert.equal(wakeRow("ada").last_sent_ms > 0 && wakeRow("bob").last_sent_ms > 0, true);
+
+	const followAda = await s.send(ada, "follow-ada", "ctx-race");
+	const adaPendingJson = wakeRow("ada").pending_json;
+	const followBob = await s.send(bob, "follow-bob", "ctx-race");
+	assert.equal(followAda.data.result.contextId, "ctx-race");
+	assert.equal(followBob.data.result.contextId, "ctx-race");
+	assert.equal(wakeRow("ada").pending_json, adaPendingJson);
+	const adaPending = JSON.parse(adaPendingJson || "null");
+	const bobPending = JSON.parse(wakeRow("bob").pending_json || "null");
+	assert.equal(adaPending.preview, "follow-ada");
+	assert.equal(bobPending.preview, "follow-bob");
+	assert.equal(adaPending.taskIds.includes(right.data.result.id), false);
+	assert.equal(adaPending.taskIds.includes(followBob.data.result.id), false);
+	assert.equal(bobPending.taskIds.includes(left.data.result.id), false);
+	assert.equal(bobPending.taskIds.includes(followAda.data.result.id), false);
+	const adaHist = await s.owner("GET", "/owner/history/ctx-race?from=ada");
+	const bobHist = await s.owner("GET", "/owner/history/ctx-race?from=bob");
+	assert.deepEqual((adaHist.data as { text: string; peer: string }[]).map((r) => r.text), ["from-ada", "follow-ada"]);
+	assert.deepEqual((bobHist.data as { text: string; peer: string }[]).map((r) => r.text), ["from-bob", "follow-bob"]);
+	assert.equal((adaHist.data as { peer: string }[]).every((r) => r.peer === "ada"), true);
+	assert.equal((bobHist.data as { peer: string }[]).every((r) => r.peer === "bob"), true);
+});

package/worker/test/facade.test.ts

@@ -326,7 +326,9 @@ test("proxy mode: peers sharing the upstream identity can't touch each other's t
 	for (const [method, params] of [
 		["GetTask", { id: taskId }], ["CancelTask", { id: taskId }], ["tasks/get", { id: taskId }],
 		["GetTaskPushNotificationConfig", { taskId, id: "x" }], ["ListTaskPushNotificationConfig", { taskId }],
-		["DeleteTaskPushNotificationConfig", { taskId, id: "x" }], ["GetTask", { id: "never-seen" }],
+		["ListTaskPushNotificationConfigs", { taskId }], ["DeleteTaskPushNotificationConfig", { taskId, id: "x" }],
+		["tasks/pushNotificationConfig/list", { id: taskId }], ["tasks/pushNotificationConfig/delete", { id: taskId, pushNotificationConfigId: "x" }],
+		["GetTask", { id: "never-seen" }],
 	] as const) {
 		const x = await s.rpc(b, method, params);
 		assert.equal(x.data.error?.code, -32001, `${method}: ${JSON.stringify(x.data)}`);
@@ -390,7 +392,9 @@ test("proxy mode: push configs never reach the upstream (it would call them from
 		["CreateTaskPushNotificationConfig", { taskId, url: "https://hooks.example.org/b" }],
 		["tasks/pushNotificationConfig/set", { taskId, pushNotificationConfig: { url: "https://hooks.example.org/b" } }],
 		["GetTaskPushNotificationConfig", { taskId, id: "x" }], ["ListTaskPushNotificationConfig", { taskId }],
-		["DeleteTaskPushNotificationConfig", { taskId, id: "x" }], ["tasks/pushNotificationConfig/get", { id: taskId }],
+		["ListTaskPushNotificationConfigs", { taskId }], ["DeleteTaskPushNotificationConfig", { taskId, id: "x" }],
+		["tasks/pushNotificationConfig/list", { id: taskId }], ["tasks/pushNotificationConfig/delete", { id: taskId, pushNotificationConfigId: "x" }],
+		["tasks/pushNotificationConfig/get", { id: taskId }],
 	] as const) {
 		const r = await s.rpc(a, method, params);
 		assert.equal(r.data.error?.code, -32003, method);

package/worker/test/list-tasks.test.ts

@@ -0,0 +1,120 @@
+// ListTasks returns a cursor. The page is this peer's tasks, newest update first. Run: npm test
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import worker from "../src/index.ts";
+import { d1 } from "./d1.ts";
+
+const BASE = "https://agent.example.com";
+
+function setup() {
+	const DB = d1(new URL("../migrations/", import.meta.url));
+	const env: any = {
+		DB, PUBLIC_URL: BASE, OWNER_TOKEN: "owner-secret", AGENT_NAME: "Test Inbox", WAKE_PRESET: "generic",
+	};
+	const call = async (token: string, method: string, params: unknown) => {
+		const res = await worker.fetch(new Request(BASE + "/", {
+			method: "POST",
+			headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+			body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
+		}) as any, env, { waitUntil() {}, passThroughOnException() {} } as any);
+		const text = await res.text();
+		let data: any = text;
+		try { data = text ? JSON.parse(text) : null; } catch { /* not json */ }
+		return { status: res.status, data, text };
+	};
+	const owner = async (method: string, path: string, json?: unknown) => {
+		const res = await worker.fetch(new Request(BASE + path, {
+			method, headers: { authorization: "Bearer owner-secret", "content-type": "application/json" },
+			body: json === undefined ? undefined : JSON.stringify(json),
+		}) as any, env, { waitUntil() {}, passThroughOnException() {} } as any);
+		return res.json() as Promise<any>;
+	};
+	return { DB, call, owner };
+}
+
+function stamp(n: number): string {
+	return `2026-01-01T00:00:${String(n).padStart(2, "0")}.000Z`;
+}
+
+function decodeCursor(token: string): { updatedAt: string; id: string } {
+	const pad = token.length % 4 === 0 ? "" : "=".repeat(4 - (token.length % 4));
+	const text = Buffer.from(token.replace(/-/g, "+").replace(/_/g, "/") + pad, "base64").toString();
+	const nl = text.indexOf("\n");
+	return { updatedAt: text.slice(0, nl), id: text.slice(nl + 1) };
+}
+
+test("ListTasks pages with nextPageToken and stays on the caller", async () => {
+	const s = setup();
+	const ada = (await s.owner("POST", "/owner/peers", { label: "ada" })).token as string;
+	const bob = (await s.owner("POST", "/owner/peers", { label: "bob" })).token as string;
+	const insert = s.DB.db.prepare(`INSERT INTO tasks (id, context_id, peer, state, protocol, created_at, updated_at, status_json, artifacts_json, push_configs_json)
+		VALUES (?, 'ctx-page', ?, 'submitted', '1.0', ?, ?, ?, '[]', '[]')`);
+	const ids: string[] = [];
+	for (let n = 1; n <= 16; n++) {
+		const id = `t-${String(n).padStart(2, "0")}`;
+		ids.push(id);
+		// t-16 and t-15 share a timestamp so the tie breaks on id descending.
+		const at = stamp(n === 15 ? 16 : n);
+		insert.run(id, "ada", at, at, JSON.stringify({ state: "submitted", timestamp: at }));
+	}
+	insert.run("t-bob", "bob", stamp(30), stamp(30), JSON.stringify({ state: "submitted", timestamp: stamp(30) }));
+	const expected = [...ids].reverse();
+	assert.deepEqual(expected.slice(0, 2), ["t-16", "t-15"]);
+
+	const seen: string[] = [];
+	let token = "";
+	let pages = 0;
+	let total = -1;
+	do {
+		const page = await s.call(ada, "ListTasks", { pageSize: 5, ...(token ? { pageToken: token } : {}) });
+		assert.equal(page.status, 200);
+		assert.equal(page.data.error, undefined);
+		const result = page.data.result;
+		assert.equal(result.pageSize, 5);
+		assert.equal(result.totalSize, 16);
+		total = result.totalSize;
+		const pageIds = (result.tasks as { id: string; contextId: string }[]).map((task) => task.id);
+		assert.equal(pageIds.includes("t-bob"), false);
+		assert.equal((result.tasks as { contextId: string }[]).every((task) => task.contextId === "ctx-page"), true);
+		if (result.nextPageToken) {
+			const cursor = decodeCursor(result.nextPageToken);
+			assert.equal(cursor.id, pageIds[pageIds.length - 1]);
+			assert.equal(result.tasks.length, 5);
+		} else {
+			assert.equal(result.nextPageToken, "");
+		}
+		seen.push(...pageIds);
+		token = result.nextPageToken;
+		pages++;
+	} while (token);
+	assert.equal(pages, 4);
+	assert.equal(total, 16);
+	assert.deepEqual(seen, expected);
+	assert.equal(new Set(seen).size, 16);
+
+	const bobPage = await s.call(bob, "ListTasks", { pageSize: 5 });
+	assert.deepEqual((bobPage.data.result.tasks as { id: string }[]).map((task) => task.id), ["t-bob"]);
+	assert.equal(bobPage.data.result.totalSize, 1);
+	assert.equal(bobPage.data.result.nextPageToken, "");
+
+	const filtered = await s.call(ada, "ListTasks", { contextId: "ctx-page", pageSize: 100 });
+	assert.equal(filtered.data.result.totalSize, 16);
+	assert.equal(filtered.data.result.pageSize, 100);
+	assert.equal(filtered.data.result.nextPageToken, "");
+	const empty = await s.call(ada, "ListTasks", { contextId: "ctx-none" });
+	assert.deepEqual(empty.data.result, { tasks: [], nextPageToken: "", pageSize: 50, totalSize: 0 });
+	const badContext = await s.call(ada, "ListTasks", { contextId: "bad id" });
+	assert.equal(badContext.data.error?.code, -32602);
+
+	const bad = "page-token-secret-value";
+	const rejected = await s.call(ada, "ListTasks", { pageToken: bad });
+	assert.deepEqual(rejected.data.error, { code: -32602, message: "Invalid params: pageToken" });
+	assert.equal(rejected.text.includes(bad), false);
+	const garbage = Buffer.from("not-a-cursor", "utf8").toString("base64url");
+	const rejectedGarbage = await s.call(ada, "ListTasks", { pageToken: garbage });
+	assert.equal(rejectedGarbage.data.error?.message, "Invalid params: pageToken");
+	assert.equal(rejectedGarbage.text.includes(garbage), false);
+
+	const absent = await s.call(ada, "tasks/list", {});
+	assert.equal(absent.data.error?.code, -32601);
+});

package/worker/test/migrations.test.ts

@@ -57,7 +57,7 @@ test("migration files: NNNN_name.sql, unique numbers, no gaps, 0002_wake_budget
 test("fresh database: every migration applies in order; a second run applies nothing", () => {
 	const db = new DatabaseSync(":memory:");
 	assert.deepEqual(applyMigrations(db), [...FILES].sort(byNumber));
-	for (const t of ["peers", "tasks", "wakes", "wake_budget", "device_requests", "pairing_rate", "settings", "facade_owners", "oauth_clients", "oauth_codes", "mcp_grants", "outbound_peers", "oauth_client_metadata", "oidc_txns"]) assert.ok(tables(db).includes(t), t);
+	for (const t of ["peers", "tasks", "wakes", "wake_budget", "device_requests", "pairing_rate", "settings", "facade_owners", "oauth_clients", "oauth_codes", "mcp_grants", "outbound_peers", "oauth_client_metadata", "oidc_txns", "conversation_owners"]) assert.ok(tables(db).includes(t), t);
 	assert.ok(columns(db, "peers").includes("source"));
 	assert.ok(columns(db, "device_requests").includes("replaces_label"));
 	assert.ok(columns(db, "device_requests").includes("replaces_hash"));
@@ -67,15 +67,15 @@ test("fresh database: every migration applies in order; a second run applies not
 test("database from the 0002 fix (0001-0003 recorded): only 0004 and later apply; pending requests keep working", () => {
 	const db = existingDb([sql("0001_init.sql"), sql("0002_wake_budget.sql"), sql("0003_device_pairing.sql")], ["0001_init.sql", "0002_wake_budget.sql", "0003_device_pairing.sql"]);
 	db.prepare("INSERT INTO device_requests (device_hash, user_code, status, created_ms, expires_ms, interval_s) VALUES ('h', 'WDJB4827', 'pending', 1, 2, 5)").run();
-	assert.deepEqual(applyMigrations(db), ["0004_pairing_replace.sql", "0005_facade_owners.sql", "0006_mcp.sql", "0007_cimd.sql", "0008_oidc_txns.sql", "0009_outbound_seen.sql"]);
+	assert.deepEqual(applyMigrations(db), ["0004_pairing_replace.sql", "0005_facade_owners.sql", "0006_mcp.sql", "0007_cimd.sql", "0008_oidc_txns.sql", "0009_outbound_seen.sql", "0010_conversation_peer.sql", "0011_conversation_owner.sql", "0012_conversation_peer_owner.sql"]);
 	assert.equal((db.prepare("SELECT replaces_label FROM device_requests WHERE device_hash = 'h'").get() as any).replaces_label, null);
 });
 
 test("database from v0.2.0 (0001 and 0003 recorded): 0002 applies as a no-op and keeps the data", () => {
 	const db = existingDb([sql("0001_init.sql"), sql("0003_device_pairing.sql")], ["0001_init.sql", "0003_device_pairing.sql"]);
 	db.prepare("INSERT INTO wake_budget (hour, count) VALUES (1, 7)").run();
-	assert.deepEqual(applyMigrations(db), ["0002_wake_budget.sql", "0004_pairing_replace.sql", "0005_facade_owners.sql", "0006_mcp.sql", "0007_cimd.sql", "0008_oidc_txns.sql", "0009_outbound_seen.sql"]);
-	assert.deepEqual(recorded(db), ["0001_init.sql", "0003_device_pairing.sql", "0002_wake_budget.sql", "0004_pairing_replace.sql", "0005_facade_owners.sql", "0006_mcp.sql", "0007_cimd.sql", "0008_oidc_txns.sql", "0009_outbound_seen.sql"]);
+	assert.deepEqual(applyMigrations(db), ["0002_wake_budget.sql", "0004_pairing_replace.sql", "0005_facade_owners.sql", "0006_mcp.sql", "0007_cimd.sql", "0008_oidc_txns.sql", "0009_outbound_seen.sql", "0010_conversation_peer.sql", "0011_conversation_owner.sql", "0012_conversation_peer_owner.sql"]);
+	assert.deepEqual(recorded(db), ["0001_init.sql", "0003_device_pairing.sql", "0002_wake_budget.sql", "0004_pairing_replace.sql", "0005_facade_owners.sql", "0006_mcp.sql", "0007_cimd.sql", "0008_oidc_txns.sql", "0009_outbound_seen.sql", "0010_conversation_peer.sql", "0011_conversation_owner.sql", "0012_conversation_peer_owner.sql"]);
 	assert.equal((db.prepare("SELECT count FROM wake_budget WHERE hour = 1").get() as any).count, 7);
 });
 
@@ -107,7 +107,7 @@ test("database from an earlier build without wake_budget (0001 and 0003 recorded
 		assert.equal(before.data.error?.code, -32603, JSON.stringify(before.data));
 		assert.equal(wakes.length, 0);
 
-		assert.deepEqual(applyMigrations(db), ["0002_wake_budget.sql", "0004_pairing_replace.sql", "0005_facade_owners.sql", "0006_mcp.sql", "0007_cimd.sql", "0008_oidc_txns.sql", "0009_outbound_seen.sql"]);
+		assert.deepEqual(applyMigrations(db), ["0002_wake_budget.sql", "0004_pairing_replace.sql", "0005_facade_owners.sql", "0006_mcp.sql", "0007_cimd.sql", "0008_oidc_txns.sql", "0009_outbound_seen.sql", "0010_conversation_peer.sql", "0011_conversation_owner.sql", "0012_conversation_peer_owner.sql"]);
 		assert.deepEqual(columns(db, "wake_budget"), ["hour", "count"]);
 		assert.deepEqual(applyMigrations(db), []);
 
@@ -122,3 +122,50 @@ test("database from an earlier build without wake_budget (0001 and 0003 recorded
 		globalThis.fetch = origFetch;
 	}
 });
+
+test("0010 keys an existing wake by the peer in its payload and allows a second peer", () => {
+	const prior = [...FILES].sort(byNumber).filter((f) => f !== "0010_conversation_peer.sql");
+	const db = existingDb(prior.map(sql), prior);
+	db.prepare(`INSERT INTO tasks (id, context_id, peer, state, protocol, created_at, updated_at, status_json, artifacts_json, push_configs_json)
+		VALUES ('t1', 'ctx-y', 'ada', 'submitted', '0.3', 't', 't', '{}', '[]', '[]')`).run();
+	const pending = JSON.stringify({ contextId: "ctx-y", from: "ada", taskId: "t1", taskIds: ["t1"], kind: "inbound", preview: "hi" });
+	db.prepare("INSERT INTO wakes (context_id, last_sent_ms, pending_json, pending_since_ms) VALUES ('ctx-y', 5, ?, 5)").run(pending);
+	assert.deepEqual(applyMigrations(db), ["0010_conversation_peer.sql"]);
+	const row = db.prepare("SELECT peer, pending_json, last_sent_ms FROM wakes WHERE context_id = 'ctx-y'").get() as { peer: string; pending_json: string; last_sent_ms: number };
+	assert.equal(row.peer, "ada");
+	assert.equal(row.last_sent_ms, 5);
+	assert.equal(JSON.parse(row.pending_json).preview, "hi");
+	db.prepare("INSERT INTO wakes (context_id, peer, last_sent_ms) VALUES ('ctx-y', 'bob', 6)").run();
+	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM wakes WHERE context_id = 'ctx-y'").get() as { n: number }).n, 2);
+	assert.equal((db.prepare("SELECT pending_json FROM wakes WHERE context_id = 'ctx-y' AND peer = 'ada'").get() as { pending_json: string }).pending_json, pending);
+});
+
+test("0011 keeps one owner per context from the earliest task, then history, then outbound", () => {
+	const prior = [...FILES].sort(byNumber).filter((f) => f !== "0011_conversation_owner.sql" && f !== "0012_conversation_peer_owner.sql");
+	const db = existingDb(prior.map(sql), prior);
+	const task = `INSERT INTO tasks (id, context_id, peer, state, protocol, created_at, updated_at, status_json, artifacts_json, push_configs_json)
+		VALUES (?, ?, ?, 'submitted', '0.3', ?, ?, '{}', '[]', '[]')`;
+	db.prepare(task).run("t-bob", "ctx-y", "bob", "2026-02-01T00:00:00.000Z", "2026-02-01T00:00:00.000Z");
+	db.prepare(task).run("t-ada", "ctx-y", "ada", "2026-01-01T00:00:00.000Z", "2026-01-01T00:00:00.000Z");
+	db.prepare("INSERT INTO history (context_id, ts, dir, peer, text) VALUES ('ctx-h', '2026-01-01T00:00:00.000Z', 'local', 'ada', 'note')").run();
+	db.prepare("INSERT INTO outbound (task_id, context_id, peer, sent_at) VALUES ('o1', 'ctx-o', 'alias', '2026-01-01T00:00:00.000Z')").run();
+	assert.deepEqual(applyMigrations(db, ["0011_conversation_owner.sql"]), ["0011_conversation_owner.sql"]);
+	const owner = (id: string) => (db.prepare("SELECT peer FROM conversation_owners WHERE context_id = ?").get(id) as { peer: string }).peer;
+	assert.equal(owner("ctx-y"), "ada");
+	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM conversation_owners WHERE context_id = 'ctx-y'").get() as { n: number }).n, 1);
+	assert.equal(owner("ctx-h"), "ada");
+	assert.equal(owner("ctx-o"), "alias");
+	assert.throws(() => db.prepare("INSERT INTO conversation_owners (context_id, peer, created_at) VALUES ('ctx-y', 'bob', 'later')").run());
+});
+
+test("0012 lets each peer own the same context id and keeps the first row", () => {
+	const prior = [...FILES].sort(byNumber).filter((f) => f !== "0012_conversation_peer_owner.sql");
+	const db = existingDb(prior.map(sql), prior);
+	db.prepare("INSERT INTO conversation_owners (context_id, peer, created_at) VALUES ('ctx-y', 'ada', '2026-01-01T00:00:00.000Z')").run();
+	assert.throws(() => db.prepare("INSERT INTO conversation_owners (context_id, peer, created_at) VALUES ('ctx-y', 'bob', 'later')").run());
+	assert.deepEqual(applyMigrations(db), ["0012_conversation_peer_owner.sql"]);
+	assert.equal((db.prepare("SELECT created_at FROM conversation_owners WHERE context_id = 'ctx-y' AND peer = 'ada'").get() as { created_at: string }).created_at, "2026-01-01T00:00:00.000Z");
+	db.prepare("INSERT INTO conversation_owners (context_id, peer, created_at) VALUES ('ctx-y', 'bob', 'later')").run();
+	const peers = db.prepare("SELECT peer FROM conversation_owners WHERE context_id = 'ctx-y' ORDER BY peer").all() as { peer: string }[];
+	assert.deepEqual(peers.map((r) => r.peer), ["ada", "bob"]);
+});

package/worker/test/owner-rpc.test.ts

@@ -12,9 +12,11 @@ test("owner RPC allowlist is the management reads and the calls that do not retu
 	assert.equal(ok("GET", "/owner/inbox")?.name, "GET /owner/inbox");
 	assert.equal(ok("GET", "/owner/summary")?.name, "GET /owner/summary");
 	assert.equal(ok("GET", "/owner/inbox", { context: "ctx-1", all: "1" })?.search, "?context=ctx-1&all=1");
+	assert.equal(ok("GET", "/owner/inbox", { from: "ada" })?.search, "?from=ada");
 	assert.equal(ok("GET", "/owner/inbox", { limit: "20", cursor: "abc_DEF-012" })?.search, "?limit=20&cursor=abc_DEF-012");
 	assert.equal(ok("GET", "/owner/tasks/task-1")?.path, "/owner/tasks/task-1");
 	assert.equal(ok("GET", "/owner/history/ctx-1", { n: "50" })?.search, "?n=50");
+	assert.equal(ok("GET", "/owner/history/ctx-1", { n: "50", from: "ada" })?.search, "?n=50&from=ada");
 	assert.equal(ok("GET", "/owner/outbound/task-1")?.name, "GET /owner/outbound/:id");
 	assert.equal(ok("GET", "/owner/peers")?.name, "GET /owner/peers");
 	assert.equal(ok("DELETE", "/owner/peers/ada")?.path, "/owner/peers/ada");
@@ -63,6 +65,8 @@ test("owner RPC allowlist is the management reads and the calls that do not retu
 	assert.deepEqual(refused("GET", "/owner/inbox", { limit: "201" }), { ok: false, reason: "query" });
 	assert.deepEqual(refused("GET", "/owner/inbox", { limit: "0" }), { ok: false, reason: "query" });
 	assert.deepEqual(refused("GET", "/owner/inbox", { cursor: "bad+cursor" }), { ok: false, reason: "query" });
+	assert.deepEqual(refused("GET", "/owner/inbox", { from: "bad peer" }), { ok: false, reason: "query" });
+	assert.deepEqual(refused("GET", "/owner/history/ctx-1", { from: "../x" }), { ok: false, reason: "query" });
 	assert.deepEqual(refused("GET", "/owner/summary", { all: "1" }), { ok: false, reason: "query" });
 	assert.deepEqual(refused("GET", "/owner/history/ctx-1", { n: "1001" }), { ok: false, reason: "query" });
 	assert.deepEqual(refused("GET", "/owner/history/.."), { ok: false, reason: "path" });