@agentcomms/resend 0.27.1 → 0.29.0

package/dist/{send-BbyDPqGS.mjs → send-BC8FI-_F.mjs}

@@ -1,19 +1,20 @@
-import { C as unknown, S as union, b as strictObject, c as boolean, g as object, h as number, i as _enum, l as discriminatedUnion, m as looseObject, n as datetime, p as literal$1, s as array, x as string, y as record } from "./iso-5-9R47LC.mjs";
-import { access, chmod, constants, link, lstat, mkdir, open, readFile, readdir, readlink, realpath, rename, rm, stat, unlink, utimes } from "node:fs/promises";
+import { C as unknown, S as union$1, b as strictObject, c as boolean, g as object, h as number, i as _enum, l as discriminatedUnion, m as looseObject, n as datetime, p as literal$1, s as array, x as string, y as record } from "./iso-5-9R47LC.mjs";
+import { execFile, spawn } from "node:child_process";
+import { createHash, randomBytes, randomInt, timingSafeEqual } from "node:crypto";
+import { accessSync, constants, existsSync, lstatSync, readFileSync, readlinkSync, realpathSync, statSync } from "node:fs";
+import { access, chmod, constants as constants$1, link, lstat, mkdir, open, readFile, readdir, readlink, realpath, rename, rm, stat, unlink, utimes } from "node:fs/promises";
+import { homedir, platform, userInfo } from "node:os";
 import path, { basename, delimiter, dirname, extname, isAbsolute, join, posix, relative, resolve, sep, win32 } from "node:path";
 import { domainToASCII, fileURLToPath, pathToFileURL } from "node:url";
-import { createHash, randomBytes, randomInt, timingSafeEqual } from "node:crypto";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import "node:readline/promises";
 import { styleText } from "node:util";
-import { homedir, platform, userInfo } from "node:os";
-import { accessSync, constants as constants$1, lstatSync, readFileSync, readlinkSync, realpathSync, statSync } from "node:fs";
-import { execFile, spawn } from "node:child_process";
 import { gunzipSync } from "node:zlib";
+import { AsyncLocalStorage } from "node:async_hooks";
 //#endregion
 //#region src/version.ts
 /** The package version, read from package.json at build time. */
-const VERSION$2 = "0.27.1";
+const VERSION$2 = "0.29.0";
 //#endregion
 //#region src/api/routes.ts
 /**
@@ -201,8 +202,70 @@ const RESEND_CALLER = Object.freeze({
 	url: import.meta.url,
 	packageName: PACKAGE_NAME
 });
-//#endregion
-//#region ../core/dist/update-check-BVv--MbW.mjs
+Object.freeze(["on", "off"]);
+/** Whether `value` is a retention a person can set: a whole number of days from 1 to 365. */
+function isActivityRetention(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 365;
+}
+function isActivityRecordSetting(value) {
+	return value === "on" || value === "off";
+}
+/** The `activity` block as the file holds it, raw: an object, or nothing. */
+function storedActivity(config) {
+	const stored = config.activity;
+	return typeof stored === "object" && stored !== null && !Array.isArray(stored) ? stored : null;
+}
+/**
+* The settings in force for `config`. A missing block, or a missing key, is the default. Anything else this release
+* cannot read is named in `problems`, and read so that nothing is recorded and nothing is deleted: a word other than
+* `on` or `off` as `off`; a retention that is not a whole number from 1 to 365 — out of range, a fraction, not a
+* number — as 365 days with recording `off`; a block that is not an object as both.
+*/
+function readActivitySettings(config) {
+	const problems = [];
+	if (config.activity === void 0) return {
+		record: "on",
+		retentionDays: 30,
+		problems
+	};
+	const stored = storedActivity(config);
+	if (stored === null) {
+		problems.push(`activity in config.json is not an object, so recording is off and 365 days are kept`);
+		return {
+			record: "off",
+			retentionDays: 365,
+			problems
+		};
+	}
+	let record = "on";
+	if (stored.record !== void 0) {
+		if (isActivityRecordSetting(stored.record)) record = stored.record;
+		else {
+			record = "off";
+			problems.push(`activity.record is ${describe(stored.record)}, not on or off, so recording is off`);
+		}
+	}
+	let retentionDays = 30;
+	const days = stored.retentionDays;
+	if (days !== void 0) {
+		if (isActivityRetention(days)) retentionDays = days;
+		else {
+			retentionDays = 365;
+			record = "off";
+			problems.push(`activity.retentionDays is ${describe(days)}, not a whole number from 1 to 365, so recording is off and 365 days are kept`);
+		}
+	}
+	return {
+		record,
+		retentionDays,
+		problems
+	};
+}
+/** A stored value in a sentence: short, and never more than a few dozen characters of whatever the file held. */
+function describe(value) {
+	const text = typeof value === "string" ? JSON.stringify(value) : String(JSON.stringify(value) ?? value);
+	return text.length > 40 ? `${text.slice(0, 39)}…` : text;
+}
 /**
 * Every failure a user or an agent can act on carries a specific, stable code from this registry, a message, an
 * optional one-line hint and structured `details`. The code decides the process exit status; agents and skills branch
@@ -402,22 +465,6 @@ function toCommsError(value) {
 	if (isCommsError(value)) return value;
 	return new CommsError("UNEXPECTED", value instanceof Error ? value.message : String(value), { cause: value });
 }
-function sha256Hex(data) {
-	return createHash("sha256").update(data).digest("hex");
-}
-/** Lower-cases the address part of `Name <addr>` or a bare address; display names are dropped. */
-function normaliseAddress(value) {
-	return (/<([^<>]+)>\s*$/.exec(value)?.[1] ?? value).trim().toLowerCase();
-}
-function collapseWhitespace(text) {
-	return text.replace(/\s+/g, " ").trim();
-}
-/** Deterministic JSON: keys sorted at every level, undefined members dropped. */
-function canonicalJson$1(value) {
-	if (Array.isArray(value)) return `[${value.map(canonicalJson$1).join(",")}]`;
-	if (value && typeof value === "object") return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson$1(v)}`).join(",")}}`;
-	return JSON.stringify(value);
-}
 /** Creates a directory (and parents) readable only by the current user. Tightens an existing one. */
 async function ensurePrivateDir(path) {
 	await mkdir(path, {
@@ -535,6 +582,1267 @@ async function syncDirectory(path) {
 		await handle.close();
 	}
 }
+/** True when a path exists and is readable or writable by someone other than its owner (POSIX only). */
+async function isGroupOrWorldAccessible(path) {
+	if (process.platform === "win32") return false;
+	return ((await stat(path)).mode & 63) !== 0;
+}
+/**
+* The activity log (design 2026-10-25-activity, §4 with S1–S5): one line for every call an agent session makes that
+* reads or writes account data, tied to the session that made it — what it touched, never what it said.
+*
+* - **Where:** `<state>/activity/YYYY-MM-DD.jsonl` (the UTC day of the line), each file owner-only (600) in an
+*   owner-only folder (700), each line appended whole with `appendPrivateLine`, as the audit log's are. Daily files,
+*   so retention drops whole days (`prune`).
+* - **What a line holds:** `ActivityLine`, and nothing else. Every line is rebuilt field by field from the fields a
+*   line has (`activityLineOf`), so a channel that hands over a whole message — body, text, HTML, attachment bytes —
+*   still writes only its id, subject and sender: the type says so, and the copy makes it so. Subjects and names are
+*   kept as received, cut to their bounds, and shown only inside the untrusted-content envelope.
+* - **Never in the way:** `append` never throws into its caller. A line that cannot be written is said once per
+*   process on stderr, remembered for `doctor`, and the call it describes goes on (§4.6).
+* - **The audit log is unchanged.** It stays small, content-free and shareable; this one is private.
+*/
+/** What the call did with account data: read it, wrote it, was told of it (an event delivery, S1), or approved it. */
+const ACTIVITY_KINDS = Object.freeze([
+	"read",
+	"write",
+	"told",
+	"approval"
+]);
+/** How it ended: done, refused by a policy, an approval or a rule, or failed. */
+const ACTIVITY_OUTCOMES = Object.freeze([
+	"ok",
+	"refused",
+	"failed"
+]);
+/** Which kind of process recorded it: an MCP server, a CLI call, or the event service's own work. */
+const ACTIVITY_SURFACES = Object.freeze([
+	"mcp",
+	"cli",
+	"daemon"
+]);
+/**
+* The most a line may take as written, its newline included: 16 KiB, well inside the one write `appendPrivateLine`
+* makes of it, so a line is always whole or absent, whatever its items hold. Past it, `fitted` cuts it.
+*/
+const MAX_ACTIVITY_LINE_BYTES = 16384;
+const BOUNDS = {
+	id: 200,
+	name: 200,
+	address: 320,
+	fileName: 255,
+	conversation: 200,
+	query: 500,
+	reason: 300,
+	word: 100,
+	alias: 128,
+	folder: 4096,
+	startedAt: 64,
+	version: 64
+};
+const MAX_RECIPIENTS$1 = 50;
+const MAX_COUNTS = 10;
+const SESSION_KEY = /^[0-9a-f]{16}$/;
+const ISO_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+const DAY_FILE = /^(\d{4}-\d{2}-\d{2})\.jsonl$/;
+const DAY_MS$1 = 864e5;
+/** `value` cut to `max` characters — whole characters, never half a surrogate pair — ending in `…` when cut. */
+function cut(value, max) {
+	if (typeof value !== "string") return void 0;
+	if (value.length <= max) return value;
+	const chars = Array.from(value.slice(0, max * 2 + 2));
+	return chars.length <= max ? chars.join("") : `${chars.slice(0, max - 1).join("")}…`;
+}
+function whole(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.round(value) : void 0;
+}
+function isoDay(at) {
+	return new Date(at).toISOString().slice(0, 10);
+}
+function own$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function itemOf$1(raw) {
+	const item = own$3(raw);
+	const id = cut(item?.id, BOUNDS.id);
+	if (item === void 0 || id === void 0) return null;
+	const sender = own$3(item.from);
+	const from = sender === void 0 ? void 0 : {
+		...typeof sender.name === "string" ? { name: cut(sender.name, BOUNDS.name) } : {},
+		...typeof sender.address === "string" ? { address: cut(sender.address, BOUNDS.address) } : {}
+	};
+	const size = whole(item.size);
+	return {
+		id,
+		...typeof item.subject === "string" ? { subject: cut(item.subject, 200) } : {},
+		...from !== void 0 && Object.keys(from).length > 0 ? { from } : {},
+		...typeof item.name === "string" ? { name: cut(item.name, BOUNDS.fileName) } : {},
+		...size !== void 0 ? { size } : {},
+		...typeof item.conversation === "string" ? { conversation: cut(item.conversation, BOUNDS.conversation) } : {}
+	};
+}
+function clientOf(raw) {
+	const client = own$3(raw);
+	const name = cut(client?.name, BOUNDS.word);
+	if (name === void 0 || name === "") return void 0;
+	const version = cut(client?.version, BOUNDS.version);
+	return {
+		name,
+		...version ? { version } : {}
+	};
+}
+/** A parent in this exact key order — the order `sessionOfAncestor` finds it by. */
+function parentOf(raw) {
+	const parent = own$3(raw);
+	const pid = whole(parent?.pid);
+	const startedAt = cut(parent?.startedAt, BOUNDS.startedAt);
+	if (pid === void 0 || startedAt === void 0) return void 0;
+	return {
+		pid,
+		startedAt,
+		name: cut(parent?.name, BOUNDS.word) ?? ""
+	};
+}
+function sessionOf(raw) {
+	const session = own$3(raw) ?? {};
+	const key = typeof session.key === "string" && SESSION_KEY.test(session.key) ? session.key : null;
+	const surface = ACTIVITY_SURFACES.includes(session.surface) ? session.surface : "mcp";
+	const client = clientOf(session.client);
+	const parent = parentOf(session.parent);
+	const ancestors = Array.isArray(session.ancestors) ? session.ancestors.slice(0, 3).flatMap((name) => typeof name === "string" ? [cut(name, BOUNDS.word) ?? ""] : []) : void 0;
+	return {
+		key: key ?? randomKey(),
+		process: cut(session.process, BOUNDS.word) ?? PROCESS_ID,
+		pid: whole(session.pid) ?? 0,
+		...client === void 0 ? {} : { client },
+		folder: typeof session.folder === "string" ? cut(session.folder, BOUNDS.folder) ?? null : null,
+		...parent === void 0 ? {} : { parent },
+		...ancestors === void 0 ? {} : { ancestors },
+		grouped: key !== null && session.grouped === true,
+		surface
+	};
+}
+/**
+* The line as it is written: every field copied from what a line has, each cut to its bound, in one fixed order.
+* Anything else the input carries — a body, a text, an HTML part, bytes — is not copied, whatever it is called.
+*/
+function activityLineOf(input, now = /* @__PURE__ */ new Date()) {
+	return fitted(boundedLine(input, now));
+}
+/** How many bytes a line takes as written, its newline included. */
+function bytesOf(line) {
+	return Buffer.byteLength(JSON.stringify(line)) + 1;
+}
+/**
+* The line, cut until it fits in `MAX_ACTIVITY_LINE_BYTES`, and marked `truncated` when it was: items from the end
+* first — `count` keeps how many there were — then recipients from the end, then the longer words shortened, and
+* last the words that are not the line's own dropped. Text a sender wrote can be many times its length as JSON (a
+* control character is six bytes), so the bounds on each field alone do not bound the line.
+*/
+function fitted(line) {
+	if (bytesOf(line) <= 16384) return line;
+	const items = [...line.items ?? []];
+	const recipients = [...line.recipients ?? []];
+	let cutLine = {
+		...line,
+		truncated: true
+	};
+	const fits = () => bytesOf(cutLine) <= MAX_ACTIVITY_LINE_BYTES;
+	while (items.length > 0 && !fits()) {
+		items.pop();
+		cutLine = {
+			...cutLine,
+			items: [...items]
+		};
+	}
+	while (recipients.length > 0 && !fits()) {
+		recipients.pop();
+		cutLine = {
+			...cutLine,
+			recipients: [...recipients]
+		};
+	}
+	if (fits()) return cutLine;
+	const short = (text, max) => text === void 0 ? void 0 : cut(text, max);
+	const { ancestors: _ancestors, ...session } = cutLine.session;
+	cutLine = {
+		...cutLine,
+		channel: short(cutLine.channel, 40) ?? "",
+		operation: short(cutLine.operation, 64) ?? "",
+		account: {
+			id: short(cutLine.account.id, 64) ?? "",
+			alias: short(cutLine.account.alias, 64) ?? ""
+		},
+		session: {
+			...session,
+			folder: cutLine.session.folder === null ? null : short(cutLine.session.folder, 256) ?? null,
+			...session.client === void 0 ? {} : { client: {
+				name: short(session.client.name, 40) ?? "",
+				...session.client.version === void 0 ? {} : { version: short(session.client.version, 20) }
+			} },
+			...session.parent === void 0 ? {} : { parent: {
+				...session.parent,
+				name: short(session.parent.name, 40) ?? ""
+			} }
+		},
+		...cutLine.reason === void 0 ? {} : { reason: short(cutLine.reason, 100) },
+		...cutLine.query === void 0 ? {} : { query: short(cutLine.query, 100) },
+		...cutLine.told === void 0 ? {} : { told: {
+			rule: short(cutLine.told.rule, 60) ?? "",
+			target: short(cutLine.told.target, 60) ?? ""
+		} }
+	};
+	if (fits()) return cutLine;
+	const { reason: _reason, query: _query, told: _told, counts: _counts, ...rest } = cutLine;
+	return {
+		...rest,
+		truncated: true
+	};
+}
+/** The line every field of it bounded, before the line as a whole is (`fitted`). */
+function boundedLine(input, now) {
+	const raw = input;
+	const at = typeof raw.at === "string" && ISO_TIME.test(raw.at) ? raw.at : now.toISOString();
+	const account = own$3(raw.account);
+	const items = Array.isArray(raw.items) ? raw.items : void 0;
+	const kept = items?.slice(0, 50).flatMap((item) => itemOf$1(item) ?? []);
+	const given = whole(raw.count);
+	const count = items === void 0 ? given : Math.max(items.length, given ?? 0);
+	const counts = own$3(raw.counts);
+	const keptCounts = counts === void 0 ? void 0 : Object.fromEntries(Object.entries(counts).filter(([name, value]) => /^[a-z][A-Za-z]{0,31}$/.test(name) && whole(value) !== void 0).slice(0, MAX_COUNTS).map(([name, value]) => [name, whole(value)]));
+	const recipients = Array.isArray(raw.recipients) ? raw.recipients.slice(0, MAX_RECIPIENTS$1).flatMap((address) => typeof address === "string" ? [cut(address, BOUNDS.address)] : []) : void 0;
+	const told = own$3(raw.told);
+	const reason = cut(raw.reason, BOUNDS.reason);
+	const query = cut(raw.query, BOUNDS.query);
+	const approvalId = typeof raw.approvalId === "string" && /^[A-Za-z0-9_-]{1,64}$/.test(raw.approvalId) ? raw.approvalId : void 0;
+	return {
+		at,
+		channel: cut(raw.channel, BOUNDS.word) ?? "",
+		account: {
+			id: cut(account?.id, BOUNDS.alias) ?? "",
+			alias: cut(account?.alias, BOUNDS.alias) ?? ""
+		},
+		operation: cut(raw.operation, BOUNDS.word) ?? "",
+		kind: ACTIVITY_KINDS.includes(raw.kind) ? raw.kind : "read",
+		outcome: ACTIVITY_OUTCOMES.includes(raw.outcome) ? raw.outcome : "ok",
+		...reason ? { reason } : {},
+		session: sessionOf(raw.session),
+		ms: whole(raw.ms) ?? 0,
+		...kept === void 0 ? {} : { items: kept },
+		...count === void 0 ? {} : { count },
+		...keptCounts === void 0 || Object.keys(keptCounts).length === 0 ? {} : { counts: keptCounts },
+		...query === void 0 ? {} : { query },
+		...recipients === void 0 ? {} : { recipients },
+		...approvalId === void 0 ? {} : { approvalId },
+		...told === void 0 ? {} : { told: {
+			rule: cut(told.rule, BOUNDS.name) ?? "",
+			target: cut(told.target, BOUNDS.name) ?? ""
+		} },
+		...raw.truncated === true ? { truncated: true } : {}
+	};
+}
+/** A line read back from a file: one this release can show, or null for anything else. */
+function readLine(text) {
+	let raw;
+	try {
+		raw = JSON.parse(text);
+	} catch {
+		return null;
+	}
+	const line = own$3(raw);
+	if (line === void 0 || typeof line.at !== "string" || !ISO_TIME.test(line.at)) return null;
+	const session = own$3(line.session);
+	if (typeof session?.key !== "string" || !SESSION_KEY.test(session.key)) return null;
+	return activityLineOf(line);
+}
+function emptyKinds() {
+	return {
+		read: 0,
+		write: 0,
+		told: 0,
+		approval: 0
+	};
+}
+function emptyOutcomes() {
+	return {
+		ok: 0,
+		refused: 0,
+		failed: 0
+	};
+}
+function aggregateOf(line) {
+	const kind = emptyKinds();
+	kind[line.kind] += 1;
+	const outcome = emptyOutcomes();
+	outcome[line.outcome] += 1;
+	return {
+		key: line.session.key,
+		grouped: line.session.grouped,
+		surfaces: [line.session.surface],
+		primary: {
+			at: line.at,
+			cli: line.session.surface === "cli",
+			folder: line.session.folder,
+			client: line.session.client ?? null,
+			parent: line.session.parent ?? null
+		},
+		firstSeen: line.at,
+		lastSeen: line.at,
+		processes: [line.session.process],
+		channels: line.channel ? [line.channel] : [],
+		accounts: line.account.alias ? [line.account.alias] : [],
+		kind,
+		outcome
+	};
+}
+function union(a, b) {
+	return [.../* @__PURE__ */ new Set([...a, ...b])];
+}
+/** Two aggregates of one session, added together. */
+function merge(a, b) {
+	const first = (x, y) => x.cli !== y.cli ? x.cli ? y : x : x.at <= y.at ? x : y;
+	const primary = first(a.primary, b.primary);
+	const other = primary === a.primary ? b.primary : a.primary;
+	const kind = emptyKinds();
+	const outcome = emptyOutcomes();
+	for (const name of ACTIVITY_KINDS) kind[name] = a.kind[name] + b.kind[name];
+	for (const name of ACTIVITY_OUTCOMES) outcome[name] = a.outcome[name] + b.outcome[name];
+	return {
+		key: a.key,
+		grouped: a.grouped || b.grouped,
+		surfaces: union(a.surfaces, b.surfaces),
+		primary: {
+			...primary,
+			client: primary.client ?? other.client,
+			parent: primary.parent ?? other.parent
+		},
+		firstSeen: a.firstSeen <= b.firstSeen ? a.firstSeen : b.firstSeen,
+		lastSeen: a.lastSeen >= b.lastSeen ? a.lastSeen : b.lastSeen,
+		processes: union(a.processes, b.processes),
+		channels: union(a.channels, b.channels),
+		accounts: union(a.accounts, b.accounts),
+		kind,
+		outcome
+	};
+}
+function add(groups, aggregate) {
+	const held = groups.get(aggregate.key);
+	groups.set(aggregate.key, held === void 0 ? aggregate : merge(held, aggregate));
+}
+function summaryOf$1(aggregate) {
+	return {
+		key: aggregate.key,
+		grouped: aggregate.grouped,
+		surfaces: [...aggregate.surfaces].sort(),
+		folder: aggregate.primary.folder,
+		client: aggregate.primary.client,
+		parent: aggregate.primary.parent,
+		firstSeen: aggregate.firstSeen,
+		lastSeen: aggregate.lastSeen,
+		processes: aggregate.processes.length,
+		channels: [...aggregate.channels].sort(),
+		accounts: [...aggregate.accounts].sort(),
+		counts: {
+			kind: { ...aggregate.kind },
+			outcome: { ...aggregate.outcome }
+		}
+	};
+}
+/** A day's aggregates read back from its index: trusted only as far as their shape, and dropped whole otherwise. */
+function aggregatesOf(raw) {
+	if (!Array.isArray(raw)) return null;
+	const strings = (value) => Array.isArray(value) && value.every((each) => typeof each === "string");
+	for (const each of raw) {
+		const held = own$3(each);
+		if (held === void 0 || typeof held.key !== "string" || !SESSION_KEY.test(held.key) || typeof held.firstSeen !== "string" || typeof held.lastSeen !== "string" || own$3(held.primary) === void 0 || own$3(held.kind) === void 0 || own$3(held.outcome) === void 0 || !strings(held.processes) || !strings(held.channels) || !strings(held.accounts) || !strings(held.surfaces)) return null;
+	}
+	return raw;
+}
+const FAILURE_FILE = "activity-failure.json";
+const INDEX_DIR = ".index";
+/**
+* Each day's server windows: one small line for each server process's window on that day — its key, parent and
+* folder — so a CLI call finds the window it runs in without reading the day (`sessionOfAncestor`).
+*/
+const PARENTS_DIR = ".parents";
+const DEFAULT_SHOW_LIMIT = 1e3;
+const ON_BY_DEFAULT = Object.freeze({
+	record: "on",
+	retentionDays: 30,
+	problems: []
+});
+const UNREADABLE = Object.freeze({
+	record: "off",
+	retentionDays: 365,
+	problems: ["the configuration could not be read, so nothing is recorded"]
+});
+/** The once-a-process line, when the stderr default is used: one process, one line, however many logs it opens. */
+let warnedOnStderr = false;
+function codeOf$1(error) {
+	if (error instanceof CommsError) return error.code;
+	const code = error?.code;
+	return typeof code === "string" ? code : "error";
+}
+function messageOf$2(error) {
+	return cut(error instanceof Error ? error.message : String(error), BOUNDS.reason) ?? "unknown";
+}
+var ActivityLog = class {
+	directory;
+	#failureFile;
+	#now;
+	#settings;
+	#warn;
+	#failure = null;
+	#failureWrittenAt = 0;
+	#warned = false;
+	#prunedDay = null;
+	/** The days this process has made sure of a parents file for, and the windows it has noted there, by day. */
+	#parentsReady = /* @__PURE__ */ new Set();
+	#parentsNoted = /* @__PURE__ */ new Set();
+	constructor(stateDir, options = {}) {
+		this.directory = join(stateDir, "activity");
+		this.#failureFile = join(stateDir, FAILURE_FILE);
+		this.#now = options.now ?? (() => /* @__PURE__ */ new Date());
+		this.#settings = options.settings ?? (async () => ON_BY_DEFAULT);
+		this.#warn = options.warn;
+	}
+	/** The last line this process could not write, or null. */
+	get lastFailure() {
+		return this.#failure;
+	}
+	/**
+	* Appends one line, unless recording is off. True when it was written. Never throws: a line that cannot be written
+	* is said once per process (`warn`, stderr by default), recorded beside the log for `doctor`, and returns false.
+	*
+	* The first call a process makes on each day — this, or any read — first prunes days older than the retention in
+	* force, whether or not recording is on: the log's daily maintenance, best effort.
+	*/
+	async append(input) {
+		if ((await this.#maintained()).record !== "on") return false;
+		try {
+			const line = activityLineOf(input, this.#now());
+			await appendPrivateLine(join(this.directory, `${line.at.slice(0, 10)}.jsonl`), JSON.stringify(line));
+			await this.#noteParent(line);
+			if (this.#failure !== null) {
+				this.#failure = null;
+				await rm(this.#failureFile, { force: true }).catch(() => void 0);
+			}
+		} catch (error) {
+			await this.#failed(error);
+			return false;
+		}
+		return true;
+	}
+	async #failed(error) {
+		const now = this.#now();
+		const failure = {
+			at: now.toISOString(),
+			code: codeOf$1(error),
+			message: messageOf$2(error),
+			pid: process.pid
+		};
+		this.#failure = failure;
+		const said = `agent-communications: activity is not being recorded: ${failure.message}`;
+		if (this.#warn !== void 0) {
+			if (!this.#warned) this.#warn(said);
+		} else if (!warnedOnStderr) {
+			warnedOnStderr = true;
+			process.stderr.write(`${said}\n`);
+		}
+		this.#warned = true;
+		if (now.getTime() - this.#failureWrittenAt < 6e4) return;
+		this.#failureWrittenAt = now.getTime();
+		await writeFileAtomic(this.#failureFile, `${JSON.stringify(failure)}\n`).catch(() => void 0);
+	}
+	/**
+	* The day's parents file, made on a process's first line of the day — so a reader can tell a day with no window
+	* from one an earlier build wrote, with no index — and a grouped server's window noted in it once a day. Best
+	* effort: without it a CLI call reads the day itself.
+	*/
+	async #noteParent(line) {
+		const day = line.at.slice(0, 10);
+		const path = join(this.directory, PARENTS_DIR, `${day}.jsonl`);
+		try {
+			if (!this.#parentsReady.has(day)) {
+				await ensurePrivateDir(join(this.directory, PARENTS_DIR));
+				await (await open(path, "a", 384)).close();
+				this.#parentsReady.add(day);
+			}
+			const { session } = line;
+			if (session.surface !== "mcp" || !session.grouped || session.parent === void 0) return;
+			const noted = `${day}\0${session.key}`;
+			if (this.#parentsNoted.has(noted)) return;
+			await appendPrivateLine(path, JSON.stringify({
+				key: session.key,
+				parent: session.parent,
+				folder: session.folder
+			}));
+			this.#parentsNoted.add(noted);
+		} catch {}
+	}
+	/** The windows noted on `day`, or null when the day has no parents file (an earlier build wrote it, or none). */
+	async #parentsOf(day) {
+		let text;
+		try {
+			text = await readFile(join(this.directory, PARENTS_DIR, `${day}.jsonl`), "utf8");
+		} catch {
+			return null;
+		}
+		return text.split("\n").flatMap((raw) => {
+			if (!raw) return [];
+			try {
+				const held = own$3(JSON.parse(raw));
+				const parent = parentOf(held?.parent);
+				const key = held?.key;
+				if (typeof key !== "string" || !SESSION_KEY.test(key) || parent === void 0) return [];
+				return [{
+					key,
+					parent,
+					folder: typeof held?.folder === "string" ? held.folder : null
+				}];
+			} catch {
+				return [];
+			}
+		});
+	}
+	/** The settings in force, read afresh; a reader that throws reads as `UNREADABLE` — off, and every day kept. */
+	async #settingsNow() {
+		try {
+			return await this.#settings();
+		} catch {
+			return UNREADABLE;
+		}
+	}
+	/**
+	* The settings in force, after the day's maintenance: the first call a process makes on a day — an append or a read,
+	* recording on or off — deletes the days past the retention. Never throws.
+	*/
+	async #maintained() {
+		const settings = await this.#settingsNow();
+		const today = isoDay(this.#now().getTime());
+		if (this.#prunedDay !== today) {
+			this.#prunedDay = today;
+			await this.prune(settings.retentionDays).catch(() => void 0);
+		}
+		return settings;
+	}
+	/** The first day the retention in force keeps: any day before it is never shown, deleted yet or not. */
+	#cutoff(retentionDays) {
+		return isoDay(this.#now().getTime() - retentionDays * DAY_MS$1);
+	}
+	/** The days held, oldest first. */
+	async days() {
+		let names;
+		try {
+			names = await readdir(this.directory);
+		} catch (error) {
+			const code = error.code;
+			if (code === "ENOENT" || code === "ENOTDIR") return [];
+			throw error;
+		}
+		return names.flatMap((name) => DAY_FILE.exec(name)?.[1] ?? []).sort();
+	}
+	/**
+	* Deletes every day whose last line is older than `retentionDays` days: a day goes once all of it is that old, so
+	* every line is kept at least that long and at most a day longer. Whole days only; every other day is left whole.
+	*/
+	async prune(retentionDays) {
+		if (!isActivityRetention(retentionDays)) throw new CommsError("USAGE", `the activity log keeps a whole number of days, 1 to 365, not ${String(retentionDays)}`);
+		const cutoff = this.#cutoff(retentionDays);
+		const deleted = [];
+		for (const day of await this.days()) {
+			if (day >= cutoff) continue;
+			await rm(join(this.directory, `${day}.jsonl`), { force: true });
+			await rm(join(this.directory, INDEX_DIR, `${day}.json`), { force: true }).catch(() => void 0);
+			await rm(join(this.directory, PARENTS_DIR, `${day}.jsonl`), { force: true }).catch(() => void 0);
+			deleted.push(day);
+		}
+		return { deleted };
+	}
+	async #lines(day) {
+		const text = await this.#text(day);
+		return text === null ? [] : text.split("\n").flatMap((raw) => raw ? readLine(raw) ?? [] : []);
+	}
+	async #text(day) {
+		try {
+			return await readFile(join(this.directory, `${day}.jsonl`), "utf8");
+		} catch (error) {
+			if (error.code === "ENOENT") return null;
+			throw error;
+		}
+	}
+	/**
+	* A whole past day's sessions, from its index when the index was made from the file as it is now, else from the
+	* file — and the index written again, best effort. Today's is never indexed: it is still being written.
+	*/
+	async #dayAggregates(day) {
+		const file = join(this.directory, `${day}.jsonl`);
+		const index = join(this.directory, INDEX_DIR, `${day}.json`);
+		let mark;
+		try {
+			const info = await stat(file);
+			mark = `${info.size}:${info.mtimeMs}`;
+		} catch {
+			return [];
+		}
+		try {
+			const held = JSON.parse(await readFile(index, "utf8"));
+			const sessions = held.version === 1 && held.mark === mark ? aggregatesOf(held.sessions) : null;
+			if (sessions !== null) return sessions;
+		} catch {}
+		const groups = /* @__PURE__ */ new Map();
+		for (const line of await this.#lines(day)) add(groups, aggregateOf(line));
+		const sessions = [...groups.values()];
+		await writeFileAtomic(index, `${JSON.stringify({
+			version: 1,
+			mark,
+			sessions
+		})}\n`).catch(() => void 0);
+		return sessions;
+	}
+	/**
+	* Every session with a line at or after `since` (every day the retention keeps, when left out), newest first. A day
+	* past the retention is never read, whether or not it has been deleted yet.
+	*/
+	async sessions(options = {}) {
+		const since = options.since;
+		const today = isoDay(this.#now().getTime());
+		const cutoff = this.#cutoff((await this.#maintained()).retentionDays);
+		const groups = /* @__PURE__ */ new Map();
+		for (const day of await this.days()) {
+			if (day < cutoff) continue;
+			if (since !== void 0 && `${day}T23:59:59.999Z` < since) continue;
+			if ((since === void 0 || since <= `${day}T00:00:00.000Z`) && day < today) {
+				for (const aggregate of await this.#dayAggregates(day)) add(groups, aggregate);
+				continue;
+			}
+			for (const line of await this.#lines(day)) if (since === void 0 || line.at >= since) add(groups, aggregateOf(line));
+		}
+		return [...groups.values()].map(summaryOf$1).sort((a, b) => a.lastSeen === b.lastSeen ? a.key.localeCompare(b.key) : a.lastSeen < b.lastSeen ? 1 : -1);
+	}
+	/**
+	* One session's lines, newest first, that match every filter given; and its summary over the time asked. Only
+	* lines whose session key is exactly `key` are ever read into the answer, and none of a day past the retention.
+	*/
+	async show(key, filters = {}) {
+		if (!SESSION_KEY.test(key)) throw new CommsError("USAGE", `"${cut(key, 40)}" is not a session key`);
+		const cutoff = this.#cutoff((await this.#maintained()).retentionDays);
+		const limit = filters.limit ?? DEFAULT_SHOW_LIMIT;
+		const since = filters.since;
+		const needle = `"key":"${key}"`;
+		const lines = [];
+		let matched = 0;
+		let summary = null;
+		const days = (await this.days()).filter((day) => day >= cutoff).reverse();
+		for (const day of days) {
+			if (since !== void 0 && `${day}T23:59:59.999Z` < since) break;
+			const text = await this.#text(day);
+			if (text === null) continue;
+			const raws = text.split("\n");
+			for (let index = raws.length - 1; index >= 0; index -= 1) {
+				const raw = raws[index];
+				if (!raw.includes(needle)) continue;
+				const line = readLine(raw);
+				if (line === null || line.session.key !== key) continue;
+				if (since !== void 0 && line.at < since) continue;
+				const aggregate = aggregateOf(line);
+				summary = summary === null ? aggregate : merge(summary, aggregate);
+				if (!matches(line, filters)) continue;
+				lines.push(line);
+				matched += 1;
+				if (lines.length >= limit * 2) {
+					lines.sort(newestFirst);
+					lines.length = limit;
+				}
+			}
+		}
+		lines.sort(newestFirst);
+		if (lines.length > limit) lines.length = limit;
+		return {
+			lines,
+			more: matched > limit,
+			summary: summary === null ? null : summaryOf$1(summary)
+		};
+	}
+	/**
+	* The window a CLI call belongs to (S2): the session of a server process, today or yesterday, whose parent is one of
+	* `ancestors` — the nearest first. Null when none is. Read from each day's parents file; a day with none — written
+	* by an earlier build — is read whole, as before.
+	*/
+	async sessionOfAncestor(ancestors) {
+		const now = this.#now().getTime();
+		const noted = [];
+		const texts = [];
+		for (const day of [isoDay(now), isoDay(now - DAY_MS$1)]) {
+			const parents = await this.#parentsOf(day);
+			if (parents !== null) {
+				noted.push(...parents);
+				continue;
+			}
+			const text = await this.#text(day).catch(() => null);
+			if (text !== null) texts.push(text);
+		}
+		for (const ancestor of ancestors) {
+			const found = noted.find((each) => each.parent.pid === ancestor.pid && each.parent.startedAt === ancestor.startedAt);
+			if (found !== void 0) return found;
+			const needle = `"parent":{"pid":${ancestor.pid},"startedAt":${JSON.stringify(ancestor.startedAt)}`;
+			for (const text of texts) {
+				let from = text.indexOf(needle);
+				while (from !== -1) {
+					const start = text.lastIndexOf("\n", from) + 1;
+					const end = text.indexOf("\n", from);
+					const line = readLine(text.slice(start, end === -1 ? text.length : end));
+					const parent = line?.session.parent;
+					if (line?.session.grouped && line.session.surface === "mcp" && parent?.pid === ancestor.pid && parent.startedAt === ancestor.startedAt) return {
+						key: line.session.key,
+						parent,
+						folder: line.session.folder
+					};
+					from = text.indexOf(needle, from + needle.length);
+				}
+			}
+		}
+		return null;
+	}
+	/** The last failure recorded by any process — the newer of the file beside the log and this process's own. */
+	async readFailure() {
+		let stored = null;
+		try {
+			const raw = own$3(JSON.parse(await readFile(this.#failureFile, "utf8")));
+			if (raw !== void 0 && typeof raw.at === "string" && ISO_TIME.test(raw.at)) stored = {
+				at: raw.at,
+				code: cut(raw.code, BOUNDS.word) ?? "error",
+				message: cut(raw.message, BOUNDS.reason) ?? "unknown",
+				pid: whole(raw.pid) ?? 0
+			};
+		} catch {}
+		const mine = this.#failure;
+		if (mine === null) return stored;
+		if (stored === null) return mine;
+		return mine.at >= stored.at ? mine : stored;
+	}
+	/**
+	* What `doctor` shows of the log. It creates nothing; like every read it first deletes the days past the retention,
+	* once a day per process, so the days it lists past the retention are those that could not be deleted.
+	*/
+	async health() {
+		await this.#maintained();
+		const today = isoDay(this.#now().getTime());
+		let exists = false;
+		let isDirectory = true;
+		try {
+			const info = await stat(this.directory);
+			exists = true;
+			isDirectory = info.isDirectory();
+		} catch {}
+		const days = exists && isDirectory ? await this.days().catch(() => []) : [];
+		let lastWritten = null;
+		const newest = days.at(-1);
+		if (newest !== void 0) lastWritten = await stat(join(this.directory, `${newest}.jsonl`)).then((info) => info.mtime.toISOString(), () => null);
+		const state = join(this.directory, "..");
+		const target = days.includes(today) ? join(this.directory, `${today}.jsonl`) : exists ? this.directory : existsSync(state) ? state : null;
+		const writable = isDirectory && (target === null || await access(target, constants$1.W_OK).then(() => true, () => false));
+		const loose = exists && isDirectory ? await isGroupOrWorldAccessible(this.directory).catch(() => false) : false;
+		return {
+			directory: this.directory,
+			exists,
+			isDirectory,
+			private: !exists || !isDirectory || process.platform === "win32" ? null : !loose,
+			writable,
+			days,
+			lastWritten,
+			failure: await this.readFailure()
+		};
+	}
+};
+/** Newest first; lines of one time in the order they were met. */
+function newestFirst(a, b) {
+	return a.at === b.at ? 0 : a.at < b.at ? 1 : -1;
+}
+function matches(line, filters) {
+	if (filters.kind !== void 0 && line.kind !== filters.kind) return false;
+	if (filters.outcome !== void 0 && line.outcome !== filters.outcome) return false;
+	if (filters.channel !== void 0 && line.channel !== filters.channel) return false;
+	if (filters.account !== void 0 && line.account.alias !== filters.account && line.account.id !== filters.account) return false;
+	return true;
+}
+/** `ps -o ppid=,lstart=,comm=` in the C locale: the parent, the start as five words, and the executable — last. */
+const PS_LINE = /^\s*(\d+)\s+([A-Z][a-z]{2}\s+[A-Z][a-z]{2}\s+\d{1,2}\s+\d{1,2}:\d{2}:\d{2}\s+\d{4})\s+(.+?)\s*$/;
+/** One process's line of `ps -o ppid=,lstart=,comm=`, or null for anything else. The name is the executable's own. */
+function parsePsLine(text) {
+	const first = text.split("\n").find((row) => row.trim() !== "");
+	const match = first === void 0 ? null : PS_LINE.exec(first);
+	if (match === null) return null;
+	const command = match[3];
+	const name = command.includes("/") ? command.split("/").at(-1) ?? command : command;
+	return {
+		ppid: Number(match[1]),
+		startedAt: match[2].replace(/\s+/g, " "),
+		name
+	};
+}
+const PS_PROGRAMS = ["/bin/ps", "/usr/bin/ps"];
+/**
+* This machine's `ps`, by its full path, in the C locale so the start reads the same in every process, bounded by
+* `timeoutMs`. Never on Windows: no query there answers inside the bound (PowerShell alone takes longer to start),
+* so a Windows process is ungrouped.
+*/
+const psProbe = (pid, timeoutMs) => new Promise((resolve) => {
+	const program = PS_PROGRAMS.find((path) => existsSync(path));
+	if (process.platform === "win32" || program === void 0) {
+		resolve(null);
+		return;
+	}
+	try {
+		execFile(program, [
+			"-o",
+			"ppid=,lstart=,comm=",
+			"-p",
+			String(pid)
+		], {
+			timeout: Math.max(1, Math.round(timeoutMs)),
+			env: {
+				LC_ALL: "C",
+				LANG: "C",
+				PATH: "/bin:/usr/bin"
+			},
+			maxBuffer: 65536,
+			windowsHide: true
+		}, (error, stdout) => resolve(error ? null : parsePsLine(String(stdout)))).on("error", () => resolve(null));
+	} catch {
+		resolve(null);
+	}
+});
+function randomKey() {
+	return randomBytes(8).toString("hex");
+}
+/**
+* What a process has worked out of its session: its random ids, its background reads of its parent, and a CLI call's
+* identity. One per process (`sessionIdentity` keeps its own); a test makes its own.
+*/
+var SessionIdentityCache = class {
+	/** A random id this process made when it started (§4.3). */
+	processId = randomBytes(6).toString("hex");
+	/** The key of this process's own session, when it is not grouped with others. */
+	ownKey = randomKey();
+};
+/** Each cache's background reads, and its CLI identity by log: held here, so the class shows only its ids. */
+const READS = /* @__PURE__ */ new WeakMap();
+const CLI_IDENTITIES = /* @__PURE__ */ new WeakMap();
+function heldIn(map, cache) {
+	let held = map.get(cache);
+	if (held === void 0) {
+		held = /* @__PURE__ */ new Map();
+		map.set(cache, held);
+	}
+	return held;
+}
+const PROCESS_CACHE = new SessionIdentityCache();
+/** This process's own random id: a line handed in without one names this process. */
+const PROCESS_ID = PROCESS_CACHE.processId;
+/** `promise`, or null after `ms`. Its timer is not unref'd: whoever awaits it keeps the process alive till then. */
+function within$2(promise, ms) {
+	return new Promise((resolve) => {
+		const timer = setTimeout(() => resolve(null), Math.max(0, ms));
+		promise.then((value) => {
+			clearTimeout(timer);
+			resolve(value);
+		}, () => {
+			clearTimeout(timer);
+			resolve(null);
+		});
+	});
+}
+function folderOf(options) {
+	try {
+		return (options.cwd ?? (() => process.cwd()))();
+	} catch {
+		return null;
+	}
+}
+async function readAncestry(options, depth, initIsParent, budgetMs) {
+	const platform = options.platform ?? process.platform;
+	const pid = options.pid ?? process.pid;
+	const folder = folderOf(options);
+	const chain = [];
+	if (platform === "win32") return {
+		pid,
+		folder,
+		chain,
+		complete: true
+	};
+	const probe = options.probe ?? psProbe;
+	const deadline = Date.now() + budgetMs;
+	let next = options.ppid ?? process.ppid;
+	while (chain.length < depth && (next > 1 || initIsParent && next === 1 && chain.length === 0)) {
+		const left = deadline - Date.now();
+		if (left <= 0) return {
+			pid,
+			folder,
+			chain,
+			complete: false
+		};
+		const facts = await within$2(probe(next, left), left);
+		if (facts === null) return {
+			pid,
+			folder,
+			chain,
+			complete: false
+		};
+		chain.push({
+			pid: next,
+			startedAt: facts.startedAt,
+			name: facts.name,
+			ppid: facts.ppid
+		});
+		if (next === 1) break;
+		next = facts.ppid;
+	}
+	return {
+		pid,
+		folder,
+		chain,
+		complete: true
+	};
+}
+/**
+* The background read of this process's parent, begun if none is under way or kept: a read that finished is kept for
+* good, one under way is waited on, and one that ran out of time is begun again once a minute has passed.
+*/
+function ancestryRead(cache, options, initIsParent) {
+	const id = initIsParent ? "daemon" : "server";
+	const now = (options.now ?? Date.now)();
+	const reads = heldIn(READS, cache);
+	const held = reads.get(id);
+	if (held !== void 0 && (held.settled === null || held.settled.complete || now - held.at < 6e4)) return held;
+	const read = {
+		at: now,
+		settled: null,
+		promise: readAncestry(options, 1, initIsParent, options.budgetMs ?? 2e3)
+	};
+	read.promise.then((ancestry) => {
+		read.settled = ancestry;
+	}, () => void 0);
+	reads.set(id, read);
+	return read;
+}
+/**
+* Begins working out this process's session in the background, as an MCP server or the event service starts, so its
+* first calls find it done: a read of its parent of up to `SESSION_IDENTITY_BACKGROUND_MS`. Returns at once; never
+* throws. A CLI call reads its own, and is not warmed.
+*/
+function warmSessionIdentity(surface = "mcp", options = {}) {
+	if (surface === "cli") return;
+	try {
+		ancestryRead(options.cache ?? PROCESS_CACHE, options, surface === "daemon");
+	} catch {}
+}
+function windowKey(parent, folder, connection) {
+	const named = connection === void 0 || connection === "" ? "" : `\0${connection}`;
+	return createHash("sha256").update(`${parent.pid}\0${parent.startedAt}\0${folder}${named}`).digest("hex").slice(0, 16);
+}
+/** System folders, each with everything under it: no project is started there. */
+const POSIX_SYSTEM_TREES = [
+	"/System",
+	"/Library",
+	"/Applications",
+	"/usr",
+	"/bin",
+	"/sbin",
+	"/etc",
+	"/dev",
+	"/proc",
+	"/sys",
+	"/boot"
+];
+/** Folders that hold everyone's projects, or anyone's temporary files — only the folder itself, not what is in it. */
+const POSIX_SHARED = [
+	"/tmp",
+	"/var",
+	"/private",
+	"/private/tmp",
+	"/private/var",
+	"/opt",
+	"/Volumes",
+	"/mnt",
+	"/media"
+];
+const WINDOWS_SYSTEM_TREES = [
+	"\\windows",
+	"\\program files",
+	"\\program files (x86)",
+	"\\programdata"
+];
+/**
+* Whether a folder is one that cannot tell projects apart (S3): a filesystem's root, the home folder or a folder above
+* it, a system folder or anything in one, or a shared one such as `/tmp`. A client that starts every server from one
+* process there — a desktop app started in `/`, say — would otherwise make every project it serves one session.
+*/
+function sharedFolder(folder, home, platform = process.platform) {
+	if (platform === "win32") {
+		const plain = (path) => path.replace(/\//g, "\\").replace(/\\+$/, "").toLowerCase();
+		const at = plain(folder);
+		const homeAt = plain(home);
+		if (/^[a-z]:$/.test(at) || at === "") return true;
+		if (homeAt !== "" && (at === homeAt || homeAt.startsWith(`${at}\\`))) return true;
+		const rest = at.replace(/^[a-z]:/, "");
+		return rest === "\\users" || WINDOWS_SYSTEM_TREES.some((tree) => rest === tree || rest.startsWith(`${tree}\\`));
+	}
+	const plain = (path) => (path.length > 1 ? path.replace(/\/+$/, "") : path) || "/";
+	const at = plain(folder);
+	const homeAt = plain(home);
+	if (at === "/") return true;
+	if (homeAt !== "/" && (at === homeAt || homeAt.startsWith(`${at}/`))) return true;
+	if (POSIX_SHARED.includes(at)) return true;
+	return POSIX_SYSTEM_TREES.some((tree) => at === tree || at.startsWith(`${tree}/`));
+}
+/**
+* Which session this process's calls belong to (S2): its id, its parent's id, start and name, its folder and the
+* session key. Never throws.
+*
+* - **An MCP server** (`mcp`) is grouped with every other server its parent started in the same folder: one agent
+*   window. Its parent is read in the background — begun by `warmSessionIdentity` as the server starts, or by its first
+*   call — for up to two seconds; a call waits for it about 200 ms and, when it is not done, goes on alone for now. A
+*   read that ran out of time is not kept: one a minute or more later tries again. A parent that has gone, a folder
+*   that cannot be read, and a folder that cannot tell projects apart (`sharedFolder`: `/`, the home folder, a system
+*   folder) leave it ungrouped, with a key of its own.
+* - **A CLI call** (`cli`) reads up to three processes above it, within about 200 ms. When one of them is the parent
+*   of a server process that recorded a line today (or yesterday) in `options.log`, the call joins that window's
+*   session; otherwise it is a session of its own. Its `ancestors` name those processes either way.
+* - **The event service** (`daemon`) is grouped by its parent too, process 1 included, whatever its folder — it serves
+*   no project — so it is one session since it started. It waits for the whole read: it records on a timer, and keeps
+*   what it is given.
+* - **On Windows** no process is grouped: a query of a process's parent and start does not answer within the bound.
+*
+* `clientInfo` is what an MCP client said it is; it is stored as that, and nothing depends on it.
+*/
+async function sessionIdentity(surface, clientInfo, options = {}) {
+	const seams = options.pid !== void 0 || options.ppid !== void 0 || options.cwd !== void 0 || options.probe !== void 0 || options.platform !== void 0 || options.budgetMs !== void 0 || options.waitMs !== void 0 || options.home !== void 0 || options.now !== void 0;
+	const cache = options.cache ?? (seams ? null : PROCESS_CACHE);
+	const client = clientOf(clientInfo);
+	try {
+		if (surface === "cli" && cache !== null) {
+			const directory = options.log?.directory ?? "";
+			const identities = heldIn(CLI_IDENTITIES, cache);
+			let held = identities.get(directory);
+			if (held === void 0) {
+				held = identityOf$1(surface, options, cache);
+				identities.set(directory, held);
+			}
+			return {
+				...await held,
+				...client === void 0 ? {} : { client }
+			};
+		}
+		return {
+			...await identityOf$1(surface, options, cache),
+			...client === void 0 ? {} : { client }
+		};
+	} catch {
+		return {
+			key: cache?.ownKey ?? randomKey(),
+			process: cache?.processId ?? PROCESS_ID,
+			pid: options.pid ?? process.pid,
+			...client === void 0 ? {} : { client },
+			folder: null,
+			grouped: false,
+			surface
+		};
+	}
+}
+async function identityOf$1(surface, options, cache) {
+	const own = cache?.ownKey ?? randomKey();
+	const processId = cache?.processId ?? randomBytes(6).toString("hex");
+	const parentOfChain = (chain, index) => {
+		const held = chain[index];
+		return held === void 0 ? void 0 : {
+			pid: held.pid,
+			startedAt: held.startedAt,
+			name: held.name
+		};
+	};
+	if (surface === "cli") {
+		const { pid, folder, chain } = await readAncestry(options, 3, false, options.budgetMs ?? 200);
+		const base = {
+			process: processId,
+			pid,
+			folder,
+			surface
+		};
+		const ancestors = chain.map((held) => held.name);
+		const parents = chain.map((_, index) => parentOfChain(chain, index));
+		const joined = parents.length > 0 && options.log ? await options.log.sessionOfAncestor(parents) : null;
+		if (joined !== null) return {
+			key: joined.key,
+			...base,
+			parent: joined.parent,
+			ancestors,
+			grouped: true
+		};
+		const parent = parentOfChain(chain, 0);
+		return {
+			key: own,
+			...base,
+			...parent === void 0 ? {} : { parent },
+			ancestors,
+			grouped: false
+		};
+	}
+	const initIsParent = surface === "daemon";
+	let ancestry;
+	if (cache === null) ancestry = await readAncestry(options, 1, initIsParent, options.budgetMs ?? 200);
+	else {
+		const read = ancestryRead(cache, options, initIsParent);
+		const wait = initIsParent ? options.budgetMs ?? 2e3 : options.waitMs ?? 200;
+		ancestry = read.settled ?? await within$2(read.promise, wait);
+	}
+	if (ancestry === null) return {
+		key: own,
+		process: processId,
+		pid: options.pid ?? process.pid,
+		folder: folderOf(options),
+		grouped: false,
+		surface
+	};
+	const { pid, folder, chain } = ancestry;
+	const base = {
+		process: processId,
+		pid,
+		folder,
+		surface
+	};
+	const parent = parentOfChain(chain, 0);
+	const home = options.home ?? homedir();
+	const shared = !initIsParent && folder !== null && sharedFolder(folder, home, options.platform ?? process.platform);
+	if (parent === void 0 || folder === null || shared) return {
+		key: own,
+		...base,
+		...parent === void 0 ? {} : { parent },
+		grouped: false
+	};
+	return {
+		key: windowKey(parent, folder, options.connection),
+		...base,
+		parent,
+		grouped: true
+	};
+}
+/**
+* Records one line in `core`'s activity log. Never throws, and never fails the call it describes: a line that cannot
+* be written is reported by the log itself (`ActivityLog.append`). Recording off writes nothing.
+*
+* For a line a channel builds itself — the event service's `told` lines (S1), say. Around an operation, use
+* `withActivity`, which times it and records how it ended.
+*/
+async function recordActivity(core, line) {
+	try {
+		await core.activity.append(line);
+	} catch {}
+}
+/** The refusals a call can end in — a policy, an approval, a rule, a cap or a usage mistake — rather than a failure. */
+const REFUSED_CODES = /* @__PURE__ */ new Set([
+	"APPROVAL_REQUIRED",
+	"APPROVAL_PENDING",
+	"APPROVAL_EXPIRED",
+	"APPROVAL_VOID",
+	"SEND_REFUSED",
+	"POLICY_NEVER",
+	"ACT_NOT_ALLOWED",
+	"STANDING_REFUSED",
+	"STANDING_LIMIT",
+	"RATE_CAPPED",
+	"LOOSENING_REFUSED",
+	"USAGE",
+	"WHATSAPP_VISIBILITY_SEAM_REQUIRED"
+]);
+function failureDetail(error) {
+	const code = error instanceof CommsError ? error.code : "UNEXPECTED";
+	return {
+		outcome: REFUSED_CODES.has(code) ? "refused" : "failed",
+		reason: `${code}: ${messageOf$2(error)}`
+	};
+}
+async function recordCall(context, operation, kind, ms, detail) {
+	try {
+		const clientInfo = typeof context.clientInfo === "function" ? context.clientInfo() : context.clientInfo;
+		const session = context.session ?? await sessionIdentity(context.surface, clientInfo, {
+			log: context.core.activity,
+			connection: typeof context.connection === "function" ? context.connection() : context.connection
+		});
+		const query = detail.query ?? context.query;
+		await recordActivity(context.core, {
+			channel: context.channel,
+			account: detail.account ?? context.account,
+			operation,
+			kind,
+			outcome: detail.outcome ?? "ok",
+			...detail.reason === void 0 ? {} : { reason: detail.reason },
+			session,
+			ms,
+			...detail.items === void 0 ? {} : { items: detail.items },
+			...detail.count === void 0 ? {} : { count: detail.count },
+			...detail.counts === void 0 ? {} : { counts: detail.counts },
+			...query === void 0 ? {} : { query },
+			...detail.recipients === void 0 ? {} : { recipients: detail.recipients },
+			...detail.approvalId === void 0 ? {} : { approvalId: detail.approvalId },
+			...detail.told === void 0 ? {} : { told: detail.told }
+		});
+	} catch {}
+}
+/**
+* Runs one operation and records its line (§8): times `fn`, and when it returns records `describe(result)` as `ok`
+* (or the outcome `describe` names); when it throws, records `refused` for a policy's, an approval's or a rule's
+* refusal and `failed` for anything else, with the error's code and message as the reason, and throws the same error
+* on. What it returns, or throws, is exactly what `fn` did: recording never changes or fails the call, and a
+* `describe` that throws records the line without its details.
+*
+* `operationId` is the capability id in `capabilities.json` (`gmail.search`); `kind` is `read`, `write`, `told` or
+* `approval`.
+*
+* @example
+*   const found = await withActivity(
+*     { core, channel: 'gmail', surface: 'mcp', account: { id: inbox.id, alias }, clientInfo: () => server.getClientVersion() },
+*     'gmail.search',
+*     'read',
+*     () => search(core, request),
+*     (result) => ({ query: request.query, count: result.total, items: result.messages.map((m) => ({ id: m.id, subject: m.subject, from: m.from })) }),
+*   );
+*/
+async function withActivity(context, operationId, kind, fn, describe) {
+	const started = performance.now();
+	let result;
+	try {
+		result = await fn();
+	} catch (error) {
+		await recordCall(context, operationId, kind, performance.now() - started, failureDetail(error));
+		throw error;
+	}
+	const ms = performance.now() - started;
+	let detail = {};
+	try {
+		detail = describe(result) ?? {};
+	} catch {
+		detail = {};
+	}
+	await recordCall(context, operationId, kind, ms, detail);
+	return result;
+}
+function sha256Hex(data) {
+	return createHash("sha256").update(data).digest("hex");
+}
+/** Lower-cases the address part of `Name <addr>` or a bare address; display names are dropped. */
+function normaliseAddress(value) {
+	return (/<([^<>]+)>\s*$/.exec(value)?.[1] ?? value).trim().toLowerCase();
+}
+function collapseWhitespace(text) {
+	return text.replace(/\s+/g, " ").trim();
+}
+/** Deterministic JSON: keys sorted at every level, undefined members dropped. */
+function canonicalJson$1(value) {
+	if (Array.isArray(value)) return `[${value.map(canonicalJson$1).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson$1(v)}`).join(",")}}`;
+	return JSON.stringify(value);
+}
 /**
 * Opening `wx` failed because someone else holds the path — retry, rather than failing the command.
 *
@@ -3681,7 +4989,7 @@ async function launcherCanStart(runtimeDir, name) {
 	const cli = launcherCli(runtimeDir, name);
 	try {
 		if (!(await stat(cli)).isFile()) return false;
-		await access(cli, constants$1.R_OK);
+		await access(cli, constants.R_OK);
 		return true;
 	} catch {
 		return false;
@@ -3692,7 +5000,7 @@ function launcherCanStartSync(runtimeDir, name) {
 	const cli = launcherCli(runtimeDir, name);
 	try {
 		if (!statSync(cli).isFile()) return false;
-		accessSync(cli, constants$1.R_OK);
+		accessSync(cli, constants.R_OK);
 		return true;
 	} catch {
 		return false;
@@ -3981,7 +5289,7 @@ function nodeProgram(env, platform = process.platform) {
 		const candidate = join(directory, name);
 		try {
 			if (!statSync(candidate).isFile()) continue;
-			accessSync(candidate, constants$1.X_OK);
+			accessSync(candidate, constants.X_OK);
 			if (!sameRealPath(realpathSync(candidate), real, platform)) continue;
 			return sameRealPath(candidate, own, platform) ? own : candidate;
 		} catch {}
@@ -4237,8 +5545,8 @@ function managedShimStarting(context, binary, entry) {
 		if (recorded === void 0 || recorded.path !== path) return null;
 		if (!lstatSync(path).isFile() || sha256(readFileSync(path, "utf8")) !== recorded.digest) return null;
 		if (realpathSync(recorded.entry) !== realpathSync(entry)) return null;
-		accessSync(recorded.node, constants$1.X_OK);
-		accessSync(path, constants$1.X_OK);
+		accessSync(recorded.node, constants.X_OK);
+		accessSync(path, constants.X_OK);
 		return publicPath;
 	} catch {
 		return null;
@@ -4542,7 +5850,7 @@ async function executableIn(name, directories, env) {
 	for (const directory of paths) for (const extension of extensions) {
 		const candidate = join(directory, name + extension.toLowerCase());
 		try {
-			await access(candidate, constants.X_OK);
+			await access(candidate, constants$1.X_OK);
 			return candidate;
 		} catch {}
 	}
@@ -4745,7 +6053,7 @@ async function installManagedRuntime(context, product, version) {
 async function findNpmCli() {
 	const candidates = [join(dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js"), join(dirname(process.execPath), "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")];
 	for (const candidate of candidates) try {
-		await access(candidate, constants.R_OK);
+		await access(candidate, constants$1.R_OK);
 		return resolve(candidate);
 	} catch {}
 	throw new CommsError("CONFIG", "npm could not be found next to this Node installation", { hint: "Install with `--launcher npx` instead, which runs the published package directly." });
@@ -4879,7 +6187,7 @@ async function localCliEntry(moduleUrl) {
 		join(here, "..", "cli.mjs")
 	];
 	for (const candidate of candidates) try {
-		await access(candidate, constants.R_OK);
+		await access(candidate, constants$1.R_OK);
 		return resolve(candidate);
 	} catch {}
 	throw new CommsError("UNEXPECTED", "cannot find this package's own command to register");
@@ -7127,14 +8435,14 @@ async function resolveInsideRoot(root, target) {
 async function createUniqueFile(directory, filename) {
 	const extension = extname(filename);
 	const stem = extension ? filename.slice(0, -extension.length) : filename;
-	const noFollow = process.platform === "win32" ? 0 : constants$1.O_NOFOLLOW;
+	const noFollow = process.platform === "win32" ? 0 : constants.O_NOFOLLOW;
 	for (let attempt = 1; attempt < 1e3; attempt += 1) {
 		const name = attempt === 1 ? filename : `${stem}-${attempt}${extension}`;
 		const path = join(directory, name);
 		try {
 			return {
 				path,
-				handle: await open(path, constants$1.O_WRONLY | constants$1.O_CREAT | constants$1.O_EXCL | noFollow, 384)
+				handle: await open(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | noFollow, 384)
 			};
 		} catch (error) {
 			if (error.code === "EEXIST") continue;
@@ -7477,7 +8785,7 @@ const configV1Schema = looseObject({
 	version: literal$1(1),
 	...v1BodyShape
 }).superRefine(checkV1Body);
-const servesSchema = union([literal$1("any"), looseObject({ domains: array(string().min(1)).min(1) })]);
+const servesSchema = union$1([literal$1("any"), looseObject({ domains: array(string().min(1)).min(1) })]);
 const generationSchema = looseObject({
 	name: aliasSchema,
 	clientId: string().min(1),
@@ -7633,7 +8941,7 @@ const configV3Naming2Schema = looseObject({
 	...v2BodyShape,
 	...v3Shape
 }).superRefine(checkV2Body);
-union([configV3Naming1Schema, configV3Naming2Schema]);
+union$1([configV3Naming1Schema, configV3Naming2Schema]);
 function schemaFor(version, naming = 2) {
 	if (version === 3) return naming === 1 ? configV3Naming1Schema : configV3Naming2Schema;
 	return version === 2 ? configV2Schema : configV1Schema;
@@ -8440,6 +9748,10 @@ function classifyChange(before, after) {
 		const levels = behaviourLevels(behaviour.deltas);
 		loosen("behaviour.rules", levels.before, levels.after);
 	}
+	const activityBefore = readActivitySettings(before);
+	const activityAfter = readActivitySettings(after);
+	if (activityBefore.record === "off" && activityAfter.record === "on") loosen("activity.record", activityBefore.record, activityAfter.record);
+	if (activityAfter.retentionDays > activityBefore.retentionDays) loosen("activity.retentionDays", activityBefore.retentionDays, activityAfter.retentionDays);
 	return {
 		loosened: changes.map((change) => change.path),
 		changes
@@ -8523,7 +9835,7 @@ const ACCOUNT_SETTINGS = [
 ];
 /**
 * Every setting that differs between `before` and `after`, loosened or tightened: the defaults, the secret store,
-* the agent label's settings, the behaviour rules, and each mailbox's and account's own settings — including those of
+* the agent label's settings, the behaviour rules, the activity log's, and each mailbox's and account's own settings — including those of
 * one added or removed.
 *
 * What a change approval binds, beside its loosenings. A preview shows the whole change — "sends approved by never;
@@ -8566,6 +9878,8 @@ function changedSettings(before, after) {
 	const labelAfter = storedAgentLabel(after);
 	for (const key of LABEL_SETTINGS) record(`agentLabel.${key}`, labelBefore[key], labelAfter[key]);
 	record("behaviour.rules", storedBehaviourRules(before), storedBehaviourRules(after));
+	record("activity.record", storedActivity(before)?.record, storedActivity(after)?.record);
+	record("activity.retentionDays", storedActivity(before)?.retentionDays, storedActivity(after)?.retentionDays);
 	return changes;
 }
 /** The behaviour rules as the file holds them — raw, ids and all, as `changedSettings` records every setting. */
@@ -12996,7 +14310,7 @@ function folding(platform) {
 	return platform === "win32" ? (text) => text.toLowerCase() : (text) => text;
 }
 /** The package version, read from package.json at build time. */
-const VERSION = "0.27.1";
+const VERSION = "0.29.0";
 /**
 * The command a person is told to run for one of this suite's own CLIs (design 2026-10-04, D1 and D5; CUE-403).
 *
@@ -13373,7 +14687,7 @@ function stableLauncher(dataDir, packageName, version, platform) {
 		const name = launcherName(packageName);
 		const { launcher } = launcherPaths(dataDir, name);
 		if (!statSync(launcher).isFile()) return null;
-		accessSync(launcher, platform === "win32" ? constants$1.R_OK : constants$1.X_OK);
+		accessSync(launcher, platform === "win32" ? constants.R_OK : constants.X_OK);
 		const pointer = readPointerSync(dataDir, name);
 		if (pointer === void 0 || !launcherCanStartSync(pointer.current, name)) return null;
 		const started = readPackageManifest(join(pointer.current, "node_modules", ...packageName.split("/")));
@@ -13546,7 +14860,7 @@ function checkedEntry(root, entry) {
 			ok: false,
 			why: `${entry} is not a file`
 		};
-		accessSync(real, constants$1.R_OK);
+		accessSync(real, constants.R_OK);
 	} catch {
 		return {
 			ok: false,
@@ -14319,7 +15633,9 @@ const SETTING_LABELS = {
 	"agentLabel.rules": "who each kind of message appears to come from",
 	"agentLabel.slackIcons": "the icon of the agent’s Slack posts",
 	"agentLabel.slackStyles": "how the agent’s Slack messages look",
-	"behaviour.rules": "what an agent may do"
+	"behaviour.rules": "what an agent may do",
+	"activity.record": "recording what agent sessions read and send",
+	"activity.retentionDays": "how many days the activity log keeps"
 };
 /**
 * What the loosening means for the person, in their terms.
@@ -14351,6 +15667,8 @@ function meaning(field, after, scope) {
 		case "agentLabel.slackIcons": return "the app’s Slack posts will show this icon beside your name";
 		case "agentLabel.slackStyles": return "every agent message there goes out as you, labelled in its words, even where the app could post: it trades Slack’s own APP tag, which no one can fake, for words in the message";
 		case "behaviour.rules": return "where it allows more, an agent may start those acts; each one still waits for your yes";
+		case "activity.record": return "every call an agent session makes to your accounts will be recorded on this machine again: the subjects and senders it read, what it searched for, what it sent and to whom — never a message body";
+		case "activity.retentionDays": return "what agent sessions read and sent — subjects, senders, searches, recipients — will be kept on this machine for longer";
 		default: return "";
 	}
 }
@@ -14843,7 +16161,7 @@ var FileSecretStore = class {
 	}
 	async get(ref) {
 		try {
-			const handle = await open(this.#path(ref), constants$1.O_RDONLY | constants$1.O_NOFOLLOW);
+			const handle = await open(this.#path(ref), constants.O_RDONLY | constants.O_NOFOLLOW);
 			let raw;
 			try {
 				raw = await handle.readFile("utf8");
@@ -15284,7 +16602,7 @@ strictObject({
 		clientId: string().regex(GOOGLE_CLIENT_ID_PATTERN, "a Google client id is digits, a hyphen, then .apps.googleusercontent.com"),
 		clientSecret: string().regex(/^[\x20-\x7e]{1,256}$/, "the client secret is 1–256 printable ASCII characters"),
 		projectId: string().regex(/^[a-z][a-z0-9-]{4,28}[a-z0-9]$/, "a Google Cloud project id is 6–30 lowercase letters, digits or hyphens").optional(),
-		serves: union([literal$1("any"), strictObject({ domains: array(string().regex(DOMAIN_PATTERN, "each domain is a lower-case host name")).min(1).max(50) })])
+		serves: union$1([literal$1("any"), strictObject({ domains: array(string().regex(DOMAIN_PATTERN, "each domain is a lower-case host name")).min(1).max(50) })])
 	}).optional(),
 	slack: strictObject({
 		workspace: string().regex(SLACK_WORKSPACE_ID_PATTERN, "a Slack workspace id is T followed by capital letters or digits"),
@@ -15325,7 +16643,7 @@ function shownPath(path) {
 async function readBounded(path, what) {
 	let handle;
 	try {
-		handle = await open(path, constants$1.O_RDONLY | (constants$1.O_NONBLOCK ?? 0));
+		handle = await open(path, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0));
 	} catch (error) {
 		return what.unopened(error);
 	}
@@ -16050,6 +17368,10 @@ function openCore(options = {}) {
 		plans: new PlanStore(paths.stateDir, now),
 		taint: new TaintStore(paths.stateDir, now),
 		audit,
+		activity: new ActivityLog(paths.stateDir, {
+			now,
+			settings: async () => readActivitySettings(await config.load())
+		}),
 		handoffs,
 		async secrets(kind) {
 			const chosen = kind ?? secretsStoreOf(await config.load());
@@ -16741,7 +18063,7 @@ async function corePackageRoot() {
 	}
 	throw new CommsError("UNEXPECTED", "cannot find the @agentcomms/core package this is running from");
 }
-const exists = (path) => access(path, constants.R_OK).then(() => true, () => false);
+const exists = (path) => access(path, constants$1.R_OK).then(() => true, () => false);
 /**
 * A module URL inside a channel's package, for the `local` launcher, which registers a checkout's own code.
 *
@@ -17191,7 +18513,7 @@ function serverPruneChange(core, env, request, own) {
 	};
 	const { packageName, version } = ownProduct(request.channel, own) ?? {
 		packageName: serverFacts(request.channel).packageName,
-		version: "0.27.1"
+		version: "0.29.0"
 	};
 	const product = {
 		packageName,
@@ -19339,7 +20661,7 @@ function terminalUpdateHooks(core, env, options = {}) {
 	} };
 }
 //#endregion
-//#region ../core/dist/tool-arguments-CxbRW3Ep.mjs
+//#region ../core/dist/tool-arguments-1XgEf3VM.mjs
 const APPLIED = Symbol.for("agentcomms.strictToolArguments");
 const TARGET = "draft-2020-12";
 /**
@@ -31782,6 +33104,11 @@ var ResendContext = class {
 	platform;
 	surface;
 	/**
+	* What the MCP client said it is (`clientInfo`), for the activity log's session: set by the server once it exists,
+	* read when a line is written, since a client says it only on connecting. Never set for the CLI.
+	*/
+	clientInfo = void 0;
+	/**
 	* What every result, refusal and hint names for a person to run: Resend's own CLI as this installation runs it, or
 	* core's through its installed dependency (`own`, `core`), quoted for `platform` — or why there is none here.
 	*/
@@ -32973,6 +34300,98 @@ async function runDoctor(context, options = {}) {
 	};
 }
 //#endregion
+//#region src/activity.ts
+/**
+* Resend's half of the activity log (design 2026-10-25-activity §4.2, §8 Task 2a): every operation a capability row
+* names that reads or writes a Resend account records one line, through core's `withActivity`, from inside the
+* operation — so the command and the tool that run it record the same line.
+*
+* - **One line per call.** An operation another recorded operation calls on its way records nothing of its own; the
+*   outer call is known by the async context it runs in, so two calls at once in one server are two lines.
+* - **What it touched, never what it said.** Ids, counts, subjects, senders' names and addresses, file names and
+*   sizes, a send's recipients and its approval — never a body, a preview or bytes. A field a result carries inside the
+*   untrusted-content envelope is taken out of it for the line (`plain`); the log wraps it again wherever it is shown.
+* - **Never in the way.** Working out the account never throws, and `withActivity` never changes what the call returns
+*   or throws.
+*/
+/** Set for the length of a recorded call: an operation it calls on its way records nothing of its own. */
+const recording = new AsyncLocalStorage();
+/** The account a line is recorded against, as known before the call: its id and its name, or the name alone. */
+async function accountOf(context, name) {
+	try {
+		return {
+			id: (await context.accounts.find(name))?.account.id ?? "",
+			alias: name
+		};
+	} catch {
+		return {
+			id: "",
+			alias: name
+		};
+	}
+}
+/**
+* Runs one Resend operation and records its line: `operation` is the capability id (`resend.emails.list`), `kind`
+* what it did, `account` the account's name as the call gives it. Inside another recorded call it only runs `fn`.
+*/
+async function recorded(context, operation, kind, account, fn, describe) {
+	if (recording.getStore() === true) return fn();
+	const named = await accountOf(context, account);
+	return recording.run(true, () => withActivity({
+		core: context.core,
+		channel: "resend",
+		surface: context.surface,
+		account: named,
+		clientInfo: () => context.clientInfo?.()
+	}, operation, kind, fn, describe));
+}
+/** What a read answers when its key cannot read: a refusal that comes back as a result, recorded as one. */
+function unavailable(result) {
+	return {
+		outcome: "refused",
+		reason: result.reason
+	};
+}
+const ENVELOPE = new RegExp(`^<${UNTRUSTED_TAG} boundary="([A-Za-z0-9_-]+)"[^>\\n]*>\\n([\\s\\S]*)\\n</${UNTRUSTED_TAG} boundary="\\1">$`);
+/**
+* A field as its sender wrote it: the text inside its untrusted-content envelope when it is wrapped, the field itself
+* when it is bare (a plain address), and undefined for nothing at all.
+*/
+function plain(field) {
+	if (typeof field !== "string" || field === "") return void 0;
+	return ENVELOPE.exec(field)?.[2] ?? field;
+}
+/** A sender from a `Name <address>` field, bare or wrapped: the name only when there is one. */
+function senderOfField(field) {
+	const text = plain(field);
+	if (text === void 0) return void 0;
+	const parsed = parseAddressList(text)[0];
+	if (parsed === void 0) return { address: text };
+	return {
+		...parsed.name ? { name: parsed.name } : {},
+		address: parsed.address
+	};
+}
+/** A sender from its two fields, each bare or wrapped. Undefined when there is neither. */
+function senderOf(from) {
+	const name = plain(from?.name ?? void 0);
+	const address = plain(from?.address ?? void 0);
+	if (name === void 0 && address === void 0) return void 0;
+	return {
+		...name === void 0 ? {} : { name },
+		...address === void 0 ? {} : { address }
+	};
+}
+/** One email touched: its id, and its subject and sender when it has them. */
+function itemOf(id, subject, from) {
+	const text = plain(subject ?? void 0);
+	return {
+		id,
+		...text === void 0 ? {} : { subject: text },
+		...from === void 0 ? {} : { from }
+	};
+}
+//#endregion
 //#region src/compose/inbound.ts
 /**
 * Turning what arrived — or what the team sent — into what an agent may read.
@@ -33360,8 +34779,11 @@ function domainRow(entry) {
 		createdAt: text(entry.created_at)
 	};
 }
-/** The team's domains; with `domain`, that one with the DNS records it needs. */
+/** The team's domains; with `domain`, that one with the DNS records it needs. Recorded by how many there are. */
 async function listDomains(context, name, options = {}) {
+	return recorded(context, "resend.domains", "read", name, () => domainsOf(context, name, options), (result) => result.available ? { count: result.domains.length } : unavailable(result));
+}
+async function domainsOf(context, name, options) {
 	return whenReadable(context, name, async (named, transport) => {
 		const domains = ((await resendRequest(transport, "GET", "/domains")).data ?? []).map(domainRow);
 		if (options.domain === void 0) return { domains };
@@ -33417,7 +34839,18 @@ function pageQuery(paging, fallback) {
 		after: cursorOf(paging.after)
 	};
 }
+/** A sent email as its activity line keeps it: its id, its subject and who it was from. */
+function sentItem(row) {
+	return itemOf(row.id, row.subject, senderOfField(row.from));
+}
+/** The emails the team sent, recorded by each one's id, subject and sender. */
 async function listSentEmails(context, name, paging = {}) {
+	return recorded(context, "resend.emails.list", "read", name, () => sentEmailsOf(context, name, paging), (result) => result.available ? {
+		count: result.emails.length,
+		items: result.emails.map(sentItem)
+	} : unavailable(result));
+}
+async function sentEmailsOf(context, name, paging) {
 	const query = pageQuery(paging, 20);
 	return whenReadable(context, name, async (_named, transport) => {
 		const page = await resendRequest(transport, "GET", "/emails", { query });
@@ -33435,7 +34868,11 @@ async function listSentEmails(context, name, paging = {}) {
 		};
 	});
 }
+/** One sent email, recorded by its id, subject and sender. */
 async function showSentEmail(context, name, id) {
+	return recorded(context, "resend.emails.show", "read", name, () => sentEmailOf(context, name, id), (result) => result.available ? { items: [sentItem(result.email)] } : unavailable(result));
+}
+async function sentEmailOf(context, name, id) {
 	const emailId = resendId(id, "email id");
 	return whenReadable(context, name, async (_named, transport) => {
 		const entry = await resendRequest(transport, "GET", `/emails/${emailId}`);
@@ -33516,7 +34953,14 @@ async function recordTaint(context, named, transport, collector, entries) {
 		internalDomains
 	});
 }
+/** The emails the team received, recorded by each one's id, subject and sender. */
 async function listReceived(context, name, paging = {}) {
+	return recorded(context, "resend.received.list", "read", name, () => receivedOf(context, name, paging), (result) => result.available ? {
+		count: result.emails.length,
+		items: result.emails.map((email) => itemOf(email.id, email.subject, senderOf(email.from)))
+	} : unavailable(result));
+}
+async function receivedOf(context, name, paging) {
 	const query = pageQuery(paging, 20);
 	return whenReadable(context, name, async (named, transport) => {
 		const page = await resendRequest(transport, "GET", "/emails/receiving", { query });
@@ -33552,7 +34996,16 @@ async function listReceived(context, name, paging = {}) {
 		};
 	});
 }
+/** One received email, recorded by its id, subject and sender. */
 async function showReceived(context, name, id) {
+	return recorded(context, "resend.received.show", "read", name, () => receivedEmailOf(context, name, id), (result) => {
+		if (!result.available) return unavailable(result);
+		const email = result.email;
+		const subject = typeof email.subject === "string" ? email.subject : void 0;
+		return { items: [itemOf(String(email.id ?? ""), subject, senderOf(email.from))] };
+	});
+}
+async function receivedEmailOf(context, name, id) {
 	const emailId = resendId(id, "email id");
 	return whenReadable(context, name, async (named, transport) => {
 		const entry = await resendRequest(transport, "GET", `/emails/receiving/${emailId}`);
@@ -33661,7 +35114,25 @@ async function downloadsRoot(context) {
 * path is the sender's: see {@link storedName}. The names they gave, and the types they declared, come back as their
 * own fields, wrapped where they are text; their addresses are recorded as tainted before the result is returned.
 */
+/** Saves a received email's attachments, recorded by each file's id, the name its sender gave it, and its size. */
 async function downloadReceived(context, name, id, options = {}) {
+	return recorded(context, "resend.received.download", "read", name, () => downloadReceivedOf(context, name, id, options), (result) => {
+		if (!result.available) return unavailable(result);
+		const items = result.files.map((file) => {
+			const filename = plain(file.filename);
+			return {
+				id: file.attachmentId,
+				...filename === void 0 ? {} : { name: filename },
+				size: file.size
+			};
+		});
+		return {
+			items,
+			counts: { saved: items.length }
+		};
+	});
+}
+async function downloadReceivedOf(context, name, id, options) {
 	const emailId = resendId(id, "email id");
 	const only = options.attachmentId === void 0 ? void 0 : resendId(options.attachmentId, "attachment id");
 	const subpath = relativeSubpath(options.out);
@@ -33733,7 +35204,11 @@ function dateOf(raw, name) {
 	if (typeof raw !== "string" || !DATE.test(raw.trim())) throw new CommsError("USAGE", `${name} must be a date like 2026-09-01, or an ISO 8601 time with a zone`);
 	return raw.trim();
 }
+/** The team's sending totals, recorded only as asked: they name no email. */
 async function getMetrics(context, name, range = {}) {
+	return recorded(context, "resend.metrics", "read", name, () => metricsOf(context, name, range), (result) => result.available ? {} : unavailable(result));
+}
+async function metricsOf(context, name, range) {
 	const start = dateOf(range.start, "start");
 	const end = dateOf(range.end, "end");
 	return whenReadable(context, name, async (_named, transport) => {
@@ -33756,7 +35231,11 @@ const ORIGINS = [
 	"complaint",
 	"manual"
 ];
+/** The addresses Resend will not send to, recorded by how many there are — never the addresses. */
 async function listSuppressions(context, name, options = {}) {
+	return recorded(context, "resend.suppressions", "read", name, () => suppressionsOf(context, name, options), (result) => result.available ? { count: result.suppressions.length } : unavailable(result));
+}
+async function suppressionsOf(context, name, options) {
 	const query = pageQuery(options, 20);
 	if (options.origin !== void 0 && !ORIGINS.includes(String(options.origin))) throw new CommsError("USAGE", `"${String(options.origin)}" is not an origin: use bounce, complaint or manual`);
 	return whenReadable(context, name, async (_named, transport) => {
@@ -33790,7 +35269,14 @@ async function listSuppressions(context, name, options = {}) {
 	});
 }
 const SCHEDULED_PAGES = 3;
+/** The emails waiting to go, recorded by each one's id, subject and sender. */
 async function listScheduled(context, name) {
+	return recorded(context, "resend.scheduled.list", "read", name, () => scheduledOf(context, name), (result) => result.available ? {
+		count: result.scheduled.length,
+		items: result.scheduled.map(sentItem)
+	} : unavailable(result));
+}
+async function scheduledOf(context, name) {
 	return whenReadable(context, name, async (named, transport) => {
 		const records = new SendRecords(context.core.paths.stateDir, context.now);
 		const envelope = {
@@ -33831,7 +35317,31 @@ async function listScheduled(context, name) {
 function messageOf$1(error) {
 	return error instanceof Error ? error.message : String(error);
 }
+/**
+* Cancelling one scheduled email, as a change the shared change flow plans and applies. Recorded in the activity log
+* as the write it is — the email's id, and how many recipients it had — when it is applied, or when the look before it
+* refuses; a call that only prepares the change's approval writes nothing to the account, and the approval store keeps
+* it.
+*/
 function cancelScheduledChange(context, name, id) {
+	const change = cancelChange(context, name, id);
+	return {
+		...change,
+		plan: async (config) => {
+			try {
+				return await change.plan(config);
+			} catch (error) {
+				await recorded(context, "resend.scheduled.cancel", "write", name, () => Promise.reject(error), () => ({})).catch(() => void 0);
+				throw error;
+			}
+		},
+		apply: (consent, request) => recorded(context, "resend.scheduled.cancel", "write", name, () => change.apply(consent, request), (cancelled) => ({
+			items: [{ id: cancelled.id }],
+			counts: { recipients: cancelled.recipients }
+		}))
+	};
+}
+function cancelChange(context, name, id) {
 	const emailId = resendId(id, "email id");
 	const look = async () => {
 		const named = await context.accounts.require(name);
@@ -34326,6 +35836,21 @@ async function attachPolicy(context) {
 * this exact content. Nothing is sent; preparing twice is free.
 */
 async function prepareSend(context, name, input) {
+	return recorded(context, "resend.send.prepare", "approval", name, () => prepareOneSend(context, name, input), (prepared) => ({
+		approvalId: prepared.approvalId,
+		items: [itemOf(prepared.approvalId, prepared.expect.subject)],
+		recipients: activityRecipients(prepared.expect)
+	}));
+}
+/** A send's recipients as its activity line keeps them: To, Cc and Bcc, as addresses. */
+function activityRecipients(expect) {
+	return [
+		...expect.to,
+		...expect.cc,
+		...expect.bcc
+	].flatMap((address) => plain(address) ?? []);
+}
+async function prepareOneSend(context, name, input) {
 	const { legacyDrain } = await ensureSendEpochConfig(context.core, { now: context.now });
 	const named = await context.accounts.require(name);
 	requireSendMode(named, context.handoffs);
@@ -34583,6 +36108,13 @@ function acceptedSaid(withId, scheduledAt) {
 * request, send — never retried, because a retried send may deliver twice.
 */
 async function executeSend(context, name, options) {
+	return recorded(context, "resend.send.execute", "write", name, () => sendApproved(context, name, options), (sent) => ({
+		approvalId: sent.approvalId,
+		items: [itemOf(sent.resendId ?? sent.approvalId, sent.subject)],
+		recipients: activityRecipients(sent)
+	}));
+}
+async function sendApproved(context, name, options) {
 	const { legacyDrain } = await ensureSendEpochConfig(context.core, { now: context.now });
 	const named = await context.accounts.require(name);
 	requireSendMode(named, context.handoffs);
@@ -34823,6 +36355,12 @@ function outcomeWords(outcome) {
 * machine's own record of a cancellation Resend confirmed; without it, a cancellation is as Resend reports it.
 */
 async function sendStatus(context, name, approvalId) {
+	return recorded(context, "resend.send.status", "read", name, () => statusOf(context, name, approvalId), (status) => ({
+		approvalId: status.approvalId,
+		...status.resend === null ? {} : { items: [{ id: status.resend.id }] }
+	}));
+}
+async function statusOf(context, name, approvalId) {
 	const named = await context.accounts.require(name);
 	const local = await new SendRecords(context.core.paths.stateDir, context.now).summary(named.account.id, approvalId);
 	const seen = await context.core.approvals.inspect(approvalId, {
@@ -35096,4 +36634,4 @@ async function revokeSendApproval(context, approvalId) {
 	});
 }
 //#endregion
-export { colorEnabled as $, removeAccountChange as A, waitCallOptions as At, strictToolArguments as B, VERSION$2 as Bt, inspectKey as C, serverPruneChange as Ct, policyChange as D, truncateDisplay as Dt, policyApprovalRefusal as E, toCommsError as Et, CHANGE_POLICIES as F, RESEND_CALLER as Ft, UPDATE_CHECK_CHILD_COMMAND as G, CommsError as H, MODES as I, REFUSED as It, approveRefusedHint as J, agentMarker as K, SEND_POLICIES as L, RESEND_API_ORIGIN as Lt, showAccount as M, wholeNumber as Mt, resendRequest as N, writeResult as Nt, policyReport as O, updateNoticeAtTerminal as Ot, ResendContext as P, PACKAGE_NAME as Pt, cliHandoffs as Q, checkNewName as R, RESEND_DOWNLOAD_ORIGIN as Rt, addAccountChange as S, serverInstallChange as St, modeOf as T, terminalUpdateHooks as Tt, EXIT_CODES as U, CHANNEL_SERVERS as V, PATH_OPTIONS as W, changeToolResult as X, canPrompt as Y, checkForUpdates as Z, showSentEmail as _, renderInstall as _t, revokeSendApproval as a, gatedChangeAtTerminal as at, readBody as b, runCommand as bt, downloadReceived as c, installExitStatus as ct, listReceived as d, newBoundary as dt, commandPathOf as et, listScheduled as f, openCore as ft, showReceived as g, renderApprovalWait as gt, resendId as h, refuseUnclaimedApproval as ht, prepareSend as i, gatedChange as it, sendPolicyOf as j, waitForApproval as jt, policyWanted as k, updateToolNotice as kt, getMetrics as l, kindOf as lt, listSuppressions as m, pathOverridesFromCliOptions as mt, executeSend as n, escapeForDisplay as nt, sendStatus as o, handoffSentence as ot, listSentEmails as p, paint as pt, approveChangeAtTerminal as q, finishSendApproval as r, exemptFromUpdateNotice as rt, cancelScheduledChange as s, handoffSentenceToFill as st, beginSendApproval as t, describeFenceReport as tt, listDomains as u, neutralise as ut, addressesOf as v, renderPrune as vt, listAccounts as w, stripInvisible as wt, runDoctor as x, runUpdateCheckChild as xt, attachmentRisks as y, resolvePaths as yt, keyPermissionOf as z, ROUTES as zt };
+export { colorEnabled as $, removeAccountChange as A, waitCallOptions as At, strictToolArguments as B, ROUTES as Bt, inspectKey as C, serverPruneChange as Ct, policyChange as D, truncateDisplay as Dt, policyApprovalRefusal as E, toCommsError as Et, CHANGE_POLICIES as F, PACKAGE_NAME as Ft, UPDATE_CHECK_CHILD_COMMAND as G, CommsError as H, MODES as I, RESEND_CALLER as It, approveRefusedHint as J, agentMarker as K, SEND_POLICIES as L, REFUSED as Lt, showAccount as M, warmSessionIdentity as Mt, resendRequest as N, wholeNumber as Nt, policyReport as O, updateNoticeAtTerminal as Ot, ResendContext as P, writeResult as Pt, cliHandoffs as Q, checkNewName as R, RESEND_API_ORIGIN as Rt, addAccountChange as S, serverInstallChange as St, modeOf as T, terminalUpdateHooks as Tt, EXIT_CODES as U, CHANNEL_SERVERS as V, VERSION$2 as Vt, PATH_OPTIONS as W, changeToolResult as X, canPrompt as Y, checkForUpdates as Z, showSentEmail as _, renderInstall as _t, revokeSendApproval as a, gatedChangeAtTerminal as at, readBody as b, runCommand as bt, downloadReceived as c, installExitStatus as ct, listReceived as d, newBoundary as dt, commandPathOf as et, listScheduled as f, openCore as ft, showReceived as g, renderApprovalWait as gt, resendId as h, refuseUnclaimedApproval as ht, prepareSend as i, gatedChange as it, sendPolicyOf as j, waitForApproval as jt, policyWanted as k, updateToolNotice as kt, getMetrics as l, kindOf as lt, listSuppressions as m, pathOverridesFromCliOptions as mt, executeSend as n, escapeForDisplay as nt, sendStatus as o, handoffSentence as ot, listSentEmails as p, paint as pt, approveChangeAtTerminal as q, finishSendApproval as r, exemptFromUpdateNotice as rt, cancelScheduledChange as s, handoffSentenceToFill as st, beginSendApproval as t, describeFenceReport as tt, listDomains as u, neutralise as ut, addressesOf as v, renderPrune as vt, listAccounts as w, stripInvisible as wt, runDoctor as x, runUpdateCheckChild as xt, attachmentRisks as y, resolvePaths as yt, keyPermissionOf as z, RESEND_DOWNLOAD_ORIGIN as zt };