a2a-exposed 0.8.17 → 0.8.19

package/worker/src/wake.ts

@@ -46,7 +46,7 @@ export type WakeConfig = {
 
 export type WakeRequest = { url: string; method: "POST"; headers: Record<string, string>; body: string };
 
-export const PRESETS = ["grok-bot", "claude-code", "openclaw-wake", "openclaw-agent", "hermes", "generic"] as const;
+export const PRESETS = ["grok-bot", "claude-code", "openclaw-wake", "openclaw-agent", "hermes", "openbot", "generic"] as const;
 
 /** Default debounce window per preset (seconds), used when WAKE_DEBOUNCE_SECONDS is unset. */
 export function defaultDebounceSeconds(preset: string): number {
@@ -92,9 +92,11 @@ export function pairingInstructions(p: PairingInfo, cli: string): string {
 
 function hintFor(ev: WakeEvent, cli: string): string {
 	if (ev.kind === "pairing_request") return `${cli} pair list`;
+	// `--from` keeps the read on this peer. The same context id can be another peer's separate conversation.
+	const from = /^[A-Za-z0-9_.-]{1,64}$/.test(ev.from) ? ` --from ${ev.from}` : "";
 	return ev.kind === "outbound_update"
-		? `${cli} history ${ev.contextId}`
-		: `${cli} inbox --context ${ev.contextId}`;
+		? `${cli} history ${ev.contextId}${from}`
+		: `${cli} inbox --context ${ev.contextId}${from}`;
 }
 
 /** Human/agent-readable wake text. `withPreview=false` keeps peer-authored text out entirely. */
@@ -205,6 +207,16 @@ export async function renderWake(cfg: WakeConfig, ev: WakeEvent, opts: { nowMs?:
 			// `name` is the hook name OpenClaw filters match. It stays "A2A inbox". The wake text itself starts with "A2A endpoint:".
 			body = JSON.stringify({ message: wakeSummary(ev, cli), name: "A2A inbox", agentId: cfg.agentId || "main", sessionMode: "isolated", deliver: false });
 			break;
+		case "openbot": {
+			const ts = String(Math.floor(nowMs / 1000));
+			headers["x-openbot-timestamp"] = ts;
+			headers["x-openbot-delivery-id"] = requestId;
+			// Serialize once: the signature covers exactly the UTF-8 bytes sent to OpenBot.
+			body = JSON.stringify({ type: "a2a_wake", occurredAt: new Date(nowMs).toISOString(), data: wakePayload(ev, cli) });
+			if (cfg.hmacSecret)
+				headers["x-openbot-signature"] = `sha256=${await hmacSha256Hex(cfg.hmacSecret, `${ts}.${requestId}.${body}`)}`;
+			break;
+		}
 		case "hermes":
 			headers["x-request-id"] = requestId;
 			body = JSON.stringify(wakePayload(ev, cli));
@@ -266,7 +278,7 @@ export function cloudflareErrorHint(status: number, body: string, opts?: { tunne
 
 /** Headers a wake preview may show in full. Every other header carries a credential, whatever its name. */
 export const PREVIEW_PLAIN_HEADERS = new Set([
-	"content-type", "user-agent", "x-request-id", "idempotency-key", "anthropic-version", "x-webhook-timestamp",
+	"content-type", "user-agent", "x-request-id", "idempotency-key", "anthropic-version", "x-webhook-timestamp", "x-openbot-timestamp", "x-openbot-delivery-id",
 ]);
 
 export function previewHeaderPlain(name: string): boolean {

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

@@ -1,4 +1,5 @@
-// A peer must not post into another peer's conversation by reusing its contextId.
+// 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";
@@ -6,7 +7,6 @@ import worker from "../src/index.ts";
 import { d1 } from "./d1.ts";
 
 const BASE = "https://agent.example.com";
-const UNKNOWN = "Invalid params: unknown contextId (omit contextId to start a new conversation, then use the one returned)";
 
 function setup() {
 	const DB = d1(new URL("../migrations/", import.meta.url));
@@ -32,91 +32,191 @@ function setup() {
 		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, restore: () => { globalThis.fetch = origFetch; } };
+	return { DB, owner, send, call, restore: () => { globalThis.fetch = origFetch; } };
 }
 
-test("another peer's contextId is refused without joining that conversation", async (t) => {
+/** 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, first.text);
+	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, second.text);
+	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 = () => s.owner("GET", "/owner/history/ctx-y");
-	const beforeHist = await history();
-	assert.equal(beforeHist.status, 200, beforeHist.text);
-	const beforeTexts = (beforeHist.data as { text: string }[]).map((r) => r.text);
-	assert.deepEqual(beforeTexts, ["y-one", "y-two"]);
-	const wake = () => 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 = 'ada'").get() as {
+	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;
-	};
-	const beforeWake = wake();
-	assert.equal(beforeWake.peer, "ada");
-	const pending = JSON.parse(beforeWake.pending_json);
+	} | 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(second.data.result.id), true);
+	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.deepEqual(foreign.data.error, { code: -32602, message: UNKNOWN });
-	assert.deepEqual(foreignV1.data.error, foreign.data.error);
-	const body = JSON.stringify(foreign.data);
-	assert.equal(body.includes("ada"), false);
-	assert.equal(body.includes("ctx-y"), false);
-	assert.equal(body.includes("y-one"), false);
-	assert.equal(body.includes("y-two"), false);
-	assert.equal(body.includes("exists"), false);
-	assert.equal(body.includes(ada), false);
-	assert.equal(body.includes(bob), false);
-
-	const afterHist = await history();
-	assert.deepEqual(afterHist.data, beforeHist.data);
-	assert.deepEqual(wake(), beforeWake);
+	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 = 'bob'").get() as { n: number }).n, 0);
-	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM history WHERE context_id = 'ctx-y' AND peer = 'bob'").get() as { n: number }).n, 0);
-	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM wakes WHERE context_id = 'ctx-y' AND peer = 'bob'").get() as { n: number }).n, 0);
-	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM messages WHERE context_id = 'ctx-y' AND message_json LIKE '%x-inject%'").get() as { n: number }).n, 0);
+	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");
 
-	assert.equal((db.prepare("SELECT peer FROM conversation_owners WHERE context_id = 'ctx-y'").get() as { peer: string }).peer, "ada");
+	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, follow.text);
+	assert.equal(follow.status, 200);
 	assert.equal(follow.data.result.contextId, "ctx-y");
-	const texts = ((await history()).data as { text: string; peer: string }[]).map((r) => r.text);
-	assert.deepEqual(texts, ["y-one", "y-two", "y-three"]);
-	const after = JSON.parse(wake().pending_json);
+	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);
-	assert.equal(after.taskIds.includes(follow.data.result.id), true);
-	assert.equal(after.taskIds.includes(second.data.result.id), true);
+
+	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, own.text);
+	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, again.text);
+	assert.equal(again.status, 200);
 	assert.equal(again.data.result.contextId, "ctx-x");
-	const bobHist = await s.owner("GET", "/owner/history/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"]);
-	assert.deepEqual(((await history()).data as { text: string }[]).map((r) => r.text), ["y-one", "y-two", "y-three"]);
-	assert.equal(JSON.parse(wake().pending_json).from, "ada");
-	assert.equal(JSON.parse(wake().pending_json).preview, "y-three");
-	assert.equal((db.prepare("SELECT peer FROM conversation_owners WHERE context_id = 'ctx-x'").get() as { peer: string }).peer, "bob");
-	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM conversation_owners WHERE context_id = 'ctx-y'").get() as { n: number }).n, 1);
 });
 
-test("two peers cannot both claim one unused contextId", async (t) => {
+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;
@@ -138,34 +238,53 @@ test("two peers cannot both claim one unused contextId", async (t) => {
 		s.send(bob, "from-bob", "ctx-race"),
 	]);
 	assert.equal(arrived, 2);
-	const ok = [left, right].filter((r) => r.status === 200 && !r.data.error);
-	const denied = [left, right].filter((r) => r.data?.error);
-	assert.equal(ok.length, 1, JSON.stringify([left.data, right.data]));
-	assert.equal(denied.length, 1);
-	assert.deepEqual(denied[0].data.error, { code: -32602, message: UNKNOWN });
-	assert.equal(ok[0].data.result.contextId, "ctx-race");
-	const body = JSON.stringify(denied[0].data);
-	for (const secret of ["ada", "bob", "ctx-race", "from-ada", "from-bob", "exists", ada, bob]) assert.equal(body.includes(secret), false, secret);
+	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'").all() as { peer: string }[];
-	assert.equal(owners.length, 1);
-	const winner = owners[0].peer;
-	const loser = winner === "ada" ? "bob" : "ada";
-	assert.equal(winner === "ada" || winner === "bob", true);
-	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM tasks WHERE context_id = 'ctx-race'").get() as { n: number }).n, 1);
-	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM tasks WHERE context_id = 'ctx-race' AND peer = ?").get(loser) as { n: number }).n, 0);
-	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM history WHERE context_id = 'ctx-race' AND peer = ?").get(loser) as { n: number }).n, 0);
-	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM messages WHERE context_id = 'ctx-race' AND message_json LIKE ?").get(`%from-${loser}%`) as { n: number }).n, 0);
-	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM wakes WHERE context_id = 'ctx-race' AND peer = ?").get(loser) as { n: number }).n, 0);
-
-	const follow = await s.send(winner === "ada" ? ada : bob, "follow", "ctx-race");
-	assert.equal(follow.status, 200, follow.text);
-	assert.equal(follow.data.result.contextId, "ctx-race");
-	const hist = await s.owner("GET", "/owner/history/ctx-race");
-	assert.deepEqual((hist.data as { text: string; peer: string }[]).map((r) => r.text), [winner === "ada" ? "from-ada" : "from-bob", "follow"]);
-	assert.equal((hist.data as { peer: string }[]).every((r) => r.peer === winner), true);
-	const again = await s.send(loser === "ada" ? ada : bob, "still-no", "ctx-race");
-	assert.deepEqual(again.data.error, { code: -32602, message: UNKNOWN });
-	assert.equal((db.prepare("SELECT COUNT(*) AS n FROM tasks WHERE context_id = 'ctx-race' AND peer = ?").get(loser) as { n: number }).n, 0);
+	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

@@ -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", "0010_conversation_peer.sql", "0011_conversation_owner.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", "0010_conversation_peer.sql", "0011_conversation_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"]);
+	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", "0010_conversation_peer.sql", "0011_conversation_owner.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), []);
 
@@ -141,7 +141,7 @@ test("0010 keys an existing wake by the peer in its payload and allows a second
 });
 
 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");
+	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', ?, ?, '{}', '[]', '[]')`;
@@ -149,7 +149,7 @@ test("0011 keeps one owner per context from the earliest task, then history, the
 	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"]);
+	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);
@@ -157,3 +157,15 @@ test("0011 keeps one owner per context from the earliest task, then history, the
 	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"]);
+});