@agentcomms/whatsapp 0.28.0 → 0.29.0

package/dist/{sync-DSl-bmBj.mjs → sync-NJRjuwaR.mjs}

@@ -1,17 +1,17 @@
-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, 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, 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, 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 { 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";
 //#endregion
 //#region src/version.ts
 /** The package version, read from package.json at build time. */
-const VERSION$2 = "0.28.0";
+const VERSION$2 = "0.29.0";
 //#endregion
 //#region src/caller.ts
 /** This package's name, as its manifest has it. */
@@ -27,8 +27,70 @@ const CALLER = Object.freeze({
 	url: import.meta.url,
 	packageName: PACKAGE_NAME
 });
-//#endregion
-//#region ../core/dist/update-check-CEMQ4eVV.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
@@ -228,19 +290,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();
-}
-/** 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, {
@@ -364,6 +413,1248 @@ async function isGroupOrWorldAccessible(path) {
 	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 = 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(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(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).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$1(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$1(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$1(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$1(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$1(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$1 = /* @__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$1, 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;
+}
+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$1(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();
+}
+/** 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.
 *
 * EPERM and EBUSY are how Windows reports what EEXIST reports elsewhere: the file is there, or the holder is deleting
@@ -3371,7 +4662,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;
@@ -3382,7 +4673,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;
@@ -3703,7 +4994,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 {}
@@ -3959,8 +5250,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;
@@ -4264,7 +5555,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 {}
 	}
@@ -4467,7 +5758,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." });
@@ -4601,7 +5892,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");
@@ -6861,7 +8152,7 @@ const configV1Schema = looseObject({
 	version: literal(1),
 	...v1BodyShape
 }).superRefine(checkV1Body);
-const servesSchema = union([literal("any"), looseObject({ domains: array(string().min(1)).min(1) })]);
+const servesSchema = union$1([literal("any"), looseObject({ domains: array(string().min(1)).min(1) })]);
 const generationSchema = looseObject({
 	name: aliasSchema,
 	clientId: string().min(1),
@@ -7017,7 +8308,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;
@@ -7784,6 +9075,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
@@ -7867,7 +9162,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;
@@ -7910,6 +9205,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. */
@@ -12026,7 +13323,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.28.0";
+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).
 *
@@ -12403,7 +13700,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("/")));
@@ -12576,7 +13873,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,
@@ -13270,7 +14567,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.
@@ -13302,6 +14601,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 "";
 	}
 }
@@ -13751,7 +15052,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");
@@ -14192,7 +15493,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("any"), strictObject({ domains: array(string().regex(DOMAIN_PATTERN, "each domain is a lower-case host name")).min(1).max(50) })])
+		serves: union$1([literal("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"),
@@ -14233,7 +15534,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);
 	}
@@ -14937,6 +16238,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());
@@ -15270,7 +16575,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.
 *
@@ -15720,7 +17025,7 @@ function serverPruneChange(core, env, request, own) {
 	};
 	const { packageName, version } = ownProduct(request.channel, own) ?? {
 		packageName: serverFacts(request.channel).packageName,
-		version: "0.28.0"
+		version: "0.29.0"
 	};
 	const product = {
 		packageName,
@@ -16260,7 +17565,7 @@ function commandDecisionLine(core, decision, channel, platform) {
 }
 channelServer("core").packageName;
 //#endregion
-//#region ../core/dist/tool-arguments-Bh0ujwoA.mjs
+//#region ../core/dist/tool-arguments-1XgEf3VM.mjs
 const APPLIED = Symbol.for("agentcomms.strictToolArguments");
 const TARGET = "draft-2020-12";
 /**
@@ -18513,12 +19818,12 @@ var WhatsAppIndex = class WhatsAppIndex {
 		const kinds = options.kinds;
 		if (kinds.length === 0) return [];
 		return this.#db.prepare(`${CHAT_SELECT} WHERE agent_sees_chat(c.id) AND ${KIND} IN (${kinds.map(() => "?").join(", ")})
-         ORDER BY c.last_message_at IS NULL, c.last_message_at DESC, c.id LIMIT ?`).all(...kinds, options.limit).map(chatOf);
+         ORDER BY c.last_message_at IS NULL, c.last_message_at DESC, c.id LIMIT ?`).all(...kinds, options.limit).map(chatOf$1);
 	}
 	/** One chat by its id — or null, as for a chat that does not exist, when the lists hide it. */
 	chat(id) {
 		const row = this.#db.prepare(`${CHAT_SELECT} WHERE c.id = ? AND agent_sees_chat(c.id)`).get(id);
-		return row ? chatOf(row) : null;
+		return row ? chatOf$1(row) : null;
 	}
 	message(id) {
 		if (!/^\d{1,15}$/.test(id)) return null;
@@ -18564,7 +19869,7 @@ const CHAT_SELECT = `
               THEN (SELECT COUNT(*) FROM messages m WHERE m.chat_id = c.id AND ${SEES_MESSAGE})
               ELSE c.message_count END AS message_count
   FROM chats c`;
-function chatOf(row) {
+function chatOf$1(row) {
 	return {
 		id: String(row.id),
 		kind: row.kind,
@@ -18968,6 +20273,8 @@ var WhatsAppContext = class {
 	lists;
 	/** The name a pinned server was started for, as given. */
 	pinned;
+	/** What the MCP client said it is, for the activity log; undefined at the command line. */
+	clientInfo;
 	#log;
 	#migration = null;
 	#pinnedId;
@@ -18987,6 +20294,7 @@ var WhatsAppContext = class {
 		this.handoffs = requireHandoffs(this.core).on(this.platform);
 		this.lists = new ChatListStore(this.core.paths.configDir);
 		this.pinned = options.account;
+		this.clientInfo = options.clientInfo;
 		this.#log = options.log;
 		this.#source = {
 			io: options.sourceIo,
@@ -19097,6 +20405,129 @@ var WhatsAppContext = class {
 	}
 };
 //#endregion
+//#region src/activity.ts
+/**
+* What this package writes in core's activity log (design 2026-10-25-activity, S4, and §8 Task 2b): one line for each
+* call that reads an account's chats or drafts to one — **counts and nothing else**.
+*
+* - **A line holds** the operation, the account, `counts` (`chats`, `messages`), the outcome and the session.
+* - **Its kind:** `read` for a sync and every read of the index; `approval` for a draft, which reaches nothing — it is a
+*   link the person checks and sends themselves (the lead's rule for 0.29.0: `write` is only an act that reaches the
+*   service, and this package has none).
+* - **It never holds** a chat's id, a name, a number, a message or a preview — nor a search's words, which may be a
+*   name or a number — and no item at all. So a chat the person denies later leaves nothing behind in the log, as it
+*   leaves nothing in the index (`visibility.ts`), and core never needs WhatsApp's lists to keep the log clean.
+* - **Nor does its reason.** A refusal here names the chat it refused (`no chat 15555550101@s.whatsapp.net in …`), so a
+*   failed or refused line keeps the error's code and none of its words. The call still throws the error it threw.
+* - **Its session is this process's own, ungrouped.** Grouping a process with its agent window (S2) reads the parent's
+*   start with `ps`, and this package starts no process but the link opener (`no-network.test.ts`): so each server and
+*   each command is a session of its own, marked ungrouped, with its folder and — over MCP — what the client said.
+*/
+const CHANNEL = "whatsapp";
+/** What a failed or refused line says in place of the error's own words, which may name a chat or a number. */
+const WITHHELD = "details withheld: a WhatsApp line names no chat, person or number";
+/**
+* The account a call acts on: the one it names, or the pinned server's. With `anyAccount` — a draft, which applies
+* every account's lists when it names none — the only account there is, or every one of several: one line, their names
+* joined by commas and no id, as a call over several accounts is recorded (the lead's rule for 0.29.0). Undefined when
+* the call names an account this machine does not have, or none where one is needed: it is then refused before any
+* account is read, and records nothing.
+*
+* Read from the configuration alone — never through `context.account`, which reads the person's lists too: the
+* operation looks its account up itself, once, as it always has.
+*/
+async function accountOf(context, named, anyAccount) {
+	try {
+		let names;
+		if (context.pinned !== void 0) {
+			names = await context.accountNames();
+			if (named !== void 0 && !names.includes(named)) return void 0;
+		} else if (named !== void 0) names = [named];
+		else if (anyAccount) names = await context.accountNames();
+		else return void 0;
+		const config = await context.config();
+		const accounts = names.map((name) => ({
+			name,
+			account: lookupName(config, "account", name)
+		}));
+		if (accounts.length === 0 || accounts.some(({ account }) => account?.platform !== "whatsapp")) return void 0;
+		const [only] = accounts;
+		if (accounts.length === 1 && only?.account !== void 0) return {
+			id: only.account.id,
+			alias: only.name
+		};
+		return {
+			id: "",
+			alias: names.join(",")
+		};
+	} catch {
+		return;
+	}
+}
+/** This process's own session key and id: made once, so every line of this process is one session. */
+const OWN = {
+	key: randomBytes(8).toString("hex"),
+	process: randomBytes(6).toString("hex")
+};
+/** The session a line of this process is recorded under: its own, ungrouped, with no process started to learn more. */
+function ownSession(context) {
+	let folder;
+	try {
+		folder = process.cwd();
+	} catch {
+		folder = null;
+	}
+	const client = context.clientInfo?.();
+	return {
+		key: OWN.key,
+		process: OWN.process,
+		pid: process.pid,
+		...client?.name ? { client: {
+			name: client.name,
+			...client.version ? { version: client.version } : {}
+		} } : {},
+		folder,
+		grouped: false,
+		surface: context.surface
+	};
+}
+/** The counts of a result, as whole numbers, and only the two a WhatsApp line may hold. */
+function countsOf(counts) {
+	return Object.fromEntries(Object.entries({
+		chats: counts.chats,
+		messages: counts.messages
+	}).filter((entry) => typeof entry[1] === "number"));
+}
+/**
+* Runs `fn` — one capability's call on the account `named` — and records its line: `operation` is the capability id
+* in `capabilities.json`, and `counts` how many chats and messages it touched. What `fn` returns or throws is exactly
+* what this returns or throws: the error that is recorded is a copy with the same code and none of the words, and the
+* one `fn` threw is the one thrown on.
+*/
+async function recordWhatsApp(context, named, operation, kind, fn, counts, options = {}) {
+	const account = await accountOf(context, named, options.anyAccount === true);
+	if (account === void 0) return fn();
+	let thrown;
+	try {
+		return await withActivity({
+			core: context.core,
+			channel: CHANNEL,
+			surface: context.surface,
+			account,
+			session: ownSession(context)
+		}, operation, kind, async () => {
+			try {
+				return await fn();
+			} catch (error) {
+				thrown = { error };
+				throw new CommsError(isCommsError(error) ? error.code : "UNEXPECTED", WITHHELD);
+			}
+		}, (result) => ({ counts: countsOf(counts(result)) }));
+	} catch (error) {
+		throw thrown === void 0 ? error : thrown.error;
+	}
+}
+//#endregion
 //#region src/visibility.ts
 /** One entry per person or chat: a phone number and the ids that carry it compare equal. */
 function listKey(jid) {
@@ -19275,6 +20706,12 @@ function composeDraft(request) {
 * one account is not drafted to by naming another. A pinned server serves its account alone and consults no other.
 */
 async function draftMessage(context, request) {
+	return recordWhatsApp(context, request.account, "whatsapp.draft", "approval", () => draftOf(context, request), () => ({
+		chats: 1,
+		messages: 1
+	}), { anyAccount: true });
+}
+async function draftOf(context, request) {
 	const draft = composeDraft({
 		to: request.to,
 		text: request.text
@@ -19483,6 +20920,9 @@ async function openIndex(context, accountName) {
 	};
 }
 async function listChats(context, request) {
+	return recordWhatsApp(context, request.account, "whatsapp.chats", "read", () => chatsOf(context, request), (result) => ({ chats: result.chats.length }));
+}
+async function chatsOf(context, request) {
 	const limit = wholeNumber(request.limit ?? 50, {
 		name: "limit",
 		min: 1,
@@ -19507,6 +20947,12 @@ async function listChats(context, request) {
 	}
 }
 async function readChat(context, request) {
+	return recordWhatsApp(context, request.account, "whatsapp.read", "read", () => chatOf(context, request), (result) => ({
+		chats: 1,
+		messages: result.messages.length
+	}));
+}
+async function chatOf(context, request) {
 	const limit = wholeNumber(request.limit ?? 50, {
 		name: "limit",
 		min: 1,
@@ -19546,6 +20992,12 @@ function wordsOf(query) {
 	return query.normalize("NFKC").split(/[^\p{L}\p{N}]+/u).filter((word) => word.length > 0).slice(0, 16);
 }
 async function searchMessages(context, request) {
+	return recordWhatsApp(context, request.account, "whatsapp.search", "read", () => searchOf(context, request), (result) => ({
+		chats: new Set(result.results.map((hit) => hit.chat.id)).size,
+		messages: result.results.length
+	}));
+}
+async function searchOf(context, request) {
 	const limit = wholeNumber(request.limit ?? 20, {
 		name: "limit",
 		min: 1,
@@ -19600,7 +21052,7 @@ async function searchMessages(context, request) {
 }
 //#endregion
 //#region src/source/snapshot.ts
-const SOURCE_FLAGS = constants$1.O_RDONLY | (constants$1.O_NOFOLLOW ?? 0) | (constants$1.O_NONBLOCK ?? 0);
+const SOURCE_FLAGS = constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0);
 const nodeSourceIo = {
 	lstat: (path) => lstat(path, { bigint: true }),
 	async open(path) {
@@ -19752,7 +21204,7 @@ async function closeSources(sources) {
 const CHUNK_BYTES = 1048576;
 /** Every byte of an open source file, into a file created for it — exclusively, owner-only. */
 async function copyOpened(source, to) {
-	const out = await open(to, constants$1.O_WRONLY | constants$1.O_CREAT | constants$1.O_EXCL, 384);
+	const out = await open(to, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 384);
 	try {
 		const buffer = Buffer.allocUnsafe(CHUNK_BYTES);
 		for (let position = 0;;) {
@@ -20045,6 +21497,12 @@ async function withCheckedCopy(context, request, work) {
 *   deny hides is never written, not merely filtered out when read.
 */
 async function syncAccount(context, request) {
+	return recordWhatsApp(context, request.account, "whatsapp.sync", "read", () => syncOnce(context, request), (result) => ({
+		chats: result.chats,
+		messages: result.messages
+	}));
+}
+async function syncOnce(context, request) {
 	return withCheckedCopy(context, request, async (copy) => {
 		let current = await context.accountById(copy.account.id);
 		if (!current) throw removedWhileSyncing(context, copy.accountName, copy.account);