@alfe.ai/openclaw-email 0.0.0-stage → 0.1.0

package/dist/plugin2.cjs

@@ -0,0 +1,1795 @@
+let node_module = require("node:module");
+let _alfe_ai_agent_api_client = require("@alfe.ai/agent-api-client");
+let _alfe_ai_config = require("@alfe.ai/config");
+let _alfe_ai_email = require("@alfe.ai/email");
+let _alfe_ai_openclaw_plugin_kit = require("@alfe.ai/openclaw-plugin-kit");
+let node_crypto = require("node:crypto");
+let _auriclabs_roles = require("@auriclabs/roles");
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+//#region src/hash.ts
+/**
+* Session and target identifiers derived from mailbox and thread ids.
+*
+* OpenClaw lowercases peer ids, and Graph conversation ids are
+* case-sensitive, so ids are hashed to lowercase hex rather than embedded.
+*/
+function shortHash(value) {
+	return (0, node_crypto.createHash)("sha256").update(value, "utf8").digest("hex").slice(0, 16);
+}
+/** Mailbox addresses are case-insensitive. */
+function mailboxHash(address) {
+	return shortHash(address.trim().toLowerCase());
+}
+/** Provider thread ids are case-sensitive. */
+function threadHash(threadId) {
+	return shortHash(threadId);
+}
+/** One OpenClaw session per email thread (`session.dmScope: per-channel-peer`). */
+function peerIdFor(mailboxAddress, threadId) {
+	return `email:${mailboxHash(mailboxAddress)}:${threadHash(threadId)}`;
+}
+/** Outbound target for a thread. `sendText` gets no session, so the thread rides in `to`. */
+function threadTarget(hash) {
+	return `thread:${hash}`;
+}
+const THREAD_TARGET = /^thread:([0-9a-f]{16})$/;
+function parseThreadTarget(to) {
+	return THREAD_TARGET.exec(to?.trim() ?? "")?.[1] ?? null;
+}
+/** `a***@example.com`: enough to correlate logs without logging the address. */
+function maskAddress(address) {
+	const at = address.lastIndexOf("@");
+	if (at <= 0) return "***";
+	return `${address.slice(0, 1)}***${address.slice(at)}`;
+}
+//#endregion
+//#region src/channel.ts
+/**
+* The registered OpenClaw `email` channel.
+*
+* Turn replies go through dispatch's `deliver` callback; this channel carries
+* sends made OUTSIDE a turn (the `message` tool, cron, follow-ups). 9.5's
+* outbound `sendText` context has no session or peer, so the thread is
+* encoded in the target: `thread:<threadHash>`, the same value dispatch sets
+* as the session's `OriginatingTo`.
+*/
+const CHANNEL_ID = "email";
+const ACCOUNT_ID$1 = "default";
+function createEmailChannelPlugin(getHandle) {
+	return {
+		id: CHANNEL_ID,
+		meta: {
+			id: CHANNEL_ID,
+			label: "Email",
+			selectionLabel: "Email (Gmail & Outlook)",
+			detailLabel: "Email",
+			docsPath: "/channels/email",
+			docsLabel: "email",
+			blurb: "Email threads in the agent's connected Gmail or Outlook mailbox.",
+			systemImage: "envelope",
+			order: 110,
+			forceAccountBinding: false,
+			showConfigured: true
+		},
+		capabilities: {
+			chatTypes: ["direct"],
+			reactions: false,
+			edit: false,
+			unsend: false,
+			reply: true,
+			effects: false,
+			groupManagement: false,
+			threads: false,
+			media: false,
+			nativeCommands: false,
+			polls: false
+		},
+		config: {
+			listAccountIds() {
+				return [ACCOUNT_ID$1];
+			},
+			resolveAccount(_cfg, accountId) {
+				return {
+					accountId: accountId ?? ACCOUNT_ID$1,
+					enabled: true
+				};
+			},
+			defaultAccountId() {
+				return ACCOUNT_ID$1;
+			},
+			isEnabled() {
+				return true;
+			},
+			isConfigured() {
+				return getHandle() !== null;
+			},
+			describeAccount(account) {
+				const status = getHandle()?.status();
+				return {
+					accountId: account.accountId,
+					enabled: true,
+					configured: status !== void 0,
+					running: status?.state === "ok",
+					statusState: status?.state ?? "stopped",
+					...status?.reason ? { stateReason: status.reason } : {},
+					lastError: status?.state === "error" ? status.message ?? null : null,
+					lastMessageAt: status?.lastMessageAt ?? null
+				};
+			}
+		},
+		outbound: {
+			deliveryMode: "direct",
+			textChunkLimit: 1e5,
+			resolveTarget(params) {
+				const hash = parseThreadTarget(params.to);
+				if (!hash) return {
+					ok: false,
+					error: /* @__PURE__ */ new Error("Invalid email target: use thread:<threadHash>")
+				};
+				const handle = getHandle();
+				if (handle && !handle.hasThread(hash)) return {
+					ok: false,
+					error: /* @__PURE__ */ new Error("Unknown email thread for this mailbox")
+				};
+				return {
+					ok: true,
+					to: `thread:${hash}`
+				};
+			},
+			async sendText(ctx) {
+				const handle = getHandle();
+				if (!handle) throw new Error("Email channel is not running; outbound email is disabled");
+				const outcome = await handle.sendToThread(ctx.to, ctx.text);
+				if (outcome.kind !== "sent") throw new Error(`Email not sent (${outcome.kind})`);
+				return {
+					channel: CHANNEL_ID,
+					messageId: outcome.messageId,
+					target: {
+						kind: "conversation",
+						id: ctx.to
+					},
+					timestamp: Date.now()
+				};
+			}
+		}
+	};
+}
+//#endregion
+//#region src/credentials.ts
+/**
+* - `reconnect`: the Connection cannot serve this mailbox until the user
+*   reconnects it.
+* - `agent-auth`: the Agent API rejected THIS AGENT's own token (401). That is
+*   an agent credential problem, not a mailbox one; reconnecting the mailbox
+*   would not fix it.
+*/
+var CredentialError = class extends Error {
+	constructor(message, reason = "reconnect") {
+		super(message);
+		this.reason = reason;
+		this.name = "CredentialError";
+	}
+};
+/** Treat a token as expired this long before its stated expiry. */
+const EXPIRY_SKEW_MS = 6e4;
+/** Agent API statuses that mean "this Connection is unusable", not "try again". */
+const RECONNECT_STATUSES = new Set([
+	400,
+	403,
+	404
+]);
+var ConnectionCredentials = class {
+	described = null;
+	storedToken = null;
+	inflight = null;
+	refreshConflicts = 0;
+	constructor(client, connectionId, now = Date.now) {
+		this.client = client;
+		this.connectionId = connectionId;
+		this.now = now;
+	}
+	/** Fetch the Connection once to learn its provider and mailbox. */
+	async describe() {
+		if (this.described) return this.described;
+		const creds = await this.call(() => this.client.getConnectionCredentials(this.connectionId));
+		if (creds.provider !== "google" && creds.provider !== "microsoft") throw new CredentialError("The email channel's Connection is not a Google or Microsoft mailbox");
+		if (typeof creds.accountIdentifier !== "string" || !creds.accountIdentifier.includes("@")) throw new CredentialError("The email channel's Connection has no mailbox address");
+		this.described = {
+			provider: creds.provider,
+			accountIdentifier: creds.accountIdentifier
+		};
+		const expiresAt = parseExpiry(creds.accessTokenExpiresAt);
+		if (typeof creds.accessToken === "string" && creds.accessToken !== "" && expiresAt > this.now() + EXPIRY_SKEW_MS) this.storedToken = {
+			token: creds.accessToken,
+			expiresAt
+		};
+		return this.described;
+	}
+	/** The driver's {@link AccessTokenProvider}. */
+	getAccessToken = () => {
+		this.inflight ??= this.nextToken().finally(() => {
+			this.inflight = null;
+		});
+		return this.inflight;
+	};
+	async nextToken() {
+		const { provider, accountIdentifier } = await this.describe();
+		const stored = this.storedToken;
+		this.storedToken = null;
+		if (stored && stored.expiresAt > this.now() + EXPIRY_SKEW_MS) return stored.token;
+		let refreshed;
+		try {
+			refreshed = await this.call(() => provider === "microsoft" ? this.client.refreshMicrosoftAccountToken(accountIdentifier, { connectionId: this.connectionId }) : this.client.refreshSocialAccount("google", accountIdentifier, { connectionId: this.connectionId }));
+		} catch (err) {
+			if (err?.status !== 409) {
+				this.refreshConflicts = 0;
+				throw err;
+			}
+			this.refreshConflicts += 1;
+			if (this.refreshConflicts >= 3) throw new CredentialError(`Connect refused ${String(this.refreshConflicts)} refreshes in a row because this mailbox no longer resolves to the channel's Connection`);
+			throw err;
+		}
+		this.refreshConflicts = 0;
+		if (typeof refreshed.accessToken !== "string" || refreshed.accessToken === "") throw new CredentialError("Connect returned no access token for the mailbox");
+		return refreshed.accessToken;
+	}
+	async call(fn) {
+		try {
+			return await fn();
+		} catch (err) {
+			const status = err?.status;
+			if (status === 401) throw new CredentialError("The Agent API rejected this agent's token", "agent-auth");
+			if (typeof status === "number" && RECONNECT_STATUSES.has(status)) throw new CredentialError(`Connect rejected the mailbox Connection (${String(status)})`);
+			throw err;
+		}
+	}
+};
+function parseExpiry(value) {
+	if (typeof value !== "string" || value === "") return 0;
+	const ms = Date.parse(value);
+	return Number.isFinite(ms) ? ms : 0;
+}
+//#endregion
+//#region src/errors.ts
+/**
+* Errors only the user can fix by reconnecting the mailbox: revoked consent,
+* a token without a needed scope (an Outlook grant from before Mail.Send), or
+* a Connection Connect will no longer serve.
+*/
+function isReconnectError(err) {
+	return err instanceof _alfe_ai_email.MailboxAuthError || err instanceof _alfe_ai_email.MailboxScopeError || err instanceof CredentialError && err.reason === "reconnect";
+}
+/** The Agent API rejected this agent's own token: not fixable by reconnecting the mailbox. */
+function isAgentAuthError(err) {
+	return err instanceof CredentialError && err.reason === "agent-auth";
+}
+function reconnectMessage(err) {
+	if (err instanceof _alfe_ai_email.MailboxScopeError) return "The mailbox connection is missing a permission email needs (for Outlook, Mail.Send); reconnect the account";
+	if (err instanceof _alfe_ai_email.MailboxAuthError) return "The mailbox rejected its credentials; reconnect the account";
+	return `${err instanceof Error ? err.message : String(err)}; reconnect the account`;
+}
+//#endregion
+//#region src/host-version.ts
+/**
+* Tolerant OpenClaw host-version gate (copy of
+* `@alfe.ai/openclaw-identity/src/host-version.ts`; kept local so the plugins
+* do not depend on each other).
+*
+* `api.runtime.version` is the host's VERSION string; `OPENCLAW_BUNDLED_VERSION`
+* can override it. Accept a bare `YYYY.M.P`, a branded `OpenClaw 2026.9.5 (sha)`
+* line, or a pre-release / build suffix (`2026.9.5-beta.1` counts as its base
+* release). Anything unparseable is "unknown" and the caller refuses to start.
+*/
+const VERSION_TOKEN = /(?:^|[^\d.])(\d{4})\.(\d+)\.(\d+)(?=$|[^\d.]|\.[^\d])/u;
+function parseHostVersion(value) {
+	if (typeof value !== "string") return void 0;
+	const match = VERSION_TOKEN.exec(value.trim());
+	if (!match) return void 0;
+	return [
+		Number(match[1]),
+		Number(match[2]),
+		Number(match[3])
+	];
+}
+/** True only when `version` parses and is at least `minimum`. */
+function isHostAtLeast(version, minimum) {
+	const have = parseHostVersion(version);
+	const want = parseHostVersion(minimum);
+	if (!have || !want) return false;
+	for (let i = 0; i < 3; i++) if (have[i] !== want[i]) return (have[i] ?? 0) > (want[i] ?? 0);
+	return true;
+}
+/**
+* The tool gate in `@alfe.ai/openclaw-identity` needs 9.5's per-sender hook
+* context (`before_tool_call` `ctx.requester`). Mirrors
+* `package.json#openclaw.install.minHostVersion`.
+*/
+const MIN_HOST_VERSION = "2026.9.5";
+//#endregion
+//#region src/admission.ts
+/**
+* Sender admission: may this sender instruct this agent over email?
+*
+* Same evaluation as `@alfe.ai/openclaw-identity`'s `agent-exec-gate.ts`
+* (copied, not imported, so the plugins stay independent): one
+* `createAbility(raw permission strings).has(...)` call against the scoped
+* `agent:<agentId>` gate, so `cannot` (`!agent:chat`) entries are honoured.
+*/
+function allowsAgentChat(permissions, agentId) {
+	if (!agentId) return false;
+	const ability = (0, _auriclabs_roles.createAbility)(permissions);
+	const gatePermission = {
+		subject: "agent",
+		action: "chat",
+		scope: `agent:${agentId}`
+	};
+	return ability.has(gatePermission);
+}
+//#endregion
+//#region src/state.ts
+/**
+* Per-mailbox poller state: `<stateDir>/email/<mailboxHash>.json`.
+*
+* One file holds the sync cursor, the dedupe LRU, the replied set, the thread
+* map out-of-turn sends resolve against, loop-cap counters, the resolve retry
+* queue and the admitted-but-unfinished turns. Writes are atomic (owner-only
+* temp file, then rename) and serialised. A missing, unreadable or invalid
+* file starts fresh, which reseeds the cursor, so history is never replayed.
+*/
+const LIMITS = {
+	seen: 500,
+	replied: 500,
+	threads: 500,
+	retry: 100,
+	pending: 100
+};
+/** Bounds on what a thread record keeps from attacker-controlled headers. */
+const PARENT_LIMITS = {
+	addresses: 50,
+	references: 20,
+	subject: 998,
+	address: 320,
+	name: 256,
+	id: 998
+};
+const HOUR_MS = 60 * 6e4;
+function stateFilePath(stateDir, mailbox) {
+	return (0, node_path.join)(stateDir, "email", `${mailboxHash(mailbox)}.json`);
+}
+function freshState(mailbox) {
+	return {
+		version: 1,
+		mailbox,
+		cursor: null,
+		seen: [],
+		replied: [],
+		threads: {},
+		replies: {},
+		retry: [],
+		pending: [],
+		lastMessageAt: 0
+	};
+}
+var StateStore = class {
+	data;
+	writeChain = Promise.resolve();
+	constructor(file, mailbox, log) {
+		this.file = file;
+		this.mailbox = mailbox;
+		this.log = log;
+		this.data = freshState(mailbox);
+	}
+	async load() {
+		try {
+			const parsed = JSON.parse(await (0, node_fs_promises.readFile)(this.file, "utf8"));
+			if (!isMailboxState(parsed)) throw new Error("invalid state shape");
+			if (parsed.mailbox !== this.mailbox) throw new Error("state belongs to another mailbox");
+			this.data = parsed;
+		} catch (err) {
+			if (!isMissingFile(err)) this.log.warn(`Ignoring unreadable email state; the mailbox will be reseeded (${errorMessage$1(err)})`);
+			this.data = freshState(this.mailbox);
+		}
+	}
+	/** Atomic, serialised write of the current state. */
+	save() {
+		const contents = JSON.stringify(this.data);
+		const next = this.writeChain.then(async () => {
+			const temporary = `${this.file}.${String(process.pid)}.${(0, node_crypto.randomUUID)()}.tmp`;
+			try {
+				await (0, node_fs_promises.mkdir)((0, node_path.dirname)(this.file), {
+					recursive: true,
+					mode: 448
+				});
+				await (0, node_fs_promises.writeFile)(temporary, contents, { mode: 384 });
+				await (0, node_fs_promises.rename)(temporary, this.file);
+			} catch (err) {
+				await (0, node_fs_promises.rm)(temporary, { force: true }).catch(() => void 0);
+				throw err;
+			}
+		});
+		this.writeChain = next.catch(() => void 0);
+		return next;
+	}
+	get cursor() {
+		return this.data.cursor;
+	}
+	set cursor(value) {
+		this.data.cursor = value;
+	}
+	get lastMessageAt() {
+		return this.data.lastMessageAt;
+	}
+	set lastMessageAt(value) {
+		this.data.lastMessageAt = value;
+	}
+	hasSeenId(id) {
+		return this.data.seen.some((entry) => entry.id === id);
+	}
+	hasSeenMessageId(mid) {
+		return mid !== "" && this.data.seen.some((entry) => entry.mid === mid);
+	}
+	markSeen(id, mid) {
+		this.data.seen = this.data.seen.filter((entry) => entry.id !== id);
+		this.data.seen.push({
+			id,
+			mid
+		});
+		this.trim(this.data.seen, LIMITS.seen, "dedupe");
+	}
+	isReplied(mid) {
+		return this.data.replied.includes(mid);
+	}
+	markReplied(mid) {
+		if (this.data.replied.includes(mid)) return;
+		this.data.replied.push(mid);
+		this.trim(this.data.replied, LIMITS.replied, "replied");
+	}
+	/** Undo {@link markReplied} for a reply that was definitely not sent. */
+	unmarkReplied(mid) {
+		this.data.replied = this.data.replied.filter((entry) => entry !== mid);
+	}
+	/** Undo {@link recordReply} for a reply that was definitely not sent. */
+	forgetReply(hash, at) {
+		if (!Object.hasOwn(this.data.replies, hash)) return;
+		const times = this.data.replies[hash] ?? [];
+		const index = times.lastIndexOf(at);
+		if (index !== -1) times.splice(index, 1);
+	}
+	repliesInLastHour(hash, now) {
+		return (this.data.replies[hash] ?? []).filter((at) => now - at < HOUR_MS).length;
+	}
+	recordReply(hash, now) {
+		const recent = (this.data.replies[hash] ?? []).filter((at) => now - at < HOUR_MS);
+		recent.push(now);
+		this.data.replies[hash] = recent;
+		for (const [key, times] of Object.entries(this.data.replies)) if (!times.some((at) => now - at < HOUR_MS)) delete this.data.replies[key];
+	}
+	getThread(hash) {
+		return Object.hasOwn(this.data.threads, hash) ? this.data.threads[hash] : void 0;
+	}
+	upsertThread(hash, record) {
+		this.data.threads[hash] = record;
+		const entries = Object.entries(this.data.threads);
+		if (entries.length <= LIMITS.threads) return;
+		entries.sort((a, b) => a[1].lastActivityAt - b[1].lastActivityAt);
+		for (const [key] of entries.slice(0, entries.length - LIMITS.threads)) delete this.data.threads[key];
+		this.log.debug(`Email state thread map full; evicted ${String(entries.length - LIMITS.threads)} oldest thread(s)`);
+	}
+	retryEntries() {
+		return this.data.retry;
+	}
+	hasRetry(id) {
+		return this.data.retry.some((entry) => entry.id === id);
+	}
+	getRetry(id) {
+		return this.data.retry.find((entry) => entry.id === id);
+	}
+	putRetry(entry) {
+		this.removeRetry(entry.id);
+		this.data.retry.push(entry);
+		this.trim(this.data.retry, LIMITS.retry, "retry");
+	}
+	removeRetry(id) {
+		this.data.retry = this.data.retry.filter((entry) => entry.id !== id);
+	}
+	pendingEntries() {
+		return this.data.pending;
+	}
+	addPending(entry) {
+		this.removePending(entry.id);
+		this.data.pending.push(entry);
+		this.trim(this.data.pending, LIMITS.pending, "pending");
+	}
+	removePending(id) {
+		this.data.pending = this.data.pending.filter((entry) => entry.id !== id);
+	}
+	trim(list, max, what) {
+		const dropped = trimFront(list, max);
+		if (dropped > 0) this.log.debug(`Email state ${what} list full; dropped ${String(dropped)} oldest entr${dropped === 1 ? "y" : "ies"}`);
+	}
+	/** For tests and diagnostics. */
+	snapshot() {
+		return structuredClone(this.data);
+	}
+};
+function trimFront(list, max) {
+	const excess = list.length - max;
+	if (excess <= 0) return 0;
+	list.splice(0, excess);
+	return excess;
+}
+function isMissingFile(err) {
+	return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+}
+function errorMessage$1(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isString(value) {
+	return typeof value === "string";
+}
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function isBoundedString(value, max) {
+	return typeof value === "string" && value.length <= max;
+}
+function isAddress(value) {
+	return isRecord(value) && isBoundedString(value.address, PARENT_LIMITS.address) && (value.name === void 0 || isBoundedString(value.name, PARENT_LIMITS.name));
+}
+function isAddressList(value) {
+	return Array.isArray(value) && value.length <= PARENT_LIMITS.addresses && value.every(isAddress);
+}
+function isParentRef(value) {
+	const id = (v) => isBoundedString(v, PARENT_LIMITS.id);
+	return isRecord(value) && id(value.id) && id(value.threadId) && id(value.messageId) && Array.isArray(value.references) && value.references.length <= PARENT_LIMITS.references && value.references.every(id) && isAddress(value.from) && isAddressList(value.to) && isAddressList(value.cc) && isBoundedString(value.subject, PARENT_LIMITS.subject) && typeof value.verified === "boolean" && (value.threadIndex === void 0 || id(value.threadIndex)) && (value.threadTopic === void 0 || isBoundedString(value.threadTopic, PARENT_LIMITS.subject));
+}
+function isIdPair(value) {
+	return isRecord(value) && isString(value.id) && isString(value.threadId);
+}
+function isMailboxState(value) {
+	if (!isRecord(value) || value.version !== 1 || !isString(value.mailbox)) return false;
+	if (value.cursor !== null && !isString(value.cursor)) return false;
+	if (!isFiniteNumber(value.lastMessageAt)) return false;
+	if (!Array.isArray(value.seen) || value.seen.length > LIMITS.seen) return false;
+	if (!value.seen.every((entry) => isRecord(entry) && isString(entry.id) && isString(entry.mid))) return false;
+	if (!Array.isArray(value.replied) || value.replied.length > LIMITS.replied || !value.replied.every(isString)) return false;
+	if (!isRecord(value.threads) || Object.keys(value.threads).length > LIMITS.threads) return false;
+	for (const thread of Object.values(value.threads)) if (!isRecord(thread) || !isString(thread.threadId) || !isFiniteNumber(thread.lastActivityAt) || !isParentRef(thread.parent)) return false;
+	if (!isRecord(value.replies)) return false;
+	for (const times of Object.values(value.replies)) if (!Array.isArray(times) || !times.every(isFiniteNumber)) return false;
+	if (!Array.isArray(value.retry) || value.retry.length > LIMITS.retry) return false;
+	if (!value.retry.every((entry) => isIdPair(entry) && isFiniteNumber(entry.attempts) && isFiniteNumber(entry.nextAt) && (entry.recovering === void 0 || typeof entry.recovering === "boolean"))) return false;
+	if (!Array.isArray(value.pending) || value.pending.length > LIMITS.pending || !value.pending.every(isIdPair)) return false;
+	return true;
+}
+//#endregion
+//#region src/outbound.ts
+/**
+* Outbound email: one reply per turn, reply idempotency, loop cap, and
+* out-of-turn sends to a thread target.
+*
+* Turn replies arrive through dispatch's `deliver` callback once per reply
+* payload; {@link TurnBuffer} collects them and the pipeline sends a single
+* email when the dispatch promise resolves (the turn-end signal on 9.5).
+*
+* Idempotency is keyed by the inbound Message-ID: the key is recorded and
+* persisted BEFORE the send, so a restart never re-sends a recorded reply (a
+* crash mid-send may lose it). Within one send, a retry happens only after a
+* provider throttle (429) or a connection failure, never after a timeout or
+* 5xx where the provider may already have accepted the message; a connection
+* that drops after the provider accepted the request is the one remaining way
+* to get a duplicate.
+*
+* Recipients: a DMARC-verified sender gets reply-all (the thread's people);
+* an unverified sender gets a reply to From only, so a forged From cannot turn
+* the agent into a relay to arbitrary To/Cc addresses. Either way at most
+* {@link MAX_RECIPIENTS} addresses are kept.
+*/
+/** Delays before each send retry (3 retries). */
+const SEND_RETRY_DELAYS_MS = [
+	1e3,
+	4e3,
+	16e3
+];
+/** Agent output is bounded before it becomes an email. */
+const MAX_REPLY_CHARS = 1e5;
+/** Collects a turn's reply payloads. */
+var TurnBuffer = class {
+	parts = [];
+	push(payload) {
+		const text = typeof payload.text === "string" ? payload.text.trim() : "";
+		if (text) this.parts.push(text);
+	}
+	text() {
+		return this.parts.join("\n\n");
+	}
+};
+/** What a reply needs from the inbound email, bounded before it is persisted. */
+function parentRefOf(email, verified, log) {
+	const limit = PARENT_LIMITS;
+	const list = (entries, what) => {
+		if (entries.length > limit.addresses) log?.warn(`Email ${what} list truncated to ${String(limit.addresses)} of ${String(entries.length)} addresses`);
+		return entries.slice(0, limit.addresses).map(boundAddress);
+	};
+	return {
+		id: email.id.slice(0, limit.id),
+		threadId: email.threadId.slice(0, limit.id),
+		messageId: email.messageId.slice(0, limit.id),
+		references: email.references.slice(-limit.references).map((ref) => ref.slice(0, limit.id)),
+		from: boundAddress(email.from),
+		to: list(email.to, "To"),
+		cc: list(email.cc, "Cc"),
+		subject: email.subject.slice(0, limit.subject),
+		verified,
+		...email.threadIndex !== void 0 ? { threadIndex: email.threadIndex.slice(0, limit.id) } : {},
+		...email.threadTopic !== void 0 ? { threadTopic: email.threadTopic.slice(0, limit.subject) } : {}
+	};
+}
+function boundAddress(entry) {
+	return {
+		address: entry.address.slice(0, PARENT_LIMITS.address),
+		...entry.name !== void 0 ? { name: entry.name.slice(0, PARENT_LIMITS.name) } : {}
+	};
+}
+/**
+* Who the reply goes to. Unverified senders: From only. Verified: From + To +
+* Cc. Own address removed, deduped case-insensitively, capped.
+*/
+function replyAudience(parent, ownAddress, log) {
+	const seen = new Set([ownAddress.trim().toLowerCase()]);
+	const keep = (entries) => entries.filter((entry) => {
+		const key = entry.address.trim().toLowerCase();
+		if (key === "" || seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+	const to = keep(parent.verified ? [parent.from, ...parent.to] : [parent.from]);
+	const cc = parent.verified ? keep(parent.cc) : [];
+	const total = to.length + cc.length;
+	if (total <= 20) return {
+		to,
+		cc
+	};
+	log.warn(`Email reply recipients capped at ${String(20)} of ${String(total)}`);
+	const cappedTo = to.slice(0, 20);
+	return {
+		to: cappedTo,
+		cc: cc.slice(0, 20 - cappedTo.length)
+	};
+}
+function asParentEmail(parent, audience) {
+	const [from = { address: "" }, ...to] = audience.to;
+	return {
+		id: parent.id,
+		threadId: parent.threadId,
+		messageId: parent.messageId,
+		references: parent.references,
+		from,
+		to,
+		cc: audience.cc,
+		subject: parent.subject,
+		...parent.threadIndex !== void 0 ? { threadIndex: parent.threadIndex } : {},
+		...parent.threadTopic !== void 0 ? { threadTopic: parent.threadTopic } : {},
+		textBody: "",
+		headers: /* @__PURE__ */ new Map(),
+		headerList: [],
+		attachments: []
+	};
+}
+/**
+* Send one reply on a thread. `inboundKey` (the inbound Message-ID) makes the
+* send idempotent; out-of-turn sends have none.
+*/
+async function sendReply(deps, args) {
+	const markdown = bound(args.markdown.trim());
+	if (!markdown) return { kind: "empty" };
+	if (args.inboundKey !== void 0 && deps.state.isReplied(args.inboundKey)) return { kind: "duplicate" };
+	const now = deps.now();
+	if (deps.state.repliesInLastHour(args.threadHash, now) >= deps.loopCap) {
+		deps.log.warn(`Email reply suppressed: thread reached ${String(deps.loopCap)} replies in the last hour`);
+		return { kind: "capped" };
+	}
+	const audience = replyAudience(args.parent, deps.ownAddress, deps.log);
+	const composed = (0, _alfe_ai_email.composeReply)({
+		parent: asParentEmail(args.parent, audience),
+		ownAddress: deps.ownAddress,
+		markdown
+	});
+	if (composed.recipients.length === 0) {
+		deps.log.warn("Email reply skipped: the thread has no recipients other than this mailbox");
+		return { kind: "no-recipients" };
+	}
+	if (args.inboundKey !== void 0) deps.state.markReplied(args.inboundKey);
+	deps.state.recordReply(args.threadHash, now);
+	await deps.state.save();
+	for (let attempt = 0;; attempt++) try {
+		await deps.driver.sendMime(composed.raw, { threadId: args.parent.threadId });
+		return {
+			kind: "sent",
+			messageId: messageIdOf(composed.raw)
+		};
+	} catch (err) {
+		if (!isSafeToRetrySend(err) || attempt >= SEND_RETRY_DELAYS_MS.length) {
+			if (isDefinitelyNotSent(err)) {
+				if (args.inboundKey !== void 0) deps.state.unmarkReplied(args.inboundKey);
+				deps.state.forgetReply(args.threadHash, now);
+				await deps.state.save().catch(() => void 0);
+			}
+			throw err;
+		}
+		const delay = SEND_RETRY_DELAYS_MS[attempt] ?? 0;
+		const retryAfter = err?.retryAfterMs;
+		const wait = typeof retryAfter === "number" && retryAfter > delay ? Math.min(retryAfter, 6e4) : delay;
+		deps.log.warn(`Email send failed; retrying in ${String(wait)}ms (${errorMessage(err)})`);
+		await deps.sleep(wait);
+	}
+}
+/** Out-of-turn send (message tool, cron, follow-ups) to `thread:<threadHash>`. */
+async function sendToThread(deps, to, text) {
+	const hash = parseThreadTarget(to);
+	if (!hash) throw new Error("Invalid email target: use thread:<threadHash>");
+	const thread = deps.state.getThread(hash);
+	if (!thread) throw new Error("Unknown email thread: this mailbox has no conversation with that target");
+	return await sendReply(deps, {
+		threadHash: hash,
+		parent: thread.parent,
+		markdown: text
+	});
+}
+/**
+* Retry a send only when the provider cannot have accepted it: a throttle, or
+* a fetch that failed to connect. A timeout, a 5xx, auth and scope errors are
+* final (the message may already be out, or retrying cannot help).
+*/
+function isSafeToRetrySend(err) {
+	if (err instanceof _alfe_ai_email.MailboxRateLimitError) return true;
+	if (err instanceof _alfe_ai_email.MailboxHttpError) return false;
+	if (!(err instanceof TypeError)) return false;
+	const code = err.cause?.code;
+	return typeof code === "string" && CONNECT_ERRORS.has(code);
+}
+/**
+* The provider refused the send before accepting it: auth, scope, throttle,
+* any other 4xx except 408 (request timeout), or a failed connect. A 5xx,
+* a timeout or an unknown error is ambiguous and keeps the at-most-once key.
+*/
+function isDefinitelyNotSent(err) {
+	if (err instanceof _alfe_ai_email.MailboxAuthError || err instanceof _alfe_ai_email.MailboxScopeError) return true;
+	if (err instanceof _alfe_ai_email.MailboxHttpError) return err.status >= 400 && err.status < 500 && err.status !== 408;
+	return isSafeToRetrySend(err);
+}
+const CONNECT_ERRORS = new Set([
+	"ECONNREFUSED",
+	"ENOTFOUND",
+	"EAI_AGAIN",
+	"ENETUNREACH",
+	"EHOSTUNREACH",
+	"UND_ERR_CONNECT_TIMEOUT"
+]);
+function bound(text) {
+	return text.length > MAX_REPLY_CHARS ? `${text.slice(0, MAX_REPLY_CHARS)}\n\n[reply truncated]` : text;
+}
+function messageIdOf(raw) {
+	return /^Message-ID: (<[^>\r\n]+>)/im.exec(raw)?.[1] ?? "";
+}
+function errorMessage(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+//#endregion
+//#region src/sender-context.ts
+/**
+* Cross-plugin sender-context registry (contract `alfe.senderContext.v1`),
+* write side.
+*
+* `@alfe.ai/openclaw-identity` reads this before re-resolving a sender in its
+* tool gate, because stock OpenClaw message metadata drops Alfe identity
+* fields and the identity plugin's own resolve cannot repeat this channel's
+* DMARC-verified `emailVerified` evidence.
+*
+* The store lives on `globalThis` under a registry symbol so it survives the
+* OpenClaw 9.x double plugin load and is shared across packages without a
+* plugin-kit dependency. Each package ships its own copy of this contract;
+* keep the key, the key format, and the entry shape identical to
+* `packages/openclaw-identity/src/sender-context.ts`.
+*
+* - Key: `${sessionKey}\u0000${senderId}`, using OpenClaw's run `SessionKey`
+*   and `SenderId`.
+* - This plugin owns its entries: written before dispatch, deleted when the
+*   dispatch promise resolves. `expiresAt` (epoch ms) is the crash backstop,
+*   refreshed while a long turn is still running.
+*/
+const KEY = Symbol.for("alfe.senderContext.v1");
+function senderContextStore() {
+	const g = globalThis;
+	return g[KEY] ??= /* @__PURE__ */ new Map();
+}
+function senderContextKey(sessionKey, senderId) {
+	return `${sessionKey}\u0000${senderId}`;
+}
+/** Entries live at most this long without a refresh. */
+const SENDER_CONTEXT_TTL_MS = 2 * 6e4;
+function writeSenderContext(sessionKey, senderId, entry, now = Date.now()) {
+	const written = {
+		identityId: entry.identityId,
+		status: entry.status,
+		permissions: [...entry.permissions],
+		expiresAt: now + SENDER_CONTEXT_TTL_MS
+	};
+	senderContextStore().set(senderContextKey(sessionKey, senderId), written);
+	return written;
+}
+/** Extend the TTL of an entry this writer wrote, if it is still the live one. */
+function touchSenderContext(sessionKey, senderId, written, now = Date.now()) {
+	if (senderContextStore().get(senderContextKey(sessionKey, senderId)) === written) written.expiresAt = now + SENDER_CONTEXT_TTL_MS;
+}
+/** Delete the entry only if it is still the one this writer wrote. */
+function deleteSenderContext(sessionKey, senderId, written) {
+	const store = senderContextStore();
+	const key = senderContextKey(sessionKey, senderId);
+	if (store.get(key) === written) store.delete(key);
+}
+var SenderContextKeeper = class {
+	entries = /* @__PURE__ */ new Map();
+	timer = null;
+	stopped = false;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/** Write (or refresh) the entry for an admitted inbound, before its dispatch. */
+	admit(sessionKey, senderId, sender) {
+		if (this.stopped) return;
+		const now = this.deps.now();
+		const key = `${sessionKey}\u0000${senderId}`;
+		if (this.entries.get(key)) this.entries.delete(key);
+		this.entries.set(key, {
+			sessionKey,
+			senderId,
+			from: sender.from,
+			verified: sender.verified,
+			written: writeSenderContext(sessionKey, senderId, sender.context, now),
+			lastAdmittedAt: now,
+			lastResolvedAt: now,
+			resolving: null
+		});
+		this.evictOverflow();
+		this.ensureTimer();
+	}
+	/** One heartbeat: expire, re-resolve or rewrite every kept entry. Exposed for tests. */
+	async tick() {
+		const now = this.deps.now();
+		const retention = this.deps.retentionMs ?? 18e5;
+		const reResolve = this.deps.reResolveMs ?? 3e5;
+		const work = [];
+		for (const [key, kept] of [...this.entries]) if (now - kept.lastAdmittedAt >= retention) this.drop(key, kept);
+		else if (now - kept.lastResolvedAt >= reResolve) {
+			kept.resolving ??= this.reResolve(key, kept).finally(() => {
+				kept.resolving = null;
+			});
+			work.push(kept.resolving);
+		} else touchSenderContext(kept.sessionKey, kept.senderId, kept.written, now);
+		await Promise.all(work);
+		if (this.entries.size === 0) this.clearTimer();
+	}
+	/** Stop heartbeats and delete every entry this keeper owns. */
+	stop() {
+		this.stopped = true;
+		this.clearTimer();
+		for (const [key, kept] of [...this.entries]) this.drop(key, kept);
+	}
+	size() {
+		return this.entries.size;
+	}
+	async reResolve(key, kept) {
+		let keep = false;
+		let reason = "denied";
+		try {
+			const resolved = await this.deps.identity.resolveIdentity({
+				provider: "email",
+				platformId: `email:${kept.from}`,
+				email: kept.from,
+				emailVerified: kept.verified
+			});
+			if (resolved.permissionsUnavailable === true) reason = "permissions unavailable";
+			else if (allowsAgentChat(resolved.permissions, this.deps.agentId)) {
+				keep = true;
+				if (this.entries.get(key) !== kept) return;
+				const now = this.deps.now();
+				deleteSenderContext(kept.sessionKey, kept.senderId, kept.written);
+				kept.written = writeSenderContext(kept.sessionKey, kept.senderId, {
+					identityId: resolved.identityId,
+					status: resolved.status,
+					permissions: resolved.permissions
+				}, now);
+				kept.lastResolvedAt = now;
+			}
+		} catch (err) {
+			reason = `resolve failed: ${errorMessage(err)}`;
+		}
+		if (!keep && this.entries.get(key) === kept) {
+			this.deps.log.info(`Email sender context released on re-resolve (${reason})`);
+			this.drop(key, kept);
+		}
+	}
+	drop(key, kept) {
+		deleteSenderContext(kept.sessionKey, kept.senderId, kept.written);
+		if (this.entries.get(key) === kept) this.entries.delete(key);
+	}
+	evictOverflow() {
+		const max = this.deps.maxEntries ?? 200;
+		while (this.entries.size > max) {
+			const oldest = this.entries.entries().next();
+			if (oldest.done) return;
+			this.drop(oldest.value[0], oldest.value[1]);
+			this.deps.log.debug("Email sender context limit reached; evicted the least recently admitted sender");
+		}
+	}
+	ensureTimer() {
+		if (this.timer || this.stopped) return;
+		this.timer = setInterval(() => {
+			this.tick().catch((err) => {
+				this.deps.log.warn(`Email sender context heartbeat failed: ${errorMessage(err)}`);
+			});
+		}, this.deps.heartbeatMs ?? 6e4);
+		this.timer.unref();
+	}
+	clearTimer() {
+		if (this.timer) clearInterval(this.timer);
+		this.timer = null;
+	}
+};
+//#endregion
+//#region src/pipeline.ts
+/**
+* Inbound pipeline, in order:
+* dedupe → filters → resolve → admission → per-thread serialisation →
+* sender-context registry write (kept after the turn) → dispatch → reply → markHandled.
+*
+* Admission and enqueue are quick, so the poller is never blocked by a long
+* agent turn; the turn itself runs on the thread's promise chain.
+*
+* Per-thread serialisation: OpenClaw would merge a second message into an
+* active run, and `ctx.requester.senderId` would still name the first sender.
+* Each thread's turns therefore chain on the previous turn's dispatch promise
+* (which resolves at turn end on 9.5; `agent_end` is fire-and-forget and not
+* ordered after delivery), so every message runs as its own turn with its own
+* sender context.
+*
+* Denied, filtered and dropped messages are left unread; only a completed
+* turn marks its message handled.
+*/
+const RESOLVE_RETRY_DELAYS_MS = [
+	3e4,
+	2 * 6e4,
+	10 * 6e4
+];
+const CHANNEL = "email";
+const ACCOUNT_ID = "default";
+const MAX_BODY_CHARS = 32e3;
+const MAX_ATTACHMENTS_LISTED = 10;
+var EmailPipeline = class {
+	chains = /* @__PURE__ */ new Map();
+	now;
+	sleep;
+	loopCap;
+	retryDelays;
+	/** Keeps admitted senders' registry entries alive across the session (see sender-keeper.ts). */
+	senders;
+	turnTimeoutMs;
+	outbound;
+	stopped = false;
+	warnedNoRoute = false;
+	constructor(deps) {
+		this.deps = deps;
+		this.now = deps.now ?? Date.now;
+		this.sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+		this.loopCap = deps.loopCap ?? 10;
+		this.retryDelays = deps.retryDelaysMs ?? RESOLVE_RETRY_DELAYS_MS;
+		this.senders = new SenderContextKeeper({
+			identity: deps.identity,
+			agentId: deps.agentId,
+			log: deps.log,
+			now: this.now,
+			...deps.senderKeeper
+		});
+		this.turnTimeoutMs = deps.turnTimeoutMs ?? 9e5;
+		this.outbound = {
+			driver: deps.driver,
+			state: deps.state,
+			ownAddress: deps.ownAddress,
+			log: deps.log,
+			now: this.now,
+			sleep: this.sleep,
+			loopCap: this.loopCap
+		};
+	}
+	/** A message a sync round surfaced. */
+	async processSynced(message) {
+		const { state } = this.deps;
+		if (state.hasSeenId(message.id) || state.hasRetry(message.id)) return "skipped";
+		return await this.admit(message, {
+			retry: void 0,
+			recovering: false
+		});
+	}
+	/** A due retry-queue entry. */
+	async processRetry(entry) {
+		return await this.admit(entry, {
+			retry: entry,
+			recovering: entry.recovering === true
+		});
+	}
+	/** A turn that was admitted but had not finished when the process stopped. */
+	async processPending(entry) {
+		return await this.admit(entry, {
+			retry: void 0,
+			recovering: true
+		});
+	}
+	/** Out-of-turn send to `thread:<threadHash>`. */
+	async sendToThread(to, text) {
+		try {
+			const outcome = await sendToThread(this.outbound, to, text);
+			if (outcome.kind === "sent") this.deps.onSent?.();
+			return outcome;
+		} catch (err) {
+			if (isReconnectError(err)) this.deps.onReconnectRequired?.(err);
+			throw err;
+		}
+	}
+	/** Stop starting new turns. Running turns finish; unfinished ones stay pending. */
+	stop() {
+		this.stopped = true;
+	}
+	/** After the drain: stop sender-context heartbeats and delete this plugin's entries. */
+	close() {
+		this.stopped = true;
+		this.senders.stop();
+	}
+	/** Resolves when every queued turn has settled. */
+	async idle() {
+		while (this.chains.size > 0) await Promise.all([...this.chains.values()]);
+	}
+	async admit(message, ctx) {
+		const { state, driver, log } = this.deps;
+		let email;
+		let raw;
+		try {
+			raw = await driver.fetchRaw(message.id);
+			email = await (0, _alfe_ai_email.parseEmail)(raw, {
+				id: message.id,
+				threadId: message.threadId
+			});
+		} catch (err) {
+			if (isUnprocessable(err)) {
+				log.warn(`Email skipped: the message cannot be processed (${errorName(err)})`);
+				this.finishWithoutTurn(message.id, "");
+				await state.save();
+				return "dropped";
+			}
+			throw err;
+		}
+		const mid = email.messageId;
+		const inboundKey = replyKeyOf(email);
+		if (!ctx.recovering && state.hasSeenMessageId(mid)) {
+			this.finishWithoutTurn(message.id, mid);
+			await state.save();
+			return "skipped";
+		}
+		const ignoreReason = (0, _alfe_ai_email.shouldIgnore)(email, this.deps.ownAddress);
+		if (ignoreReason !== null) {
+			log.debug(`Email ignored (${ignoreReason})`);
+			this.finishWithoutTurn(message.id, mid);
+			await state.save();
+			return "ignored";
+		}
+		const thread = threadHash(email.threadId);
+		if (state.repliesInLastHour(thread, this.now()) >= this.loopCap) {
+			log.warn(`Email ignored: thread reached the ${String(this.loopCap)}-replies-per-hour loop cap`);
+			this.finishWithoutTurn(message.id, mid);
+			await state.save();
+			return "ignored";
+		}
+		const from = senderAddressOf(email);
+		const fromDomain = from.slice(from.lastIndexOf("@") + 1);
+		const verdictOrPromise = this.deps.evaluateSender ? this.deps.evaluateSender(email, fromDomain, driver.trust, this.deps.ownAddress) : (0, _alfe_ai_email.evaluateAuth)({
+			headerList: email.headerList,
+			raw
+		}, fromDomain, driver.trust, this.deps.ownAddress, { receivedAt: driver.receivedAt?.(message.id) });
+		const verdict = await Promise.resolve(verdictOrPromise);
+		let resolved;
+		try {
+			resolved = await this.deps.identity.resolveIdentity({
+				provider: "email",
+				platformId: `email:${from}`,
+				email: from,
+				emailVerified: verdict.verified
+			});
+			if (resolved.permissionsUnavailable === true) throw new Error("permissions unavailable");
+		} catch (err) {
+			return await this.resolveFailed(message, ctx, err);
+		}
+		state.removeRetry(message.id);
+		if (!allowsAgentChat(resolved.permissions, this.deps.agentId)) {
+			log.info(`Email from ${maskAddress(from)} not admitted (no agent:chat; auth ${verdict.reason})`);
+			this.finishWithoutTurn(message.id, mid);
+			await state.save();
+			return "denied";
+		}
+		if (ctx.recovering && state.isReplied(inboundKey)) {
+			await this.markHandled(email.id);
+			this.finishWithoutTurn(message.id, mid);
+			await state.save();
+			return "skipped";
+		}
+		const now = this.now();
+		state.markSeen(message.id, mid);
+		const parent = parentRefOf(email, verdict.verified, log);
+		state.upsertThread(thread, {
+			threadId: email.threadId,
+			parent,
+			lastActivityAt: now
+		});
+		state.addPending({
+			id: message.id,
+			threadId: message.threadId
+		});
+		state.lastMessageAt = now;
+		await state.save();
+		this.enqueue(thread, () => this.runTurn(email, parent, thread, {
+			identityId: resolved.identityId,
+			status: resolved.status,
+			permissions: resolved.permissions
+		}));
+		return "dispatched";
+	}
+	async resolveFailed(message, ctx, err) {
+		const { state, log } = this.deps;
+		const attempts = ctx.retry === void 0 ? 0 : ctx.retry.attempts + 1;
+		if (attempts >= this.retryDelays.length) {
+			log.error(`Email dropped: sender resolve failed after ${String(attempts)} retries (${errorMessage(err)})`);
+			this.finishWithoutTurn(message.id, "");
+			await state.save();
+			return "dropped";
+		}
+		log.warn(`Email sender resolve failed; retry ${String(attempts + 1)} queued (${errorMessage(err)})`);
+		state.putRetry({
+			id: message.id,
+			threadId: message.threadId,
+			attempts,
+			nextAt: this.now() + (this.retryDelays[attempts] ?? 0),
+			...ctx.recovering ? { recovering: true } : {}
+		});
+		await state.save();
+		return "queued";
+	}
+	finishWithoutTurn(id, mid) {
+		const { state } = this.deps;
+		if (mid !== "" || !state.hasSeenId(id)) state.markSeen(id, mid);
+		state.removeRetry(id);
+		state.removePending(id);
+	}
+	enqueue(thread, task) {
+		const next = (this.chains.get(thread) ?? Promise.resolve()).then(task).catch((err) => {
+			this.deps.log.error(`Email turn failed: ${errorMessage(err)}`);
+		});
+		this.chains.set(thread, next);
+		next.finally(() => {
+			if (this.chains.get(thread) === next) this.chains.delete(thread);
+		});
+	}
+	async runTurn(email, parent, thread, sender) {
+		if (this.stopped) return;
+		const { runtime, state, log, ownAddress } = this.deps;
+		const cfg = runtime.readConfig();
+		const peer = {
+			kind: "direct",
+			id: peerIdFor(ownAddress, email.threadId)
+		};
+		const from = senderAddressOf(email);
+		const senderId = `email:${from}`;
+		const sessionKey = this.resolveSessionKey(cfg, peer);
+		if (sessionKey) this.senders.admit(sessionKey, senderId, {
+			from,
+			verified: parent.verified,
+			context: sender
+		});
+		const buffer = new TurnBuffer();
+		let failed = false;
+		let timedOut = false;
+		let timer;
+		const timeout = new Promise((resolve) => {
+			timer = setTimeout(() => {
+				resolve("timeout");
+			}, this.turnTimeoutMs);
+		});
+		try {
+			const dispatched = runtime.dispatch({
+				cfg,
+				runtime: { channel: runtime.channelRuntime },
+				channel: CHANNEL,
+				channelLabel: "Email",
+				accountId: ACCOUNT_ID,
+				peer,
+				senderId,
+				senderAddress: senderId,
+				recipientAddress: `email:${ownAddress.toLowerCase()}`,
+				conversationLabel: `[Email] ${from}`,
+				rawBody: renderBody(email),
+				messageId: email.messageId || email.id,
+				timestamp: this.now(),
+				provider: CHANNEL,
+				originatingTo: threadTarget(thread),
+				deliver: (payload) => {
+					buffer.push(payload);
+					return Promise.resolve();
+				},
+				onRecordError: (err) => {
+					failed = true;
+					log.error(`Email session record error: ${errorMessage(err)}`);
+				},
+				onDispatchError: (err, info) => {
+					failed = true;
+					log.error(`Email dispatch error (${info.kind}): ${errorMessage(err)}`);
+				}
+			});
+			if (await Promise.race([dispatched, timeout]) === "timeout") {
+				failed = true;
+				timedOut = true;
+				log.error(`Email turn exceeded ${String(this.turnTimeoutMs)}ms; releasing the thread without a reply`);
+				dispatched.catch(() => void 0);
+			}
+		} catch (err) {
+			failed = true;
+			log.error(`Email dispatch failed: ${errorMessage(err)}`);
+		} finally {
+			clearTimeout(timer);
+		}
+		try {
+			const markdown = timedOut ? "" : buffer.text();
+			if ((await sendReply(this.outbound, {
+				threadHash: thread,
+				parent,
+				markdown,
+				inboundKey: replyKeyOf(email)
+			})).kind === "sent") this.deps.onSent?.();
+		} catch (err) {
+			failed = true;
+			log.error(`Email reply could not be sent: ${errorMessage(err)}`);
+			if (isReconnectError(err)) this.deps.onReconnectRequired?.(err);
+		}
+		if (!failed) await this.markHandled(email.id);
+		state.removePending(email.id);
+		await state.save().catch((err) => {
+			log.error(`Email state save failed: ${errorMessage(err)}`);
+		});
+	}
+	resolveSessionKey(cfg, peer) {
+		const { runtime, log } = this.deps;
+		try {
+			const session = cfg.session;
+			const key = (runtime.resolveRoute?.({
+				cfg,
+				channel: CHANNEL,
+				accountId: ACCOUNT_ID,
+				peer,
+				runtime: runtime.channelRuntime,
+				sessionStore: session?.store
+			}))?.route.sessionKey;
+			if (typeof key === "string" && key !== "") return key;
+		} catch (err) {
+			log.warn(`Email session route could not be resolved (${errorMessage(err)})`);
+		}
+		if (!this.warnedNoRoute) {
+			this.warnedNoRoute = true;
+			log.warn("Email sender context unavailable: the identity plugin will resolve senders without email verification");
+		}
+		return null;
+	}
+	async markHandled(id) {
+		try {
+			await this.deps.driver.markHandled(id);
+		} catch (err) {
+			this.deps.log.warn(`Email could not be marked handled: ${errorMessage(err)}`);
+		}
+	}
+};
+/** Untrusted content, bounded before it reaches the model. */
+function renderBody(email) {
+	const subject = stripControl(email.subject).slice(0, 500);
+	let body = email.textBody.length > MAX_BODY_CHARS ? `${email.textBody.slice(0, MAX_BODY_CHARS)}\n\n[message truncated]` : email.textBody;
+	const attachments = email.attachments.slice(0, MAX_ATTACHMENTS_LISTED).map((a) => `${stripControl(a.filename).slice(0, 200) || "unnamed"} (${stripControl(a.contentType).slice(0, 100)}, ${String(a.size)} bytes)`);
+	if (attachments.length > 0) {
+		const more = email.attachments.length - attachments.length;
+		body += `\n\n[Attachments, content not included: ${attachments.join(", ")}${more > 0 ? `, and ${String(more)} more` : ""}]`;
+	}
+	return `Subject: ${subject}\n\n${body}`;
+}
+function stripControl(value) {
+	return value.replace(/[\u0000-\u001f\u007f]/g, " ").trim();
+}
+/** Permanent per-message failures: skip the message rather than block the mailbox. */
+function isUnprocessable(err) {
+	if (err instanceof _alfe_ai_email.MessageTooLargeError) return true;
+	return err?.status === 404;
+}
+function errorName(err) {
+	return err instanceof Error ? err.name : "unknown";
+}
+/** The reply idempotency key: the inbound Message-ID, else the provider id. */
+function replyKeyOf(email) {
+	return email.messageId || `id:${email.id}`;
+}
+/** Lowercased From address with control characters removed (it reaches ctx and logs). */
+function senderAddressOf(email) {
+	return stripControl(email.from.address).replace(/\s+/g, "").toLowerCase();
+}
+//#endregion
+//#region src/poller.ts
+/**
+* The mailbox poller: one per configured mailbox (v1: one per agent).
+*
+* Adaptive interval, as in the Google Chat poller:
+*   active  (mail in the last 5 min)  → 1 s
+*   warm    (mail in the last 30 min) → 5 s
+*   idle                               → 15 s
+*   dormant (2 h or more without mail) → 30 s
+*
+* The first run seeds the cursor (`seedCursor()`), so historic mail is never
+* answered. An expired cursor reseeds with a warning; nothing is replayed.
+* The cursor advances only after every message of a sync round has been
+* decided (admitted, queued for retry, or skipped), so a transient failure
+* re-reads the round and dedupe absorbs the repeats.
+*
+* Revoked consent, a missing scope, or an unusable Connection puts the
+* channel in the `error` state with reason `reconnect`; the poller keeps the
+* cursor and retries slowly, resuming where it stopped once the user
+* reconnects.
+*/
+const INTERVALS_MS = {
+	active: 1e3,
+	warm: 5e3,
+	idle: 15e3,
+	dormant: 3e4
+};
+const ACTIVE_WINDOW_MS = 5 * 6e4;
+const WARM_WINDOW_MS = 30 * 6e4;
+const DORMANT_AFTER_MS = 120 * 6e4;
+const RECONNECT_BACKOFF_MS = 5 * 6e4;
+const MAX_ERROR_BACKOFF_MS = 6e4;
+/** A message that fails this many rounds in a row is skipped so it cannot block the mailbox. */
+const MAX_MESSAGE_FAILURES = 3;
+function computeInterval(lastMessageAt, now) {
+	if (lastMessageAt <= 0) return INTERVALS_MS.idle;
+	const elapsed = now - lastMessageAt;
+	if (elapsed < ACTIVE_WINDOW_MS) return INTERVALS_MS.active;
+	if (elapsed < WARM_WINDOW_MS) return INTERVALS_MS.warm;
+	if (elapsed < DORMANT_AFTER_MS) return INTERVALS_MS.idle;
+	return INTERVALS_MS.dormant;
+}
+var EmailPoller = class {
+	session = null;
+	recovering = null;
+	timer = null;
+	running = false;
+	inflight = null;
+	errorStreak = 0;
+	failures = /* @__PURE__ */ new Map();
+	now;
+	constructor(deps) {
+		this.deps = deps;
+		this.now = deps.now ?? Date.now;
+	}
+	start() {
+		if (this.running) return;
+		this.running = true;
+		this.schedule(0);
+	}
+	async stop() {
+		this.running = false;
+		if (this.timer) clearTimeout(this.timer);
+		this.timer = null;
+		await this.inflight?.catch(() => void 0);
+		const session = this.session;
+		session?.pipeline.stop();
+		if (session) await this.drain(session);
+		session?.pipeline.close();
+		await session?.state.save().catch((err) => {
+			this.deps.log.error(`Email state save failed on stop: ${errorMessage(err)}`);
+		});
+		this.deps.status.stopped();
+	}
+	async drain(session) {
+		let timer;
+		const limit = this.deps.drainTimeoutMs ?? 3e4;
+		const timedOut = new Promise((resolve) => {
+			timer = setTimeout(() => {
+				resolve("timeout");
+			}, limit);
+		});
+		const result = await Promise.race([session.pipeline.idle().then(() => "idle"), timedOut]);
+		clearTimeout(timer);
+		if (result === "timeout") this.deps.log.warn(`Email stop: turns still running after ${String(limit)}ms; they stay pending and re-run after restart`);
+	}
+	/** The live session, for out-of-turn sends. */
+	current() {
+		return this.session;
+	}
+	/**
+	* One poll round. Returns the delay before the next round. Exposed for tests;
+	* the timer loop calls it.
+	*/
+	async cycle() {
+		try {
+			const delay = await this.round();
+			this.errorStreak = 0;
+			this.deps.status.ok();
+			return delay;
+		} catch (err) {
+			return this.onError(err);
+		}
+	}
+	schedule(delay) {
+		if (!this.running) return;
+		this.timer = setTimeout(() => {
+			this.timer = null;
+			this.inflight = this.cycle().then((next) => {
+				this.inflight = null;
+				this.schedule(next);
+			});
+		}, delay);
+	}
+	async round() {
+		if (!this.session) {
+			this.session = await this.deps.bootstrap();
+			this.recovering = new Set(this.session.state.pendingEntries().map((entry) => entry.id));
+		}
+		const { driver, state, pipeline } = this.session;
+		if (state.cursor === null) {
+			state.cursor = await driver.seedCursor();
+			await state.save();
+			this.deps.log.info("Email mailbox seeded; only mail arriving from now on will be answered");
+			return this.interval(state);
+		}
+		await this.recoverPending();
+		await this.processDueRetries();
+		const result = await driver.sync(state.cursor);
+		if (result.kind === "cursor-expired") {
+			this.deps.log.warn("Email sync cursor expired; reseeding (mail received while offline beyond the provider window is not answered)");
+			state.cursor = await driver.seedCursor();
+			await state.save();
+			return this.interval(state);
+		}
+		for (const message of result.messages) await this.guarded(message.id, () => pipeline.processSynced(message), () => {
+			state.markSeen(message.id, "");
+		});
+		state.cursor = result.nextCursor;
+		await state.save();
+		if (result.messages.length > 0) this.deps.status.messageSeen(this.now());
+		return this.interval(state);
+	}
+	async recoverPending() {
+		const session = this.session;
+		if (!session || !this.recovering || this.recovering.size === 0) return;
+		const { state, pipeline } = session;
+		for (const entry of [...state.pendingEntries()]) {
+			if (!this.recovering.has(entry.id)) continue;
+			await this.guarded(entry.id, () => pipeline.processPending(entry), () => {
+				state.removePending(entry.id);
+				state.removeRetry(entry.id);
+				state.markSeen(entry.id, "");
+			});
+			this.recovering.delete(entry.id);
+		}
+		this.recovering.clear();
+	}
+	async processDueRetries() {
+		const session = this.session;
+		if (!session) return;
+		const now = this.now();
+		const { state, pipeline } = session;
+		for (const entry of [...state.retryEntries()]) {
+			if (entry.nextAt > now) continue;
+			await this.guarded(entry.id, () => pipeline.processRetry(entry), () => {
+				state.removeRetry(entry.id);
+				state.removePending(entry.id);
+				state.markSeen(entry.id, "");
+			});
+		}
+	}
+	/**
+	* Run one message's step. Throttling and credential problems are not the
+	* message's fault and fail the round as-is. Any other error fails the round
+	* too (so it is retried in order), but after {@link MAX_MESSAGE_FAILURES}
+	* consecutive failures the message is given up so it cannot block the mailbox.
+	*/
+	async guarded(id, step, giveUp) {
+		try {
+			await step();
+			this.failures.delete(id);
+		} catch (err) {
+			if (isReconnectError(err) || isAgentAuthError(err) || err instanceof _alfe_ai_email.MailboxRateLimitError) throw err;
+			const count = (this.failures.get(id) ?? 0) + 1;
+			if (count < MAX_MESSAGE_FAILURES) {
+				this.failures.set(id, count);
+				throw err;
+			}
+			this.failures.delete(id);
+			this.deps.log.error(`Email skipped after ${String(count)} failed attempts: ${errorMessage(err)}`);
+			giveUp();
+			await this.session?.state.save();
+		}
+	}
+	interval(state) {
+		return computeInterval(state.lastMessageAt, this.now());
+	}
+	onError(err) {
+		if (isReconnectError(err)) {
+			this.deps.status.error("reconnect", reconnectMessage(err));
+			return RECONNECT_BACKOFF_MS;
+		}
+		if (isAgentAuthError(err)) {
+			this.deps.status.error("agent-auth", "The Agent API rejected this agent's token; check the agent's Alfe API key");
+			return RECONNECT_BACKOFF_MS;
+		}
+		this.errorStreak += 1;
+		const backoff = Math.min(2e3 * 2 ** (this.errorStreak - 1), MAX_ERROR_BACKOFF_MS);
+		const retryAfter = err?.retryAfterMs;
+		const delay = typeof retryAfter === "number" && Number.isFinite(retryAfter) && retryAfter > 0 ? Math.max(backoff, Math.min(retryAfter, 15 * 6e4)) : backoff;
+		this.deps.log.warn(`Email poll failed; retrying in ${String(delay)}ms (${errorMessage(err)})`);
+		return delay;
+	}
+};
+//#endregion
+//#region src/runtime-config.ts
+function readRuntimeConfig(config) {
+	if (typeof config?.current === "function") return config.current() ?? {};
+	if (typeof config?.loadConfig === "function") return config.loadConfig();
+	throw new Error("OpenClaw plugin runtime exposes neither config.current() nor config.loadConfig()");
+}
+//#endregion
+//#region src/status.ts
+var ChannelStatus = class {
+	current = {
+		state: "starting",
+		lastMessageAt: null
+	};
+	constructor(log) {
+		this.log = log;
+	}
+	snapshot() {
+		return { ...this.current };
+	}
+	/**
+	* A successful poll must not hide a send-side error (an Outlook token that
+	* reads mail but lacks Mail.Send), so each path clears only its own error.
+	*/
+	ok(source = "poll") {
+		if (this.current.state === "error") {
+			if (this.current.source !== source) return;
+			this.log.info("Email channel recovered");
+		}
+		this.current = {
+			state: "ok",
+			lastMessageAt: this.current.lastMessageAt
+		};
+	}
+	error(reason, message, source = "poll") {
+		const changed = this.current.state !== "error" || this.current.reason !== reason || this.current.message !== message;
+		this.current = {
+			state: "error",
+			reason,
+			message,
+			source,
+			lastMessageAt: this.current.lastMessageAt
+		};
+		if (changed) this.log.error(`Email channel error (${reason}): ${message}`);
+	}
+	stopped() {
+		this.current = {
+			state: "stopped",
+			lastMessageAt: this.current.lastMessageAt
+		};
+	}
+	messageSeen(at) {
+		this.current.lastMessageAt = at;
+	}
+};
+//#endregion
+//#region src/plugin.ts
+/**
+* @alfe.ai/openclaw-email — chat with the agent through its connected Gmail
+* or Outlook mailbox.
+*
+*   mailbox (poll 1-30 s via @alfe.ai/email drivers)
+*     → EmailPoller → EmailPipeline (dedupe, filters, resolve, agent:chat admission)
+*       → dispatchInboundDirectDmWithRuntime() per thread, serialised
+*       ← deliver() payloads buffered → one reply-all email per turn
+*   registered `email` channel → out-of-turn sends to `thread:<threadHash>`
+*
+* Requires OpenClaw >= 2026.9.5 (`package.json#openclaw.install.minHostVersion`
+* plus a runtime check): the per-sender tool gate in
+* `@alfe.ai/openclaw-identity` relies on 9.5's `before_tool_call`
+* `ctx.requester`.
+*
+* Config (`plugins.entries.<id>.config`, projected from the agent's Connect
+* `email` Channel by desired state): `{ channelId, connectionId }`.
+*/
+const pkg = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href)("../package.json");
+const PLUGIN_ID = "@alfe.ai/openclaw-email";
+function parsePluginConfig(value) {
+	if (typeof value !== "object" || value === null) return null;
+	const { channelId, connectionId } = value;
+	if (typeof channelId !== "string" || channelId.trim() === "") return null;
+	if (typeof connectionId !== "string" || connectionId.trim() === "") return null;
+	return {
+		channelId: channelId.trim(),
+		connectionId: connectionId.trim()
+	};
+}
+const ACTIVATION_KEY = (0, _alfe_ai_openclaw_plugin_kit.getActivationKey)("email");
+const RUNTIME_KEY = Symbol.for("alfe.openclaw-email.runtime.v1");
+function runtimeHandle() {
+	const g = globalThis;
+	return g[RUNTIME_KEY] ??= {
+		poller: null,
+		status: null
+	};
+}
+function channelHandle() {
+	const { poller, status } = runtimeHandle();
+	if (!poller || !status) return null;
+	return {
+		status: () => status.snapshot(),
+		hasThread: (hash) => poller.current()?.state.getThread(hash) !== void 0,
+		sendToThread: async (to, text) => {
+			const session = poller.current();
+			if (!session) throw new Error("Email channel is still starting; retry shortly");
+			return await session.pipeline.sendToThread(to, text);
+		}
+	};
+}
+async function stopRunning(log) {
+	const handle = runtimeHandle();
+	const poller = handle.poller;
+	handle.poller = null;
+	await poller?.stop();
+	(0, _alfe_ai_openclaw_plugin_kit.resetActivation)(ACTIVATION_KEY);
+	log.info("Email channel stopped");
+}
+const plugin = {
+	id: PLUGIN_ID,
+	name: "Email",
+	description: "Email channel via the agent's connected Gmail or Outlook mailbox",
+	version: pkg.version,
+	activate(api) {
+		const log = api.logger;
+		const mode = api.registrationMode;
+		if (mode !== void 0 && mode !== "full") {
+			api.registerChannel(createEmailChannelPlugin(() => null));
+			return;
+		}
+		if (!isHostAtLeast(api.runtime?.version, "2026.9.5")) {
+			log.error(`Email channel requires OpenClaw >= ${MIN_HOST_VERSION} (host reports ${describeVersion(api.runtime?.version)}); not activating`);
+			return;
+		}
+		api.registerChannel(createEmailChannelPlugin(channelHandle));
+		api.registerService({
+			id: "email-poller",
+			start: (ctx) => {
+				startService(api, ctx);
+			},
+			stop: async () => {
+				await stopRunning(log);
+			}
+		});
+		log.info("Email channel registered");
+	},
+	async deactivate(api) {
+		await stopRunning(api.logger);
+	}
+};
+function startService(api, ctx) {
+	const log = api.logger;
+	(0, _alfe_ai_openclaw_plugin_kit.guardedStart)(ACTIVATION_KEY, log, () => {
+		const handle = runtimeHandle();
+		const status = new ChannelStatus(log);
+		handle.status = status;
+		const config = parsePluginConfig(api.pluginConfig);
+		if (!config) {
+			status.error("config", "Plugin config needs channelId and connectionId");
+			(0, _alfe_ai_openclaw_plugin_kit.resetActivation)(ACTIVATION_KEY);
+			return;
+		}
+		const runtime = api.runtime;
+		const dispatch = (0, _alfe_ai_openclaw_plugin_kit.resolveOpenClawSdk)(log, { unresolvableNote: "OpenClaw SDK not resolvable; email dispatch is disabled" });
+		const resolveRoute = (0, _alfe_ai_openclaw_plugin_kit.resolveOpenClawSdk)(log, {
+			specifier: "openclaw/plugin-sdk/inbound-envelope",
+			exportName: "resolveInboundRouteEnvelopeBuilderWithRuntime",
+			unresolvableNote: "OpenClaw route resolver not resolvable; email sender context is disabled"
+		});
+		const stateDir = ctx.stateDir ?? runtime?.state?.resolveStateDir?.();
+		if (!dispatch || !runtime || !stateDir) {
+			log.error("Email channel runtime prerequisites unavailable; polling disabled");
+			(0, _alfe_ai_openclaw_plugin_kit.resetActivation)(ACTIVATION_KEY);
+			return;
+		}
+		const alfe = (0, _alfe_ai_config.resolveConfig)();
+		const client = new _alfe_ai_agent_api_client.AgentApiClient({
+			apiKey: alfe.apiKey,
+			apiUrl: alfe.apiUrl
+		});
+		const credentials = new ConnectionCredentials(client, config.connectionId);
+		const bootstrap = async () => {
+			const described = await credentials.describe();
+			const driver = described.provider === "google" ? new _alfe_ai_email.GmailDriver({ getAccessToken: credentials.getAccessToken }) : new _alfe_ai_email.GraphDriver({ getAccessToken: credentials.getAccessToken });
+			const { address } = await driver.whoami();
+			const mailbox = address.trim().toLowerCase();
+			const { agentId } = await client.whoami();
+			const state = new StateStore(stateFilePath(stateDir, mailbox), mailbox, log);
+			await state.load();
+			const pipeline = new EmailPipeline({
+				driver,
+				state,
+				identity: client,
+				agentId,
+				ownAddress: mailbox,
+				runtime: {
+					dispatch,
+					resolveRoute,
+					readConfig: () => readRuntimeConfig(runtime.config),
+					channelRuntime: runtime.channel
+				},
+				log,
+				onReconnectRequired: (err) => {
+					status.error("reconnect", reconnectMessage(err), "send");
+				},
+				onSent: () => {
+					status.ok("send");
+				}
+			});
+			log.info(`Email channel polling ${described.provider} mailbox for channel ${config.channelId}`);
+			return {
+				driver,
+				state,
+				pipeline
+			};
+		};
+		const poller = new EmailPoller({
+			bootstrap,
+			status,
+			log
+		});
+		handle.poller = poller;
+		poller.start();
+	});
+}
+function describeVersion(value) {
+	return typeof value === "string" ? value.slice(0, 64) : "no version";
+}
+var plugin_default = {
+	...plugin,
+	register: plugin.activate.bind(plugin)
+};
+//#endregion
+Object.defineProperty(exports, "PLUGIN_ID", {
+	enumerable: true,
+	get: function() {
+		return PLUGIN_ID;
+	}
+});
+Object.defineProperty(exports, "parsePluginConfig", {
+	enumerable: true,
+	get: function() {
+		return parsePluginConfig;
+	}
+});
+Object.defineProperty(exports, "plugin_default", {
+	enumerable: true,
+	get: function() {
+		return plugin_default;
+	}
+});