agent-transport-system 0.7.18 → 0.7.19

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.19";
 var package_default = {
 	$schema: "https://www.schemastore.org/package.json",
 	name: "agent-transport-system",
@@ -39584,6 +39584,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 +40276,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 +40357,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 +40878,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 });