a2a-exposed 0.8.35 → 0.8.37

package/lib/hosted.mjs

@@ -5,6 +5,7 @@ import { controlOrigin, deviceLogin } from "./account.mjs";
 import { CliError, upstreamUrlProblem } from "./a2a.mjs";
 
 export const SETUP_SCOPES = ["agents:read", "agents:create", "agents:owner-token", "wake:write", "wake:test"];
+const SETUP_UNSUPPORTED = "This service does not expose scoped hosted setup capabilities. Check the --control-url service origin. Use the service dashboard to create an agent and configure Wake settings, or hosted MCP create_agent/set_wake with human confirmation and secret entry. Do not run init or deploy to repair a hosted address; no setup approval was requested.";
 const NEXT = "Run hosted capabilities --json to list scopes and presets; login --machine NAME --scopes SCOPES to approve setup.";
 const fail = (code, next) => { const error = new CliError(next); error.result = { ok: false, code, next }; throw error; };
 const printable = value => typeof value === "string" && value.length <= 4096 && !/[\x00-\x1f\x7f]/.test(value);
@@ -34,14 +35,16 @@ function originFor(o = {}) {
 
 async function request(origin, path, { token = "", method = "GET", body, fetchImpl = fetch } = {}) {
 	let response, data;
+	const discovery = method === "GET" && path === "/api/v1/setup/capabilities";
 	try {
 		response = await fetchImpl(`${origin}${path}`, {
 			method, redirect: "error", signal: AbortSignal.timeout(30_000),
 			headers: { accept: "application/json", ...(token ? { authorization: `Bearer ${token}` } : {}), ...(body === undefined ? {} : { "content-type": "application/json" }) },
 			...(body === undefined ? {} : { body: JSON.stringify(body) }),
 		});
-		data = await response.json();
+		if (!(discovery && response.status === 404)) data = await response.json();
 	} catch { fail("unavailable", "Hosted setup did not answer with JSON. Check the service and try again. Do not repeat a create request until hosted list confirms its result."); }
+	if (discovery && response.status === 404) fail("unsupported", SETUP_UNSUPPORTED);
 	if (!data || typeof data !== "object" || Array.isArray(data)) fail("invalid_response", "The hosted service returned an invalid setup response.");
 	if (!response.ok) {
 		if (response.status === 429 && data.error === "too_many_references") {
@@ -70,7 +73,7 @@ async function request(origin, path, { token = "", method = "GET", body, fetchIm
 
 export async function capabilities(o = {}) {
 	const data = await request(originFor(o), "/api/v1/setup/capabilities");
-	if (!Array.isArray(data.scopes) || !Array.isArray(data.wake?.presets)) fail("unsupported", "This service does not expose hosted setup capabilities yet.");
+	if (!Array.isArray(data.scopes) || !Array.isArray(data.wake?.presets)) fail("unsupported", SETUP_UNSUPPORTED);
 	return { ok: true, code: "capabilities", next: "Select explicit scopes and a wake preset from this listing.", scopes: data.scopes.filter(s => SETUP_SCOPES.includes(s)), presets: data.wake.presets.filter(s => /^[a-z-]+$/.test(s)), preflight: data.preflight === true, secret_reference: data.wake.secret_reference === true, wake_removal: data.wake.removal === true, secure_link_create: data.wake.secure_link_create === true };
 }
 
@@ -194,6 +197,8 @@ export async function status(o = {}) {
 
 export async function wake(sub, o = {}) {
 	if (!["preview", "test", "set", "prepare", "remove", "unset"].includes(sub)) fail("usage", "Use wake preview|test|set|prepare|remove. List presets with hosted capabilities --json.");
+	if (sub === "set" && C.deploymentKind() === "hosted" && !o.agent)
+		fail("hosted_config", "This is a hosted config. Use dashboard Wake settings or hosted MCP set_wake; the human enters wake secrets on the confirmation page. For scoped CLI setup, run hosted capabilities --json, then hosted list --json to select an explicit --agent NAME before wake set --agent NAME --url URL --preset P --json. No wake settings were changed.");
 	const removing = sub === "remove" || sub === "unset";
  const preparingRemoval = sub === "prepare" && o.clear === true;
  if (o.clear && !preparingRemoval) fail("usage", "Use wake prepare --clear for an MCP removal reference, or wake remove --version N. Run wake preview --json to list the current version.");
@@ -266,7 +271,16 @@ export async function wake(sub, o = {}) {
 	// Do not print proofs, arbitrary service text, webhook URLs or unexpected fields.
 	const code = typeof result.code === "string" && /^(?:[1-5][0-9]{2}|access-40[13]|none|timeout|tls|private|dns|dns-missing|transport-delivery|transport-native|transport-socket|cloudflare-target-unsupported|connection|failed|unreadable|signing)$/.test(result.code) ? result.code : result.saved === true ? "saved" : "failed";
 	const ok = result.ok === true && (sub !== "set" || result.saved === true);
-	return { ok, code, saved: result.saved === true, next: ok ? sub === "set" ? "Check the receiver for the test wake." : "The draft passed. Run wake set with the same inputs to test and save." : code === "cloudflare-target-unsupported" ? "Use polling or a self-hosted Worker for this Cloudflare-proxied webhook." : "Saved settings were not changed. Check the receiver, credentials and draft, then test again." };
+	const recovery = {
+		"cloudflare-target-unsupported": "This hosted service cannot deliver to this Cloudflare-proxied webhook. Choose a supported public HTTPS route, polling, or an explicitly authorized self-hosted Worker; do not create another tunnel or weaken Access or hook authentication.",
+		"transport-socket": "The hosted service could not connect using its public-HTTPS socket transport. Check hosted route compatibility before changing the receiver. An owner-created Cloudflare Tunnel can pass local checks and still be unreachable by this transport; do not weaken Access or hook authentication.",
+		"dns": "The hosted service could not resolve the webhook hostname. Check its public DNS before testing again.",
+		"dns-missing": "The hosted service could not resolve the webhook hostname. Check its public DNS before testing again.",
+		"tls": "The hosted service could not establish TLS to the webhook. Check the hostname and certificate; keep HTTPS verification enabled.",
+		"access-401": "Cloudflare Access refused the test. Check the selected Access service token and policy without disabling Access or hook authentication.",
+		"access-403": "Cloudflare Access refused the test. Check the selected Access service token and policy without disabling Access or hook authentication.",
+	};
+	return { ok, code, saved: result.saved === true, next: ok ? sub === "set" ? "Check the receiver for the test wake." : "The draft passed. Run wake set with the same inputs to test and save." : `Saved settings were not changed. ${recovery[code] || "Check the receiver, credentials and draft, then test again."}` };
 }
 
 export async function output(run, o = {}) {

package/lib/main.mjs

@@ -28,6 +28,7 @@ Setup options: --skip-install skips dependency installation when dependencies al
 
 Hosted setup:
   hosted capabilities --json   list setup scopes, wake presets and service capabilities
+                                unsupported/404: check --control-url; use dashboard or hosted MCP with human confirmation
   login --machine NAME --scopes SCOPES [--control-url URL] --json
                                 approve the explicit scopes using the printed website link once;
                                 save the scoped grant locally (mode 600), never print it
@@ -131,7 +132,9 @@ https://github.com/telegraphic-dev/a2a-exposed/blob/main/docs/getting-started.md
   deploy [same flags]           redeploy with saved settings (secrets persist); tag the Worker version as a2a-exposed-<version>
   wake set [--preset P] [--agent-id A] [--key-header H] [--key-prefix X] [--body-template JSON]
            [--cli-command CMD] [--debounce S] [--max-per-hour N]
-                                save wake settings, upload wake secrets from env, and redeploy (one step)
+                                self-hosted: save wake settings, upload wake secrets from env, and redeploy
+                                hosted config without --agent: stop with dashboard Wake settings / hosted MCP set_wake guidance
+                                hosted CLI: list hosted capabilities --json and hosted list --json, then select --agent NAME
                                 openbot: human supplies WAKE_HMAC_SECRET via protected env/secret storage, never chat or argv
                                 the Worker refuses unsigned openbot wakes (a webhook key is not a signing secret)
                                 --max-per-hour  hourly cap; 0 or unset is unlimited, except Claude Code,
@@ -191,8 +194,11 @@ Status
                                 read selected hosted agent wake configuration; select NAME with hosted list --json.
                                 Uses setup approval or that agent's matching owner credential; no delivery test.
   Hosted-only configs report deployment: hosted and hosted recovery guidance.
+  Hosted status lists capability/preview next steps; saved wake settings do not prove delivery.
+  Offer webhook or polling after checking hook support and hosted route compatibility.
+  A listed OpenClaw preset does not prove route reachability; check delivery preflight before tunnel setup.
   status [--json]               deployment, Worker version, base URL, agent card check (fetched by the CLI), wake
-                                mode (webhook / tunnel / none = polling), tunnel state, proxy mode (--upstream):
+                                mode (webhook / tunnel / none = no webhook), tunnel state, proxy mode (--upstream):
                                 upstream card, Access credential and upstream bearer configured (separately), the
                                 live upstream check, the last failed peer call, card-leak check; warnings for peer
                                 token variables shadowing saved tokens; and the next step to run.
@@ -233,7 +239,9 @@ Inbox (owner side)
                                            requests (tell your human; the dashboard URL when MANAGE_URL is set;
                                            --json: rows on stdout, requests on stderr). Follows every page; past
                                            10000 pages it errors instead of a short list. Reading marks returned replies
-                                           seen and clears matching pending wakes; task state is unchanged
+                                           seen and clears matching pending wakes; task state is unchanged.
+                                           Direct reply messages are completed without a new-work wake;
+                                           read them with history or inbox --all
   show <taskId>                            full task JSON
   working <taskId>                         mark task working
   reply <taskId> (--text T | --stdin) [--state completed|input-required|rejected|failed|working]

package/lib/status.mjs

@@ -191,9 +191,12 @@ export async function checkCard(base) {
 
 /** One line describing how wakes reach the agent. */
 export function wakeLine(s) {
-	if (!s.wake) return "unknown (owner API not reachable)";
+	if (!s.wake) return s.deployment === "hosted" && s.ownerApi?.ok
+		? "unknown (hosted wake preview unavailable)" : "unknown (owner API not reachable)";
 	const w = s.wake;
-	if (!w.configured) return "none: no WAKE_WEBHOOK_URL on the Worker, so the agent is expected to poll the A2A endpoint";
+	if (!w.configured) return s.deployment === "hosted"
+		? "no webhook configured; choose delivery after checking hosted route compatibility"
+		: "none: no WAKE_WEBHOOK_URL on the Worker, so the agent is expected to poll the A2A endpoint";
 	const auth = [w.hasKey && "bearer/API key", w.hasHmacSecret && "HMAC signature", w.hasAccessServiceToken && "Access service token"].filter(Boolean);
 	return `webhook (preset ${w.preset}${s.tunnel ? ", through the tunnel" : ""}); auth: ${auth.join(" + ") || "none"}; URL fingerprint ${w.urlFingerprint || "-"}`;
 }
@@ -294,10 +297,13 @@ function nextStepCore(s) {
 		if (s.card.urlProblem) return fail(`the hosted agent card has a different endpoint: ${s.card.urlProblem}. Check the address with the hosted service.`);
 		if (!s.health?.ok) return fail("the hosted health check failed. Check the hosted service and run status again.");
 		if (!s.ownerApi.ok) return fail("the hosted owner API refused or could not check the saved credential. Check the hosted agent access with its owner.");
-		if (!s.wake) return done("the hosted endpoint is reachable and its owner credential is accepted. Wake preview is unavailable; check wake delivery through the hosted service.");
-		return done(s.wake?.configured
-			? "none: the hosted endpoint is reachable and its owner credential is accepted. Check wake delivery through the hosted service."
-			: "the hosted endpoint is reachable. Configure a public HTTPS webhook through the hosted service, or use polling. Cloudflare Tunnel delivery may be unavailable; do not provision a self-hosted tunnel for this address.");
+		const discover = `Run \`${CLI} hosted capabilities --json\` to list supported setup scopes and wake presets.`;
+		const fallback = "If unavailable, use hosted dashboard Wake settings or MCP set_wake.";
+		if (!s.wake) return done(`the hosted endpoint is reachable and its owner credential is accepted. Wake preview is unavailable; delivery is unverified. ${discover}`, [fallback]);
+		if (s.wake.configured) return done(`the hosted endpoint is reachable and wake settings are saved; status does not test delivery. ${discover}`, [fallback,
+			`When supported, read \`${CLI} wake preview --json\` for the saved agent before an authorized draft test, then verify an inbox-and-reply run.`]);
+		return done(`the hosted endpoint is reachable; no webhook is configured. ${discover}`, [fallback,
+			"Check hook support and hosted route compatibility, then offer webhook or polling with its interval and cost before configuring either. Do not provision a self-hosted tunnel for this address."]);
 	}
 	if (!s.deployed) return fail(`nothing is deployed from ${path.dirname(s.configFile)}. Run \`${CLI} init\` (see the quick start). Another deployment? Set A2A_CONFIG_DIR.`);
 	if (s.baseUrlEnv)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "a2a-exposed",
-	"version": "0.8.35",
+	"version": "0.8.37",
 	"description": "Give any AI agent a public A2A (Agent2Agent) endpoint: a Cloudflare Worker, a wake webhook, or scheduled checks",
 	"type": "module",
 	"bin": {

package/worker/src/index.ts

@@ -698,6 +698,7 @@ type Rpc = (p: Json, label: string, version: string, ctx: TenantContext, ectx: E
 const rpcSend: Rpc = async (params, label, version, ctx, ectx) => {
 	const msg = A.normMessage(params.message);
 	if (msg.role !== "user") throw new RpcError(-32602, "message.role must be user");
+	const directReply = directReplyParams(params);
 	const conf = params.configuration || {};
 	const push = conf.taskPushNotificationConfig || conf.pushNotificationConfig;
 	const pushCfg = push ? normPushCfg(push, version) : null;
@@ -718,9 +719,11 @@ const rpcSend: Rpc = async (params, label, version, ctx, ectx) => {
 	if (!task) task = { id: A.newId(), contextId, status: { state: "submitted", timestamp: ts }, artifacts: [], history: [], _peer: label, _protocol: version, _createdAt: ts, _push: [] };
 	msg.contextId = contextId; msg.taskId = task.id;
 	task.history.push(msg);
-	task.status = { state: "submitted", timestamp: ts };
+	task.status = { state: directReply ? "completed" : "submitted", timestamp: ts };
 	if (pushCfg) task._push = [...task._push.filter((c: Json) => c.id !== pushCfg.id), pushCfg];
 	if (params.metadata && typeof params.metadata === "object") task.metadata = { ...(task.metadata || {}), ...params.metadata };
+	// Keep the loop marker on the task even when it was supplied only on the message.
+	if (directReply) task.metadata = { ...(task.metadata || {}), [DIRECT_REPLY_META]: params.metadata?.[DIRECT_REPLY_META] || msg.metadata?.[DIRECT_REPLY_META] };
 	const preview = A.textOf(msg);
 	if (creating) {
 		const stored = await ctx.DB.batch([
@@ -738,7 +741,8 @@ const rpcSend: Rpc = async (params, label, version, ctx, ectx) => {
 		]);
 	}
 	log("message_received", { peer: label, contextId, taskId: task.id, chars: preview.length, version });
-	await wake(ctx, ectx, contextId, task.id, label, preview);
+	// Direct replies are stored for history, not scheduled as new work.
+	if (!directReply) await wake(ctx, ectx, contextId, task.id, label, preview);
 	const pt = A.publicTask(task, version, conf.historyLength);
 	return version.startsWith("1") ? { task: pt } : pt;
 };
@@ -1143,7 +1147,7 @@ async function checkedPeerFetch(ctx: TenantContext, ectx: ExecutionContext, base
 	try { baseUrl = new URL(base); target = new URL(url); } catch { throw new ToolError("peer endpoint is not a URL"); }
 	if (target.origin !== baseUrl.origin) throw new ToolError("peer card endpoint refused: it is on a different origin");
 	const why = peerUrlProblem(target.href);
-	if (why) throw new ToolError(`peer endpoint ${target.href} refused: ${why}`);
+	if (why) throw new ToolError(`peer endpoint ${target.host} refused: ${why}`);
 	const internal = await fetchTenant(ctx, target, { ...init, redirect: "manual" });
 	if (internal) {
 		if (internal.status >= 300 && internal.status < 400) throw new ToolError("peer endpoint refused: redirects are not allowed");
@@ -1559,10 +1563,12 @@ async function deliverReplyMessage(ctx: TenantContext, ectx: ExecutionContext, t
 		const pushed = await notifyPeer(ctx, ectx, task, signal);
 		const failed = pushed.find((x: Json) => !x.ok);
 		const target = safeTarget(undefined, String((failed || pushed[0])?.url || ""));
-		const http = /HTTP (\d{3})/.exec(String((failed || pushed[0])?.info || ""));
+		const info = String((failed || pushed[0])?.info || "");
+		const http = /^HTTP (\d{3})$/.exec(info);
+		const httpStatus = http && http[0] === info ? Number(http[1]) : undefined;
 		return {
 			status: failed ? "delivery-failed" : "delivered", method: "push", taskId: task.id, state,
-			...(target ? { target } : {}), ...(http ? { httpStatus: Number(http[1]) } : {}),
+			...(target ? { target } : {}), ...(httpStatus !== undefined && httpStatus >= 100 && httpStatus <= 599 ? { httpStatus } : {}),
 			detail: failed ? "A task push failed; the reply remains stored on the task." : "Delivered as the task's existing push update.",
 		};
 	}

package/worker/src/version.ts

@@ -1,2 +1,2 @@
 /** Inbox build. Keep this equal to `version` in cli/package.json. */
-export const VERSION = "0.8.35";
+export const VERSION = "0.8.37";

package/worker/test/reply-delivery.test.ts

@@ -55,8 +55,10 @@ async function fixture(t: Parameters<typeof test>[1] extends (t: infer T) => unk
 	byId.set("id-alice", a); byId.set("id-bob", b);
 	store.set("tenant:alice", JSON.stringify({ id: "id-alice", status: "active", region: "default", version: 1 }));
 	store.set("tenant:bob", JSON.stringify({ id: "id-bob", status: "active", region: "default", version: 1 }));
-	const owner = (ctx: TenantContext, accountId: string, method: string, path: string, body?: unknown) =>
-		runOwnerRpc(ctx, ectx as never, { accountId, method, path, ...(body === undefined ? {} : { body }) });
+	const owner = (ctx: TenantContext, accountId: string, method: string, path: string, body?: unknown) => {
+		const url = new URL(path, ctx.PUBLIC_URL);
+		return runOwnerRpc(ctx, ectx as never, { accountId, method, path: url.pathname, query: Object.fromEntries(url.searchParams), ...(body === undefined ? {} : { body }) });
+	};
 	const issue = async (ctx: TenantContext, ownerToken: string, label: string) => {
 		const r = await dispatch(new Request(ctx.PUBLIC_URL + "/owner/peers", { method: "POST", headers: { authorization: `Bearer ${ownerToken}`, "content-type": "application/json" }, body: JSON.stringify({ label }) }), ctx, ectx as never);
 		return (await r.json() as { token: string }).token;
@@ -71,7 +73,7 @@ async function fixture(t: Parameters<typeof test>[1] extends (t: infer T) => unk
 		assert.equal(r.status, 200, JSON.stringify(data));
 		return data.result.id as string;
 	};
-	return { a, b, dbA, dbB, owner, sendToBob, cards, missingCard() { missingCard = true; }, get directPosts() { return directPosts; }, get aborted() { return aborted; }, blockDirect() {
+	return { a, b, dbA, dbB, owner, sendToBob, bobAtAlice, otherAtAlice: () => issue(a, ownerA, "other"), cards, missingCard() { missingCard = true; }, get directPosts() { return directPosts; }, get aborted() { return aborted; }, blockDirect() {
 		let release!: () => void;
 		hold = new Promise<void>((resolve) => { release = resolve; });
 		const started = new Promise<void>((resolve) => { posted = resolve; });
@@ -91,15 +93,20 @@ test("reply delivers once to an exact paired peer in the same context and a dire
 	assert.equal(JSON.stringify(first.body).includes("a2aow_"), false);
 	assert.equal(s.directPosts, 1);
 
-	const inbox = await s.owner(s.a, "acct-alice", "GET", "/owner/inbox");
+	const inbox = await s.owner(s.a, "acct-alice", "GET", "/owner/inbox?all=1");
 	const delivered = (inbox.body as any[]).find((row) => row.text === "answer");
 	assert.equal(delivered.contextId, "ctx-direct");
+	assert.equal(delivered.state, "completed");
+	assert.deepEqual((await s.dbA.prepare("SELECT * FROM wakes").all()).results, []);
+	const openInbox = await s.owner(s.a, "acct-alice", "GET", "/owner/inbox");
+	assert.deepEqual(openInbox.body, []);
 	const stored = await s.dbA.prepare("SELECT metadata_json FROM tasks WHERE id = ?").bind(delivered.taskId).first() as { metadata_json?: string };
 	const metadata = JSON.parse(stored.metadata_json || "{}");
 	assert.deepEqual(metadata["a2a.exposed/reply-delivery"].taskId, taskId);
 
 	const noLoop = await s.owner(s.a, "acct-alice", "POST", "/owner/mcp/reply", { taskId: delivered.taskId, text: "ack", state: "completed" });
-	assert.equal((noLoop.body as any).structuredContent.status, "stored-only");
+	assert.equal((noLoop.body as any).isError, true);
+	assert.match(String((noLoop.body as any).text), /already completed/);
 	assert.equal(s.directPosts, 1, "a directly delivered reply is never delivered back");
 
 	const retry = await s.owner(s.b, "acct-bob", "POST", "/owner/mcp/reply", { taskId, text: "answer", state: "completed" });
@@ -219,3 +226,69 @@ test("reply discovers one canonical card and uses the paired base when it is mis
 	assert.deepEqual(s.cards, ["/.well-known/agent-card.json"]);
 	assert.equal(s.directPosts, 1);
 });
+
+for (const version of ["0.3", "1.0"]) {
+	for (const placement of ["request", "message"]) {
+		test(`direct reply metadata on ${placement} auto-completes without waking (${version})`, async (t) => {
+			const s = await fixture(t as never);
+			const contextId = "ctx-marker";
+			const marker = { "a2a.exposed/reply-delivery": { taskId: "remote-task", messageId: "remote-message", state: "working" } };
+			const send = async (metadata: unknown, taskId?: string, token = s.bobAtAlice) => {
+				const message = { role: version === "1.0" ? "ROLE_USER" : "user", messageId: crypto.randomUUID(), contextId,
+					parts: [{ kind: "text", text: "reply text" }], ...(taskId ? { taskId } : {}), ...(placement === "message" ? { metadata } : {}) };
+				const r = await dispatch(new Request(s.a.PUBLIC_URL, { method: "POST", headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+					body: JSON.stringify({ jsonrpc: "2.0", id: "marker", method: version === "1.0" ? "SendMessage" : "message/send", params: { message, ...(placement === "request" ? { metadata } : {}) } }) }), s.a, ectx as never);
+				return await r.json() as any;
+			};
+			const result = await send(marker);
+			const task = version === "1.0" ? result.result.task : result.result;
+			assert.equal(task.status.state, version === "1.0" ? "TASK_STATE_COMPLETED" : "completed");
+			assert.deepEqual(task.metadata, marker);
+			assert.deepEqual((await s.owner(s.a, "acct-alice", "GET", "/owner/inbox")).body, []);
+			assert.deepEqual((await s.dbA.prepare("SELECT * FROM wakes").all()).results, []);
+			const history = await s.owner(s.a, "acct-alice", "GET", `/owner/history/${contextId}?from=bob`);
+			assert.match(JSON.stringify(history.body), /reply text/);
+			const unauthorized = await send(marker, task.id, await s.otherAtAlice());
+			assert.equal(unauthorized.error.code, -32001);
+			for (const metadata of [{ other: {} }, { "a2a.exposed/reply-delivery": "completed" }]) {
+				const normal = await send(metadata);
+				assert.equal((version === "1.0" ? normal.result.task : normal.result).status.state, version === "1.0" ? "TASK_STATE_SUBMITTED" : "submitted");
+			}
+			assert.equal(((await s.owner(s.a, "acct-alice", "GET", "/owner/inbox")).body as any[]).length, 2);
+			assert.equal((await s.dbA.prepare("SELECT COUNT(*) AS n FROM wakes").first() as any).n, 1);
+		});
+	}
+}
+
+
+test("push status only accepts an exact HTTP result in the output schema range", async (t) => {
+	const s = await fixture(t as never);
+	const originalFetch = globalThis.fetch;
+	t.after(() => { globalThis.fetch = originalFetch; });
+	for (const value of [200, 307, 401, 599, 99, 600, 999, "HTTP 999", "prefix HTTP 401 suffix", "HTTP 401\n"]) {
+		globalThis.fetch = (async () => {
+			if (typeof value === "string") throw value;
+			const response = new Response(null);
+			Object.defineProperty(response, "status", { value });
+			return response;
+		}) as typeof fetch;
+		const taskId = await s.sendToBob("status " + value, crypto.randomUUID(), { id: "cfg", url: "https://push.example.net/update" });
+		const result = await s.owner(s.b, "acct-bob", "POST", "/owner/mcp/reply", { taskId, text: "stored answer" });
+		const delivery = (result.body as any).structuredContent as Delivery;
+		assert.equal(delivery.httpStatus, typeof value === "number" && value >= 100 && value <= 599 ? value : undefined, String(value));
+		assert.equal(delivery.status, value === 200 ? "delivered" : "delivery-failed");
+		const stored = await s.dbB.prepare("SELECT state FROM tasks WHERE id = ?").bind(taskId).first() as { state: string };
+		assert.equal(stored.state, "completed");
+	}
+});
+
+test("direct reply refusal reports only the endpoint host", async (t) => {
+	const s = await fixture(t as never);
+	await s.dbB.prepare("UPDATE outbound_peers SET url = 'http://alice.example.com/private-path?private-query=yes' WHERE alias = 'alice'").run();
+	const taskId = await s.sendToBob("refused endpoint", "ctx-refused-url");
+	const result = await s.owner(s.b, "acct-bob", "POST", "/owner/mcp/reply", { taskId, text: "stored answer" });
+	const delivery = (result.body as any).structuredContent;
+	assert.equal(delivery.status, "delivery-failed");
+	assert.match(delivery.detail, /peer endpoint alice\.example\.com refused/);
+	assert.doesNotMatch(JSON.stringify(result.body), /private-path|private-query|http:\/\//);
+});