acpx 0.18.0 → 0.19.1

package/dist/{flows-WOQNzCMC.js → flows-DimX0it5.js}

@@ -1,7 +1,7 @@
-import { t as createOutputFormatter } from "./output-CL18YmsG.js";
-import { C as promptToDisplayText, Dt as PERMISSION_MODES, I as resolveSessionRecord, ht as writePrivateJsonFile, kt as SESSION_RECORD_SCHEMA, lt as defaultSessionEventLog, mt as writePrivateFile, w as textPrompt } from "./ipc-BJrvfNXr.js";
-import { B as cloneSessionAcpxState, G as recordSessionUpdate, H as createSessionConversation, U as recordClientOperation, W as recordPromptSubmission, _ as cancelSessionPrompt, at as InterruptedError, ct as withInterrupt, i as runOnce, lt as withTimeout, m as createSessionWithClient, o as sendSessionDirect, ot as TimeoutError } from "./queue-owner-runtime-Cr0dWJuL.js";
-import { M as runTimedExecFile } from "./agent-registry-DdKB-zia.js";
+import { t as createOutputFormatter } from "./output-Cnuji8Bo.js";
+import { D as textPrompt, E as promptToDisplayText, _t as writePrivateFile, ft as defaultSessionEventLog, jt as SESSION_RECORD_SCHEMA, kt as PERMISSION_MODES, vt as writePrivateJsonFile, z as resolveSessionRecord } from "./ipc-DAApJ5mi.js";
+import { G as recordPromptSubmission, K as recordSessionUpdate, U as createSessionConversation, V as cloneSessionAcpxState, W as recordClientOperation, i as runOnce, lt as withInterrupt, m as createSessionWithClient, o as sendSessionDirect, ot as InterruptedError, st as TimeoutError, ut as withTimeout } from "./queue-owner-runtime-C4OOosbo.js";
+import { N as runTimedExecFile } from "./agent-registry-DWlx5BQ4.js";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import fs from "node:fs/promises";
@@ -10,6 +10,131 @@ 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";
+import { performance } from "node:perf_hooks";
+//#region src/flows/attempt.ts
+/** One node attempt owns admission and completion of its managed operations. */
+var FlowAttempt = class {
+	signal;
+	nodeId;
+	attemptId;
+	startedAt;
+	terminationSignal = "SIGTERM";
+	controller = new AbortController();
+	pending = /* @__PURE__ */ new Set();
+	cancellations = /* @__PURE__ */ new Set();
+	cleanupFailures = [];
+	deadlineAt;
+	timeoutMs;
+	timer;
+	accepting = true;
+	finished = false;
+	constructor(options) {
+		this.nodeId = options.nodeId;
+		this.attemptId = options.attemptId;
+		this.startedAt = options.startedAt;
+		this.signal = this.controller.signal;
+		if (options.timeoutMs != null && options.timeoutMs > 0) {
+			this.timeoutMs = options.timeoutMs;
+			this.deadlineAt = performance.now() + options.timeoutMs;
+			this.timer = setTimeout(() => this.cancel(new TimeoutError(options.timeoutMs)), options.timeoutMs);
+		}
+	}
+	get active() {
+		return this.accepting && !this.signal.aborted;
+	}
+	assertActive() {
+		this.checkDeadline();
+		this.signal.throwIfAborted();
+		if (!this.accepting) throw new Error("Flow attempt has finished accepting work");
+	}
+	remainingTimeoutMs() {
+		this.assertActive();
+		return this.deadlineAt === void 0 ? void 0 : Math.max(1, Math.ceil(this.deadlineAt - performance.now()));
+	}
+	cancel(reason, signal = "SIGTERM") {
+		if (this.finished || this.signal.aborted) return;
+		this.accepting = false;
+		this.terminationSignal = signal;
+		this.controller.abort(reason);
+		for (const cancel of this.cancellations) this.trackCancellation(cancel);
+	}
+	registerCancellation(cancel) {
+		if (!this.active) {
+			this.trackCancellation(cancel);
+			return () => {};
+		}
+		this.cancellations.add(cancel);
+		return () => {
+			this.cancellations.delete(cancel);
+		};
+	}
+	/** Track runtime work, never an arbitrary user callback that may ignore cancellation. */
+	own(run, options = {}) {
+		this.assertActive();
+		const operation = run().then((value) => {
+			this.checkDeadline();
+			if (this.signal.aborted) this.signal.throwIfAborted();
+			return value;
+		});
+		const outcome = operation.then(() => ({ ok: true }), (error) => options.bestEffort ? { ok: true } : {
+			ok: false,
+			error
+		});
+		this.pending.add(outcome);
+		outcome.then(() => this.pending.delete(outcome));
+		return operation;
+	}
+	async run(run) {
+		let rejectAbort = () => {};
+		const aborted = new Promise((_resolve, reject) => {
+			rejectAbort = reject;
+		});
+		const onAbort = () => rejectAbort(this.signal.reason);
+		this.signal.addEventListener("abort", onAbort, { once: true });
+		try {
+			this.assertActive();
+			const value = await Promise.race([run(), aborted]);
+			this.accepting = false;
+			const errors = await this.drain();
+			if (errors.length > 0) throw this.cleanupError(errors);
+			this.checkDeadline();
+			this.signal.throwIfAborted();
+			return value;
+		} catch (error) {
+			this.cancel(error);
+			const errors = await this.drain();
+			if (errors.length > 0) throw this.cleanupError([error, ...errors]);
+			throw error;
+		} finally {
+			this.accepting = false;
+			this.finished = true;
+			clearTimeout(this.timer);
+			this.signal.removeEventListener("abort", onAbort);
+		}
+	}
+	checkDeadline() {
+		if (this.deadlineAt !== void 0 && performance.now() >= this.deadlineAt) this.cancel(new TimeoutError(this.timeoutMs));
+	}
+	async drain() {
+		const errors = [];
+		while (this.pending.size > 0) for (const outcome of await Promise.all(this.pending)) if (!outcome.ok && outcome.error !== this.signal.reason) errors.push(outcome.error);
+		return [.../* @__PURE__ */ new Set([...errors, ...this.cleanupFailures.splice(0)])];
+	}
+	trackCancellation(cancel) {
+		const outcome = Promise.resolve().then(() => cancel(this.terminationSignal)).then(() => ({ ok: true }), (error) => {
+			this.cleanupFailures.push(error);
+			return { ok: true };
+		});
+		this.pending.add(outcome);
+		outcome.then(() => this.pending.delete(outcome));
+	}
+	cleanupError(errors) {
+		const reason = this.signal.reason;
+		const failures = [.../* @__PURE__ */ new Set([...this.signal.aborted ? [reason] : [], ...errors])];
+		return new AggregateError(failures, "Flow attempt cleanup failed", { cause: failures[0] });
+	}
+};
+//#endregion
 //#region src/flows/authoring.ts
 const FLOW_DEFINITION_BRAND = Symbol.for("acpx.flow.definition");
 function markDefinedFlow(definition) {
@@ -109,7 +234,7 @@ const flowDefinitionSchema = extensibleObject({
 const flowNodeTypeSchema = z.object({ nodeType: z.enum(FLOW_NODE_TYPES) });
 function assertValidFlowDefinitionShape(flow) {
 	const parsed = parseWithSchema("flow definition", flowDefinitionSchema, flow);
-	for (const [nodeId, node] of Object.entries(parsed.nodes)) assertValidFlowNodeDefinitionShape(node, `flow node "${nodeId}"`);
+	for (const [nodeId, node] of Object.entries(flow.nodes)) assertValidFlowNodeDefinitionShape(node, `flow node "${nodeId}"`);
 	parsed.edges.forEach((edge, index) => {
 		assertValidFlowEdgeShape(edge, `flow definition: edges.${index}`);
 	});
@@ -164,6 +289,8 @@ function assertValidFlowEdgeShape(edge, label) {
 		return;
 	}
 	parseWithSchema(label, switchFlowEdgeSchema, edge);
+	const cases = edge.switch.cases;
+	for (const [key, target] of Object.entries(cases)) parseWithSchema(`${label}: switch.cases.${key}`, z.string(), target);
 }
 function parseWithSchema(label, schema, value) {
 	try {
@@ -414,25 +541,11 @@ function resolveShellActionTimeoutMs(timeoutMs) {
 	if (timeoutMs == null || !(timeoutMs > 0)) return;
 	return timeoutMs;
 }
-async function withShellAbort(run, signal) {
-	signal.throwIfAborted();
-	let rejectAbort = () => {};
-	const aborted = new Promise((_resolve, reject) => {
-		rejectAbort = reject;
-	});
-	const onAbort = () => rejectAbort(signal.reason);
-	signal.addEventListener("abort", onAbort, { once: true });
-	try {
-		return await Promise.race([run(), aborted]);
-	} finally {
-		signal.removeEventListener("abort", onAbort);
-	}
-}
 function rejectIfShellFailed(spec, args, result, timedOut, timeoutMs) {
 	if (timedOut) return new TimeoutError(timeoutMs ?? spec.timeoutMs ?? 0);
 	if (((result.exitCode ?? 0) !== 0 || result.signal != null) && spec.allowNonZeroExit !== true) return createShellFailureError(spec, args, result.exitCode, result.signal, result.stderr);
 }
-function waitForShellExit(child, spec, args, cwd, startMs, timeoutMs, termination) {
+function waitForShellResult(child, spec, args, cwd, startMs, termination, mode) {
 	const stdoutStream = child.stdout;
 	const stderrStream = child.stderr;
 	if (!stdoutStream || !stderrStream) throw new Error("Shell action child is missing stdio pipes");
@@ -442,7 +555,8 @@ function waitForShellExit(child, spec, args, cwd, startMs, timeoutMs, terminatio
 			settled = true;
 			reject(error);
 		};
-		const capture = createShellOutputCapture(spec.maxBufferBytes, () => settled || termination.timedOut(), (error) => {
+		const capture = createShellOutputCapture(spec.maxBufferBytes, () => settled || mode === "node" && termination.cancelled(), (error) => {
+			if (termination.cancelled()) return;
 			fail(error);
 			termination.cancel("SIGTERM").catch(fail);
 		});
@@ -455,10 +569,10 @@ function waitForShellExit(child, spec, args, cwd, startMs, timeoutMs, terminatio
 			capture.append("stderr", chunk);
 		});
 		child.once("error", fail);
-		child.once("exit", (exitCode, signal) => {
+		child.once(mode === "node" ? "exit" : "close", (exitCode, signal) => {
 			settled = true;
 			const { stdout, stderr } = capture.output;
-			const result = {
+			resolve({
 				command: spec.command,
 				args,
 				cwd,
@@ -467,14 +581,9 @@ function waitForShellExit(child, spec, args, cwd, startMs, timeoutMs, terminatio
 				combinedOutput: `${stdout}${stderr}`,
 				exitCode,
 				signal,
-				durationMs: Date.now() - startMs
-			};
-			const error = rejectIfShellFailed(spec, args, result, termination.timedOut(), timeoutMs);
-			if (error) {
-				reject(error);
-				return;
-			}
-			resolve(result);
+				durationMs: Date.now() - startMs,
+				timedOut: mode === "node" ? termination.cancelled() : termination.timedOut()
+			});
 		});
 	});
 }
@@ -486,6 +595,7 @@ function createShellTermination(child, timeoutMs, options) {
 	});
 	let termination;
 	let timedOut = false;
+	let cancelled = false;
 	let released = false;
 	let deadline;
 	let monitor;
@@ -504,7 +614,8 @@ function createShellTermination(child, timeoutMs, options) {
 	const cancel = (signal) => {
 		if (termination) return termination;
 		if (released) return Promise.resolve();
-		timedOut = true;
+		clearDeadline();
+		cancelled = true;
 		termination = stopShellProcess(child, closed, signal).finally(release);
 		termination.catch(rejectCleanup);
 		return termination;
@@ -514,6 +625,7 @@ function createShellTermination(child, timeoutMs, options) {
 	};
 	options.signal?.addEventListener("abort", onAbort, { once: true });
 	if (timeoutMs != null) deadline = setTimeout(() => {
+		timedOut = true;
 		cancel("SIGTERM");
 	}, timeoutMs);
 	unregister = options.registerOwner?.({
@@ -532,6 +644,7 @@ function createShellTermination(child, timeoutMs, options) {
 	return {
 		cancel,
 		timedOut: () => timedOut,
+		cancelled: () => cancelled,
 		cleanupFailure,
 		async dispose() {
 			clearDeadline();
@@ -544,7 +657,16 @@ function createShellTermination(child, timeoutMs, options) {
 	};
 }
 async function runShellAction(spec, options = {}) {
-	if (options?.signal?.aborted) throw options.signal.reason;
+	const { timedOut, ...result } = await runShellProcess(spec, options, "node");
+	const failure = rejectIfShellFailed(spec, result.args, result, timedOut, resolveShellActionTimeoutMs(spec.timeoutMs));
+	if (failure) throw failure;
+	return result;
+}
+async function runShellCommand(spec, options) {
+	return await runShellProcess(spec, options, "command");
+}
+async function runShellProcess(spec, options, mode) {
+	options.signal?.throwIfAborted();
 	const cwd = spec.cwd ?? process.cwd();
 	const args = spec.args ?? [];
 	const startMs = Date.now();
@@ -566,47 +688,57 @@ async function runShellAction(spec, options = {}) {
 		detached: process.platform !== "win32"
 	});
 	const termination = createShellTermination(child, timeoutMs, options);
-	const finish = waitForShellExit(child, spec, args, cwd, startMs, timeoutMs, termination);
+	const finish = waitForShellResult(child, spec, args, cwd, startMs, termination, mode);
 	writeShellStdin(child, spec.stdin);
 	try {
-		return await Promise.race([finish, termination.cleanupFailure]);
+		const result = await Promise.race([finish, termination.cleanupFailure]);
+		throwIfShellCancelled(options.signal, mode);
+		return result;
 	} finally {
 		await termination.dispose();
 	}
 }
+function throwIfShellCancelled(signal, mode) {
+	if (!signal?.aborted) return;
+	const reason = signal.reason;
+	if (mode === "command" || reason instanceof TimeoutError || reason instanceof InterruptedError) throw reason;
+}
 //#endregion
 //#region src/flows/graph.ts
 function validateFlowDefinition(flow) {
 	assertValidFlowDefinitionShape(flow);
-	if (!flow.nodes[flow.startAt]) throw new Error(`Flow start node is missing: ${flow.startAt}`);
+	assertKnownFlowNode(flow, flow.startAt, "Flow start node is missing");
 	const outgoingEdges = /* @__PURE__ */ new Set();
 	for (const edge of flow.edges) validateFlowEdge(flow, edge, outgoingEdges);
 }
 function assertKnownFlowNode(flow, nodeId, description) {
-	if (!flow.nodes[nodeId]) throw new Error(`${description}: ${nodeId}`);
+	if (!Object.hasOwn(flow.nodes, nodeId)) throw new Error(`${description}: ${nodeId}`);
+}
+function isDirectEdge(edge) {
+	return Object.hasOwn(edge, "to");
 }
 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) {
+	if (isDirectEdge(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 canFollowEdge(edge, result) {
-	return !result || result.outcome === "ok" || "switch" in edge && edge.switch.on.startsWith("$result.");
+	return !result || result.outcome === "ok" || !isDirectEdge(edge) && edge.switch.on.startsWith("$result.");
 }
 function resolveNext(edges, from, output, result) {
 	const edge = edges.find((candidate) => candidate.from === from);
 	if (!edge || !canFollowEdge(edge, result)) return null;
-	if ("to" in edge) return edge.to;
+	if (isDirectEdge(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}`);
-	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;
+	const key = String(value);
+	if (!Object.hasOwn(edge.switch.cases, key)) throw new Error(`No flow switch case for ${edge.switch.on}=${JSON.stringify(value)}`);
+	return edge.switch.cases[key];
 }
 function getBySwitchPath(output, result, jsonPath) {
 	if (jsonPath.startsWith("$result.")) return getByPath(result, `$.${jsonPath.slice(8)}`);
@@ -707,11 +839,19 @@ function summarizePrompt(promptText, explicitDetail) {
 }
 function createQuietCaptureOutput() {
 	const chunks = [];
+	let sessionId;
+	const formatter = createOutputFormatter("quiet", { stdout: { write(chunk) {
+		chunks.push(chunk);
+	} } });
+	const setContext = formatter.setContext.bind(formatter);
+	formatter.setContext = (context) => {
+		sessionId = context.sessionId ?? sessionId;
+		setContext(context);
+	};
 	return {
-		formatter: createOutputFormatter("quiet", { stdout: { write(chunk) {
-			chunks.push(chunk);
-		} } }),
-		read: () => chunks.join("").trim()
+		formatter,
+		read: () => chunks.join("").trim(),
+		sessionId: () => sessionId
 	};
 }
 async function resolveFlowRunTitle(flow, input, flowPath) {
@@ -730,8 +870,13 @@ function normalizeFlowRunTitle(value) {
 function createRunId(flowName) {
 	return `${isoNow$1().replaceAll(":", "").replaceAll(".", "")}-${slugifyAsciiIdPart(flowName)}-${randomUUID().slice(0, 8)}`;
 }
-function createSessionBindingKey(agentCommand, cwd, handle) {
-	return `${agentCommand}::${cwd}::${handle}`;
+function createSessionBindingKey(agentCommand, cwd, handle, agentArgv) {
+	return JSON.stringify([
+		agentCommand,
+		agentArgv ?? null,
+		cwd,
+		handle
+	]);
 }
 function createSessionName(flowName, handle, cwd, runId) {
 	return `${flowName}-${handle}-${stableShortHash(cwd)}-${runId.slice(-8)}`;
@@ -909,10 +1054,15 @@ var FlowRunStore = class {
 	traceSeqByRun = /* @__PURE__ */ new Map();
 	sessionSeqByBundle = /* @__PURE__ */ new Map();
 	manifestByRun = /* @__PURE__ */ new Map();
-	appendChainByPath = /* @__PURE__ */ new Map();
+	writeChainByPath = /* @__PURE__ */ new Map();
 	constructor(outputRoot = flowRunsBaseDir()) {
 		this.outputRoot = outputRoot;
 	}
+	releaseRun(runDir) {
+		this.traceSeqByRun.delete(runDir);
+		this.manifestByRun.delete(runDir);
+		for (const key of this.sessionSeqByBundle.keys()) if (key.startsWith(`${runDir}::`)) this.sessionSeqByBundle.delete(key);
+	}
 	async createRunDir(runId) {
 		const runDir = path.join(this.outputRoot, runId);
 		await fs.mkdir(path.join(runDir, PROJECTIONS_DIR), {
@@ -1002,57 +1152,65 @@ var FlowRunStore = class {
 		});
 		return artifact;
 	}
-	async ensureSessionBundle(runDir, state, binding, record) {
+	async ensureSessionBundle(runDir, state, inputBinding, record) {
+		const binding = structuredClone(inputBinding);
 		const sessionDir = this.resolveRunPath(runDir, sessionDirPath(binding.bundleId));
-		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);
-		const isNew = !manifest.sessions.find((entry) => entry.id === binding.bundleId);
-		if (isNew) {
-			const entry = {
-				id: binding.bundleId,
-				handle: binding.handle,
-				bindingPath: path.posix.join(sessionDirPath(binding.bundleId), "binding.json"),
-				recordPath: path.posix.join(sessionDirPath(binding.bundleId), "record.json"),
-				eventsPath: path.posix.join(sessionDirPath(binding.bundleId), "events.ndjson")
-			};
-			manifest.sessions.push(entry);
-			await writePrivateJsonFile(this.resolveRunPath(runDir, MANIFEST_PATH), manifest);
-		}
-		if (isNew) await this.appendTrace(runDir, state, {
-			scope: "session",
-			type: "session_bound",
-			sessionId: binding.bundleId,
-			payload: {
-				sessionId: binding.bundleId,
-				handle: binding.handle,
-				bindingArtifact: {
-					path: path.posix.join(sessionDirPath(binding.bundleId), "binding.json"),
+		await this.serializeWrite(path.join(sessionDir, "binding.json"), async () => {
+			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);
+			if (!manifest.sessions.find((entry) => entry.id === binding.bundleId)) {
+				const bindingArtifact = await this.writeArtifact(runDir, state, binding, {
 					mediaType: "application/json",
-					sha256: await fileSha256(path.join(sessionDir, "binding.json"))
-				}
+					extension: "json",
+					emitTrace: false
+				});
+				const entry = {
+					id: binding.bundleId,
+					handle: binding.handle,
+					bindingPath: path.posix.join(sessionDirPath(binding.bundleId), "binding.json"),
+					recordPath: path.posix.join(sessionDirPath(binding.bundleId), "record.json"),
+					eventsPath: path.posix.join(sessionDirPath(binding.bundleId), "events.ndjson")
+				};
+				manifest.sessions.push(entry);
+				await writePrivateJsonFile(this.resolveRunPath(runDir, MANIFEST_PATH), manifest);
+				await this.appendTrace(runDir, state, {
+					scope: "session",
+					type: "session_bound",
+					sessionId: binding.bundleId,
+					payload: {
+						sessionId: binding.bundleId,
+						handle: binding.handle,
+						bindingArtifact
+					}
+				});
 			}
 		});
 	}
 	async writeSessionRecord(runDir, _state, binding, record) {
-		const bundledRecord = createBundledSessionRecord(binding, record, this.sessionSeqByBundle.get(`${runDir}::${binding.bundleId}`) ?? 0);
+		const bundledRecord = createBundledSessionRecord(binding, record, this.sessionSeqByBundle.get(`${runDir}::${binding.bundleId}`)?.persisted ?? 0);
 		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}`;
-		const seq = (this.sessionSeqByBundle.get(sessionKey) ?? 0) + 1;
-		this.sessionSeqByBundle.set(sessionKey, seq);
+		const sequence = this.sessionSeqByBundle.get(sessionKey) ?? {
+			allocated: 0,
+			persisted: 0
+		};
+		this.sessionSeqByBundle.set(sessionKey, sequence);
+		const seq = ++sequence.allocated;
 		await this.appendJsonLine(this.resolveRunPath(runDir, path.posix.join(sessionDirPath(binding.bundleId), "events.ndjson")), {
 			seq,
 			at: isoNow(),
 			direction,
 			message
 		});
+		sequence.persisted = Math.max(sequence.persisted, seq);
 		return seq;
 	}
 	getManifest(runDir, state) {
@@ -1083,7 +1241,7 @@ var FlowRunStore = class {
 		return path.join(runDir, ...relativePath.split("/"));
 	}
 	async appendJsonLine(filePath, value) {
-		const tracked = (this.appendChainByPath.get(filePath) ?? Promise.resolve()).then(async () => {
+		await this.serializeWrite(filePath, async () => {
 			await fs.mkdir(path.dirname(filePath), {
 				recursive: true,
 				mode: 448
@@ -1093,10 +1251,13 @@ var FlowRunStore = class {
 				content: `${JSON.stringify(value)}\n`,
 				mode: 384
 			});
-		}).finally(() => {
-			if (this.appendChainByPath.get(filePath) === tracked) this.appendChainByPath.delete(filePath);
 		});
-		this.appendChainByPath.set(filePath, tracked);
+	}
+	async serializeWrite(filePath, write) {
+		const tracked = (this.writeChainByPath.get(filePath) ?? Promise.resolve()).then(write).finally(() => {
+			if (this.writeChainByPath.get(filePath) === tracked) this.writeChainByPath.delete(filePath);
+		});
+		this.writeChainByPath.set(filePath, tracked);
 		await tracked;
 	}
 };
@@ -1229,10 +1390,6 @@ async function ensureFile(filePath) {
 		mode: 384
 	});
 }
-async function fileSha256(filePath) {
-	const payload = await fs.readFile(filePath);
-	return createHash("sha256").update(payload).digest("hex");
-}
 function toArtifactBuffer(content, mediaType) {
 	if (typeof content === "string") return Buffer.from(content, "utf8");
 	if (Buffer.isBuffer(content)) return content;
@@ -1254,6 +1411,14 @@ function isoNow() {
 //#region src/flows/runtime.ts
 const DEFAULT_FLOW_HEARTBEAT_MS = 5e3;
 const DEFAULT_FLOW_STEP_TIMEOUT_MS = 9e5;
+function setNodeValue(values, nodeId, value) {
+	Object.defineProperty(values, nodeId, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+}
 var FlowRunner = class {
 	resolveAgent;
 	defaultCwd;
@@ -1264,7 +1429,8 @@ var FlowRunner = class {
 	services;
 	store;
 	pendingPersistentSessionClients = /* @__PURE__ */ new Map();
-	shellInterrupts = /* @__PURE__ */ new Map();
+	attempts = /* @__PURE__ */ new Map();
+	pendingClientReleases = /* @__PURE__ */ new WeakMap();
 	runInterruptions = /* @__PURE__ */ new Map();
 	shellOwners = /* @__PURE__ */ new Map();
 	constructor(options) {
@@ -1305,23 +1471,27 @@ var FlowRunner = class {
 			steps: [],
 			sessionBindings: {}
 		};
-		const inputArtifact = await this.store.writeArtifact(runDir, state, input, {
-			mediaType: "application/json",
-			extension: "json",
-			emitTrace: false
-		});
-		await this.store.initializeRunBundle(runDir, {
-			flow,
-			state,
-			inputArtifact
-		});
 		try {
-			return await this.runWithShellOwnership(flow, input, runDir, state);
+			const inputArtifact = await this.store.writeArtifact(runDir, state, input, {
+				mediaType: "application/json",
+				extension: "json",
+				emitTrace: false
+			});
+			await this.store.initializeRunBundle(runDir, {
+				flow,
+				state,
+				inputArtifact
+			});
+			return await this.runWithOwnership(flow, input, runDir, state);
 		} finally {
-			await this.closePendingPersistentSessionClients();
+			try {
+				await this.closePendingPersistentSessionClients(runDir);
+			} finally {
+				this.store.releaseRun(runDir);
+			}
 		}
 	}
-	async runWithShellOwnership(flow, input, runDir, state) {
+	async runWithOwnership(flow, input, runDir, state) {
 		let execution;
 		let cancellation;
 		let interruption;
@@ -1334,11 +1504,8 @@ var FlowRunner = class {
 			this.runInterruptions.set(runDir, reason);
 			cancellation ??= this.cancelShellOwners(runDir, signal);
 			cancellation.catch(() => {});
-			const interruptShell = this.shellInterrupts.get(runDir);
-			if (interruptShell) {
-				interruptShell(reason, signal);
-				await execution?.catch(() => {});
-			}
+			this.attempts.get(runDir)?.cancel(reason, signal);
+			await execution?.catch(() => {});
 		}).then((value) => ({
 			ok: true,
 			value
@@ -1390,7 +1557,7 @@ var FlowRunner = class {
 		let current = flow.startAt;
 		const attemptCounts = /* @__PURE__ */ new Map();
 		try {
-			while (current) {
+			while (current !== null) {
 				this.throwIfRunInterrupted(runDir);
 				const step = await this.executeFlowStep(flow, input, runDir, state, current, attemptCounts);
 				this.throwIfRunInterrupted(runDir, step.executionError);
@@ -1412,21 +1579,33 @@ var FlowRunner = class {
 		if (interrupted) throw error ?? interrupted;
 	}
 	async executeFlowStep(flow, input, runDir, state, nodeId, attemptCounts) {
+		if (!Object.hasOwn(flow.nodes, nodeId)) throw new Error(`Unknown flow node: ${nodeId}`);
 		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);
-		const context = makeFlowNodeContext(state, input, this.services);
+		const attempt = new FlowAttempt({
+			nodeId,
+			attemptId,
+			startedAt,
+			timeoutMs: node.timeoutMs ?? this.defaultNodeTimeoutMs
+		});
+		this.attempts.set(runDir, attempt);
+		const context = this.makeAttemptContext(runDir, state, input, node, attempt);
+		let stopHeartbeat = () => {};
 		let executed;
 		let outcome = "ok";
 		let executionError;
 		try {
 			this.throwIfRunInterrupted(runDir);
-			executed = await this.executeNode(runDir, state, flow, nodeId, node, context);
+			executed = await attempt.run(async () => {
+				await attempt.own(() => this.writeNodeStartedSnapshot(runDir, state, nodeId, attemptId, node));
+				stopHeartbeat = this.startHeartbeat(runDir, state, node, attempt);
+				const result = await this.executeNode(runDir, state, flow, nodeId, node, context);
+				result.trace = await attempt.own(() => finalizeStepTrace(this.store, runDir, state, nodeId, attemptId, result.output, result.trace));
+				return result;
+			});
 			this.throwIfRunInterrupted(runDir);
-			executed.trace = await finalizeStepTrace(this.store, runDir, state, nodeId, attemptId, executed.output, executed.trace);
 		} catch (error) {
 			outcome = outcomeForError(error);
 			executionError = error;
@@ -1436,8 +1615,12 @@ var FlowRunner = class {
 				rawText: null,
 				sessionInfo: null,
 				agentInfo: null,
-				trace: await finalizeStepTrace(this.store, runDir, state, nodeId, attemptId, void 0, extractAttachedStepTrace(error) ?? null)
+				...context.acpResult,
+				trace: await finalizeStepTrace(this.store, runDir, state, nodeId, attemptId, void 0, context.acpResult ? context.acpResult.trace : extractAttachedStepTrace(error) ?? null)
 			};
+		} finally {
+			stopHeartbeat();
+			this.attempts.delete(runDir);
 		}
 		const nodeResult = createNodeResult({
 			attemptId,
@@ -1448,7 +1631,7 @@ var FlowRunner = class {
 			finishedAt: isoNow$1(),
 			...outcome === "ok" ? { output: executed.output } : { error: executionError instanceof Error ? executionError.message : String(executionError) }
 		});
-		state.results[nodeId] = nodeResult;
+		setNodeValue(state.results, nodeId, nodeResult);
 		return {
 			...executed,
 			nodeResult,
@@ -1460,6 +1643,17 @@ var FlowRunner = class {
 			state
 		};
 	}
+	makeAttemptContext(runDir, state, input, node, attempt) {
+		const context = {
+			nodeContext: {
+				...makeFlowNodeContext(state, input, this.services),
+				signal: attempt.signal
+			},
+			attempt
+		};
+		if (node.nodeType === "action" && "run" in node) context.nodeContext.runShell = (execution) => this.runCallbackShell(runDir, attempt, execution);
+		return context;
+	}
 	async writeNodeStartedSnapshot(runDir, state, nodeId, attemptId, node) {
 		await this.store.writeSnapshot(runDir, state, {
 			scope: "node",
@@ -1475,7 +1669,7 @@ var FlowRunner = class {
 	}
 	async maybeCompleteCheckpointStep(runDir, state, step) {
 		if (step.nodeResult.outcome !== "ok" || step.node.nodeType !== "checkpoint") return;
-		state.outputs[step.nodeId] = step.output;
+		setNodeValue(state.outputs, step.nodeId, step.output);
 		state.waitingOn = step.nodeId;
 		state.updatedAt = isoNow$1();
 		state.status = "waiting";
@@ -1487,11 +1681,11 @@ var FlowRunner = class {
 	}
 	resolveNextNode(flow, step) {
 		if (step.nodeResult.outcome === "ok") {
-			step.state.outputs[step.nodeId] = step.output;
+			setNodeValue(step.state.outputs, step.nodeId, step.output);
 			return resolveNext(flow.edges, step.nodeId, step.output, step.nodeResult);
 		}
 		const next = resolveNext(flow.edges, step.nodeId, void 0, step.nodeResult);
-		if (next) return next;
+		if (next !== null) return next;
 		throw step.executionError;
 	}
 	async completeFlowRun(runDir, state) {
@@ -1537,19 +1731,22 @@ var FlowRunner = class {
 	}
 	async executeNode(runDir, state, flow, nodeId, node, context) {
 		switch (node.nodeType) {
-			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 "compute": return await this.executeCallbackNode(nodeId, node, context);
+			case "action": return "run" in node ? await this.executeCallbackNode(nodeId, node, context) : await this.executeShellNode(runDir, state, node, context);
+			case "checkpoint": return await this.executeCallbackNode(nodeId, node, context);
 			case "acp": return await this.executeAcpNode(runDir, state, flow, node, context);
 			default: throw new Error(`Unsupported flow node: ${String(node)}`);
 		}
 	}
-	async executeCallbackNode(runDir, state, nodeId, node, context) {
+	async executeCallbackNode(nodeId, node, context) {
+		context.attempt.assertActive();
+		const output = node.nodeType === "checkpoint" && typeof node.run !== "function" ? {
+			checkpoint: nodeId,
+			summary: node.summary ?? nodeId
+		} : await node.run?.(context.nodeContext);
+		context.attempt.assertActive();
 		return {
-			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)),
+			output,
 			promptText: null,
 			rawText: null,
 			sessionInfo: null,
@@ -1558,186 +1755,173 @@ var FlowRunner = class {
 		};
 	}
 	async executeShellNode(runDir, state, node, context) {
-		const nodeTimeoutMs = node.timeoutMs ?? this.defaultNodeTimeoutMs;
-		const shellAbort = new AbortController();
-		let runningOwner;
-		const shellControl = {
-			signal: shellAbort.signal,
-			registerOwner: (owner) => {
-				runningOwner = owner;
-				return this.registerShellOwner(runDir, owner);
-			}
+		const attempt = context.attempt;
+		const execution = await node.exec(context.nodeContext);
+		attempt.assertActive();
+		const effectiveExecution = {
+			...execution,
+			cwd: resolveShellActionCwd(this.defaultCwd, execution.cwd),
+			timeoutMs: resolveShellActionTimeoutMs(execution.timeoutMs ?? attempt.remainingTimeoutMs())
 		};
-		this.shellInterrupts.set(runDir, (reason, signal) => {
-			shellControl.terminationSignal = signal;
-			shellAbort.abort(reason);
-		});
-		let runningShell;
-		const { output, rawText, trace } = await this.runWithHeartbeat(runDir, state, state.currentNode ?? "", node, nodeTimeoutMs, () => withShellAbort(async () => {
-			const execution = await Promise.resolve(node.exec(context));
-			shellAbort.signal.throwIfAborted();
-			const effectiveExecution = {
-				...execution,
-				cwd: resolveShellActionCwd(this.defaultCwd, execution.cwd),
-				timeoutMs: resolveShellActionTimeoutMs(execution.timeoutMs ?? nodeTimeoutMs)
-			};
-			updateStatusDetail(state, formatShellActionSummary(effectiveExecution));
-			await this.store.writeLive(runDir, state, {
-				scope: "node",
-				type: "node_heartbeat",
-				nodeId: state.currentNode,
-				attemptId: state.currentAttemptId,
-				payload: { statusDetail: state.statusDetail }
-			});
-			shellAbort.signal.throwIfAborted();
-			await this.store.appendTrace(runDir, state, {
-				scope: "action",
-				type: "action_prepared",
-				nodeId: state.currentNode,
-				attemptId: state.currentAttemptId,
-				payload: { action: {
-					actionType: "shell",
-					command: effectiveExecution.command,
-					args: effectiveExecution.args ?? [],
-					cwd: effectiveExecution.cwd
-				} }
-			});
-			runningShell = runShellAction(effectiveExecution, shellControl);
-			const result = await runningShell;
-			shellAbort.signal.throwIfAborted();
-			const stdoutArtifact = await this.store.writeArtifact(runDir, state, result.stdout, {
-				mediaType: "text/plain",
-				extension: "txt",
-				nodeId: state.currentNode,
-				attemptId: state.currentAttemptId
-			});
-			const stderrArtifact = await this.store.writeArtifact(runDir, state, result.stderr, {
-				mediaType: "text/plain",
-				extension: "txt",
-				nodeId: state.currentNode,
-				attemptId: state.currentAttemptId
-			});
-			shellAbort.signal.throwIfAborted();
-			await this.store.appendTrace(runDir, state, {
-				scope: "action",
-				type: "action_completed",
-				nodeId: state.currentNode,
-				attemptId: state.currentAttemptId,
-				payload: {
-					action: {
-						actionType: "shell",
-						command: result.command,
-						args: result.args,
-						cwd: result.cwd,
-						exitCode: result.exitCode,
-						signal: result.signal,
-						durationMs: result.durationMs
-					},
-					stdoutArtifact,
-					stderrArtifact
-				}
-			});
-			const trace = {
-				action: {
-					actionType: "shell",
-					command: result.command,
-					args: result.args,
-					cwd: result.cwd,
-					exitCode: result.exitCode,
-					signal: result.signal,
-					durationMs: result.durationMs
-				},
+		updateStatusDetail(state, formatShellActionSummary(effectiveExecution));
+		await attempt.own(() => this.store.writeLive(runDir, state, {
+			scope: "node",
+			type: "node_heartbeat",
+			nodeId: attempt.nodeId,
+			attemptId: attempt.attemptId,
+			payload: { statusDetail: state.statusDetail }
+		}));
+		await attempt.own(() => this.store.appendTrace(runDir, state, {
+			scope: "action",
+			type: "action_prepared",
+			nodeId: attempt.nodeId,
+			attemptId: attempt.attemptId,
+			payload: { action: {
+				actionType: "shell",
+				command: effectiveExecution.command,
+				args: effectiveExecution.args ?? [],
+				cwd: effectiveExecution.cwd
+			} }
+		}));
+		const result = await attempt.own(() => runShellAction(effectiveExecution, this.shellControl(runDir, attempt)));
+		const stdoutArtifact = await attempt.own(() => this.store.writeArtifact(runDir, state, result.stdout, {
+			mediaType: "text/plain",
+			extension: "txt",
+			nodeId: attempt.nodeId,
+			attemptId: attempt.attemptId
+		}));
+		const stderrArtifact = await attempt.own(() => this.store.writeArtifact(runDir, state, result.stderr, {
+			mediaType: "text/plain",
+			extension: "txt",
+			nodeId: attempt.nodeId,
+			attemptId: attempt.attemptId
+		}));
+		const actionTrace = {
+			actionType: "shell",
+			command: result.command,
+			args: result.args,
+			cwd: result.cwd,
+			exitCode: result.exitCode,
+			signal: result.signal,
+			durationMs: result.durationMs
+		};
+		await attempt.own(() => this.store.appendTrace(runDir, state, {
+			scope: "action",
+			type: "action_completed",
+			nodeId: attempt.nodeId,
+			attemptId: attempt.attemptId,
+			payload: {
+				action: actionTrace,
 				stdoutArtifact,
 				stderrArtifact
-			};
-			shellAbort.signal.throwIfAborted();
-			let parsedOutput;
-			try {
-				parsedOutput = node.parse ? await node.parse(result, context) : result;
-				shellAbort.signal.throwIfAborted();
-			} catch (error) {
-				throw attachStepTrace(error, trace);
-			}
-			return {
-				output: parsedOutput,
-				rawText: result.combinedOutput,
-				trace
-			};
-		}, shellAbort.signal)).catch(async (error) => {
-			shellAbort.abort(error);
-			try {
-				await runningOwner?.cancel(shellControl.terminationSignal ?? "SIGTERM");
-				await runningShell;
-			} catch (cleanupError) {
-				if (!(cleanupError instanceof TimeoutError) && cleanupError !== error) throw new AggregateError([error, cleanupError], "Shell action cleanup failed", { cause: cleanupError });
 			}
-			throw error;
-		}).finally(() => {
-			this.shellInterrupts.delete(runDir);
-		});
+		}));
+		const trace = {
+			action: actionTrace,
+			stdoutArtifact,
+			stderrArtifact
+		};
+		let output;
+		try {
+			output = node.parse ? await node.parse(result, context.nodeContext) : result;
+			attempt.assertActive();
+		} catch (error) {
+			throw attachStepTrace(error, trace);
+		}
 		return {
 			output,
 			promptText: null,
-			rawText,
+			rawText: result.combinedOutput,
 			sessionInfo: null,
 			agentInfo: null,
 			trace
 		};
 	}
+	shellControl(runDir, attempt) {
+		return {
+			signal: attempt.signal,
+			get terminationSignal() {
+				return attempt.terminationSignal;
+			},
+			registerOwner: (owner) => {
+				const releaseAttempt = attempt.registerCancellation((signal) => owner.cancel(signal));
+				const releaseRun = this.registerShellOwner(runDir, owner);
+				return () => {
+					releaseAttempt();
+					releaseRun();
+				};
+			}
+		};
+	}
+	runCallbackShell(runDir, attempt, execution) {
+		return attempt.own(() => runShellCommand({
+			...execution,
+			cwd: resolveShellActionCwd(this.defaultCwd, execution.cwd)
+		}, this.shellControl(runDir, attempt)));
+	}
 	async executeAcpNode(runDir, state, flow, node, context) {
-		const nodeTimeoutMs = node.timeoutMs ?? this.defaultNodeTimeoutMs;
-		let boundSession = null;
-		return await this.runWithHeartbeat(runDir, state, state.currentNode ?? "", node, nodeTimeoutMs, async () => {
-			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 });
-		});
+		const attempt = context.attempt;
+		const prepared = await this.prepareAcpPrompt(runDir, state, node, context);
+		if (node.session?.isolated) return await this.executeIsolatedAcpPrompt(runDir, state, flow, node, context, prepared);
+		const boundSession = await this.ensureSessionBinding(runDir, state, flow, node, prepared.agentInfo, attempt);
+		return await this.executePersistentAcpPrompt(runDir, state, node, context, prepared, boundSession);
 	}
-	async prepareAcpPrompt(runDir, state, node, context, nodeTimeoutMs) {
+	async prepareAcpPrompt(runDir, state, node, context) {
 		const resolvedAgent = this.resolveAgent(node.profile);
 		const agentInfo = {
 			...resolvedAgent,
-			cwd: await resolveNodeCwd(resolvedAgent.cwd, node.cwd, context)
+			agentArgv: resolvedAgent.agentArgv?.slice(),
+			cwd: await resolveNodeCwd(resolvedAgent.cwd, node.cwd, context.nodeContext)
 		};
-		const prompt = normalizePromptInput(await Promise.resolve(node.prompt(context)));
+		context.attempt.assertActive();
+		const prompt = normalizePromptInput(await Promise.resolve(node.prompt(context.nodeContext)));
+		context.attempt.assertActive();
 		const promptText = promptToDisplayText(prompt);
+		const result = {
+			output: void 0,
+			promptText,
+			rawText: null,
+			sessionInfo: null,
+			agentInfo,
+			trace: null
+		};
+		context.acpResult = result;
 		updateStatusDetail(state, summarizePrompt(promptText, node.statusDetail));
-		await this.writeAcpPromptHeartbeat(runDir, state);
+		await context.attempt.own(() => this.writeAcpPromptHeartbeat(runDir, state, context.attempt));
+		const promptArtifact = await context.attempt.own(() => this.store.writeArtifact(runDir, state, promptText, {
+			mediaType: "text/plain",
+			extension: "txt",
+			nodeId: context.attempt.nodeId,
+			attemptId: context.attempt.attemptId
+		}));
+		result.trace = { promptArtifact };
 		return {
 			agentInfo,
 			prompt,
-			promptText,
-			promptArtifact: await this.store.writeArtifact(runDir, state, promptText, {
-				mediaType: "text/plain",
-				extension: "txt",
-				nodeId: state.currentNode,
-				attemptId: state.currentAttemptId
-			}),
-			nodeTimeoutMs
+			promptArtifact,
+			attempt: context.attempt,
+			result
 		};
 	}
-	async writeAcpPromptHeartbeat(runDir, state) {
+	async writeAcpPromptHeartbeat(runDir, state, attempt) {
 		await this.store.writeLive(runDir, state, {
 			scope: "node",
 			type: "node_heartbeat",
-			nodeId: state.currentNode,
-			attemptId: state.currentAttemptId,
+			nodeId: attempt.nodeId,
+			attemptId: attempt.attemptId,
 			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 binding = createIsolatedSessionBinding(flow.name, state.runId, prepared.attempt.attemptId, node.profile, prepared.agentInfo);
+		prepared.result.sessionInfo = binding;
+		await prepared.attempt.own(() => this.initializeIsolatedSessionBundle(runDir, state, binding, prepared.attempt));
+		await prepared.attempt.own(() => this.appendAcpPromptPreparedTrace(runDir, state, binding, prepared.promptArtifact, prepared.attempt));
+		const prompt = await prepared.attempt.own(() => this.runIsolatedPrompt(runDir, state, binding, prepared));
+		return await this.finishAcpPrompt(runDir, state, node, context, prepared, prompt);
+	}
+	async initializeIsolatedSessionBundle(runDir, state, binding, attempt) {
+		const timestamp = attempt.startedAt;
 		const initialRecord = createSyntheticSessionRecord({
 			binding,
 			createdAt: timestamp,
@@ -1749,16 +1933,17 @@ var FlowRunner = class {
 		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);
+		prepared.result.sessionInfo = binding;
+		await prepared.attempt.own(() => this.appendAcpPromptPreparedTrace(runDir, state, binding, prepared.promptArtifact, prepared.attempt));
+		const prompt = await prepared.attempt.own(() => this.runPersistentPrompt(runDir, state, binding, prepared));
+		return await this.finishAcpPrompt(runDir, state, node, context, prepared, prompt);
 	}
-	async appendAcpPromptPreparedTrace(runDir, state, binding, promptArtifact) {
+	async appendAcpPromptPreparedTrace(runDir, state, binding, promptArtifact, attempt) {
 		await this.store.appendTrace(runDir, state, {
 			scope: "acp",
 			type: "acp_prompt_prepared",
-			nodeId: state.currentNode,
-			attemptId: state.currentAttemptId,
+			nodeId: attempt.nodeId,
+			attemptId: attempt.attemptId,
 			sessionId: binding.bundleId,
 			payload: {
 				sessionId: binding.bundleId,
@@ -1766,107 +1951,121 @@ var FlowRunner = class {
 			}
 		});
 	}
-	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);
+	async finishAcpPrompt(runDir, state, node, context, prepared, prompt) {
+		await prepared.attempt.own(() => this.appendAcpResponseParsedTrace(runDir, state, prompt, prepared.attempt));
+		const output = await this.parseAcpOutput(node, context, prompt.rawText);
+		return {
+			...prepared.result,
+			output
+		};
+	}
+	async publishAcpCapture(runDir, state, prepared, sessionInfo, record, messageStart, rawText, events) {
+		const result = prepared.result;
+		result.sessionInfo = sessionInfo;
 		const trace = {
 			sessionId: sessionInfo.bundleId,
-			promptArtifact: prepared.promptArtifact,
-			rawResponseArtifact,
-			conversation: prompt.conversation
+			promptArtifact: prepared.promptArtifact
 		};
-		return {
-			output: await this.parseAcpOutput(node, context, prompt.rawText, trace),
-			promptText: prepared.promptText,
-			rawText: prompt.rawText,
-			sessionInfo,
-			agentInfo: prepared.agentInfo,
-			trace
+		result.trace = trace;
+		await this.store.ensureSessionBundle(runDir, state, sessionInfo);
+		await this.store.writeSessionRecord(runDir, state, sessionInfo, record);
+		if (events) trace.conversation = {
+			sessionId: sessionInfo.bundleId,
+			messageStart,
+			messageEnd: Math.max(messageStart, record.messages.length - 1),
+			...events
 		};
-	}
-	async writeAcpRawResponseArtifact(runDir, state, prompt, sessionInfo) {
-		return await this.store.writeArtifact(runDir, state, prompt.rawText, {
+		const rawResponseArtifact = await this.store.writeArtifact(runDir, state, rawText, {
 			mediaType: "text/plain",
 			extension: "txt",
-			nodeId: state.currentNode,
-			attemptId: state.currentAttemptId,
+			nodeId: prepared.attempt.nodeId,
+			attemptId: prepared.attempt.attemptId,
 			sessionId: sessionInfo.bundleId
 		});
+		trace.rawResponseArtifact = rawResponseArtifact;
+		return {
+			rawText,
+			sessionInfo,
+			conversation: trace.conversation,
+			rawResponseArtifact
+		};
 	}
-	async appendAcpResponseParsedTrace(runDir, state, prompt, sessionInfo, rawResponseArtifact) {
+	async appendAcpResponseParsedTrace(runDir, state, prompt, attempt) {
 		await this.store.appendTrace(runDir, state, {
 			scope: "acp",
 			type: "acp_response_parsed",
-			nodeId: state.currentNode,
-			attemptId: state.currentAttemptId,
-			sessionId: sessionInfo.bundleId,
+			nodeId: attempt.nodeId,
+			attemptId: attempt.attemptId,
+			sessionId: prompt.sessionInfo.bundleId,
 			payload: {
-				sessionId: sessionInfo.bundleId,
+				sessionId: prompt.sessionInfo.bundleId,
 				conversation: prompt.conversation,
-				rawResponseArtifact
+				rawResponseArtifact: prompt.rawResponseArtifact
 			}
 		});
 	}
-	async parseAcpOutput(node, context, rawText, trace) {
-		try {
-			return node.parse ? await node.parse(rawText, context) : rawText;
-		} catch (error) {
-			throw attachStepTrace(error, trace);
-		}
+	async parseAcpOutput(node, context, rawText) {
+		context.attempt.assertActive();
+		const output = node.parse ? await node.parse(rawText, context.nodeContext) : rawText;
+		context.attempt.assertActive();
+		return output;
 	}
-	async runWithHeartbeat(runDir, state, nodeId, node, timeoutMs, run, onTimeout) {
+	startHeartbeat(runDir, state, node, attempt) {
 		const heartbeatMs = Math.max(0, Math.round(node.heartbeatMs ?? DEFAULT_FLOW_HEARTBEAT_MS));
-		let timer;
-		let active = true;
-		let heartbeatPending = false;
+		if (heartbeatMs === 0) return () => {};
+		let pending = false;
 		const heartbeat = async () => {
-			if (!active || heartbeatPending) return;
-			heartbeatPending = true;
+			if (!attempt.active || pending) return;
+			pending = true;
 			try {
-				state.lastHeartbeatAt = isoNow$1();
-				state.updatedAt = state.lastHeartbeatAt;
-				await this.store.writeLive(runDir, state, {
-					scope: "node",
-					type: "node_heartbeat",
-					nodeId,
-					attemptId: state.currentAttemptId,
-					payload: { statusDetail: state.statusDetail }
-				});
-			} finally {
-				heartbeatPending = false;
+				await attempt.own(async () => {
+					state.lastHeartbeatAt = isoNow$1();
+					state.updatedAt = state.lastHeartbeatAt;
+					await this.store.writeLive(runDir, state, {
+						scope: "node",
+						type: "node_heartbeat",
+						nodeId: attempt.nodeId,
+						attemptId: attempt.attemptId,
+						payload: { statusDetail: state.statusDetail }
+					});
+				}, { bestEffort: true });
+			} catch {} finally {
+				pending = false;
 			}
 		};
-		if (heartbeatMs > 0) timer = setInterval(() => {
-			heartbeat().catch(() => {});
+		const timer = setInterval(() => {
+			heartbeat();
 		}, heartbeatMs);
-		try {
-			return await withTimeout(run(), timeoutMs);
-		} catch (error) {
-			if (error instanceof TimeoutError && onTimeout) await onTimeout().catch(() => {});
-			throw error;
-		} finally {
-			active = false;
-			if (timer) clearInterval(timer);
-		}
+		return () => clearInterval(timer);
 	}
-	async ensureSessionBinding(runDir, state, flow, node, agent, timeoutMs) {
+	async ensureSessionBinding(runDir, state, flow, node, agent, attempt) {
 		const handle = node.session?.handle ?? "main";
-		const key = createSessionBindingKey(agent.agentCommand, agent.cwd, handle);
+		const key = createSessionBindingKey(agent.agentCommand, agent.cwd, handle, agent.agentArgv);
 		const existing = state.sessionBindings[key];
 		if (existing) {
-			await this.store.ensureSessionBundle(runDir, state, existing);
+			await attempt.own(() => this.store.ensureSessionBundle(runDir, state, existing));
 			return existing;
 		}
 		const name = createSessionName(flow.name, handle, agent.cwd, state.runId);
-		const created = await createSessionWithClient({
-			agentCommand: agent.agentCommand,
-			agentArgv: agent.agentArgv,
-			cwd: agent.cwd,
-			name,
-			...this.connectionOptions,
-			timeoutMs,
-			sessionOptions: this.sessionOptions
+		const created = await attempt.own(async () => {
+			const acquired = await createSessionWithClient({
+				agentCommand: agent.agentCommand,
+				agentArgv: agent.agentArgv,
+				cwd: agent.cwd,
+				name,
+				...this.connectionOptions,
+				signal: attempt.signal,
+				handleProcessInterrupts: false,
+				sessionOptions: this.sessionOptions
+			});
+			this.pendingClientReleases.set(acquired.client, attempt.registerCancellation(async () => {
+				const clients = this.pendingPersistentSessionClients.get(runDir);
+				if (clients?.get(key) === acquired.client) clients.delete(key);
+				await acquired.client.close();
+			}));
+			return acquired;
 		});
+		attempt.assertActive();
 		const binding = {
 			key,
 			handle,
@@ -1882,31 +2081,44 @@ var FlowRunner = class {
 			agentSessionId: created.record.agentSessionId
 		};
 		state.sessionBindings[key] = binding;
-		this.pendingPersistentSessionClients.set(binding.key, created.client);
-		await this.store.ensureSessionBundle(runDir, state, binding, created.record);
+		let clients = this.pendingPersistentSessionClients.get(runDir);
+		if (!clients) {
+			clients = /* @__PURE__ */ new Map();
+			this.pendingPersistentSessionClients.set(runDir, clients);
+		}
+		clients.set(binding.key, created.client);
+		await attempt.own(() => this.store.ensureSessionBundle(runDir, state, binding, created.record));
 		return binding;
 	}
-	async refreshSessionBinding(binding) {
-		const record = await resolveSessionRecord(binding.acpxRecordId);
-		return {
-			...binding,
-			acpSessionId: record.acpSessionId,
-			agentSessionId: record.agentSessionId
-		};
-	}
 	createPromptEventCapture(runDir, binding) {
-		const pending = [];
+		const pending = /* @__PURE__ */ new Set();
+		let ordinal = 0;
+		let failure;
+		let eventStartSeq;
+		let eventEndSeq = 0;
+		const snapshot = (outcome) => ({
+			outcome,
+			events: !failure && eventStartSeq !== void 0 ? {
+				eventStartSeq,
+				eventEndSeq
+			} : void 0,
+			lastSeq: eventEndSeq
+		});
 		return {
 			onAcpMessage: (direction, message) => {
-				pending.push(this.store.appendSessionEvent(runDir, binding, direction, message).then((value) => ({
-					status: "fulfilled",
-					value
-				}), (reason) => ({
-					status: "rejected",
-					reason
-				})));
+				const index = ordinal++;
+				const write = this.store.appendSessionEvent(runDir, binding, direction, message).then((seq) => {
+					eventStartSeq = Math.min(eventStartSeq ?? seq, seq);
+					eventEndSeq = Math.max(eventEndSeq, seq);
+				}, (reason) => {
+					if (!failure || index < failure.ordinal) failure = {
+						ordinal: index,
+						reason
+					};
+				}).finally(() => pending.delete(write));
+				pending.add(write);
 			},
-			async run(operation) {
+			async run(operation, finalize) {
 				let result;
 				try {
 					result = {
@@ -1919,78 +2131,84 @@ var FlowRunner = class {
 						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);
+				await Promise.all(pending);
+				let finalized;
+				try {
+					finalized = {
+						status: "fulfilled",
+						value: await finalize(snapshot(result))
+					};
+				} catch (reason) {
+					finalized = {
+						status: "rejected",
+						reason
+					};
 				}
+				if (result.status === "rejected") throw result.reason;
+				if (failure) throw failure.reason;
 				if (eventStartSeq === void 0) throw new Error(`Missing ACP event capture for session ${binding.bundleId}`);
-				return {
-					result: result.value,
-					eventStartSeq,
-					eventEndSeq
-				};
+				if (finalized.status === "rejected") throw finalized.reason;
+				return finalized.value;
 			}
 		};
 	}
-	async runPersistentPrompt(runDir, state, binding, prompt, timeoutMs) {
+	async runPersistentPrompt(runDir, state, binding, prepared) {
+		const { attempt, prompt } = prepared;
 		const capture = createQuietCaptureOutput();
 		const beforeRecord = await resolveSessionRecord(binding.acpxRecordId);
+		attempt.assertActive();
 		const events = this.createPromptEventCapture(runDir, binding);
-		const initialClient = this.pendingPersistentSessionClients.get(binding.key);
-		if (initialClient) this.pendingPersistentSessionClients.delete(binding.key);
-		try {
-			const { eventStartSeq, eventEndSeq } = await events.run(() => sendSessionDirect({
-				sessionId: binding.acpxRecordId,
-				prompt,
-				resumePolicy: "same-session-only",
-				...this.connectionOptions,
-				outputFormatter: capture.formatter,
-				errorEmissionPolicy: { queueErrorAlreadyEmitted: false },
-				onAcpMessage: events.onAcpMessage,
-				suppressSdkConsoleErrors: this.suppressSdkConsoleErrors,
-				timeoutMs,
-				client: initialClient
-			}));
-			const sessionInfo = await this.refreshSessionBinding(binding);
-			state.sessionBindings[sessionInfo.key] = sessionInfo;
-			await this.store.ensureSessionBundle(runDir, state, sessionInfo);
-			const afterRecord = await resolveSessionRecord(sessionInfo.acpxRecordId);
-			await this.store.writeSessionRecord(runDir, state, sessionInfo, afterRecord);
-			const messageStartResolved = findConversationDeltaStart(beforeRecord.messages, afterRecord.messages);
-			return {
-				rawText: capture.read(),
-				sessionInfo,
-				conversation: {
-					sessionId: sessionInfo.bundleId,
-					messageStart: messageStartResolved,
-					messageEnd: Math.max(messageStartResolved, afterRecord.messages.length - 1),
-					eventStartSeq,
-					eventEndSeq
-				}
-			};
-		} finally {
-			if (initialClient) await initialClient.close().catch(() => {});
+		const clients = this.pendingPersistentSessionClients.get(runDir);
+		const initialClient = clients?.get(binding.key);
+		if (initialClient) {
+			clients?.delete(binding.key);
+			this.pendingClientReleases.get(initialClient)?.();
+			this.pendingClientReleases.delete(initialClient);
 		}
+		return await events.run(() => sendSessionDirect({
+			sessionId: binding.acpxRecordId,
+			prompt,
+			resumePolicy: "same-session-only",
+			...this.connectionOptions,
+			outputFormatter: capture.formatter,
+			errorEmissionPolicy: { queueErrorAlreadyEmitted: false },
+			onAcpMessage: events.onAcpMessage,
+			suppressSdkConsoleErrors: this.suppressSdkConsoleErrors,
+			client: initialClient
+		}, {
+			signal: attempt.signal,
+			handleProcessInterrupts: false
+		}), async (receipt) => {
+			const rawText = capture.read();
+			prepared.result.rawText = rawText;
+			const afterRecord = await resolveSessionRecord(binding.acpxRecordId);
+			const sessionInfo = {
+				...binding,
+				acpSessionId: afterRecord.acpSessionId,
+				agentSessionId: afterRecord.agentSessionId
+			};
+			state.sessionBindings[sessionInfo.key] = sessionInfo;
+			return await this.publishAcpCapture(runDir, state, prepared, sessionInfo, afterRecord, findConversationDeltaStart(beforeRecord.messages, afterRecord.messages), rawText, receipt.events);
+		});
 	}
-	async closePendingPersistentSessionClients() {
-		const pendingClients = [...this.pendingPersistentSessionClients.values()];
-		this.pendingPersistentSessionClients.clear();
-		await Promise.all(pendingClients.map(async (client) => {
-			await client.close().catch(() => {});
-		}));
-	}
-	async runIsolatedPrompt(runDir, state, binding, agent, prompt, timeoutMs) {
+	async closePendingPersistentSessionClients(runDir) {
+		const pendingClients = [...this.pendingPersistentSessionClients.get(runDir)?.values() ?? []];
+		this.pendingPersistentSessionClients.delete(runDir);
+		const failure = (await Promise.allSettled(pendingClients.map(async (client) => {
+			this.pendingClientReleases.get(client)?.();
+			this.pendingClientReleases.delete(client);
+			await client.close();
+		}))).find((result) => result.status === "rejected");
+		if (failure?.status === "rejected") throw failure.reason;
+	}
+	async runIsolatedPrompt(runDir, state, binding, prepared) {
+		const { agentInfo: agent, prompt, attempt } = prepared;
 		const capture = createQuietCaptureOutput();
-		const conversation = createSessionConversation(state.currentNodeStartedAt ?? isoNow$1());
+		const conversation = createSessionConversation(attempt.startedAt);
 		let acpxState;
-		recordPromptSubmission(conversation, prompt, state.currentNodeStartedAt ?? isoNow$1());
+		recordPromptSubmission(conversation, prompt, attempt.startedAt);
 		const events = this.createPromptEventCapture(runDir, binding);
-		const { result, eventStartSeq, eventEndSeq } = await events.run(() => runOnce({
+		return await events.run(() => runOnce({
 			agentCommand: agent.agentCommand,
 			agentArgv: agent.agentArgv,
 			cwd: agent.cwd,
@@ -2006,35 +2224,29 @@ var FlowRunner = class {
 				acpxState = recordClientOperation(conversation, acpxState, operation);
 			},
 			suppressSdkConsoleErrors: this.suppressSdkConsoleErrors,
-			timeoutMs,
 			sessionOptions: this.sessionOptions
-		}));
-		const sessionInfo = {
-			...binding,
-			acpxRecordId: result.sessionId,
-			acpSessionId: result.sessionId
-		};
-		await this.store.ensureSessionBundle(runDir, state, sessionInfo);
-		const syntheticRecord = createSyntheticSessionRecord({
-			binding: sessionInfo,
-			createdAt: state.currentNodeStartedAt ?? isoNow$1(),
-			updatedAt: conversation.updated_at,
-			conversation,
-			acpxState: cloneSessionAcpxState(acpxState),
-			lastSeq: eventEndSeq
+		}, {
+			signal: attempt.signal,
+			handleProcessInterrupts: false
+		}), async (receipt) => {
+			const rawText = capture.read();
+			prepared.result.rawText = rawText;
+			const sessionId = receipt.outcome.status === "fulfilled" ? receipt.outcome.value.sessionId : capture.sessionId();
+			const sessionInfo = sessionId === void 0 ? binding : {
+				...binding,
+				acpxRecordId: sessionId,
+				acpSessionId: sessionId
+			};
+			const record = createSyntheticSessionRecord({
+				binding: sessionInfo,
+				createdAt: attempt.startedAt,
+				updatedAt: conversation.updated_at,
+				conversation,
+				acpxState: cloneSessionAcpxState(acpxState),
+				lastSeq: receipt.lastSeq
+			});
+			return await this.publishAcpCapture(runDir, state, prepared, sessionInfo, record, 0, rawText, receipt.events);
 		});
-		await this.store.writeSessionRecord(runDir, state, sessionInfo, syntheticRecord);
-		return {
-			rawText: capture.read(),
-			sessionInfo,
-			conversation: {
-				sessionId: sessionInfo.bundleId,
-				messageStart: 0,
-				messageEnd: Math.max(0, conversation.messages.length - 1),
-				eventStartSeq,
-				eventEndSeq
-			}
-		};
 	}
 };
 //#endregion
@@ -2064,9 +2276,23 @@ function parseFencedJsonIfAllowed(text, mode) {
 	const fencedText = extractFencedJsonText(text);
 	return fencedText === null ? { ok: false } : tryParse(fencedText);
 }
+const COMPAT_JSON_WORK_MULTIPLIER = 8;
+function consumeRecoveryWork(budget, units) {
+	if (units > budget.remaining) {
+		budget.remaining = 0;
+		return false;
+	}
+	budget.remaining -= units;
+	return true;
+}
 function parseBalancedJsonCandidate(text) {
-	for (const candidate of extractBalancedJsonCandidates(text)) {
-		const parsed = tryParse(candidate);
+	const budget = { remaining: text.length * COMPAT_JSON_WORK_MULTIPLIER };
+	for (let index = 0; index < text.length && budget.remaining > 0; index += 1) {
+		if (text[index] !== "{" && text[index] !== "[") continue;
+		const end = scanBalanced(text, index, budget);
+		if (end === null) continue;
+		if (!consumeRecoveryWork(budget, end - index)) return { ok: false };
+		const parsed = tryParse(text.slice(index, end));
 		if (parsed.ok) return parsed;
 	}
 	return { ok: false };
@@ -2100,20 +2326,12 @@ function extractFencedJsonText(text) {
 function isFenceWhitespace(char) {
 	return char === " " || char === "\n" || char === "\r" || char === "	";
 }
-function extractBalancedJsonCandidates(text) {
-	const candidates = [];
-	for (let index = 0; index < text.length; index += 1) {
-		if (text[index] !== "{" && text[index] !== "[") continue;
-		const result = scanBalanced(text, index);
-		if (result) candidates.push(result);
-	}
-	return candidates;
-}
-function scanBalanced(text, startIndex) {
+function scanBalanced(text, startIndex, budget) {
 	const stack = [];
 	let inString = false;
 	let escaped = false;
 	for (let index = startIndex; index < text.length; index += 1) {
+		if (!consumeRecoveryWork(budget, 1)) return null;
 		const char = text[index];
 		if (inString) {
 			const next = scanStringChar(char, escaped);
@@ -2125,13 +2343,13 @@ function scanBalanced(text, startIndex) {
 			inString = true;
 			continue;
 		}
-		const result = scanBalancedToken(text, startIndex, index, char, stack);
+		const result = scanBalancedToken(index, char, stack);
 		if (result !== SCAN_CONTINUE) return result;
 	}
 	return null;
 }
 const SCAN_CONTINUE = Symbol("scan-continue");
-function scanBalancedToken(text, startIndex, index, char, stack) {
+function scanBalancedToken(index, char, stack) {
 	if (char === "{" || char === "[") {
 		stack.push(char);
 		return SCAN_CONTINUE;
@@ -2139,7 +2357,7 @@ function scanBalancedToken(text, startIndex, index, char, stack) {
 	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;
+	return stack.length === 0 ? index + 1 : SCAN_CONTINUE;
 }
 function balancedClosingTokenMatches(open, close) {
 	if (open === "{") return close === "}";
@@ -2229,4 +2447,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-WOQNzCMC.js.map
+//# sourceMappingURL=flows-DimX0it5.js.map