acpx 0.15.1 → 0.17.0

package/dist/{flows-BOI1XkMp.js → flows-CTOdIk-m.js}

@@ -1,12 +1,15 @@
-import { d as createSessionWithClient, f as cancelSessionPrompt, o as runOnce, s as sendSessionDirect, t as createOutputFormatter } from "./output-8-D6Gd4Z.js";
-import { Dt as TimeoutError, Et as InterruptedError, F as runTimedExecFile, Ot as withInterrupt, Tt as textPrompt, Y as resolveSessionRecord, Yt as PERMISSION_MODES, Zt as SESSION_RECORD_SCHEMA, _ as recordPromptSubmission, dt as defaultSessionEventLog, g as recordClientOperation, h as createSessionConversation, kt as withTimeout, p as cloneSessionAcpxState, v as recordSessionUpdate, wt as promptToDisplayText } from "./live-checkpoint-sB7dFOYR.js";
+import { t as createOutputFormatter } from "./output-BPPjvJTI.js";
+import { C as textPrompt, Dt as SESSION_RECORD_SCHEMA, F as resolveSessionRecord, S as promptToDisplayText, Tt as PERMISSION_MODES, ct as defaultSessionEventLog, mt as writePrivateJsonFile, pt as writePrivateFile } from "./ipc-D3akHMEq.js";
+import { B as recordClientOperation, H as recordSessionUpdate, L as cloneSessionAcpxState, V as recordPromptSubmission, _ as cancelSessionPrompt, at as withInterrupt, i as runOnce, m as createSessionWithClient, nt as InterruptedError, o as sendSessionDirect, ot as withTimeout, rt as TimeoutError, z as createSessionConversation } from "./queue-owner-runtime--IbbndGz.js";
+import { M as runTimedExecFile } from "./agent-registry-DU6mhZBL.js";
 import path from "node:path";
+import { spawn } from "node:child_process";
 import fs from "node:fs/promises";
 import os from "node:os";
-import { createHash, randomUUID } from "node:crypto";
-import { ZodError, z } from "zod";
-import { spawn } from "node:child_process";
+import { appendRegularFile } from "@openclaw/fs-safe/advanced";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { ZodError, z } from "zod";
+import { createHash, randomUUID } from "node:crypto";
 //#region src/flows/authoring.ts
 const FLOW_DEFINITION_BRAND = Symbol.for("acpx.flow.definition");
 function markDefinedFlow(definition) {
@@ -592,9 +595,12 @@ function validateFlowEdge(flow, edge, outgoingEdges) {
 	}
 	for (const target of Object.values(edge.switch.cases)) assertKnownFlowNode(flow, target, "Flow switch references unknown to-node");
 }
+function canFollowEdge(edge, result) {
+	return !result || result.outcome === "ok" || "switch" in edge && edge.switch.on.startsWith("$result.");
+}
 function resolveNext(edges, from, output, result) {
 	const edge = edges.find((candidate) => candidate.from === from);
-	if (!edge) return null;
+	if (!edge || !canFollowEdge(edge, result)) return null;
 	if ("to" in edge) return edge.to;
 	const value = getBySwitchPath(output, result, edge.switch.on);
 	if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") throw new Error(`Flow switch value must be scalar for ${edge.switch.on}`);
@@ -602,16 +608,6 @@ function resolveNext(edges, from, output, result) {
 	if (!next) throw new Error(`No flow switch case for ${edge.switch.on}=${JSON.stringify(value)}`);
 	return next;
 }
-function resolveNextForOutcome(edges, from, result) {
-	const edge = edges.find((candidate) => candidate.from === from);
-	if (!edge || "to" in edge) return null;
-	if (!edge.switch.on.startsWith("$result.")) return null;
-	const value = getBySwitchPath(void 0, result, edge.switch.on);
-	if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") throw new Error(`Flow switch value must be scalar for ${edge.switch.on}`);
-	const next = edge.switch.cases[String(value)];
-	if (!next) throw new Error(`No flow switch case for ${edge.switch.on}=${JSON.stringify(value)}`);
-	return next;
-}
 function getBySwitchPath(output, result, jsonPath) {
 	if (jsonPath.startsWith("$result.")) return getByPath(result, `$.${jsonPath.slice(8)}`);
 	if (jsonPath.startsWith("$output.")) return getByPath(output, `$.${jsonPath.slice(8)}`);
@@ -919,41 +915,30 @@ var FlowRunStore = class {
 	}
 	async createRunDir(runId) {
 		const runDir = path.join(this.outputRoot, runId);
-		await fs.mkdir(path.join(runDir, PROJECTIONS_DIR), { recursive: true });
-		await fs.mkdir(path.join(runDir, SESSIONS_DIR), { recursive: true });
-		await fs.mkdir(path.join(runDir, ARTIFACTS_DIR), { recursive: true });
+		await fs.mkdir(path.join(runDir, PROJECTIONS_DIR), {
+			recursive: true,
+			mode: 448
+		});
+		await fs.mkdir(path.join(runDir, SESSIONS_DIR), {
+			recursive: true,
+			mode: 448
+		});
+		await fs.mkdir(path.join(runDir, ARTIFACTS_DIR), {
+			recursive: true,
+			mode: 448
+		});
 		this.traceSeqByRun.set(runDir, 0);
 		return runDir;
 	}
 	async initializeRunBundle(runDir, options) {
 		const snapshot = createFlowDefinitionSnapshot(options.flow);
-		const manifest = {
-			schema: FLOW_BUNDLE_SCHEMA,
-			runId: options.state.runId,
-			flowName: options.state.flowName,
-			runTitle: options.state.runTitle,
-			flowPath: options.state.flowPath,
-			startedAt: options.state.startedAt,
-			finishedAt: options.state.finishedAt,
-			status: options.state.status,
-			traceSchema: FLOW_TRACE_SCHEMA,
-			paths: {
-				flow: FLOW_SNAPSHOT_PATH,
-				trace: TRACE_PATH,
-				runProjection: RUN_PROJECTION_PATH,
-				liveProjection: LIVE_PROJECTION_PATH,
-				stepsProjection: STEPS_PROJECTION_PATH,
-				sessionsDir: SESSIONS_DIR,
-				artifactsDir: ARTIFACTS_DIR
-			},
-			sessions: []
-		};
+		const manifest = createRunManifest(options.state);
 		this.manifestByRun.set(runDir, manifest);
-		await writeJsonAtomic(this.resolveRunPath(runDir, FLOW_SNAPSHOT_PATH), snapshot);
-		await writeJsonAtomic(this.resolveRunPath(runDir, MANIFEST_PATH), manifest);
-		await writeJsonAtomic(this.resolveRunPath(runDir, RUN_PROJECTION_PATH), options.state);
-		await writeJsonAtomic(this.resolveRunPath(runDir, LIVE_PROJECTION_PATH), createLiveState(options.state));
-		await writeJsonAtomic(this.resolveRunPath(runDir, STEPS_PROJECTION_PATH), options.state.steps);
+		await writePrivateJsonFile(this.resolveRunPath(runDir, FLOW_SNAPSHOT_PATH), snapshot);
+		await writePrivateJsonFile(this.resolveRunPath(runDir, MANIFEST_PATH), manifest);
+		await writePrivateJsonFile(this.resolveRunPath(runDir, RUN_PROJECTION_PATH), options.state);
+		await writePrivateJsonFile(this.resolveRunPath(runDir, LIVE_PROJECTION_PATH), createLiveState(options.state));
+		await writePrivateJsonFile(this.resolveRunPath(runDir, STEPS_PROJECTION_PATH), options.state.steps);
 		await ensureFile(this.resolveRunPath(runDir, TRACE_PATH));
 		await this.appendTrace(runDir, options.state, {
 			scope: "run",
@@ -968,15 +953,15 @@ var FlowRunStore = class {
 	}
 	async writeSnapshot(runDir, state, event) {
 		state.updatedAt = isoNow();
-		await writeJsonAtomic(this.resolveRunPath(runDir, RUN_PROJECTION_PATH), state);
-		await writeJsonAtomic(this.resolveRunPath(runDir, LIVE_PROJECTION_PATH), createLiveState(state));
-		await writeJsonAtomic(this.resolveRunPath(runDir, STEPS_PROJECTION_PATH), state.steps);
+		await writePrivateJsonFile(this.resolveRunPath(runDir, RUN_PROJECTION_PATH), state);
+		await writePrivateJsonFile(this.resolveRunPath(runDir, LIVE_PROJECTION_PATH), createLiveState(state));
+		await writePrivateJsonFile(this.resolveRunPath(runDir, STEPS_PROJECTION_PATH), state.steps);
 		await this.writeManifest(runDir, state);
 		await this.appendTrace(runDir, state, event);
 	}
 	async writeLive(runDir, state, event) {
 		state.updatedAt = isoNow();
-		await writeJsonAtomic(this.resolveRunPath(runDir, LIVE_PROJECTION_PATH), createLiveState(state));
+		await writePrivateJsonFile(this.resolveRunPath(runDir, LIVE_PROJECTION_PATH), createLiveState(state));
 		await this.writeManifest(runDir, state);
 		await this.appendTrace(runDir, state, event);
 	}
@@ -995,11 +980,10 @@ var FlowRunStore = class {
 		const sha256 = createHash("sha256").update(buffer).digest("hex");
 		const relativePath = path.posix.join(ARTIFACTS_DIR, `sha256-${sha256}${normalizeArtifactExtension(options.extension)}`);
 		const filePath = this.resolveRunPath(runDir, relativePath);
-		await fs.mkdir(path.dirname(filePath), { recursive: true });
 		try {
 			await fs.access(filePath);
 		} catch {
-			await fs.writeFile(filePath, buffer);
+			await writePrivateFile(filePath, buffer);
 		}
 		const artifact = {
 			path: relativePath,
@@ -1020,8 +1004,11 @@ var FlowRunStore = class {
 	}
 	async ensureSessionBundle(runDir, state, binding, record) {
 		const sessionDir = this.resolveRunPath(runDir, sessionDirPath(binding.bundleId));
-		await fs.mkdir(sessionDir, { recursive: true });
-		await writeJsonAtomic(path.join(sessionDir, "binding.json"), binding);
+		await fs.mkdir(sessionDir, {
+			recursive: true,
+			mode: 448
+		});
+		await writePrivateJsonFile(path.join(sessionDir, "binding.json"), binding);
 		await ensureFile(path.join(sessionDir, "events.ndjson"));
 		if (record) await this.writeSessionRecord(runDir, state, binding, record);
 		const manifest = this.getManifest(runDir, state);
@@ -1035,7 +1022,7 @@ var FlowRunStore = class {
 				eventsPath: path.posix.join(sessionDirPath(binding.bundleId), "events.ndjson")
 			};
 			manifest.sessions.push(entry);
-			await writeJsonAtomic(this.resolveRunPath(runDir, MANIFEST_PATH), manifest);
+			await writePrivateJsonFile(this.resolveRunPath(runDir, MANIFEST_PATH), manifest);
 		}
 		if (isNew) await this.appendTrace(runDir, state, {
 			scope: "session",
@@ -1054,7 +1041,7 @@ var FlowRunStore = class {
 	}
 	async writeSessionRecord(runDir, _state, binding, record) {
 		const bundledRecord = createBundledSessionRecord(binding, record, this.sessionSeqByBundle.get(`${runDir}::${binding.bundleId}`) ?? 0);
-		await writeJsonAtomic(this.resolveRunPath(runDir, path.posix.join(sessionDirPath(binding.bundleId), "record.json")), bundledRecord);
+		await writePrivateJsonFile(this.resolveRunPath(runDir, path.posix.join(sessionDirPath(binding.bundleId), "record.json")), bundledRecord);
 	}
 	async appendSessionEvent(runDir, binding, direction, message) {
 		const sessionKey = `${runDir}::${binding.bundleId}`;
@@ -1079,33 +1066,13 @@ var FlowRunStore = class {
 			existing.runTitle = state.runTitle;
 			return existing;
 		}
-		const created = {
-			schema: FLOW_BUNDLE_SCHEMA,
-			runId: state.runId,
-			flowName: state.flowName,
-			runTitle: state.runTitle,
-			flowPath: state.flowPath,
-			startedAt: state.startedAt,
-			finishedAt: state.finishedAt,
-			status: state.status,
-			traceSchema: FLOW_TRACE_SCHEMA,
-			paths: {
-				flow: FLOW_SNAPSHOT_PATH,
-				trace: TRACE_PATH,
-				runProjection: RUN_PROJECTION_PATH,
-				liveProjection: LIVE_PROJECTION_PATH,
-				stepsProjection: STEPS_PROJECTION_PATH,
-				sessionsDir: SESSIONS_DIR,
-				artifactsDir: ARTIFACTS_DIR
-			},
-			sessions: []
-		};
+		const created = createRunManifest(state);
 		this.manifestByRun.set(runDir, created);
 		return created;
 	}
 	async writeManifest(runDir, state) {
 		const manifest = this.getManifest(runDir, state);
-		await writeJsonAtomic(this.resolveRunPath(runDir, MANIFEST_PATH), manifest);
+		await writePrivateJsonFile(this.resolveRunPath(runDir, MANIFEST_PATH), manifest);
 	}
 	nextTraceSeq(runDir) {
 		const next = (this.traceSeqByRun.get(runDir) ?? 0) + 1;
@@ -1117,8 +1084,15 @@ var FlowRunStore = class {
 	}
 	async appendJsonLine(filePath, value) {
 		const tracked = (this.appendChainByPath.get(filePath) ?? Promise.resolve()).then(async () => {
-			await fs.mkdir(path.dirname(filePath), { recursive: true });
-			await fs.appendFile(filePath, `${JSON.stringify(value)}\n`, "utf8");
+			await fs.mkdir(path.dirname(filePath), {
+				recursive: true,
+				mode: 448
+			});
+			await appendRegularFile({
+				filePath,
+				content: `${JSON.stringify(value)}\n`,
+				mode: 384
+			});
 		}).finally(() => {
 			if (this.appendChainByPath.get(filePath) === tracked) this.appendChainByPath.delete(filePath);
 		});
@@ -1126,6 +1100,29 @@ var FlowRunStore = class {
 		await tracked;
 	}
 };
+function createRunManifest(state) {
+	return {
+		schema: FLOW_BUNDLE_SCHEMA,
+		runId: state.runId,
+		flowName: state.flowName,
+		runTitle: state.runTitle,
+		flowPath: state.flowPath,
+		startedAt: state.startedAt,
+		finishedAt: state.finishedAt,
+		status: state.status,
+		traceSchema: FLOW_TRACE_SCHEMA,
+		paths: {
+			flow: FLOW_SNAPSHOT_PATH,
+			trace: TRACE_PATH,
+			runProjection: RUN_PROJECTION_PATH,
+			liveProjection: LIVE_PROJECTION_PATH,
+			stepsProjection: STEPS_PROJECTION_PATH,
+			sessionsDir: SESSIONS_DIR,
+			artifactsDir: ARTIFACTS_DIR
+		},
+		sessions: []
+	};
+}
 function createLiveState(state) {
 	return {
 		runId: state.runId,
@@ -1225,16 +1222,12 @@ function createBundledSessionRecord(binding, record, bundleLastSeq) {
 		}
 	};
 }
-async function writeJsonAtomic(filePath, value) {
-	const tempPath = `${filePath}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
-	const payload = JSON.stringify(value, null, 2);
-	await fs.mkdir(path.dirname(filePath), { recursive: true });
-	await fs.writeFile(tempPath, `${payload}\n`, "utf8");
-	await fs.rename(tempPath, filePath);
-}
 async function ensureFile(filePath) {
-	await fs.mkdir(path.dirname(filePath), { recursive: true });
-	await fs.appendFile(filePath, "", "utf8");
+	await appendRegularFile({
+		filePath,
+		content: "",
+		mode: 384
+	});
 }
 async function fileSha256(filePath) {
 	const payload = await fs.readFile(filePath);
@@ -1264,16 +1257,8 @@ const DEFAULT_FLOW_STEP_TIMEOUT_MS = 9e5;
 var FlowRunner = class {
 	resolveAgent;
 	defaultCwd;
-	permissionMode;
-	mcpServers;
-	nonInteractivePermissions;
-	permissionPolicy;
-	authCredentials;
-	authPolicy;
-	fs;
-	timeoutMs;
+	connectionOptions;
 	defaultNodeTimeoutMs;
-	verbose;
 	suppressSdkConsoleErrors;
 	sessionOptions;
 	services;
@@ -1285,16 +1270,17 @@ var FlowRunner = class {
 	constructor(options) {
 		this.resolveAgent = options.resolveAgent;
 		this.defaultCwd = options.resolveAgent(void 0).cwd;
-		this.permissionMode = options.permissionMode;
-		this.mcpServers = options.mcpServers;
-		this.nonInteractivePermissions = options.nonInteractivePermissions;
-		this.permissionPolicy = options.permissionPolicy;
-		this.authCredentials = options.authCredentials;
-		this.authPolicy = options.authPolicy;
-		this.fs = options.fs;
-		this.timeoutMs = options.timeoutMs;
+		this.connectionOptions = {
+			permissionMode: options.permissionMode,
+			mcpServers: options.mcpServers,
+			nonInteractivePermissions: options.nonInteractivePermissions,
+			permissionPolicy: options.permissionPolicy,
+			authCredentials: options.authCredentials,
+			authPolicy: options.authPolicy,
+			fs: options.fs,
+			verbose: options.verbose
+		};
 		this.defaultNodeTimeoutMs = options.defaultNodeTimeoutMs ?? options.timeoutMs ?? DEFAULT_FLOW_STEP_TIMEOUT_MS;
-		this.verbose = options.verbose;
 		this.suppressSdkConsoleErrors = options.suppressSdkConsoleErrors;
 		this.sessionOptions = options.sessionOptions;
 		this.services = options.services ?? {};
@@ -1432,16 +1418,47 @@ var FlowRunner = class {
 		const startedAt = isoNow$1();
 		markNodeStarted(state, nodeId, attemptId, node.nodeType, startedAt, node.statusDetail);
 		await this.writeNodeStartedSnapshot(runDir, state, nodeId, attemptId, node);
-		return await this.executeStartedFlowStep({
-			flow,
-			input,
-			runDir,
-			state,
-			nodeId,
-			node,
+		const context = makeFlowNodeContext(state, input, this.services);
+		let executed;
+		let outcome = "ok";
+		let executionError;
+		try {
+			this.throwIfRunInterrupted(runDir);
+			executed = await this.executeNode(runDir, state, flow, nodeId, node, context);
+			this.throwIfRunInterrupted(runDir);
+			executed.trace = await finalizeStepTrace(this.store, runDir, state, nodeId, attemptId, executed.output, executed.trace);
+		} catch (error) {
+			outcome = outcomeForError(error);
+			executionError = error;
+			executed = {
+				output: void 0,
+				promptText: null,
+				rawText: null,
+				sessionInfo: null,
+				agentInfo: null,
+				trace: await finalizeStepTrace(this.store, runDir, state, nodeId, attemptId, void 0, extractAttachedStepTrace(error) ?? null)
+			};
+		}
+		const nodeResult = createNodeResult({
 			attemptId,
-			startedAt
+			nodeId,
+			nodeType: node.nodeType,
+			outcome,
+			startedAt,
+			finishedAt: isoNow$1(),
+			...outcome === "ok" ? { output: executed.output } : { error: executionError instanceof Error ? executionError.message : String(executionError) }
 		});
+		state.results[nodeId] = nodeResult;
+		return {
+			...executed,
+			nodeResult,
+			executionError,
+			attemptId,
+			nodeId,
+			node,
+			startedAt,
+			state
+		};
 	}
 	async writeNodeStartedSnapshot(runDir, state, nodeId, attemptId, node) {
 		await this.store.writeSnapshot(runDir, state, {
@@ -1451,84 +1468,18 @@ var FlowRunner = class {
 			attemptId,
 			payload: {
 				nodeType: node.nodeType,
-				...node.timeoutMs !== void 0 ? { timeoutMs: node.timeoutMs ?? this.defaultNodeTimeoutMs } : { timeoutMs: this.defaultNodeTimeoutMs },
+				timeoutMs: node.timeoutMs ?? this.defaultNodeTimeoutMs,
 				...state.statusDetail ? { statusDetail: state.statusDetail } : {}
 			}
 		});
 	}
-	async executeStartedFlowStep(params) {
-		const context = makeFlowNodeContext(params.state, params.input, this.services);
-		try {
-			this.throwIfRunInterrupted(params.runDir);
-			const executed = await this.executeNode(params.runDir, params.state, params.flow, params.nodeId, params.node, context);
-			this.throwIfRunInterrupted(params.runDir);
-			return await this.createSuccessfulFlowStep(params, executed);
-		} catch (error) {
-			return await this.createFailedFlowStep(params, error);
-		}
-	}
-	async createSuccessfulFlowStep(params, executed) {
-		const trace = await finalizeStepTrace(this.store, params.runDir, params.state, params.nodeId, params.attemptId, executed.output, executed.trace);
-		const nodeResult = createNodeResult({
-			attemptId: params.attemptId,
-			nodeId: params.nodeId,
-			nodeType: params.node.nodeType,
-			outcome: "ok",
-			startedAt: params.startedAt,
-			finishedAt: isoNow$1(),
-			output: executed.output
-		});
-		params.state.results[params.nodeId] = nodeResult;
-		return {
-			...executed,
-			trace,
-			nodeResult,
-			attemptId: params.attemptId,
-			nodeId: params.nodeId,
-			node: params.node,
-			startedAt: params.startedAt,
-			state: params.state
-		};
-	}
-	async createFailedFlowStep(params, error) {
-		const trace = await finalizeStepTrace(this.store, params.runDir, params.state, params.nodeId, params.attemptId, void 0, extractAttachedStepTrace(error) ?? null);
-		const nodeResult = createNodeResult({
-			attemptId: params.attemptId,
-			nodeId: params.nodeId,
-			nodeType: params.node.nodeType,
-			outcome: outcomeForError(error),
-			startedAt: params.startedAt,
-			finishedAt: isoNow$1(),
-			error: error instanceof Error ? error.message : String(error)
-		});
-		params.state.results[params.nodeId] = nodeResult;
-		return {
-			output: void 0,
-			promptText: null,
-			rawText: null,
-			sessionInfo: null,
-			agentInfo: null,
-			trace,
-			nodeResult,
-			executionError: error,
-			attemptId: params.attemptId,
-			nodeId: params.nodeId,
-			node: params.node,
-			startedAt: params.startedAt,
-			state: params.state
-		};
-	}
 	async maybeCompleteCheckpointStep(runDir, state, step) {
 		if (step.nodeResult.outcome !== "ok" || step.node.nodeType !== "checkpoint") return;
 		state.outputs[step.nodeId] = step.output;
 		state.waitingOn = step.nodeId;
 		state.updatedAt = isoNow$1();
 		state.status = "waiting";
-		await this.recordFlowStepOutcome(runDir, state, step, {
-			sessionInfo: null,
-			agentInfo: null,
-			statusDetail: step.output?.summary ?? step.nodeId
-		});
+		await this.recordFlowStepOutcome(runDir, state, step, { statusDetail: step.output?.summary ?? step.nodeId });
 		return {
 			runDir,
 			state
@@ -1539,7 +1490,7 @@ var FlowRunner = class {
 			step.state.outputs[step.nodeId] = step.output;
 			return resolveNext(flow.edges, step.nodeId, step.output, step.nodeResult);
 		}
-		const next = resolveNextForOutcome(flow.edges, step.nodeId, step.nodeResult);
+		const next = resolveNext(flow.edges, step.nodeId, void 0, step.nodeResult);
 		if (next) return next;
 		throw step.executionError;
 	}
@@ -1572,8 +1523,8 @@ var FlowRunner = class {
 			rawText: step.rawText,
 			output: step.output,
 			error: step.nodeResult.error,
-			session: overrides.sessionInfo ?? step.sessionInfo,
-			agent: overrides.agentInfo ?? step.agentInfo,
+			session: step.sessionInfo,
+			agent: step.agentInfo,
 			...step.trace ? { trace: step.trace } : {}
 		});
 		await this.store.writeSnapshot(runDir, state, {
@@ -1586,34 +1537,28 @@ var FlowRunner = class {
 	}
 	async executeNode(runDir, state, flow, nodeId, node, context) {
 		switch (node.nodeType) {
-			case "compute": return await this.executeComputeNode(runDir, state, node, context);
-			case "action": return await this.executeActionNode(runDir, state, node, context);
-			case "checkpoint": return await this.executeCheckpointNode(runDir, state, nodeId, node, context);
+			case "compute": return await this.executeCallbackNode(runDir, state, nodeId, node, context);
+			case "action": return "run" in node ? await this.executeCallbackNode(runDir, state, nodeId, node, context) : await this.executeShellNode(runDir, state, node, context);
+			case "checkpoint": return await this.executeCallbackNode(runDir, state, nodeId, node, context);
 			case "acp": return await this.executeAcpNode(runDir, state, flow, node, context);
 			default: throw new Error(`Unsupported flow node: ${String(node)}`);
 		}
 	}
-	async executeComputeNode(runDir, state, node, context) {
-		const nodeTimeoutMs = node.timeoutMs ?? this.defaultNodeTimeoutMs;
+	async executeCallbackNode(runDir, state, nodeId, node, context) {
 		return {
-			output: await this.runWithHeartbeat(runDir, state, state.currentNode ?? "", node, nodeTimeoutMs, async () => await Promise.resolve(node.run(context))),
+			output: node.nodeType === "checkpoint" && typeof node.run !== "function" ? {
+				checkpoint: nodeId,
+				summary: node.summary ?? nodeId
+			} : await this.runWithHeartbeat(runDir, state, nodeId, node, node.timeoutMs ?? this.defaultNodeTimeoutMs, async () => await node.run?.(context)),
 			promptText: null,
 			rawText: null,
 			sessionInfo: null,
 			agentInfo: null,
-			trace: null
+			trace: node.nodeType === "action" ? { action: { actionType: "function" } } : null
 		};
 	}
-	async executeActionNode(runDir, state, node, context) {
+	async executeShellNode(runDir, state, node, context) {
 		const nodeTimeoutMs = node.timeoutMs ?? this.defaultNodeTimeoutMs;
-		if ("run" in node) return {
-			output: await this.runWithHeartbeat(runDir, state, state.currentNode ?? "", node, nodeTimeoutMs, async () => await Promise.resolve(node.run(context))),
-			promptText: null,
-			rawText: null,
-			sessionInfo: null,
-			agentInfo: null,
-			trace: { action: { actionType: "function" } }
-		};
 		const shellAbort = new AbortController();
 		let runningOwner;
 		const shellControl = {
@@ -1739,20 +1684,6 @@ var FlowRunner = class {
 			trace
 		};
 	}
-	async executeCheckpointNode(runDir, state, nodeId, node, context) {
-		const nodeTimeoutMs = node.timeoutMs ?? this.defaultNodeTimeoutMs;
-		return {
-			output: typeof node.run === "function" ? await this.runWithHeartbeat(runDir, state, state.currentNode ?? "", node, nodeTimeoutMs, async () => await Promise.resolve(node.run?.(context))) : {
-				checkpoint: nodeId,
-				summary: node.summary ?? nodeId
-			},
-			promptText: null,
-			rawText: null,
-			sessionInfo: null,
-			agentInfo: null,
-			trace: null
-		};
-	}
 	async executeAcpNode(runDir, state, flow, node, context) {
 		const nodeTimeoutMs = node.timeoutMs ?? this.defaultNodeTimeoutMs;
 		let boundSession = null;
@@ -1932,15 +1863,8 @@ var FlowRunner = class {
 			agentArgv: agent.agentArgv,
 			cwd: agent.cwd,
 			name,
-			mcpServers: this.mcpServers,
-			permissionMode: this.permissionMode,
-			nonInteractivePermissions: this.nonInteractivePermissions,
-			permissionPolicy: this.permissionPolicy,
-			authCredentials: this.authCredentials,
-			authPolicy: this.authPolicy,
-			fs: this.fs,
+			...this.connectionOptions,
 			timeoutMs,
-			verbose: this.verbose,
 			sessionOptions: this.sessionOptions
 		});
 		const binding = {
@@ -1970,40 +1894,68 @@ var FlowRunner = class {
 			agentSessionId: record.agentSessionId
 		};
 	}
+	createPromptEventCapture(runDir, binding) {
+		const pending = [];
+		return {
+			onAcpMessage: (direction, message) => {
+				pending.push(this.store.appendSessionEvent(runDir, binding, direction, message).then((value) => ({
+					status: "fulfilled",
+					value
+				}), (reason) => ({
+					status: "rejected",
+					reason
+				})));
+			},
+			async run(operation) {
+				let result;
+				try {
+					result = {
+						status: "fulfilled",
+						value: await operation()
+					};
+				} catch (reason) {
+					result = {
+						status: "rejected",
+						reason
+					};
+				}
+				const writes = await Promise.all(pending);
+				if (result.status === "rejected") throw result.reason;
+				let eventStartSeq;
+				let eventEndSeq = 0;
+				for (const write of writes) {
+					if (write.status === "rejected") throw write.reason;
+					eventStartSeq = Math.min(eventStartSeq ?? write.value, write.value);
+					eventEndSeq = Math.max(eventEndSeq, write.value);
+				}
+				if (eventStartSeq === void 0) throw new Error(`Missing ACP event capture for session ${binding.bundleId}`);
+				return {
+					result: result.value,
+					eventStartSeq,
+					eventEndSeq
+				};
+			}
+		};
+	}
 	async runPersistentPrompt(runDir, state, binding, prompt, timeoutMs) {
 		const capture = createQuietCaptureOutput();
 		const beforeRecord = await resolveSessionRecord(binding.acpxRecordId);
-		let eventStartSeq;
-		let eventEndSeq;
-		const pendingEventWrites = [];
+		const events = this.createPromptEventCapture(runDir, binding);
 		const initialClient = this.pendingPersistentSessionClients.get(binding.key);
 		if (initialClient) this.pendingPersistentSessionClients.delete(binding.key);
 		try {
-			await sendSessionDirect({
+			const { eventStartSeq, eventEndSeq } = await events.run(() => sendSessionDirect({
 				sessionId: binding.acpxRecordId,
 				prompt,
 				resumePolicy: "same-session-only",
-				mcpServers: this.mcpServers,
-				permissionMode: this.permissionMode,
-				nonInteractivePermissions: this.nonInteractivePermissions,
-				permissionPolicy: this.permissionPolicy,
-				authCredentials: this.authCredentials,
-				authPolicy: this.authPolicy,
-				fs: this.fs,
+				...this.connectionOptions,
 				outputFormatter: capture.formatter,
-				onAcpMessage: (direction, message) => {
-					const pending = this.store.appendSessionEvent(runDir, binding, direction, message).then((seq) => {
-						eventStartSeq = eventStartSeq === void 0 ? seq : Math.min(eventStartSeq, seq);
-						eventEndSeq = eventEndSeq === void 0 ? seq : Math.max(eventEndSeq, seq);
-					});
-					pendingEventWrites.push(pending);
-				},
+				errorEmissionPolicy: { queueErrorAlreadyEmitted: false },
+				onAcpMessage: events.onAcpMessage,
 				suppressSdkConsoleErrors: this.suppressSdkConsoleErrors,
 				timeoutMs,
-				verbose: this.verbose,
 				client: initialClient
-			});
-			await Promise.all(pendingEventWrites);
+			}));
 			const sessionInfo = await this.refreshSessionBinding(binding);
 			state.sessionBindings[sessionInfo.key] = sessionInfo;
 			await this.store.ensureSessionBundle(runDir, state, sessionInfo);
@@ -2017,12 +1969,8 @@ var FlowRunner = class {
 					sessionId: sessionInfo.bundleId,
 					messageStart: messageStartResolved,
 					messageEnd: Math.max(messageStartResolved, afterRecord.messages.length - 1),
-					eventStartSeq: eventStartSeq ?? (() => {
-						throw new Error(`Missing ACP event capture for session ${sessionInfo.bundleId}`);
-					})(),
-					eventEndSeq: eventEndSeq ?? (() => {
-						throw new Error(`Missing ACP event capture for session ${sessionInfo.bundleId}`);
-					})()
+					eventStartSeq,
+					eventEndSeq
 				}
 			};
 		} finally {
@@ -2041,29 +1989,16 @@ var FlowRunner = class {
 		const conversation = createSessionConversation(state.currentNodeStartedAt ?? isoNow$1());
 		let acpxState;
 		recordPromptSubmission(conversation, prompt, state.currentNodeStartedAt ?? isoNow$1());
-		let eventStartSeq;
-		let eventEndSeq;
-		const pendingEventWrites = [];
-		const result = await runOnce({
+		const events = this.createPromptEventCapture(runDir, binding);
+		const { result, eventStartSeq, eventEndSeq } = await events.run(() => runOnce({
 			agentCommand: agent.agentCommand,
 			agentArgv: agent.agentArgv,
 			cwd: agent.cwd,
 			prompt,
-			mcpServers: this.mcpServers,
-			permissionMode: this.permissionMode,
-			nonInteractivePermissions: this.nonInteractivePermissions,
-			permissionPolicy: this.permissionPolicy,
-			authCredentials: this.authCredentials,
-			authPolicy: this.authPolicy,
-			fs: this.fs,
+			...this.connectionOptions,
 			outputFormatter: capture.formatter,
-			onAcpMessage: (direction, message) => {
-				const pending = this.store.appendSessionEvent(runDir, binding, direction, message).then((seq) => {
-					eventStartSeq = eventStartSeq === void 0 ? seq : Math.min(eventStartSeq, seq);
-					eventEndSeq = eventEndSeq === void 0 ? seq : Math.max(eventEndSeq, seq);
-				});
-				pendingEventWrites.push(pending);
-			},
+			errorEmissionPolicy: { queueErrorAlreadyEmitted: false },
+			onAcpMessage: events.onAcpMessage,
 			onSessionUpdate: (notification) => {
 				acpxState = recordSessionUpdate(conversation, acpxState, notification);
 			},
@@ -2072,10 +2007,8 @@ var FlowRunner = class {
 			},
 			suppressSdkConsoleErrors: this.suppressSdkConsoleErrors,
 			timeoutMs,
-			verbose: this.verbose,
 			sessionOptions: this.sessionOptions
-		});
-		await Promise.all(pendingEventWrites);
+		}));
 		const sessionInfo = {
 			...binding,
 			acpxRecordId: result.sessionId,
@@ -2088,7 +2021,7 @@ var FlowRunner = class {
 			updatedAt: conversation.updated_at,
 			conversation,
 			acpxState: cloneSessionAcpxState(acpxState),
-			lastSeq: eventEndSeq ?? 0
+			lastSeq: eventEndSeq
 		});
 		await this.store.writeSessionRecord(runDir, state, sessionInfo, syntheticRecord);
 		return {
@@ -2098,12 +2031,8 @@ var FlowRunner = class {
 				sessionId: sessionInfo.bundleId,
 				messageStart: 0,
 				messageEnd: Math.max(0, conversation.messages.length - 1),
-				eventStartSeq: eventStartSeq ?? (() => {
-					throw new Error(`Missing ACP event capture for session ${sessionInfo.bundleId}`);
-				})(),
-				eventEndSeq: eventEndSeq ?? (() => {
-					throw new Error(`Missing ACP event capture for session ${sessionInfo.bundleId}`);
-				})()
+				eventStartSeq,
+				eventEndSeq
 			}
 		};
 	}
@@ -2300,4 +2229,4 @@ function formatDecisionPrompt(question, choices, field) {
 //#endregion
 export { parseStrictJsonObject as a, validateFlowDefinition as c, checkpoint as d, compute as f, isDefinedFlow as h, parseJsonObject as i, acp as l, shell as m, decisionEdge as n, FlowRunner as o, defineFlow as p, extractJsonObject as r, flowRunsBaseDir as s, decision as t, action as u };
 
-//# sourceMappingURL=flows-BOI1XkMp.js.map
+//# sourceMappingURL=flows-CTOdIk-m.js.map