@dispatch-foo/protocol 0.0.0 → 0.2.0

package/dist/version-Ds8ZFZLh.js

@@ -0,0 +1,2490 @@
+import { c as MAX_ADDRESS_BYTES, d as SYSTEM_ADDRESS, f as gateTypeOf, h as raiserOf, l as MAX_SEGMENT_BYTES, m as isDecidingAuthor, n as BUILT_IN_KINDS, o as GATE_TYPES, p as hasGateData, r as DELIVERY_STATES, s as MARKERS, u as REF_TYPES } from "./constants-CRXF4f7g.js";
+import { ActorRefError, TASK_ID_PATTERN, dbVersion, openSqliteDb, parseActorRef, queryAll, queryOne } from "@dispatch-foo/core";
+
+//#region src/errors.ts
+var MessagingError = class extends Error {
+	constructor(code, message, field) {
+		super(message);
+		this.code = code;
+		this.field = field;
+		this.name = "MessagingError";
+	}
+};
+
+//#endregion
+//#region src/address.ts
+/** An outbound A2A peer's alias: the handle grammar, at most 40 characters. */
+const PEER_ALIAS_PATTERN = /^[a-z0-9][a-z0-9._-]{0,39}$/;
+const RUN_ID = /^r-[0-9a-f]{6,12}$/;
+const CHANNEL_NAME = /^[a-z0-9][a-z0-9._-]*(\/[a-z0-9][a-z0-9._-]*)*$/;
+const utf8Length = (s) => new TextEncoder().encode(s).byteLength;
+function parseAddress(raw, field = "to") {
+	if (typeof raw !== "string") throw new MessagingError("invalid", "expected an address string", field);
+	const bad = (why) => {
+		throw new MessagingError("invalid", `invalid address ${JSON.stringify(raw.slice(0, 80))}: ${why}`, field);
+	};
+	if (utf8Length(raw) > MAX_ADDRESS_BYTES) return bad(`at most ${MAX_ADDRESS_BYTES} bytes`);
+	const segment = (value, what) => {
+		if (utf8Length(value) > MAX_SEGMENT_BYTES) bad(`${what} is over ${MAX_SEGMENT_BYTES} bytes`);
+	};
+	const colon = raw.indexOf(":");
+	if (colon <= 0) return bad("expected <kind>:<id>");
+	const scheme = raw.slice(0, colon);
+	const rest = raw.slice(colon + 1);
+	switch (scheme) {
+		case "human":
+		case "agent": {
+			let ref;
+			try {
+				ref = parseActorRef(raw);
+			} catch (err) {
+				if (err instanceof ActorRefError) return bad(err.message);
+				throw err;
+			}
+			if (ref === null || ref.handle === null) return bad("actor needs a handle");
+			segment(ref.handle, "handle");
+			if (ref.operator !== null) segment(ref.operator, "operator");
+			return ref.kind === "human" ? {
+				kind: "human",
+				handle: ref.handle,
+				address: raw
+			} : {
+				kind: "agent",
+				handle: ref.handle,
+				operator: ref.operator,
+				address: raw
+			};
+		}
+		case "task":
+			segment(rest, "id");
+			return TASK_ID_PATTERN.test(rest) ? {
+				kind: "task",
+				id: rest,
+				address: raw
+			} : bad("not a task id");
+		case "run":
+			segment(rest, "id");
+			return RUN_ID.test(rest) ? {
+				kind: "run",
+				id: rest,
+				address: raw
+			} : bad("not a run id");
+		case "channel":
+			for (const part of rest.split("/")) segment(part, "channel segment");
+			return CHANNEL_NAME.test(rest) ? {
+				kind: "channel",
+				name: rest,
+				address: raw
+			} : bad("not a channel name");
+		case "a2a":
+			segment(rest, "alias");
+			return PEER_ALIAS_PATTERN.test(rest) ? {
+				kind: "a2a",
+				alias: rest,
+				address: raw
+			} : bad("not an A2A peer alias (a-z, 0-9, \".\", \"_\", \"-\"; at most 40)");
+		default: return bad(`unknown kind ${JSON.stringify(scheme)}`);
+	}
+}
+/** An outbound A2A peer (`a2a:<alias>`); every message it sends is recorded by the daemon. */
+function isPeerAddress(address) {
+	return address.startsWith("a2a:");
+}
+/** True for senders the ping-pong breaker counts: runs, agents and A2A peers, not the system. */
+function isAgentAuthored(address) {
+	if (address === SYSTEM_ADDRESS) return false;
+	return address.startsWith("run:") || address.startsWith("agent:") || isPeerAddress(address);
+}
+
+//#endregion
+//#region src/lines.ts
+const LINE_BREAK = /\r\n|[\n\v\f\r\u0085\u2028\u2029]/;
+
+//#endregion
+//#region src/envelope.ts
+const MEMORY_GATE_KINDS = [
+	"preference",
+	"convention",
+	"constraint",
+	"hazard",
+	"decision",
+	"fact",
+	"reference"
+];
+const MEMORY_GATE_ACTIONS = [
+	"add",
+	"supersede",
+	"retire"
+];
+const PROPOSAL_ID = /^mp-[0-9A-HJKMNP-TV-Z]{26}$/;
+const PACKAGE_GATE_TYPES = new Set(GATE_TYPES);
+const X_KIND = /^x-[a-z0-9][a-z0-9-]*$/;
+const IDENTIFIER = /^[a-z0-9][a-z0-9._-]*$/;
+const ASKING_KINDS = new Set(["question", "handoff"]);
+const MAX_BODY_BYTES = 64 * 1024;
+const MAX_DATA_BYTES = 64 * 1024;
+const MAX_RECIPIENTS = 50;
+const MAX_REFS = 50;
+const MAX_CHOICES = 20;
+const MAX_REF_BYTES = 512;
+const MAX_LABEL_BYTES = 200;
+/** The gate payload a message carries, or null when `data` is not a gate. */
+function gateOf(message) {
+	const data = message.data;
+	if (data === null || typeof data !== "object" || Array.isArray(data)) return null;
+	const type = data["type"];
+	return typeof type === "string" && GATE_TYPES.includes(type) ? data : null;
+}
+function isSystemMarker(message, type) {
+	const data = message.data;
+	return message.from === SYSTEM_ADDRESS && message.origin === void 0 && typeof data === "object" && data !== null && !Array.isArray(data) && data["type"] === type;
+}
+function invalid(field, why) {
+	throw new MessagingError("invalid", `${field}: ${why}`, field);
+}
+/** §1.4's identifier: lowercase, no line breaks, at most one segment's bytes. */
+function isIdentifier(value) {
+	return typeof value === "string" && IDENTIFIER.test(value) && value.length <= MAX_SEGMENT_BYTES;
+}
+function overBytes(text, max) {
+	if (text.length > max) return true;
+	if (text.length * 3 <= max) return false;
+	return new TextEncoder().encode(text).byteLength > max;
+}
+function singleLine(value, field, maxBytes) {
+	if (typeof value !== "string") return;
+	if (LINE_BREAK.test(value)) invalid(field, "must not contain line breaks");
+	if (overBytes(value, maxBytes)) invalid(field, `at most ${maxBytes} bytes (UTF-8)`);
+}
+function checkIdempotencyKey(key) {
+	if (key === "") invalid("idempotencyKey", "must not be empty");
+	singleLine(key, "idempotencyKey", MAX_LABEL_BYTES);
+}
+function validateGate(input, sender, canDecide, known) {
+	const type = input.data.type;
+	if (!ASKING_KINDS.has(input.kind)) invalid("data.type", "gate data travels only on questions and handoffs; private payloads use an x- type");
+	if (!known.has(type)) invalid("data.type", `unregistered or unimplemented gate type ${type}; private payloads use an x- type`);
+	if (type === "memory") validateMemoryShape(input);
+	if (type === "doc") validateDocShape(input);
+	const raiser = raiserOf(type);
+	if (raiser === "session" && !sender.startsWith("run:")) throw new MessagingError("forbidden", `only runs may request ${type}`, "data");
+	if (raiser === "system" && sender !== SYSTEM_ADDRESS) throw new MessagingError("forbidden", `only Dispatch may raise ${type} gates`, "data");
+	if (raiser === "system-or-decider" && sender !== SYSTEM_ADDRESS && !(canDecide && sender.startsWith("human:"))) throw new MessagingError("forbidden", `only Dispatch may raise ${type} gates, or a deciding human`, "data");
+	if (type === "scope") validateScopeShape(input);
+}
+function validateScopeShape(input) {
+	const gate = input.data;
+	if (!Array.isArray(gate.paths) || gate.paths.length === 0 || !gate.paths.every((p) => typeof p === "string" && p !== "")) invalid("data.paths", "expected a non-empty list of paths");
+	if (typeof gate.reason !== "string" || gate.reason.trim() === "") invalid("data.reason", "required");
+	if (input.kind !== "question" || input.blocking !== true || JSON.stringify(input.choices) !== "[\"grant\",\"deny\"]") invalid("data", "a scope request is { kind: \"question\", blocking: true, choices: [\"grant\", \"deny\"], data: { type: \"scope\", paths, reason } }");
+}
+function validateMemoryShape(input) {
+	const gate = input.data;
+	if (typeof gate.proposalId !== "string" || !PROPOSAL_ID.test(gate.proposalId)) invalid("data.proposalId", "expected a proposal id like mp-01K…");
+	if (!MEMORY_GATE_ACTIONS.includes(gate.action)) invalid("data.action", `expected ${MEMORY_GATE_ACTIONS.join("|")}`);
+	if (gate.scope !== "project" && gate.scope !== "team") invalid("data.scope", "expected project|team");
+	if (!MEMORY_GATE_KINDS.includes(gate.kind)) invalid("data.kind", `expected ${MEMORY_GATE_KINDS.join("|")}`);
+	if (input.kind !== "question" || input.blocking !== true || JSON.stringify(input.choices) !== "[\"approve\",\"reject\"]") invalid("data", "a memory gate is { kind: \"question\", blocking: true, choices: [\"approve\", \"reject\"], data: { type: \"memory\", proposalId, action, scope, kind } }");
+}
+function validateDocShape(input) {
+	const gate = input.data;
+	if (typeof gate.doc !== "string" || !gate.doc.startsWith("doc-")) invalid("data.doc", "expected a doc- id");
+	if (typeof gate.proposal !== "string" || !gate.proposal.startsWith("rev-")) invalid("data.proposal", "expected a rev- id");
+	if (input.kind !== "question" || input.blocking !== true || JSON.stringify(input.choices) !== "[\"approve\",\"reject\"]") invalid("data", "a doc gate is { kind: \"question\", blocking: true, choices: [\"approve\", \"reject\"], data: { type: \"doc\", doc, proposal } }");
+}
+function validateSendInput(input, sender, canDecide, replyTarget, options = {}) {
+	const known = options.gateTypes ?? PACKAGE_GATE_TYPES;
+	if (typeof input !== "object" || input === null || Array.isArray(input)) invalid("input", "expected an object");
+	if (input.refs !== void 0 && !Array.isArray(input.refs)) invalid("refs", "expected a list");
+	if (input.choices !== void 0 && (!Array.isArray(input.choices) || input.choices.some((c) => typeof c !== "string"))) invalid("choices", "expected a list of strings");
+	if (input.replyTo !== void 0 && input.replyTo !== null && typeof input.replyTo !== "string") invalid("replyTo", "expected a message id or null");
+	if (!Array.isArray(input.to) || input.to.length === 0) invalid("to", "at least one recipient");
+	if (input.to.length > MAX_RECIPIENTS) invalid("to", `at most ${MAX_RECIPIENTS} recipients`);
+	input.to.forEach((addr, i) => parseAddress(addr, `to[${i}]`));
+	const kind = input.kind;
+	if (typeof kind !== "string") invalid("kind", "expected a string");
+	if (!BUILT_IN_KINDS.includes(kind) && !X_KIND.test(kind)) invalid("kind", `unknown kind ${JSON.stringify(kind)}`);
+	const hasChoice = typeof input.choice === "string";
+	if (typeof input.body !== "string" || input.body.trim() === "" && !(kind === "answer" && hasChoice)) invalid("body", "required");
+	if (overBytes(input.body, MAX_BODY_BYTES)) invalid("body", `at most ${MAX_BODY_BYTES} bytes (UTF-8)`);
+	if (input.data !== void 0 && overBytes(JSON.stringify(input.data), MAX_DATA_BYTES)) invalid("data", `at most ${MAX_DATA_BYTES} bytes as JSON`);
+	singleLine(input.session, "session", MAX_LABEL_BYTES);
+	if (input.idempotencyKey !== void 0) checkIdempotencyKey(input.idempotencyKey);
+	const refs = input.refs ?? [];
+	if (refs.length > MAX_REFS) invalid("refs", `at most ${MAX_REFS} refs`);
+	refs.forEach((ref, i) => {
+		if (typeof ref !== "object" || ref === null) invalid(`refs[${i}]`, "expected { type, id }");
+		const registered = REF_TYPES.includes(ref.type);
+		const receivedOk = options.origin === "received" && isIdentifier(ref.type);
+		if (!registered && !receivedOk) invalid(`refs[${i}].type`, "unknown ref type");
+		if (typeof ref.id !== "string" || ref.id === "") invalid(`refs[${i}].id`, "required");
+		singleLine(ref.id, `refs[${i}].id`, MAX_REF_BYTES);
+		singleLine(ref.at, `refs[${i}].at`, MAX_REF_BYTES);
+	});
+	const asking = ASKING_KINDS.has(kind);
+	if (input.blocking === true && !asking) invalid("blocking", "only questions and handoffs block");
+	if (input.choices !== void 0) {
+		if (!asking) invalid("choices", "only questions and handoffs carry choices");
+		const choices = input.choices;
+		if (choices.length > MAX_CHOICES) invalid("choices", `at most ${MAX_CHOICES} choices`);
+		choices.forEach((c, i) => singleLine(c, `choices[${i}]`, MAX_LABEL_BYTES));
+		if (choices.length === 0 || new Set(choices).size !== choices.length || choices.some((c) => c.trim() === "")) invalid("choices", "expected distinct, non-empty choices");
+	}
+	if (hasChoice && kind !== "answer") invalid("choice", "only answers carry a choice");
+	singleLine(input.choice, "choice", MAX_LABEL_BYTES);
+	const replyTo = input.replyTo ?? null;
+	if (kind === "answer" && replyTo === null) invalid("replyTo", "an answer needs the question id");
+	if (replyTo !== null) {
+		if (replyTarget === null) {
+			if (options.parentOptional !== true) throw new MessagingError("not-found", `no message ${replyTo}`, "replyTo");
+		} else if (kind === "answer") {
+			if (!ASKING_KINDS.has(replyTarget.kind)) invalid("replyTo", "only questions and handoffs take answers");
+			const isGate = gateTypeOf(replyTarget, known) !== null;
+			if (isGate && !canDecide) throw new MessagingError("forbidden", "answering this gate needs the decide tier", "replyTo");
+			const choices = replyTarget.choices ?? [];
+			if ((isGate || replyTarget.kind === "handoff") && choices.length > 0 && !hasChoice) invalid("choice", `choose one of ${choices.join(", ")}`);
+			if (hasChoice && !choices.includes(input.choice)) invalid("choice", `choose one of ${choices.join(", ")}`);
+		}
+	}
+	if (hasGateData(input)) validateGate(input, sender, canDecide, known);
+}
+
+//#endregion
+//#region src/localOnly.ts
+/** Markers that never leave the machine: the registry's plus the policy engine's. */
+const LOCAL_ONLY_MARKERS = [...new Set([
+	...MARKERS,
+	"x-policy",
+	"x-expired"
+])];
+const OVERSEER = /^agent:[^/]+\/overseer$/;
+const A2A_AGENT = /^agent:[^/]+\/a2a\./;
+/** Overseer and A2A identities: never federated, never in channel or agent ops. */
+function isFederationLocalAddress(address) {
+	return address.startsWith("a2a:") || OVERSEER.test(address) || A2A_AGENT.test(address);
+}
+function dataType(message) {
+	const data = message.data;
+	if (data === null || data === void 0 || typeof data !== "object" || Array.isArray(data)) return null;
+	const type = data.type;
+	return typeof type === "string" ? type : null;
+}
+function localOnlyReason(message, replyTarget, root) {
+	if (hasGateData(message) || replyTarget !== null && hasGateData(replyTarget)) return "gate";
+	const type = dataType(message);
+	if (type !== null && LOCAL_ONLY_MARKERS.includes(type)) return "marker";
+	if ([message.from, ...message.to].some(isFederationLocalAddress)) return "participant";
+	if (root !== null && root.id !== message.id && localOnlyReason(root, null, null) !== null) return "root";
+	return null;
+}
+
+//#endregion
+//#region src/render.ts
+const DIGEST_WIDTH = 80;
+function refText(m) {
+	if (m.refs.length === 0) return null;
+	return `refs: ${m.refs.map((r) => `${r.type}:${r.id}${r.at ? `@${r.at}` : ""}`).join(", ")}`;
+}
+function senderLabel(m, external, remote) {
+	if (remote !== void 0) return `${m.from} (remote: ${remote})`;
+	return external ? `${m.from} (external)` : m.from;
+}
+function renderForAgent(m, external = false, remote) {
+	const quote = (line) => `│ ${line}`;
+	const tags = [
+		m.kind,
+		...m.urgent ? ["urgent"] : [],
+		m.id
+	].join(" · ");
+	const lines = [`[message from ${senderLabel(m, external, remote)} · ${tags}]`, ...m.body.split(LINE_BREAK).map(quote)];
+	if (m.replyTo !== null) lines.push(`(in reply to ${m.replyTo})`);
+	const carried = [];
+	if (m.choices !== void 0) carried.push(`choices: ${m.choices.join(" | ")}`);
+	if (m.choice !== void 0) carried.push(`choice: ${m.choice}`);
+	const refs = refText(m);
+	if (refs !== null) carried.push(refs);
+	const quoteCarried = external || remote !== void 0;
+	lines.push(...quoteCarried ? carried.map(quote) : carried);
+	if (m.blocking) lines.push(`The sender is waiting. Answer with msg_reply(messageId: "${m.id}").`);
+	return lines.join("\n");
+}
+function firstLine(body) {
+	const first = body.split(LINE_BREAK, 1)[0] ?? "";
+	const chars = Array.from(first);
+	return chars.length > DIGEST_WIDTH ? `${chars.slice(0, DIGEST_WIDTH - 1).join("")}…` : first;
+}
+function renderDigestLine(m, external = false, remote) {
+	const channel = m.to.find((a) => a.startsWith("channel:"));
+	return `📬${channel === void 0 ? "" : ` #${channel.slice(8)} ·`} ${m.kind} from ${senderLabel(m, external, remote)}: ${firstLine(m.body)} (${m.id})`;
+}
+
+//#endregion
+//#region src/ulid.ts
+const ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+const MAX_TIME = 2 ** 48 - 1;
+function defaultRandom(n) {
+	return crypto.getRandomValues(new Uint8Array(n));
+}
+function encodeTime(ms) {
+	let out = "";
+	let t = ms;
+	for (let i = 0; i < 10; i++) {
+		out = ALPHABET[t % 32] + out;
+		t = Math.floor(t / 32);
+	}
+	return out;
+}
+function increment(digits) {
+	for (let i = digits.length - 1; i >= 0; i--) {
+		if (digits[i] < 31) {
+			digits[i] += 1;
+			return;
+		}
+		digits[i] = 0;
+	}
+	throw new Error("ulid random component overflowed within one millisecond");
+}
+function createUlidFactory(randomBytes = defaultRandom) {
+	let lastTime = -1;
+	let lastRandom = [];
+	return (nowMs) => {
+		if (!Number.isInteger(nowMs) || nowMs < 0 || nowMs > MAX_TIME) throw new RangeError(`ulid time out of range: ${nowMs}`);
+		if (nowMs <= lastTime) increment(lastRandom);
+		else {
+			lastTime = nowMs;
+			lastRandom = Array.from(randomBytes(16), (b) => b % 32);
+		}
+		return encodeTime(lastTime) + lastRandom.map((d) => ALPHABET[d]).join("");
+	};
+}
+
+//#endregion
+//#region src/engine.ts
+const DEFAULT_LIMITS = {
+	urgentPerHour: 10,
+	agentTurnsPerThreadPerHour: 20,
+	agentThreadsPerHour: Number.POSITIVE_INFINITY,
+	openWakeGatesPerTarget: Number.POSITIVE_INFINITY
+};
+const HOUR_MS = 3600 * 1e3;
+/** Superseded-answer notices one question sends at most (FW-R33). */
+const MAX_SUPERSEDED_NOTICES = 5;
+const SYSTEM_SENDER = {
+	address: SYSTEM_ADDRESS,
+	canDecide: true
+};
+const LOCAL = { kind: "local" };
+const LOCAL_ONLY_TEXT = {
+	gate: "gates never leave the machine whose runs they guard",
+	marker: "system markers never travel between machines",
+	participant: "overseer and A2A conversations stay on their machine",
+	root: "this thread stays on the machine it started on"
+};
+const REMOTE_RANK = {
+	refused: -1,
+	forwarded: 0,
+	held: 1,
+	pushed: 2,
+	notified: 2,
+	read: 3,
+	answered: 4
+};
+const LOCAL_RANK = {
+	held: 0,
+	sending: 1,
+	pushed: 2,
+	notified: 2,
+	read: 3,
+	answered: 4
+};
+var DeliveryEngine = class {
+	store;
+	host;
+	limits;
+	ulid;
+	gateTypes;
+	listeners = /* @__PURE__ */ new Set();
+	constructor(opts) {
+		this.store = opts.store;
+		this.host = opts.host;
+		this.limits = {
+			...DEFAULT_LIMITS,
+			...opts.limits
+		};
+		this.ulid = opts.newUlid ?? createUlidFactory();
+		this.gateTypes = new Set(opts.gateTypes ?? ["wake"]);
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	/** How many listeners are subscribed right now, so a test can check that a
+	*  subscriber's cleanup unsubscribed it. */
+	get listenerCount() {
+		return this.listeners.size;
+	}
+	emit(e) {
+		for (const l of this.listeners) try {
+			l(e);
+		} catch (err) {
+			console.error("messaging listener failed", err);
+		}
+	}
+	id(prefix) {
+		return `${prefix}-${this.ulid(this.host.now().getTime()).toLowerCase()}`;
+	}
+	nowIso() {
+		return this.host.now().toISOString();
+	}
+	hourAgoIso() {
+		return new Date(this.host.now().getTime() - HOUR_MS).toISOString();
+	}
+	authorize(sender) {
+		if (sender.canDecide && sender.address !== SYSTEM_ADDRESS && !sender.address.startsWith("human:")) throw new MessagingError("forbidden", `${sender.address} cannot decide; only humans and the system do`, "from");
+		if (parseAddress(sender.address, "from").kind !== "agent" || sender.address === SYSTEM_ADDRESS) return { muted: false };
+		const agent = this.store.getAgent(sender.address);
+		if (agent === null || agent.status !== "approved") throw new MessagingError("forbidden", `${sender.address} is not an approved agent`, "from");
+		return { muted: agent.muted };
+	}
+	resolveTargets(to, sender, fields) {
+		const senderTask = sender.startsWith("run:") ? this.host.taskOfRun(sender.slice(4)) : null;
+		const isSelf = (addr) => addr === sender || senderTask !== null && addr === `task:${senderTask}`;
+		const byRecipient = /* @__PURE__ */ new Map();
+		const add = (recipient, via) => {
+			if (isSelf(recipient) || recipient === SYSTEM_ADDRESS) return;
+			const existing = byRecipient.get(recipient);
+			if (existing === void 0 || existing.via === "channel" && via === "direct") byRecipient.set(recipient, {
+				recipient,
+				via
+			});
+		};
+		for (const addr of to) {
+			const field = fields.get(addr) ?? "to";
+			const parsed = parseAddress(addr, field);
+			if (parsed.kind !== "channel") {
+				add(addr, "direct");
+				continue;
+			}
+			const explicit = this.store.members(parsed.name);
+			const implicit = this.host.implicitMembers(parsed.name);
+			if (!this.store.channels().some((c) => c.name === parsed.name) && implicit.length === 0) throw new MessagingError("not-found", `no channel ${parsed.name}`, field);
+			for (const member of [...explicit, ...implicit]) if (!member.startsWith("channel:")) add(member, "channel");
+		}
+		return [...byRecipient.values()];
+	}
+	plan(target, muted, field, heldIfEnded) {
+		const base = {
+			id: this.id("d"),
+			messageId: "",
+			recipient: target.recipient,
+			via: target.via,
+			updatedAt: this.nowIso()
+		};
+		if (muted) return {
+			...base,
+			runId: null,
+			state: "read"
+		};
+		const parsed = parseAddress(target.recipient, field);
+		switch (parsed.kind) {
+			case "human": return {
+				...base,
+				runId: null,
+				state: "notified"
+			};
+			case "agent":
+			case "channel":
+			case "a2a": return {
+				...base,
+				runId: null,
+				state: "held"
+			};
+			case "task": {
+				const run = this.host.liveRunFor(parsed.id);
+				return run === null ? {
+					...base,
+					runId: null,
+					state: "held"
+				} : {
+					...base,
+					runId: run,
+					state: "sending"
+				};
+			}
+			case "run":
+				if (!this.host.isLiveRun(parsed.id)) {
+					if (target.via === "channel") return null;
+					if (heldIfEnded) return {
+						...base,
+						runId: null,
+						state: "held"
+					};
+					throw new MessagingError("invalid", `run ${parsed.id} is not live`, field);
+				}
+				return {
+					...base,
+					runId: parsed.id,
+					state: "sending"
+				};
+		}
+	}
+	async send(input, sender, options = {}) {
+		const { muted } = this.authorize(sender);
+		const key = input.idempotencyKey;
+		if (key !== void 0) {
+			checkIdempotencyKey(key);
+			const prior = this.replay(sender.address, key);
+			if (prior !== null) return prior;
+		}
+		const replyTo = input.replyTo ?? null;
+		const replyTarget = replyTo === null ? null : this.store.getMessage(replyTo);
+		if (replyTo !== null && (replyTarget === null || !this.participates(replyTarget, sender))) throw new MessagingError("not-found", `no message ${replyTo}`, "replyTo");
+		validateSendInput(input, sender.address, sender.canDecide, replyTarget, {
+			gateTypes: this.gateTypes,
+			origin: options.origin ?? "local"
+		});
+		await this.checkBreaker(replyTarget, sender);
+		this.checkNewThreads(input, replyTarget, sender);
+		const raced = key === void 0 ? null : this.replay(sender.address, key);
+		if (raced !== null) return raced;
+		if (input.kind === "answer" && replyTarget !== null && this.store.answersTo(replyTarget.id).length > 0) throw alreadyAnswered(replyTarget.id);
+		let urgent = input.urgent === true;
+		let downgraded = false;
+		if (urgent && !sender.address.startsWith("human:") && sender.address !== SYSTEM_ADDRESS) {
+			const since = this.hourAgoIso();
+			if ((this.host.quotaGroup?.(sender.address) ?? [sender.address]).reduce((n, address) => n + this.store.countFrom(address, since, true), 0) >= this.limits.urgentPerHour) {
+				urgent = false;
+				downgraded = true;
+			}
+		}
+		const id = this.id("m");
+		const message = {
+			id,
+			thread: replyTarget?.thread ?? id,
+			replyTo: input.replyTo ?? null,
+			from: sender.address,
+			to: this.replyRecipients(input.to, replyTarget),
+			kind: input.kind,
+			body: input.body,
+			refs: input.refs ?? [],
+			urgent,
+			blocking: input.blocking === true,
+			wake: input.wake ?? "none",
+			createdAt: this.nowIso()
+		};
+		if (input.session !== void 0) message.session = input.session;
+		if (input.data !== void 0) message.data = input.data;
+		if (input.choices !== void 0) message.choices = input.choices;
+		else if (input.kind === "handoff") message.choices = ["accept", "decline"];
+		if (input.choice !== void 0) message.choice = input.choice;
+		const fields = this.recipientFields(input.to, replyTarget);
+		const { targets: placedTargets, placed } = this.place(this.resolveTargets(message.to, sender.address, fields), fields, replyTarget, message);
+		const targets = this.admitExternal(placedTargets, fields, sender, replyTarget, message);
+		const fed = this.host.federation;
+		if (fed !== void 0) message.hlc = fed.hlc();
+		const wakesRuns = wakesEndedRuns(message);
+		const deliveries = [];
+		const remotes = [];
+		const skipWake = /* @__PURE__ */ new Set();
+		for (const t of targets) {
+			const p = placed.get(t.recipient) ?? LOCAL;
+			if (p.kind === "remote") {
+				remotes.push({
+					messageId: id,
+					recipient: t.recipient,
+					via: t.via,
+					state: "forwarded",
+					homes: p.homes,
+					wakeAt: p.wakeAt ?? null,
+					refusedBy: [],
+					updatedAt: this.nowIso()
+				});
+				if (p.wakeAt !== void 0 && fed !== void 0 && p.wakeAt !== fed.replica) skipWake.add(t.recipient);
+				if (!p.alsoLocal) continue;
+			}
+			const planned = this.plan(t, muted, fields.get(t.recipient) ?? "to", t.recipient === replyTarget?.from || wakesRuns && this.hasTask(t.recipient));
+			if (planned !== null) deliveries.push({
+				...planned,
+				messageId: id
+			});
+		}
+		const question = message.kind === "answer" ? replyTarget : null;
+		const settledAs = question === null || fed === void 0 ? null : this.localAnswerSettledAs(question);
+		const written = this.store.transaction(() => {
+			const prior = key === void 0 ? null : this.replay(sender.address, key);
+			if (prior !== null) return prior;
+			if (question !== null && this.store.answersTo(question.id).length > 0) throw alreadyAnswered(question.id);
+			this.store.insertMessage(message, key, settledAs === null ? void 0 : { settledAs });
+			for (const d of deliveries) this.store.insertDelivery(d);
+			for (const r of remotes) this.store.insertRemote(r);
+			if (question !== null && settledAs === "accepted" && fed !== void 0) this.store.putSettlement({
+				questionId: question.id,
+				answerId: id,
+				closedReason: null,
+				settler: fed.replica,
+				at: this.nowIso()
+			});
+			return question === null ? [] : this.markAnswered(question.id);
+		});
+		if (!Array.isArray(written)) return written;
+		const answered = written;
+		const gateType = question === null ? null : gateTypeOf(question, this.gateTypes);
+		if (question !== null && gateType !== null && this.gateTypes.has(gateType) && !isSystemMarker(message, "x-closed") && isDecidingAuthor(message.from)) await this.applyGate(question, message);
+		this.emit({
+			type: "message",
+			message
+		});
+		for (const d of answered) this.emit({
+			type: "delivery",
+			delivery: d
+		});
+		for (const r of remotes) this.emit({
+			type: "remote",
+			messageId: id,
+			recipient: r.recipient
+		});
+		const settled = [];
+		for (const d of deliveries) settled.push((await this.dispatch(d, message)).delivery);
+		if (message.wake === "request") try {
+			await this.runWake(message, settled, skipWake);
+		} catch (err) {
+			console.error("messaging wake failed", err);
+		}
+		return {
+			message,
+			deliveries: settled,
+			downgraded
+		};
+	}
+	localAnswerSettledAs(question) {
+		if (question.origin !== void 0) return "pending";
+		return this.store.remoteDeliveries({ messageId: question.id }).length > 0 ? "accepted" : null;
+	}
+	hasTask(address) {
+		return address.startsWith("run:") && this.host.taskOfRun(address.slice(4)) !== null;
+	}
+	place(targets, fields, replyTarget, message) {
+		const fed = this.host.federation;
+		const gateData = hasGateData(message) || replyTarget !== null && hasGateData(replyTarget);
+		const placed = /* @__PURE__ */ new Map();
+		let external = false;
+		for (const t of targets) {
+			if (this.isExternal(t.recipient)) {
+				external = true;
+				continue;
+			}
+			let p = fed === void 0 ? LOCAL : fed.placement(t, message, replyTarget);
+			if (gateData && p.kind === "remote") p = p.alsoLocal ? LOCAL : {
+				kind: "refuse",
+				reason: "local-only"
+			};
+			placed.set(t.recipient, p);
+		}
+		const refused = targets.filter((t) => placed.get(t.recipient)?.kind === "refuse");
+		if (gateData && (external || refused.length > 0)) throw new MessagingError("forbidden", "gates never leave this machine", "data");
+		for (const t of refused) if (t.via === "direct") throw new MessagingError("forbidden", "overseer and A2A conversations stay on this machine", fields.get(t.recipient) ?? "to");
+		return {
+			targets: targets.filter((t) => placed.get(t.recipient)?.kind !== "refuse"),
+			placed
+		};
+	}
+	admitExternal(targets, fields, sender, replyTarget, message) {
+		const external = (t) => this.isExternal(t.recipient);
+		if (!targets.some(external)) return targets;
+		const out = [];
+		for (const t of targets) {
+			if (!external(t)) {
+				out.push(t);
+				continue;
+			}
+			const target = {
+				recipient: t.recipient,
+				via: t.via,
+				field: fields.get(t.recipient) ?? "to"
+			};
+			try {
+				if ((this.host.admitExternal?.(target, sender, replyTarget, message) ?? "deliver") === "deliver") out.push(t);
+			} catch (err) {
+				if (t.via === "channel" && err instanceof MessagingError) continue;
+				throw err;
+			}
+		}
+		return out;
+	}
+	isExternal(address) {
+		return (this.host.external?.(address) ?? null) !== null;
+	}
+	replay(from, key) {
+		const message = this.store.byIdemKey(from, key);
+		if (message === null) return null;
+		return {
+			message,
+			deliveries: this.store.deliveries({ messageId: message.id }),
+			downgraded: false,
+			replayed: true
+		};
+	}
+	rewriteForReply(address, target) {
+		return target !== null && (address === target.from || target.to.includes(address)) ? this.deliverableAddress(address) : address;
+	}
+	replyRecipients(to, target) {
+		if (target === null) return [...to];
+		return [...new Set(to.map((a) => this.rewriteForReply(a, target)))];
+	}
+	recipientFields(to, target) {
+		const fields = /* @__PURE__ */ new Map();
+		to.forEach((address, i) => {
+			const resolved = this.rewriteForReply(address, target);
+			if (!fields.has(resolved)) fields.set(resolved, `to[${i}]`);
+		});
+		return fields;
+	}
+	participates(target, sender) {
+		if (decides(sender)) return true;
+		const senderRunId = sender.address.startsWith("run:") ? sender.address.slice(4) : null;
+		const senderTask = senderRunId !== null ? this.host.taskOfRun(senderRunId) : null;
+		const actsFor = (address) => address === sender.address || senderTask !== null && (address === `task:${senderTask}` || address.startsWith("run:") && this.host.taskOfRun(address.slice(4)) === senderTask);
+		if (actsFor(target.from)) return true;
+		return this.store.deliveries({ messageId: target.id }).some((d) => actsFor(d.recipient) || senderRunId !== null && d.runId === senderRunId);
+	}
+	canRead(messageId, sender) {
+		const message = this.store.getMessage(messageId);
+		return message !== null && this.participates(message, sender);
+	}
+	canReadThread(threadId, sender) {
+		return this.store.thread(threadId).some((m) => this.participates(m, sender));
+	}
+	async applyGate(question, answer) {
+		if (!isDecidingAuthor(answer.from)) return false;
+		try {
+			await this.host.onAnswered(question, answer);
+		} catch (err) {
+			console.error("messaging hook failed", err);
+			return false;
+		}
+		try {
+			this.store.markGateApplied(question.id, this.nowIso());
+		} catch (err) {
+			console.error("messaging markGateApplied failed", err);
+			return false;
+		}
+		return true;
+	}
+	async dispatch(d, message, opts = {}) {
+		let next = d;
+		if (d.state === "sending" && d.runId !== null) {
+			const push = d.via === "direct" || (opts.urgent ?? message.urgent);
+			const external = this.isExternal(message.from);
+			const remote = opts.remote ?? this.remoteLabel(message);
+			try {
+				if (push) await this.host.push(d.runId, renderForAgent(message, external, remote), message);
+				else await this.host.notify(d.runId, renderDigestLine(message, external, remote), message);
+				next = {
+					...d,
+					state: push ? "pushed" : "notified",
+					updatedAt: this.nowIso()
+				};
+			} catch {
+				next = {
+					...d,
+					state: "held",
+					runId: null,
+					updatedAt: this.nowIso()
+				};
+			}
+			if (!this.store.setDelivery(next.id, next.state, next.runId, next.updatedAt, "sending")) return {
+				delivery: this.store.getDelivery(d.id) ?? d,
+				won: false
+			};
+		} else if (d.state === "notified") try {
+			this.host.notifyHuman(d.recipient, message);
+		} catch {}
+		this.emit({
+			type: "delivery",
+			delivery: next
+		});
+		return {
+			delivery: next,
+			won: true
+		};
+	}
+	remoteLabel(message) {
+		if (message.origin === void 0) return void 0;
+		return this.host.federation?.label(message.origin) ?? message.origin;
+	}
+	async recover() {
+		let retried = 0;
+		let reverted = 0;
+		let replayed = 0;
+		let voided = 0;
+		for (const d of this.store.deliveries({ states: ["sending"] })) {
+			const message = this.store.getMessage(d.messageId);
+			if (d.runId !== null && message !== null && this.host.isLiveRun(d.runId)) {
+				const { won } = await this.dispatch(d, message);
+				if (won) retried++;
+			} else if (this.store.setDelivery(d.id, "held", null, this.nowIso(), "sending")) reverted++;
+		}
+		for (const { question, answer } of this.store.unappliedAnsweredGates()) {
+			const type = gateTypeOf(question, this.gateTypes);
+			if (type === null || !this.gateTypes.has(type)) continue;
+			if (!isDecidingAuthor(answer.from)) {
+				if (await this.voidAndReopen(question, answer)) voided++;
+				continue;
+			}
+			if (await this.applyGate(question, answer)) replayed++;
+		}
+		return {
+			retried,
+			reverted,
+			replayed,
+			voided
+		};
+	}
+	async voidAndReopen(question, answer) {
+		const muted = this.store.getAgent(question.from)?.muted === true;
+		const reopened = this.store.transaction(() => {
+			if (!this.store.voidAnswer(answer.id, question.id, this.nowIso())) return null;
+			const out = [];
+			for (const d of this.store.deliveries({ messageId: question.id })) {
+				if (d.state !== "answered") continue;
+				const { state, runId } = this.reopenState(d, muted);
+				const next = {
+					...d,
+					state,
+					runId,
+					updatedAt: this.nowIso()
+				};
+				if (this.store.setDelivery(d.id, state, runId, next.updatedAt, "answered")) out.push(next);
+			}
+			return out;
+		});
+		if (reopened === null) return false;
+		const voidedRow = this.store.getMessage(answer.id);
+		if (voidedRow !== null) this.emit({
+			type: "message",
+			message: voidedRow
+		});
+		for (const d of reopened) await this.dispatch(d, question);
+		try {
+			await this.send({
+				to: [this.host.owner(answer.from)],
+				kind: "notice",
+				replyTo: question.id,
+				refs: [{
+					type: "message",
+					id: answer.id
+				}],
+				body: `An answer from ${answer.from} to gate ${question.id} was set aside; only deciding humans answer gates. The gate is open again.`
+			}, SYSTEM_SENDER);
+		} catch (err) {
+			console.error("messaging void notice failed", err);
+		}
+		return true;
+	}
+	reopenState(d, muted) {
+		try {
+			const planned = this.plan({
+				recipient: d.recipient,
+				via: d.via
+			}, muted, "to", true);
+			return planned === null ? {
+				state: "held",
+				runId: null
+			} : {
+				state: planned.state,
+				runId: planned.runId
+			};
+		} catch {
+			return {
+				state: "held",
+				runId: null
+			};
+		}
+	}
+	getMessage(id) {
+		return this.store.getMessage(id);
+	}
+	/** What `address` sent at or after `sinceIso`, oldest first, optionally only these kinds. */
+	messagesFrom(address, sinceIso, kinds) {
+		return this.store.messagesFrom(address, sinceIso, kinds);
+	}
+	answerOf(questionId) {
+		return this.store.answersTo(questionId)[0] ?? null;
+	}
+	openBlocking() {
+		return this.store.openBlocking();
+	}
+	/** One message's local deliveries; recipients homed elsewhere are not among them. */
+	deliveriesOf(messageId) {
+		return this.store.deliveries({ messageId });
+	}
+	thread(threadId) {
+		const messages = this.store.thread(threadId);
+		return {
+			messages,
+			deliveries: messages.flatMap((m) => this.store.deliveries({ messageId: m.id }))
+		};
+	}
+	inbox(recipient, states) {
+		return this.store.deliveries({
+			recipient,
+			states
+		}).flatMap((delivery) => {
+			const message = this.store.getMessage(delivery.messageId);
+			return message === null ? [] : [{
+				delivery,
+				message
+			}];
+		});
+	}
+	markRead(deliveryId) {
+		const d = this.store.getDelivery(deliveryId);
+		if (d === null) throw new MessagingError("not-found", `no delivery ${deliveryId}`, "deliveryId");
+		if (d.state === "answered" || d.state === "read") return d;
+		const next = {
+			...d,
+			state: "read",
+			updatedAt: this.nowIso()
+		};
+		if (!this.store.setDelivery(next.id, next.state, next.runId, next.updatedAt, d.state)) return this.store.getDelivery(d.id) ?? d;
+		this.emit({
+			type: "delivery",
+			delivery: next
+		});
+		return next;
+	}
+	markRelayed(deliveryId) {
+		const d = this.store.getDelivery(deliveryId);
+		if (d === null || d.state !== "held" || !isPeerAddress(d.recipient)) return null;
+		const next = {
+			...d,
+			state: "pushed",
+			updatedAt: this.nowIso()
+		};
+		if (!this.store.setDelivery(next.id, next.state, next.runId, next.updatedAt, "held")) return null;
+		this.emit({
+			type: "delivery",
+			delivery: next
+		});
+		return next;
+	}
+	join(channel, member) {
+		parseAddress(`channel:${channel}`, "channel");
+		const parsed = parseAddress(member, "member");
+		if (parsed.kind === "run") throw new MessagingError("invalid", "channels hold tasks and actors, not runs — join as task:<id>", "member");
+		if (parsed.kind === "channel") throw new MessagingError("invalid", "channels hold tasks and actors, not channels", "member");
+		if (this.store.transaction(() => {
+			this.store.ensureChannel(channel, this.nowIso(), false);
+			return this.store.addMember(channel, member, this.nowIso());
+		})) this.emit({
+			type: "membership",
+			channel,
+			member,
+			joined: true
+		});
+	}
+	leave(channel, member) {
+		const removed = this.store.removeMember(channel, member);
+		if (removed) this.emit({
+			type: "membership",
+			channel,
+			member,
+			joined: false
+		});
+		return removed;
+	}
+	deliverableAddress(address) {
+		if (!address.startsWith("run:")) return address;
+		const runId = address.slice(4);
+		if (this.host.isLiveRun(runId)) return address;
+		const task = this.host.taskOfRun(runId);
+		if (task !== null) return `task:${task}`;
+		const remote = this.host.federation?.remoteRunTask(runId) ?? null;
+		return remote === null ? address : `task:${remote}`;
+	}
+	async reply(messageId, input, sender) {
+		this.authorize(sender);
+		const target = this.store.getMessage(messageId);
+		if (target === null) throw new MessagingError("not-found", `no message ${messageId}`, "replyTo");
+		const asking = target.kind === "question" || target.kind === "handoff";
+		return this.send({
+			...input,
+			to: [target.from],
+			kind: asking ? "answer" : "message",
+			replyTo: messageId
+		}, sender);
+	}
+	close(questionId, reason) {
+		const target = this.store.getMessage(questionId);
+		if (target === null) throw new MessagingError("not-found", `no message ${questionId}`, "replyTo");
+		if (target.kind !== "question" && target.kind !== "handoff") throw new MessagingError("invalid", `${questionId} is a ${target.kind}, not a question or handoff`, "replyTo");
+		if (this.answerOf(questionId) !== null) throw alreadyAnswered(questionId);
+		const answer = {
+			id: this.id("m"),
+			thread: target.thread,
+			replyTo: questionId,
+			from: SYSTEM_ADDRESS,
+			to: [target.from],
+			kind: "answer",
+			body: `Closed: ${reason}`,
+			refs: [],
+			data: {
+				type: "x-closed",
+				reason
+			},
+			urgent: false,
+			blocking: false,
+			wake: "none",
+			createdAt: this.nowIso()
+		};
+		const fed = this.host.federation;
+		if (fed !== void 0) answer.hlc = fed.hlc();
+		const answered = this.store.transaction(() => {
+			this.store.insertMessage(answer);
+			return this.markAnswered(questionId);
+		});
+		this.emit({
+			type: "message",
+			message: answer
+		});
+		for (const d of answered) this.emit({
+			type: "delivery",
+			delivery: d
+		});
+		return answer;
+	}
+	markAnswered(questionId) {
+		const moved = [];
+		for (const d of this.store.deliveries({ messageId: questionId })) {
+			if (d.state === "answered") continue;
+			const next = {
+				...d,
+				state: "answered",
+				updatedAt: this.nowIso()
+			};
+			if (this.store.setDelivery(next.id, next.state, next.runId, next.updatedAt, d.state)) moved.push(next);
+		}
+		return moved;
+	}
+	async deliverHeld(runId, taskId) {
+		const claimed = this.store.transaction(() => {
+			const held = [...this.store.deliveries({
+				recipient: `task:${taskId}`,
+				states: ["held"]
+			}), ...this.store.deliveries({
+				recipientPrefix: "run:",
+				states: ["held"]
+			}).filter((d) => this.host.taskOfRun(d.recipient.slice(4)) === taskId)];
+			const out$1 = [];
+			for (const d of held) {
+				const message = this.store.getMessage(d.messageId);
+				if (message === null) continue;
+				const bound = {
+					...d,
+					state: "sending",
+					runId,
+					updatedAt: this.nowIso()
+				};
+				if (this.store.setDelivery(bound.id, bound.state, bound.runId, bound.updatedAt, "held")) out$1.push({
+					bound,
+					message
+				});
+			}
+			return out$1;
+		});
+		const out = [];
+		for (const { bound, message } of claimed) out.push((await this.dispatch(bound, message)).delivery);
+		return out;
+	}
+	requireFederation() {
+		const fed = this.host.federation;
+		if (fed === void 0) throw new Error("this host does not federate");
+		return fed;
+	}
+	async receive(message, origin) {
+		const fed = this.requireFederation();
+		checkReceivedEnvelope(message);
+		checkReceivedTargets(origin);
+		const stored = this.store.getMessage(message.id);
+		if (stored !== null) {
+			if (!sameSignedContent(stored, this.store.settledAs(stored.id), message)) throw new MessagingError("conflict", `message id ${message.id} was reused with other content`, "id");
+			return {
+				status: "duplicate",
+				deliveries: await this.applyForward(stored, origin)
+			};
+		}
+		const replyTarget = message.replyTo === null ? null : this.store.getMessage(message.replyTo);
+		const root = message.thread === message.id ? null : this.store.getMessage(message.thread);
+		checkReceivedThread(message, replyTarget, root);
+		const local = localOnlyReason(message, replyTarget, root);
+		if (local !== null) throw new MessagingError("forbidden", LOCAL_ONLY_TEXT[local], local === "gate" ? "data" : "to");
+		const { muted } = this.authorizeRemote(message, origin.replica);
+		const joined = replyTarget ?? root;
+		if (joined !== null && !this.remoteParticipant(joined, message.from, origin.replica, fed)) throw new MessagingError("forbidden", `${message.from} is not a participant of ${joined.id}`, joined === replyTarget ? "replyTo" : "thread");
+		validateSendInput(toSendInput(message), message.from, false, replyTarget, {
+			gateTypes: this.gateTypes,
+			origin: "received",
+			parentOptional: true
+		});
+		const sender = {
+			address: message.from,
+			canDecide: false
+		};
+		await this.checkBreaker(joined, sender, true);
+		const demote = message.urgent && !message.from.startsWith("human:") && this.store.countFrom(message.from, this.hourAgoIso(), true, origin.replica) >= this.limits.urgentPerHour;
+		const answer = this.settleOnArrival(message, replyTarget);
+		const asking = message.kind === "question" || message.kind === "handoff";
+		const early = this.store.earlySettlements(message.id);
+		const valid = asking ? early.find((s) => s.settler === origin.replica) ?? null : null;
+		const refused = early.filter((s) => s !== valid);
+		const closeHlc = valid !== null && valid.closedReason !== null ? fed.hlc() : void 0;
+		const deliveries = [];
+		const remotes = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const t of origin.targets) {
+			if (t.recipient === SYSTEM_ADDRESS || seen.has(t.recipient)) continue;
+			seen.add(t.recipient);
+			if (!(t.homes.includes(fed.replica) || origin.forwardTarget === t.recipient)) {
+				remotes.push(remoteRow(message.id, t, this.nowIso()));
+				continue;
+			}
+			const planned = this.planRemote(t, muted);
+			if (deliveries.some((d) => d.recipient === planned.recipient)) continue;
+			deliveries.push({
+				...planned,
+				messageId: message.id
+			});
+		}
+		const storedMessage = {
+			...message,
+			kind: answer.kind,
+			origin: origin.replica
+		};
+		const changed = [];
+		const answered = this.store.transaction(() => {
+			if (this.store.getMessage(message.id) !== null) return null;
+			if (answer.swapFirst && message.replyTo !== null) changed.push(...this.swapSettled(message.replyTo, message.id));
+			this.store.insertMessage(storedMessage, void 0, {
+				receivedAt: this.nowIso(),
+				...answer.settledAs === void 0 ? {} : { settledAs: answer.settledAs }
+			});
+			for (const d of deliveries) this.store.insertDelivery(d);
+			for (const r of remotes) this.store.insertRemote(r);
+			if (answer.recordSettlement && message.replyTo !== null) this.store.putSettlement({
+				questionId: message.replyTo,
+				answerId: message.id,
+				closedReason: null,
+				settler: fed.replica,
+				at: this.nowIso()
+			});
+			if (early.length > 0) this.store.clearEarlySettlements(message.id);
+			const honoured = valid === null ? [] : this.honourSettlement(storedMessage, valid, changed, closeHlc);
+			const answeredFirst = asking ? this.answerEarly(storedMessage, fed, changed) : [];
+			return [
+				...honoured,
+				...answeredFirst,
+				...answer.markAnswered === null ? [] : this.markAnswered(answer.markAnswered)
+			];
+		});
+		if (answered === null) return {
+			status: "duplicate",
+			deliveries: []
+		};
+		this.emit({
+			type: "message",
+			message: storedMessage
+		});
+		this.emitChanged(changed, message.id);
+		for (const d of answered) this.emit({
+			type: "delivery",
+			delivery: d
+		});
+		for (const r of remotes) this.emit({
+			type: "remote",
+			messageId: r.messageId,
+			recipient: r.recipient
+		});
+		const moved = new Map(answered.map((d) => [d.id, d]));
+		const label = fed.label(origin.replica);
+		const settled = [];
+		for (const d of deliveries) {
+			const done = moved.get(d.id);
+			settled.push(done ?? (await this.dispatch(d, storedMessage, {
+				remote: label,
+				urgent: !demote && message.urgent
+			})).delivery);
+		}
+		try {
+			for (const s of refused) fed.problem(`message:${message.id}`, `${s.settler} sent a settle for ${message.id}; only the question's origin settles it`);
+			if (answer.supersededBy !== null && message.replyTo !== null && this.mayNoteSuperseded(message.replyTo, message.id)) await this.noticeTo(message.from, message, `${message.id} was already answered by ${answer.supersededBy}; yours was kept as a reply.`);
+			if (storedMessage.wake === "request") {
+				const wakeHere = new Set(origin.targets.filter((t) => t.wakeAt === fed.replica).map((t) => t.recipient));
+				const skip = new Set(settled.map((d) => d.recipient).filter((r) => !wakeHere.has(r)));
+				await this.runWake(storedMessage, settled, skip);
+			}
+		} catch (err) {
+			console.error("messaging receive follow-up failed", err);
+		}
+		return {
+			status: "applied",
+			deliveries: settled
+		};
+	}
+	async applyForward(stored, origin) {
+		if (origin.forwardTarget === void 0) return [];
+		const target = origin.targets.find((t) => t.recipient === origin.forwardTarget);
+		if (target === void 0) return [];
+		const muted = this.store.getAgent(stored.from)?.muted === true;
+		const planned = {
+			...this.planRemote(target, muted),
+			messageId: stored.id
+		};
+		if (!this.store.transaction(() => {
+			if (this.store.deliveries({
+				messageId: stored.id,
+				recipient: planned.recipient
+			}).length > 0) return false;
+			if (!this.store.deleteRemote(stored.id, target.recipient)) return false;
+			this.store.insertDelivery(planned);
+			return true;
+		})) return [];
+		this.emit({
+			type: "remote",
+			messageId: stored.id,
+			recipient: target.recipient
+		});
+		return [(await this.dispatch(planned, stored)).delivery];
+	}
+	authorizeRemote(message, replica) {
+		const parsed = parseAddress(message.from, "from");
+		if (message.from === SYSTEM_ADDRESS) {
+			if (!(message.kind === "notice" && message.data === void 0 && message.refs.length > 0 && message.refs.every((r) => r.type === "message" && this.exchangedWith(r.id, replica)))) throw new MessagingError("forbidden", `${SYSTEM_ADDRESS} from another machine may only send notices about messages exchanged with it`, "from");
+			return { muted: false };
+		}
+		if (parsed.kind === "task" || parsed.kind === "channel") throw new MessagingError("forbidden", `${message.from} cannot send`, "from");
+		if (parsed.kind !== "agent") return { muted: false };
+		const agent = this.store.getAgent(message.from);
+		if (agent === null || agent.status !== "approved") throw new MessagingError("forbidden", `${message.from} is not an approved agent`, "from");
+		return { muted: agent.muted };
+	}
+	exchangedWith(messageId, replica) {
+		const m = this.store.getMessage(messageId);
+		if (m === null) return false;
+		return m.origin === replica || this.store.remoteDeliveries({ messageId }).some((r) => r.homes.includes(replica));
+	}
+	remoteParticipant(target, from, replica, fed) {
+		const taskOf = (runId) => this.host.taskOfRun(runId) ?? fed.remoteRunTask(runId);
+		const fromTask = from.startsWith("run:") ? taskOf(from.slice(4)) : null;
+		const actsFor = (address) => {
+			if (address === SYSTEM_ADDRESS) return from === SYSTEM_ADDRESS && target.origin === replica;
+			if (address === from) return true;
+			if (fromTask === null) return false;
+			return address === `task:${fromTask}` || address.startsWith("run:") && taskOf(address.slice(4)) === fromTask;
+		};
+		const remoteRows = this.store.remoteDeliveries({ messageId: target.id });
+		return actsFor(target.from) || target.to.some(actsFor) || this.store.deliveries({ messageId: target.id }).some((d) => actsFor(d.recipient)) || remoteRows.some((r) => actsFor(r.recipient)) || from.startsWith("human:") && remoteRows.some((r) => r.homes.includes(replica));
+	}
+	answerEarly(question, fed, changed) {
+		if (this.store.settlement(question.id) !== null) return this.store.answersTo(question.id).length > 0 ? this.markAnswered(question.id) : [];
+		const early = this.store.answerCandidates(question.id).filter((c) => c.settledAs === "pending" || c.settledAs === "candidate");
+		const first = early.find((c) => this.earlyAnswerHolds(question, c.message, fed)) ?? null;
+		for (const c of early) {
+			if (c === first || c.settledAs === "candidate") continue;
+			this.store.setSettled(c.message.id, "message", "candidate");
+			changed.push(c.message.id);
+		}
+		if (first === null) return [];
+		if (first.settledAs !== "pending") {
+			this.store.setSettled(first.message.id, "answer", "pending");
+			changed.push(first.message.id);
+		}
+		return this.markAnswered(question.id);
+	}
+	earlyAnswerHolds(question, answer, fed) {
+		if (answer.origin === void 0 || !this.remoteParticipant(question, answer.from, answer.origin, fed)) return false;
+		try {
+			validateSendInput(toSendInput({
+				...answer,
+				kind: "answer"
+			}), answer.from, false, question, {
+				gateTypes: this.gateTypes,
+				origin: "received"
+			});
+			return true;
+		} catch (err) {
+			if (err instanceof MessagingError) return false;
+			throw err;
+		}
+	}
+	planRemote(t, muted) {
+		const recipient = this.deliverableAddress(t.recipient);
+		const held = {
+			id: this.id("d"),
+			messageId: "",
+			recipient,
+			runId: null,
+			via: t.via,
+			state: "held",
+			updatedAt: this.nowIso()
+		};
+		if (muted) return {
+			...held,
+			state: "read"
+		};
+		if (recipient.startsWith("run:")) {
+			const runId = recipient.slice(4);
+			return this.host.isLiveRun(runId) ? {
+				...held,
+				runId,
+				state: "sending"
+			} : held;
+		}
+		try {
+			return this.plan({
+				recipient,
+				via: t.via
+			}, false, "to", true) ?? held;
+		} catch {
+			return held;
+		}
+	}
+	settleOnArrival(message, question) {
+		const plain = {
+			kind: message.kind,
+			markAnswered: null,
+			recordSettlement: false,
+			swapFirst: false,
+			supersededBy: null
+		};
+		if (message.kind !== "answer" || message.replyTo === null) return plain;
+		const first = this.store.answersTo(message.replyTo)[0] ?? null;
+		if (question !== null && question.origin === void 0) {
+			if (first === null) return {
+				...plain,
+				settledAs: "accepted",
+				markAnswered: question.id,
+				recordSettlement: true
+			};
+			return {
+				...plain,
+				kind: "message",
+				settledAs: "superseded",
+				supersededBy: first.from
+			};
+		}
+		const settlement = question === null ? null : this.store.settlement(question.id);
+		if (question !== null && settlement !== null) {
+			if (settlement.answerId === message.id) return {
+				...plain,
+				settledAs: "accepted",
+				markAnswered: question.id,
+				swapFirst: true
+			};
+			return {
+				...plain,
+				kind: "message",
+				settledAs: "superseded"
+			};
+		}
+		if (first === null) return {
+			...plain,
+			settledAs: "pending",
+			markAnswered: question?.id ?? null
+		};
+		return {
+			...plain,
+			kind: "message",
+			settledAs: "candidate"
+		};
+	}
+	applyState(entries, publisher) {
+		const fed = this.requireFederation();
+		const events = [];
+		const notices = [];
+		this.store.transaction(() => {
+			for (const e of entries) if (e.t === "delivery") this.mergeDelivery(e, publisher, events);
+			else this.mergeRefused(e, publisher, fed, events, notices);
+		});
+		for (const e of events) this.emit(e);
+		for (const n of notices) this.noticeTo(n.to, n.about, n.body).catch((err) => console.error("messaging refusal notice failed", err));
+	}
+	mergeDelivery(e, publisher, events) {
+		const now = this.nowIso();
+		const where = {
+			messageId: e.message,
+			recipient: e.recipient
+		};
+		for (const row of this.store.remoteDeliveries(where)) {
+			if (!row.homes.includes(publisher)) continue;
+			const state = maxRemote(row.state, e.state);
+			if (state === row.state) continue;
+			const patch = row.state === "refused" ? {
+				state,
+				refusedBy: []
+			} : { state };
+			if (this.store.setRemote(row.messageId, row.recipient, patch, now, row.state)) events.push({
+				type: "remote",
+				...where
+			});
+		}
+		for (const d of this.store.deliveries(where)) if (d.recipient.startsWith("human:")) {
+			if (e.state !== "read" && e.state !== "answered") continue;
+			if (LOCAL_RANK[e.state] <= LOCAL_RANK[d.state]) continue;
+			if (this.store.setDelivery(d.id, e.state, d.runId, now, d.state)) events.push({
+				type: "delivery",
+				delivery: {
+					...d,
+					state: e.state,
+					updatedAt: now
+				}
+			});
+		} else if (d.recipient.startsWith("task:") && d.state === "held" && REMOTE_RANK[e.state] >= REMOTE_RANK.pushed) {
+			this.store.deleteDelivery(d.id);
+			this.putRemote(d, [publisher], e.state, now);
+			events.push({
+				type: "remote",
+				...where
+			});
+		}
+	}
+	mergeRefused(e, publisher, fed, events, notices) {
+		const message = this.store.getMessage(e.message);
+		if (message === null || message.origin !== void 0) return;
+		const now = this.nowIso();
+		let newlyRefused = false;
+		for (const row of this.store.remoteDeliveries({ messageId: message.id })) {
+			if (!row.homes.includes(publisher) || row.refusedBy.includes(publisher)) continue;
+			const refusedBy = [...row.refusedBy, publisher];
+			const all = row.homes.every((h) => refusedBy.includes(h));
+			const state = all ? "refused" : row.state;
+			if (!this.store.setRemote(row.messageId, row.recipient, {
+				state,
+				refusedBy
+			}, now, row.state)) continue;
+			events.push({
+				type: "remote",
+				messageId: row.messageId,
+				recipient: row.recipient
+			});
+			if (all && row.state !== "refused") newlyRefused = true;
+		}
+		if (newlyRefused && message.from !== SYSTEM_ADDRESS) notices.push({
+			to: message.from,
+			about: message,
+			body: `${message.id} was refused by ${fed.label(publisher)}'s machine: ${e.reason}.`
+		});
+		const question = message.replyTo === null ? null : this.store.getMessage(message.replyTo);
+		if (question === null || question.origin !== publisher || this.store.settledAs(message.id) !== "pending") return;
+		this.store.setSettled(message.id, "message", null);
+		events.push({
+			type: "message",
+			message: {
+				...message,
+				kind: "message"
+			}
+		});
+		for (const d of this.store.deliveries({
+			messageId: question.id,
+			states: ["answered"]
+		})) {
+			const state = d.recipient.startsWith("human:") ? "notified" : "held";
+			if (this.store.setDelivery(d.id, state, null, now, "answered")) events.push({
+				type: "delivery",
+				delivery: {
+					...d,
+					state,
+					runId: null,
+					updatedAt: now
+				}
+			});
+		}
+	}
+	applySettlement(entry, publisher) {
+		const fed = this.requireFederation();
+		const record = {
+			questionId: entry.question,
+			answerId: entry.answer,
+			closedReason: entry.closed ?? null,
+			settler: publisher,
+			at: entry.at
+		};
+		const q = this.store.getMessage(entry.question);
+		if (q === null) {
+			this.store.putEarlySettlement(record);
+			return;
+		}
+		if ((q.origin ?? fed.replica) !== publisher) throw new MessagingError("forbidden", `${publisher} did not ask ${entry.question}`, "question");
+		const closeHlc = entry.closed === void 0 ? void 0 : fed.hlc();
+		const changed = [];
+		const moved = this.store.transaction(() => this.honourSettlement(q, record, changed, closeHlc));
+		this.emitChanged(changed);
+		for (const d of moved) this.emit({
+			type: "delivery",
+			delivery: d
+		});
+	}
+	honourSettlement(q, s, changed, closeHlc) {
+		const answer = s.answerId === null ? null : this.store.getMessage(s.answerId);
+		if (answer !== null && !this.store.answerCandidates(q.id).some((c) => c.message.id === answer.id)) return [];
+		this.store.putSettlement(s);
+		if (s.answerId === null) return [];
+		if (answer !== null) {
+			changed.push(...this.swapSettled(q.id, s.answerId));
+			return this.markAnswered(q.id);
+		}
+		if (s.closedReason === null) return [];
+		changed.push(...this.demoteOtherAnswers(q.id, s.answerId));
+		this.store.insertMessage(closeCopy(q, s.answerId, s.closedReason, s.settler, this.nowIso(), closeHlc), void 0, {
+			receivedAt: this.nowIso(),
+			settledAs: "accepted"
+		});
+		changed.push(s.answerId);
+		return this.markAnswered(q.id);
+	}
+	swapSettled(questionId, answerId) {
+		const changed = this.demoteOtherAnswers(questionId, answerId);
+		this.store.setSettled(answerId, "answer", "accepted");
+		return [...changed, answerId];
+	}
+	demoteOtherAnswers(questionId, keep) {
+		const changed = [];
+		for (const c of this.store.answerCandidates(questionId)) {
+			if (c.message.id === keep) continue;
+			if (c.message.kind !== "answer" && c.settledAs === "superseded") continue;
+			this.store.setSettled(c.message.id, "message", "superseded");
+			changed.push(c.message.id);
+		}
+		return changed;
+	}
+	emitChanged(ids, skip) {
+		for (const id of new Set(ids)) {
+			if (id === skip) continue;
+			const m = this.store.getMessage(id);
+			if (m !== null) this.emit({
+				type: "message",
+				message: m
+			});
+		}
+	}
+	claimRemote(taskId) {
+		const recipient = `task:${taskId}`;
+		const now = this.nowIso();
+		const retired = [];
+		const claimed = this.store.transaction(() => {
+			const out = [];
+			for (const row of this.store.remoteDeliveries({
+				recipient,
+				states: ["forwarded", "held"]
+			})) {
+				if (this.store.getMessage(row.messageId) === null) continue;
+				if (this.store.deleteRemote(row.messageId, recipient)) retired.push(row.messageId);
+				if (this.store.deliveries({
+					messageId: row.messageId,
+					recipient
+				}).length > 0) continue;
+				const d = {
+					id: this.id("d"),
+					messageId: row.messageId,
+					recipient,
+					runId: null,
+					via: row.via,
+					state: "held",
+					updatedAt: now
+				};
+				this.store.insertDelivery(d);
+				out.push(d);
+			}
+			return out;
+		});
+		for (const messageId of retired) this.emit({
+			type: "remote",
+			messageId,
+			recipient
+		});
+		for (const d of claimed) this.emit({
+			type: "delivery",
+			delivery: d
+		});
+		return claimed;
+	}
+	moveToRemote(messageId, recipient, homes, state = "forwarded") {
+		const now = this.nowIso();
+		if (this.store.transaction(() => {
+			const local = this.store.deliveries({
+				messageId,
+				recipient
+			});
+			const [first] = local;
+			if (first === void 0) return false;
+			for (const d of local) this.store.deleteDelivery(d.id);
+			this.putRemote(first, homes, state, now);
+			return true;
+		})) this.emit({
+			type: "remote",
+			messageId,
+			recipient
+		});
+	}
+	putRemote(d, homes, state, now) {
+		const row = {
+			messageId: d.messageId,
+			recipient: d.recipient,
+			via: d.via,
+			state,
+			homes,
+			wakeAt: null,
+			refusedBy: [],
+			updatedAt: now
+		};
+		if (this.store.insertRemote(row)) return;
+		const [existing] = this.store.remoteDeliveries({
+			messageId: d.messageId,
+			recipient: d.recipient
+		});
+		if (existing === void 0) return;
+		this.store.setRemote(d.messageId, d.recipient, {
+			state: maxRemote(existing.state, state),
+			homes: [...new Set([...existing.homes, ...homes])]
+		}, now);
+	}
+	mayNoteSuperseded(questionId, answerId) {
+		return this.store.answerCandidates(questionId).filter((c) => c.settledAs === "superseded" && c.message.id !== answerId).length < MAX_SUPERSEDED_NOTICES;
+	}
+	async noticeTo(recipient, about, body) {
+		await this.send({
+			to: [this.deliverableAddress(recipient)],
+			kind: "notice",
+			body,
+			refs: [{
+				type: "message",
+				id: about.id
+			}]
+		}, SYSTEM_SENDER);
+	}
+	async runWake(message, settled, skip) {
+		const wakesRuns = wakesEndedRuns(message);
+		for (const d of settled) {
+			if (d.state !== "held" || skip.has(d.recipient)) continue;
+			if (!d.recipient.startsWith("task:") && !(wakesRuns && d.recipient.startsWith("run:"))) continue;
+			const request = {
+				type: "wake",
+				target: d.recipient,
+				message
+			};
+			if (message.origin !== void 0) request.origin = message.origin;
+			const ruling = this.host.decide(request);
+			if (ruling === "allow") {
+				let result;
+				try {
+					result = await this.host.wake(d.recipient, message);
+				} catch (err) {
+					console.error("messaging hook failed", err);
+					result = {
+						ok: false,
+						reason: err instanceof Error ? err.message : String(err)
+					};
+				}
+				if (!result.ok) await this.noticeTo(message.from, message, `Could not wake ${d.recipient}: ${result.reason}. Your message is waiting for it.`);
+			} else if (ruling === "deny") await this.noticeTo(message.from, message, `Waking ${d.recipient} was not allowed. Your message is waiting for it.`);
+			else {
+				if (this.openWakeGates(d.recipient) >= this.limits.openWakeGatesPerTarget) continue;
+				const label = this.remoteLabel(message);
+				const who = label === void 0 ? message.from : `${message.from} (remote: ${label})`;
+				await this.send({
+					to: [this.host.owner(d.recipient, message.from)],
+					kind: "question",
+					blocking: true,
+					choices: ["approve", "deny"],
+					body: `${who} wants to wake ${d.recipient}:\n\n> ${firstLine(message.body)}`,
+					data: {
+						type: "wake",
+						target: d.recipient,
+						message: message.id
+					},
+					refs: [{
+						type: "message",
+						id: message.id
+					}]
+				}, SYSTEM_SENDER);
+			}
+		}
+	}
+	checkNewThreads(input, replyTarget, sender) {
+		if (replyTarget !== null || !isAgentAuthored(sender.address) || !isAgentThread(input.to)) return;
+		const started = this.store.countAgentThreadsFrom(sender.address, this.hourAgoIso());
+		if (started < this.limits.agentThreadsPerHour) return;
+		throw new MessagingError("limited", `${sender.address} started ${started} new threads with other agents this hour; message a human or wait`, "to");
+	}
+	openWakeGates(target) {
+		return this.openBlocking().filter((m) => {
+			const gate = gateOf(m);
+			return gate?.type === "wake" && gate.target === target;
+		}).length;
+	}
+	async checkBreaker(replyTarget, sender, remote = false) {
+		const agentAuthored = isAgentAuthored(sender.address) || remote && sender.address === SYSTEM_ADDRESS;
+		if (replyTarget === null || !agentAuthored) return;
+		const since = this.hourAgoIso();
+		const count = this.store.countAgentAuthored(replyTarget.thread, since, SYSTEM_ADDRESS);
+		if (count < this.limits.agentTurnsPerThreadPerHour) return;
+		if (!this.store.thread(replyTarget.thread).some((m) => isSystemMarker(m, "x-breaker") && m.createdAt >= since)) await this.send({
+			to: [this.host.owner(sender.address)],
+			kind: "notice",
+			replyTo: replyTarget.id,
+			body: `Agents have sent ${count} messages in thread ${replyTarget.thread} this hour; further agent replies are paused.`,
+			data: {
+				type: "x-breaker",
+				thread: replyTarget.thread
+			}
+		}, SYSTEM_SENDER);
+		throw new MessagingError("limited", `thread ${replyTarget.thread} hit the agent turn limit; a human has been asked to step in`, "replyTo");
+	}
+};
+function alreadyAnswered(questionId) {
+	return new MessagingError("conflict", `${questionId} is already answered`, "replyTo");
+}
+function decides(sender) {
+	return sender.address === SYSTEM_ADDRESS || sender.canDecide && sender.address.startsWith("human:");
+}
+function maxRemote(current, reported) {
+	if (current === "refused") return reported;
+	return REMOTE_RANK[reported] > REMOTE_RANK[current] ? reported : current;
+}
+function remoteRow(messageId, t, now) {
+	return {
+		messageId,
+		recipient: t.recipient,
+		via: t.via,
+		state: "forwarded",
+		homes: t.homes,
+		wakeAt: t.wakeAt ?? null,
+		refusedBy: [],
+		updatedAt: now
+	};
+}
+function closeCopy(q, id, reason, settler, now, hlc) {
+	const close = {
+		id,
+		thread: q.thread,
+		replyTo: q.id,
+		from: SYSTEM_ADDRESS,
+		to: [q.from],
+		kind: "answer",
+		body: `Closed: ${reason}`,
+		refs: [],
+		data: {
+			type: "x-closed",
+			reason
+		},
+		urgent: false,
+		blocking: false,
+		wake: "none",
+		createdAt: now,
+		origin: settler
+	};
+	if (hlc !== void 0) close.hlc = hlc;
+	return close;
+}
+function toSendInput(m) {
+	const input = {
+		to: m.to,
+		kind: m.kind,
+		body: m.body,
+		refs: m.refs,
+		urgent: m.urgent,
+		blocking: m.blocking,
+		replyTo: m.replyTo,
+		wake: m.wake
+	};
+	if (m.data !== void 0) input.data = m.data;
+	if (m.choices !== void 0) input.choices = m.choices;
+	if (m.choice !== void 0) input.choice = m.choice;
+	if (m.session !== void 0) input.session = m.session;
+	return input;
+}
+function malformed(field, why) {
+	throw new MessagingError("invalid", `${field}: ${why}`, field);
+}
+function checkReceivedEnvelope(m) {
+	if (!isIdentifier(m.id)) malformed("id", "expected a message id");
+	if (!isIdentifier(m.thread)) malformed("thread", "expected a message id");
+	if (m.replyTo !== null && !isIdentifier(m.replyTo)) malformed("replyTo", "expected a message id or null");
+	for (const field of [
+		"from",
+		"kind",
+		"body",
+		"createdAt"
+	]) if (typeof m[field] !== "string") malformed(field, "expected a string");
+	for (const field of [
+		"session",
+		"hlc",
+		"choice"
+	]) if (m[field] !== void 0 && typeof m[field] !== "string") malformed(field, "expected a string");
+	if (!Array.isArray(m.to)) malformed("to", "expected a list");
+	checkStrings(m.to, "to");
+	if (m.choices !== void 0) {
+		if (!Array.isArray(m.choices)) malformed("choices", "expected a list");
+		checkStrings(m.choices, "choices");
+	}
+	if (!Array.isArray(m.refs) || !m.refs.every((r) => typeof r === "object" && r !== null)) malformed("refs", "expected a list of refs");
+	m.refs.forEach((r, i) => {
+		if (typeof r.type !== "string") malformed(`refs[${i}].type`, "expected a string");
+		if (typeof r.id !== "string") malformed(`refs[${i}].id`, "expected a string");
+		if (r.at !== void 0 && typeof r.at !== "string") malformed(`refs[${i}].at`, "expected a string");
+	});
+	if (typeof m.urgent !== "boolean") malformed("urgent", "expected a boolean");
+	if (typeof m.blocking !== "boolean") malformed("blocking", "expected a boolean");
+	if (m.wake !== "none" && m.wake !== "request") malformed("wake", "expected none or request");
+}
+function checkStrings(list, field) {
+	list.forEach((v, i) => {
+		if (typeof v !== "string") malformed(`${field}[${i}]`, "expected a string");
+	});
+}
+function checkReceivedTargets(origin) {
+	if (!Array.isArray(origin.targets)) malformed("targets", "expected a list");
+	if (origin.forwardTarget !== void 0 && typeof origin.forwardTarget !== "string") malformed("forwardTarget", "expected an address");
+	origin.targets.forEach((raw, i) => {
+		const at = `targets[${i}]`;
+		const t = typeof raw === "object" && raw !== null ? raw : {};
+		if (typeof t.recipient !== "string") malformed(`${at}.recipient`, "expected an address");
+		if (t.via !== "direct" && t.via !== "channel") malformed(`${at}.via`, "expected direct or channel");
+		if (!Array.isArray(t.homes)) malformed(`${at}.homes`, "expected a list");
+		checkStrings(t.homes, `${at}.homes`);
+		if (t.wakeAt !== void 0 && typeof t.wakeAt !== "string") malformed(`${at}.wakeAt`, "expected a replica id");
+		if (isFederationLocalAddress(t.recipient)) throw new MessagingError("forbidden", LOCAL_ONLY_TEXT.participant, "to");
+		parseAddress(t.recipient, at);
+	});
+}
+function checkReceivedThread(m, replyTarget, root) {
+	if (m.replyTo === m.id) malformed("replyTo", "a message cannot reply to itself");
+	if (root !== null && root.thread !== root.id) malformed("thread", `${root.id} is a reply, not a thread's first message`);
+	if (m.replyTo === null && m.thread !== m.id) malformed("thread", "a message that replies to nothing starts its own thread");
+	if (replyTarget !== null && m.thread !== replyTarget.thread) malformed("thread", `expected ${replyTarget.thread}, the thread of ${replyTarget.id}`);
+}
+const SIGNED_FIELDS = [
+	"id",
+	"thread",
+	"replyTo",
+	"from",
+	"session",
+	"to",
+	"kind",
+	"body",
+	"refs",
+	"data",
+	"urgent",
+	"blocking",
+	"choices",
+	"choice",
+	"wake",
+	"createdAt",
+	"hlc"
+];
+function sameSignedContent(stored, settledAs, incoming) {
+	const storedKind = settledAs === "superseded" || settledAs === "candidate" ? "answer" : stored.kind;
+	const signed = (m, kind) => canonical(Object.fromEntries(SIGNED_FIELDS.map((f) => [f, f === "kind" ? kind : m[f]])));
+	return signed(stored, storedKind) === signed(incoming, incoming.kind);
+}
+function canonical(value) {
+	if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+	if (value !== null && typeof value === "object") {
+		const record = value;
+		return `{${Object.keys(record).filter((k) => record[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}:${canonical(record[k])}`).join(",")}}`;
+	}
+	return JSON.stringify(value) ?? "null";
+}
+function wakesEndedRuns(message) {
+	return message.wake === "request" && message.origin === void 0 && message.from.startsWith("human:");
+}
+function isAgentThread(to) {
+	return !to.some((a) => a.startsWith("human:")) && to.some((a) => a.startsWith("agent:") || a.startsWith("run:") || a.startsWith("task:"));
+}
+
+//#endregion
+//#region src/store.ts
+const REMOTE_STATES = [
+	"forwarded",
+	"held",
+	"pushed",
+	"notified",
+	"read",
+	"answered",
+	"refused"
+];
+
+//#endregion
+//#region src/sqliteStore.ts
+const MESSAGES_DB_VERSION = 1;
+const DDL = `
+CREATE TABLE IF NOT EXISTS messages (
+  id TEXT PRIMARY KEY, thread TEXT NOT NULL, reply_to TEXT, from_addr TEXT NOT NULL,
+  session TEXT, kind TEXT NOT NULL, body TEXT NOT NULL, refs_json TEXT NOT NULL,
+  data_json TEXT, urgent INTEGER NOT NULL, blocking INTEGER NOT NULL,
+  choices_json TEXT, choice TEXT, wake TEXT NOT NULL, created_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS messages_thread ON messages (thread, id);
+CREATE INDEX IF NOT EXISTS messages_reply ON messages (reply_to);
+CREATE INDEX IF NOT EXISTS messages_from ON messages (from_addr, created_at);
+CREATE UNIQUE INDEX IF NOT EXISTS messages_one_answer ON messages (reply_to) WHERE kind = 'answer';
+CREATE TABLE IF NOT EXISTS recipients (
+  message_id TEXT NOT NULL, position INTEGER NOT NULL, addr TEXT NOT NULL,
+  PRIMARY KEY (message_id, position)
+);
+CREATE INDEX IF NOT EXISTS recipients_addr ON recipients (addr);
+CREATE TABLE IF NOT EXISTS deliveries (
+  id TEXT PRIMARY KEY, message_id TEXT NOT NULL, recipient TEXT NOT NULL,
+  run_id TEXT, via TEXT NOT NULL, state TEXT NOT NULL, updated_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS deliveries_recipient ON deliveries (recipient, state);
+CREATE INDEX IF NOT EXISTS deliveries_message ON deliveries (message_id);
+CREATE INDEX IF NOT EXISTS deliveries_run ON deliveries (run_id);
+CREATE TABLE IF NOT EXISTS channels (
+  name TEXT PRIMARY KEY, created_at TEXT NOT NULL, auto INTEGER NOT NULL
+);
+CREATE TABLE IF NOT EXISTS members (
+  channel TEXT NOT NULL, addr TEXT NOT NULL, joined_at TEXT NOT NULL,
+  PRIMARY KEY (channel, addr)
+);
+CREATE TABLE IF NOT EXISTS agents (
+  addr TEXT PRIMARY KEY, display_name TEXT NOT NULL, client TEXT NOT NULL,
+  token_hash TEXT NOT NULL UNIQUE, status TEXT NOT NULL, muted INTEGER NOT NULL,
+  approved_by TEXT, created_at TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS gate_effects (
+  question_id TEXT PRIMARY KEY, applied_at TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS voided_answers (
+  answer_id TEXT PRIMARY KEY, question_id TEXT NOT NULL, at TEXT NOT NULL
+);
+`;
+function openMessagesDb(path) {
+	const db = openSqliteDb(path);
+	const existing = dbVersion(db);
+	if (existing > MESSAGES_DB_VERSION) {
+		db.close();
+		throw new Error(`messages database at ${path} was written by a newer schema (version ${existing}, this build understands ${MESSAGES_DB_VERSION})`);
+	}
+	db.exec(DDL);
+	addIdemKey(db);
+	addFederationSchema(db);
+	addMessageRefs(db);
+	db.exec(`PRAGMA user_version = ${MESSAGES_DB_VERSION}`);
+	return db;
+}
+function addIdemKey(db) {
+	if (!hasIdemKey(db)) try {
+		db.exec("ALTER TABLE messages ADD COLUMN idem_key TEXT");
+	} catch (err) {
+		if (!hasIdemKey(db)) throw err;
+	}
+	db.exec("CREATE UNIQUE INDEX IF NOT EXISTS messages_idem ON messages (from_addr, idem_key) WHERE idem_key IS NOT NULL");
+}
+function hasIdemKey(db) {
+	return messageColumns(db).has("idem_key");
+}
+function messageColumns(db) {
+	return new Set(queryAll(db, "PRAGMA table_info(messages)").map((c) => c.name));
+}
+const FEDERATION_DDL = `
+CREATE TABLE IF NOT EXISTS remote_deliveries (
+  message_id TEXT NOT NULL, recipient TEXT NOT NULL, via TEXT NOT NULL,
+  state TEXT NOT NULL, homes_json TEXT NOT NULL, wake_at TEXT, refused_by TEXT,
+  updated_at TEXT NOT NULL, PRIMARY KEY (message_id, recipient)
+);
+CREATE INDEX IF NOT EXISTS remote_recipient ON remote_deliveries (recipient, state);
+CREATE TABLE IF NOT EXISTS settlements (
+  question_id TEXT PRIMARY KEY, answer_id TEXT, closed_reason TEXT,
+  settler TEXT NOT NULL, at TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS early_settlements (
+  question_id TEXT NOT NULL, settler TEXT NOT NULL, answer_id TEXT,
+  closed_reason TEXT, at TEXT NOT NULL, PRIMARY KEY (question_id, settler)
+);
+`;
+const FEDERATION_COLUMNS = [
+	"origin",
+	"hlc",
+	"received_at",
+	"settled_as"
+];
+const SETTLED_AS = [
+	"pending",
+	"accepted",
+	"superseded",
+	"candidate"
+];
+function addFederationSchema(db) {
+	const have = messageColumns(db);
+	for (const column of FEDERATION_COLUMNS) {
+		if (have.has(column)) continue;
+		try {
+			db.exec(`ALTER TABLE messages ADD COLUMN ${column} TEXT`);
+		} catch (err) {
+			if (!messageColumns(db).has(column)) throw err;
+		}
+	}
+	db.exec("CREATE INDEX IF NOT EXISTS messages_thread_hlc ON messages (thread, hlc, id)");
+	db.exec(FEDERATION_DDL);
+}
+function addMessageRefs(db) {
+	const existed = queryOne(db, "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'message_refs'") !== void 0;
+	db.exec(`CREATE TABLE IF NOT EXISTS message_refs (
+  message_id TEXT NOT NULL, type TEXT NOT NULL, ref_id TEXT NOT NULL,
+  PRIMARY KEY (message_id, type, ref_id)
+);
+CREATE INDEX IF NOT EXISTS message_refs_target ON message_refs (type, ref_id);`);
+	if (existed) return;
+	db.exec(`INSERT OR IGNORE INTO message_refs (message_id, type, ref_id)
+    SELECT m.id, json_extract(j.value, '$.type'), json_extract(j.value, '$.id')
+    FROM messages m, json_each(m.refs_json) j
+    WHERE json_extract(j.value, '$.type') IS NOT NULL
+      AND json_extract(j.value, '$.id') IS NOT NULL`);
+}
+function oneOf(value, allowed, what) {
+	if (!allowed.includes(value)) throw new Error(`messages.db: bad ${what} ${JSON.stringify(value)}`);
+	return value;
+}
+var SqliteMessageStore = class {
+	depth = 0;
+	constructor(db) {
+		this.db = db;
+	}
+	transaction(fn) {
+		if (this.depth > 0) return fn();
+		this.db.exec("BEGIN");
+		this.depth++;
+		try {
+			const out = fn();
+			this.db.exec("COMMIT");
+			return out;
+		} catch (err) {
+			this.db.exec("ROLLBACK");
+			throw err;
+		} finally {
+			this.depth--;
+		}
+	}
+	insertMessage(m, idemKey, meta) {
+		this.transaction(() => {
+			this.db.prepare(`INSERT INTO messages (id, thread, reply_to, from_addr, session, kind, body, refs_json, data_json, urgent, blocking, choices_json, choice, wake, created_at, idem_key, origin, hlc, received_at, settled_as) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(m.id, m.thread, m.replyTo, m.from, m.session ?? null, m.kind, m.body, JSON.stringify(m.refs), m.data === void 0 ? null : JSON.stringify(m.data), m.urgent ? 1 : 0, m.blocking ? 1 : 0, m.choices === void 0 ? null : JSON.stringify(m.choices), m.choice ?? null, m.wake, m.createdAt, idemKey ?? null, m.origin ?? null, m.hlc ?? null, meta?.receivedAt ?? null, meta?.settledAs ?? null);
+			const insert = this.db.prepare("INSERT INTO recipients (message_id, position, addr) VALUES (?,?,?)");
+			m.to.forEach((addr, i) => insert.run(m.id, i, addr));
+			const ref = this.db.prepare("INSERT OR IGNORE INTO message_refs (message_id, type, ref_id) VALUES (?,?,?)");
+			for (const r of m.refs) ref.run(m.id, r.type, r.id);
+		});
+	}
+	toMessage(row) {
+		const to = queryAll(this.db, "SELECT addr FROM recipients WHERE message_id = ? ORDER BY position", [row.id]).map((r) => r.addr);
+		const message = {
+			id: row.id,
+			thread: row.thread,
+			replyTo: row.reply_to,
+			from: row.from_addr,
+			to,
+			kind: row.kind,
+			body: row.body,
+			refs: JSON.parse(row.refs_json),
+			urgent: row.urgent === 1,
+			blocking: row.blocking === 1,
+			wake: oneOf(row.wake, ["none", "request"], "wake"),
+			createdAt: row.created_at
+		};
+		if (row.session !== null) message.session = row.session;
+		if (row.data_json !== null) message.data = JSON.parse(row.data_json);
+		if (row.choices_json !== null) message.choices = JSON.parse(row.choices_json);
+		if (row.choice !== null) message.choice = row.choice;
+		if (row.origin !== null) message.origin = row.origin;
+		if (row.hlc !== null) message.hlc = row.hlc;
+		return message;
+	}
+	getMessage(id) {
+		const row = queryOne(this.db, "SELECT * FROM messages WHERE id = ?", [id]);
+		return row === void 0 ? null : this.toMessage(row);
+	}
+	byIdemKey(from, key) {
+		const row = queryOne(this.db, "SELECT * FROM messages WHERE from_addr = ? AND idem_key = ?", [from, key]);
+		return row === void 0 ? null : this.toMessage(row);
+	}
+	idemKeysFor(messageIds) {
+		const out = /* @__PURE__ */ new Map();
+		for (let i = 0; i < messageIds.length; i += 500) {
+			const chunk = messageIds.slice(i, i + 500);
+			const rows = queryAll(this.db, `SELECT id, idem_key FROM messages WHERE idem_key IS NOT NULL AND id IN (${chunk.map(() => "?").join(",")})`, chunk);
+			for (const r of rows) out.set(r.id, r.idem_key);
+		}
+		return out;
+	}
+	messagesFrom(address, sinceIso, kinds) {
+		const byKind = kinds === void 0 ? "" : ` AND kind IN (${kinds.map(() => "?").join(",")})`;
+		return queryAll(this.db, `SELECT * FROM messages WHERE from_addr = ? AND created_at >= ?${byKind} ORDER BY id`, [
+			address,
+			sinceIso,
+			...kinds ?? []
+		]).map((r) => this.toMessage(r));
+	}
+	thread(threadId) {
+		return queryAll(this.db, "SELECT * FROM messages WHERE thread = ? ORDER BY (hlc IS NOT NULL), hlc, id", [threadId]).map((r) => this.toMessage(r));
+	}
+	answersTo(messageId) {
+		return queryAll(this.db, "SELECT * FROM messages WHERE reply_to = ? AND kind = 'answer' ORDER BY id", [messageId]).map((r) => this.toMessage(r));
+	}
+	openBlocking() {
+		return queryAll(this.db, "SELECT m.* FROM messages m WHERE m.blocking = 1 AND NOT EXISTS (SELECT 1 FROM messages a WHERE a.reply_to = m.id AND a.kind = 'answer') ORDER BY m.id").map((r) => this.toMessage(r));
+	}
+	insertDelivery(d) {
+		this.db.prepare("INSERT INTO deliveries (id, message_id, recipient, run_id, via, state, updated_at) VALUES (?,?,?,?,?,?,?)").run(d.id, d.messageId, d.recipient, d.runId, d.via, d.state, d.updatedAt);
+	}
+	deleteDelivery(id) {
+		return Number(this.db.prepare("DELETE FROM deliveries WHERE id = ?").run(id).changes) > 0;
+	}
+	toDelivery(r) {
+		return {
+			id: r.id,
+			messageId: r.message_id,
+			recipient: r.recipient,
+			runId: r.run_id,
+			via: oneOf(r.via, ["direct", "channel"], "via"),
+			state: oneOf(r.state, DELIVERY_STATES, "state"),
+			updatedAt: r.updated_at
+		};
+	}
+	getDelivery(id) {
+		const row = queryOne(this.db, "SELECT * FROM deliveries WHERE id = ?", [id]);
+		return row === void 0 ? null : this.toDelivery(row);
+	}
+	deliveries(filter) {
+		const where = [];
+		const params = [];
+		if (filter.recipient !== void 0) {
+			where.push("recipient = ?");
+			params.push(filter.recipient);
+		}
+		if (filter.runId !== void 0) {
+			where.push("run_id = ?");
+			params.push(filter.runId);
+		}
+		if (filter.recipientPrefix !== void 0) {
+			where.push("recipient LIKE ? ESCAPE '\\'");
+			params.push(`${filter.recipientPrefix.replace(/[\\%_]/g, "\\$&")}%`);
+		}
+		if (filter.messageId !== void 0) {
+			where.push("message_id = ?");
+			params.push(filter.messageId);
+		}
+		if (filter.states !== void 0) {
+			const placeholders = filter.states.map(() => "?").join(",");
+			where.push(`state IN (${placeholders.length > 0 ? placeholders : "''"})`);
+			params.push(...filter.states);
+		}
+		const sql = `SELECT * FROM deliveries${where.length > 0 ? ` WHERE ${where.join(" AND ")}` : ""} ORDER BY id`;
+		return queryAll(this.db, sql, params).map((r) => this.toDelivery(r));
+	}
+	setDelivery(id, state, runId, at, expected) {
+		const result = expected === void 0 ? this.db.prepare("UPDATE deliveries SET state = ?, run_id = ?, updated_at = ? WHERE id = ?").run(state, runId, at, id) : this.db.prepare("UPDATE deliveries SET state = ?, run_id = ?, updated_at = ? WHERE id = ? AND state = ?").run(state, runId, at, id, expected);
+		return Number(result.changes) > 0;
+	}
+	markGateApplied(questionId, at) {
+		this.db.prepare("INSERT INTO gate_effects (question_id, applied_at) VALUES (?,?) ON CONFLICT (question_id) DO NOTHING").run(questionId, at);
+	}
+	voidAnswer(answerId, questionId, at) {
+		return this.transaction(() => {
+			const changed = this.db.prepare("UPDATE messages SET kind = 'message' WHERE id = ? AND reply_to = ? AND kind = 'answer'").run(answerId, questionId);
+			if (Number(changed.changes) === 0) return false;
+			this.db.prepare("INSERT INTO voided_answers (answer_id, question_id, at) VALUES (?,?,?) ON CONFLICT (answer_id) DO NOTHING").run(answerId, questionId, at);
+			return true;
+		});
+	}
+	unappliedAnsweredGates() {
+		return queryAll(this.db, `SELECT q.id AS question_id, a.id AS answer_id FROM messages q
+       JOIN messages a ON a.reply_to = q.id AND a.kind = 'answer'
+       WHERE q.data_json LIKE '%"type":%'
+       AND NOT EXISTS (SELECT 1 FROM gate_effects g WHERE g.question_id = q.id)
+       ORDER BY q.id`).flatMap((r) => {
+			const question = this.getMessage(r.question_id);
+			const answer = this.getMessage(r.answer_id);
+			if (question === null || answer === null || !hasGateData(question)) return [];
+			return isSystemMarker(answer, "x-closed") ? [] : [{
+				question,
+				answer
+			}];
+		});
+	}
+	countFrom(from, sinceIso, urgentOnly, origin, untilIso) {
+		const row = queryOne(this.db, `SELECT COUNT(*) AS n FROM messages WHERE from_addr = ? AND COALESCE(received_at, created_at) >= ? AND COALESCE(received_at, created_at) <= ?${urgentOnly ? " AND urgent = 1" : ""}${origin === void 0 ? "" : " AND origin = ?"}`, origin === void 0 ? [
+			from,
+			sinceIso,
+			untilIso ?? "9999"
+		] : [
+			from,
+			sinceIso,
+			untilIso ?? "9999",
+			origin
+		]);
+		return row === void 0 ? 0 : Number(row.n);
+	}
+	countDeliveredTo(recipient, sinceIso, untilIso) {
+		const row = queryOne(this.db, "SELECT COUNT(DISTINCT m.id) AS n FROM deliveries d JOIN messages m ON m.id = d.message_id WHERE d.recipient = ? AND m.created_at >= ? AND m.created_at <= ?", [
+			recipient,
+			sinceIso,
+			untilIso ?? "9999"
+		]);
+		return row === void 0 ? 0 : Number(row.n);
+	}
+	countAgentThreadsFrom(from, sinceIso) {
+		const row = queryOne(this.db, "SELECT COUNT(*) AS n FROM messages m WHERE m.from_addr = ? AND m.thread = m.id AND COALESCE(m.received_at, m.created_at) >= ? AND EXISTS (SELECT 1 FROM recipients r WHERE r.message_id = m.id AND (r.addr LIKE 'agent:%' OR r.addr LIKE 'run:%' OR r.addr LIKE 'task:%')) AND NOT EXISTS (SELECT 1 FROM recipients r WHERE r.message_id = m.id AND r.addr LIKE 'human:%') AND NOT EXISTS (SELECT 1 FROM deliveries d WHERE d.message_id = m.id AND d.recipient LIKE 'human:%')", [from, sinceIso]);
+		return row === void 0 ? 0 : Number(row.n);
+	}
+	countAgentAuthored(threadId, sinceIso, exclude) {
+		const row = queryOne(this.db, "SELECT COUNT(*) AS n FROM messages WHERE thread = ? AND COALESCE(received_at, created_at) >= ? AND (from_addr != ? OR origin IS NOT NULL) AND (from_addr LIKE 'run:%' OR from_addr LIKE 'agent:%' OR from_addr LIKE 'a2a:%')", [
+			threadId,
+			sinceIso,
+			exclude
+		]);
+		return row === void 0 ? 0 : Number(row.n);
+	}
+	settledAs(messageId) {
+		const row = queryOne(this.db, "SELECT settled_as FROM messages WHERE id = ?", [messageId]);
+		return row === void 0 || row.settled_as === null ? null : oneOf(row.settled_as, SETTLED_AS, "settled_as");
+	}
+	setSettled(messageId, kind, settledAs) {
+		this.db.prepare("UPDATE messages SET kind = ?, settled_as = ? WHERE id = ?").run(kind, settledAs, messageId);
+	}
+	answerCandidates(questionId) {
+		return queryAll(this.db, "SELECT * FROM messages WHERE reply_to = ? AND (kind = 'answer' OR settled_as IS NOT NULL) ORDER BY rowid", [questionId]).map((r) => ({
+			message: this.toMessage(r),
+			settledAs: r.settled_as === null ? null : oneOf(r.settled_as, SETTLED_AS, "settled_as")
+		}));
+	}
+	insertRemote(row) {
+		const result = this.db.prepare("INSERT INTO remote_deliveries (message_id, recipient, via, state, homes_json, wake_at, refused_by, updated_at) VALUES (?,?,?,?,?,?,?,?) ON CONFLICT (message_id, recipient) DO NOTHING").run(row.messageId, row.recipient, row.via, row.state, JSON.stringify(row.homes), row.wakeAt, JSON.stringify(row.refusedBy), row.updatedAt);
+		return Number(result.changes) > 0;
+	}
+	toRemote(r) {
+		return {
+			messageId: r.message_id,
+			recipient: r.recipient,
+			via: oneOf(r.via, ["direct", "channel"], "via"),
+			state: oneOf(r.state, REMOTE_STATES, "remote state"),
+			homes: JSON.parse(r.homes_json),
+			wakeAt: r.wake_at,
+			refusedBy: r.refused_by === null ? [] : JSON.parse(r.refused_by),
+			updatedAt: r.updated_at
+		};
+	}
+	remoteDeliveries(filter) {
+		const where = [];
+		const params = [];
+		if (filter.messageId !== void 0) {
+			where.push("message_id = ?");
+			params.push(filter.messageId);
+		}
+		if (filter.recipient !== void 0) {
+			where.push("recipient = ?");
+			params.push(filter.recipient);
+		}
+		if (filter.states !== void 0) {
+			const placeholders = filter.states.map(() => "?").join(",");
+			where.push(`state IN (${placeholders.length > 0 ? placeholders : "''"})`);
+			params.push(...filter.states);
+		}
+		const sql = `SELECT * FROM remote_deliveries${where.length > 0 ? ` WHERE ${where.join(" AND ")}` : ""} ORDER BY message_id, recipient`;
+		return queryAll(this.db, sql, params).map((r) => this.toRemote(r));
+	}
+	setRemote(messageId, recipient, patch, at, expected) {
+		const sets = ["updated_at = ?"];
+		const params = [at];
+		if (patch.state !== void 0) {
+			sets.push("state = ?");
+			params.push(patch.state);
+		}
+		if (patch.refusedBy !== void 0) {
+			sets.push("refused_by = ?");
+			params.push(JSON.stringify(patch.refusedBy));
+		}
+		if (patch.homes !== void 0) {
+			sets.push("homes_json = ?");
+			params.push(JSON.stringify(patch.homes));
+		}
+		params.push(messageId, recipient);
+		if (expected !== void 0) params.push(expected);
+		const result = this.db.prepare(`UPDATE remote_deliveries SET ${sets.join(", ")} WHERE message_id = ? AND recipient = ?${expected === void 0 ? "" : " AND state = ?"}`).run(...params);
+		return Number(result.changes) > 0;
+	}
+	deleteRemote(messageId, recipient) {
+		return Number(this.db.prepare("DELETE FROM remote_deliveries WHERE message_id = ? AND recipient = ?").run(messageId, recipient).changes) > 0;
+	}
+	settlement(questionId) {
+		const row = queryOne(this.db, "SELECT * FROM settlements WHERE question_id = ?", [questionId]);
+		return row === void 0 ? null : toSettlement(row);
+	}
+	putSettlement(s) {
+		this.db.prepare(`INSERT INTO settlements (question_id, answer_id, closed_reason, settler, at) VALUES (?,?,?,?,?)
+      ON CONFLICT (question_id) DO UPDATE SET answer_id = excluded.answer_id, closed_reason = excluded.closed_reason,
+      settler = excluded.settler, at = excluded.at`).run(s.questionId, s.answerId, s.closedReason, s.settler, s.at);
+	}
+	putEarlySettlement(s) {
+		this.db.prepare(`INSERT INTO early_settlements (question_id, settler, answer_id, closed_reason, at) VALUES (?,?,?,?,?)
+      ON CONFLICT (question_id, settler) DO UPDATE SET answer_id = excluded.answer_id,
+      closed_reason = excluded.closed_reason, at = excluded.at`).run(s.questionId, s.settler, s.answerId, s.closedReason, s.at);
+	}
+	earlySettlements(questionId) {
+		return queryAll(this.db, "SELECT * FROM early_settlements WHERE question_id = ? ORDER BY at, settler", [questionId]).map(toSettlement);
+	}
+	clearEarlySettlements(questionId) {
+		this.db.prepare("DELETE FROM early_settlements WHERE question_id = ?").run(questionId);
+	}
+	messagesAfter(rowid, limit) {
+		return queryAll(this.db, "SELECT rowid AS rid, * FROM messages WHERE rowid > ? AND origin IS NULL ORDER BY rowid LIMIT ?", [rowid, limit]).map((r) => ({
+			rowid: Number(r.rid),
+			message: this.toMessage(r)
+		}));
+	}
+	maxRowid() {
+		const row = queryOne(this.db, "SELECT MAX(rowid) AS n FROM messages");
+		return row === void 0 || row.n === null ? 0 : Number(row.n);
+	}
+	ensureChannel(name, at, auto) {
+		this.db.prepare("INSERT INTO channels (name, created_at, auto) VALUES (?,?,?) ON CONFLICT (name) DO NOTHING").run(name, at, auto ? 1 : 0);
+	}
+	channels() {
+		return queryAll(this.db, "SELECT * FROM channels ORDER BY name").map((r) => ({
+			name: r.name,
+			createdAt: r.created_at,
+			auto: r.auto === 1
+		}));
+	}
+	addMember(channel, member, at) {
+		return Number(this.db.prepare("INSERT INTO members (channel, addr, joined_at) VALUES (?,?,?) ON CONFLICT (channel, addr) DO NOTHING").run(channel, member, at).changes) > 0;
+	}
+	removeMember(channel, member) {
+		return Number(this.db.prepare("DELETE FROM members WHERE channel = ? AND addr = ?").run(channel, member).changes) > 0;
+	}
+	members(channel) {
+		return queryAll(this.db, "SELECT addr FROM members WHERE channel = ? ORDER BY addr", [channel]).map((r) => r.addr);
+	}
+	channelsOf(member) {
+		return queryAll(this.db, "SELECT channel FROM members WHERE addr = ? ORDER BY channel", [member]).map((r) => r.channel);
+	}
+	putAgent(a) {
+		this.db.prepare(`INSERT INTO agents (addr, display_name, client, token_hash, status, muted, approved_by, created_at) VALUES (?,?,?,?,?,?,?,?)
+      ON CONFLICT (addr) DO UPDATE SET display_name = excluded.display_name, client = excluded.client, token_hash = excluded.token_hash,
+      status = excluded.status, muted = excluded.muted, approved_by = excluded.approved_by`).run(a.address, a.displayName, a.client, a.tokenHash, a.status, a.muted ? 1 : 0, a.approvedBy, a.createdAt);
+	}
+	toAgent(r) {
+		return {
+			address: r.addr,
+			displayName: r.display_name,
+			client: r.client,
+			tokenHash: r.token_hash,
+			status: oneOf(r.status, [
+				"pending",
+				"approved",
+				"revoked"
+			], "agent status"),
+			muted: r.muted === 1,
+			approvedBy: r.approved_by,
+			createdAt: r.created_at
+		};
+	}
+	getAgent(address) {
+		const row = queryOne(this.db, "SELECT * FROM agents WHERE addr = ?", [address]);
+		return row === void 0 ? null : this.toAgent(row);
+	}
+	agentByTokenHash(hash) {
+		const row = queryOne(this.db, "SELECT * FROM agents WHERE token_hash = ?", [hash]);
+		return row === void 0 ? null : this.toAgent(row);
+	}
+	agents() {
+		return queryAll(this.db, "SELECT * FROM agents ORDER BY addr").map((r) => this.toAgent(r));
+	}
+	recentThreads(limit, about) {
+		if (about !== void 0 && about.length === 0) return [];
+		const params = [];
+		let where = "";
+		if (about !== void 0) {
+			const clause = threadsAbout(about);
+			where = `WHERE thread IN (${clause.sql})`;
+			params.push(...clause.params);
+		}
+		params.push(limit);
+		return queryAll(this.db, `SELECT thread, MAX(rowid) AS last_rowid, COUNT(*) AS count
+       FROM messages ${where} GROUP BY thread ORDER BY last_rowid DESC LIMIT ?`, params).flatMap((r) => {
+			const root = this.getMessage(r.thread) ?? this.firstStored(r.thread);
+			const last = this.byRowid(Number(r.last_rowid));
+			return root === null || last === null ? [] : [{
+				thread: r.thread,
+				root,
+				last,
+				count: Number(r.count)
+			}];
+		});
+	}
+	/** Messages a conversation read matches, newest (highest id) first. */
+	conversation(match, page) {
+		const where = [];
+		const params = [];
+		if (match.kind === "pair") {
+			const party = "(m.from_addr = ? OR EXISTS (SELECT 1 FROM recipients r WHERE r.message_id = m.id AND r.addr = ?))";
+			where.push(`${party} AND ${party}`);
+			params.push(match.a, match.a, match.b, match.b);
+		} else if (match.kind === "about") {
+			if (match.addresses.length === 0) return [];
+			const clause = threadsAbout(match.addresses);
+			where.push(`m.thread IN (${clause.sql})`);
+			params.push(...clause.params);
+		} else {
+			where.push(`m.thread IN (SELECT t.thread FROM message_refs x
+        JOIN messages t ON t.id = x.message_id WHERE x.type = ? AND x.ref_id = ?)`);
+			params.push(match.type, match.id);
+		}
+		if (page.before !== void 0) {
+			where.push("m.id < ?");
+			params.push(page.before);
+		}
+		if (page.rootsOnly === true) where.push("m.id = m.thread");
+		params.push(page.limit ?? 50);
+		return queryAll(this.db, `SELECT m.* FROM messages m WHERE ${where.join(" AND ")} ORDER BY m.id DESC LIMIT ?`, params).map((r) => this.toMessage(r));
+	}
+	firstStored(threadId) {
+		const row = queryOne(this.db, "SELECT * FROM messages WHERE thread = ? ORDER BY rowid LIMIT 1", [threadId]);
+		return row === void 0 ? null : this.toMessage(row);
+	}
+	byRowid(rowid) {
+		const row = queryOne(this.db, "SELECT * FROM messages WHERE rowid = ?", [rowid]);
+		return row === void 0 ? null : this.toMessage(row);
+	}
+};
+function threadsAbout(about) {
+	const marks = about.map(() => "?").join(", ");
+	const runIds = about.filter((a) => a.startsWith("run:")).map((a) => a.slice(4));
+	return {
+		sql: `SELECT thread FROM messages WHERE from_addr IN (${marks})
+        UNION SELECT m.thread FROM messages m JOIN recipients r ON r.message_id = m.id WHERE r.addr IN (${marks})
+        UNION SELECT m.thread FROM messages m JOIN deliveries d ON d.message_id = m.id
+          WHERE d.recipient IN (${marks})${runIds.length === 0 ? "" : ` OR d.run_id IN (${runIds.map(() => "?").join(", ")})`}`,
+		params: [
+			...about,
+			...about,
+			...about,
+			...runIds
+		]
+	};
+}
+function toSettlement(r) {
+	return {
+		questionId: r.question_id,
+		answerId: r.answer_id,
+		closedReason: r.closed_reason,
+		settler: r.settler,
+		at: r.at
+	};
+}
+
+//#endregion
+//#region src/version.ts
+const PROTOCOL_VERSION = "1.0.0-draft.2";
+
+//#endregion
+export { parseAddress as C, isPeerAddress as S, isSystemMarker as _, REMOTE_STATES as a, PEER_ALIAS_PATTERN as b, createUlidFactory as c, LOCAL_ONLY_MARKERS as d, isFederationLocalAddress as f, gateOf as g, checkIdempotencyKey as h, openMessagesDb as i, renderDigestLine as l, MEMORY_GATE_KINDS as m, MESSAGES_DB_VERSION as n, DEFAULT_LIMITS as o, localOnlyReason as p, SqliteMessageStore as r, DeliveryEngine as s, PROTOCOL_VERSION as t, renderForAgent as u, validateSendInput as v, MessagingError as w, isAgentAuthored as x, LINE_BREAK as y };
+//# sourceMappingURL=version-Ds8ZFZLh.js.map