dsh-auto-flow 0.1.1 → 0.1.2

package/lib/index.js

@@ -1,79 +1,2170 @@
+import "./types.js";
+import * as path from "node:path";
+import { join } from "node:path";
 import { Service } from "@deepseek-ai/cordis";
-import { HarnessError } from "@deepseek-ai/dsh-llm";
-import { defineTool } from "@deepseek-ai/dsh-tools";
 import { Remote, RemoteError, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { HarnessError, createUserMessage } from "@deepseek-ai/dsh-llm";
 import z from "@deepseek-ai/schemastery";
 import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
 import { z as z$1 } from "zod";
-//#region src/domain.ts
+import { appendFile, mkdir, open, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import mime from "mime";
+import { deadline, timeoutOf } from "@deepseek-ai/dsh-timeout";
+import { deepEqualJson } from "@deepseek-ai/dsh-util-values";
+import { promises } from "node:fs";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { Buffer as Buffer$1 } from "node:buffer";
+//#region src/host/config.ts
 /**
-* dsh-auto-flow 的持久化领域（dsh-storage domain）声明。
-*
-* 插件的持久化状态一律进 **domain storage**（这里），与 session 日志完全隔离
-* （`dsh-storage-domain` 只存非会话数据、不追加会话事件）。不要把机器执行信息 /
-* 运行态写成会话里的 durable 节点——往会话日志里塞非会话数据，会导致该会话在
-* dsh 重启后无法正常打开。
-*
-* 领域用 `defineDomain` 声明一次（表 schema 用 zod，`z.infer` 派生类型），
-* 由 `ctx.storageDomain.open(spec)` 打开，返回的 `Domain` 提供同步读 + 串行化落盘写。
-*
-* 高级选项（DomainSpec）与适用场景：
-* - layout: 'single'（默认）整单元一文档；'per-record' 按记录分文档，适合大/稀疏/可
-*   独立丢弃的记录（如投影缓存），并逐记录做版本隔离（过期记录文档被丢弃而非迁移）。
-* - compatibleVersions: 列旧版本号，声明当前 record schema 仍能接受旧记录（把旧字段
-*   声明为可选）。升级 version 后写这里。
-* - invalidRecords: 缺省（打开遇坏记录直接拒绝）——权威数据用这个；'backup-and-skip'
-*   把坏记录移到备份、打开继续——可丢弃的派生数据用这个。全局槽始终拒绝。
-* - global: 全局单例槽（schema + 未写前 initial），见下方示例。
+* dsh-auto-flow 的插件配置：Config 接口、schema 与校验归一化。
+* ConfigSchema 既是 Loader 读的类静态 Config，也是 settings namespace 的 schema。
+*/
+/** 工作流运行产物根目录（每次运行在其下建 run-* 子目录）。 */
+const DEFAULT_WORKSPACE_DIR = "workflow-runs";
+/** 领域错误：extends HarnessError 以便失败类别可机器路由。 */
+var AutoFlowError = class extends HarnessError {
+	constructor(message, code) {
+		super(message, code);
+	}
+};
+/** 在边界处校验并归一化一份配置。 */
+function resolveConfig(config = {}) {
+	const workspaceDir = (config.workspaceDir ?? "workflow-runs").trim();
+	if (workspaceDir === "") throw new AutoFlowError("auto-flow: workspaceDir 不能是空字符串", "AUTO_FLOW_INVALID_WORKSPACE_DIR");
+	const maxAgentDepth = config.maxAgentDepth ?? 3;
+	if (!Number.isSafeInteger(maxAgentDepth) || maxAgentDepth < 0) throw new AutoFlowError("auto-flow: maxAgentDepth 必须是非负安全整数", "AUTO_FLOW_INVALID_MAX_AGENT_DEPTH");
+	const runLogRetentionDays = config.runLogRetentionDays ?? 14;
+	if (!Number.isSafeInteger(runLogRetentionDays) || runLogRetentionDays < 1) throw new AutoFlowError("auto-flow: runLogRetentionDays 必须是正整数", "AUTO_FLOW_INVALID_RUN_LOG_RETENTION");
+	return {
+		workspaceDir,
+		maxAgentDepth,
+		runLogRetentionDays
+	};
+}
+/** 配置 schema：Loader 校验的类静态 Config，也是 settings namespace 的 schema。 */
+const ConfigSchema = z.object({
+	workspaceDir: z.string().default(DEFAULT_WORKSPACE_DIR),
+	maxAgentDepth: z.number().default(3),
+	runLogRetentionDays: z.number().default(14)
+});
+//#endregion
+//#region src/host/domain.ts
+/**
+* dsh-auto-flow 的持久化领域声明。
+* 注意：插件持久化只进 domain storage，别往会话日志里塞非会话数据（会导致会话打不开）。
+*/
+/** 工作流数据值 schema（与 types.ts 的 FlowDataValue 同形，递归 JSON）。 */
+const FlowDataValueSchema = z$1.lazy(() => z$1.union([
+	z$1.string(),
+	z$1.number(),
+	z$1.boolean(),
+	z$1.null(),
+	z$1.array(FlowDataValueSchema),
+	z$1.record(z$1.string(), FlowDataValueSchema)
+]));
+/** 工作流节点/连线/画布的持久化 schema（与 types.ts 的 JSON 安全载荷同形）。 */
+const FlowNodeSchema = z$1.object({
+	id: z$1.string(),
+	type: z$1.string(),
+	position: z$1.object({
+		x: z$1.number(),
+		y: z$1.number()
+	}),
+	data: z$1.record(z$1.string(), FlowDataValueSchema),
+	style: z$1.record(z$1.string(), FlowDataValueSchema).optional()
+});
+const FlowEdgeSchema = z$1.object({
+	id: z$1.string(),
+	source: z$1.string(),
+	target: z$1.string(),
+	type: z$1.string().optional(),
+	animated: z$1.boolean().optional(),
+	data: z$1.record(z$1.string(), FlowDataValueSchema).optional()
+});
+/**
+* flows 表的持久化 schema（向后兼容）：旧版记录只有 `{ nodes, edges }`，
+* 元数据字段（formatVersion / name / description）可缺省——读取时由
+* {@link decodeWorkflowDefinition} 用 id 兜底归一化，旧存档无需迁移即可继续工作。
 */
-/** 领域名：UNIT_NAME_RE /^[a-z][a-z0-9_]*$/，由脚手架按包名推导（dsh_auto_flow）。 */
-const GreetingDomain = defineDomain({
+const StoredWorkflowSchema = z$1.object({
+	formatVersion: z$1.number().int().positive().optional(),
+	name: z$1.string().optional(),
+	description: z$1.string().optional(),
+	nodes: z$1.array(FlowNodeSchema),
+	edges: z$1.array(FlowEdgeSchema)
+});
+/** 把 flows 表的一条原始记录归一化为当前文档形态（旧版缺省元数据时以 id 兜底）。 */
+function decodeWorkflowDefinition(id, stored) {
+	return {
+		formatVersion: stored.formatVersion ?? 1,
+		name: stored.name ?? id,
+		description: stored.description ?? "",
+		nodes: stored.nodes,
+		edges: stored.edges
+	};
+}
+/** 领域名（UNIT_NAME_RE /^[a-z][a-z0-9_]*$/），由脚手架按包名推导。
+*  只持有长期资产（工作流定义）；运行记录是高频即弃的审计数据，走插件自持的
+*  追加式按天 JSONL 运行日志（host/run-store.ts），不进 domain storage。 */
+const AutoFlowDomain = defineDomain({
 	name: "dsh_auto_flow",
 	version: 1,
 	layout: "single",
-	global: {
-		schema: z$1.object({ lastGreetedAt: z$1.number().nullable() }),
-		initial: { lastGreetedAt: null }
-	},
-	tables: { greetings: domainTable(z$1.object({
-		id: z$1.number(),
-		text: z$1.string(),
-		createdAt: z$1.number()
-	})) }
+	tables: { flows: domainTable(StoredWorkflowSchema) }
 });
 //#endregion
-//#region src/invariant.ts
-/**
-* 断言助手：失败抛 HarnessError（稳定机器可路由码 INVARIANT）。
-* 官方参考：@deepseek-ai/dsh-goal 的 ./invariant 出口。
-*/
-/**
-* 断言 condition 为真，否则抛 INVARIANT 错误（route on code，勿解析 message）。
-* @param condition - 期望为真的条件。
-* @param message - 失败时的人类可读消息。
-*/
-function invariant(condition, message) {
-	if (!condition) throw new HarnessError(message, "INVARIANT");
+//#region src/host/command-line.ts
+/** 按空白分割命令行，但双引号包裹的段整体保留（支持 `task="hello world"` 这类含空格值，
+* 也支持 `key="a b"` 形态；引号本身不进入标记）。
+* 用状态机代替正则：`\S+` 会把 `task="hello` 里的引号一并吞掉，`=` 前缀后的引号段
+* 无法用正则交替干净捕获。
+* @param line - 命令行文本。
+* @returns 分割后的标记；未闭合引号按剩余内容宽容处理。
+*/
+function splitWorkflowLine(line) {
+	const tokens = [];
+	let current = "";
+	let inQuote = false;
+	for (const ch of line) {
+		if (ch === "\"") {
+			inQuote = !inQuote;
+			continue;
+		}
+		if (ch === " " || ch === "	") {
+			if (inQuote) current += ch;
+			else if (current !== "") {
+				tokens.push(current);
+				current = "";
+			}
+			continue;
+		}
+		current += ch;
+	}
+	if (current !== "") tokens.push(current);
+	return tokens;
+}
+/** 解析 `/workflow` 命令名之后的文本。
+* @param rawInput - 命令名之后的完整文本（含分隔空白）。
+* @returns 已解析的命令行；运行输入保持字符串，允许空值。
+*/
+function parseWorkflowCommandLine(rawInput) {
+	const [target, ...rest] = splitWorkflowLine(rawInput);
+	if (target === void 0) return { kind: "list" };
+	const args = {};
+	for (const token of rest) {
+		const eq = token.indexOf("=");
+		if (eq <= 0) return {
+			kind: "error",
+			error: `无法解析参数「${token}」：应为 key=value 形式`
+		};
+		args[token.slice(0, eq)] = token.slice(eq + 1);
+	}
+	return {
+		kind: "run",
+		target,
+		args
+	};
+}
+/** 把 `/workflow` 的目标词解析为工作流 id：先精确 id，再唯一精确名称匹配。 */
+function resolveWorkflowTarget(flows, target) {
+	if (flows.some((f) => f.id === target)) return {
+		ok: true,
+		id: target
+	};
+	const byName = flows.filter((f) => f.name === target);
+	if (byName.length === 1) return {
+		ok: true,
+		id: byName[0].id
+	};
+	if (byName.length > 1) return {
+		ok: false,
+		error: `名称「${target}」匹配多个工作流（${byName.map((f) => f.id).join("、")}），请改用 id`
+	};
+	return {
+		ok: false,
+		error: `没有名称或 id 为「${target}」的工作流`
+	};
+}
+/** 把一次已保存工作流的摘要渲染成列表文本（人类 /workflow 命令用：名称/描述/输入键/节点数，不含 uuid）。 */
+function renderFlowList(flows) {
+	return flows.map((f) => {
+		const desc = f.description === "" ? "" : `：${f.description}`;
+		const inputs = f.inputs.length > 0 ? `（输入：${f.inputs.join("、")}）` : "";
+		return `- ${f.name}（${f.nodeCount} 个节点）${desc}${inputs}`;
+	}).join("\n");
+}
+//#endregion
+//#region src/host/run-store.ts
+/**
+* 运行日志表：插件自持的追加式、按天轮转的运行记录日志（对齐参考项目 dsh-auto-flow）。
+*
+* 运行记录是高频、即弃的审计数据，因此与「定义进 domain storage」不同——运行日志放在
+* `workspaceDir/runs/` 下每天一个 `YYYY-MM-DD.jsonl` 文件，终态时追加一行 JSON（settled
+* 记录只写一次，不做逐节点重写）：永不重写历史，写入 O(1)；保留期按文件年龄
+* （`retentionDays`）整体删除文件，用完即弃就是字面意义的删文件。读取只读最近文件的
+* 尾部（最多 1MB），单行损坏只丢单行。
+*
+* 运行中的实时状态归宿主服务内存（runRuntimes）权威，本模块只承担终态记录的落盘与
+* 重启后的读取兜底。写操作经一条串行链排队，运行并发结算也不会撕裂行。
+* @module dsh-auto-flow/run-store
+*/
+/** 日志文件名：`YYYY-MM-DD.jsonl`。 */
+const DAY_FILE_PATTERN = /^\d{4}-\d{2}-\d{2}\.jsonl$/u;
+/** 尾部读取上限：最近文件只读末尾这么多字节就足以覆盖近期记录。 */
+const MAX_TAIL_BYTES = 1048576;
+/** 一毫秒的日换算系数（保留期计算用）。 */
+const MS_PER_DAY = 864e5;
+/** 把一个时间戳格式化为日志文件名中的日期戳。 */
+function dayStamp(time) {
+	const date = new Date(time);
+	const pad = (value) => String(value).padStart(2, "0");
+	return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+/** 插件自持的运行日志：追加写入、尾部读取、按天保留。 */
+var WorkflowRunStore = class {
+	dir;
+	retentionDays;
+	logger;
+	/** 写链尾：所有追加串行化；链自身的拒绝被吞掉，一次写失败不毒化后续写入。 */
+	writeChain = Promise.resolve();
+	/** 上次执行过期清理的日期戳；跨天时清理一次过期文件。 */
+	lastPruneDay;
+	constructor(dir, retentionDays, logger) {
+		this.dir = dir;
+		this.retentionDays = retentionDays;
+		this.logger = logger;
+	}
+	/** 追加一条运行记录（当日文件、单行 JSON、串行写）。 */
+	append(record) {
+		const next = this.writeChain.then(() => this.appendNow(record));
+		this.writeChain = next.then(() => void 0, () => void 0);
+		return next;
+	}
+	/** 读取单条运行记录；找不到时返回 undefined（按天文件从新到旧扫描尾部）。 */
+	async read(runId) {
+		for (const name of await this.dayFiles()) for (const record of this.parseLines(await this.tailRead(name))) if (record.runId === runId) return record;
+	}
+	/** 按条件列出运行记录，整体按 updatedAt 倒序（新文件优先 + 文件内最新在前），
+	* 使「最近 N 条」语义（limit 截断）取到真正的新记录而非最旧记录。 */
+	async list(filter = {}) {
+		const runs = [];
+		const limit = filter.limit ?? 200;
+		for (const name of await this.dayFiles()) {
+			const lines = [...this.parseLines(await this.tailRead(name))].reverse();
+			for (const record of lines) {
+				if (filter.sessionId !== void 0 && record.sessionId !== filter.sessionId) continue;
+				if (filter.workflowId !== void 0 && record.workflowId !== filter.workflowId) continue;
+				runs.push(record);
+				if (runs.length >= limit) return runs;
+			}
+		}
+		return runs;
+	}
+	/** 串行链上的一次追加：确保目录、追加当日文件、跨天时清理过期文件。 */
+	async appendNow(record) {
+		await mkdir(this.dir, { recursive: true });
+		const day = dayStamp(Date.now());
+		await appendFile(this.dayPath(day), `${JSON.stringify(record)}\n`, "utf8");
+		if (this.lastPruneDay !== day) {
+			this.lastPruneDay = day;
+			await this.pruneExpired(day);
+		}
+	}
+	/** 删除早于保留期的日志文件（按文件名日期比较；当天文件永不清除）。 */
+	async pruneExpired(today) {
+		const cutoff = dayStamp(Date.now() - this.retentionDays * MS_PER_DAY);
+		for (const name of await this.dayFiles()) {
+			if (name >= cutoff || name === today) continue;
+			await rm(this.dayPath(name), { force: true });
+		}
+	}
+	/** 列出全部日志文件的日期戳（`YYYY-MM-DD`），新到旧。目录不存在时为空。 */
+	async dayFiles() {
+		let entries;
+		try {
+			entries = await readdir(this.dir);
+		} catch {
+			return [];
+		}
+		return entries.filter((name) => DAY_FILE_PATTERN.test(name)).map((name) => name.slice(0, -6)).sort().reverse();
+	}
+	dayPath(day) {
+		return join(this.dir, `${day}.jsonl`);
+	}
+	/** 读取一个日志文件的末尾（至多 1MB）；文件不存在时返回空行。 */
+	async tailRead(day) {
+		const path = this.dayPath(day);
+		let size;
+		try {
+			size = (await stat(path)).size;
+		} catch {
+			return [];
+		}
+		const handle = await open(path, "r");
+		try {
+			const start = Math.max(0, size - MAX_TAIL_BYTES);
+			const buffer = Buffer.alloc(size - start);
+			await handle.read(buffer, 0, buffer.length, start);
+			const lines = buffer.toString("utf8").split("\n");
+			return start > 0 ? lines.slice(1) : lines;
+		} finally {
+			await handle.close();
+		}
+	}
+	/** 逐行解析运行记录；空行跳过，损坏行只丢单行并留痕（不再完全静默）。 */
+	*parseLines(lines) {
+		for (const line of lines) {
+			if (line.length === 0) continue;
+			try {
+				const record = JSON.parse(line);
+				if (typeof record.runId !== "string" || typeof record.status !== "string") continue;
+				yield record;
+			} catch (error) {
+				this.logger?.warn(`auto-flow: dropped damaged run-log line: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+	}
+};
+//#endregion
+//#region src/workflow/pipeline.ts
+/** 脚本节点的兜底硬超时（毫秒）：节点未配 timeout 或填 0 时启用，
+*  防止脚本内部长等待（如元宝图生文动辄数分钟的点击等待）一旦永不满足就把运行永久挂起。 */
+const SCRIPT_NODE_DEFAULT_TIMEOUT_MS = 6e5;
+/** 把任意 JSON 字符串弱化为对象（非法/非对象 → 空对象）。 */
+function parseJsonObject(raw) {
+	if (typeof raw !== "string" || raw.trim() === "") return {};
+	try {
+		const parsed = JSON.parse(raw);
+		if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+	} catch {}
+	return {};
+}
+/** 把聚合得到的产物文件路径按脚本规则整形。 */
+function shapeFiles(files, spec, payload) {
+	if (spec.filesShape === "vidu-imgs") {
+		const raw = payload[spec.filesPromptKey ?? "prompt"];
+		const prompts = typeof raw === "string" && raw !== "" ? [raw] : Array.isArray(raw) ? raw.filter((v) => typeof v === "string") : [];
+		return files.map((imgPath) => ({
+			imgPath,
+			prompts
+		}));
+	}
+	return files;
+}
+/** 按「内联负载 → 直连表单字段 → 直连脚本输出 → 直连脚本文件」装配 payload（与脚本节点 UI 解耦）。 */
+function buildScriptPayload(script, input, artifacts) {
+	const payload = { ...parseJsonObject(input.inline.payload) };
+	Object.assign(payload, input.params);
+	for (const out of Object.values(input.outputs)) Object.assign(payload, out);
+	if (artifacts?.filesKey !== void 0) {
+		const files = Object.values(input.files).flat();
+		if (files.length > 0) payload[artifacts.filesKey] = shapeFiles(files, artifacts, payload);
+	}
+	return payload;
+}
+/** 由脚本节点数据派生本次运行选项（browser 覆写 + 硬超时）。 */
+function buildScriptRunOptions(inline) {
+	const options = {};
+	const headless = inline.headless;
+	const channel = inline.browser;
+	const browser = {};
+	if (typeof headless === "boolean") browser.headless = headless;
+	if (typeof channel === "string" && channel !== "") browser.channel = channel;
+	if (browser.headless !== void 0 || browser.channel !== void 0) options.browser = browser;
+	const timeout = inline.timeout;
+	if (typeof timeout === "number" && Number.isFinite(timeout) && timeout > 0) options.timeoutMs = timeout;
+	else options.timeoutMs = SCRIPT_NODE_DEFAULT_TIMEOUT_MS;
+	return options;
+}
+const FORM_NODE_TYPE = "form";
+/** 值传递节点（确定性内容流水线，来自参考项目 my-dsh-plugin 的节点族）。 */
+const PROMPT_NODE_TYPE = "prompt";
+const VISION_NODE_TYPE = "vision";
+const COMMAND_NODE_TYPE = "command";
+const HTTP_NODE_TYPE = "http";
+const CONDITION_NODE_TYPE = "condition";
+const OUTPUT_NODE_TYPE = "output";
+/** AI 智能体节点（硬→软）：把子任务委托给一个子代理（LLM + 工具循环），结果回灌值链。 */
+const AGENT_NODE_TYPE = "agent";
+/** 调用工作流节点（硬→硬复用）：运行另一个已保存工作流并回灌其 Output 值。 */
+const WORKFLOW_NODE_TYPE = "workflow";
+/** 条件节点支持的运算符（安全白名单，不做任意 JS 求值）。 */
+const CONDITION_OPERATORS = [
+	"equals",
+	"notEquals",
+	"contains",
+	"exists",
+	"truthy"
+];
+/** 读取节点的实际类型：优先 data.nodeType，回退 React Flow 的 type。 */
+function nodeTypeOf(node) {
+	return typeof node.data.nodeType === "string" ? node.data.nodeType : node.type;
+}
+/** 表单节点 data 去掉 nodeType / fields 元键后的字段值对象。 */
+function formFieldsOf(data) {
+	const out = {};
+	for (const [key, value] of Object.entries(data)) {
+		if (key === "nodeType" || key === "fields") continue;
+		out[key] = value;
+	}
+	return out;
+}
+/**
+* 沿入边向上游遍历（穿越审批节点——审批是数据通道），对遇到的表单节点 / 脚本节点各回调一次。
+* 静态校验（missingRequiredParams）与运行时聚合（engine.collectInputs）共用，避免两处各写一遍遍历。
+*/
+function walkUpstream(flow, nodeId, nodesById, onForm, onScript) {
+	const visited = /* @__PURE__ */ new Set([nodeId]);
+	const stack = [nodeId];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		for (const edge of flow.edges) {
+			if (edge.target !== current) continue;
+			const source = nodesById.get(edge.source);
+			if (source === void 0 || visited.has(source.id)) continue;
+			const type = nodeTypeOf(source);
+			if (type === "form") {
+				visited.add(source.id);
+				onForm(source);
+			} else if (type === "pw-script") {
+				visited.add(source.id);
+				onScript(source);
+			} else if (type === "approval") {
+				visited.add(source.id);
+				stack.push(source.id);
+			}
+		}
+	}
+}
+/** 节点展示名（脚本节点按 data.script + 脚本展示名定位）。 */
+function nodeLabel(nodeType, script, label) {
+	if (nodeType === "form") return "表单参数";
+	if (nodeType === "approval") return "人工审批";
+	if (nodeType === "pw-script") {
+		if (script !== void 0 && script !== "") return label ?? script;
+		return "运行脚本";
+	}
+	if (nodeType === "prompt") return "文本模板";
+	if (nodeType === "llm") return "AI 模型";
+	if (nodeType === "agent") return "AI 智能体";
+	if (nodeType === "workflow") return "调用工作流";
+	if (nodeType === "vision") return "图片识别";
+	if (nodeType === "command") return "执行命令";
+	if (nodeType === "http") return "HTTP 请求";
+	if (nodeType === "condition") return "条件分支";
+	if (nodeType === "output") return "输出";
+	return nodeType;
+}
+const TEMPLATE_REFERENCE_PATTERN = /{{\s*([^{}]+?)\s*}}/g;
+/** 从模板字符串提取全部变量引用（按出现顺序，去首尾空白）。 */
+function templateReferences(template) {
+	return [...template.matchAll(TEMPLATE_REFERENCE_PATTERN)].map((match) => match[1].trim());
+}
+/** 把任意 JSON 值弱化为字符串（字符串原样，其余 JSON 序列化）。 */
+function stringify(value) {
+	return typeof value === "string" ? value : JSON.stringify(value) ?? "";
+}
+/**
+* 读取一条点分变量路径：`current`、`input`、`input.*` 或 `steps.<nodeId>[.*]`。
+* 任一段缺失返回 undefined（模板插值时降级为空串）。
+*/
+function readPath(path, input, steps, current) {
+	if (path === "current") return current;
+	if (path === "input") return input;
+	const parts = path.split(".");
+	let value;
+	if (parts[0] === "input") value = input;
+	else if (parts[0] === "steps") value = steps[parts[1] ?? ""];
+	else return void 0;
+	for (const part of parts.slice(parts[0] === "steps" ? 2 : 1)) {
+		if (value === null || value === void 0 || typeof value !== "object" || Array.isArray(value)) return void 0;
+		value = Object.prototype.hasOwnProperty.call(value, part) ? value[part] : void 0;
+	}
+	return value;
+}
+/** 解析一个模板：精确引用（整串是 {{x}}）保留 JSON 类型，插值处一律转字符串。 */
+function resolveValue(source, input, steps, current) {
+	const exact = source.match(/^{{\s*([^{}]+?)\s*}}$/);
+	if (exact !== null) return readPath(exact[1].trim(), input, steps, current);
+	return renderText(source, input, steps, current);
+}
+/** 把模板渲染为文本：所有 `{{...}}` 引用以字符串展开。 */
+function renderText(source, input, steps, current) {
+	return source.replace(TEMPLATE_REFERENCE_PATTERN, (_match, path) => stringify(readPath(path.trim(), input, steps, current) ?? ""));
+}
+/** 构造直接 LLM 节点的提示词：含模板则原样渲染，否则在末尾追加当前输入。 */
+function promptFor(source, input, steps, current) {
+	return TEMPLATE_REFERENCE_PATTERN.test(source) ? renderText(source, input, steps, current) : `${source}\n\nInput:\n${stringify(current)}`;
+}
+/** 按边做拓扑排序（Kahn），返回节点 id 顺序；无依赖/孤立节点按出现顺序追加。 */
+function topoSortNodeIds(flow) {
+	const nodes = flow.nodes;
+	const indegree = new Map(nodes.map((n) => [n.id, 0]));
+	const out = new Map(nodes.map((n) => [n.id, []]));
+	for (const edge of flow.edges) {
+		if (!indegree.has(edge.source) || !indegree.has(edge.target)) continue;
+		out.get(edge.source).push(edge.target);
+		indegree.set(edge.target, (indegree.get(edge.target) ?? 0) + 1);
+	}
+	const queue = [];
+	for (const [id, degree] of indegree) if (degree === 0) queue.push(id);
+	queue.sort((a, b) => nodes.findIndex((n) => n.id === a) - nodes.findIndex((n) => n.id === b));
+	const result = [];
+	while (queue.length > 0) {
+		const id = queue.shift();
+		result.push(id);
+		for (const next of out.get(id) ?? []) {
+			const degree = (indegree.get(next) ?? 0) - 1;
+			indegree.set(next, degree);
+			if (degree === 0) queue.push(next);
+		}
+		queue.sort((a, b) => nodes.findIndex((n) => n.id === a) - nodes.findIndex((n) => n.id === b));
+	}
+	const seen = new Set(result);
+	for (const node of nodes) if (!seen.has(node.id)) result.push(node.id);
+	return result;
+}
+/**
+* 检测工作流画布中是否存在环（DFS 三色 + 回溯路径）。
+* 返回构成环的节点 id 列表（首尾同 id，便于展示）；无环返回 null。
+*/
+function detectCycle(flow) {
+	const adj = new Map(flow.nodes.map((n) => [n.id, []]));
+	const nodeIds = new Set(flow.nodes.map((n) => n.id));
+	for (const edge of flow.edges) if (nodeIds.has(edge.source) && nodeIds.has(edge.target)) adj.get(edge.source).push(edge.target);
+	const WHITE = 0;
+	const GRAY = 1;
+	const BLACK = 2;
+	const color = new Map(flow.nodes.map((n) => [n.id, WHITE]));
+	const stack = [];
+	const dfs = (u) => {
+		color.set(u, GRAY);
+		stack.push(u);
+		for (const v of adj.get(u) ?? []) if (color.get(v) === WHITE) {
+			const cycle = dfs(v);
+			if (cycle !== null) return cycle;
+		} else if (color.get(v) === GRAY) {
+			const start = stack.indexOf(v);
+			return [...stack.slice(start), v];
+		}
+		stack.pop();
+		color.set(u, BLACK);
+		return null;
+	};
+	for (const node of flow.nodes) if (color.get(node.id) === WHITE) {
+		const cycle = dfs(node.id);
+		if (cycle !== null) return cycle;
+	}
+	return null;
+}
+/** 由画布构建运行步骤列表（拓扑序；每个节点一步）；resolveScriptLabel 提供脚本展示名。 */
+function buildRunSteps(flow, resolveScriptLabel) {
+	const nodesById = new Map(flow.nodes.map((n) => [n.id, n]));
+	return topoSortNodeIds(flow).map((nodeId) => {
+		const node = nodesById.get(nodeId);
+		const nodeType = node !== void 0 ? nodeTypeOf(node) : "__unknown__";
+		const script = nodeType === "pw-script" && node !== void 0 && typeof node.data.script === "string" ? node.data.script : void 0;
+		const label = script !== void 0 ? resolveScriptLabel?.(script) : void 0;
+		return {
+			nodeId,
+			nodeType,
+			...script !== void 0 ? { script } : {},
+			label: nodeLabel(nodeType, script, label),
+			status: "pending"
+		};
+	});
+}
+/** 值是否「空」（视为未填）。 */
+function isEmptyValue(value) {
+	return value === void 0 || value === null || value === "";
+}
+/**
+* 运行前静态校验：找出「必填参数在当前画布里确定无法满足」的脚本节点。
+* 只做确定性的静态判断，绝不误报：
+* - 内联 payload JSON 提供该 key 且非空 → 满足；
+* - 直连（穿越审批）表单提供该 key 且非空 → 满足；
+* - 存在直连（穿越审批）上游脚本 → 该节点的必填参数整体视为「运行时再校验」，跳过；
+* - 其余视为缺失。
+*/
+function missingRequiredParams(flow, paramsByScript) {
+	const nodesById = new Map(flow.nodes.map((n) => [n.id, n]));
+	const missing = [];
+	for (const node of flow.nodes) {
+		if (nodeTypeOf(node) !== "pw-script") continue;
+		const script = typeof node.data.script === "string" ? node.data.script : "";
+		if (script === "") continue;
+		const params = paramsByScript.get(script);
+		if (params === void 0) continue;
+		const upstream = staticUpstream(flow, node.id, nodesById);
+		if (upstream.hasScript) continue;
+		const inline = parseJsonObject(node.data.payload);
+		for (const param of params) {
+			if (param.required !== true) continue;
+			if (!isEmptyValue(inline[param.key]) || !isEmptyValue(upstream.formValues[param.key])) continue;
+			missing.push({
+				nodeId: node.id,
+				script,
+				param: param.key
+			});
+		}
+	}
+	return missing;
+}
+/** 收集某脚本节点的直连上游（穿越审批节点）：表单字段值 + 是否存在上游脚本。 */
+function staticUpstream(flow, nodeId, nodesById) {
+	const formValues = {};
+	let hasScript = false;
+	walkUpstream(flow, nodeId, nodesById, (source) => Object.assign(formValues, formFieldsOf(source.data)), () => {
+		hasScript = true;
+	});
+	return {
+		formValues,
+		hasScript
+	};
+}
+//#endregion
+//#region src/workflow/validation.ts
+/** 值节点里参与 {{...}} 模板的字段（用于引用校验）。 */
+const VALUE_TEMPLATE_KEYS = {
+	[PROMPT_NODE_TYPE]: ["template"],
+	["llm"]: ["prompt"],
+	[AGENT_NODE_TYPE]: ["task"],
+	[VISION_NODE_TYPE]: ["image", "instruction"],
+	[COMMAND_NODE_TYPE]: ["command"],
+	[HTTP_NODE_TYPE]: [
+		"url",
+		"headers",
+		"body"
+	],
+	[CONDITION_NODE_TYPE]: ["left", "right"],
+	[OUTPUT_NODE_TYPE]: ["value"],
+	[WORKFLOW_NODE_TYPE]: ["args"]
+};
+/** 运行前结构化校验：返回结构化诊断（不抛错）。 */
+function validateFlow(flow, paramsByScript = /* @__PURE__ */ new Map()) {
+	const diagnostics = [];
+	const nodesById = new Map(flow.nodes.map((n) => [n.id, n]));
+	const cycle = detectCycle(flow);
+	if (cycle !== null) diagnostics.push({
+		level: "error",
+		code: "cycle",
+		message: `工作流存在环：${cycle.join(" → ")}`
+	});
+	const nodeIds = /* @__PURE__ */ new Set();
+	for (const node of flow.nodes) if (nodeIds.has(node.id)) diagnostics.push({
+		level: "error",
+		code: "duplicate-node-id",
+		message: `节点 ID 重复：${node.id}`,
+		nodeId: node.id
+	});
+	else nodeIds.add(node.id);
+	const edgeIds = /* @__PURE__ */ new Set();
+	for (const edge of flow.edges) {
+		if (edgeIds.has(edge.id)) diagnostics.push({
+			level: "error",
+			code: "duplicate-edge-id",
+			message: `连线 ID 重复：${edge.id}`,
+			edgeId: edge.id
+		});
+		else edgeIds.add(edge.id);
+		if (edge.source === edge.target) diagnostics.push({
+			level: "error",
+			code: "self-edge",
+			message: "节点不能连接到自身",
+			edgeId: edge.id
+		});
+	}
+	for (const edge of flow.edges) {
+		const source = nodesById.get(edge.source);
+		if (source === void 0) continue;
+		if ((typeof source.data.nodeType === "string" ? source.data.nodeType : source.type) !== "condition") continue;
+		if (edge.sourceHandle !== "true" && edge.sourceHandle !== "false") diagnostics.push({
+			level: "error",
+			code: "condition-edge-handle",
+			message: "条件分支连线必须从 true 或 false 端口发出",
+			edgeId: edge.id
+		});
+	}
+	for (const node of flow.nodes) {
+		if ((typeof node.data.nodeType === "string" ? node.data.nodeType : node.type) !== "pw-script") continue;
+		if (typeof node.data.script !== "string" || node.data.script === "") diagnostics.push({
+			level: "error",
+			code: "blank-script",
+			message: "运行脚本节点未选择脚本",
+			nodeId: node.id
+		});
+	}
+	for (const node of flow.nodes) {
+		if ((typeof node.data.nodeType === "string" ? node.data.nodeType : node.type) !== "agent") continue;
+		if (typeof node.data.task !== "string" || node.data.task.trim() === "") diagnostics.push({
+			level: "error",
+			code: "blank-task",
+			message: "AI 智能体节点未填写任务",
+			nodeId: node.id
+		});
+	}
+	for (const missing of missingRequiredParams(flow, paramsByScript)) diagnostics.push({
+		level: "error",
+		code: "missing-required-param",
+		message: `${missing.script} 缺少必填参数 ${missing.param}`,
+		nodeId: missing.nodeId
+	});
+	for (const node of flow.nodes) {
+		const type = typeof node.data.nodeType === "string" ? node.data.nodeType : node.type;
+		const blank = (key) => typeof node.data[key] !== "string" || node.data[key].trim() === "";
+		if (type === "prompt" && blank("template")) diagnostics.push({
+			level: "error",
+			code: "blank-prompt-template",
+			message: "文本模板节点的模板不能为空",
+			nodeId: node.id
+		});
+		else if (type === "llm" && blank("prompt")) diagnostics.push({
+			level: "error",
+			code: "blank-llm-prompt",
+			message: "AI 模型节点的提示词不能为空",
+			nodeId: node.id
+		});
+		else if (type === "vision") {
+			if (node.data.skipWhenNoImage !== true && blank("image")) diagnostics.push({
+				level: "error",
+				code: "blank-vision-image",
+				message: "图片识别节点的图片路径不能为空",
+				nodeId: node.id
+			});
+			if (blank("instruction")) diagnostics.push({
+				level: "error",
+				code: "blank-vision-instruction",
+				message: "图片识别节点的识别指令不能为空",
+				nodeId: node.id
+			});
+			if (blank("provider")) diagnostics.push({
+				level: "error",
+				code: "blank-vision-provider",
+				message: "图片识别节点的模型路由不能为空",
+				nodeId: node.id
+			});
+			if (blank("model")) diagnostics.push({
+				level: "error",
+				code: "blank-vision-model",
+				message: "图片识别节点的模型不能为空",
+				nodeId: node.id
+			});
+		} else if (type === "command" && blank("command")) diagnostics.push({
+			level: "error",
+			code: "blank-command-line",
+			message: "执行命令节点的命令不能为空",
+			nodeId: node.id
+		});
+		else if (type === "http" && blank("url")) diagnostics.push({
+			level: "error",
+			code: "blank-http-url",
+			message: "HTTP 请求节点的地址不能为空",
+			nodeId: node.id
+		});
+		else if (type === "condition" && blank("left")) diagnostics.push({
+			level: "error",
+			code: "blank-condition-left",
+			message: "条件分支节点的左值不能为空",
+			nodeId: node.id
+		});
+		else if (type === "output" && blank("value")) diagnostics.push({
+			level: "error",
+			code: "blank-output-value",
+			message: "输出节点的返回值不能为空",
+			nodeId: node.id
+		});
+		else if (type === "workflow" && blank("workflowId")) diagnostics.push({
+			level: "error",
+			code: "blank-workflow-id",
+			message: "调用工作流节点未选择目标工作流",
+			nodeId: node.id
+		});
+	}
+	for (const node of flow.nodes) {
+		const type = typeof node.data.nodeType === "string" ? node.data.nodeType : node.type;
+		const keys = VALUE_TEMPLATE_KEYS[type];
+		if (keys === void 0) continue;
+		for (const key of keys) {
+			const raw = node.data[key];
+			if (typeof raw !== "string") continue;
+			for (const ref of templateReferences(raw)) {
+				if (ref === "current" || ref === "input") continue;
+				if (ref.startsWith("input.")) continue;
+				if (ref.startsWith("steps.")) {
+					const target = ref.slice(6).split(".")[0];
+					if (!nodesById.has(target)) diagnostics.push({
+						level: "error",
+						code: "unknown-step-reference",
+						message: `变量引用不存在的节点：${target}`,
+						nodeId: node.id
+					});
+					else if (target === node.id) diagnostics.push({
+						level: "error",
+						code: "self-step-reference",
+						message: "节点不能引用自身尚未生成的输出",
+						nodeId: node.id
+					});
+					continue;
+				}
+				diagnostics.push({
+					level: "error",
+					code: "unknown-variable-reference",
+					message: `不支持的变量引用：${ref}`,
+					nodeId: node.id
+				});
+			}
+		}
+	}
+	return {
+		valid: diagnostics.every((d) => d.level !== "error"),
+		diagnostics
+	};
+}
+//#endregion
+//#region src/host/workspace.ts
+/**
+* 工作区文件操作（宿主）：引擎在运行中重扫脚本产物文件用。
+* 注意：人工增删改查不再走本插件（用户直接在 dsh 工作区目录里用系统资源管理器 /
+* dsh 文件工具操作），本模块只保留引擎聚合下游脚本产物需要的「列出文件」。
+*/
+/** 不参与产物聚合的元数据文件。 */
+const SKIP_NAMES = /* @__PURE__ */ new Set(["task.json"]);
+/** 递归列出根目录下所有产物文件（相对路径相对 rootDir；跳过 task.json）。 */
+async function listWorkspaceFiles(rootDir) {
+	const files = [];
+	async function walk(dir) {
+		let entries;
+		try {
+			entries = await promises.readdir(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const full = path.join(dir, entry.name);
+			if (entry.isDirectory()) {
+				await walk(full);
+				continue;
+			}
+			if (!entry.isFile() || SKIP_NAMES.has(entry.name)) continue;
+			const stat = await promises.stat(full).catch(() => null);
+			files.push({
+				path: full,
+				relativePath: path.relative(rootDir, full),
+				name: entry.name,
+				size: stat?.size ?? 0
+			});
+		}
+	}
+	await walk(rootDir);
+	return files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+/** HTTP 节点响应体保留上限（字符）。 */
+const HTTP_NODE_BODY_CAP_CHARS = 1e5;
+/** HTTP 节点超时在 dsh-timeout 里携带的稳定错误码。 */
+const HTTP_TIMEOUT_CODE = "AUTO_FLOW_HTTP_TIMEOUT";
+/** 计算一次条件比较（安全白名单运算符）；JSON 值用 dsh 生态的 deepEqualJson 做结构比较。 */
+function compare(left, operator, right) {
+	if (operator === "equals") return deepEqualJson(left, right);
+	if (operator === "notEquals") return !deepEqualJson(left, right);
+	if (operator === "exists") return left !== void 0 && left !== null;
+	if (operator === "truthy") return Boolean(left);
+	if (operator === "contains") {
+		if (typeof left === "string") return left.includes(String(right ?? ""));
+		if (Array.isArray(left)) return left.some((item) => deepEqualJson(item, right));
+		return false;
+	}
+	return false;
+}
+/** 确定性错误码：重试必失败，不做无谓重试（其余/无码一律视为瞬态、可重试）。 */
+const NON_RETRYABLE_CODES = /* @__PURE__ */ new Set(["SCRIPT_NOT_FOUND", "SCRIPT_PARAM_ERROR"]);
+/** 判断运行是否被外部取消（cancelRun 在服务层设置，引擎内部不做此赋值，故经独立函数读取避免 TS 收窄）。 */
+function isCancelled(state) {
+	return state.status === "cancelled";
+}
+var WorkflowEngine = class {
+	deps;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/** 运行入口：发出 run-start，执行图，最后按终态发出 run-end（观察者失败不影响运行）。 */
+	async run(state, flow) {
+		this.emit("auto-flow/run-start", {
+			runId: state.runId,
+			nodeCount: state.steps.length
+		});
+		await this.runInner(state, flow);
+		const result = runResultOf(state);
+		this.emit("auto-flow/run-end", {
+			runId: state.runId,
+			stopReason: state.status,
+			...result !== void 0 ? { result } : {}
+		});
+	}
+	/** 发出一次生命周期事件；观察者抛错一律吞掉，绝不影响本次运行。 */
+	emit(type, payload) {
+		try {
+			this.deps.emit?.(type, payload);
+		} catch {}
+	}
+	/** 运行是否被取消：显式状态（cancelRun）或运行级信号已中止。 */
+	cancelled(state) {
+		return isCancelled(state) || this.deps.signal?.aborted === true;
+	}
+	/** 把运行标记为已取消并持久化（幂等；cancelRun 已置位时跳过）。 */
+	markCancelled(state) {
+		if (state.status === "cancelled") return;
+		state.status = "cancelled";
+		this.update(state);
+	}
+	async runInner(state, flow) {
+		const nodesById = new Map(flow.nodes.map((n) => [n.id, n]));
+		const ctx = new RunContext(state.workspaceDir);
+		const steps = state.steps;
+		const n = steps.length;
+		const indexOf = new Map(steps.map((s, i) => [s.nodeId, i]));
+		const upstream = Array.from({ length: n }, () => []);
+		for (const edge of flow.edges) {
+			const s = indexOf.get(edge.source);
+			const t = indexOf.get(edge.target);
+			if (s !== void 0 && t !== void 0 && s !== t) upstream[t].push(s);
+		}
+		const level = Array.from({ length: n }, () => 0);
+		for (let i = 0; i < n; i++) {
+			let maxUp = -1;
+			for (const s of upstream[i]) maxUp = Math.max(maxUp, level[s]);
+			level[i] = maxUp + 1;
+		}
+		const byLevel = /* @__PURE__ */ new Map();
+		for (let i = 0; i < n; i++) {
+			const lv = level[i];
+			const list = byLevel.get(lv);
+			if (list === void 0) byLevel.set(lv, [i]);
+			else list.push(i);
+		}
+		const levels = [...byLevel.keys()].sort((a, b) => a - b);
+		const values = {};
+		const started = /* @__PURE__ */ new Set();
+		const completed = /* @__PURE__ */ new Set();
+		const input = collectWorkflowInput(flow);
+		/** 一条边是否仍活跃：源节点已开始执行；条件节点只看所选分支（true/false 源句柄）。 */
+		const edgeActive = (edge) => {
+			if (!started.has(edge.source)) return false;
+			const source = nodesById.get(edge.source);
+			if (source === void 0) return false;
+			if (nodeTypeOf(source) !== "condition") return true;
+			return values[edge.source] === (edge.sourceHandle === "true");
+		};
+		/** 节点的「当前值」= 拓扑序最大的活跃前驱输出；无前驱（入口）时取全局输入。 */
+		const primaryValue = (nodeId) => {
+			const incoming = flow.edges.filter((e) => e.target === nodeId && edgeActive(e));
+			let primary;
+			let best = -1;
+			for (const e of incoming) {
+				const idx = indexOf.get(e.source) ?? -1;
+				if (idx > best) {
+					best = idx;
+					primary = e.source;
+				}
+			}
+			if (primary === void 0) return input;
+			return values[primary] ?? null;
+		};
+		for (const lv of levels) {
+			if (this.cancelled(state)) {
+				this.markCancelled(state);
+				return;
+			}
+			const batch = byLevel.get(lv);
+			const runnable = [];
+			for (const i of batch) {
+				const step = steps[i];
+				if (nodesById.get(step.nodeId) === void 0) {
+					step.status = "skipped";
+					step.error = "节点不存在";
+					continue;
+				}
+				if (!(upstream[i].length === 0 || flow.edges.some((e) => e.target === step.nodeId && edgeActive(e)))) {
+					step.status = "skipped";
+					continue;
+				}
+				runnable.push(i);
+			}
+			const valueIdx = [];
+			const approvalIdx = [];
+			const scriptIdx = [];
+			for (const i of runnable) {
+				const t = nodeTypeOf(nodesById.get(steps[i].nodeId));
+				if (t === "approval") approvalIdx.push(i);
+				else if (t === "pw-script") scriptIdx.push(i);
+				else valueIdx.push(i);
+			}
+			if (valueIdx.length > 0) {
+				for (const i of valueIdx) {
+					const step = steps[i];
+					started.add(step.nodeId);
+					step.status = "running";
+					this.emit("auto-flow/node-start", {
+						runId: state.runId,
+						nodeId: step.nodeId,
+						nodeType: step.nodeType,
+						label: step.label
+					});
+				}
+				this.update(state);
+				const results = await Promise.allSettled(valueIdx.map((i) => {
+					const step = steps[i];
+					const node = nodesById.get(step.nodeId);
+					return this.executeValueNode(nodeTypeOf(node), node, input, values, primaryValue(step.nodeId));
+				}));
+				if (this.cancelled(state)) {
+					this.markCancelled(state);
+					return;
+				}
+				for (let k = 0; k < valueIdx.length; k++) {
+					const step = steps[valueIdx[k]];
+					const r = results[k];
+					if (r.status === "fulfilled") {
+						values[step.nodeId] = r.value;
+						step.result = r.value;
+						step.status = "success";
+						completed.add(step.nodeId);
+						this.emit("auto-flow/node-result", {
+							runId: state.runId,
+							nodeId: step.nodeId,
+							nodeType: step.nodeType,
+							label: step.label,
+							ok: true,
+							output: r.value
+						});
+					} else {
+						const error = r.reason instanceof Error ? r.reason.message : String(r.reason);
+						step.status = "failed";
+						step.error = error;
+						this.emit("auto-flow/node-result", {
+							runId: state.runId,
+							nodeId: step.nodeId,
+							nodeType: step.nodeType,
+							label: step.label,
+							ok: false,
+							error
+						});
+						state.status = "failed";
+						this.update(state);
+						return;
+					}
+				}
+			}
+			for (const i of approvalIdx) {
+				const step = steps[i];
+				started.add(step.nodeId);
+				this.emit("auto-flow/node-start", {
+					runId: state.runId,
+					nodeId: step.nodeId,
+					nodeType: step.nodeType,
+					label: step.label
+				});
+				await this.runApproval(state, step, nodesById.get(step.nodeId));
+				if (state.status === "failed" || state.status === "cancelled") {
+					this.emit("auto-flow/node-result", {
+						runId: state.runId,
+						nodeId: step.nodeId,
+						nodeType: step.nodeType,
+						label: step.label,
+						ok: false,
+						...step.error !== void 0 ? { error: step.error } : {}
+					});
+					return;
+				}
+				const value = primaryValue(step.nodeId);
+				values[step.nodeId] = value;
+				step.result = value;
+				completed.add(step.nodeId);
+				this.emit("auto-flow/node-result", {
+					runId: state.runId,
+					nodeId: step.nodeId,
+					nodeType: step.nodeType,
+					label: step.label,
+					ok: true,
+					output: value
+				});
+			}
+			if (scriptIdx.length > 0) {
+				for (const i of scriptIdx) started.add(steps[i].nodeId);
+				const limit = this.deps.maxConcurrency ?? 4;
+				const results = [];
+				for (let start = 0; start < scriptIdx.length; start += limit) {
+					const chunk = scriptIdx.slice(start, start + limit);
+					const chunkResults = await Promise.allSettled(chunk.map((i) => this.runScriptStep(state, steps[i], nodesById.get(steps[i].nodeId), flow, nodesById, ctx, i, input, values, primaryValue(steps[i].nodeId))));
+					results.push(...chunkResults);
+				}
+				if (this.cancelled(state)) {
+					this.markCancelled(state);
+					return;
+				}
+				let failed = false;
+				for (let k = 0; k < scriptIdx.length; k++) {
+					const step = steps[scriptIdx[k]];
+					if (step.status === "failed") {
+						failed = true;
+						continue;
+					}
+					const r = results[k];
+					if (r.status === "rejected") {
+						step.status = "failed";
+						step.error = r.reason instanceof Error ? r.reason.message : String(r.reason);
+						failed = true;
+					} else if (r.value.ok === false) {
+						step.status = "failed";
+						step.error = r.value.error;
+						failed = true;
+					} else {
+						values[step.nodeId] = step.result ?? {};
+						completed.add(step.nodeId);
+					}
+				}
+				if (failed) {
+					state.status = "failed";
+					this.update(state);
+					return;
+				}
+			}
+			this.update(state);
+		}
+		if (this.cancelled(state)) {
+			this.markCancelled(state);
+			return;
+		}
+		state.status = "completed";
+		this.update(state);
+	}
+	/** 执行一个值节点（form/prompt/llm/vision/command/http/condition/output），返回其输出值。 */
+	async executeValueNode(nodeType, node, input, values, current) {
+		const d = node.data;
+		switch (nodeType) {
+			case FORM_NODE_TYPE: return formFieldsOf(d);
+			case PROMPT_NODE_TYPE: return renderText(asString(d.template), input, values, current);
+			case OUTPUT_NODE_TYPE: return resolveValue(asString(d.value), input, values, current) ?? null;
+			case CONDITION_NODE_TYPE: {
+				const left = resolveValue(asString(d.left), input, values, current);
+				const right = resolveValue(asString(d.right), input, values, current);
+				return compare(left, asConditionOperator(d.operator), right);
+			}
+			case "llm": return this.runLlmNode(node, input, values, current);
+			case AGENT_NODE_TYPE: return this.runAgentNode(node, input, values, current);
+			case WORKFLOW_NODE_TYPE: return this.runWorkflowNode(node, input, values, current);
+			case VISION_NODE_TYPE: return this.runVisionNode(node, input, values, current);
+			case COMMAND_NODE_TYPE: return this.runCommandNode(node, input, values, current);
+			case HTTP_NODE_TYPE: return this.runHttpNode(node, input, values, current);
+			default: throw new Error(`未知节点类型: ${nodeType}`);
+		}
+	}
+	/** 直接 LLM 调用（单次，无 agent 循环）。 */
+	async runLlmNode(node, input, values, current) {
+		const llm = this.deps.llm;
+		if (llm === void 0) throw new Error("AI 模型节点需要 LLM 服务，但当前部署未提供");
+		const d = node.data;
+		const promptText = promptFor(asString(d.prompt), input, values, current);
+		const provider = asString(d.provider);
+		const model = asString(d.model);
+		let resolvedProvider = provider;
+		let resolvedModel = model;
+		if (resolvedProvider === "" || resolvedModel === "") {
+			const fallback = this.deps.agentDefaultModel?.currentSelection();
+			resolvedProvider = resolvedProvider === "" ? fallback?.provider.trim() ?? "" : resolvedProvider;
+			resolvedModel = resolvedModel === "" ? fallback?.model.trim() ?? "" : resolvedModel;
+		}
+		if (resolvedProvider === "" || resolvedModel === "") throw new Error("AI 模型节点未配置 provider / model，且部署无默认模型");
+		const maxTokens = asNumber(d.maxTokens);
+		const stream = llm.stream({
+			provider: resolvedProvider,
+			model: resolvedModel,
+			messages: [createUserMessage({
+				content: [{
+					type: "text",
+					text: promptText
+				}],
+				source: {
+					kind: "plugin",
+					plugin: "dsh-auto-flow"
+				}
+			})],
+			...maxTokens !== void 0 ? { maxTokens } : {},
+			...this.deps.signal !== void 0 ? { signal: this.deps.signal } : {}
+		});
+		const collected = await this.collectLlmText(stream);
+		if (!collected.ok) throw new Error(`AI 模型调用失败：${collected.error}`);
+		return collected.text;
+	}
+	/** AI 智能体节点：把子任务委托给子代理（LLM + 工具循环），结果回灌值链。 */
+	async runAgentNode(node, input, values, current) {
+		const agent = this.deps.agent;
+		if (agent === void 0) throw new Error("AI 智能体节点需要子代理能力：请由 agent 触发（workflow_run），且部署已组合 subagents 服务");
+		const d = node.data;
+		const task = promptFor(asString(d.task), input, values, current).trim();
+		if (task === "") throw new Error("AI 智能体节点的任务为空");
+		const provider = asString(d.provider);
+		const model = asString(d.model);
+		const outcome = await agent.run(task, {
+			label: node.id,
+			...provider !== "" ? { provider } : {},
+			...model !== "" ? { model } : {}
+		});
+		if (!outcome.ok) throw new Error(`AI 智能体执行失败：${outcome.error ?? "未知错误"}`);
+		return outcome.text ?? "";
+	}
+	/** 调用另一个已保存工作流：渲染 args（JSON 对象）→ 嵌套运行 → 回灌其 Output 值。 */
+	async runWorkflowNode(node, input, values, current) {
+		const runWorkflow = this.deps.runWorkflow;
+		if (runWorkflow === void 0) throw new Error("调用工作流节点需要运行能力，但当前部署未提供");
+		const d = node.data;
+		const workflowId = asString(d.workflowId).trim();
+		if (workflowId === "") throw new Error("调用工作流节点的目标工作流为空");
+		const argsRaw = asString(d.args);
+		let args = {};
+		if (argsRaw !== "") {
+			const rendered = renderText(argsRaw, input, values, current).trim();
+			if (rendered !== "") try {
+				const parsed = JSON.parse(rendered);
+				if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) args = parsed;
+			} catch {
+				throw new Error("调用工作流节点的参数不是合法 JSON 对象");
+			}
+		}
+		const outcome = await runWorkflow(workflowId, args);
+		if (!outcome.ok) throw new Error(outcome.error ?? "调用工作流失败");
+		return outcome.result ?? null;
+	}
+	/** 图片识别：宿主读文件 → 附件存储 → 一次视觉模型调用。 */
+	async runVisionNode(node, input, values, current) {
+		const llm = this.deps.llm;
+		if (llm === void 0) throw new Error("图片识别节点需要 LLM 服务，但当前部署未提供");
+		const d = node.data;
+		const imagePath = renderText(asString(d.image), input, values, current).trim();
+		if (imagePath === "" && d.skipWhenNoImage === true) return current;
+		const instruction = renderText(asString(d.instruction), input, values, current);
+		if (imagePath === "") throw new Error("图片识别节点的图片路径为空");
+		const attachments = this.deps.attachments;
+		if (attachments === void 0) throw new Error("图片识别节点需要附件存储，但当前部署未提供");
+		const provider = asString(d.provider);
+		const model = asString(d.model);
+		if (provider === "" || model === "") throw new Error("图片识别节点未配置 provider / model");
+		let bytes;
+		try {
+			bytes = await readFile(imagePath);
+		} catch {
+			throw new Error(`图片识别节点无法读取图片：${imagePath}`);
+		}
+		const mediaType = mediaTypeOfPath(imagePath);
+		if (mediaType === void 0) throw new Error(`图片识别节点的图片不是受支持类型：${imagePath}`);
+		const saved = await attachments.saveImage({
+			data: bytes,
+			mediaType,
+			name: node.id
+		});
+		const stream = llm.stream({
+			provider,
+			model,
+			messages: [createUserMessage({
+				content: [{
+					type: "image",
+					attachment: { attachmentId: saved.attachmentId }
+				}, {
+					type: "text",
+					text: instruction
+				}],
+				source: {
+					kind: "plugin",
+					plugin: "dsh-auto-flow"
+				}
+			})]
+		});
+		const collected = await this.collectLlmText(stream);
+		if (!collected.ok) throw new Error(`图片识别调用失败：${collected.error}`);
+		return collected.text;
+	}
+	/** 确定性 shell 命令执行。 */
+	async runCommandNode(node, input, values, current) {
+		const shell = this.deps.shell;
+		if (shell === void 0) throw new Error("执行命令节点需要 shell 服务，但当前部署未提供");
+		const d = node.data;
+		const command = renderText(asString(d.command), input, values, current).trim();
+		if (command === "") throw new Error("执行命令节点的命令为空");
+		const workdir = asString(d.workdir);
+		const timeoutMs = asNumber(d.timeoutMs);
+		const sandboxMode = asString(d.sandboxMode);
+		const spec = shell.resolve({
+			command,
+			...workdir === "" ? {} : { workdir },
+			...timeoutMs !== void 0 ? { timeoutMs } : {},
+			...sandboxMode === "" ? {} : { sandboxPolicy: {
+				mode: sandboxMode,
+				workspaceRoot: process.cwd()
+			} },
+			...this.deps.signal !== void 0 ? { signal: this.deps.signal } : {}
+		});
+		const result = await shell.run(spec);
+		if (result.sandbox?.denied === true) throw new Error("执行命令被沙箱拒绝");
+		if (result.timedOut) throw new Error(`执行命令超时（${result.timeoutMs ?? timeoutMs ?? "默认"} ms）`);
+		if (result.aborted) throw new Error("执行命令已中止");
+		if (result.exitCode !== 0) {
+			const detail = [result.stderr.text.trim(), result.stdout.text.trim()].filter((line) => line !== "").join("\n");
+			throw new Error(`命令退出码 ${String(result.exitCode)}${detail === "" ? "" : `：\n${detail}`}`);
+		}
+		return result.stdout.text.trim();
+	}
+	/** 确定性 HTTP 请求（超时 + 响应截断）。 */
+	async runHttpNode(node, input, values, current) {
+		const d = node.data;
+		const url = renderText(asString(d.url), input, values, current).trim();
+		if (url === "") throw new Error("HTTP 请求节点的地址为空");
+		const method = asString(d.method) || "GET";
+		let headers;
+		const headersRaw = asString(d.headers);
+		if (headersRaw !== "") {
+			const rendered = renderText(headersRaw, input, values, current).trim();
+			try {
+				const parsed = JSON.parse(rendered);
+				if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error();
+				headers = parsed;
+			} catch {
+				throw new Error("HTTP 请求节点的请求头不是合法 JSON 对象");
+			}
+		}
+		const bodyRaw = asString(d.body);
+		const body = bodyRaw === "" ? void 0 : renderText(bodyRaw, input, values, current);
+		const timeoutMs = asNumber(d.timeoutMs) ?? 3e4;
+		const fused = deadline(this.deps.signal, timeoutMs, HTTP_TIMEOUT_CODE);
+		const controller = new AbortController();
+		const onAbort = () => controller.abort();
+		if (fused.signal.aborted) onAbort();
+		else fused.signal.addEventListener("abort", onAbort, { once: true });
+		try {
+			const response = await fetch(url, {
+				method,
+				...headers === void 0 ? {} : { headers },
+				...body === void 0 ? {} : { body },
+				signal: controller.signal
+			});
+			const text = (await response.text()).slice(0, HTTP_NODE_BODY_CAP_CHARS);
+			const bodyText = text.length === 1e5 ? `${text}…[已截断]` : text;
+			return {
+				status: response.status,
+				ok: response.ok,
+				body: bodyText
+			};
+		} catch (error) {
+			if (timeoutOf(fused.signal, HTTP_TIMEOUT_CODE) !== void 0) throw new Error(`HTTP 请求超时（${timeoutMs} ms）`);
+			if (fused.signal.aborted) throw new Error("HTTP 请求已取消");
+			throw new Error(`HTTP 请求失败：${error instanceof Error ? error.message : String(error)}`);
+		} finally {
+			fused.signal.removeEventListener("abort", onAbort);
+			fused[Symbol.dispose]();
+		}
+	}
+	/** 把一次直接 LLM 流收敛为文本。 */
+	async collectLlmText(stream) {
+		const parts = [];
+		let finishKind;
+		let finishMessage;
+		for await (const chunk of stream) {
+			if (chunk.type === "text-delta" && typeof chunk.text === "string") parts.push(chunk.text);
+			if (chunk.type !== "finish") continue;
+			finishKind = chunk.reason?.kind;
+			finishMessage = chunk.reason?.failure?.message;
+		}
+		if (finishKind === "error" || finishKind === "aborted") return {
+			ok: false,
+			error: finishMessage ?? "模型请求失败"
+		};
+		return {
+			ok: true,
+			text: parts.join("").trim()
+		};
+	}
+	async runApproval(state, step, node) {
+		step.status = "waiting";
+		state.status = "waiting";
+		this.update(state);
+		this.emit("auto-flow/run-need-approval", {
+			runId: state.runId,
+			nodeId: step.nodeId,
+			label: step.label
+		});
+		const options = approvalOptionsOf(node.data);
+		const chosen = await this.deps.waitApproval(step, options);
+		if (isCancelled(state)) return;
+		const matched = options.find((o) => o.label === chosen) ?? {
+			label: chosen,
+			action: "abort"
+		};
+		step.result = matched.label;
+		if (matched.action === "abort") {
+			step.status = "failed";
+			step.error = `审批中止：${matched.label}`;
+			state.status = "failed";
+			this.update(state);
+			return;
+		}
+		step.status = "success";
+		state.status = "running";
+	}
+	async runScriptStep(state, step, node, flow, nodesById, ctx, topoIndex, input, values, current) {
+		step.status = "running";
+		this.update(state);
+		this.emit("auto-flow/node-start", {
+			runId: state.runId,
+			nodeId: step.nodeId,
+			nodeType: step.nodeType,
+			label: step.label
+		});
+		const script = typeof node.data.script === "string" ? node.data.script : "";
+		if (script === "") {
+			step.status = "failed";
+			step.error = "未选择脚本";
+			this.emit("auto-flow/node-result", {
+				runId: state.runId,
+				nodeId: step.nodeId,
+				nodeType: step.nodeType,
+				label: step.label,
+				ok: false,
+				error: "未选择脚本"
+			});
+			return {
+				ok: false,
+				error: "未选择脚本"
+			};
+		}
+		step.script = script;
+		step.stepDir = `${topoIndex}-${script.replaceAll("/", "-")}`;
+		try {
+			const payload = interpolatePayload(buildScriptPayload(script, await this.collectInputs(node, flow, nodesById, ctx), this.deps.resolveArtifacts?.(script)), input, values, current);
+			const outcome = await this.runWithRetry(script, payload, ctx, state, step.stepDir, buildScriptRunOptions(node.data), this.deps.maxRetries ?? 1);
+			step.result = outcome.data;
+			step.durationMs = outcome.durationMs;
+			step.status = outcome.ok ? "success" : "failed";
+			if (!outcome.ok) {
+				step.error = outcome.error;
+				step.errorCode = outcome.code;
+			}
+			this.emit("auto-flow/node-result", {
+				runId: state.runId,
+				nodeId: step.nodeId,
+				nodeType: step.nodeType,
+				label: step.label,
+				ok: outcome.ok,
+				...step.result !== void 0 ? { output: step.result } : {},
+				...!outcome.ok && step.error !== void 0 ? { error: step.error } : {}
+			});
+			return outcome;
+		} catch (err) {
+			step.status = "failed";
+			step.error = err instanceof Error ? err.message : String(err);
+			this.emit("auto-flow/node-result", {
+				runId: state.runId,
+				nodeId: step.nodeId,
+				nodeType: step.nodeType,
+				label: step.label,
+				ok: false,
+				error: step.error
+			});
+			return {
+				ok: false,
+				error: step.error
+			};
+		}
+	}
+	/** 执行脚本并按需重试：仅在失败/抛错时重试，成功立即返回。 */
+	async runWithRetry(script, payload, ctx, state, stepDir, runOptions, maxRetries) {
+		let last = {
+			ok: false,
+			error: "未执行"
+		};
+		for (let attempt = 0; attempt <= maxRetries; attempt++) {
+			try {
+				last = await this.runStep(script, payload, ctx, state, stepDir, runOptions);
+			} catch (err) {
+				last = {
+					ok: false,
+					error: err instanceof Error ? err.message : String(err)
+				};
+			}
+			if (last.ok) return last;
+			if (last.code !== void 0 && NON_RETRYABLE_CODES.has(last.code)) return last;
+		}
+		if (!last.ok && maxRetries > 0) return {
+			ok: false,
+			error: `${last.error}（已重试 ${maxRetries} 次）`
+		};
+		return last;
+	}
+	/**
+	* 聚合「直连上游」（穿越审批节点，审批是数据通道不改变数据流）：
+	* - 表单 → 字段值（参数数据源）；
+	* - 脚本 → 产物文件 + 标量输出（脚本是终止来源，不继续穿越）。
+	*/
+	async collectInputs(node, flow, nodesById, ctx) {
+		const params = {};
+		const scriptNodes = [];
+		walkUpstream(flow, node.id, nodesById, (source) => Object.assign(params, formFieldsOf(source.data)), (source) => {
+			scriptNodes.push(source);
+		});
+		const files = {};
+		const outputs = {};
+		for (const source of scriptNodes) {
+			const sourceScript = typeof source.data.script === "string" ? source.data.script : "";
+			if (sourceScript === "") continue;
+			files[sourceScript] = (await ctx.filesOf(sourceScript)).map((f) => f.path);
+			const out = ctx.outputs[sourceScript];
+			if (out !== void 0 && out.ok) outputs[sourceScript] = out.data;
+		}
+		return {
+			params,
+			files,
+			outputs,
+			inline: node.data
+		};
+	}
+	async runStep(script, payload, ctx, state, stepDir, runOptions) {
+		const outcome = await this.deps.runScript(script, payload, {
+			baseDir: state.workspaceDir,
+			runId: stepDir,
+			...runOptions,
+			...this.deps.signal !== void 0 ? { signal: this.deps.signal } : {}
+		});
+		if (outcome.ok) {
+			const data = asRecord(outcome.data);
+			const dir = path.join(state.workspaceDir, stepDir);
+			ctx.outputs[script] = {
+				script,
+				ok: true,
+				data,
+				stepDir: dir
+			};
+			ctx.stepDirs.set(script, dir);
+			return {
+				ok: true,
+				data,
+				durationMs: outcome.durationMs
+			};
+		}
+		return {
+			ok: false,
+			error: outcome.error,
+			code: outcome.code,
+			durationMs: outcome.durationMs
+		};
+	}
+	update(state) {
+		state.updatedAt = Date.now();
+		this.deps.persist(state);
+	}
+};
+/** 引擎在一次运行中维护的「产物」上下文（脚本返回 data + 落盘目录，供下游聚合取用）。 */
+var RunContext = class {
+	workspaceDir;
+	outputs = {};
+	stepDirs = /* @__PURE__ */ new Map();
+	constructor(workspaceDir) {
+		this.workspaceDir = workspaceDir;
+	}
+	/** 取某脚本「当前」产物文件（人工删改后实时重扫）。 */
+	async filesOf(script) {
+		const dir = this.stepDirs.get(script);
+		if (dir === void 0) return [];
+		return listWorkspaceFiles(dir);
+	}
+};
+/** 把任意 JSON 值弱化为对象（脚本 data 应为对象）。 */
+function asRecord(value) {
+	if (value !== null && typeof value === "object" && !Array.isArray(value)) return value;
+	return {};
+}
+/** 审批节点的默认选项：通过（继续）/ 驳回（中止）。 */
+const DEFAULT_APPROVAL_OPTIONS = [{
+	label: "通过",
+	action: "continue"
+}, {
+	label: "驳回",
+	action: "abort"
+}];
+/** 从审批节点 data.options 解析选项（非法/空则回退默认 通过/驳回）。 */
+function approvalOptionsOf(data) {
+	const raw = data.options;
+	if (Array.isArray(raw)) {
+		const options = [];
+		for (const item of raw) {
+			if (item === null || typeof item !== "object" || Array.isArray(item)) continue;
+			const o = item;
+			if (typeof o.label !== "string" || o.label === "") continue;
+			options.push({
+				label: o.label,
+				action: o.action === "abort" ? "abort" : "continue"
+			});
+		}
+		if (options.length > 0) return options;
+	}
+	return [...DEFAULT_APPROVAL_OPTIONS];
+}
+/** 一次运行的「最终结果」= 最后一个成功执行的 output 节点值（无 output 节点则 undefined）。 */
+function runResultOf(state) {
+	let result;
+	for (const step of state.steps) if (step.nodeType === "output" && step.status === "success") result = step.result;
+	return result;
+}
+/** 弱化为字符串（非字符串 → 空串）。 */
+function asString(value) {
+	return typeof value === "string" ? value : "";
+}
+/** 弱化为有限数值（非数字/非有限 → undefined）。 */
+function asNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+/** 弱化为条件运算符（白名单；非法/缺省回退 equals）。 */
+function asConditionOperator(value) {
+	const s = asString(value);
+	return CONDITION_OPERATORS.includes(s) ? s : "equals";
+}
+/** 全局输入 = 全部表单节点字段值合并（{{input.*}} 的取值来源；画布顺序靠后者覆盖）。 */
+function collectWorkflowInput(flow) {
+	const out = {};
+	for (const node of flow.nodes) {
+		if (nodeTypeOf(node) !== "form") continue;
+		Object.assign(out, formFieldsOf(node.data));
+	}
+	return out;
+}
+/** 按扩展名推断图片媒体类型（vision 节点白名单；交给 mime 库识别扩展名）。 */
+function mediaTypeOfPath(p) {
+	const type = mime.getType(p);
+	return type === "image/png" || type === "image/jpeg" || type === "image/webp" || type === "image/gif" ? type : void 0;
+}
+/** 递归插值脚本 payload 里的字符串值（消费上游值节点输出 / 全局输入 / current）。 */
+function interpolatePayload(payload, input, values, current) {
+	const out = {};
+	for (const [key, value] of Object.entries(payload)) out[key] = interpolateDeep(value, input, values, current);
+	return out;
+}
+function interpolateDeep(value, input, values, current) {
+	if (typeof value === "string") return resolveValue(value, input, values, current) ?? value;
+	if (Array.isArray(value)) return value.map((item) => interpolateDeep(item, input, values, current));
+	if (value !== null && typeof value === "object") {
+		const out = {};
+		for (const [key, item] of Object.entries(value)) out[key] = interpolateDeep(item, input, values, current);
+		return out;
+	}
+	return value;
+}
+//#endregion
+//#region src/host/agent-tools.ts
+/** 渲染运行工具结果文本（截断）。 */
+function renderRun(id, nodesStarted, value, maxChars) {
+	const rendered = JSON.stringify(value, null, 2);
+	return `工作流 "${id}" 运行完成（${nodesStarted} 个节点）。\n结果：\n${rendered.length > maxChars ? `${rendered.slice(0, maxChars)}\n…[已截断]` : rendered}`;
+}
+/** 渲染运行历史列表文本（一列一行，倒序已由 listRuns 保证）。 */
+function renderRuns(runs) {
+	if (runs.length === 0) return "（没有运行记录）";
+	return runs.map((r) => `- ${r.runId} · ${r.name}（${r.workflowId}）· ${r.status} · ${new Date(r.createdAt).toISOString()}`).join("\n");
+}
+/** 把任意业务对象编码为线协议 JSON 值（JSON 往返丢弃 undefined，并满足工具 output 的 JsonValue 约束）。 */
+function toJsonValue(value) {
+	return JSON.parse(JSON.stringify(value) ?? "null");
+}
+/** 把模型提供的工作流对象（含 id）弱化为 { id, flow }；形状非法时抛错说明缺什么。 */
+function coerceWorkflow(raw) {
+	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) throw new Error("workflow 必须是对象");
+	const o = raw;
+	const id = typeof o.id === "string" ? o.id.trim() : "";
+	if (id === "") throw new Error("workflow.id 必须是非空字符串");
+	if (!Array.isArray(o.nodes)) throw new Error("workflow.nodes 必须是数组");
+	if (!Array.isArray(o.edges)) throw new Error("workflow.edges 必须是数组");
+	return {
+		id,
+		flow: {
+			formatVersion: typeof o.formatVersion === "number" ? o.formatVersion : 1,
+			name: typeof o.name === "string" ? o.name : id,
+			description: typeof o.description === "string" ? o.description : "",
+			nodes: o.nodes,
+			edges: o.edges
+		}
+	};
+}
+/**
+* 注册 workflow_run / workflow_list / workflow_runs / workflow_read / workflow_save / workflow_delete 模型工具（tools 服务未组合时跳过）。
+*
+* 注册契约：在插件根上下文经 `ctx.tools.register` 注册即落在 dsh-tools 的「全局层」，
+* 所有子代理（soft `workflow` 工具的 fan-out 子代理、硬工作流 agent 节点的子代理）默认
+* 继承全局层工具——除非部署的子代理 preset 用 `ctx.tools.restrict()` 显式过滤。因此软→硬
+* 调用桥（子代理里调 workflow_run / workflow_read 等）在注册层天然已通，唯一的外部前提是
+* preset 未把这些工具 restrict 掉。
+*/
+function registerAutoFlowTools(ctx, service) {
+	const tools = ctx.get("tools");
+	if (tools === void 0) return;
+	tools.register(defineTool({
+		name: "workflow_list",
+		description: "列出工作流编辑器里已保存的工作流（id / 名称 / 描述 / 节点数 / 输入键）。运行某个工作流前先用它发现 id 与可传的输入键。",
+		parameters: {},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: { workflows: {
+					type: "array",
+					required: true,
+					items: {
+						type: "object",
+						additionalProperties: false,
+						properties: {
+							id: {
+								type: "string",
+								required: true
+							},
+							name: {
+								type: "string",
+								required: true
+							},
+							description: {
+								type: "string",
+								required: true
+							},
+							nodeCount: {
+								type: "integer",
+								required: true
+							},
+							inputs: {
+								type: "array",
+								required: true,
+								items: { type: "string" }
+							}
+						}
+					}
+				} }
+			},
+			render: (_args, value) => {
+				const workflows = value.workflows;
+				return [{
+					type: "text",
+					text: workflows.length === 0 ? "（没有已保存的工作流）" : workflows.map((w) => {
+						const inputs = w.inputs.length > 0 ? `（输入：${w.inputs.join("、")}）` : "";
+						return `- ${w.name}（id: ${w.id}，${w.nodeCount} 个节点）：${w.description}${inputs}`;
+					}).join("\n")
+				}];
+			}
+		},
+		async execute() {
+			return { workflows: (await service.listFlows()).map((f) => ({
+				id: f.id,
+				name: f.name,
+				description: f.description,
+				nodeCount: f.nodeCount,
+				inputs: f.inputs
+			})) };
+		},
+		presentCall: () => ({
+			card: "generic",
+			title: "workflow_list"
+		}),
+		presentResult: () => ({ card: "generic" })
+	}));
+	tools.register(defineTool({
+		name: "workflow_run",
+		description: "按 id 运行工作流编辑器里已保存的工作流（浏览器脚本 / shell / HTTP / LLM / AI 智能体节点）。先用 workflow_list 发现 id 与可传的输入键；args 按输入键覆盖工作流表单的默认值。若工作流含人工审批节点，会在本会话里弹卡片请你通过/驳回。",
+		parameters: {
+			id: {
+				type: "string",
+				required: true,
+				description: "要运行的工作流 id（用 workflow_list 发现）。"
+			},
+			args: {
+				type: "object",
+				additionalProperties: true,
+				description: "可选运行输入；覆盖工作流表单默认值。"
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					runId: {
+						type: "string",
+						required: true
+					},
+					nodesStarted: {
+						type: "integer",
+						required: true
+					},
+					result: {
+						type: "json",
+						required: true
+					}
+				}
+			},
+			render: (args, value) => {
+				const v = value;
+				return [{
+					type: "text",
+					text: renderRun(String(args.id ?? ""), v.nodesStarted, v.result, 5e4)
+				}];
+			}
+		},
+		async execute(args, exec) {
+			const id = String(args.id ?? "");
+			const runArgs = args.args ?? {};
+			const outcome = await service.runForAgent(id, runArgs, exec.agent, exec.signal);
+			if (!outcome.ok) throw new Error(outcome.error ?? "运行失败");
+			const nodesStarted = outcome.steps.filter((s) => s.status !== "skipped" && s.status !== "pending").length;
+			return {
+				runId: outcome.runId,
+				nodesStarted,
+				result: outcome.result ?? null
+			};
+		},
+		presentCall: (args) => ({
+			card: "generic",
+			title: `workflow_run: ${String(args.id ?? "")}`,
+			rawInput: JSON.stringify(args.args ?? {})
+		}),
+		presentResult: () => ({ card: "generic" })
+	}));
+	tools.register(defineTool({
+		name: "workflow_runs",
+		description: "读取工作流运行历史（状态 / 节点数 / 时间），可按 workflowId 或 sessionId 过滤。用于排查某次运行是否失败、查看某个工作流或会话的历史运行记录。",
+		parameters: {
+			workflowId: {
+				type: "string",
+				description: "只返回该工作流的运行记录。"
+			},
+			sessionId: {
+				type: "string",
+				description: "只返回该会话发起的运行记录。"
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: { runs: {
+					type: "array",
+					required: true,
+					items: {
+						type: "object",
+						additionalProperties: false,
+						properties: {
+							runId: {
+								type: "string",
+								required: true
+							},
+							workflowId: {
+								type: "string",
+								required: true
+							},
+							name: {
+								type: "string",
+								required: true
+							},
+							status: {
+								type: "string",
+								required: true
+							},
+							nodeCount: {
+								type: "integer",
+								required: true
+							},
+							createdAt: {
+								type: "integer",
+								required: true
+							}
+						}
+					}
+				} }
+			},
+			render: (_args, value) => {
+				const runs = value.runs;
+				return [{
+					type: "text",
+					text: renderRuns(runs)
+				}];
+			}
+		},
+		async execute(args) {
+			const a = args;
+			return { runs: (await service.listRuns({
+				...typeof a.workflowId === "string" && a.workflowId !== "" ? { workflowId: a.workflowId } : {},
+				...typeof a.sessionId === "string" && a.sessionId !== "" ? { sessionId: a.sessionId } : {}
+			})).map((r) => ({
+				runId: r.runId,
+				workflowId: r.workflowId,
+				name: r.name,
+				status: r.status,
+				nodeCount: r.nodeCount,
+				createdAt: r.createdAt
+			})) };
+		},
+		presentCall: (args) => ({
+			card: "generic",
+			title: "workflow_runs",
+			rawInput: JSON.stringify(args ?? {})
+		}),
+		presentResult: () => ({ card: "generic" })
+	}));
+	tools.register(defineTool({
+		name: "workflow_read",
+		description: "按 id 读取工作流定义（formatVersion / name / description / nodes / edges），用于查看某个工作流做了什么，或作为用 workflow_save 调整它的起点。",
+		parameters: { id: {
+			type: "string",
+			required: true,
+			description: "要读取的工作流 id（用 workflow_list 发现）。"
+		} },
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: { workflow: { type: "json" } }
+			},
+			render: (_args, value) => {
+				const w = value.workflow;
+				return [{
+					type: "text",
+					text: w === null || w === void 0 ? "工作流不存在。" : `工作流定义：\n${JSON.stringify(w, null, 2)}`
+				}];
+			}
+		},
+		async execute(args) {
+			const id = String(args.id ?? "").trim();
+			if (id === "") return {};
+			const loaded = await service.loadFlow(id);
+			return loaded === null ? {} : { workflow: toJsonValue({
+				id,
+				...loaded
+			}) };
+		},
+		presentCall: (args) => ({
+			card: "generic",
+			title: `workflow_read: ${String(args.id ?? "")}`
+		}),
+		presentResult: () => ({ card: "generic" })
+	}));
+	tools.register(defineTool({
+		name: "workflow_save",
+		description: "创建或更新一个工作流定义。workflow 必须包含：id（kebab-case）、name、description、nodes、edges。保存前会做结构化校验（环 / 空白字段 / 变量引用等），失败时错误说明要改什么，可迭代修正。调整前先用 workflow_read 读取当前定义。",
+		parameters: { workflow: {
+			type: "object",
+			additionalProperties: true,
+			required: true,
+			description: "完整工作流定义（含 id）。"
+		} },
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					saved: {
+						type: "boolean",
+						required: true
+					},
+					id: {
+						type: "string",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => {
+				const v = value;
+				return [{
+					type: "text",
+					text: `工作流「${v.id}」${v.saved ? "已保存" : "未保存"}。`
+				}];
+			}
+		},
+		async execute(args) {
+			const parsed = coerceWorkflow(args.workflow);
+			const validation = validateFlow({
+				nodes: parsed.flow.nodes,
+				edges: parsed.flow.edges
+			});
+			if (!validation.valid) throw new Error(`工作流校验失败，未保存：${validation.diagnostics.map((d) => d.message).join("；")}`);
+			await service.saveFlow(parsed.id, parsed.flow);
+			return {
+				saved: true,
+				id: parsed.id
+			};
+		},
+		presentCall: (args) => ({
+			card: "generic",
+			title: "workflow_save",
+			rawInput: JSON.stringify(args.workflow ?? {})
+		}),
+		presentResult: () => ({ card: "generic" })
+	}));
+	tools.register(defineTool({
+		name: "workflow_delete",
+		description: "按 id 删除一个工作流，返回是否实际删除。仅在用户明确要求删除时使用；删除前先用 workflow_list 确认目标。删除定义不会删除其历史运行记录。",
+		parameters: { id: {
+			type: "string",
+			required: true,
+			description: "要删除的工作流 id。"
+		} },
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: { deleted: {
+					type: "boolean",
+					required: true
+				} }
+			},
+			render: (args, value) => {
+				const v = value;
+				const id = String(args.id ?? "");
+				return [{
+					type: "text",
+					text: v.deleted ? `工作流「${id}」已删除。` : `工作流「${id}」不存在（已删除）。`
+				}];
+			}
+		},
+		async execute(args) {
+			const id = String(args.id ?? "").trim();
+			if (id === "") return { deleted: false };
+			return service.deleteFlow(id);
+		},
+		presentCall: (args) => ({
+			card: "generic",
+			title: `workflow_delete: ${String(args.id ?? "")}`
+		}),
+		presentResult: () => ({ card: "generic" })
+	}));
+}
+//#endregion
+//#region src/host/experience.ts
+/** 系统提示指引：让模型知道何时/如何用 workflow_* 全套工具（运行 + 增删改查 + 历史）。 */
+const SYSTEM_PROMPT_SECTION = "当用户明确要求运行工作流编辑器（auto-flow）里保存的确定性工作流时，先用 workflow_list 发现 id 与可传输入键，再用 workflow_run 按 id 运行并传入 args（按输入键覆盖工作流表单默认值）。工作流在本机确定性执行（浏览器脚本 / shell / HTTP / 直接模型调用 / AI 智能体节点）；若含人工审批节点，会在会话里弹卡片请你通过/驳回。管理定义：workflow_read 读定义、workflow_save 建改定义（保存前校验，失败会报错说明要改什么）、workflow_delete 仅在用户明确要求删除时使用；workflow_runs 读运行历史（可按 workflowId / sessionId 过滤）排查失败。不要臆造 id、参数键或文件路径。";
+/** 注册系统提示指引与 /workflow 斜杠命令（对应宿主服务未组合时静默跳过）。 */
+function registerWorkflowExperience(ctx, service) {
+	const systemPrompt = ctx.get("systemPrompt");
+	if (systemPrompt !== void 0) ctx.effect(() => systemPrompt.section({
+		name: "auto-flow:tools",
+		order: 2600,
+		text: SYSTEM_PROMPT_SECTION
+	}), "auto-flow: 系统提示指引");
+	const commands = ctx.get("commands");
+	if (commands !== void 0) ctx.effect(() => commands.register({
+		name: "workflow",
+		description: "列出或运行工作流编辑器里保存的工作流（不带参数列出；/workflow <id> [key=value ...] 运行）",
+		input: { hint: "<id> [key=value ...]" },
+		recordInput: false,
+		handler: (invocation) => service.runWorkflowCommand(invocation)
+	}), "auto-flow: /workflow 命令");
+}
+function isImageMediaType(value) {
+	return value === "image/png" || value === "image/jpeg" || value === "image/webp" || value === "image/gif";
+}
+/** 解析一条 `user/message` 事件为文本与图片引用；非普通用户消息返回 undefined。 */
+function parseUserTurn(event) {
+	if (event.type !== "user/message") return void 0;
+	const data = event.data;
+	if (data === null || typeof data !== "object") return void 0;
+	const record = data;
+	if (record.source?.kind !== "user") return void 0;
+	if (!Array.isArray(record.content)) return void 0;
+	const images = [];
+	const texts = [];
+	for (const block of record.content) {
+		if (block === null || typeof block !== "object") continue;
+		const item = block;
+		if (item.type === "text" && typeof item.text === "string" && item.text.length > 0) texts.push(item.text);
+		if (item.type === "image") {
+			const attachment = item.attachment;
+			if (attachment === null || typeof attachment !== "object") continue;
+			const ref = attachment;
+			if (typeof ref.attachmentId !== "string" || !isImageMediaType(ref.mediaType)) continue;
+			images.push({
+				attachmentId: ref.attachmentId,
+				mediaType: ref.mediaType
+			});
+		}
+	}
+	return {
+		text: texts.join("\n"),
+		images
+	};
+}
+/** 读取最近一条普通用户回合，跳过不带图片的 `/workflow` 命令行；图片取自最新一条带图消息。 */
+function latestUserTurn(events) {
+	let images;
+	let text;
+	for (let index = events.length - 1; index >= 0; index -= 1) {
+		const turn = parseUserTurn(events[index]);
+		if (turn === void 0) continue;
+		const trimmed = turn.text.trim();
+		if (turn.images.length === 0 && /^\/workflow(?:\s|$)/u.test(trimmed)) continue;
+		if (images === void 0 && turn.images.length > 0) images = turn.images;
+		if (text === void 0) {
+			if (trimmed.length === 0) {} else if (usableTaskText(trimmed) !== void 0) text = trimmed;
+			else text = "";
+		}
+		if (images !== void 0 && text !== void 0) break;
+	}
+	if (images === void 0 && text === void 0) return void 0;
+	return {
+		text: text ?? "",
+		images: images ?? []
+	};
+}
+/** 可安全注入 args.task 的用户文本：简短提问，非命令、非超长父会话长文。 */
+function usableTaskText(text) {
+	const trimmed = text.trim();
+	if (trimmed.length === 0) return void 0;
+	if (/^\/workflow(?:\s|$)/u.test(trimmed)) return void 0;
+	if (trimmed.length > 200) return void 0;
+	return trimmed;
+}
+/** 该运行图是否读取 input.image（声明了 image 表单输入，或含图片识别节点）。 */
+function workflowAcceptsImageInput(inputs, nodes) {
+	if (inputs.includes("image")) return true;
+	return nodes.some((node) => (typeof node.data.nodeType === "string" ? node.data.nodeType : node.type) === VISION_NODE_TYPE);
+}
+/** 该运行图是否读取 input.task。 */
+function workflowAcceptsTaskInput(inputs) {
+	return inputs.includes("task");
+}
+function isBlankArg(value) {
+	return value === void 0 || value === null || typeof value === "string" && value.trim() === "";
+}
+/** 把最近一条用户回合补齐进缺失的 image/task；显式参数优先，无补填时原样返回 args。 */
+function mergeSessionRunArgs(inputs, nodes, args, turn, imagePath) {
+	if (turn === void 0 && imagePath === void 0) return args;
+	const next = { ...args };
+	let changed = false;
+	if (imagePath !== void 0 && imagePath.trim() !== "" && workflowAcceptsImageInput(inputs, nodes) && isBlankArg(next.image)) {
+		next.image = imagePath;
+		changed = true;
+	}
+	const task = turn === void 0 ? void 0 : usableTaskText(turn.text);
+	if (task !== void 0 && workflowAcceptsTaskInput(inputs) && isBlankArg(next.task)) {
+		next.task = task;
+		changed = true;
+	}
+	if (!changed) return args;
+	return next;
+}
+/** 把会话图片落盘为文件，返回供 vision 节点图片模板使用的绝对路径。 */
+async function materializeSessionImage(attachments, image, uploadsDir, signal) {
+	const stored = await attachments.readImage(image, signal);
+	await mkdir(uploadsDir, { recursive: true });
+	const extension = stored.mediaType === "image/jpeg" ? "jpg" : stored.mediaType.slice(6);
+	const stamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/[:T]/g, "-");
+	const file = path.resolve(uploadsDir, `${stamp}-${crypto.randomUUID().slice(0, 8)}.${extension}`);
+	await writeFile(file, Buffer$1.from(stored.data));
+	return file;
 }
 //#endregion
-//#region src/index.ts
+//#region src/host/service.ts
 /**
-* dsh-auto-flow — Host 半（dsh 的 Node 进程内运行）。
-*
-* 通信与平台集成（业务开发按此分工）：
-* - 重通道：AutoFlowService（Cordis 服务，@Remote 严格模式暴露给浏览器，
-*   契约由 `pnpm typert:gen` 生成——双向 zod 校验 + 完整类型）
-* - 轻执行也走 @Remote：`exec` 在宿主内经 ctx.shell（与 bash 工具同一执行器、不经过
-*   模型）执行；`runInBackground` 走 shell.start 自管后台进程 + `execRead`/`execKill` 消费。
-* - 模型工具：plugin_auto_flow（复用上面的服务；presentCall + presentResult）
-* - 斜杠命令：/auto-flow（ctx.commands 注册，用户键入后直接进 handler，不经过模型）
-* - 持久化：greetings 写入 domain storage（dsh-storage-domain，与 session 日志隔离；
-*   不追加自定义会话事件——harness 持久化读路径会拒绝未知事件类型，见 send 的说明）
-
-* - 事件：声明 + 发出 + 监听 `autoFlow/recorded`（跨插件实时通知 seam）
-* - 系统提示词：ctx.systemPrompt.section 贡献一条模型可见指引
-* - 设置：同一份 Config schema 注册为 settings namespace，UI 内可编辑、可 watch
-* - 生命周期：持久层异步打开走 `[Service.init]`（Cordis 类插件 init 钩子）
+* dsh-auto-flow 的 Host 半：服务类本体，负责把工作流能力挂到 ctx 上。
+* 能力按文件拆开：配置 → config.ts、领域 → domain.ts、执行引擎 → engine.ts、
+* 工作区文件 → workspace.ts。本文件只做「组装 + @Remote 方法」。
 */
 var __runInitializers = function(thisArg, initializers, value) {
 	var useValue = arguments.length > 2;
@@ -115,168 +2206,249 @@ var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializ
 	if (target) Object.defineProperty(target, contextIn.name, descriptor);
 	done = true;
 };
-/** 模型可见的工具名。 */
-const TOOL_NAME = "plugin_auto_flow";
-/** 斜杠命令名（小写、不带斜杠前缀）。 */
-const COMMAND_NAME = "auto-flow";
-/** 设置命名空间：与插件短名一致（小写字母开头，字母/数字/连字符）。 */
+/** 设置命名空间，与插件短名一致。 */
 const SETTINGS_NS = "auto-flow";
-/** 默认问候前缀。 */
-const DEFAULT_PREFIX = "Hello";
-/** 单条 `exec` 命令允许的最大 UTF-8 字节长度（随部署变化，可经 Config / settings 覆盖）。 */
-const DEFAULT_MAX_COMMAND_BYTES = 1024;
-/** dsh-auto-flow 的领域错误：extends HarnessError 以便工具结果/重放保留失败类别。 */
-var GreetingError = class extends HarnessError {
-	constructor(message, code) {
-		super(message, code);
+/** 审批等待超时：超过此时长仍无人放行/驳回则自动取消该运行，回收内存。 */
+const APPROVAL_TIMEOUT_MS = 18e5;
+/** 调用工作流节点（硬→硬复用）的嵌套深度上限：防止工作流 A→B→A 无限递归。 */
+const MAX_WORKFLOW_DEPTH = 8;
+/** 追加进会话事件的节点输出/结果字符上限（会话日志卫生；domain 表仍存全量）。 */
+const SESSION_EVENT_OUTPUT_CAP = 2e3;
+/** 截断一条要进会话日志的 JSON 值（字符串截断，其余原样透传）。 */
+function capFlowValue(value) {
+	if (typeof value === "string" && value.length > SESSION_EVENT_OUTPUT_CAP) return `${value.slice(0, SESSION_EVENT_OUTPUT_CAP)}…[已截断]`;
+	return value;
+}
+/** 对追加进会话日志的运行事件做输出截断（仅截断 node-result.output 与 run-end.result 两个大字段）。 */
+function capSessionEvent(type, payload) {
+	if (type === "auto-flow/node-result") {
+		const p = payload;
+		if (p.output !== void 0) return {
+			...payload,
+			output: capFlowValue(p.output)
+		};
 	}
-};
-/** 在边界处校验并归一化一份配置。 */
-function resolveConfig(config = {}) {
-	const prefix = (config.prefix ?? DEFAULT_PREFIX).trim();
-	if (prefix === "") throw new GreetingError("auto-flow: prefix 不能是空字符串", "GREETING_EMPTY_PREFIX");
-	const maxCommandBytes = config.maxCommandBytes ?? DEFAULT_MAX_COMMAND_BYTES;
-	if (!Number.isSafeInteger(maxCommandBytes) || maxCommandBytes < 1) throw new GreetingError(`auto-flow: maxCommandBytes 必须是正的安全整数，收到 ${String(maxCommandBytes)}`, "GREETING_INVALID_MAX_BYTES");
-	return {
-		prefix,
-		maxCommandBytes
-	};
+	if (type === "auto-flow/run-end") {
+		const p = payload;
+		if (p.result !== void 0) return {
+			...payload,
+			result: capFlowValue(p.result)
+		};
+	}
+	return payload;
 }
-/** 配置 schema：既是 Loader 校验的类静态 Config，也是 settings namespace 的 schema。 */
-const ConfigSchema = z.object({
-	prefix: z.string().default(DEFAULT_PREFIX),
-	maxCommandBytes: z.number().step(1).min(1).default(DEFAULT_MAX_COMMAND_BYTES)
-});
-/** 把 ShellRunResult 映射为客户端安全的 ExecForegroundResult（保留截断/沙箱事实）。 */
-function mapRunResult(result) {
+/** 派生一份工作流文档暴露给模型/命令的输入键（= 全部表单节点的字段键并集）。 */
+function workflowInputs(nodes) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const node of nodes) {
+		if ((typeof node.data.nodeType === "string" ? node.data.nodeType : node.type) !== "form") continue;
+		for (const key of Object.keys(node.data)) {
+			if (key === "nodeType" || key === "fields") continue;
+			keys.add(key);
+		}
+	}
+	return [...keys];
+}
+/** 读取调用方 agent 的会话日志（最近用户回合注入 image/task 的输入源）。 */
+function sessionEventsOf(agent) {
+	if (agent === null || typeof agent !== "object") return void 0;
+	const session = agent.session;
+	if (session === void 0 || !Array.isArray(session.events)) return void 0;
+	return session.events;
+}
+/** 读取 agent 句柄的会话 id（dsh 里 agent.id 即 session id，归属标签用）。 */
+function sessionIdOf(agent) {
+	if (agent === null || typeof agent !== "object") return void 0;
+	const id = agent.id;
+	return typeof id === "string" ? id : void 0;
+}
+/** 读取 agent 句柄所属会话的工作目录（session.header.cwd，绝对路径）。 */
+function sessionCwdOf(agent) {
+	if (agent === null || typeof agent !== "object") return void 0;
+	const cwd = agent.session?.header?.cwd;
+	return typeof cwd === "string" && cwd !== "" ? cwd : void 0;
+}
+/** 把运行参数合并进表单节点（args 覆盖表单默认值）；返回浅拷贝后的画布。 */
+function applyRunArgs(flow, args) {
 	return {
-		kind: "foreground",
-		exitCode: result.exitCode,
-		signal: result.signal,
-		timedOut: result.timedOut,
-		aborted: result.aborted,
-		timeoutMs: result.timeoutMs,
-		stdout: {
-			text: result.stdout.text,
-			truncated: result.stdout.truncated,
-			...result.stdout.spillPath !== void 0 ? { spillPath: result.stdout.spillPath } : {}
-		},
-		stderr: {
-			text: result.stderr.text,
-			truncated: result.stderr.truncated,
-			...result.stderr.spillPath !== void 0 ? { spillPath: result.stderr.spillPath } : {}
-		},
-		...result.sandbox !== void 0 ? { sandbox: {
-			mode: result.sandbox.mode,
-			denied: result.sandbox.denied,
-			...result.sandbox.enforcement !== void 0 ? { enforcement: result.sandbox.enforcement } : {},
-			...result.sandbox.runnerFailed !== void 0 ? { runnerFailed: result.sandbox.runnerFailed } : {}
-		} } : {}
+		nodes: flow.nodes.map((node) => {
+			if ((typeof node.data.nodeType === "string" ? node.data.nodeType : node.type) !== "form") return node;
+			return {
+				...node,
+				data: {
+					...node.data,
+					...args
+				}
+			};
+		}),
+		edges: flow.edges
 	};
 }
-/** 后台进程增量读取：附上丢失/溢出提示（与 tool-bash 的 renderProcessRead 同构）。 */
-function renderProcessRead(read) {
-	const notices = [];
-	if (read.lossy) {
-		const paths = [read.stdoutSpillPath, read.stderrSpillPath].filter((path) => path !== void 0);
-		notices.push(`[部分输出被丢弃；完整输出：${paths.length > 0 ? paths.join(", ") : "(unavailable)"}]`);
-	}
-	if (notices.length === 0) return read.delta;
-	return `${read.delta}${read.delta.length > 0 && !read.delta.endsWith("\n") ? "\n" : ""}${notices.join("\n")}`;
-}
+//#endregion
+//#region src/index.ts
 /**
-* 示例服务：类本身就是插件——static inject / Config 是 Cordis 类插件的约定，
-* 构造器里的注册（工具/事件/设置/命令）随插件卸载自动回收。
-*
-* 平台服务消费方式（跨插件协作走 Cordis 服务、禁止互相 import）：
-* - 必需依赖用 `static inject`（tools）；
-* - 可选依赖用 `ctx.inject([...], cb)`（settings / commands / systemPrompt /
-*   autoFlowFormatter）——服务缺失时插件照常加载；
-* - shell / sandboxPolicy 是可选服务：用 `ctx.get(...)` 读取，未组合时
-*   `exec` 报错、插件其余部分照常工作；
-* - 持久层异步打开走 `[Service.init]`（storageDomain 可选：缺省退化为内存态）。
+* Host 半入口：只 default-export 服务供 Loader 装配。
+* 业务编排在 src/host/；tsdown host 段以此为 entry（连同 src/types.ts）。
 */
-let AutoFlowService = (() => {
+var src_default = (() => {
 	let _classSuper = TypertRemoteService;
 	let _instanceExtraInitializers = [];
-	let _send_decorators;
-	let _list_decorators;
-	let _last_decorators;
-	let _exec_decorators;
-	let _execRead_decorators;
-	let _execKill_decorators;
+	let _listFlows_decorators;
+	let _listRuns_decorators;
+	let _loadFlow_decorators;
+	let _saveFlow_decorators;
+	let _deleteFlow_decorators;
+	let _listScripts_decorators;
+	let _listLlmRoutes_decorators;
+	let _listRouteModels_decorators;
+	let _runFlow_decorators;
+	let _runState_decorators;
+	let _cancelRun_decorators;
+	let _approveRun_decorators;
 	return class AutoFlowService extends _classSuper {
 		static {
 			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-			_send_decorators = [Remote("send")];
-			_list_decorators = [Remote("list")];
-			_last_decorators = [Remote("last")];
-			_exec_decorators = [Remote("exec")];
-			_execRead_decorators = [Remote("execRead")];
-			_execKill_decorators = [Remote("execKill")];
-			__esDecorate(this, null, _send_decorators, {
+			_listFlows_decorators = [Remote("listFlows")];
+			_listRuns_decorators = [Remote("listRuns")];
+			_loadFlow_decorators = [Remote("loadFlow")];
+			_saveFlow_decorators = [Remote("saveFlow")];
+			_deleteFlow_decorators = [Remote("deleteFlow")];
+			_listScripts_decorators = [Remote("listScripts")];
+			_listLlmRoutes_decorators = [Remote("listLlmRoutes")];
+			_listRouteModels_decorators = [Remote("listRouteModels")];
+			_runFlow_decorators = [Remote("runFlow")];
+			_runState_decorators = [Remote("runState")];
+			_cancelRun_decorators = [Remote("cancelRun")];
+			_approveRun_decorators = [Remote("approveRun")];
+			__esDecorate(this, null, _listFlows_decorators, {
+				kind: "method",
+				name: "listFlows",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listFlows" in obj,
+					get: (obj) => obj.listFlows
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _listRuns_decorators, {
+				kind: "method",
+				name: "listRuns",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listRuns" in obj,
+					get: (obj) => obj.listRuns
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _loadFlow_decorators, {
+				kind: "method",
+				name: "loadFlow",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "loadFlow" in obj,
+					get: (obj) => obj.loadFlow
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _saveFlow_decorators, {
+				kind: "method",
+				name: "saveFlow",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "saveFlow" in obj,
+					get: (obj) => obj.saveFlow
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _deleteFlow_decorators, {
+				kind: "method",
+				name: "deleteFlow",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "deleteFlow" in obj,
+					get: (obj) => obj.deleteFlow
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _listScripts_decorators, {
 				kind: "method",
-				name: "send",
+				name: "listScripts",
 				static: false,
 				private: false,
 				access: {
-					has: (obj) => "send" in obj,
-					get: (obj) => obj.send
+					has: (obj) => "listScripts" in obj,
+					get: (obj) => obj.listScripts
 				},
 				metadata: _metadata
 			}, null, _instanceExtraInitializers);
-			__esDecorate(this, null, _list_decorators, {
+			__esDecorate(this, null, _listLlmRoutes_decorators, {
 				kind: "method",
-				name: "list",
+				name: "listLlmRoutes",
 				static: false,
 				private: false,
 				access: {
-					has: (obj) => "list" in obj,
-					get: (obj) => obj.list
+					has: (obj) => "listLlmRoutes" in obj,
+					get: (obj) => obj.listLlmRoutes
 				},
 				metadata: _metadata
 			}, null, _instanceExtraInitializers);
-			__esDecorate(this, null, _last_decorators, {
+			__esDecorate(this, null, _listRouteModels_decorators, {
 				kind: "method",
-				name: "last",
+				name: "listRouteModels",
 				static: false,
 				private: false,
 				access: {
-					has: (obj) => "last" in obj,
-					get: (obj) => obj.last
+					has: (obj) => "listRouteModels" in obj,
+					get: (obj) => obj.listRouteModels
 				},
 				metadata: _metadata
 			}, null, _instanceExtraInitializers);
-			__esDecorate(this, null, _exec_decorators, {
+			__esDecorate(this, null, _runFlow_decorators, {
 				kind: "method",
-				name: "exec",
+				name: "runFlow",
 				static: false,
 				private: false,
 				access: {
-					has: (obj) => "exec" in obj,
-					get: (obj) => obj.exec
+					has: (obj) => "runFlow" in obj,
+					get: (obj) => obj.runFlow
 				},
 				metadata: _metadata
 			}, null, _instanceExtraInitializers);
-			__esDecorate(this, null, _execRead_decorators, {
+			__esDecorate(this, null, _runState_decorators, {
 				kind: "method",
-				name: "execRead",
+				name: "runState",
 				static: false,
 				private: false,
 				access: {
-					has: (obj) => "execRead" in obj,
-					get: (obj) => obj.execRead
+					has: (obj) => "runState" in obj,
+					get: (obj) => obj.runState
 				},
 				metadata: _metadata
 			}, null, _instanceExtraInitializers);
-			__esDecorate(this, null, _execKill_decorators, {
+			__esDecorate(this, null, _cancelRun_decorators, {
 				kind: "method",
-				name: "execKill",
+				name: "cancelRun",
 				static: false,
 				private: false,
 				access: {
-					has: (obj) => "execKill" in obj,
-					get: (obj) => obj.execKill
+					has: (obj) => "cancelRun" in obj,
+					get: (obj) => obj.cancelRun
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _approveRun_decorators, {
+				kind: "method",
+				name: "approveRun",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "approveRun" in obj,
+					get: (obj) => obj.approveRun
 				},
 				metadata: _metadata
 			}, null, _instanceExtraInitializers);
@@ -287,121 +2459,39 @@ let AutoFlowService = (() => {
 				value: _metadata
 			});
 		}
-		/** 依赖的服务；缺失时 Loader 会等待其出现。 */
-		static inject = ["tools"];
-		/** Config 的 Schema（Cordis 类插件约定：Loader 读类静态 `Config` 校验注入并补齐默认值；
-		* 模块级同名导出不会被 Loader 识别——生成插件请把 Schema 放在类上）。 */
+		/** Config 的 Schema。Cordis 约定：Loader 读类静态 Config，请放在类上（模块级同名导出不会被识别）。 */
 		static Config = ConfigSchema;
 		/** 校验后的配置（settings scope 可在运行时覆盖，故非 readonly）。 */
 		resolved = __runInitializers(this, _instanceExtraInitializers);
-		/** 问候的内存视图（domain storage 是持久层）。 */
-		greetings = [];
-		/** 已打开的持久化领域；无后端时保持 null（内存态兜底）。 */
+		/** 已打开的持久化领域；未组合 storageDomain 时保持 null。 */
 		storage = null;
-		/** 第二包提供的格式化服务；未安装第二包时保持 null（可选依赖）。 */
-		formatter = null;
-		/** 最近一次提交的问候（由 `autoFlow/recorded` 监听器维护，供 @Remote last）。 */
-		lastRecorded = null;
-		/** 后台进程句柄（@Remote 轻执行自管；不依赖 ctx.jobs，见 exec 说明）。 */
-		background = /* @__PURE__ */ new Map();
-		nextBgId = 1;
-		nextId = 1;
+		/** 运行中的工作流运行时（runId → 状态 + 审批放行句柄）；终态后回收。 */
+		runRuntimes = /* @__PURE__ */ new Map();
+		/** 进行中运行的中止控制器（runId → AbortController）；cancelRun 触发，终态回收。 */
+		runControllers = /* @__PURE__ */ new Map();
+		/** 插件自持的运行日志（追加式按天 JSONL；终态 settled 记录只写一次）。 */
+		runStore;
+		/** 已追加进运行日志的 runId（终态 append 幂等守卫）。 */
+		persistedRunIds = /* @__PURE__ */ new Set();
+		/** 进行中的终态追加（runId → append Promise）；结算返回前 await 它保证落盘先于结算。 */
+		pendingPersists = /* @__PURE__ */ new Map();
 		constructor(ctx, config = {}) {
 			super(ctx, "autoFlow");
 			this.resolved = resolveConfig(config);
-			this.registerTool(ctx);
+			this.rebuildRunStore();
 			this.registerSettings(ctx, config);
-			this.registerCommand(ctx);
-			this.registerSystemPrompt(ctx);
-			this.registerCore(ctx);
-			this.registerEvents(ctx);
-			this.registerBackgroundCleanup(ctx);
+			this.registerStorageCleanup(ctx);
+			registerAutoFlowTools(ctx, this);
+			registerWorkflowExperience(ctx, this);
 		}
-		/**
-		* 异步初始化钩子（Cordis 类插件约定）：构造完成后运行。持久层在这里打开——
-		* 与 @deepseek-ai/dsh-message-feedback 的 `[Service.init]` 同构；storageDomain
-		* 是可选服务，缺失时保持内存态兜底。
-		*/
+		/** 异步初始化：打开持久层。storageDomain 是本插件硬依赖——缺失时大声失败，
+		* 不静默退化成内存态（否则 saveFlow 假装成功但重启即丢数据，是数据丢失陷阱）。 */
 		async [Service.init]() {
 			const storageDomain = this.ctx.get("storageDomain");
-			if (storageDomain === void 0) return;
-			try {
-				this.storage = await storageDomain.open(GreetingDomain);
-				this.hydrateFromStorage();
-			} catch {}
-		}
-		/** 模型工具：复用 @Remote send；presentCall + presentResult 双态展示。 */
-		registerTool(ctx) {
-			ctx.tools.register(defineTool({
-				name: TOOL_NAME,
-				description: "追加一条问候记录，返回新记录与当前总数。",
-				parameters: { text: {
-					type: "string",
-					required: true,
-					description: "问候内容"
-				} },
-				output: {
-					schema: {
-						type: "object",
-						additionalProperties: false,
-						properties: {
-							hello: {
-								type: "object",
-								required: true,
-								additionalProperties: false,
-								properties: {
-									id: {
-										type: "integer",
-										required: true
-									},
-									text: {
-										type: "string",
-										required: true
-									},
-									createdAt: {
-										type: "integer",
-										required: true
-									}
-								}
-							},
-							total: {
-								type: "integer",
-								required: true
-							}
-						}
-					},
-					render: (_args, value) => [{
-						type: "text",
-						text: `已记录：${value.hello.text}（共 ${value.total} 条）`
-					}]
-				},
-				presentCall: (args) => ({
-					card: "generic",
-					title: "记录问候",
-					kind: "other",
-					rawInput: args.text
-				}),
-				presentResult: (_args, result) => {
-					const block = result.content[0];
-					if (block === void 0 || block.type !== "text") return void 0;
-					return {
-						card: "generic",
-						title: "问候已记录",
-						content: [{
-							type: "text",
-							text: block.text
-						}]
-					};
-				},
-				execute: async (args) => {
-					return {
-						hello: await this.send(args.text),
-						total: this.greetings.length
-					};
-				}
-			}));
+			if (storageDomain === void 0) throw new Error("auto-flow: 缺少 storageDomain 服务，无法持久化工作流与运行记录；请确保已装配 @deepseek-ai/dsh-storage-domain（本插件不提供内存兜底）");
+			this.storage = await storageDomain.open(AutoFlowDomain);
 		}
-		/** 设置：同一份 Config schema 注册为可编辑 namespace，入口配置作为 base 层。 */
+		/** 把同一份 Config schema 注册为可编辑的 settings namespace。 */
 		registerSettings(ctx, config) {
 			ctx.inject(["settings"], (settingsCtx) => {
 				let readConfig = () => config;
@@ -414,179 +2504,584 @@ let AutoFlowService = (() => {
 					},
 					onChange: () => {
 						this.resolved = resolveConfig(readConfig());
+						this.rebuildRunStore();
 					}
 				});
 			});
 		}
-		/** 从持久化领域恢复内存视图与自增 id。 */
-		hydrateFromStorage() {
-			if (this.storage === null) return;
-			const table = this.storage.table("greetings");
-			const restored = [];
-			let maxId = 0;
-			for (const [, greeting] of table.entries()) {
-				restored.push(greeting);
-				if (greeting.id > maxId) maxId = greeting.id;
-			}
-			restored.sort((a, b) => a.id - b.id);
-			this.greetings.length = 0;
-			this.greetings.push(...restored);
-			this.nextId = maxId + 1;
-			invariant(this.greetings.length === restored.length, "水合后的内存视图应与恢复记录一致");
-		}
-		/** 斜杠命令：用户键入 /auto-flow 后直接进 handler（不经过模型）。 */
-		registerCommand(ctx) {
-			ctx.inject(["commands"], (commandsCtx) => {
-				commandsCtx.commands.register({
-					name: COMMAND_NAME,
-					description: "记录一条问候并返回当前总数",
-					input: { hint: "问候内容" },
-					handler: async (invocation) => {
-						const text = invocation.rawInput.trim();
-						if (text === "") return {
-							kind: "error",
-							text: "问候内容不能为空"
-						};
-						return {
-							kind: "success",
-							text: `已记录：${(await this.send(text)).text}（共 ${this.greetings.length} 条）`
-						};
-					}
-				});
-			});
+		/** 卸载时中止在飞运行并关闭已打开的领域（Domain 句柄由调用方持有并按 effect 回收）。 */
+		registerStorageCleanup(ctx) {
+			ctx.effect(() => () => {
+				for (const controller of this.runControllers.values()) controller.abort();
+				this.runControllers.clear();
+				return this.storage?.close();
+			}, "auto-flow: 中止在飞运行并关闭持久化领域");
 		}
-		/** 系统提示词：贡献一条模型可见指引（name 唯一、order 升序拼接）。 */
-		registerSystemPrompt(ctx) {
-			ctx.inject(["systemPrompt"], (promptCtx) => {
-				promptCtx.systemPrompt.section({
-					name: "auto-flow",
-					order: 900,
-					text: "auto-flow: 问候通过模型工具 plugin_auto_flow 或斜杠命令 /auto-flow 追加，落插件 domain storage；exec 轻执行输出只回调用方、不进会话日志。"
-				});
-			});
+		/** 依据当前 resolved 配置重建运行日志（workspaceDir / 保留期变更时随之重建）。 */
+		rebuildRunStore() {
+			this.runStore = new WorkflowRunStore(path.resolve(this.resolved.workspaceDir, "runs"), this.resolved.runLogRetentionDays, this.ctx.logger);
 		}
-		/** 事件：监听自身域事件维护 lastRecorded 缓存（演示 ctx.on —— 监听器随 fiber 回收）。
-		* 其它插件也可 ctx.on('autoFlow/recorded', ...) 订阅，实现跨插件实时通知。 */
-		registerEvents(ctx) {
-			ctx.on("autoFlow/recorded", ({ greeting }) => {
-				this.lastRecorded = greeting;
+		/** 列举全部工作流摘要（id + 名称 + 描述 + 节点数 + 输入键；按 id 升序）。 */
+		listFlows() {
+			if (this.storage === null) return Promise.resolve([]);
+			const rows = [...this.storage.table("flows").entries()].map(([id, stored]) => {
+				const def = decodeWorkflowDefinition(id, stored);
+				return {
+					id,
+					name: def.name,
+					description: def.description,
+					nodeCount: def.nodes.length,
+					inputs: workflowInputs(def.nodes)
+				};
 			});
+			rows.sort((a, b) => a.id.localeCompare(b.id));
+			return Promise.resolve(rows);
 		}
-		/** 卸载时回收所有未结束的后台进程（@Remote 轻执行自管句柄，必须随 fiber 清理）。 */
-		registerBackgroundCleanup(ctx) {
-			ctx.effect(() => () => {
-				for (const proc of this.background.values()) proc.kill();
-				this.background.clear();
-			}, "auto-flow: 后台进程清理");
-		}
-		/** 跨插件服务消费：第二包（dsh-auto-flow-core）可选提供 autoFlowFormatter。
-		* 用 ctx.inject 而非 static inject——第二包未安装时插件照常加载（send 走无格式化兜底）。 */
-		registerCore(ctx) {
-			ctx.inject(["autoFlowFormatter"], (coreCtx) => {
-				this.formatter = coreCtx.get("autoFlowFormatter");
+		/** 列举历史运行摘要（按 updatedAt 倒序，来自插件自持运行日志；支持按会话/工作流过滤，含归属标签）。
+		* @param request - 可选过滤：发起会话与工作流（两个条件可同时使用）。 */
+		async listRuns(request) {
+			return (await this.runStore.list({
+				...request.sessionId !== void 0 ? { sessionId: request.sessionId } : {},
+				...request.workflowId !== void 0 ? { workflowId: request.workflowId } : {}
+			})).map((state) => ({
+				runId: state.runId,
+				workflowId: state.workflowId,
+				name: state.name,
+				...state.sessionId !== void 0 ? { sessionId: state.sessionId } : {},
+				status: state.status,
+				nodeCount: state.steps.length,
+				createdAt: state.createdAt,
+				updatedAt: state.updatedAt
+			}));
+		}
+		/** 按 id 读取工作流文档（不存在或未组合 storageDomain 时返回 null）。 */
+		loadFlow(flowId) {
+			if (this.storage === null) return Promise.resolve(null);
+			const stored = this.storage.table("flows").get(flowId);
+			return Promise.resolve(stored === void 0 ? null : decodeWorkflowDefinition(flowId, stored));
+		}
+		/** 按 id 保存工作流文档（domain 打开时落盘，否则仅返回原样；失败大声抛出）。 */
+		async saveFlow(flowId, flow) {
+			if (this.storage !== null) await this.storage.table("flows").put(flowId, flow);
+			return flow;
+		}
+		/** 按 id 删除工作流。 */
+		async deleteFlow(flowId) {
+			if (this.storage === null) return { deleted: false };
+			return { deleted: await this.storage.table("flows").delete(flowId) };
+		}
+		/** 列出可运行脚本清单（展示名/描述/参数/产物装配规则；playwright-ag 为准，缺失时返回空）。 */
+		async listScripts() {
+			const ag = this.ctx.get("playwrightAg");
+			if (ag === void 0) return [];
+			return ag.listScripts();
+		}
+		/** 列出实时 LLM 模型路由（llm/vision/agent 节点的 provider 下拉）。 */
+		listLlmRoutes() {
+			const llm = this.ctx.get("llm");
+			if (llm === void 0) return { routes: [] };
+			return { routes: llm.listProviders().map((route) => ({
+				provider: route.id,
+				displayName: route.name
+			})) };
+		}
+		/** 列出某实时模型路由上的模型目录（llm/vision/agent 节点的 model 下拉）。 */
+		async listRouteModels(request) {
+			const llm = this.ctx.get("llm");
+			if (llm === void 0) return { models: [] };
+			const provider = request.provider.trim();
+			if (provider === "") return { models: [] };
+			try {
+				return { models: (await llm.listModels(provider)).map((model) => ({
+					id: model.id,
+					name: model.name
+				})) };
+			} catch (err) {
+				return {
+					models: [],
+					error: err instanceof Error ? err.message : String(err)
+				};
+			}
+		}
+		/**
+		* 启动一次工作流运行（@Remote，画布触发）：按层级并发执行 表单→脚本→审批，审批经画布 approveRun/cancelRun 放行。
+		* 返回 runId 即返回，进度经 runState 轮询；校验失败抛 invalid-flow（含诊断项）。
+		* sessionId 用于把产物落到「当前会话工作区」（缺省回退配置 workspaceDir）。
+		*/
+		async runFlow(request) {
+			const workspaceRoot = this.resolveWorkspaceRoot(request.sessionId);
+			const { runId, promise } = await this.startRun(request.flow, (runtime, step, options) => this.canvasWaitApproval(runtime, step, options), {
+				...request.workflowId !== void 0 ? { workflowId: request.workflowId } : {},
+				...request.name !== void 0 ? { name: request.name } : {},
+				...request.sessionId !== void 0 ? { sessionId: request.sessionId } : {},
+				workspaceRoot
 			});
+			return { runId };
+		}
+		/** 解析本次运行应写入的工作区根目录：优先触发会话的 header.cwd，否则配置 workspaceDir 兜底。 */
+		resolveWorkspaceRoot(sessionId) {
+			if (sessionId !== void 0) {
+				const cwd = this.ctx.get("sessions")?.get(sessionId)?.header?.cwd;
+				if (cwd !== void 0 && cwd !== "") return cwd;
+			}
+			return this.resolved.workspaceDir;
 		}
 		/**
-		* 追加一条问候并返回记录（写透 domain storage；若有第二包则先格式化；提交后发域事件）。
-		*
-		* 不追加自定义会话事件：harness 的 session 持久化读路径会拒绝 `KNOWN_SESSION_EVENT_TYPES`
-		* 之外的事件类型（除非信封标记 `ignorable`，而 `Session.append` 无此参数），把插件
-		* 自定义事件写进会话日志会导致该会话在重启后无法打开。
+		* 启动一次运行并返回结算句柄（宿主内部，供 @Remote runFlow 与模型工具共用）。
+		* @param flow 画布（本方法负责校验）。
+		* @param waitApproval 审批等待器工厂 (runtime, step, options) => Promise<string>（返回选中的选项标签）。
+		* @param runContext 运行归属与触发方：workflowId/name/sessionId 是运行记录归属标签；
+		*   workspaceRoot 是产物根目录（缺省配置 workspaceDir）；有 parent 且部署有 subagents 时
+		*   AI 智能体节点才可用；recordSession 存在时把 auto-flow/* 运行事实追加为会话事件（会话进度）；
+		*   depth 是调用工作流节点的嵌套深度。
 		*/
-		async send(text) {
-			const raw = this.resolved.prefix + text;
-			const greeting = {
-				id: this.nextId,
-				text: this.formatter !== null ? this.formatter.format(raw) : raw,
-				createdAt: Date.now()
+		async startRun(flow, waitApproval, runContext = {}) {
+			const ag = this.ctx.get("playwrightAg");
+			if (ag === void 0) throw new RemoteError("autoFlow/playwright-missing", "运行工作流需要组合 playwright-ag 插件", {});
+			const scripts = await ag.listScripts();
+			const labelByScript = new Map(scripts.map((s) => [s.name, s.label]));
+			const artifactsByScript = new Map(scripts.flatMap((s) => s.artifacts !== void 0 ? [[s.name, s.artifacts]] : []));
+			const validation = validateFlow(flow, new Map(scripts.map((s) => [s.name, s.params])));
+			if (!validation.valid) {
+				const detail = validation.diagnostics.map((d) => d.message).join("；");
+				throw new RemoteError("autoFlow/invalid-flow", `工作流校验失败：${detail}`, { diagnostics: validation.diagnostics });
+			}
+			const runId = `run-${crypto.randomUUID()}`;
+			const workspaceDir = path.resolve(runContext.workspaceRoot ?? this.resolved.workspaceDir, runId);
+			const state = {
+				runId,
+				workflowId: runContext.workflowId ?? "",
+				name: runContext.name ?? "",
+				...runContext.sessionId !== void 0 ? { sessionId: runContext.sessionId } : {},
+				status: "running",
+				workspaceDir,
+				steps: buildRunSteps(flow, (script) => labelByScript.get(script) ?? script),
+				createdAt: Date.now(),
+				updatedAt: Date.now()
+			};
+			const runtime = {
+				state,
+				delegatedApprovals: []
+			};
+			this.runRuntimes.set(runId, runtime);
+			const rootRuntime = runContext.rootRuntime ?? runtime;
+			const runController = new AbortController();
+			this.runControllers.set(runId, runController);
+			const externalSignal = runContext.signal;
+			if (externalSignal !== void 0) {
+				if (externalSignal.aborted) runController.abort();
+				else externalSignal.addEventListener("abort", () => runController.abort(), { once: true });
+			}
+			const runSignal = runController.signal;
+			const subagents = this.ctx.get("subagents");
+			const agents = this.ctx.get("agents");
+			const parent = runContext.parent;
+			let bareParent;
+			const resolveParent = async () => {
+				if (parent !== void 0) return parent;
+				if (agents === void 0) return void 0;
+				if (bareParent === void 0) try {
+					bareParent = await agents.create({
+						sessionId: `auto-flow:${runId}`,
+						meta: {
+							cwd: workspaceDir,
+							delegationDepth: 0
+						}
+					});
+				} catch (err) {
+					throw new Error(`无法为画布运行创建工作流父代理：${err instanceof Error ? err.message : String(err)}`);
+				}
+				return bareParent.agent;
+			};
+			const agentFace = subagents !== void 0 && (parent !== void 0 || agents !== void 0) ? { run: async (task, options) => {
+				try {
+					const resolved = await resolveParent();
+					if (resolved === void 0) return {
+						ok: false,
+						error: "AI 智能体节点需要子代理能力，但当前部署未组合 agents 服务且非 agent 触发"
+					};
+					return await this.delegateToAgent(subagents, resolved, task, options ?? {}, runContext.signal);
+				} catch (err) {
+					return {
+						ok: false,
+						error: err instanceof Error ? err.message : String(err)
+					};
+				}
+			} } : void 0;
+			return {
+				runId,
+				promise: new WorkflowEngine({
+					runScript: async (script, payload, options) => {
+						const { signal, ...runOptions } = options;
+						const result = await ag.runScript(script, payload, runOptions, signal);
+						return result.ok ? {
+							ok: true,
+							data: result.data,
+							durationMs: result.meta.durationMs
+						} : {
+							ok: false,
+							error: result.error.message,
+							code: result.error.code,
+							durationMs: result.meta.durationMs
+						};
+					},
+					persist: (s) => void this.persistRun(s),
+					waitApproval: (step, options) => waitApproval(runtime, step, options),
+					resolveArtifacts: (script) => artifactsByScript.get(script),
+					llm: this.ctx.get("llm"),
+					shell: this.ctx.get("shell"),
+					attachments: this.ctx.get("attachments"),
+					agentDefaultModel: this.ctx.get("agentDefaultModel"),
+					agent: agentFace,
+					runWorkflow: (workflowId, args) => this.runNestedWorkflow(workflowId, args, rootRuntime, parent, runContext.recordSession, runSignal, runContext.depth ?? 0),
+					signal: runSignal,
+					emit: (type, payload) => {
+						try {
+							this.ctx.emit(type, payload);
+						} catch {}
+						const recordSession = runContext.recordSession;
+						if (recordSession !== void 0) try {
+							recordSession.append(type, capSessionEvent(type, payload));
+						} catch {}
+					}
+				}).run(state, flow).then(async () => {
+					await this.persistRun(state);
+					const result = runResultOf(state);
+					const failed = state.steps.find((s) => s.status === "failed");
+					return {
+						runId: state.runId,
+						ok: state.status === "completed",
+						...result !== void 0 ? { result } : {},
+						...failed?.error !== void 0 ? { error: failed.error } : {},
+						steps: state.steps
+					};
+				}).catch(async (err) => {
+					const message = err instanceof Error ? err.message : String(err);
+					this.failRun(runtime, message);
+					await this.persistRun(state);
+					return {
+						runId: state.runId,
+						ok: false,
+						error: message,
+						steps: state.steps
+					};
+				}).finally(() => {
+					if (bareParent !== void 0) bareParent.dispose();
+				})
 			};
-			invariant(Number.isSafeInteger(greeting.id) && greeting.id >= 1, "greeting id 必须是正安全整数");
-			this.nextId += 1;
-			this.greetings.push(greeting);
-			if (this.storage !== null) try {
-				await this.storage.table("greetings").put(String(greeting.id), greeting);
-				await this.storage.global.set({ lastGreetedAt: greeting.createdAt });
-			} catch {}
-			this.ctx.emit("autoFlow/recorded", { greeting });
-			return greeting;
-		}
-		/** 返回全部问候记录（内存视图，已由 domain storage 水合）。 */
-		list() {
-			return Promise.resolve([...this.greetings]);
-		}
-		/** 返回最近一次提交的问候（由域事件监听器维护），首次提交前为 null。 */
-		last() {
-			return Promise.resolve(this.lastRecorded);
+		}
+		/** 画布审批等待器：挂起直至 approveRun/cancelRun 放行；30 分钟无人处理则自动取消。 */
+		canvasWaitApproval(runtime, _step, _options) {
+			return new Promise((resolve) => {
+				runtime.approveResolve = resolve;
+				runtime.approvalTimer = setTimeout(() => {
+					runtime.approveResolve = void 0;
+					runtime.approvalTimer = void 0;
+					if (runtime.state.status === "waiting") {
+						runtime.state.status = "cancelled";
+						runtime.state.updatedAt = Date.now();
+						this.persistRun(runtime.state);
+					}
+					resolve("");
+				}, APPROVAL_TIMEOUT_MS);
+			});
+		}
+		/** 审批提问等待器：经 userQuestions 交互卡片让用户选择；无交互 UI 时回退画布审批。 */
+		async chatWaitApproval(runtime, step, agent, signal, options) {
+			const userQuestions = this.ctx.get("userQuestions");
+			if (userQuestions === void 0) return this.canvasWaitApproval(runtime, step, options);
+			const abortLabel = options.find((o) => o.action === "abort")?.label ?? "";
+			try {
+				return (await userQuestions.ask({
+					questions: [{
+						id: "approve",
+						question: `审批节点「${step.label}」：请选择`,
+						header: "工作流审批",
+						options: options.map((o) => ({ label: o.label }))
+					}],
+					agent,
+					...signal !== void 0 ? { signal } : {}
+				})).answers[0]?.selected?.[0] ?? abortLabel;
+			} catch {
+				return abortLabel;
+			}
 		}
 		/**
-		* 执行一条命令行（宿主内经 ctx.shell，与 bash 工具同一执行器，绝不经过模型）。
-		* 输出只回调用方、不进会话日志。@Remote 严格契约保证浏览器端完整类型与校验。
-		*
-		* 相比模型工具（@deepseek-ai/dsh-tool-bash）的 shell 面，@Remote 轻执行只能拿到
-		* 能映射过来的子集：timeoutMs / stdoutMaxBytes / sandboxPolicy / 后台任务 / 结果保真。
-		* 模型工具专属的 seam（shellEnv.collect 需要 ToolExecution、sandbox 升级需要 approval
-		* + callId、abort 需要 ToolExecution.signal）不适用于 @Remote，此处不做。
-		*
-		* 注意：@Remote 方法不能带 `agent: Agent` 参数——第三方仓库的 typert 生成器无法解析
-		* `agent` lookup（其 wire 类型 SessionId 是 branded 类型，官方 monorepo 内才可用）。
-		* 因此沙箱策略退化为「部署默认」（`sandboxPolicy.resolve()` 无 session）。
-		*
-		* 后台执行不走 ctx.jobs（那是给模型工具 job_output/job_kill 用的，需要 agent owner +
-		* dsh-tool-jobs 控制器，@Remote 里拿不到）：直接用 `shell.start()` 拿 ShellProcess
-		* 句柄，自管在 this.background Map 里，execRead/execKill 直接操作句柄；卸载时统一 kill。
-		*
-		* shell / sandboxPolicy 是可选依赖：未组合时抛对应 RemoteError，插件其余照常。
+		* 调用工作流节点（硬→硬复用）的嵌套运行：加载目标工作流、合并 args、复用本运行的
+		* parent/session/signal 再跑一次 startRun，并把其 Output 值作为节点结果回灌。
+		* @param workflowId 目标工作流 id。
+		* @param args 覆盖目标工作流表单默认值的运行参数。
+		* @param parent 外层运行的父代理（审批卡片与会话归属用）。
+		* @param recordSession 外层运行的会话记录目标（嵌套进度追加到同一会话）。
+		* @param signal 外层运行的取消信号（取消外层即中止嵌套运行）。
+		* @param depth 当前嵌套深度（0 = 顶层）；达到上限即拒绝，防无限递归。
 		*/
-		async exec(request) {
-			const command = request.command.trim();
-			if (command === "") throw new RemoteError("gateway/bad-request", "命令不能为空", {});
-			const actualBytes = Buffer.byteLength(command, "utf8");
-			if (actualBytes > this.resolved.maxCommandBytes) throw new RemoteError("autoFlow/command-too-long", `命令超过 ${this.resolved.maxCommandBytes} 字节`, {
-				maxBytes: this.resolved.maxCommandBytes,
-				actualBytes
+		async runNestedWorkflow(workflowId, args, rootRuntime, parent, recordSession, signal, depth) {
+			if (depth >= MAX_WORKFLOW_DEPTH) return {
+				ok: false,
+				error: `工作流嵌套调用超过深度上限 ${MAX_WORKFLOW_DEPTH}`
+			};
+			const loaded = await this.loadFlow(workflowId);
+			if (loaded === null) return {
+				ok: false,
+				error: `工作流 ${workflowId} 不存在`
+			};
+			const { promise } = await this.startRun(applyRunArgs({
+				nodes: loaded.nodes,
+				edges: loaded.edges
+			}, args), (nestedRuntime, step, options) => parent !== void 0 ? this.chatWaitApproval(nestedRuntime, step, parent, signal, options) : this.delegatedCanvasWaitApproval(rootRuntime, nestedRuntime, step, options), {
+				workflowId,
+				name: loaded.name,
+				...parent !== void 0 ? { parent } : {},
+				...recordSession !== void 0 ? { recordSession } : {},
+				signal,
+				depth: depth + 1,
+				rootRuntime
 			});
-			const shell = this.ctx.get("shell");
-			if (shell === void 0) throw new RemoteError("autoFlow/shell-missing", "exec 需要组合 shell 提供方（@deepseek-ai/dsh-shell）", {});
-			const sandboxPolicy = this.ctx.get("sandboxPolicy")?.resolve();
-			const spec = shell.resolve({
-				command,
-				...request.workdir !== void 0 ? { workdir: request.workdir } : {},
-				...request.timeoutMs !== void 0 ? { timeoutMs: request.timeoutMs } : {},
-				...request.stdoutMaxBytes !== void 0 ? { stdoutMaxBytes: request.stdoutMaxBytes } : {},
-				...sandboxPolicy !== void 0 ? { sandboxPolicy } : {}
+			const outcome = await promise;
+			if (!outcome.ok) return {
+				ok: false,
+				error: outcome.error ?? "运行失败"
+			};
+			return {
+				ok: true,
+				result: outcome.result
+			};
+		}
+		/** 画布场景的嵌套审批上抛：把嵌套运行加入根运行的上抛队列，画布经根 runId 即可看到/操作它。 */
+		delegatedCanvasWaitApproval(rootRuntime, nestedRuntime, step, options) {
+			nestedRuntime.delegatedBy = rootRuntime;
+			rootRuntime.delegatedApprovals.push({ runtime: nestedRuntime });
+			return this.canvasWaitApproval(nestedRuntime, step, options);
+		}
+		/** 供模型工具：按 flowId 加载并运行，args 覆盖表单默认值，等待完成返回结算结果。
+		*  同时把最近一条用户消息的图片/文本补填进缺失的 image/task 输入（会话上下文注入）。 */
+		async runForAgent(flowId, args, agent, signal) {
+			const loaded = await this.loadFlow(flowId);
+			if (loaded === null) return {
+				runId: "",
+				ok: false,
+				error: `工作流 ${flowId} 不存在`,
+				steps: []
+			};
+			const recordSession = agent !== null && typeof agent === "object" ? agent.session : void 0;
+			const merged = await this.resolveSessionRunArgs(loaded, args, sessionEventsOf(agent), signal);
+			const sessionId = sessionIdOf(agent);
+			const { promise } = await this.startRun(applyRunArgs({
+				nodes: loaded.nodes,
+				edges: loaded.edges
+			}, merged ?? args), (runtime, step, options) => this.chatWaitApproval(runtime, step, agent, signal, options), {
+				workflowId: flowId,
+				name: loaded.name,
+				parent: agent,
+				workspaceRoot: sessionCwdOf(agent) ?? this.resolved.workspaceDir,
+				...signal !== void 0 ? { signal } : {},
+				...recordSession !== void 0 ? { recordSession } : {},
+				...sessionId !== void 0 ? { sessionId } : {}
 			});
-			if (request.runInBackground === true) {
-				const proc = shell.start(spec);
-				const jobId = `auto-flow-${this.nextBgId}`;
-				this.nextBgId += 1;
-				this.background.set(jobId, proc);
+			return promise;
+		}
+		/** 把最近一条用户消息的图片/文本补填进运行参数（image/task）；无会话或已显式传入时原样返回。 */
+		async resolveSessionRunArgs(workflow, args, events, signal) {
+			if (events === void 0) return args;
+			const turn = latestUserTurn(events);
+			const inputs = workflowInputs(workflow.nodes);
+			const first = turn?.images[0];
+			const imageBlank = args?.image === void 0 || args.image === null || typeof args.image === "string" && args.image.trim() === "";
+			let imagePath;
+			if (first !== void 0 && workflowAcceptsImageInput(inputs, workflow.nodes) && imageBlank) {
+				const attachments = this.ctx.get("attachments");
+				if (attachments !== void 0) try {
+					imagePath = await materializeSessionImage(attachments, first, path.resolve(this.resolved.workspaceDir, "uploads"), signal);
+				} catch (err) {
+					this.ctx.logger.warn("auto-flow: 会话图片落盘失败：%s", err instanceof Error ? err.message : String(err));
+				}
+			}
+			return mergeSessionRunArgs(inputs, workflow.nodes, args, turn, imagePath);
+		}
+		/** 执行 /workflow 命令：不带参数列出工作流；/workflow <id> [key=value ...] 运行并等待结算。 */
+		async runWorkflowCommand(invocation) {
+			const line = parseWorkflowCommandLine(invocation.rawInput);
+			if (line.kind === "error") return {
+				kind: "error",
+				text: line.error
+			};
+			if (line.kind === "list") {
+				const flows = await this.listFlows();
+				if (flows.length === 0) return {
+					kind: "success",
+					text: "（没有已保存的工作流）"
+				};
 				return {
-					kind: "background",
-					jobId
+					kind: "success",
+					text: renderFlowList(flows)
 				};
 			}
-			return mapRunResult(await shell.run(spec));
-		}
-		/** 读后台进程的下一次增量/终态输出（自管 ShellProcess 句柄，不依赖 ctx.jobs）。 */
-		async execRead(jobId) {
-			const proc = this.background.get(jobId);
-			if (proc === void 0) throw new RemoteError("autoFlow/job-not-found", "后台任务不存在或已结束", {});
-			const settled = proc.status === "completed" || proc.status === "killed";
+			const resolved = resolveWorkflowTarget(await this.listFlows(), line.target);
+			if (!resolved.ok) return {
+				kind: "error",
+				text: resolved.error
+			};
+			const outcome = await this.runForAgent(resolved.id, line.args, invocation.agent, invocation.signal);
+			if (!outcome.ok) return {
+				kind: "error",
+				text: outcome.error ?? "运行失败"
+			};
+			const value = outcome.result;
 			return {
-				text: renderProcessRead(proc.readOutput()),
-				status: proc.status,
-				...settled ? { detail: proc.signal !== null ? `signal: ${proc.signal}` : `exit code: ${proc.exitCode ?? 0}` } : {}
+				kind: "success",
+				text: `运行完成。\n${value === void 0 ? "（无返回值）" : typeof value === "string" ? value : JSON.stringify(value, null, 2)}`
+			};
+		}
+		/** 把 AI 智能体节点的子任务委托给子代理（LLM + 工具循环），返回最终文本。 */
+		async delegateToAgent(subagents, parent, task, options, signal) {
+			const providerName = subagents.list()[0];
+			if (providerName === void 0) return {
+				ok: false,
+				error: "subagents 服务未注册任何子代理 provider"
 			};
+			const maxDepth = subagents.getProvider(providerName)?.capabilities.depthLimit === true ? this.resolved.maxAgentDepth : void 0;
+			let run;
+			try {
+				run = await subagents.start(providerName, {
+					...options.label !== void 0 ? { label: options.label } : {},
+					prompt: [{
+						type: "text",
+						text: task
+					}],
+					parent,
+					...options.provider !== void 0 || options.model !== void 0 ? { agentOptions: {
+						...options.provider !== void 0 ? { provider: options.provider } : {},
+						...options.model !== void 0 ? { model: options.model } : {}
+					} } : {},
+					...maxDepth !== void 0 ? { maxDepth } : {},
+					signal: signal ?? new AbortController().signal
+				});
+				const result = await run.result;
+				if (result.stopReason !== "completed") return {
+					ok: false,
+					error: result.diagnostic ?? `子代理未完成（${result.stopReason}）`
+				};
+				return {
+					ok: true,
+					text: result.output.map((block) => block.type === "text" && typeof block.text === "string" ? block.text : "").join("").trim()
+				};
+			} catch (err) {
+				return {
+					ok: false,
+					error: err instanceof Error ? err.message : String(err)
+				};
+			} finally {
+				if (run !== void 0) await run.dispose();
+			}
+		}
+		/** 轮询运行状态（内存权威；未在内存中时读运行日志兜底）。 */
+		async runState(runId) {
+			const runtime = this.resolveRuntime(runId);
+			if (runtime !== void 0) return runtime.state;
+			return await this.runStore.read(runId) ?? null;
+		}
+		/** 取消运行：协作式取消，中止在飞的脚本/LLM/shell/HTTP，引擎在下一个步骤边界停下；若正等待审批则放行让引擎退出。
+		*  画布面向的根运行取消时会连带取消其整个审批上抛队列中的嵌套运行。 */
+		async cancelRun(runId) {
+			const runtime = this.runRuntimes.get(runId);
+			if (runtime === void 0) throw new RemoteError("autoFlow/run-not-found", "运行不存在或已结束", {});
+			const root = runtime.delegatedBy ?? runtime;
+			this.runControllers.get(root.state.runId)?.abort();
+			const targets = [root, ...root.delegatedApprovals.map((d) => d.runtime)];
+			root.delegatedApprovals = [];
+			for (const target of targets) {
+				if (target.state.status === "completed" || target.state.status === "failed" || target.state.status === "cancelled") continue;
+				target.state.status = "cancelled";
+				target.state.updatedAt = Date.now();
+				this.clearApprovalTimer(target);
+				target.approveResolve?.("");
+				target.approveResolve = void 0;
+				await this.persistRun(target.state);
+			}
+			return runtime.state;
+		}
+		/** 审批选择：choice = 审批节点的某个选项标签；画布用根 runId 操作时，自动作用于当前待处理的嵌套审批（队首）。 */
+		async approveRun(runId, choice) {
+			const runtime = this.runRuntimes.get(runId);
+			if (runtime === void 0) throw new RemoteError("autoFlow/run-not-found", "运行不存在或已结束", {});
+			const pending = this.takePendingApproval(runtime);
+			this.clearApprovalTimer(pending);
+			pending.approveResolve?.(choice);
+			pending.approveResolve = void 0;
+			return pending.state;
+		}
+		/**
+		* 解析运行时的「画布可见运行」：若传入的是画布面向的根 runId 且其审批上抛队列非空，
+		* 则返回队首待处理的嵌套运行（跳过已不再等待的残留项）；否则返回该运行时本身。
+		*/
+		resolveRuntime(runId) {
+			const runtime = this.runRuntimes.get(runId);
+			if (runtime === void 0) return void 0;
+			while (runtime.delegatedApprovals.length > 0) {
+				const front = runtime.delegatedApprovals[0].runtime;
+				if (front.state.status === "waiting") return front;
+				runtime.delegatedApprovals.shift();
+			}
+			return runtime;
+		}
+		/**
+		* 从审批上抛队列中取出当前应处理的运行时：
+		* - 若传入的是被上抛的嵌套运行时（有反向指针），从根的队列里移除自身并返回自身；
+		* - 若传入的是根运行，取出并返回队首嵌套运行，队列为空时返回根自身。
+		*/
+		takePendingApproval(runtime) {
+			const root = runtime.delegatedBy ?? runtime;
+			if (runtime.delegatedBy !== void 0) {
+				const idx = root.delegatedApprovals.findIndex((d) => d.runtime === runtime);
+				if (idx >= 0) root.delegatedApprovals.splice(idx, 1);
+				return runtime;
+			}
+			return root.delegatedApprovals.shift()?.runtime ?? runtime;
+		}
+		/** 清除审批等待超时定时器（放行/驳回/终态时调用）。 */
+		clearApprovalTimer(runtime) {
+			if (runtime.approvalTimer !== void 0) {
+				clearTimeout(runtime.approvalTimer);
+				runtime.approvalTimer = void 0;
+			}
 		}
-		/** 请求取消后台进程（自管 ShellProcess 句柄，不依赖 ctx.jobs）。 */
-		async execKill(jobId) {
-			const proc = this.background.get(jobId);
-			if (proc === void 0) return { kind: "already-finished" };
-			return { kind: proc.kill() ? "requested" : "already-finished" };
+		failRun(runtime, message) {
+			const { state } = runtime;
+			const running = state.steps.find((s) => s.status === "running");
+			if (running !== void 0) {
+				running.status = "failed";
+				running.error = message;
+			}
+			state.status = "failed";
+			state.updatedAt = Date.now();
+			this.persistRun(state);
+		}
+		persistRun(state) {
+			if (!(state.status === "completed" || state.status === "failed" || state.status === "cancelled")) return Promise.resolve();
+			const existing = this.pendingPersists.get(state.runId);
+			if (existing !== void 0) return existing;
+			const pending = (async () => {
+				try {
+					if (!this.persistedRunIds.has(state.runId)) {
+						this.persistedRunIds.add(state.runId);
+						await this.runStore.append(state);
+					}
+				} catch (err) {
+					this.ctx.logger.warn("auto-flow: 运行记录追加失败：%s", err instanceof Error ? err.message : String(err));
+				}
+				const runtime = this.runRuntimes.get(state.runId);
+				if (runtime !== void 0) this.clearApprovalTimer(runtime);
+				this.runRuntimes.delete(state.runId);
+				this.runControllers.delete(state.runId);
+				this.pendingPersists.delete(state.runId);
+			})();
+			this.pendingPersists.set(state.runId, pending);
+			return pending;
 		}
 	};
 })();
 //#endregion
-export { AutoFlowService, AutoFlowService as default };
+export { src_default as default };
 
 //# sourceMappingURL=index.js.map