@cannbot-plugin/cannbot-harness 0.3.2 → 0.3.4

package/lib/index.js

@@ -8,8 +8,12 @@ import z from "@deepseek-ai/schemastery";
 import { spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
-import { cp, lstat, mkdir, mkdtemp, open, readFile, realpath, rename, rm, unlink, writeFile } from "node:fs/promises";
+import { access, cp, lstat, mkdir, mkdtemp, open, readFile, realpath, rename, rm, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
+import { DatabaseSync } from "node:sqlite";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { createInterface } from "node:readline";
+import { parse } from "yaml";
 //#region src/workflows.ts
 const WORKFLOWS = [
 	{
@@ -26,36 +30,6 @@ const WORKFLOWS = [
 		id: "ops-registry-invoke",
 		label: "registry",
 		description: "registryDescription"
-	},
-	{
-		id: "model-infer-optimize",
-		label: "model",
-		description: "modelDescription"
-	},
-	{
-		id: "hccl-op-generator",
-		label: "hccl",
-		description: "hcclDescription"
-	},
-	{
-		id: "triton-op-generator",
-		label: "triton",
-		description: "tritonDescription"
-	},
-	{
-		id: "catlass-op-generator",
-		label: "catlass",
-		description: "catlassDescription"
-	},
-	{
-		id: "ops-perf-optimize",
-		label: "performance",
-		description: "performanceDescription"
-	},
-	{
-		id: "pypto-op-orchestrator",
-		label: "pypto",
-		description: "pyptoDescription"
 	}
 ];
 //#endregion
@@ -123,7 +97,7 @@ function installWorkflowContext(ctx, config, content) {
 					source,
 					content: [{
 						type: "text",
-						text: renderSkillContent(skill)
+						text: renderSkillContent(skill) + "\n\nDSH 会话任务跟踪：在执行多步骤工作前，用 todo_write 建立具体的 PM 任务计划；需求确认、环境准备、工作流组装等启动前工作也要列入。开始、完成或受阻时及时更新计划，不要只在聊天中报告进展。命令返回或文件生成不等于任务验收通过。插件自动同步 [工作流] 节点状态；todo_write 只维护你自己的 PM 计划，勿复制或修改插件节点。在此插件内启动或续跑编排器使用 cannbot_workflow_run，查询使用 cannbot_workflow_status，节点由 DSH agent loop 执行；不要经 shell 改用其他 provider。若已有外部编排器在运行，不要重复启动；先核实并报告其状态。"
 					}]
 				})]
 			};
@@ -132,11 +106,7 @@ function installWorkflowContext(ctx, config, content) {
 }
 //#endregion
 //#region src/client/plugin-update.ts
-const UPDATE_PACKAGES = [
-	"cannbot-harness",
-	"cannbot-dsh",
-	"@cannbot-plugin/cannbot-harness"
-];
+const UPDATE_PACKAGES = ["cannbot-harness", "@cannbot-plugin/cannbot-harness"];
 /** Only stable npm releases of our two installation entries may be selected. */
 function newerVersion(candidate, current) {
 	const next = /^(\d+)\.(\d+)\.(\d+)$/.exec(candidate);
@@ -146,7 +116,7 @@ function newerVersion(candidate, current) {
 		const difference = Number(next[index]) - Number(old[index]);
 		if (difference) return difference > 0;
 	}
-	return current.includes("-");
+	return /^\d+\.\d+\.\d+-/.test(current);
 }
 //#endregion
 //#region src/update-host.ts
@@ -242,39 +212,93 @@ function registerHostUpdater(ctx) {
 	});
 }
 //#endregion
-//#region src/content-lock.ts
-async function withContentLock(path, action) {
-	await mkdir(dirname(path), { recursive: true });
-	const owner = JSON.stringify({
-		pid: process.pid,
-		id: randomUUID()
+//#region src/process-runner.mjs
+/** Wait for termination before callers release locks or remove staging files. */
+function runProcess(command, args, { signal, timeoutMs, graceMs = 1e3, onData, ...options } = {}) {
+	signal?.throwIfAborted();
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			...options,
+			detached: true
+		});
+		let stopped, escalation, timer;
+		const kill = (force) => {
+			if (!child.pid) return;
+			try {
+				process.kill(-child.pid, force ? "SIGKILL" : "SIGTERM");
+			} catch {}
+		};
+		const stop = (reason) => {
+			if (stopped) return;
+			stopped = reason;
+			kill(false);
+			escalation = setTimeout(() => kill(true), graceMs);
+		};
+		const abort = () => stop(signal.reason ?? /* @__PURE__ */ new Error("Operation cancelled"));
+		const cleanup = () => {
+			clearTimeout(timer);
+			clearTimeout(escalation);
+			signal?.removeEventListener("abort", abort);
+		};
+		if (onData) {
+			child.stdout?.on("data", onData);
+			child.stderr?.on("data", onData);
+		}
+		signal?.addEventListener("abort", abort, { once: true });
+		if (signal?.aborted) abort();
+		if (timeoutMs !== void 0) timer = setTimeout(() => stop(/* @__PURE__ */ new Error("Initialization timed out")), timeoutMs);
+		child.on("error", (error) => {
+			cleanup();
+			reject(error);
+		});
+		child.on("close", (code, exitSignal) => {
+			if (stopped) kill(true);
+			cleanup();
+			if (stopped) reject(stopped);
+			else if (code !== 0) reject(/* @__PURE__ */ new Error(`Command failed: ${command} (exit ${code ?? exitSignal})`));
+			else resolve();
+		});
 	});
-	const deadline = Date.now() + 20 * 6e4;
-	for (;;) try {
-		const handle = await open(path, "wx", 384);
-		await handle.writeFile(owner);
-		await handle.close();
-		break;
+}
+//#endregion
+//#region packages/install/lib/file-lock.mjs
+/** Never unlink this inode. The kernel releases the SQLite transaction on exit.
+* The suffix separates legacy JSON locks from the database format. */
+async function acquireFileLock(path, timeout = 0) {
+	await mkdir(dirname(path), { recursive: true });
+	const file = path + ".sqlite3";
+	await (await open(file, "a", 384)).close();
+	const database = new DatabaseSync(file);
+	const deadline = Date.now() + timeout;
+	try {
+		for (;;) try {
+			database.exec("BEGIN EXCLUSIVE");
+			break;
+		} catch (error) {
+			if (error.errcode !== 5) throw error;
+			if (Date.now() >= deadline) throw new Error("Another installation or content operation is still running");
+			await new Promise((resolve) => setTimeout(resolve, Math.min(250, Math.max(1, deadline - Date.now()))));
+		}
 	} catch (error) {
-		if (error.code !== "EEXIST") throw error;
-		try {
-			const previous = await readFile(path, "utf8"), record = JSON.parse(previous);
-			if (Number.isSafeInteger(record.pid) && typeof record.id === "string") try {
-				process.kill(record.pid, 0);
-			} catch (dead) {
-				if (dead.code === "ESRCH" && await readFile(path, "utf8") === previous) {
-					await unlink(path);
-					continue;
-				}
-			}
-		} catch {}
-		if (Date.now() > deadline) throw new Error("Another content operation is still running");
-		await new Promise((done) => setTimeout(done, 250));
+		database.close();
+		throw error;
 	}
+	let released = false;
+	return () => {
+		if (!released) {
+			released = true;
+			database.close();
+		}
+	};
+}
+//#endregion
+//#region src/content-lock.ts
+async function withContentLock(path, action) {
+	const release = await acquireFileLock(path, 20 * 6e4);
 	try {
 		return await action();
 	} finally {
-		if (await readFile(path, "utf8").catch(() => "") === owner) await unlink(path);
+		release();
 	}
 }
 //#endregion
@@ -406,6 +430,12 @@ async function initializeTransaction(workspace, recoveryRoot, descriptor, resour
 		} catch (recovery) {
 			throw new Error(`${error.message}\n自动恢复未完成，备份保留在 ${directory}：${recovery.message}`);
 		}
+		await rm(directory, {
+			recursive: true,
+			force: true,
+			maxRetries: 3,
+			retryDelay: 100
+		}).catch(() => {});
 		throw new Error(`${error.message}\n已恢复本次初始化前的 Skills 和工作区配置。`);
 	}
 	await rm(journalPath);
@@ -457,6 +487,8 @@ var ContentManager = class {
 	stamp = "";
 	fetcher;
 	registry = REGISTRY;
+	/** Workflows declared by the shipped defaults; registry catalogs may not reintroduce others. */
+	shipped;
 	state = {
 		phase: "idle",
 		message: "",
@@ -466,6 +498,7 @@ var ContentManager = class {
 		this.fetcher = fetcher;
 		this.root = resolve(root);
 		const entries = JSON.parse(readFileSync(defaults, "utf8")).workflows.map(checkedEntry);
+		this.shipped = new Set(entries.map((item) => item.id));
 		this.index = {
 			schemaVersion: 1,
 			entries,
@@ -526,6 +559,10 @@ var ContentManager = class {
 			await this.fetcher.extract(manifest.dist.tarball, directory, options);
 			return directory;
 		} catch (error) {
+			await rm(directory, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
 			if (String(error.message).includes("EINTEGRITY") || error.code === "EINTEGRITY") throw error;
 			const registry = new URL(manifest.dist.tarball).hostname === "registry.npmjs.org" ? MIRROR : REGISTRY;
 			const alternative = await this.fetcher.manifest(`${manifest.name}@${manifest.version}`, {
@@ -535,8 +572,16 @@ var ContentManager = class {
 			validateTarball(alternative);
 			if (alternative.name !== manifest.name || alternative.version !== manifest.version || alternative.dist.integrity !== manifest.dist.integrity) throw new Error("Registry mirror disagrees with the selected package integrity");
 			const fresh = await mkdtemp(join(dirname(directory), `${manifest.version}-mirror-`));
-			await this.fetcher.extract(alternative.dist.tarball, fresh, options);
-			return fresh;
+			try {
+				await this.fetcher.extract(alternative.dist.tarball, fresh, options);
+				return fresh;
+			} catch (error) {
+				await rm(fresh, {
+					recursive: true,
+					force: true
+				}).catch(() => {});
+				throw error;
+			}
 		}
 	}
 	descriptor(record) {
@@ -705,26 +750,30 @@ var ContentManager = class {
 		});
 		return this.pending;
 	}
-	installDependencies(catalogFile, resolvePackage) {
+	installDependencies(catalogFile, resolvePackage, replaceFromSource = false) {
 		return this.operation("dependencies", async () => {
 			const catalog = JSON.parse(await readFile(catalogFile, "utf8"));
 			if (catalog.name !== "@cannbot-plugin/workflow-catalog" || !validVersion(catalog.version) || catalog.cannbotWorkflowCatalog?.schemaVersion !== 1 || !Array.isArray(catalog.cannbotWorkflowCatalog.workflows)) throw new Error("Invalid installed workflow catalog");
-			const baseline = catalog.cannbotWorkflowCatalog.workflows.map(checkedEntry);
+			const baseline = catalog.cannbotWorkflowCatalog.workflows.map(checkedEntry).filter((item) => this.shipped.has(item.id));
 			if (!baseline.length || new Set(baseline.map((item) => item.id)).size !== baseline.length) throw new Error("Invalid installed workflow entries");
-			const newerCatalog = this.index.catalogVersion && newerVersion(this.index.catalogVersion, catalog.version);
+			const newerCatalog = !replaceFromSource && this.index.catalogVersion && newerVersion(this.index.catalogVersion, catalog.version);
 			const entries = newerCatalog ? [...this.index.entries] : [...baseline];
 			for (const old of this.index.entries) if (!entries.some((item) => item.id === old.id)) entries.push(old);
-			await this.save({
+			const next = {
 				...this.index,
 				entries,
-				catalogVersion: newerCatalog ? this.index.catalogVersion : catalog.version
-			});
+				catalogVersion: newerCatalog ? this.index.catalogVersion : catalog.version,
+				records: { ...this.index.records },
+				pinned: [...this.index.pinned]
+			};
 			for (const entry of baseline.filter((item) => item.default)) {
-				if (this.index.records[entry.id]) continue;
+				if (!replaceFromSource && this.index.records[entry.id]) continue;
 				if (!catalog.dependencies?.[entry.package]) throw new Error(`Workflow dependency missing: ${entry.package}`);
 				const packageFile = resolvePackage(entry.package);
 				const manifest = JSON.parse(await readFile(packageFile, "utf8"));
 				if (manifest.name !== entry.package || !validVersion(manifest.version)) throw new Error("Incorrect installed workflow dependency");
+				const identity = (replaceFromSource ? "source:" : "dependency:") + createHash("sha512").update(await readFile(join(dirname(packageFile), "workflow.json"))).digest("base64");
+				if (replaceFromSource && this.index.records[entry.id]?.integrity === identity) continue;
 				const parent = join(this.root, "packages", entry.id);
 				await mkdir(parent, { recursive: true });
 				const directory = await mkdtemp(join(parent, `${manifest.version}-dependency-`));
@@ -732,7 +781,7 @@ var ContentManager = class {
 					recursive: true,
 					dereference: true
 				});
-				const integrity = "dependency:" + createHash("sha512").update(await readFile(join(directory, "workflow.json"))).digest("base64");
+				const integrity = identity;
 				const record = {
 					id: entry.id,
 					package: entry.package,
@@ -742,15 +791,17 @@ var ContentManager = class {
 					installedAt: (/* @__PURE__ */ new Date()).toISOString(),
 					dependency: true
 				};
-				this.descriptor(record);
-				await this.save({
-					...this.index,
-					records: {
-						...this.index.records,
-						[entry.id]: record
-					}
-				});
+				const previous = this.index;
+				try {
+					this.index = next;
+					this.descriptor(record);
+				} finally {
+					this.index = previous;
+				}
+				next.records[entry.id] = record;
+				if (replaceFromSource) next.pinned = next.pinned.filter((id) => id !== entry.id);
 			}
+			await this.save(next);
 			this.publish({
 				phase: "ready",
 				message: "Installed workflow dependencies are ready."
@@ -766,7 +817,7 @@ var ContentManager = class {
 		});
 		const catalog = await this.manifest(`${CATALOG_PACKAGE}@latest`);
 		if (catalog.name !== "@cannbot-plugin/workflow-catalog" || !validVersion(catalog.version) || catalog.cannbotWorkflowCatalog?.schemaVersion !== 1 || !Array.isArray(catalog.cannbotWorkflowCatalog.workflows)) throw new Error("Unsupported workflow catalog");
-		const entries = catalog.cannbotWorkflowCatalog.workflows.map(checkedEntry);
+		const entries = catalog.cannbotWorkflowCatalog.workflows.map(checkedEntry).filter((item) => this.shipped.has(item.id));
 		if (!entries.length || new Set(entries.map((item) => item.id)).size !== entries.length) throw new Error("Invalid workflow catalog");
 		for (const old of this.index.entries) if (this.index.records[old.id] && !entries.some((item) => item.id === old.id)) entries.push(old);
 		await this.save({
@@ -820,27 +871,45 @@ var ContentManager = class {
 				const parent = join(this.root, "packages", entry.id);
 				await mkdir(parent, { recursive: true });
 				let directory = await mkdtemp(join(parent, `${manifest.version}-`));
-				directory = await this.extract(manifest, directory);
-				const record = {
-					id: entry.id,
-					package: entry.package,
-					version: manifest.version,
-					integrity: manifest.dist.integrity,
-					directory: relative(this.root, directory).split(sep).join("/"),
-					installedAt: (/* @__PURE__ */ new Date()).toISOString()
-				};
-				this.descriptor(record);
-				const history = { ...this.index.history };
-				if (previous) history[entry.id] = [previous, ...(history[entry.id] ?? []).filter((item) => item.version !== previous.version)];
-				await this.save({
-					...this.index,
-					records: {
-						...this.index.records,
-						[entry.id]: record
-					},
-					history,
-					pinned: this.index.pinned.filter((item) => item !== entry.id)
-				});
+				let committed = false;
+				try {
+					directory = await this.extract(manifest, directory);
+					const record = {
+						id: entry.id,
+						package: entry.package,
+						version: manifest.version,
+						integrity: manifest.dist.integrity,
+						directory: relative(this.root, directory).split(sep).join("/"),
+						installedAt: (/* @__PURE__ */ new Date()).toISOString()
+					};
+					this.descriptor(record);
+					const history = { ...this.index.history };
+					if (previous) history[entry.id] = [previous, ...(history[entry.id] ?? []).filter((item) => item.version !== previous.version)];
+					await this.save({
+						...this.index,
+						records: {
+							...this.index.records,
+							[entry.id]: record
+						},
+						history,
+						pinned: this.index.pinned.filter((item) => item !== entry.id)
+					});
+					committed = true;
+				} finally {
+					if (!committed) {
+						let retained = true;
+						try {
+							const active = JSON.parse(await readFile(join(this.root, "active.json"), "utf8"));
+							retained = Object.values(active.records).some((record) => inside(this.root, record.directory) === directory);
+						} catch (error) {
+							if (error.code === "ENOENT") retained = false;
+						}
+						if (!retained) await rm(directory, {
+							recursive: true,
+							force: true
+						}).catch(() => {});
+					}
+				}
 				this.errors.delete(entry.id);
 			} catch (error) {
 				const message = String(error.message).slice(-500);
@@ -874,61 +943,30 @@ var ContentManager = class {
 		});
 	}
 	async runInitializer(entry, args, cwd) {
-		await new Promise((accept, reject) => {
-			let output = "", stopped = false;
-			const compatibility = join(import.meta.dirname, "../runtime/initializer-compat.cjs");
-			const child = spawn(process.execPath, [
-				"--require",
-				compatibility,
-				entry,
-				...args
-			], {
+		let output = "";
+		try {
+			await runProcess(process.execPath, [entry, ...args], {
 				cwd,
-				windowsHide: true,
-				detached: process.platform !== "win32",
 				stdio: [
 					"ignore",
 					"pipe",
 					"pipe"
 				],
+				timeoutMs: 20 * 6e4,
 				env: {
 					...process.env,
 					...process.versions.electron ? { ELECTRON_RUN_AS_NODE: "1" } : {},
-					CANNBOT_INITIALIZER_WORKSPACE: cwd,
 					GIT_TERMINAL_PROMPT: "0",
 					GCM_INTERACTIVE: "never"
+				},
+				onData: (data) => {
+					output = (output + data).slice(-16e3);
+					this.publish({ log: output.slice(-6e3) });
 				}
 			});
-			const log = (data) => {
-				output = (output + data).slice(-16e3);
-				this.publish({ log: output.slice(-6e3) });
-			};
-			child.stdout.on("data", log);
-			child.stderr.on("data", log);
-			const timer = setTimeout(() => {
-				stopped = true;
-				if (child.pid) if (process.platform === "win32") spawn("taskkill", [
-					"/PID",
-					String(child.pid),
-					"/T",
-					"/F"
-				], {
-					windowsHide: true,
-					stdio: "ignore"
-				});
-				else try {
-					process.kill(-child.pid, "SIGTERM");
-				} catch {}
-			}, 20 * 6e4);
-			child.on("error", (error) => {
-				clearTimeout(timer);
-				reject(error);
-			});
-			child.on("close", (code) => {
-				clearTimeout(timer);
-				code === 0 && !stopped ? accept() : reject(new Error(stopped ? "Initialization timed out" : output.slice(-1500) || "Initialization failed"));
-			});
-		});
+		} catch (error) {
+			throw new Error(`${error.message}\n${output.slice(-1500)}`);
+		}
 	}
 	async prepare(cwd, id) {
 		if (!validId(id)) throw new Error("Invalid workflow");
@@ -1107,6 +1145,887 @@ function registerContentRoutes(ctx, content) {
 	});
 }
 //#endregion
+//#region src/native-workflow-bootstrap.mjs
+/** Plugin-owned Python bootstrap. Paths and prompts travel as argv, never interpolated code. */
+const pythonBootstrap = String.raw`
+import concurrent.futures
+import json
+import os
+import sys
+import threading
+import uuid
+
+# Import the installed workflow's shared scheduler, including its sibling modules.
+script = os.path.abspath(sys.argv.pop(1))
+sys.path.insert(0, os.path.dirname(script))
+sys.argv[0] = script
+import orchestrator
+
+# Use the unchanged CLI parser for ordinary YAML/workspace/prompt arguments.
+args = orchestrator.parse_args()
+if args.provider is not None:
+    raise SystemExit("The plugin supplies its execution callback; do not pass a CLI provider")
+
+class PipeExecutor:
+    def __init__(self, output):
+        self.output = output
+        self.lock = threading.Lock()
+        self.pending = {}
+        threading.Thread(target=self._receive, daemon=True).start()
+
+    def _receive(self):
+        try:
+            for line in sys.stdin:
+                response = json.loads(line)
+                with self.lock:
+                    future = self.pending.pop(response['id'], None)
+                if future is not None:
+                    future.set_result(response)
+        finally:
+            # Host loss releases the Python scheduler even while awaiting approval.
+            os._exit(2)
+
+    def execute(self, entry, work_dir, path):
+        request_id = str(uuid.uuid4())
+        future = concurrent.futures.Future()
+        with self.lock:
+            self.pending[request_id] = future
+            self.output.write(json.dumps({'id': request_id, 'taskId': entry['task_id'],
+                                         'role': entry['agent'], 'phase': entry['_phase'],
+                                         'prompt': entry['prompt'], 'workDir': work_dir}) + '\n')
+            self.output.flush()
+        response = future.result()
+        with open(path, 'w', encoding='utf-8') as output:
+            json.dump(response, output, ensure_ascii=False)
+        return ('executed' if entry['_phase'] == 'execute' else ''), not response.get('ok', False)
+
+# Preserve one protocol descriptor; scheduler/subprocess logs all go to stderr.
+protocol = os.fdopen(os.dup(sys.stdout.fileno()), 'w', encoding='utf-8')
+os.dup2(sys.stderr.fileno(), sys.stdout.fileno())
+sys.stdout = sys.stderr
+executor = PipeExecutor(protocol)
+sys.exit(orchestrator.main(task_executor=executor.execute, args=args))
+`;
+//#endregion
+//#region src/workflow-todos.mjs
+const PREFIX$1 = "[工作流] ";
+const active = new Set([
+	"running",
+	"executed",
+	"verifying",
+	"awaiting_approval"
+]);
+const labels = {
+	pending: "待执行",
+	running: "执行中",
+	executed: "待验证",
+	verifying: "验证中",
+	awaiting_approval: "待审批",
+	pass: "已完成",
+	fail: "失败",
+	skipped: "已跳过"
+};
+function externalWorkflowLaunch(event) {
+	if (event.type !== "tool/call" || event.data.name !== "bash") return;
+	try {
+		const { command } = JSON.parse(event.data.arguments);
+		if (!/(?:run_workflow|orchestrator)\.py(?:\s|["'])/.test(command)) return;
+		const argument = (name) => {
+			const match = command.match(new RegExp(`--${name}\\s+(?:"([^"$\\\\]+)"|'([^']+)'|([^\\s;|&<>"'$\\\\]+))`));
+			const value = match?.[1] ?? match?.[2] ?? match?.[3];
+			return value && isAbsolute(value) ? value : void 0;
+		};
+		const cwd = argument("work-dir"), yaml = argument("yaml");
+		if (cwd && yaml) return {
+			cwd,
+			yaml,
+			external: true
+		};
+	} catch {}
+}
+/** The native TodoItem has three states. Preserve richer scheduler states in its text. */
+async function readTaskNames(yaml) {
+	const names = /* @__PURE__ */ new Map();
+	try {
+		const config = parse(await readFile(yaml, "utf8"));
+		for (const node of config?.nodes ?? []) if (node?.id != null && typeof node.title === "string" && node.title.trim()) names.set(String(node.id), node.title.trim());
+	} catch {}
+	return names;
+}
+async function readCompletionOrder(cwd) {
+	const order = [];
+	try {
+		for (const line of (await readFile(join(cwd, ".workflow/log.jsonl"), "utf8")).split("\n")) try {
+			const event = JSON.parse(line);
+			if (event.task_id != null && (["pass", "skipped"].includes(event.to) || event.verdict === "pass")) {
+				const id = String(event.task_id), index = order.indexOf(id);
+				if (index >= 0) order.splice(index, 1);
+				order.push(id);
+			}
+		} catch {}
+	} catch {}
+	return order;
+}
+function workflowTodos(workflow, state, finished = false, taskNames = /* @__PURE__ */ new Map(), completionOrder = []) {
+	const entries = Object.entries(state?.tasks ?? {});
+	const completed = entries.filter(([, task]) => ["pass", "skipped"].includes(task?.status)).sort(([a], [b]) => completionOrder.indexOf(a) - completionOrder.indexOf(b));
+	return [...entries.filter(([, task]) => !["pass", "skipped"].includes(task?.status)), ...completed].flatMap(([id, task]) => {
+		if (!task || typeof task !== "object") return [];
+		const detail = finished && active.has(task.status) ? finished === "paused" ? "已暂停" : "已中断" : labels[task.status] ?? "未知状态";
+		const retry = Number.isSafeInteger(task.retries) && task.retries > 0 ? `，重试 ${task.retries}` : "";
+		return [{
+			content: `${PREFIX$1}${workflow || "当前工作流"} / ${taskNames.get(id) ?? id} · ${detail}${retry}`,
+			status: ["pass", "skipped"].includes(task.status) ? "completed" : !finished && active.has(task.status) ? "in_progress" : "pending"
+		}];
+	});
+}
+/** Publish through DSH's existing durable todo projection, preserving non-workflow todos. */
+var WorkflowTodos = class {
+	constructor(ctx) {
+		this.ctx = ctx;
+		this.sessions = /* @__PURE__ */ new Map();
+		this.closed = false;
+		this.restoring = /* @__PURE__ */ new Set();
+		this.externalSessions = /* @__PURE__ */ new Map();
+		this.externalRuns = /* @__PURE__ */ new Map();
+		this.observer = setInterval(() => {
+			for (const session of this.externalSessions.values()) this.restore(session, true);
+		}, 1e3);
+		this.observer.unref?.();
+		this.releaseCreated = ctx.on?.("session/created", (session) => {
+			this.restore(session);
+		});
+		for (const session of ctx.sessions?.list() ?? []) this.restore(session);
+		this.release = ctx.on?.("session/event", (session, event) => {
+			if (externalWorkflowLaunch(event)) {
+				this.externalSessions.set(session.id, session);
+				this.restore(session);
+			}
+			const entry = this.sessions.get(session.id);
+			if (!entry || !["todo/write", "turn/start"].includes(event.type)) return;
+			if (entry.queued) return;
+			entry.queued = true;
+			queueMicrotask(() => {
+				entry.queued = false;
+				this.sync(entry);
+			});
+		});
+	}
+	async restore(session, refresh = false) {
+		if (this.closed || !this.ctx.sessionQuery || !session.header?.cwd || this.restoring.has(session.id)) return;
+		this.restoring.add(session.id);
+		try {
+			const history = refresh ? { events: [] } : await this.ctx.sessionQuery.readSession(session.id);
+			const calls = /* @__PURE__ */ new Map(), runs = refresh ? new Map(this.externalRuns.get(session.id) ?? []) : /* @__PURE__ */ new Map();
+			for (const event of history.events) {
+				if (event.seq < (session.inheritedEventCount ?? 0)) continue;
+				const external = externalWorkflowLaunch(event);
+				if (external) {
+					runs.set(external.cwd, external);
+					this.externalSessions.set(session.id, session);
+				}
+				if (event.type === "tool/call" && event.data.name === "cannbot_workflow_run") try {
+					calls.set(event.data.callId, JSON.parse(event.data.arguments));
+				} catch {}
+				if (event.type !== "tool/result" || event.data.isError) continue;
+				const message = event.data.message, args = calls.get(message?.toolCallId);
+				if (!args) continue;
+				for (const block of message.content ?? []) try {
+					const result = JSON.parse(block.text);
+					if (result.runId && typeof result.workDir === "string") {
+						for (const [cwd, old] of runs) if (old.workflow === args.workflow) runs.delete(cwd);
+						runs.set(result.workDir, {
+							cwd: result.workDir,
+							workflow: args.workflow
+						});
+					}
+				} catch {}
+			}
+			const latest = [...runs.values()].at(-1);
+			if (latest?.external) {
+				runs.clear();
+				runs.set(latest.cwd, latest);
+				this.externalRuns.set(session.id, new Map(runs));
+			} else {
+				for (const [cwd, run] of runs) if (run.external) runs.delete(cwd);
+				this.externalRuns.delete(session.id);
+				this.externalSessions.delete(session.id);
+			}
+			const workspace = await realpath(session.header.cwd);
+			for (const run of runs.values()) try {
+				const path = await realpath(join(run.cwd, ".workflow/status.json"));
+				const diff = relative(workspace, path);
+				if (diff === ".." || diff.startsWith("../") || isAbsolute(diff)) continue;
+				const state = JSON.parse(await readFile(path, "utf8"));
+				if (run.external) {
+					const yaml = await realpath(run.yaml);
+					if (!withinWorkspace(workspace, yaml) || await realpath(state.workflow) !== yaml) continue;
+					run.workflow = parse(await readFile(yaml, "utf8")).workflow || "外部工作流";
+				}
+				run.taskNames = await readTaskNames(state.workflow);
+				run.completionOrder = await readCompletionOrder(run.cwd);
+				const existing = this.sessions.get(session.id)?.runs.get(run.cwd);
+				if (this.closed || existing && !existing.external) continue;
+				if (run.external) {
+					const entry = this.sessions.get(session.id);
+					for (const [cwd, old] of entry?.runs ?? []) if (cwd !== run.cwd && old.workflow === run.workflow && (old.external || old.finished)) entry.runs.delete(cwd);
+				}
+				this.update({
+					id: session.id,
+					session
+				}, run, state, !run.external);
+			} catch {}
+		} catch (error) {
+			this.ctx.logger?.warn(`Cannot restore workflow todos for ${session.id}: ${error.message}`);
+		} finally {
+			this.restoring.delete(session.id);
+		}
+	}
+	update(parent, run, state, finished = false) {
+		if (this.closed || !parent.session || !this.ctx.sessionProjections?.stateOf) return;
+		let entry = this.sessions.get(parent.id);
+		if (!entry) {
+			entry = {
+				session: parent.session,
+				runs: /* @__PURE__ */ new Map(),
+				queued: false
+			};
+			this.sessions.set(parent.id, entry);
+		}
+		for (const [cwd, old] of entry.runs) if (cwd !== run.cwd && old.workflow === run.workflow && old.finished) entry.runs.delete(cwd);
+		const previous = entry.runs.get(run.cwd);
+		const completed = Object.keys(state?.tasks ?? {}).filter((id) => ["pass", "skipped"].includes(state.tasks[id]?.status));
+		const completionOrder = (previous?.completionOrder ?? run.completionOrder ?? []).filter((id) => completed.includes(id));
+		for (const id of completed) if (!completionOrder.includes(id)) completionOrder.push(id);
+		entry.runs.set(run.cwd, {
+			workflow: run.workflow,
+			cwd: run.cwd,
+			external: run.external,
+			taskNames: run.taskNames,
+			completionOrder,
+			state,
+			finished
+		});
+		this.sync(entry);
+	}
+	sync(entry) {
+		if (this.closed || this.sessions.get(entry.session.id) !== entry) return;
+		try {
+			const current = this.ctx.sessionProjections.stateOf(entry.session, "todos");
+			if (current === void 0) return;
+			const existing = current ?? [];
+			const names = [...entry.runs.values()].map((run) => run.workflow);
+			const rows = [...entry.runs.values()].flatMap((run) => workflowTodos(names.filter((name) => name === run.workflow).length > 1 ? `${run.workflow} (${run.cwd})` : run.workflow, run.state, run.finished, run.taskNames, run.completionOrder));
+			const todos = [...existing.filter((item) => !item.content.startsWith(PREFIX$1)), ...rows];
+			if (JSON.stringify(todos) !== JSON.stringify(existing)) entry.session.append("todo/write", { todos });
+		} catch {}
+	}
+	dispose() {
+		this.closed = true;
+		clearInterval(this.observer);
+		this.externalSessions.clear();
+		this.externalRuns.clear();
+		this.release?.();
+		this.releaseCreated?.();
+		this.sessions.clear();
+	}
+};
+function withinWorkspace(root, path) {
+	const diff = relative(root, path);
+	return diff !== ".." && !diff.startsWith("../") && !isAbsolute(diff);
+}
+//#endregion
+//#region src/native-workflow.mjs
+/** Python owns scheduling and verdicts; each dispatched node runs in DSH's native child loop. */
+function within(root, path) {
+	const diff = relative(root, path);
+	return diff !== ".." && !diff.startsWith("../") && !diff.startsWith("..\\") && !isAbsolute(diff);
+}
+var NativeWorkflow = class {
+	constructor(ctx) {
+		this.ctx = ctx;
+		this.todos = new WorkflowTodos(ctx);
+		this.runs = /* @__PURE__ */ new Map();
+		this.closed = false;
+	}
+	async start(parent, { runner, yaml, cwd, resources, prompt, workflow = "", goalId }) {
+		if (this.closed) throw new Error("DSH workflow runner is stopping");
+		await mkdir(cwd, { recursive: true });
+		cwd = await realpath(cwd);
+		for (const run of this.runs.values()) if (run.cwd === cwd && run.code === null) throw new Error("A workflow is already running in this directory");
+		const id = randomUUID(), controller = new AbortController();
+		const run = {
+			id,
+			owner: parent.id,
+			goalId,
+			workflow,
+			cwd,
+			code: null,
+			error: "",
+			controller,
+			process: null,
+			done: null,
+			log: "",
+			finalState: void 0
+		};
+		this.runs.set(id, run);
+		let file;
+		try {
+			run.taskNames = await readTaskNames(yaml);
+			run.completionOrder = await readCompletionOrder(cwd);
+			await mkdir(join(cwd, ".workflow"), { recursive: true });
+			file = await open(join(cwd, ".workflow/dsh-runner.log"), "a");
+			controller.signal.throwIfAborted();
+			if (this.closed) throw new Error("DSH workflow runner is stopping");
+			const argv = [
+				"-c",
+				pythonBootstrap,
+				runner,
+				"--yaml",
+				yaml,
+				"--work-dir",
+				cwd
+			];
+			if (prompt) argv.push("--prompt", prompt);
+			const child = spawn("python3", argv, {
+				cwd,
+				stdio: [
+					"pipe",
+					"pipe",
+					"pipe"
+				]
+			});
+			run.process = child;
+			const pending = /* @__PURE__ */ new Set();
+			const lines = createInterface({ input: child.stdout });
+			let logging = Promise.resolve();
+			const log = (text) => {
+				run.log = (run.log + String(text)).slice(-8192);
+				logging = logging.then(() => file.appendFile(text)).catch((error) => {
+					run.error = String(error);
+				});
+			};
+			child.stderr.on("data", log);
+			child.stdin.on("error", (error) => {
+				if (!controller.signal.aborted) run.error = String(error);
+			});
+			child.on("error", (error) => {
+				run.error = String(error);
+			});
+			lines.on("line", (line) => {
+				let request;
+				try {
+					request = JSON.parse(line);
+					if (typeof request.id !== "string" || typeof request.prompt !== "string" || typeof request.taskId !== "string" || ![
+						"execute",
+						"verify",
+						"advice"
+					].includes(request.phase) || resolve(request.workDir) !== cwd) throw new Error("Invalid Python dispatch");
+				} catch (error) {
+					run.error = String(error);
+					controller.abort();
+					child.kill();
+					return;
+				}
+				const job = this.executeNode(parent, request, resources, controller.signal).catch((error) => ({
+					ok: false,
+					error: String(error)
+				})).then((result) => {
+					if (!child.stdin.destroyed && !controller.signal.aborted) child.stdin.write(JSON.stringify({
+						id: request.id,
+						...result
+					}) + "\n");
+				});
+				pending.add(job);
+				job.finally(() => pending.delete(job));
+			});
+			run.done = new Promise((accept) => child.on("close", async (code, signal) => {
+				run.todoStopped = true;
+				clearTimeout(run.todoTimer);
+				await run.todoPoll;
+				controller.abort();
+				lines.close();
+				await Promise.allSettled([...pending]);
+				await logging;
+				await file.close().catch((error) => {
+					run.error = String(error);
+				});
+				try {
+					run.finalState = JSON.parse(await readFile(join(cwd, ".workflow/status.json"), "utf8"));
+				} catch {}
+				run.code = code ?? 2;
+				if (signal) run.error ||= `Scheduler terminated by ${signal}`;
+				this.todos.update(parent, run, run.finalState, run.paused ? "paused" : true);
+				accept();
+			}));
+			this.trackTodos(parent, run);
+			return {
+				runId: id,
+				workDir: cwd,
+				status: "running"
+			};
+		} catch (error) {
+			this.runs.delete(id);
+			await file?.close();
+			throw error;
+		}
+	}
+	trackTodos(parent, run) {
+		if (!parent.session || !this.ctx.sessionProjections?.stateOf) return;
+		const poll = () => {
+			run.todoPoll = (async () => {
+				try {
+					const state = JSON.parse(await readFile(join(run.cwd, ".workflow/status.json"), "utf8"));
+					if (!run.todoStopped) this.todos.update(parent, run, state);
+				} catch {}
+				if (!run.todoStopped) run.todoTimer = setTimeout(poll, 1e3);
+			})();
+		};
+		poll();
+	}
+	async executeNode(parent, request, resources, signal) {
+		if (typeof request.role !== "string" || !/^[\w-]+$/.test(request.role)) throw new Error("Invalid workflow role");
+		const role = await readFile(join(resources, "agents", request.role + ".md"), "utf8");
+		signal.throwIfAborted();
+		const activation = await this.ctx.subagents.startActivation({
+			provider: "spawn",
+			delivery: "caller",
+			signal,
+			label: `CANNBot ${request.taskId} · ${request.phase}`,
+			request: {
+				parent,
+				cwd: request.workDir,
+				prompt: [{
+					type: "text",
+					text: `Execute one Python-scheduled workflow node using the DSH agent loop.\nWorkflow resources: ${resources}\nSkills: ${join(resources, "skills")}\nRole instructions (frontmatter is metadata):\n${role}\n\nFollow the task's verdict callback instructions. Python owns dependencies, retries, approvals and status updates.\n` + request.prompt
+				}]
+			}
+		});
+		const cancel = () => {
+			activation.dispose().catch(() => {});
+		};
+		signal.addEventListener("abort", cancel, { once: true });
+		if (signal.aborted) cancel();
+		try {
+			const result = await activation.result;
+			return {
+				ok: !signal.aborted && result.stopReason === "completed",
+				childSessionId: activation.childId,
+				stopReason: result.stopReason,
+				output: result.output,
+				diagnostic: result.diagnostic
+			};
+		} finally {
+			signal.removeEventListener("abort", cancel);
+			await activation.dispose();
+		}
+	}
+	owned(parent, id) {
+		const run = this.runs.get(id);
+		if (!run || run.owner !== parent.id) throw new Error("Workflow run is unavailable in this session");
+		return run;
+	}
+	async status(parent, id, waitMs = 0) {
+		const run = this.owned(parent, id);
+		if (!Number.isInteger(waitMs) || waitMs < 0 || waitMs > 3e4) throw new Error("waitMs must be between 0 and 30000");
+		let timer;
+		if (run.done && run.code === null && waitMs) try {
+			await Promise.race([run.done, new Promise((accept) => {
+				timer = setTimeout(accept, waitMs);
+			})]);
+		} finally {
+			clearTimeout(timer);
+		}
+		let state = run.finalState;
+		if (run.code === null) try {
+			state = JSON.parse(await readFile(join(run.cwd, ".workflow/status.json"), "utf8"));
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		if (state) this.todos.update(parent, run, state, run.code !== null && (run.paused ? "paused" : true));
+		return {
+			runId: id,
+			workDir: run.cwd,
+			status: run.code === null ? "running" : run.paused ? "paused" : run.code === 0 ? "completed" : "failed",
+			exitCode: run.code,
+			error: run.error || void 0,
+			state,
+			log: run.log
+		};
+	}
+	async stop(run) {
+		run.controller.abort();
+		run.process?.stdin.end();
+		run.process?.kill("SIGTERM");
+		const timer = setTimeout(() => run.process?.kill("SIGKILL"), 3e3);
+		try {
+			await run.done;
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+	async cancel(parent, id) {
+		const run = this.owned(parent, id);
+		if (run.code === null) await this.stop(run);
+		return this.status(parent, id);
+	}
+	async dispose() {
+		this.closed = true;
+		await Promise.all([...this.runs.values()].filter((run) => run.code === null).map((run) => this.stop(run)));
+		this.todos.dispose();
+	}
+};
+//#endregion
+//#region src/goal-workflow-resume.mjs
+/** Recover successful starts belonging to this goal, excluding fork-inherited work. */
+function goalWorkflowRuns(events, goalId, inherited = 0) {
+	const calls = /* @__PURE__ */ new Map(), runs = /* @__PURE__ */ new Map();
+	let currentGoal, turn, hadGoal = false;
+	for (const event of events) {
+		if (event.seq < inherited) continue;
+		if (event.type === "tool/call") turn = event.data.turn;
+		if (event.type === "goal/change") {
+			if (!hadGoal && event.data.operation === "create") {
+				for (const call of calls.values()) if (call.turn === turn) call.goal = event.data.goal?.id;
+			}
+			currentGoal = event.data.goal?.id;
+			hadGoal = true;
+		}
+		if (event.type === "tool/call" && event.data.name === "cannbot_workflow_run") try {
+			calls.set(event.data.callId, {
+				args: JSON.parse(event.data.arguments),
+				goal: currentGoal,
+				turn
+			});
+		} catch {}
+		if (event.type !== "tool/result" || event.data.isError) continue;
+		const message = event.data.message, call = calls.get(message?.toolCallId);
+		if (!call) continue;
+		for (const block of message.content ?? []) try {
+			const result = JSON.parse(block.text);
+			if (result.runId && typeof result.workDir === "string") runs.set(result.workDir, {
+				call,
+				workDir: result.workDir
+			});
+		} catch {}
+	}
+	return [...runs.values()].filter((run) => run.call.goal === goalId).map(({ call, workDir }) => ({
+		workflow: call.args.workflow,
+		yaml: call.args.yaml,
+		workDir
+	}));
+}
+function installGoalWorkflowResume(ctx, execution, start) {
+	const pending = /* @__PURE__ */ new Map();
+	const stopping = /* @__PURE__ */ new Map();
+	ctx.on("goal/changed", ({ agent, change }) => {
+		if (change.operation === "resume") pending.set(agent, change.ref);
+		else pending.delete(agent);
+		if (change.operation === "pause") {
+			const previous = stopping.get(agent);
+			const job = (async () => {
+				await previous;
+				const history = await ctx.sessionQuery.readSession(agent.id);
+				const directories = new Set(goalWorkflowRuns(history.events, change.ref.id, agent.session.inheritedEventCount).map((run) => run.workDir));
+				await Promise.all([...execution.runs.values()].filter((run) => run.owner === agent.id && run.code === null && (run.goalId === change.ref.id || directories.has(run.cwd))).map((run) => {
+					run.paused = true;
+					return execution.stop(run);
+				}));
+			})();
+			stopping.set(agent, job);
+			job.catch((error) => ctx.logger?.warn(`Cannot pause workflow: ${error}`));
+			return job;
+		}
+	});
+	ctx.on("agent/disposed", ({ agent }) => {
+		pending.delete(agent);
+		stopping.delete(agent);
+	});
+	ctx.on("dispose", () => {
+		pending.clear();
+		stopping.clear();
+	});
+	ctx.on("agent/pre-step", async ({ agent, signal }, next) => {
+		const decision = await next();
+		const ref = pending.get(agent);
+		if (decision.kind !== "enter" || !ref) return decision;
+		const valid = () => {
+			const goal = ctx.goals.get(agent);
+			return pending.get(agent) === ref && goal?.id === ref.id && goal.revision === ref.revision && goal.phase === "active";
+		};
+		if (!valid()) return decision;
+		const notices = [];
+		try {
+			await stopping.get(agent);
+			signal.throwIfAborted();
+			if (!valid()) return decision;
+			const runs = goalWorkflowRuns((await ctx.sessionQuery.readSession(agent.id)).events, ref.id, agent.session.inheritedEventCount);
+			const workspace = await realpath(await ctx.workingDirectory.ensure(agent, signal));
+			for (const args of runs) {
+				signal.throwIfAborted();
+				if (!valid()) break;
+				const cwd = await realpath(args.workDir);
+				if (!within(workspace, cwd)) throw new Error("Workflow directory escapes the session workspace");
+				const live = [...execution.runs.values()].find((run) => run.cwd === cwd && run.code === null);
+				if (live) {
+					if (live.owner !== agent.id) throw new Error("Workflow directory is running in another session");
+					notices.push({
+						workflow: args.workflow,
+						runId: live.id,
+						status: "running",
+						reused: true
+					});
+					continue;
+				}
+				const path = await realpath(join(cwd, ".workflow/status.json"));
+				if (!within(workspace, path)) throw new Error("Workflow state escapes the session workspace");
+				const state = JSON.parse(await readFile(path, "utf8"));
+				const tasks = Object.values(state.tasks ?? {});
+				if (!tasks.length || tasks.every((task) => ["pass", "skipped"].includes(task.status))) continue;
+				signal.throwIfAborted();
+				if (!valid()) break;
+				const result = await start(args, agent, signal);
+				const run = execution.runs.get(result.runId);
+				if (run) run.goalId = ref.id;
+				if (!valid()) {
+					if (run && run.code === null) {
+						run.paused = true;
+						await execution.stop(run);
+					}
+					break;
+				}
+				notices.push({
+					workflow: args.workflow,
+					...result
+				});
+			}
+		} catch (error) {
+			if (signal.aborted) throw error;
+			notices.push({
+				error: String(error),
+				instruction: "Workflow recovery failed. Diagnose this error; do not assume a stale running state means the scheduler is alive."
+			});
+		}
+		if (pending.get(agent) === ref) pending.delete(agent);
+		if (!notices.length) return decision;
+		return {
+			...decision,
+			messages: decision.messages.map((message, index) => index === 0 ? {
+				...message,
+				content: [...message.content, {
+					type: "text",
+					text: `CANNBot workflow recovery after goal resume: ${JSON.stringify(notices)}\nUse cannbot_workflow_status with the reported runId to track scheduling; do not replace it with shell sleep/poll loops.`
+				}]
+			} : message)
+		};
+	});
+}
+//#endregion
+//#region src/pm-progress.mjs
+const PREFIX = "[PM 当前操作] ";
+const isWorkflow = (item) => item.content.startsWith("[工作流] ");
+const isProgress = (item) => item.content.startsWith(PREFIX);
+/** Keep native PM plans across turns; show factual activity until PM supplies a plan. */
+var PmProgress = class {
+	constructor(ctx) {
+		this.ctx = ctx;
+		this.entries = /* @__PURE__ */ new Map();
+		this.closed = false;
+		this.releases = [ctx.on("session/created", (session) => {
+			this.restore(session);
+		}), ctx.on("session/event", (session, event) => this.event(session, event))];
+		for (const session of ctx.sessions?.list() ?? []) this.restore(session);
+	}
+	event(session, event, replay = false) {
+		if (this.closed) return;
+		if (![
+			"user/message",
+			"tool/call",
+			"tool/result",
+			"todo/write",
+			"turn/start",
+			"turn/end"
+		].includes(event.type)) return;
+		let entry = this.entries.get(session.id);
+		if (event.type === "user/message" && event.data.source?.kind === "cannbot-harness-workflow") {
+			if (!entry) {
+				entry = {
+					session,
+					plan: [],
+					activity: "准备工作流",
+					status: "in_progress",
+					queued: false
+				};
+				this.entries.set(session.id, entry);
+			}
+		}
+		if (!entry) return;
+		if (event.type === "tool/call" && event.data.name !== "todo_write") try {
+			const args = JSON.parse(event.data.arguments);
+			if (typeof args.description === "string" && args.description.trim()) {
+				entry.activity = args.description.trim().slice(0, 240);
+				entry.status = "in_progress";
+				entry.callId = event.data.callId;
+			}
+		} catch {}
+		if (event.type === "tool/result" && event.data.message?.toolCallId === entry.callId && event.data.isError) {
+			entry.status = "pending";
+			entry.activity = `操作失败，待处理：${entry.activity}`;
+		}
+		if (event.type === "todo/write") {
+			const rows = event.data.todos ?? [];
+			const plan = rows.filter((item) => !isWorkflow(item) && !isProgress(item));
+			if (!rows.some(isProgress) && (plan.length || !rows.length)) entry.plan = plan;
+		}
+		if (event.type === "turn/end") entry.status = "pending";
+		if (event.type === "turn/start") entry.status = "in_progress";
+		if (!replay) this.queue(entry);
+	}
+	queue(entry) {
+		if (entry.queued || this.closed) return;
+		entry.queued = true;
+		queueMicrotask(() => {
+			entry.queued = false;
+			if (this.closed || this.entries.get(entry.session.id) !== entry) return;
+			const current = this.ctx.sessionProjections.stateOf(entry.session, "todos");
+			if (current === void 0) return;
+			const workflow = (current ?? []).filter(isWorkflow);
+			const rows = [...entry.plan, ...workflow];
+			if (!rows.length) rows.push({
+				content: PREFIX + entry.activity,
+				status: entry.status
+			});
+			if (JSON.stringify(current) !== JSON.stringify(rows)) entry.session.append("todo/write", { todos: rows });
+		});
+	}
+	async restore(session) {
+		try {
+			const history = await this.ctx.sessionQuery.readSession(session.id);
+			if (this.closed || this.entries.has(session.id)) return;
+			for (const event of history.events) if (event.seq >= (session.inheritedEventCount ?? 0)) this.event(session, event, true);
+			const entry = this.entries.get(session.id);
+			if (entry) this.queue(entry);
+		} catch (error) {
+			this.ctx.logger?.warn(`Cannot restore PM progress: ${error}`);
+		}
+	}
+	dispose() {
+		this.closed = true;
+		for (const release of this.releases) release?.();
+		this.entries.clear();
+	}
+};
+//#endregion
+//#region src/native-workflow-tools.mjs
+/** Register generic Python workflow scheduling tools when DSH's native loop is available. */
+function installNativeWorkflowTools(ctx, content) {
+	ctx.inject([
+		"tools",
+		"subagents",
+		"workingDirectory",
+		"sessionProjections",
+		"sessions",
+		"sessionQuery"
+	], (scoped) => {
+		const execution = new NativeWorkflow(scoped);
+		const progress = new PmProgress(scoped);
+		let goals;
+		scoped.on("dispose", () => execution.dispose());
+		scoped.on("dispose", () => progress.dispose());
+		async function start(args, agent, signal) {
+			const workspace = await realpath(await scoped.workingDirectory.ensure(agent, signal));
+			await content.prepare(workspace, args.workflow);
+			const source = content.getSource();
+			const plugin = source.catalog.plugins.find((item) => item.id === args.workflow);
+			if (!plugin) throw new Error("Unknown workflow package");
+			const resources = await realpath(resolve(source.assets, plugin.resourceDirectory ?? plugin.id));
+			const runner = join(resources, "skills/workflow-orchestrator/scripts/orchestrator.py");
+			await access(runner);
+			const yaml = await realpath(isAbsolute(args.yaml) ? args.yaml : resolve(resources, args.yaml));
+			if (!within(resources, yaml) && !within(workspace, yaml)) throw new Error("Workflow YAML must belong to the package or workspace");
+			const cwd = resolve(workspace, args.workDir ?? ".");
+			if (!within(workspace, cwd)) throw new Error("Workflow directory must be inside the session workspace");
+			let ancestor = cwd;
+			while (true) try {
+				if (!within(workspace, await realpath(ancestor))) throw new Error("Workflow directory escapes the session workspace");
+				break;
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+				ancestor = resolve(ancestor, "..");
+			}
+			signal.throwIfAborted();
+			return execution.start(agent, {
+				runner,
+				yaml,
+				cwd,
+				resources,
+				prompt: args.prompt,
+				workflow: args.workflow,
+				goalId: goals?.get(agent)?.id
+			});
+		}
+		scoped.inject(["goals"], (goalScope) => {
+			goals = goalScope.goals;
+			goalScope.on("dispose", () => {
+				goals = void 0;
+			});
+			installGoalWorkflowResume(goalScope, execution, start);
+		});
+		const string = {
+			type: "string",
+			required: true
+		};
+		const specs = [
+			[
+				"cannbot_workflow_run",
+				{
+					workflow: string,
+					yaml: string,
+					prompt: { type: "string" },
+					workDir: { type: "string" }
+				},
+				"Run or resume a YAML workflow from the selected CANNBot workflow package. Python owns scheduling, parallelism, retries and verdicts; nodes use the DSH native agent loop and inherit the session model. No CLI provider is needed. yaml is absolute or relative to package resources; workDir defaults to the session workspace. prompt is required for a new run."
+			],
+			[
+				"cannbot_workflow_status",
+				{
+					runId: string,
+					waitMs: { type: "number" }
+				},
+				"Read Python workflow state and log. Optionally wait up to 30000 ms. Awaiting approvals remain governed by the Python workflow approval scripts."
+			],
+			[
+				"cannbot_workflow_cancel",
+				{ runId: string },
+				"Stop this session’s scheduler and native node agents. Start the same YAML and working directory again to recover through the Python resume logic."
+			]
+		];
+		for (const [name, parameters, description] of specs) scoped.tools.register(defineTool({
+			name,
+			parameters,
+			description,
+			output: {
+				schema: {
+					type: "object",
+					properties: {},
+					additionalProperties: true
+				},
+				render: (_args, value) => [{
+					type: "text",
+					text: JSON.stringify(value)
+				}]
+			},
+			async execute(args, exec) {
+				if (!exec.agent) throw new Error("A live DSH session is required");
+				if (name === "cannbot_workflow_status") return execution.status(exec.agent, args.runId, args.waitMs);
+				if (name === "cannbot_workflow_cancel") return execution.cancel(exec.agent, args.runId);
+				if (["provider", "model"].some((key) => key in args)) throw new Error("Workflow nodes inherit the DSH session model");
+				return start(args, exec.agent, exec.signal);
+			}
+		}));
+	});
+}
+//#endregion
 //#region src/index.ts
 const inject = ["skills"];
 async function apply(ctx, config = {}) {
@@ -1117,6 +2036,7 @@ async function apply(ctx, config = {}) {
 	await content.installDependencies(catalogFile, (name) => dependencies.resolve(`${name}/package.json`));
 	registerContentRoutes(ctx, content);
 	installWorkflowContext(ctx, config, content);
+	installNativeWorkflowTools(ctx, content);
 	ctx.skills.registerProvider((control) => {
 		let observed = content.getSource().revision;
 		const release = content.subscribe(() => {