agent-transport-system 0.7.18 → 0.7.20

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.18";
+var version = "0.7.20";
 var package_default = {
 	$schema: "https://www.schemastore.org/package.json",
 	name: "agent-transport-system",
@@ -26205,6 +26205,28 @@ async function recoverLifecycleFailure(input) {
 	const originalErrorMessage = toErrorMessage$19(input.error);
 	const originalFailureStage = resolveLifecycleFailureStage(input.error, input.state.failureStage);
 	const originalReasonCodes = resolveLifecycleFailureReasonCodes(input.error);
+	const restartedCurrentVersion = await recoverBackgroundLifecycleVerificationFailure({
+		commandOptions: input.commandOptions,
+		error: input.error,
+		expectedVersion: input.expectedVersion,
+		failureStage: originalFailureStage,
+		operation: input.operation,
+		restorePoint: input.restorePoint,
+		serviceManager: input.serviceManager,
+		target: input.target
+	}).catch(() => null);
+	if (restartedCurrentVersion) return {
+		status: "aligned",
+		targetVersion: input.expectedVersion,
+		inventoryBefore: input.inventoryBefore,
+		inventoryAfter: restartedCurrentVersion,
+		reasonCodes: [],
+		completedPhases: input.state.completedPhases,
+		desiredState: input.restorePoint.desiredState,
+		shouldStartAfterLifecycle: input.restorePoint.shouldStartAfterLifecycle,
+		backupDataPath: null,
+		errorMessage: null
+	};
 	if (input.restorePoint.trusted) {
 		const restoredPrevious = await restoreVerifiedPreviousState({
 			restorePoint: input.restorePoint,
@@ -26334,6 +26356,47 @@ async function transitionLifecycleToStoppedSafeCurrentVersion(input) {
 		target: buildDaemonServiceTargetSpec({ daemonVersion: input.expectedVersion })
 	});
 }
+async function recoverBackgroundLifecycleVerificationFailure(input) {
+	if (!shouldRecoverBackgroundLifecycleVerificationFailure({
+		failureInventory: readLifecycleFailureInventory(input.error),
+		failureStage: input.failureStage,
+		restorePoint: input.restorePoint
+	})) return null;
+	await input.serviceManager.stop();
+	await input.serviceManager.waitUntilStopped();
+	await ensureNoOwnedProcessesRemain();
+	await startLifecycleServiceWithRetry({
+		serviceCommandSpec: buildDaemonSystemServiceCommandSpec({
+			controller: input.serviceManager.controller,
+			environmentTarget: input.commandOptions.environmentTarget
+		}),
+		serviceManager: input.serviceManager
+	});
+	await input.serviceManager.waitUntilRunning();
+	return await waitForVerifiedLifecycleInventory({
+		desiredState: "background",
+		expectedVersion: input.expectedVersion,
+		operation: input.operation,
+		shouldStartAfterLifecycle: true,
+		target: input.target
+	});
+}
+function shouldRecoverBackgroundLifecycleVerificationFailure(input) {
+	if (input.failureStage !== "verify_final_inventory" || input.restorePoint.desiredState !== "background" || input.restorePoint.shouldStartAfterLifecycle !== true || !input.failureInventory) return false;
+	const anomalyCodes = input.failureInventory.anomalies.map((anomaly) => anomaly.code);
+	if (anomalyCodes.length === 0) return false;
+	const recoverableCodes = new Set(["manager_running_without_runtime", "runtime_stale"]);
+	return anomalyCodes.every((code) => recoverableCodes.has(code));
+}
+function readLifecycleFailureInventory(error) {
+	if (!(error instanceof DaemonServiceLifecycleStageError)) return null;
+	return isDaemonServiceInventory(error.cause) ? error.cause : null;
+}
+function isDaemonServiceInventory(value) {
+	if (!(value && typeof value === "object")) return false;
+	const candidate = value;
+	return Array.isArray(candidate.anomalies) && !!candidate.runtimeStatus;
+}
 function createLifecycleRestorePoint(input) {
 	return {
 		desiredState: input.desiredState,
@@ -26618,6 +26681,7 @@ async function waitForVerifiedLifecycleInventory(input) {
 			shouldStartAfterLifecycle: input.shouldStartAfterLifecycle
 		})) throw new DaemonServiceLifecycleStageError({
 			message: verificationError,
+			reasonCodes: readDaemonServiceInventoryAnomalyCodes(inventory),
 			stage: "verify_final_inventory",
 			cause: inventory
 		});
@@ -26627,10 +26691,14 @@ async function waitForVerifiedLifecycleInventory(input) {
 	}
 	throw new DaemonServiceLifecycleStageError({
 		message: lastError ?? "ATS could not verify the final local service inventory state.",
+		reasonCodes: lastInventory ? readDaemonServiceInventoryAnomalyCodes(lastInventory) : [],
 		stage: "verify_final_inventory",
 		cause: lastInventory
 	});
 }
+function readDaemonServiceInventoryAnomalyCodes(inventory) {
+	return inventory.anomalies.map((anomaly) => anomaly.code);
+}
 async function startLifecycleServiceWithRetry(input) {
 	try {
 		await input.serviceManager.start();
@@ -39584,6 +39652,7 @@ function normalizeOptionalText$12(value) {
 //#region src/daemon/dispatch/execute-dispatch-task.ts
 const BOOTSTRAP_IDLE_STALE_MS = 1440 * 60 * 1e3;
 const BOOTSTRAP_DISPATCH_STALE_THRESHOLD = 12;
+const CLI_SPACE_ACTION_RECORD_POLL_INTERVAL_MS = 25;
 const DEFAULT_CONVERSATION_POLICY = {};
 const STRUCTURED_SPACE_ACTION_BLOCK_HEADER_REGEX = /^\s*\r?\n?/u;
 function mergeOpenClawGatewayVisibility(input) {
@@ -40275,7 +40344,7 @@ async function handleDispatchDeliverFrame(input) {
 			phase: "runtime_invocation_started",
 			result: "started"
 		});
-		let runtimeResult = await runDispatchRuntimeExecution({
+		const runtimeExecutionPromise = Promise.resolve(runDispatchRuntimeExecution({
 			contextId: contextIdForDispatch,
 			executionMode: "normal",
 			io: ledgerIo,
@@ -40356,12 +40425,15 @@ async function handleDispatchDeliverFrame(input) {
 			runtimeEnvOverrides,
 			runtimeControllerSupport,
 			agentControllerConversationOverride
-		});
-		runtimeResult = applyCliSpaceActionRecordIfPresent({
+		}));
+		let runtimeResult = await resolveRuntimeResultFromRuntimeOrCliSpaceAction({
+			contextIdForDispatch,
 			dispatchSpaceActionContext,
+			ledgerIo,
+			ledgerPaths: input.ledgerPaths,
 			parsedTask,
 			presenter: input.presenter,
-			runtimeResult
+			runtimeExecutionPromise
 		});
 		const structuredSpaceActionOutcome = await resolveRuntimeResultStructuredSpaceAction({
 			ledgerIo,
@@ -40874,6 +40946,146 @@ function createDispatchSpaceActionRuntimeContext(input) {
 		}
 	};
 }
+async function resolveRuntimeResultFromRuntimeOrCliSpaceAction(input) {
+	if (!input.dispatchSpaceActionContext) return await input.runtimeExecutionPromise;
+	const cliSpaceActionAbortController = new AbortController();
+	let completion;
+	try {
+		completion = await Promise.race([input.runtimeExecutionPromise.then((runtimeResult) => ({
+			kind: "runtime",
+			runtimeResult
+		})), waitForCliSpaceActionRecord({
+			dispatchSpaceActionContext: input.dispatchSpaceActionContext,
+			signal: cliSpaceActionAbortController.signal
+		})]);
+	} finally {
+		cliSpaceActionAbortController.abort();
+	}
+	if (completion.kind === "runtime") return applyCliSpaceActionRecordIfPresent({
+		dispatchSpaceActionContext: input.dispatchSpaceActionContext,
+		parsedTask: input.parsedTask,
+		presenter: input.presenter,
+		runtimeResult: completion.runtimeResult
+	});
+	if (completion.kind === "cli_space_action_poll_aborted") return await input.runtimeExecutionPromise;
+	input.runtimeExecutionPromise.catch((error) => {
+		emitRunLine({
+			presenter: input.presenter,
+			code: "daemon.run.runtime_ignored_after_cli_space_action",
+			text: `runtime completed after CLI ATS Space Action finalized task ${input.parsedTask.taskId}`,
+			payload: {
+				dispatchId: input.parsedTask.dispatchId,
+				errorMessage: toErrorMessage$34(error),
+				targetProfileId: input.parsedTask.targetProfileId,
+				taskId: input.parsedTask.taskId
+			}
+		});
+	});
+	if (completion.kind === "cli_space_action_invalid") throw new DaemonServiceRunError({
+		code: "dispatch.cli_space_action.invalid",
+		message: completion.errorMessage
+	});
+	emitRunLine({
+		presenter: input.presenter,
+		code: "daemon.run.cli_space_action_finalized",
+		text: `CLI ATS Space Action finalized task ${input.parsedTask.taskId}`,
+		payload: {
+			command: completion.record.command,
+			dispatchId: input.parsedTask.dispatchId,
+			spaceActionType: completion.record.action.type,
+			targetProfileId: input.parsedTask.targetProfileId,
+			taskId: input.parsedTask.taskId
+		}
+	});
+	return await buildCliSpaceActionRuntimeResult({
+		contextIdForDispatch: input.contextIdForDispatch,
+		ledgerIo: input.ledgerIo,
+		ledgerPaths: input.ledgerPaths,
+		parsedTask: input.parsedTask,
+		record: completion.record
+	});
+}
+async function waitForCliSpaceActionRecord(input) {
+	while (!input.signal.aborted) {
+		const readResult = readDispatchSpaceActionRecord({ context: input.dispatchSpaceActionContext });
+		if (readResult.status === "loaded") return {
+			kind: "cli_space_action_recorded",
+			record: readResult.record
+		};
+		if (readResult.status === "invalid") return {
+			kind: "cli_space_action_invalid",
+			errorMessage: readResult.errorMessage
+		};
+		try {
+			await setTimeout$1(CLI_SPACE_ACTION_RECORD_POLL_INTERVAL_MS, void 0, { signal: input.signal });
+		} catch (error) {
+			if (input.signal.aborted) return { kind: "cli_space_action_poll_aborted" };
+			throw error;
+		}
+	}
+	return { kind: "cli_space_action_poll_aborted" };
+}
+async function buildCliSpaceActionRuntimeResult(input) {
+	const output = resolveStructuredActionOutputFallback({
+		action: input.record.action,
+		cleanedOutput: ""
+	});
+	const resultPayload = {
+		...buildTaskResultPayloadFromOutcome({
+			agentId: input.parsedTask.targetProfileId,
+			attemptId: input.parsedTask.attemptId,
+			deduped: false,
+			emitFailed: false,
+			output,
+			sourceEventId: input.parsedTask.sourceEventId,
+			taskId: input.parsedTask.taskId
+		}),
+		spaceAction: input.record.action,
+		spaceActionProvenance: "cli_action"
+	};
+	const state = await withLedgerStateTransaction({
+		invalidStateStrategy: "backup_and_reset",
+		io: input.ledgerIo,
+		mutate: (state) => {
+			const nextState = settleInflightTask({
+				state,
+				taskId: input.parsedTask.taskId
+			});
+			return {
+				nextState,
+				value: nextState
+			};
+		},
+		paths: input.ledgerPaths
+	});
+	await appendLedgerHistoryEntry({
+		entry: {
+			message: "task finalized from CLI Space Action",
+			reasonCode: "task.cli_space_action",
+			status: resultPayload.status,
+			taskId: input.parsedTask.taskId,
+			ts: (/* @__PURE__ */ new Date()).toISOString()
+		},
+		io: input.ledgerIo,
+		paths: input.ledgerPaths
+	});
+	return {
+		agentContextLifecycleCounters: state.agentContextLifecycleCounters,
+		deduped: false,
+		dispatchResult: {
+			adapterResult: {
+				...input.contextIdForDispatch ? { contextDelta: { agentControllerConversationId: input.contextIdForDispatch } } : {},
+				output,
+				status: "success"
+			},
+			dispatched: true,
+			reason: "dispatched"
+		},
+		resultPayload,
+		runtimeState: "idle",
+		state
+	};
+}
 function applyCliSpaceActionRecordIfPresent(input) {
 	if (!input.dispatchSpaceActionContext) return input.runtimeResult;
 	const readResult = readDispatchSpaceActionRecord({ context: input.dispatchSpaceActionContext });