primcli 1.45.0 → 1.47.0

package/dist/machine-session-Dr5W2fHb.js

@@ -0,0 +1,4754 @@
+import { n as __exportAll } from "./rolldown-runtime-CNZpIYwj.js";
+import { B as parseOwnerMemberAddress, F as agentProfilesDirectory, I as connectedAgentIdentity, L as connectedApiBaseUrl, M as AgentConnectionSetupError, N as agentProfileDirectory, P as agentProfileName, R as loadConnectedAgentProfile, U as saveConnectedAgentProfile, V as profileAlreadyConnectedMessage, W as PrimitiveApiClient, j as AGENT_PROFILE_ENV, x as loadCliCredentials, z as parseConnectedAgentProfile } from "./cli-config-DGrZCUfw.js";
+import { $t as getAgentContactPolicy, Dn as listSentEmails, Fn as putContact, Gn as sendEmail, Gt as deleteAgentContact, Hn as searchEmails, Kt as deleteContact, Nn as putAgentContact, Pn as putAgentContactPolicy, Pt as refreshStoredCliCredentials, _n as listContacts, bn as listDomains, en as getContact, hn as listAgentContacts, in as getEmail } from "./api-command-C1JvJqV0.js";
+import { _ as acquireListenLock, c as mailTime, d as readMailJson, f as removeMailFile, g as ListenStateError, h as writeMailJson, i as mailId, l as privateMailDirectory, o as mailObject, r as mailAddress, s as mailString } from "./shared-mail-files-SPPcis9g.js";
+import { a as readBundledConnectSkill, h as connectNativeSession, m as SESSION_UUID, n as detectAgentRuntime, o as notificationScope, r as installConnectSkill, u as NotificationRetryError } from "./connect-skill-CH2pq436.js";
+import { l as stopBackgroundListen, r as backgroundListenStatus } from "./listen-background-CyLc8VBn.js";
+import { t as readSharedMailOwner } from "./shared-mail-watch-BUfUaq6j.js";
+import { a as scopedChatSenderTrust } from "./scoped-chat-DhxtuNXs.js";
+import { accessSync, chmodSync, closeSync, constants, copyFileSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { basename, delimiter, dirname, isAbsolute, join, resolve } from "node:path";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { execFile, execFileSync, spawn } from "node:child_process";
+import { homedir } from "node:os";
+import { promisify } from "node:util";
+//#region src/oclif/machine-files.ts
+/** Hand-edited files larger than this are reported, never rewritten. */
+const MAX_MANAGED_FILE_BYTES = 1048576;
+/** Backups kept per file; older Primitive backups of the same file are pruned. */
+const BACKUPS_KEPT = 10;
+const BACKUP_INFIX = ".primitive-bak-";
+/** A safe, user-facing reason a file was not changed. */
+var MachineFileError = class extends Error {};
+/**
+* Read a user-owned text file without following it anywhere surprising. A
+* symlink is followed to its real file so a later write updates the file the
+* user linked instead of replacing the link.
+*/
+function readManagedFile(path) {
+	let info;
+	try {
+		info = lstatSync(path);
+	} catch (error) {
+		if (error.code === "ENOENT") return {
+			state: "absent",
+			path,
+			target: path
+		};
+		return {
+			state: "invalid",
+			path,
+			detail: `${path} cannot be read (${error.code ?? "error"}).`
+		};
+	}
+	let target = path;
+	if (info.isSymbolicLink()) try {
+		target = realpathSync(path);
+		info = statSync(target);
+	} catch {
+		return {
+			state: "invalid",
+			path,
+			detail: `${path} is a symlink to a missing file; it was left unchanged.`
+		};
+	}
+	if (!info.isFile()) return {
+		state: "invalid",
+		path,
+		detail: `${path} is not a regular file; it was left unchanged.`
+	};
+	if (info.size > MAX_MANAGED_FILE_BYTES) return {
+		state: "invalid",
+		path,
+		detail: `${path} is larger than 1 MiB; it was left unchanged.`
+	};
+	let raw;
+	try {
+		raw = readFileSync(target);
+	} catch (error) {
+		return {
+			state: "invalid",
+			path,
+			detail: `${path} cannot be read (${error.code ?? "error"}).`
+		};
+	}
+	const text = raw.toString("utf8");
+	if (text.includes("\0") || !Buffer.from(text, "utf8").equals(raw)) return {
+		state: "invalid",
+		path,
+		detail: `${path} is not UTF-8 text; it was left unchanged.`
+	};
+	return {
+		state: "present",
+		path,
+		target,
+		text,
+		mode: info.mode & 511
+	};
+}
+function backupStamp(now) {
+	return now.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+}
+function syncDirectory(directory) {
+	if (process.platform === "win32") return;
+	try {
+		const fd = openSync(directory, "r");
+		try {
+			fsyncSync(fd);
+		} finally {
+			closeSync(fd);
+		}
+	} catch {}
+}
+function pruneBackups(target) {
+	const directory = dirname(target);
+	const prefix = `${basename(target)}${BACKUP_INFIX}`;
+	try {
+		const backups = readdirSync(directory).filter((name) => name.startsWith(prefix)).sort();
+		for (const name of backups.slice(0, Math.max(0, backups.length - BACKUPS_KEPT))) unlinkSync(join(directory, name));
+	} catch {}
+}
+/** Copy the current file beside itself before any change. Returns the copy's path. */
+function backupManagedFile(target, mode, now) {
+	const base = `${target}${BACKUP_INFIX}${backupStamp(now)}`;
+	for (let attempt = 0; attempt < 100; attempt++) {
+		const candidate = attempt === 0 ? base : `${base}-${attempt}`;
+		try {
+			copyFileSync(target, candidate, constants.COPYFILE_EXCL);
+			chmodSync(candidate, mode);
+			return candidate;
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+		}
+	}
+	throw new MachineFileError(`Could not create a backup of ${target}.`);
+}
+/**
+* Replace a file atomically (temporary file plus rename in the same
+* directory), after backing up the existing content. The write is refused when
+* the file changed since it was read, so a concurrent edit is never lost.
+*/
+function writeManagedFile(params) {
+	const { read } = params;
+	const target = read.target;
+	const expected = read.state === "present" ? read.text : null;
+	const directory = dirname(target);
+	mkdirSync(directory, {
+		recursive: true,
+		mode: 448
+	});
+	const current = () => {
+		try {
+			return readFileSync(target, "utf8");
+		} catch (error) {
+			if (error.code === "ENOENT") return null;
+			throw error;
+		}
+	};
+	if (current() !== expected) throw new MachineFileError(`${read.path} changed while it was being repaired; it was left unchanged.`);
+	const mode = read.state === "present" ? read.mode : params.newFileMode ?? 420;
+	const backup = read.state === "present" ? backupManagedFile(target, mode, (params.now ?? (() => /* @__PURE__ */ new Date()))()) : null;
+	const temporary = join(directory, `.${basename(target)}.${randomUUID()}.tmp`);
+	try {
+		const fd = openSync(temporary, "wx", mode);
+		try {
+			writeFileSync(fd, params.content, "utf8");
+			fsyncSync(fd);
+		} finally {
+			closeSync(fd);
+		}
+		chmodSync(temporary, mode);
+		if (current() !== expected) throw new MachineFileError(`${read.path} changed while it was being repaired; it was left unchanged.`);
+		renameSync(temporary, target);
+		syncDirectory(directory);
+	} finally {
+		if (existsSync(temporary)) unlinkSync(temporary);
+	}
+	if (backup) pruneBackups(target);
+	return { backup };
+}
+const START = /^<!-- primitive:managed-block v=(\d+) START -->\r?$/;
+const END = /^<!-- primitive:managed-block END -->\r?$/;
+/** Character offsets of the single managed block, or why the markers are unusable. */
+function locateBlock(text) {
+	const starts = [];
+	const ends = [];
+	let offset = 0;
+	for (const line of text.split("\n")) {
+		const start = START.exec(line);
+		if (start) starts.push({
+			offset,
+			version: Number(start[1])
+		});
+		else if (END.test(line)) ends.push({
+			offset,
+			length: line.endsWith("\r") ? line.length - 1 : line.length
+		});
+		else if (line.includes("primitive:managed-block")) return { malformed: "a primitive:managed-block marker line was edited; fix or remove it by hand" };
+		offset += line.length + 1;
+	}
+	if (starts.length === 0 && ends.length === 0) return null;
+	if (starts.length !== 1 || ends.length !== 1) return { malformed: `found ${starts.length} START and ${ends.length} END markers; expected one of each` };
+	const [start] = starts;
+	const [end] = ends;
+	if (!start || !end || end.offset < start.offset) return { malformed: "the END marker comes before the START marker" };
+	return {
+		start: start.offset,
+		end: end.offset + end.length,
+		version: start.version
+	};
+}
+/** The exact block for a body, using the file's own line ending. */
+function renderManagedBlock(body, eol = "\n") {
+	return [
+		`<!-- primitive:managed-block v=1 START -->`,
+		...body.replace(/\r\n/g, "\n").replace(/\n+$/, "").split("\n"),
+		"<!-- primitive:managed-block END -->"
+	].join(eol);
+}
+function lineEnding(text) {
+	return text.includes("\r\n") ? "\r\n" : "\n";
+}
+function inspectManagedBlock(text, body) {
+	const found = locateBlock(text);
+	if (found === null) return { state: "missing" };
+	if ("malformed" in found) return {
+		state: "malformed",
+		detail: found.malformed
+	};
+	return text.slice(found.start, found.end).replace(/\r\n/g, "\n") === renderManagedBlock(body) ? { state: "ok" } : {
+		state: "outdated",
+		version: found.version
+	};
+}
+/**
+* Replace only the managed block, or append it when absent. Text outside the
+* markers is preserved byte for byte. Throws for malformed markers.
+*/
+function upsertManagedBlock(text, body) {
+	const found = locateBlock(text);
+	if (found !== null && "malformed" in found) throw new MachineFileError(found.malformed);
+	const eol = lineEnding(text);
+	const block = renderManagedBlock(body, eol);
+	if (found) return `${text.slice(0, found.start)}${block}${text.slice(found.end)}`;
+	if (text.length === 0) return `${block}${eol}`;
+	return `${text}${text.endsWith(`${eol}${eol}`) ? "" : text.endsWith(eol) ? eol : `${eol}${eol}`}${block}${eol}`;
+}
+/** Indentation the file already uses, so a rewrite keeps its style. */
+function jsonIndentation(text) {
+	return /^[{[][^\n]*\n([ \t]+)\S/.exec(text)?.[1] ?? 2;
+}
+//#endregion
+//#region src/oclif/claude-machine-hooks.ts
+function record$2(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function realpathOrNull(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return null;
+	}
+}
+/** Two paths name the same existing file. */
+function samePath(a, b) {
+	if (typeof a !== "string" || !a) return false;
+	if (a === b) return existsSync(a);
+	const left = realpathOrNull(a);
+	return left !== null && left === realpathOrNull(b);
+}
+/**
+* A hook's Node command is current when it is the chosen Node path itself,
+* or another link to the same binary. A command that pins the versioned file
+* behind the stable link stops working once an upgrade replaces that file,
+* so it is not current and gets rewritten to the stable path.
+*/
+function nodeCommandCurrent(command, node) {
+	if (!samePath(command, node)) return false;
+	if (command === node) return true;
+	return realpathOrNull(String(command)) !== command;
+}
+function executable(path) {
+	try {
+		accessSync(path, constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** The first PATH entry for a command, without running a shell. */
+function findOnPath(name, env) {
+	for (const directory of (env.PATH ?? "").split(delimiter)) {
+		if (!directory) continue;
+		const candidate = join(directory, name);
+		if (existsSync(candidate) && executable(candidate)) return candidate;
+	}
+	return null;
+}
+/**
+* Prefer a PATH link (for example a package manager's `bin/node`) over a
+* versioned install directory when both are the same binary, so a hook keeps
+* working after the versioned directory is replaced by an upgrade.
+*/
+function stableNodePath(env, execPath = process.execPath) {
+	const onPath = findOnPath("node", env);
+	if (onPath && isAbsolute(onPath) && onPath !== execPath && samePath(onPath, execPath)) return onPath;
+	return execPath;
+}
+/** Locate the running CLI. Null when its files are not where a package install puts them. */
+function currentCliLocation(entryArg, env, execPath = process.execPath) {
+	const entry = realpathOrNull(entryArg);
+	if (!entry) return null;
+	const wake = realpathOrNull(join(dirname(entry), "claude-wake.mjs"));
+	const pending = realpathOrNull(join(dirname(entry), "claude-pending-mail.mjs"));
+	if (!wake || !pending) return null;
+	return {
+		node: stableNodePath(env, execPath),
+		entry,
+		wake,
+		pending
+	};
+}
+/** Package-runner caches are cleaned up behind the user's back. */
+function ephemeralCliReason(entry) {
+	if (/[\\/]_npx[\\/]/.test(entry)) return "an npx cache";
+	if (/[\\/]dlx[-\\/]/.test(entry)) return "a pnpm dlx cache";
+	if (/[\\/]bunx-/.test(entry)) return "a bunx cache";
+	return null;
+}
+function claudeConfigDir(env, home) {
+	return resolve(env.CLAUDE_CONFIG_DIR || join(home, ".claude"));
+}
+function jsonErrorDetail(error) {
+	const message = error instanceof Error ? error.message : "";
+	const position = /position (\d+)/.exec(message)?.[1];
+	const line = /line (\d+)/.exec(message)?.[1];
+	return line ? ` near line ${line}` : position ? ` near character ${position}` : "";
+}
+/** Parse settings.json. Anything unexpected is reported, never repaired. */
+function readClaudeSettings(claudeDir) {
+	const path = join(claudeDir, "settings.json");
+	const read = readManagedFile(path);
+	if (read.state === "invalid") return {
+		ok: false,
+		detail: read.detail
+	};
+	if (read.state === "absent") return {
+		ok: true,
+		read,
+		settings: {}
+	};
+	let parsed;
+	try {
+		parsed = JSON.parse(read.text);
+	} catch (error) {
+		return {
+			ok: false,
+			detail: `${path} is not valid JSON${jsonErrorDetail(error)}. Fix it by hand; it was not modified.`
+		};
+	}
+	if (!record$2(parsed)) return {
+		ok: false,
+		detail: `${path} must contain a JSON object. Fix it by hand; it was not modified.`
+	};
+	if (parsed.hooks !== void 0 && !record$2(parsed.hooks)) return {
+		ok: false,
+		detail: `${path} has a "hooks" value that is not an object. Fix it by hand; it was not modified.`
+	};
+	return {
+		ok: true,
+		read,
+		settings: parsed
+	};
+}
+const LOCK_WAIT$1 = new Int32Array(new SharedArrayBuffer(4));
+/**
+* Write settings under the same lock every Primitive hook installer uses,
+* keeping the file's indentation, after a timestamped backup.
+*/
+function writeClaudeSettings(params) {
+	let release;
+	for (let attempt = 0; attempt < 80; attempt++) try {
+		release = acquireListenLock(params.claudeDir, "primitive-claude-settings");
+		break;
+	} catch {
+		Atomics.wait(LOCK_WAIT$1, 0, 0, 25);
+	}
+	if (!release) throw new MachineFileError("Another Primitive command is editing Claude settings; try again shortly.");
+	try {
+		const original = params.read.state === "present" ? params.read.text : null;
+		const indent = original === null ? 2 : jsonIndentation(original);
+		const trailing = original === null || original.endsWith("\n") ? "\n" : "";
+		return writeManagedFile({
+			read: params.read,
+			content: `${JSON.stringify(params.settings, null, indent)}${trailing}`,
+			now: params.now,
+			newFileMode: 384
+		});
+	} finally {
+		release();
+	}
+}
+const STATE_PHRASES = {
+	missing: "missing",
+	stale: "session disconnected or removed",
+	duplicate: "duplicate",
+	outdated: "old CLI path",
+	old_address: "old agent address"
+};
+/** "profile my-agent, session 1234...": who a session hook serves. */
+function describeSessionHookOwner(item) {
+	const profile = item.profile ? `profile ${item.profile}` : "a profile an old CLI did not record";
+	return item.session ? `${profile}, session ${item.session}` : profile;
+}
+/** One short line naming a hook, its owner and its state. */
+function describeSessionHookItem(item) {
+	return `${item.hook} hook for ${describeSessionHookOwner(item)}: ${STATE_PHRASES[item.state]}`;
+}
+/** One short line naming what a repair did to a hook. */
+function describeSessionHookChange(change) {
+	return `${change.action === "added" ? "Added" : change.action === "removed" ? "Removed" : "Rewrote"} ${change.hook} hook for ${describeSessionHookOwner(change)} (${STATE_PHRASES[change.state]})`;
+}
+/** Group items by owner, at most `limit` owners, for a one-line detail. */
+function summarizeOwners(items, limit = 3) {
+	const owners = [];
+	for (const item of items) {
+		const owner = describeSessionHookOwner(item);
+		if (!owners.includes(owner)) owners.push(owner);
+	}
+	const shown = owners.slice(0, limit).join("; ");
+	return owners.length > limit ? `${shown}; and ${owners.length - limit} more` : shown;
+}
+const GLOBAL_HOOKS = {
+	"claude.hook.session_start": {
+		event: "SessionStart",
+		subcommand: "session-register",
+		timeout: 15
+	},
+	"claude.hook.session_end": {
+		event: "SessionEnd",
+		subcommand: "session-end",
+		timeout: 10
+	}
+};
+/** A hook this CLI installed for every Claude session, from any CLI path or version. */
+function isGlobalManaged(hook, spec) {
+	if (!record$2(hook) || hook.type !== "command" || !Array.isArray(hook.args)) return false;
+	const args = hook.args;
+	return args.length === 6 && typeof args[0] === "string" && args[1] === "agent" && args[2] === spec.subcommand && args[3] === "--runtime" && args[4] === "claude" && args[5] === "--hook";
+}
+function globalHookArgs(cli, spec) {
+	return [
+		cli.entry,
+		"agent",
+		spec.subcommand,
+		"--runtime",
+		"claude",
+		"--hook"
+	];
+}
+function globalHookCurrent(hook, cli) {
+	const args = hook.args;
+	return nodeCommandCurrent(hook.command, cli.node) && samePath(args[0], cli.entry);
+}
+const WAKE_MARKER = "primitive-agent-wake-v1";
+const PENDING_MARKER$1 = "primitive-pending-mail-v1";
+const SESSION_EVENTS = [
+	"Stop",
+	"SessionStart",
+	"PostToolUse"
+];
+/** Which receive hook each event carries. */
+const SESSION_HOOK_KIND = {
+	Stop: "wake",
+	SessionStart: "wake",
+	PostToolUse: "pending"
+};
+/**
+* The one test of whether an event already carries a current receive hook
+* for this exact profile, address and session, run by the Node binary at
+* `node` (compared as files). `agent connect --status` and machine doctor
+* both use it, so they never disagree about a hook being present.
+*/
+function hasSessionReceiveHook(hooks, event, target, node) {
+	const entries = hooks[event];
+	if (!Array.isArray(entries)) return false;
+	const pending = SESSION_HOOK_KIND[event] === "pending";
+	const configDir = resolve(target.configDir);
+	const session = target.session.toLowerCase();
+	return entries.some((entry) => record$2(entry) && Array.isArray(entry.hooks) && entry.hooks.some((hook) => {
+		if (!record$2(hook) || hook.type !== "command") return false;
+		const args = hook.args;
+		return Array.isArray(args) && args.length === 7 && args.every((value) => typeof value === "string") && basename(args[0]) === (pending ? "claude-pending-mail.mjs" : "claude-wake.mjs") && resolve(args[2]) === configDir && args[3] === target.profile && args[4] === target.address && args[5].toLowerCase() === session && args[6] === (pending ? PENDING_MARKER$1 : WAKE_MARKER) && samePath(hook.command, node);
+	}));
+}
+/** A per-session receive hook written by `agent connect` or `agent enroll`, any version. */
+function parseSessionHook(hook) {
+	if (!record$2(hook) || hook.type !== "command" || !Array.isArray(hook.args)) return null;
+	const args = hook.args;
+	if (!args.every((value) => typeof value === "string")) return null;
+	const strings = args;
+	const script = basename(strings[0] ?? "");
+	if (script === "claude-pending-mail.mjs") return strings.length === 7 && strings[6] === PENDING_MARKER$1 ? {
+		kind: "pending",
+		configDir: strings[2] ?? "",
+		profile: strings[3] ?? null,
+		address: strings[4] ?? null,
+		session: strings[5] ?? null
+	} : null;
+	if (script !== "claude-wake.mjs") return null;
+	if (strings.length === 7 && strings[6] === WAKE_MARKER) return {
+		kind: "wake",
+		configDir: strings[2] ?? "",
+		profile: strings[3] ?? null,
+		address: strings[4] ?? null,
+		session: strings[5] ?? null
+	};
+	if (strings.length === 6 && strings[5] === WAKE_MARKER) return {
+		kind: "wake",
+		configDir: strings[2] ?? "",
+		profile: strings[3] ?? null,
+		address: strings[4] ?? null,
+		session: null
+	};
+	if (strings.length === 4 && strings[3] === WAKE_MARKER) return {
+		kind: "wake",
+		configDir: strings[2] ?? "",
+		profile: null,
+		address: null,
+		session: null
+	};
+	return null;
+}
+/** A saved connected profile still holds a credential. Unreadable counts as live. */
+function profileStillConnected(configDir, profile) {
+	try {
+		return loadConnectedAgentProfile(configDir, profile) !== null;
+	} catch {
+		return true;
+	}
+}
+function sessionHookPathsCurrent(hook, parsed, cli) {
+	const args = hook.args;
+	if (!cli) return existsSync(String(hook.command)) && existsSync(args[0] ?? "") && existsSync(args[1] ?? "");
+	return nodeCommandCurrent(hook.command, cli.node) && samePath(args[0], parsed.kind === "wake" ? cli.wake : cli.pending) && samePath(args[1], cli.entry);
+}
+function judgeSessionHooks(hooks, cli, bound = []) {
+	const verdicts = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	for (const event of SESSION_EVENTS) {
+		const entries = hooks[event];
+		if (!Array.isArray(entries)) continue;
+		for (const entry of entries) {
+			if (!record$2(entry) || !Array.isArray(entry.hooks)) continue;
+			for (const hook of entry.hooks) {
+				const parsed = parseSessionHook(hook);
+				if (!parsed || !record$2(hook)) continue;
+				const pathsExist = existsSync(String(hook.command)) && existsSync(String(hook.args[0])) && existsSync(String(hook.args[1]));
+				if (!(parsed.profile ? existsSync(parsed.configDir) && profileStillConnected(parsed.configDir, parsed.profile) : existsSync(parsed.configDir) && pathsExist)) {
+					verdicts.set(hook, "stale");
+					continue;
+				}
+				const current = bound.find((item) => item.configDir === resolve(parsed.configDir) && item.profile === parsed.profile && item.session === parsed.session?.toLowerCase());
+				if (current && parsed.address !== current.address) {
+					verdicts.set(hook, "old_address");
+					continue;
+				}
+				const key = [
+					event,
+					parsed.kind,
+					resolve(parsed.configDir),
+					parsed.profile ?? "",
+					parsed.session?.toLowerCase() ?? ""
+				].join("\0");
+				if (seen.has(key)) {
+					verdicts.set(hook, "duplicate");
+					continue;
+				}
+				seen.add(key);
+				verdicts.set(hook, sessionHookPathsCurrent(hook, parsed, cli) ? "keep" : "outdated");
+			}
+		}
+	}
+	return verdicts;
+}
+function eventEntries(hooks, event) {
+	const entries = hooks[event];
+	if (entries === void 0) return [];
+	return Array.isArray(entries) ? entries : "invalid";
+}
+/**
+* Connected profiles whose setup binds an external (hook) receiver to a
+* Claude session that this machine has not recorded as ended.
+*/
+function boundSessionProfiles(configDir) {
+	const root = resolve(configDir);
+	let names;
+	try {
+		names = readdirSync(join(agentProfilesDirectory(root), "profiles")).sort();
+	} catch {
+		return [];
+	}
+	const bound = [];
+	for (const name of names) try {
+		agentProfileName(name);
+		const setup = readMailJson(join(agentProfileDirectory(root, name), "setup.json"));
+		if (setup?.receiverMode !== "external" || typeof setup.session !== "string" || !SESSION_UUID.test(setup.session)) continue;
+		const session = setup.session.toLowerCase();
+		if (typeof readMailJson(join(root, "machine", "sessions", `${session}.json`))?.endedAt === "string") continue;
+		const profile = loadConnectedAgentProfile(root, name);
+		if (profile) bound.push({
+			configDir: root,
+			profile: name,
+			address: profile.agent_address,
+			session
+		});
+	} catch {}
+	return bound;
+}
+function boundKey(item) {
+	return [
+		resolve(item.configDir),
+		item.profile,
+		item.session
+	].join("\0");
+}
+/**
+* Bound profiles whose receive hooks are entirely absent while the same
+* session receives through another connected profile, or while several profiles are
+* bound to it and none receives. Such a profile is not restored without
+* being named: its hooks were removed on purpose, or it would give the
+* session a second address. A profile that still has any receive hook for
+* the session, or the only profile bound to a session, is restored as usual.
+*/
+/**
+* For each session, the connected profiles it receives as through the
+* per-session receive hooks in `hooks`, keyed like `boundKey`. A hook for a
+* disconnected or removed profile is stale (machine doctor removes it), so
+* the session does not receive through it.
+*/
+function receivingProfilesBySession(hooks, always) {
+	const receiving = /* @__PURE__ */ new Map();
+	for (const event of SESSION_EVENTS) {
+		const entries = hooks[event];
+		if (!Array.isArray(entries)) continue;
+		for (const entry of entries) {
+			if (!record$2(entry) || !Array.isArray(entry.hooks)) continue;
+			for (const hook of entry.hooks) {
+				const parsed = parseSessionHook(hook);
+				if (!parsed?.profile || !parsed.session) continue;
+				const session = parsed.session.toLowerCase();
+				const key = [
+					resolve(parsed.configDir),
+					parsed.profile,
+					session
+				].join("\0");
+				if (key !== always && (!existsSync(parsed.configDir) || !profileStillConnected(parsed.configDir, parsed.profile))) continue;
+				const profiles = receiving.get(session) ?? /* @__PURE__ */ new Set();
+				profiles.add(key);
+				receiving.set(session, profiles);
+			}
+		}
+	}
+	return receiving;
+}
+/**
+* The other connected profiles a session already receives as, when `target`
+* itself has no receive hook for it. Adding `target`'s hooks then would give
+* the session a second address; an empty list means it would not (the
+* session receives as nobody else, or `target` already has hooks there and
+* only needs them repaired). Uses the same rule as machine doctor, so an
+* automatic install never binds a profile doctor would leave alone.
+*/
+function otherSessionReceivers(hooks, target) {
+	const session = target.session.toLowerCase();
+	const own = [
+		resolve(target.configDir),
+		target.profile,
+		session
+	].join("\0");
+	const present = receivingProfilesBySession(hooks, own).get(session) ?? /* @__PURE__ */ new Set();
+	if (present.has(own)) return [];
+	return [...present].map((other) => other.split("\0")[1] ?? "").sort();
+}
+function heldSessionProfiles(hooks, bound, restore) {
+	const receiving = receivingProfilesBySession(hooks);
+	const held = /* @__PURE__ */ new Map();
+	for (const item of bound) {
+		const key = boundKey(item);
+		const present = receiving.get(item.session) ?? /* @__PURE__ */ new Set();
+		if (present.has(key) || restore?.has(item.profile)) continue;
+		const others = [...present].map((other) => other.split("\0")[1] ?? "");
+		const siblings = bound.filter((candidate) => candidate.session === item.session);
+		if (others.length > 0 || siblings.length > 1) held.set(key, {
+			item,
+			receivingAs: others.sort()
+		});
+	}
+	return held;
+}
+/** Receive hooks each bound profile should have and does not. */
+function missingSessionHooks(hooks, bound, node) {
+	return bound.flatMap((item) => SESSION_EVENTS.filter((event) => !hasSessionReceiveHook(hooks, event, item, node)).map((event) => ({
+		event,
+		bound: item
+	})));
+}
+/** Every hook judged for repair, in settings order, then every missing one. */
+function sessionHookItems(hooks, verdicts, missing) {
+	const items = missing.map(({ event, bound }) => ({
+		profile: bound.profile,
+		session: bound.session,
+		hook: event,
+		state: "missing"
+	}));
+	for (const event of SESSION_EVENTS) {
+		const entries = hooks[event];
+		if (!Array.isArray(entries)) continue;
+		for (const entry of entries) {
+			if (!record$2(entry) || !Array.isArray(entry.hooks)) continue;
+			for (const hook of entry.hooks) {
+				const verdict = verdicts.get(hook);
+				const parsed = parseSessionHook(hook);
+				if (!verdict || verdict === "keep" || !parsed) continue;
+				items.push({
+					profile: parsed.profile,
+					session: parsed.session?.toLowerCase() ?? null,
+					hook: event,
+					state: verdict
+				});
+			}
+		}
+	}
+	return items;
+}
+/** The exact entry `agent connect` and `session-register` install. */
+function sessionHookEntry(event, item, cli) {
+	const pending = SESSION_HOOK_KIND[event] === "pending";
+	const hook = {
+		type: "command",
+		command: cli.node,
+		args: [
+			pending ? cli.pending : cli.wake,
+			cli.entry,
+			item.configDir,
+			item.profile,
+			item.address,
+			item.session,
+			pending ? PENDING_MARKER$1 : WAKE_MARKER
+		],
+		...pending ? { timeout: 10 } : {
+			asyncRewake: true,
+			timeout: 604800
+		}
+	};
+	return event === "SessionStart" ? {
+		matcher: "resume",
+		hooks: [hook]
+	} : { hooks: [hook] };
+}
+/** Inspect every Primitive-owned Claude hook without changing anything. */
+function inspectClaudeHooks(settings, context) {
+	const hooks = record$2(settings.hooks) ? settings.hooks : {};
+	const canFix = context.cli !== null && context.blocked === null;
+	const blockedNote = context.blocked ? ` ${context.blocked}` : "";
+	const findings = {};
+	for (const [id, spec] of Object.entries(GLOBAL_HOOKS)) {
+		const entries = eventEntries(hooks, spec.event);
+		if (entries === "invalid") {
+			findings[id] = {
+				status: "fail",
+				detail: `hooks.${spec.event} is not a list. Fix settings.json by hand; it was not modified.`,
+				fixable: false
+			};
+			continue;
+		}
+		const managed = entries.flatMap((entry) => record$2(entry) && Array.isArray(entry.hooks) ? entry.hooks.filter((hook) => isGlobalManaged(hook, spec)) : []);
+		const [first] = managed;
+		if (!first) findings[id] = {
+			status: "fail",
+			detail: `No ${spec.event} hook runs \`primitive agent ${spec.subcommand}\`.${blockedNote}`,
+			fixable: canFix
+		};
+		else if (managed.length > 1) findings[id] = {
+			status: "fail",
+			detail: `${managed.length} ${spec.event} hooks run \`primitive agent ${spec.subcommand}\`; expected exactly one.${blockedNote}`,
+			fixable: canFix
+		};
+		else if (!context.cli || !globalHookCurrent(first, context.cli)) findings[id] = {
+			status: "fail",
+			detail: `The ${spec.event} hook runs ${String(first.args[0])}, which ${existsSync(String(first.args[0])) ? "is not this CLI" : "no longer exists"}.${blockedNote}`,
+			fixable: canFix
+		};
+		else findings[id] = {
+			status: "ok",
+			detail: `${spec.event} runs \`primitive agent ${spec.subcommand}\` from ${context.cli.entry}.`,
+			fixable: false
+		};
+	}
+	const invalid = SESSION_EVENTS.find((event) => eventEntries(hooks, event) === "invalid");
+	if (invalid) {
+		findings["claude.hook.stop"] = {
+			status: "fail",
+			detail: `hooks.${invalid} is not a list. Fix settings.json by hand; it was not modified.`,
+			fixable: false
+		};
+		return findings;
+	}
+	const held = heldSessionProfiles(hooks, context.bound ?? [], context.restoreProfiles);
+	const bound = (context.bound ?? []).filter((item) => !held.has(boundKey(item)));
+	const heldNote = held.size ? ` Left alone: ${[...held.values()].map(({ item, receivingAs }) => `profile ${item.profile} is bound to session ${item.session}, which ${receivingAs.length ? `receives as ${receivingAs.join(", ")}` : "has several bound profiles and receives as none"}`).join("; ")}. Run \`primitive machine doctor --fix --profile <profile>\` to restore one deliberately.` : "";
+	const counts = {
+		keep: 0,
+		stale: 0,
+		duplicate: 0,
+		outdated: 0,
+		old_address: 0
+	};
+	const verdicts = judgeSessionHooks(hooks, context.cli, bound);
+	for (const verdict of verdicts.values()) counts[verdict]++;
+	const missingHooks = missingSessionHooks(hooks, bound, context.cli?.node ?? process.execPath);
+	const missing = missingHooks.length;
+	const items = sessionHookItems(hooks, verdicts, missingHooks);
+	const problems = [
+		missing ? `${missing} missing for connected sessions` : "",
+		counts.old_address ? `${counts.old_address} naming an old agent address` : "",
+		counts.stale ? `${counts.stale} for disconnected or removed sessions` : "",
+		counts.duplicate ? `${counts.duplicate} duplicates` : "",
+		counts.outdated ? `${counts.outdated} pointing at an old CLI path` : ""
+	].filter(Boolean);
+	findings["claude.hook.stop"] = problems.length ? {
+		status: "fail",
+		detail: `Per-session receive hooks need cleanup: ${problems.join(", ")}. Affected: ${summarizeOwners(items)}.${blockedNote}${heldNote}`,
+		fixable: canFix || counts.outdated === 0 && missing === 0 && context.blocked === null,
+		items
+	} : {
+		status: "ok",
+		detail: `${counts.keep ? `${counts.keep} per-session receive hooks, each present once and current.` : "No per-session receive hooks; each registered session adds its own exact-session hooks."}${heldNote}`,
+		fixable: false
+	};
+	return findings;
+}
+function rewriteEntries(entries, transform) {
+	let changed = false;
+	return {
+		entries: entries.flatMap((entry) => {
+			if (!record$2(entry) || !Array.isArray(entry.hooks)) return [entry];
+			let touched = false;
+			const kept = entry.hooks.flatMap((hook) => {
+				const replacement = transform(hook);
+				if (replacement === hook) return [hook];
+				touched = true;
+				return replacement === void 0 ? [] : [replacement];
+			});
+			if (!touched) return [entry];
+			changed = true;
+			return kept.length ? [{
+				...entry,
+				hooks: kept
+			}] : [];
+		}),
+		changed
+	};
+}
+/**
+* Apply fixes for the requested checks to a copy of the settings. Only
+* Primitive-owned hooks are added, rewritten or removed; every other key,
+* entry and sibling hook is carried over unchanged.
+*/
+function repairClaudeHooks(settings, context, checks, options = {}) {
+	const changed = /* @__PURE__ */ new Set();
+	const changes = [];
+	const selected = (profile) => !options.profiles || profile !== null && options.profiles.has(profile);
+	const hooks = record$2(settings.hooks) ? { ...settings.hooks } : {};
+	const cli = context.blocked === null ? context.cli : null;
+	for (const [id, spec] of Object.entries(GLOBAL_HOOKS)) {
+		if (!checks.has(id) || !cli) continue;
+		const entries = eventEntries(hooks, spec.event);
+		if (entries === "invalid") continue;
+		let placed = false;
+		const result = rewriteEntries(entries, (hook) => {
+			if (!isGlobalManaged(hook, spec)) return hook;
+			if (placed) return void 0;
+			placed = true;
+			if (globalHookCurrent(hook, cli)) return hook;
+			return {
+				...hook,
+				command: cli.node,
+				args: globalHookArgs(cli, spec)
+			};
+		});
+		let next = result.entries;
+		if (!placed) next = [...next, { hooks: [{
+			type: "command",
+			command: cli.node,
+			args: globalHookArgs(cli, spec),
+			timeout: spec.timeout
+		}] }];
+		if (result.changed || !placed) {
+			hooks[spec.event] = next;
+			changed.add(id);
+		}
+	}
+	if (checks.has("claude.hook.stop") && context.blocked === null) {
+		if (!SESSION_EVENTS.some((event) => eventEntries(hooks, event) === "invalid")) {
+			const held = heldSessionProfiles(hooks, context.bound ?? [], context.restoreProfiles);
+			const bound = (context.bound ?? []).filter((item) => !held.has(boundKey(item)));
+			const verdicts = judgeSessionHooks(hooks, context.cli, bound);
+			for (const event of SESSION_EVENTS) {
+				const entries = eventEntries(hooks, event);
+				if (entries === "invalid" || entries.length === 0) continue;
+				const result = rewriteEntries(entries, (hook) => {
+					const verdict = verdicts.get(hook);
+					const parsed = parseSessionHook(hook);
+					if (!verdict || verdict === "keep" || !parsed) return hook;
+					if (!selected(parsed.profile)) return hook;
+					const item = {
+						profile: parsed.profile,
+						session: parsed.session?.toLowerCase() ?? null,
+						hook: event,
+						state: verdict
+					};
+					if (verdict === "stale" || verdict === "duplicate" || verdict === "old_address") {
+						changes.push({
+							...item,
+							action: "removed"
+						});
+						return;
+					}
+					if (!cli || !record$2(hook)) return hook;
+					const args = [...hook.args];
+					args[0] = parsed.kind === "pending" ? cli.pending : cli.wake;
+					args[1] = cli.entry;
+					changes.push({
+						...item,
+						action: "updated"
+					});
+					return {
+						...hook,
+						command: cli.node,
+						args
+					};
+				});
+				if (result.changed) {
+					hooks[event] = result.entries;
+					changed.add("claude.hook.stop");
+				}
+			}
+			if (cli) for (const missing of missingSessionHooks(hooks, bound, cli.node)) {
+				if (!selected(missing.bound.profile)) continue;
+				const entries = eventEntries(hooks, missing.event);
+				if (entries === "invalid") continue;
+				changes.push({
+					profile: missing.bound.profile,
+					session: missing.bound.session,
+					hook: missing.event,
+					state: "missing",
+					action: "added"
+				});
+				hooks[missing.event] = [...entries, sessionHookEntry(missing.event, missing.bound, cli)];
+				changed.add("claude.hook.stop");
+			}
+		}
+	}
+	if (!changed.size) return {
+		settings,
+		changed,
+		changes
+	};
+	return {
+		settings: {
+			...settings,
+			hooks
+		},
+		changed,
+		changes
+	};
+}
+//#endregion
+//#region src/oclif/claude-wake-install.ts
+const HOOK_MARKER = "primitive-agent-wake-v1";
+const WAKE_EVENTS = ["Stop", "SessionStart"];
+const PENDING_MARKER = "primitive-pending-mail-v1";
+const PENDING_EVENT = "PostToolUse";
+const LOCK_WAIT = new Int32Array(new SharedArrayBuffer(4));
+function record$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** Clock skew tolerated for a record written slightly in the future. */
+const RECORD_CLOCK_SKEW_MS = 6e4;
+function hookMailCheckPath(configDir, profileName, sessionId) {
+	return join(agentProfileDirectory(configDir, profileName), `pending-mail-${sessionId}.mail-check.json`);
+}
+/**
+* Record that a listener run by this session's receive hook just completed a
+* mail check with the server. Fails open: receiving never depends on it.
+*/
+function recordHookMailCheck(options) {
+	try {
+		if (!SESSION_UUID.test(options.sessionId)) return;
+		writeMailJson(hookMailCheckPath(resolve(options.configDir), agentProfileName(options.profileName), options.sessionId.toLowerCase()), {
+			version: 1,
+			at: new Date(options.at ?? Date.now()).toISOString()
+		});
+	} catch {}
+}
+function recordedAt(value) {
+	return record$1(value) && value.version === 1 && typeof value.at === "string" && Number.isFinite(Date.parse(value.at)) ? value.at : null;
+}
+function claudeWakeHookStatus(options) {
+	const unavailable = {
+		installed: false,
+		lastFiredAt: null,
+		lastMailCheckAt: null,
+		firedRecently: false,
+		liveness: "unknown"
+	};
+	try {
+		const configDir = resolve(options.configDir);
+		const profileName = agentProfileName(options.profileName);
+		const agentAddress = mailAddress(options.agentAddress);
+		if (!SESSION_UUID.test(options.sessionId)) return unavailable;
+		const sessionId = options.sessionId.toLowerCase();
+		const env = options.env ?? process.env;
+		const read = readManagedFile(join(resolve(env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude")), "settings.json"));
+		if (read.state !== "present") return unavailable;
+		const settings = JSON.parse(read.text);
+		if (!record$1(settings) || !record$1(settings.hooks)) return unavailable;
+		const hooks = settings.hooks;
+		const target = {
+			configDir,
+			profile: profileName,
+			address: agentAddress,
+			session: sessionId
+		};
+		const node = stableNodePath(env);
+		const installed = [
+			"Stop",
+			"SessionStart",
+			"PostToolUse"
+		].every((event) => hasSessionReceiveHook(hooks, event, target, node));
+		const lastFiredAt = recordedAt(readMailJson(join(agentProfileDirectory(configDir, profileName), `pending-mail-${sessionId}.fired.json`)));
+		const lastMailCheckAt = recordedAt(readMailJson(hookMailCheckPath(configDir, profileName, sessionId)));
+		const now = options.now ?? Date.now();
+		const recent = (at) => {
+			if (at === null) return false;
+			const age = now - Date.parse(at);
+			return age >= -RECORD_CLOCK_SKEW_MS && age <= 6e5;
+		};
+		return {
+			installed,
+			lastFiredAt,
+			lastMailCheckAt,
+			firedRecently: installed && recent(lastFiredAt),
+			liveness: installed && recent(lastMailCheckAt) ? "checked_recently" : "unknown"
+		};
+	} catch {
+		return unavailable;
+	}
+}
+/**
+* Apply one edit to Claude's settings under the shared lock, backing up the
+* previous file. Exported for tests.
+*/
+function editClaudeSettings(claudeDir, edit) {
+	mkdirSync(claudeDir, {
+		recursive: true,
+		mode: 448
+	});
+	let release;
+	for (let attempt = 0; attempt < 40; attempt++) try {
+		release = acquireListenLock(claudeDir, "primitive-claude-settings");
+		break;
+	} catch {
+		Atomics.wait(LOCK_WAIT, 0, 0, 25);
+	}
+	if (!release) return false;
+	try {
+		const settingsPath = join(claudeDir, "settings.json");
+		for (let attempt = 0; attempt < 3; attempt++) {
+			const read = readManagedFile(settingsPath);
+			if (read.state === "invalid") return false;
+			let settings = {};
+			if (read.state === "present") {
+				const parsed = JSON.parse(read.text);
+				if (!record$1(parsed)) return false;
+				settings = parsed;
+			}
+			const next = edit(settings);
+			if (next === null) return true;
+			const content = `${JSON.stringify(next, null, 2)}\n`;
+			if (read.state === "present" && content === read.text) return true;
+			try {
+				writeManagedFile({
+					read,
+					content,
+					newFileMode: 384
+				});
+				return true;
+			} catch (error) {
+				if (!(error instanceof MachineFileError)) throw error;
+			}
+		}
+		return false;
+	} finally {
+		release();
+	}
+}
+/** Add exact-session fail-open receiving hooks while preserving unrelated settings. */
+function installClaudeWakeHook(options) {
+	try {
+		const cliPath = realpathSync(options.cliPath);
+		const wrapperPath = realpathSync(join(dirname(cliPath), "claude-wake.mjs"));
+		const pendingPath = realpathSync(join(dirname(cliPath), "claude-pending-mail.mjs"));
+		const configDir = resolve(options.configDir);
+		const profileName = agentProfileName(options.profileName);
+		const agentAddress = mailAddress(options.agentAddress);
+		if (!SESSION_UUID.test(options.sessionId)) return "unavailable";
+		const sessionId = options.sessionId.toLowerCase();
+		const env = options.env ?? process.env;
+		const claudeDir = resolve(env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude"));
+		const node = stableNodePath(env);
+		let held = false;
+		if (!editClaudeSettings(claudeDir, (settings) => {
+			const hooks = settings.hooks ?? {};
+			if (!record$1(hooks)) throw new Error("Invalid hook settings");
+			for (const event of WAKE_EVENTS) if (!Array.isArray(hooks[event] ?? [])) throw new Error(`Invalid ${event} hooks`);
+			if (!Array.isArray(hooks[PENDING_EVENT] ?? [])) throw new Error(`Invalid ${PENDING_EVENT} hooks`);
+			held = options.yieldToOtherProfiles === true && otherSessionReceivers(hooks, {
+				configDir,
+				profile: profileName,
+				session: sessionId
+			}).length > 0;
+			const hook = {
+				type: "command",
+				command: node,
+				args: [
+					wrapperPath,
+					cliPath,
+					configDir,
+					profileName,
+					agentAddress,
+					sessionId,
+					HOOK_MARKER
+				],
+				asyncRewake: true,
+				timeout: 604800
+			};
+			const pendingHook = {
+				type: "command",
+				command: node,
+				args: [
+					pendingPath,
+					cliPath,
+					configDir,
+					profileName,
+					agentAddress,
+					sessionId,
+					PENDING_MARKER
+				],
+				timeout: 10
+			};
+			const isOwnPendingHook = (candidate) => record$1(candidate) && candidate.type === "command" && Array.isArray(candidate.args) && candidate.args.length === 7 && typeof candidate.args[0] === "string" && basename(candidate.args[0]) === "claude-pending-mail.mjs" && candidate.args[2] === configDir && candidate.args[3] === profileName && candidate.args[5] === sessionId && candidate.args[6] === PENDING_MARKER;
+			const isOwnHook = (candidate) => {
+				if (!record$1(candidate) || !Array.isArray(candidate.args)) return false;
+				if (typeof candidate.args[0] !== "string" || basename(candidate.args[0]) !== "claude-wake.mjs" || candidate.args[2] !== configDir || candidate.args[3] !== profileName) return false;
+				if (candidate.args.length === 7 && candidate.args[5] === sessionId && candidate.args[6] === HOOK_MARKER) return true;
+				if (candidate.args.length !== 6 || candidate.args[5] !== HOOK_MARKER) return false;
+				try {
+					const state = readMailJson(join(agentProfileDirectory(configDir, profileName), "setup.json"));
+					return record$1(state) && state.session === sessionId;
+				} catch {
+					return false;
+				}
+			};
+			const nextHooks = { ...hooks };
+			for (const event of WAKE_EVENTS) {
+				const entries = hooks[event];
+				const retained = (entries ?? []).flatMap((entry) => {
+					if (!record$1(entry) || !Array.isArray(entry.hooks)) return [entry];
+					const siblings = entry.hooks.filter((candidate) => !isOwnHook(candidate));
+					if (siblings.length === entry.hooks.length) return [entry];
+					return siblings.length ? [{
+						...entry,
+						hooks: siblings
+					}] : [];
+				});
+				if (held) {
+					if (entries) nextHooks[event] = retained;
+				} else nextHooks[event] = [...retained, event === "SessionStart" ? {
+					matcher: "resume",
+					hooks: [hook]
+				} : { hooks: [hook] }];
+			}
+			const pendingEntries = hooks[PENDING_EVENT];
+			const pendingRetained = (pendingEntries ?? []).flatMap((entry) => {
+				if (!record$1(entry) || !Array.isArray(entry.hooks)) return [entry];
+				const siblings = entry.hooks.filter((candidate) => !isOwnPendingHook(candidate));
+				if (siblings.length === entry.hooks.length) return [entry];
+				return siblings.length ? [{
+					...entry,
+					hooks: siblings
+				}] : [];
+			});
+			if (held) {
+				if (pendingEntries) nextHooks[PENDING_EVENT] = pendingRetained;
+			} else nextHooks[PENDING_EVENT] = [...pendingRetained, { hooks: [pendingHook] }];
+			if (held && JSON.stringify(nextHooks) === JSON.stringify(hooks)) return null;
+			return {
+				...settings,
+				hooks: nextHooks
+			};
+		})) return "unavailable";
+		return held ? "held_for_other_profile" : "installed_unverified";
+	} catch {
+		return "unavailable";
+	}
+}
+/** Remove only this profile's exact-session hooks after disconnection. */
+function uninstallClaudeWakeHook(options) {
+	try {
+		const configDir = resolve(options.configDir);
+		const profileName = agentProfileName(options.profileName);
+		const agentAddress = mailAddress(options.agentAddress);
+		if (!SESSION_UUID.test(options.sessionId)) return false;
+		const sessionId = options.sessionId.toLowerCase();
+		const claudeDir = resolve((options.env ?? process.env).CLAUDE_CONFIG_DIR || join(homedir(), ".claude"));
+		if (!existsSync(join(claudeDir, "settings.json"))) return true;
+		return editClaudeSettings(claudeDir, (settings) => {
+			const hooks = settings.hooks ?? {};
+			if (!record$1(hooks)) throw new Error("Invalid hook settings");
+			for (const event of WAKE_EVENTS) if (!Array.isArray(hooks[event] ?? [])) throw new Error(`Invalid ${event} hooks`);
+			if (!Array.isArray(hooks[PENDING_EVENT] ?? [])) throw new Error(`Invalid ${PENDING_EVENT} hooks`);
+			const legacySessionMatches = () => {
+				try {
+					const setup = readMailJson(join(agentProfileDirectory(configDir, profileName), "setup.json"));
+					return record$1(setup) && setup.session === sessionId;
+				} catch {
+					return false;
+				}
+			};
+			const isOwnHook = (candidate) => {
+				if (!record$1(candidate) || !Array.isArray(candidate.args)) return false;
+				const args = candidate.args;
+				return candidate.type === "command" && typeof candidate.command === "string" && candidate.asyncRewake === true && typeof args[0] === "string" && basename(args[0]) === "claude-wake.mjs" && typeof args[1] === "string" && args[2] === configDir && args[3] === profileName && args[4] === agentAddress && (args.length === 7 && args[5] === sessionId && args[6] === HOOK_MARKER || args.length === 6 && args[5] === HOOK_MARKER && legacySessionMatches());
+			};
+			const isOwnPendingHook = (candidate) => {
+				if (!record$1(candidate) || !Array.isArray(candidate.args)) return false;
+				const args = candidate.args;
+				return candidate.type === "command" && typeof candidate.command === "string" && typeof args[0] === "string" && basename(args[0]) === "claude-pending-mail.mjs" && args[2] === configDir && args[3] === profileName && args[4] === agentAddress && args[5] === sessionId && args[6] === PENDING_MARKER && args.length === 7;
+			};
+			let removed = false;
+			const nextHooks = { ...hooks };
+			for (const event of WAKE_EVENTS) nextHooks[event] = (hooks[event] ?? []).flatMap((entry) => {
+				if (!record$1(entry) || !Array.isArray(entry.hooks)) return [entry];
+				const siblings = entry.hooks.filter((candidate) => !isOwnHook(candidate));
+				if (siblings.length === entry.hooks.length) return [entry];
+				removed = true;
+				return siblings.length ? [{
+					...entry,
+					hooks: siblings
+				}] : [];
+			});
+			nextHooks[PENDING_EVENT] = (hooks[PENDING_EVENT] ?? []).flatMap((entry) => {
+				if (!record$1(entry) || !Array.isArray(entry.hooks)) return [entry];
+				const siblings = entry.hooks.filter((candidate) => !isOwnPendingHook(candidate));
+				if (siblings.length === entry.hooks.length) return [entry];
+				removed = true;
+				return siblings.length ? [{
+					...entry,
+					hooks: siblings
+				}] : [];
+			});
+			return removed ? {
+				...settings,
+				hooks: nextHooks
+			} : null;
+		});
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/oclif/agent-connect.ts
+const MAX_INVITATION_BYTES = 4096;
+const MAX_RESPONSE_BYTES$1 = 32768;
+const UNCERTAIN_CLAIM = "Setup did not complete safely. The invitation may have been consumed. Request a fresh invitation from the owner; do not retry this invitation.";
+/** The receiver a saved profile's setup record names. Offline. */
+function savedReceiver(configDir, profileName) {
+	try {
+		const setup = readMailJson(join(agentProfileDirectory(configDir, profileName), "setup.json"));
+		if (!setup || typeof setup !== "object" || Array.isArray(setup)) return null;
+		const saved = setup;
+		return {
+			mode: saved.receiverMode === "external" || saved.receiverMode === "poll" ? saved.receiverMode : "native",
+			session: typeof saved.session === "string" && SESSION_UUID.test(saved.session) ? saved.session : null
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Where to inspect a saved profile's receiver, by how it receives. Hook and
+* poll receivers run no background listener, so `listen --status` would
+* report one absent; they are inspected with `agent connect --status`.
+*/
+function receiverStatusCommand(configDir, profileName) {
+	const receiver = savedReceiver(configDir, profileName);
+	if (receiver?.mode === "native" && receiver.session) return {
+		mode: "native",
+		command: `PRIMITIVE_AGENT_PROFILE=${profileName} primitive listen --status --notify-session ${receiver.session}`
+	};
+	return {
+		mode: receiver?.mode ?? null,
+		command: `primitive agent connect --profile ${profileName} --status --json`
+	};
+}
+/** Offline metadata only; a saved profile is not proof of current API or listener readiness. */
+function agentConnectionStatus(configDir, profileName, env = process.env) {
+	agentProfileName(profileName);
+	const profile = loadConnectedAgentProfile(configDir, profileName);
+	const setup = profile ? readMailJson(join(agentProfileDirectory(configDir, profileName), "setup.json")) : null;
+	const saved = setup && typeof setup === "object" && !Array.isArray(setup) ? setup : null;
+	const session = saved && typeof saved.session === "string" && SESSION_UUID.test(saved.session) ? saved.session : null;
+	const mode = saved?.receiverMode === "external" || saved?.receiverMode === "poll" ? saved.receiverMode : "native";
+	const receiving = profile && saved && mode === "poll" ? {
+		mode,
+		sessionId: session,
+		state: "poll",
+		reason: "agent_checks_mail",
+		lastSuccessfulMailCheckAt: null,
+		liveness: "unknown"
+	} : profile && session && mode === "native" ? (() => {
+		const scope = notificationScope(profile.api_base_url, profile.api_key);
+		const listener = backgroundListenStatus({
+			configDir,
+			scope,
+			threadId: session
+		});
+		const mailOwner = readSharedMailOwner({ directory: join(configDir, "shared-mail", createHash("sha256").update(scope).digest("hex")) });
+		return {
+			mode,
+			sessionId: session,
+			state: listener.healthy ? listener.phase === "receiving" ? "running" : "degraded" : listener.reason === "restarting" ? "degraded" : listener.reason === "absent" ? "unknown" : "down",
+			reason: listener.reason ?? listener.failureCode,
+			failureCode: listener.failureCode,
+			detail: listener.detail ?? null,
+			lastSuccessfulMailCheckAt: mailOwner?.lastMailCheckAt ?? null,
+			liveness: listener.healthy && listener.phase === "receiving" ? "live" : "unknown",
+			listener
+		};
+	})() : profile && session ? (() => {
+		const hook = claudeWakeHookStatus({
+			configDir,
+			profileName,
+			agentAddress: profile.agent_address,
+			sessionId: session,
+			env
+		});
+		const checked = hook.liveness === "checked_recently";
+		const unconfirmed = !checked && hook.firedRecently;
+		return {
+			mode,
+			sessionId: session,
+			state: !hook.installed ? "down" : checked ? "running" : "unknown",
+			reason: !hook.installed ? "hook_missing" : checked ? "hook_mail_check_recent" : unconfirmed ? "hook_mail_check_unconfirmed" : "hook_liveness_unverified",
+			detail: !hook.installed ? "The receive hook for this session is missing, so mail will not wake this session. Run `primitive machine doctor --fix` to reinstall it." : checked ? "A listener run by this session's receive hook completed a mail check recently. A wake from idle is confirmed only when new mail arrives." : unconfirmed ? "The receive hook ran recently, but no completed mail check has been recorded in that time. Mail may not be arriving; check this session's Primitive connection." : null,
+			lastSuccessfulMailCheckAt: hook.lastMailCheckAt,
+			lastFiredAt: hook.lastFiredAt,
+			liveness: hook.liveness,
+			hook
+		};
+	})() : {
+		mode: "unknown",
+		sessionId: null,
+		state: "unknown",
+		reason: "session_not_configured",
+		lastSuccessfulMailCheckAt: null,
+		liveness: "unknown"
+	};
+	return profile ? {
+		status: "configured",
+		identity: connectedAgentIdentity(profileName, profile),
+		receiving
+	} : {
+		status: "not_configured",
+		profileName
+	};
+}
+function parseAgentInvitation(input) {
+	try {
+		if (Buffer.byteLength(input) > MAX_INVITATION_BYTES) throw new Error();
+		const text = input.trim();
+		let token;
+		let base;
+		if (text.startsWith("{")) {
+			const value = JSON.parse(text);
+			if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error();
+			const row = value;
+			if (Object.keys(row).some((key) => key !== "token" && key !== "api_base_url")) throw new Error();
+			token = row.token;
+			base = row.api_base_url ?? "https://api.primitive.dev/v1";
+		} else {
+			const url = new URL(text);
+			if (url.username || url.password || url.search || url.pathname !== "/v1/agent-connections/setup") throw new Error();
+			const fragment = new URLSearchParams(url.hash.slice(1));
+			if (Array.from(fragment.keys()).length !== 1 || fragment.getAll("token").length !== 1) throw new Error();
+			token = fragment.get("token");
+			base = `${url.origin}/v1`;
+		}
+		if (typeof token !== "string" || token.length < 32 || token.length > 256 || /\s/.test(token) || Array.from(token).some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127)) throw new Error();
+		return {
+			token,
+			apiBaseUrl: connectedApiBaseUrl(base)
+		};
+	} catch {
+		throw new AgentConnectionSetupError("Pipe the private Primitive setup URL or a JSON object containing token and optional api_base_url to stdin. Invitation values are never accepted as command arguments.");
+	}
+}
+/** The saved binding of an invitation: a one-way hash of its origin and token. */
+function agentInvitationHash(input) {
+	const invitation = parseAgentInvitation(input);
+	return createHash("sha256").update(invitation.apiBaseUrl).update("\0").update(invitation.token).digest("hex");
+}
+async function readAgentInvitation(input, isTTY) {
+	if (isTTY) throw new AgentConnectionSetupError("Pipe the private setup invitation to stdin.");
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of input) {
+		const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		size += bytes.length;
+		if (size > MAX_INVITATION_BYTES) throw new AgentConnectionSetupError("Setup invitation exceeds the input limit.");
+		chunks.push(bytes);
+	}
+	return Buffer.concat(chunks).toString("utf8");
+}
+async function readClaimResponse(response) {
+	const reader = response.body?.getReader();
+	if (!reader) throw new Error();
+	const chunks = [];
+	let size = 0;
+	try {
+		for (;;) {
+			const part = await reader.read();
+			if (part.done) break;
+			size += part.value.byteLength;
+			if (size > MAX_RESPONSE_BYTES$1) throw new Error();
+			chunks.push(part.value);
+		}
+		return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+	} finally {
+		await reader.cancel().catch(() => void 0);
+	}
+}
+function profileFromClaim(value, invitation, invitationHash, now) {
+	const response = value;
+	const data = response?.data;
+	const connection = data?.connection;
+	if (response?.success !== true || !data || !connection || data.api_base_url !== invitation.apiBaseUrl || data.owner_address !== connection.owner_address || !["claimed", "connected"].includes(String(connection.status))) throw new Error();
+	let ownerMember;
+	try {
+		ownerMember = Object.hasOwn(data, "owner_member_address") ? parseOwnerMemberAddress(data.owner_member_address, mailAddress(data.owner_address), mailAddress(connection.address)) : void 0;
+	} catch {
+		ownerMember = void 0;
+	}
+	return parseConnectedAgentProfile({
+		version: 1,
+		auth_method: "agent_connection",
+		api_key: data.api_key,
+		api_base_url: data.api_base_url,
+		org_id: data.org_id,
+		agent_address: connection.address,
+		owner_address: data.owner_address,
+		...ownerMember === void 0 ? {} : { owner_member_address: ownerMember },
+		invitation_hash: invitationHash,
+		created_at: new Date(now()).toISOString(),
+		...data.presence_profile === void 0 ? {} : { presence_profile: data.presence_profile }
+	});
+}
+/** Claims once; saved identity is local configuration, not proof of email readiness. */
+async function connectAgent(params) {
+	const profileName = agentProfileName(params.profileName);
+	const invitation = parseAgentInvitation(params.invitation);
+	const invitationHash = agentInvitationHash(params.invitation);
+	const directory = agentProfilesDirectory(params.configDir);
+	let release;
+	try {
+		privateMailDirectory(directory, true);
+		release = acquireListenLock(directory, "agent-connection-setup");
+	} catch {
+		throw new AgentConnectionSetupError("Agent setup is already running, or its private directory is unavailable. No invitation was submitted.");
+	}
+	try {
+		const existing = loadConnectedAgentProfile(params.configDir, profileName);
+		if (existing) {
+			if (existing.invitation_hash !== invitationHash) throw new AgentConnectionSetupError(profileAlreadyConnectedMessage(profileName, existing.agent_address));
+			return {
+				status: "already_configured",
+				identity: connectedAgentIdentity(profileName, existing)
+			};
+		}
+		privateMailDirectory(join(directory, "profiles"), true);
+		privateMailDirectory(agentProfileDirectory(params.configDir, profileName), true);
+		const journal = join(directory, "claims", `${invitationHash}.json`);
+		privateMailDirectory(join(directory, "claims"), true);
+		if (readMailJson(journal) !== null) throw new AgentConnectionSetupError(UNCERTAIN_CLAIM);
+		writeMailJson(journal, {
+			version: 1,
+			profile_name: profileName,
+			status: "attempted"
+		});
+		try {
+			const response = await (params.fetch ?? fetch)(`${invitation.apiBaseUrl}/agent-connections/claim`, {
+				method: "POST",
+				redirect: "error",
+				signal: AbortSignal.timeout(25e3),
+				headers: {
+					"content-type": "application/json",
+					accept: "application/json"
+				},
+				body: JSON.stringify({
+					token: invitation.token,
+					...params.presence ? { capabilities: ["primitive.presence/1"] } : {}
+				})
+			});
+			if (response.status !== 200) {
+				await response.body?.cancel();
+				throw new Error();
+			}
+			const profile = profileFromClaim(await readClaimResponse(response), invitation, invitationHash, params.now ?? Date.now);
+			saveConnectedAgentProfile(params.configDir, profileName, profile);
+			return {
+				status: "claimed",
+				identity: connectedAgentIdentity(profileName, profile)
+			};
+		} catch {
+			throw new AgentConnectionSetupError(UNCERTAIN_CLAIM);
+		}
+	} finally {
+		release();
+	}
+}
+//#endregion
+//#region src/oclif/contacts.ts
+var ContactsApiError = class extends Error {
+	directoryAvailable = false;
+	constructor(payload) {
+		super("Contact request failed.");
+		this.payload = payload;
+	}
+};
+function contactAddress(value) {
+	const address = value.trim().toLowerCase();
+	if (address.length > 254 || !/^[A-Za-z0-9.!#$%&'*+/=?^_`{|}~-]+@[A-Za-z0-9](?:[A-Za-z0-9.-]*[A-Za-z0-9])?$/.test(address)) throw new Error("Provide a bare contact email address.");
+	return address;
+}
+function contactAgentAddress(explicit, connected) {
+	if (!explicit && !connected) throw new Error("Pass --agent or select a connected agent profile.");
+	const address = contactAddress(explicit ?? connected ?? "");
+	if (connected && address !== contactAddress(connected)) throw new Error("This connected profile can manage only its own agent contacts.");
+	return address;
+}
+function version(value) {
+	if (!/^[a-f\d]{8}(?:-[a-f\d]{4}){3}-[a-f\d]{12}$/i.test(value)) throw new Error("The contact version must be the UUID returned by the API.");
+	return value;
+}
+async function response(pending) {
+	const result = await pending;
+	if (result.error !== void 0) throw new ContactsApiError(result.error);
+	if (result.data?.success !== true || result.data.data == null) throw new Error("The contacts API returned an incomplete response.");
+	return result.data;
+}
+function pageCursor(value) {
+	const cursor = value.meta?.cursor;
+	if (cursor === null) return null;
+	if (typeof cursor !== "string") throw new Error("The contacts API omitted pagination state; no write was attempted.");
+	return contactAddress(cursor);
+}
+async function membershipVersion(client, agent, address, signal) {
+	let cursor;
+	const seen = /* @__PURE__ */ new Set();
+	for (let page = 0; page < 1e3; page++) {
+		signal?.throwIfAborted();
+		const result = await response(listAgentContacts({
+			client,
+			path: { agent_address: agent },
+			query: {
+				limit: 100,
+				cursor
+			},
+			signal,
+			responseStyle: "fields"
+		}));
+		if (!Array.isArray(result.data)) throw new Error("The contacts API returned an invalid page.");
+		const next = pageCursor(result);
+		const found = result.data.find((row) => row.contact_address === address);
+		if (found) {
+			if (found.agent_address !== agent) throw new Error("The contacts API returned a different agent.");
+			return version(found.version);
+		}
+		if (next === null) throw new Error("Agent contact not found. Use agent contacts add to create it.");
+		if (seen.has(next)) throw new Error("Contact pagination repeated a cursor; no write was attempted.");
+		seen.add(next);
+		cursor = next;
+	}
+	throw new Error("Contact lookup exceeded its page limit; pass an explicit --if-version.");
+}
+/** Public generated operations only. Every mutation uses one explicit CAS condition. */
+async function runContactRequest(client, request) {
+	const { action, target, signal } = request;
+	signal?.throwIfAborted();
+	const address = action === "list" ? void 0 : contactAddress(request.address ?? "");
+	const agent = target === "agent" ? contactAgentAddress(request.agent) : void 0;
+	const limit = request.limit ?? 50;
+	if (!Number.isInteger(limit) || limit < 1 || limit > 100) throw new Error("--limit must be between 1 and 100.");
+	const cursor = request.cursor === void 0 ? void 0 : contactAddress(request.cursor);
+	if (request.name !== void 0 && request.clearName) throw new Error("Use either --name or --clear-name.");
+	if (request.purpose !== void 0 && request.clearPurpose) throw new Error("Use either --purpose or --clear-purpose.");
+	if (request.name !== void 0 && Array.from(request.name).length > 200) throw new Error("Contact names may contain at most 200 characters.");
+	if (request.purpose !== void 0 && Array.from(request.purpose).length > 2e3) throw new Error("Contact purposes may contain at most 2000 characters.");
+	const expected = request.ifVersion === void 0 ? void 0 : version(request.ifVersion);
+	if (action === "add" && expected) throw new Error("Add never overwrites an existing contact. Use update with --if-version.");
+	if (action === "list") {
+		const result = target === "directory" ? await response(listContacts({
+			client,
+			signal,
+			query: {
+				cursor,
+				limit
+			},
+			responseStyle: "fields"
+		})) : await response(listAgentContacts({
+			client,
+			signal,
+			path: { agent_address: agent ?? "" },
+			query: {
+				cursor,
+				limit
+			},
+			responseStyle: "fields"
+		}));
+		if (!Array.isArray(result.data)) throw new Error("The contacts API returned an invalid page.");
+		pageCursor(result);
+		return result;
+	}
+	if (!address) throw new Error("Provide a contact email address.");
+	if (target === "directory") {
+		const name = request.clearName ? null : request.name;
+		if (action === "update" && name === void 0) throw new Error("Pass --name or --clear-name to update the contact.");
+		if (action === "get" || (action === "update" || action === "remove") && !expected) {
+			const result = await response(getContact({
+				client,
+				signal,
+				path: { address },
+				responseStyle: "fields"
+			}));
+			if (result.data.address !== address) throw new Error("The contacts API returned a different contact.");
+			if (action === "get") return result.data;
+			request = {
+				...request,
+				ifVersion: version(result.data.version)
+			};
+		}
+		signal?.throwIfAborted();
+		if (action === "remove") return (await response(deleteContact({
+			client,
+			signal,
+			path: { address },
+			query: { if_version: version(request.ifVersion ?? "") },
+			responseStyle: "fields"
+		}))).data;
+		const result = await response(putContact({
+			client,
+			signal,
+			path: { address },
+			body: {
+				...action === "add" ? { if_absent: true } : { if_version: version(request.ifVersion ?? "") },
+				...name === void 0 ? {} : { display_name: name }
+			},
+			responseStyle: "fields"
+		}));
+		if (result.data.address !== address) throw new Error("The contacts API returned a different contact.");
+		return result.data;
+	}
+	if (!agent) throw new Error("Provide an agent address.");
+	if (action === "get") throw new Error("Use agent contacts list to inspect memberships.");
+	const purpose = request.clearPurpose ? null : request.purpose;
+	if (action === "update" && purpose === void 0 && request.notify === void 0) throw new Error("Pass --purpose, --clear-purpose, --notify or --no-notify.");
+	const path = {
+		agent_address: agent,
+		contact_address: address
+	};
+	if (action === "add") {
+		if ((await response(putContact({
+			client,
+			signal,
+			path: { address },
+			body: { if_absent: true },
+			responseStyle: "fields"
+		}))).data.address !== address) throw new Error("The contacts API returned a different contact.");
+	}
+	const ifVersion = action === "add" ? void 0 : expected ?? await membershipVersion(client, agent, address, signal);
+	if (action === "remove") {
+		signal?.throwIfAborted();
+		return (await response(deleteAgentContact({
+			client,
+			signal,
+			path,
+			query: { if_version: version(ifVersion ?? "") },
+			responseStyle: "fields"
+		}))).data;
+	}
+	try {
+		signal?.throwIfAborted();
+		const result = await response(putAgentContact({
+			client,
+			signal,
+			path,
+			body: {
+				...action === "add" ? { if_absent: true } : { if_version: version(ifVersion ?? "") },
+				...purpose === void 0 ? {} : { purpose },
+				...request.notify === void 0 ? {} : { notify: request.notify }
+			},
+			responseStyle: "fields"
+		}));
+		if (result.data.agent_address !== agent || result.data.contact_address !== address) throw new Error("The contacts API returned a different membership.");
+		return result.data;
+	} catch (error) {
+		if (action === "add") {
+			const failure = error instanceof ContactsApiError ? error : new ContactsApiError({
+				code: "contact_membership_unsaved",
+				message: error instanceof Error ? error.message : "Agent contact request failed."
+			});
+			failure.directoryAvailable = true;
+			throw failure;
+		}
+		throw error;
+	}
+}
+//#endregion
+//#region src/oclif/address-notes.ts
+var AddressNotesApiError = class extends Error {
+	constructor(payload, status) {
+		super("Address note request failed.");
+		this.payload = payload;
+		this.status = status;
+	}
+};
+const security = [{
+	scheme: "bearer",
+	type: "http"
+}];
+function addressNoteName(value) {
+	if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/.test(value)) throw new Error("Note name must start with a letter or digit and contain at most 128 letters, digits, underscores, dots, or hyphens.");
+	return value;
+}
+function addressNoteVersion(value) {
+	if (!/^[0-9]{1,19}$/.test(value)) throw new Error("Note version must be the decimal version returned by the API.");
+	return value;
+}
+function addressNoteTarget(explicit, connected, write) {
+	if (!explicit && !connected) throw new Error("Pass --address or select a connected agent profile.");
+	const address = contactAddress(explicit ?? connected ?? "");
+	if (write && connected && address !== contactAddress(connected)) throw new Error("This connected profile can write only its own address notes.");
+	return address;
+}
+function note(value, address, name) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("The address notes API returned an invalid note.");
+	const row = value;
+	if (row.address !== address || typeof row.name !== "string" || name !== void 0 && row.name !== name || row.visibility !== "private" && row.visibility !== "public" || typeof row.version !== "string" || !/^[0-9]{1,19}$/.test(row.version) || typeof row.created_at !== "string" || typeof row.updated_at !== "string" || !("value" in row)) throw new Error("The address notes API returned an invalid note.");
+	return row;
+}
+function envelope(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("The address notes API returned an invalid response.");
+	const row = value;
+	if (row.success !== true || !("data" in row)) throw new Error("The address notes API returned an incomplete response.");
+	return row;
+}
+async function result(pending) {
+	const response = await pending;
+	if (response.error !== void 0) throw new AddressNotesApiError(response.error, response.response?.status);
+	return envelope(response.data).data;
+}
+async function getNote(client, address, name, signal) {
+	return note(await result(client.get({
+		security,
+		url: "/address-notes/{address}/{name}",
+		path: {
+			address,
+			name
+		},
+		responseStyle: "fields",
+		...signal ? { signal } : {}
+	})), address, name);
+}
+async function runAddressNotesRequest(client, request) {
+	const address = contactAddress(request.address);
+	if (request.action === "list") {
+		const limit = request.limit ?? 50;
+		if (!Number.isInteger(limit) || limit < 1 || limit > 100) throw new Error("--limit must be between 1 and 100.");
+		const prefix = request.prefix;
+		if (prefix !== void 0 && !/^[A-Za-z0-9_.-]{0,128}$/.test(prefix)) throw new Error("--prefix may contain at most 128 letters, digits, underscores, dots, or hyphens.");
+		const cursor = request.cursor === void 0 ? void 0 : addressNoteName(request.cursor);
+		const response = await client.get({
+			security,
+			url: "/address-notes",
+			query: {
+				address,
+				prefix,
+				cursor,
+				limit
+			},
+			responseStyle: "fields"
+		});
+		if (response.error !== void 0) throw new AddressNotesApiError(response.error, response.response?.status);
+		const body = envelope(response.data);
+		if (!Array.isArray(body.data) || !body.meta || typeof body.meta !== "object" || Array.isArray(body.meta)) throw new Error("The address notes API returned an invalid page.");
+		const next = body.meta.cursor;
+		if (next !== null && (typeof next !== "string" || addressNoteName(next) !== next)) throw new Error("The address notes API omitted valid pagination state.");
+		return {
+			...body,
+			data: body.data.map((row) => note(row, address))
+		};
+	}
+	const name = addressNoteName(request.name ?? "");
+	if (request.action === "get") return getNote(client, address, name, request.signal);
+	if (request.ifAbsent && request.ifVersion !== void 0) throw new Error("Use either --if-absent or --if-version.");
+	const ifVersion = request.ifVersion === void 0 ? void 0 : addressNoteVersion(request.ifVersion);
+	if (request.action === "set") {
+		if (request.value === void 0) throw new Error("Provide a note value.");
+		let condition;
+		if (request.ifAbsent) condition = { if_absent: true };
+		else if (ifVersion) condition = { if_version: ifVersion };
+		else try {
+			condition = { if_version: (await getNote(client, address, name)).version };
+		} catch (error) {
+			if (!(error instanceof AddressNotesApiError) || error.status !== 404) throw error;
+			condition = { if_absent: true };
+		}
+		return note(await result(client.put({
+			security,
+			url: "/address-notes/{address}/{name}",
+			path: {
+				address,
+				name
+			},
+			body: {
+				value: request.value,
+				...condition,
+				...request.visibility ? { visibility: request.visibility } : {}
+			},
+			headers: { "Content-Type": "application/json" },
+			responseStyle: "fields"
+		})), address, name);
+	}
+	const version = ifVersion ?? (await getNote(client, address, name)).version;
+	const data = await result(client.delete({
+		security,
+		url: "/address-notes/{address}/{name}",
+		path: {
+			address,
+			name
+		},
+		query: { if_version: version },
+		responseStyle: "fields"
+	}));
+	if (!data || typeof data !== "object" || Array.isArray(data) || typeof data.deleted !== "boolean") throw new Error("The address notes API returned an invalid deletion response.");
+	return data;
+}
+//#endregion
+//#region src/oclif/agent-setup-read.ts
+function retryDelay(response, attempt, now) {
+	const raw = response?.headers.get("retry-after")?.trim();
+	if (raw && /^\d+(?:\.\d+)?$/.test(raw)) {
+		const value = Number(raw) * 1e3;
+		if (Number.isFinite(value)) return Math.max(1e3, Math.ceil(value));
+	}
+	if (raw) {
+		const date = Date.parse(raw);
+		if (Number.isFinite(date)) return Math.max(1e3, date - now);
+	}
+	return Math.min(1e3 * 2 ** attempt, 1e4);
+}
+/** Read-only recovery. The caller supplies a GET operation, never a claim or write. */
+async function readSetupApi(budget, stage, read) {
+	for (let attempt = 0;; attempt++) {
+		const remaining = budget.deadline - budget.now();
+		if (remaining <= 0 || budget.signal.aborted) throw new AgentConnectionSetupError(`Setup ${stage} reached its read deadline. Resume the saved profile; no claim or send was replayed.`);
+		let result;
+		let failed = false;
+		try {
+			result = await read(AbortSignal.any([budget.signal, AbortSignal.timeout(Math.min(1e4, Math.max(1, remaining)))]));
+		} catch {
+			failed = true;
+		}
+		const status = result?.response?.status;
+		if (!(status === 429 || status !== void 0 && status >= 500 && status <= 599 || status === void 0 && (failed || result?.error !== void 0))) {
+			if (failed || !result || result.error !== void 0 || status !== void 0 && status >= 400) throw new AgentConnectionSetupError(`Setup ${stage} could not be read${status === void 0 ? "" : ` (HTTP ${status})`}. Resume the saved profile after resolving access; no claim or send was replayed.`);
+			return result;
+		}
+		const waitMs = retryDelay(result?.response, attempt, budget.now());
+		const remainingAfterRead = budget.deadline - budget.now();
+		if (attempt >= 4 || waitMs >= remainingAfterRead || budget.signal.aborted) throw new AgentConnectionSetupError(`Setup ${stage} is temporarily unavailable${status === void 0 ? " (transport failure)" : ` (HTTP ${status})`}. Retry after ${Math.ceil(waitMs / 1e3)} seconds with the saved profile's --resume command; no claim or send was replayed.`);
+		await budget.sleep(waitMs);
+		budget.retries++;
+	}
+}
+//#endregion
+//#region src/oclif/contact-rule-matcher.ts
+const localPart = /^[a-z0-9!#$%&'+/=^_`{|}~-]+(?:\.[a-z0-9!#$%&'+/=^_`{|}~-]+)*$/;
+const patternPart = /^[a-z0-9.!#$%&'+/=^_`{|}~*-]+$/;
+const label = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+function domain(value) {
+	const labels = value.split(".");
+	return value.length <= 253 && labels.length >= 2 && labels.every((part) => label.test(part)) && /[a-z]/.test(labels.at(-1) ?? "");
+}
+function domainPattern(value) {
+	return domain(value.startsWith("*.") ? value.slice(2) : value);
+}
+function splitAddress(value) {
+	const parts = value.split("@");
+	const [local, host] = parts;
+	return parts.length === 2 && local && host ? [local, host] : null;
+}
+/** Restricted selectors are canonical data, never regular expressions. */
+function canonicalContactSelector(input) {
+	const invalid = () => /* @__PURE__ */ new Error("Invalid contact approval selector.");
+	const trimmed = input.value.trim();
+	for (const character of trimmed) if (character.charCodeAt(0) > 127) throw invalid();
+	const value = trimmed.toLowerCase();
+	if (!value || value.length > 254) throw invalid();
+	if (input.kind === "domain") {
+		if (!domainPattern(value)) throw invalid();
+		return {
+			kind: input.kind,
+			value
+		};
+	}
+	const parts = splitAddress(value);
+	if (!parts) throw invalid();
+	const [local, host] = parts;
+	if (local.length > 64 || local.startsWith(".") || local.endsWith(".") || local.includes("..")) throw invalid();
+	if (input.kind === "address") {
+		if (!localPart.test(local) || !domain(host)) throw invalid();
+	} else if (input.kind === "pattern") {
+		if (!patternPart.test(local) || local !== "*" && !localPart.test(local.endsWith("*") ? local.slice(0, -1) : local) || !domainPattern(host) || local.includes("*") && (!local.endsWith("*") || local.slice(0, -1).includes("*"))) throw invalid();
+	} else throw invalid();
+	return {
+		kind: input.kind,
+		value
+	};
+}
+function matchesDomain(pattern, value) {
+	if (!pattern.startsWith("*.")) return pattern === value;
+	const suffix = pattern.slice(1);
+	return value.length > suffix.length && value.endsWith(suffix);
+}
+function matchesLocal(pattern, value) {
+	return pattern.endsWith("*") ? value.startsWith(pattern.slice(0, -1)) : value === pattern;
+}
+function matchesContactPattern(pattern, sender) {
+	return matchesContactSelector({
+		kind: "pattern",
+		value: pattern
+	}, sender);
+}
+/** Malformed sender identities never match; malformed stored rules fail closed. */
+function matchesContactSelector(input, sender) {
+	const selector = canonicalContactSelector(input);
+	let address;
+	try {
+		address = canonicalContactSelector({
+			kind: "address",
+			value: sender
+		}).value;
+	} catch {
+		return false;
+	}
+	if (selector.kind === "address") return selector.value === address;
+	const [local, host] = splitAddress(address) ?? [];
+	if (!local || !host) return false;
+	if (selector.kind === "domain") return matchesDomain(selector.value, host);
+	const [localPattern, hostPattern] = splitAddress(selector.value) ?? [];
+	return Boolean(localPattern && hostPattern && matchesDomain(hostPattern, host) && matchesLocal(localPattern, local));
+}
+//#endregion
+//#region src/oclif/contact-policy.ts
+function record(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid contact policy.");
+	return value;
+}
+function fingerprint(value) {
+	if (typeof value !== "string" || !/^[a-f0-9]{64}$/.test(value)) throw new Error("Invalid contact policy version.");
+	return value;
+}
+function document(value, organization) {
+	const row = record(value);
+	if (!Array.isArray(row.rules) || row.rules.length > 100 || !(typeof row.allow_contact_requests === "boolean" || !organization && row.allow_contact_requests === null)) throw new Error("Invalid contact policy document.");
+	const seen = /* @__PURE__ */ new Set();
+	const rules = row.rules.map((value) => {
+		const rule = record(value);
+		if (typeof rule.pattern !== "string" || rule.effect !== "allow" && rule.effect !== "silence") throw new Error("Invalid contact policy rule.");
+		const pattern = canonicalContactSelector({
+			kind: "pattern",
+			value: rule.pattern
+		}).value;
+		const key = `${pattern}:${rule.effect}`;
+		if (pattern !== rule.pattern || seen.has(key)) throw new Error("Invalid contact policy rule.");
+		seen.add(key);
+		if (rule.effect === "silence") {
+			if (rule.notify_since !== null || rule.notification_generation !== null) throw new Error("Invalid silence rule.");
+			return {
+				pattern,
+				effect: "silence",
+				notify_since: null,
+				notification_generation: null
+			};
+		}
+		return {
+			pattern,
+			effect: "allow",
+			notify_since: mailTime(rule.notify_since),
+			notification_generation: mailId(rule.notification_generation)
+		};
+	});
+	const version = row.version === null ? null : mailId(row.version);
+	const updatedAt = row.updated_at === null ? null : mailTime(row.updated_at);
+	if (version === null !== (updatedAt === null)) throw new Error("Invalid contact policy document version.");
+	const requests = row.allow_contact_requests;
+	if (requests !== true && (row.contact_request_since !== null || row.contact_request_generation !== null)) throw new Error("Invalid contact request activation.");
+	if (version === null && (rules.length || requests !== (organization ? false : null))) throw new Error("Invalid missing contact policy document.");
+	return {
+		rules,
+		allow_contact_requests: requests,
+		contact_request_since: requests === true ? mailTime(row.contact_request_since) : null,
+		contact_request_generation: requests === true ? mailId(row.contact_request_generation) : null,
+		version,
+		updated_at: updatedAt
+	};
+}
+function parseAgentContactPolicy(value, recipient) {
+	const row = record(value);
+	if (row.agent_address !== recipient || typeof row.allow_contact_requests !== "boolean") throw new Error("Contact policy recipient mismatch.");
+	const org = document(row.org_policy, true);
+	const agent = document(row.agent_policy, false);
+	if (row.allow_contact_requests !== (agent.allow_contact_requests ?? org.allow_contact_requests)) throw new Error("Inconsistent contact request policy.");
+	if (!row.allow_contact_requests && (row.contact_request_since !== null || row.contact_request_generation !== null)) throw new Error("Invalid effective contact request activation.");
+	return {
+		agent_address: recipient,
+		org_policy: org,
+		agent_policy: agent,
+		effective_version: fingerprint(row.effective_version),
+		effective_since: mailTime(row.effective_since),
+		allow_contact_requests: row.allow_contact_requests,
+		contact_request_since: row.allow_contact_requests ? mailTime(row.contact_request_since) : null,
+		contact_request_generation: row.allow_contact_requests ? fingerprint(row.contact_request_generation) : null
+	};
+}
+const latest = (left, right) => Date.parse(left) >= Date.parse(right) ? left : right;
+const arrived = (received, since) => Date.parse(received) >= Date.parse(since);
+/** Owner rules are unordered. Agent matches take precedence; silence wins ties. */
+function evaluateContactPolicy(options) {
+	const { policy, sender, receivedAt, membership } = options;
+	if (membership?.notify === false) return {
+		kind: "silent",
+		source: "membership"
+	};
+	for (const source of ["agent", "org"]) {
+		const matches = policy[`${source}_policy`].rules.filter((rule) => matchesContactPattern(rule.pattern, sender));
+		if (!matches.length) continue;
+		if (matches.some((rule) => rule.effect === "silence")) return {
+			kind: "silent",
+			source
+		};
+		for (const rule of matches.sort((a, b) => a.pattern < b.pattern ? -1 : a.pattern > b.pattern ? 1 : 0)) {
+			if (!rule.notify_since || !rule.notification_generation) throw new Error("Missing rule activation.");
+			const since = latest(rule.notify_since, policy.effective_since);
+			if (arrived(receivedAt, since)) return {
+				kind: "allowed",
+				source,
+				pattern: rule.pattern,
+				generation: rule.notification_generation,
+				notifySince: since
+			};
+		}
+		return {
+			kind: "silent",
+			source
+		};
+	}
+	if (membership?.notify === true) {
+		const since = membership.notifySince;
+		return arrived(receivedAt, since) ? {
+			kind: "allowed",
+			source: "membership",
+			generation: membership.generation,
+			notifySince: since
+		} : {
+			kind: "silent",
+			source: "membership"
+		};
+	}
+	if (options.contactRequests && policy.allow_contact_requests && policy.contact_request_since && policy.contact_request_generation) {
+		const since = latest(policy.contact_request_since, policy.effective_since);
+		if (arrived(receivedAt, since)) return {
+			kind: "request",
+			generation: policy.contact_request_generation,
+			notifySince: since
+		};
+	}
+	return {
+		kind: "silent",
+		source: "default"
+	};
+}
+const CONTACT_POLICY_RETRY_MIN_MS = 1e3;
+const CONTACT_POLICY_RETRY_MAX_MS = 3e4;
+const NETWORK_ADMISSION_PENDING_RETRY_MS = 5e3;
+var NetworkAdmissionPendingError = class extends NotificationRetryError {
+	constructor() {
+		super("Network mail admission is pending delivery proof.");
+	}
+};
+var ContactPolicyReadRetryError = class extends NotificationRetryError {
+	constructor() {
+		super("Contact notification policy is temporarily unavailable. Mail remains pending while permissions are refreshed.");
+	}
+};
+const unavailable = () => new ListenStateError("Contact notification preferences are unavailable or invalid. No contact notification was submitted; restart after access is restored.");
+const changed = () => new NotificationRetryError("Contact notification permission changed or expired before dispatch.");
+/** Read one connected address's policy. Partial pages never authorize delivery. */
+function createNotificationContactPolicy(options) {
+	const recipient = mailAddress(options.recipient);
+	const now = options.now ?? (() => performance.now());
+	let snapshot;
+	let retryAt = 0;
+	let retryDelay = CONTACT_POLICY_RETRY_MIN_MS;
+	function fresh(value) {
+		if (!value) return false;
+		const elapsed = now() - value.startedAt;
+		return elapsed >= 0 && elapsed < 3e4;
+	}
+	async function refreshOnce(signal) {
+		snapshot = void 0;
+		signal.throwIfAborted();
+		if (now() < retryAt) throw new ContactPolicyReadRetryError();
+		const startedAt = now();
+		const peers = /* @__PURE__ */ new Set();
+		let cursor;
+		try {
+			const next = {
+				startedAt,
+				senders: /* @__PURE__ */ new Map(),
+				policy: parseAgentContactPolicy(await options.readPolicy(signal), recipient)
+			};
+			do {
+				signal.throwIfAborted();
+				const page = await options.readPage(cursor, signal);
+				signal.throwIfAborted();
+				if (!fresh(next) || !Array.isArray(page.data) || page.data.length > 100) throw unavailable();
+				let previous = cursor;
+				for (const value of page.data) {
+					if (!value || typeof value !== "object" || Array.isArray(value)) throw unavailable();
+					const row = value;
+					const peer = mailAddress(row.contact_address);
+					if (row.agent_address !== recipient || row.contact_address !== peer || previous !== void 0 && peer <= previous || peers.has(peer) || typeof row.notify !== "boolean") throw unavailable();
+					mailId(row.version);
+					peers.add(peer);
+					previous = peer;
+					if (row.notify) next.senders.set(peer, {
+						notify: true,
+						generation: mailId(row.notification_generation),
+						notifySince: mailTime(row.notify_since)
+					});
+					else if (row.notification_generation !== null || row.notify_since !== null) throw unavailable();
+					else next.senders.set(peer, { notify: false });
+				}
+				if (page.cursor === null) cursor = void 0;
+				else {
+					const following = mailAddress(page.cursor);
+					if (!page.data.length || following !== previous) throw unavailable();
+					cursor = following;
+				}
+			} while (cursor !== void 0);
+			if (!fresh(next)) throw unavailable();
+			snapshot = next;
+			retryAt = 0;
+			retryDelay = CONTACT_POLICY_RETRY_MIN_MS;
+			return next;
+		} catch (error) {
+			snapshot = void 0;
+			signal.throwIfAborted();
+			if (error instanceof ContactPolicyReadRetryError) {
+				retryAt = now() + retryDelay;
+				retryDelay = Math.min(retryDelay * 2, CONTACT_POLICY_RETRY_MAX_MS);
+				throw error;
+			}
+			throw unavailable();
+		}
+	}
+	function admission(value, sender, receivedAt, solicited = false) {
+		const decision = evaluateContactPolicy({
+			policy: value.policy,
+			sender,
+			receivedAt,
+			membership: value.senders.get(sender),
+			contactRequests: options.contactRequests === true
+		});
+		if (decision.kind === "silent") {
+			if (!solicited || decision.source !== "default") return null;
+			return {
+				sender,
+				receivedAt,
+				generation: value.policy.effective_version,
+				notifySince: value.policy.effective_since,
+				kind: "response",
+				effectiveVersion: value.policy.effective_version
+			};
+		}
+		return {
+			sender,
+			receivedAt,
+			generation: decision.generation,
+			notifySince: decision.notifySince,
+			kind: solicited ? "response" : decision.kind,
+			effectiveVersion: value.policy.effective_version
+		};
+	}
+	async function admissionWithNetwork(value, sender, receivedAt, signal, emailId, networkReader = options.readNetworkAdmission, solicited = false) {
+		const contact = admission(value, sender, receivedAt, solicited);
+		const decision = evaluateContactPolicy({
+			policy: value.policy,
+			sender,
+			receivedAt,
+			membership: value.senders.get(sender),
+			contactRequests: options.contactRequests === true
+		});
+		if (!networkReader) return contact;
+		if (!emailId) throw unavailable();
+		const network = await networkReader(emailId, sender, signal);
+		signal.throwIfAborted();
+		if (typeof network.member_policy_required !== "boolean") throw unavailable();
+		if (network.sender_relation !== void 0 && (!network.member_policy_required || !["owner", "member"].includes(network.sender_relation))) throw unavailable();
+		if (network.member_policy_required) {
+			if (network.allowed && !network.sender_relation) throw unavailable();
+			if (network.pending) throw new NetworkAdmissionPendingError();
+			if (!network.allowed) return null;
+			if (decision.kind === "silent" && decision.source !== "default") return null;
+			return networkAdmission(value, sender, receivedAt, emailId, network, solicited);
+		}
+		const scopedContact = contact ? {
+			...contact,
+			emailId
+		} : null;
+		if (contact?.kind === "allowed" || contact?.kind === "response") return scopedContact;
+		if (decision.kind !== "request" && !(decision.kind === "silent" && decision.source === "default")) return scopedContact;
+		if (network.pending) throw new NetworkAdmissionPendingError();
+		if (!network.allowed) return scopedContact;
+		return networkAdmission(value, sender, receivedAt, emailId, network, solicited);
+	}
+	function networkAdmission(value, sender, receivedAt, emailId, network, solicited) {
+		const networkSince = network.allowed_since && mailTime(network.allowed_since);
+		if (!networkSince) throw unavailable();
+		const since = Date.parse(value.policy.effective_since) > Date.parse(networkSince) ? value.policy.effective_since : networkSince;
+		if (Date.parse(receivedAt) < Date.parse(since)) return null;
+		return {
+			sender,
+			emailId,
+			receivedAt,
+			generation: since,
+			notifySince: since,
+			kind: solicited ? "response" : "allowed",
+			effectiveVersion: value.policy.effective_version,
+			source: "network",
+			...network.sender_relation ? { senderRelation: network.sender_relation } : {}
+		};
+	}
+	function permits(prior, current) {
+		return current !== null && current.emailId === prior.emailId && current.kind === prior.kind && current.source === prior.source && current.senderRelation === prior.senderRelation && current.generation === prior.generation && current.notifySince === prior.notifySince && current.effectiveVersion === prior.effectiveVersion;
+	}
+	return {
+		refresh: refreshOnce,
+		members() {
+			if (!fresh(snapshot)) throw unavailable();
+			return snapshot.senders.keys();
+		},
+		async admit(sender, receivedAt, signal, emailId) {
+			signal.throwIfAborted();
+			let peer;
+			try {
+				peer = mailAddress(sender);
+			} catch {
+				return null;
+			}
+			const received = mailTime(receivedAt);
+			const inboundId = emailId === void 0 ? void 0 : mailId(emailId);
+			const reader = options.readNetworkAdmission;
+			let networkResult;
+			const networkReader = reader ? (id, address, abort) => networkResult ??= reader(id, address, abort) : void 0;
+			const cached = fresh(snapshot);
+			let current = cached && snapshot ? snapshot : await refreshOnce(signal);
+			let allowed = await admissionWithNetwork(current, peer, received, signal, inboundId, networkReader);
+			if (cached && allowed?.kind !== "allowed") {
+				current = await refreshOnce(signal);
+				allowed = await admissionWithNetwork(current, peer, received, signal, inboundId, networkReader);
+			}
+			return allowed;
+		},
+		async recheck(prior, signal) {
+			const current = await refreshOnce(signal);
+			const candidate = await admissionWithNetwork(current, prior.sender, prior.receivedAt, signal, prior.emailId, options.readNetworkAdmission, prior.kind === "response");
+			if (!permits(prior, candidate)) throw changed();
+			return () => {
+				signal.throwIfAborted();
+				if (!fresh(snapshot) || snapshot !== current || !permits(prior, candidate)) throw changed();
+			};
+		},
+		async admitResponse(sender, receivedAt, signal, emailId) {
+			return admissionWithNetwork(await refreshOnce(signal), mailAddress(sender), mailTime(receivedAt), signal, emailId, options.readNetworkAdmission, true);
+		}
+	};
+}
+//#endregion
+//#region src/oclif/agent-setup.ts
+const SUBJECT = "Connect your agent to Primitive";
+const MARKER = /\bprimitive-connection:([a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}):([1-9]\d*)\b/g;
+const fail = (message) => new AgentConnectionSetupError(message);
+const RECEIVER_MODES = [
+	"native",
+	"external",
+	"poll"
+];
+const RECEIPT_STATUSES = new Set([
+	"queued",
+	"submitted_to_agent",
+	"agent_failed",
+	"gate_denied",
+	"unknown",
+	"delivered",
+	"bounced",
+	"deferred",
+	"wait_timeout",
+	"scheduled",
+	"canceled"
+]);
+function parseReceipt(value) {
+	const row = mailObject(value, ["id", "status"]);
+	if (!RECEIPT_STATUSES.has(row.status)) throw fail("The verification send receipt is incomplete or invalid. Its outcome remains unknown; no verification was resent.");
+	return {
+		id: mailId(row.id),
+		status: mailString(row.status, 100)
+	};
+}
+/** Waits between status reads after the reply is submitted. The last value repeats. */
+const VERIFICATION_BACKOFF_MS = [
+	1e3,
+	1e3,
+	2e3,
+	2e3,
+	3e3,
+	5e3
+];
+/** Both states mean the setup reply was accepted for sending. */
+function verificationReplySubmitted(state) {
+	return state === "reply_submitted" || state === "verified";
+}
+/** Parse GET /agent-connections/me for the expected address. Unknown shapes are unavailable. */
+function parseVerificationCheck(value, agentAddress) {
+	if (!value || typeof value !== "object") return { state: "unavailable" };
+	const envelope = value;
+	if (envelope.success !== true || !envelope.data) return { state: "unavailable" };
+	if (typeof envelope.data !== "object") return { state: "unavailable" };
+	const connection = envelope.data.connection;
+	if (!connection || typeof connection !== "object") return { state: "unavailable" };
+	const row = connection;
+	if (typeof row.address !== "string" || row.address.toLowerCase() !== agentAddress.toLowerCase()) return { state: "unavailable" };
+	if (row.status === "connected") return {
+		state: "verified",
+		verifiedAt: typeof row.verified_at === "string" && Number.isFinite(Date.parse(row.verified_at)) ? row.verified_at : null
+	};
+	if (row.status === "claimed") return { state: "pending" };
+	return { state: "unavailable" };
+}
+async function checkVerification(context, timeoutMs) {
+	try {
+		const response = await context.fetch(`${context.profile.api_base_url}/agent-connections/me`, {
+			method: "GET",
+			redirect: "error",
+			signal: AbortSignal.timeout(timeoutMs),
+			headers: {
+				authorization: `Bearer ${context.profile.api_key}`,
+				accept: "application/json"
+			}
+		});
+		if (response.status !== 200) {
+			await response.body?.cancel();
+			return { state: "unavailable" };
+		}
+		const text = await response.text();
+		if (text.length > 65536) return { state: "unavailable" };
+		return parseVerificationCheck(JSON.parse(text), context.identity.agentAddress);
+	} catch {
+		return { state: "unavailable" };
+	}
+}
+/**
+* Poll until the server reports the connection verified, the budget runs out,
+* or the status read is unavailable. Elapsed time is the larger of the clock
+* and the requested waits, so slow reads count against the budget and a
+* frozen clock in tests cannot loop forever. Each read is capped at the time
+* remaining (and at five seconds).
+*/
+async function awaitVerification(context, dependencies, timeoutMs) {
+	const started = dependencies.now();
+	let waited = 0;
+	const remaining = () => timeoutMs - Math.max(waited, dependencies.now() - started);
+	for (let attempt = 0;; attempt++) {
+		const readBudget = Math.min(5e3, remaining());
+		if (readBudget <= 0) return { state: "pending" };
+		const check = await dependencies.checkVerification(context, readBudget);
+		if (check.state !== "pending") return check;
+		const step = VERIFICATION_BACKOFF_MS[Math.min(attempt, VERIFICATION_BACKOFF_MS.length - 1)] ?? 5e3;
+		const wait = Math.min(step, remaining());
+		if (wait <= 0) return check;
+		await dependencies.sleep(wait);
+		waited += wait;
+	}
+}
+function parseState(value) {
+	const keys = [
+		"version",
+		"session",
+		"invitationHash",
+		"since",
+		"contactRequests",
+		"challenge",
+		"phase",
+		"receipt"
+	];
+	const row = mailObject(value, value && typeof value === "object" && Object.hasOwn(value, "receiverMode") ? [...keys, "receiverMode"] : keys);
+	if (row.version !== 1 || row.receiverMode !== void 0 && !RECEIVER_MODES.includes(row.receiverMode) || typeof row.contactRequests !== "boolean" || ![
+		"waiting",
+		"sending",
+		"sent"
+	].includes(String(row.phase))) throw fail("Saved setup state is invalid. Preserve its private files.");
+	const challenge = row.challenge === null ? null : mailObject(row.challenge, [
+		"id",
+		"messageId",
+		"marker"
+	]);
+	const receipt = row.receipt === null ? null : parseReceipt(row.receipt);
+	const invitationHash = mailString(row.invitationHash, 64);
+	if (!/^[a-f0-9]{64}$/.test(invitationHash)) throw fail("Saved setup identity is invalid.");
+	const state = {
+		version: 1,
+		session: row.session === null && row.receiverMode === "poll" ? null : mailId(row.session),
+		receiverMode: row.receiverMode ?? "native",
+		invitationHash,
+		since: mailTime(row.since),
+		contactRequests: row.contactRequests,
+		phase: row.phase,
+		challenge: challenge ? {
+			id: mailId(challenge.id),
+			messageId: mailString(challenge.messageId, 1e3),
+			marker: mailString(challenge.marker, 100)
+		} : null,
+		receipt
+	};
+	if (state.phase !== "waiting" && !state.challenge || state.phase === "sent" && !state.receipt) throw fail("Saved setup progress is inconsistent. Preserve its private files.");
+	return state;
+}
+/** Match only authenticated owner mail. Subject/search results alone grant no authority. */
+function setupChallenge(detail, identity, since) {
+	if (detail.subject !== SUBJECT || detail.recipient.toLowerCase() !== identity.agentAddress || detail.to_email.toLowerCase() !== identity.agentAddress || !["accepted", "completed"].includes(detail.status) || !detail.message_id || /[\r\n]/.test(detail.message_id) || detail.parsed?.status !== "complete" || Date.parse(detail.received_at) < Date.parse(since) || !Number.isFinite(Date.parse(detail.received_at)) || !scopedChatSenderTrust(detail, identity.ownerAddress).trusted) return null;
+	const markers = [...new Set((detail.body_text ?? "").match(MARKER) ?? [])];
+	if (markers.length !== 1) return null;
+	return {
+		id: mailId(detail.id),
+		messageId: detail.message_id,
+		marker: markers[0] ?? ""
+	};
+}
+async function findChallenge(context, since) {
+	const page = await readSetupApi(context.readBudget, "challenge search", (signal) => searchEmails({
+		client: context.client.client,
+		query: {
+			from: context.identity.ownerAddress,
+			to: context.identity.agentAddress,
+			subject: SUBJECT,
+			date_from: since,
+			limit: 10,
+			snippet: "false",
+			include_facets: "false"
+		},
+		signal,
+		responseStyle: "fields"
+	}));
+	if (page.error || !Array.isArray(page.data?.data) || page.data.meta?.cursor !== null) throw fail("The setup challenge search is incomplete or ambiguous. No verification reply was sent.");
+	const matches = [];
+	for (const row of page.data.data) {
+		const response = await readSetupApi(context.readBudget, "challenge detail", (signal) => getEmail({
+			client: context.client.client,
+			path: { id: row.id },
+			signal,
+			responseStyle: "fields"
+		}));
+		if (response.error || !response.data?.data) throw fail("The setup challenge could not be read. Resume this profile; do not claim again.");
+		const match = setupChallenge(response.data.data, context.identity, since);
+		if (match) matches.push(match);
+	}
+	if (matches.length > 1) throw fail("Several recent setup challenges match. No challenge was guessed or answered. Ask the owner to confirm the current challenge.");
+	return matches[0] ?? null;
+}
+async function enableOwner(context) {
+	let lastReadError;
+	const policy = createNotificationContactPolicy({
+		now: context.readBudget.now,
+		recipient: context.identity.agentAddress,
+		async readPolicy() {
+			const result = await readSetupApi(context.readBudget, "owner notification policy", (signal) => getAgentContactPolicy({
+				client: context.client.client,
+				path: { agent_address: context.identity.agentAddress },
+				signal,
+				responseStyle: "fields"
+			})).catch((error) => {
+				lastReadError = error;
+				throw error;
+			});
+			if (result.data?.success !== true || !result.data.data) throw fail("The owner notification policy response is incomplete. Resume the saved profile; no preference was changed.");
+			return result.data.data;
+		},
+		async readPage(cursor) {
+			const result = await readSetupApi(context.readBudget, "owner contact preferences", (signal) => listAgentContacts({
+				client: context.client.client,
+				path: { agent_address: context.identity.agentAddress },
+				query: {
+					limit: 100,
+					...cursor ? { cursor } : {}
+				},
+				signal,
+				responseStyle: "fields"
+			})).catch((error) => {
+				lastReadError = error;
+				throw error;
+			});
+			if (result.data?.success !== true) throw fail("The owner contact preferences response is incomplete. Resume the saved profile; no preference was changed.");
+			return {
+				data: result.data.data,
+				cursor: result.data.meta?.cursor
+			};
+		}
+	});
+	async function refresh() {
+		for (let attempt = 0;; attempt++) {
+			lastReadError = void 0;
+			const retries = context.readBudget.retries;
+			try {
+				return await policy.refresh(context.signal);
+			} catch (error) {
+				if (lastReadError) throw lastReadError;
+				if (attempt >= 2 || context.readBudget.retries === retries) throw error;
+			}
+		}
+	}
+	const current = await refresh();
+	const member = current.senders.get(context.identity.ownerAddress);
+	const decision = evaluateContactPolicy({
+		policy: current.policy,
+		sender: context.identity.ownerAddress,
+		receivedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		membership: member,
+		contactRequests: false
+	});
+	if (member?.notify === false || decision.kind === "silent" && ["agent", "org"].includes(decision.source)) return "silenced";
+	if (!member) await runContactRequest(context.client.client, {
+		target: "agent",
+		action: "add",
+		agent: context.identity.agentAddress,
+		address: context.identity.ownerAddress,
+		notify: true,
+		purpose: "Messages from this agent's owner",
+		signal: context.signal
+	});
+	await refresh();
+	return (await policy.admit(context.identity.ownerAddress, (/* @__PURE__ */ new Date()).toISOString(), context.signal))?.kind === "allowed" ? "enabled" : "silenced";
+}
+/** Probe that this exact session is loaded and reachable for native receiving. */
+async function nativeSessionPreflight(session) {
+	(await connectNativeSession({
+		threadId: session,
+		expectedCwd: process.cwd(),
+		signal: AbortSignal.timeout(1e4)
+	})).close();
+}
+function defaults$1() {
+	return {
+		checkVerification,
+		now: Date.now,
+		sleep: async (ms) => {
+			await setTimeout$1(ms);
+		},
+		preflight: nativeSessionPreflight,
+		findChallenge,
+		async sendVerification(context, challenge, key) {
+			const result = await sendEmail({
+				client: context.client.client,
+				headers: { "Idempotency-Key": key },
+				body: {
+					from: context.identity.agentAddress,
+					to: context.identity.ownerAddress,
+					subject: `Re: ${SUBJECT}`,
+					body_text: challenge.marker,
+					in_reply_to: challenge.messageId,
+					references: [challenge.messageId]
+				},
+				signal: context.signal,
+				responseStyle: "fields"
+			});
+			if (result.error || !result.data?.data) throw fail("The verification send outcome is unknown. Resume this saved profile; do not resend or claim again.");
+			return {
+				id: mailId(result.data.data.id),
+				status: result.data.data.status
+			};
+		},
+		async reconcile(context, key) {
+			const page = (await readSetupApi(context.readBudget, "verification send lookup", (signal) => listSentEmails({
+				client: context.client.client,
+				query: {
+					idempotency_key: key,
+					limit: 2
+				},
+				signal,
+				responseStyle: "fields"
+			}))).data;
+			if (!Array.isArray(page?.data) || page.meta?.cursor !== null || page.data.length > 1) throw fail("The verification send lookup is incomplete or ambiguous. Its outcome remains unknown; no verification was resent.");
+			const result = page.data[0];
+			if (!result) return null;
+			if (result.client_idempotency_key !== key || result.from_address !== context.identity.agentAddress || result.to_address !== context.identity.ownerAddress) throw fail("The verification send lookup returned conflicting identity metadata. Its outcome remains unknown; no verification was resent.");
+			return {
+				id: mailId(result.id),
+				status: result.status
+			};
+		},
+		enableOwner,
+		async startListener(profile, session, contactRequests, configDir) {
+			const entry = process.argv[1];
+			if (!entry) throw fail("CLI entrypoint unavailable. Resume setup using the installed CLI.");
+			const { stdout } = await promisify(execFile)(process.execPath, [
+				entry,
+				"listen",
+				"--background",
+				"--notify-session",
+				session,
+				"--contacts",
+				...contactRequests ? ["--contact-requests"] : []
+			], {
+				env: {
+					...process.env,
+					[AGENT_PROFILE_ENV]: profile,
+					PRIMITIVE_CONFIG_DIR: configDir
+				},
+				timeout: 35e3,
+				maxBuffer: 65536
+			});
+			const result = JSON.parse(stdout);
+			if (!result || typeof result !== "object") return false;
+			const status = result.status;
+			return status?.healthy === true && status.phase === "receiving";
+		}
+	};
+}
+/**
+* Saved choices are reused when an option is omitted. Only an explicit option
+* that disagrees with the saved setup is refused, and the message names it so
+* the caller can drop or correct that one option.
+*/
+function refuseSetupConflicts(state, params) {
+	const conflicts = [
+		...(params.session === void 0 ? state.receiverMode !== "poll" : state.session !== params.session) ? [state.session ? `--session (this profile is bound to session ${state.session})` : "--session (this profile's setup binds no session)"] : [],
+		...params.receiverMode !== void 0 && state.receiverMode !== params.receiverMode ? [`--receiver ${params.receiverMode} (saved: ${state.receiverMode})`] : [],
+		...params.contactRequests !== void 0 && state.contactRequests !== params.contactRequests ? [state.contactRequests ? "contact requests off (saved setup has --contact-requests)" : "--contact-requests (saved setup did not enable it)"] : []
+	];
+	if (conflicts.length) throw fail(`This profile's saved setup conflicts with ${conflicts.join(" and ")}. Omit the option to reuse the saved setup. Its session and notification preferences were not changed.${params.resume ? "" : " Do not create a separate profile on your own: if this session should get a different address, ask the user whether to keep the existing one or disconnect it first."}`);
+}
+/** One resumable operation owns setup plumbing; it never stores or replays the invitation. */
+async function setupAgent(params) {
+	const profileName = agentProfileName(params.profileName);
+	if (params.session !== void 0 && !SESSION_UUID.test(params.session)) throw fail("--session requires the exact loaded session UUID.");
+	if (params.resume ? params.invitation !== void 0 : params.invitation === void 0) throw fail("Use an invitation on stdin for setup, or --resume without an invitation.");
+	const timeoutMs = params.timeoutMs ?? 3e4;
+	if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 0 || timeoutMs > 12e4) throw fail("Setup timeout must be between zero and two minutes.");
+	const verificationTimeoutMs = params.verificationTimeoutMs ?? 6e4;
+	if (!Number.isSafeInteger(verificationTimeoutMs) || verificationTimeoutMs < 0 || verificationTimeoutMs > 12e4) throw fail("Verification wait must be between zero and two minutes.");
+	const dependencies = {
+		...defaults$1(),
+		...params.dependencies
+	};
+	const directory = agentProfileDirectory(params.configDir, profileName);
+	let saved = null;
+	try {
+		const value = readMailJson(join(directory, "setup.json"));
+		saved = value === null ? null : parseState(value);
+	} catch {}
+	if (saved) refuseSetupConflicts(saved, params);
+	const receiverMode = params.receiverMode ?? (params.resume ? saved?.receiverMode : void 0);
+	if (params.session === void 0 && (receiverMode ?? "native") !== "poll") throw fail("--session requires the exact loaded session UUID. Without one, use --receiver poll. No invitation was claimed.");
+	if ((receiverMode ?? "native") === "native" && params.session) try {
+		await dependencies.preflight(params.session);
+	} catch {
+		throw fail("This exact session is not available for native receiving. No invitation was claimed. Open a supported session and retry setup.");
+	}
+	privateMailDirectory(directory, true);
+	const release = acquireListenLock(directory, "setup");
+	try {
+		const path = join(directory, "setup.json");
+		const value = readMailJson(path);
+		let state = value === null ? null : parseState(value);
+		if (state) refuseSetupConflicts(state, params);
+		if (!state && loadConnectedAgentProfile(params.configDir, profileName)) throw fail("This profile was configured without a setup binding. Use its existing session setup; do not adopt it into another session.");
+		if (params.resume && !state) throw fail("No resumable setup exists for this profile. Do not adopt another session's identity.");
+		if (!params.resume) {
+			const invitation = parseAgentInvitation(params.invitation ?? "");
+			const hash = createHash("sha256").update(invitation.apiBaseUrl).update("\0").update(invitation.token).digest("hex");
+			if (state && state.invitationHash !== hash) throw fail(profileAlreadyConnectedMessage(profileName, loadConnectedAgentProfile(params.configDir, profileName)?.agent_address ?? null));
+			if (!state) {
+				state = {
+					version: 1,
+					session: params.session ?? null,
+					receiverMode: params.receiverMode ?? "native",
+					invitationHash: hash,
+					since: (/* @__PURE__ */ new Date(dependencies.now() - 15 * 6e4)).toISOString(),
+					contactRequests: Boolean(params.contactRequests),
+					phase: "waiting",
+					challenge: null,
+					receipt: null
+				};
+				writeMailJson(path, state);
+			}
+			await connectAgent({
+				configDir: params.configDir,
+				profileName,
+				invitation: params.invitation ?? "",
+				fetch: params.fetch,
+				presence: true
+			});
+		}
+		const profile = loadConnectedAgentProfile(params.configDir, profileName);
+		if (!profile || !state || profile.invitation_hash !== state.invitationHash) throw fail("The claim has no matching saved credential. Preserve private state and request a fresh invitation; do not replay this one.");
+		const setupBudgetMs = Math.max(9e4, timeoutMs + 3e4);
+		const readBudget = {
+			deadline: dependencies.now() + setupBudgetMs,
+			now: dependencies.now,
+			sleep: dependencies.sleep,
+			signal: AbortSignal.timeout(setupBudgetMs),
+			retries: 0
+		};
+		const context = {
+			identity: connectedAgentIdentity(profileName, profile),
+			profile,
+			client: new PrimitiveApiClient({
+				apiKey: profile.api_key,
+				apiBaseUrl: profile.api_base_url,
+				fetch: params.fetch
+			}),
+			fetch: params.fetch ?? fetch,
+			signal: readBudget.signal,
+			readBudget
+		};
+		let confirmed = null;
+		const submittedState = () => state?.phase === "sent" ? [
+			"agent_failed",
+			"gate_denied",
+			"bounced",
+			"canceled"
+		].includes(state.receipt?.status ?? "") ? "reply_failed" : ["unknown", "wait_timeout"].includes(state.receipt?.status ?? "") ? "delivery_unknown" : "reply_submitted" : state?.phase === "sending" ? "send_unknown" : "challenge_pending";
+		const result = (receiving, ownerNotifications) => ({
+			identity: context.identity,
+			sessionId: params.session ?? state?.session ?? null,
+			verification: {
+				state: confirmed && submittedState() === "reply_submitted" ? "verified" : submittedState(),
+				...confirmed ? { verifiedAt: confirmed.verifiedAt } : {},
+				...state?.receipt ? {
+					sentId: state.receipt.id,
+					deliveryStatus: state.receipt.status
+				} : {}
+			},
+			receiving: { state: receiving },
+			...ownerNotifications ? { ownerNotifications } : {},
+			resumeCommand: `primitive agent connect --profile ${profileName}${state?.session ? ` --session ${state.session}` : ""}${state?.receiverMode === "external" || state?.receiverMode === "poll" ? ` --receiver ${state.receiverMode}` : ""} --resume${state?.contactRequests ? " --contact-requests" : ""} --json`,
+			guidance: confirmed ? "Primitive verified this connection. Receiving health is reported separately. Keep this profile for all mail commands." : submittedState() === "reply_submitted" ? "The verification reply was submitted and Primitive has not confirmed it yet. Verification usually completes within seconds; check it later with GET /agent-connections/me. Receiving health is reported separately. Keep this profile for all mail commands." : "Reply submission is not proof of delivery or app verification. Receiving health is reported separately. Keep this profile for all mail commands."
+		});
+		const key = `connection-verification-${state.invitationHash}`;
+		if (state.phase === "sending") {
+			const receipt = await dependencies.reconcile(context, key);
+			if (!receipt) return result("not_started");
+			state.receipt = parseReceipt(receipt);
+			state.phase = "sent";
+			writeMailJson(path, state);
+		}
+		if (state.phase === "waiting") {
+			const deadline = dependencies.now() + timeoutMs;
+			do {
+				state.challenge = await dependencies.findChallenge(context, state.since);
+				if (state.challenge || dependencies.now() >= deadline) break;
+				await dependencies.sleep(Math.min(1500, deadline - dependencies.now()));
+			} while (dependencies.now() <= deadline);
+			if (!state.challenge) return result("not_started");
+			state.phase = "sending";
+			writeMailJson(path, state);
+			try {
+				state.receipt = parseReceipt(await dependencies.sendVerification({
+					...context,
+					signal: AbortSignal.any([context.signal, AbortSignal.timeout(3e4)])
+				}, state.challenge, key));
+				state.phase = "sent";
+				writeMailJson(path, state);
+			} catch {
+				return result("not_started");
+			}
+		}
+		const ownerNotifications = await dependencies.enableOwner(context);
+		let healthy = false;
+		if ((state.receiverMode ?? "native") === "native" && state.session) try {
+			healthy = await dependencies.startListener(profileName, state.session, state.contactRequests, params.configDir);
+		} catch {}
+		if (verificationTimeoutMs > 0 && submittedState() === "reply_submitted") {
+			const check = await awaitVerification(context, dependencies, verificationTimeoutMs);
+			if (check.state === "verified") confirmed = { verifiedAt: check.verifiedAt };
+		}
+		return result(state.receiverMode === "external" ? "external_setup_required" : state.receiverMode === "poll" ? "poll" : healthy ? "healthy" : "not_ready", ownerNotifications);
+	} finally {
+		release();
+	}
+}
+//#endregion
+//#region src/oclif/owner-member-address.ts
+const REFRESH_TIMEOUT_MS = 5e3;
+const MAX_RESPONSE_BYTES = 64 * 1024;
+/** Reads at most MAX_RESPONSE_BYTES, stopping as soon as the body exceeds it. */
+async function boundedText(response) {
+	const reader = response.body?.getReader();
+	if (!reader) return null;
+	const chunks = [];
+	let size = 0;
+	try {
+		for (;;) {
+			const part = await reader.read();
+			if (part.done) break;
+			size += part.value.byteLength;
+			if (size > MAX_RESPONSE_BYTES) return null;
+			chunks.push(part.value);
+		}
+		return Buffer.concat(chunks).toString("utf8");
+	} finally {
+		await reader.cancel().catch(() => void 0);
+	}
+}
+/**
+* Reads the owner's personal mailbox from the connection's own record
+* (GET /agent-connections/me) and saves it in the profile, so an agent paired
+* before the server reported it, or before its owner set one up, learns where
+* to send reports. Best effort: any failure keeps the saved value. Returns the
+* address to report to, or null when there is none or it is unknown.
+*/
+async function refreshOwnerMemberAddress(params) {
+	const profile = loadConnectedAgentProfile(params.configDir, params.profileName);
+	if (!profile) return null;
+	const saved = profile.owner_member_address ?? null;
+	try {
+		const response = await (params.fetch ?? fetch)(`${profile.api_base_url}/agent-connections/me`, {
+			headers: { authorization: `Bearer ${profile.api_key}` },
+			redirect: "error",
+			signal: AbortSignal.timeout(params.timeoutMs ?? REFRESH_TIMEOUT_MS)
+		});
+		if (!response.ok) return saved;
+		const text = await boundedText(response);
+		if (text === null) return saved;
+		const body = JSON.parse(text);
+		const connection = body?.data?.connection;
+		if (body?.success !== true || !connection || !Object.hasOwn(connection, "owner_member_address") || mailAddress(connection.address) !== profile.agent_address || mailAddress(connection.owner_address) !== profile.owner_address) return saved;
+		const current = parseOwnerMemberAddress(connection.owner_member_address, profile.owner_address, profile.agent_address);
+		if (profile.owner_member_address !== current) saveConnectedAgentProfile(params.configDir, params.profileName, {
+			...profile,
+			owner_member_address: current
+		});
+		return current;
+	} catch {
+		return saved;
+	}
+}
+/** One sentence telling the agent where its reports go. */
+function ownerReportGuidance(identity) {
+	return identity.ownerMemberAddress ? `Send reports and questions to your owner's personal address ${identity.ownerMemberAddress}; ${identity.ownerAddress} is the setup and presence control address and nobody reads it.` : `No personal owner address is known, so reply to the member who wrote to you; never send reports to ${identity.ownerAddress}, the setup and presence control address.`;
+}
+/**
+* Adds the current personal address and report guidance to a result that
+* carries a connected identity, refreshing the saved profile first.
+*/
+async function withOwnerMemberAddress(result, params) {
+	const saved = loadConnectedAgentProfile(params.configDir, result.identity.profileName);
+	const ownerMemberAddress = params.onlyIfUnknown && typeof saved?.owner_member_address === "string" ? saved.owner_member_address : await refreshOwnerMemberAddress({
+		configDir: params.configDir,
+		profileName: result.identity.profileName,
+		fetch: params.fetch
+	});
+	const identity = {
+		...result.identity,
+		ownerMemberAddress
+	};
+	return {
+		...result,
+		identity,
+		ownerReportGuidance: ownerReportGuidance(identity)
+	};
+}
+//#endregion
+//#region src/oclif/agent-connect-flow.ts
+/** What this CLI version can do in one `agent connect --session` call. */
+const AGENT_CONNECT_CAPABILITIES = [
+	"invitation_claim_from_stdin",
+	"verification_reply",
+	"native_background_receiver",
+	"claude_external_hooks",
+	"bundled_skill_install",
+	"agent_info_seed",
+	"resume",
+	"poll_receiver"
+];
+const AGENT_INFO_NOTE = "AGENT_INFO";
+const MAX_NAME_LENGTH = 80;
+const MAX_INFO_LENGTH = 1e3;
+const MAIL_CHECK_WAIT_MS = 2e4;
+const PENDING_AGENT_INFO_FILE = "agent-info-pending.json";
+function readPendingAgentInfo(path) {
+	try {
+		const saved = readMailJson(path);
+		if (saved && typeof saved === "object" && !Array.isArray(saved) && saved.version === 1) {
+			const value = saved.value;
+			if (typeof value === "string" && value.length > 0) return value;
+		}
+	} catch {}
+	return null;
+}
+function savedSetup(configDir, profileName) {
+	try {
+		const saved = readMailJson(join(agentProfileDirectory(configDir, profileName), "setup.json"));
+		if (!saved || typeof saved !== "object" || Array.isArray(saved)) return null;
+		const row = saved;
+		return {
+			receiverMode: row.receiverMode === "external" || row.receiverMode === "poll" ? row.receiverMode : "native",
+			contactRequests: row.contactRequests === true
+		};
+	} catch {
+		return null;
+	}
+}
+/** Best effort: a lost pending note only means --name/--info must be passed again. */
+function savePendingAgentInfo(path, value) {
+	try {
+		writeMailJson(path, {
+			version: 1,
+			value
+		});
+	} catch {}
+}
+function clearPendingAgentInfo(path) {
+	try {
+		removeMailFile(path);
+	} catch {}
+}
+function defaultAgentProfileName(session) {
+	return `session-${session.toLowerCase()}`;
+}
+/**
+* The profile for a setup that binds no session. It is derived from the
+* invitation, so running the same invitation again finds the same profile and
+* its saved claim instead of claiming twice. A one-way hash prefix reveals
+* nothing usable about the invitation.
+*/
+function invitationProfileName(invitation) {
+	const parsed = parseAgentInvitation(invitation);
+	return `connection-${createHash("sha256").update(parsed.apiBaseUrl).update("\0").update(parsed.token).digest("hex").slice(0, 12)}`;
+}
+/** The command that checks a poll-receiving profile for new mail. */
+function pollCheckCommand(invocation, profileName) {
+	return `PRIMITIVE_AGENT_PROFILE=${profileName} ${invocation} agent check-mail --json`;
+}
+/** A short private role note; never a transcript or secret. */
+function agentInfoValue(name, info) {
+	const clean = (value, max, label) => {
+		if (value === void 0) return void 0;
+		const trimmed = value.trim();
+		if (!trimmed || trimmed.length > max || [...trimmed].some((character) => {
+			const code = character.charCodeAt(0);
+			return code < 32 && character !== "\n" || code === 127;
+		})) throw new AgentConnectionSetupError(`--${label} must be 1-${max} characters without control characters.`);
+		return trimmed;
+	};
+	const cleanName = clean(name, MAX_NAME_LENGTH, "name");
+	const cleanInfo = clean(info, MAX_INFO_LENGTH, "info");
+	if (cleanName && cleanInfo) return `${cleanName}: ${cleanInfo}`;
+	return cleanName ?? cleanInfo ?? null;
+}
+function defaults(options) {
+	return {
+		setupAgent,
+		nativePreflight: nativeSessionPreflight,
+		installClaudeWakeHook,
+		installSkill(runtime) {
+			return installConnectSkill({
+				bundle: readBundledConnectSkill(options.packageRoot),
+				runtime,
+				project: options.project,
+				cwd: options.cwd,
+				env: options.env
+			});
+		},
+		seedAgentInfo: (profileName, value) => seedAgentInfoNote(options.configDir, profileName, value),
+		refreshOwnerMemberAddress: (profileName) => refreshOwnerMemberAddress({
+			configDir: options.configDir,
+			profileName
+		}),
+		async awaitMailCheck(profileName, since) {
+			const deadline = Date.now() + (options.mailCheckWaitMs ?? MAIL_CHECK_WAIT_MS);
+			for (;;) {
+				const status = agentConnectionStatus(options.configDir, profileName);
+				const at = status.status === "configured" ? status.receiving.lastSuccessfulMailCheckAt : null;
+				if (at && Date.parse(at) >= since) return {
+					state: "confirmed",
+					lastSuccessfulMailCheckAt: at
+				};
+				if (Date.now() >= deadline) return {
+					state: "pending",
+					lastSuccessfulMailCheckAt: null
+				};
+				await setTimeout$1(250);
+			}
+		}
+	};
+}
+/** Create the private AGENT_INFO note only when the address has none. */
+async function seedAgentInfoNote(configDir, profileName, value, fetchImpl) {
+	const profile = loadConnectedAgentProfile(configDir, profileName);
+	if (!profile) return "failed";
+	const client = new PrimitiveApiClient({
+		apiKey: profile.api_key,
+		apiBaseUrl: profile.api_base_url,
+		...fetchImpl ? { fetch: fetchImpl } : {}
+	});
+	try {
+		await runAddressNotesRequest(client.client, {
+			action: "set",
+			address: profile.agent_address,
+			name: AGENT_INFO_NOTE,
+			value,
+			visibility: "private",
+			ifAbsent: true
+		});
+		return "created";
+	} catch (error) {
+		if (error instanceof AddressNotesApiError && error.status === 409) return "already_present";
+		return "failed";
+	}
+}
+/**
+* One call: self check, install the matching skill, claim and verify, start
+* receiving, seed AGENT_INFO, and report everything as one result. Every step
+* after the claim is safe to repeat with --resume.
+*/
+async function runAgentConnect(options) {
+	const env = options.env ?? process.env;
+	const dependencies = {
+		...defaults(options),
+		...Object.fromEntries(Object.entries(options.dependencies ?? {}).filter(([, value]) => value !== void 0))
+	};
+	const session = options.session?.trim() ? options.session : void 0;
+	if (session !== void 0 && !SESSION_UUID.test(session)) throw new AgentConnectionSetupError("--session requires the exact loaded session UUID.");
+	if (session === void 0 && options.receiver && options.receiver !== "poll") throw new AgentConnectionSetupError(`--receiver ${options.receiver} requires the exact loaded session UUID. Without one, use --receiver poll. No invitation was claimed.`);
+	if (session === void 0 && options.resume && !options.profileName) throw new AgentConnectionSetupError("Pass --profile to resume a setup that binds no session.");
+	const runtime = session ? detectAgentRuntime(session, env) : null;
+	const invitation = options.resume || session || options.profileName ? void 0 : await options.readInvitation();
+	const profileName = agentProfileName(options.profileName ?? (session ? defaultAgentProfileName(session) : invitationProfileName(invitation ?? "")));
+	const receiver = options.receiver ?? (options.resume ? savedSetup(options.configDir, profileName)?.receiverMode ?? null : null) ?? (!session ? "poll" : runtime === "claude" ? "external" : "native");
+	if (receiver === "external" && env.CLAUDE_CODE_SESSION_ID?.trim().toLowerCase() !== session?.toLowerCase()) throw new AgentConnectionSetupError("External receiving requires this exact Claude session ID. No invitation was claimed.");
+	const agentInfo = agentInfoValue(options.name, options.info);
+	const skipped = [];
+	let skill;
+	if (options.skill === false) skill = {
+		state: "skipped",
+		runtime,
+		path: null,
+		version: null,
+		reason: "not_requested"
+	};
+	else if (!runtime) skill = {
+		state: "skipped",
+		runtime: null,
+		path: null,
+		version: null,
+		reason: "runtime_unknown"
+	};
+	else try {
+		skill = dependencies.installSkill(runtime);
+	} catch {
+		skill = {
+			state: "failed",
+			runtime,
+			path: null,
+			version: null,
+			reason: "bundled_skill_unavailable"
+		};
+	}
+	if (skill.state === "skipped" || skill.state === "failed") skipped.push({
+		step: "skill",
+		reason: skill.reason ?? skill.state
+	});
+	const startedAt = Date.now();
+	const setupInvitation = options.resume ? void 0 : invitation ?? await options.readInvitation();
+	if (options.beforeSetup) {
+		if (receiver === "native" && session) try {
+			await dependencies.nativePreflight(session);
+		} catch {
+			throw new AgentConnectionSetupError("This exact session is not available for native receiving. No invitation was claimed and nothing was changed. Open a supported session and retry setup.");
+		}
+		await options.beforeSetup();
+	}
+	const result = await dependencies.setupAgent({
+		configDir: options.configDir,
+		profileName,
+		...session ? { session } : {},
+		receiverMode: receiver,
+		resume: options.resume,
+		contactRequests: options.contactRequests,
+		...setupInvitation === void 0 ? {} : { invitation: setupInvitation }
+	});
+	const verified = verificationReplySubmitted(result.verification.state);
+	const ownerMemberAddress = await dependencies.refreshOwnerMemberAddress(result.identity.profileName);
+	const identity = {
+		...result.identity,
+		ownerMemberAddress
+	};
+	let externalHook = null;
+	if (receiver === "external") if (verified) externalHook = dependencies.installClaudeWakeHook({
+		cliPath: options.cliPath,
+		configDir: options.configDir,
+		profileName: result.identity.profileName,
+		agentAddress: result.identity.agentAddress,
+		sessionId: session ?? "",
+		env
+	});
+	else skipped.push({
+		step: "receiver",
+		reason: "pending_verification"
+	});
+	let mailCheck = null;
+	if (receiver === "native") if (result.receiving.state === "healthy") {
+		mailCheck = await dependencies.awaitMailCheck(profileName, startedAt);
+		if (mailCheck.state === "pending") skipped.push({
+			step: "mail_check",
+			reason: "not_yet_observed"
+		});
+	} else skipped.push({
+		step: "receiver",
+		reason: verified ? "not_ready" : "pending_verification"
+	});
+	const pendingPath = join(agentProfileDirectory(options.configDir, profileName), PENDING_AGENT_INFO_FILE);
+	const noteValue = agentInfo ?? readPendingAgentInfo(pendingPath);
+	let agentInfoState = "not_requested";
+	if (noteValue === null) skipped.push({
+		step: "agent_info",
+		reason: "not_requested"
+	});
+	else if (!verified) {
+		agentInfoState = "pending_verification";
+		savePendingAgentInfo(pendingPath, noteValue);
+		skipped.push({
+			step: "agent_info",
+			reason: "pending_verification"
+		});
+	} else {
+		agentInfoState = await dependencies.seedAgentInfo(profileName, noteValue);
+		if (agentInfoState === "failed") {
+			savePendingAgentInfo(pendingPath, noteValue);
+			skipped.push({
+				step: "agent_info",
+				reason: "failed"
+			});
+		} else clearPendingAgentInfo(pendingPath);
+		if (agentInfoState === "already_present") skipped.push({
+			step: "agent_info",
+			reason: "already_present"
+		});
+	}
+	const invocation = options.invocation ?? "primitive";
+	const receiving = receiver === "external" ? {
+		...result.receiving,
+		mode: "external",
+		hook: externalHook
+	} : receiver === "poll" ? {
+		...result.receiving,
+		mode: "poll",
+		checkCommand: pollCheckCommand(invocation, result.identity.profileName)
+	} : {
+		...result.receiving,
+		mode: "native",
+		mailCheck: mailCheck?.state ?? "not_started",
+		lastSuccessfulMailCheckAt: mailCheck?.lastSuccessfulMailCheckAt ?? null
+	};
+	const receiverReady = receiver === "external" ? externalHook === "installed_unverified" : receiver === "poll" || result.receiving.state === "healthy";
+	const resumeCommand = [
+		invocation,
+		"agent connect",
+		`--profile ${result.identity.profileName}`,
+		...session ? [`--session ${session}`] : [],
+		`--receiver ${receiver}`,
+		"--resume",
+		...options.contactRequests ?? savedSetup(options.configDir, profileName)?.contactRequests ? ["--contact-requests"] : [],
+		...options.skill === false ? ["--no-skill"] : [],
+		...options.project ? ["--project"] : [],
+		"--json"
+	].join(" ");
+	return {
+		status: verified && receiverReady ? "connected" : "pending",
+		address: result.identity.agentAddress,
+		orgId: result.identity.orgId,
+		ownerAddress: result.identity.ownerAddress,
+		ownerMemberAddress,
+		profile: result.identity.profileName,
+		sessionId: session ?? null,
+		runtime,
+		cli: {
+			version: options.cliVersion,
+			capabilities: [...AGENT_CONNECT_CAPABILITIES]
+		},
+		skill,
+		verification: result.verification,
+		receiving,
+		...result.ownerNotifications ? { ownerNotifications: result.ownerNotifications } : {},
+		agentInfo: agentInfoState,
+		skipped,
+		selectProfile: `PRIMITIVE_AGENT_PROFILE=${result.identity.profileName}`,
+		resumeCommand,
+		guidance: `${result.guidance} ${ownerReportGuidance(identity)}`,
+		identity,
+		externalHook
+	};
+}
+//#endregion
+//#region src/oclif/agent-identity-suggestions.ts
+/** The connection name enrollment uses when none is given. */
+const DEFAULT_ENROLL_NAME = "Coding agent";
+/** npx runs the CLI from its cache; print follow-up commands the same way. */
+function cliInvocation(entry) {
+	return entry && /[\\/]_npx[\\/]/.test(entry) ? "npx -y primitive@latest" : "primitive";
+}
+/**
+* Whether an enrollment's connection name is the fallback it chose by itself.
+* Session registration's `<runtime>-<repository>` names are reported by
+* registration, which knows the exact name it generated.
+*/
+function generatedAgentName(name) {
+	return name === DEFAULT_ENROLL_NAME;
+}
+/**
+* Additive result fields for a connect, enroll or session registration.
+* `nameIsDefault` appears only when it is known whether the connection name
+* is one this CLI generated. The runtime note is suggested once, after a
+* connection this run completed.
+*/
+function identitySuggestions(params) {
+	const prefix = `PRIMITIVE_AGENT_PROFILE=${params.profile} ${params.invocation}`;
+	const suggestions = [];
+	const nameIsDefault = params.nameIsDefault;
+	if (nameIsDefault) suggestions.push({
+		kind: "rename",
+		command: `${prefix} agent rename "<new name>"`
+	});
+	if (params.connectedNow) suggestions.push({
+		kind: "runtime_note",
+		command: `${prefix} agent runtime set`
+	});
+	return nameIsDefault === void 0 ? { suggestions } : {
+		nameIsDefault,
+		suggestions
+	};
+}
+//#endregion
+//#region src/oclif/agent-disconnect.ts
+var AgentDisconnectError = class extends Error {};
+function credentialDigest(profile) {
+	return createHash("sha256").update("primitive-agent-disconnect-v1\0").update(profile.api_key).digest("hex");
+}
+function boundSession(directory, profile) {
+	const raw = readMailJson(join(directory, "setup.json"));
+	if (raw === null) return null;
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new AgentDisconnectError("Saved session setup is invalid. The connection was not changed.");
+	const row = raw;
+	if (row.receiverMode === "poll" && row.session === null && row.invitationHash === profile.invitation_hash) return null;
+	if (typeof row.session !== "string" || !SESSION_UUID.test(row.session) || row.invitationHash !== profile.invitation_hash) throw new AgentDisconnectError("Saved session binding does not match this profile. The connection was not changed.");
+	return row.session.toLowerCase();
+}
+function receiverStopped(status) {
+	return status.phase === null || status.phase === "stopped" || status.phase === "failed" || status.reason === "exited";
+}
+function confirmationPath(directory, profile) {
+	return join(directory, `disconnected-${profile.invitation_hash}.json`);
+}
+function confirmedLocally(directory, profile) {
+	const raw = readMailJson(confirmationPath(directory, profile));
+	if (raw === null) return false;
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new AgentDisconnectError("Saved revocation confirmation is invalid. The credential was preserved.");
+	const row = raw;
+	if (row.version !== 1 || row.address !== profile.agent_address || row.api_base_url !== profile.api_base_url || row.credential_digest !== credentialDigest(profile) || typeof row.revoked_at !== "string" || !Number.isFinite(Date.parse(row.revoked_at))) throw new AgentDisconnectError("Saved revocation confirmation does not match this credential. The credential was preserved.");
+	return true;
+}
+/** The API error code from an error envelope, when it has one. */
+function errorCode(error) {
+	if (!error || typeof error !== "object") return void 0;
+	const inner = error.error;
+	const code = inner && typeof inner === "object" ? inner.code : error.code;
+	return typeof code === "string" && /^[a-z0-9_]{1,64}$/.test(code) ? code : void 0;
+}
+async function revoke(profile, fetcher) {
+	const client = new PrimitiveApiClient({
+		apiKey: profile.api_key,
+		apiBaseUrl: profile.api_base_url,
+		...fetcher ? { fetch: fetcher } : {}
+	});
+	let result;
+	try {
+		result = await client.client.delete({
+			security: [{
+				scheme: "bearer",
+				type: "http"
+			}],
+			url: "/agent-connections/{address}",
+			path: { address: profile.agent_address },
+			redirect: "error",
+			signal: AbortSignal.timeout(25e3),
+			responseStyle: "fields"
+		});
+	} catch {
+		throw new AgentDisconnectError("Revocation outcome is unknown after a transport error. The profile and credential were preserved. Check the agent in the app before retrying.");
+	}
+	if (result.error !== void 0) {
+		const status = result.response?.status;
+		if (status === void 0) throw new AgentDisconnectError("Revocation outcome is unknown: no response was received from Primitive. The profile and credential were preserved. Check your connection, then retry or check the agent in the app.");
+		const code = errorCode(result.error);
+		const label = `HTTP ${status}${code ? `, ${code}` : ""}`;
+		throw new AgentDisconnectError(status === 401 ? `Revocation was not confirmed (${label}). The credential was preserved; it may already be invalid. Check the agent in the app before retrying.` : status >= 500 ? `Primitive returned a server error while revoking this agent (${label}), so revocation is unconfirmed. The profile was preserved. Retry the same command; a 401 on retry means the credential was already revoked.` : `Revocation was refused by Primitive (${label}). The credential was preserved. Check the agent in the app before retrying.`);
+	}
+	const envelope = result.data;
+	if (!envelope || typeof envelope !== "object" || Array.isArray(envelope)) throw new AgentDisconnectError("Revocation response was incomplete. The credential was preserved. Check the agent in the app before retrying.");
+	const row = envelope;
+	const data = row.data;
+	const connection = data && typeof data === "object" && !Array.isArray(data) ? data.connection : void 0;
+	if (row.success !== true || !connection || typeof connection !== "object" || Array.isArray(connection) || connection.address !== profile.agent_address || connection.owner_address !== profile.owner_address || connection.status !== "revoked") throw new AgentDisconnectError("Revocation response was incomplete. The credential was preserved. Check the agent in the app before retrying.");
+}
+/** Revoke one selected connected credential; never alter OAuth login or mail evidence. */
+async function disconnectAgent(params) {
+	const profileName = agentProfileName(params.profileName);
+	if (!loadConnectedAgentProfile(params.configDir, profileName)) throw new AgentDisconnectError("This agent profile is not configured. Nothing was changed.");
+	const directory = agentProfileDirectory(params.configDir, profileName);
+	let releaseSetup;
+	let releaseClaim;
+	try {
+		releaseSetup = acquireListenLock(directory, "setup");
+		releaseClaim = acquireListenLock(agentProfilesDirectory(params.configDir), "agent-connection-setup");
+		const profile = loadConnectedAgentProfile(params.configDir, profileName);
+		if (!profile) throw new AgentDisconnectError("The selected profile changed before disconnect. Nothing was changed.");
+		const session = boundSession(directory, profile);
+		const receiver = session ? await (params.stopReceiver ?? stopBackgroundListen)({
+			configDir: params.configDir,
+			scope: notificationScope(profile.api_base_url, profile.api_key),
+			threadId: session
+		}) : null;
+		if (receiver && !receiverStopped(receiver)) throw new AgentDisconnectError("The bound receiver has not confirmed stopping. The connection and credential were preserved. Check listener status before retrying.");
+		const previous = confirmedLocally(directory, profile);
+		if (!previous) await revoke(profile, params.fetch);
+		if (!previous) try {
+			writeMailJson(confirmationPath(directory, profile), {
+				version: 1,
+				address: profile.agent_address,
+				api_base_url: profile.api_base_url,
+				credential_digest: credentialDigest(profile),
+				revoked_at: (params.now ?? (() => /* @__PURE__ */ new Date()))().toISOString()
+			});
+		} catch {
+			throw new AgentDisconnectError("Primitive confirmed revocation, but its local confirmation could not be saved. The credential was preserved. Keep this profile for recovery.");
+		}
+		const current = loadConnectedAgentProfile(params.configDir, profileName);
+		if (!current || current.api_key !== profile.api_key) throw new AgentDisconnectError("The selected profile changed after revocation. Its credential was preserved for inspection.");
+		try {
+			removeMailFile(join(directory, "connection.json"));
+		} catch {
+			throw new AgentDisconnectError("Primitive confirmed revocation, but the local credential could not be removed. Confirmation is saved; retry this command to finish local cleanup.");
+		}
+		const externalHook = session ? uninstallClaudeWakeHook({
+			configDir: params.configDir,
+			profileName,
+			agentAddress: profile.agent_address,
+			sessionId: session,
+			env: params.env
+		}) ? "removed" : "unavailable" : null;
+		return {
+			status: "disconnected",
+			identity: connectedAgentIdentity(profileName, profile),
+			receiver,
+			revocation: previous ? "previously_confirmed" : "confirmed",
+			externalHook
+		};
+	} catch (error) {
+		if (error instanceof AgentDisconnectError) throw error;
+		throw new AgentDisconnectError("Disconnect could not safely complete. The credential and local evidence were preserved. Check this profile and listener status before retrying.");
+	} finally {
+		releaseClaim?.();
+		releaseSetup?.();
+	}
+}
+//#endregion
+//#region src/oclif/agent-enroll.ts
+const RESPONSE_LIMIT = 32768;
+const CONNECTION_LIST_LIMIT = 131072;
+const CONFIRMATION_BUDGET_MS = 12e4;
+const CONFIRMATION_MAX_ATTEMPTS = 40;
+const CONFIRMATION_PAGE_LIMIT = 20;
+const refuse = (message) => new AgentConnectionSetupError(message);
+function plainRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function savedEnrollment(value) {
+	const row = plainRecord(value);
+	const keys = [
+		"version",
+		"session",
+		"profile",
+		"name",
+		"address",
+		"orgId",
+		"grantId",
+		"apiBaseUrl",
+		"receiverMode",
+		"contactRequests",
+		"startedAt",
+		"phase",
+		"invitationHash",
+		"ownerAddress"
+	];
+	if (row?.version === 2) keys.push("createRequestId", "continueAttempted");
+	if (!row || Object.keys(row).length !== keys.length || keys.some((key) => !Object.hasOwn(row, key)) || row.version !== 1 && row.version !== 2 || row.version === 2 && (typeof row.createRequestId !== "string" || !SESSION_UUID.test(row.createRequestId) || typeof row.continueAttempted !== "boolean") || typeof row.session !== "string" || !SESSION_UUID.test(row.session) || row.profile !== `session-${row.session}` || typeof row.name !== "string" || !validName(row.name) || !(typeof row.address === "string" && validAddress(row.address) || row.version === 2 && row.address === null && row.phase === "create_attempted") || typeof row.orgId !== "string" || !row.orgId || typeof row.grantId !== "string" || !row.grantId || typeof row.apiBaseUrl !== "string" || !RECEIVER_MODES.includes(row.receiverMode) || typeof row.contactRequests !== "boolean" || typeof row.startedAt !== "string" || !Number.isFinite(Date.parse(row.startedAt)) || !["create_attempted", "setup_attempted"].includes(String(row.phase)) || row.phase === "create_attempted" && (row.invitationHash !== null || row.ownerAddress !== null) || row.phase === "setup_attempted" && (typeof row.address !== "string" || typeof row.invitationHash !== "string" || !/^[a-f0-9]{64}$/.test(row.invitationHash) || typeof row.ownerAddress !== "string" || !row.ownerAddress.includes("@"))) throw refuse("Saved enrollment state is invalid. Preserve its private files.");
+	connectedApiBaseUrl(row.apiBaseUrl);
+	if (row.ownerAddress !== null) try {
+		if (mailAddress(row.ownerAddress) !== row.ownerAddress) throw new Error();
+	} catch {
+		throw refuse("Saved enrollment owner is invalid. Preserve its private files.");
+	}
+	return row;
+}
+function validName(value) {
+	return value.length >= 1 && value.length <= 80 && value.trim() === value && Array.from(value).every((character) => {
+		const code = character.charCodeAt(0);
+		return code >= 32 && code !== 127;
+	});
+}
+function validAddress(value) {
+	return value.length <= 254 && /^[a-z0-9][a-z0-9-]{0,62}@[a-z0-9](?:[a-z0-9.-]*[a-z0-9])$/.test(value);
+}
+function resolvedEnrollment(state) {
+	if (!state.address) throw refuse("The server has not assigned this session an address yet. Preserve its setup request.");
+	return {
+		...state,
+		address: state.address
+	};
+}
+async function preflight(session, receiver, env) {
+	if (receiver === "poll") return;
+	if (receiver === "external") {
+		if (env.CLAUDE_CODE_SESSION_ID !== session) throw refuse("External receiving requires this exact Claude session ID. No address was created.");
+		return;
+	}
+	assertNativeSessionIdentity(session, env);
+	(await connectNativeSession({
+		threadId: session,
+		expectedCwd: process.cwd(),
+		signal: AbortSignal.timeout(1e4)
+	})).close();
+}
+/** Refuse a different loaded Codex thread before creating an address. */
+function assertNativeSessionIdentity(session, env) {
+	if (env.CODEX_THREAD_ID && env.CODEX_THREAD_ID !== session) throw refuse("The requested session differs from this Codex thread. No address was created.");
+	if (!env.CODEX_THREAD_ID && env.CODEX_SESSION_ID && env.CODEX_SESSION_ID !== session) throw refuse("The requested session differs from this Codex session. No address was created.");
+}
+async function managedDomains(client, apiBaseUrl) {
+	const response = await listDomains({
+		client: client.client,
+		responseStyle: "fields"
+	});
+	const rows = response.data?.data;
+	if (response.error || !Array.isArray(rows)) throw refuse("Could not list the owner's managed domains. No address was created.");
+	const suffix = apiBaseUrl === "https://api.primitive-staging-1.com/v1" ? ".primitive-staging.email" : ".primitive.email";
+	const domains = [...new Set(rows.filter((row) => row.verified === true && "is_active" in row && row.is_active === true && row.domain.toLowerCase().endsWith(suffix)).map((row) => row.domain.toLowerCase()).filter((domain) => /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])$/.test(domain)))].sort();
+	if (!domains[0]) throw refuse("This organization has no verified managed domain for agent enrollment.");
+	return domains;
+}
+async function boundedJson(response, label = "connection creation", limit = RESPONSE_LIMIT) {
+	const reader = response.body?.getReader();
+	if (!reader) throw refuse(`The ${label} response is incomplete.`);
+	const chunks = [];
+	let size = 0;
+	try {
+		for (;;) {
+			const part = await reader.read();
+			if (part.done) break;
+			size += part.value.byteLength;
+			if (size > limit) throw refuse(`The ${label} response is too large.`);
+			chunks.push(part.value);
+		}
+		return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+	} catch {
+		throw refuse(`The ${label} response is incomplete or invalid.`);
+	} finally {
+		await reader.cancel().catch(() => void 0);
+	}
+}
+async function rejectedUnsuitableDomain(response) {
+	if (response.status !== 400) return false;
+	try {
+		const envelope = plainRecord(await boundedJson(response, "connection rejection"));
+		return envelope?.success === false && plainRecord(envelope.error)?.code === "connection_domain_unavailable";
+	} catch {
+		return false;
+	}
+}
+function invitationFrom(value, expected, now) {
+	const envelope = plainRecord(value);
+	const data = plainRecord(envelope?.data);
+	const connection = plainRecord(data?.connection);
+	const invitation = plainRecord(data?.invitation);
+	if (envelope?.success !== true || connection?.address !== expected.address || typeof connection?.name !== "string" || connection?.status !== "pending" || typeof connection.owner_address !== "string" || typeof invitation?.claim_url !== "string" || typeof invitation.expires_at !== "string" || !Number.isFinite(Date.parse(invitation.expires_at)) || Date.parse(invitation.expires_at) <= now + 3e4) throw refuse("The connection creation result was incomplete or did not match this session. No invitation was claimed.");
+	const parsed = parseAgentInvitation(invitation.claim_url);
+	if (parsed.apiBaseUrl !== expected.apiBaseUrl) throw refuse("The connection invitation origin differs from the owner's login. No invitation was claimed.");
+	let ownerAddress;
+	try {
+		ownerAddress = mailAddress(connection.owner_address);
+	} catch {
+		throw refuse("The connection owner address was invalid. No invitation was claimed.");
+	}
+	return {
+		url: invitation.claim_url,
+		hash: createHash("sha256").update(parsed.apiBaseUrl).update("\0").update(parsed.token).digest("hex"),
+		ownerAddress
+	};
+}
+function policyRuleInputs(rules) {
+	return rules.map(({ pattern, effect }) => ({
+		pattern,
+		effect
+	})).sort((left, right) => {
+		const a = `${left.pattern}:${left.effect}`;
+		const b = `${right.pattern}:${right.effect}`;
+		return a < b ? -1 : a > b ? 1 : 0;
+	});
+}
+async function enableAgentContactRequests(options) {
+	const saved = loadCliCredentials(options.configDir);
+	if (!saved || saved.org_id !== options.orgId || saved.oauth_grant_id !== options.grantId || saved.api_base_url !== options.apiBaseUrl) throw refuse("The saved member login changed before contact requests were enabled. This agent remains connected; sign in to its organization and resume this exact enrollment.");
+	const credentials = await refreshStoredCliCredentials({
+		apiBaseUrl: options.apiBaseUrl,
+		configDir: options.configDir,
+		credentials: saved,
+		fetch: options.fetch,
+		now: options.now
+	});
+	if (credentials.org_id !== options.orgId || credentials.oauth_grant_id !== options.grantId || credentials.api_base_url !== options.apiBaseUrl) throw refuse("The saved member login changed before contact requests were enabled. This agent remains connected; sign in to its organization and resume this exact enrollment.");
+	const client = new PrimitiveApiClient({
+		apiKey: credentials.access_token,
+		apiBaseUrl: options.apiBaseUrl,
+		fetch: options.fetch
+	});
+	async function readPolicy() {
+		try {
+			const response = await getAgentContactPolicy({
+				client: client.client,
+				path: { agent_address: options.address },
+				signal: AbortSignal.timeout(1e4),
+				responseStyle: "fields"
+			});
+			if (response.error || response.data?.success !== true || !response.data.data) throw new Error();
+			return parseAgentContactPolicy(response.data.data, options.address);
+		} catch {
+			return null;
+		}
+	}
+	const before = await readPolicy();
+	if (!before) return "unavailable";
+	if (before.agent_policy.allow_contact_requests === false) return "owner_disabled";
+	const rules = policyRuleInputs(before.agent_policy.rules);
+	if (before.agent_policy.allow_contact_requests !== true) try {
+		const response = await putAgentContactPolicy({
+			client: client.client,
+			path: { agent_address: options.address },
+			body: {
+				rules,
+				allow_contact_requests: true,
+				...before.agent_policy.version ? { if_version: before.agent_policy.version } : { if_absent: true }
+			},
+			signal: AbortSignal.timeout(1e4),
+			responseStyle: "fields"
+		});
+		if (response.error || response.data?.success !== true || !response.data.data) throw new Error();
+		const updated = parseAgentContactPolicy(response.data.data, options.address);
+		if (updated.agent_policy.allow_contact_requests !== true || JSON.stringify(policyRuleInputs(updated.agent_policy.rules)) !== JSON.stringify(rules)) throw new Error();
+	} catch {
+		return "unavailable";
+	}
+	const after = await readPolicy();
+	if (!after || after.agent_policy.allow_contact_requests !== true || after.allow_contact_requests !== true || !after.contact_request_since || !after.contact_request_generation || JSON.stringify(policyRuleInputs(after.agent_policy.rules)) !== JSON.stringify(rules)) return "unavailable";
+	return "enabled";
+}
+async function readOwnerConnection(enrollment, params, deadline, listed) {
+	const saved = loadCliCredentials(params.configDir);
+	if (!saved || saved.org_id !== enrollment.orgId || saved.oauth_grant_id !== enrollment.grantId || saved.api_base_url !== enrollment.apiBaseUrl) throw refuse("The saved member login changed before connection confirmation. Preserve this session's profile and resume with the original member login.");
+	const credentials = await refreshStoredCliCredentials({
+		apiBaseUrl: enrollment.apiBaseUrl,
+		configDir: params.configDir,
+		credentials: saved,
+		fetch: params.fetch,
+		now: params.now
+	});
+	if (credentials.org_id !== enrollment.orgId || credentials.oauth_grant_id !== enrollment.grantId || credentials.api_base_url !== enrollment.apiBaseUrl) throw refuse("The saved member login changed before connection confirmation. Preserve this session's profile and resume with the original member login.");
+	let cursor;
+	for (let page = 0; page < CONFIRMATION_PAGE_LIMIT; page++) {
+		const remaining = deadline - Date.now();
+		if (remaining <= 0) return "unavailable";
+		const url = new URL(`${enrollment.apiBaseUrl}/agent-connections`);
+		url.searchParams.set("limit", "50");
+		if (cursor) url.searchParams.set("cursor", cursor);
+		let value;
+		try {
+			const response = await (params.fetch ?? fetch)(url, {
+				method: "GET",
+				redirect: "error",
+				signal: AbortSignal.timeout(Math.min(5e3, remaining)),
+				headers: {
+					authorization: `Bearer ${credentials.access_token}`,
+					accept: "application/json"
+				}
+			});
+			if (response.status !== 200) {
+				await response.body?.cancel();
+				return "unavailable";
+			}
+			value = await boundedJson(response, "connection list", CONNECTION_LIST_LIMIT);
+		} catch {
+			return "unavailable";
+		}
+		const envelope = plainRecord(value);
+		if (envelope?.success !== true || !Array.isArray(envelope.data)) return "unavailable";
+		for (const candidate of envelope.data) {
+			const connection = plainRecord(candidate);
+			if (connection?.address !== enrollment.address) continue;
+			if (connection.owner_address !== enrollment.ownerAddress) throw refuse("The owner connection list did not match this session's saved identity. Preserve the profile and inspect the connection in the app.");
+			if (typeof connection.name === "string") listed.name = connection.name;
+			if (connection.owner_active === false) return "owner_inactive";
+			if (connection.status === "revoked") return "revoked";
+			if (connection.status === "connected" && typeof connection.verified_at === "string" && Number.isFinite(Date.parse(connection.verified_at))) return "connected";
+			return "pending";
+		}
+		const next = plainRecord(envelope.meta)?.cursor;
+		if (next === null) return "unavailable";
+		if (typeof next !== "string" || !SESSION_UUID.test(next) || next === cursor) return "unavailable";
+		cursor = next;
+	}
+	return "unavailable";
+}
+async function confirmOwnerConnection(enrollment, params, listed) {
+	const deadline = Date.now() + CONFIRMATION_BUDGET_MS;
+	let last = "unavailable";
+	for (let attempt = 0; attempt < CONFIRMATION_MAX_ATTEMPTS; attempt++) {
+		last = await readOwnerConnection(enrollment, params, deadline, listed);
+		if (last === "connected" || last === "revoked" || last === "owner_inactive") return last;
+		const remaining = deadline - Date.now();
+		if (remaining <= 0 || attempt === CONFIRMATION_MAX_ATTEMPTS - 1) break;
+		await (params.confirmationSleep ?? ((milliseconds) => setTimeout$1(milliseconds)))(Math.min(3e3, remaining));
+	}
+	return last;
+}
+/**
+* True when `session-<session>` holds this session's own enrollment, saved
+* state and credential agreeing, so rerunning enroll resumes it rather than
+* adding a second address. Offline and read-only.
+*/
+function enrollmentResumes(configDir, session) {
+	const profile = `session-${session}`;
+	try {
+		const raw = readMailJson(join(agentProfileDirectory(configDir, profile), "enrollment", "state.json"));
+		if (raw === null) return false;
+		const state = savedEnrollment(raw);
+		if (state.profile !== profile) return false;
+		const existing = loadConnectedAgentProfile(configDir, profile);
+		return !existing || existing.agent_address === state.address && existing.org_id === state.orgId && existing.api_base_url === state.apiBaseUrl && (state.phase !== "setup_attempted" || existing.invitation_hash === state.invitationHash && existing.owner_address === state.ownerAddress);
+	} catch {
+		return false;
+	}
+}
+/** Trusted-machine enrollment using only saved member OAuth and the public API. */
+async function enrollAgent(params) {
+	if (!SESSION_UUID.test(params.session)) throw refuse("Enrollment requires the exact current session UUID.");
+	let name = params.name ?? "Coding agent";
+	if (!validName(name)) throw refuse("Agent name must be 1-80 characters without control characters.");
+	const receiverMode = params.receiverMode ?? "native";
+	const contactRequests = Boolean(params.contactRequests);
+	const env = params.env ?? process.env;
+	if (env["PRIMITIVE_AGENT_PROFILE"]?.trim() || env.PRIMITIVE_API_KEY?.trim() || env.PRIMITIVE_KEY?.trim()) throw refuse("Enrollment requires the saved member OAuth login. Unset agent-profile and API-key environment overrides.");
+	const saved = loadCliCredentials(params.configDir);
+	if (!saved) throw refuse("Sign in with `primitive signin` as a member of this organization first.");
+	const apiBaseUrl = connectedApiBaseUrl(saved.api_base_url);
+	const profile = `session-${params.session}`;
+	const directory = join(agentProfileDirectory(params.configDir, profile), "enrollment");
+	privateMailDirectory(directory, true);
+	const release = acquireListenLock(directory, "agent-enrollment");
+	try {
+		await (params.preflight ?? ((session, receiver) => preflight(session, receiver, env)))(params.session, receiverMode);
+		await params.beforeCreate?.();
+		const path = join(directory, "state.json");
+		const old = readMailJson(path);
+		let state = old === null ? null : savedEnrollment(old);
+		if (state && params.name === void 0) name = state.name;
+		if (state && (state.session !== params.session || state.profile !== profile || state.name !== name || state.orgId !== saved.org_id || state.grantId !== saved.oauth_grant_id || state.apiBaseUrl !== apiBaseUrl || state.receiverMode !== receiverMode || state.contactRequests !== contactRequests)) throw refuse("This session's enrollment belongs to another owner, address, or setup choice. Nothing was changed.");
+		if (state && Date.parse(state.startedAt) > (params.now ?? Date.now)() + 6e4) throw refuse("Saved enrollment time is inconsistent. Preserve its private files.");
+		const existing = loadConnectedAgentProfile(params.configDir, profile);
+		if (existing && (!state || existing.agent_address !== state.address || existing.org_id !== state.orgId || existing.api_base_url !== state.apiBaseUrl || state.phase === "setup_attempted" && (existing.invitation_hash !== state.invitationHash || existing.owner_address !== state.ownerAddress))) throw refuse("This session profile already belongs to another connection. Nothing was changed.");
+		const finish = async (enrollment, resume, invitation) => {
+			const setup = await (params.setup ?? setupAgent)({
+				configDir: params.configDir,
+				profileName: profile,
+				session: params.session,
+				receiverMode,
+				...resume ? { resume: true } : { invitation },
+				contactRequests,
+				fetch: params.fetch
+			});
+			const ownerMemberAddress = await refreshOwnerMemberAddress({
+				configDir: params.configDir,
+				profileName: profile,
+				fetch: params.fetch
+			});
+			const identity = {
+				...setup.identity,
+				ownerMemberAddress
+			};
+			const report = ownerReportGuidance(identity);
+			const result = {
+				...setup,
+				identity,
+				name
+			};
+			if (!verificationReplySubmitted(result.verification.state)) return {
+				...result,
+				guidance: `${result.guidance} ${report}`,
+				contactRequestPolicy: contactRequests ? "pending_verification" : "not_requested",
+				connection: { status: "pending" }
+			};
+			const contactRequestPolicy = contactRequests ? await enableAgentContactRequests({
+				configDir: params.configDir,
+				address: enrollment.address,
+				orgId: enrollment.orgId,
+				grantId: enrollment.grantId,
+				apiBaseUrl: enrollment.apiBaseUrl,
+				fetch: params.fetch,
+				now: params.now
+			}) : "not_requested";
+			const current = {};
+			const listed = await confirmOwnerConnection(enrollment, params, current);
+			const verifiedBySetup = result.verification.state === "verified" && (listed === "pending" || listed === "unavailable");
+			const status = verifiedBySetup ? "connected" : listed;
+			return {
+				...result,
+				...status === "owner_inactive" ? { receiving: { state: "not_ready" } } : {},
+				guidance: `${verifiedBySetup ? "This agent's connection status reports pairing verified. Receiving is separate; configure and verify this session's external hook if external mode was selected." : status === "connected" ? "The owner connection list confirms pairing. Receiving is separate; configure and verify this session's external hook if external mode was selected." : status === "revoked" ? "The owner connection list reports this pairing revoked. Stop using this profile and ask the owner to review it." : status === "owner_inactive" ? "The original human owner is no longer an active member. This profile must not be treated as receiving; ask an organization manager to review or remove it." : "The challenge reply was submitted, but pairing is not confirmed. Resume this exact enrollment with the same options; do not create another address or resend the reply."}${status === "revoked" || status === "owner_inactive" ? "" : ` ${report}`}`,
+				contactRequestPolicy,
+				connection: { status },
+				name: current.name ?? name
+			};
+		};
+		if (state?.phase === "setup_attempted") {
+			if (!existing) throw refuse("The invitation claim may have been consumed. Keep this pending agent and inspect it in the app; do not create or claim another address.");
+			return finish(resolvedEnrollment(state), true);
+		}
+		if (existing) throw refuse("This profile is already connected without a matching enrollment. Nothing was changed.");
+		if (state?.version === 1) throw refuse("Connection creation may already have happened. Inspect this session's pending address in the app and issue a fresh invitation there if needed. Use `primitive agent connect` with that invitation and this session's profile; do not rerun enrollment or create another address.");
+		const credentials = await refreshStoredCliCredentials({
+			apiBaseUrl,
+			configDir: params.configDir,
+			credentials: saved,
+			fetch: params.fetch,
+			now: params.now
+		});
+		if (credentials.org_id !== saved.org_id || credentials.oauth_grant_id !== saved.oauth_grant_id || credentials.api_base_url !== apiBaseUrl) throw refuse("The saved member login changed during enrollment. No address was created. Sign in to the intended organization and retry this exact session.");
+		const fetchImpl = params.fetch ?? fetch;
+		const firstAttempt = state === null;
+		if (state?.continueAttempted) throw refuse("Continue setup already ran and its result may be uncertain. Inspect the saved agent in the app; do not issue another invitation automatically.");
+		if (!state) {
+			if (params.continueSetup) throw refuse("There is no saved enrollment to continue. Start enrollment normally first.");
+			if (!(await managedDomains(new PrimitiveApiClient({
+				apiKey: credentials.access_token,
+				apiBaseUrl,
+				fetch: params.fetch
+			}), apiBaseUrl)).length) throw refuse("No managed domain is available for enrollment.");
+			state = {
+				version: 2,
+				session: params.session,
+				profile,
+				name,
+				address: null,
+				createRequestId: randomUUID(),
+				continueAttempted: false,
+				orgId: saved.org_id,
+				grantId: saved.oauth_grant_id,
+				apiBaseUrl,
+				receiverMode,
+				contactRequests,
+				startedAt: new Date((params.now ?? Date.now)()).toISOString(),
+				phase: "create_attempted",
+				invitationHash: null,
+				ownerAddress: null
+			};
+			writeMailJson(path, state);
+		}
+		let payload;
+		try {
+			const response = await fetchImpl(`${apiBaseUrl}/agent-connections`, {
+				method: "POST",
+				redirect: "error",
+				signal: AbortSignal.timeout(25e3),
+				headers: {
+					authorization: `Bearer ${credentials.access_token}`,
+					"content-type": "application/json",
+					accept: "application/json"
+				},
+				body: JSON.stringify({
+					name: state.name,
+					create_request_id: state.createRequestId
+				})
+			});
+			if (await rejectedUnsuitableDomain(response)) {
+				if (firstAttempt) unlinkSync(path);
+				throw refuse("No verified managed domain is currently sendable for agent enrollment. No address was created by this request.");
+			}
+			if ([
+				400,
+				401,
+				403
+			].includes(response.status)) {
+				await response.body?.cancel().catch(() => void 0);
+				if (firstAttempt) unlinkSync(path);
+				throw refuse("Connection creation was rejected before an address was created. Check the selected organization, managed domain, and member access, then retry this exact session.");
+			}
+			if (response.status !== 200) {
+				const code = plainRecord(plainRecord(await boundedJson(response, "connection recovery"))?.error)?.code;
+				if (code === "connection_removed") throw refuse("This saved setup belongs to a removed agent. It cannot create another identity. Review the removed agent in the app.");
+				if (code === "connection_create_request_conflict") throw refuse("This saved setup belongs to different choices or membership. Preserve its request and inspect the original agent in the app.");
+				throw new Error();
+			}
+			payload = await boundedJson(response);
+		} catch (error) {
+			if (error instanceof AgentConnectionSetupError) throw error;
+			throw refuse("Connection creation has an unknown outcome. Rerun this exact enrollment to recover the same saved request; no second identity or invitation will be created automatically.");
+		}
+		const envelope = plainRecord(payload);
+		const data = plainRecord(envelope?.data);
+		const connection = plainRecord(data?.connection);
+		if (envelope?.success !== true || typeof connection?.address !== "string" || !validAddress(connection.address) || typeof connection.name !== "string" || !validName(connection.name) || ![
+			"pending",
+			"claimed",
+			"connected",
+			"revoked"
+		].includes(String(connection.status)) || state.address !== null && state.address !== connection.address) throw refuse("The connection result was incomplete or changed the saved identity. Preserve this setup request; no invitation was claimed.");
+		state = {
+			...state,
+			address: connection.address
+		};
+		writeMailJson(path, state);
+		if (data?.recovered === true) {
+			if (data.invitation !== null) throw refuse("Recovered setup unexpectedly included an invitation. Preserve the saved identity; no invitation was claimed.");
+			if (connection.status !== "pending") throw refuse("The saved agent is already claimed, connected or disconnected. Its credential was not changed. Inspect it in the app; do not automatically reconnect it.");
+			if (!params.continueSetup) throw refuse(`Recovered ${state.address}. Run this exact command with --continue-setup to explicitly obtain one pending-only invitation.`);
+			state = {
+				...state,
+				continueAttempted: true
+			};
+			writeMailJson(path, state);
+			try {
+				const response = await fetchImpl(`${apiBaseUrl}/agent-connections/${encodeURIComponent(connection.address)}/invitation`, {
+					method: "POST",
+					redirect: "error",
+					signal: AbortSignal.timeout(25e3),
+					headers: {
+						authorization: `Bearer ${credentials.access_token}`,
+						"content-type": "application/json",
+						accept: "application/json"
+					},
+					body: JSON.stringify({ pending_only: true })
+				});
+				if (response.status !== 200) {
+					if (plainRecord(plainRecord(await boundedJson(response, "pending setup continuation"))?.error)?.code === "connection_already_claimed") throw refuse("This agent was claimed before Continue setup. Its credential was not changed. Inspect it in the app.");
+					throw new Error();
+				}
+				payload = await boundedJson(response);
+			} catch (error) {
+				if (error instanceof AgentConnectionSetupError) throw error;
+				throw refuse("Continue setup has an uncertain outcome. Inspect the saved agent in the app; do not repeat it and invalidate another invitation.");
+			}
+		}
+		const invitation = invitationFrom(payload, state, (params.now ?? Date.now)());
+		state = {
+			...state,
+			phase: "setup_attempted",
+			invitationHash: invitation.hash,
+			ownerAddress: invitation.ownerAddress
+		};
+		writeMailJson(path, state);
+		return finish(resolvedEnrollment(state), false, invitation.url);
+	} finally {
+		release();
+	}
+}
+//#endregion
+//#region src/oclif/machine-session.ts
+var machine_session_exports = /* @__PURE__ */ __exportAll({
+	MACHINE_RUNTIMES: () => MACHINE_RUNTIMES,
+	OMP_MAIN: () => OMP_MAIN,
+	agentConnectionState: () => agentConnectionState,
+	agentInfoForSession: () => agentInfoForSession,
+	connectedProfilesForSession: () => connectedProfilesForSession,
+	defaultSessionName: () => defaultSessionName,
+	endSession: () => endSession,
+	headlessClaudeRun: () => headlessClaudeRun,
+	ompProcessSession: () => ompProcessSession,
+	pendingSessionDisconnects: () => pendingSessionDisconnects,
+	psProcessInfo: () => psProcessInfo,
+	readClaudeHookInput: () => readClaudeHookInput,
+	registerSession: () => registerSession,
+	retryPendingDisconnects: () => retryPendingDisconnects,
+	revokeWithMemberLogin: () => revokeWithMemberLogin,
+	runDetached: () => runDetached,
+	runtimeSessionId: () => runtimeSessionId,
+	workspaceName: () => workspaceName
+});
+const MACHINE_RUNTIMES = [
+	"claude",
+	"codex",
+	"omp"
+];
+function sessionRecordPath(configDir, session) {
+	return join(configDir, "machine", "sessions", `${session}.json`);
+}
+function readSessionRecord(configDir, session) {
+	try {
+		const value = readMailJson(sessionRecordPath(configDir, session));
+		if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+		const row = value;
+		if (row.version !== 1 || row.session !== session || typeof row.profile !== "string" || typeof row.name !== "string" || !MACHINE_RUNTIMES.includes(row.runtime) || row.createdBy !== "session-register" && row.createdBy !== "existing") return null;
+		return {
+			version: 1,
+			runtime: row.runtime,
+			session,
+			profile: row.profile,
+			name: row.name,
+			createdBy: row.createdBy,
+			address: typeof row.address === "string" ? row.address : null,
+			agentInfo: row.agentInfo === "created" || row.agentInfo === "already_present" ? row.agentInfo : null,
+			registeredAt: typeof row.registeredAt === "string" ? row.registeredAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+			endedAt: typeof row.endedAt === "string" ? row.endedAt : null,
+			disconnect: row.disconnect === "done" || row.disconnect === "pending" || row.disconnect === "pending_enrollment" ? row.disconnect : typeof row.endedAt === "string" ? "done" : null
+		};
+	} catch {
+		return null;
+	}
+}
+function saveSessionRecord(configDir, row) {
+	writeMailJson(sessionRecordPath(configDir, row.session), row);
+}
+/** The repository (or directory) a session works in, for its default name. */
+function workspaceName(cwd) {
+	let current = resolve(cwd);
+	for (let depth = 0; depth < 64; depth++) {
+		if (existsSync(join(current, ".git"))) return basename(current);
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return basename(resolve(cwd));
+}
+function defaultSessionName(runtime, cwd) {
+	return Array.from(`${runtime}-${workspaceName(cwd)}`).filter((character) => {
+		const code = character.charCodeAt(0);
+		return code >= 32 && code !== 127;
+	}).join("").replace(/\s+/g, " ").trim().slice(0, 80).trim() || runtime;
+}
+/** A short private role note. Never transcript content. */
+function agentInfoForSession(runtime, cwd) {
+	return `${runtime === "claude" ? "Claude Code" : runtime === "codex" ? "Codex" : "omp"} coding session. Repository: ${workspaceName(cwd)}. Directory: ${basename(resolve(cwd))}.`.slice(0, 1e3);
+}
+function psProcessInfo(pid) {
+	try {
+		const line = execFileSync("ps", [
+			"-o",
+			"ppid=,lstart=,command=",
+			"-p",
+			String(pid)
+		], {
+			encoding: "utf8",
+			timeout: 2e3,
+			env: {
+				...process.env,
+				LC_ALL: "C"
+			},
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+		const match = /^(\d+)\s+(\w{3}\s+\w{3}\s+\d+\s+\d\d:\d\d:\d\d\s+\d{4})\s+(.*)$/.exec(line);
+		if (!match) return null;
+		return {
+			ppid: Number(match[1]),
+			started: match[2] ?? "",
+			command: match[3] ?? ""
+		};
+	} catch {
+		return null;
+	}
+}
+const OMP_MAIN = /(?:^|[\s/\\])omp(?:\s|$)|pi-coding-agent[\\/]dist[\\/]cli\.js(?:\s|$)/;
+/**
+* omp does not expose a session ID to the commands it runs. Use one generated
+* ID per running omp process, keyed by its PID and start time so a reused PID
+* never inherits another process's identity. A command reached through one of
+* omp's shared worker processes gets no ID rather than a guessed one.
+*/
+function ompProcessSession(configDir, options = {}) {
+	if ((options.platform ?? process.platform) === "win32") return null;
+	const info = options.processInfo ?? psProcessInfo;
+	let pid = options.startPid ?? process.ppid;
+	for (let hop = 0; hop < 16 && pid > 1; hop++) {
+		const row = info(pid);
+		if (!row) return null;
+		if (row.command.includes("__omp_worker")) return null;
+		if (OMP_MAIN.test(row.command)) {
+			const key = createHash("sha256").update(`${pid}\0${row.started}`).digest("hex").slice(0, 32);
+			const directory = join(configDir, "machine", "omp-processes");
+			const path = join(directory, `${key}.json`);
+			privateMailDirectory(directory, true);
+			try {
+				const fd = openSync(path, "wx", 384);
+				try {
+					writeFileSync(fd, `${JSON.stringify({
+						version: 1,
+						session: randomUUID()
+					})}\n`);
+					fsyncSync(fd);
+				} finally {
+					closeSync(fd);
+				}
+			} catch (error) {
+				if (error.code !== "EEXIST") return null;
+			}
+			const saved = readMailJson(path);
+			return typeof saved?.session === "string" && SESSION_UUID.test(saved.session) ? saved.session : null;
+		}
+		pid = row.ppid;
+	}
+	return null;
+}
+/** The session this runtime says the command is running in. */
+function runtimeSessionId(runtime, env, configDir, ompSession = ompProcessSession) {
+	return (runtime === "claude" ? env.CLAUDE_CODE_SESSION_ID : runtime === "codex" ? env.CODEX_THREAD_ID?.trim() || env.CODEX_SESSION_ID : ompSession(configDir))?.trim() || null;
+}
+/**
+* Claude sets CLAUDE_CODE_ENTRYPOINT to "cli" for an interactive session and
+* to "sdk-cli" for `claude -p`; SDK hosts set "sdk-ts" or "sdk-py", and the
+* GitHub action and MCP server modes have their own values. Those runs are
+* not sessions a person works in, so they get no address. Any other or
+* missing value is treated as interactive.
+*/
+const HEADLESS_CLAUDE_ENTRYPOINTS = new Set([
+	"sdk-cli",
+	"sdk-ts",
+	"sdk-py",
+	"claude-code-github-action",
+	"mcp"
+]);
+function headlessClaudeRun(env) {
+	return HEADLESS_CLAUDE_ENTRYPOINTS.has(env.CLAUDE_CODE_ENTRYPOINT?.trim() ?? "");
+}
+const HEADLESS_DETAIL = "This is a non-interactive Claude run (CLAUDE_CODE_ENTRYPOINT), so no address is used for it.";
+/** Read the connection's own record with its credential. */
+async function agentConnectionState(profile, fetchImpl = fetch, timeoutMs = 5e3) {
+	try {
+		const response = await fetchImpl(`${profile.api_base_url}/agent-connections/me`, {
+			method: "GET",
+			redirect: "error",
+			signal: AbortSignal.timeout(timeoutMs),
+			headers: {
+				authorization: `Bearer ${profile.api_key}`,
+				accept: "application/json"
+			}
+		});
+		if (response.status === 401 || response.status === 403) {
+			await response.body?.cancel().catch(() => void 0);
+			return "rejected";
+		}
+		if (response.status !== 200) {
+			await response.body?.cancel().catch(() => void 0);
+			return "unavailable";
+		}
+		const text = await response.text();
+		if (text.length > 65536) return "unavailable";
+		const body = JSON.parse(text);
+		const connection = body?.data?.connection;
+		if (body?.success !== true || typeof connection?.address !== "string" || connection.address.toLowerCase() !== profile.agent_address.toLowerCase()) return "unavailable";
+		if (connection.status === "connected") return "connected";
+		if (connection.status === "revoked") return "revoked";
+		if (connection.status === "claimed" || connection.status === "pending") return "pending";
+		return "unavailable";
+	} catch {
+		return "unavailable";
+	}
+}
+function receiverMode(setupDirectory) {
+	try {
+		const saved = readMailJson(join(setupDirectory, "setup.json"));
+		if (!saved) return null;
+		return saved.receiverMode === "external" ? "external" : "native";
+	} catch {
+		return null;
+	}
+}
+/** Serialize every read-modify-write of one session's record. */
+async function withRecordLock(configDir, session, action) {
+	const directory = join(configDir, "machine", "sessions");
+	privateMailDirectory(directory, true);
+	let release;
+	for (let attempt = 0; attempt < 200 && !release; attempt++) try {
+		release = acquireListenLock(directory, `session-record-${session}`);
+	} catch {
+		await setTimeout$1(50);
+	}
+	if (!release) throw new ListenStateError("The session record is locked by another run.");
+	try {
+		return await action();
+	} finally {
+		release();
+	}
+}
+/** Read, change and save one record under its lock. Returns the saved record. */
+function updateSessionRecord(configDir, session, change) {
+	return withRecordLock(configDir, session, () => {
+		const current = readSessionRecord(configDir, session);
+		const next = change(current);
+		if (next && next !== current) saveSessionRecord(configDir, next);
+		return next ?? current;
+	});
+}
+/** The address an interrupted enrollment saved, when there is one. */
+function enrollmentAddress(configDir, profileName) {
+	try {
+		const state = readMailJson(join(agentProfileDirectory(configDir, profileName), "enrollment", "state.json"), 65536);
+		if (state === null) return {
+			exists: false,
+			address: null
+		};
+		return {
+			exists: true,
+			address: typeof state.address === "string" ? state.address : null
+		};
+	} catch {
+		return {
+			exists: true,
+			address: null
+		};
+	}
+}
+/**
+* Saved profiles, other than the session's own, whose setup says they were
+* connected for this exact session. Sorted for a stable choice.
+*/
+function profilesBoundToSession(configDir, sessionId, ownProfile, mode) {
+	let names;
+	try {
+		names = readdirSync(join(agentProfilesDirectory(configDir), "profiles"));
+	} catch {
+		return [];
+	}
+	const bound = [];
+	for (const name of names.sort()) {
+		if (name === ownProfile) continue;
+		try {
+			const setup = readMailJson(join(agentProfileDirectory(configDir, name), "setup.json"));
+			const saved = setup?.receiverMode === void 0 ? "native" : setup.receiverMode;
+			if (typeof setup?.session !== "string" || setup.session.toLowerCase() !== sessionId || saved !== mode) continue;
+			const profile = loadConnectedAgentProfile(configDir, name);
+			if (profile) bound.push({
+				name,
+				profile
+			});
+		} catch {}
+	}
+	return bound;
+}
+/**
+* Every saved profile that still holds a credential and is bound to this
+* session: the session's own `session-<id>` profile, the profile its session
+* record names, and any profile whose setup names the session, in any
+* receiver mode. Mail to any of them wakes the session, so a second one
+* splits its mail across two addresses. Offline and read-only.
+*/
+function connectedProfilesForSession(configDir, session, exclude) {
+	const sessionId = session.trim().toLowerCase();
+	if (!SESSION_UUID.test(sessionId)) return [];
+	const candidates = new Set([`session-${sessionId}`]);
+	const record = readSessionRecord(configDir, sessionId);
+	if (record) candidates.add(record.profile);
+	try {
+		for (const name of readdirSync(join(agentProfilesDirectory(configDir), "profiles")).sort()) try {
+			const setup = readMailJson(join(agentProfileDirectory(configDir, name), "setup.json"));
+			if (typeof setup?.session === "string" && setup.session.toLowerCase() === sessionId) candidates.add(name);
+		} catch {}
+	} catch {}
+	const bound = [];
+	for (const name of [...candidates].sort()) {
+		if (name === exclude) continue;
+		try {
+			const profile = loadConnectedAgentProfile(configDir, name);
+			if (profile && !existsSync(join(agentProfileDirectory(configDir, name), `disconnected-${profile.invitation_hash}.json`))) bound.push({
+				profile: name,
+				address: profile.agent_address
+			});
+		} catch {}
+	}
+	return bound;
+}
+/** `agent disconnect` already confirmed revocation of this profile's credential. */
+function disconnectConfirmedLocally(configDir, profileName) {
+	try {
+		return readdirSync(agentProfileDirectory(configDir, profileName)).some((name) => /^disconnected-[a-f0-9]{64}\.json$/.test(name));
+	} catch {
+		return false;
+	}
+}
+/**
+* Revoke a connection by address with the saved member login, for a session
+* whose local credential is gone. True only when Primitive confirms it.
+*/
+async function revokeWithMemberLogin(configDir, address, fetchImpl = fetch) {
+	try {
+		const saved = loadCliCredentials(configDir);
+		if (!saved) return false;
+		const credentials = await refreshStoredCliCredentials({
+			apiBaseUrl: saved.api_base_url,
+			configDir,
+			credentials: saved,
+			fetch: fetchImpl
+		});
+		const response = await fetchImpl(`${credentials.api_base_url}/agent-connections/${encodeURIComponent(address)}`, {
+			method: "DELETE",
+			redirect: "error",
+			signal: AbortSignal.timeout(15e3),
+			headers: {
+				authorization: `Bearer ${credentials.access_token}`,
+				accept: "application/json"
+			}
+		});
+		if (response.status !== 200) {
+			await response.body?.cancel().catch(() => void 0);
+			return false;
+		}
+		const text = await response.text();
+		if (text.length > 65536) return false;
+		const body = JSON.parse(text);
+		return body?.success === true && body.data?.connection?.address === address && body.data.connection.status === "revoked";
+	} catch {
+		return false;
+	}
+}
+/** Enrollment saves its state before any request, so a quiet record this old created nothing. */
+const ENROLLMENT_SETTLED_MS = 10 * 6e4;
+async function disconnectSessionAgent(configDir, record, deps, env, fetchImpl, enrollmentSettled = false) {
+	try {
+		if (loadConnectedAgentProfile(configDir, record.profile)) {
+			await deps.disconnect({
+				configDir,
+				profileName: record.profile,
+				fetch: fetchImpl,
+				env
+			});
+			return "done";
+		}
+		if (disconnectConfirmedLocally(configDir, record.profile)) return "done";
+		const enrollment = enrollmentAddress(configDir, record.profile);
+		const address = record.address ?? enrollment.address;
+		if (!address) {
+			if (enrollment.exists) return "pending";
+			return enrollmentSettled || Date.now() - Date.parse(record.registeredAt) > ENROLLMENT_SETTLED_MS ? "done" : "pending_enrollment";
+		}
+		return await deps.revokeByAddress(configDir, address, fetchImpl) ? "done" : "pending";
+	} catch {
+		return "pending";
+	}
+}
+async function finishSessionDisconnect(configDir, record, deps, env, fetchImpl, enrollmentSettled = false) {
+	const outcome = await disconnectSessionAgent(configDir, record, deps, env, fetchImpl, enrollmentSettled);
+	return (await updateSessionRecord(configDir, record.session, (current) => !current || current.disconnect === "done" || current.disconnect === outcome ? current : {
+		...current,
+		disconnect: outcome
+	}))?.disconnect === "done" ? "done" : outcome;
+}
+const RECEIVING = {
+	claude: "external_hook",
+	codex: "native",
+	omp: "unsupported"
+};
+function withDefined(defaults, overrides) {
+	return {
+		...defaults,
+		...Object.fromEntries(Object.entries(overrides ?? {}).filter(([, value]) => value !== void 0))
+	};
+}
+const HELD_DETAIL = "This session already receives as another connected profile, so this profile's receive hooks were not added. Run `primitive machine doctor --fix --profile <profile>` to bind it deliberately.";
+const ENDED_DETAIL = "This session ended, so its agent was disconnected. A new address is never created for the same session.";
+const ENDED_PENDING_DETAIL = "This session ended, but disconnecting its agent has not been confirmed yet; `primitive machine doctor --fix` retries it.";
+/**
+* Give this session an address once. Safe to run on every start and resume:
+* a session already bound to a profile is only re-verified, and a session
+* whose agent was disconnected or removed is never given a second address.
+* Never throws; every failure is a status.
+*/
+async function registerSession(options) {
+	const env = options.env ?? process.env;
+	const deps = withDefined({
+		enroll: enrollAgent,
+		installClaudeHook: installClaudeWakeHook,
+		seedAgentInfo: (configDir, profileName, value) => seedAgentInfoNote(configDir, profileName, value, options.fetch),
+		connectionState: (profile) => agentConnectionState(profile, options.fetch),
+		ompSession: ompProcessSession,
+		now: () => /* @__PURE__ */ new Date(),
+		disconnect: disconnectAgent,
+		revokeByAddress: revokeWithMemberLogin
+	}, options.dependencies);
+	const runtime = options.runtime;
+	const base = {
+		runtime,
+		session: null,
+		profile: null,
+		address: null,
+		receiving: null
+	};
+	if (runtime === "claude" && headlessClaudeRun(env)) return {
+		...base,
+		status: "skipped_headless",
+		detail: HEADLESS_DETAIL
+	};
+	let session;
+	try {
+		session = options.session?.trim() || runtimeSessionId(runtime, env, options.configDir, deps.ompSession);
+	} catch {
+		session = null;
+	}
+	if (!session) return {
+		...base,
+		status: "no_session",
+		detail: runtime === "omp" ? "omp does not expose a session ID to commands, and no running omp process was found. Pass --session." : `No ${runtime === "claude" ? "CLAUDE_CODE_SESSION_ID" : "CODEX_THREAD_ID"} in this environment. Pass --session.`
+	};
+	if (!SESSION_UUID.test(session)) return {
+		...base,
+		status: "failed",
+		detail: "The session ID is not a UUID. Nothing was changed."
+	};
+	const sessionId = session.toLowerCase();
+	const ownProfile = `session-${sessionId}`;
+	let profileName = ownProfile;
+	try {
+		const saved = readSessionRecord(options.configDir, sessionId);
+		if (saved?.createdBy === "existing" && saved.profile !== ownProfile) profileName = agentProfileName(saved.profile);
+		else if (!saved && !loadConnectedAgentProfile(options.configDir, ownProfile) && !enrollmentAddress(options.configDir, ownProfile).exists) {
+			let offline = false;
+			for (const candidate of profilesBoundToSession(options.configDir, sessionId, ownProfile, runtime === "codex" ? "native" : "external")) {
+				const state = await deps.connectionState(candidate.profile);
+				if (state === "connected") {
+					profileName = candidate.name;
+					offline = false;
+					break;
+				}
+				if (state === "unavailable") offline = true;
+			}
+			if (offline) return {
+				...base,
+				session: sessionId,
+				receiving: RECEIVING[runtime],
+				status: "offline",
+				detail: "A saved profile is connected for this session, but its status could not be checked right now. No new address was created."
+			};
+		}
+	} catch {
+		profileName = ownProfile;
+	}
+	const reused = profileName !== ownProfile;
+	const known = {
+		...base,
+		session: sessionId,
+		profile: profileName
+	};
+	const cwd = resolve(options.cwd ?? process.cwd());
+	const ended = async (current, enrolledNow = false) => {
+		const outcome = current.disconnect === "done" && !enrolledNow ? "done" : await finishSessionDisconnect(options.configDir, current, deps, env, options.fetch, enrolledNow);
+		return {
+			...known,
+			address: current.address,
+			status: "ended",
+			detail: outcome === "done" ? ENDED_DETAIL : ENDED_PENDING_DETAIL
+		};
+	};
+	const newRecord = (createdBy, address) => ({
+		version: 1,
+		runtime,
+		session: sessionId,
+		profile: profileName,
+		name: defaultSessionName(runtime, cwd),
+		createdBy,
+		address,
+		agentInfo: null,
+		registeredAt: deps.now().toISOString(),
+		endedAt: null,
+		disconnect: null
+	});
+	try {
+		let record = readSessionRecord(options.configDir, sessionId);
+		if (record?.endedAt) return await ended(record);
+		const finishAgentInfo = async () => {
+			if (reused || record?.agentInfo) return;
+			const seeded = await deps.seedAgentInfo(options.configDir, profileName, agentInfoForSession(runtime, cwd));
+			if (seeded !== "created" && seeded !== "already_present") return;
+			record = await updateSessionRecord(options.configDir, sessionId, (current) => current ? {
+				...current,
+				agentInfo: seeded
+			} : current);
+		};
+		const claudeHook = (agentAddress) => {
+			const outcome = deps.installClaudeHook({
+				cliPath: options.cliPath,
+				configDir: options.configDir,
+				profileName,
+				agentAddress,
+				sessionId,
+				env,
+				yieldToOtherProfiles: true
+			});
+			return outcome === "installed_unverified" ? "installed" : outcome === "held_for_other_profile" ? "held" : "failed";
+		};
+		const installHook = (profile) => runtime !== "claude" || receiverMode(agentProfileDirectory(options.configDir, profileName)) !== "external" ? "installed" : claudeHook(profile.agent_address);
+		const existing = loadConnectedAgentProfile(options.configDir, profileName);
+		if (existing) {
+			record = await updateSessionRecord(options.configDir, sessionId, (current) => current ?? newRecord("existing", existing.agent_address));
+			if (!record) throw new Error("session record unavailable");
+			if (record.endedAt) return await ended(record);
+			const state = await deps.connectionState(existing);
+			const withAddress = {
+				...known,
+				address: existing.agent_address
+			};
+			if (state === "revoked" || state === "rejected") return {
+				...withAddress,
+				status: "revoked",
+				detail: "This session's agent was disconnected in Primitive. No new address was created. `primitive machine doctor --fix` removes the stale local profile."
+			};
+			if (state === "unavailable") return {
+				...withAddress,
+				receiving: RECEIVING[runtime],
+				status: "offline",
+				detail: "This session already has an address; its status could not be checked right now."
+			};
+			if (state === "pending" && record.createdBy !== "session-register") return {
+				...withAddress,
+				status: "pending",
+				detail: "This session's agent is waiting for pairing confirmation. Finish it with the command that started it."
+			};
+			if (state === "connected") {
+				const hooked = installHook(existing);
+				await finishAgentInfo();
+				return {
+					...withAddress,
+					receiving: RECEIVING[runtime],
+					status: "already_registered",
+					detail: hooked === "installed" ? "This session is already connected." : hooked === "held" ? HELD_DETAIL : "This session is already connected, but its receive hook could not be installed. Run `primitive machine doctor`."
+				};
+			}
+		} else if (record?.address && record.createdBy === "session-register" && !enrollmentAddress(options.configDir, profileName).exists || record?.createdBy === "existing") return {
+			...known,
+			address: record.address,
+			status: "removed",
+			detail: "This session's local profile was removed. No new address was created for the same session."
+		};
+		let credentials;
+		try {
+			credentials = loadCliCredentials(options.configDir);
+		} catch {
+			credentials = null;
+		}
+		if (!credentials) return {
+			...known,
+			status: "not_logged_in",
+			detail: "No saved member login on this machine. Run `primitive signin`, then start the session again."
+		};
+		record = await updateSessionRecord(options.configDir, sessionId, (current) => current ?? newRecord("session-register", null));
+		if (!record) throw new Error("session record unavailable");
+		if (record.endedAt) return await ended(record);
+		const enrollEnv = { ...env };
+		delete enrollEnv.PRIMITIVE_AGENT_PROFILE;
+		delete enrollEnv.PRIMITIVE_API_KEY;
+		delete enrollEnv.PRIMITIVE_KEY;
+		if (runtime === "claude" && options.trustedSession) enrollEnv.CLAUDE_CODE_SESSION_ID = sessionId;
+		let result = null;
+		let enrollError = null;
+		try {
+			result = await deps.enroll({
+				configDir: options.configDir,
+				session: sessionId,
+				name: record.name,
+				receiverMode: runtime === "codex" ? "native" : "external",
+				contactRequests: false,
+				env: enrollEnv,
+				fetch: options.fetch,
+				...runtime === "omp" ? { preflight: async () => void 0 } : {}
+			});
+		} catch (error) {
+			if (error instanceof ListenStateError) throw error;
+			enrollError = error;
+		}
+		let created = result?.identity.agentAddress ?? null;
+		if (!created) try {
+			created = loadConnectedAgentProfile(options.configDir, profileName)?.agent_address ?? enrollmentAddress(options.configDir, profileName).address;
+		} catch {
+			created = enrollmentAddress(options.configDir, profileName).address;
+		}
+		record = await updateSessionRecord(options.configDir, sessionId, (current) => current && created && current.address !== created ? {
+			...current,
+			address: created
+		} : current);
+		if (!record) throw new Error("session record unavailable");
+		if (record.endedAt) return await ended(record, true);
+		if (enrollError || !result) throw enrollError;
+		const address = result.identity.agentAddress;
+		const submitted = verificationReplySubmitted(result.verification.state);
+		const status = result.connection.status;
+		let hooked = "installed";
+		if (runtime === "claude" && submitted && status !== "owner_inactive") hooked = claudeHook(address);
+		if (status === "connected") await finishAgentInfo();
+		const withAddress = {
+			...known,
+			address,
+			receiving: RECEIVING[runtime]
+		};
+		const name = result.name ?? record.name;
+		if (status === "connected") return {
+			...withAddress,
+			status: "registered",
+			name,
+			nameIsDefault: name === record.name,
+			detail: hooked === "installed" ? `Connected as ${address}.` : hooked === "held" ? `Connected as ${address}. ${HELD_DETAIL}` : `Connected as ${address}, but the receive hook could not be installed. Run \`primitive machine doctor\`.`
+		};
+		if (status === "revoked" || status === "owner_inactive") return {
+			...withAddress,
+			status,
+			detail: status === "revoked" ? "The new agent was disconnected in Primitive before setup finished." : "The member who owns this login is no longer active in the organization."
+		};
+		return {
+			...withAddress,
+			status: "pending",
+			detail: "The address exists and pairing is not confirmed yet. The next session start resumes it; no second address is created."
+		};
+	} catch (error) {
+		if (error instanceof ListenStateError) return {
+			...known,
+			status: "busy",
+			detail: "Another registration for this session is already running."
+		};
+		return {
+			...known,
+			status: "failed",
+			detail: error instanceof AgentConnectionSetupError ? error.message : "Registration stopped before finishing. The session continues normally; the next start resumes it."
+		};
+	}
+}
+/**
+* Disconnect the agent a session got from `session-register`. Agents
+* connected any other way are left alone. The end is recorded first, under
+* the record's lock, so a registration still enrolling sees it and
+* disconnects the agent it creates. Never throws.
+*/
+async function endSession(options) {
+	const env = options.env ?? process.env;
+	const deps = withDefined({
+		disconnect: disconnectAgent,
+		revokeByAddress: revokeWithMemberLogin,
+		now: () => /* @__PURE__ */ new Date()
+	}, options.dependencies);
+	const runtime = options.runtime;
+	const base = {
+		runtime,
+		session: null,
+		address: null
+	};
+	if (runtime === "claude" && headlessClaudeRun(env)) return {
+		...base,
+		status: "skipped_headless",
+		detail: HEADLESS_DETAIL
+	};
+	let session;
+	try {
+		session = options.session?.trim() || runtimeSessionId(runtime, env, options.configDir, () => null);
+	} catch {
+		session = null;
+	}
+	if (!session || !SESSION_UUID.test(session)) return {
+		...base,
+		status: "no_session",
+		detail: "No session ID was given or found. Nothing was changed."
+	};
+	const sessionId = session.toLowerCase();
+	try {
+		let managed = false;
+		let alreadyDone = false;
+		const record = await updateSessionRecord(options.configDir, sessionId, (current) => {
+			if (!current || current.createdBy !== "session-register") return current;
+			managed = true;
+			if (current.endedAt && current.disconnect === "done") {
+				alreadyDone = true;
+				return current;
+			}
+			return {
+				...current,
+				endedAt: current.endedAt ?? deps.now().toISOString(),
+				disconnect: "pending"
+			};
+		});
+		const known = {
+			...base,
+			session: sessionId,
+			address: record?.address ?? null
+		};
+		if (!record || !managed) return {
+			...known,
+			status: "not_managed",
+			detail: "This session's agent was not created by `agent session-register`, so it was left connected."
+		};
+		if (alreadyDone) return {
+			...known,
+			status: "already_ended",
+			detail: "This session's agent was already disconnected."
+		};
+		return await finishSessionDisconnect(options.configDir, record, deps, env, options.fetch) === "done" ? {
+			...known,
+			status: "disconnected",
+			detail: "This session's agent was disconnected."
+		} : {
+			...known,
+			status: "disconnect_pending",
+			detail: "The session is marked ended, but disconnecting its agent is not confirmed yet. The next `primitive machine doctor --fix` (or a registration still finishing) retries it."
+		};
+	} catch (error) {
+		return {
+			...base,
+			session: sessionId,
+			status: "failed",
+			detail: error instanceof AgentDisconnectError ? error.message : "Disconnect did not finish. The agent was left as it was."
+		};
+	}
+}
+/** Ended sessions whose agent disconnect still needs confirming. */
+function pendingSessionDisconnects(configDir) {
+	const directory = join(configDir, "machine", "sessions");
+	let names;
+	try {
+		names = readdirSync(directory);
+	} catch {
+		return [];
+	}
+	return names.flatMap((name) => {
+		const match = /^([0-9a-f-]{36})\.json$/.exec(name);
+		if (!match?.[1]) return [];
+		const record = readSessionRecord(configDir, match[1]);
+		return record?.endedAt && (record.disconnect === "pending" || record.disconnect === "pending_enrollment") ? [record] : [];
+	});
+}
+/** Retry every pending disconnect. Returns how many are now confirmed. */
+async function retryPendingDisconnects(configDir, options = {}) {
+	const deps = withDefined({
+		disconnect: disconnectAgent,
+		revokeByAddress: revokeWithMemberLogin
+	}, options.dependencies);
+	let done = 0;
+	for (const record of pendingSessionDisconnects(configDir)) if (await finishSessionDisconnect(configDir, record, deps, options.env ?? process.env, options.fetch) === "done") done++;
+	return done;
+}
+/** Read Claude's hook JSON from stdin within a short budget. */
+async function readClaudeHookInput(stdin, timeoutMs = 2e3) {
+	let input = "";
+	const read = (async () => {
+		for await (const chunk of stdin) {
+			input += String(chunk);
+			if (input.length > 65536) return false;
+		}
+		return true;
+	})().catch(() => false);
+	let timer;
+	const complete = await Promise.race([read, new Promise((done) => {
+		timer = setTimeout(() => done(false), timeoutMs);
+		timer.unref();
+	})]);
+	if (timer) clearTimeout(timer);
+	if (!complete) return null;
+	try {
+		const value = JSON.parse(input);
+		if (typeof value?.session_id !== "string" || !SESSION_UUID.test(value.session_id)) return null;
+		return {
+			sessionId: value.session_id.toLowerCase(),
+			cwd: typeof value.cwd === "string" && value.cwd ? value.cwd : null
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Run the real work in a detached process so a hook never holds up the
+* session; wait for it only up to the budget.
+*/
+async function runDetached(params) {
+	try {
+		const child = spawn(params.node, [params.entry, ...params.args], {
+			detached: true,
+			stdio: "ignore",
+			env: params.env,
+			...params.cwd && existsSync(params.cwd) ? { cwd: params.cwd } : {}
+		});
+		child.unref();
+		return await new Promise((done) => {
+			const timer = setTimeout(() => done("detached"), params.waitMs);
+			child.once("error", () => {
+				clearTimeout(timer);
+				done("failed");
+			});
+			child.once("exit", () => {
+				clearTimeout(timer);
+				done("finished");
+			});
+		});
+	} catch {
+		return "failed";
+	}
+}
+//#endregion
+export { describeSessionHookItem as $, NetworkAdmissionPendingError as A, runContactRequest as B, pollCheckCommand as C, verificationReplySubmitted as D, RECEIVER_MODES as E, addressNoteTarget as F, receiverStatusCommand as G, agentInvitationHash as H, runAddressNotesRequest as I, recordHookMailCheck as J, savedReceiver as K, ContactsApiError as L, evaluateContactPolicy as M, canonicalContactSelector as N, ContactPolicyReadRetryError as O, AddressNotesApiError as P, describeSessionHookChange as Q, contactAddress as R, invitationProfileName as S, withOwnerMemberAddress as T, connectAgent as U, agentConnectionStatus as V, readAgentInvitation as W, claudeConfigDir as X, boundSessionProfiles as Y, currentCliLocation as Z, disconnectAgent as _, endSession as a, samePath as at, identitySuggestions as b, pendingSessionDisconnects as c, inspectManagedBlock as ct, registerSession as d, upsertManagedBlock as dt, ephemeralCliReason as et, retryPendingDisconnects as f, writeManagedFile as ft, AgentDisconnectError as g, enrollmentResumes as h, connectedProfilesForSession as i, repairClaudeHooks as it, createNotificationContactPolicy as j, NETWORK_ADMISSION_PENDING_RETRY_MS as k, psProcessInfo as l, jsonIndentation as lt, enrollAgent as m, OMP_MAIN as n, inspectClaudeHooks as nt, headlessClaudeRun as o, writeClaudeSettings as ot, runDetached as p, installClaudeWakeHook as q, agentConnectionState as r, readClaudeSettings as rt, machine_session_exports as s, MachineFileError as st, MACHINE_RUNTIMES as t, findOnPath as tt, readClaudeHookInput as u, readManagedFile as ut, cliInvocation as v, runAgentConnect as w, defaultAgentProfileName as x, generatedAgentName as y, contactAgentAddress as z };