acpx 0.7.0 → 0.9.0

package/dist/{flows-CF8w1rPI.js → flows-WLs26_5Y.js}

@@ -1,7 +1,5 @@
-import { M as SESSION_RECORD_SCHEMA, g as textPrompt, h as promptToDisplayText, j as PERMISSION_MODES } from "./perf-metrics-C2pXfxvR.js";
-import { F as resolveSessionRecord, J as withInterrupt, K as InterruptedError, Y as withTimeout, b as recordPromptSubmission, g as cloneSessionAcpxState, q as TimeoutError, v as createSessionConversation, x as recordSessionUpdate, y as recordClientOperation, z as defaultSessionEventLog } from "./prompt-turn-CVPMWdj1.js";
-import { c as createSessionWithClient, i as sendSessionDirect, l as cancelSessionPrompt, r as runOnce } from "./session-CDaQe6BH.js";
-import { t as createOutputFormatter } from "./output-DmHvT8vm.js";
+import { d as createSessionWithClient, f as cancelSessionPrompt, o as runOnce, s as sendSessionDirect, t as createOutputFormatter } from "./output-DPg20dvn.js";
+import { Ft as PERMISSION_MODES, H as resolveSessionRecord, K as defaultSessionEventLog, Lt as SESSION_RECORD_SCHEMA, _ as recordPromptSubmission, _t as withTimeout, ft as promptToDisplayText, g as recordClientOperation, gt as withInterrupt, h as createSessionConversation, ht as TimeoutError, mt as InterruptedError, p as cloneSessionAcpxState, pt as textPrompt, v as recordSessionUpdate } from "./live-checkpoint-D5d-K9s1.js";
 import path from "node:path";
 import fs from "node:fs/promises";
 import os from "node:os";
@@ -238,6 +236,15 @@ function renderShellCommand(command, args) {
 	const renderedArgs = args.map((arg) => JSON.stringify(arg)).join(" ");
 	return renderedArgs.length > 0 ? `${command} ${renderedArgs}` : command;
 }
+function createShellFailureError(spec, args, exitCode, signal, stderr) {
+	const status = signal ? `signal ${signal}` : `exit ${String(exitCode)}`;
+	const details = stderr.length > 0 ? `\n${stderr.trim()}` : "";
+	return /* @__PURE__ */ new Error(`Shell action failed (${renderShellCommand(spec.command, args)}): ${status}${details}`);
+}
+function rejectIfShellFailed(spec, args, result, timedOut) {
+	if (timedOut) return new TimeoutError(spec.timeoutMs ?? 0);
+	if (((result.exitCode ?? 0) !== 0 || result.signal != null) && spec.allowNonZeroExit !== true) return createShellFailureError(spec, args, result.exitCode, result.signal, result.stderr);
+}
 async function runShellAction(spec) {
 	const cwd = spec.cwd ?? process.cwd();
 	const args = spec.args ?? [];
@@ -282,12 +289,9 @@ async function runShellAction(spec) {
 				signal,
 				durationMs: Date.now() - startMs
 			};
-			if (timedOut) {
-				reject(new TimeoutError(spec.timeoutMs ?? 0));
-				return;
-			}
-			if (((exitCode ?? 0) !== 0 || signal != null) && spec.allowNonZeroExit !== true) {
-				reject(/* @__PURE__ */ new Error(`Shell action failed (${renderShellCommand(spec.command, args)}): ${signal ? `signal ${signal}` : `exit ${String(exitCode)}`}${stderr.length > 0 ? `\n${stderr.trim()}` : ""}`));
+			const error = rejectIfShellFailed(spec, args, result, timedOut);
+			if (error) {
+				reject(error);
 				return;
 			}
 			resolve(result);
@@ -314,16 +318,20 @@ function validateFlowDefinition(flow) {
 	assertValidFlowDefinitionShape(flow);
 	if (!flow.nodes[flow.startAt]) throw new Error(`Flow start node is missing: ${flow.startAt}`);
 	const outgoingEdges = /* @__PURE__ */ new Set();
-	for (const edge of flow.edges) {
-		if (!flow.nodes[edge.from]) throw new Error(`Flow edge references unknown from-node: ${edge.from}`);
-		if (outgoingEdges.has(edge.from)) throw new Error(`Flow node must not declare multiple outgoing edges: ${edge.from}`);
-		outgoingEdges.add(edge.from);
-		if ("to" in edge) {
-			if (!flow.nodes[edge.to]) throw new Error(`Flow edge references unknown to-node: ${edge.to}`);
-			continue;
-		}
-		for (const target of Object.values(edge.switch.cases)) if (!flow.nodes[target]) throw new Error(`Flow switch references unknown to-node: ${target}`);
+	for (const edge of flow.edges) validateFlowEdge(flow, edge, outgoingEdges);
+}
+function assertKnownFlowNode(flow, nodeId, description) {
+	if (!flow.nodes[nodeId]) throw new Error(`${description}: ${nodeId}`);
+}
+function validateFlowEdge(flow, edge, outgoingEdges) {
+	assertKnownFlowNode(flow, edge.from, "Flow edge references unknown from-node");
+	if (outgoingEdges.has(edge.from)) throw new Error(`Flow node must not declare multiple outgoing edges: ${edge.from}`);
+	outgoingEdges.add(edge.from);
+	if ("to" in edge) {
+		assertKnownFlowNode(flow, edge.to, "Flow edge references unknown to-node");
+		return;
 	}
+	for (const target of Object.values(edge.switch.cases)) assertKnownFlowNode(flow, target, "Flow switch references unknown to-node");
 }
 function resolveNext(edges, from, output, result) {
 	const edge = edges.find((candidate) => candidate.from === from);
@@ -586,14 +594,16 @@ function extractAttachedStepTrace(error) {
 }
 function toInlineOutput(value) {
 	if (value == null || typeof value === "number" || typeof value === "boolean") return value;
-	if (typeof value === "string") return value.length <= 200 && !value.includes("\n") ? value : void 0;
+	if (typeof value === "string") return isInlineSerializableText(value) ? value : void 0;
 	try {
-		const serialized = JSON.stringify(value);
-		if (serialized.length <= 200 && !serialized.includes("\n")) return value;
+		if (isInlineSerializableText(JSON.stringify(value))) return value;
 	} catch {
 		return;
 	}
 }
+function isInlineSerializableText(value) {
+	return value.length <= 200 && !value.includes("\n");
+}
 function outputArtifactMediaType(value) {
 	return typeof value === "string" ? "text/plain" : "application/json";
 }
@@ -887,24 +897,9 @@ function createFlowDefinitionSnapshot(flow) {
 	};
 }
 function snapshotNode(node) {
-	const common = {
-		nodeType: node.nodeType,
-		...node.timeoutMs !== void 0 ? { timeoutMs: node.timeoutMs } : {},
-		...node.heartbeatMs !== void 0 ? { heartbeatMs: node.heartbeatMs } : {},
-		...node.statusDetail ? { statusDetail: node.statusDetail } : {}
-	};
+	const common = snapshotCommonNodeFields(node);
 	switch (node.nodeType) {
-		case "acp": return {
-			...common,
-			...node.profile ? { profile: node.profile } : {},
-			session: {
-				...node.session?.handle ? { handle: node.session.handle } : {},
-				...node.session?.isolated ? { isolated: true } : {}
-			},
-			cwd: snapshotCwd(node.cwd),
-			hasPrompt: true,
-			hasParse: typeof node.parse === "function"
-		};
+		case "acp": return snapshotAcpNode(node, common);
 		case "compute": return {
 			...common,
 			hasRun: true
@@ -927,6 +922,27 @@ function snapshotNode(node) {
 	}
 	throw new Error(`Unsupported flow node type: ${String(node)}`);
 }
+function snapshotCommonNodeFields(node) {
+	return {
+		nodeType: node.nodeType,
+		...node.timeoutMs !== void 0 ? { timeoutMs: node.timeoutMs } : {},
+		...node.heartbeatMs !== void 0 ? { heartbeatMs: node.heartbeatMs } : {},
+		...node.statusDetail ? { statusDetail: node.statusDetail } : {}
+	};
+}
+function snapshotAcpNode(node, common) {
+	return {
+		...common,
+		...node.profile ? { profile: node.profile } : {},
+		session: {
+			...node.session?.handle ? { handle: node.session.handle } : {},
+			...node.session?.isolated ? { isolated: true } : {}
+		},
+		cwd: snapshotCwd(node.cwd),
+		hasPrompt: true,
+		hasParse: typeof node.parse === "function"
+	};
+}
 function snapshotCwd(cwd) {
 	if (typeof cwd === "function") return { mode: "dynamic" };
 	if (typeof cwd === "string") return {
@@ -989,6 +1005,7 @@ var FlowRunner = class {
 	permissionMode;
 	mcpServers;
 	nonInteractivePermissions;
+	permissionPolicy;
 	authCredentials;
 	authPolicy;
 	timeoutMs;
@@ -1005,6 +1022,7 @@ var FlowRunner = class {
 		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.timeoutMs = options.timeoutMs;
@@ -1044,156 +1062,188 @@ var FlowRunner = class {
 			state,
 			inputArtifact
 		});
-		let current = flow.startAt;
-		const attemptCounts = /* @__PURE__ */ new Map();
 		try {
-			return await withInterrupt(async () => {
-				try {
-					while (current) {
-						const node = flow.nodes[current];
-						if (!node) throw new Error(`Unknown flow node: ${current}`);
-						const attemptId = nextAttemptId(attemptCounts, current);
-						const startedAt = isoNow$1();
-						const context = makeFlowNodeContext(state, input, this.services);
-						let output;
-						let promptText = null;
-						let rawText = null;
-						let sessionInfo = null;
-						let agentInfo = null;
-						let trace = null;
-						markNodeStarted(state, current, attemptId, node.nodeType, startedAt, node.statusDetail);
-						await this.store.writeSnapshot(runDir, state, {
-							scope: "node",
-							type: "node_started",
-							nodeId: current,
-							attemptId,
-							payload: {
-								nodeType: node.nodeType,
-								...node.timeoutMs !== void 0 ? { timeoutMs: node.timeoutMs ?? this.defaultNodeTimeoutMs } : { timeoutMs: this.defaultNodeTimeoutMs },
-								...state.statusDetail ? { statusDetail: state.statusDetail } : {}
-							}
-						});
-						let nodeResult;
-						let executionError;
-						try {
-							({output, promptText, rawText, sessionInfo, agentInfo, trace} = await this.executeNode(runDir, state, flow, current, node, context));
-							trace = await finalizeStepTrace(this.store, runDir, state, current, attemptId, output, trace);
-							nodeResult = createNodeResult({
-								attemptId,
-								nodeId: current,
-								nodeType: node.nodeType,
-								outcome: "ok",
-								startedAt,
-								finishedAt: isoNow$1(),
-								output
-							});
-						} catch (error) {
-							executionError = error;
-							trace = extractAttachedStepTrace(error) ?? trace;
-							trace = await finalizeStepTrace(this.store, runDir, state, current, attemptId, void 0, trace);
-							nodeResult = createNodeResult({
-								attemptId,
-								nodeId: current,
-								nodeType: node.nodeType,
-								outcome: outcomeForError(error),
-								startedAt,
-								finishedAt: isoNow$1(),
-								error: error instanceof Error ? error.message : String(error)
-							});
-						}
-						state.results[current] = nodeResult;
-						if (nodeResult.outcome === "ok" && node.nodeType === "checkpoint") {
-							state.outputs[current] = output;
-							state.waitingOn = current;
-							state.updatedAt = isoNow$1();
-							state.status = "waiting";
-							clearActiveNode(state, output?.summary ?? current);
-							state.steps.push({
-								attemptId,
-								nodeId: current,
-								nodeType: node.nodeType,
-								outcome: nodeResult.outcome,
-								startedAt,
-								finishedAt: nodeResult.finishedAt,
-								promptText,
-								rawText,
-								output,
-								session: null,
-								agent: null,
-								...trace ? { trace } : {}
-							});
-							await this.store.writeSnapshot(runDir, state, {
-								scope: "node",
-								type: "node_outcome",
-								nodeId: current,
-								attemptId,
-								payload: createNodeOutcomePayload(nodeResult, trace)
-							});
-							return {
-								runDir,
-								state
-							};
-						}
-						if (nodeResult.outcome === "ok") state.outputs[current] = output;
-						state.updatedAt = isoNow$1();
-						clearActiveNode(state);
-						state.steps.push({
-							attemptId,
-							nodeId: current,
-							nodeType: node.nodeType,
-							outcome: nodeResult.outcome,
-							startedAt,
-							finishedAt: nodeResult.finishedAt,
-							promptText,
-							rawText,
-							output,
-							error: nodeResult.error,
-							session: sessionInfo,
-							agent: agentInfo,
-							...trace ? { trace } : {}
-						});
-						await this.store.writeSnapshot(runDir, state, {
-							scope: "node",
-							type: "node_outcome",
-							nodeId: current,
-							attemptId,
-							payload: createNodeOutcomePayload(nodeResult, trace)
-						});
-						if (nodeResult.outcome === "ok") {
-							current = resolveNext(flow.edges, current, output, nodeResult);
-							continue;
-						}
-						const next = resolveNextForOutcome(flow.edges, current, nodeResult);
-						if (next) {
-							current = next;
-							continue;
-						}
-						throw executionError;
-					}
-					state.status = "completed";
-					state.finishedAt = isoNow$1();
-					state.updatedAt = state.finishedAt;
-					clearActiveNode(state);
-					await this.store.writeSnapshot(runDir, state, {
-						scope: "run",
-						type: "run_completed",
-						payload: { status: state.status }
-					});
-					return {
-						runDir,
-						state
-					};
-				} catch (error) {
-					await persistRunFailure(this.store, runDir, state, error);
-					throw error;
-				}
-			}, async () => {
+			return await withInterrupt(async () => await this.executeFlowRun(flow, input, runDir, state), async () => {
 				await persistRunFailure(this.store, runDir, state, new InterruptedError());
 			});
 		} finally {
 			await this.closePendingPersistentSessionClients();
 		}
 	}
+	async executeFlowRun(flow, input, runDir, state) {
+		let current = flow.startAt;
+		const attemptCounts = /* @__PURE__ */ new Map();
+		try {
+			while (current) {
+				const step = await this.executeFlowStep(flow, input, runDir, state, current, attemptCounts);
+				const waiting = await this.maybeCompleteCheckpointStep(runDir, state, step);
+				if (waiting) return waiting;
+				await this.recordFlowStepOutcome(runDir, state, step);
+				current = this.resolveNextNode(flow, step);
+			}
+			return await this.completeFlowRun(runDir, state);
+		} catch (error) {
+			await persistRunFailure(this.store, runDir, state, error);
+			throw error;
+		}
+	}
+	async executeFlowStep(flow, input, runDir, state, nodeId, attemptCounts) {
+		const node = flow.nodes[nodeId];
+		if (!node) throw new Error(`Unknown flow node: ${nodeId}`);
+		const attemptId = nextAttemptId(attemptCounts, nodeId);
+		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,
+			attemptId,
+			startedAt
+		});
+	}
+	async writeNodeStartedSnapshot(runDir, state, nodeId, attemptId, node) {
+		await this.store.writeSnapshot(runDir, state, {
+			scope: "node",
+			type: "node_started",
+			nodeId,
+			attemptId,
+			payload: {
+				nodeType: node.nodeType,
+				...node.timeoutMs !== void 0 ? { timeoutMs: node.timeoutMs ?? this.defaultNodeTimeoutMs } : { timeoutMs: this.defaultNodeTimeoutMs },
+				...state.statusDetail ? { statusDetail: state.statusDetail } : {}
+			}
+		});
+	}
+	async executeStartedFlowStep(params) {
+		const context = makeFlowNodeContext(params.state, params.input, this.services);
+		try {
+			const executed = await this.executeNode(params.runDir, params.state, params.flow, params.nodeId, params.node, context);
+			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
+		});
+		return {
+			runDir,
+			state
+		};
+	}
+	resolveNextNode(flow, step) {
+		if (step.nodeResult.outcome === "ok") {
+			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);
+		if (next) return next;
+		throw step.executionError;
+	}
+	async completeFlowRun(runDir, state) {
+		state.status = "completed";
+		state.finishedAt = isoNow$1();
+		state.updatedAt = state.finishedAt;
+		clearActiveNode(state);
+		await this.store.writeSnapshot(runDir, state, {
+			scope: "run",
+			type: "run_completed",
+			payload: { status: state.status }
+		});
+		return {
+			runDir,
+			state
+		};
+	}
+	async recordFlowStepOutcome(runDir, state, step, overrides = {}) {
+		state.updatedAt = isoNow$1();
+		clearActiveNode(state, overrides.statusDetail);
+		state.steps.push({
+			attemptId: step.attemptId,
+			nodeId: step.nodeId,
+			nodeType: step.node.nodeType,
+			outcome: step.nodeResult.outcome,
+			startedAt: step.startedAt,
+			finishedAt: step.nodeResult.finishedAt,
+			promptText: step.promptText,
+			rawText: step.rawText,
+			output: step.output,
+			error: step.nodeResult.error,
+			session: overrides.sessionInfo ?? step.sessionInfo,
+			agent: overrides.agentInfo ?? step.agentInfo,
+			...step.trace ? { trace: step.trace } : {}
+		});
+		await this.store.writeSnapshot(runDir, state, {
+			scope: "node",
+			type: "node_outcome",
+			nodeId: step.nodeId,
+			attemptId: step.attemptId,
+			payload: createNodeOutcomePayload(step.nodeResult, step.trace)
+		});
+	}
 	async executeNode(runDir, state, flow, nodeId, node, context) {
 		switch (node.nodeType) {
 			case "compute": return await this.executeComputeNode(runDir, state, node, context);
@@ -1335,147 +1385,132 @@ var FlowRunner = class {
 		const nodeTimeoutMs = node.timeoutMs ?? this.defaultNodeTimeoutMs;
 		let boundSession = null;
 		return await this.runWithHeartbeat(runDir, state, state.currentNode ?? "", node, nodeTimeoutMs, async () => {
-			const resolvedAgent = this.resolveAgent(node.profile);
-			const agentInfo = {
-				...resolvedAgent,
-				cwd: await resolveNodeCwd(resolvedAgent.cwd, node.cwd, context)
-			};
-			const prompt = normalizePromptInput(await Promise.resolve(node.prompt(context)));
-			const promptText = promptToDisplayText(prompt);
-			updateStatusDetail(state, summarizePrompt(promptText, node.statusDetail));
-			await this.store.writeLive(runDir, state, {
-				scope: "node",
-				type: "node_heartbeat",
-				nodeId: state.currentNode,
-				attemptId: state.currentAttemptId,
-				payload: { statusDetail: state.statusDetail }
-			});
-			const promptArtifact = await this.store.writeArtifact(runDir, state, promptText, {
+			const prepared = await this.prepareAcpPrompt(runDir, state, node, context, nodeTimeoutMs);
+			if (node.session?.isolated) return await this.executeIsolatedAcpPrompt(runDir, state, flow, node, context, prepared);
+			boundSession = await this.ensureSessionBinding(runDir, state, flow, node, prepared.agentInfo, nodeTimeoutMs);
+			return await this.executePersistentAcpPrompt(runDir, state, node, context, prepared, boundSession);
+		}, async () => {
+			if (!boundSession) return;
+			await cancelSessionPrompt({ sessionId: boundSession.acpxRecordId });
+		});
+	}
+	async prepareAcpPrompt(runDir, state, node, context, nodeTimeoutMs) {
+		const resolvedAgent = this.resolveAgent(node.profile);
+		const agentInfo = {
+			...resolvedAgent,
+			cwd: await resolveNodeCwd(resolvedAgent.cwd, node.cwd, context)
+		};
+		const prompt = normalizePromptInput(await Promise.resolve(node.prompt(context)));
+		const promptText = promptToDisplayText(prompt);
+		updateStatusDetail(state, summarizePrompt(promptText, node.statusDetail));
+		await this.writeAcpPromptHeartbeat(runDir, state);
+		return {
+			agentInfo,
+			prompt,
+			promptText,
+			promptArtifact: await this.store.writeArtifact(runDir, state, promptText, {
 				mediaType: "text/plain",
 				extension: "txt",
 				nodeId: state.currentNode,
 				attemptId: state.currentAttemptId
-			});
-			if (node.session?.isolated) {
-				const isolatedBinding = createIsolatedSessionBinding(flow.name, state.runId, state.currentAttemptId ?? randomUUID(), node.profile, agentInfo);
-				const initialIsolatedRecord = createSyntheticSessionRecord({
-					binding: isolatedBinding,
-					createdAt: state.currentNodeStartedAt ?? isoNow$1(),
-					updatedAt: state.currentNodeStartedAt ?? isoNow$1(),
-					conversation: createSessionConversation(state.currentNodeStartedAt ?? isoNow$1()),
-					acpxState: void 0,
-					lastSeq: 0
-				});
-				await this.store.ensureSessionBundle(runDir, state, isolatedBinding, initialIsolatedRecord);
-				await this.store.appendTrace(runDir, state, {
-					scope: "acp",
-					type: "acp_prompt_prepared",
-					nodeId: state.currentNode,
-					attemptId: state.currentAttemptId,
-					sessionId: isolatedBinding.bundleId,
-					payload: {
-						sessionId: isolatedBinding.bundleId,
-						promptArtifact
-					}
-				});
-				const isolatedPrompt = await this.runIsolatedPrompt(runDir, state, isolatedBinding, agentInfo, prompt, nodeTimeoutMs);
-				const rawResponseArtifact = await this.store.writeArtifact(runDir, state, isolatedPrompt.rawText, {
-					mediaType: "text/plain",
-					extension: "txt",
-					nodeId: state.currentNode,
-					attemptId: state.currentAttemptId,
-					sessionId: isolatedBinding.bundleId
-				});
-				await this.store.appendTrace(runDir, state, {
-					scope: "acp",
-					type: "acp_response_parsed",
-					nodeId: state.currentNode,
-					attemptId: state.currentAttemptId,
-					sessionId: isolatedBinding.bundleId,
-					payload: {
-						sessionId: isolatedBinding.bundleId,
-						conversation: isolatedPrompt.conversation,
-						rawResponseArtifact
-					}
-				});
-				const trace = {
-					sessionId: isolatedBinding.bundleId,
-					promptArtifact,
-					rawResponseArtifact,
-					conversation: isolatedPrompt.conversation
-				};
-				let parsedOutput;
-				try {
-					parsedOutput = node.parse ? await node.parse(isolatedPrompt.rawText, context) : isolatedPrompt.rawText;
-				} catch (error) {
-					throw attachStepTrace(error, trace);
-				}
-				return {
-					output: parsedOutput,
-					promptText,
-					rawText: isolatedPrompt.rawText,
-					sessionInfo: isolatedBinding,
-					agentInfo,
-					trace
-				};
+			}),
+			nodeTimeoutMs
+		};
+	}
+	async writeAcpPromptHeartbeat(runDir, state) {
+		await this.store.writeLive(runDir, state, {
+			scope: "node",
+			type: "node_heartbeat",
+			nodeId: state.currentNode,
+			attemptId: state.currentAttemptId,
+			payload: { statusDetail: state.statusDetail }
+		});
+	}
+	async executeIsolatedAcpPrompt(runDir, state, flow, node, context, prepared) {
+		const binding = createIsolatedSessionBinding(flow.name, state.runId, state.currentAttemptId ?? randomUUID(), node.profile, prepared.agentInfo);
+		await this.initializeIsolatedSessionBundle(runDir, state, binding);
+		await this.appendAcpPromptPreparedTrace(runDir, state, binding, prepared.promptArtifact);
+		const prompt = await this.runIsolatedPrompt(runDir, state, binding, prepared.agentInfo, prepared.prompt, prepared.nodeTimeoutMs);
+		return await this.finishAcpPrompt(runDir, state, node, context, prepared, prompt, binding);
+	}
+	async initializeIsolatedSessionBundle(runDir, state, binding) {
+		const timestamp = state.currentNodeStartedAt ?? isoNow$1();
+		const initialRecord = createSyntheticSessionRecord({
+			binding,
+			createdAt: timestamp,
+			updatedAt: timestamp,
+			conversation: createSessionConversation(timestamp),
+			acpxState: void 0,
+			lastSeq: 0
+		});
+		await this.store.ensureSessionBundle(runDir, state, binding, initialRecord);
+	}
+	async executePersistentAcpPrompt(runDir, state, node, context, prepared, binding) {
+		await this.appendAcpPromptPreparedTrace(runDir, state, binding, prepared.promptArtifact);
+		const prompt = await this.runPersistentPrompt(runDir, state, binding, prepared.prompt, prepared.nodeTimeoutMs);
+		return await this.finishAcpPrompt(runDir, state, node, context, prepared, prompt, prompt.sessionInfo);
+	}
+	async appendAcpPromptPreparedTrace(runDir, state, binding, promptArtifact) {
+		await this.store.appendTrace(runDir, state, {
+			scope: "acp",
+			type: "acp_prompt_prepared",
+			nodeId: state.currentNode,
+			attemptId: state.currentAttemptId,
+			sessionId: binding.bundleId,
+			payload: {
+				sessionId: binding.bundleId,
+				promptArtifact
 			}
-			boundSession = await this.ensureSessionBinding(runDir, state, flow, node, agentInfo, nodeTimeoutMs);
-			await this.store.appendTrace(runDir, state, {
-				scope: "acp",
-				type: "acp_prompt_prepared",
-				nodeId: state.currentNode,
-				attemptId: state.currentAttemptId,
-				sessionId: boundSession.bundleId,
-				payload: {
-					sessionId: boundSession.bundleId,
-					promptArtifact
-				}
-			});
-			const persistentPrompt = await this.runPersistentPrompt(runDir, state, boundSession, prompt, nodeTimeoutMs);
-			const rawResponseArtifact = await this.store.writeArtifact(runDir, state, persistentPrompt.rawText, {
-				mediaType: "text/plain",
-				extension: "txt",
-				nodeId: state.currentNode,
-				attemptId: state.currentAttemptId,
-				sessionId: persistentPrompt.sessionInfo.bundleId
-			});
-			await this.store.appendTrace(runDir, state, {
-				scope: "acp",
-				type: "acp_response_parsed",
-				nodeId: state.currentNode,
-				attemptId: state.currentAttemptId,
-				sessionId: persistentPrompt.sessionInfo.bundleId,
-				payload: {
-					sessionId: persistentPrompt.sessionInfo.bundleId,
-					conversation: persistentPrompt.conversation,
-					rawResponseArtifact
-				}
-			});
-			const trace = {
-				sessionId: persistentPrompt.sessionInfo.bundleId,
-				promptArtifact,
-				rawResponseArtifact,
-				conversation: persistentPrompt.conversation
-			};
-			let parsedOutput;
-			try {
-				parsedOutput = node.parse ? await node.parse(persistentPrompt.rawText, context) : persistentPrompt.rawText;
-			} catch (error) {
-				throw attachStepTrace(error, trace);
+		});
+	}
+	async finishAcpPrompt(runDir, state, node, context, prepared, prompt, sessionInfo) {
+		const rawResponseArtifact = await this.writeAcpRawResponseArtifact(runDir, state, prompt, sessionInfo);
+		await this.appendAcpResponseParsedTrace(runDir, state, prompt, sessionInfo, rawResponseArtifact);
+		const trace = {
+			sessionId: sessionInfo.bundleId,
+			promptArtifact: prepared.promptArtifact,
+			rawResponseArtifact,
+			conversation: prompt.conversation
+		};
+		return {
+			output: await this.parseAcpOutput(node, context, prompt.rawText, trace),
+			promptText: prepared.promptText,
+			rawText: prompt.rawText,
+			sessionInfo,
+			agentInfo: prepared.agentInfo,
+			trace
+		};
+	}
+	async writeAcpRawResponseArtifact(runDir, state, prompt, sessionInfo) {
+		return await this.store.writeArtifact(runDir, state, prompt.rawText, {
+			mediaType: "text/plain",
+			extension: "txt",
+			nodeId: state.currentNode,
+			attemptId: state.currentAttemptId,
+			sessionId: sessionInfo.bundleId
+		});
+	}
+	async appendAcpResponseParsedTrace(runDir, state, prompt, sessionInfo, rawResponseArtifact) {
+		await this.store.appendTrace(runDir, state, {
+			scope: "acp",
+			type: "acp_response_parsed",
+			nodeId: state.currentNode,
+			attemptId: state.currentAttemptId,
+			sessionId: sessionInfo.bundleId,
+			payload: {
+				sessionId: sessionInfo.bundleId,
+				conversation: prompt.conversation,
+				rawResponseArtifact
 			}
-			return {
-				output: parsedOutput,
-				promptText,
-				rawText: persistentPrompt.rawText,
-				sessionInfo: persistentPrompt.sessionInfo,
-				agentInfo,
-				trace
-			};
-		}, async () => {
-			if (!boundSession) return;
-			await cancelSessionPrompt({ sessionId: boundSession.acpxRecordId });
 		});
 	}
+	async parseAcpOutput(node, context, rawText, trace) {
+		try {
+			return node.parse ? await node.parse(rawText, context) : rawText;
+		} catch (error) {
+			throw attachStepTrace(error, trace);
+		}
+	}
 	async runWithHeartbeat(runDir, state, nodeId, node, timeoutMs, run, onTimeout) {
 		const heartbeatMs = Math.max(0, Math.round(node.heartbeatMs ?? DEFAULT_FLOW_HEARTBEAT_MS));
 		let timer;
@@ -1521,6 +1556,7 @@ var FlowRunner = class {
 			mcpServers: this.mcpServers,
 			permissionMode: this.permissionMode,
 			nonInteractivePermissions: this.nonInteractivePermissions,
+			permissionPolicy: this.permissionPolicy,
 			authCredentials: this.authCredentials,
 			authPolicy: this.authPolicy,
 			timeoutMs,
@@ -1569,6 +1605,7 @@ var FlowRunner = class {
 				mcpServers: this.mcpServers,
 				permissionMode: this.permissionMode,
 				nonInteractivePermissions: this.nonInteractivePermissions,
+				permissionPolicy: this.permissionPolicy,
 				authCredentials: this.authCredentials,
 				authPolicy: this.authPolicy,
 				outputFormatter: capture.formatter,
@@ -1632,6 +1669,7 @@ var FlowRunner = class {
 			mcpServers: this.mcpServers,
 			permissionMode: this.permissionMode,
 			nonInteractivePermissions: this.nonInteractivePermissions,
+			permissionPolicy: this.permissionPolicy,
 			authCredentials: this.authCredentials,
 			authPolicy: this.authPolicy,
 			outputFormatter: capture.formatter,
@@ -1700,18 +1738,25 @@ function parseJsonObject(text, options = {}) {
 	const mode = options.mode ?? "compat";
 	const direct = tryParse(trimmed);
 	if (direct.ok) return direct.value;
-	if (mode === "fenced" || mode === "compat") {
-		const fencedText = extractFencedJsonText(trimmed);
-		if (fencedText !== null) {
-			const fenced = tryParse(fencedText);
-			if (fenced.ok) return fenced.value;
-		}
+	const fenced = parseFencedJsonIfAllowed(trimmed, mode);
+	if (fenced.ok) return fenced.value;
+	if (mode === "compat") {
+		const balanced = parseBalancedJsonCandidate(trimmed);
+		if (balanced.ok) return balanced.value;
 	}
-	if (mode === "compat") for (const candidate of extractBalancedJsonCandidates(trimmed)) {
+	throw new Error(`Could not parse JSON from assistant output:\n${trimmed}`);
+}
+function parseFencedJsonIfAllowed(text, mode) {
+	if (mode !== "fenced" && mode !== "compat") return { ok: false };
+	const fencedText = extractFencedJsonText(text);
+	return fencedText === null ? { ok: false } : tryParse(fencedText);
+}
+function parseBalancedJsonCandidate(text) {
+	for (const candidate of extractBalancedJsonCandidates(text)) {
 		const parsed = tryParse(candidate);
-		if (parsed.ok) return parsed.value;
+		if (parsed.ok) return parsed;
 	}
-	throw new Error(`Could not parse JSON from assistant output:\n${trimmed}`);
+	return { ok: false };
 }
 function parseStrictJsonObject(text) {
 	return parseJsonObject(text, { mode: "strict" });
@@ -1758,27 +1803,50 @@ function scanBalanced(text, startIndex) {
 	for (let index = startIndex; index < text.length; index += 1) {
 		const char = text[index];
 		if (inString) {
-			if (escaped) escaped = false;
-			else if (char === "\\") escaped = true;
-			else if (char === "\"") inString = false;
+			const next = scanStringChar(char, escaped);
+			escaped = next.escaped;
+			inString = next.inString;
 			continue;
 		}
 		if (char === "\"") {
 			inString = true;
 			continue;
 		}
-		if (char === "{" || char === "[") {
-			stack.push(char);
-			continue;
-		}
-		if (char !== "}" && char !== "]") continue;
-		const last = stack.at(-1);
-		if (last === "{" && char !== "}" || last === "[" && char !== "]") return null;
-		stack.pop();
-		if (stack.length === 0) return text.slice(startIndex, index + 1);
+		const result = scanBalancedToken(text, startIndex, index, char, stack);
+		if (result !== SCAN_CONTINUE) return result;
 	}
 	return null;
 }
+const SCAN_CONTINUE = Symbol("scan-continue");
+function scanBalancedToken(text, startIndex, index, char, stack) {
+	if (char === "{" || char === "[") {
+		stack.push(char);
+		return SCAN_CONTINUE;
+	}
+	if (char !== "}" && char !== "]") return SCAN_CONTINUE;
+	if (!balancedClosingTokenMatches(stack.at(-1), char)) return null;
+	stack.pop();
+	return stack.length === 0 ? text.slice(startIndex, index + 1) : SCAN_CONTINUE;
+}
+function balancedClosingTokenMatches(open, close) {
+	if (open === "{") return close === "}";
+	if (open === "[") return close === "]";
+	return false;
+}
+function scanStringChar(char, escaped) {
+	if (escaped) return {
+		escaped: false,
+		inString: true
+	};
+	if (char === "\\") return {
+		escaped: true,
+		inString: true
+	};
+	return {
+		escaped: false,
+		inString: char !== "\""
+	};
+}
 //#endregion
 //#region src/flows/decision.ts
 const DEFAULT_FIELD = "route";
@@ -1848,4 +1916,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-CF8w1rPI.js.map
+//# sourceMappingURL=flows-WLs26_5Y.js.map