a2a-exposed 0.8.41 → 0.8.42

package/lib/a2a.mjs

@@ -1,11 +1,12 @@
 // Minimal A2A client helpers (0.3 + 1.0) and HTTP utilities.
 import crypto from "node:crypto";
+import { CLI_COMMAND } from "./config.mjs";
 
 export const ID_RE = /^[A-Za-z0-9._:-]{1,128}$/;
 
 /** The one way docs, hints and CLI output tell people (and agents) to run the CLI: npx, always the latest release, no
  *  global install (agent sandboxes block global installs as untrusted code). A global install is an optional speed-up. */
-export const CLI = "npx -y a2a-exposed@latest";
+export const CLI = CLI_COMMAND;
 
 export class CliError extends Error {}
 export const die = (msg) => { throw new CliError(msg); };

package/lib/commands.mjs

@@ -23,9 +23,16 @@ export async function ownerTry(method, path, body, timeout) {
 }
 
 function printPush(res) {
-	for (const r of (res && res.push) || []) console.error(`push -> ${r.url}: ${r.ok ? "ok" : "FAILED"} (${r.info})`);
+	for (const r of (res && res.push) || []) {
+		// Older Workers return a full URL. Print only its host, including on that compatibility path.
+		let host = r.host || "unknown host";
+		if (!r.host && r.url) { try { host = new URL(r.url).host; } catch { /* omit invalid URLs */ } }
+		console.error(`push -> ${r.role || "task push config"} ${host} [${r.fingerprint || "unknown fingerprint"}]: ${r.ok ? "ok" : "FAILED"} (${/^HTTP \d{3}$/.test(r.info) ? r.info : "push request failed"})`);
+	}
 }
 
+const printState = (state, timestamp, task = "") => console.log(`${task ? `${task} ` : ""}current state: ${plainState({ status: { state } })} (${timestamp || "timestamp unavailable"})`);
+
 function printDelivery(res) {
 	const d = res && res.delivery;
 	if (!d) return;
@@ -102,6 +109,7 @@ export async function inbox(o) {
 		console.log(r.text);
 		console.log("<<< END PEER MESSAGE");
 		if (reply) console.log(`(a reply to a message you sent; read it with \`${CLI} history ${r.contextId}\`. Continue with send, not reply.)`);
+		printState(r.state, r.updated);
 	}
 	if (pairing.length) {
 		console.log(`=== ${pairing.length} pending pairing request${pairing.length === 1 ? "" : "s"} (another agent asks to connect; ${pairing[0].approval} approval)`);
@@ -129,8 +137,10 @@ export async function reply(id, o) {
 	const res = await owner("POST", `/owner/tasks/${q(id)}/reply`, {
 		text, state: o.state, artifact: !!o.artifact, artifactName: o["artifact-name"], force: !!o.force,
 	});
+	printPush(res.delivery || res);
 	printDelivery(res);
 	console.log(`${id} -> ${o.state}`);
+	console.log(`task state saved: ${res.task?.status?.state || o.state} (peers can read it with GetTask even if a push fails)`);
 }
 
 export async function history(ctx, o) {
@@ -138,10 +148,15 @@ export async function history(ctx, o) {
 	if (o.from) qs.set("from", o.from);
 	const rows = await owner("GET", `/owner/history/${q(ctx)}?${qs}`);
 	if (o.json) return out(rows);
+	const states = new Map();
+	const peers = new Map(rows.filter((e) => e.task_id && e.peer).map((e) => [e.task_id, e.peer]));
 	for (const e of rows) {
 		const tag = [e.event, e.state || e.role].filter(Boolean).join("/");
-		console.log(`${e.ts} ${(e.dir || "").padEnd(5)} ${(e.peer || "-").padEnd(10)} ${e.task_id || "-"} ${tag}: ${(e.text || "").slice(0, 400)}`);
+		const forced = e.data?.forced ? `forced: ${e.data.previousState} → ${e.data.state}; ` : "";
+		console.log(`${e.ts} ${(e.dir || "").padEnd(5)} ${(e.peer || "-").padEnd(10)} ${e.task_id || "-"} ${tag}: ${forced}${(e.text || "").slice(0, 400)}`);
+		if (e.currentState?.state || e.state) states.set(`${e.peer || peers.get(e.task_id) || "-"}/${e.task_id || "-"}`, e.currentState || { state: e.state, timestamp: e.ts });
 	}
+	for (const [task, status] of states) printState(status.state, status.timestamp, states.size > 1 ? task : "");
 }
 
 export async function contexts() {

package/lib/config.mjs

@@ -9,7 +9,12 @@ export function defaultConfigDir(base = process.env.XDG_CONFIG_HOME || path.join
 	return path.join(base, "a2a-exposed");
 }
 
-export const CONFIG_DIR = process.env.A2A_CONFIG_DIR || defaultConfigDir();
+export const CONFIG_DIR = path.resolve(process.env.A2A_CONFIG_DIR || defaultConfigDir());
+export const NON_DEFAULT_CONFIG = CONFIG_DIR !== path.resolve(defaultConfigDir());
+/** POSIX shell word; never interpolate paths as shell syntax. */
+export const shellQuote = (value) => /^[A-Za-z0-9_./:@+,-]+$/.test(value) ? value : "'" + value.replaceAll("'", "'\\''") + "'";
+export const DEFAULT_CLI_COMMAND = "npx -y a2a-exposed@latest";
+export const CLI_COMMAND = DEFAULT_CLI_COMMAND + (NON_DEFAULT_CONFIG ? ` --config-dir ${shellQuote(CONFIG_DIR)}` : "");
 export const CONFIG_FILE = path.join(CONFIG_DIR, "config.env");
 export const PEERS_FILE = path.join(CONFIG_DIR, "peers.json");
 

package/lib/deploy.mjs

@@ -5,6 +5,7 @@ import path from "node:path";
 import { spawn, spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import * as C from "./config.mjs";
+import { pathNode, pinnedCommand, sameExecutable } from "./runtime.mjs";
 import { CLI, cardUrlProblem, cfErrorCode, die, fetchUpstreamCard, fingerprint, httpJson, randomToken, upstreamAuth, upstreamCardUrlProblem, upstreamUrlProblem } from "./a2a.mjs";
 import { owner, ownerTry } from "./commands.mjs";
 import { readHidden } from "./pair.mjs";
@@ -565,12 +566,23 @@ function deployedBase() {
 	return base;
 }
 
+/** Preserve an explicit/saved hint; default hints carry this deployment's config directory. */
+function configureWakeCommand(o) {
+	const saved = C.get("WAKE_CLI_COMMAND");
+	if (o["cli-command"] === undefined && (!saved || saved === C.DEFAULT_CLI_COMMAND) && C.NON_DEFAULT_CONFIG)
+		C.saveConfig({ WAKE_CLI_COMMAND: C.CLI_COMMAND });
+	const fromPath = pathNode();
+	if (!sameExecutable(fromPath, process.execPath))
+		console.error(`Node runtime: ${process.execPath}; PATH node: ${fromPath || "not found"}. Pinned wake command: ${pinnedCommand()}. To save it, pass --cli-command with that command.`);
+}
+
 export async function init(o) {
 	const prevUpstream = C.fileConfig().A2A_UPSTREAM_URL || "";
 	const switched = applyFlags(o);
 	const upstreamSecrets = await upstreamTokenCheck(o, { upstreamChanged: (C.get("A2A_UPSTREAM_URL") || "") !== prevUpstream });
 	const dir = workerDir(o);
-	C.saveConfig({ A2A_WORKER_DIR: dir, A2A_WORKER_NAME: workerName() });
+	C.saveConfig({ A2A_WORKER_DIR: dir, A2A_WORKER_NAME: workerName(), A2A_NODE_EXEC_PATH: process.execPath });
+	configureWakeCommand(o);
 	if (workersDevMode()) {
 		if (!WD.LABEL_RE.test(workerName())) die("on workers.dev the --worker-name must be a DNS label (lowercase letters, digits, hyphens)");
 		if (!C.get("A2A_HOSTNAME")) console.error(`note: no --hostname, deploying to https://${workerName()}.<account subdomain>.workers.dev (${WD.DOCS})`);
@@ -712,6 +724,7 @@ export async function deploy(o) {
 		die(`${C.CONFIG_FILE} has a saved deployment (A2A_D1_ID) but no A2A_WORKER_NAME; rerun with --worker-name <the Worker it deployed> (saved for next time)`);
 	const prevUpstream = C.fileConfig().A2A_UPSTREAM_URL || "";
 	const switched = applyFlags(o);
+	configureWakeCommand(o);
 	const upstreamSecrets = await upstreamTokenCheck(o, { upstreamChanged: (C.get("A2A_UPSTREAM_URL") || "") !== prevUpstream });
 	const dir = workerDir(o);
 	if (workersDevMode() && !WD.LABEL_RE.test(workerName())) die("on workers.dev the worker name must be a DNS label (lowercase letters, digits, hyphens)");

package/lib/main.mjs

@@ -74,6 +74,9 @@ npx cf auth login --no-browser; on a VPS where it fails with HTTP 403 before sho
 CLOUDFLARE_API_TOKEN instead: setup skill, Troubleshooting. a2a.exposed hosts the A2A endpoint and is open to everyone
 (https://a2a.exposed/pricing). When to use it:
 https://github.com/telegraphic-dev/a2a-exposed/blob/main/docs/getting-started.md#hosted-inbox)
+  env [--json]                 print export A2A_CONFIG_DIR=<absolute dir> (no credentials; read-only).
+                                Pin scheduled jobs: mise exec node@22 -- npx -y a2a-exposed@latest
+                                --config-dir DIR inbox; use an absolute mise path outside your shell.
   init [--hostname <host> | --workers-dev [--workers-dev-subdomain NAME]]
        [--agent-name N] [--agent-description D] [--agent-skills JSON]
        [--provider-organization O --provider-url U] [--preset P] [--worker-name W] [--d1-name D]
@@ -137,7 +140,9 @@ https://github.com/telegraphic-dev/a2a-exposed/blob/main/docs/getting-started.md
                                 --upstream-token-stdin  read UPSTREAM_TOKEN from stdin (hidden prompt on a terminal)
                                 --no-upstream-token  the upstream needs no bearer token: skip that check (saved)
                                 --cli-command  command shown in wake hints (default "npx -y a2a-exposed@latest";
-                                               e.g. "node /path/to/repo/cli/bin/a2a-exposed.mjs")
+                                               e.g. "node /path/to/repo/cli/bin/a2a-exposed.mjs"). Non-default config dirs
+                                               are included in default hints; init saves the Node path and prints
+                                               a pinned command if PATH selects another Node.
                                 --worker-dir   where the Worker project (template copy) lives (default
                                                <config dir>/worker). The config dir is --config-dir / A2A_CONFIG_DIR
   deploy [same flags]           redeploy with saved settings (secrets persist); tag the Worker version as a2a-exposed-<version>
@@ -188,6 +193,8 @@ anywhere on the account: the A2A endpoint itself can be on workers.dev or a cust
                                 Defaults: openclaw-* -> http://127.0.0.1:18789 /hooks/wake|agent, hermes -> :8644
                                 /webhooks/a2a-wake (override with --hermes-route NAME). Token -> <config dir>/tunnel-token (chmod 600).
                                 Worker secrets show up in about 15 to 40 seconds. Wait about 30 seconds and check again
+                                Creation prints resource, connector, and optional persistent-service states.
+                                status reports connections and ephemeral/unknown persistence; macOS service install needs an admin terminal.
   tunnel zones [--json]         list available Cloudflare zones before selecting --tunnel-zone
   tunnel status                 tunnel/Access/Worker state + probes (bare request blocked? connector up?)
                                 A network error says DNS may still be propagating; retry in 30 seconds
@@ -220,7 +227,7 @@ Status
                                 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.
+                                token variables shadowing saved tokens; Node version/path and wake runtime mismatch; the next step.
                                 Older Workers need deploy (exit 1); npm latest hints use the local update cache.
                                 When GET /owner/mcp reports enabled and the agent card is reachable, prints
                                 \`claude mcp add --transport http a2a-exposed <base URL>/mcp\`.
@@ -266,8 +273,11 @@ Inbox (owner side)
   reply <taskId> (--text T | --stdin) [--state completed|input-required|rejected|failed|working]
         [--artifact] [--artifact-name N] [--force]
                                            delivery waits at most 18 s; identical retries read the first result
+                                           --force changes a terminal task again; peers see every change
+                                           push results show role/host/URL fingerprint; task state saved confirms storage
   history <contextId> [--from PEER] [-n 50] [--json]
-                                           conversation log. --from is one peer (the wake hint includes it)
+                                           conversation log with forced transitions and current state per task.
+                                           --from is one peer (the wake hint includes it)
   contexts                                 recent conversations
   export [--sql]                       JSON dump of this A2A endpoint on stdout (peer-token hashes and
                                        encrypted peer tokens are in the dump; the owner token stays
@@ -389,6 +399,8 @@ Self-hosted only. Hosted configs use hosted webhook settings or polling. Check s
                                 A finished tunnel creates nothing when you run it again. A partial tunnel stops and
                                 asks for tunnel rm. Prints the Access application name and ids, then how to undo it
                                 with tunnel rm. Worker secrets show up in about 15 to 40 seconds. Wait about 30 seconds.
+                                Creation prints resource, connector, and optional persistent-service states.
+                                status reports connections and ephemeral/unknown persistence; macOS service install needs an admin terminal.
   tunnel zones [--json]         List active zones before choosing --tunnel-zone; no resource changes.
   tunnel status                 Tunnel, Access, and Worker state, plus two probes.
                                 A network error says DNS may still be propagating; retry in 30 seconds.
@@ -434,6 +446,7 @@ const SPEC = {
 	send: { to: S, text: S, context: S, task: S, push: B, proto: S },
 	poll: { to: S, proto: S },
 	status: { json: B, agent: S, "control-url": S },
+	env: { json: B },
 	export: { sql: B },
 	upstream: { json: B },
 	connect: { alias: S, name: S, json: B, "no-wait": B, replace: B, force: B, "card-url": S },
@@ -477,7 +490,7 @@ export async function main(argv) {
 		if (extra.length && !ok)
 			throw new CliError("`pair set-password` takes no password argument: it reads the password from the terminal, without echo (never from argv, stdin or the environment). For a one-time web link instead: `pair set-password --web [--ttl MIN] [--json]`");
 	}
-	upd.check(VERSION);
+	if (name !== "env") upd.check(VERSION);
 	let parsed;
 	try {
 		parsed = parseArgs({ args: rest, options: SPEC[name] || {}, allowPositionals: true, strict: true });
@@ -494,6 +507,9 @@ export async function main(argv) {
 	const { values: o, positionals: p } = parsed;
 	if (o["worker-dir"] !== undefined) o.dir = o["worker-dir"];
 	switch (name) {
+		case "env":
+			if (p.length) throw new CliError("env takes no arguments; use --config-dir DIR to select a directory");
+			return console.log(o.json ? JSON.stringify({ A2A_CONFIG_DIR: C.CONFIG_DIR }) : `export A2A_CONFIG_DIR=${C.shellQuote(C.CONFIG_DIR)}`);
 		case "init":
 			if (o.tunnel) tun.preflight(o); // refuse early (hosted preset, missing --tunnel-path) before anything is deployed
 			await dep.init(o);

package/lib/pair.mjs

@@ -142,7 +142,7 @@ export async function setOidc(o, extra = []) {
 	console.error("The client secret was not written there and was not printed.");
 	if (sawStdin && !(process.env.APPROVAL_OIDC_CLIENT_SECRET || "").trim())
 		console.error(`Export APPROVAL_OIDC_CLIENT_SECRET in the environment you use for deploy. This command did not store it.`);
-	console.error(`The next \`npx -y a2a-exposed@latest deploy\` uploads APPROVAL_OIDC_CLIENT_SECRET only when that variable is set in the environment. A line from --secret-stdin is discarded.`);
+	console.error(`The next \`${CLI} deploy\` uploads APPROVAL_OIDC_CLIENT_SECRET only when that variable is set in the environment. A line from --secret-stdin is discarded.`);
 	console.error("Password approval stays available unless --methods oidc (and only once the issuer, client id, secret and allowlist are all set).");
 }
 
@@ -290,7 +290,7 @@ async function discover(target) {
 			ep = { device: m.data.device_authorization_endpoint, token: m.data.token_endpoint };
 	}
 	if (!ep) die(`${base} does not offer device-flow pairing (no OAuth2 deviceCode flow on its agent card, no ${u.origin}/.well-known/oauth-authorization-server).
-Ask its owner for a token instead: they run \`${CLI} token issue <label>\` and send it to you privately; then \`${CLI} peers add <alias> ${base} --token-stdin\`.`);
+Ask its owner for a token instead: they run \`${C.DEFAULT_CLI_COMMAND} token issue <label>\` and send it to you privately; then \`${CLI} peers add <alias> ${base} --token-stdin\`.`);
 	for (const x of [ep.device, ep.token]) {
 		const e = new URL(x);
 		if (e.protocol !== "https:" && !["127.0.0.1", "localhost", "[::1]"].includes(e.hostname)) die(`refusing a non-https pairing endpoint: ${x}`);
@@ -378,7 +378,7 @@ A different agent at the same URL? Pass another --alias.`);
 		const mins = Math.round((st.expiresAt - Date.now()) / 60000);
 		const swap = !st.replacing ? "" : st.replacesLabel
 			? ` On approval the peer replaces our token "${st.replacesLabel}" (the old one stops working).`
-			: ` This peer does not swap tokens: our old token${oldLabel ? ` (label "${oldLabel}" on its side)` : ""} stays active until its owner revokes it${oldLabel ? ` (\`${CLI} token revoke ${oldLabel}\`)` : ""}; tell them.`;
+			: ` This peer does not swap tokens: our old token${oldLabel ? ` (label "${oldLabel}" on its side)` : ""} stays active until its owner revokes it${oldLabel ? ` (\`${C.DEFAULT_CLI_COMMAND} token revoke ${oldLabel}\`)` : ""}; tell them.`;
 		emit({ status: "authorization_pending", alias, user_code: st.userCode, verification_uri: st.verificationUri, verification_uri_complete: st.verificationUriComplete, expires_in: Math.round((st.expiresAt - Date.now()) / 1000), interval: st.interval,
 			...(st.replacing ? { replaces_label: st.replacesLabel } : {}),
 			instructions: `Show the code and the link to your human. They confirm the code with the owner of ${peerName}, who approves it on that page.${swap}` },
@@ -399,7 +399,7 @@ Show this code and link to your human. They confirm the code with the owner of $
 		dropState(alias);
 		const orphan = st.replacing && !r.data.replaced ? (st.replacesLabel || oldLabel || null) : null;
 		const note = r.data.replaced ? ` It replaced our previous token there (label "${label}").`
-			: st.replacing ? ` Our previous token${orphan ? ` ("${orphan}")` : ""} is still active on the peer until its owner revokes it${orphan ? `: \`${CLI} token revoke ${orphan}\`` : ""}.` : "";
+			: st.replacing ? ` Our previous token${orphan ? ` ("${orphan}")` : ""} is still active on the peer until its owner revokes it${orphan ? `: \`${C.DEFAULT_CLI_COMMAND} token revoke ${orphan}\`` : ""}.` : "";
 		emit({ status: "connected", alias, url: base, token_env: tokenEnv, ...(label ? { peer_label: label } : {}), ...(st.replacing ? { replaced: !!r.data.replaced } : {}), ...(envOverrides ? { env_overrides_token: true } : {}) },
 			`connected: peer "${alias}" -> ${base}${label ? ` (we are "${label}" there)` : ""}; token stored in ${C.CONFIG_FILE} as ${tokenEnv} (not printed).${note}
 Send a message: ${CLI} send --to ${alias} --text "..."`);

package/lib/runtime.mjs

@@ -0,0 +1,54 @@
+// Runtime diagnostics only: inspect paths, never execute a saved wake command.
+import fs from "node:fs";
+import path from "node:path";
+import * as C from "./config.mjs";
+
+const canonical = (file) => { try { return fs.realpathSync(file); } catch { return path.resolve(file); } };
+export const sameExecutable = (a, b) => !!a && !!b && canonical(a) === canonical(b);
+
+export function pathNode(env = process.env) {
+	for (const dir of (env.PATH || "").split(path.delimiter)) {
+		const file = path.resolve(dir || ".", process.platform === "win32" ? "node.exe" : "node");
+		try {
+			fs.accessSync(file, fs.constants.X_OK);
+			if (fs.statSync(file).isFile()) return file;
+		} catch { /* try the next PATH entry */ }
+	}
+	return null;
+}
+
+/** Pin env-based Node shebangs (including npx and its children) to this runtime. */
+export function pinnedCommand(execPath = process.execPath) {
+	return `env PATH=${C.shellQuote(path.dirname(execPath))}:"$PATH" ${C.CLI_COMMAND}`;
+}
+
+// Read the first shell word without evaluating expansions, substitutions or commands.
+function firstWord(text) {
+	text = text.trim();
+	let word = "", quote = "";
+	for (let i = 0; i < text.length; i++) {
+		const c = text[i];
+		if (quote) {
+			if (c === quote) quote = "";
+			else if (c === "\\" && quote === '"') word += text[++i] || "";
+			else word += c;
+		} else if (c === "'" || c === '"') quote = c;
+		else if (/\s/.test(c)) break;
+		else if (c === "\\") word += text[++i] || "";
+		else word += c;
+	}
+	return quote ? "" : word;
+}
+
+export function runtimeInfo({ execPath = process.execPath, node = process.versions.node,
+	pathExecPath = pathNode(), initExecPath = C.get("A2A_NODE_EXEC_PATH"), command = C.get("WAKE_CLI_COMMAND", C.CLI_COMMAND) } = {}) {
+	const first = firstWord(command);
+	let wakeExecPath = null;
+	if (command === pinnedCommand(execPath)) wakeExecPath = execPath;
+	else if (initExecPath && command === pinnedCommand(initExecPath)) wakeExecPath = initExecPath;
+	else if (/^(node|npx|a2a-exposed)(\.exe|\.cmd)?$/.test(first)) wakeExecPath = pathExecPath;
+	else if (/^node(\.exe)?$/.test(path.basename(first)) && path.isAbsolute(first)) wakeExecPath = first;
+	const warning = wakeExecPath && !sameExecutable(wakeExecPath, execPath)
+		? `WAKE_CLI_COMMAND selects a different Node (${wakeExecPath}); this process uses ${execPath}. Pin the wake runtime with --cli-command (see env --help).` : null;
+	return { node, execPath, initExecPath: initExecPath || null, pathExecPath, wakeExecPath, warning };
+}

package/lib/status.mjs

@@ -2,11 +2,14 @@
 // calls only), so an agent that was interrupted can resume from the printed next step. The CLI fetches the agent card
 // itself, so agents need no curl (some agent sandboxes flag *.dev URLs in shell commands).
 import dns from "node:dns";
+import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import { isIP } from "node:net";
 import path from "node:path";
+import os from "node:os";
 import { promisify } from "node:util";
 import * as C from "./config.mjs";
+import { runtimeInfo } from "./runtime.mjs";
 import { CLI, cardUrlProblem, cfErrorCode, describeHttp, die, fingerprint, httpJson, isPrivateHost } from "./a2a.mjs";
 import { baseUrl, owner, ownerTry } from "./commands.mjs";
 import * as D from "./deploy.mjs";
@@ -14,6 +17,44 @@ import { buildLayers, layerValue, usablePin } from "./layers.mjs";
 import * as T from "./tunnel.mjs";
 import { cacheFile, readCache, newer } from "./update.mjs";
 
+/** Best-effort local check only. A terminal-attached process using this exact token file is ephemeral.
+ * Never return process arguments (they may contain credentials), or infer persistence from remote connections. */
+export function connectorPersistence(tokenFile, { platform = process.platform, run = spawnSync, exists = fs.existsSync, home = os.homedir() } = {}) {
+	if (!["darwin", "linux"].includes(platform) || !tokenFile) return "unknown";
+	try {
+		const ps = run("ps", ["-axo", "tty=,comm=,args="], { encoding: "utf8", timeout: 2000, maxBuffer: 1024 * 1024 });
+		if (ps.status !== 0 || ps.error) return "unknown";
+		const fileForms = [tokenFile, C.shellQuote(tokenFile), '"' + tokenFile.replaceAll('"', '\\"') + '"'];
+		const foreground = ps.stdout.split("\n").some((line) => {
+			const row = line.trim().match(/^(\S+)\s+(\S+)\s+(.+)$/);
+			if (!row || row[1] === "-" || row[1].startsWith("?")) return false;
+			if (path.basename(row[2]) !== "cloudflared" || !/\btunnel\s+run\b/.test(row[3])) return false;
+			return ["--token-file ", "--token-file="].some((flag) => fileForms.some((file) =>
+				row[3].endsWith(flag + file) || row[3].includes(flag + file + " --")));
+		});
+		if (!foreground) return "unknown";
+		const serviceFiles = platform === "darwin"
+			? ["/Library/LaunchDaemons/com.cloudflare.cloudflared.plist", "/Library/LaunchAgents/com.cloudflare.cloudflared.plist", path.join(home, "Library/LaunchAgents/com.cloudflare.cloudflared.plist")]
+			: ["/etc/systemd/system/cloudflared.service", "/usr/lib/systemd/system/cloudflared.service", path.join(home, ".config/systemd/user/cloudflared.service")];
+		if (serviceFiles.some(exists)) return "unknown";
+		const service = platform === "darwin"
+			? run("launchctl", ["list"], { encoding: "utf8", timeout: 2000, maxBuffer: 1024 * 1024 })
+			: run("systemctl", ["list-unit-files", "--type=service", "--no-pager", "--no-legend"], { encoding: "utf8", timeout: 2000, maxBuffer: 1024 * 1024 });
+		if (service.status !== 0 || service.error || /cloudflared/i.test(service.stdout)) return "unknown";
+		if (platform === "linux") {
+			const user = run("systemctl", ["--user", "list-unit-files", "--type=service", "--no-pager", "--no-legend"], { encoding: "utf8", timeout: 2000, maxBuffer: 1024 * 1024 });
+			if (user.status !== 0 || user.error || /cloudflared/i.test(user.stdout)) return "unknown";
+		}
+		// This describes the observed terminal process, not every possible custom service.
+		return "ephemeral";
+	} catch { return "unknown"; }
+}
+
+export function connectorLine(t) {
+	const state = t.connections == null ? "unknown" : t.connections > 0 ? `connected (${t.connections})` : "not connected (0)";
+	return `${state}, ${t.persistence === "ephemeral" ? "ephemeral (local terminal connector; no cloudflared service found)" : "persistence unknown"}`;
+}
+
 const DOH_URL = "https://cloudflare-dns.com/dns-query";
 const LOOKUP_MS = 5000;
 
@@ -284,7 +325,7 @@ export function nextStep(s) {
 	const n = nextStepCore(s);
 	const version = s.cliVersion || D.VERSION;
 	if (s.deployment !== "hosted" && s.workerVersion && s.latestVersion && newer(s.latestVersion, s.workerVersion) && !newer(s.workerVersion, version))
-		n.also.push(`a2a-exposed ${s.latestVersion} is available: run npx -y a2a-exposed@latest deploy`);
+		n.also.push(`a2a-exposed ${s.latestVersion} is available: run ${CLI} deploy`);
 	const sh = (s.peerTokenShadowed || []).map((k) => `${k} is set in the environment and overrides the different peer token saved in ${s.configFile} (e.g. a stale value from before \`connect\` stored a new one): send/poll use the environment value. Unset ${k} where it is set to use the saved token`);
 	const addr = s.addresses;
 	if (addr && Array.isArray(addr.announcePending) && addr.announcePending.length)
@@ -362,7 +403,7 @@ function nextStepCore(s) {
 		if (s.pairing && s.pairing.mode === "human" && !s.pairing.passwordSet)
 			also.push(`peers can't connect yet: run \`${CLI} pair set-password --web\` and send your human the one-time link (or they run \`${CLI} pair set-password\` in a terminal); never set it yourself`);
 		if (s.pairing && s.pairing.pending) also.push(`${s.pairing.pending} pending pairing request(s): \`${CLI} pair list\`, then tell your human (never approve on your own)`);
-		return done(`none: the façade is up and forwards paired peers' A2A calls to the upstream. Peers connect with \`${CLI} connect ${s.baseUrl}\``, also);
+		return done(`none: the façade is up and forwards paired peers' A2A calls to the upstream. Peers connect with \`${C.DEFAULT_CLI_COMMAND} connect ${s.baseUrl}\``, also);
 	}
 	const t = s.tunnel;
 	if (t && !t.complete) return fail(`a previous \`tunnel create\` did not finish: run \`${CLI} tunnel rm\`, then \`${CLI} tunnel create\``);
@@ -402,7 +443,7 @@ function nextStepCore(s) {
 		return done2(`no wake webhook, so ${poll}.`, [`optional: ${tunnel}`, ...(pub ? [`optional: ${pub}`] : [])]);
 	}
 	return done2(`none: setup is complete. Check a real wake with \`${CLI} wake test\`.`,
-		[`peers connect with \`${CLI} connect ${s.baseUrl}\` (your human approves each one); \`${CLI} token issue <peer>\` is the manual fallback`]);
+		[`peers connect with \`${C.DEFAULT_CLI_COMMAND} connect ${s.baseUrl}\` (your human approves each one); \`${CLI} token issue <peer>\` is the manual fallback`]);
 }
 
 function hostOf(url) {
@@ -465,7 +506,7 @@ function finishLayers(s, extra) {
  *  `net.lookup` and `net.doh` replace the system resolver and DNS-over-HTTPS in tests. */
 export async function collect(net = {}) {
 	const s = {
-		configFile: C.CONFIG_FILE,
+		configFile: C.CONFIG_FILE, runtime: runtimeInfo(),
 		deployment: C.deploymentKind(),
 		deployed: !!(C.get("A2A_D1_ID") && C.get("A2A_WORKER_NAME")),
 		worker: C.get("A2A_WORKER_NAME"), d1: C.get("A2A_D1_NAME"), account: C.get("CLOUDFLARE_ACCOUNT_ID"), cfProfile: C.get("CF_PROFILE"),
@@ -535,7 +576,8 @@ export async function collect(net = {}) {
 			const url = T.wakeUrl(tunnelHost || "?", C.get("A2A_TUNNEL_PATH") || "/");
 			s.tunnel = { hostname: tunnelHost, wakeUrl: url, origin: C.get("A2A_TUNNEL_ORIGIN"), complete: T.tunnelComplete(), tokenFileOk: T.tokenFileOk(),
 				tokenFile: C.get("A2A_TUNNEL_TOKEN_FILE") || "<config dir>/tunnel-token", workerUrlMatches: s.wake?.urlFingerprint === fingerprint(url),
-				secretsAt: Number(C.get("A2A_TUNNEL_SECRETS_AT")) || 0, connections: null };
+				secretsAt: Number(C.get("A2A_TUNNEL_SECRETS_AT")) || 0, connections: null,
+				persistence: connectorPersistence(C.get("A2A_TUNNEL_TOKEN_FILE")) };
 			if (haveCf && C.get("A2A_TUNNEL_ID")) {
 				try {
 					const t = T.cfCall(dir, ["tunnels", "get", C.get("A2A_TUNNEL_ID")], { allowNotFound: true });
@@ -609,6 +651,7 @@ export async function status(o) {
 	else {
 		const rows = [
 			["config", s.configFile],
+			["runtime", `Node ${s.runtime.node} (${s.runtime.execPath})${s.runtime.warning ? `; WARNING: ${s.runtime.warning}` : ""}`],
 			["deployment", s.deployment === "hosted" ? "hosted" : s.deployed ? `Worker ${s.worker}, D1 ${s.d1 || s.worker}${s.account ? `, account ${s.account}` : ""}${s.cfProfile ? `, cf profile ${s.cfProfile}` : ""}${s.cron ? ", cron flush on" : ""}` : "none"],
 			["base URL", s.baseUrl ? `${s.baseUrl} (${s.baseUrlEnv ? `from the exported A2A_BASE_URL; ${s.configFile} has ${s.baseUrlSaved || "none"}` : s.urlKind})` : "(not saved)"],
 		];
@@ -636,6 +679,7 @@ export async function status(o) {
 			const t = s.tunnel;
 			rows.push(["tunnel", !t ? "none" : `${t.wakeUrl} -> ${t.origin || "?"}; ${!t.complete ? "INCOMPLETE" : t.tokenFileOk ? "set up" : "set up, but the connector token file is MISSING"}` +
 				(t.connections != null ? `; ${tunnelStateLabel(t.state)}, ${t.connections} connector connection(s)` : t.error ? `; state unknown (${t.error})` : "")]);
+			if (t) rows.push(["connector", connectorLine(t)]);
 			if (s.zones) rows.push(["zones", s.zones.length ? s.zones.join(", ") : "none on this account"]);
 			const addr = s.addresses;
 			if (addr) {

package/lib/tunnel.mjs

@@ -156,7 +156,9 @@ export function connectorInstructions(tokenFile, token = "") {
 		"Run the connector there (outbound TCP/UDP 7844 to Cloudflare must be allowed):",
 		`  cloudflared tunnel run --token-file ${tokenFile}        # cloudflared 2025.4+`,
 		`  cloudflared tunnel run --token ${t}`,
-		`  sudo cloudflared service install ${t}   # as a system service (starts on boot)`,
+		`  sudo cloudflared service install ${t}   # optional system service (starts on boot)`,
+		"  On macOS, service install needs an admin password at a terminal; do not run it unattended.",
+		"  Without admin access, keep the --token-file command in a terminal, or use a user LaunchAgent (untested).",
 		token ? "  (token shown because of --show-token: treat it like a password)"
 			: `  The tunnel token is in ${tokenFile} (chmod 600). Copy that file to the agent's machine if it is another machine.`,
 	].join("\n");
@@ -373,6 +375,7 @@ export async function create(o) {
 		console.error(`Then (Worker secrets apply within about 15 to 40 seconds; wait about 30 seconds): ${CLI} tunnel status   and   ${CLI} wake test`);
 		if (!Object.keys(agentAuth).length && preset !== "generic")
 			console.error(`note: no WAKE_WEBHOOK_KEY / WAKE_HMAC_SECRET in the environment; keep the ${preset} webhook's own auth too (export it and run \`wake set\`)`);
+		console.error("created: tunnel, DNS, Access app, token\nconnector: not running (start it now)\npersistent service: not installed (optional)");
 	} catch (e) {
 		console.error("==> rolling back what was created");
 		await remove(o, { quiet: true, secretNames: createdSecrets }).catch((r) => console.error(`rollback incomplete: ${r.message}; re-run \`${CLI} tunnel rm\``));

package/lib/update.mjs

@@ -2,6 +2,7 @@
 // version and caches it; every run only reads that cache (no network call in the foreground). Off with
 // A2A_NO_UPDATE_CHECK=1, DO_NOT_TRACK=1, NO_UPDATE_NOTIFIER, CI, and when running from a source checkout.
 import fs from "node:fs";
+import { CLI_COMMAND } from "./config.mjs";
 import os from "node:os";
 import path from "node:path";
 import { spawn } from "node:child_process";
@@ -31,7 +32,7 @@ export function newer(a, b) {
 /** The notice for `current`, given the cache contents (or "" when up to date / unknown). */
 export function notice(current, cache) {
 	if (!cache || !cache.latest || !newer(cache.latest, current)) return "";
-	return `a2a-exposed ${cache.latest} is available (you have ${current}): run npx -y a2a-exposed@latest deploy (updates the Worker; applies new D1 migrations). With a global install, npm i -g a2a-exposed@latest first. Silence: A2A_NO_UPDATE_CHECK=1`;
+	return `a2a-exposed ${cache.latest} is available (you have ${current}): run ${CLI_COMMAND} deploy (updates the Worker; applies new D1 migrations). With a global install, npm i -g a2a-exposed@latest first. Silence: A2A_NO_UPDATE_CHECK=1`;
 }
 
 export const due = (cache, now = Date.now()) => !cache || !(now - (cache.checkedAt || 0) < CHECK_INTERVAL_MS);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "a2a-exposed",
-	"version": "0.8.41",
+	"version": "0.8.42",
 	"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

@@ -834,7 +834,7 @@ const rpcSend: Rpc = async (params, label, version, ctx, ectx) => {
 	const directReply = directReplyParams(params);
 	const conf = params.configuration || {};
 	const push = conf.taskPushNotificationConfig || conf.pushNotificationConfig;
-	const pushCfg = push ? normPushCfg(push, version) : null;
+	const pushCfg = push ? { ...normPushCfg(push, version), _role: "message push" } : null;
 	let task: Json = null;
 	if (msg.taskId) {
 		task = await ownedTask(ctx, msg.taskId, label);
@@ -896,7 +896,7 @@ const rpcPushSet: Rpc = async (p, label, version, ctx) => {
 	else if (p.config && typeof p.config === "object") { taskId = p.taskId || String(p.parent || "").split("/").pop(); cfg = p.config; }
 	else { taskId = p.taskId; cfg = { id: p.id, url: p.url, token: p.token, authentication: p.authentication }; }
 	const t = await ownedTask(ctx, taskId, label);
-	const c = normPushCfg(cfg, version);
+	const c = { ...normPushCfg(cfg, version), _role: "task push config" };
 	t._push = [...t._push.filter((x: Json) => x.id !== c.id), c];
 	await saveTaskStmt(ctx, t).run();
 	return pubCfg(t.id, c, version);
@@ -1237,8 +1237,8 @@ async function sendPush(ctx: TenantContext, ectx: ExecutionContext, task: Json,
 	try {
 		const r = await doFetch(ctx, ectx, cfg.url, { method: "POST", headers, body: JSON.stringify(body), signal });
 		return [r.status >= 200 && r.status < 300, `HTTP ${r.status}`];
-	} catch (e) {
-		return [false, String(e).slice(0, 200)];
+	} catch {
+		return [false, "push request failed"];
 	}
 }
 
@@ -1250,8 +1250,9 @@ async function notifyPeer(ctx: TenantContext, ectx: ExecutionContext, t: Json, s
 			? await withDeadline(7000, (step) => sendPush(ctx, ectx, t, cfg, step), signal)
 			: await sendPush(ctx, ectx, t, cfg);
 		signal?.throwIfAborted();
-		results.push({ url: cfg.url, ok, info });
-		await histStmt(ctx, t.contextId, { dir: "out", peer: t._peer, taskId: t.id, event: "push", state: t.status.state, text: `${ok ? "ok" : "FAILED"} ${info}` }).run();
+		const result = { role: cfg._role === "message push" ? "message push" : "task push config", host: new URL(cfg.url).host, fingerprint: await A.fingerprint(cfg.url), ok, info };
+		results.push(result);
+		await histStmt(ctx, t.contextId, { dir: "out", peer: t._peer, taskId: t.id, event: "push", state: t.status.state, text: `${result.role} ${result.host} [${result.fingerprint}]: ${ok ? "ok" : "FAILED"} ${info}`, data: result }).run();
 	}
 	return results;
 }
@@ -1264,6 +1265,7 @@ type ReplyDelivery = {
 	target?: { alias?: string; host: string };
 	httpStatus?: number;
 	detail: string;
+	push?: Json[];
 };
 
 const DIRECT_REPLY_META = "a2a.exposed/reply-delivery";
@@ -1695,12 +1697,13 @@ async function deliverReplyMessage(ctx: TenantContext, ectx: ExecutionContext, t
 	if (task._push?.length) {
 		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 host = (failed || pushed[0])?.host;
+		const target = host ? { host } : undefined;
 		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,
+			status: failed ? "delivery-failed" : "delivered", method: "push", taskId: task.id, state, push: pushed,
 			...(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.",
 		};
@@ -2123,7 +2126,7 @@ async function handleOwner(req: Request, ctx: TenantContext, ectx: ExecutionCont
 		if (seg[2] === "working" && m === "POST") {
 			if (A.TERMINAL.has(t.status.state)) return json({ error: `task is already ${t.status.state}` }, 409);
 			t.status = { state: "working", timestamp: A.nowIso() };
-			await ctx.DB.batch([saveTaskStmt(ctx, t), histStmt(ctx, t.contextId, { dir: "local", taskId: t.id, event: "state", state: "working" })]);
+			await ctx.DB.batch([saveTaskStmt(ctx, t), histStmt(ctx, t.contextId, { dir: "local", peer: t._peer, taskId: t.id, event: "state", state: "working" })]);
 			await ackPendingWakes(ctx, [{ taskId: t.id, contextId: t.contextId }]);
 			return json({ task: ownerTaskView(t), push: await notifyPeer(ctx, ectx, t) });
 		}
@@ -2164,11 +2167,14 @@ async function handleOwner(req: Request, ctx: TenantContext, ectx: ExecutionCont
 				if (raced?.result_json) return json({ task: ownerTaskView(await loadTask(ctx, t.id)), delivery: JSON.parse(raced.result_json), idempotent: true });
 				return json({ error: "this reply is already being delivered; retry to read its result" }, 409);
 			}
+			const forced = !!b.force && A.TERMINAL.has(t.status.state);
+			const previousState = t.status.state;
 			if (state === "completed" || b.artifact) t.artifacts.push({ artifactId: A.newId(), name: b.artifactName || "response", parts: [{ kind: "text", text: b.text }] });
 			t.history.push(msg);
 			t.status = { state, timestamp: now, message: msg };
 			await ctx.DB.batch([saveTaskStmt(ctx, t), msgStmt(ctx, t, msg),
-				histStmt(ctx, t.contextId, { dir: "out", peer: t._peer, taskId: t.id, role: "agent", state, text: b.text })]);
+				histStmt(ctx, t.contextId, { dir: "out", peer: t._peer, taskId: t.id, role: "agent", state, text: b.text,
+					...(forced ? { event: "forced", data: { forced: true, previousState, state } } : {}) })]);
 			await ackPendingWakes(ctx, [{ taskId: t.id, contextId: t.contextId }]);
 			let delivery: ReplyDelivery;
 			try { delivery = await withDeadline(18000, (signal) => deliverReplyMessage(ctx, ectx, t, msg, state, b.text, signal)); }
@@ -2192,7 +2198,13 @@ async function handleOwner(req: Request, ctx: TenantContext, ectx: ExecutionCont
 		if (fromFilter !== null && !PEER_FILTER.test(fromFilter)) return json({ error: "from is invalid" }, 400);
 		// Without `from`, rows for every peer that owns this context id (a task or an outbound task), plus local notes.
 		// With `from`, one peer's rows only, so another peer's conversation is not in this read.
-		const rows = await ctx.DB.prepare(fromFilter ? `SELECT * FROM (
+		const rows = await ctx.DB.prepare(`SELECT h.*,
+			(SELECT status_json FROM tasks WHERE id = h.task_id AND context_id = h.context_id
+			 AND (h.peer IS NULL OR h.peer = '' OR peer = h.peer)) AS current_status_json,
+			(SELECT json_object('state', state, 'timestamp', ts) FROM history latest
+			 WHERE latest.context_id = h.context_id AND latest.task_id = h.task_id AND latest.peer IS h.peer
+			 AND latest.state IS NOT NULL ORDER BY latest.seq DESC LIMIT 1) AS current_history_json
+			FROM (${fromFilter ? `SELECT * FROM (
 			SELECT * FROM history WHERE context_id = ? AND (
 				peer = ?
 				OR (
@@ -2213,10 +2225,12 @@ async function handleOwner(req: Request, ctx: TenantContext, ectx: ExecutionCont
 					AND NOT EXISTS (SELECT 1 FROM outbound WHERE context_id = ?)
 				)
 			) ORDER BY seq DESC LIMIT ?
-		) ORDER BY seq`).bind(...(fromFilter
+		) ORDER BY seq`} ) h ORDER BY h.seq`).bind(...(fromFilter
 			? [seg[1], fromFilter, seg[1], fromFilter, seg[1], fromFilter, n]
 			: [seg[1], seg[1], seg[1], seg[1], seg[1], n])).all();
-		return json((rows.results as Json[]).map((r) => ({ ...r, data: r.data_json ? JSON.parse(r.data_json) : undefined, data_json: undefined })));
+		return json((rows.results as Json[]).map((r) => ({ ...r, data: r.data_json ? JSON.parse(r.data_json) : undefined, data_json: undefined,
+			currentState: r.current_status_json ? (({ state, timestamp }) => ({ state, timestamp }))(JSON.parse(r.current_status_json))
+				: r.current_history_json ? JSON.parse(r.current_history_json) : undefined, current_status_json: undefined, current_history_json: undefined })));
 	}
 	if (seg[0] === "history" && !seg[1] && m === "POST") {
 		const b = await body();

package/worker/src/mcp.ts

@@ -346,6 +346,10 @@ export const TOOLS: { name: string; title: string; description: string; inputSch
 			status: str("Delivery outcome", { enum: ["delivered", "stored-only", "delivery-failed"] }),
 			method: str("Path used", { enum: ["push", "a2a-message", "stored"] }),
 			target: { type: "object", properties: { alias: str("Paired peer alias"), host: str("Destination host") }, required: ["host"], additionalProperties: false },
+			push: { type: "array", items: { type: "object", properties: {
+				role: str("Callback origin", { enum: ["task push config", "message push"] }), host: str("Callback host"),
+				fingerprint: str("First 12 hex characters of SHA-256 of the callback URL"), ok: { type: "boolean" }, info: str("Safe push result"),
+			}, required: ["role", "host", "fingerprint", "ok", "info"], additionalProperties: false } },
 			httpStatus: { type: "integer", minimum: 100, maximum: 599 }, detail: str("Safe delivery summary"),
 		}, required: ["taskId", "state", "status", "method", "detail"], additionalProperties: false } },
 	{ name: "send", title: "Send to peer", annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },

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.41";
+export const VERSION = "0.8.42";

package/worker/test/push-config.test.ts

@@ -159,3 +159,70 @@ test("1.0 list pages configs and 0.3 delete returns null", async (t) => {
 	hides(del.text, token);
 	assert.equal(s.logs.some((line) => line.includes(token)), false);
 });
+
+test("push results identify callbacks without URLs, and forced replies preserve transitions", async (t) => {
+	const s = setup();
+	t.after(s.restore);
+	const originalFetch = globalThis.fetch;
+	t.after(() => { globalThis.fetch = originalFetch; });
+	const attempted: string[] = [];
+	globalThis.fetch = (async (url: any) => {
+		attempted.push(String(url));
+		return new Response(null, { status: String(url).includes("first") ? 401 : 200 });
+	}) as typeof fetch;
+	const ada = (await s.owner("POST", "/owner/peers", { label: "ada" })).token;
+	const first = "https://hooks.example.net/private/first?token=first-secret";
+	const second = "https://hooks.example.net/private/second?token=second-secret";
+	const sent = await s.call(ada, "message/send", {
+		message: { kind: "message", role: "user", messageId: crypto.randomUUID(), parts: [{ kind: "text", text: "hello" }] },
+		configuration: { pushNotificationConfig: { id: "message", url: first } },
+	});
+	const { id: taskId, contextId } = sent.data.result;
+	await s.call(ada, "tasks/pushNotificationConfig/set", { taskId, pushNotificationConfig: { id: "task", url: second } });
+	const working = await s.owner("POST", `/owner/tasks/${taskId}/working`, {});
+	assert.deepEqual(working.push.map((r: any) => [r.role, r.host, r.ok, r.info]), [
+		["message push", "hooks.example.net", false, "HTTP 401"], ["task push config", "hooks.example.net", true, "HTTP 200"],
+	]);
+	assert.deepEqual(working.push.map((r: any) => r.fingerprint), [(await sha256(first)).slice(0, 12), (await sha256(second)).slice(0, 12)]);
+	assert.doesNotMatch(JSON.stringify(working.push), /token=|first-secret|second-secret|private|https:/);
+	const done = await s.owner("POST", `/owner/tasks/${taskId}/reply`, { text: "done", state: "completed" });
+	assert.deepEqual(done.delivery.push, working.push);
+	assert.equal(done.task.status.state, "completed");
+	const blocked = await s.owner("POST", `/owner/tasks/${taskId}/reply`, { text: "question", state: "input-required" });
+	assert.match(blocked.error, /already completed/);
+	const forced = await s.owner("POST", `/owner/tasks/${taskId}/reply`, { text: "question", state: "input-required", force: true });
+	assert.equal(forced.task.status.state, "input-required");
+	const history = await s.owner("GET", `/owner/history/${contextId}?from=ada`);
+	const transitions = history.filter((r: any) => r.event === "forced");
+	assert.equal(transitions.length, 1);
+	assert.deepEqual(transitions[0].data, { forced: true, previousState: "completed", state: "input-required" });
+	assert.ok(history.every((r: any) => r.currentState.state === "input-required"));
+	assert.deepEqual(history.at(-1).currentState, { state: "input-required", timestamp: forced.task.status.timestamp });
+	assert.doesNotMatch(JSON.stringify(history), /first-secret|second-secret|private/);
+	const count = attempted.length;
+	const retry = await s.owner("POST", `/owner/tasks/${taskId}/reply`, { text: "question", state: "input-required", force: true });
+	assert.equal(retry.idempotent, true);
+	assert.equal(attempted.length, count);
+	const after = await s.owner("GET", `/owner/history/${contextId}?n=1&from=ada`);
+	assert.deepEqual(after[0].currentState, history.at(-1).currentState);
+	globalThis.fetch = (async () => { throw new Error(`failed ${first}`); }) as typeof fetch;
+	const failed = await s.owner("POST", `/owner/tasks/${taskId}/reply`, { text: "final", state: "completed" });
+	assert.doesNotMatch(JSON.stringify(failed.delivery), /first-secret|second-secret|private/);
+	assert.equal(failed.delivery.push[0].info, "push request failed");
+});
+
+test("limited outbound history reports the latest state for that peer only", async (t) => {
+	const s = setup();
+	t.after(s.restore);
+	const contextId = "outbound-history";
+	const taskId = "remote-task";
+	await s.owner("POST", "/owner/history", { contextId, taskId, peer: "ada", state: "working", ts: "2026-11-07T01:00:00.000Z" });
+	await s.owner("POST", "/owner/history", { contextId, taskId, peer: "bob", state: "failed", ts: "2026-11-07T01:01:00.000Z" });
+	await s.owner("POST", "/owner/history", { contextId, taskId, peer: "ada", event: "note", text: "latest note without a state" });
+	const rows = await s.owner("GET", `/owner/history/${contextId}?from=ada&n=1`);
+	assert.equal(rows.length, 1);
+	assert.equal(rows[0].event, "note");
+	assert.deepEqual(rows[0].currentState, { state: "working", timestamp: "2026-11-07T01:00:00.000Z" });
+	assert.equal(rows[0].current_history_json, undefined);
+	assert.equal(rows[0].current_status_json, undefined);
+});