acpx 0.4.0 → 0.5.0

package/dist/{flows-DnIYoHI1.js → flows-CR7xCmkR.js}

@@ -1,44 +1,233 @@
-import { L as promptToDisplayText, R as textPrompt, j as SESSION_RECORD_SCHEMA } from "./queue-ipc-CgWf63GN.js";
-import { C as TimeoutError, S as InterruptedError, T as withTimeout, _ as recordClientOperation, a as runOnce, g as createSessionConversation, h as cloneSessionAcpxState, i as createSessionWithClient, m as defaultSessionEventLog, p as resolveSessionRecord, r as cancelSessionPrompt, s as sendSessionDirect, v as recordPromptSubmission, w as withInterrupt, y as recordSessionUpdate } from "./session-BtpTC2pM.js";
-import { t as createOutputFormatter } from "./output-C58ukIo3.js";
-import fs from "node:fs/promises";
+import { A as PERMISSION_MODES, g as textPrompt, h as promptToDisplayText, j as SESSION_RECORD_SCHEMA } from "./perf-metrics-D9QC81lB.js";
+import { A as resolveSessionRecord, H as TimeoutError, P as defaultSessionEventLog, U as withInterrupt, V as InterruptedError, W as withTimeout, _ as recordSessionUpdate, f as cloneSessionAcpxState, g as recordPromptSubmission, h as recordClientOperation, m as createSessionConversation } from "./prompt-turn-Bt8T3SRR.js";
+import { c as createSessionWithClient, i as sendSessionDirect, l as cancelSessionPrompt, r as runOnce } from "./session-BbN0SBgf.js";
+import { t as createOutputFormatter } from "./output-Di0M9Et8.js";
 import path from "node:path";
+import fs from "node:fs/promises";
 import os from "node:os";
 import { spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
+import { ZodError, z } from "zod";
+//#region src/flows/authoring.ts
+const FLOW_DEFINITION_BRAND = Symbol.for("acpx.flow.definition");
+function markDefinedFlow(definition) {
+	if (isDefinedFlow(definition)) return definition;
+	Object.defineProperty(definition, FLOW_DEFINITION_BRAND, {
+		value: true,
+		enumerable: false,
+		configurable: false,
+		writable: false
+	});
+	return definition;
+}
+function isDefinedFlow(value) {
+	return value != null && typeof value === "object" && value[FLOW_DEFINITION_BRAND] === true;
+}
+//#endregion
+//#region src/flows/schema.ts
+const FLOW_NODE_TYPES = [
+	"acp",
+	"compute",
+	"action",
+	"checkpoint"
+];
+const finiteNonNegativeNumberSchema = z.number().finite().nonnegative();
+const nonEmptyTrimmedStringSchema = z.string().refine((value) => value.trim().length > 0, { message: "must not be empty" });
+function extensibleObject(shape) {
+	return z.object(shape).passthrough();
+}
+function functionSchema(label) {
+	return z.custom((value) => typeof value === "function", { message: `${label} must be a function` });
+}
+const flowNodeCommonShape = {
+	timeoutMs: finiteNonNegativeNumberSchema.optional(),
+	heartbeatMs: finiteNonNegativeNumberSchema.optional(),
+	statusDetail: z.string().optional()
+};
+const flowPermissionRequirementsSchema = extensibleObject({
+	requiredMode: z.enum(PERMISSION_MODES),
+	requireExplicitGrant: z.boolean().optional(),
+	reason: nonEmptyTrimmedStringSchema.optional()
+});
+const flowRunDefinitionSchema = extensibleObject({ title: z.union([z.string(), functionSchema("run.title")]).optional() });
+const acpSessionSchema = extensibleObject({
+	handle: z.string().optional(),
+	isolated: z.boolean().optional()
+});
+const acpNodeSchema = extensibleObject({
+	...flowNodeCommonShape,
+	nodeType: z.literal("acp"),
+	profile: z.string().optional(),
+	cwd: z.union([z.string(), functionSchema("cwd")]).optional(),
+	session: acpSessionSchema.optional(),
+	prompt: functionSchema("prompt"),
+	parse: functionSchema("parse").optional()
+});
+const computeNodeSchema = extensibleObject({
+	...flowNodeCommonShape,
+	nodeType: z.literal("compute"),
+	run: functionSchema("run")
+});
+const functionActionNodeSchema = extensibleObject({
+	...flowNodeCommonShape,
+	nodeType: z.literal("action"),
+	run: functionSchema("run")
+});
+const shellActionNodeSchema = extensibleObject({
+	...flowNodeCommonShape,
+	nodeType: z.literal("action"),
+	exec: functionSchema("exec"),
+	parse: functionSchema("parse").optional()
+}).refine((node) => !hasOwn(node, "run"), { message: "shell action nodes must not define run" });
+const checkpointNodeSchema = extensibleObject({
+	...flowNodeCommonShape,
+	nodeType: z.literal("checkpoint"),
+	summary: z.string().optional(),
+	run: functionSchema("run").optional()
+});
+const directFlowEdgeSchema = extensibleObject({
+	from: z.string(),
+	to: z.string()
+});
+const switchFlowEdgeSchema = extensibleObject({
+	from: z.string(),
+	switch: extensibleObject({
+		on: z.string(),
+		cases: z.record(z.string(), z.string())
+	})
+});
+const flowDefinitionSchema = extensibleObject({
+	name: nonEmptyTrimmedStringSchema,
+	run: flowRunDefinitionSchema.optional(),
+	permissions: flowPermissionRequirementsSchema.optional(),
+	startAt: z.string(),
+	nodes: z.record(z.string(), z.unknown()),
+	edges: z.array(z.unknown())
+});
+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}"`);
+	parsed.edges.forEach((edge, index) => {
+		assertValidFlowEdgeShape(edge, `flow definition: edges.${index}`);
+	});
+}
+function assertValidAcpNodeDefinition(node) {
+	parseWithSchema("acp node definition", acpNodeSchema, node);
+}
+function assertValidComputeNodeDefinition(node) {
+	parseWithSchema("compute node definition", computeNodeSchema, node);
+}
+function assertValidActionNodeDefinition(node) {
+	assertValidActionNodeDefinitionShape(node, "action node definition");
+}
+function assertValidShellActionNodeDefinition(node) {
+	parseWithSchema("shell action node definition", shellActionNodeSchema, node);
+}
+function assertValidCheckpointNodeDefinition(node) {
+	parseWithSchema("checkpoint node definition", checkpointNodeSchema, node);
+}
+function assertValidFlowNodeDefinitionShape(node, label) {
+	const { nodeType } = parseWithSchema(label, flowNodeTypeSchema, node);
+	switch (nodeType) {
+		case "acp":
+			parseWithSchema(label, acpNodeSchema, node);
+			return;
+		case "compute":
+			parseWithSchema(label, computeNodeSchema, node);
+			return;
+		case "action":
+			assertValidActionNodeDefinitionShape(node, label);
+			return;
+		case "checkpoint":
+			parseWithSchema(label, checkpointNodeSchema, node);
+			return;
+	}
+}
+function assertValidActionNodeDefinitionShape(node, label) {
+	const hasRun = hasOwn(node, "run");
+	const hasExec = hasOwn(node, "exec");
+	if (hasRun === hasExec) throw new Error(`Invalid ${label}: action nodes must define exactly one of run or exec`);
+	if (hasExec) {
+		parseWithSchema(label, shellActionNodeSchema, node);
+		return;
+	}
+	parseWithSchema(label, functionActionNodeSchema, node);
+}
+function assertValidFlowEdgeShape(edge, label) {
+	const hasTo = hasOwn(edge, "to");
+	if (hasTo === hasOwn(edge, "switch")) throw new Error(`Invalid ${label}: edge must define exactly one of to or switch`);
+	if (hasTo) {
+		parseWithSchema(label, directFlowEdgeSchema, edge);
+		return;
+	}
+	parseWithSchema(label, switchFlowEdgeSchema, edge);
+}
+function parseWithSchema(label, schema, value) {
+	try {
+		return schema.parse(value);
+	} catch (error) {
+		if (error instanceof ZodError) throw new Error(formatValidationError(label, error), { cause: error });
+		throw error;
+	}
+}
+function formatValidationError(label, error) {
+	return `Invalid ${label}: ${Array.from(new Set(error.issues.flatMap((issue) => formatIssue(issue)))).join("; ")}`;
+}
+function formatIssue(issue, parentPath = []) {
+	const path = [...parentPath, ...issue.path.map(String)];
+	if (issue.code === "invalid_union") return issue.errors.flatMap((branch) => branch.flatMap((nestedIssue) => formatIssue(nestedIssue, path)));
+	const renderedPath = path.join(".");
+	return [renderedPath ? `${renderedPath}: ${issue.message}` : issue.message];
+}
+function hasOwn(value, key) {
+	return value != null && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, key);
+}
+//#endregion
 //#region src/flows/definition.ts
 function defineFlow(definition) {
-	return definition;
+	assertValidFlowDefinitionShape(definition);
+	return markDefinedFlow(definition);
 }
 function acp(definition) {
-	return {
+	const node = {
 		nodeType: "acp",
 		...definition
 	};
+	assertValidAcpNodeDefinition(node);
+	return node;
 }
 function compute(definition) {
-	return {
+	const node = {
 		nodeType: "compute",
 		...definition
 	};
+	assertValidComputeNodeDefinition(node);
+	return node;
 }
 function action(definition) {
-	return {
+	const node = {
 		nodeType: "action",
 		...definition
 	};
+	assertValidActionNodeDefinition(node);
+	return node;
 }
 function shell(definition) {
-	return {
+	const node = {
 		nodeType: "action",
 		...definition
 	};
+	assertValidShellActionNodeDefinition(node);
+	return node;
 }
 function checkpoint(definition = {}) {
-	return {
+	const node = {
 		nodeType: "checkpoint",
 		...definition
 	};
+	assertValidCheckpointNodeDefinition(node);
+	return node;
 }
 //#endregion
 //#region src/flows/executors/shell.ts
@@ -122,8 +311,7 @@ async function runShellAction(spec) {
 //#endregion
 //#region src/flows/graph.ts
 function validateFlowDefinition(flow) {
-	if (!flow.name.trim()) throw new Error("Flow name must not be empty");
-	if (flow.permissions?.reason !== void 0 && !flow.permissions.reason.trim()) throw new Error("Flow permission reason must not be empty");
+	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) {
@@ -170,6 +358,244 @@ function getByPath(value, jsonPath) {
 	}, value);
 }
 //#endregion
+//#region src/flows/runtime-support.ts
+function isoNow$1() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+function persistRunFailure(store, runDir, state, error) {
+	if (state.finishedAt !== void 0 && (state.status === "failed" || state.status === "timed_out")) return Promise.resolve();
+	state.status = error instanceof TimeoutError ? "timed_out" : "failed";
+	state.updatedAt = isoNow$1();
+	state.finishedAt = state.updatedAt;
+	state.error = error instanceof Error ? error.message : String(error);
+	state.statusDetail = state.currentNode ? `Failed in ${state.currentNode}: ${state.error}` : state.error;
+	return store.writeSnapshot(runDir, state, {
+		scope: "run",
+		type: "run_failed",
+		payload: {
+			status: state.status,
+			error: state.error
+		}
+	});
+}
+function makeFlowNodeContext(state, input, services) {
+	return {
+		input,
+		outputs: state.outputs,
+		results: state.results,
+		state,
+		services
+	};
+}
+function markNodeStarted(state, nodeId, attemptId, nodeType, startedAt, detail) {
+	state.status = "running";
+	state.waitingOn = void 0;
+	state.currentNode = nodeId;
+	state.currentAttemptId = attemptId;
+	state.currentNodeType = nodeType;
+	state.currentNodeStartedAt = startedAt;
+	state.lastHeartbeatAt = startedAt;
+	state.statusDetail = detail ?? `Running ${nodeType} node ${nodeId}`;
+}
+function clearActiveNode(state, detail) {
+	state.currentNode = void 0;
+	state.currentAttemptId = void 0;
+	state.currentNodeType = void 0;
+	state.currentNodeStartedAt = void 0;
+	state.lastHeartbeatAt = void 0;
+	state.statusDetail = detail;
+}
+function updateStatusDetail(state, detail) {
+	if (!detail) return;
+	state.statusDetail = detail;
+}
+async function finalizeStepTrace(store, runDir, state, nodeId, attemptId, output, baseTrace) {
+	const trace = baseTrace ? structuredClone(baseTrace) : {};
+	if (output !== void 0) {
+		const inlineOutput = toInlineOutput(output);
+		if (inlineOutput !== void 0) trace.outputInline = inlineOutput;
+		else trace.outputArtifact = await store.writeArtifact(runDir, state, output, {
+			mediaType: outputArtifactMediaType(output),
+			extension: outputArtifactExtension(output),
+			nodeId,
+			attemptId
+		});
+	}
+	return Object.keys(trace).length > 0 ? trace : null;
+}
+function normalizePromptInput(prompt) {
+	return typeof prompt === "string" ? textPrompt(prompt) : prompt;
+}
+async function resolveNodeCwd(defaultCwd, cwd, context) {
+	if (typeof cwd === "function") {
+		const resolved = await cwd(context) ?? defaultCwd;
+		return path.resolve(defaultCwd, resolved);
+	}
+	return path.resolve(defaultCwd, cwd ?? defaultCwd);
+}
+function resolveShellActionCwd(defaultCwd, cwd) {
+	return path.resolve(defaultCwd, cwd ?? defaultCwd);
+}
+function summarizePrompt(promptText, explicitDetail) {
+	if (explicitDetail) return explicitDetail;
+	const line = promptText.split("\n").map((candidate) => candidate.trim()).find((candidate) => candidate.length > 0);
+	if (!line) return "Running ACP prompt";
+	return `ACP: ${line.length > 120 ? `${line.slice(0, 117)}...` : line}`;
+}
+function createQuietCaptureOutput() {
+	const chunks = [];
+	return {
+		formatter: createOutputFormatter("quiet", { stdout: { write(chunk) {
+			chunks.push(chunk);
+		} } }),
+		read: () => chunks.join("").trim()
+	};
+}
+async function resolveFlowRunTitle(flow, input, flowPath) {
+	const titleDefinition = flow.run?.title;
+	if (titleDefinition === void 0) return;
+	return normalizeFlowRunTitle(typeof titleDefinition === "function" ? await Promise.resolve(titleDefinition({
+		input,
+		flowName: flow.name,
+		flowPath
+	})) : titleDefinition);
+}
+function normalizeFlowRunTitle(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+}
+function createRunId(flowName) {
+	return `${isoNow$1().replaceAll(":", "").replaceAll(".", "")}-${flowName.replace(/[^a-z0-9]+/gi, "-").replace(/^-+|-+$/g, "").toLowerCase()}-${randomUUID().slice(0, 8)}`;
+}
+function createSessionBindingKey(agentCommand, cwd, handle) {
+	return `${agentCommand}::${cwd}::${handle}`;
+}
+function createSessionName(flowName, handle, cwd, runId) {
+	return `${flowName}-${handle}-${stableShortHash(cwd)}-${runId.slice(-8)}`;
+}
+function createSessionBundleId(handle, key) {
+	return `${handle.replace(/[^a-z0-9]+/gi, "-").replace(/^-+|-+$/g, "").toLowerCase() || "session"}-${stableShortHash(key)}`;
+}
+function createIsolatedSessionBinding(flowName, runId, attemptId, profile, agent) {
+	const key = `isolated::${attemptId}`;
+	const handle = "isolated";
+	return {
+		key,
+		handle,
+		bundleId: createSessionBundleId(`${handle}-${attemptId}`, `${key}::${agent.cwd}`),
+		name: `${flowName}-${attemptId}-${runId.slice(-8)}`,
+		profile,
+		agentName: agent.agentName,
+		agentCommand: agent.agentCommand,
+		cwd: agent.cwd,
+		acpxRecordId: key,
+		acpSessionId: key
+	};
+}
+function createSyntheticSessionRecord(options) {
+	return {
+		schema: SESSION_RECORD_SCHEMA,
+		acpxRecordId: options.binding.acpxRecordId,
+		acpSessionId: options.binding.acpSessionId,
+		agentSessionId: options.binding.agentSessionId,
+		agentCommand: options.binding.agentCommand,
+		cwd: options.binding.cwd,
+		name: options.binding.name,
+		createdAt: options.createdAt,
+		lastUsedAt: options.updatedAt,
+		lastSeq: options.lastSeq,
+		lastRequestId: void 0,
+		eventLog: defaultSessionEventLog(options.binding.acpxRecordId),
+		closed: true,
+		closedAt: options.updatedAt,
+		title: options.conversation.title,
+		messages: options.conversation.messages,
+		updated_at: options.conversation.updated_at,
+		cumulative_token_usage: options.conversation.cumulative_token_usage,
+		request_token_usage: options.conversation.request_token_usage,
+		acpx: options.acpxState
+	};
+}
+function createNodeResult(options) {
+	return {
+		attemptId: options.attemptId,
+		nodeId: options.nodeId,
+		nodeType: options.nodeType,
+		outcome: options.outcome,
+		startedAt: options.startedAt,
+		finishedAt: options.finishedAt,
+		durationMs: new Date(options.finishedAt).getTime() - new Date(options.startedAt).getTime(),
+		output: options.output,
+		error: options.error
+	};
+}
+function outcomeForError(error) {
+	if (error instanceof TimeoutError) return "timed_out";
+	if (error instanceof InterruptedError) return "cancelled";
+	return "failed";
+}
+function stableShortHash(value) {
+	return createHash("sha1").update(value).digest("hex").slice(0, 8);
+}
+function nextAttemptId(attemptCounts, nodeId) {
+	const next = (attemptCounts.get(nodeId) ?? 0) + 1;
+	attemptCounts.set(nodeId, next);
+	return `${nodeId}#${next}`;
+}
+function createNodeOutcomePayload(result, trace) {
+	return {
+		nodeType: result.nodeType,
+		outcome: result.outcome,
+		durationMs: result.durationMs,
+		error: result.error ?? null,
+		...trace
+	};
+}
+function attachStepTrace(error, trace) {
+	const attached = error instanceof Error ? error : new Error(typeof error === "string" ? error : String(error));
+	attached.flowStepTrace = trace;
+	return attached;
+}
+function extractAttachedStepTrace(error) {
+	if (!(error instanceof Error)) return;
+	return error.flowStepTrace;
+}
+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;
+	try {
+		const serialized = JSON.stringify(value);
+		if (serialized.length <= 200 && !serialized.includes("\n")) return value;
+	} catch {
+		return;
+	}
+}
+function outputArtifactMediaType(value) {
+	return typeof value === "string" ? "text/plain" : "application/json";
+}
+function outputArtifactExtension(value) {
+	return typeof value === "string" ? "txt" : "json";
+}
+function findConversationDeltaStart(before, after) {
+	const maxOverlap = Math.min(before.length, after.length);
+	for (let overlap = maxOverlap; overlap >= 0; overlap -= 1) {
+		let matches = true;
+		for (let index = 0; index < overlap; index += 1) {
+			const beforeMessage = before[before.length - overlap + index];
+			const afterMessage = after[index];
+			if (!deepEqualJson(beforeMessage, afterMessage)) {
+				matches = false;
+				break;
+			}
+		}
+		if (matches) return overlap;
+	}
+	return 0;
+}
+function deepEqualJson(left, right) {
+	return JSON.stringify(left) === JSON.stringify(right);
+}
+//#endregion
 //#region src/flows/store.ts
 const FLOW_BUNDLE_SCHEMA = "acpx.flow-run-bundle.v1";
 const FLOW_TRACE_SCHEMA = "acpx.flow-trace-event.v1";
@@ -245,7 +671,7 @@ var FlowRunStore = class {
 		});
 	}
 	async writeSnapshot(runDir, state, event) {
-		state.updatedAt = isoNow$1();
+		state.updatedAt = isoNow();
 		await writeJsonAtomic(this.resolveRunPath(runDir, RUN_PROJECTION_PATH), state);
 		await writeJsonAtomic(this.resolveRunPath(runDir, LIVE_PROJECTION_PATH), createLiveState(state));
 		await writeJsonAtomic(this.resolveRunPath(runDir, STEPS_PROJECTION_PATH), state.steps);
@@ -253,7 +679,7 @@ var FlowRunStore = class {
 		await this.appendTrace(runDir, state, event);
 	}
 	async writeLive(runDir, state, event) {
-		state.updatedAt = isoNow$1();
+		state.updatedAt = isoNow();
 		await writeJsonAtomic(this.resolveRunPath(runDir, LIVE_PROJECTION_PATH), createLiveState(state));
 		await this.writeManifest(runDir, state);
 		await this.appendTrace(runDir, state, event);
@@ -261,7 +687,7 @@ var FlowRunStore = class {
 	async appendTrace(runDir, state, event) {
 		const traceEvent = {
 			seq: this.nextTraceSeq(runDir),
-			at: isoNow$1(),
+			at: isoNow(),
 			runId: state.runId,
 			...event
 		};
@@ -340,7 +766,7 @@ var FlowRunStore = class {
 		this.sessionSeqByBundle.set(sessionKey, seq);
 		await this.appendJsonLine(this.resolveRunPath(runDir, path.posix.join(sessionDirPath(binding.bundleId), "events.ndjson")), {
 			seq,
-			at: isoNow$1(),
+			at: isoNow(),
 			direction,
 			message
 		});
@@ -525,7 +951,7 @@ function normalizeArtifactExtension(extension) {
 function sessionDirPath(bundleId) {
 	return path.posix.join(SESSIONS_DIR, bundleId);
 }
-function isoNow$1() {
+function isoNow() {
 	return (/* @__PURE__ */ new Date()).toISOString();
 }
 //#endregion
@@ -574,8 +1000,8 @@ var FlowRunner = class {
 			flowName: flow.name,
 			runTitle,
 			flowPath: options.flowPath,
-			startedAt: isoNow(),
-			updatedAt: isoNow(),
+			startedAt: isoNow$1(),
+			updatedAt: isoNow$1(),
 			status: "running",
 			input,
 			outputs: {},
@@ -602,15 +1028,15 @@ var FlowRunner = class {
 						const node = flow.nodes[current];
 						if (!node) throw new Error(`Unknown flow node: ${current}`);
 						const attemptId = nextAttemptId(attemptCounts, current);
-						const startedAt = isoNow();
-						const context = this.makeContext(state, input);
+						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;
-						this.markNodeStarted(state, current, attemptId, node.nodeType, startedAt, node.statusDetail);
+						markNodeStarted(state, current, attemptId, node.nodeType, startedAt, node.statusDetail);
 						await this.store.writeSnapshot(runDir, state, {
 							scope: "node",
 							type: "node_started",
@@ -626,27 +1052,27 @@ var FlowRunner = class {
 						let executionError;
 						try {
 							({output, promptText, rawText, sessionInfo, agentInfo, trace} = await this.executeNode(runDir, state, flow, current, node, context));
-							trace = await this.finalizeStepTrace(runDir, state, current, attemptId, output, trace);
+							trace = await finalizeStepTrace(this.store, runDir, state, current, attemptId, output, trace);
 							nodeResult = createNodeResult({
 								attemptId,
 								nodeId: current,
 								nodeType: node.nodeType,
 								outcome: "ok",
 								startedAt,
-								finishedAt: isoNow(),
+								finishedAt: isoNow$1(),
 								output
 							});
 						} catch (error) {
 							executionError = error;
 							trace = extractAttachedStepTrace(error) ?? trace;
-							trace = await this.finalizeStepTrace(runDir, state, current, attemptId, void 0, 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(),
+								finishedAt: isoNow$1(),
 								error: error instanceof Error ? error.message : String(error)
 							});
 						}
@@ -654,9 +1080,9 @@ var FlowRunner = class {
 						if (nodeResult.outcome === "ok" && node.nodeType === "checkpoint") {
 							state.outputs[current] = output;
 							state.waitingOn = current;
-							state.updatedAt = isoNow();
+							state.updatedAt = isoNow$1();
 							state.status = "waiting";
-							this.clearActiveNode(state, output?.summary ?? current);
+							clearActiveNode(state, output?.summary ?? current);
 							state.steps.push({
 								attemptId,
 								nodeId: current,
@@ -684,8 +1110,8 @@ var FlowRunner = class {
 							};
 						}
 						if (nodeResult.outcome === "ok") state.outputs[current] = output;
-						state.updatedAt = isoNow();
-						this.clearActiveNode(state);
+						state.updatedAt = isoNow$1();
+						clearActiveNode(state);
 						state.steps.push({
 							attemptId,
 							nodeId: current,
@@ -720,9 +1146,9 @@ var FlowRunner = class {
 						throw executionError;
 					}
 					state.status = "completed";
-					state.finishedAt = isoNow();
+					state.finishedAt = isoNow$1();
 					state.updatedAt = state.finishedAt;
-					this.clearActiveNode(state);
+					clearActiveNode(state);
 					await this.store.writeSnapshot(runDir, state, {
 						scope: "run",
 						type: "run_completed",
@@ -733,41 +1159,16 @@ var FlowRunner = class {
 						state
 					};
 				} catch (error) {
-					await this.persistRunFailure(runDir, state, error);
+					await persistRunFailure(this.store, runDir, state, error);
 					throw error;
 				}
 			}, async () => {
-				await this.persistRunFailure(runDir, state, new InterruptedError());
+				await persistRunFailure(this.store, runDir, state, new InterruptedError());
 			});
 		} finally {
 			await this.closePendingPersistentSessionClients();
 		}
 	}
-	async persistRunFailure(runDir, state, error) {
-		if (state.finishedAt !== void 0 && (state.status === "failed" || state.status === "timed_out")) return;
-		state.status = error instanceof TimeoutError ? "timed_out" : "failed";
-		state.updatedAt = isoNow();
-		state.finishedAt = state.updatedAt;
-		state.error = error instanceof Error ? error.message : String(error);
-		state.statusDetail = state.currentNode ? `Failed in ${state.currentNode}: ${state.error}` : state.error;
-		await this.store.writeSnapshot(runDir, state, {
-			scope: "run",
-			type: "run_failed",
-			payload: {
-				status: state.status,
-				error: state.error
-			}
-		});
-	}
-	makeContext(state, input) {
-		return {
-			input,
-			outputs: state.outputs,
-			results: state.results,
-			state,
-			services: this.services
-		};
-	}
 	async executeNode(runDir, state, flow, nodeId, node, context) {
 		switch (node.nodeType) {
 			case "compute": return await this.executeComputeNode(runDir, state, node, context);
@@ -805,7 +1206,7 @@ var FlowRunner = class {
 				cwd: resolveShellActionCwd(this.defaultCwd, execution.cwd),
 				timeoutMs: execution.timeoutMs ?? nodeTimeoutMs
 			};
-			this.updateStatusDetail(state, formatShellActionSummary(effectiveExecution));
+			updateStatusDetail(state, formatShellActionSummary(effectiveExecution));
 			await this.store.writeLive(runDir, state, {
 				scope: "node",
 				type: "node_heartbeat",
@@ -916,7 +1317,7 @@ var FlowRunner = class {
 			};
 			const prompt = normalizePromptInput(await Promise.resolve(node.prompt(context)));
 			const promptText = promptToDisplayText(prompt);
-			this.updateStatusDetail(state, summarizePrompt(promptText, node.statusDetail));
+			updateStatusDetail(state, summarizePrompt(promptText, node.statusDetail));
 			await this.store.writeLive(runDir, state, {
 				scope: "node",
 				type: "node_heartbeat",
@@ -934,9 +1335,9 @@ var FlowRunner = class {
 				const isolatedBinding = createIsolatedSessionBinding(flow.name, state.runId, state.currentAttemptId ?? randomUUID(), node.profile, agentInfo);
 				const initialIsolatedRecord = createSyntheticSessionRecord({
 					binding: isolatedBinding,
-					createdAt: state.currentNodeStartedAt ?? isoNow(),
-					updatedAt: state.currentNodeStartedAt ?? isoNow(),
-					conversation: createSessionConversation(state.currentNodeStartedAt ?? isoNow()),
+					createdAt: state.currentNodeStartedAt ?? isoNow$1(),
+					updatedAt: state.currentNodeStartedAt ?? isoNow$1(),
+					conversation: createSessionConversation(state.currentNodeStartedAt ?? isoNow$1()),
 					acpxState: void 0,
 					lastSeq: 0
 				});
@@ -1050,49 +1451,13 @@ var FlowRunner = class {
 			await cancelSessionPrompt({ sessionId: boundSession.acpxRecordId });
 		});
 	}
-	markNodeStarted(state, nodeId, attemptId, nodeType, startedAt, detail) {
-		state.status = "running";
-		state.waitingOn = void 0;
-		state.currentNode = nodeId;
-		state.currentAttemptId = attemptId;
-		state.currentNodeType = nodeType;
-		state.currentNodeStartedAt = startedAt;
-		state.lastHeartbeatAt = startedAt;
-		state.statusDetail = detail ?? `Running ${nodeType} node ${nodeId}`;
-	}
-	clearActiveNode(state, detail) {
-		state.currentNode = void 0;
-		state.currentAttemptId = void 0;
-		state.currentNodeType = void 0;
-		state.currentNodeStartedAt = void 0;
-		state.lastHeartbeatAt = void 0;
-		state.statusDetail = detail;
-	}
-	updateStatusDetail(state, detail) {
-		if (!detail) return;
-		state.statusDetail = detail;
-	}
-	async finalizeStepTrace(runDir, state, nodeId, attemptId, output, baseTrace) {
-		const trace = baseTrace ? structuredClone(baseTrace) : {};
-		if (output !== void 0) {
-			const inlineOutput = toInlineOutput(output);
-			if (inlineOutput !== void 0) trace.outputInline = inlineOutput;
-			else trace.outputArtifact = await this.store.writeArtifact(runDir, state, output, {
-				mediaType: outputArtifactMediaType(output),
-				extension: outputArtifactExtension(output),
-				nodeId,
-				attemptId
-			});
-		}
-		return Object.keys(trace).length > 0 ? trace : null;
-	}
 	async runWithHeartbeat(runDir, state, nodeId, node, timeoutMs, run, onTimeout) {
 		const heartbeatMs = Math.max(0, Math.round(node.heartbeatMs ?? DEFAULT_FLOW_HEARTBEAT_MS));
 		let timer;
 		let active = true;
 		const heartbeat = async () => {
 			if (!active) return;
-			state.lastHeartbeatAt = isoNow();
+			state.lastHeartbeatAt = isoNow$1();
 			state.updatedAt = state.lastHeartbeatAt;
 			await this.store.writeLive(runDir, state, {
 				scope: "node",
@@ -1229,9 +1594,9 @@ var FlowRunner = class {
 	}
 	async runIsolatedPrompt(runDir, state, binding, agent, prompt, timeoutMs) {
 		const capture = createQuietCaptureOutput();
-		const conversation = createSessionConversation(state.currentNodeStartedAt ?? isoNow());
+		const conversation = createSessionConversation(state.currentNodeStartedAt ?? isoNow$1());
 		let acpxState;
-		recordPromptSubmission(conversation, prompt, state.currentNodeStartedAt ?? isoNow());
+		recordPromptSubmission(conversation, prompt, state.currentNodeStartedAt ?? isoNow$1());
 		let eventStartSeq;
 		let eventEndSeq;
 		const pendingEventWrites = [];
@@ -1272,7 +1637,7 @@ var FlowRunner = class {
 		await this.store.ensureSessionBundle(runDir, state, sessionInfo);
 		const syntheticRecord = createSyntheticSessionRecord({
 			binding: sessionInfo,
-			createdAt: state.currentNodeStartedAt ?? isoNow(),
+			createdAt: state.currentNodeStartedAt ?? isoNow$1(),
 			updatedAt: conversation.updated_at,
 			conversation,
 			acpxState: cloneSessionAcpxState(acpxState),
@@ -1296,181 +1661,6 @@ var FlowRunner = class {
 		};
 	}
 };
-function normalizePromptInput(prompt) {
-	return typeof prompt === "string" ? textPrompt(prompt) : prompt;
-}
-async function resolveNodeCwd(defaultCwd, cwd, context) {
-	if (typeof cwd === "function") {
-		const resolved = await cwd(context) ?? defaultCwd;
-		return path.resolve(defaultCwd, resolved);
-	}
-	return path.resolve(defaultCwd, cwd ?? defaultCwd);
-}
-function resolveShellActionCwd(defaultCwd, cwd) {
-	return path.resolve(defaultCwd, cwd ?? defaultCwd);
-}
-function summarizePrompt(promptText, explicitDetail) {
-	if (explicitDetail) return explicitDetail;
-	const line = promptText.split("\n").map((candidate) => candidate.trim()).find((candidate) => candidate.length > 0);
-	if (!line) return "Running ACP prompt";
-	return `ACP: ${line.length > 120 ? `${line.slice(0, 117)}...` : line}`;
-}
-function createQuietCaptureOutput() {
-	const chunks = [];
-	return {
-		formatter: createOutputFormatter("quiet", { stdout: { write(chunk) {
-			chunks.push(chunk);
-		} } }),
-		read: () => chunks.join("").trim()
-	};
-}
-async function resolveFlowRunTitle(flow, input, flowPath) {
-	const titleDefinition = flow.run?.title;
-	if (titleDefinition === void 0) return;
-	return normalizeFlowRunTitle(typeof titleDefinition === "function" ? await Promise.resolve(titleDefinition({
-		input,
-		flowName: flow.name,
-		flowPath
-	})) : titleDefinition);
-}
-function normalizeFlowRunTitle(value) {
-	const trimmed = value?.trim();
-	return trimmed ? trimmed : void 0;
-}
-function createRunId(flowName) {
-	return `${isoNow().replaceAll(":", "").replaceAll(".", "")}-${flowName.replace(/[^a-z0-9]+/gi, "-").replace(/^-+|-+$/g, "").toLowerCase()}-${randomUUID().slice(0, 8)}`;
-}
-function createSessionBindingKey(agentCommand, cwd, handle) {
-	return `${agentCommand}::${cwd}::${handle}`;
-}
-function createSessionName(flowName, handle, cwd, runId) {
-	return `${flowName}-${handle}-${stableShortHash(cwd)}-${runId.slice(-8)}`;
-}
-function createSessionBundleId(handle, key) {
-	return `${handle.replace(/[^a-z0-9]+/gi, "-").replace(/^-+|-+$/g, "").toLowerCase() || "session"}-${stableShortHash(key)}`;
-}
-function createIsolatedSessionBinding(flowName, runId, attemptId, profile, agent) {
-	const key = `isolated::${attemptId}`;
-	const handle = "isolated";
-	return {
-		key,
-		handle,
-		bundleId: createSessionBundleId(`${handle}-${attemptId}`, `${key}::${agent.cwd}`),
-		name: `${flowName}-${attemptId}-${runId.slice(-8)}`,
-		profile,
-		agentName: agent.agentName,
-		agentCommand: agent.agentCommand,
-		cwd: agent.cwd,
-		acpxRecordId: key,
-		acpSessionId: key
-	};
-}
-function createSyntheticSessionRecord(options) {
-	return {
-		schema: SESSION_RECORD_SCHEMA,
-		acpxRecordId: options.binding.acpxRecordId,
-		acpSessionId: options.binding.acpSessionId,
-		agentSessionId: options.binding.agentSessionId,
-		agentCommand: options.binding.agentCommand,
-		cwd: options.binding.cwd,
-		name: options.binding.name,
-		createdAt: options.createdAt,
-		lastUsedAt: options.updatedAt,
-		lastSeq: options.lastSeq,
-		lastRequestId: void 0,
-		eventLog: defaultSessionEventLog(options.binding.acpxRecordId),
-		closed: true,
-		closedAt: options.updatedAt,
-		title: options.conversation.title,
-		messages: options.conversation.messages,
-		updated_at: options.conversation.updated_at,
-		cumulative_token_usage: options.conversation.cumulative_token_usage,
-		request_token_usage: options.conversation.request_token_usage,
-		acpx: options.acpxState
-	};
-}
-function createNodeResult(options) {
-	return {
-		attemptId: options.attemptId,
-		nodeId: options.nodeId,
-		nodeType: options.nodeType,
-		outcome: options.outcome,
-		startedAt: options.startedAt,
-		finishedAt: options.finishedAt,
-		durationMs: new Date(options.finishedAt).getTime() - new Date(options.startedAt).getTime(),
-		output: options.output,
-		error: options.error
-	};
-}
-function outcomeForError(error) {
-	if (error instanceof TimeoutError) return "timed_out";
-	if (error instanceof InterruptedError) return "cancelled";
-	return "failed";
-}
-function stableShortHash(value) {
-	return createHash("sha1").update(value).digest("hex").slice(0, 8);
-}
-function nextAttemptId(attemptCounts, nodeId) {
-	const next = (attemptCounts.get(nodeId) ?? 0) + 1;
-	attemptCounts.set(nodeId, next);
-	return `${nodeId}#${next}`;
-}
-function createNodeOutcomePayload(result, trace) {
-	return {
-		nodeType: result.nodeType,
-		outcome: result.outcome,
-		durationMs: result.durationMs,
-		error: result.error ?? null,
-		...trace
-	};
-}
-function attachStepTrace(error, trace) {
-	const attached = error instanceof Error ? error : new Error(typeof error === "string" ? error : String(error));
-	attached.flowStepTrace = trace;
-	return attached;
-}
-function extractAttachedStepTrace(error) {
-	if (!(error instanceof Error)) return;
-	return error.flowStepTrace;
-}
-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;
-	try {
-		const serialized = JSON.stringify(value);
-		if (serialized.length <= 200 && !serialized.includes("\n")) return value;
-	} catch {
-		return;
-	}
-}
-function outputArtifactMediaType(value) {
-	return typeof value === "string" ? "text/plain" : "application/json";
-}
-function outputArtifactExtension(value) {
-	return typeof value === "string" ? "txt" : "json";
-}
-function findConversationDeltaStart(before, after) {
-	const maxOverlap = Math.min(before.length, after.length);
-	for (let overlap = maxOverlap; overlap >= 0; overlap -= 1) {
-		let matches = true;
-		for (let index = 0; index < overlap; index += 1) {
-			const beforeMessage = before[before.length - overlap + index];
-			const afterMessage = after[index];
-			if (!deepEqualJson(beforeMessage, afterMessage)) {
-				matches = false;
-				break;
-			}
-		}
-		if (matches) return overlap;
-	}
-	return 0;
-}
-function deepEqualJson(left, right) {
-	return JSON.stringify(left) === JSON.stringify(right);
-}
-function isoNow() {
-	return (/* @__PURE__ */ new Date()).toISOString();
-}
 //#endregion
 //#region src/flows/json.ts
 function parseJsonObject(text, options = {}) {
@@ -1546,6 +1736,6 @@ function scanBalanced(text, startIndex) {
 	return null;
 }
 //#endregion
-export { flowRunsBaseDir as a, checkpoint as c, shell as d, FlowRunner as i, compute as l, parseJsonObject as n, acp as o, parseStrictJsonObject as r, action as s, extractJsonObject as t, defineFlow as u };
+export { flowRunsBaseDir as a, action as c, defineFlow as d, shell as f, FlowRunner as i, checkpoint as l, parseJsonObject as n, validateFlowDefinition as o, isDefinedFlow as p, parseStrictJsonObject as r, acp as s, extractJsonObject as t, compute as u };
 
-//# sourceMappingURL=flows-DnIYoHI1.js.map
+//# sourceMappingURL=flows-CR7xCmkR.js.map