agent-transport-system 0.7.10 → 0.7.12

package/dist/ats.js

@@ -27,7 +27,7 @@ import wrapAnsi from "wrap-ansi";
 import { Box, Container, Editor, Key, ProcessTerminal, TUI, Text, getEditorKeybindings, matchesKey } from "@mariozechner/pi-tui";
 
 //#region package.json
-var version = "0.7.10";
+var version = "0.7.12";
 var package_default = {
 	$schema: "https://www.schemastore.org/package.json",
 	name: "agent-transport-system",
@@ -8246,10 +8246,30 @@ function safeParseJson$1(raw) {
 	}
 }
 
+//#endregion
+//#region src/config/published-production-safety.ts
+const PUBLISHED_PRODUCTION_ATS_ROOT = normalizeComparablePath(join(homedir(), resolveDefaultAtsHomeDirname("prod")));
+function assertNoPublishedProductionMutationDuringTests(pathInput, targetName) {
+	if (!isTestProcess(pathInput)) return;
+	if (!isPublishedProductionAtsRoot(pathInput)) return;
+	throw new Error([`Refusing to mutate ${targetName} in the published production lane during tests.`, "Set ATS_HOME to a fresh temporary directory, or run the validation through ats-dev or ats-canary."].join(" "));
+}
+function isPublishedProductionAtsRoot(pathInput) {
+	return normalizeComparablePath(resolveAtsRootDir(pathInput)) === PUBLISHED_PRODUCTION_ATS_ROOT;
+}
+function isTestProcess(pathInput = {}) {
+	const env = pathInput.env ?? process.env;
+	const argv = pathInput.argv ?? process.argv;
+	return env.NODE_ENV === "test" || env.VITEST === "true" || typeof env.VITEST_WORKER_ID === "string" || typeof env.JEST_WORKER_ID === "string" || argv.some((arg) => arg.includes("vitest"));
+}
+function normalizeComparablePath(path) {
+	const normalized = resolve(path);
+	return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+
 //#endregion
 //#region src/config/daemon-service-contract.ts
 const DAEMON_SERVICE_CONTRACT_FILENAME = "service-contract.json";
-const PUBLISHED_PRODUCTION_ATS_ROOT = normalizeComparablePath(join(homedir(), resolveDefaultAtsHomeDirname("prod")));
 function daemonServiceContractPath(pathInput = {}) {
 	return join(daemonRuntimeStateRootPath(pathInput), DAEMON_SERVICE_CONTRACT_FILENAME);
 }
@@ -8283,13 +8303,11 @@ async function clearDaemonServiceContract(pathInput = {}) {
 	await rm(daemonServiceContractPath(pathInput), { force: true });
 }
 function assertDaemonServiceContractMutationAllowed(pathInput) {
-	if (!isTestProcess()) return;
-	if (!isPublishedProductionAtsRoot(pathInput)) return;
-	throw new Error(["Refusing to mutate ATS Service contract in the published production lane during tests.", "Set ATS_HOME to a fresh temporary directory, or run the validation through ats-dev or ats-canary."].join(" "));
+	assertNoPublishedProductionMutationDuringTests(pathInput, "ATS Service contract");
 }
 function assertDaemonServiceContractIdentityAllowed(candidate, pathInput) {
-	if (!isPublishedProductionAtsRoot(pathInput)) return;
 	if (!isUnsafeProductionDaemonServiceContractIdentity(candidate)) return;
+	if (isTestProcess(pathInput) && !isPublishedProductionAtsRoot(pathInput)) return;
 	throw new Error(["Refusing to write ATS Service contract with a test fixture identity in the published production lane.", "Run `ats service repair --profile <profile-id>` from the signed-in production lane, or clear the polluted local service state before retrying."].join(" "));
 }
 function isDaemonServiceContractIdentityReusable(contract, pathInput = {}) {
@@ -8317,16 +8335,6 @@ const UNSAFE_PRODUCTION_PROFILE_IDS = new Set([
 function normalizeFixtureText(value) {
 	return value.trim().toLowerCase();
 }
-function isPublishedProductionAtsRoot(pathInput) {
-	return normalizeComparablePath(resolveAtsRootDir(pathInput)) === PUBLISHED_PRODUCTION_ATS_ROOT;
-}
-function isTestProcess(env = process.env) {
-	return env.NODE_ENV === "test" || env.VITEST === "true" || typeof env.VITEST_WORKER_ID === "string" || typeof env.JEST_WORKER_ID === "string" || process.argv.some((arg) => arg.includes("vitest"));
-}
-function normalizeComparablePath(path) {
-	const normalized = resolve(path);
-	return process.platform === "win32" ? normalized.toLowerCase() : normalized;
-}
 function buildContractCandidate(input, pathInput, current) {
 	const lane = input.lane ?? resolveAtsEnvPreset(pathInput);
 	const connectedComputerId = input.connectedComputerId ?? (current && current.lane === lane && current.gatewayUrl === input.gatewayUrl && current.profileId === input.profileId && current.deviceId === input.deviceId ? current.connectedComputerId : void 0);
@@ -9793,6 +9801,7 @@ async function resolveDaemonLifecycleAttribution(input) {
 	};
 }
 async function emitDaemonLifecycleEvent(input) {
+	assertNoPublishedProductionMutationDuringTests(input.pathInput ?? {}, "ATS Service lifecycle journal");
 	const journalPath = daemonLifecycleJournalPath(input.pathInput);
 	const attribution = await resolveDaemonLifecycleAttribution(input);
 	const event = {
@@ -50412,7 +50421,7 @@ async function resolveDaemonServiceParticipationStatusAfterInstall(input) {
 	return { status: refreshedStatus };
 }
 async function runDaemonServiceSafeRefresh(input) {
-	const outcome = await runDaemonReinstall({
+	return await runDaemonReinstall({
 		agentOverviewHandled: true,
 		...input.gatewayUrl ? { gatewayUrl: input.gatewayUrl } : {},
 		...input.atsProfileId ? { profile: input.atsProfileId } : {},
@@ -50423,8 +50432,6 @@ async function runDaemonServiceSafeRefresh(input) {
 		suppressAgentOverview: true,
 		suppressInstallOutput: true
 	});
-	if (outcome.ok && outcome.result === "completed" && outcome.serviceState === "running") return;
-	throw new Error(`ATS Service refresh did not complete: ${outcome.result}`);
 }
 async function runDaemonServiceParticipationActionStage(input) {
 	if (input.status.kind === "needs_repair") return await runDaemonServiceParticipationRefresh({
@@ -50459,11 +50466,39 @@ async function runDaemonServiceParticipationRefresh(input) {
 		data: { reasonCode: input.accountIssue.reasonCode }
 	});
 	try {
-		await runDaemonServiceSafeRefresh({
+		const refreshOutcome = await runDaemonServiceSafeRefresh({
 			atsProfileId: input.input.atsProfileId,
 			gatewayUrl: input.input.gatewayUrl,
 			view: input.input.view
 		});
+		if (refreshOutcome.ok && (refreshOutcome.result === "completed" || refreshOutcome.result === "stopped_safe") && refreshOutcome.serviceState === "stopped") {
+			const startMapped = await mapDaemonBackgroundStartResult(await runDaemonBackgroundStartForDecision({
+				gatewayUrl: input.input.gatewayUrl,
+				...input.input.atsProfileId ? { profile: input.input.atsProfileId } : {},
+				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;
+		}
+		if (!(refreshOutcome.ok && refreshOutcome.result === "completed" && refreshOutcome.serviceState === "running")) throw new Error(`ATS Service refresh did not complete: ${refreshOutcome.result}`);
 	} catch (error) {
 		renderDaemonStartNeedsAttention({
 			presenter: input.input.presenter,
@@ -52927,6 +52962,7 @@ async function runSkillsInstall(input) {
 		presenter,
 		installResults,
 		legacyFindings,
+		quiet: input.quiet,
 		storeDir: skillsDir()
 	});
 	return "completed";
@@ -54532,6 +54568,7 @@ function emitInstallSummary(input) {
 		legacyReview: legacyFindings.length > 0 ? buildLegacyAtsSkillAgentReview(legacyFindings) : null,
 		requiresReview: summary.failed > 0 || legacyFindings.length > 0
 	};
+	if (input.quiet && !payload.requiresReview) return;
 	if (input.resolvedView === "agent") {
 		emitLegacyAtsSkillAgentAttention({
 			legacyFindings,
@@ -64731,7 +64768,7 @@ function buildTerminalStep(input) {
 		case "refresh_service": return {
 			message: "Starting or repairing ATS Service.",
 			run: async () => {
-				if ((await runDaemonServiceParticipationGate({
+				const gate = await runDaemonServiceParticipationGate({
 					intent: "start",
 					presenter: input.input.presenter,
 					resolvedView: input.input.runtime.resolvedView,
@@ -64741,7 +64778,8 @@ function buildTerminalStep(input) {
 					...input.humanProfileId ? { atsProfileId: input.humanProfileId } : {},
 					forcePrompt: true,
 					view: input.input.view
-				})).status !== "aligned") throw new Error("ATS Service is not connected yet.");
+				});
+				if (gate.status !== "aligned") throw new Error(gate.errorMessage ?? "ATS Service is not connected yet.");
 				emitHumanStatus(input.input, "Current step", ["Connecting this computer to ATS.", "Saving this computer's ATS Service identity so ATS Web can use it."]);
 				const runtimeIdentity = await syncLocalSetupCurrentDeviceTargetFromServiceContract({ gatewayUrl: input.input.gatewayUrl });
 				emitHumanStatus(input.input, "Current step", ["Checking local setup state.", "Reading installed local agents and ATS Service compatibility."]);
@@ -67842,31 +67880,6 @@ async function emitSetupLocalAgentConnectionReadinessResult(input) {
 		reasonCodes: assessment.reasonCodes,
 		runtimeReportSubmission
 	});
-	const basePayload = {
-		profile: {
-			profileId: input.profile.atsProfileId,
-			profileName: input.profile.profileName,
-			profileKind: input.profile.profileKind
-		},
-		localAgentReadiness,
-		atsService: {
-			serviceReadiness: serviceReadiness.serviceReadiness,
-			serviceReadinessState: serviceReadiness.serviceReadinessState,
-			summaryText: serviceReadiness.summaryText,
-			detailText: serviceReadiness.detailText,
-			nextSteps: serviceReadiness.nextSteps,
-			runtimeHeadline: serviceReadiness.runtimeHeadline
-		},
-		diagnostics: buildLocalReplyReadinessEvidenceDiagnostics({
-			deviceReplyReadiness: snapshot.deviceReplyReadiness,
-			legacyAgentReplyReadiness: snapshot.agentReplyReadiness
-		}),
-		runtimeReportSubmission,
-		agentProfileBindingEnsure,
-		formalAgentConnection,
-		agentConnectionReadiness,
-		guidance
-	};
 	if (input.view === "human") {
 		renderInfoCard({
 			presenter: input.presenter,
@@ -67910,19 +67923,23 @@ async function emitSetupLocalAgentConnectionReadinessResult(input) {
 		});
 		return completionFacts;
 	}
-	const prepareReadiness = await resolvePrepareReadinessApiEvidence({ profile: input.profile });
-	const payload = {
-		...basePayload,
-		prepareReadiness
-	};
+	const payload = buildSetupLocalAgentConnectionAgentPayload({
+		agentConnectionReadiness,
+		agentProfileBindingEnsure,
+		formalAgentConnection,
+		guidance,
+		localAgentReadiness,
+		profile: input.profile,
+		runtimeReportSubmission,
+		serviceReadiness
+	});
 	input.presenter.data({
 		code: "setup.local_agent_connection.result",
 		payload
 	});
 	input.presenter.line({
 		code: "setup.local_agent_connection.summary",
-		text: `profile ${input.profile.atsProfileId}: agent_connection=${agentConnectionReadiness.status}, can_reply_from_this_computer=${agentConnectionReadiness.canReplyFromThisComputer ? "true" : "false"}, local_agent_readiness_evidence=${localAgentReadiness.status}, ats_service=${serviceReadiness.serviceReadiness}, next_action=${agentConnectionReadiness.nextAction ?? "none"}`,
-		data: payload
+		text: `profile ${input.profile.atsProfileId}: agent_connection=${agentConnectionReadiness.status}, can_reply_from_this_computer=${agentConnectionReadiness.canReplyFromThisComputer ? "true" : "false"}, local_agent_readiness_evidence=${localAgentReadiness.status}, ats_service=${serviceReadiness.serviceReadiness}, next_action=${agentConnectionReadiness.nextAction ?? "none"}`
 	});
 	return completionFacts;
 }
@@ -68015,6 +68032,54 @@ function resolveLocalAgentReadinessSummary(state) {
 		};
 	}
 }
+function buildSetupLocalAgentConnectionAgentPayload(input) {
+	const reportDetail = input.runtimeReportSubmission;
+	const capability = parseCapabilityRef(input.runtimeReportSubmission.capabilityRef);
+	return {
+		profile: {
+			profileId: input.profile.atsProfileId,
+			profileName: input.profile.profileName,
+			profileKind: input.profile.profileKind
+		},
+		localAgent: capability ? {
+			agentId: capability.id,
+			capabilityRef: capability.ref
+		} : null,
+		connection: {
+			status: input.agentConnectionReadiness.status,
+			canBeWokenInSpaces: input.agentConnectionReadiness.canBeWokenInSpaces,
+			canReplyFromThisComputer: input.agentConnectionReadiness.canReplyFromThisComputer,
+			summary: input.agentConnectionReadiness.summary,
+			nextAction: input.agentConnectionReadiness.nextAction,
+			reasonCodes: [...input.agentConnectionReadiness.reasonCodes]
+		},
+		localAgentReadiness: {
+			status: input.localAgentReadiness.status,
+			label: input.localAgentReadiness.label
+		},
+		atsService: {
+			status: input.serviceReadiness.serviceReadiness,
+			label: formatServiceParticipationReadinessLabel(input.serviceReadiness),
+			nextSteps: input.serviceReadiness.nextSteps
+		},
+		serverConnectionReport: {
+			status: input.runtimeReportSubmission.status,
+			runtimeId: reportDetail.runtimeId ?? null,
+			reason: reportDetail.reason ?? null
+		},
+		binding: {
+			status: input.agentProfileBindingEnsure.status,
+			label: input.formalAgentConnection.label,
+			routable: input.agentProfileBindingEnsure.routable,
+			reasonCodes: [...input.formalAgentConnection.reasonCodes]
+		},
+		guidance: {
+			summary: input.guidance.summary,
+			nextSteps: input.guidance.nextSteps
+		},
+		detailsCommand: formatAtsCliCommand(`ats service status --profile ${input.profile.atsProfileId} --view agent`)
+	};
+}
 function resolveFormalAgentConnectionProjection(result) {
 	if (result.status === "accepted" && result.routable) return {
 		label: "Connected to this computer.",
@@ -68136,12 +68201,6 @@ function isLocalServiceConnectionUnavailableReason(reasonCode) {
 function isConnectionVerificationPendingReason(reasonCode) {
 	return reasonCode === "agent_profile_binding.execution_readiness_pending";
 }
-function buildLocalReplyReadinessEvidenceDiagnostics(input) {
-	return buildLocalServiceDiagnosticsPayload({
-		deviceEvidence: input.deviceReplyReadiness,
-		agentEvidence: input.legacyAgentReplyReadiness
-	});
-}
 function formatRuntimeReportSubmission(submission) {
 	switch (submission.status) {
 		case "submitted": return "Submitted.";
@@ -68481,9 +68540,44 @@ function emitSetupComplete(input) {
 	}
 	input.presenter.data({
 		code: "setup.complete",
-		payload
+		payload: buildSetupCompleteAgentPayload(payload)
 	});
 }
+function buildSetupCompleteAgentPayload(input) {
+	return {
+		lane: input.lane,
+		cliCommandPrefix: input.cliCommandPrefix,
+		laneRoot: input.laneRoot,
+		gatewayUrl: input.gatewayUrl,
+		authBaseUrl: input.authBaseUrl,
+		path: input.path,
+		service: input.service,
+		localAgents: input.localAgents,
+		localComponents: {
+			entrypoint: input.localComponents.entrypoint,
+			summaryLabel: input.localComponents.summaryLabel,
+			setupAction: input.localComponents.setupAction,
+			setupActionLabel: input.localComponents.setupActionLabel,
+			cli: {
+				status: input.localComponents.cli.status,
+				packageVersion: input.localComponents.cli.packageVersion,
+				latestPackageVersion: input.localComponents.cli.latestPackageVersion ?? null
+			},
+			service: {
+				status: input.localComponents.service.status,
+				installedBundleVersion: input.localComponents.service.installedBundleVersion ?? null,
+				expectedBundleVersion: input.localComponents.service.expectedBundleVersion ?? null
+			},
+			skills: {
+				status: input.localComponents.skills.status,
+				targetCount: input.localComponents.skills.targetCount
+			}
+		},
+		routeCatalogSync: input.routeCatalogSync,
+		nextCommands: input.nextCommands,
+		note: input.note
+	};
+}
 async function ensureSetupManagedSkills(input) {
 	const result = await runSkillsEnsure({
 		all: true,
@@ -76025,12 +76119,6 @@ function buildLocalServiceNotRequiredPreflight(input) {
 			},
 			actionRequirements: input.actionRequirements,
 			agentReplyReadiness: null,
-			services: { daemon: {
-				installed: false,
-				version: null,
-				runtimeStatus: "unknown",
-				runtimeReason: null
-			} },
 			env: {
 				baseUrl: input.baseUrl,
 				requestTimeoutMs: resolveSpaceRequestTimeoutMsForDiagnostics()
@@ -76127,7 +76215,7 @@ function shouldSurfaceServiceRepairGuidanceInPreflight(command) {
 }
 function buildAgentSpaceCommandPreflightText(input) {
 	if (input.payload.actionRequirements.localService === "not_required") return `preflight ${input.payload.command}: auth=${input.payload.auth.state}, profile=${input.payload.profile.profileId}, local_service=not_required`;
-	return `preflight ${input.payload.command}: auth=${input.payload.auth.state}, profile=${input.payload.profile.profileId}, daemon=${input.payload.services.daemon.runtimeStatus}, local_service_link=${input.serviceParticipationReadiness.serviceReadiness}, service_state=${input.serviceParticipationReadiness.serviceReadinessState}`;
+	return `preflight ${input.payload.command}: auth=${input.payload.auth.state}, profile=${input.payload.profile.profileId}, daemon=${input.payload.services?.daemon.runtimeStatus ?? "unknown"}, local_service_link=${input.serviceParticipationReadiness.serviceReadiness}, service_state=${input.serviceParticipationReadiness.serviceReadinessState}`;
 }
 function buildHumanSpaceCommandPreflightText(input) {
 	const actionRequirements = resolveSpacePreflightActionRequirements(input.command);
@@ -96816,6 +96904,33 @@ function emitSpaceStatusHumanOutput(input) {
 		minContentWidth: 56
 	});
 }
+function emitSpaceStatusAgentOutput(input) {
+	const spaceLabel = input.status.name?.trim() || input.status.spaceId;
+	input.presenter.line({
+		code: "space.status",
+		text: `space status: ${spaceLabel}, members=${input.status.members.totalCount}, agents=${input.status.members.agentCount}, wakeable=${input.status.members.wakeableAgentCount}, offline=${input.status.members.offlineAgentCount}`,
+		data: {
+			spaceId: input.status.spaceId,
+			spaceName: input.status.name ?? null,
+			members: {
+				totalCount: input.status.members.totalCount,
+				humanCount: input.status.members.humanCount,
+				agentCount: input.status.members.agentCount,
+				liveHumanCount: input.status.members.liveHumanCount,
+				liveAgentCount: input.status.members.liveAgentCount,
+				wakeableAgentCount: input.status.members.wakeableAgentCount,
+				offlineAgentCount: input.status.members.offlineAgentCount
+			},
+			latestVisibleUpdate: input.status.latestVisibleUpdate ? {
+				signalId: input.status.latestVisibleUpdate.signalId,
+				signalType: input.status.latestVisibleUpdate.signalType,
+				actorProfileId: input.status.latestVisibleUpdate.actorProfileId,
+				actorName: input.status.latestVisibleUpdate.actorName ?? null,
+				previewText: sanitizeTerminalDisplayText(input.status.latestVisibleUpdate.previewText, "single-line")
+			} : null
+		}
+	});
+}
 function buildSpaceStatusOverviewRows(status) {
 	return [
 		{
@@ -96954,6 +97069,13 @@ async function runSpaceStatus(input) {
 		outJsonLine(statusRead.result);
 		return;
 	}
+	if (runtime.resolvedView === "agent") {
+		emitSpaceStatusAgentOutput({
+			presenter,
+			status: statusRead.result
+		});
+		return;
+	}
 	emitSpaceStatusHumanOutput({
 		presenter,
 		status: statusRead.result