a2a-exposed 0.8.38 → 0.8.40

package/lib/deploy.mjs

@@ -51,7 +51,7 @@ const DEPLOY_KEYS = [
 	"A2A_AGENT_NAME", "A2A_AGENT_DESCRIPTION", "A2A_AGENT_VERSION", "A2A_AGENT_SKILLS",
 	"A2A_PROVIDER_ORGANIZATION", "A2A_PROVIDER_URL", "A2A_DOCUMENTATION_URL",
 	"WAKE_PRESET", "WAKE_AGENT_ID", "WAKE_KEY_HEADER", "WAKE_KEY_PREFIX", "WAKE_BODY_TEMPLATE", "WAKE_CLI_COMMAND",
-	"WAKE_DEBOUNCE_SECONDS", "WAKE_MAX_PER_HOUR", "A2A_MAX_BODY", "A2A_RATE_PER_MIN", "A2A_ENABLE_CRON",
+	"WAKE_DEBOUNCE_SECONDS", "WAKE_BUSY_SECONDS", "WAKE_MAX_PER_HOUR", "A2A_MAX_BODY", "A2A_RATE_PER_MIN", "A2A_ENABLE_CRON",
 	"A2A_WORKERS_DEV_SUBDOMAIN", "A2A_RETIRED_HOSTNAMES", "PAIRING_APPROVAL", "A2A_PBKDF2_ITERATIONS", "A2A_WORKERS_LOGS", "A2A_MCP",
 	"A2A_UPSTREAM_URL", "A2A_UPSTREAM_CARD_URL",
 	"APPROVAL_OIDC_ISSUER", "APPROVAL_OIDC_CLIENT_ID", "APPROVAL_OIDC_ALLOWED_SUBJECTS", "APPROVAL_METHODS",
@@ -63,7 +63,7 @@ const FLAG_KEYS = {
 	"agent-name": "A2A_AGENT_NAME", "agent-description": "A2A_AGENT_DESCRIPTION", "agent-skills": "A2A_AGENT_SKILLS",
 	"provider-organization": "A2A_PROVIDER_ORGANIZATION", "provider-url": "A2A_PROVIDER_URL",
 	preset: "WAKE_PRESET", "agent-id": "WAKE_AGENT_ID", "key-header": "WAKE_KEY_HEADER", "key-prefix": "WAKE_KEY_PREFIX",
-	"body-template": "WAKE_BODY_TEMPLATE", "cli-command": "WAKE_CLI_COMMAND", debounce: "WAKE_DEBOUNCE_SECONDS", "max-per-hour": "WAKE_MAX_PER_HOUR",
+	"body-template": "WAKE_BODY_TEMPLATE", "cli-command": "WAKE_CLI_COMMAND", debounce: "WAKE_DEBOUNCE_SECONDS", busy: "WAKE_BUSY_SECONDS", "max-per-hour": "WAKE_MAX_PER_HOUR",
 	"pairing-approval": "PAIRING_APPROVAL", "pbkdf2-iterations": "A2A_PBKDF2_ITERATIONS", "workers-logs": "A2A_WORKERS_LOGS", mcp: "A2A_MCP",
 	upstream: "A2A_UPSTREAM_URL", "upstream-card-url": "A2A_UPSTREAM_CARD_URL",
 	"manage-url": "MANAGE_URL", "event-url": "EVENT_URL",

package/lib/hosted.mjs

@@ -4,7 +4,7 @@ import * as C from "./config.mjs";
 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"];
+export const SETUP_SCOPES = ["agents:read", "agents:create", "agents:owner-token", "wake:write", "wake:test", "upstream:write", "upstream: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; };
@@ -62,6 +62,7 @@ async function request(origin, path, { token = "", method = "GET", body, fetchIm
 		const code = known.includes(data.error) ? data.error : `http_${response.status}`;
 		const next = code === "taken" || code === "reserved_name" ? "Choose another --name using hosted names --name NAME --json before creating."
 			: code === "limit" ? "The account is at its agent limit. Read hosted capacity --json and review account plans."
+			: code === "conflict" && path.includes("/upstream") ? "Upstream settings changed. Run hosted upstream preview --agent NAME --json, then repeat with its explicit --version."
 			: code === "conflict" ? "Wake settings changed. Run wake preview --json, then test the draft again."
 			: code === "invalid_reference" ? "The wake reference was already used, expired or does not match this draft. Run wake prepare again with the draft inputs and a new --reference-file."
 			: code === "invalid_grant" || code === "insufficient_scope" ? NEXT
@@ -74,7 +75,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", 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 };
+	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)), upstream: data.upstream?.configuration === true && data.upstream?.verify === true, 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 };
 }
 
 export async function login(o = {}) {
@@ -283,6 +284,34 @@ export async function wake(sub, o = {}) {
 	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."}` };
 }
 
+/** Hosted upstream configuration uses only scoped setup or this agent's owner credential. */
+export async function upstream(sub, o = {}) {
+	if (!["preview", "set", "clear", "verify"].includes(sub)) fail("usage", "Use hosted upstream preview|set|clear|verify --agent NAME --json. Select NAME with hosted list --json and scopes with hosted capabilities --json.");
+	const allowed = new Set(["agent", "json", "control-url", ...(sub === "preview" ? [] : ["version"]), ...(sub === "set" ? ["url", "upstream-token-file", "upstream-token-env", "access-client-id-file", "access-client-id-env", "access-client-secret-file", "access-client-secret-env"] : [])]);
+	if (Object.keys(o).some(key => !allowed.has(key))) fail("usage", "Use only the options for hosted upstream preview|set|clear|verify shown in --help; secret inputs belong only to set.");
+	if (sub !== "preview" && (!/^(0|[1-9][0-9]*)$/.test(String(o.version ?? "")) || !Number.isSafeInteger(Number(o.version)))) fail("version", "Pass --version N from hosted upstream preview --agent NAME --json; no version is selected automatically.");
+	let body = { version: Number(o.version) };
+	if (sub === "set") {
+		const url = String(o.url || "");
+		if (!url || upstreamUrlProblem(url)) fail("url", "Pass --url with a public HTTPS A2A address; use hosted upstream clear to remove it.");
+		body = { ...body, url, token: secret(o, "upstream-token", "UPSTREAM_TOKEN"), accessClientId: secret(o, "access-client-id", "UPSTREAM_ACCESS_CLIENT_ID"), accessClientSecret: secret(o, "access-client-secret", "UPSTREAM_ACCESS_CLIENT_SECRET") };
+		if (Boolean(body.accessClientId) !== Boolean(body.accessClientSecret)) fail("access", "Supply both Access credentials through protected files or named environment variables. A new address requires both.");
+	}
+	const { origin, token, name } = wakeCredential(o, true);
+	if (!(await capabilities({ "control-url": origin })).upstream) fail("unsupported", "This service does not expose upstream configuration. Run hosted capabilities --json before selecting an operation.");
+	const path = `/api/v1/agents/${encodeURIComponent(name)}/upstream`;
+	const current = await request(origin, path, { token });
+	if (!Number.isSafeInteger(current.version) || typeof current.configured !== "boolean") fail("invalid_response", "No valid upstream version was returned. Run hosted upstream preview --agent NAME --json before retrying.");
+	if (sub === "preview") return { ok: true, code: "upstream", version: current.version, configured: current.configured, next: "Review this version, then pass --version N to set, clear or verify. Addresses and credentials are never printed." };
+
+	if (Number(o.version) !== current.version) fail("conflict", "Upstream settings changed. Run hosted upstream preview --agent NAME --json, review the version and repeat the explicit operation.");
+
+	const result = await request(origin, sub === "verify" ? `${path}/verify` : path, { token, method: sub === "verify" ? "POST" : sub === "clear" ? "DELETE" : "PUT", body });
+	const reasons = ["reachable", "access_credentials_missing", "access_rejected", "upstream_auth_missing", "upstream_auth_rejected", "tunnel_down", "upstream_unavailable", "network", "unexpected_response", "misconfigured"];
+	const ok = result.ok === true && (sub === "verify" ? result.reason === "reachable" : sub === "clear" ? result.removed === true : result.saved === true);
+	return { ok, code: sub === "verify" ? reasons.includes(result.reason) ? result.reason : "unexpected_response" : ok ? sub === "clear" ? "removed" : "saved" : "failed", ...(Number.isSafeInteger(result.version) ? { version: result.version } : {}), next: sub === "verify" ? ok ? "The saved upstream is reachable. You may pair and send a message." : "Check the connection layer named by code, then verify again. Keep Access and agent authentication enabled." : "Run hosted upstream preview --json, then verify with its explicit version before pairing." };
+}
+
 export async function output(run, o = {}) {
 	try {
 		const result = await run();

package/lib/main.mjs

@@ -36,9 +36,19 @@ Hosted setup:
                                 check one name anonymously before device approval; never lists other agents
   hosted capacity --json      read account room with agents:read (or agents:create); reserves nothing
   hosted list --json           list hosted agents with agents:read or agents:create before choosing an agent
+  hosted upstream preview|set|clear|verify --agent NAME --json
+                                list scopes with hosted capabilities and agents with hosted list first
+                                preview returns version; set/clear/verify require --version N
+                                set takes --url URL and --upstream-token-file FILE|--upstream-token-env VAR,
+                                --access-client-id-file FILE|--access-client-id-env VAR and
+                                --access-client-secret-file FILE|--access-client-secret-env VAR
+                                files require mode 600; defaults UPSTREAM_TOKEN/UPSTREAM_ACCESS_CLIENT_ID/
+                                UPSTREAM_ACCESS_CLIENT_SECRET; never pass secret values as arguments
   hosted create --name NAME --json
                                 create and save the owner credential in this config directory;
                                 use a separate --config-dir for each agent
+                                manual fallback: human creates the address in a signed-in dashboard session,
+                                then saves A2A_BASE_URL + A2A_OWNER_TOKEN in protected config or routine secrets
   wake preview|test|set --agent NAME [--url URL] [--preset P] --json
                                 hosted settings: read, test a draft, or test then save it
                                 secrets: --key-file, --key-env, --key-stdin, --hmac-secret-file, --hmac-secret-env,
@@ -66,7 +76,7 @@ https://github.com/telegraphic-dev/a2a-exposed/blob/main/docs/getting-started.md
   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]
-       [--account-id ID] [--cf-profile NAME] [--cli-command CMD] [--debounce S] [--max-per-hour N]
+       [--account-id ID] [--cf-profile NAME] [--cli-command CMD] [--debounce S] [--busy S] [--max-per-hour N]
        [--pairing-approval human|agent|off] [--pbkdf2-iterations N] [--workers-logs on|off] [--mcp on|off] [--cron]
        [--manage-url URL] [--event-url URL] [--event-secret-stdin]
        [--rotate-owner-token]
@@ -131,12 +141,15 @@ https://github.com/telegraphic-dev/a2a-exposed/blob/main/docs/getting-started.md
                                                <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>
   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]
+           [--cli-command CMD] [--debounce S] [--busy S] [--max-per-hour N]
                                 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)
+                                --busy S        seconds a conversation stays busy after a sent wake.
+                                               0 disables it. Unset uses the preset default:
+                                               300 for claude-code, 180 for the others
                                 --max-per-hour  hourly cap; 0 or unset is unlimited, except Claude Code,
                                                which defaults to 25 when this is unset
   wake preview                  rendered wake request (a credential is Bearer •••• or ••••, none of the secret)
@@ -397,7 +410,7 @@ const deployOpts = {
 	"workers-dev": B, "workers-dev-subdomain": S, "upstream-token-stdin": B, "no-upstream-token": B, "event-secret-stdin": B,
 };
 const SPEC = {
-	hosted: { name: S, json: B, agent: S, hostname: S, origin: S, path: S, preset: S, "control-url": S, "secret-file": S, "secret-env": S, "secret-from": S, "hermes-home": S, route: S, "token-file": S, "no-run": B },
+	hosted: { url: S, version: S, "upstream-token-file": S, "upstream-token-env": S, "access-client-id-file": S, "access-client-id-env": S, "access-client-secret-file": S, "access-client-secret-env": S, name: S, json: B, agent: S, hostname: S, origin: S, path: S, preset: S, "control-url": S, "secret-file": S, "secret-env": S, "secret-from": S, "hermes-home": S, route: S, "token-file": S, "no-run": B },
 	init: { ...deployOpts, ...tunnelOpts, tunnel: B }, deploy: deployOpts,
 	wake: { ...deployOpts, json: B, url: S, "reference-file": S, "reference-env": S, clear: B, version: S, agent: S, "control-url": S, "key-header": S, "key-file": S, "key-env": S, "key-stdin": B, "hmac-secret-file": S, "hmac-secret-env": S, "access-client-id-file": S, "access-client-id-env": S, "access-client-secret-file": S, "access-client-secret-env": S }, tunnel: tunnelOpts,
 	inbox: { context: S, from: S, all: B, json: B },
@@ -523,6 +536,7 @@ export async function main(argv) {
 			throw new CliError(`unknown peer action ${sub} (announce|forward)`);
 		}
 		case "hosted": {
+			if (p[0] === "upstream" && p.length === 2) return hosted.output(() => hosted.upstream(p[1], o), o);
 			if (p.length === 1 && ["capabilities", "list", "create", "names", "capacity"].includes(p[0])) return hosted.output(() => hosted[p[0]](o), o);
 			if (p.length !== 2 || p[0] !== "link" || !["finish", "create"].includes(p[1])) return linkOutput(linkUsage, o);
 			return linkOutput(() => (p[1] === "create" ? createLink : finishLink)({ ...o, "control-url": o["control-url"] || C.get("CONTROL_URL") }), o);

package/lib/status.mjs

@@ -198,7 +198,12 @@ export function wakeLine(s) {
 		? "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 || "-"}`;
+	const timing = [
+		Number.isFinite(Number(w.debounceSeconds)) ? `debounce ${w.debounceSeconds}s` : "",
+		Number.isFinite(Number(w.busySeconds)) ? `busy ${w.busySeconds}s` : "",
+	].filter(Boolean);
+	const timingText = timing.length ? `; ${timing.join(", ")}` : "";
+	return `webhook (preset ${w.preset}${s.tunnel ? ", through the tunnel" : ""})${timingText}; auth: ${auth.join(" + ") || "none"}; URL fingerprint ${w.urlFingerprint || "-"}`;
 }
 
 // ---------------------------------------------------------------- proxy mode: upstream diagnosis
@@ -487,7 +492,9 @@ export async function collect(net = {}) {
 				const p = await owner("GET", "/owner/wake/preview");
 				s.ownerApi = { ok: true };
 				s.wake = { preset: p.preset, configured: !!p.configured, hasKey: !!p.hasKey, hasHmacSecret: !!p.hasHmacSecret,
-					hasAccessServiceToken: !!p.hasAccessServiceToken, urlFingerprint: p.fingerprints?.url || null };
+					hasAccessServiceToken: !!p.hasAccessServiceToken, urlFingerprint: p.fingerprints?.url || null,
+					...(Number.isFinite(Number(p.debounceSeconds)) ? { debounceSeconds: Number(p.debounceSeconds) } : {}),
+					...(Number.isFinite(Number(p.busySeconds)) ? { busySeconds: Number(p.busySeconds) } : {}) };
 			} catch (e) {
 				s.ownerApi = { ok: false, error: e.message };
 				if (s.deployment === "hosted" && /HTTP (404|405)\b/.test(e.message)) {

package/package.json

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

package/worker/cloudflare.config.ts

@@ -35,7 +35,10 @@ const plain: Record<string, string> = {
 	WAKE_BODY_TEMPLATE: v("WAKE_BODY_TEMPLATE"), // generic preset JSON template
 	WAKE_CLI_COMMAND: v("WAKE_CLI_COMMAND"), // how the woken agent runs the CLI (default "npx -y a2a-exposed@latest")
 	WAKE_DEBOUNCE_SECONDS: v("WAKE_DEBOUNCE_SECONDS"),
+	WAKE_BUSY_SECONDS: v("WAKE_BUSY_SECONDS"),
 	WAKE_MAX_PER_HOUR: v("WAKE_MAX_PER_HOUR"),
+	// Visible at runtime so a busy catch-up is held only when this minute cron will flush it.
+	ENABLE_CRON: v("A2A_ENABLE_CRON") === "1" ? "1" : "",
 	MAX_BODY: v("A2A_MAX_BODY"),
 	RATE_PER_MIN: v("A2A_RATE_PER_MIN"),
 	RETIRED_HOSTNAMES: v("A2A_RETIRED_HOSTNAMES"), // custom domains this agent moved away from (see movedResponse)

package/worker/migrations/0016_wake_busy.sql

@@ -0,0 +1,3 @@
+-- Busy cool-down after a sent message wake. Later events for this peer and conversation
+-- accumulate until busy_until_ms, which sends one catch-up. An inbox read does not clear it.
+ALTER TABLE wakes ADD COLUMN busy_until_ms INTEGER;

package/worker/src/index.ts

@@ -7,7 +7,7 @@
 import { VERSION } from "./version.ts";
 import * as A from "./a2a.ts";
 import * as F from "./facade.ts";
-import { renderWake, redact, cloudflareErrorHint, wakeUrlIsTunnelHost, defaultDebounceSeconds, defaultMaxPerHour, type WakeConfig, type WakeEvent } from "./wake.ts";
+import { renderWake, redact, cloudflareErrorHint, wakeUrlIsTunnelHost, defaultBusySeconds, defaultDebounceSeconds, defaultMaxPerHour, type WakeConfig, type WakeEvent } from "./wake.ts";
 import { fetchCheckedPeer, fetchCheckedWake } from "./wake-target.ts";
 import { withDeadline } from "./deadline.ts";
 import * as Addr from "./address.ts";
@@ -174,6 +174,50 @@ function wakeConfig(ctx: TenantContext): WakeConfig {
 
 const debounceMs = (ctx: TenantContext) => Number(ctx.WAKE_DEBOUNCE_SECONDS || defaultDebounceSeconds(preset(ctx))) * 1000;
 
+/** Kinds that share a conversation busy window. Pairing, address, and test wakes send on their own. */
+const MESSAGE_WAKE_KINDS = new Set(["inbound", "outbound_update"]);
+
+function messageWake(kind: string): boolean {
+	return MESSAGE_WAKE_KINDS.has(kind);
+}
+
+function wakeHooked(ctx: TenantContext): boolean {
+	return !!(ctx.WAKE_WEBHOOK_URL || "").trim();
+}
+
+/**
+ * Busy cool-down after a sent message wake. Empty uses the preset default.
+ * An explicit 0 disables it. A non-numeric value uses the preset default.
+ */
+function busyMs(ctx: TenantContext): number {
+	const raw = (ctx.WAKE_BUSY_SECONDS ?? "").trim();
+	const n = raw === "" ? defaultBusySeconds(preset(ctx)) : Number(raw);
+	if (!Number.isFinite(n) || n < 0) return defaultBusySeconds(preset(ctx)) * 1000;
+	return Math.floor(n) * 1000;
+}
+
+/** Due time of a pending wake: the busy deadline when the row is held, otherwise last send plus the debounce. */
+const WAKE_DUE_SQL = `CASE
+  WHEN json_extract(pending_json, '$.busy') = 1 AND busy_until_ms IS NOT NULL THEN busy_until_ms
+  ELSE last_sent_ms + ?
+END`;
+
+/** A catch-up past the in-request wait needs the hosted alarm or the self-host minute cron. */
+function busyScheduled(ctx: TenantContext, ectx: object): boolean {
+	return wakeWriteHooks.has(ectx) || ctx.ENABLE_CRON === "1";
+}
+
+function busyActive(ctx: TenantContext, ectx: object, row: Json | null, now: number): boolean {
+	if (!busyScheduled(ctx, ectx) || busyMs(ctx) <= 0) return false;
+	const until = Number(row?.busy_until_ms);
+	return Number.isFinite(until) && until > now;
+}
+
+/** Seconds `wake preview` reports. 0 when the cool-down is disabled or nothing will flush a catch-up. */
+function busySecondsReported(ctx: TenantContext, ectx: object): number {
+	return busyScheduled(ctx, ectx) ? busyMs(ctx) / 1000 : 0;
+}
+
 /**
  * Hourly wake cap. 0 means unlimited, including an explicit "0".
  * An empty or unset value uses the preset default (unlimited, or 25 for Claude Code).
@@ -208,13 +252,21 @@ async function noteWakeWrite(ectx: object): Promise<void> {
 }
 
 async function sendWake(ctx: TenantContext, ectx: ExecutionContext, payload: Json): Promise<{ status: number | null; info: string }> {
-	const ev: WakeEvent = { ...payload, publicUrl: ctx.PUBLIC_URL };
+	const catchUp = !!payload.busy;
+	const delivered = { ...payload };
+	delete delivered.busy;
+	const ev: WakeEvent = { ...delivered, publicUrl: ctx.PUBLIC_URL };
 	let req;
 	try { req = await renderWake(wakeConfig(ctx), ev); } catch (e) {
 		log("wake_render_failed", { preset: preset(ctx), error: String(e).slice(0, 200) });
+		await clearBusy(ctx, payload);
 		return { status: null, info: "render failed: " + String(e).slice(0, 200) };
 	}
-	if (!req) { log("wake_skipped", { contextId: ev.contextId, reason: "WAKE_WEBHOOK_URL unset" }); return { status: null, info: "WAKE_WEBHOOK_URL unset" }; }
+	if (!req) {
+		log("wake_skipped", { contextId: ev.contextId, reason: "WAKE_WEBHOOK_URL unset" });
+		await clearBusy(ctx, payload);
+		return { status: null, info: "WAKE_WEBHOOK_URL unset" };
+	}
 	try {
 		let r: Response;
 		if (ctx.gates.wakeTargetPolicy === "public-https") {
@@ -224,6 +276,7 @@ async function sendWake(ctx: TenantContext, ectx: ExecutionContext, payload: Jso
 			});
 			if ("refused" in checked) {
 				log("wake_refused", { preset: preset(ctx), contextId: ev.contextId, reason: checked.refused });
+				await clearBusy(ctx, payload);
 				return { status: null, info: `refused: ${checked.refused}` };
 			}
 			r = checked.response;
@@ -234,11 +287,17 @@ async function sendWake(ctx: TenantContext, ectx: ExecutionContext, payload: Jso
 		const hint = r.ok ? "" : cloudflareErrorHint(r.status, (await r.text().catch(() => "")).slice(0, 4096), {
 			tunnel: !!(ctx.WAKE_ACCESS_CLIENT_ID && ctx.WAKE_ACCESS_CLIENT_SECRET) || wakeUrlIsTunnelHost(req.url),
 		});
-		log("wake_sent", { preset: preset(ctx), contextId: ev.contextId, taskId: ev.taskId, status: r.status, ...(hint ? { hint } : {}) });
-		if (r.status === 429 || r.status === 503) await requeueWake(ctx, ectx, payload, r.headers.get("retry-after"));
+		log("wake_sent", { preset: preset(ctx), contextId: ev.contextId, taskId: ev.taskId, status: r.status, ...(catchUp ? { catchUp: true } : {}), ...(hint ? { hint } : {}) });
+		if (r.ok) await armBusy(ctx, ectx, delivered, Date.now());
+		else if (r.status === 429 || r.status === 503) {
+			// Retry-After owns the next POST. Drop the busy window so the retry is not held behind it.
+			await clearBusy(ctx, payload);
+			await requeueWake(ctx, ectx, payload, r.headers.get("retry-after"));
+		} else await clearBusy(ctx, payload);
 		return { status: r.status, info: `HTTP ${r.status}${hint ? ` (${hint})` : ""}` };
 	} catch (e) {
 		log("wake_failed", { preset: preset(ctx), contextId: ev.contextId, error: String(e).slice(0, 200) });
+		await clearBusy(ctx, payload);
 		return { status: null, info: String(e).slice(0, 200) };
 	}
 }
@@ -264,6 +323,52 @@ async function loadWake(ctx: TenantContext, contextId: string, peer: string): Pr
 	return ctx.DB.prepare("SELECT * FROM wakes WHERE context_id = ? AND peer = ''").bind(contextId).first();
 }
 
+/** The busy window starts at this send and does not move when later events are absorbed. */
+async function armBusy(ctx: TenantContext, ectx: object, payload: Json, now: number): Promise<void> {
+	const wait = busyMs(ctx);
+	if (wait <= 0 || !busyScheduled(ctx, ectx) || !messageWake(String(payload?.kind || "")) || !wakeHooked(ctx)) return;
+	const from = typeof payload.from === "string" ? payload.from : "";
+	const contextId = typeof payload.contextId === "string" ? payload.contextId : "";
+	const row = await loadWake(ctx, contextId, from);
+	if (!row) return;
+	const peer = typeof row.peer === "string" ? row.peer : "";
+	await ctx.DB.prepare("UPDATE wakes SET busy_until_ms = ? WHERE context_id = ? AND peer = ?")
+		.bind(now + wait, contextId, peer).run();
+}
+
+/** A send did not stick. Drop the busy window and leave any absorbed tasks as an ordinary pending wake.
+ *  The pending text is replaced only when it still matches the row just read, and a lost race retries. */
+async function clearBusy(ctx: TenantContext, payload: Json): Promise<void> {
+	if (!messageWake(String(payload?.kind || ""))) return;
+	const from = typeof payload.from === "string" ? payload.from : "";
+	const contextId = typeof payload.contextId === "string" ? payload.contextId : "";
+	for (let attempt = 0; attempt < 4; attempt++) {
+		const row = await loadWake(ctx, contextId, from);
+		if (!row) return;
+		const peer = typeof row.peer === "string" ? row.peer : "";
+		const original = typeof row.pending_json === "string" ? row.pending_json : null;
+		let next = original;
+		if (typeof next === "string") {
+			try {
+				const parsed = JSON.parse(next);
+				if (parsed && typeof parsed === "object" && parsed.busy) {
+					delete parsed.busy;
+					next = JSON.stringify(parsed);
+				}
+			} catch { /* keep the stored text */ }
+		}
+		if (row.busy_until_ms == null && next === original) return;
+		const args: unknown[] = [next, contextId, peer];
+		const pendingMatch = original == null ? "pending_json IS NULL" : "pending_json = ?";
+		if (original != null) args.push(original);
+		const res = await ctx.DB.prepare(
+			`UPDATE wakes SET busy_until_ms = NULL, pending_json = ? WHERE context_id = ? AND peer = ? AND ${pendingMatch}`,
+		).bind(...args).run();
+		if (changed(res) === 1) return;
+	}
+	log("wake_busy_clear_failed", { contextId });
+}
+
 async function requeueWake(ctx: TenantContext, ectx: ExecutionContext, payload: Json, retryAfter: string | null) {
 	if (payload.kind !== "inbound") return;
 	const attempts = (Number(payload.attempts) || 0) + 1;
@@ -275,14 +380,17 @@ async function requeueWake(ctx: TenantContext, ectx: ExecutionContext, payload:
 	const cur: Json = await loadWake(ctx, contextId, peer);
 	const prev = cur?.pending_json ? JSON.parse(cur.pending_json) : null;
 	const merged = { ...payload, attempts, taskIds: [...new Set([...(prev?.taskIds || []), ...(payload.taskIds || [])])] };
+	delete merged.busy;
 	// flushWake and nextCronAt wait until last_sent_ms + debounce. Store Retry-After minus that debounce so the
 	// deadline is Retry-After itself, including when the debounce is longer than Retry-After. Do not keep the
 	// previous last_sent_ms: that clock is the send we just made, and keeping it would wait out the debounce.
+	// A retry is not a busy wake: the cool-down stays clear until a 2xx.
 	const due = now + waitMs - debounceMs(ctx);
 	const rowPeer = cur && (cur.peer === peer || cur.peer === "" || cur.peer == null) ? (cur.peer ?? "") : peer;
 	await ctx.DB.prepare(`INSERT INTO wakes (context_id, peer, last_sent_ms, pending_json, pending_since_ms) VALUES (?, ?, ?, ?, ?)
 		ON CONFLICT(context_id, peer) DO UPDATE SET pending_json = excluded.pending_json, last_sent_ms = excluded.last_sent_ms,
-		pending_since_ms = COALESCE(wakes.pending_since_ms, excluded.pending_since_ms)`).bind(contextId, rowPeer === "" ? peer : rowPeer, due, JSON.stringify(merged), now).run();
+		pending_since_ms = COALESCE(wakes.pending_since_ms, excluded.pending_since_ms),
+		busy_until_ms = NULL`).bind(contextId, rowPeer === "" ? peer : rowPeer, due, JSON.stringify(merged), now).run();
 	log("wake_requeued", { contextId, retryInS: Math.round(waitMs / 1000), attempt: attempts });
 	// The row exists now. A hosted alarm has to be set from this turn: the request that started sendWake may already have returned.
 	await noteWakeWrite(ectx);
@@ -303,25 +411,42 @@ async function wake(ctx: TenantContext, ectx: ExecutionContext, contextId: strin
 		} else row = null;
 	}
 	const peer = row?.peer ?? from;
+	const suppress = wakeHooked(ctx) && messageWake(kind) && busyActive(ctx, ectx, row, now);
 	let claimed = false;
 	if (!row) {
 		const r = await ctx.DB.prepare("INSERT INTO wakes (context_id, peer, last_sent_ms) VALUES (?, ?, ?) ON CONFLICT DO NOTHING").bind(contextId, peer, now).run();
 		claimed = r.meta.changes === 1;
-	} else if (!row.pending_json && now - row.last_sent_ms >= deb) {
+	} else if (!suppress && !row.pending_json && now - row.last_sent_ms >= deb) {
 		const r = await ctx.DB.prepare("UPDATE wakes SET last_sent_ms = ? WHERE context_id = ? AND peer = ? AND last_sent_ms = ? AND pending_json IS NULL")
 			.bind(now, contextId, peer, row.last_sent_ms).run();
 		claimed = r.meta.changes === 1;
 	}
-	if (claimed && (await wakeBudgetOk(ctx))) { ectx.waitUntil(sendWake(ctx, ectx, payload)); return; }
-	// debounce window (or hourly cap reached): merge into the pending wake and flush it later
+	if (claimed && (await wakeBudgetOk(ctx))) {
+		// Cover the in-flight POST. sendWake refreshes the busy window on 2xx and clears it otherwise.
+		if (messageWake(kind) && wakeHooked(ctx)) await armBusy(ctx, ectx, payload, now);
+		ectx.waitUntil(sendWake(ctx, ectx, payload));
+		return;
+	}
+	// Debounce window, hourly cap, or a busy conversation: merge into the pending wake.
+	// Absorbing does not move busy_until_ms. The deadline stays the successful send plus the cool-down.
 	const cur: Json = await loadWake(ctx, contextId, from);
 	const curPeer = cur?.peer ?? peer;
 	const prev = cur?.pending_json ? JSON.parse(cur.pending_json) : null;
+	const sentAt = Number(cur?.last_sent_ms) || 0;
+	const hold = wakeHooked(ctx) && messageWake(kind) && busyActive(ctx, ectx, cur, now) && !prev?.attempts && now - sentAt >= deb;
+	const keeping = !!(prev?.busy && busyActive(ctx, ectx, cur, now) && !prev?.attempts);
 	payload.taskIds = [...new Set([...(prev?.taskIds || []), taskId])];
+	if (hold || keeping) payload.busy = 1;
 	await ctx.DB.prepare("UPDATE wakes SET pending_json = ?, pending_since_ms = COALESCE(pending_since_ms, ?) WHERE context_id = ? AND peer = ?")
 		.bind(JSON.stringify(payload), now, contextId, curPeer).run();
 	// The pending row exists now. A hosted alarm is set in this turn, including when the delay is too long for waitUntil.
 	await noteWakeWrite(ectx);
+	// A busy hold is taken only when an alarm or the minute cron will flush the catch-up.
+	// waitUntil cannot cover that window, so there is no in-request timer on this path.
+	if (payload.busy) {
+		log("wake_absorbed", { contextId, kind, tasks: payload.taskIds.length });
+		return;
+	}
 	const delay = Math.max(0, (cur?.last_sent_ms || now) + deb - now) + 100;
 	// waitUntil can outlive the response by ~30s. Longer windows are flushed by a later request, the optional
 	// single-inbox cron, or the registered alarm (set above).
@@ -332,7 +457,10 @@ async function flushWake(ctx: TenantContext, ectx: ExecutionContext, contextId:
 	const row: Json = await ctx.DB.prepare("SELECT * FROM wakes WHERE context_id = ? AND peer = ?").bind(contextId, peer).first();
 	if (!row || !row.pending_json) return;
 	const now = Date.now();
-	if (now - row.last_sent_ms < debounceMs(ctx)) return;
+	const payload = JSON.parse(row.pending_json);
+	// A busy wake waits for its cool-down. A burst still waits out the short debounce.
+	if (payload?.busy && Number(row.busy_until_ms) > now) return;
+	if (!payload?.busy && now - row.last_sent_ms < debounceMs(ctx)) return;
 	if (maxPerHour(ctx)) {
 		const hour = Math.floor(now / 3600000);
 		const b: Json = await ctx.DB.prepare("SELECT count FROM wake_budget WHERE hour = ?").bind(hour).first();
@@ -341,13 +469,16 @@ async function flushWake(ctx: TenantContext, ectx: ExecutionContext, contextId:
 	const r = await ctx.DB.prepare(
 		"UPDATE wakes SET pending_json = NULL, pending_since_ms = NULL, last_sent_ms = ? WHERE context_id = ? AND peer = ? AND last_sent_ms = ? AND pending_json IS NOT NULL",
 	).bind(now, contextId, peer, row.last_sent_ms).run();
-	if (r.meta.changes === 1 && (await wakeBudgetOk(ctx))) await sendWake(ctx, ectx, JSON.parse(row.pending_json));
+	if (r.meta.changes === 1 && (await wakeBudgetOk(ctx))) {
+		if (messageWake(String(payload?.kind || "")) && wakeHooked(ctx)) await armBusy(ctx, ectx, payload, now);
+		await sendWake(ctx, ectx, payload);
+	}
 }
 
-/** Flush every pending wake whose debounce window has passed (called opportunistically and from cron). */
+/** Flush every pending wake whose debounce or busy cool-down has passed (called opportunistically and from cron). */
 async function flushDue(ctx: TenantContext, ectx: ExecutionContext) {
-	const rows = await ctx.DB.prepare("SELECT context_id, peer FROM wakes WHERE pending_json IS NOT NULL AND last_sent_ms <= ? LIMIT 20")
-		.bind(Date.now() - debounceMs(ctx)).all();
+	const rows = await ctx.DB.prepare(`SELECT context_id, peer FROM wakes WHERE pending_json IS NOT NULL AND (${WAKE_DUE_SQL}) <= ? LIMIT 20`)
+		.bind(debounceMs(ctx), Date.now()).all();
 	for (const r of rows.results as Json[]) await flushWake(ctx, ectx, r.context_id, typeof r.peer === "string" ? r.peer : "");
 }
 
@@ -366,8 +497,9 @@ export async function cronFlush(ctx: TenantContext, ectx: ExecutionContext): Pro
 	]);
 }
 
-async function minMs(ctx: TenantContext, sql: string, shift: (t: number) => number): Promise<number | null> {
-	const row = await ctx.DB.prepare(sql).first<{ t: number | null }>();
+async function minMs(ctx: TenantContext, sql: string, shift: (t: number) => number, args: unknown[] = []): Promise<number | null> {
+	const q = ctx.DB.prepare(sql);
+	const row = await (args.length ? q.bind(...args) : q).first<{ t: number | null }>();
 	if (!row || row.t == null) return null;
 	const t = Number(row.t);
 	return Number.isFinite(t) ? shift(t) : null;
@@ -380,7 +512,7 @@ async function minMs(ctx: TenantContext, sql: string, shift: (t: number) => numb
 export async function nextCronAt(ctx: TenantContext, now = Date.now()): Promise<number | null> {
 	const times: number[] = [];
 	const deb = debounceMs(ctx);
-	const wake = await minMs(ctx, "SELECT MIN(last_sent_ms) AS t FROM wakes WHERE pending_json IS NOT NULL", (t) => t + deb);
+	const wake = await minMs(ctx, `SELECT MIN(${WAKE_DUE_SQL}) AS t FROM wakes WHERE pending_json IS NOT NULL`, (t) => t, [deb]);
 	if (wake != null) {
 		const cap = maxPerHour(ctx);
 		if (cap && wake <= now) {
@@ -1840,8 +1972,9 @@ async function ackOutboundReplies(ctx: TenantContext, snaps: ReplySnap[]): Promi
 	if (acked.length) await ackPendingWakes(ctx, acked, "outbound_update");
 }
 
-/** Drop these task ids from the inbound wake for that conversation. A wake for another conversation, or an
- *  outbound update that reuses the task id, stays pending. A wake that still names other tasks stays pending. */
+/** Drop these task ids from the pending wake for that conversation. A wake for another conversation, or an
+ *  outbound update that reuses the task id, stays pending. A wake that still names other tasks stays pending.
+ *  This does not end the busy cool-down: a task that arrives after this read still waits for one catch-up. */
 async function ackPendingWakes(ctx: TenantContext, seen: { taskId: string; contextId: string }[], kind = "inbound"): Promise<void> {
 	const byContext = new Map<string, Set<string>>();
 	for (const row of seen) {
@@ -1960,7 +2093,8 @@ async function handleOwner(req: Request, ctx: TenantContext, ectx: ExecutionCont
 				});
 			}
 		}
-		// Clear a pending wake only for tasks in this page. Ids the caller did not get stay pending,
+		// Clear a pending wake only for tasks in this page. The busy cool-down stays until it expires.
+		// Ids the caller did not get stay pending,
 		// including when one wake names tasks on this page and tasks on a later page.
 		// A reply is marked seen only when its stored update still equals the snapshot in this response.
 		// HEAD does not mark the inbox seen. The hosted owner RPC defers both clears until it has
@@ -2275,7 +2409,7 @@ async function handleOwner(req: Request, ctx: TenantContext, ectx: ExecutionCont
 		if (preset(ctx) === "openbot" && !ctx.WAKE_HMAC_SECRET?.trim())
 			return json({ error: "OpenBot requires WAKE_HMAC_SECRET from the routine settings" }, 400);
 		const req = await renderWake(wakeConfig(ctx), ev, { requestId: "preview" });
-		return json({ preset: preset(ctx), configured: !!req, debounceSeconds: debounceMs(ctx) / 1000, maxPerHour: maxPerHour(ctx),
+		return json({ preset: preset(ctx), configured: !!req, debounceSeconds: debounceMs(ctx) / 1000, busySeconds: busySecondsReported(ctx, ectx), maxPerHour: maxPerHour(ctx),
 			hasKey: !!ctx.WAKE_WEBHOOK_KEY, hasHmacSecret: !!ctx.WAKE_HMAC_SECRET,
 			hasAccessServiceToken: !!(ctx.WAKE_ACCESS_CLIENT_ID && ctx.WAKE_ACCESS_CLIENT_SECRET),
 			fingerprints: { url: await A.fingerprint(ctx.WAKE_WEBHOOK_URL), key: await A.fingerprint(ctx.WAKE_WEBHOOK_KEY),

package/worker/src/migrations.ts

@@ -15,6 +15,7 @@ import m0012 from "../migrations/0012_conversation_peer_owner.sql?raw";
 import m0013 from "../migrations/0013_reply_delivery.sql?raw";
 import m0014 from "../migrations/0014_peer_address.sql?raw";
 import m0015 from "../migrations/0015_outbound_source.sql?raw";
+import m0016 from "../migrations/0016_wake_busy.sql?raw";
 import type { Migration } from "./storage.ts";
 
 export const MIGRATIONS: Migration[] = [
@@ -33,4 +34,5 @@ export const MIGRATIONS: Migration[] = [
 	{ name: "0013_reply_delivery.sql", sql: m0013 },
 	{ name: "0014_peer_address.sql", sql: m0014 },
 	{ name: "0015_outbound_source.sql", sql: m0015 },
+	{ name: "0016_wake_busy.sql", sql: m0016 },
 ];

package/worker/src/tenancy.ts

@@ -35,7 +35,9 @@ export const CONFIG_KEYS = [
 	"PROVIDER_ORGANIZATION", "PROVIDER_URL", "DOCUMENTATION_URL",
 	"WAKE_WEBHOOK_URL", "WAKE_WEBHOOK_KEY", "WAKE_HMAC_SECRET", "WAKE_ACCESS_CLIENT_ID", "WAKE_ACCESS_CLIENT_SECRET",
 	"WAKE_PRESET", "WAKE_AGENT_ID", "WAKE_KEY_HEADER", "WAKE_KEY_PREFIX", "WAKE_BODY_TEMPLATE", "WAKE_CLI_COMMAND",
-	"WAKE_DEBOUNCE_SECONDS", "WAKE_MAX_PER_HOUR",
+	"WAKE_DEBOUNCE_SECONDS", "WAKE_BUSY_SECONDS", "WAKE_MAX_PER_HOUR",
+	/** "1" when this self-host deploy has the minute cron. Hosted flushes from the inbox alarm instead. */
+	"ENABLE_CRON",
 	"MAX_BODY", "RATE_PER_MIN",
 	"PAIRING_APPROVAL", "PBKDF2_ITERATIONS",
 	"UPSTREAM_URL", "UPSTREAM_CARD_URL", "UPSTREAM_TOKEN", "UPSTREAM_ACCESS_CLIENT_ID", "UPSTREAM_ACCESS_CLIENT_SECRET",
@@ -376,7 +378,9 @@ export class TenantContext implements ConfigFields {
 	readonly WAKE_BODY_TEMPLATE?: string;
 	readonly WAKE_CLI_COMMAND?: string;
 	readonly WAKE_DEBOUNCE_SECONDS?: string;
+	readonly WAKE_BUSY_SECONDS?: string;
 	readonly WAKE_MAX_PER_HOUR?: string;
+	readonly ENABLE_CRON?: string;
 	readonly MAX_BODY?: string;
 	readonly RATE_PER_MIN?: string;
 	readonly PAIRING_APPROVAL?: string;

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

package/worker/src/wake.ts

@@ -55,6 +55,15 @@ export function defaultDebounceSeconds(preset: string): number {
 	return preset === "claude-code" ? 20 : 10;
 }
 
+/**
+ * Default busy cool-down per preset (seconds), used when WAKE_BUSY_SECONDS is unset.
+ * These are starting points: a sent message wake holds further webhooks for this long, then one catch-up goes out.
+ * Claude Code is longer because each fire is a new session. An explicit 0 disables the cool-down.
+ */
+export function defaultBusySeconds(preset: string): number {
+	return preset === "claude-code" ? 300 : 180;
+}
+
 /**
  * Default hourly wake cap per preset. 0 means unlimited. Claude Code routines allow 30 fires/hour,
  * so that preset defaults to 25 only when WAKE_MAX_PER_HOUR is unset. An explicit 0 stays unlimited.

package/worker/test/migrations.test.ts

@@ -62,6 +62,7 @@ test("fresh database: every migration applies in order; a second run applies not
 	assert.ok(columns(db, "peers").includes("identity_key"));
 	assert.ok(columns(db, "peers").includes("card_url"));
 	assert.ok(columns(db, "peers").includes("token_enc"));
+	assert.ok(columns(db, "wakes").includes("busy_until_ms"));
 	assert.ok(columns(db, "device_requests").includes("identity_key"));
 	assert.ok(columns(db, "device_requests").includes("replaces_label"));
 	assert.ok(columns(db, "device_requests").includes("replaces_hash"));
@@ -71,15 +72,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", "0012_conversation_peer_owner.sql", "0013_reply_delivery.sql", "0014_peer_address.sql", "0015_outbound_source.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", "0013_reply_delivery.sql", "0014_peer_address.sql", "0015_outbound_source.sql", "0016_wake_busy.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", "0012_conversation_peer_owner.sql", "0013_reply_delivery.sql", "0014_peer_address.sql", "0015_outbound_source.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", "0013_reply_delivery.sql", "0014_peer_address.sql", "0015_outbound_source.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", "0013_reply_delivery.sql", "0014_peer_address.sql", "0015_outbound_source.sql", "0016_wake_busy.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", "0013_reply_delivery.sql", "0014_peer_address.sql", "0015_outbound_source.sql", "0016_wake_busy.sql"]);
 	assert.equal((db.prepare("SELECT count FROM wake_budget WHERE hour = 1").get() as any).count, 7);
 });
 
@@ -111,7 +112,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", "0012_conversation_peer_owner.sql", "0013_reply_delivery.sql", "0014_peer_address.sql", "0015_outbound_source.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", "0013_reply_delivery.sql", "0014_peer_address.sql", "0015_outbound_source.sql", "0016_wake_busy.sql"]);
 		assert.deepEqual(columns(db, "wake_budget"), ["hour", "count"]);
 		assert.deepEqual(applyMigrations(db), []);
 
@@ -174,6 +175,21 @@ test("0012 lets each peer own the same context id and keeps the first row", () =
 	assert.deepEqual(peers.map((r) => r.peer), ["ada", "bob"]);
 });
 
+test("0016 adds the wake busy column and keeps an existing wake", () => {
+	const prior = [...FILES].sort(byNumber).filter((f) => f !== "0016_wake_busy.sql");
+	const db = existingDb(prior.map(sql), prior);
+	const pending = JSON.stringify({ contextId: "ctx-y", from: "ada", taskId: "t1", taskIds: ["t1"], kind: "inbound", preview: "hi" });
+	db.prepare("INSERT INTO wakes (context_id, peer, last_sent_ms, pending_json, pending_since_ms) VALUES ('ctx-y', 'ada', 5, ?, 5)").run(pending);
+	assert.deepEqual(applyMigrations(db), ["0016_wake_busy.sql"]);
+	const row = db.prepare("SELECT pending_json, last_sent_ms, busy_until_ms FROM wakes WHERE context_id = 'ctx-y'").get() as {
+		pending_json: string; last_sent_ms: number; busy_until_ms: number | null;
+	};
+	assert.equal(row.pending_json, pending);
+	assert.equal(row.last_sent_ms, 5);
+	assert.equal(row.busy_until_ms, null);
+	assert.ok(columns(db, "wakes").includes("busy_until_ms"));
+});
+
 test("0014 adds address columns and keeps an existing peer token", () => {
 	const prior = [...FILES].sort(byNumber).filter((f) => f !== "0014_peer_address.sql");
 	const db = existingDb(prior.map(sql), prior);

package/worker/test/wake-latch.test.ts

@@ -0,0 +1,182 @@
+// A sent message wake stays busy. Later events wait for one catch-up. An inbox read does not end that window.
+// Run: npm test
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import worker, { nextCronAt } from "../src/index.ts";
+import { d1 } from "./d1.ts";
+import { resolveTenant } from "../src/tenancy.ts";
+
+const BASE = "https://agent.example.com";
+const realNow = Date.now;
+
+function envFor(over: Record<string, string> = {}) {
+	const env: Record<string, unknown> = {
+		DB: d1(new URL("../migrations/", import.meta.url)), PUBLIC_URL: BASE, OWNER_TOKEN: "owner-secret",
+		WAKE_PRESET: "generic", WAKE_WEBHOOK_URL: "https://hook.example.net/wake", WAKE_WEBHOOK_KEY: "k",
+		WAKE_DEBOUNCE_SECONDS: "10", WAKE_BUSY_SECONDS: "120", ENABLE_CRON: "1", ...over,
+	};
+	return env;
+}
+
+test("busy cool-down, debounce, preset defaults, and an explicit 0", async (t) => {
+	let offset = 0;
+	Date.now = () => realNow() + offset;
+	const events: string[] = [];
+	const origLog = console.log;
+	console.log = (...args: unknown[]) => { events.push(String(args[0])); origLog(...args); };
+	const sent: any[] = [];
+	const origFetch = globalThis.fetch;
+	globalThis.fetch = (async (_url: unknown, init: any) => {
+		if (init?.body) sent.push(JSON.parse(String(init.body)));
+		return new Response("ok", { status: 200 });
+	}) as typeof fetch;
+	t.after(() => { globalThis.fetch = origFetch; Date.now = realNow; console.log = origLog; });
+
+	const call = async (env: any, method: string, path: string, json?: unknown, auth = "Bearer owner-secret") => {
+		const pending: Promise<unknown>[] = [];
+		const res = await worker.fetch(new Request(BASE + path, {
+			method,
+			headers: { "content-type": "application/json", authorization: auth },
+			body: json === undefined ? undefined : JSON.stringify(json),
+		}) as any, env, { waitUntil: (p: Promise<unknown>) => pending.push(p), passThroughOnException() {} } as any);
+		await Promise.allSettled(pending);
+		const text = await res.text();
+		let data: any = text;
+		try { data = text ? JSON.parse(text) : null; } catch { /* plain */ }
+		return data;
+	};
+
+	// Inbox read does not end the busy window. The next task is one catch-up, then a later task wakes.
+	const busy = envFor();
+	const token = (await call(busy, "POST", "/owner/peers", { label: "ada" })).token as string;
+	const taskIdOf = (data: any) => data?.result?.id || data?.result?.task?.id;
+	const msg = async (env: any, peer: string, contextId: string, text: string) => {
+		const data = await call(env, "POST", "/", {
+			jsonrpc: "2.0", id: 1, method: "message/send",
+			params: { message: { kind: "message", role: "user", messageId: crypto.randomUUID(), contextId, parts: [{ kind: "text", text }] } },
+		}, `Bearer ${peer}`);
+		const id = taskIdOf(data);
+		assert.equal(typeof id, "string", JSON.stringify(data));
+		return id as string;
+	};
+	const bodies = (contextId: string) => sent.filter((b) => b.contextId === contextId && b.from === "ada");
+	const row = () => busy.DB.db.prepare(
+		"SELECT pending_json, busy_until_ms, last_sent_ms FROM wakes WHERE context_id = 'ctx-busy' AND peer = 'ada'",
+	).get() as { pending_json: string | null; busy_until_ms: number | null; last_sent_ms: number };
+
+	const first = await msg(busy, token, "ctx-busy", "one");
+	assert.deepEqual(bodies("ctx-busy").map((b) => b.taskIds), [[first]]);
+	const busyUntil = row().busy_until_ms as number;
+	assert.ok(Math.abs(busyUntil - (row().last_sent_ms + 120_000)) < 1000, "busy starts at the send");
+	const inbox = await call(busy, "GET", "/owner/inbox?context=ctx-busy&from=ada");
+	assert.deepEqual(inbox.map((r: { taskId: string }) => r.taskId), [first]);
+	assert.equal(row().pending_json, null);
+	assert.equal(row().busy_until_ms, busyUntil, "the inbox read leaves the busy deadline in place");
+
+	offset += 11_000;
+	const second = await msg(busy, token, "ctx-busy", "two");
+	assert.equal(bodies("ctx-busy").length, 1, "a task during the busy window does not send");
+	const held = JSON.parse(row().pending_json!);
+	assert.equal(held.busy, 1);
+	assert.equal(held.taskId, second);
+	assert.deepEqual(held.taskIds, [second]);
+	assert.equal(row().busy_until_ms, busyUntil, "an absorbed event does not move the deadline");
+
+	offset = (busyUntil as number) - realNow() - 1000;
+	await call(busy, "GET", "/health");
+	assert.equal(bodies("ctx-busy").length, 1, "the catch-up waits for the busy deadline");
+	offset = (busyUntil as number) - realNow() + 1000;
+	await call(busy, "GET", "/health");
+	const after = bodies("ctx-busy");
+	assert.equal(after.length, 2);
+	assert.equal(after[1].taskId, second);
+	assert.deepEqual(after[1].taskIds, [second]);
+	assert.equal("busy" in after[1], false);
+	assert.equal(row().pending_json, null);
+	const nextBusy = row().busy_until_ms as number;
+	assert.ok(nextBusy > (busyUntil as number), "the catch-up starts a new busy window");
+	offset = nextBusy - realNow() + 1000;
+	await call(busy, "GET", "/health");
+	assert.equal(bodies("ctx-busy").length, 2, "an empty busy window does not send");
+	const third = await msg(busy, token, "ctx-busy", "three");
+	const done = bodies("ctx-busy");
+	assert.equal(done.length, 3);
+	assert.equal(done[2].taskId, third);
+	assert.deepEqual(done[2].taskIds, [third]);
+
+	// A burst inside the short debounce flushes then, not at the busy deadline.
+	const burst = envFor({ WAKE_DEBOUNCE_SECONDS: "30", WAKE_BUSY_SECONDS: "300" });
+	const burstToken = (await call(burst, "POST", "/owner/peers", { label: "ada" })).token as string;
+	const before = sent.length;
+	await msg(burst, burstToken, "ctx-burst", "one");
+	await msg(burst, burstToken, "ctx-burst", "two");
+	assert.equal(sent.length, before + 1);
+	const burstPending = JSON.parse(burst.DB.db.prepare("SELECT pending_json FROM wakes WHERE context_id = 'ctx-burst'").get().pending_json);
+	assert.equal(burstPending.busy, undefined);
+	const due = await nextCronAt(resolveTenant(burst as never), Date.now());
+	assert.ok(due != null && due <= Date.now() + 31_000 && due > Date.now() + 20_000, `debounce due ${due}`);
+	offset += 31_000;
+	await call(burst, "GET", "/health");
+	assert.equal(sent.length, before + 2, "the burst flushes at the debounce");
+
+	// Explicit 0 disables the cool-down. Unset uses the preset default, shown on wake preview.
+	const off = envFor({ WAKE_PRESET: "claude-code", WAKE_BUSY_SECONDS: "0", WAKE_DEBOUNCE_SECONDS: "20" });
+	const offPreview = await call(off, "GET", "/owner/wake/preview");
+	assert.equal(offPreview.preset, "claude-code");
+	assert.equal(offPreview.debounceSeconds, 20);
+	assert.equal(offPreview.busySeconds, 0);
+	const grok = envFor({ WAKE_PRESET: "grok-bot", WAKE_DEBOUNCE_SECONDS: "" });
+	delete grok.WAKE_BUSY_SECONDS;
+	const grokPreview = await call(grok, "GET", "/owner/wake/preview");
+	assert.equal(grokPreview.debounceSeconds, 10);
+	assert.equal(grokPreview.busySeconds, 180);
+	const offToken = (await call(off, "POST", "/owner/peers", { label: "ada" })).token as string;
+	const offBefore = sent.length;
+	await msg(off, offToken, "ctx-off", "one");
+	offset += 21_000;
+	await msg(off, offToken, "ctx-off", "two");
+	assert.equal(sent.length, offBefore + 2, "busy 0 sends again once the debounce has passed");
+	const offRow = off.DB.db.prepare("SELECT busy_until_ms FROM wakes WHERE context_id = 'ctx-off'").get() as { busy_until_ms: number | null };
+	assert.equal(offRow.busy_until_ms, null);
+
+	// No minute cron and no hosted alarm: the cool-down stays off, so the next task sends after the debounce.
+	const bare = envFor({ WAKE_PRESET: "claude-code", WAKE_DEBOUNCE_SECONDS: "20" });
+	delete bare.ENABLE_CRON;
+	delete bare.WAKE_BUSY_SECONDS;
+	const barePreview = await call(bare, "GET", "/owner/wake/preview");
+	assert.equal(barePreview.debounceSeconds, 20);
+	assert.equal(barePreview.busySeconds, 0);
+	const bareToken = (await call(bare, "POST", "/owner/peers", { label: "ada" })).token as string;
+	const bareBefore = sent.length;
+	await msg(bare, bareToken, "ctx-bare", "one");
+	offset += 21_000;
+	await msg(bare, bareToken, "ctx-bare", "two");
+	assert.equal(sent.length, bareBefore + 2, "without a flush timer the second task sends");
+	const bareRow = bare.DB.db.prepare("SELECT busy_until_ms FROM wakes WHERE context_id = 'ctx-bare'").get() as { busy_until_ms: number | null };
+	assert.equal(bareRow.busy_until_ms, null);
+
+	const parsed = events.flatMap((line) => { try { return [JSON.parse(line)]; } catch { return []; } });
+	assert.equal(parsed.filter((e) => e.event === "wake_absorbed" && e.contextId === "ctx-busy").length, 1);
+	assert.equal(parsed.some((e) => e.event === "wake_sent" && e.catchUp === true && e.contextId === "ctx-busy"), true);
+	assert.equal(parsed.some((e) => e.event === "wake_absorbed" && e.preview !== undefined), false);
+});
+
+test("a busy pending wake is due at busy_until_ms, not the debounce", async () => {
+	const now = 1_700_000_000_000;
+	const DB = d1(new URL("../migrations/", import.meta.url));
+	const tenant = resolveTenant({
+		DB, PUBLIC_URL: BASE, OWNER_TOKEN: "owner-secret", WAKE_PRESET: "generic",
+		WAKE_DEBOUNCE_SECONDS: "10", WAKE_BUSY_SECONDS: "120", WAKE_MAX_PER_HOUR: "0",
+	} as never);
+	const until = now + 120_000;
+	const pending = JSON.stringify({ contextId: "ctx-lat", from: "ada", taskId: "t-2", taskIds: ["t-2"], kind: "inbound", busy: 1 });
+	await DB.prepare(
+		"INSERT INTO wakes (context_id, peer, last_sent_ms, pending_json, pending_since_ms, busy_until_ms) VALUES ('ctx-lat', 'ada', ?, ?, ?, ?)",
+	).bind(now - 60_000, pending, now - 60_000, until).run();
+	await DB.prepare(
+		"INSERT INTO wakes (context_id, peer, last_sent_ms, pending_json, pending_since_ms) VALUES ('ctx-soon', 'ada', ?, ?, ?)",
+	).bind(now - 5_000, "{}", now).run();
+	assert.equal(await nextCronAt(tenant, now), now - 5_000 + 10_000);
+	await DB.prepare("DELETE FROM wakes WHERE context_id = 'ctx-soon'").run();
+	assert.equal(await nextCronAt(tenant, now), until);
+});

package/worker/test/wake.test.ts

@@ -2,13 +2,24 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 import { createHmac } from "node:crypto";
-import { renderWake, renderTemplate, wakeSummary, redact, addAccessHeaders, cloudflareErrorHint, PRESETS, wakePayload, type WakeEvent } from "../src/wake.ts";
+import { renderWake, renderTemplate, wakeSummary, redact, addAccessHeaders, cloudflareErrorHint, PRESETS, defaultBusySeconds, defaultDebounceSeconds, wakePayload, type WakeEvent } from "../src/wake.ts";
 
 const ev: WakeEvent = {
 	contextId: "ctx-1", taskId: "t-2", taskIds: ["t-1", "t-2"], from: "peer-a",
 	preview: 'Please "do" X\nnow', kind: "inbound", publicUrl: "https://agent.example.com",
 };
 
+test("busy and debounce defaults differ by preset", () => {
+	assert.equal(defaultDebounceSeconds("claude-code"), 20);
+	assert.equal(defaultDebounceSeconds("grok-bot"), 10);
+	assert.equal(defaultBusySeconds("claude-code"), 300);
+	for (const preset of PRESETS) {
+		if (preset === "claude-code") continue;
+		assert.equal(defaultBusySeconds(preset), 180, preset);
+		assert.equal(defaultDebounceSeconds(preset), 10, preset);
+	}
+});
+
 test("unconfigured wake is a no-op", async () => {
 	assert.equal(await renderWake({ preset: "grok-bot" }, ev), null);
 });