primcli 1.37.0 → 1.38.0

package/dist/oclif/index.js

@@ -4,16 +4,16 @@ import { $ as putAgentContactPolicy, A as getRepeatingSend, B as listEmails, C a
 import { A as saveActiveChatState, C as resolveCliAuth, D as deleteChatState, E as chatStatePath, O as loadActiveChatState, T as saveSignupCredentials, _ as deleteCliCredentials, a as normalizeCliEnvironmentName, b as hasStoredCliLogin, c as resolveConfigEnvironment, g as credentialsPath, h as credentialsLockPath, i as loadCliConfig, j as PrimitiveApiClient, k as loadChatConversationByLocalId, l as saveCliConfig, m as cliAccessTokenExpiresAt, n as deleteCliConfig, o as redactCliEnvironment, p as acquireCliCredentialsLock, r as emptyCliConfig, s as removeCliEnvironment, u as upsertCliEnvironment, v as deleteCliCredentialsLock, w as saveCliCredentials, x as loadCliCredentials, y as detectPrimitiveKeyEnvMisname } from "../cli-config-UOlrfcPz.js";
 import { S as resolveListenSubscription, _ as acquireListenLock, a as mailLockBusy, c as mailTime, d as readMailJson, f as removeMailFile, g as ListenStateError, h as writeMailJson, i as mailId, l as privateMailDirectory, m as withMailLock, o as mailObject, p as syncMailDirectory, r as mailAddress, s as mailString, u as privateMailPermissions, x as normalizeListenOrigin, y as listenIdentity } from "../shared-mail-files-CZqI1kj6.js";
 import { $ as extractErrorCode, A as reserveSharedMailSubscription, At as queryUsesAutomated, B as sentInThread, C as thrownErrorExitCode, Ct as AutomatedFilterUnsupportedError, D as ensureSharedMailSubscription, Dt as expectedAutomatedVerdicts, E as sharedMailScope, Et as ensureSearchReportsAutomated, F as describeWake, Ft as resolveCliApiRequestConfig, G as EventConnection, H as serverRelationship, I as displayAddress, J as pushFile, K as EventReceiverError, L as formatWakeContext, M as readConversationFollow, Mt as createAuthenticatedCliApiClient, N as otherParticipants, Nt as createCliApiClient, O as createSharedMailWaiter, Ot as hasAutomatedVerdict, P as bareAddress, Pt as refreshStoredCliCredentials, Q as createOperationCommand, R as latestOwnOutbound, S as successfulSendOutcome, St as AUTOMATED_VALUES, T as openSharedMailReceiver, Tt as automatedRejectedError, U as wakeRelationship, V as serverMuted, W as readSharedMailOwner, X as API_ERROR_CODES, Y as API_BASE_URL_FLAG_DESCRIPTION, Z as TIME_FLAG_DESCRIPTION, _ as reportSendCommandResult, _t as queryUsesAwaiting, a as assertValidIdempotencyKey, at as writeErrorWithHints, b as sentHistoryWindowStart, bt as AUTOMATED_FILTER_UNSUPPORTED_CODE, c as checkPriorReplies, ct as REPLY_STATE_UNSUPPORTED_CODE, d as formatDeletedEarlierSendNotice, dt as awaitingRejectedError, et as extractErrorPayload, f as formatPriorRepliesCheckSkipped, ft as ensureSearchReportsReplyState, g as priorRepliesThatWentOut, gt as isAwaitingRejectedError, h as formatSendRecordFailureSummary, ht as hasReplyState, i as apiResultHttpStatus, it as surfaceUnauthorizedHint, j as followEmailConversation, k as openSharedMailStore, kt as isAutomatedRejectedError, l as classifySendError, lt as ReplyStateUnsupportedError, m as formatSendFailureSummary, mt as formatRepliesCell, n as IDEMPOTENCY_KEY_FLAG_DESCRIPTION, nt as readTextFileFlag, o as buildFollowUpCommand, ot as AWAITING_FLAG_DESCRIPTION, p as formatPriorRepliesWarning, pt as formatAwaitingCell, q as pullFile, r as SEND_OUTCOME_HELP, rt as runWithTiming, s as buildThrownSendFailureEnvelope, st as AWAITING_VALUES, t as sendSignal, tt as formatErrorPayload, u as deriveSendIdempotencyKey, ut as assertAwaitingFilterRows, v as sendIdentityFields, vt as formatAlreadySentNotice, w as reconcileChatSend, wt as assertAutomatedVerdict, x as serializeErrorPayload, xt as AUTOMATED_FLAG_DESCRIPTION, y as sendOutcomeExitCode, yt as writeIdempotentReplayBannerIfReplay, z as readThreadContext } from "../signal-command-CKaEqXro.js";
-import { _ as NativeSessionNotLoadedError, a as notificationSenders, c as NotificationRetryError, d as readConversationStatusContent, f as SESSION_UUID$1, g as NativeSessionError, h as NativeSessionDisconnectedError, i as notificationScope, l as isRoutineNotificationContent, m as defaultSessionSocket, n as installConnectSkill, o as openSessionNotifications, p as connectNativeSession, r as readBundledConnectSkill, s as notificationReceiptPage, t as detectAgentRuntime, u as notificationPartReader, v as NotificationOutcomeUnknownError } from "../connect-skill-DednypYJ.js";
+import { _ as NativeSessionDisconnectedError, a as readBundledConnectSkill, b as NotificationOutcomeUnknownError, c as openSessionNotifications, d as isRoutineNotificationContent, f as notificationPartReader, g as defaultSessionSocket, h as connectNativeSession, i as installedVersion, l as notificationReceiptPage, m as SESSION_UUID$1, n as detectAgentRuntime, o as notificationScope, p as readConversationStatusContent, r as installConnectSkill, s as notificationSenders, t as connectSkillTarget, u as NotificationRetryError, v as NativeSessionError, y as NativeSessionNotLoadedError } from "../connect-skill-HJNQC3A9.js";
 import { c as startBackgroundListen, i as backgroundListenToken, l as stopBackgroundListen, o as runBackgroundListen, r as backgroundListenStatus, u as verifyBackgroundListenTarget } from "../listen-background-Bsofqq_6.js";
 import { F as readBeforeDeadline, I as scopedChatSenderTrust, L as presenceDisposition, M as isConnectedChatCredential, N as isPlainChatReply, P as isScopedChatReply, R as readPresenceProjection, T as restoreAutoWorking, g as haltAutoWorking, h as dispatchAutoWorking, l as autoSignalEligible, m as dispatchAutoRead } from "../auto-signals-UPcJmV3j.js";
 import { t as guardJsonOutputCommands } from "../json-output-BVRgl6jf.js";
 import { Args, Command, Errors, Flags, ux } from "@oclif/core";
-import { chmodSync, closeSync, constants, existsSync, fstatSync, fsyncSync, linkSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { accessSync, chmodSync, closeSync, constants, copyFileSync, cpSync, existsSync, fstatSync, fsyncSync, linkSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { createHash, randomUUID, scryptSync } from "node:crypto";
-import path, { basename, dirname, join, relative, resolve, sep } from "node:path";
+import path, { basename, delimiter, dirname, join, relative, resolve, sep } from "node:path";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
-import { execFile, spawn } from "node:child_process";
+import { execFile, execFileSync, spawn } from "node:child_process";
 import { homedir, hostname } from "node:os";
 import { promisify } from "node:util";
 import process$1 from "node:process";
@@ -34954,10 +34954,10 @@ function isMemoryJsonValue(value, seen = /* @__PURE__ */ new Set()) {
 //#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_MARKER$1 = "primitive-pending-mail-v1";
 const PENDING_EVENT = "PostToolUse";
-const LOCK_WAIT = new Int32Array(new SharedArrayBuffer(4));
-function record$2(value) {
+const LOCK_WAIT$1 = new Int32Array(new SharedArrayBuffer(4));
+function record$4(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function claudeWakeHookStatus(options) {
@@ -34973,21 +34973,21 @@ function claudeWakeHookStatus(options) {
 		if (!SESSION_UUID$1.test(options.sessionId)) return unavailable;
 		const sessionId = options.sessionId.toLowerCase();
 		const settings = readMailJson(join(resolve(options.env?.CLAUDE_CONFIG_DIR || join(homedir(), ".claude")), "settings.json"));
-		if (!record$2(settings) || !record$2(settings.hooks)) return unavailable;
+		if (!record$4(settings) || !record$4(settings.hooks)) return unavailable;
 		const hooks = settings.hooks;
 		const owns = (event, script, marker) => {
 			const entries = hooks[event];
-			return Array.isArray(entries) && entries.some((entry) => record$2(entry) && Array.isArray(entry.hooks) && entry.hooks.some((candidate) => {
-				if (!record$2(candidate) || !Array.isArray(candidate.args)) return false;
+			return Array.isArray(entries) && entries.some((entry) => record$4(entry) && Array.isArray(entry.hooks) && entry.hooks.some((candidate) => {
+				if (!record$4(candidate) || !Array.isArray(candidate.args)) return false;
 				const args = candidate.args;
 				const offset = 2;
 				return candidate.type === "command" && candidate.command === process.execPath && args.length === 7 && typeof args[0] === "string" && basename(args[0]) === script && args[offset] === configDir && args[offset + 1] === profileName && args[offset + 2] === agentAddress && args[offset + 3] === sessionId && args[offset + 4] === marker;
 			}));
 		};
-		const installed = owns("Stop", "claude-wake.mjs", HOOK_MARKER) && owns("SessionStart", "claude-wake.mjs", HOOK_MARKER) && owns(PENDING_EVENT, "claude-pending-mail.mjs", PENDING_MARKER);
+		const installed = owns("Stop", "claude-wake.mjs", HOOK_MARKER) && owns("SessionStart", "claude-wake.mjs", HOOK_MARKER) && owns(PENDING_EVENT, "claude-pending-mail.mjs", PENDING_MARKER$1);
 		let lastFiredAt = null;
 		const fired = readMailJson(join(agentProfileDirectory(configDir, profileName), `pending-mail-${sessionId}.fired.json`));
-		if (record$2(fired) && fired.version === 1 && typeof fired.at === "string" && Number.isFinite(Date.parse(fired.at))) lastFiredAt = fired.at;
+		if (record$4(fired) && fired.version === 1 && typeof fired.at === "string" && Number.isFinite(Date.parse(fired.at))) lastFiredAt = fired.at;
 		return {
 			installed,
 			lastFiredAt,
@@ -35007,7 +35007,7 @@ function editClaudeSettings(claudeDir, edit) {
 		release = acquireListenLock(claudeDir, "primitive-claude-settings");
 		break;
 	} catch {
-		Atomics.wait(LOCK_WAIT, 0, 0, 25);
+		Atomics.wait(LOCK_WAIT$1, 0, 0, 25);
 	}
 	if (!release) return false;
 	try {
@@ -35020,7 +35020,7 @@ function editClaudeSettings(claudeDir, edit) {
 				if (!stat.isFile() || stat.size > 1048576) return false;
 				original = readFileSync(settingsPath, "utf8");
 				const parsed = JSON.parse(original);
-				if (!record$2(parsed)) return false;
+				if (!record$4(parsed)) return false;
 				settings = parsed;
 			}
 			const next = edit(settings);
@@ -35058,7 +35058,7 @@ function installClaudeWakeHook(options) {
 		const sessionId = options.sessionId.toLowerCase();
 		return editClaudeSettings(resolve((options.env ?? process.env).CLAUDE_CONFIG_DIR || join(homedir(), ".claude")), (settings) => {
 			const hooks = settings.hooks ?? {};
-			if (!record$2(hooks)) throw new Error("Invalid hook settings");
+			if (!record$4(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 hook = {
@@ -35086,26 +35086,26 @@ function installClaudeWakeHook(options) {
 					profileName,
 					agentAddress,
 					sessionId,
-					PENDING_MARKER
+					PENDING_MARKER$1
 				],
 				timeout: 10
 			};
-			const isOwnPendingHook = (candidate) => record$2(candidate) && candidate.type === "command" && candidate.command === process.execPath && Array.isArray(candidate.args) && candidate.args.length === 7 && candidate.args[0] === pendingPath && candidate.args[1] === cliPath && candidate.args[2] === configDir && candidate.args[5] === sessionId && candidate.args[6] === PENDING_MARKER;
+			const isOwnPendingHook = (candidate) => record$4(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[5] === sessionId && candidate.args[6] === PENDING_MARKER$1;
 			const isOwnHook = (candidate) => {
-				if (!record$2(candidate) || !Array.isArray(candidate.args)) return false;
-				if (candidate.command !== process.execPath || candidate.args[0] !== wrapperPath || candidate.args[1] !== cliPath || candidate.args[2] !== configDir) return false;
+				if (!record$4(candidate) || !Array.isArray(candidate.args)) return false;
+				if (typeof candidate.args[0] !== "string" || basename(candidate.args[0]) !== "claude-wake.mjs" || candidate.args[2] !== configDir) 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, agentProfileName(String(candidate.args[3]))), "setup.json"));
-					return record$2(state) && state.session === sessionId;
+					return record$4(state) && state.session === sessionId;
 				} catch {
 					return false;
 				}
 			};
 			const nextHooks = { ...hooks };
 			for (const event of WAKE_EVENTS) nextHooks[event] = [...(hooks[event] ?? []).flatMap((entry) => {
-				if (!record$2(entry) || !Array.isArray(entry.hooks)) return [entry];
+				if (!record$4(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 ? [{
@@ -35117,7 +35117,7 @@ function installClaudeWakeHook(options) {
 				hooks: [hook]
 			} : { hooks: [hook] }];
 			nextHooks[PENDING_EVENT] = [...(hooks[PENDING_EVENT] ?? []).flatMap((entry) => {
-				if (!record$2(entry) || !Array.isArray(entry.hooks)) return [entry];
+				if (!record$4(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 ? [{
@@ -35146,31 +35146,31 @@ function uninstallClaudeWakeHook(options) {
 		if (!existsSync(join(claudeDir, "settings.json"))) return true;
 		return editClaudeSettings(claudeDir, (settings) => {
 			const hooks = settings.hooks ?? {};
-			if (!record$2(hooks)) throw new Error("Invalid hook settings");
+			if (!record$4(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$2(setup) && setup.session === sessionId;
+					return record$4(setup) && setup.session === sessionId;
 				} catch {
 					return false;
 				}
 			};
 			const isOwnHook = (candidate) => {
-				if (!record$2(candidate) || !Array.isArray(candidate.args)) return false;
+				if (!record$4(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$2(candidate) || !Array.isArray(candidate.args)) return false;
+				if (!record$4(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;
+				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$1 && args.length === 7;
 			};
 			let removed = false;
 			const nextHooks = { ...hooks };
 			for (const event of WAKE_EVENTS) nextHooks[event] = (hooks[event] ?? []).flatMap((entry) => {
-				if (!record$2(entry) || !Array.isArray(entry.hooks)) return [entry];
+				if (!record$4(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;
@@ -35180,7 +35180,7 @@ function uninstallClaudeWakeHook(options) {
 				}] : [];
 			});
 			nextHooks[PENDING_EVENT] = (hooks[PENDING_EVENT] ?? []).flatMap((entry) => {
-				if (!record$2(entry) || !Array.isArray(entry.hooks)) return [entry];
+				if (!record$4(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;
@@ -35853,7 +35853,7 @@ function matchesContactSelector(input, sender) {
 }
 //#endregion
 //#region src/oclif/contact-policy.ts
-function record$1(value) {
+function record$3(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid contact policy.");
 	return value;
 }
@@ -35862,11 +35862,11 @@ function fingerprint(value) {
 	return value;
 }
 function document(value, organization) {
-	const row = record$1(value);
+	const row = record$3(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$1(value);
+		const rule = record$3(value);
 		if (typeof rule.pattern !== "string" || rule.effect !== "allow" && rule.effect !== "silence") throw new Error("Invalid contact policy rule.");
 		const pattern = canonicalContactSelector({
 			kind: "pattern",
@@ -35907,7 +35907,7 @@ function document(value, organization) {
 	};
 }
 function parseAgentContactPolicy(value, recipient) {
-	const row = record$1(value);
+	const row = record$3(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);
@@ -36858,28 +36858,7 @@ function defaults(options) {
 				env: options.env
 			});
 		},
-		async seedAgentInfo(profileName, value) {
-			const profile = loadConnectedAgentProfile(options.configDir, profileName);
-			if (!profile) return "failed";
-			const client = new PrimitiveApiClient({
-				apiKey: profile.api_key,
-				apiBaseUrl: profile.api_base_url
-			});
-			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";
-			}
-		},
+		seedAgentInfo: (profileName, value) => seedAgentInfoNote(options.configDir, profileName, value),
 		refreshOwnerMemberAddress: (profileName) => refreshOwnerMemberAddress({
 			configDir: options.configDir,
 			profileName
@@ -36902,6 +36881,30 @@ function defaults(options) {
 		}
 	};
 }
+/** 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
@@ -38210,6 +38213,853 @@ var AgentNotesDeleteCommand = class AgentNotesDeleteCommand extends Command {
 	}
 };
 //#endregion
+//#region src/oclif/machine-session.ts
+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$1.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
+		};
+	}
+}
+/** `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 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$1.test(session)) return {
+		...base,
+		status: "failed",
+		detail: "The session ID is not a UUID. Nothing was changed."
+	};
+	const sessionId = session.toLowerCase();
+	const profileName = `session-${sessionId}`;
+	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 (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 installHook = (profile) => runtime !== "claude" || receiverMode(agentProfileDirectory(options.configDir, profileName)) !== "external" || deps.installClaudeHook({
+			cliPath: options.cliPath,
+			configDir: options.configDir,
+			profileName,
+			agentAddress: profile.agent_address,
+			sessionId,
+			env
+		}) === "installed_unverified";
+		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 ? "This session is already connected." : "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 = true;
+		if (runtime === "claude" && submitted && status !== "owner_inactive") hooked = deps.installClaudeHook({
+			cliPath: options.cliPath,
+			configDir: options.configDir,
+			profileName,
+			agentAddress: address,
+			sessionId,
+			env
+		}) === "installed_unverified";
+		if (status === "connected") await finishAgentInfo();
+		const withAddress = {
+			...known,
+			address,
+			receiving: RECEIVING[runtime]
+		};
+		if (status === "connected") return {
+			...withAddress,
+			status: "registered",
+			detail: hooked ? `Connected as ${address}.` : `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$1.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$1.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
+//#region src/oclif/commands/agent-session-end.ts
+var AgentSessionEndCommand = class AgentSessionEndCommand extends Command {
+	static summary = "Disconnect the agent a session registered when it ends";
+	static description = "Disconnects the agent that `primitive agent session-register` created for this session, and removes its exact-session receive hooks. Agents connected any other way are left connected. Never blocks or fails a session: every outcome exits 0 with a status. --hook reads Claude's SessionEnd hook input from stdin and disconnects in the background.";
+	static examples = ["<%= config.bin %> agent session-end --runtime claude --json", "<%= config.bin %> agent session-end --runtime codex --session 11111111-1111-4111-8111-111111111111"];
+	static flags = {
+		runtime: Flags.string({
+			required: true,
+			options: [...MACHINE_RUNTIMES],
+			description: "The coding agent runtime this session runs in"
+		}),
+		session: Flags.string({ description: "Exact session UUID; defaults to the runtime's own session ID" }),
+		hook: Flags.boolean({ description: "Read Claude hook JSON from stdin and disconnect in the background" }),
+		json: Flags.boolean({ description: "Print the result as JSON" }),
+		quiet: Flags.boolean({ description: "Print nothing" })
+	};
+	async run() {
+		const { flags } = await this.parse(AgentSessionEndCommand);
+		const runtime = flags.runtime;
+		if (flags.hook) {
+			const input = await readClaudeHookInput(process.stdin);
+			if (!input || runtime === "claude" && headlessClaudeRun(process.env)) return;
+			await runDetached({
+				node: process.execPath,
+				entry: process.argv[1] ?? "",
+				args: [
+					"agent",
+					"session-end",
+					"--runtime",
+					runtime,
+					"--session",
+					input.sessionId,
+					"--quiet"
+				],
+				env: process.env,
+				waitMs: 0
+			});
+			return;
+		}
+		const result = await endSession({
+			configDir: this.config.configDir,
+			runtime,
+			session: flags.session
+		});
+		const { status, ...rest } = result;
+		if (flags.json) this.log(JSON.stringify({
+			status,
+			...rest
+		}));
+		else if (!flags.quiet) this.log(`${result.status}: ${result.detail}`);
+	}
+};
+//#endregion
+//#region src/oclif/commands/agent-session-register.ts
+/** A hook waits this long for registration before letting the session start. */
+const HOOK_BUDGET_MS = 3e3;
+var AgentSessionRegisterCommand = class AgentSessionRegisterCommand extends Command {
+	static summary = "Register this coding session with Primitive, once";
+	static description = "Gives the current Claude Code, Codex or omp session an address in your organization using the saved member login, without a browser. Safe to run on every start and resume: a session that already has a profile is only re-verified, and a session whose agent was disconnected or removed never gets a second address. The session ID comes from CLAUDE_CODE_SESSION_ID (Claude), CODEX_THREAD_ID or CODEX_SESSION_ID (Codex), or --session. omp does not expose a session ID to commands, so omp sessions use one generated ID per running omp process, and receiving mail is not supported for them. The agent is named <runtime>-<repository> and gets a private AGENT_INFO note naming the runtime and repository when it has none. Claude sessions receive mail through exact-session hooks; Codex through the native receiver. Non-interactive Claude runs (claude -p and SDK hosts, by CLAUDE_CODE_ENTRYPOINT) are skipped with status skipped_headless. Never blocks a session: every outcome, including no login or no network, exits 0 with a status. --hook reads Claude's or Codex's SessionStart hook input from stdin, returns within a few seconds and finishes slower work in the background.";
+	static examples = [
+		"<%= config.bin %> agent session-register --runtime codex --quiet",
+		"<%= config.bin %> agent session-register --runtime claude --json",
+		"<%= config.bin %> agent session-register --runtime omp --session 11111111-1111-4111-8111-111111111111 --json"
+	];
+	static flags = {
+		runtime: Flags.string({
+			required: true,
+			options: [...MACHINE_RUNTIMES],
+			description: "The coding agent runtime this session runs in"
+		}),
+		session: Flags.string({ description: "Exact session UUID; defaults to the runtime's own session ID" }),
+		cwd: Flags.string({ description: "Working directory used for the agent's name and AGENT_INFO; defaults to the current directory" }),
+		hook: Flags.boolean({ description: "Read Claude or Codex SessionStart hook JSON from stdin and finish in the background if registration is slow" }),
+		json: Flags.boolean({ description: "Print the result as JSON" }),
+		quiet: Flags.boolean({ description: "Print nothing" })
+	};
+	async run() {
+		const { flags } = await this.parse(AgentSessionRegisterCommand);
+		const runtime = flags.runtime;
+		if (flags.hook) {
+			const input = await readClaudeHookInput(process.stdin);
+			if (!input || runtime !== "claude" && runtime !== "codex" || runtime === "claude" && headlessClaudeRun(process.env)) return;
+			await runDetached({
+				node: process.execPath,
+				entry: process.argv[1] ?? "",
+				args: [
+					"agent",
+					"session-register",
+					"--runtime",
+					runtime,
+					"--session",
+					input.sessionId,
+					...input.cwd ? ["--cwd", input.cwd] : [],
+					"--quiet"
+				],
+				env: {
+					...process.env,
+					...runtime === "claude" ? { CLAUDE_CODE_SESSION_ID: input.sessionId } : { CODEX_THREAD_ID: input.sessionId }
+				},
+				cwd: input.cwd ?? void 0,
+				waitMs: HOOK_BUDGET_MS
+			});
+			return;
+		}
+		const result = await registerSession({
+			configDir: this.config.configDir,
+			runtime,
+			session: flags.session,
+			cwd: flags.cwd,
+			cliPath: process.argv[1] ?? ""
+		});
+		const { status, ...rest } = result;
+		if (flags.json) this.log(JSON.stringify({
+			status,
+			...rest
+		}));
+		else if (!flags.quiet) this.log(`${result.status}: ${result.detail}`);
+	}
+};
+//#endregion
 //#region src/oclif/commands/agent-upgrade.ts
 /**
 * Interactive upgrade of an emailless agent account to a full developer
@@ -45000,7 +45850,7 @@ const PRIMITIVE_TEAM_AUTHOR = {
 	url: "https://primitive.dev"
 };
 const SDK_VERSION_RANGE = "^1.34.0";
-const CLI_VERSION_RANGE = "^1.37.0";
+const CLI_VERSION_RANGE = "^1.38.0";
 const ESBUILD_VERSION_RANGE = "^0.27.0";
 function renderHandler() {
 	return `// env.PRIMITIVE_API_KEY, env.PRIMITIVE_WEBHOOK_SECRET, and
@@ -51336,6 +52186,1627 @@ var LogoutCommand = class LogoutCommand extends Command {
 	}
 };
 //#endregion
+//#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$1(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$1(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);
+}
+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 && 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 = 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, 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 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 samePath(hook.command, cli.node) && samePath(args[0], cli.entry);
+}
+const WAKE_MARKER = "primitive-agent-wake-v1";
+const PENDING_MARKER = "primitive-pending-mail-v1";
+const SESSION_EVENTS = [
+	"Stop",
+	"SessionStart",
+	"PostToolUse"
+];
+/** 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 ? {
+		kind: "pending",
+		configDir: strings[2] ?? "",
+		profile: strings[3] ?? 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,
+		session: strings[5] ?? null
+	};
+	if (strings.length === 6 && strings[5] === WAKE_MARKER) return {
+		kind: "wake",
+		configDir: strings[2] ?? "",
+		profile: strings[3] ?? null,
+		session: null
+	};
+	if (strings.length === 4 && strings[3] === WAKE_MARKER) return {
+		kind: "wake",
+		configDir: strings[2] ?? "",
+		profile: 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 samePath(hook.command, cli.node) && samePath(args[0], parsed.kind === "wake" ? cli.wake : cli.pending) && samePath(args[1], cli.entry);
+}
+function judgeSessionHooks(hooks, cli) {
+	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 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";
+}
+/** 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 counts = {
+		keep: 0,
+		stale: 0,
+		duplicate: 0,
+		outdated: 0
+	};
+	for (const verdict of judgeSessionHooks(hooks, context.cli).values()) counts[verdict]++;
+	const problems = [
+		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(", ")}.${blockedNote}`,
+		fixable: canFix || counts.outdated === 0 && context.blocked === null
+	} : {
+		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.",
+		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) {
+	const changed = /* @__PURE__ */ new Set();
+	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 verdicts = judgeSessionHooks(hooks, context.cli);
+			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);
+					if (verdict === "stale" || verdict === "duplicate") return void 0;
+					if (verdict !== "outdated" || !cli || !record$2(hook)) return hook;
+					const parsed = parseSessionHook(hook);
+					const args = [...hook.args];
+					args[0] = parsed?.kind === "pending" ? cli.pending : cli.wake;
+					args[1] = cli.entry;
+					return {
+						...hook,
+						command: cli.node,
+						args
+					};
+				});
+				if (result.changed) {
+					hooks[event] = result.entries;
+					changed.add("claude.hook.stop");
+				}
+			}
+		}
+	}
+	if (!changed.size) return {
+		settings,
+		changed
+	};
+	return {
+		settings: {
+			...settings,
+			hooks
+		},
+		changed
+	};
+}
+//#endregion
+//#region src/oclif/codex-machine-hooks.ts
+function record$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** Codex hook commands are shell strings, so every path is single-quoted. */
+function shellQuote(value) {
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+const MANAGED_SUFFIX = /\bagent session-register --runtime codex --hook\s*$/;
+function codexHookCommand(cli) {
+	return `${shellQuote(cli.node)} ${shellQuote(cli.entry)} agent session-register --runtime codex --hook`;
+}
+/** A SessionStart hook this CLI installed, from any CLI path or version. */
+function isManaged(hook) {
+	return record$1(hook) && hook.type === "command" && typeof hook.command === "string" && MANAGED_SUFFIX.test(hook.command);
+}
+/** Parse hooks.json. Anything unexpected is reported, never repaired. */
+function readCodexHooks(codexHome) {
+	const path = join(codexHome, "hooks.json");
+	const read = readManagedFile(path);
+	if (read.state === "invalid") return {
+		ok: false,
+		path,
+		detail: read.detail
+	};
+	if (read.state === "absent") return {
+		ok: true,
+		path,
+		read,
+		settings: {}
+	};
+	let parsed;
+	try {
+		parsed = JSON.parse(read.text);
+	} catch {
+		return {
+			ok: false,
+			path,
+			detail: `${path} is not valid JSON. Fix it by hand; it was not modified.`
+		};
+	}
+	if (!record$1(parsed) || parsed.hooks !== void 0 && !record$1(parsed.hooks)) return {
+		ok: false,
+		path,
+		detail: `${path} must be a JSON object with a "hooks" object. Fix it by hand; it was not modified.`
+	};
+	const entries = record$1(parsed.hooks) ? parsed.hooks.SessionStart : void 0;
+	if (entries !== void 0 && !Array.isArray(entries)) return {
+		ok: false,
+		path,
+		detail: `hooks.SessionStart in ${path} is not a list. Fix it by hand; it was not modified.`
+	};
+	return {
+		ok: true,
+		path,
+		read,
+		settings: parsed
+	};
+}
+function sessionStartEntries(settings) {
+	const hooks = record$1(settings.hooks) ? settings.hooks : {};
+	return Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
+}
+/** Where each managed hook sits, as Codex numbers hooks for trust records. */
+function managedPositions(settings) {
+	const found = [];
+	sessionStartEntries(settings).forEach((entry, entryIndex) => {
+		if (!record$1(entry) || !Array.isArray(entry.hooks)) return;
+		const hooks = entry.hooks;
+		hooks.forEach((hook, hookIndex) => {
+			if (isManaged(hook)) found.push({
+				entry: entryIndex,
+				hook: hookIndex,
+				value: hook,
+				last: hookIndex === hooks.length - 1,
+				matcher: typeof entry.matcher === "string" ? entry.matcher : null
+			});
+		});
+	});
+	return found;
+}
+/** Codex's default spill threshold; a hook set to it hashes as if unset. */
+const DEFAULT_ADDITIONAL_CONTEXT_LIMIT = 2500;
+function sortKeys(value) {
+	if (Array.isArray(value)) return value.map(sortKeys);
+	if (record$1(value)) return Object.fromEntries(Object.keys(value).sort().map((key) => [key, sortKeys(value[key])]));
+	return value;
+}
+/**
+* The trust hash Codex computes for a hooks.json command hook: SHA-256 of the
+* key-sorted JSON of its normalized identity (event, matcher, and the
+* handler with its default timeout filled in and unset options omitted).
+* Checked against the trust records Codex wrote on a real machine.
+*/
+function codexHookTrustHash(event, matcher, hook) {
+	const timeout = typeof hook.timeout === "number" && Number.isInteger(hook.timeout) ? Math.max(1, hook.timeout) : 600;
+	const handler = {
+		type: "command",
+		command: hook.command,
+		timeout,
+		async: hook.async === true
+	};
+	if (typeof hook.statusMessage === "string") handler.statusMessage = hook.statusMessage;
+	if (typeof hook.additionalContextLimit === "number" && hook.additionalContextLimit !== DEFAULT_ADDITIONAL_CONTEXT_LIMIT) handler.additionalContextLimit = hook.additionalContextLimit;
+	const identity = {
+		event_name: event,
+		hooks: [handler]
+	};
+	if (matcher !== null) identity.matcher = matcher;
+	return `sha256:${createHash("sha256").update(JSON.stringify(sortKeys(identity))).digest("hex")}`;
+}
+/**
+* Codex runs a hooks.json hook only once the person approves it. It records
+* the approval under `[hooks.state."<file>:session_start:<entry>:<hook>"]` in
+* config.toml with the hash of the hook as approved; a different current hash
+* means the approval no longer applies.
+*/
+function trustState(configToml, key, currentHash) {
+	if (configToml === null) return "untrusted";
+	const lines = configToml.split(/\r?\n/);
+	const header = `[hooks.state."${key}"]`;
+	const start = lines.findIndex((line) => line.trim() === header);
+	if (start < 0) return "untrusted";
+	let trusted = null;
+	let disabled = false;
+	for (const line of lines.slice(start + 1)) {
+		if (line.trim().startsWith("[")) break;
+		const hash = /^\s*trusted_hash\s*=\s*"([^"]*)"/.exec(line);
+		if (hash) trusted = hash[1] ?? null;
+		if (/^\s*enabled\s*=\s*false\b/.test(line)) disabled = true;
+	}
+	if (disabled) return "disabled";
+	if (trusted === null) return "untrusted";
+	return trusted === currentHash ? "trusted" : "modified";
+}
+function inspectCodexHook(read, context, configToml) {
+	const canFix = context.cli !== null && context.blocked === null;
+	const blockedNote = context.blocked ? ` ${context.blocked}` : "";
+	const managed = managedPositions(read.settings);
+	const [first] = managed;
+	if (!first) return {
+		status: "fail",
+		detail: `No SessionStart hook in ${read.path} runs \`primitive agent session-register --runtime codex --hook\`.${blockedNote}`,
+		fixable: canFix
+	};
+	const desired = context.cli ? codexHookCommand(context.cli) : null;
+	const extras = managed.slice(1);
+	const removable = extras.filter((copy) => copy.last).length;
+	const stale = managed.filter((copy) => copy.value.command !== desired).length;
+	if (removable || stale) return {
+		status: "fail",
+		detail: [stale ? `${stale} SessionStart hooks run \`primitive agent session-register\` from another CLI path.` : "", removable ? `${removable} extra copies can be removed without moving other hooks.` : ""].filter(Boolean).join(" ").concat(blockedNote),
+		fixable: canFix
+	};
+	if (extras.length) return {
+		status: "warn",
+		detail: `${extras.length} extra copies of the hook sit before other hooks in their entries; they were left in place so those hooks keep their Codex approval. Remove them by hand if you like.`,
+		fixable: false
+	};
+	const trust = trustState(configToml, `${read.path}:session_start:${first.entry}:${first.hook}`, codexHookTrustHash("session_start", first.matcher, first.value));
+	if (trust === "disabled") return {
+		status: "warn",
+		detail: "The Codex SessionStart hook is installed but disabled in Codex.",
+		fixable: false
+	};
+	if (trust !== "trusted") return {
+		status: "warn",
+		detail: trust === "modified" ? "The Codex SessionStart hook changed since it was approved; approval needs to be confirmed in Codex." : "The Codex SessionStart hook is installed; approval needs to be confirmed in Codex before it runs.",
+		fixable: false
+	};
+	return {
+		status: "ok",
+		detail: `SessionStart runs \`primitive agent session-register --runtime codex --hook\` from ${context.cli?.entry ?? "this CLI"}, approved in Codex.`,
+		fixable: false
+	};
+}
+/**
+* Codex keys approvals by entry and hook position, so this never removes or
+* reorders an entry, and never moves a hook that is not Primitive's. Managed
+* hooks are rewritten in place; an extra copy is removed only when it is the
+* last hook in its entry (its entry stays, even if empty); a hook is appended
+* as a new last entry when none exists.
+*/
+function repairCodexHook(settings, cli) {
+	const desired = codexHookCommand(cli);
+	let placed = false;
+	let changed = false;
+	const entries = sessionStartEntries(settings).map((entry) => {
+		if (!record$1(entry) || !Array.isArray(entry.hooks)) return entry;
+		const hooks = entry.hooks;
+		let touched = false;
+		const next = hooks.flatMap((hook, index) => {
+			if (!isManaged(hook)) return [hook];
+			const isLast = index === hooks.length - 1;
+			if (placed && isLast) {
+				touched = true;
+				return [];
+			}
+			placed = true;
+			if (hook.command === desired) return [hook];
+			touched = true;
+			return [{
+				...hook,
+				command: desired
+			}];
+		});
+		if (!touched) return entry;
+		changed = true;
+		return {
+			...entry,
+			hooks: next
+		};
+	});
+	if (!placed) {
+		entries.push({ hooks: [{
+			type: "command",
+			command: desired
+		}] });
+		changed = true;
+	}
+	if (!changed) return {
+		settings,
+		changed
+	};
+	const hooks = record$1(settings.hooks) ? settings.hooks : {};
+	return {
+		settings: {
+			...settings,
+			hooks: {
+				...hooks,
+				SessionStart: entries
+			}
+		},
+		changed
+	};
+}
+function writeCodexHooks(params) {
+	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" : "";
+	writeManagedFile({
+		read: params.read,
+		content: `${JSON.stringify(params.settings, null, indent)}${trailing}`,
+		now: params.now,
+		newFileMode: 384
+	});
+}
+const DOCTOR_CHECK_IDS = [
+	"cli.installed",
+	"cli.version",
+	"cli.path_stable",
+	"auth.member_login",
+	"claude.settings_valid",
+	"claude.hook.session_start",
+	"claude.hook.session_end",
+	"claude.hook.stop",
+	"claude.instructions",
+	"codex.hook.session_start",
+	"codex.instructions",
+	"omp.instructions",
+	"skill.claude",
+	"skill.codex",
+	"profiles.orphaned"
+];
+const TITLES = {
+	"cli.installed": "Primitive CLI installed",
+	"cli.version": "Primitive CLI version",
+	"cli.path_stable": "CLI location is stable",
+	"auth.member_login": "Member login",
+	"claude.settings_valid": "Claude Code settings file",
+	"claude.hook.session_start": "Claude SessionStart hook",
+	"claude.hook.session_end": "Claude SessionEnd hook",
+	"claude.hook.stop": "Claude per-session receive hooks",
+	"claude.instructions": "Claude Code instructions",
+	"codex.hook.session_start": "Codex SessionStart hook",
+	"codex.instructions": "Codex instructions",
+	"omp.instructions": "omp instructions",
+	"skill.claude": "primitive-connect skill for Claude Code",
+	"skill.codex": "primitive-connect skill for Codex",
+	"profiles.orphaned": "Saved agent profiles"
+};
+const WORKING_LINE = "Keep AGENT_WORKING current: `primitive agent working set \"<task>: <files>\"` when work starts and `primitive agent working clear` when it ends.";
+const REPLY_LINE = "Answer Primitive mail on Primitive with `primitive reply`; read receipts are automatic.";
+const SECRET_LINE = "Never print invitation tokens or credentials.";
+/** The managed instruction block for one runtime. Kept short on purpose. */
+function managedInstructions(runtime) {
+	return [
+		"## Primitive",
+		"",
+		`- ${runtime === "claude" || runtime === "codex" ? `A Primitive SessionStart hook registers this session with \`primitive agent session-register --runtime ${runtime} --quiet\`; if it has not run, run that command once.` : `At session start, if this session is not registered yet, run \`primitive agent session-register --runtime ${runtime} --quiet\`.`}`,
+		`- ${REPLY_LINE}`,
+		`- ${WORKING_LINE}`,
+		`- ${SECRET_LINE}`
+	].join("\n");
+}
+/** Compare dotted numeric versions; pre-release suffixes are ignored. */
+function compareVersions(a, b) {
+	const parse = (value) => {
+		const match = /^v?(\d+)\.(\d+)\.(\d+)/.exec(value.trim());
+		return match ? match.slice(1, 4).map(Number) : null;
+	};
+	const left = parse(a);
+	const right = parse(b);
+	if (!left || !right) return null;
+	for (let index = 0; index < 3; index++) {
+		const difference = (left[index] ?? 0) - (right[index] ?? 0);
+		if (difference) return Math.sign(difference);
+	}
+	return 0;
+}
+async function npmLatestVersion(fetchImpl) {
+	try {
+		const response = await fetchImpl("https://registry.npmjs.org/primitive/latest", {
+			headers: { accept: "application/json" },
+			redirect: "follow",
+			signal: AbortSignal.timeout(3e3)
+		});
+		if (!response.ok) return null;
+		const text = await response.text();
+		if (text.length > 1048576) return null;
+		const version = JSON.parse(text).version;
+		return typeof version === "string" ? version : null;
+	} catch {
+		return null;
+	}
+}
+const SKILL_BACKUPS_KEPT = 2;
+/**
+* Skill backups are named <runtime>-<sequence>-<timestamp>. The sequence is
+* one past the highest existing one for the runtime, so names order strictly
+* by creation even when several are made within the same second. Backups
+* from the earlier <runtime>-<timestamp>[-<n>] naming have no sequence; they
+* sort before every sequenced backup, oldest first, so pruning removes them
+* first.
+*/
+function skillBackups(directory, runtime) {
+	const sequenced = new RegExp(`^${runtime}-(\\d{6,})-\\d{8}T\\d{6}Z$`);
+	const legacy = new RegExp(`^${runtime}-(\\d{8}T\\d{6}Z)(?:-(\\d+))?$`);
+	let names;
+	try {
+		names = readdirSync(directory);
+	} catch {
+		return [];
+	}
+	const legacyNames = names.flatMap((name) => {
+		const match = legacy.exec(name);
+		return match ? [{
+			name,
+			stamp: match[1] ?? "",
+			suffix: Number(match[2] ?? 0)
+		}] : [];
+	}).sort((left, right) => left.stamp === right.stamp ? left.suffix - right.suffix : left.stamp < right.stamp ? -1 : 1).map(({ name }, index, all) => ({
+		name,
+		sequence: index - all.length
+	}));
+	const sequencedNames = names.flatMap((name) => {
+		const match = sequenced.exec(name);
+		return match ? [{
+			name,
+			sequence: Number(match[1])
+		}] : [];
+	});
+	return [...legacyNames, ...sequencedNames].sort((left, right) => left.sequence - right.sequence);
+}
+function nextSkillBackupName(directory, runtime, now) {
+	const last = Math.max(0, skillBackups(directory, runtime).at(-1)?.sequence ?? 0);
+	return `${runtime}-${String(last + 1).padStart(6, "0")}-${backupStamp(now)}`;
+}
+function pruneSkillBackups(directory, runtime) {
+	const backups = skillBackups(directory, runtime);
+	for (const { name } of backups.slice(0, Math.max(0, backups.length - SKILL_BACKUPS_KEPT))) try {
+		rmSync(join(directory, name), {
+			recursive: true,
+			force: true
+		});
+	} catch {}
+}
+function backupStamp(now) {
+	return now.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+}
+function runtimePresent(runtime, paths, env) {
+	return existsSync(runtime === "claude" ? paths.claudeDir : runtime === "codex" ? paths.codexHome : paths.ompRoot) || findOnPath(runtime, env) !== null;
+}
+function runtimePaths(env, home) {
+	const ompRoot = resolve(home, env.PI_CONFIG_DIR || ".omp");
+	return {
+		claudeDir: claudeConfigDir(env, home),
+		codexHome: resolve(env.CODEX_HOME || join(home, ".codex")),
+		ompRoot,
+		ompAgentDir: resolve(env.PI_CODING_AGENT_DIR || join(ompRoot, "agent"))
+	};
+}
+/** Codex reads AGENTS.override.md instead of AGENTS.md when it has content. */
+function codexInstructionsPath(codexHome) {
+	const override = join(codexHome, "AGENTS.override.md");
+	const read = readManagedFile(override);
+	if (read.state === "present" && read.text.trim()) return override;
+	return join(codexHome, "AGENTS.md");
+}
+async function memberCredentialsFor(options) {
+	try {
+		const saved = loadCliCredentials(options.configDir);
+		if (!saved) return null;
+		return await refreshStoredCliCredentials({
+			apiBaseUrl: saved.api_base_url,
+			configDir: options.configDir,
+			credentials: saved,
+			fetch: options.fetch
+		});
+	} catch {
+		return null;
+	}
+}
+/** Find an address in the member's connection list; null when it cannot be confirmed. */
+async function ownerListedStatus(credentials, address, fetchImpl) {
+	let cursor;
+	for (let page = 0; page < 10; page++) {
+		const url = new URL(`${credentials.api_base_url}/agent-connections`);
+		url.searchParams.set("limit", "50");
+		if (cursor) url.searchParams.set("cursor", cursor);
+		try {
+			const response = await fetchImpl(url, {
+				method: "GET",
+				redirect: "error",
+				signal: AbortSignal.timeout(5e3),
+				headers: {
+					authorization: `Bearer ${credentials.access_token}`,
+					accept: "application/json"
+				}
+			});
+			if (response.status !== 200) {
+				await response.body?.cancel().catch(() => void 0);
+				return null;
+			}
+			const text = await response.text();
+			if (text.length > 1048576) return null;
+			const body = JSON.parse(text);
+			if (body.success !== true || !Array.isArray(body.data)) return null;
+			for (const row of body.data) if (row?.address === address && typeof row.status === "string") return row.status;
+			const next = body.meta?.cursor;
+			if (typeof next !== "string" || !next || next === cursor) return null;
+			cursor = next;
+		} catch {
+			return null;
+		}
+	}
+	return null;
+}
+function check(id, status, detail, extra = {}) {
+	return {
+		id,
+		title: TITLES[id],
+		status,
+		detail,
+		fixable: false,
+		...extra
+	};
+}
+/**
+* Inspect this machine's Primitive setup for every agent runtime, and with
+* `fix`, repair what can be repaired without the person. Repairs only touch
+* Primitive-owned content, back up any file before changing it, write
+* atomically, and are no-ops when nothing drifted.
+*/
+async function runMachineDoctor(options) {
+	const env = options.env;
+	const fetchImpl = options.fetch ?? fetch;
+	const now = options.now ?? (() => /* @__PURE__ */ new Date());
+	const paths = runtimePaths(env, options.home);
+	const selected = (runtime) => !options.runtimes || options.runtimes.has(runtime);
+	const present = Object.fromEntries(MACHINE_RUNTIMES.map((runtime) => [runtime, runtimePresent(runtime, paths, env)]));
+	const skipRuntime = (runtime) => !selected(runtime) ? "Not selected with --runtime." : !present[runtime] ? `${runtime === "claude" ? "Claude Code" : runtime === "codex" ? "Codex" : "omp"} was not found on this machine.` : null;
+	const cli = currentCliLocation(options.cliEntry, env, options.execPath);
+	const ephemeral = cli ? ephemeralCliReason(cli.entry) : null;
+	const hookBlocked = !cli ? "This CLI's hook scripts were not found next to it." : ephemeral ? `This CLI runs from ${ephemeral}, which can be deleted; install it with \`npm install -g primitive\` before repairing hooks.` : null;
+	const skillEnv = {
+		...env,
+		CLAUDE_CONFIG_DIR: paths.claudeDir,
+		CODEX_HOME: paths.codexHome
+	};
+	let bundle;
+	const loadBundle = () => {
+		if (bundle !== void 0) return bundle;
+		try {
+			bundle = (options.bundle ?? (() => readBundledConnectSkill(options.packageRoot)))();
+		} catch {
+			bundle = null;
+		}
+		return bundle;
+	};
+	const instruction = (id, runtime, path) => ({
+		inspect: () => {
+			const skip = skipRuntime(runtime);
+			if (skip) return check(id, "skip", skip);
+			const target = path();
+			const body = managedInstructions(runtime);
+			const read = readManagedFile(target);
+			if (read.state === "invalid") return check(id, "fail", read.detail, {
+				path: target,
+				action: "edit_file"
+			});
+			if (read.state === "absent") return check(id, "fail", `${target} does not exist yet.`, {
+				path: target,
+				fixable: true
+			});
+			const state = inspectManagedBlock(read.text, body);
+			if (state.state === "ok") return check(id, "ok", `The Primitive block in ${target} is current.`, { path: target });
+			if (state.state === "malformed") return check(id, "fail", `${target}: ${state.detail}. It was left unchanged.`, {
+				path: target,
+				action: "edit_file"
+			});
+			return check(id, "fail", state.state === "missing" ? `${target} has no Primitive block.` : `The Primitive block in ${target} is out of date (v${state.version}).`, {
+				path: target,
+				fixable: true
+			});
+		},
+		repair: () => {
+			const read = readManagedFile(path());
+			if (read.state === "invalid") return false;
+			const next = upsertManagedBlock(read.state === "present" ? read.text : "", managedInstructions(runtime));
+			if (read.state === "present" && next === read.text) return false;
+			writeManagedFile({
+				read,
+				content: next,
+				now
+			});
+			return true;
+		}
+	});
+	const skill = (id, runtime) => ({
+		inspect: () => {
+			const skip = skipRuntime(runtime);
+			if (skip) return check(id, "skip", skip);
+			const current = loadBundle();
+			if (!current) return check(id, "skip", "This CLI build does not include the bundled skill.");
+			const target = connectSkillTarget({
+				runtime,
+				env: skillEnv
+			});
+			let info = null;
+			try {
+				info = lstatSync(target);
+			} catch {
+				info = null;
+			}
+			if (!info) return check(id, "fail", `Not installed at ${target}.`, {
+				path: target,
+				fixable: true
+			});
+			if (info.isSymbolicLink()) return check(id, "warn", `${target} is a symlink you manage; it was left unchanged.`, { path: target });
+			const version = installedVersion(target);
+			if (version === current.version) return check(id, "ok", `Version ${version} matches this CLI.`, { path: target });
+			return check(id, "fail", version ? `Installed version ${version} differs from this CLI's ${current.version}.` : `${target} is not a readable skill directory.`, {
+				path: target,
+				fixable: version !== null
+			});
+		},
+		repair: () => {
+			const current = loadBundle();
+			if (!current) return false;
+			const target = connectSkillTarget({
+				runtime,
+				env: skillEnv
+			});
+			const backups = join(options.configDir, "machine", "backups", "skills");
+			if (existsSync(target)) {
+				mkdirSync(backups, {
+					recursive: true,
+					mode: 448
+				});
+				const backup = join(backups, nextSkillBackupName(backups, runtime, now()));
+				mkdirSync(backup, { mode: 448 });
+				cpSync(target, backup, {
+					recursive: true,
+					verbatimSymlinks: true
+				});
+			}
+			const result = installConnectSkill({
+				bundle: current,
+				runtime,
+				env: skillEnv
+			});
+			if (result.state === "failed") throw new MachineFileError(`The skill could not be installed (${result.reason ?? "unknown"}).`);
+			pruneSkillBackups(backups, runtime);
+			return result.state === "installed" || result.state === "updated";
+		}
+	});
+	const HOOK_CHECK_IDS = [
+		"claude.hook.session_start",
+		"claude.hook.session_end",
+		"claude.hook.stop"
+	];
+	const repairedAhead = /* @__PURE__ */ new Set();
+	let settingsRead = readClaudeSettings(paths.claudeDir);
+	const hookContext = {
+		cli,
+		blocked: hookBlocked
+	};
+	const hookCheck = (id) => ({
+		inspect: () => {
+			const skip = skipRuntime("claude");
+			if (skip) return check(id, "skip", skip);
+			if (!settingsRead.ok) return check(id, "fail", "Claude settings.json is invalid; repair it first.", { path: join(paths.claudeDir, "settings.json") });
+			const finding = inspectClaudeHooks(settingsRead.settings, hookContext)[id];
+			return check(id, finding.status, finding.detail, {
+				fixable: finding.fixable,
+				path: join(paths.claudeDir, "settings.json"),
+				...finding.status === "fail" && !finding.fixable && hookBlocked ? { action: "install_cli" } : {}
+			});
+		},
+		repair: () => {
+			if (!settingsRead.ok) return false;
+			const findings = inspectClaudeHooks(settingsRead.settings, hookContext);
+			const ids = HOOK_CHECK_IDS.filter((hook) => (hook === id || !options.only || options.only.has(hook)) && findings[hook].status === "fail" && findings[hook].fixable);
+			const repaired = repairClaudeHooks(settingsRead.settings, hookContext, new Set(ids));
+			if (!repaired.changed.size) return false;
+			for (const hook of repaired.changed) repairedAhead.add(hook);
+			writeClaudeSettings({
+				claudeDir: paths.claudeDir,
+				read: settingsRead.read,
+				settings: repaired.settings,
+				now
+			});
+			settingsRead = readClaudeSettings(paths.claudeDir);
+			return repaired.changed.has(id);
+		}
+	});
+	const codexHook = {
+		inspect: () => {
+			const id = "codex.hook.session_start";
+			const skip = skipRuntime("codex");
+			if (skip) return check(id, "skip", skip);
+			const read = readCodexHooks(paths.codexHome);
+			if (!read.ok) return check(id, "fail", read.detail, {
+				path: read.path,
+				action: "edit_file"
+			});
+			const configToml = readManagedFile(join(paths.codexHome, "config.toml"));
+			const finding = inspectCodexHook(read, hookContext, configToml.state === "present" ? configToml.text : null);
+			return check(id, finding.status, finding.detail, {
+				fixable: finding.fixable,
+				path: read.path,
+				...finding.status === "fail" && !finding.fixable && hookBlocked ? { action: "install_cli" } : {}
+			});
+		},
+		repair: () => {
+			const read = readCodexHooks(paths.codexHome);
+			if (!read.ok || !cli || hookBlocked) return false;
+			const repaired = repairCodexHook(read.settings, cli);
+			if (!repaired.changed) return false;
+			writeCodexHooks({
+				read: read.read,
+				settings: repaired.settings,
+				now
+			});
+			return true;
+		}
+	};
+	const orphans = [];
+	const inspectProfiles = async () => {
+		orphans.length = 0;
+		const directory = join(agentProfilesDirectory(options.configDir), "profiles");
+		let names = [];
+		try {
+			names = readdirSync(directory).filter((name) => {
+				try {
+					agentProfileName(name);
+					return true;
+				} catch {
+					return false;
+				}
+			});
+		} catch {
+			names = [];
+		}
+		const profiles = [];
+		let unreadable = 0;
+		for (const name of names) try {
+			const profile = loadConnectedAgentProfile(options.configDir, name);
+			if (profile) profiles.push({
+				name,
+				profile
+			});
+		} catch {
+			unreadable++;
+		}
+		if (!profiles.length) return unreadable ? check("profiles.orphaned", "warn", `${unreadable} saved profiles could not be read; they were left unchanged.`) : check("profiles.orphaned", "ok", "No saved agent profiles.");
+		let member;
+		let unconfirmed = 0;
+		let unknown = 0;
+		let connected = 0;
+		const states = [];
+		for (let start = 0; start < profiles.length; start += 8) states.push(...await Promise.all(profiles.slice(start, start + 8).map(async (entry) => ({
+			...entry,
+			state: await agentConnectionState(entry.profile, fetchImpl)
+		}))));
+		for (const entry of states) if (entry.state === "revoked") orphans.push(entry);
+		else if (entry.state === "rejected") {
+			member ??= await memberCredentialsFor(options);
+			if ((member && member.org_id === entry.profile.org_id && member.api_base_url === entry.profile.api_base_url ? await ownerListedStatus(member, entry.profile.agent_address, fetchImpl) : null) === "revoked") orphans.push(entry);
+			else unconfirmed++;
+		} else if (entry.state === "unavailable") unknown++;
+		else connected++;
+		if (orphans.length) return check("profiles.orphaned", "fail", `${orphans.length} saved profiles were disconnected in Primitive: ${orphans.map((entry) => entry.profile.agent_address).join(", ")}. A repair moves them aside locally; nothing changes in Primitive.`, { fixable: true });
+		if (unconfirmed || unreadable) return check("profiles.orphaned", "warn", [unconfirmed ? `${unconfirmed} profiles' credentials were rejected but disconnection could not be confirmed` : "", unreadable ? `${unreadable} profiles could not be read` : ""].filter(Boolean).join("; ").concat("; they were left unchanged."));
+		if (unknown && !connected) return check("profiles.orphaned", "skip", "Primitive could not be reached to check saved profiles.");
+		return check("profiles.orphaned", "ok", `${connected} saved profiles are connected${unknown ? `; ${unknown} could not be checked` : ""}.`);
+	};
+	const moveOrphans = async () => {
+		let moved = 0;
+		for (const entry of orphans) {
+			const directory = agentProfileDirectory(options.configDir, entry.name);
+			let session = null;
+			try {
+				const setup = readMailJson(join(directory, "setup.json"));
+				if (typeof setup?.session === "string" && SESSION_UUID$1.test(setup.session)) session = setup.session.toLowerCase();
+			} catch {
+				session = null;
+			}
+			if (session) {
+				const stopped = await (options.stopReceiver ?? stopBackgroundListen)({
+					configDir: options.configDir,
+					scope: notificationScope(entry.profile.api_base_url, entry.profile.api_key),
+					threadId: session
+				}).catch(() => null);
+				if (!stopped || !(stopped.phase === null || stopped.phase === "stopped" || stopped.phase === "failed" || stopped.reason === "exited")) continue;
+			}
+			const aside = join(agentProfilesDirectory(options.configDir), "orphaned");
+			mkdirSync(aside, {
+				recursive: true,
+				mode: 448
+			});
+			renameSync(directory, join(aside, `${entry.name}-${backupStamp(now())}`));
+			moved++;
+		}
+		return moved > 0;
+	};
+	const runners = {
+		"cli.installed": { inspect: () => cli ? check("cli.installed", "ok", `primitive ${options.cliVersion} at ${cli.entry}.`, { path: cli.entry }) : check("cli.installed", "fail", "The running CLI's files could not be located.", { action: "install_cli" }) },
+		"cli.version": { inspect: async () => {
+			const version = options.cliVersion;
+			if (options.minCliVersion) {
+				const compared = compareVersions(version, options.minCliVersion);
+				if (compared === null) return check("cli.version", "warn", `Cannot compare ${version} with the required ${options.minCliVersion}.`);
+				if (compared < 0) return check("cli.version", "fail", `${version} is older than the required ${options.minCliVersion}.`, { action: "update_cli" });
+			}
+			const latest = await (options.latestVersion ?? (() => npmLatestVersion(fetchImpl)))();
+			if (!latest) return options.minCliVersion ? check("cli.version", "ok", `${version} meets the required ${options.minCliVersion}; the latest release could not be checked.`) : check("cli.version", "skip", `${version}; the latest release could not be checked.`);
+			const behind = compareVersions(version, latest);
+			if (behind !== null && behind < 0) return check("cli.version", "warn", `${version} is older than the latest release ${latest}.`, { action: "update_cli" });
+			return check("cli.version", "ok", `${version} is current.`);
+		} },
+		"cli.path_stable": { inspect: () => {
+			if (!cli) return check("cli.path_stable", "fail", "The running CLI's files could not be located.", { action: "install_cli" });
+			if (ephemeral) return check("cli.path_stable", "fail", `This CLI runs from ${ephemeral}; hooks pointing at it would break. Install it globally with \`npm install -g primitive\`.`, {
+				action: "install_cli",
+				path: cli.entry
+			});
+			const onPath = findOnPath("primitive", env);
+			if (onPath && !samePath(onPath, cli.entry)) return check("cli.path_stable", "warn", `\`primitive\` on PATH is ${onPath}, but this run is ${cli.entry}; hooks follow the copy that runs the doctor.`, { path: cli.entry });
+			return check("cli.path_stable", "ok", `Hooks use ${cli.node} and ${cli.entry}.`, { path: cli.entry });
+		} },
+		"auth.member_login": { inspect: async () => {
+			let saved;
+			try {
+				saved = loadCliCredentials(options.configDir);
+			} catch {
+				return check("auth.member_login", "fail", "The saved login file is unreadable. Sign in again.", { action: "login" });
+			}
+			if (!saved) return check("auth.member_login", "fail", "No saved member login on this machine.", { action: "login" });
+			let credentials;
+			try {
+				credentials = await refreshStoredCliCredentials({
+					apiBaseUrl: saved.api_base_url,
+					configDir: options.configDir,
+					credentials: saved,
+					fetch: options.fetch
+				});
+			} catch (error) {
+				return error instanceof Error && error.message === "Saved Primitive CLI OAuth session expired or was revoked. Run `primitive signin` to authenticate again." ? check("auth.member_login", "fail", "The saved login expired or was revoked.", { action: "login" }) : check("auth.member_login", "warn", "The saved login could not be refreshed right now (offline?).");
+			}
+			try {
+				const response = await fetchImpl(`${credentials.api_base_url}/account`, {
+					method: "GET",
+					redirect: "error",
+					signal: AbortSignal.timeout(5e3),
+					headers: {
+						authorization: `Bearer ${credentials.access_token}`,
+						accept: "application/json"
+					}
+				});
+				await response.body?.cancel().catch(() => void 0);
+				if (response.status === 401 || response.status === 403) return check("auth.member_login", "fail", "The saved login was rejected.", { action: "login" });
+				if (!response.ok) return check("auth.member_login", "warn", `The saved login could not be verified (HTTP ${response.status}).`);
+			} catch {
+				return check("auth.member_login", "warn", "The saved login could not be verified right now (offline?).");
+			}
+			return check("auth.member_login", "ok", `Signed in to ${credentials.org_name ?? credentials.org_id}.`);
+		} },
+		"claude.settings_valid": { inspect: () => {
+			const skip = skipRuntime("claude");
+			if (skip) return check("claude.settings_valid", "skip", skip);
+			const path = join(paths.claudeDir, "settings.json");
+			if (!settingsRead.ok) return check("claude.settings_valid", "fail", settingsRead.detail, {
+				path,
+				action: "edit_file"
+			});
+			return check("claude.settings_valid", "ok", settingsRead.read.state === "absent" ? `${path} does not exist yet; a repair creates it.` : `${path} is valid JSON.`, { path });
+		} },
+		"claude.hook.session_start": hookCheck("claude.hook.session_start"),
+		"claude.hook.session_end": hookCheck("claude.hook.session_end"),
+		"claude.hook.stop": hookCheck("claude.hook.stop"),
+		"codex.hook.session_start": codexHook,
+		"claude.instructions": instruction("claude.instructions", "claude", () => join(paths.claudeDir, "CLAUDE.md")),
+		"codex.instructions": instruction("codex.instructions", "codex", () => codexInstructionsPath(paths.codexHome)),
+		"omp.instructions": instruction("omp.instructions", "omp", () => join(paths.ompAgentDir, "AGENTS.md")),
+		"skill.claude": skill("skill.claude", "claude"),
+		"skill.codex": skill("skill.codex", "codex"),
+		"profiles.orphaned": {
+			inspect: async () => {
+				const result = await inspectProfiles();
+				const pending = pendingSessionDisconnects(options.configDir);
+				if (!pending.length) return result;
+				const addresses = pending.flatMap((record) => record.address ? [record.address] : []);
+				return check("profiles.orphaned", "fail", `${pending.length} ended sessions still need their agent disconnected${addresses.length ? ` (${addresses.join(", ")})` : ""}; a repair retries it.${result.status === "ok" ? "" : ` ${result.detail}`}`, { fixable: true });
+			},
+			repair: async () => {
+				const retried = await retryPendingDisconnects(options.configDir, {
+					env,
+					fetch: options.fetch,
+					...options.sessionDisconnect ? { dependencies: options.sessionDisconnect } : {}
+				});
+				return await moveOrphans() || retried > 0;
+			}
+		}
+	};
+	let release;
+	let busy = false;
+	if (options.fix) {
+		for (let attempt = 0; attempt < 40 && !release; attempt++) try {
+			release = acquireListenLock(join(options.configDir, "machine"), "machine-doctor");
+		} catch {
+			await new Promise((done) => setTimeout(done, 250));
+		}
+		busy = !release;
+	}
+	const results = /* @__PURE__ */ new Map();
+	try {
+		const order = ["profiles.orphaned", ...DOCTOR_CHECK_IDS.filter((id) => id !== "profiles.orphaned")];
+		for (const id of order) {
+			const runner = runners[id];
+			let result;
+			try {
+				result = await runner.inspect();
+			} catch {
+				result = check(id, "fail", "This check could not run.");
+			}
+			if (result.status === "ok" && repairedAhead.has(id)) result = {
+				...result,
+				fixed: true
+			};
+			const wanted = !options.only || options.only.has(id);
+			if (options.fix && !busy && wanted && result.fixable && result.status !== "ok" && runner.repair) try {
+				const changed = await runner.repair(result);
+				const after = await runner.inspect();
+				result = {
+					...after,
+					fixed: changed && after.status !== "fail"
+				};
+				if (changed && after.status === "fail") result.detail = `${after.detail} (A repair was applied but did not resolve this.)`;
+			} catch (error) {
+				result = {
+					...result,
+					fixed: false,
+					detail: `${result.detail} Repair failed: ${error instanceof MachineFileError ? error.message : "an unexpected error; nothing further was changed."}`
+				};
+			}
+			results.set(id, result);
+		}
+	} finally {
+		release?.();
+	}
+	const checks = DOCTOR_CHECK_IDS.map((id) => results.get(id) ?? check(id, "fail", "This check did not run."));
+	const summary = {
+		ok: 0,
+		warn: 0,
+		fail: 0,
+		skip: 0
+	};
+	for (const item of checks) summary[item.status]++;
+	return {
+		version: 1,
+		cliVersion: options.cliVersion,
+		checks,
+		summary,
+		fixedCount: checks.filter((item) => item.fixed).length,
+		...busy ? { repair: "skipped_busy" } : {}
+	};
+}
+//#endregion
+//#region src/oclif/commands/machine-doctor.ts
+function renderCheck(check) {
+	const tag = check.status === "ok" ? "[OK]  " : check.status === "warn" ? "[WARN]" : check.status === "skip" ? "[SKIP]" : "[FAIL]";
+	const fixed = check.fixed ? " (fixed)" : "";
+	return `${tag} ${check.id}${fixed}: ${check.detail}`;
+}
+var MachineDoctorCommand = class MachineDoctorCommand extends Command {
+	static summary = "Check, and optionally repair, this machine's Primitive setup for coding agents";
+	static description = "Checks everything that lets Claude Code, Codex and omp sessions on this machine register with Primitive and answer mail: the CLI install and version, the saved member login, Claude settings and Primitive's SessionStart, SessionEnd and per-session receive hooks, the managed instruction block in each runtime's global instructions file, the bundled primitive-connect skill, and saved agent profiles disconnected in Primitive. Each check reports ok, warn, fail or skip, whether it can be repaired automatically, and an action (login, install_cli, update_cli, edit_file) when only a person can fix it. --fix repairs what it safely can: it only adds, rewrites or removes Primitive-owned hooks, blocks and skill copies, backs up any existing file beside it as <file>.primitive-bak-<timestamp> before changing it, writes atomically, and changes nothing when nothing drifted, so it is safe to run on a timer. Malformed or hand-edited files it cannot parse are reported and left unchanged. Exits 0 when every check is ok or skipped, 1 otherwise.";
+	static examples = [
+		"<%= config.bin %> machine doctor",
+		"<%= config.bin %> machine doctor --json",
+		"<%= config.bin %> machine doctor --fix --json",
+		"<%= config.bin %> machine doctor --fix --check claude.hook.stop --json",
+		"<%= config.bin %> machine doctor --runtime claude,codex --min-cli-version 1.38.0 --json"
+	];
+	static flags = {
+		fix: Flags.boolean({ description: "Repair every fixable check (or only those named with --check)" }),
+		check: Flags.string({
+			description: "With --fix, repair only this check; repeatable. Every check is still reported",
+			multiple: true,
+			options: [...DOCTOR_CHECK_IDS]
+		}),
+		runtime: Flags.string({ description: "Comma-separated runtimes to check: claude, codex, omp. Defaults to every runtime found on this machine" }),
+		"min-cli-version": Flags.string({ description: "Report cli.version as failing when this CLI is older than the given version" }),
+		json: Flags.boolean({ description: "Print the report as JSON" })
+	};
+	async run() {
+		const { flags } = await this.parse(MachineDoctorCommand);
+		let runtimes;
+		if (flags.runtime) {
+			const names = flags.runtime.split(",").map((name) => name.trim().toLowerCase()).filter(Boolean);
+			const unknown = names.filter((name) => !MACHINE_RUNTIMES.includes(name));
+			if (unknown.length) this.error(`Unknown runtime ${unknown.join(", ")}. Use claude, codex or omp.`, { exit: 2 });
+			runtimes = new Set(names);
+		}
+		if (flags.check?.length && !flags.fix) this.error("--check selects which checks --fix repairs; add --fix.", { exit: 2 });
+		const report = await runMachineDoctor({
+			fix: flags.fix,
+			only: flags.check?.length ? new Set(flags.check) : void 0,
+			runtimes,
+			configDir: this.config.configDir,
+			home: homedir(),
+			env: process.env,
+			packageRoot: this.config.root,
+			cliVersion: this.config.version,
+			cliEntry: process.argv[1] ?? "",
+			minCliVersion: flags["min-cli-version"]
+		});
+		if (flags.json) this.log(JSON.stringify(report));
+		else {
+			for (const check of report.checks) this.log(renderCheck(check));
+			this.log(`${report.summary.ok} ok, ${report.summary.warn} warn, ${report.summary.fail} fail, ${report.summary.skip} skipped${report.fixedCount ? `; ${report.fixedCount} fixed` : ""}.`);
+			if (report.repair === "skipped_busy") this.log("Another repair was running, so nothing was changed.");
+			else if (!flags.fix && report.checks.some((check) => check.fixable)) this.log("Run `primitive machine doctor --fix` to repair fixable checks.");
+		}
+		if (report.summary.fail || report.summary.warn) process.exitCode = 1;
+	}
+};
+//#endregion
 //#region src/oclif/commands/memories.ts
 var MemoryCliInputError = class extends Error {};
 const API_KEY_FLAG = Flags.string({
@@ -57900,6 +60371,8 @@ const COMMANDS = {
 	"agent:connect": AgentConnectCommand,
 	"agent:disconnect": AgentDisconnectCommand,
 	"agent:enroll": AgentEnrollCommand,
+	"agent:session-register": AgentSessionRegisterCommand,
+	"agent:session-end": AgentSessionEndCommand,
 	"contacts:request": ContactsRequestCommand,
 	"contacts:accept": ContactsAcceptCommand,
 	"contacts:wait": ContactsWaitCommand,
@@ -57965,6 +60438,7 @@ const COMMANDS = {
 	whoami: WhoamiCommand,
 	signal: SignalCommand,
 	doctor: DoctorCommand,
+	"machine:doctor": MachineDoctorCommand,
 	"emails:latest": EmailsLatestCommand,
 	"emails:watch": EmailsWatchCommand,
 	"emails:wait": EmailsWaitCommand,