openmeld 0.3.210 → 0.3.212

package/dist/agents-Y-UJ74By.js

@@ -0,0 +1,4153 @@
+#!/usr/bin/env node
+
+import { t as isLoopbackHostname } from "./loopback-hostname-DHQPKq8N.js";
+import { Cn as listAgentTargetStates, Fn as parseAgentEnabledOption, In as sortAgentRegistrations, Ln as repairBuiltinControllerInstall, Mn as updateAgentRegistrations, Nn as normalizeAgentId, On as removeAgentCustomTarget, Pn as normalizeAgentIds, Ra as resolveRuntimeContext, Sn as listAgentRegistrations, Tn as readAgentRuntimeConfigHealth, Xt as DAEMON_SERVICE_WAKEABILITY_ADVISORY_ANOMALIES, _o as compareAgentControllerRefsForDisplay, bn as createRegistrationFromCatalogTarget, jn as updateAgentCustomTarget, kn as resolveAgentTargetState, pa as toErrorMessage, si as buildAgentControllerRef, ui as createAgentControllerInterfaceDisplayRows, xn as listAgentCustomTargets, yn as addAgentCustomTarget } from "./daemon-service-update-coordinator-DcjOzGu1.js";
+import { $n as runInteractivePrompt, A as buildDaemonStartNeedsAttentionCard, B as resolveDaemonServiceParticipationStatus, F as emitCliJsonEnvelope, Jn as renderInfoCard, Qn as isReturnKeypress, Zn as promptTextEntry, _ as buildDaemonBackgroundStartFailure, a as runDaemonBackgroundStartForDecision, dt as collectLocalAgentControllerInventory, ht as resolveAgentControllerInterfaceSnapshot, j as runDaemonStartDecisionPrompt, k as buildDaemonStartDeferredCard, l as runDaemonReinstall, qn as buildTextInfoCardLines, s as runDaemonInstall, v as buildSystemServiceStartupFailureReportFromVerdict } from "./service-CTG3_X0o.js";
+import { Vt as readDaemonServiceContract } from "./daemon-service-runtime-CWTlAhZY.js";
+import { Ft as buildBuiltinAgentSelectionExamples, Gt as createPresenter, It as getBuiltinAgentSelectionOptionalArguments, Kt as sanitizeTerminalDisplayText, Lt as getBuiltinAgentSelectionRequiredArguments, Pt as buildBuiltinAgentSelectionCommand, Wt as formatAgentOverviewPayload, g as canUseInteractivePrompts, i as formatDaemonInstallFailedMessage, p as runDaemonInstallDecisionPrompt, zt as validateBuiltinAgentSelectionInput } from "./elapsed-time-iFOSSUJo.js";
+import { i as normalizeGatewayBaseUrlOrNull, l as DEFAULT_RUNTIME_AGENT_TRANSPORT_MODE } from "./base-url-C6sHRNGu.js";
+import { c as formatOpenMeldCliTextBlock, i as formatInlineOpenMeldCliCommands, o as formatOpenMeldCliCommands } from "./openmeld-environment-target-NtJYJe1D.js";
+import { r as waitForOpenMeldToolsUpdateCompletion } from "./openmeld-tools-update-join-DS_EIL5q.js";
+import { isAbsolute } from "node:path";
+import pc from "picocolors";
+import { cancel, isCancel, select } from "@clack/prompts";
+//#region src/system/local-service-participation-gate.ts
+function shouldRequireDaemonServiceParticipation(localDemand) {
+	return localDemand?.decision === "keep_running";
+}
+async function runDaemonServiceParticipationGate(input) {
+	const forceRefresh = input.forceRefresh === true;
+	if (!shouldRunDaemonServiceParticipationGate({
+		...input,
+		forceRefresh
+	})) return { status: "aligned" };
+	const initialStatus = await resolveDaemonServiceParticipationStatus();
+	if (isReadyAdvisoryServiceDrift(initialStatus)) {
+		const codePrefix = resolveDaemonServiceParticipationCodePrefix(input.intent);
+		if (input.autoRepair === true) return await runDaemonServiceParticipationRefresh({
+			input,
+			codePrefix,
+			expectedVersion: initialStatus.expectedVersion,
+			scheduleBackgroundUpdate: hasServiceVersionAdvisory(initialStatus)
+		});
+	}
+	if (isRunningAdvisoryOnlyServiceDrift(initialStatus)) {
+		const accountIssue = await resolveDaemonServiceAccountAlignmentIssue(input);
+		if (!accountIssue) return { status: "aligned" };
+		const codePrefix = resolveDaemonServiceParticipationCodePrefix(input.intent);
+		if (input.autoRepair === true) return await runDaemonServiceParticipationRefresh({
+			input,
+			codePrefix,
+			expectedVersion: initialStatus.expectedVersion,
+			accountIssue
+		});
+		renderDaemonStartNeedsAttention({
+			presenter: input.presenter,
+			codePrefix,
+			summary: accountIssue.summary
+		});
+		input.presenter.line({
+			code: `${codePrefix}.account_alignment_failed`,
+			text: accountIssue.summary,
+			data: { reasonCode: accountIssue.reasonCode }
+		});
+		return { status: "needs_attention" };
+	}
+	if (forceRefresh && initialStatus.kind === "ready") return await runDaemonServiceParticipationRefresh({
+		input,
+		codePrefix: resolveDaemonServiceParticipationCodePrefix(input.intent),
+		expectedVersion: initialStatus.expectedVersion
+	});
+	if (initialStatus.kind === "ready") {
+		const accountIssue = await resolveDaemonServiceAccountAlignmentIssue(input);
+		if (!accountIssue) return { status: "aligned" };
+		const codePrefix = resolveDaemonServiceParticipationCodePrefix(input.intent);
+		if (input.autoRepair === true) return await runDaemonServiceParticipationRefresh({
+			input,
+			codePrefix,
+			expectedVersion: initialStatus.expectedVersion,
+			accountIssue
+		});
+		renderDaemonStartNeedsAttention({
+			presenter: input.presenter,
+			codePrefix,
+			summary: accountIssue.summary
+		});
+		input.presenter.line({
+			code: `${codePrefix}.account_alignment_failed`,
+			text: accountIssue.summary,
+			data: { reasonCode: accountIssue.reasonCode }
+		});
+		return { status: "needs_attention" };
+	}
+	const codePrefix = resolveDaemonServiceParticipationCodePrefix(input.intent);
+	const installStageResult = await runDaemonServiceParticipationInstallStage({
+		input,
+		codePrefix,
+		status: initialStatus
+	});
+	if (installStageResult.result) return installStageResult.result;
+	return await runDaemonServiceParticipationActionStage({
+		input,
+		codePrefix,
+		status: installStageResult.status
+	});
+}
+function isRunningAdvisoryOnlyServiceDrift(status) {
+	return status.kind === "needs_repair" && status.runtimeStatus === "running" && status.anomalyCodes.length > 0 && status.anomalyCodes.every((code) => DAEMON_SERVICE_WAKEABILITY_ADVISORY_ANOMALIES.has(code));
+}
+function isReadyAdvisoryServiceDrift(status) {
+	return status.kind === "ready" && Array.isArray(status.advisoryAnomalyCodes) && status.advisoryAnomalyCodes.length > 0;
+}
+function hasServiceVersionAdvisory(status) {
+	return Boolean(status.advisoryAnomalyCodes?.some((code) => code === "version_outdated" || code === "bundle_version_drift"));
+}
+function shouldRunDaemonServiceParticipationGate(input) {
+	const canActWithoutPrompt = input.autoRepair === true && (input.resolvedView === "human" || input.resolvedView === "agent" && (input.forcePrompt === true || input.forceRefresh === true));
+	return (input.resolvedView === "human" && (input.allowPrompt || input.autoRepair === true) || canActWithoutPrompt) && (input.forcePrompt === true || input.forceRefresh === true || shouldRequireDaemonServiceParticipation(input.localDemand));
+}
+async function runDaemonServiceParticipationInstallStage(input) {
+	if (input.status.kind !== "missing" && input.status.kind !== "outdated") return { status: input.status };
+	const installableStatus = input.status;
+	if (input.input.autoRepair === true) {
+		try {
+			await runDaemonServiceParticipationInstallAction({
+				input: input.input,
+				status: installableStatus
+			});
+		} catch {
+			renderDaemonStartNeedsAttention({
+				presenter: input.input.presenter,
+				codePrefix: input.codePrefix,
+				summary: formatDaemonInstallFailedMessage(installableStatus.kind)
+			});
+			return {
+				status: installableStatus,
+				result: { status: "needs_attention" }
+			};
+		}
+		return await resolveDaemonServiceParticipationStatusAfterInstall(input);
+	}
+	const installResult = await runDaemonInstallDecisionPrompt({
+		kind: installableStatus.kind,
+		...installableStatus.kind === "outdated" ? { installedVersion: installableStatus.installedVersion } : {},
+		expectedVersion: installableStatus.expectedVersion,
+		emitLine: (text) => {
+			input.input.presenter.line({
+				code: `${input.codePrefix}.install`,
+				text
+			});
+		},
+		installService: async () => {
+			await runDaemonServiceParticipationInstallAction({
+				input: input.input,
+				status: installableStatus
+			});
+		}
+	});
+	if (installResult === "cancelled") return {
+		status: installableStatus,
+		result: { status: "cancelled" }
+	};
+	if (installResult === "failed") return {
+		status: installableStatus,
+		result: { status: "needs_attention" }
+	};
+	if (installResult === "not_now" || !shouldStartAfterDaemonInstall(input.input.intent)) return {
+		status: installableStatus,
+		result: { status: "declined" }
+	};
+	return await resolveDaemonServiceParticipationStatusAfterInstall(input);
+}
+async function runDaemonServiceParticipationInstallAction(input) {
+	if (input.status.kind === "outdated") {
+		input.input.serviceProgress?.detail({
+			code: "daemon.participation.refresh.updating",
+			text: "Updating OpenMeld Service..."
+		});
+		await runDaemonServiceSafeRefresh({
+			openMeldProfileId: input.input.openMeldProfileId,
+			gatewayUrl: input.input.gatewayUrl,
+			suppressHumanResultCard: input.input.suppressRefreshHumanResultCard,
+			view: input.input.view
+		});
+		return;
+	}
+	await runDaemonInstall({
+		...input.input.gatewayUrl ? { gatewayUrl: input.input.gatewayUrl } : {},
+		...input.input.openMeldProfileId ? { profile: input.input.openMeldProfileId } : {},
+		view: input.input.view
+	}, {
+		suppressHumanOutput: shouldSuppressHumanInstallOutput(input.input.intent),
+		...input.input.serviceProgress ? { serviceProgress: input.input.serviceProgress } : {}
+	});
+}
+async function resolveDaemonServiceParticipationStatusAfterInstall(input) {
+	const refreshedStatus = await resolveDaemonServiceParticipationStatus();
+	if (refreshedStatus.kind === "ready") return {
+		status: refreshedStatus,
+		result: { status: "aligned" }
+	};
+	if (refreshedStatus.kind === "missing" || refreshedStatus.kind === "outdated") {
+		renderDaemonStartNeedsAttention({
+			presenter: input.input.presenter,
+			codePrefix: input.codePrefix,
+			summary: refreshedStatus.kind === "missing" ? formatDaemonInstallFailedMessage("missing") : formatDaemonInstallFailedMessage("outdated")
+		});
+		return {
+			status: refreshedStatus,
+			result: { status: "needs_attention" }
+		};
+	}
+	return { status: refreshedStatus };
+}
+async function runDaemonServiceSafeRefresh(input) {
+	return await runDaemonReinstall({
+		agentOverviewHandled: true,
+		...input.scheduleBackgroundUpdate ? { displayAction: "update" } : {},
+		...input.gatewayUrl ? { gatewayUrl: input.gatewayUrl } : {},
+		...input.openMeldProfileId ? { profile: input.openMeldProfileId } : {},
+		view: input.view
+	}, {
+		skipConfirm: true,
+		startAfterInstallMode: "always",
+		suppressAgentOverview: true,
+		...input.suppressHumanResultCard !== void 0 ? { suppressHumanResultCard: input.suppressHumanResultCard } : {},
+		suppressInstallOutput: true,
+		...input.forceReinstall === true ? { forceReinstall: true } : {}
+	});
+}
+async function runDaemonBackgroundStartForParticipation(input) {
+	return await runDaemonBackgroundStartForDecision({
+		gatewayUrl: input.gatewayUrl,
+		...input.openMeldProfileId ? { profile: input.openMeldProfileId } : {},
+		...input.serviceProgress ? { serviceProgress: input.serviceProgress } : {},
+		...input.suppressStartSpinner === true ? { suppressStartSpinner: true } : {},
+		view: input.view
+	});
+}
+async function runDaemonServiceParticipationActionStage(input) {
+	if (input.status.kind === "needs_repair") return await runDaemonServiceParticipationRefresh({
+		input: input.input,
+		codePrefix: input.codePrefix,
+		expectedVersion: input.status.expectedVersion
+	});
+	if (input.status.kind !== "not_running") return { status: "aligned" };
+	if (input.input.autoRepair === true) return await mapDaemonBackgroundStartResult(await runDaemonBackgroundStartForParticipation({
+		openMeldProfileId: input.input.openMeldProfileId,
+		gatewayUrl: input.input.gatewayUrl,
+		serviceProgress: input.input.serviceProgress,
+		suppressStartSpinner: input.input.suppressStartSpinner,
+		view: input.input.view
+	}), {
+		expectedVersion: input.status.expectedVersion,
+		presenter: input.input.presenter,
+		codePrefix: input.codePrefix
+	});
+	return await mapDaemonBackgroundStartResult(await runDaemonStartDecisionPrompt({ startService: async () => await runDaemonBackgroundStartForParticipation({
+		openMeldProfileId: input.input.openMeldProfileId,
+		gatewayUrl: input.input.gatewayUrl,
+		serviceProgress: input.input.serviceProgress,
+		suppressStartSpinner: input.input.suppressStartSpinner,
+		view: input.input.view
+	}) }), {
+		expectedVersion: input.status.expectedVersion,
+		presenter: input.input.presenter,
+		codePrefix: input.codePrefix
+	});
+}
+async function runDaemonServiceParticipationRefresh(input) {
+	emitServiceAccountRefreshNotice(input);
+	try {
+		input.input.serviceProgress?.detail({
+			code: "daemon.participation.refresh.updating",
+			text: "Updating OpenMeld Service..."
+		});
+		const refreshOutcome = await runDaemonServiceSafeRefresh({
+			openMeldProfileId: input.input.openMeldProfileId,
+			gatewayUrl: input.input.gatewayUrl,
+			suppressHumanResultCard: input.input.suppressRefreshHumanResultCard,
+			view: input.input.view,
+			forceReinstall: shouldForceDaemonServiceReinstall({
+				accountIssue: input.accountIssue,
+				forceRefresh: input.input.forceRefresh
+			}),
+			...input.scheduleBackgroundUpdate === void 0 ? {} : { scheduleBackgroundUpdate: input.scheduleBackgroundUpdate }
+		});
+		if (isCancelledDaemonServiceRefresh(refreshOutcome)) return { status: "cancelled" };
+		if (isStoppedDaemonServiceRefresh(refreshOutcome)) {
+			const startMapped = await mapDaemonBackgroundStartResult(await runDaemonBackgroundStartForParticipation({
+				openMeldProfileId: input.input.openMeldProfileId,
+				gatewayUrl: input.input.gatewayUrl,
+				serviceProgress: input.input.serviceProgress,
+				suppressStartSpinner: input.input.suppressStartSpinner,
+				view: input.input.view
+			}), {
+				expectedVersion: input.expectedVersion,
+				presenter: input.input.presenter,
+				codePrefix: input.codePrefix
+			});
+			if (startMapped.status !== "aligned") return startMapped;
+			const accountIssueAfterStart = await resolveDaemonServiceAccountAlignmentIssue(input.input);
+			if (accountIssueAfterStart) {
+				renderDaemonStartNeedsAttention({
+					presenter: input.input.presenter,
+					codePrefix: input.codePrefix,
+					summary: accountIssueAfterStart.summary
+				});
+				input.input.presenter.line({
+					code: `${input.codePrefix}.account_alignment_failed`,
+					text: accountIssueAfterStart.summary,
+					data: { reasonCode: accountIssueAfterStart.reasonCode }
+				});
+				return { status: "needs_attention" };
+			}
+			return startMapped;
+		}
+		const scheduled = await completeScheduledServiceRefresh({
+			outcome: refreshOutcome,
+			presenter: input.input.presenter,
+			codePrefix: input.codePrefix
+		});
+		if (!refreshOutcome.ok && (refreshOutcome.result === "start_failed" || refreshOutcome.result === "start_blocked") && (refreshOutcome.startFailureVerdict?.jobDiagnostics || refreshOutcome.startFailureVerdict?.localMachineIssue)) return renderRefreshStartFailure({
+			codePrefix: input.codePrefix,
+			presenter: input.input.presenter,
+			verdict: refreshOutcome.startFailureVerdict
+		});
+		if (!(scheduled || refreshOutcome.ok && (refreshOutcome.result === "already_healthy" || refreshOutcome.result === "completed") && refreshOutcome.serviceState === "running")) throw new Error(`OpenMeld Service refresh did not complete: ${refreshOutcome.result}`);
+	} catch (error) {
+		renderRefreshFailureIfVisible({
+			codePrefix: input.codePrefix,
+			presenter: input.input.presenter,
+			summary: "OpenMeld Service was repaired, but it is not running yet. Local Wake work will keep waiting until OpenMeld Service starts. Run `openmeld service start`.",
+			suppressed: input.input.suppressRefreshHumanResultCard === true
+		});
+		return {
+			errorMessage: toErrorMessage(error),
+			status: "needs_attention"
+		};
+	}
+	const refreshedStatus = await resolveDaemonServiceParticipationStatus({ expectedVersion: input.expectedVersion });
+	const accountIssue = await resolveDaemonServiceAccountAlignmentIssue(input.input);
+	if (refreshedStatus.kind === "ready" && !accountIssue) return { status: "aligned" };
+	renderDaemonStartNeedsAttention({
+		presenter: input.input.presenter,
+		codePrefix: input.codePrefix,
+		summary: accountIssue?.summary ?? summarizeDaemonServiceParticipationStatus(refreshedStatus)
+	});
+	if (accountIssue) input.input.presenter.line({
+		code: `${input.codePrefix}.account_alignment_failed`,
+		text: accountIssue.summary,
+		data: { reasonCode: accountIssue.reasonCode }
+	});
+	return { status: "needs_attention" };
+}
+function emitServiceAccountRefreshNotice(input) {
+	if (!input.accountIssue) return;
+	input.input.presenter.line({
+		code: `${input.codePrefix}.account_alignment_refresh`,
+		text: input.accountIssue.summary,
+		data: { reasonCode: input.accountIssue.reasonCode }
+	});
+}
+async function completeScheduledServiceRefresh(input) {
+	if (!(input.outcome.ok && input.outcome.result === "scheduled")) return false;
+	await waitForOpenMeldToolsUpdateCompletion({
+		operationId: input.outcome.jobId,
+		onWaiting: (operation) => {
+			input.presenter.line({
+				code: `${input.codePrefix}.update.waiting`,
+				text: "OpenMeld is finishing its background update. This command will continue automatically when it finishes.",
+				data: {
+					operationId: operation.operationId,
+					phase: operation.phase,
+					targetVersion: operation.targetVersion
+				}
+			});
+		}
+	});
+	return true;
+}
+function renderRefreshFailureIfVisible(input) {
+	if (input.suppressed) return;
+	renderDaemonStartNeedsAttention({
+		autoRepairAttempted: true,
+		codePrefix: input.codePrefix,
+		presenter: input.presenter,
+		summary: input.summary
+	});
+}
+function shouldForceDaemonServiceReinstall(input) {
+	return input.accountIssue !== void 0 || input.forceRefresh === true;
+}
+function renderRefreshStartFailure(input) {
+	const report = buildSystemServiceStartupFailureReportFromVerdict(input.verdict, { autoRepairAttempted: true });
+	renderInfoCard({
+		presenter: input.presenter,
+		title: report.title,
+		codePrefix: `${input.codePrefix}.failed`,
+		rows: report.rows
+	});
+	const { outcome: _outcome, ...failure } = buildDaemonBackgroundStartFailure(input.verdict);
+	return {
+		...failure,
+		status: "needs_attention"
+	};
+}
+async function resolveDaemonServiceAccountAlignmentIssue(input) {
+	const expectedProfileId = normalizeOptionalText$1(input.openMeldProfileId);
+	const expectedOwnerUserId = normalizeOptionalText$1(input.expectedOwnerUserId);
+	const expectedGatewayUrl = normalizeGatewayBaseUrlOrNull(input.gatewayUrl);
+	if (!(expectedProfileId || expectedOwnerUserId || expectedGatewayUrl)) return null;
+	const contract = await readDaemonServiceContract().catch(() => null);
+	if (!contract) return {
+		reasonCode: "service_contract.missing",
+		summary: "OpenMeld Service is running, but this setup could not verify the service account contract for this computer."
+	};
+	const contractOwnerUserId = normalizeOptionalText$1(contract.ownerUserId);
+	if (expectedOwnerUserId && contractOwnerUserId && contractOwnerUserId !== expectedOwnerUserId) return {
+		reasonCode: "service_contract.owner_mismatch",
+		summary: "OpenMeld Service is running for a different OpenMeld account. This setup will reconnect OpenMeld Service to the current Web account."
+	};
+	if (expectedProfileId && contract.profileId && contract.profileId !== expectedProfileId) return {
+		reasonCode: "service_contract.profile_mismatch",
+		summary: "OpenMeld Service is running for a different OpenMeld account. This setup will reconnect OpenMeld Service to the current Web account."
+	};
+	if (expectedOwnerUserId && expectedProfileId && !(contractOwnerUserId || contract.profileId)) return {
+		reasonCode: "service_contract.owner_unverified",
+		summary: "OpenMeld Service is running, but this setup could not verify that OpenMeld Service belongs to the current Web account. This setup will reconnect OpenMeld Service to the current Web account."
+	};
+	const contractGatewayUrl = normalizeGatewayBaseUrlOrNull(contract.gatewayUrl);
+	if (expectedGatewayUrl && contractGatewayUrl && contractGatewayUrl !== expectedGatewayUrl) return {
+		reasonCode: "service_contract.gateway_mismatch",
+		summary: "OpenMeld Service is running for a different OpenMeld gateway. This setup will reconnect OpenMeld Service to the current Web account."
+	};
+	return null;
+}
+function normalizeOptionalText$1(value) {
+	const normalized = String(value ?? "").trim();
+	return normalized.length > 0 ? normalized : null;
+}
+function resolveDaemonServiceParticipationCodePrefix(intent) {
+	switch (intent) {
+		case "start": return "start.service";
+		case "space_create_join": return "space.create_join.service";
+		case "space_join": return "space.join.service";
+		case "space_add_members": return "space.add_members.service";
+		default: throw new Error(`Unknown local service participation intent: ${intent}`);
+	}
+}
+function isCancelledDaemonServiceRefresh(outcome) {
+	return !outcome.ok && outcome.result === "cancelled";
+}
+function isStoppedDaemonServiceRefresh(outcome) {
+	return outcome.ok && (outcome.result === "already_healthy" || outcome.result === "completed" || outcome.result === "stopped_safe") && outcome.serviceState === "stopped";
+}
+function shouldStartAfterDaemonInstall(_intent) {
+	return true;
+}
+function shouldSuppressHumanInstallOutput(intent) {
+	return intent !== "start";
+}
+async function mapDaemonBackgroundStartResult(result, input) {
+	if (typeof result === "object") return {
+		status: "needs_attention",
+		errorMessage: result.errorMessage,
+		...result.localMachineIssue ? { localMachineIssue: result.localMachineIssue } : {}
+	};
+	if (result === "started") {
+		const refreshedStatus = await resolveDaemonServiceParticipationStatus({ expectedVersion: input.expectedVersion });
+		if (refreshedStatus.kind === "ready") return { status: "aligned" };
+		renderDaemonStartNeedsAttention({
+			presenter: input.presenter,
+			codePrefix: input.codePrefix,
+			summary: summarizeDaemonServiceParticipationStatus(refreshedStatus)
+		});
+		return { status: "needs_attention" };
+	}
+	if (result === "deferred_with_card") return { status: "declined" };
+	if (result === "cancelled") return { status: "cancelled" };
+	if (result === "not_now") {
+		renderDaemonStartDeferred({
+			presenter: input.presenter,
+			codePrefix: input.codePrefix
+		});
+		return { status: "declined" };
+	}
+	if (result === "failed") {
+		renderDaemonStartNeedsAttention({
+			presenter: input.presenter,
+			codePrefix: input.codePrefix,
+			summary: "OpenMeld could not finish starting OpenMeld Service."
+		});
+		return { status: "needs_attention" };
+	}
+	return { status: "needs_attention" };
+}
+function summarizeDaemonServiceParticipationStatus(status) {
+	switch (status.kind) {
+		case "missing": return formatDaemonInstallFailedMessage("missing");
+		case "outdated": return formatDaemonInstallFailedMessage("outdated");
+		case "needs_repair": return status.detail;
+		case "not_running": return "OpenMeld could not finish starting OpenMeld Service.";
+		case "ready": return "OpenMeld Service is running.";
+		default: return "OpenMeld Service still needs attention on this device.";
+	}
+}
+function renderDaemonStartDeferred(input) {
+	const card = buildDaemonStartDeferredCard();
+	renderInfoCard({
+		presenter: input.presenter,
+		title: card.title,
+		codePrefix: `${input.codePrefix}.deferred`,
+		rows: card.rows
+	});
+}
+function renderDaemonStartNeedsAttention(input) {
+	const card = buildDaemonStartNeedsAttentionCard({
+		summary: input.summary,
+		...input.nextStep ? { nextStep: input.nextStep } : {},
+		...input.detail ? { detail: input.detail } : {},
+		...input.autoRepairAttempted ? { autoRepairAttempted: input.autoRepairAttempted } : {}
+	});
+	renderInfoCard({
+		presenter: input.presenter,
+		title: card.title,
+		codePrefix: `${input.codePrefix}.failed`,
+		rows: card.rows
+	});
+}
+//#endregion
+//#region src/space/web-url.ts
+function buildSpaceWebUrl(baseUrl, organizationSlug, spaceId, options) {
+	const url = new URL(resolveGatewayWebOrigin(baseUrl));
+	const orgSlug = requireOrganizationSlug(organizationSlug);
+	url.pathname = `/o/${encodeURIComponent(orgSlug)}/spaces/${encodeURIComponent(spaceId)}`;
+	url.search = "";
+	const profileId = normalizeOptionalText(options?.profileId);
+	if (profileId) url.searchParams.set("profileId", profileId);
+	url.hash = "";
+	return url.toString();
+}
+function resolveGatewayWebOrigin(baseUrl) {
+	const url = new URL(baseUrl);
+	if (isLoopbackHostname(url.hostname) && url.port === LOCAL_GATEWAY_PORT) url.port = LOCAL_WEB_PORT;
+	const pair = OPENMELD_ORIGIN_HOST_PAIRS.find(({ gateway }) => gateway === url.hostname);
+	if (pair) {
+		url.hostname = pair.web;
+		url.port = "";
+		url.protocol = "https:";
+	}
+	url.pathname = "";
+	url.search = "";
+	url.hash = "";
+	return url.origin;
+}
+function resolveSpaceWebGatewayOrigin(spaceUrl) {
+	const url = new URL(spaceUrl.toString());
+	const pair = OPENMELD_ORIGIN_HOST_PAIRS.find(({ web }) => web === url.hostname);
+	if (pair) {
+		if (url.protocol !== "https:" || url.port.length > 0) throw new Error(TRUSTED_SPACE_WEB_ORIGIN_ERROR);
+		url.hostname = pair.gateway;
+	} else if (isLoopbackHostname(url.hostname) && (url.protocol === "http:" || url.protocol === "https:") && url.port === LOCAL_WEB_PORT) url.port = LOCAL_GATEWAY_PORT;
+	else throw new Error(TRUSTED_SPACE_WEB_ORIGIN_ERROR);
+	url.pathname = "";
+	url.search = "";
+	url.hash = "";
+	return url.origin;
+}
+function normalizeOptionalText(value) {
+	const normalized = String(value ?? "").trim();
+	return normalized.length > 0 ? normalized : null;
+}
+function requireOrganizationSlug(value) {
+	const normalized = normalizeOptionalText(value);
+	if (!normalized) throw new Error("Active organization slug is required to build a Space URL.");
+	return normalized;
+}
+const OPENMELD_ORIGIN_HOST_PAIRS = [
+	{
+		gateway: "gateway.openmeld.ai",
+		web: "openmeld.ai"
+	},
+	{
+		gateway: "gateway.staging.openmeld.ai",
+		web: "staging.openmeld.ai"
+	},
+	{
+		gateway: "gateway.openmeld.invalid",
+		web: "openmeld.invalid"
+	}
+];
+const LOCAL_GATEWAY_PORT = "8080";
+const LOCAL_WEB_PORT = "3000";
+const TRUSTED_SPACE_WEB_ORIGIN_ERROR = "Space URL must use a trusted OpenMeld Web origin. For a custom local environment, pass --gateway-url explicitly.";
+//#endregion
+//#region src/runtime/retry-delay.ts
+const RETRY_DELAY_SCHEDULE_MS = [
+	250,
+	500,
+	1e3,
+	2e3
+];
+const RETRY_DELAY_CAP_MS = 2e3;
+function computeRetryDelayMs(attempt) {
+	const index = Math.max(0, Math.min(attempt - 1, RETRY_DELAY_SCHEDULE_MS.length - 1));
+	return RETRY_DELAY_SCHEDULE_MS[index] ?? RETRY_DELAY_CAP_MS;
+}
+//#endregion
+//#region src/agents/agent-overview.ts
+function emitAgentsAgentOverview(input) {
+	input.presenter.data({
+		code: `agents.${input.command}.agent_overview`,
+		payload: formatAgentOverviewPayload(buildAgentsAgentOverviewPayload(input.command))
+	});
+}
+function buildBuiltinAgentSelectionOverviewPayload(command) {
+	return {
+		commands: buildBuiltinAgentSelectionExamples({
+			command,
+			includeViewFlag: true
+		}),
+		optionalArguments: getBuiltinAgentSelectionOptionalArguments(command),
+		requiredArguments: getBuiltinAgentSelectionRequiredArguments(command)
+	};
+}
+function buildAgentsAgentOverviewPayload(command) {
+	switch (command) {
+		case "menu": return {
+			summary: "Manage local OpenMeld-connected agents, agent visibility in Space, and custom agent targets.",
+			requiredArguments: [],
+			optionalArguments: [],
+			commands: [
+				"openmeld agents --view agent",
+				"openmeld agents detect --view agent",
+				"openmeld agents list --view agent",
+				...buildBuiltinAgentSelectionExamples({
+					command: "enable",
+					includeViewFlag: true
+				}),
+				"openmeld agents manage --view agent"
+			],
+			stages: ["Inspect available agents and current registrations.", "Choose an explicit subcommand for detect, list, enable, disable, show, config, or custom targets."],
+			notes: ["Agent view does not open the human interactive agents menu.", "Use explicit subcommands to keep automation deterministic."],
+			humanActionRequired: false
+		};
+		case "manage": return {
+			summary: "Review connected agent IDs and decide whether to inspect, enable, or disable them with explicit commands.",
+			requiredArguments: [],
+			optionalArguments: [],
+			commands: [
+				"openmeld agents list --view agent",
+				"openmeld agents show <agent-id> --view agent",
+				...buildBuiltinAgentSelectionExamples({
+					command: "repair",
+					includeViewFlag: true
+				}),
+				"openmeld agents config <agent-id> --enabled true|false --view agent",
+				...buildBuiltinAgentSelectionExamples({
+					command: "disable",
+					includeViewFlag: true
+				})
+			],
+			stages: ["List connected agent IDs.", "Inspect one agent or change enabled state with explicit subcommands."],
+			notes: ["The manage menu is interactive in human view only."],
+			humanActionRequired: true
+		};
+		case "detect": return {
+			summary: "Detect supported local AI tools on this computer and report which ones are available to OpenMeld now.",
+			requiredArguments: [],
+			optionalArguments: [],
+			commands: ["openmeld agents detect --view agent"],
+			stages: ["Scan supported builtin agent targets.", "Return detected agents and whether each one is immediately selectable."],
+			notes: [],
+			humanActionRequired: false
+		};
+		case "list": return {
+			summary: "List currently registered OpenMeld agent IDs that can wake and reply in Space.",
+			requiredArguments: [],
+			optionalArguments: [],
+			commands: ["openmeld agents list --view agent"],
+			stages: ["Load agent registrations from your local OpenMeld config.", "Return registered agents and enabled state."],
+			notes: [],
+			humanActionRequired: false
+		};
+		case "repair": return {
+			summary: "Repair one or more builtin local agents so OpenMeld can start them again on this computer.",
+			...buildBuiltinAgentSelectionOverviewPayload("repair"),
+			stages: ["Resolve a fresh launch contract for each requested builtin agent.", "Persist the repaired machine launch contract into OpenMeld runtime state."],
+			notes: ["Repair does not enable or disable agents. It refreshes how OpenMeld starts them on this computer."],
+			humanActionRequired: false
+		};
+		case "show": return {
+			summary: "Show one registered agent ID, its current OpenMeld config, and how OpenMeld will wake it.",
+			requiredArguments: ["<agent-id>"],
+			optionalArguments: [],
+			commands: ["openmeld agents show <agent-id> --view agent"],
+			stages: ["Resolve the requested agent ID.", "Return the current registration and effective runtime config."],
+			notes: [],
+			humanActionRequired: false
+		};
+		case "enable": return {
+			summary: "Enable one or more detected agents so new Space @mentions can wake them.",
+			...buildBuiltinAgentSelectionOverviewPayload("enable"),
+			stages: [
+				"Resolve selectable detected agents.",
+				"Register or re-enable them in your local OpenMeld config.",
+				"Return per-agent enable summary."
+			],
+			notes: ["Use `openmeld agents detect --view agent` first if you need to discover selectable ids."],
+			humanActionRequired: false
+		};
+		case "disable": return {
+			summary: "Disable one or more registered agents so new Space @mentions stop waking them.",
+			...buildBuiltinAgentSelectionOverviewPayload("disable"),
+			stages: [
+				"Resolve requested registered agent ids.",
+				"Update enabled=false in your local OpenMeld config.",
+				"Return per-agent disable summary."
+			],
+			notes: [],
+			humanActionRequired: false
+		};
+		case "config": return {
+			summary: "Update a registered agent's OpenMeld configuration with explicit flags.",
+			requiredArguments: ["<agent-id>", "--enabled true|false"],
+			optionalArguments: [],
+			commands: ["openmeld agents config <agent-id> --enabled true --view agent", "openmeld agents config <agent-id> --enabled false --view agent"],
+			stages: [
+				"Resolve the requested registered agent id.",
+				"Apply explicit config updates.",
+				"Return the updated effective config."
+			],
+			notes: [],
+			humanActionRequired: false
+		};
+		case "custom_list": return {
+			summary: "List custom agent targets stored in your local OpenMeld config and whether they are currently registered.",
+			requiredArguments: [],
+			optionalArguments: [],
+			commands: ["openmeld agents custom list --view agent"],
+			stages: ["Load configured custom targets.", "Project whether each target is registered and enabled."],
+			notes: [],
+			humanActionRequired: false
+		};
+		case "custom_add": return {
+			summary: "Add a custom agent target to your local OpenMeld config with an absolute directory path.",
+			requiredArguments: ["--name <name>", "--dir <absolute-path>"],
+			optionalArguments: ["--id <id>"],
+			commands: ["openmeld agents custom add --name <name> --dir <absolute-path> --view agent", "openmeld agents custom add --id <id> --name <name> --dir <absolute-path> --view agent"],
+			stages: [
+				"Validate explicit custom target input.",
+				"Save the target in your local OpenMeld config.",
+				"Return the created custom target."
+			],
+			notes: [],
+			humanActionRequired: false
+		};
+		case "custom_update": return {
+			summary: "Update a custom agent target while keeping its ID stable.",
+			requiredArguments: ["--id <id>", "one update: --name <name> | --dir <absolute-path>"],
+			optionalArguments: [],
+			commands: ["openmeld agents custom update --id <id> --name <name> --view agent", "openmeld agents custom update --id <id> --dir <absolute-path> --view agent"],
+			stages: [
+				"Resolve the custom target id.",
+				"Apply explicit updates.",
+				"Return the updated target and changed fields."
+			],
+			notes: [],
+			humanActionRequired: false
+		};
+		case "custom_remove": return {
+			summary: "Remove a custom agent target that is not currently registered.",
+			requiredArguments: ["--id <id>"],
+			optionalArguments: [],
+			commands: ["openmeld agents custom remove --id <id> --view agent"],
+			stages: [
+				"Resolve the custom target id.",
+				"Verify it is not currently registered.",
+				"Remove it from your local OpenMeld config and report the result."
+			],
+			notes: ["Install records are kept after removal; clean them up with OpenMeld skills commands when needed."],
+			humanActionRequired: false
+		};
+		default: return assertNever(command);
+	}
+}
+function assertNever(value) {
+	throw new Error(`unsupported agents agent overview command: ${String(value)}`);
+}
+//#endregion
+//#region src/ui/visible-window.ts
+function clampNumber(value, min, max) {
+	if (!Number.isFinite(value)) return min;
+	if (value < min) return min;
+	if (value > max) return max;
+	return value;
+}
+function resolveAnchoredVisibleWindow(input) {
+	if (input.itemCount <= input.maxVisible) return {
+		start: 0,
+		end: input.itemCount
+	};
+	const start = clampNumber((input.anchorIndex === null ? 0 : clampNumber(input.anchorIndex, 0, input.itemCount - 1)) - Math.floor(input.maxVisible / 2), 0, input.itemCount - input.maxVisible);
+	return {
+		start,
+		end: Math.min(input.itemCount, start + input.maxVisible)
+	};
+}
+function resolveOffsetVisibleWindow(input) {
+	if (input.itemCount <= input.maxVisible) return {
+		start: 0,
+		end: input.itemCount
+	};
+	const maxStart = Math.max(0, input.itemCount - input.maxVisible);
+	const start = resolveVisibleWindowOffset(input.offset, maxStart);
+	return {
+		start,
+		end: Math.min(input.itemCount, start + input.maxVisible)
+	};
+}
+function resolveVisibleWindowOffset(offset, maxStart) {
+	if (!Number.isFinite(offset)) return offset > 0 ? maxStart : 0;
+	return clampNumber(offset, 0, maxStart);
+}
+//#endregion
+//#region src/ui/search-select.ts
+const PROMPT_SYMBOL_ACTIVE = pc.green("◇");
+const PROMPT_SYMBOL_CANCELLED = pc.red("■");
+const CURSOR_SYMBOL = pc.cyan("❯");
+const BAR_SYMBOL = pc.dim("│");
+const SINGLE_SELECTED_SYMBOL = pc.green("●");
+const SINGLE_UNSELECTED_SYMBOL = pc.dim("○");
+const MULTI_SELECTED_SYMBOL = pc.green("■");
+const MULTI_UNSELECTED_SYMBOL = pc.dim("□");
+const EMPTY_MATCH_LABEL = "No matches found";
+const DEFAULT_MAX_VISIBLE = 8;
+const PRINTABLE_SEARCH_INPUT_REGEX = /^[\x20-\x7E]+$/;
+function createSearchPromptState(input) {
+	const items = input.items.map(sanitizeSearchPromptItem);
+	const baseState = {
+		mode: input.mode,
+		message: sanitizeTerminalDisplayText(input.message, "single-line"),
+		noticeLines: (input.noticeLines ?? []).map((line) => sanitizeTerminalDisplayText(line, "single-line")),
+		items,
+		footerActions: (input.footerActions ?? []).map(sanitizeSearchPromptFooterAction),
+		footerActionsResolver: input.footerActionsResolver ?? null,
+		workbench: input.workbench === true,
+		allowBack: input.allowBack === true,
+		backLabel: sanitizeTerminalDisplayText(input.backLabel ?? "Back", "single-line"),
+		emptyLabel: sanitizeTerminalDisplayText(input.emptyLabel ?? EMPTY_MATCH_LABEL, "single-line"),
+		maxVisible: normalizeMaxVisible(input.maxVisible),
+		required: input.required === true,
+		readOnly: input.readOnly === true,
+		summaryCard: input.summaryCard === void 0 ? null : sanitizeSearchPromptSummaryCard(input.summaryCard),
+		selectedValues: dedupeValues(input.initialSelectedValues ?? []),
+		query: "",
+		activeRowIndex: 0
+	};
+	return syncSearchPromptState({
+		...baseState,
+		activeRowIndex: resolveInitialSearchPromptActiveRowIndex(baseState)
+	});
+}
+function sanitizeSearchPromptFooterAction(action) {
+	return {
+		...action,
+		label: sanitizeTerminalDisplayText(action.label, "single-line"),
+		...typeof action.icon === "string" ? { icon: sanitizeTerminalDisplayText(action.icon, "single-line") } : {},
+		...typeof action.hint === "string" ? { hint: sanitizeTerminalDisplayText(action.hint, "single-line") } : {}
+	};
+}
+function sanitizeSearchPromptItem(item) {
+	const normalizedItem = {
+		...item,
+		label: sanitizeTerminalDisplayText(item.label, "single-line"),
+		...typeof item.detail === "string" ? { detail: sanitizeTerminalDisplayText(item.detail, "single-line") } : {},
+		...typeof item.hint === "string" ? { hint: sanitizeTerminalDisplayText(item.hint, "single-line") } : {},
+		...typeof item.searchText === "string" ? { searchText: sanitizeTerminalDisplayText(item.searchText, "multi-line") } : {}
+	};
+	return {
+		...normalizedItem,
+		searchKey: buildSearchKey(normalizedItem)
+	};
+}
+function sanitizeSearchPromptSummaryCard(card) {
+	return {
+		...card,
+		title: sanitizeTerminalDisplayText(card.title, "single-line"),
+		rows: card.rows.map((row) => ({
+			label: sanitizeTerminalDisplayText(row.label, "single-line"),
+			value: sanitizeTerminalDisplayText(row.value, "single-line")
+		}))
+	};
+}
+function getSearchPromptViewModel(state) {
+	const filteredIndexes = getFilteredItemIndexes(state);
+	const footerActions = resolveSearchPromptFooterActions(state);
+	const rows = buildSearchPromptRows({
+		allowBack: state.allowBack,
+		filteredIndexes,
+		footerActions,
+		workbench: state.workbench
+	});
+	const activeRow = rows[state.activeRowIndex] ?? null;
+	const activeItemFilteredIndex = resolveSearchPromptActiveItemFilteredIndex({
+		activeRow,
+		filteredIndexes,
+		workbench: state.workbench
+	});
+	const visibleWindow = resolveAnchoredVisibleWindow({
+		itemCount: filteredIndexes.length,
+		anchorIndex: activeItemFilteredIndex,
+		maxVisible: state.maxVisible
+	});
+	return {
+		filteredIndexes,
+		rows,
+		activeRow,
+		activeItemFilteredIndex,
+		visibleRows: buildSearchPromptVisibleRows({
+			activeRow,
+			filteredIndexes,
+			footerActions,
+			state,
+			visibleWindow
+		}),
+		hiddenBefore: visibleWindow.start,
+		hiddenAfter: Math.max(0, filteredIndexes.length - visibleWindow.end)
+	};
+}
+function resolveSearchPromptActiveItemFilteredIndex(input) {
+	if (input.activeRow?.kind === "item") return input.activeRow.filteredIndex;
+	if (input.filteredIndexes.length === 0) return null;
+	return input.filteredIndexes.length - 1;
+}
+function updateSearchPromptState(state, action) {
+	switch (action.type) {
+		case "move": return moveSearchPromptCursor(state, action.delta);
+		case "query-append":
+			if (action.text.length === 0) return state;
+			return syncSearchPromptState({
+				...state,
+				query: `${state.query}${action.text}`
+			});
+		case "query-backspace":
+			if (state.query.length === 0) return state;
+			return syncSearchPromptState({
+				...state,
+				query: state.query.slice(0, -1)
+			});
+		case "query-clear":
+			if (state.query.length === 0) return state;
+			return syncSearchPromptState({
+				...state,
+				query: ""
+			});
+		case "set-query": return syncSearchPromptState({
+			...state,
+			query: action.query
+		});
+		case "toggle-active": return toggleSearchPromptActiveSelection(state);
+		case "set-selected": return syncSearchPromptState({
+			...state,
+			selectedValues: dedupeValues(action.selectedValues)
+		});
+		default: return state;
+	}
+}
+function getSearchPromptSelection(state) {
+	const viewModel = getSearchPromptViewModel(state);
+	if (viewModel.activeRow?.kind === "back") return state.workbench ? {
+		status: "back",
+		selectedValues: state.selectedValues
+	} : { status: "back" };
+	if (viewModel.activeRow?.kind === "action") {
+		const action = resolveSearchPromptFooterActions(state)[viewModel.activeRow.actionIndex];
+		if (!action || action.disabled === true) return null;
+		return {
+			status: "action",
+			action: action.value,
+			selectedValues: state.selectedValues
+		};
+	}
+	if (state.readOnly) return null;
+	if (state.workbench) return null;
+	if (state.mode === "single") {
+		const activeItem = getActiveItem(state);
+		if (!activeItem || activeItem.disabled === true) return null;
+		return {
+			status: "submitted",
+			value: activeItem.value
+		};
+	}
+	if (state.required && state.selectedValues.length === 0) return null;
+	return {
+		status: "submitted",
+		value: state.selectedValues
+	};
+}
+function renderSearchPromptLines(state, status = "active") {
+	const lines = [`${status === "cancelled" ? PROMPT_SYMBOL_CANCELLED : PROMPT_SYMBOL_ACTIVE}  ${pc.bold(state.message)}`];
+	if (status === "submitted") {
+		lines.push(`${BAR_SYMBOL}  ${pc.dim(buildSubmittedSearchPromptSummary(state) ?? "Done")}`);
+		return lines;
+	}
+	if (status === "cancelled") {
+		lines.push(`${BAR_SYMBOL}  ${pc.strikethrough(pc.dim("Cancelled"))}`);
+		return lines;
+	}
+	lines.push(...renderActiveSearchPromptLines(state));
+	lines.push(pc.dim("└"));
+	return lines;
+}
+function renderActiveSearchPromptLines(state) {
+	const viewModel = getSearchPromptViewModel(state);
+	const lines = [];
+	if (state.summaryCard) {
+		lines.push(`${BAR_SYMBOL}`);
+		lines.push(...renderSearchPromptSummaryCardLines(state.summaryCard));
+		lines.push(`${BAR_SYMBOL}`);
+	}
+	if (state.noticeLines.length > 0) {
+		lines.push(`${BAR_SYMBOL}`);
+		lines.push(...renderSearchPromptNoticeCardLines(state.noticeLines));
+		lines.push(`${BAR_SYMBOL}`);
+	}
+	lines.push(`${BAR_SYMBOL}  ${pc.dim("Search:")} ${state.query}${pc.inverse(" ")}`, renderSearchPromptHintLine({
+		mode: state.mode,
+		allowBack: state.allowBack,
+		readOnly: state.readOnly,
+		workbench: state.workbench
+	}));
+	lines.push(`${BAR_SYMBOL}`);
+	lines.push(...renderSearchPromptBodyLines(state, viewModel));
+	lines.push(...renderSearchPromptOverflowLines(viewModel));
+	if (state.workbench) {
+		lines.push(...renderSearchPromptSelectionSummaryLines(state));
+		lines.push(...renderSearchPromptWorkbenchMenuLines(viewModel));
+	} else {
+		lines.push(...renderSearchPromptActionLines(viewModel));
+		lines.push(...renderSearchPromptBackLines(state, viewModel));
+		lines.push(...renderSearchPromptSelectionSummaryLines(state));
+	}
+	return lines;
+}
+function renderSearchPromptBodyLines(state, viewModel) {
+	const itemRows = viewModel.visibleRows.filter((row) => row.kind === "item");
+	if (itemRows.length === 0) return [`${BAR_SYMBOL}  ${pc.dim(state.emptyLabel)}`];
+	return itemRows.flatMap((row) => {
+		const lines = [renderSearchPromptItemLine(row, {
+			mode: state.mode,
+			readOnly: state.readOnly
+		})];
+		if (row.item.detail) lines.push(`${BAR_SYMBOL}    ${pc.dim(row.item.detail)}`);
+		return lines;
+	});
+}
+function renderSearchPromptOverflowLines(viewModel) {
+	if (viewModel.hiddenBefore === 0 && viewModel.hiddenAfter === 0) return [];
+	const hiddenLabels = [];
+	if (viewModel.hiddenBefore > 0) hiddenLabels.push(`↑ ${String(viewModel.hiddenBefore)} more`);
+	if (viewModel.hiddenAfter > 0) hiddenLabels.push(`↓ ${String(viewModel.hiddenAfter)} more`);
+	return [`${BAR_SYMBOL}  ${pc.dim(hiddenLabels.join("  "))}`];
+}
+function renderSearchPromptActionLines(viewModel) {
+	const actionRows = viewModel.visibleRows.filter((row) => row.kind === "action");
+	if (actionRows.length === 0) return [];
+	return renderSearchPromptActionBlockLines(actionRows);
+}
+function renderSearchPromptWorkbenchMenuLines(viewModel) {
+	const actionRows = viewModel.visibleRows.filter((row) => row.kind === "action");
+	const backRow = viewModel.visibleRows.find((row) => row.kind === "back");
+	if (actionRows.length === 0 && !backRow) return [];
+	const lines = renderSearchPromptActionBlockLines(actionRows);
+	if (backRow) {
+		if (actionRows.length > 0) lines.push(`${BAR_SYMBOL}`);
+		lines.push(renderSearchPromptBackLine(backRow, { workbench: true }));
+	}
+	return lines;
+}
+function renderSearchPromptBackLines(state, viewModel) {
+	if (!state.allowBack || state.workbench) return [];
+	const backRow = viewModel.visibleRows.find((row) => row.kind === "back");
+	if (!backRow) return [];
+	return [`${BAR_SYMBOL}`, renderSearchPromptBackLine(backRow)];
+}
+function renderSearchPromptSelectionSummaryLines(state) {
+	if (state.mode !== "multiple" || state.readOnly) return [];
+	const lines = [`${BAR_SYMBOL}`, `${BAR_SYMBOL}  ${pc.green("Selected:")} ${buildMultiselectSummary(state)}`];
+	if (!state.workbench && (!state.required || state.selectedValues.length > 0)) lines.push(`${BAR_SYMBOL}  ${pc.dim("Press ")}${pc.green("`Enter`")}${pc.dim(" to continue.")}`);
+	return lines;
+}
+function handleSearchPromptKeypress(input) {
+	const { state, str, key } = input;
+	if (!key) return { type: "ignore" };
+	if (key.ctrl === true && key.name === "c") return {
+		type: "result",
+		result: buildSearchPromptDismissResult({
+			state,
+			status: "cancelled"
+		}),
+		status: "cancelled"
+	};
+	if (key.name === "escape") return handleSearchPromptEscapeKeypress(state);
+	if (isReturnKeypress({
+		key,
+		str
+	})) return handleSearchPromptReturnKeypress(state);
+	const moveDelta = resolveSearchPromptMoveDelta(key.name);
+	if (moveDelta !== null) return {
+		type: "state",
+		state: updateSearchPromptState(state, {
+			type: "move",
+			delta: moveDelta
+		})
+	};
+	if (key.name === "space" && state.mode === "multiple") return {
+		type: "state",
+		state: updateSearchPromptState(state, { type: "toggle-active" })
+	};
+	if (key.name === "backspace") return {
+		type: "state",
+		state: updateSearchPromptState(state, { type: "query-backspace" })
+	};
+	if (key.ctrl === true && key.name === "u") return {
+		type: "state",
+		state: updateSearchPromptState(state, { type: "query-clear" })
+	};
+	const printableInput = normalizePrintableSearchInput(str, state.mode);
+	if (printableInput !== null) return {
+		type: "state",
+		state: updateSearchPromptState(state, {
+			type: "query-append",
+			text: printableInput
+		})
+	};
+	return { type: "ignore" };
+}
+function buildSearchPromptDismissResult(input) {
+	if (input.state.workbench) {
+		if (input.status === "back") return {
+			status: "back",
+			selectedValues: input.state.selectedValues
+		};
+		return {
+			status: "cancelled",
+			selectedValues: input.state.selectedValues
+		};
+	}
+	if (input.status === "back") return { status: "back" };
+	return { status: "cancelled" };
+}
+function handleSearchPromptEscapeKeypress(state) {
+	return {
+		type: "result",
+		result: buildSearchPromptDismissResult({
+			state,
+			status: state.allowBack ? "back" : "cancelled"
+		}),
+		status: state.allowBack ? "submitted" : "cancelled",
+		state: state.allowBack ? focusSearchPromptBackRow(state) : state
+	};
+}
+function handleSearchPromptReturnKeypress(state) {
+	if (state.workbench && getSearchPromptViewModel(state).activeRow?.kind === "item") return {
+		type: "state",
+		state: updateSearchPromptState(state, { type: "toggle-active" })
+	};
+	const result = getSearchPromptSelection(state);
+	if (!result) return { type: "ignore" };
+	return {
+		type: "result",
+		result,
+		status: "submitted"
+	};
+}
+function promptSearchSelect(input, streams) {
+	return runInteractiveSearchPrompt(createSearchPromptState({
+		...input,
+		mode: "single"
+	}), streams).then((result) => result);
+}
+function promptSearchMultiselect(input, streams) {
+	return runInteractiveSearchPrompt(createSearchPromptState({
+		...input,
+		mode: "multiple"
+	}), streams).then((result) => result);
+}
+function promptSearchMultiselectWorkbench(input) {
+	return runInteractiveSearchPrompt(createSearchPromptState({
+		...input,
+		mode: "multiple",
+		workbench: true
+	})).then((result) => result);
+}
+function buildSearchKey(item) {
+	return [
+		item.searchText,
+		item.label,
+		item.detail,
+		item.hint,
+		String(item.value)
+	].filter((value) => typeof value === "string").join("\n").trim().toLowerCase();
+}
+function getFilteredItemIndexes(state) {
+	const query = state.query.trim().toLowerCase();
+	if (query.length === 0) return state.items.map((_item, index) => index);
+	return state.items.flatMap((item, index) => item.searchKey.includes(query) ? [index] : []);
+}
+function syncSearchPromptState(state) {
+	const viewModel = getSearchPromptViewModelInternal(state);
+	const activeRowIndex = viewModel.rows.length === 0 ? 0 : clampNumber(state.activeRowIndex, 0, viewModel.rows.length - 1);
+	return {
+		...state,
+		activeRowIndex
+	};
+}
+function getSearchPromptViewModelInternal(state) {
+	const filteredIndexes = getFilteredItemIndexes(state);
+	const footerActions = resolveSearchPromptFooterActions(state);
+	return {
+		filteredIndexes,
+		rows: buildSearchPromptRows({
+			allowBack: state.allowBack,
+			filteredIndexes,
+			footerActions,
+			workbench: state.workbench
+		})
+	};
+}
+function buildSearchPromptRows(input) {
+	const itemRows = input.filteredIndexes.map((itemIndex, filteredIndex) => ({
+		kind: "item",
+		filteredIndex,
+		itemIndex
+	}));
+	const actionRows = input.footerActions.map((_action, actionIndex) => ({
+		kind: "action",
+		actionIndex
+	}));
+	const rows = input.workbench ? [...itemRows, ...actionRows] : [...itemRows, ...actionRows];
+	if (input.allowBack) rows.push({ kind: "back" });
+	return rows;
+}
+function buildSearchPromptVisibleRows(input) {
+	const itemRows = input.filteredIndexes.slice(input.visibleWindow.start, input.visibleWindow.end).map((itemIndex, offset) => {
+		const filteredIndex = input.visibleWindow.start + offset;
+		const item = input.state.items[itemIndex];
+		if (!item) throw new Error("search prompt item is missing");
+		return {
+			kind: "item",
+			filteredIndex,
+			itemIndex,
+			item,
+			active: input.activeRow?.kind === "item" && input.activeRow.filteredIndex === filteredIndex,
+			selected: isItemSelected(input.state, item.value)
+		};
+	});
+	const actionRows = input.footerActions.map((action, actionIndex) => ({
+		kind: "action",
+		action,
+		actionIndex,
+		active: input.activeRow?.kind === "action" && input.activeRow.actionIndex === actionIndex
+	}));
+	const rows = [...itemRows, ...actionRows];
+	if (input.state.allowBack) rows.push({
+		kind: "back",
+		active: input.activeRow?.kind === "back",
+		label: input.state.backLabel
+	});
+	return rows;
+}
+function resolveInitialSearchPromptActiveRowIndex(state) {
+	if (!state.workbench) return 0;
+	if (getFilteredItemIndexes(state).length > 0) return 0;
+	return 0;
+}
+function moveSearchPromptCursor(state, delta) {
+	const viewModel = getSearchPromptViewModelInternal(state);
+	if (viewModel.rows.length === 0 || delta === 0) return state;
+	return {
+		...state,
+		activeRowIndex: wrapNumber(state.activeRowIndex + delta, 0, viewModel.rows.length - 1)
+	};
+}
+function toggleSearchPromptActiveSelection(state) {
+	if (state.mode !== "multiple") return state;
+	const activeItem = getActiveItem(state);
+	if (!activeItem || activeItem.disabled === true) return state;
+	const selectedValues = new Set(state.selectedValues);
+	if (selectedValues.has(activeItem.value)) selectedValues.delete(activeItem.value);
+	else selectedValues.add(activeItem.value);
+	return {
+		...state,
+		selectedValues: Array.from(selectedValues)
+	};
+}
+function getActiveItem(state) {
+	const viewModel = getSearchPromptViewModel(state);
+	if (viewModel.activeRow?.kind !== "item") return null;
+	return state.items[viewModel.activeRow.itemIndex] ?? null;
+}
+function isItemSelected(state, value) {
+	return state.selectedValues.includes(value);
+}
+function renderSearchPromptItemLine(row, input) {
+	const prefix = row.active ? CURSOR_SYMBOL : " ";
+	if (input.readOnly) {
+		const hint = row.item.hint ? pc.dim(` (${row.item.hint})`) : "";
+		return `${BAR_SYMBOL} ${prefix} ${row.item.label}${hint}`;
+	}
+	const marker = resolveSearchPromptItemMarker({
+		mode: input.mode,
+		active: row.active,
+		selected: row.selected
+	});
+	const label = row.item.label;
+	const hint = row.item.hint ? pc.dim(` (${row.item.hint})`) : "";
+	const renderedLabel = row.item.disabled === true ? pc.dim(label) : label;
+	return `${BAR_SYMBOL} ${prefix} ${marker} ${renderedLabel}${hint}`;
+}
+function renderSearchPromptActionLine(row) {
+	const prefix = row.active ? CURSOR_SYMBOL : " ";
+	const icon = typeof row.action.icon === "string" && row.action.icon.length > 0 ? `${row.action.disabled === true || row.action.icon === "·" ? pc.dim(row.action.icon) : pc.cyan(row.action.icon)} ` : "";
+	let label = pc.bold(row.action.label);
+	if (row.action.accent === true) label = pc.green(row.action.label);
+	if (row.action.disabled === true) label = pc.dim(row.action.label);
+	const hint = row.action.hint ? pc.dim(` (${row.action.hint})`) : "";
+	return `${BAR_SYMBOL} ${prefix} ${icon}${label}${hint}`;
+}
+function renderSearchPromptActionBlockLines(actionRows) {
+	const lines = [`${BAR_SYMBOL}`];
+	for (const row of actionRows) {
+		if (row.action.separatorBefore === true) lines.push(`${BAR_SYMBOL}`);
+		lines.push(renderSearchPromptActionLine(row));
+	}
+	return lines;
+}
+function resolveSearchPromptItemMarker(input) {
+	if (input.mode === "multiple") return input.selected ? MULTI_SELECTED_SYMBOL : MULTI_UNSELECTED_SYMBOL;
+	return input.active ? SINGLE_SELECTED_SYMBOL : SINGLE_UNSELECTED_SYMBOL;
+}
+function renderSearchPromptBackLine(row, input) {
+	const prefix = row.active ? CURSOR_SYMBOL : " ";
+	if (input?.workbench === true) return `${BAR_SYMBOL} ${prefix} ${row.label}`;
+	return `${BAR_SYMBOL} ${prefix} ${row.label}`;
+}
+function buildSubmittedSearchPromptSummary(state) {
+	const viewModel = getSearchPromptViewModel(state);
+	if (viewModel.activeRow?.kind === "back") return state.backLabel;
+	if (viewModel.activeRow?.kind === "action") return resolveSearchPromptFooterActions(state)[viewModel.activeRow.actionIndex]?.label ?? null;
+	if (state.mode === "single") return getActiveItem(state)?.label ?? null;
+	return buildMultiselectSummary(state);
+}
+function buildMultiselectSummary(state) {
+	const labels = state.items.filter((item) => isItemSelected(state, item.value)).map((item) => item.label);
+	if (labels.length === 0) return "(none)";
+	if (labels.length <= 3) return labels.join(", ");
+	return `${labels.slice(0, 3).join(", ")} +${String(labels.length - 3)} more`;
+}
+function focusSearchPromptBackRow(state) {
+	const backRowIndex = getSearchPromptViewModel(state).rows.findIndex((row) => row.kind === "back");
+	if (backRowIndex < 0) return state;
+	return {
+		...state,
+		activeRowIndex: backRowIndex
+	};
+}
+function resolveSearchPromptMoveDelta(name) {
+	if (name === "up") return -1;
+	if (name === "down") return 1;
+	return null;
+}
+function renderSearchPromptHintLine(input) {
+	if (input.readOnly) return `${BAR_SYMBOL}  ${pc.dim(input.allowBack ? "↑↓ browse, type to filter, Esc back" : "↑↓ browse, type to filter")}`;
+	if (input.workbench) return `${BAR_SYMBOL}  ${pc.dim("↑↓ move, Press ")}${pc.green("`Space`")}${pc.dim(" or ")}${pc.green("`Enter`")}${pc.dim(input.allowBack ? " to select, choose an action to continue, Esc back" : " to select, choose an action to continue")}`;
+	if (input.mode === "multiple") return `${BAR_SYMBOL}  ${pc.dim("↑↓ move, Press ")}${pc.green("`Space`")}${pc.dim(" to select, Press ")}${pc.green("`Enter`")}${pc.dim(input.allowBack ? " to confirm, Esc back" : " to confirm")}`;
+	return `${BAR_SYMBOL}  ${pc.dim("↑↓ move, Press ")}${pc.green("`Enter`")}${pc.dim(input.allowBack ? " to select, Esc back" : " to select")}`;
+}
+function renderSearchPromptSummaryCardLines(card) {
+	return buildTextInfoCardLines({
+		...card,
+		sanitize: true
+	}).map((line) => `${BAR_SYMBOL}  ${line}`);
+}
+function renderSearchPromptNoticeCardLines(noticeLines) {
+	if (noticeLines.length === 0) return [];
+	return buildTextInfoCardLines({
+		title: pc.yellow("⚠️ Notification"),
+		rows: noticeLines.map((line) => ({
+			label: "",
+			value: pc.yellow(`⚠️ ${line}`)
+		})),
+		compact: true,
+		minContentWidth: 48
+	}).map((line) => `${BAR_SYMBOL}  ${line}`);
+}
+function normalizeMaxVisible(value) {
+	const normalized = typeof value === "number" ? Math.trunc(value) : NaN;
+	return Number.isFinite(normalized) && normalized > 0 ? normalized : DEFAULT_MAX_VISIBLE;
+}
+function wrapNumber(value, min, max) {
+	if (value < min) return max;
+	if (value > max) return min;
+	return value;
+}
+function dedupeValues(values) {
+	return Array.from(new Set(values));
+}
+function runInteractiveSearchPrompt(initialState, streams) {
+	return runInteractivePrompt({
+		initialState,
+		fallbackResult: buildSearchPromptFallbackResult(initialState),
+		renderLines: (state, status) => renderSearchPromptLines(state, status),
+		handleKeypress: ({ state, str, key }) => handleSearchPromptKeypress({
+			state,
+			str,
+			key
+		})
+	}, streams);
+}
+function buildSearchPromptFallbackResult(state) {
+	return buildSearchPromptDismissResult({
+		state,
+		status: state.allowBack ? "back" : "cancelled"
+	});
+}
+function resolveSearchPromptFooterActions(state) {
+	if (state.footerActionsResolver === null) return state.footerActions;
+	return state.footerActionsResolver({ selectedValues: state.selectedValues }).map(sanitizeSearchPromptFooterAction);
+}
+function isPrintableSearchInput(value, mode) {
+	if (typeof value !== "string" || value.length === 0) return false;
+	if (mode === "multiple" && value === " ") return false;
+	return PRINTABLE_SEARCH_INPUT_REGEX.test(value);
+}
+function normalizePrintableSearchInput(value, mode) {
+	return typeof value === "string" && isPrintableSearchInput(value, mode) ? value : null;
+}
+//#endregion
+//#region src/ui/transport-mode-display.ts
+const DISPLAY_NOT_SET_UP = "Not set up";
+function formatTransportModeDisplay(value) {
+	const normalized = String(value ?? "").trim();
+	if (!normalized || normalized === "not configured") return DISPLAY_NOT_SET_UP;
+	if (normalized === "local-cli") return "Local CLI";
+	if (normalized === "codex-app-server") return "Codex App Server";
+	if (normalized === "acp") return "Agent Client Protocol (ACP)";
+	return normalized;
+}
+//#endregion
+//#region src/commands/agents-text.ts
+const formatAgentsCopy = (text) => formatOpenMeldCliTextBlock(text);
+function formatAgentMention(agentId) {
+	return pc.bold(pc.cyan(`@${agentId}`));
+}
+function formatAgentsToneText(tone, value) {
+	if (tone === "success") return pc.green(value);
+	if (tone === "warning") return pc.yellow(value);
+	return pc.cyan(value);
+}
+function formatStatusTextForHuman(value) {
+	if (value.length === 0) return value;
+	const normalized = value.replaceAll("_", " ");
+	return normalized[0]?.toUpperCase() + normalized.slice(1);
+}
+function normalizeOptionalString(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+//#endregion
+//#region src/commands/agents-cards.ts
+const AGENTS_CARD_MIN_CONTENT_WIDTH = 34;
+function renderAgentsInfoCard(input) {
+	renderInfoCard({
+		presenter: input.presenter,
+		title: input.title,
+		codePrefix: input.codePrefix,
+		rows: input.rows,
+		minContentWidth: input.minContentWidth ?? AGENTS_CARD_MIN_CONTENT_WIDTH,
+		horizontalPadding: 1,
+		compact: true
+	});
+}
+function formatAgentListItem(input) {
+	const parts = [
+		formatAgentMention(input.agentId),
+		pc.dim("·"),
+		input.displayName
+	];
+	if (input.detail) parts.push(pc.dim(input.detail));
+	return parts.join(" ");
+}
+function buildReadyAgentCardRow(agentId, displayName) {
+	return {
+		label: "",
+		value: formatAgentListItem({
+			agentId,
+			displayName
+		})
+	};
+}
+function buildStatusAgentCardRow(input) {
+	return {
+		label: "",
+		value: formatAgentListItem({
+			agentId: input.agentId,
+			displayName: input.displayName,
+			detail: input.detail
+		})
+	};
+}
+function buildTurnedOffAgentCardRow(agentId, displayName) {
+	return {
+		label: "",
+		value: formatAgentListItem({
+			agentId,
+			displayName
+		})
+	};
+}
+function buildReadyCountValue(count, noun) {
+	return `${formatAgentsToneText("success", pc.bold(String(count)))} ${pc.dim(noun)}`;
+}
+function buildNotReadyCountValue(count, noun) {
+	return `${formatAgentsToneText("warning", pc.bold(String(count)))} ${pc.dim(noun)}`;
+}
+//#endregion
+//#region src/commands/agents-descriptions.ts
+function normalizeDescriptionLines(description) {
+	return (Array.isArray(description) ? description : [description]).map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function buildInteractiveMenuMessage(input) {
+	return [
+		input.title,
+		...normalizeDescriptionLines(input.description).map((line) => pc.dim(formatAgentsCopy(line))),
+		""
+	].join("\n");
+}
+function emitInteractiveDescription(description) {
+	const lines = normalizeDescriptionLines(description);
+	if (lines.length === 0) return;
+	process.stdout.write(`${lines.map((line) => pc.dim(formatAgentsCopy(line))).join("\n")}\n`);
+}
+function emitHumanSectionDescription(presenter, input) {
+	if (presenter.view !== "human") return;
+	const lines = normalizeDescriptionLines(input.description);
+	for (const [index, line] of lines.entries()) presenter.line({
+		code: `${input.codePrefix}.description.${String(index)}`,
+		text: pc.dim(formatAgentsCopy(line))
+	});
+}
+function emitHumanSectionHeader(presenter, input) {
+	if (presenter.view !== "human") return;
+	presenter.line({
+		code: `${input.codePrefix}.spacer`,
+		text: ""
+	});
+	presenter.line({
+		code: `${input.codePrefix}.title`,
+		text: input.title
+	});
+}
+//#endregion
+//#region src/commands/agents-summary-cards.ts
+const AGENTS_ENABLE_RESULT_DESCRIPTION = "These agents can now reply when someone mentions them in a Space from this computer.";
+const AGENTS_DISABLE_RESULT_DESCRIPTION = "These agents will stop replying to new mentions in Spaces.";
+function emitEnableSummaryCardsForHuman(input) {
+	emitHumanSectionDescription(input.presenter, {
+		codePrefix: "agents.enable",
+		description: AGENTS_ENABLE_RESULT_DESCRIPTION
+	});
+	renderAgentsInfoCard({
+		presenter: input.presenter,
+		codePrefix: "agents.enable.summary.card",
+		title: "Agents Turned On",
+		rows: buildEnableSummaryRows(input.summary),
+		minContentWidth: 38
+	});
+	const detailCards = buildEnableDetailCards(input.summary, input.targetStateById);
+	for (const card of detailCards) {
+		input.presenter.line({
+			code: `agents.enable.${card.codeSuffix}.spacer`,
+			text: ""
+		});
+		renderAgentsInfoCard({
+			presenter: input.presenter,
+			codePrefix: `agents.enable.${card.codeSuffix}.card`,
+			title: card.title,
+			rows: card.rows,
+			minContentWidth: 30
+		});
+	}
+}
+function buildEnableSummaryRows(summary) {
+	const rows = [{
+		label: "Status",
+		value: buildEnableSummaryStatus(summary)
+	}];
+	if (summary.registered.length > 0) rows.push({
+		label: "On now",
+		value: String(summary.registered.length)
+	});
+	if (summary.reenabled.length > 0) rows.push({
+		label: "Back on",
+		value: String(summary.reenabled.length)
+	});
+	if (summary.skipped.length > 0) rows.push({
+		label: "Already on",
+		value: String(summary.skipped.length)
+	});
+	if (summary.errors.length > 0) rows.push({
+		label: "Needs attention",
+		value: String(summary.errors.length)
+	});
+	return rows;
+}
+function buildEnableSummaryStatus(summary) {
+	const readyCount = summary.registered.length + summary.reenabled.length;
+	const reviewCount = summary.skipped.length + summary.errors.length;
+	if (readyCount > 0 && reviewCount === 0) {
+		if (summary.allMode) return readyCount === 1 ? `1 detected agent is ${formatAgentsToneText("success", "available now")}` : `All detected available agents are ${formatAgentsToneText("success", "on now")}`;
+		return readyCount === 1 ? `1 selected agent is ${formatAgentsToneText("success", "available now")}` : `${readyCount} selected agents are ${formatAgentsToneText("success", "available now")}`;
+	}
+	if (readyCount > 0) return readyCount === 1 ? `1 agent is ${formatAgentsToneText("success", "available now")} ${pc.dim("· review the rest below")}` : `${readyCount} agents are ${formatAgentsToneText("success", "available now")} ${pc.dim("· review the rest below")}`;
+	if (summary.skipped.length > 0 && summary.errors.length === 0) return formatAgentsToneText("info", "Already on");
+	return formatAgentsToneText("warning", "OpenMeld could not turn these on");
+}
+function buildEnableDetailCards(summary, targetStateById) {
+	const cards = [];
+	if (summary.registered.length > 0) cards.push({
+		codeSuffix: "enabled_now",
+		title: `Turned On Now (${summary.registered.length})`,
+		rows: summary.registered.map((agentId) => buildReadyAgentCardRow(agentId, resolveEnableResultDisplayName(agentId, targetStateById)))
+	});
+	if (summary.reenabled.length > 0) cards.push({
+		codeSuffix: "reenabled",
+		title: `Turned Back On (${summary.reenabled.length})`,
+		rows: summary.reenabled.map((agentId) => buildReadyAgentCardRow(agentId, resolveEnableResultDisplayName(agentId, targetStateById)))
+	});
+	if (summary.skipped.length > 0) cards.push({
+		codeSuffix: "already_enabled",
+		title: `Already On (${summary.skipped.length})`,
+		rows: summary.skipped.map((item) => ({
+			label: resolveEnableResultDisplayName(item.agentId, targetStateById),
+			value: formatEnableSkippedReasonForHuman(item.reason)
+		}))
+	});
+	if (summary.errors.length > 0) cards.push({
+		codeSuffix: "needs_attention",
+		title: `Needs Attention (${summary.errors.length})`,
+		rows: summary.errors.map((item) => ({
+			label: resolveEnableResultDisplayName(item.agentId, targetStateById),
+			value: formatEnableErrorReasonForHuman(item)
+		}))
+	});
+	return cards;
+}
+function resolveEnableResultDisplayName(agentId, targetStateById) {
+	return targetStateById.get(agentId)?.displayName ?? agentId;
+}
+function formatEnableSkippedReasonForHuman(reason) {
+	if (reason === "already_enabled") return "Already on in OpenMeld";
+	return formatStatusTextForHuman(reason);
+}
+function formatEnableErrorReasonForHuman(input) {
+	if (input.code === "controller.launch.choice_required" && input.installChoices && input.installChoices.length > 0) {
+		const choiceSummary = input.installChoices.map((installChoice) => `${installChoice.installId} (${installChoice.label} · ${installChoice.detail})`).join("; ");
+		const nextStepSummary = (input.nextSteps ?? []).join(" or ");
+		return [
+			input.summary ?? "Needs your choice on this Mac before OpenMeld can continue.",
+			`Choices: ${choiceSummary}`,
+			nextStepSummary ? `Next: ${nextStepSummary}` : null
+		].filter((line) => Boolean(line)).join(" ");
+	}
+	if (input.reason === "not found") return "Not found on this computer";
+	if (input.reason === "will be supported soon") return "Found on this computer, but OpenMeld support is coming soon";
+	if (input.reason === "custom target is not runnable yet") return "Custom targets cannot be enabled yet";
+	if (input.reason === "not selectable in current runtime") return "Not available in this runtime";
+	if (input.reason === "unknown built-in target id") return "Not in the built-in support list";
+	if (input.reason === "needs repair") return "Needs repair on this computer before OpenMeld can start it";
+	if (input.reason === "needs your choice") return "Needs your choice on this Mac before OpenMeld can use it";
+	if (input.code === "agents.config_write_failed") return "OpenMeld could not save this change";
+	return formatStatusTextForHuman(input.reason);
+}
+function buildRepairSummaryRows(summary) {
+	const rows = [{
+		label: "Status",
+		value: buildRepairSummaryStatus(summary)
+	}];
+	if (summary.repaired.length > 0) rows.push({
+		label: "Repaired",
+		value: String(summary.repaired.length)
+	});
+	if (summary.skipped.length > 0) rows.push({
+		label: "Already available",
+		value: String(summary.skipped.length)
+	});
+	if (summary.errors.length > 0) rows.push({
+		label: "Needs attention",
+		value: String(summary.errors.length)
+	});
+	return rows;
+}
+function buildRepairSummaryStatus(summary) {
+	if (summary.repaired.length > 0 && summary.errors.length === 0) {
+		if (summary.skipped.length === 0) return summary.repaired.length === 1 ? `1 agent is ${formatAgentsToneText("success", "available now")}` : `${String(summary.repaired.length)} agents are ${formatAgentsToneText("success", "available now")}`;
+		return `${String(summary.repaired.length)} agents are ${formatAgentsToneText("success", "available now")} ${pc.dim("· review the rest below")}`;
+	}
+	if (summary.skipped.length > 0 && summary.errors.length === 0) return formatAgentsToneText("info", "Already available");
+	return formatAgentsToneText("warning", "OpenMeld could not repair all selected agents");
+}
+function buildRepairDetailCards(summary, targetStateById) {
+	const cards = [];
+	if (summary.repaired.length > 0) cards.push({
+		codeSuffix: "repaired",
+		title: `Available Now (${summary.repaired.length})`,
+		rows: summary.repaired.map((agentId) => buildReadyAgentCardRow(agentId, resolveEnableResultDisplayName(agentId, targetStateById)))
+	});
+	if (summary.skipped.length > 0) cards.push({
+		codeSuffix: "already_ready",
+		title: `Already Available (${summary.skipped.length})`,
+		rows: summary.skipped.map((item) => ({
+			label: resolveEnableResultDisplayName(item.agentId, targetStateById),
+			value: item.reason === "already_ready" ? "Already available on this computer" : formatStatusTextForHuman(item.reason)
+		}))
+	});
+	if (summary.errors.length > 0) cards.push({
+		codeSuffix: "needs_attention",
+		title: `Needs Attention (${summary.errors.length})`,
+		rows: summary.errors.map((item) => ({
+			label: resolveEnableResultDisplayName(item.agentId, targetStateById),
+			value: formatRepairErrorReasonForHuman(item)
+		}))
+	});
+	return cards;
+}
+function formatRepairErrorReasonForHuman(input) {
+	if (input.reason === "agent is not registered") return "This agent is not connected in OpenMeld yet";
+	if (input.reason === "custom target is not runnable yet") return "Custom targets cannot be repaired yet";
+	if (input.reason === "unknown built-in target id") return "Not in the built-in support list";
+	return formatEnableErrorReasonForHuman(input);
+}
+function emitDisableSummaryCardsForHuman(input) {
+	emitHumanSectionDescription(input.presenter, {
+		codePrefix: "agents.disable",
+		description: AGENTS_DISABLE_RESULT_DESCRIPTION
+	});
+	renderAgentsInfoCard({
+		presenter: input.presenter,
+		codePrefix: "agents.disable.summary.card",
+		title: "Agents Turned Off",
+		rows: buildDisableSummaryRows(input.summary),
+		minContentWidth: 38
+	});
+	const detailCards = buildDisableDetailCards(input.summary, input.displayNameById);
+	for (const card of detailCards) {
+		input.presenter.line({
+			code: `agents.disable.${card.codeSuffix}.spacer`,
+			text: ""
+		});
+		renderAgentsInfoCard({
+			presenter: input.presenter,
+			codePrefix: `agents.disable.${card.codeSuffix}.card`,
+			title: card.title,
+			rows: card.rows,
+			minContentWidth: 30
+		});
+	}
+}
+function buildDisableSummaryRows(summary) {
+	const rows = [{
+		label: "Status",
+		value: buildDisableSummaryStatus(summary)
+	}];
+	if (summary.disabled.length > 0) rows.push({
+		label: "Off now",
+		value: String(summary.disabled.length)
+	});
+	if (summary.skipped.length > 0) rows.push({
+		label: "Already off",
+		value: String(summary.skipped.length)
+	});
+	if (summary.errors.length > 0) rows.push({
+		label: "Needs attention",
+		value: String(summary.errors.length)
+	});
+	return rows;
+}
+function buildDisableSummaryStatus(summary) {
+	if (summary.disabled.length > 0 && summary.skipped.length === 0) return summary.disabled.length === 1 ? `1 agent ${formatAgentsToneText("warning", "turned off")}` : `${String(summary.disabled.length)} agents ${formatAgentsToneText("warning", "turned off")}`;
+	if (summary.disabled.length > 0) return summary.disabled.length === 1 ? `1 agent ${formatAgentsToneText("warning", "turned off")} ${pc.dim("· review the rest below")}` : `${String(summary.disabled.length)} agents ${formatAgentsToneText("warning", "turned off")} ${pc.dim("· review the rest below")}`;
+	if (summary.skipped.length > 0 && summary.errors.length === 0) return formatAgentsToneText("info", "Already off");
+	return formatAgentsToneText("warning", "OpenMeld could not turn these off");
+}
+function buildDisableDetailCards(summary, displayNameById) {
+	const cards = [];
+	if (summary.disabled.length > 0) cards.push({
+		codeSuffix: "turned_off",
+		title: `Turned Off (${summary.disabled.length})`,
+		rows: summary.disabled.map((agentId) => buildTurnedOffAgentCardRow(agentId, displayNameById.get(agentId) ?? agentId))
+	});
+	if (summary.skipped.length > 0) cards.push({
+		codeSuffix: "already_off",
+		title: `Already Off (${summary.skipped.length})`,
+		rows: summary.skipped.map((item) => ({
+			label: displayNameById.get(item.agentId) ?? item.agentId,
+			value: formatDisableSkippedReasonForHuman(item.reason)
+		}))
+	});
+	if (summary.errors.length > 0) cards.push({
+		codeSuffix: "needs_attention",
+		title: `Needs Attention (${summary.errors.length})`,
+		rows: summary.errors.map((item) => ({
+			label: displayNameById.get(item.agentId) ?? item.agentId,
+			value: formatDisableErrorReasonForHuman(item)
+		}))
+	});
+	return cards;
+}
+function formatDisableSkippedReasonForHuman(reason) {
+	if (reason === "already_disabled") return "Already off in OpenMeld";
+	return formatStatusTextForHuman(reason);
+}
+function formatDisableErrorReasonForHuman(input) {
+	if (input.reason === "agent is not registered") return "Not currently connected to OpenMeld";
+	if (input.code === "agents.config_write_failed") return "OpenMeld could not save this change";
+	return formatStatusTextForHuman(input.reason);
+}
+//#endregion
+//#region src/commands/agents.ts
+function isBuiltinEnableChoiceCandidate(value) {
+	return value?.targetKind === "builtin";
+}
+function hasAgentRegistration(value) {
+	return value?.registration !== null && value?.registration !== void 0;
+}
+const AGENTS_MENU_CHOICE = {
+	quickEnable: "quick_enable",
+	manage: "manage",
+	detect: "detect",
+	custom: "custom",
+	exit: "exit"
+};
+const AGENTS_MANAGE_AGENT_ACTION_CHOICE = {
+	showDetails: "show_details",
+	chooseInstall: "choose_install",
+	repair: "repair",
+	toggleEnabled: "toggle_enabled",
+	back: "back"
+};
+const CUSTOM_AGENTS_COMING_SOON_OPTION_ID = "__custom_agents_coming_soon__";
+const NO_REGISTERED_AGENTS_MANAGE_MESSAGE = "No agents are set up on this computer yet. Run `openmeld agents detect`, then turn on the ones you want OpenMeld to use.";
+const NO_ACTIONABLE_AGENTS_ENABLE_MESSAGE = "No more agents are available to enable. Run `openmeld agents detect` to scan this computer again.";
+const AGENTS_MENU_DESCRIPTION = "Enable agents on this computer so people in a Space can mention them.";
+const AGENTS_ENABLE_DESCRIPTION = "Choose which new agents OpenMeld should turn on for Space from this computer.";
+const AGENTS_SELECT_REGISTERED_DESCRIPTION = "Choose an agent on this computer to review or change.";
+const AGENTS_MENU_COMMANDS = [
+	...buildBuiltinAgentSelectionExamples({ command: "enable" }),
+	...buildBuiltinAgentSelectionExamples({ command: "repair" }),
+	"openmeld agents detect",
+	"openmeld agents list",
+	"openmeld agents manage",
+	...buildBuiltinAgentSelectionExamples({ command: "disable" }),
+	"openmeld agents show <agent-id>",
+	"openmeld agents config <agent-id> --enabled true|false",
+	"openmeld agents custom list",
+	"openmeld agents custom add --name <name> --dir <dir> [--id <id>]",
+	"openmeld agents custom update --id <id> [--name <name>] [--dir <dir>]",
+	"openmeld agents custom remove --id <id>"
+];
+const AGENTS_MANAGE_RESULT_COMMANDS = [
+	"openmeld agents list",
+	"openmeld agents show <agent-id>",
+	...buildBuiltinAgentSelectionExamples({ command: "repair" }),
+	"openmeld agents config <agent-id> --enabled true|false",
+	...buildBuiltinAgentSelectionExamples({ command: "disable" })
+];
+function formatBuiltinAgentSelectionAlternatives(command) {
+	return buildBuiltinAgentSelectionExamples({ command }).filter((example) => !example.includes(" --install ")).map((example) => `\`${example}\``).join(" or ");
+}
+function buildBuiltinAgentMenuActions(command) {
+	switch (command) {
+		case "enable": return [
+			{
+				command: buildBuiltinAgentSelectionCommand({
+					all: true,
+					command
+				}),
+				description: "Enable every detected agent OpenMeld can use on this computer."
+			},
+			{
+				command: buildBuiltinAgentSelectionCommand({
+					agentIds: ["<id...>"],
+					command
+				}),
+				description: "Enable selected agents so OpenMeld can use them."
+			},
+			{
+				command: buildBuiltinAgentSelectionCommand({
+					agentIds: ["<id>"],
+					command,
+					installId: "<install-id>"
+				}),
+				description: "Enable one agent with the exact local install OpenMeld should use."
+			}
+		];
+		case "repair": return [
+			{
+				command: buildBuiltinAgentSelectionCommand({
+					all: true,
+					command
+				}),
+				description: "Repair every connected builtin agent on this computer that needs attention."
+			},
+			{
+				command: buildBuiltinAgentSelectionCommand({
+					agentIds: ["<id...>"],
+					command
+				}),
+				description: "Refresh how OpenMeld starts selected agents on this computer."
+			},
+			{
+				command: buildBuiltinAgentSelectionCommand({
+					agentIds: ["<id>"],
+					command,
+					installId: "<install-id>"
+				}),
+				description: "Repair one agent with the exact local install to use."
+			}
+		];
+		case "disable": return [{
+			command: buildBuiltinAgentSelectionCommand({
+				all: true,
+				command
+			}),
+			description: "Disable every enabled agent for new mentions in Spaces."
+		}, {
+			command: buildBuiltinAgentSelectionCommand({
+				agentIds: ["<id...>"],
+				command
+			}),
+			description: "Disable selected agents so new mentions in Spaces stop waking them."
+		}];
+		default: throw new Error(`unsupported builtin agent selection command: ${command}`);
+	}
+}
+function formatAgentViewLaunchStatus(status) {
+	return status === "ready" ? "available" : status;
+}
+function buildQuickEnableOptionHint(actionableBuiltinCount) {
+	return actionableBuiltinCount === 1 ? "1 new agent can be turned on now" : `${String(actionableBuiltinCount)} new agents can be turned on now`;
+}
+function buildManageOptionHint(registeredCount) {
+	if (registeredCount === 0) return "No agents are set up on this computer yet";
+	if (registeredCount === 1) return "Review 1 agent on this computer";
+	return `Review ${String(registeredCount)} agents on this computer`;
+}
+function buildDetectedAgentsSubtitle(detectedAgentsCount) {
+	return detectedAgentsCount === 1 ? "1 agent found on this computer" : `${String(detectedAgentsCount)} agents found on this computer`;
+}
+function buildEnabledAgentsSubtitle(enabledAgentsCount) {
+	return enabledAgentsCount === 1 ? "1 agent is live for Space" : `${String(enabledAgentsCount)} agents are live for Space`;
+}
+async function runAgents(input) {
+	const runtime = await resolveRuntimeContext({
+		interactive: input.interactive,
+		view: input.view,
+		profile: input.profile
+	});
+	const presenter = createPresenter(runtime);
+	await emitAgentsConfigParseFallbackSignal({
+		presenter,
+		view: runtime.resolvedView
+	});
+	emitAgentsOverviewIfAgent({
+		presenter,
+		resolvedView: runtime.resolvedView,
+		command: "menu"
+	});
+	const payload = await buildAgentsMenuPayload();
+	if (runtime.resolvedView === "agent") {
+		presenter.data({
+			code: "agents.menu.result",
+			payload
+		});
+		return;
+	}
+	if (canUseInteractivePrompts(runtime)) {
+		await runInteractiveAgentsMenu({
+			profile: input.profile,
+			view: runtime.resolvedView
+		});
+		return;
+	}
+	presenter.line({
+		code: "agents.menu.header",
+		text: "OpenMeld agents commands:"
+	});
+	for (const command of formatOpenMeldCliCommands(payload.commands)) presenter.line({
+		code: "agents.menu.command",
+		text: `- ${command}`
+	});
+	for (const note of payload.notes) presenter.line({
+		code: "agents.menu.note",
+		text: `- ${formatAgentsCopy(note)}`
+	});
+}
+async function runAgentsManage(input) {
+	const runtime = await resolveRuntimeContext({
+		view: input.view,
+		profile: input.profile
+	});
+	const presenter = createPresenter(runtime);
+	await emitAgentsConfigParseFallbackSignal({
+		presenter,
+		view: runtime.resolvedView
+	});
+	emitAgentsOverviewIfAgent({
+		presenter,
+		resolvedView: runtime.resolvedView,
+		command: "manage"
+	});
+	if (runtime.resolvedView === "agent") {
+		presenter.data({
+			code: "agents.manage.result",
+			payload: {
+				interactive: true,
+				supportedView: "human",
+				commands: [...AGENTS_MANAGE_RESULT_COMMANDS]
+			}
+		});
+		return;
+	}
+	if (!canUseInteractivePrompts(runtime)) {
+		presenter.line({
+			code: "agents.manage.non_interactive",
+			text: formatInlineOpenMeldCliCommands("This menu is interactive. In scripts or non-interactive terminals, use `openmeld agents list`, `openmeld agents show <agent-id>`, `openmeld agents config <agent-id> --enabled true|false`, or `openmeld agents disable --agent <id...>`.")
+		});
+		return;
+	}
+	if (await runInteractiveAgentsManageMenu({
+		view: "human",
+		profile: input.profile
+	}) === "cancelled") cancel("Cancelled.");
+}
+async function runInteractiveAgentsMenu(input) {
+	while (true) {
+		const { enableCandidates, registrations } = await resolveAgentsChoiceState();
+		const actionableBuiltinCount = enableCandidates.filter((candidate) => canSelectAgentForNewLocalAgentSetup(candidate) && !candidate.registered).length;
+		const registeredCount = registrations.length;
+		const choice = await select({
+			message: buildInteractiveMenuMessage({
+				title: "OpenMeld agents:",
+				description: AGENTS_MENU_DESCRIPTION
+			}),
+			options: [
+				...actionableBuiltinCount > 0 ? [{
+					value: AGENTS_MENU_CHOICE.quickEnable,
+					label: "Enable available agents",
+					hint: buildQuickEnableOptionHint(actionableBuiltinCount)
+				}] : [],
+				{
+					value: AGENTS_MENU_CHOICE.manage,
+					label: "Review Agents on This Device",
+					hint: buildManageOptionHint(registeredCount)
+				},
+				{
+					value: AGENTS_MENU_CHOICE.detect,
+					label: "Find Agents on This Device",
+					hint: "Check which supported AI tools OpenMeld can see here"
+				},
+				{
+					value: AGENTS_MENU_CHOICE.exit,
+					label: "Exit"
+				}
+			]
+		});
+		if (isCancel(choice)) {
+			cancel("Cancelled.");
+			return;
+		}
+		if (choice === AGENTS_MENU_CHOICE.exit) return;
+		if (await runInteractiveAgentsMenuChoice({
+			input,
+			choice
+		}) === "cancelled") {
+			cancel("Cancelled.");
+			return;
+		}
+	}
+}
+async function runInteractiveAgentsMenuChoice(input) {
+	switch (input.choice) {
+		case AGENTS_MENU_CHOICE.detect:
+			await runAgentsDetect(input.input);
+			return "continue";
+		case AGENTS_MENU_CHOICE.quickEnable: return runInteractiveAgentsEnable(input.input);
+		case AGENTS_MENU_CHOICE.manage: return runInteractiveAgentsManageMenu(input.input);
+		case AGENTS_MENU_CHOICE.custom: return runInteractiveCustomAgentsMenu(input.input);
+		default: return "continue";
+	}
+}
+async function buildAgentsMenuPayload() {
+	const { enableCandidates, registrations } = await resolveAgentsChoiceState();
+	const registeredAgents = registrations.map((registration) => ({
+		agentId: registration.agentId,
+		displayName: registration.displayName,
+		enabled: registration.enabled
+	}));
+	return {
+		commands: formatOpenMeldCliCommands([...AGENTS_MENU_COMMANDS]),
+		notes: [
+			"Agents are AI tools on this computer. When you enable one, people in a Space can mention `@agent-id` to wake it and get a reply.",
+			"Use `openmeld agents detect` to look for supported AI tools on this computer.",
+			`Use ${formatBuiltinAgentSelectionAlternatives("enable")} to enable the agents that are available.`,
+			`If OpenMeld can see an agent but cannot start it here, use ${formatBuiltinAgentSelectionAlternatives("repair")}.`,
+			"Use `openmeld agents manage` to review enabled agents and change them later.",
+			"Manage custom agents with `openmeld agents custom`."
+		].map(formatAgentsCopy),
+		actions: [
+			...buildBuiltinAgentMenuActions("enable"),
+			...buildBuiltinAgentMenuActions("repair"),
+			{
+				command: "openmeld agents detect",
+				description: "Look for supported AI tools on this computer."
+			},
+			{
+				command: "openmeld agents list",
+				description: "List the agents people can mention in a Space."
+			},
+			{
+				command: "openmeld agents manage",
+				description: "Review enabled agents and change their settings."
+			},
+			...buildBuiltinAgentMenuActions("disable"),
+			{
+				command: "openmeld agents show <agent-id>",
+				description: "Show one agent's current OpenMeld settings."
+			},
+			{
+				command: "openmeld agents config <agent-id> --enabled true|false",
+				description: "Enable or disable one agent for Space mentions."
+			},
+			{
+				command: "openmeld agents custom list",
+				description: "List custom agent targets stored in the local OpenMeld config."
+			},
+			{
+				command: "openmeld agents custom add --name <name> --dir <dir> [--id <id>]",
+				description: "Add a custom agent target to the local OpenMeld config."
+			},
+			{
+				command: "openmeld agents custom update --id <id> [--name <name>] [--dir <dir>]",
+				description: "Update a custom agent target while keeping its id stable."
+			},
+			{
+				command: "openmeld agents custom remove --id <id>",
+				description: "Remove a custom agent target that is not currently connected."
+			}
+		].map((action) => ({
+			...action,
+			command: formatOpenMeldCliCommands([action.command])[0] ?? action.command
+		})),
+		selection: {
+			enableCandidates: enableCandidates.map((candidate) => ({
+				agentId: candidate.agentId,
+				displayName: candidate.displayName,
+				targetKind: candidate.targetKind,
+				detected: candidate.detected,
+				lifecycleStatus: candidate.lifecycleStatus,
+				registered: candidate.registered,
+				enabled: candidate.enabled,
+				selectable: candidate.selectable,
+				selectableReason: candidate.selectableReason,
+				launchStatus: formatAgentViewLaunchStatus(candidate.launchStatus),
+				launchStatusDetail: candidate.launchStatusDetail,
+				defaultTransportMode: candidate.defaultTransportMode ?? null,
+				transportModes: candidate.transportModes,
+				status: resolveEnableCandidateStatus(candidate),
+				...candidate.customDir ? { customDir: candidate.customDir } : {}
+			})),
+			selectableAgentIds: enableCandidates.filter(canSelectAgentForNewLocalAgentSetup).map((candidate) => candidate.agentId),
+			registeredAgents,
+			disableCandidates: registeredAgents.map((agent) => ({
+				agentId: agent.agentId,
+				displayName: agent.displayName,
+				enabled: agent.enabled
+			})),
+			customAgents: {
+				supported: false,
+				message: formatAgentsCopy("Custom agents are not available in this list yet. Use `openmeld agents custom` for now."),
+				commands: formatOpenMeldCliCommands([
+					"openmeld agents custom list",
+					"openmeld agents custom add --name <name> --dir <dir> [--id <id>]",
+					"openmeld agents custom update --id <id> [--name <name>] [--dir <dir>]",
+					"openmeld agents custom remove --id <id>"
+				])
+			}
+		}
+	};
+}
+async function resolveAgentsChoiceState() {
+	const enableCandidates = await listAgentTargetStates();
+	return {
+		registrations: enableCandidates.flatMap((candidate) => candidate.registration ? [candidate.registration] : []).sort((left, right) => compareAgentControllerRefsForDisplay(left.agentId, right.agentId)),
+		enableCandidates
+	};
+}
+function resolveEnableCandidateStatus(candidate) {
+	if (candidate.targetKind === "custom") return "custom_coming_soon";
+	if (!candidate.detected) return "not_detected";
+	if (candidate.lifecycleStatus === "suspended") return "detected_suspended";
+	if (candidate.launchStatus === "needs_choice") return "detected_needs_choice";
+	if (candidate.launchStatus === "needs_repair") return "detected_needs_repair";
+	if (!candidate.selectable) return "detected_not_supported_yet";
+	return "detected_supported";
+}
+function canSelectAgentForNewLocalAgentSetup(candidate) {
+	return candidate.targetKind === "builtin" && candidate.lifecycleStatus !== "suspended" && candidate.selectable;
+}
+function buildUnifiedEnableTargetHint(candidate) {
+	if (candidate.enabled) return "Already turned on in OpenMeld";
+	if (!candidate.detected) return "Not found on this computer";
+	if (candidate.lifecycleStatus === "suspended") return "Suspended for new OpenMeld profiles";
+	if (candidate.launchStatus === "needs_choice") return "Needs your choice on this Mac before OpenMeld can turn it on";
+	if (!candidate.selectable && candidate.selectableReason === "not_supported_yet") return "Found on this computer, but OpenMeld doesn't support it yet";
+	if (!candidate.selectable && candidate.selectableReason === "needs_repair") return "Needs repair before OpenMeld can start it here";
+	if (!candidate.selectable && candidate.selectableReason) return formatSelectableReasonForHuman(candidate.selectableReason);
+	return "Available to enable now";
+}
+function formatSelectableReason(reason) {
+	if (reason === "not_detected") return "not found";
+	if (reason === "not_supported_yet") return "will be supported soon";
+	if (reason === "custom_coming_soon") return "coming soon";
+	if (reason === "needs_choice") return "needs your choice";
+	if (reason === "needs_repair") return "needs repair";
+	if (reason === "suspended") return "suspended";
+	return reason;
+}
+function formatSelectableReasonForHuman(reason) {
+	if (reason === "not_detected") return "Not found on this computer";
+	if (reason === "not_supported_yet") return "Found on this computer, but OpenMeld doesn't support it yet";
+	if (reason === "custom_coming_soon") return "Custom agent support is coming soon";
+	if (reason === "needs_choice") return "Needs your choice on this Mac before OpenMeld can use it";
+	if (reason === "needs_repair") return "Needs repair on this computer before OpenMeld can start it";
+	if (reason === "suspended") return "Suspended for new OpenMeld profiles";
+	return formatStatusTextForHuman(reason);
+}
+function resolveEnableBlockedReason(state) {
+	if (!state) return "unknown built-in target id";
+	if (state.targetKind === "custom") return "custom target is not runnable yet";
+	if (!state.detected) return "not found";
+	if (state.lifecycleStatus === "suspended") return "suspended for new OpenMeld profiles";
+	if (state.launchStatus === "needs_choice") return "needs your choice";
+	if (!state.selectable && state.selectableReason === "needs_repair") return "needs repair";
+	if (!state.selectable && state.selectableReason) return formatSelectableReason(state.selectableReason);
+	return "not selectable in current runtime";
+}
+function buildRegisteredAgentHint(state) {
+	const activationHint = state.registration.enabled ? "Turned on" : "Turned off for new @mentions";
+	if (state.launchStatus === "needs_choice") return buildMetadataDetailLine([activationHint, "Needs your choice on this Mac"]);
+	if (state.launchStatus === "needs_repair") return buildMetadataDetailLine([activationHint, "Needs repair on this computer"]);
+	return buildMetadataDetailLine([activationHint, state.registration.enabled ? "Live for Space @mentions" : null]);
+}
+async function runInteractiveAgentsEnable(input) {
+	const { enableCandidates } = await resolveAgentsChoiceState();
+	const actionableCandidates = enableCandidates.filter((candidate) => candidate.targetKind === "builtin").filter((candidate) => canSelectAgentForNewLocalAgentSetup(candidate) && !candidate.registered);
+	if (actionableCandidates.length === 0) {
+		process.stderr.write(`${formatAgentsCopy(NO_ACTIONABLE_AGENTS_ENABLE_MESSAGE)}\n`);
+		return "completed";
+	}
+	const selectedResult = await promptEnableAgentIdsFromUnifiedBuiltins({ candidates: actionableCandidates });
+	if (selectedResult.status === "cancelled") return "cancelled";
+	if (selectedResult.status !== "selected") return "completed";
+	await runAgentsEnable({
+		agent: selectedResult.value,
+		profile: input.profile,
+		view: input.view
+	});
+	return "completed";
+}
+async function runInteractiveCustomAgentsMenu(input) {
+	while (true) {
+		const outcome = await handleInteractiveCustomAgentsMenuChoice({
+			input,
+			choiceResult: await promptInteractiveCustomAgentsMenuChoice()
+		});
+		if (outcome === "continue") continue;
+		return outcome;
+	}
+}
+async function runInteractiveAgentsManageMenu(input) {
+	if ((await listRegisteredAgentStates()).length === 0) {
+		process.stderr.write(`${formatAgentsCopy(NO_REGISTERED_AGENTS_MANAGE_MESSAGE)}\n`);
+		return "completed";
+	}
+	while (true) {
+		const selectedAgentResult = await promptSelectRegisteredAgent({
+			message: "Choose an agent",
+			emptyMessage: NO_REGISTERED_AGENTS_MANAGE_MESSAGE
+		});
+		if (selectedAgentResult.status === "cancelled") return "cancelled";
+		if (selectedAgentResult.status !== "selected") return "completed";
+		const selectedState = selectedAgentResult.value;
+		const actionResult = await promptInteractiveAgentsManageAgentAction({
+			agentId: selectedState.agentId,
+			displayName: selectedState.displayName,
+			enabled: selectedState.enabled,
+			launchStatus: selectedState.launchStatus
+		});
+		if (actionResult.status === "cancelled") return "cancelled";
+		if (actionResult.status !== "selected" || actionResult.value === AGENTS_MANAGE_AGENT_ACTION_CHOICE.back) continue;
+		if (actionResult.value === AGENTS_MANAGE_AGENT_ACTION_CHOICE.showDetails) {
+			await runAgentsShow({
+				agentId: selectedState.agentId,
+				profile: input.profile,
+				view: input.view
+			});
+			continue;
+		}
+		if (actionResult.value === AGENTS_MANAGE_AGENT_ACTION_CHOICE.repair) {
+			await runAgentsRepair({
+				agent: [selectedState.agentId],
+				profile: input.profile,
+				view: input.view
+			});
+			continue;
+		}
+		if (actionResult.value === AGENTS_MANAGE_AGENT_ACTION_CHOICE.chooseInstall) {
+			await runAgentsRepair({
+				agent: [selectedState.agentId],
+				changeInstall: true,
+				profile: input.profile,
+				view: input.view
+			});
+			continue;
+		}
+		await runAgentsConfig({
+			agentId: selectedState.agentId,
+			enabled: selectedState.enabled ? "false" : "true",
+			profile: input.profile,
+			view: input.view
+		});
+	}
+}
+async function handleInteractiveCustomAgentsMenuChoice(input) {
+	if (input.choiceResult.status === "cancelled") return "cancelled";
+	if (input.choiceResult.status !== "selected") return "completed";
+	switch (input.choiceResult.value) {
+		case "back": return "completed";
+		case "list":
+			await runAgentsCustomList({
+				profile: input.input.profile,
+				view: input.input.view
+			});
+			return "continue";
+		case "add": return await runInteractiveCustomAgentsAddFlow(input.input) === "cancelled" ? "cancelled" : "continue";
+		case "remove": return await runInteractiveCustomAgentsRemoveFlow(input.input) === "cancelled" ? "cancelled" : "continue";
+		case "edit": return await runInteractiveCustomAgentsEditFlow(input.input) === "cancelled" ? "cancelled" : "continue";
+		default: return "completed";
+	}
+}
+async function promptInteractiveAgentsManageAgentAction(input) {
+	const action = await select({
+		message: buildInteractiveMenuMessage({
+			title: `Agent: ${input.agentId}`,
+			description: `When on, @${input.agentId} in Space can wake ${input.displayName}.`
+		}),
+		options: [
+			{
+				value: AGENTS_MANAGE_AGENT_ACTION_CHOICE.showDetails,
+				label: "View Setup"
+			},
+			...input.launchStatus === "needs_choice" ? [{
+				value: AGENTS_MANAGE_AGENT_ACTION_CHOICE.chooseInstall,
+				label: "Choose install on This Device",
+				hint: "Pick which local install OpenMeld should use"
+			}] : [],
+			...input.launchStatus === "needs_repair" ? [{
+				value: AGENTS_MANAGE_AGENT_ACTION_CHOICE.repair,
+				label: "Repair on This Device",
+				hint: "Refresh how OpenMeld starts it locally"
+			}] : [],
+			...input.launchStatus === "ready" ? [{
+				value: AGENTS_MANAGE_AGENT_ACTION_CHOICE.chooseInstall,
+				label: "Change install on This Device",
+				hint: "Pick a different local install for future replies"
+			}] : [],
+			{
+				value: AGENTS_MANAGE_AGENT_ACTION_CHOICE.toggleEnabled,
+				label: input.enabled ? "Turn Off for Space @mentions" : "Turn On for Space @mentions",
+				hint: input.enabled ? "Stop waking it for new @mentions" : "Allow @mentions to wake it again"
+			},
+			{
+				value: AGENTS_MANAGE_AGENT_ACTION_CHOICE.back,
+				label: "Back to Agents"
+			}
+		]
+	});
+	if (isCancel(action)) return { status: "cancelled" };
+	return {
+		status: "selected",
+		value: action
+	};
+}
+async function promptInteractiveCustomAgentsMenuChoice() {
+	const choice = await select({
+		message: "Custom Targets:",
+		options: [
+			{
+				value: "add",
+				label: "Add custom target",
+				hint: "Create a new custom agent target"
+			},
+			{
+				value: "edit",
+				label: "Edit custom target",
+				hint: "Update name or dir (id remains stable)"
+			},
+			{
+				value: "remove",
+				label: "Remove custom target",
+				hint: "Blocked when target is currently registered"
+			},
+			{
+				value: "list",
+				label: "List custom targets",
+				hint: "Show custom targets and current status"
+			},
+			{
+				value: "back",
+				label: "Back"
+			}
+		]
+	});
+	if (isCancel(choice)) return { status: "cancelled" };
+	return {
+		status: "selected",
+		value: choice
+	};
+}
+async function runInteractiveCustomAgentsAddFlow(input) {
+	let namePlaceholder = "e.g. OpenMeld Agent Executor";
+	let dirPlaceholder = "/absolute/path/to/skills";
+	let idPlaceholder = "leave empty to auto-generate from dir";
+	while (true) {
+		const nameResult = await promptRequiredInteractiveText({
+			message: "Custom target name",
+			placeholder: namePlaceholder,
+			requiredMessage: "Custom target name is required."
+		});
+		if (nameResult.status === "cancelled") return "cancelled";
+		if (nameResult.status !== "selected") return "completed";
+		namePlaceholder = nameResult.value;
+		const addDetails = await promptInteractiveCustomAgentAddDetails({
+			dirPlaceholder,
+			idPlaceholder
+		});
+		if (addDetails.status === "cancelled") return "cancelled";
+		if (addDetails.status !== "submitted") continue;
+		dirPlaceholder = addDetails.value.dir;
+		if (addDetails.value.idInput) idPlaceholder = addDetails.value.idInput;
+		await runAgentsCustomAdd({
+			name: nameResult.value,
+			dir: addDetails.value.dir,
+			...addDetails.value.id ? { id: addDetails.value.id } : {},
+			profile: input.profile,
+			view: input.view
+		});
+		return "completed";
+	}
+}
+async function runInteractiveCustomAgentsRemoveFlow(input) {
+	const selectedTargetResult = await promptSelectCustomTarget({
+		message: "Select custom target to remove",
+		emptyMessage: "No custom targets available. Add a custom target with `openmeld agents custom add --name <name> --dir <dir>`."
+	});
+	if (selectedTargetResult.status === "cancelled") return "cancelled";
+	if (selectedTargetResult.status !== "selected") return "completed";
+	await runAgentsCustomRemove({
+		id: selectedTargetResult.value.id,
+		profile: input.profile,
+		view: input.view
+	});
+	return "completed";
+}
+async function runInteractiveCustomAgentsEditFlow(input) {
+	while (true) {
+		const selectedTargetResult = await promptSelectCustomTarget({
+			message: "Select custom target to edit",
+			emptyMessage: "No custom targets available. Add a custom target with `openmeld agents custom add --name <name> --dir <dir>`."
+		});
+		if (selectedTargetResult.status === "cancelled") return "cancelled";
+		if (selectedTargetResult.status !== "selected") return "completed";
+		const updateRequest = await promptInteractiveCustomAgentUpdate(selectedTargetResult.value);
+		if (updateRequest.status === "cancelled") return "cancelled";
+		if (updateRequest.status !== "submitted") continue;
+		await runAgentsCustomUpdate({
+			id: updateRequest.value.id,
+			..."name" in updateRequest.value ? { name: updateRequest.value.name } : { dir: updateRequest.value.dir },
+			profile: input.profile,
+			view: input.view
+		});
+		return "completed";
+	}
+}
+async function promptInteractiveCustomAgentAddDetails(input) {
+	while (true) {
+		const dirResult = await promptRequiredInteractiveText({
+			message: "Custom target absolute dir",
+			placeholder: input.dirPlaceholder,
+			requiredMessage: "Custom target absolute dir is required.",
+			validate: (value) => isAbsolute(value) ? null : "Custom target absolute dir must be an absolute path."
+		});
+		if (dirResult.status === "cancelled" || dirResult.status === "back") return dirResult;
+		if (dirResult.status !== "selected") continue;
+		const idResult = await promptInteractiveText({
+			message: "Custom target id (optional)",
+			placeholder: input.idPlaceholder,
+			allowEmpty: true
+		});
+		if (idResult.status === "cancelled") return idResult;
+		if (idResult.status === "back") {
+			input.dirPlaceholder = dirResult.value;
+			continue;
+		}
+		if (idResult.status !== "selected") continue;
+		return {
+			status: "submitted",
+			value: {
+				dir: dirResult.value,
+				id: normalizeOptionalString(idResult.value) ?? void 0,
+				idInput: normalizeOptionalString(idResult.value) ?? void 0
+			}
+		};
+	}
+}
+async function promptInteractiveCustomAgentUpdate(selectedTarget) {
+	while (true) {
+		const field = await promptInteractiveCustomAgentEditField();
+		if (field.status === "cancelled" || field.status === "back") return field;
+		if (field.status !== "selected") continue;
+		const valueResult = await promptInteractiveCustomAgentEditValue({
+			field: field.value,
+			selectedTarget
+		});
+		if (valueResult.status === "cancelled") return valueResult;
+		if (valueResult.status === "back") continue;
+		if (valueResult.status !== "selected") continue;
+		return {
+			status: "submitted",
+			value: field.value === "name" ? {
+				id: selectedTarget.id,
+				name: valueResult.value
+			} : {
+				id: selectedTarget.id,
+				dir: valueResult.value
+			}
+		};
+	}
+}
+async function promptInteractiveCustomAgentEditField() {
+	const field = await select({
+		message: "Edit field",
+		options: [
+			{
+				value: "name",
+				label: "Name"
+			},
+			{
+				value: "dir",
+				label: "Dir"
+			},
+			{
+				value: "back",
+				label: "Back"
+			}
+		]
+	});
+	if (isCancel(field)) return { status: "cancelled" };
+	if (field === "back") return { status: "back" };
+	return {
+		status: "selected",
+		value: field
+	};
+}
+function promptInteractiveCustomAgentEditValue(input) {
+	return input.field === "name" ? promptRequiredInteractiveText({
+		message: "New name",
+		placeholder: input.selectedTarget.name,
+		requiredMessage: "Custom target name is required."
+	}) : promptRequiredInteractiveText({
+		message: "New absolute dir",
+		placeholder: input.selectedTarget.dir,
+		requiredMessage: "Custom target absolute dir is required.",
+		validate: (nextDir) => isAbsolute(nextDir) ? null : "Custom target absolute dir must be an absolute path."
+	});
+}
+async function promptInteractiveText(input) {
+	const value = await promptTextEntry({
+		message: input.message,
+		...input.placeholder ? { placeholder: input.placeholder } : {},
+		allowBack: true,
+		backLabel: "Back",
+		allowEmpty: input.allowEmpty === true,
+		requiredMessage: "Value is required."
+	});
+	if (value.status === "cancelled") return { status: "cancelled" };
+	if (value.status === "back") return { status: "back" };
+	return {
+		status: "selected",
+		value: value.value
+	};
+}
+async function promptRequiredInteractiveText(input) {
+	while (true) {
+		const valueResult = await promptInteractiveText({
+			message: input.message,
+			...input.placeholder ? { placeholder: input.placeholder } : {}
+		});
+		if (valueResult.status === "cancelled" || valueResult.status === "back") return valueResult;
+		if (valueResult.status !== "selected") continue;
+		const normalizedValue = normalizeOptionalString(valueResult.value);
+		if (!normalizedValue) {
+			process.stderr.write(`${input.requiredMessage}\n`);
+			continue;
+		}
+		const validationMessage = input.validate?.(normalizedValue) ?? null;
+		if (validationMessage) {
+			process.stderr.write(`${validationMessage}\n`);
+			continue;
+		}
+		return {
+			status: "selected",
+			value: normalizedValue
+		};
+	}
+}
+async function promptSelectCustomTarget(input) {
+	const customTargets = await listAgentCustomTargets();
+	if (customTargets.length === 0) {
+		process.stderr.write(`${formatAgentsCopy(input.emptyMessage)}\n`);
+		return { status: "empty" };
+	}
+	const choice = await promptSearchSelect({
+		message: input.message,
+		items: customTargets.map(buildCustomTargetSearchItem),
+		maxVisible: 8,
+		allowBack: true,
+		backLabel: "Back"
+	});
+	if (choice.status === "cancelled") return { status: "cancelled" };
+	if (choice.status === "back") return { status: "back" };
+	const id = normalizeAgentId(choice.value);
+	const selectedTarget = customTargets.find((target) => target.id === id);
+	if (!selectedTarget) return { status: "empty" };
+	return {
+		status: "selected",
+		value: selectedTarget
+	};
+}
+async function promptEnableAgentIdsFromUnifiedBuiltins(input) {
+	const selectableCandidates = input.candidates.filter((candidate) => canSelectAgentForNewLocalAgentSetup(candidate) && !candidate.enabled);
+	if (selectableCandidates.length === 0) {
+		process.stderr.write(`${formatAgentsCopy(NO_ACTIONABLE_AGENTS_ENABLE_MESSAGE)}\n`);
+		return { status: "empty" };
+	}
+	emitInteractiveDescription(AGENTS_ENABLE_DESCRIPTION);
+	const selected = await promptSearchMultiselect({
+		message: "Choose agents to enable",
+		items: [...selectableCandidates.map(buildUnifiedEnableSearchItem), {
+			value: CUSTOM_AGENTS_COMING_SOON_OPTION_ID,
+			label: "Custom agents (coming soon)",
+			detail: formatInlineOpenMeldCliCommands("Use `openmeld agents custom` commands for custom targets for now."),
+			searchText: "Custom agents (coming soon) Use openmeld agents custom commands for custom targets for now",
+			disabled: true
+		}],
+		required: true,
+		maxVisible: 8,
+		allowBack: true,
+		backLabel: "Back"
+	});
+	if (selected.status === "cancelled") return { status: "cancelled" };
+	if (selected.status === "back") return { status: "back" };
+	const agentIds = normalizeAgentIds(selected.value.sort()).filter((agentId) => agentId !== CUSTOM_AGENTS_COMING_SOON_OPTION_ID);
+	if (agentIds.length === 0) return { status: "empty" };
+	return {
+		status: "selected",
+		value: agentIds
+	};
+}
+async function listRegisteredAgentStates() {
+	return (await listAgentTargetStates()).filter((state) => Boolean(state.registration));
+}
+async function promptSelectRegisteredAgent(input) {
+	const registeredStates = await listRegisteredAgentStates();
+	if (registeredStates.length === 0) {
+		process.stderr.write(`${formatAgentsCopy(input.emptyMessage)}\n`);
+		return { status: "empty" };
+	}
+	emitInteractiveDescription(AGENTS_SELECT_REGISTERED_DESCRIPTION);
+	const choice = await promptSearchSelect({
+		message: input.message,
+		items: registeredStates.map(buildRegisteredAgentSearchItem),
+		maxVisible: 8,
+		allowBack: true,
+		backLabel: "Back"
+	});
+	if (choice.status === "cancelled") return { status: "cancelled" };
+	if (choice.status === "back") return { status: "back" };
+	const agentId = normalizeAgentId(choice.value);
+	if (!agentId) return { status: "empty" };
+	const selectedState = registeredStates.find((state) => state.agentId === agentId);
+	if (!selectedState) return { status: "empty" };
+	return {
+		status: "selected",
+		value: selectedState
+	};
+}
+function buildCustomTargetSearchItem(target) {
+	return {
+		value: target.id,
+		label: target.name,
+		detail: buildMetadataDetailLine([`ID ${target.id}`, target.dir]),
+		searchText: [
+			target.name,
+			target.id,
+			target.dir
+		].join(" ")
+	};
+}
+function buildUnifiedEnableSearchItem(candidate) {
+	const statusHint = buildUnifiedEnableTargetHint(candidate);
+	return {
+		value: candidate.agentId,
+		label: candidate.displayName,
+		detail: buildMetadataDetailLine([`ID ${candidate.agentId}`, statusHint]),
+		searchText: [
+			candidate.displayName,
+			candidate.agentId,
+			statusHint,
+			candidate.selectableReason ?? ""
+		].join(" "),
+		disabled: !canSelectAgentForNewLocalAgentSetup(candidate) || candidate.enabled
+	};
+}
+function buildRegisteredAgentSearchItem(state) {
+	const enabledHint = buildRegisteredAgentHint(state);
+	return {
+		value: state.agentId,
+		label: state.agentId,
+		detail: buildMetadataDetailLine([state.displayName, enabledHint]),
+		searchText: [
+			state.displayName,
+			state.agentId,
+			enabledHint,
+			"space wake mention reply"
+		].join(" ")
+	};
+}
+function buildMetadataDetailLine(parts) {
+	return parts.map((part) => String(part ?? "").trim()).filter((part) => part.length > 0).join(" · ");
+}
+async function runAgentsDetect(input) {
+	const runtime = await resolveRuntimeContext({
+		view: input.view,
+		profile: input.profile
+	});
+	const inventory = await collectLocalAgentControllerInventory();
+	const detectedAgents = inventory.capabilities.filter((capability) => capability.detected && (capability.lifecycleStatus !== "suspended" || capability.enabled)).map((capability) => ({
+		id: capability.agentId,
+		blockerReasonCodes: capability.blockerReasonCodes,
+		displayName: capability.displayName,
+		launchability: capability.launchability,
+		launchStatus: formatAgentViewLaunchStatus(capability.launchStatus),
+		launchStatusDetail: capability.launchStatusDetail,
+		lifecycleStatus: capability.lifecycleStatus,
+		selectable: capability.selectable
+	}));
+	const payload = {
+		detectedAgents,
+		count: detectedAgents.length,
+		inventorySource: "local_runtime_inventory",
+		source: "builtin_detect"
+	};
+	if (input.json === true) {
+		emitCliJsonEnvelope({
+			schemaVersion: 1,
+			type: "agents.detect",
+			...payload
+		});
+		return;
+	}
+	const presenter = createPresenter(runtime);
+	await emitAgentsConfigParseFallbackSignal({
+		presenter,
+		view: runtime.resolvedView
+	});
+	emitAgentsOverviewIfAgent({
+		presenter,
+		resolvedView: runtime.resolvedView,
+		command: "detect"
+	});
+	if (runtime.resolvedView === "agent") {
+		presenter.data({
+			code: "agents.detect.result",
+			payload
+		});
+		return;
+	}
+	const readyAgents = detectedAgents.filter((agent) => agent.lifecycleStatus !== "suspended" && agent.launchability === "launchable");
+	const needsChoiceAgents = detectedAgents.filter((agent) => agent.lifecycleStatus !== "suspended" && agent.launchability === "needs_choice");
+	const needsRepairAgents = detectedAgents.filter((agent) => agent.lifecycleStatus !== "suspended" && agent.launchability === "needs_repair");
+	const comingSoonAgents = detectedAgents.filter((agent) => agent.lifecycleStatus !== "suspended" && agent.launchability === "not_supported" && !agent.selectable);
+	const suspendedAgents = detectedAgents.filter((agent) => agent.lifecycleStatus === "suspended");
+	const notDetectedAgents = inventory.capabilities.filter((capability) => !capability.detected);
+	if (detectedAgents.length === 0) {
+		renderAgentsInfoCard({
+			presenter,
+			codePrefix: "agents.detect.empty.card",
+			title: "Agents Found Here",
+			rows: [{
+				label: "Found",
+				value: pc.dim("No supported AI agents yet")
+			}, {
+				label: "Next",
+				value: formatInlineOpenMeldCliCommands("Open or install the AI tool you want OpenMeld to use, then run `openmeld agents detect` again.")
+			}],
+			minContentWidth: 36
+		});
+		return;
+	}
+	renderAgentsInfoCard({
+		presenter,
+		codePrefix: "agents.detect.summary.card",
+		title: "Agents Found Here",
+		rows: [
+			{
+				label: "Found",
+				value: buildDetectedAgentsSubtitle(detectedAgents.length)
+			},
+			{
+				label: "Available now",
+				value: buildReadyCountValue(readyAgents.length, "live for Space")
+			},
+			{
+				label: "Needs choice",
+				value: buildNotReadyCountValue(needsChoiceAgents.length, "found, needs your choice")
+			},
+			{
+				label: "Needs repair",
+				value: buildNotReadyCountValue(needsRepairAgents.length, "found, needs repair")
+			},
+			{
+				label: "Coming soon",
+				value: buildNotReadyCountValue(comingSoonAgents.length, "found, not supported yet")
+			},
+			{
+				label: "Suspended",
+				value: buildNotReadyCountValue(suspendedAgents.length, "already configured, not offered for new profiles")
+			},
+			{
+				label: "Not found",
+				value: buildNotReadyCountValue(notDetectedAgents.length, "not found on this computer")
+			}
+		],
+		minContentWidth: 42
+	});
+	if (readyAgents.length > 0) {
+		presenter.line({
+			code: "agents.detect.ready.spacer",
+			text: ""
+		});
+		renderAgentsInfoCard({
+			presenter,
+			codePrefix: "agents.detect.ready.card",
+			title: `Available Now (${readyAgents.length})`,
+			rows: readyAgents.map((agent) => buildReadyAgentCardRow(agent.id, agent.displayName)),
+			minContentWidth: 30
+		});
+	}
+	if (needsRepairAgents.length > 0) {
+		presenter.line({
+			code: "agents.detect.needs_repair.spacer",
+			text: ""
+		});
+		renderAgentsInfoCard({
+			presenter,
+			codePrefix: "agents.detect.needs_repair.card",
+			title: `Needs Repair (${needsRepairAgents.length})`,
+			rows: needsRepairAgents.map((agent) => buildStatusAgentCardRow({
+				agentId: agent.id,
+				displayName: agent.displayName,
+				detail: agent.launchStatusDetail ?? "Repair on this computer before OpenMeld can start it"
+			})),
+			minContentWidth: 36
+		});
+	}
+	if (needsChoiceAgents.length > 0) {
+		presenter.line({
+			code: "agents.detect.needs_choice.spacer",
+			text: ""
+		});
+		renderAgentsInfoCard({
+			presenter,
+			codePrefix: "agents.detect.needs_choice.card",
+			title: `Needs Your Choice (${needsChoiceAgents.length})`,
+			rows: needsChoiceAgents.map((agent) => buildStatusAgentCardRow({
+				agentId: agent.id,
+				displayName: agent.displayName,
+				detail: "Choose which install OpenMeld should use on this Mac"
+			})),
+			minContentWidth: 36
+		});
+	}
+	if (comingSoonAgents.length > 0) {
+		presenter.line({
+			code: "agents.detect.coming_soon.spacer",
+			text: ""
+		});
+		renderAgentsInfoCard({
+			presenter,
+			codePrefix: "agents.detect.coming_soon.card",
+			title: `Coming Soon (${comingSoonAgents.length})`,
+			rows: comingSoonAgents.map((agent) => buildStatusAgentCardRow({
+				agentId: agent.id,
+				displayName: agent.displayName,
+				detail: "OpenMeld found it, but builtin runtime support is not available yet"
+			})),
+			minContentWidth: 36
+		});
+	}
+	if (suspendedAgents.length > 0) {
+		presenter.line({
+			code: "agents.detect.suspended.spacer",
+			text: ""
+		});
+		renderAgentsInfoCard({
+			presenter,
+			codePrefix: "agents.detect.suspended.card",
+			title: `Suspended (${suspendedAgents.length})`,
+			rows: suspendedAgents.map((agent) => buildStatusAgentCardRow({
+				agentId: agent.id,
+				displayName: agent.displayName,
+				detail: "Already configured here, but OpenMeld no longer offers it for new profiles"
+			})),
+			minContentWidth: 46
+		});
+	}
+}
+async function runAgentsList(input) {
+	const runtime = await resolveRuntimeContext({
+		view: input.view,
+		profile: input.profile
+	});
+	const states = await listAgentTargetStates();
+	const registrations = states.filter(hasAgentRegistration).map((state) => buildAgentRegistrationAgentView(state)).sort((left, right) => compareAgentControllerRefsForDisplay(left.agentId, right.agentId));
+	const payload = {
+		registrations,
+		count: registrations.length
+	};
+	if (input.json === true) {
+		emitCliJsonEnvelope({
+			schemaVersion: 1,
+			type: "agents.list",
+			...payload
+		});
+		return;
+	}
+	const presenter = createPresenter(runtime);
+	await emitAgentsConfigParseFallbackSignal({
+		presenter,
+		view: runtime.resolvedView
+	});
+	emitAgentsOverviewIfAgent({
+		presenter,
+		resolvedView: runtime.resolvedView,
+		command: "list"
+	});
+	if (runtime.resolvedView === "agent") {
+		presenter.data({
+			code: "agents.list.result",
+			payload
+		});
+		return;
+	}
+	const enabledStates = states.filter((state) => state.registration?.enabled);
+	const readyEnabledStates = enabledStates.filter((state) => state.launchStatus === "ready");
+	const needsChoiceEnabledStates = enabledStates.filter((state) => state.launchStatus === "needs_choice");
+	const needsRepairEnabledStates = enabledStates.filter((state) => state.launchStatus === "needs_repair");
+	if (readyEnabledStates.length === 0 && needsChoiceEnabledStates.length === 0 && needsRepairEnabledStates.length === 0) {
+		renderAgentsInfoCard({
+			presenter,
+			codePrefix: "agents.list.empty.card",
+			title: "Agents Available for Space",
+			rows: [{
+				label: "Live now",
+				value: pc.dim("No agents are live yet")
+			}, {
+				label: "Next",
+				value: formatInlineOpenMeldCliCommands("Run `openmeld agents detect`, then enable the agents you want OpenMeld to use.")
+			}],
+			minContentWidth: 38
+		});
+		return;
+	}
+	renderAgentsInfoCard({
+		presenter,
+		codePrefix: "agents.list.summary.card",
+		title: "Agents Available for Space",
+		rows: [
+			{
+				label: "Live now",
+				value: buildEnabledAgentsSubtitle(readyEnabledStates.length)
+			},
+			{
+				label: "Needs choice",
+				value: String(needsChoiceEnabledStates.length)
+			},
+			{
+				label: "Needs repair",
+				value: String(needsRepairEnabledStates.length)
+			},
+			{
+				label: "Mention as",
+				value: `${formatAgentMention("agent-id")} ${pc.dim("in Space")}`
+			}
+		],
+		minContentWidth: 38
+	});
+	presenter.line({
+		code: "agents.list.ready.spacer",
+		text: ""
+	});
+	renderAgentsInfoCard({
+		presenter,
+		codePrefix: "agents.list.ready.card",
+		title: `Available Agents (${readyEnabledStates.length})`,
+		rows: readyEnabledStates.map((state) => buildReadyAgentCardRow(state.agentId, state.displayName)),
+		minContentWidth: 30
+	});
+	if (needsRepairEnabledStates.length > 0) {
+		presenter.line({
+			code: "agents.list.needs_repair.spacer",
+			text: ""
+		});
+		renderAgentsInfoCard({
+			presenter,
+			codePrefix: "agents.list.needs_repair.card",
+			title: `Needs Repair (${needsRepairEnabledStates.length})`,
+			rows: needsRepairEnabledStates.map((state) => buildStatusAgentCardRow({
+				agentId: state.agentId,
+				displayName: state.displayName,
+				detail: "Connected in OpenMeld, but OpenMeld can't start it on this computer yet"
+			})),
+			minContentWidth: 36
+		});
+	}
+	if (needsChoiceEnabledStates.length > 0) {
+		presenter.line({
+			code: "agents.list.needs_choice.spacer",
+			text: ""
+		});
+		renderAgentsInfoCard({
+			presenter,
+			codePrefix: "agents.list.needs_choice.card",
+			title: `Needs Your Choice (${needsChoiceEnabledStates.length})`,
+			rows: needsChoiceEnabledStates.map((state) => buildStatusAgentCardRow({
+				agentId: state.agentId,
+				displayName: state.displayName,
+				detail: "Connected in OpenMeld, but OpenMeld still needs one install choice on this Mac"
+			})),
+			minContentWidth: 36
+		});
+	}
+}
+async function runAgentsShow(input) {
+	const runtime = await resolveRuntimeContext({
+		view: input.view,
+		profile: input.profile
+	});
+	const presenter = createPresenter(runtime);
+	await emitAgentsConfigParseFallbackSignal({
+		presenter,
+		view: runtime.resolvedView
+	});
+	emitAgentsOverviewIfAgent({
+		presenter,
+		resolvedView: runtime.resolvedView,
+		command: "show"
+	});
+	const agentId = normalizeAgentId(input.agentId ?? "");
+	if (!agentId) throw new Error("agents.invalid_agent_id: provide a non-empty <agent-id> for show");
+	const state = await resolveAgentTargetState(agentId);
+	if (!hasAgentRegistration(state)) throw new Error(`agents.not_registered: agent is not registered: ${agentId}`);
+	const registration = state.registration;
+	let agentControllerInterface = null;
+	if (state.targetKind === "builtin" && state.enabled) {
+		const builtinState = state;
+		agentControllerInterface = await resolveAgentControllerInterfaceSnapshot({
+			agentControllerRef: buildAgentControllerRef({
+				id: builtinState.agentId,
+				kind: "builtin"
+			}),
+			state: builtinState
+		});
+	}
+	const payload = {
+		agent: buildAgentRegistrationAgentView(state),
+		agentControllerInterface: input.json === true || runtime.resolvedView === "agent" ? projectLegacyAgentControllerInterface(agentControllerInterface) : agentControllerInterface,
+		installChoices: state.installChoices,
+		launchStatus: formatAgentViewLaunchStatus(state.launchStatus),
+		launchStatusDetail: state.launchStatusDetail,
+		effectiveConfig: buildEffectiveConfig(state)
+	};
+	if (input.json === true) {
+		emitCliJsonEnvelope({
+			schemaVersion: 1,
+			type: "agents.show",
+			...payload
+		});
+		return;
+	}
+	if (runtime.resolvedView === "agent") {
+		presenter.data({
+			code: "agents.show.result",
+			payload
+		});
+		return;
+	}
+	renderAgentsInfoCard({
+		presenter,
+		codePrefix: "agents.show.card",
+		title: "Agent in OpenMeld",
+		rows: [
+			{
+				label: "Agent",
+				value: formatAgentMention(registration.agentId)
+			},
+			{
+				label: "App",
+				value: registration.displayName
+			},
+			{
+				label: "Status",
+				value: buildAgentsShowStatusValue({
+					enabled: registration.enabled,
+					launchStatus: state.launchStatus
+				})
+			},
+			{
+				label: "Wake",
+				value: buildAgentsShowWakeValue({
+					agentId: registration.agentId,
+					enabled: registration.enabled,
+					launchStatus: state.launchStatus
+				})
+			},
+			{
+				label: "Connection Type",
+				value: `${resolveTransportModeForDisplay(state)} ${pc.dim("on this computer")}`
+			},
+			...buildAgentControllerInterfaceRows(agentControllerInterface),
+			...state.launchStatusDetail ? [{
+				label: "Why",
+				value: state.launchStatusDetail
+			}] : [],
+			...state.launchStatus === "needs_choice" ? [{
+				label: "Next",
+				value: formatInlineOpenMeldCliCommands(`Run \`openmeld agents repair --agent ${registration.agentId}\` and choose one install`)
+			}] : [],
+			...state.launchStatus === "needs_repair" ? [{
+				label: "Next",
+				value: formatInlineOpenMeldCliCommands(`Run \`openmeld agents repair --agent ${registration.agentId}\``)
+			}] : []
+		],
+		minContentWidth: 34
+	});
+}
+function projectLegacyAgentControllerInterface(snapshot) {
+	if (!snapshot?.usageLimits) return snapshot;
+	const { usageLimits: _usageLimits, ...legacySnapshot } = snapshot;
+	return legacySnapshot;
+}
+function createSilentAgentsPresenter(runtime) {
+	return {
+		view: runtime.resolvedView,
+		event: () => void 0,
+		line: () => void 0,
+		data: () => void 0
+	};
+}
+async function runAgentsEnable(input) {
+	const runtime = await resolveRuntimeContext({
+		interactive: input.interactive,
+		view: input.view,
+		profile: input.profile
+	});
+	const presenter = input.json === true ? createSilentAgentsPresenter(runtime) : createPresenter(runtime);
+	await emitAgentsConfigParseFallbackSignal({
+		presenter,
+		view: runtime.resolvedView
+	});
+	emitAgentsOverviewIfAgent({
+		presenter,
+		resolvedView: runtime.resolvedView,
+		command: "enable",
+		handled: input.presentation === "handoff"
+	});
+	const explicitIds = normalizeAgentIds(input.agent ?? []);
+	const explicitInstallId = normalizeOptionalString(input.install);
+	validateBuiltinAgentSelectionInput({
+		all: input.all,
+		command: "enable",
+		explicitIds,
+		explicitInstallId
+	});
+	const targetStates = await listAgentTargetStates();
+	const targetStateById = new Map(targetStates.map((state) => [state.agentId, state]));
+	const selectableBuiltinIds = new Set(targetStates.filter(canSelectAgentForNewLocalAgentSetup).map((state) => state.agentId));
+	const requested = input.all ? [...selectableBuiltinIds].sort((left, right) => left.localeCompare(right)) : explicitIds;
+	const summary = {
+		requested,
+		registered: [],
+		reenabled: [],
+		skipped: [],
+		errors: [],
+		allMode: Boolean(input.all)
+	};
+	const launchSelections = await collectEnableLaunchActionSelections({
+		explicitInstallId,
+		interactiveChoiceAllowed: input.json === true ? false : resolveInteractiveChoiceAllowed({
+			all: input.all,
+			runtime
+		}),
+		requested,
+		summary,
+		targetStateById
+	});
+	if (launchSelections.status === "cancelled") {
+		cancel("Cancelled.");
+		return {
+			status: "cancelled",
+			summary
+		};
+	}
+	if (launchSelections.status === "back") return {
+		status: "back",
+		summary
+	};
+	await updateAgentRegistrations((current) => applyEnableSelectionUpdates({
+		current,
+		requested: requested.filter((agentId) => !launchSelections.blockedAgentIds.has(agentId)),
+		selectedLaunchContracts: launchSelections.selectedLaunchContracts,
+		selectableBuiltinIds,
+		summary,
+		targetStateById
+	}));
+	if (input.json === true) {
+		emitCliJsonEnvelope({
+			schemaVersion: 1,
+			type: "agents.enable",
+			...summary
+		});
+		return {
+			status: "completed",
+			summary
+		};
+	}
+	if (runtime.resolvedView === "agent") {
+		presenter.data({
+			code: "agents.enable.result",
+			payload: summary
+		});
+		return {
+			status: "completed",
+			summary
+		};
+	}
+	if (input.presentation !== "handoff") emitEnableSummaryCardsForHuman({
+		presenter,
+		summary,
+		targetStateById
+	});
+	return {
+		status: "completed",
+		summary
+	};
+}
+async function runAgentsRepair(input) {
+	const runtime = await resolveRuntimeContext({
+		interactive: input.interactive,
+		view: input.view,
+		profile: input.profile
+	});
+	const presenter = createPresenter(runtime);
+	await emitAgentsConfigParseFallbackSignal({
+		presenter,
+		view: runtime.resolvedView
+	});
+	emitAgentsOverviewIfAgent({
+		presenter,
+		resolvedView: runtime.resolvedView,
+		command: "repair",
+		handled: input.presentation === "handoff"
+	});
+	const explicitIds = normalizeAgentIds(input.agent ?? []);
+	const explicitInstallId = normalizeOptionalString(input.install);
+	validateBuiltinAgentSelectionInput({
+		all: input.all,
+		command: "repair",
+		explicitIds,
+		explicitInstallId
+	});
+	const targetStates = await listAgentTargetStates();
+	const targetStateById = new Map(targetStates.map((state) => [state.agentId, state]));
+	const requested = input.all ? targetStates.filter((state) => state.targetKind === "builtin" && state.registered && (state.launchStatus === "needs_choice" || state.launchStatus === "needs_repair")).map((state) => state.agentId) : explicitIds;
+	const summary = {
+		requested,
+		repaired: [],
+		skipped: [],
+		errors: [],
+		allMode: Boolean(input.all)
+	};
+	const repairedLaunchContracts = /* @__PURE__ */ new Map();
+	const repairOutcome = await collectRepairLaunchActions({
+		allowReadyForInstallChange: input.changeInstall === true || explicitInstallId !== null,
+		explicitInstallId,
+		interactiveChoiceAllowed: resolveInteractiveChoiceAllowed({
+			all: input.all,
+			runtime
+		}),
+		repairedLaunchContracts,
+		requested,
+		summary,
+		targetStateById
+	});
+	if (repairOutcome === "cancelled") {
+		cancel("Cancelled.");
+		return {
+			status: "cancelled",
+			summary
+		};
+	}
+	if (repairOutcome === "back") return {
+		status: "back",
+		summary
+	};
+	if (repairedLaunchContracts.size > 0) await updateAgentRegistrations((current) => {
+		const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+		return sortAgentRegistrations(current.map((registration) => {
+			const launchContract = repairedLaunchContracts.get(registration.agentId);
+			if (!launchContract) return registration;
+			return {
+				...registration,
+				launchContract,
+				updatedAt: nowIso
+			};
+		}));
+	});
+	if (runtime.resolvedView === "agent") {
+		presenter.data({
+			code: "agents.repair.result",
+			payload: summary
+		});
+		return {
+			status: "completed",
+			summary
+		};
+	}
+	if (input.presentation !== "handoff") {
+		renderAgentsInfoCard({
+			presenter,
+			codePrefix: "agents.repair.summary.card",
+			title: "Agents Repaired",
+			rows: buildRepairSummaryRows(summary),
+			minContentWidth: 38
+		});
+		for (const card of buildRepairDetailCards(summary, targetStateById)) {
+			presenter.line({
+				code: `agents.repair.${card.codeSuffix}.spacer`,
+				text: ""
+			});
+			renderAgentsInfoCard({
+				presenter,
+				codePrefix: `agents.repair.${card.codeSuffix}.card`,
+				title: card.title,
+				rows: card.rows,
+				minContentWidth: 32
+			});
+		}
+	}
+	return {
+		status: "completed",
+		summary
+	};
+}
+function buildAgentsShowStatusValue(input) {
+	if (input.launchStatus === "needs_choice") return formatAgentsToneText("warning", "Needs your choice on this Mac");
+	if (input.launchStatus === "needs_repair") return formatAgentsToneText("warning", "Needs repair on this computer");
+	if (input.enabled) return formatAgentsToneText("success", "Available in Space");
+	return formatAgentsToneText("warning", "Turned off in Space");
+}
+function buildAgentsShowWakeValue(input) {
+	const mention = formatAgentMention(input.agentId);
+	if (input.launchStatus === "needs_choice") return `New ${mention} mentions will not wake it until you choose one install on this Mac`;
+	if (input.launchStatus === "needs_repair") return `New ${mention} mentions will not wake it until you repair it`;
+	if (input.enabled) return `${mention} can wake it`;
+	return `New ${mention} mentions stay off`;
+}
+function buildAgentControllerInterfaceRows(snapshot) {
+	if (!snapshot) return [];
+	return createAgentControllerInterfaceDisplayRows(snapshot);
+}
+async function promptBuiltinAgentInstallChoice(input) {
+	const choice = await select({
+		message: buildInteractiveMenuMessage({
+			title: `Choose the ${input.displayName} install OpenMeld should use`,
+			description: `We found more than one ${input.displayName} install on this Mac. Pick the one OpenMeld should launch for replies.`
+		}),
+		options: [...input.installChoices.map((installChoice) => ({
+			value: installChoice.installId,
+			label: installChoice.label,
+			hint: installChoice.detail
+		})), {
+			value: "__back__",
+			label: "Back"
+		}]
+	});
+	if (isCancel(choice)) return { status: "cancelled" };
+	if (choice === "__back__") return { status: "back" };
+	return {
+		status: "selected",
+		value: String(choice)
+	};
+}
+function buildInstallChoiceNextSteps(input) {
+	return input.installChoices.map((installChoice) => buildBuiltinAgentSelectionCommand({
+		agentIds: [input.agentId],
+		command: input.command,
+		installId: installChoice.installId
+	}));
+}
+function createInstallChoiceError(input) {
+	return {
+		agentId: input.agentId,
+		code: "controller.launch.choice_required",
+		humanActionRequired: true,
+		installChoices: input.installChoices,
+		nextSteps: buildInstallChoiceNextSteps({
+			agentId: input.agentId,
+			command: input.command,
+			installChoices: input.installChoices
+		}),
+		reason: input.reason,
+		summary: input.summary ?? "OpenMeld needs one install choice on this Mac before it can continue."
+	};
+}
+async function resolveBuiltinLaunchAction(input) {
+	if (!(input.command === "repair" || Boolean(input.explicitInstallId) || input.state.launchStatus === "needs_choice" || input.state.launchStatus === "needs_repair")) return { status: "not_needed" };
+	let repairResult = await repairBuiltinControllerInstall({
+		agentId: input.state.agentId,
+		detected: input.state.detected,
+		displayName: input.state.displayName,
+		installId: input.explicitInstallId,
+		runtimeSupported: input.state.runtimeSupported
+	});
+	if (!repairResult.ok && repairResult.errorCode === "controller.launch.choice_required" && input.interactiveChoiceAllowed) {
+		const installChoice = await promptBuiltinAgentInstallChoice({
+			displayName: input.state.displayName,
+			installChoices: repairResult.installChoices
+		});
+		if (installChoice.status === "cancelled") return { status: "cancelled" };
+		if (installChoice.status === "back" || installChoice.status === "empty") return { status: "back" };
+		repairResult = await repairBuiltinControllerInstall({
+			agentId: input.state.agentId,
+			detected: input.state.detected,
+			displayName: input.state.displayName,
+			installId: installChoice.value,
+			runtimeSupported: input.state.runtimeSupported
+		});
+	}
+	if (!repairResult.ok) return {
+		error: repairResult.errorCode === "controller.launch.choice_required" ? createInstallChoiceError({
+			agentId: input.state.agentId,
+			command: input.command,
+			installChoices: repairResult.installChoices,
+			reason: repairResult.errorMessage
+		}) : {
+			agentId: input.state.agentId,
+			code: repairResult.errorCode,
+			reason: repairResult.errorMessage
+		},
+		status: "blocked"
+	};
+	return {
+		launchContract: repairResult.launchContract,
+		status: "resolved"
+	};
+}
+function resolveInteractiveChoiceAllowed(input) {
+	return input.runtime.resolvedView === "human" && canUseInteractivePrompts(input.runtime) && input.all !== true;
+}
+async function collectEnableLaunchActionSelections(input) {
+	const blockedAgentIds = /* @__PURE__ */ new Set();
+	const selectedLaunchContracts = /* @__PURE__ */ new Map();
+	for (const requestedId of input.requested) {
+		const state = input.targetStateById.get(requestedId) ?? null;
+		if (!isBuiltinEnableChoiceCandidate(state)) continue;
+		const launchAction = await resolveBuiltinLaunchAction({
+			command: "enable",
+			explicitInstallId: input.explicitInstallId,
+			interactiveChoiceAllowed: input.interactiveChoiceAllowed,
+			state
+		});
+		if (launchAction.status === "not_needed") continue;
+		if (launchAction.status === "cancelled" || launchAction.status === "back") return { status: launchAction.status };
+		if (launchAction.status === "blocked") {
+			blockedAgentIds.add(state.agentId);
+			input.summary.errors.push(launchAction.error);
+			continue;
+		}
+		selectedLaunchContracts.set(state.agentId, launchAction.launchContract);
+	}
+	return {
+		blockedAgentIds,
+		selectedLaunchContracts,
+		status: "completed"
+	};
+}
+async function collectRepairLaunchActions(input) {
+	for (const requestedId of input.requested) {
+		const candidate = resolveRepairCandidate({
+			allowReadyForInstallChange: input.allowReadyForInstallChange,
+			requestedId,
+			targetStateById: input.targetStateById
+		});
+		if (!candidate.ok) {
+			input.summary.errors.push(candidate.error);
+			continue;
+		}
+		if (!(input.allowReadyForInstallChange || input.explicitInstallId) && candidate.state.launchStatus === "ready" && candidate.state.registration?.launchContract) {
+			input.summary.skipped.push({
+				agentId: requestedId,
+				reason: "already_ready"
+			});
+			continue;
+		}
+		const launchAction = await resolveBuiltinLaunchAction({
+			command: "repair",
+			explicitInstallId: input.explicitInstallId,
+			interactiveChoiceAllowed: input.interactiveChoiceAllowed,
+			state: candidate.state
+		});
+		if (launchAction.status === "cancelled" || launchAction.status === "back") return launchAction.status;
+		if (launchAction.status === "blocked") {
+			input.summary.errors.push(launchAction.error);
+			continue;
+		}
+		if (launchAction.status === "not_needed") continue;
+		input.repairedLaunchContracts.set(requestedId, launchAction.launchContract);
+		input.summary.repaired.push(requestedId);
+	}
+	return "completed";
+}
+function applyEnableSelectionUpdates(input) {
+	const next = [...input.current];
+	const existingById = new Map(next.map((registration, index) => [registration.agentId, index]));
+	for (const requestedId of input.requested) applySingleEnableSelection({
+		existingById,
+		next,
+		requestedId,
+		selectedLaunchContracts: input.selectedLaunchContracts,
+		selectableBuiltinIds: input.selectableBuiltinIds,
+		summary: input.summary,
+		targetStateById: input.targetStateById
+	});
+	return sortAgentRegistrations(next);
+}
+function applySingleEnableSelection(input) {
+	if (!input.selectableBuiltinIds.has(input.requestedId)) {
+		const blockedState = input.targetStateById.get(input.requestedId) ?? null;
+		input.summary.errors.push({
+			agentId: input.requestedId,
+			code: "agents.invalid_agent_id",
+			reason: resolveEnableBlockedReason(blockedState)
+		});
+		return;
+	}
+	const targetState = input.targetStateById.get(input.requestedId);
+	if (targetState?.targetKind !== "builtin") {
+		input.summary.errors.push({
+			agentId: input.requestedId,
+			code: "agents.config_write_failed",
+			reason: "selectable built-in target missing from catalog"
+		});
+		return;
+	}
+	const selectedLaunchContract = input.selectedLaunchContracts.get(targetState.agentId) ?? null;
+	const resolvedLaunchContract = selectedLaunchContract ?? targetState.launchContract ?? void 0;
+	if (targetState.launchStatus === "needs_choice" && !selectedLaunchContract) {
+		input.summary.errors.push(createInstallChoiceError({
+			agentId: targetState.agentId,
+			command: "enable",
+			installChoices: targetState.installChoices,
+			reason: targetState.launchStatusDetail ?? "OpenMeld needs one install choice on this Mac before it can turn this on."
+		}));
+		return;
+	}
+	const existingIndex = input.existingById.get(targetState.agentId);
+	if (existingIndex === void 0) {
+		input.next.push(createRegistrationFromCatalogTarget({
+			...targetState,
+			...resolvedLaunchContract ? { launchContract: resolvedLaunchContract } : {}
+		}));
+		input.existingById.set(targetState.agentId, input.next.length - 1);
+		input.summary.registered.push(targetState.agentId);
+		return;
+	}
+	const existing = input.next[existingIndex];
+	if (!existing) {
+		input.summary.errors.push({
+			agentId: targetState.agentId,
+			code: "agents.config_write_failed",
+			reason: "registration index missing"
+		});
+		return;
+	}
+	if (existing.enabled && selectedLaunchContract) {
+		input.next[existingIndex] = applyTargetRuntimeDefaults({
+			registration: {
+				...existing,
+				launchContract: selectedLaunchContract,
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			},
+			targetState
+		});
+		input.summary.reenabled.push(targetState.agentId);
+		return;
+	}
+	if (existing.enabled) {
+		input.summary.skipped.push({
+			agentId: targetState.agentId,
+			reason: "already_enabled"
+		});
+		return;
+	}
+	input.next[existingIndex] = applyTargetRuntimeDefaults({
+		registration: {
+			...existing,
+			enabled: true,
+			...resolvedLaunchContract ? { launchContract: resolvedLaunchContract } : {},
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		},
+		targetState
+	});
+	input.summary.reenabled.push(targetState.agentId);
+}
+function applyTargetRuntimeDefaults(input) {
+	return {
+		...input.registration,
+		...input.targetState.defaultStreamingMode ? { streamingMode: input.targetState.defaultStreamingMode } : {},
+		...input.targetState.defaultTransportMode ? { transportMode: input.targetState.defaultTransportMode } : {}
+	};
+}
+function resolveRepairCandidate(input) {
+	const state = input.targetStateById.get(input.requestedId) ?? null;
+	if (!isBuiltinEnableChoiceCandidate(state)) {
+		if (!state) return {
+			error: {
+				agentId: input.requestedId,
+				code: "agents.invalid_agent_id",
+				reason: "unknown built-in target id"
+			},
+			ok: false
+		};
+		return {
+			error: {
+				agentId: input.requestedId,
+				code: "agents.invalid_agent_id",
+				reason: "custom target is not runnable yet"
+			},
+			ok: false
+		};
+	}
+	if (!state.registered) return {
+		error: {
+			agentId: input.requestedId,
+			code: "agents.not_registered",
+			reason: "agent is not registered"
+		},
+		ok: false
+	};
+	if (input.allowReadyForInstallChange !== true && !(state.launchStatus === "needs_choice" || state.launchStatus === "needs_repair")) return {
+		error: {
+			agentId: input.requestedId,
+			code: "controller.launch.needs_repair",
+			reason: "already available"
+		},
+		ok: false
+	};
+	return {
+		ok: true,
+		state
+	};
+}
+async function runAgentsDisable(input) {
+	const runtime = await resolveRuntimeContext({
+		view: input.view,
+		profile: input.profile
+	});
+	const presenter = input.json === true ? createSilentAgentsPresenter(runtime) : createPresenter(runtime);
+	await emitAgentsConfigParseFallbackSignal({
+		presenter,
+		view: runtime.resolvedView
+	});
+	emitAgentsOverviewIfAgent({
+		presenter,
+		resolvedView: runtime.resolvedView,
+		command: "disable"
+	});
+	const explicitIds = normalizeAgentIds(input.agent ?? []);
+	validateBuiltinAgentSelectionInput({
+		all: input.all,
+		command: "disable",
+		explicitIds,
+		explicitInstallId: null
+	});
+	const registrations = await listAgentRegistrations();
+	const displayNameById = new Map(registrations.map((registration) => [registration.agentId, registration.displayName]));
+	const requested = input.all ? registrations.map((registration) => registration.agentId) : explicitIds;
+	const summary = {
+		requested,
+		disabled: [],
+		skipped: [],
+		errors: [],
+		allMode: Boolean(input.all)
+	};
+	await updateAgentRegistrations((current) => {
+		const next = [...current];
+		const byId = new Map(next.map((registration, index) => [registration.agentId, index]));
+		for (const agentId of requested) {
+			const index = byId.get(agentId);
+			if (index === void 0) {
+				summary.errors.push({
+					agentId,
+					code: "agents.not_registered",
+					reason: "agent is not registered"
+				});
+				continue;
+			}
+			const registration = next[index];
+			if (!registration) {
+				summary.errors.push({
+					agentId,
+					code: "agents.config_write_failed",
+					reason: "registration index missing"
+				});
+				continue;
+			}
+			if (!registration.enabled) {
+				summary.skipped.push({
+					agentId,
+					reason: "already_disabled"
+				});
+				continue;
+			}
+			next[index] = {
+				...registration,
+				enabled: false,
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			summary.disabled.push(agentId);
+		}
+		return sortAgentRegistrations(next);
+	});
+	if (input.json === true) {
+		emitCliJsonEnvelope({
+			schemaVersion: 1,
+			type: "agents.disable",
+			...summary
+		});
+		return;
+	}
+	if (runtime.resolvedView === "agent") {
+		presenter.data({
+			code: "agents.disable.result",
+			payload: summary
+		});
+		return;
+	}
+	emitDisableSummaryCardsForHuman({
+		presenter,
+		summary,
+		displayNameById
+	});
+}
+async function runAgentsConfig(input) {
+	const runtime = await resolveRuntimeContext({
+		view: input.view,
+		profile: input.profile
+	});
+	const presenter = createPresenter(runtime);
+	await emitAgentsConfigParseFallbackSignal({
+		presenter,
+		view: runtime.resolvedView
+	});
+	emitAgentsOverviewIfAgent({
+		presenter,
+		resolvedView: runtime.resolvedView,
+		command: "config"
+	});
+	const agentId = normalizeAgentId(input.agentId ?? "");
+	if (!agentId) throw new Error("agents.invalid_agent_id: provide a non-empty <agent-id> for config");
+	const enabled = parseAgentEnabledOption(input.enabled);
+	if (enabled === void 0) throw new Error("agents.config_invalid: provide at least one option (--enabled)");
+	const updatedFields = [];
+	const effectiveConfig = (await updateAgentRegistrations((current) => {
+		const index = current.findIndex((item) => item.agentId === agentId);
+		if (index < 0) throw new Error(`agents.not_registered: agent is not registered: ${agentId}`);
+		const next = [...current];
+		const selected = next[index];
+		if (!selected) throw new Error("agents.config_write_failed: registration index missing");
+		const existing = { ...selected };
+		if (enabled !== void 0) {
+			existing.enabled = enabled;
+			updatedFields.push("enabled");
+		}
+		existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		next[index] = existing;
+		return sortAgentRegistrations(next);
+	})).find((item) => item.agentId === agentId) ?? null;
+	if (!effectiveConfig) throw new Error("agents.config_write_failed: config update returned empty");
+	const payload = {
+		agentId,
+		updatedFields,
+		effectiveConfig
+	};
+	if (runtime.resolvedView === "agent") {
+		presenter.data({
+			code: "agents.config.result",
+			payload
+		});
+		return;
+	}
+	renderAgentsInfoCard({
+		presenter,
+		codePrefix: "agents.config.result.card",
+		title: "Agent Updated",
+		rows: [
+			{
+				label: "Agent",
+				value: formatAgentMention(effectiveConfig.agentId)
+			},
+			{
+				label: "App",
+				value: effectiveConfig.displayName
+			},
+			{
+				label: "Status",
+				value: enabled ? formatAgentsToneText("success", "Available for new @mentions") : formatAgentsToneText("warning", "Turned off for new @mentions")
+			},
+			{
+				label: "Wake",
+				value: enabled ? `New ${formatAgentMention(effectiveConfig.agentId)} mentions can wake it` : `New ${formatAgentMention(effectiveConfig.agentId)} mentions stay off`
+			}
+		],
+		minContentWidth: 34
+	});
+}
+async function runAgentsCustomList(input) {
+	const runtime = await resolveRuntimeContext({
+		view: input.view,
+		profile: input.profile
+	});
+	const presenter = createPresenter(runtime);
+	await emitAgentsConfigParseFallbackSignal({
+		presenter,
+		view: runtime.resolvedView
+	});
+	emitAgentsOverviewIfAgent({
+		presenter,
+		resolvedView: runtime.resolvedView,
+		command: "custom_list"
+	});
+	const [targets, states] = await Promise.all([listAgentCustomTargets(), listAgentTargetStates()]);
+	const customStateById = new Map(states.filter((state) => state.targetKind === "custom").map((state) => [state.agentId, state]));
+	const payloadTargets = targets.map((target) => {
+		const state = customStateById.get(target.id);
+		return {
+			id: target.id,
+			name: target.name,
+			dir: target.dir,
+			registered: state?.registered ?? false,
+			enabled: state?.enabled ?? false
+		};
+	});
+	const payload = {
+		targets: payloadTargets,
+		count: payloadTargets.length
+	};
+	if (runtime.resolvedView === "agent") {
+		presenter.data({
+			code: "agents.custom.list.result",
+			payload
+		});
+		return;
+	}
+	emitHumanSectionHeader(presenter, {
+		codePrefix: "agents.custom.list",
+		title: "Custom agents"
+	});
+	if (payloadTargets.length === 0) {
+		presenter.line({
+			code: "agents.custom.list.empty",
+			text: "No custom agents configured."
+		});
+		presenter.line({
+			code: "agents.custom.list.hint",
+			text: formatInlineOpenMeldCliCommands("Tip: run `openmeld agents custom add --name <name> --dir <dir>`.")
+		});
+		return;
+	}
+	presenter.line({
+		code: "agents.custom.list.subtitle",
+		text: `Configured custom agents: ${payloadTargets.length}`
+	});
+	for (const target of payloadTargets) presenter.line({
+		code: "agents.custom.list.item",
+		text: `- ${target.name} (${target.id}) • dir=${target.dir} • registered=${target.registered ? "true" : "false"} • enabled=${target.enabled ? "true" : "false"}`
+	});
+}
+async function runAgentsCustomAdd(input) {
+	const runtime = await resolveRuntimeContext({
+		view: input.view,
+		profile: input.profile
+	});
+	const presenter = createPresenter(runtime);
+	await emitAgentsConfigParseFallbackSignal({
+		presenter,
+		view: runtime.resolvedView
+	});
+	emitAgentsOverviewIfAgent({
+		presenter,
+		resolvedView: runtime.resolvedView,
+		command: "custom_add"
+	});
+	const name = normalizeOptionalString(input.name);
+	const dir = normalizeOptionalString(input.dir);
+	if (!(name && dir)) throw new Error("agents.custom.invalid_argument: provide --name <name> and --dir <dir>");
+	if (!isAbsolute(dir)) throw new Error("agents.custom.invalid_argument: --dir must be an absolute path");
+	const id = normalizeOptionalString(input.id) ?? void 0;
+	const target = await addAgentCustomTarget({
+		name,
+		dir,
+		...id ? { id } : {}
+	});
+	const payload = { target };
+	if (runtime.resolvedView === "agent") {
+		presenter.data({
+			code: "agents.custom.add.result",
+			payload
+		});
+		return;
+	}
+	emitHumanSectionHeader(presenter, {
+		codePrefix: "agents.custom.add",
+		title: "Custom Agent Added"
+	});
+	presenter.line({
+		code: "agents.custom.add.result",
+		text: `${target.name} (${target.id}) -> ${target.dir}`
+	});
+}
+async function runAgentsCustomUpdate(input) {
+	const runtime = await resolveRuntimeContext({
+		view: input.view,
+		profile: input.profile
+	});
+	const presenter = createPresenter(runtime);
+	await emitAgentsConfigParseFallbackSignal({
+		presenter,
+		view: runtime.resolvedView
+	});
+	emitAgentsOverviewIfAgent({
+		presenter,
+		resolvedView: runtime.resolvedView,
+		command: "custom_update"
+	});
+	const id = normalizeAgentId(input.id ?? "");
+	if (!id) throw new Error("agents.custom.invalid_argument: provide --id <id>");
+	const name = normalizeOptionalString(input.name) ?? void 0;
+	const dir = normalizeOptionalString(input.dir) ?? void 0;
+	if (name === void 0 && dir === void 0) throw new Error("agents.custom.invalid_argument: provide at least one option (--name/--dir)");
+	if (dir && !isAbsolute(dir)) throw new Error("agents.custom.invalid_argument: --dir must be an absolute path");
+	const updated = await updateAgentCustomTarget({
+		id,
+		...name ? { name } : {},
+		...dir ? { dir } : {}
+	});
+	const payload = {
+		target: updated.target,
+		updatedFields: updated.updatedFields
+	};
+	if (runtime.resolvedView === "agent") {
+		presenter.data({
+			code: "agents.custom.update.result",
+			payload
+		});
+		return;
+	}
+	emitHumanSectionHeader(presenter, {
+		codePrefix: "agents.custom.update",
+		title: "Custom Agent Updated"
+	});
+	const fields = updated.updatedFields.length > 0 ? updated.updatedFields.join(", ") : "no field changed";
+	presenter.line({
+		code: "agents.custom.update.result",
+		text: `${updated.target.id}: ${fields}`
+	});
+}
+async function runAgentsCustomRemove(input) {
+	const runtime = await resolveRuntimeContext({
+		view: input.view,
+		profile: input.profile
+	});
+	const presenter = createPresenter(runtime);
+	await emitAgentsConfigParseFallbackSignal({
+		presenter,
+		view: runtime.resolvedView
+	});
+	emitAgentsOverviewIfAgent({
+		presenter,
+		resolvedView: runtime.resolvedView,
+		command: "custom_remove"
+	});
+	const id = normalizeAgentId(input.id ?? "");
+	if (!id) throw new Error("agents.custom.invalid_argument: provide --id <id>");
+	if ((await listAgentRegistrations()).some((registration) => registration.agentId === id)) throw new Error(`agents.custom.in_use: target is currently registered: ${id}`);
+	const removed = await removeAgentCustomTarget({ id });
+	const payload = {
+		targetId: id,
+		removed,
+		installsPolicy: "kept"
+	};
+	if (runtime.resolvedView === "agent") {
+		presenter.data({
+			code: "agents.custom.remove.result",
+			payload
+		});
+		return;
+	}
+	emitHumanSectionHeader(presenter, {
+		codePrefix: "agents.custom.remove",
+		title: "Custom Agent Removed"
+	});
+	presenter.line({
+		code: "agents.custom.remove.result",
+		text: `${removed.name} (${removed.id}) removed`
+	});
+	presenter.line({
+		code: "agents.custom.remove.note",
+		text: formatInlineOpenMeldCliCommands("Installs records are kept; cleanup via `openmeld skills uninstall`.")
+	});
+}
+function buildAgentRegistrationAgentView(state) {
+	const transportProjection = resolveTransportModeProjection(state);
+	return {
+		...state.registration,
+		lifecycleStatus: state.lifecycleStatus,
+		configuredTransportMode: transportProjection.configuredTransportMode,
+		configuredTransportModeStatus: transportProjection.configuredTransportModeStatus,
+		defaultTransportMode: transportProjection.defaultTransportMode,
+		effectiveConfig: buildEffectiveConfig(state),
+		effectiveTransportMode: transportProjection.effectiveTransportMode,
+		supportedTransportModes: transportProjection.supportedTransportModes,
+		transportModeSource: transportProjection.transportModeSource
+	};
+}
+function buildEffectiveConfig(state) {
+	const transportProjection = resolveTransportModeProjection(state);
+	return {
+		configuredTransportMode: transportProjection.configuredTransportMode,
+		configuredTransportModeStatus: transportProjection.configuredTransportModeStatus,
+		defaultTransportMode: transportProjection.defaultTransportMode,
+		enabled: state.registration.enabled,
+		effectiveTransportMode: transportProjection.effectiveTransportMode,
+		supportedTransportModes: transportProjection.supportedTransportModes,
+		transportMode: transportProjection.effectiveTransportMode,
+		transportModeSource: transportProjection.transportModeSource
+	};
+}
+function emitAgentsOverviewIfAgent(input) {
+	if (input.resolvedView !== "agent" || input.handled) return;
+	emitAgentsAgentOverview({
+		presenter: input.presenter,
+		command: input.command
+	});
+}
+function resolveTransportModeForDisplay(state) {
+	return formatTransportModeDisplay(resolveTransportModeProjection(state).effectiveTransportMode);
+}
+function resolveTransportModeProjection(state) {
+	const supportedTransportModes = state.transportModes.map((transportMode) => transportMode.mode);
+	const configuredTransportMode = state.registration.transportMode ?? null;
+	let configuredTransportModeStatus;
+	if (configuredTransportMode === null) configuredTransportModeStatus = "missing";
+	else if (supportedTransportModes.length === 0 || supportedTransportModes.includes(configuredTransportMode)) configuredTransportModeStatus = "supported";
+	else configuredTransportModeStatus = "unsupported";
+	if (configuredTransportModeStatus === "supported" && configuredTransportMode) return {
+		configuredTransportMode,
+		configuredTransportModeStatus,
+		defaultTransportMode: state.defaultTransportMode ?? null,
+		effectiveTransportMode: configuredTransportMode,
+		supportedTransportModes,
+		transportModeSource: "registration"
+	};
+	const registryTransportMode = state.defaultTransportMode ?? supportedTransportModes[0] ?? null;
+	if (registryTransportMode) return {
+		configuredTransportMode,
+		configuredTransportModeStatus,
+		defaultTransportMode: state.defaultTransportMode ?? null,
+		effectiveTransportMode: registryTransportMode,
+		supportedTransportModes,
+		transportModeSource: "registry_default"
+	};
+	return {
+		configuredTransportMode,
+		configuredTransportModeStatus,
+		defaultTransportMode: null,
+		effectiveTransportMode: DEFAULT_RUNTIME_AGENT_TRANSPORT_MODE,
+		supportedTransportModes,
+		transportModeSource: "global_default"
+	};
+}
+async function emitAgentsConfigParseFallbackSignal(input) {
+	const health = await readAgentRuntimeConfigHealth();
+	if (!health.parseFallback) return;
+	const reason = health.reason ?? "unknown";
+	const data = {
+		reason,
+		strategy: "fallback_to_empty_config"
+	};
+	if (input.view === "agent") {
+		input.presenter.line({
+			code: "agents.config_parse_fallback",
+			text: `runtime config parse fallback applied (${reason})`,
+			data
+		});
+		return;
+	}
+	input.presenter.line({
+		code: "agents.config_parse_fallback",
+		text: `warning: runtime config parse fallback applied (${reason})`,
+		data
+	});
+}
+//#endregion
+export { resolveGatewayWebOrigin as C, buildSpaceWebUrl as S, runDaemonServiceParticipationGate as T, promptSearchSelect as _, runAgentsCustomRemove as a, resolveOffsetVisibleWindow as b, runAgentsDisable as c, runAgentsManage as d, runAgentsRepair as f, promptSearchMultiselectWorkbench as g, promptSearchMultiselect as h, runAgentsCustomList as i, runAgentsEnable as l, formatTransportModeDisplay as m, runAgentsConfig as n, runAgentsCustomUpdate as o, runAgentsShow as p, runAgentsCustomAdd as r, runAgentsDetect as s, runAgents as t, runAgentsList as u, clampNumber as v, resolveSpaceWebGatewayOrigin as w, computeRetryDelayMs as x, resolveAnchoredVisibleWindow as y };
+
+//# sourceMappingURL=agents-Y-UJ74By.js.map