@agimon-ai/doompi-workflow 0.0.1-alpha.97 → 0.0.1-alpha.99

package/dist/extensions/server.cjs

@@ -2,9 +2,10 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_workflowTerminal = require("../workflowTerminal-WM_cpxIO.cjs");
-const require_workflowLaunchCommand = require("../workflowLaunchCommand-7y8xg5YF.cjs");
+const require_workflowTerminal = require("../workflowTerminal-Bb4bLtLu.cjs");
+const require_workflowLaunchCommand = require("../workflowLaunchCommand-DJyDB96d.cjs");
 let _agimon_ai_doompi_core_extensionFile = require("@agimon-ai/doompi-core/extensionFile");
+let _agimon_ai_doompi_core_childProcess = require("@agimon-ai/doompi-core/childProcess");
 let node_fs = require("node:fs");
 node_fs = require_workflowTerminal.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -13,82 +14,15 @@ let _agimon_ai_workflow_mcp = require("@agimon-ai/workflow-mcp");
 let zod = require("zod");
 let node_crypto = require("node:crypto");
 let _agimon_ai_doompi_minor_mode = require("@agimon-ai/doompi-minor-mode");
+let _agimon_ai_doompi_telemetry = require("@agimon-ai/doompi-telemetry");
 let _agimon_ai_doompi_core_serverFacet = require("@agimon-ai/doompi-core/serverFacet");
-let node_os = require("node:os");
-node_os = require_workflowTerminal.__toESM(node_os, 1);
+let _agimon_ai_doompi_core_hubChannel = require("@agimon-ai/doompi-core/hubChannel");
 let node_stream = require("node:stream");
 let hono = require("hono");
 let hono_streaming = require("hono/streaming");
 let _agimon_ai_doompi_core_web = require("@agimon-ai/doompi-core/web");
-//#region src/services/webWorkflowCatalog/index.ts
-function unchanged(left, right) {
-	return left !== void 0 && right !== void 0 && left.size === right.size && left.modifiedAt === right.modifiedAt;
-}
-function createWorkflowCatalogReader(deps) {
-	const cache = /* @__PURE__ */ new Map();
-	const detailFor = (path) => {
-		const stamp = deps.stamp(path);
-		const cached = cache.get(path);
-		if (cached && unchanged(cached.stamp, stamp)) return cached.detail;
-		const detail = deps.summarize(path);
-		if (stamp !== void 0) cache.set(path, {
-			stamp,
-			detail
-		});
-		return detail;
-	};
-	return {
-		async read(directory) {
-			return (await deps.list(directory)).map((entry) => {
-				const detail = detailFor(entry.path);
-				return {
-					path: entry.path,
-					relativePath: entry.relativePath,
-					name: entry.name === "" ? entry.relativePath : entry.name,
-					description: entry.description,
-					tags: entry.tags,
-					triggers: detail.triggers,
-					inputs: detail.inputs,
-					jobs: detail.jobs,
-					artifacts: detail.artifacts,
-					...detail.runners === void 0 ? {} : { runners: detail.runners },
-					...detail.error === void 0 ? {} : { error: detail.error }
-				};
-			});
-		},
-		forget(keep) {
-			for (const path of cache.keys()) if (!keep.has(path)) cache.delete(path);
-		}
-	};
-}
-/** The launchable rows first, then the ones that would not parse, name ordered. */
-function presentWorkflowCatalog(entries) {
-	return [...entries].sort((left, right) => {
-		if (left.error === void 0 !== (right.error === void 0)) return left.error === void 0 ? -1 : 1;
-		return left.name.localeCompare(right.name);
-	});
-}
-//#endregion
-//#region src/services/workflowCatalogDeps/index.ts
-/** Connect the pure catalog projection service to the workflow engine and filesystem. */
-function defaultCatalogDeps() {
-	return {
-		list: (directory) => (0, _agimon_ai_workflow_mcp.readWorkflowCatalog)(directory),
-		summarize: (workflowPath) => (0, _agimon_ai_workflow_mcp.summarizeWorkflow)(workflowPath),
-		stamp: (workflowPath) => {
-			try {
-				const stats = (0, node_fs.statSync)(workflowPath);
-				return {
-					size: stats.size,
-					modifiedAt: stats.mtimeMs
-				};
-			} catch {
-				return;
-			}
-		}
-	};
-}
-//#endregion
+let node_os = require("node:os");
+node_os = require_workflowTerminal.__toESM(node_os, 1);
 //#region src/services/workflowRuns/index.ts
 /**
 * MIRRORS @agimon-ai/workflow-mcp's on-disk registry
@@ -164,8 +98,12 @@ function asOptionalString(value) {
 function asOptionalNumber(value) {
 	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
+/** Text without its terminal escape codes, as a log file or a reader wants it. */
+function withoutAnsi(text) {
+	return text.replace(ANSI_ESCAPE_PATTERN, "");
+}
 function stripAnsi(text) {
-	return text.replace(ANSI_ESCAPE_PATTERN, "").trim();
+	return withoutAnsi(text).trim();
 }
 /**
 * Validates one run.json into the wire shape plus scoping facts.
@@ -218,6 +156,18 @@ function parseWorkflowRunRecord(raw) {
 		...piSessionId === void 0 ? {} : { piSessionId }
 	};
 }
+function parseStepRef(value) {
+	if (!isRecord(value)) return void 0;
+	const kind = asOptionalString(value.kind);
+	const id = asOptionalString(value.id);
+	if (!kind || !id) return void 0;
+	const label = asOptionalString(value.label);
+	return {
+		kind,
+		id,
+		...label === void 0 ? {} : { label }
+	};
+}
 /**
 * Parses the append-only progress log. Malformed lines are skipped rather
 * than failing the file: a reader routinely catches a torn final line
@@ -245,6 +195,8 @@ function parseWorkflowProgress(raw) {
 		const index = asOptionalNumber(parsed.index);
 		const total = asOptionalNumber(parsed.total);
 		const reason = asOptionalString(parsed.reason);
+		const ref = parseStepRef(parsed.ref);
+		const group = asOptionalString(parsed.group);
 		events.push({
 			type,
 			status,
@@ -253,6 +205,8 @@ function parseWorkflowProgress(raw) {
 			...index === void 0 ? {} : { index },
 			...total === void 0 ? {} : { total },
 			...reason === void 0 ? {} : { reason },
+			...ref === void 0 ? {} : { ref },
+			...group === void 0 ? {} : { group },
 			at
 		});
 	}
@@ -300,9 +254,16 @@ function foldWorkflowProgress(events) {
 				status: event.status
 			};
 			job.steps.push(step);
+		} else if (event.status === "running" && step.status !== "running") {
+			delete step.ref;
+			delete step.reason;
+			delete step.endedAt;
+			delete step.startedAt;
 		}
 		step.status = event.status;
 		if (event.reason !== void 0) step.reason = event.reason;
+		if (event.ref !== void 0) step.ref = event.ref;
+		if (event.group !== void 0) step.group = event.group;
 		if (event.status === "running" && step.startedAt === void 0) step.startedAt = event.at;
 		if (STEP_TERMINAL_STATES.has(event.status)) step.endedAt = event.at;
 	}
@@ -403,490 +364,850 @@ function presentWorkflowRuns(runs, now) {
 	return [...groups.entries()].sort(([left], [right]) => STAGE_ORDER[left] - STAGE_ORDER[right]).flatMap(([, group]) => group.sort((left, right) => lastMovedAt(right) - lastMovedAt(left)).slice(0, 24));
 }
 //#endregion
-//#region src/services/workflowWatcher/index.ts
+//#region src/services/serverLaunch/index.ts
+/** Beside the run's own files, so the run's artifacts list and its deletion both include it. */
+const RUN_LOG_FILENAME = "engine.log";
+/** Exit codes a run ends with when nothing went wrong: finished, or skipped by its triggers. */
+const SUCCESS_EXIT_CODES = /* @__PURE__ */ new Set([0, 2]);
+/** Lines kept before a run has a directory to write them to. */
+const PENDING_LINE_LIMIT = 500;
+/** How long closing a session waits for its in-process runs to stop. */
+const STOP_TIMEOUT_MS = 1e4;
+const SESSION_CLOSED_REASON = "The session that runs this workflow closed.";
+const RUNNING_STAGE = "running";
+const LAUNCH_REQUESTED_EVENT = "doom_workflow.launch_requested";
+const RUN_STARTED_EVENT = "doom_workflow.run_started";
+const RUN_FINISHED_EVENT = "doom_workflow.run_finished";
+const RUN_FAILED_EVENT = "doom_workflow.run_failed";
+const ENGINE_ERROR_EVENT = "doom_workflow.engine_error";
+const ENGINE_WARNING_EVENT = "doom_workflow.engine_warning";
+const RUN_LOG_FAILED_EVENT = "doom_workflow.run_log_failed";
+const RUN_STOP_FAILED_EVENT = "doom_workflow.run_stop_failed";
+function delay$1(ms) {
+	return new Promise((settle) => {
+		setTimeout(settle, ms).unref?.();
+	});
+}
+function textResult$1(text, isError = false) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		...isError ? { isError: true } : {}
+	};
+}
 /**
-* Read the durable workflow registry once.
+* The engine's log for one run, where a reader can find it.
 *
-* The registry is an initial snapshot only. Live delivery belongs to the
-* session lifecycle and is routed through the host-owned direct event bus.
+* The engine writes why a step failed as a log line. Without a logger, those
+* lines exist only in the output the run returns at its end, so a run that is
+* still going, or one read later, has nothing to say about its failures. Here
+* every line goes to the run directory's `engine.log`, and errors and warnings
+* also go to telemetry, with the line as the exception so the text survives.
 */
-function readWorkflowRuns(options = {}) {
-	const environment = options.environment;
-	const homeDir = options.homeDir ?? resolveWorkflowHome({
-		envValue: environment?.["WORKFLOW_MCP_HOME"],
-		homeDir: node_os.default.homedir()
-	});
-	const workspacesDir = node_path.default.join(homeDir, WORKSPACES_DIR_NAME);
-	const recordCache = /* @__PURE__ */ new Map();
-	const progressCache = /* @__PURE__ */ new Map();
-	const cachedParse = (cache, filePath, parse, empty) => {
-		let stat;
-		try {
-			stat = node_fs.default.statSync(filePath);
-		} catch {
-			cache.delete(filePath);
-			return empty;
-		}
-		const cached = cache.get(filePath);
-		if (cached && cached.size === stat.size && cached.mtimeMs === stat.mtimeMs) return cached.value;
-		let raw;
-		try {
-			raw = node_fs.default.readFileSync(filePath, "utf8");
-		} catch {
-			cache.delete(filePath);
-			return empty;
+function createRunLog(telemetry) {
+	const pending = [];
+	let file;
+	let writing = Promise.resolve();
+	const reportLogFailure = (error) => telemetry?.recordWarning(RUN_LOG_FAILED_EVENT, error) ?? Promise.resolve();
+	const append = (line) => {
+		if (file === void 0) {
+			pending.push(line);
+			if (pending.length > PENDING_LINE_LIMIT) pending.shift();
+			return;
 		}
-		const value = parse(raw);
-		cache.set(filePath, {
-			size: stat.size,
-			mtimeMs: stat.mtimeMs,
-			value
-		});
-		return value;
+		const target = file;
+		writing = writing.then(() => node_fs.default.promises.appendFile(target, `${line}\n`, "utf8")).catch(reportLogFailure);
 	};
-	const listDir = (directory) => {
-		try {
-			return node_fs.default.readdirSync(directory).sort();
-		} catch {
-			return [];
-		}
+	return {
+		logger: {
+			info: (message) => append(withoutAnsi(message)),
+			warn: (message) => {
+				const line = withoutAnsi(message);
+				append(line);
+				telemetry?.recordWarning(ENGINE_WARNING_EVENT, new Error(line.trim()));
+			},
+			error: (message) => {
+				const line = withoutAnsi(message);
+				append(line);
+				telemetry?.recordError(ENGINE_ERROR_EVENT, new Error(line.trim()), {}, { includeException: true });
+			}
+		},
+		attach(target) {
+			file = target;
+			const held = pending.splice(0);
+			if (held.length === 0) return;
+			writing = writing.then(() => node_fs.default.promises.appendFile(target, held.map((line) => `${line}\n`).join(""), "utf8")).catch(reportLogFailure);
+		},
+		flushed: () => writing
 	};
-	const runs = [];
-	for (const workspace of listDir(workspacesDir)) for (const stage of WORKFLOW_STAGES) {
-		const stageDir = node_path.default.join(workspacesDir, workspace, stage);
-		for (const runKey of listDir(stageDir)) {
-			const runDir = node_path.default.join(stageDir, runKey);
-			const recordPath = node_path.default.join(runDir, RUN_RECORD_FILE_NAME);
-			const progressPath = node_path.default.join(runDir, PROGRESS_FILE_NAME);
-			const parsed = cachedParse(recordCache, recordPath, parseWorkflowRunRecord, void 0);
-			if (parsed === void 0) continue;
-			const jobs = cachedParse(progressCache, progressPath, (raw) => foldWorkflowProgress(parseWorkflowProgress(raw)), []);
-			runs.push({
-				...parsed,
-				view: completeWorkflowRunView(parsed.view, jobs)
-			});
+}
+/**
+* Runs workflows inside the DoomPi server for one session.
+*
+* It is the same launch the Pi extension runs, through the same executor:
+* the same Agiflow checks, capacity limit and runner check, and the same
+* answer once the run registers. What the server adds is where the run
+* happens, in this process with the host's step executor, and what it keeps:
+* each run's engine log, telemetry for its start and end, a notice when a run
+* fails after its launch already answered, and a stop for every run still
+* going when the session closes.
+*/
+function createServerLauncher(dependencies) {
+	const { feature, telemetry } = dependencies;
+	const active = /* @__PURE__ */ new Map();
+	const runInProcess = async (input) => {
+		const launchId = input.env?.[require_workflowTerminal.WORKFLOW_LAUNCH_ID_ENV];
+		if (launchId === void 0) throw new Error("An in-process launch needs its launch id.");
+		const log = createRunLog(telemetry);
+		const run = { settled: Promise.resolve() };
+		active.set(launchId, run);
+		const runner = input.runner ?? input.cliAgent;
+		const execution = (async () => {
+			try {
+				const result = await feature.createRunService({ logger: log.logger }).run({
+					...input,
+					...runner === void 0 ? {} : { runner },
+					skipLaunch: true,
+					onRegistered: (registration) => {
+						run.registration = registration;
+						log.attach(node_path.default.join(registration.runDir, RUN_LOG_FILENAME));
+						telemetry?.recordEvent(RUN_STARTED_EVENT, { outcome: "started" });
+						dependencies.onRunsChanged?.();
+					}
+				});
+				if (SUCCESS_EXIT_CODES.has(result.exitCode)) {
+					telemetry?.recordEvent(RUN_FINISHED_EVENT, {
+						outcome: "success",
+						exit_code: result.exitCode
+					});
+					return textResult$1(withoutAnsi(result.output) || "Workflow completed.");
+				}
+				const tail = withoutAnsi(result.output).trim().split("\n").slice(-20).join("\n");
+				telemetry?.recordError(RUN_FAILED_EVENT, new Error(tail || `The workflow exited with code ${String(result.exitCode)}.`), { exit_code: result.exitCode }, { includeException: true });
+				return textResult$1(`Workflow failed (exit code ${String(result.exitCode)}):\n\n${withoutAnsi(result.output)}`, true);
+			} catch (error) {
+				telemetry?.recordError(RUN_FAILED_EVENT, error, { outcome: "error" }, { includeException: true });
+				throw error;
+			} finally {
+				await log.flushed();
+				active.delete(launchId);
+				dependencies.onRunsChanged?.();
+			}
+		})();
+		run.settled = execution.then(() => void 0, () => void 0);
+		return execution;
+	};
+	const executor = require_workflowTerminal.createWorkflowLaunchExecutor({
+		environment: dependencies.environment,
+		activeRunCount: async () => active.size,
+		...dependencies.rejectRunner === void 0 ? {} : { rejectRunner: dependencies.rejectRunner },
+		runTool: { execute: runInProcess },
+		trackPendingRun: (pending) => pending,
+		findLaunchedRun: async ({ launchId }) => {
+			const registration = active.get(launchId)?.registration;
+			if (registration === void 0) return void 0;
+			return feature.registry.readRunByKey(registration.workspace, RUNNING_STAGE, registration.runKey);
+		},
+		onLateFailure: (error) => {
+			const detail = error instanceof Error ? error.message : String(error);
+			dependencies.notify(`Workflow launch failed after it was reported started.\n${detail}`, "warning");
+		},
+		onLaunch: () => {
+			telemetry?.recordEvent(LAUNCH_REQUESTED_EVENT, { outcome: "requested" });
+			dependencies.onRunsChanged?.();
+		},
+		...dependencies.launchAckPollMs === void 0 ? {} : { launchAckPollMs: dependencies.launchAckPollMs },
+		...dependencies.launchAckTimeoutMs === void 0 ? {} : { launchAckTimeoutMs: dependencies.launchAckTimeoutMs }
+	});
+	const context = { sessionManager: { getSessionId: () => dependencies.sessionId } };
+	return {
+		launch: (input) => executor.execute(input, context),
+		activeRunCount: () => active.size,
+		async dispose() {
+			const runs = [...active.values()];
+			if (runs.length === 0) return;
+			await Promise.all(runs.map(async ({ registration }) => {
+				if (registration === void 0) return;
+				try {
+					await feature.registry.requestStop(registration.workspace, registration.runKey, SESSION_CLOSED_REASON, registration.runId);
+				} catch (error) {
+					await telemetry?.recordWarning(RUN_STOP_FAILED_EVENT, error);
+				}
+			}));
+			await Promise.race([Promise.all(runs.map((run) => run.settled)), delay$1(dependencies.stopTimeoutMs ?? STOP_TIMEOUT_MS)]);
 		}
-	}
-	return runs;
+	};
 }
 //#endregion
+//#region src/schemas/runConfig.ts
+/** A YAML list, or one comma-separated string, as `--domains a,b` accepts. */
+const nameList = zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).transform((value) => (Array.isArray(value) ? value : value.split(",")).map((name) => name.trim()).filter((name) => name.length > 0));
+const singleName = zod.z.string().trim().min(1);
+/**
+* The DoomPi keys of a workflow step's `runConfig`.
+*
+* The engine treats `runConfig` as an opaque map, so this is where a typo such
+* as `majormode` is caught instead of silently running on workspace defaults.
+*/
+const doompiRunConfigSchema = zod.z.object({
+	majorMode: singleName.optional().describe("Major mode the step session runs in."),
+	minorModes: nameList.optional().describe("Minor modes activated in the step session."),
+	profile: singleName.optional().describe("Profile the step session runs as."),
+	domains: nameList.optional().describe("Domains selected for the step session. An empty list selects none."),
+	model: singleName.optional().describe("Model selector, provider/id."),
+	thinking: singleName.optional().describe("Thinking level for the model.")
+}).strict();
+/**
+* The same keys for a templated step, whose `runConfig` is also the data its
+* command template reads: keys DoomPi does not use are left to the template.
+*/
+const doompiTemplateRunConfigSchema = doompiRunConfigSchema.strip();
+/** The runConfig keys DoomPi reads itself, the host keys `workflow-mcp doctor` checks steps against. */
+const DOOMPI_RUN_CONFIG_KEYS = doompiRunConfigSchema.keyof().options;
+//#endregion
 //#region src/types/webWorkflows.ts
+/** A customRun step ran as this child session. */
+const STEP_SESSION_REF_KIND = "session";
+/** A command step ran in this terminal pane. */
+const STEP_PANE_REF_KIND = "pane";
 const WORKFLOW_RUNS_TYPE = "workflow_runs";
 const WORKFLOW_CATALOG_TYPE = "workflow_catalog";
 //#endregion
-//#region src/services/serverRuntime/index.ts
-const SOURCE = "@agimon-ai/doompi-workflow";
-const WORKFLOW_MODE_ID = "workflow";
-const LIST_TOOL = "list_workflows";
-const LAUNCH_TOOL = "launch_workflow";
-const RUN_TOOL = "workflow_run";
-function callResult(value) {
-	const content = [];
-	if (typeof value === "object" && value !== null && "content" in value && Array.isArray(value.content)) for (const item of value.content) {
-		if (typeof item !== "object" || item === null || !("type" in item)) continue;
-		const record = item;
-		if (record.type === "text" && typeof record.text === "string") content.push({
-			type: "text",
-			text: record.text
-		});
-		else if (record.type === "image" && typeof record.data === "string" && typeof record.mimeType === "string") content.push({
-			type: "image",
-			data: record.data,
-			mimeType: record.mimeType
-		});
+//#region src/services/stepExecutor/index.ts
+const STEP_DISPLAY_ENV = "WORKFLOW_STEP_DISPLAY";
+const WORKFLOW_NAME_ENV = "WORKFLOW_NAME";
+/** The engine's completion signal for terminal agents; a session this host steers never uses it. */
+const WORKFLOW_STATUS_FILE_ENV = "WORKFLOW_STATUS_FILE";
+/** How long a busy step session is left to finish a turn it was given elsewhere, such as web guidance. */
+const BUSY_RETRY_MS = 2e3;
+/** How long ending a step's session may take before the step stops waiting for it. */
+const RELEASE_TIMEOUT_MS = 1e4;
+/** What the runtime says when a turn is already running; the reminder then waits for it. */
+const BUSY_SESSION_PATTERN = /\bbusy\b|LaneBusy/i;
+const STEP_SESSION_STARTED_EVENT = "doom_workflow.step_session_started";
+const STEP_SESSION_FAILED_EVENT = "doom_workflow.step_session_failed";
+const STEP_REMINDER_EVENT = "doom_workflow.step_reminder";
+const STEP_SESSION_RELEASE_FAILED_EVENT = "doom_workflow.step_session_release_failed";
+const STEP_PANE_FAILED_EVENT = "doom_workflow.step_pane_failed";
+const DOOMPI_KEYS = new Set(DOOMPI_RUN_CONFIG_KEYS);
+/**
+* A step's `runConfig`, validated against the keys DoomPi understands.
+*
+* A templated step's may also carry keys its command template reads. A key
+* that is neither, such as `majormode`, fails the step rather than running it
+* on workspace defaults. An engine that does not say what its template reads
+* leaves such keys unchecked.
+*/
+function readDoompiRunConfig(runConfig, template) {
+	const parsed = (template === void 0 ? doompiRunConfigSchema : doompiTemplateRunConfigSchema).safeParse(runConfig ?? {});
+	if (!parsed.success) {
+		const problems = parsed.error.issues.map((issue) => `${issue.path.join(".") || "runConfig"}: ${issue.message}`);
+		throw new Error(`Invalid runConfig: ${problems.join("; ")}`);
 	}
-	if (content.length === 0) content.push({
-		type: "text",
-		text: JSON.stringify(value, null, 2)
+	if (template?.reads !== void 0 && typeof runConfig === "object" && runConfig !== null) {
+		const reads = new Set(template.reads);
+		const unknown = Object.keys(runConfig).filter((key) => !DOOMPI_KEYS.has(key) && !reads.has(key));
+		if (unknown.length > 0) throw new Error(`Invalid runConfig: ${unknown.join(", ")} is neither a DoomPi setting nor read by the "${template.name}" command.`);
+	}
+	return parsed.data;
+}
+/** The selection a step session is pinned to; unset keys keep the workspace defaults. */
+function sessionSelection(config) {
+	return {
+		...config.majorMode === void 0 ? {} : { majorMode: config.majorMode },
+		...config.minorModes === void 0 ? {} : { minorModes: config.minorModes },
+		...config.profile === void 0 ? {} : { profile: config.profile },
+		...config.domains === void 0 ? {} : { domains: config.domains }
+	};
+}
+/**
+* What a step adds to the host environment.
+*
+* The step environment is the whole process environment plus the run's own
+* keys. Handing all of it to the session would pin a copy of the host's
+* variables into it; the difference is the part the agent actually needs, such
+* as WORKFLOW_RUN_DIR for the artifacts its prompt names.
+*/
+function stepEnvironment(env, host) {
+	return Object.fromEntries(Object.entries(env).filter(([key, value]) => host[key] !== value));
+}
+function stepSessionName(env, stepName) {
+	const display = env[STEP_DISPLAY_ENV] ?? stepName;
+	const workflow = env[WORKFLOW_NAME_ENV];
+	return workflow ? `${workflow}: ${display}` : display;
+}
+function asError(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+function delay(ms) {
+	return new Promise((settle) => {
+		setTimeout(settle, ms).unref?.();
 	});
+}
+/** A promise settled by `settle`, so a stop can end a wait that nothing else would. */
+function signal() {
+	let settle = () => void 0;
 	return {
-		content,
-		details: value,
-		...typeof value === "object" && value !== null && "isError" in value && value.isError === true ? { isError: true } : {}
+		promise: new Promise((resolve) => {
+			settle = resolve;
+		}),
+		settle
 	};
 }
-function createWorkflowServerRuntime(host, serverHost) {
-	if (serverHost.context.directEvents === void 0) throw new Error("Workflow headless facet requires the session direct event bus.");
-	const directEvents = serverHost.context.directEvents;
-	let runProvider;
-	const catalogReader = createWorkflowCatalogReader(defaultCatalogDeps());
-	const publishLifecycle = async (executionContext) => {
-		const records = readWorkflowRuns({ environment: executionContext.environment }).filter((run) => runBelongsToSession(run, executionContext.sessionId));
-		const activeItems = records.filter((run) => run.view.stage === "running" && run.view.stale !== true).map((run) => ({
-			id: `${run.view.workspace}/${run.view.runKey}`,
-			sessionId: executionContext.sessionId
-		}));
-		runProvider?.update(activeItems);
-		const runs = presentWorkflowRuns(records.map((run) => run.view), Date.now());
-		directEvents.publish(WORKFLOW_RUNS_TYPE, executionContext.sessionId, { runs });
+/**
+* An execution that already failed, with why.
+*
+* Returned instead of throwing: the engine reports a thrown start as a spawn
+* error about shells and permissions, while a failed completion keeps this
+* message as the step's reason.
+*/
+function failedExecution(error) {
+	return {
+		completion: Promise.resolve({ error: asError(error) }),
+		stop: async () => void 0
+	};
+}
+/**
+* Runs workflow steps inside DoomPi instead of a shell.
+*
+* A customRun step becomes a child session of the launching session, with the
+* step's major mode, minor modes, profile, domains and model, so its messages
+* stream like any other conversation. Command steps go to their own terminal
+* pane when a launcher is available and fall back to the engine's spawn when
+* it is not.
+*/
+function createStepExecutor(dependencies) {
+	const { sessionService, launchPane, telemetry } = dependencies;
+	const prompt = sessionService.prompt?.bind(sessionService);
+	/**
+	* Run a step as a child session of the launching session, with the step's
+	* major mode, minor modes, profile, domains and model.
+	*
+	* The session keeps going until the step has what the workflow needs: each
+	* time the agent settles, the engine's decision gate is asked, and while
+	* the step still lacks a decision (or its declared artifacts) the session is
+	* prompted with the gate's reminder. The gate counts reminders against its
+	* cap, so a stuck agent ends and the engine fails the step.
+	*/
+	async function runSession(request) {
+		if (prompt === void 0) return failedExecution("This host cannot prompt sessions, so this step cannot run here.");
+		const attributes = {
+			"workflow.step.name": request.stepName,
+			templated: request.template !== void 0
+		};
+		let scope;
+		let name;
 		try {
-			directEvents.publish(WORKFLOW_CATALOG_TYPE, executionContext.sessionId, {
-				cwd: executionContext.cwd,
-				workflows: presentWorkflowCatalog(await catalogReader.read(executionContext.cwd))
+			const config = readDoompiRunConfig(request.runConfig, request.template);
+			name = stepSessionName(request.env, request.stepName);
+			const environment = stepEnvironment(request.env, dependencies.hostEnvironment);
+			delete environment[WORKFLOW_STATUS_FILE_ENV];
+			environment[_agimon_ai_workflow_mcp.WORKFLOW_DECISION_STEERING_ENV] = _agimon_ai_workflow_mcp.WORKFLOW_DECISION_STEERING_HOST;
+			scope = await sessionService.create({
+				cwd: request.cwd,
+				name,
+				parentSessionId: dependencies.parentSessionId,
+				sessionProvenance: _agimon_ai_doompi_core_hubChannel.WORKFLOW_STEP_SESSION_PROVENANCE,
+				selection: sessionSelection(config),
+				...config.model === void 0 ? {} : { model: config.model },
+				...config.thinking === void 0 ? {} : { thinking: config.thinking },
+				...request.systemPrompt === void 0 ? {} : { appendSystemPrompt: request.systemPrompt },
+				environment
 			});
 		} catch (error) {
-			const warning = error instanceof Error ? error.message : String(error);
-			directEvents.publish(WORKFLOW_CATALOG_TYPE, executionContext.sessionId, {
-				cwd: executionContext.cwd,
-				workflows: [],
-				warning
-			});
-		}
-		return activeItems.length > 0;
-	};
-	const feature = (0, _agimon_ai_workflow_mcp.createEmbeddedWorkflowFeature)();
-	const launch = (parameters) => feature.runTool.execute({
-		...parameters,
-		env: {
-			...parameters.env,
-			[PI_SESSION_ENV]: host.context.sessionId
+			telemetry?.recordError(STEP_SESSION_FAILED_EVENT, error, attributes, { includeException: true });
+			return failedExecution(error);
+		}
+		telemetry?.recordEvent(STEP_SESSION_STARTED_EVENT, {
+			...attributes,
+			outcome: "started"
+		});
+		const sessionId = scope.sessionId;
+		const stopped = signal();
+		let stopRequested = false;
+		const decided = () => {
+			const path = request.env[_agimon_ai_workflow_mcp.WORKFLOW_DECISION_FILE_ENV];
+			return path !== void 0 && (0, _agimon_ai_workflow_mcp.readStepDecision)(path) !== void 0;
+		};
+		/**
+		* Give the agent the gate's reminder. A session busy with a turn it was
+		* given elsewhere, like web guidance, is left to finish it, then reminded
+		* unless it decided meanwhile. Undefined means the step needs no more turns.
+		*/
+		const remind = async (message) => {
+			for (;;) try {
+				return await prompt(sessionId, message);
+			} catch (error) {
+				if (!BUSY_SESSION_PATTERN.test(asError(error).message)) throw error;
+				telemetry?.recordEvent(STEP_REMINDER_EVENT, {
+					...attributes,
+					outcome: "busy"
+				});
+				await Promise.race([delay(dependencies.busyRetryMs ?? BUSY_RETRY_MS), stopped.promise]);
+				if (stopRequested || decided()) return void 0;
+			}
+		};
+		/**
+		* End the session once the step is over. Released, it stays readable in the
+		* workflow's view without holding a model, tools and extensions in the host.
+		* A host that cannot release it is asked to abort a stopped turn instead.
+		*/
+		const endSession = async () => {
+			const ending = sessionService.release ? sessionService.release(sessionId) : stopRequested ? sessionService.abort?.(sessionId) ?? Promise.resolve() : Promise.resolve();
+			const timeout = delay(dependencies.releaseTimeoutMs ?? RELEASE_TIMEOUT_MS).then(() => {
+				throw new Error(`The step session did not end within ${String(dependencies.releaseTimeoutMs ?? RELEASE_TIMEOUT_MS)}ms.`);
+			});
+			try {
+				await Promise.race([ending, timeout]);
+			} catch (error) {
+				telemetry?.recordWarning(STEP_SESSION_RELEASE_FAILED_EVENT, error, attributes);
+			}
+		};
+		const completion = async () => {
+			let receipt = await prompt(sessionId, request.prompt);
+			while (receipt !== void 0) {
+				await Promise.race([receipt.settled, stopped.promise]);
+				if (stopRequested) return { exitCode: 0 };
+				const gate = await (0, _agimon_ai_workflow_mcp.gateStepDecision)(request.env);
+				if (gate.action === "allow") return { exitCode: 0 };
+				telemetry?.recordEvent(STEP_REMINDER_EVENT, {
+					...attributes,
+					outcome: "sent"
+				});
+				receipt = await remind(gate.message);
+			}
+			return { exitCode: 0 };
+		};
+		return {
+			ref: {
+				kind: STEP_SESSION_REF_KIND,
+				id: sessionId,
+				label: name
+			},
+			completion: completion().catch((error) => ({ error: asError(error) })).then(async (outcome) => {
+				await endSession();
+				return outcome;
+			}),
+			stop: async () => {
+				stopRequested = true;
+				stopped.settle();
+			}
+		};
+	}
+	return {
+		async custom(request) {
+			return runSession({
+				cwd: request.cwd,
+				env: request.env,
+				stepName: request.stepName,
+				runConfig: request.runConfig,
+				prompt: request.customRun.prompt,
+				...request.customRun.systemPrompt === void 0 ? {} : { systemPrompt: request.customRun.systemPrompt }
+			});
+		},
+		async command(request) {
+			const template = request.template;
+			if (template?.inProcess && prompt !== void 0) return runSession({
+				cwd: request.cwd,
+				env: request.env,
+				stepName: request.stepName,
+				runConfig: request.runConfig,
+				template: {
+					name: template.name,
+					...template.reads === void 0 ? {} : { reads: template.reads }
+				},
+				prompt: template.prompt,
+				...template.systemPrompt === void 0 ? {} : { systemPrompt: template.systemPrompt }
+			});
+			if (launchPane === void 0) return void 0;
+			let pane;
+			try {
+				pane = await launchPane({
+					id: dependencies.createId(),
+					command: request.command,
+					cwd: request.cwd,
+					env: request.env
+				});
+			} catch (error) {
+				telemetry?.recordError(STEP_PANE_FAILED_EVENT, error, { "workflow.step.name": request.stepName }, { includeException: true });
+				return failedExecution(error);
+			}
+			if (pane === void 0) return void 0;
+			return {
+				ref: {
+					kind: STEP_PANE_REF_KIND,
+					id: pane.target,
+					label: request.stepName
+				},
+				completion: pane.completion.then((result) => result, (error) => ({ error: asError(error) })),
+				stop: async () => {
+					await pane.stop();
+				}
+			};
 		}
-	});
-	let control;
-	let controlDisposers = [];
-	const disposeControl = () => {
-		for (const dispose of controlDisposers.splice(0)) dispose();
-		control?.dispose();
-		control = void 0;
 	};
-	let modeOwner;
-	const modeSelected = () => (host.context.selection.state?.["minor-mode"] ?? []).includes(WORKFLOW_MODE_ID);
-	const modeState = () => {
-		const active = modeSelected();
+}
+/** The shell a command step runs in, the same one the engine spawns it with. */
+const STEP_SHELL = "/bin/zsh";
+/** Namespace for step pane sockets, apart from whole-run terminal sockets. */
+const STEP_PANE_SOCKET_SCOPE = "doompi-workflow-steps";
+const PANE_LOG_SUFFIX = ".log";
+const PANE_CAPTURE_COLUMNS = 120;
+const PANE_CAPTURE_ROWS = 40;
+/** Where a finished step pane's last screen is kept: beside the socket that served it. */
+function stepPaneLogPath(socketPath) {
+	return `${socketPath}${PANE_LOG_SUFFIX}`;
+}
+/** The pane's current screen, or undefined once there is no pane left to read. */
+async function lastScreen(service, key) {
+	try {
+		const viewer = await service.attach(key, PANE_CAPTURE_COLUMNS, PANE_CAPTURE_ROWS);
+		const lines = await viewer.snapshot();
+		viewer.detach();
+		return `${lines.join("\n")}\n`;
+	} catch {
+		return;
+	}
+}
+/**
+* Opens each command step in its own RMUX pane, through workflow-mcp's terminal host.
+*
+* The pane gets the step's whole environment, which is what lets an agent's
+* Stop hook end an interactive step through WORKFLOW_STATUS_FILE. A unix
+* socket serves the pane to the run terminal in any scope; the socket path is
+* the pane's target. When the step ends or is stopped, its last screen is kept
+* beside the socket and the pane is released, whatever fails on the way.
+*/
+function createNativeStepPaneLauncher(service = new _agimon_ai_workflow_mcp.NativeTerminalService(), telemetry) {
+	const report = (stage) => (error) => telemetry?.recordWarning(STEP_PANE_FAILED_EVENT, error, { stage }) ?? Promise.resolve();
+	return async (request) => {
+		if (!await service.available()) return void 0;
+		await service.spawn({
+			command: STEP_SHELL,
+			args: ["-c", request.command],
+			cwd: request.cwd,
+			env: { ...request.env },
+			runKey: request.id
+		});
+		const target = (0, _agimon_ai_workflow_mcp.terminalSocketPath)(STEP_PANE_SOCKET_SCOPE, request.id);
+		let server;
+		try {
+			server = await (0, _agimon_ai_workflow_mcp.serveNativeTerminal)({
+				service,
+				runKey: request.id,
+				socketPath: target
+			});
+		} catch (error) {
+			await service.kill(request.id).catch(report("kill"));
+			throw error;
+		}
+		let finishing;
+		const finish = () => finishing ??= (async () => {
+			let screen;
+			try {
+				screen = await lastScreen(service, request.id);
+				if (screen !== void 0) await node_fs.default.promises.writeFile(stepPaneLogPath(target), screen, "utf8");
+			} catch (error) {
+				await report("keep-screen")(error);
+			} finally {
+				await server.close().catch(report("close-socket"));
+				await service.kill(request.id).catch(report("kill"));
+			}
+			return screen;
+		})();
 		return {
-			activation: active ? "active" : "inactive",
-			condition: "ready",
-			...active ? { detail: "workflow tools available" } : {},
-			actions: [{
-				id: "activate",
-				enabled: !active,
-				...!active ? {} : { disabledReason: "Workflow mode is active." }
-			}, {
-				id: "deactivate",
-				enabled: active,
-				...active ? {} : { disabledReason: "Workflow mode is inactive." }
-			}]
+			target,
+			completion: service.ended(request.id).then(async (exitCode) => {
+				const screen = (await finish())?.trimEnd();
+				return screen ? {
+					exitCode,
+					outputTail: screen
+				} : { exitCode };
+			}),
+			stop: async () => {
+				await finish();
+				return true;
+			}
 		};
 	};
-	const selectMode = async (enabled) => {
-		const modes = (host.context.selection.state?.["minor-mode"] ?? []).filter((mode) => mode !== WORKFLOW_MODE_ID);
-		await host.changeSelection({
-			axis: "state",
-			key: "minor-mode",
-			values: enabled ? [...modes, WORKFLOW_MODE_ID] : modes
+}
+//#endregion
+//#region src/services/webWorkflowCatalog/index.ts
+function unchanged(left, right) {
+	return left !== void 0 && right !== void 0 && left.size === right.size && left.modifiedAt === right.modifiedAt;
+}
+function createWorkflowCatalogReader(deps) {
+	const cache = /* @__PURE__ */ new Map();
+	const detailFor = (path) => {
+		const stamp = deps.stamp(path);
+		const cached = cache.get(path);
+		if (cached && unchanged(cached.stamp, stamp)) return cached.detail;
+		const detail = deps.summarize(path);
+		if (stamp !== void 0) cache.set(path, {
+			stamp,
+			detail
 		});
-		modeOwner?.publish();
+		return detail;
 	};
-	modeOwner = (0, _agimon_ai_doompi_minor_mode.defineMinorMode)({
-		descriptor: {
-			source: SOURCE,
-			id: WORKFLOW_MODE_ID,
-			label: "Workflow",
-			description: "Workflow discovery, launch, inspection, control, and recovery tools.",
-			order: 20,
-			actions: [{
-				id: "activate",
-				label: "Activate",
-				description: "Enable workflow tools for this session.",
-				contexts: ["headless"],
-				parameters: []
-			}, {
-				id: "deactivate",
-				label: "Deactivate",
-				description: "Disable workflow tools without stopping active runs.",
-				contexts: ["headless"],
-				parameters: []
-			}]
+	return {
+		async read(directory) {
+			return (await deps.list(directory)).map((entry) => {
+				const detail = detailFor(entry.path);
+				return {
+					path: entry.path,
+					relativePath: entry.relativePath,
+					name: entry.name === "" ? entry.relativePath : entry.name,
+					description: entry.description,
+					tags: entry.tags,
+					triggers: detail.triggers,
+					inputs: detail.inputs,
+					jobs: detail.jobs,
+					artifacts: detail.artifacts,
+					...detail.runners === void 0 ? {} : { runners: detail.runners },
+					...detail.commands === void 0 ? {} : { commands: detail.commands },
+					...detail.choices === void 0 ? {} : { choices: detail.choices },
+					...detail.error === void 0 ? {} : { error: detail.error }
+				};
+			});
 		},
-		state: modeState,
-		async handleAction(_runtime, actionId, _argumentsValue, execution) {
-			execution.signal.throwIfAborted();
-			if (actionId === "activate") {
-				await selectMode(true);
-				return { message: "Workflow mode activated." };
-			}
-			if (actionId === "deactivate") {
-				await selectMode(false);
-				return { message: "Workflow mode deactivated." };
+		forget(keep) {
+			for (const path of cache.keys()) if (!keep.has(path)) cache.delete(path);
+		}
+	};
+}
+/** The launchable rows first, then the ones that would not parse, name ordered. */
+function presentWorkflowCatalog(entries) {
+	return [...entries].sort((left, right) => {
+		if (left.error === void 0 !== (right.error === void 0)) return left.error === void 0 ? -1 : 1;
+		return left.name.localeCompare(right.name);
+	});
+}
+//#endregion
+//#region src/services/workflowCatalogDeps/index.ts
+/**
+* Connect the pure catalog projection service to the workflow engine and filesystem.
+*
+* A workflow that parses can still be one DoomPi would fail mid-run, such as
+* a step whose runConfig misspells `majorMode`. The engine's doctor, told the
+* keys DoomPi reads, finds those; its errors mark the workflow as one that
+* cannot launch, in the catalog and at every launch, rather than at the step.
+*/
+function defaultCatalogDeps() {
+	return {
+		list: (directory) => (0, _agimon_ai_workflow_mcp.readWorkflowCatalog)(directory),
+		summarize: (workflowPath) => {
+			const detail = (0, _agimon_ai_workflow_mcp.summarizeWorkflow)(workflowPath);
+			if (detail.error !== void 0) return detail;
+			const errors = (0, _agimon_ai_workflow_mcp.diagnoseWorkflow)(workflowPath, { runConfigKeys: DOOMPI_RUN_CONFIG_KEYS }).diagnostics.filter((diagnostic) => diagnostic.level === "error");
+			if (errors.length === 0) return detail;
+			return {
+				...detail,
+				error: errors.map((diagnostic) => diagnostic.location === void 0 ? diagnostic.message : `${diagnostic.location}: ${diagnostic.message}`).join("\n")
+			};
+		},
+		stamp: (workflowPath) => {
+			try {
+				const stats = (0, node_fs.statSync)(workflowPath);
+				return {
+					size: stats.size,
+					modifiedAt: stats.mtimeMs
+				};
+			} catch {
+				return;
 			}
-			throw new Error(`Unknown workflow mode action: ${actionId}`);
 		}
-	}).createOwner(void 0);
+	};
+}
+//#endregion
+//#region src/services/stepPaneTerminal/index.ts
+const PROGRESS_FILENAME = "progress.ndjson";
+const NATIVE_LAUNCHER = "native";
+/** Runs whose folded refs are kept between reads; a screen stream reads its run twice a second. */
+const REFS_CACHE_LIMIT = 256;
+const PANE_CAPABILITIES = {
+	readable: true,
+	writable: true,
+	resizable: false
+};
+const PANE_LOG_CAPABILITIES = {
+	readable: true,
+	writable: false,
+	resizable: false,
+	reason: "That step has finished; this is the output it left."
+};
+const SESSION_STEP_REASON = "This step runs as an agent session; its conversation appears here as soon as the session starts.";
+const PANE_GONE_LINE = "The step pane has closed.";
+/**
+* The steps a run is on and its latest pane, folded from its progress log.
+*
+* Later events win, as in the engine's own summary. Steps of a parallel group
+* run at once, so every running step is kept, and the current one is the
+* latest-started step still running. A step that starts again is a new
+* attempt: its previous session or pane is not this attempt's, so the ref is
+* dropped until the new one is recorded. The latest pane is kept after it
+* finishes so a run between steps, or one that has ended, can still show what
+* its last command printed.
+*/
+function stepRefsFrom(events) {
+	const steps = /* @__PURE__ */ new Map();
+	const known = /* @__PURE__ */ new Map();
+	let lastPane;
+	for (const event of events) {
+		if (event.type !== "step" || event.step === void 0) continue;
+		const key = `${event.job}\u0000${event.step}`;
+		const previous = steps.get(key);
+		const running = event.status === "running";
+		const restarted = running && previous?.running !== true;
+		if (restarted) steps.delete(key);
+		const ref = event.ref ?? (restarted ? void 0 : previous?.ref);
+		steps.set(key, {
+			running,
+			...ref === void 0 ? {} : { ref }
+		});
+		if (event.ref !== void 0) known.set(event.ref.id, event.ref);
+		if (event.ref?.kind === "pane") lastPane = event.ref;
+	}
+	const running = [...steps.values()].filter((step) => step.running && step.ref !== void 0).map((step) => step.ref);
+	const current = running.at(-1);
 	return {
-		services: [(0, _agimon_ai_doompi_minor_mode.serverMinorModes)([modeOwner]), (context) => {
-			const provider = require_workflowTerminal.registerRunProvider(context);
-			runProvider = provider;
-			return () => {
-				provider.dispose();
-				if (runProvider === provider) runProvider = void 0;
+		...current === void 0 ? {} : { current },
+		...running.length === 0 ? {} : { running },
+		...lastPane === void 0 ? {} : { lastPane },
+		...known.size === 0 ? {} : { known: [...known.values()] }
+	};
+}
+/**
+* Reads a run's refs, folding its progress log again only when the log changed.
+*
+* Every screen, keystroke and capability check asks for them, and the log grows
+* with every fix loop, so an unchanged file (same size and modification time)
+* answers from the last fold.
+*/
+function createStepRefsReader() {
+	const cache = /* @__PURE__ */ new Map();
+	return (file) => {
+		let stats;
+		try {
+			stats = node_fs.default.statSync(file);
+		} catch {
+			return {};
+		}
+		const cached = cache.get(file);
+		if (cached !== void 0 && cached.size === stats.size && cached.mtimeMs === stats.mtimeMs) return cached.refs;
+		let raw;
+		try {
+			raw = node_fs.default.readFileSync(file, "utf8");
+		} catch {
+			return {};
+		}
+		const refs = stepRefsFrom(parseWorkflowProgress(raw));
+		cache.delete(file);
+		cache.set(file, {
+			size: stats.size,
+			mtimeMs: stats.mtimeMs,
+			refs
+		});
+		if (cache.size > REFS_CACHE_LIMIT) cache.delete(cache.keys().next().value);
+		return refs;
+	};
+}
+/**
+* Real dependencies: the registry's run directory, and the step executor's pane sockets.
+*
+* A pane is reached through the socket its step was served on, so any scope
+* of the server can read it, and a finished one through the screen kept
+* beside that socket.
+*/
+function createStepPaneTerminalDependencies(registry) {
+	const native = (0, _agimon_ai_workflow_mcp.connectNativeTerminal)();
+	const readRefs = createStepRefsReader();
+	return {
+		stepRefs: (record) => readRefs(node_path.default.join(registry.runDirectoryFor(record), PROGRESS_FILENAME)),
+		paneClient: () => ({
+			capture: (target) => native.snapshot(target, {}).then((lines) => lines.join("\n"), () => void 0),
+			input: (target, text) => native.write(target, text).then(() => true, () => false)
+		}),
+		paneLog: (_record, pane) => node_fs.default.promises.readFile(stepPaneLogPath(pane.id), "utf8").catch(() => void 0)
+	};
+}
+/** Removes the screens a run's finished panes left behind, once the run itself is deleted. */
+async function removeStepPaneLogs(refs) {
+	const panes = (refs.known ?? []).filter((ref) => ref.kind === STEP_PANE_REF_KIND);
+	await Promise.all(panes.map((pane) => node_fs.default.promises.rm(stepPaneLogPath(pane.id), { force: true })));
+}
+function lastLines(text, count) {
+	const lines = text.replace(/\n+$/, "").split("\n");
+	return count === void 0 ? lines : lines.slice(-count);
+}
+/**
+* A run terminal that follows the step a host executor placed.
+*
+* A run executing in the server has no launcher pane of its own; each command
+* step gets one instead. A request naming a step reads that step's pane, which
+* is how each step of a parallel group gets its own screen and keyboard.
+* Without one it follows the current step. While a customRun step runs, there
+* is no terminal to show, so it says where the agent's messages are. Between
+* steps and after the run, an in-process run shows what its latest command
+* printed. A run delegated to a terminal launcher keeps the engine's facade.
+*/
+function createStepPaneTerminal(facade, dependencies) {
+	const inProcess = (record) => record.launcher?.type === NATIVE_LAUNCHER && record.terminalSocket === void 0;
+	const resolveStep = (target) => {
+		const refs = dependencies.stepRefs(target.record);
+		const isRunning = (ref) => refs.running?.some((candidate) => candidate.id === ref.id) === true;
+		if (target.step !== void 0) {
+			const named = refs.known?.find((ref) => ref.id === target.step);
+			if (named !== void 0) return {
+				ref: named,
+				running: isRunning(named)
 			};
-		}],
-		hooks: [{
-			event: "tool_execution_end",
-			handle: async (_event, executionContext) => {
-				await publishLifecycle(executionContext);
+		}
+		if (refs.current !== void 0) return {
+			ref: refs.current,
+			running: true
+		};
+		if (refs.lastPane !== void 0 && inProcess(target.record)) return {
+			ref: refs.lastPane,
+			running: false
+		};
+	};
+	const readLog = async (record, pane, lines) => {
+		const log = await dependencies.paneLog(record, pane);
+		return log === void 0 ? [PANE_GONE_LINE] : lastLines(log, lines);
+	};
+	return {
+		capabilities(target) {
+			const step = resolveStep(target);
+			if (step === void 0) return facade.capabilities(target.record);
+			if (step.ref.kind === "session") return {
+				readable: false,
+				writable: false,
+				resizable: false,
+				reason: SESSION_STEP_REASON
+			};
+			return step.running ? PANE_CAPABILITIES : PANE_LOG_CAPABILITIES;
+		},
+		async screen(target, options) {
+			const step = resolveStep(target);
+			if (step === void 0) return facade.screen(target.record, options);
+			if (step.ref.kind === "session") return [SESSION_STEP_REASON];
+			if (step.running) {
+				const screen = await dependencies.paneClient(target.record).capture(step.ref.id);
+				if (screen !== void 0) return lastLines(screen, options.lines);
 			}
-		}, {
-			when: {
-				state: { "minor-mode": WORKFLOW_MODE_ID },
-				attribution: {
-					kind: "minor",
-					mode: WORKFLOW_MODE_ID
-				}
-			},
-			event: "session_shutdown",
-			handle: disposeControl
-		}],
-		resources: [
-			{
-				when: {
-					state: { "minor-mode": WORKFLOW_MODE_ID },
-					attribution: {
-						kind: "minor",
-						mode: WORKFLOW_MODE_ID
-					}
-				},
-				name: "doompi-author-workflow",
-				kind: "skill",
-				read: () => require_workflowTerminal.readWorkflowSkill("doompi-author-workflow")
-			},
-			{
-				when: {
-					state: { "minor-mode": WORKFLOW_MODE_ID },
-					attribution: {
-						kind: "minor",
-						mode: WORKFLOW_MODE_ID
-					}
-				},
-				name: "doompi-use-workflow",
-				kind: "skill",
-				read: () => require_workflowTerminal.readWorkflowSkill("doompi-use-workflow")
-			},
-			{
-				when: {
-					state: { "minor-mode": WORKFLOW_MODE_ID },
-					attribution: {
-						kind: "minor",
-						mode: WORKFLOW_MODE_ID
-					}
-				},
-				name: "workflow-recovery",
-				kind: "skill",
-				read: () => require_workflowTerminal.readWorkflowSkill("workflow-recovery")
-			}
-		],
-		activities: [{
-			when: {
-				state: { "minor-mode": WORKFLOW_MODE_ID },
-				attribution: {
-					kind: "minor",
-					mode: WORKFLOW_MODE_ID
-				}
-			},
-			name: SOURCE,
-			async start(executionContext) {
-				const reportFailure = (error) => {
-					process.emitWarning(`Could not publish headless workflow state: ${String(error)}`);
-				};
-				const stopFor = (ownedControl) => () => {
-					publishLifecycle(executionContext).then((active) => {
-						if (!active && !modeSelected() && control === ownedControl) disposeControl();
-					}).catch(reportFailure);
-				};
-				if (control !== void 0) {
-					const ownedControl = control;
-					await publishLifecycle(executionContext);
-					return stopFor(ownedControl);
-				}
-				control = feature.createRunControl({});
-				const ownedControl = control;
-				const refresh = () => {
-					publishLifecycle(executionContext).then((active) => {
-						if (!active && !modeSelected() && control === ownedControl) disposeControl();
-					}).catch(reportFailure);
-				};
-				controlDisposers = [
-					ownedControl.on("runStarted", refresh),
-					ownedControl.on("runUpdated", refresh),
-					ownedControl.on("runFinished", refresh)
-				];
-				try {
-					await ownedControl.start();
-					await publishLifecycle(executionContext);
-					return stopFor(ownedControl);
-				} catch (error) {
-					if (control === ownedControl) disposeControl();
-					throw error;
-				}
-			}
-		}],
-		tools: [
-			{
-				when: {
-					state: { "minor-mode": WORKFLOW_MODE_ID },
-					attribution: {
-						kind: "minor",
-						mode: WORKFLOW_MODE_ID
-					}
-				},
-				name: LIST_TOOL,
-				label: "List Workflows",
-				description: "List workflow definitions in this repository, not existing runs.",
-				promptGuidelines: ["Use list_workflows to discover definitions, not to find an existing run."],
-				parameters: zod.z.toJSONSchema(feature.listWorkflowsTool.getInputSchema()),
-				executionMode: "serial",
-				async execute(_toolCallId, parameters, signal, _onUpdate, context) {
-					signal?.throwIfAborted();
-					const input = parameters;
-					return callResult(await feature.listWorkflowsTool.execute({
-						...input,
-						directory: input?.directory === void 0 ? context.cwd : typeof input.directory === "string" ? (0, node_path.resolve)(context.cwd, input.directory) : input.directory
-					}));
-				}
-			},
-			{
-				when: {
-					state: { "minor-mode": WORKFLOW_MODE_ID },
-					attribution: {
-						kind: "minor",
-						mode: WORKFLOW_MODE_ID
-					}
-				},
-				name: LAUNCH_TOOL,
-				label: "Launch Workflow",
-				description: "Start a workflow run. A successful launch is not a completed workflow.",
-				promptGuidelines: ["Launch returns when a run starts, not when it finishes. Use the exact run key and separate workspace from its launch result for workflow_run status, not Agiflow project or job identifiers.", "Do not relaunch a healthy running workflow merely because it has not completed."],
-				parameters: zod.z.toJSONSchema(feature.runTool.getInputSchema()),
-				executionMode: "serial",
-				async execute(_toolCallId, parameters, signal, _onUpdate, context) {
-					signal?.throwIfAborted();
-					const input = parameters;
-					return callResult(await launch({
-						...input,
-						...typeof input.workflowPath === "string" ? { workflowPath: (0, node_path.resolve)(context.cwd, input.workflowPath) } : {}
-					}));
-				}
-			},
-			{
-				when: {
-					state: { "minor-mode": WORKFLOW_MODE_ID },
-					attribution: {
-						kind: "minor",
-						mode: WORKFLOW_MODE_ID
-					}
-				},
-				name: RUN_TOOL,
-				label: "Workflow Run",
-				description: "Inspect a session-owned workflow by exact run key and separate workspace, or request cooperative control.",
-				promptGuidelines: [
-					"Use workflow_run status for the recorded stage, outcome, position, jobs, and steps. A successful status lookup is not evidence that the workflow completed.",
-					"For a healthy running workflow, summarize the recorded progress. Do not automatically search CLI commands or filesystem logs, relaunch, or diagnose failure merely because it remains running.",
-					"Investigate further when the run reports failure or staleness, or when the user requests diagnostics. Only status, pause, resume, and stop are supported here; stop only on user request.",
-					"Use exact registry runKey and separate workspace from the launch or status result. Agiflow project and job identifiers are not workflow run keys."
-				],
-				parameters: {
-					type: "object",
-					properties: {
-						action: {
-							type: "string",
-							enum: [
-								"status",
-								"pause",
-								"resume",
-								"stop"
-							]
-						},
-						runKey: {
-							type: "string",
-							minLength: 1,
-							description: "Exact registry run key from the launch result, without the workspace prefix. Not an Agiflow job ID."
-						},
-						workspace: {
-							type: "string",
-							description: "Workspace from the launch result, passed separately from runKey."
-						},
-						reason: { type: "string" },
-						expectedRunId: { type: "string" }
-					},
-					required: ["action", "runKey"],
-					additionalProperties: false
-				},
-				executionMode: "serial",
-				async execute(_toolCallId, parameters, signal) {
-					signal?.throwIfAborted();
-					const input = parameters;
-					const runs = readWorkflowRuns({ environment: host.context.environment }).filter((run) => runBelongsToSession(run, host.context.sessionId) && run.view.runKey === input.runKey && (input.workspace === void 0 || run.view.workspace === input.workspace));
-					if (runs.length !== 1) return {
-						...callResult({ error: runs.length === 0 ? "No matching workflow run was found in this session. This is a lookup failure, not evidence that the workflow failed. Use the exact runKey and separate workspace from its launch result, not Agiflow job identifiers." : "Specify the workspace for this run key." }),
-						isError: true
-					};
-					const run = runs[0].view;
-					if (input.action === "status") return callResult(run);
-					if (!control) return callResult({ error: "Workflow activity is not active." });
-					if (typeof input.expectedRunId !== "string" || input.expectedRunId.length === 0) return callResult({ error: "expectedRunId is required for workflow control." });
-					return callResult(input.action === "pause" ? await control.pause(input.runKey, input.expectedRunId, input.workspace, input.reason) : input.action === "resume" ? await control.resume(input.runKey, input.expectedRunId, input.workspace) : await control.stop(input.runKey, input.expectedRunId, input.workspace, input.reason));
-				}
-			}
-		],
-		commands: [{
-			when: {
-				state: { "minor-mode": WORKFLOW_MODE_ID },
-				attribution: {
-					kind: "minor",
-					mode: WORKFLOW_MODE_ID
-				}
-			},
-			name: "workflow-launch",
-			description: "Launch a workflow from a slash command.",
-			async execute(args, execution) {
-				const parsed = require_workflowLaunchCommand.parseWorkflowLaunchCommand(args);
-				if ("error" in parsed) {
-					await execution.client.notify({
-						body: parsed.error,
-						level: "error"
-					});
-					return;
-				}
-				try {
-					const entry = require_workflowLaunchCommand.resolveWorkflowEntry(await catalogReader.read(execution.cwd), parsed.workflow);
-					if (!entry || entry.error) {
-						await execution.client.notify({
-							body: entry?.error ?? `Workflow not found: ${parsed.workflow}`,
-							level: "error"
-						});
-						return;
-					}
-					const problems = require_workflowLaunchCommand.validateWorkflowLaunch(entry, parsed);
-					if (problems.length > 0) {
-						await execution.client.notify({
-							body: problems.join("\n"),
-							level: "error"
-						});
-						return;
-					}
-					const result = callResult(await launch({
-						workflowPath: entry.path,
-						...parsed.runner === void 0 ? {} : { runner: parsed.runner },
-						...Object.keys(parsed.inputs).length === 0 ? {} : { inputs: parsed.inputs },
-						...parsed.prompt === void 0 ? {} : { prompt: parsed.prompt }
-					}));
-					const rendered = result.content.find((item) => item.type === "text");
-					await execution.client.notify({
-						body: rendered?.type === "text" ? rendered.text : "Workflow launch requested.",
-						level: result.isError ? "error" : "info"
-					});
-				} catch (error) {
-					await execution.client.notify({
-						body: String(error),
-						level: "error"
-					});
-				}
-			}
-		}],
-		onDispose() {
-			disposeControl();
-			runProvider?.dispose();
-			runProvider = void 0;
+			return readLog(target.record, step.ref, options.lines);
+		},
+		async write(target, data) {
+			const step = resolveStep(target);
+			if (step === void 0) return facade.write(target.record, data);
+			if (step.ref.kind !== "pane" || !step.running) throw new Error(PANE_GONE_LINE);
+			if (!await dependencies.paneClient(target.record).input(step.ref.id, data)) throw new Error(PANE_GONE_LINE);
+		},
+		async resize(target, columns, rows) {
+			if (resolveStep(target) !== void 0) return false;
+			return facade.resize(target.record, columns, rows);
 		}
 	};
 }
@@ -912,6 +1233,20 @@ function createWorkflowServerRuntime(host, serverHost) {
 */
 /** One run, which every route below addresses. */
 const RUN = "/runs/:workspace/:runKey";
+/**
+* The artifact route's parameter, as Hono spells a multi-segment match.
+*
+* An artifact is named by its path inside the run directory, so `reports/a.md`
+* is one parameter across two segments. The client's `params` substitution
+* fills a single segment and percent-encodes the slash with it, so the page
+* substitutes this one itself; see the page's `_lib/terminalApi.ts`.
+*/
+const ARTIFACT_NAME_PARAM = ":name{.+}";
+/**
+* The step whose pane a terminal route reads: a step ref's id. Absent, the
+* route follows the run's current step, which is one of a parallel group's.
+*/
+const STEP_TARGET_PARAM = "step";
 var apiRoutes_default = (0, _agimon_ai_doompi_core_web.defineApiRoutes)({
 	/**
 	* The terminal, as server-sent events.
@@ -922,6 +1257,7 @@ var apiRoutes_default = (0, _agimon_ai_doompi_core_web.defineApiRoutes)({
 	screen: {
 		method: "GET",
 		path: `${RUN}/screen/stream`,
+		query: [STEP_TARGET_PARAM],
 		stream: true
 	},
 	control: {
@@ -943,6 +1279,26 @@ var apiRoutes_default = (0, _agimon_ai_doompi_core_web.defineApiRoutes)({
 		path: RUN,
 		response: (0, _agimon_ai_doompi_core_web.apiResponse)()
 	},
+	stop: {
+		method: "POST",
+		path: `${RUN}/stop`,
+		response: (0, _agimon_ai_doompi_core_web.apiResponse)()
+	},
+	/** Guidance for the agent session the running step is in, like steering a Team sub-agent. */
+	steer: {
+		method: "POST",
+		path: `${RUN}/steer`,
+		response: (0, _agimon_ai_doompi_core_web.apiResponse)()
+	},
+	/**
+	* Launch a workflow into the mounting session's own runtime, which then owns
+	* the run. A dispatcher session reaches its root's session mount through this.
+	*/
+	launch: {
+		method: "POST",
+		path: "/launch",
+		response: (0, _agimon_ai_doompi_core_web.apiResponse)()
+	},
 	artifacts: {
 		method: "GET",
 		path: `${RUN}/artifacts`,
@@ -951,7 +1307,7 @@ var apiRoutes_default = (0, _agimon_ai_doompi_core_web.defineApiRoutes)({
 	/** One artifact: its metadata and text, or its raw bytes under `raw=1`. */
 	artifact: {
 		method: "GET",
-		path: `${RUN}/artifacts/:name{.+}`,
+		path: `${RUN}/artifacts/${ARTIFACT_NAME_PARAM}`,
 		query: ["raw", "download"],
 		response: (0, _agimon_ai_doompi_core_web.apiResponse)()
 	}
@@ -991,6 +1347,8 @@ const STREAM_TICK_MS = 500;
 const SETTLED_POLL_TICKS = 4;
 /** Bytes of one textual artifact returned as JSON; binary previews use a stream. */
 const MAX_ARTIFACT_BYTES = 524288;
+/** Recorded with a stop the web panel asks for, so the run log says where it came from. */
+const WEB_STOP_REASON = "Stopped from the web workflow panel.";
 /** Path segments a client supplies are names, never paths. */
 const SAFE_SEGMENT = /^[\w.@-]+$/;
 const ARTIFACT_MIME_TYPES = {
@@ -1007,6 +1365,7 @@ const ARTIFACT_MIME_TYPES = {
 	".js": "text/javascript",
 	".json": "application/json",
 	".jsx": "text/jsx",
+	".log": "text/plain",
 	".m4a": "audio/mp4",
 	".markdown": "text/markdown",
 	".md": "text/markdown",
@@ -1047,9 +1406,16 @@ async function jsonBody(context) {
 function isSafeSegment(value) {
 	return value !== "" && value !== "../adapters" && value !== ".." && SAFE_SEGMENT.test(value);
 }
-/** One run's identity for caches and leases, stable across stage moves. */
-function runIdentityOf(workspace, runKey) {
-	return `${workspace}/${runKey}`;
+/**
+* One terminal's identity for caches and leases, stable across stage moves: a
+* run's, or one step's pane in it, which keeps its own screen and keyboard.
+*/
+function runIdentityOf(workspace, runKey, step) {
+	return step === void 0 ? `${workspace}/${runKey}` : `${workspace}/${runKey}#${step}`;
+}
+/** The step a terminal request names, from its query or body; absent follows the current step. */
+function stepOf(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
 }
 /**
 * This package's HTTP surface: one workflow run's terminal, and the files its
@@ -1063,8 +1429,9 @@ function runIdentityOf(workspace, runKey) {
 function createWorkflowHubApi(options = {}) {
 	const registry = options.registry ?? new _agimon_ai_workflow_mcp.WorkflowRegistryService();
 	const facade = options.terminal ?? new _agimon_ai_workflow_mcp.WorkflowTerminalService();
+	const stepPanes = createStepPaneTerminalDependencies(registry);
 	const terminal = require_workflowTerminal.createWorkflowTerminalService({
-		terminal: facade,
+		terminal: createStepPaneTerminal(facade, stepPanes),
 		now: options.now ?? (() => Date.now())
 	});
 	const app = new hono.Hono();
@@ -1081,17 +1448,24 @@ function createWorkflowHubApi(options = {}) {
 		const runKey = context.req.param("runKey");
 		const record = await runOf(workspace, runKey);
 		if (record === void 0) return context.json(missing(workspace, runKey), 404);
-		const identity = runIdentityOf(workspace, runKey);
+		const step = stepOf(context.req.query(STEP_TARGET_PARAM));
+		const identity = runIdentityOf(workspace, runKey, step);
 		return (0, hono_streaming.streamSSE)(context, async (stream) => {
 			let settledTicks = 0;
 			let running = true;
+			let latest = record;
 			stream.onAbort(() => {
 				running = false;
 			});
 			while (running) {
 				const current = await runOf(workspace, runKey) ?? record;
-				const capabilities = terminal.capabilities(current);
-				const lines = capabilities.readable ? await terminal.screen(identity, current, SCREEN_LINES) : [];
+				latest = current;
+				const target = {
+					record: current,
+					...step === void 0 ? {} : { step }
+				};
+				const capabilities = terminal.capabilities(target);
+				const lines = capabilities.readable ? await terminal.screen(identity, target, SCREEN_LINES) : [];
 				const settled = current.stage !== "running";
 				if (settled) settledTicks += 1;
 				const ended = settled && settledTicks >= SETTLED_POLL_TICKS;
@@ -1107,7 +1481,7 @@ function createWorkflowHubApi(options = {}) {
 				if (ended) break;
 				await stream.sleep(STREAM_TICK_MS);
 			}
-			terminal.forget(/* @__PURE__ */ new Set());
+			if (latest.stage !== "running") terminal.forgetRun(identity);
 		});
 	});
 	app.post(apiRoutes_default.control.path, async (context) => {
@@ -1115,9 +1489,13 @@ function createWorkflowHubApi(options = {}) {
 		const runKey = context.req.param("runKey");
 		const record = await runOf(workspace, runKey);
 		if (record === void 0) return context.json(missing(workspace, runKey), 404);
-		const identity = runIdentityOf(workspace, runKey);
 		const body = await jsonBody(context);
-		const capabilities = terminal.capabilities(record);
+		const step = stepOf(body.step);
+		const identity = runIdentityOf(workspace, runKey, step);
+		const capabilities = terminal.capabilities({
+			record,
+			...step === void 0 ? {} : { step }
+		});
 		if (body.release === true) {
 			if (typeof body.token === "string") terminal.releaseControl(identity, body.token);
 			return context.json({ held: false });
@@ -1147,8 +1525,12 @@ function createWorkflowHubApi(options = {}) {
 		if (record === void 0) return context.json(missing(workspace, runKey), 404);
 		const body = await jsonBody(context);
 		if (typeof body.token !== "string" || typeof body.data !== "string") return context.json({ error: "A keystroke needs a control token and its data." }, 400);
+		const step = stepOf(body.step);
 		try {
-			await terminal.write(runIdentityOf(workspace, runKey), record, body.token, body.data);
+			await terminal.write(runIdentityOf(workspace, runKey, step), {
+				record,
+				...step === void 0 ? {} : { step }
+			}, body.token, body.data);
 		} catch (error) {
 			return context.json({ error: error instanceof Error ? error.message : String(error) }, 409);
 		}
@@ -1159,26 +1541,72 @@ function createWorkflowHubApi(options = {}) {
 		const runKey = context.req.param("runKey");
 		const record = await runOf(workspace, runKey);
 		if (record === void 0) return context.json(missing(workspace, runKey), 404);
-		const { token, columns, rows } = await jsonBody(context);
+		const body = await jsonBody(context);
+		const { token, columns, rows } = body;
 		if (typeof token !== "string" || typeof columns !== "number" || typeof rows !== "number") return context.json({ error: "A resize needs a control token, columns and rows." }, 400);
+		const step = stepOf(body.step);
 		try {
-			const resized = await terminal.resize(runIdentityOf(workspace, runKey), record, token, columns, rows);
+			const resized = await terminal.resize(runIdentityOf(workspace, runKey, step), {
+				record,
+				...step === void 0 ? {} : { step }
+			}, token, columns, rows);
 			return context.json({ resized });
 		} catch (error) {
 			return context.json({ error: error instanceof Error ? error.message : String(error) }, 409);
 		}
 	});
+	app.post(apiRoutes_default.stop.path, async (context) => {
+		const workspace = context.req.param("workspace");
+		const runKey = context.req.param("runKey");
+		const record = await runOf(workspace, runKey);
+		if (record === void 0) return context.json(missing(workspace, runKey), 404);
+		if (record.stage !== "running" || record.runId === void 0) return context.json({ error: "Only a running workflow can be stopped." }, 409);
+		try {
+			await registry.requestStop(workspace, runKey, WEB_STOP_REASON, record.runId);
+		} catch (error) {
+			return context.json({ error: error instanceof Error ? error.message : String(error) }, 409);
+		}
+		return context.json({ requested: true });
+	});
+	app.post(apiRoutes_default.steer.path, async (context) => {
+		const workspace = context.req.param("workspace");
+		const runKey = context.req.param("runKey");
+		const record = await runOf(workspace, runKey);
+		if (record === void 0) return context.json(missing(workspace, runKey), 404);
+		const body = await jsonBody(context);
+		const message = typeof body.message === "string" ? body.message.trim() : "";
+		if (message === "") return context.json({ error: "Guidance needs a message." }, 400);
+		if (record.stage !== "running") return context.json({ error: "Only a running workflow can be steered." }, 409);
+		const refs = stepPanes.stepRefs(record);
+		const step = typeof body.step === "string" ? body.step : void 0;
+		const current = step === void 0 ? refs.current : (refs.running ?? []).find((candidate) => candidate.id === step);
+		if (current?.kind !== "session") return context.json({ error: "The running step is not an agent session." }, 409);
+		if (options.steer === void 0) return context.json({ error: "Steering is available from the session that launched this run." }, 409);
+		try {
+			await options.steer(current.id, message);
+		} catch (error) {
+			return context.json({ error: error instanceof Error ? error.message : String(error) }, 409);
+		}
+		return context.json({ delivered: true });
+	});
+	app.post(apiRoutes_default.launch.path, async (context) => {
+		if (options.launch === void 0) return context.json({ error: "Launching needs the mount of a session with a workflow runtime." }, 409);
+		const response = await options.launch(await jsonBody(context));
+		return context.json(response);
+	});
 	app.delete(apiRoutes_default.remove.path, async (context) => {
 		const workspace = context.req.param("workspace");
 		const runKey = context.req.param("runKey");
 		const record = await runOf(workspace, runKey);
 		if (record === void 0) return context.json(missing(workspace, runKey), 404);
 		if (record.stage === "running") return context.json({ error: "A running workflow must be stopped before it can be deleted." }, 409);
+		const refs = stepPanes.stepRefs(record);
 		try {
 			node_fs.default.rmSync(registry.runDirectoryFor(record), {
 				recursive: true,
 				force: true
 			});
+			await removeStepPaneLogs(refs);
 		} catch (error) {
 			return context.json({ error: error instanceof Error ? error.message : String(error) }, 409);
 		}
@@ -1305,80 +1733,756 @@ function readArtifact(resolved, requested) {
 		} finally {
 			node_fs.default.closeSync(handle);
 		}
-	} catch {
-		return;
-	}
-	return {
-		path: requested,
-		size: stats.size,
-		modifiedAt: stats.mtime.toISOString(),
-		mimeType,
-		...text === void 0 ? {} : { text },
-		truncated: text !== void 0 && stats.size > MAX_ARTIFACT_BYTES
+	} catch {
+		return;
+	}
+	return {
+		path: requested,
+		size: stats.size,
+		modifiedAt: stats.mtime.toISOString(),
+		mimeType,
+		...text === void 0 ? {} : { text },
+		truncated: text !== void 0 && stats.size > MAX_ARTIFACT_BYTES
+	};
+}
+/** Streams media with byte-range support so browser audio, video, and PDF controls can seek. */
+function streamArtifact(resolved, requested, rangeHeader, download) {
+	const stats = statOf(resolved);
+	if (stats === void 0 || stats.isDirectory()) return void 0;
+	const mimeType = artifactMimeType(requested);
+	let start = 0;
+	let end = Math.max(0, stats.size - 1);
+	let partial = false;
+	const match = rangeHeader?.match(/^bytes=(\d*)-(\d*)$/);
+	if (match !== null && match !== void 0 && stats.size > 0) {
+		const requestedStart = match[1] === "" ? void 0 : Number(match[1]);
+		const requestedEnd = match[2] === "" ? void 0 : Number(match[2]);
+		if (requestedStart === void 0 && requestedEnd !== void 0) start = Math.max(0, stats.size - requestedEnd);
+		else if (requestedStart !== void 0) {
+			start = requestedStart;
+			end = requestedEnd === void 0 ? end : Math.min(requestedEnd, end);
+		}
+		if (start >= stats.size || start > end) return new Response(null, {
+			status: 416,
+			headers: { "content-range": `bytes */${String(stats.size)}` }
+		});
+		partial = true;
+	}
+	const filename = node_path.default.basename(requested).replace(/["\\\r\n]/g, "_");
+	const headers = new Headers({
+		"accept-ranges": "bytes",
+		"content-disposition": `${download || mimeType === "text/html" ? "attachment" : "inline"}; filename="${filename}"`,
+		"content-length": String(stats.size === 0 ? 0 : end - start + 1),
+		"content-type": mimeType,
+		"x-content-type-options": "nosniff"
+	});
+	if (partial) headers.set("content-range", `bytes ${String(start)}-${String(end)}/${String(stats.size)}`);
+	if (stats.size === 0) return new Response(null, {
+		status: 200,
+		headers
+	});
+	const body = node_stream.Readable.toWeb(node_fs.default.createReadStream(resolved, {
+		start,
+		end
+	}));
+	return new Response(body, {
+		status: partial ? 206 : 200,
+		headers
+	});
+}
+/**
+* This package's API, mounted by a session with its runtime's `launch` and by
+* the hub without one.
+*/
+function createWorkflowApi(launch) {
+	return {
+		basePath: WORKFLOW_API_BASE_PATH,
+		start(context) {
+			const steer = context.sessionService?.steer?.bind(context.sessionService);
+			const app = createWorkflowHubApi({
+				...steer === void 0 ? {} : { steer: (sessionId, message) => steer(sessionId, message) },
+				...launch === void 0 ? {} : { launch }
+			});
+			return {
+				fetch: (request) => app.fetch(request),
+				close: () => void 0
+			};
+		}
+	};
+}
+/** The named export a host imports from this package's built hub entry. */
+const api = createWorkflowApi();
+//#endregion
+//#region src/services/workflowWatcher/index.ts
+/**
+* Read the durable workflow registry once.
+*
+* The registry is an initial snapshot only. Live delivery belongs to the
+* session lifecycle and is routed through the host-owned direct event bus.
+*/
+function readWorkflowRuns(options = {}) {
+	const environment = options.environment;
+	const homeDir = options.homeDir ?? resolveWorkflowHome({
+		envValue: environment?.["WORKFLOW_MCP_HOME"],
+		homeDir: node_os.default.homedir()
+	});
+	const workspacesDir = node_path.default.join(homeDir, WORKSPACES_DIR_NAME);
+	const recordCache = /* @__PURE__ */ new Map();
+	const progressCache = /* @__PURE__ */ new Map();
+	const cachedParse = (cache, filePath, parse, empty) => {
+		let stat;
+		try {
+			stat = node_fs.default.statSync(filePath);
+		} catch {
+			cache.delete(filePath);
+			return empty;
+		}
+		const cached = cache.get(filePath);
+		if (cached && cached.size === stat.size && cached.mtimeMs === stat.mtimeMs) return cached.value;
+		let raw;
+		try {
+			raw = node_fs.default.readFileSync(filePath, "utf8");
+		} catch {
+			cache.delete(filePath);
+			return empty;
+		}
+		const value = parse(raw);
+		cache.set(filePath, {
+			size: stat.size,
+			mtimeMs: stat.mtimeMs,
+			value
+		});
+		return value;
+	};
+	const listDir = (directory) => {
+		try {
+			return node_fs.default.readdirSync(directory).sort();
+		} catch {
+			return [];
+		}
+	};
+	const runs = [];
+	for (const workspace of listDir(workspacesDir)) for (const stage of WORKFLOW_STAGES) {
+		const stageDir = node_path.default.join(workspacesDir, workspace, stage);
+		for (const runKey of listDir(stageDir)) {
+			const runDir = node_path.default.join(stageDir, runKey);
+			const recordPath = node_path.default.join(runDir, RUN_RECORD_FILE_NAME);
+			const progressPath = node_path.default.join(runDir, PROGRESS_FILE_NAME);
+			const parsed = cachedParse(recordCache, recordPath, parseWorkflowRunRecord, void 0);
+			if (parsed === void 0) continue;
+			const jobs = cachedParse(progressCache, progressPath, (raw) => foldWorkflowProgress(parseWorkflowProgress(raw)), []);
+			runs.push({
+				...parsed,
+				view: completeWorkflowRunView(parsed.view, jobs)
+			});
+		}
+	}
+	return runs;
+}
+//#endregion
+//#region src/services/serverRuntime/index.ts
+const SOURCE = "@agimon-ai/doompi-workflow";
+const WORKFLOW_MODE_ID = "workflow";
+const LIST_TOOL = "list_workflows";
+const LAUNCH_TOOL = "launch_workflow";
+const RUN_TOOL = "workflow_run";
+/** Origin of a request dispatched in process to another mount; nothing resolves it. */
+const IN_PROCESS_ORIGIN = "http://doompi.local";
+/** A burst of job and step events is published once, this long after the first. */
+const RUNS_PUBLISH_DEBOUNCE_MS = 100;
+/** A notification body's limit; a longer failure is cut to it. */
+const NOTICE_BODY_LIMIT = 4e3;
+/**
+* A launch refused because the workflow needs fixing. The doctor's findings
+* name only a job and a step, so the notice names the workflow and says
+* nothing ran; in a conversation it otherwise reads as part of whatever run
+* was reported just before it.
+*/
+function needsFixingNotice(workflow, error) {
+	return `Workflow "${workflow}" was not launched: it needs fixing.\n${error}`;
+}
+function textResult(text, isError = false) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		...isError ? { isError: true } : {}
+	};
+}
+function isLaunchResponse(value) {
+	return typeof value === "object" && value !== null && "text" in value && typeof value.text === "string";
+}
+function errorOf(value) {
+	return typeof value === "object" && value !== null && "error" in value && typeof value.error === "string" ? value.error : void 0;
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/** The text of a launch's tool result, as the launch tool and the API report it. */
+function launchResultOf(result) {
+	return textResult(result.content.map((item) => item.type === "text" ? item.text : "").filter((line) => line !== "").join("\n") || "Workflow launch requested.", result.isError === true);
+}
+function callResult(value) {
+	const content = [];
+	if (typeof value === "object" && value !== null && "content" in value && Array.isArray(value.content)) for (const item of value.content) {
+		if (typeof item !== "object" || item === null || !("type" in item)) continue;
+		const record = item;
+		if (record.type === "text" && typeof record.text === "string") content.push({
+			type: "text",
+			text: record.text
+		});
+		else if (record.type === "image" && typeof record.data === "string" && typeof record.mimeType === "string") content.push({
+			type: "image",
+			data: record.data,
+			mimeType: record.mimeType
+		});
+	}
+	if (content.length === 0) content.push({
+		type: "text",
+		text: JSON.stringify(value, null, 2)
+	});
+	return {
+		content,
+		details: value,
+		...typeof value === "object" && value !== null && "isError" in value && value.isError === true ? { isError: true } : {}
+	};
+}
+function createWorkflowServerRuntime(host, serverHost) {
+	if (serverHost.context.directEvents === void 0) throw new Error("Workflow headless facet requires the session direct event bus.");
+	const directEvents = serverHost.context.directEvents;
+	let runProvider;
+	const catalogDeps = defaultCatalogDeps();
+	const catalogReader = createWorkflowCatalogReader(catalogDeps);
+	const telemetry = (0, _agimon_ai_doompi_telemetry.createDoomTelemetry)({
+		serviceName: "doom-workflow",
+		packageName: SOURCE,
+		cwd: host.context.cwd,
+		env: host.context.environment,
+		enableLogs: true,
+		enableTraces: true
+	});
+	/** This session's runs, published to its panel and counted as its background work. */
+	const publishRuns = (executionContext) => {
+		const records = readWorkflowRuns({ environment: executionContext.environment }).filter((run) => runBelongsToSession(run, executionContext.sessionId));
+		const activeItems = records.filter((run) => run.view.stage === "running" && run.view.stale !== true).map((run) => ({
+			id: `${run.view.workspace}/${run.view.runKey}`,
+			sessionId: executionContext.sessionId
+		}));
+		runProvider?.update(activeItems);
+		const runs = presentWorkflowRuns(records.map((run) => run.view), Date.now());
+		directEvents.publish(WORKFLOW_RUNS_TYPE, executionContext.sessionId, { runs });
+		return activeItems.length > 0;
+	};
+	/** The workflows this session can launch. Runs moving on do not change them, so their events skip this. */
+	const publishCatalog = async (executionContext) => {
+		try {
+			directEvents.publish(WORKFLOW_CATALOG_TYPE, executionContext.sessionId, {
+				cwd: executionContext.cwd,
+				workflows: presentWorkflowCatalog(await catalogReader.read(executionContext.cwd))
+			});
+		} catch (error) {
+			const warning = error instanceof Error ? error.message : String(error);
+			directEvents.publish(WORKFLOW_CATALOG_TYPE, executionContext.sessionId, {
+				cwd: executionContext.cwd,
+				workflows: [],
+				warning
+			});
+		}
+	};
+	const publishLifecycle = async (executionContext) => {
+		const active = publishRuns(executionContext);
+		await publishCatalog(executionContext);
+		return active;
+	};
+	let runsTimer;
+	/** Publishes the runs once for a burst of job and step events, which a fix loop can produce by the dozen. */
+	const publishRunsSoon = (executionContext, after) => {
+		if (runsTimer !== void 0) return;
+		runsTimer = setTimeout(() => {
+			runsTimer = void 0;
+			try {
+				after?.(publishRuns(executionContext));
+			} catch (error) {
+				telemetry.recordWarning("doom_workflow.publish_failed", error);
+			}
+		}, RUNS_PUBLISH_DEBOUNCE_MS);
+		runsTimer.unref?.();
+	};
+	const sessionService = serverHost.context.sessionService;
+	const feature = (0, _agimon_ai_workflow_mcp.createEmbeddedWorkflowFeature)(sessionService === void 0 ? {} : { stepExecutor: createStepExecutor({
+		sessionService,
+		parentSessionId: host.context.sessionId,
+		hostEnvironment: process.env,
+		launchPane: createNativeStepPaneLauncher(void 0, telemetry),
+		createId: () => `workflow-${(0, node_crypto.randomUUID)()}`,
+		telemetry
+	}) });
+	const launcher = createServerLauncher({
+		feature,
+		sessionId: host.context.sessionId,
+		environment: host.context.environment,
+		telemetry,
+		notify: (body, level) => host.context.client.notify({
+			body: body.slice(0, NOTICE_BODY_LIMIT),
+			level
+		}),
+		onRunsChanged: () => publishRunsSoon(host.context)
+	});
+	/**
+	* Why this session cannot run a launch, or undefined when it can.
+	*
+	* The checks the slash command makes through the catalog, made for every
+	* launch whatever asked for it: the launch tool, another session, or the
+	* browser. The workflow must be a file in the repository the launch comes
+	* from, a worktree's own when it runs in one, and its runner, command,
+	* choice, inputs and prompt must be ones it declares.
+	*/
+	const refuseLaunch = (input, where) => {
+		if (typeof input.workflowPath !== "string" || input.workflowPath === "") return "A launch needs a workflowPath.";
+		const workflowPath = (0, node_path.resolve)(where.cwd, input.workflowPath);
+		const inside = (0, node_path.relative)(where.repoRoot, workflowPath);
+		if (inside.startsWith("..") || (0, node_path.isAbsolute)(inside)) return `Workflow ${input.workflowPath} is outside this session's repository, so it cannot be launched here.`;
+		const detail = catalogDeps.summarize(workflowPath);
+		if (detail.error !== void 0) return needsFixingNotice(inside, detail.error);
+		const problems = require_workflowLaunchCommand.validateWorkflowLaunch(detail, {
+			inputs: input.inputs ?? {},
+			...input.prompt === void 0 ? {} : { prompt: input.prompt },
+			...(input.runner ?? input.cliAgent) === void 0 ? {} : { runner: input.runner ?? input.cliAgent },
+			...input.command === void 0 ? {} : { command: input.command },
+			...input.choice === void 0 ? {} : { choice: input.choice }
+		});
+		return problems.length === 0 ? void 0 : problems.join("\n");
+	};
+	/**
+	* Run a workflow in this process and answer once it has registered.
+	*
+	* The launch goes through the same executor the Pi extension uses; see
+	* `createServerLauncher` for what the server adds around it.
+	*/
+	const launchHere = async (parameters, where = host.context) => {
+		let input;
+		try {
+			input = feature.runTool.getInputSchema().parse(parameters);
+		} catch (error) {
+			return textResult(`Error: ${errorMessage(error)}`, true);
+		}
+		const refusal = refuseLaunch(input, where);
+		if (refusal !== void 0) return textResult(`Error: ${refusal}`, true);
+		try {
+			return launchResultOf(await launcher.launch({
+				...input,
+				workflowPath: (0, node_path.resolve)(where.cwd, input.workflowPath)
+			}));
+		} catch (error) {
+			return textResult(`Error: ${errorMessage(error)}`, true);
+		}
+	};
+	/**
+	* Hand a launch to the session that owns this session's runs, through that
+	* session's own mount of this package's API. The owner runs it, so the run
+	* and its step sessions outlive this session, as a dispatcher's launches must.
+	*/
+	const launchIn = async (owner, parameters) => {
+		if (serverHost.context.requestApi === void 0) return textResult(`Error: this host cannot reach session ${owner} to launch the workflow there.`, true);
+		const response = await serverHost.context.requestApi({
+			scope: "session",
+			sessionId: owner
+		}, WORKFLOW_API_BASE_PATH, new Request(`${IN_PROCESS_ORIGIN}${apiRoutes_default.launch.path}`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify(parameters)
+		}));
+		const body = await response.json().catch((error) => ({ error: String(error) }));
+		if (response.ok && isLaunchResponse(body)) return textResult(body.text, body.isError === true);
+		return textResult(`Error: session ${owner} did not launch the workflow (${errorOf(body) ?? `HTTP ${String(response.status)}`}).`, true);
+	};
+	/**
+	* A workflow dispatcher launches for its root session, the way a CLI
+	* dispatcher child does: the same markers name it, and the root runs what
+	* it launches. Any other session runs its own launches.
+	*/
+	const dispatcher = require_workflowTerminal.isWorkflowDispatcherProcess(host.context.environment);
+	const launchOwner = () => {
+		if (!dispatcher) return void 0;
+		const parent = require_workflowTerminal.resolveDispatcherParentSession(host.context.environment);
+		if (parent === void 0) return void 0;
+		const owner = (0, _agimon_ai_doompi_core_childProcess.resolveRootSessionId)(parent, host.context.environment);
+		return owner === host.context.sessionId ? void 0 : owner;
+	};
+	const launch = async (parameters, where) => {
+		const owner = launchOwner();
+		return owner === void 0 ? launchHere(parameters, where) : launchIn(owner, parameters);
+	};
+	/** A launch another session handed this one: this session runs and owns it. */
+	const launchFromApi = async (parameters) => {
+		const result = await launchHere(parameters);
+		publishRunsSoon(host.context);
+		return {
+			text: result.content.map((item) => item.text).join("\n"),
+			...result.isError === true ? { isError: true } : {}
+		};
+	};
+	let control;
+	let controlDisposers = [];
+	const disposeControl = () => {
+		for (const dispose of controlDisposers.splice(0)) dispose();
+		control?.dispose();
+		control = void 0;
+	};
+	let modeOwner;
+	const modeSelected = () => (host.context.selection.state?.["minor-mode"] ?? []).includes(WORKFLOW_MODE_ID);
+	const modeState = () => {
+		const active = modeSelected();
+		return {
+			activation: active ? "active" : "inactive",
+			condition: "ready",
+			...active ? { detail: "workflow tools available" } : {},
+			actions: [{
+				id: "activate",
+				enabled: !active,
+				...!active ? {} : { disabledReason: "Workflow mode is active." }
+			}, {
+				id: "deactivate",
+				enabled: active,
+				...active ? {} : { disabledReason: "Workflow mode is inactive." }
+			}]
+		};
+	};
+	const selectMode = async (enabled) => {
+		const modes = (host.context.selection.state?.["minor-mode"] ?? []).filter((mode) => mode !== WORKFLOW_MODE_ID);
+		await host.changeSelection({
+			axis: "state",
+			key: "minor-mode",
+			values: enabled ? [...modes, WORKFLOW_MODE_ID] : modes
+		});
+		modeOwner?.publish();
+	};
+	modeOwner = (0, _agimon_ai_doompi_minor_mode.defineMinorMode)({
+		descriptor: {
+			source: SOURCE,
+			id: WORKFLOW_MODE_ID,
+			label: "Workflow",
+			description: "Workflow discovery, launch, inspection, control, and recovery tools.",
+			order: 20,
+			actions: [{
+				id: "activate",
+				label: "Activate",
+				description: "Enable workflow tools for this session.",
+				contexts: ["headless"],
+				parameters: []
+			}, {
+				id: "deactivate",
+				label: "Deactivate",
+				description: "Disable workflow tools without stopping active runs.",
+				contexts: ["headless"],
+				parameters: []
+			}]
+		},
+		state: modeState,
+		async handleAction(_runtime, actionId, _argumentsValue, execution) {
+			execution.signal.throwIfAborted();
+			if (actionId === "activate") {
+				await selectMode(true);
+				return { message: "Workflow mode activated." };
+			}
+			if (actionId === "deactivate") {
+				await selectMode(false);
+				return { message: "Workflow mode deactivated." };
+			}
+			throw new Error(`Unknown workflow mode action: ${actionId}`);
+		}
+	}).createOwner(void 0);
+	return {
+		api: [createWorkflowApi(launchFromApi)],
+		services: [(0, _agimon_ai_doompi_minor_mode.serverMinorModes)([modeOwner]), (context) => {
+			const provider = require_workflowTerminal.registerRunProvider(context);
+			runProvider = provider;
+			return () => {
+				provider.dispose();
+				if (runProvider === provider) runProvider = void 0;
+			};
+		}],
+		hooks: [{
+			event: "tool_execution_end",
+			handle: async (_event, executionContext) => {
+				await publishLifecycle(executionContext);
+			}
+		}, {
+			when: {
+				state: { "minor-mode": WORKFLOW_MODE_ID },
+				attribution: {
+					kind: "minor",
+					mode: WORKFLOW_MODE_ID
+				}
+			},
+			event: "session_shutdown",
+			handle: disposeControl
+		}],
+		resources: [
+			{
+				when: {
+					state: { "minor-mode": WORKFLOW_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: WORKFLOW_MODE_ID
+					}
+				},
+				name: "doompi-author-workflow",
+				kind: "skill",
+				read: () => require_workflowTerminal.readWorkflowSkill("doompi-author-workflow")
+			},
+			{
+				when: {
+					state: { "minor-mode": WORKFLOW_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: WORKFLOW_MODE_ID
+					}
+				},
+				name: "doompi-use-workflow",
+				kind: "skill",
+				read: () => require_workflowTerminal.readWorkflowSkill("doompi-use-workflow")
+			},
+			{
+				when: {
+					state: { "minor-mode": WORKFLOW_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: WORKFLOW_MODE_ID
+					}
+				},
+				name: "workflow-recovery",
+				kind: "skill",
+				read: () => require_workflowTerminal.readWorkflowSkill("workflow-recovery")
+			}
+		],
+		activities: [{
+			when: {
+				state: { "minor-mode": WORKFLOW_MODE_ID },
+				attribution: {
+					kind: "minor",
+					mode: WORKFLOW_MODE_ID
+				}
+			},
+			name: SOURCE,
+			async start(executionContext) {
+				const reportFailure = (error) => {
+					process.emitWarning(`Could not publish headless workflow state: ${String(error)}`);
+				};
+				const stopFor = (ownedControl) => () => {
+					publishLifecycle(executionContext).then((active) => {
+						if (!active && !modeSelected() && control === ownedControl) disposeControl();
+					}).catch(reportFailure);
+				};
+				if (control !== void 0) {
+					const ownedControl = control;
+					await publishLifecycle(executionContext);
+					return stopFor(ownedControl);
+				}
+				control = feature.createRunControl({});
+				const ownedControl = control;
+				const refresh = () => {
+					publishRunsSoon(executionContext, (active) => {
+						if (!active && !modeSelected() && control === ownedControl) disposeControl();
+					});
+				};
+				controlDisposers = [
+					ownedControl.on("runStarted", refresh),
+					ownedControl.on("runUpdated", refresh),
+					ownedControl.on("runFinished", refresh),
+					ownedControl.on("job", refresh),
+					ownedControl.on("step", refresh)
+				];
+				try {
+					await ownedControl.start();
+					await publishLifecycle(executionContext);
+					return stopFor(ownedControl);
+				} catch (error) {
+					if (control === ownedControl) disposeControl();
+					throw error;
+				}
+			}
+		}],
+		tools: [
+			{
+				when: {
+					state: { "minor-mode": WORKFLOW_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: WORKFLOW_MODE_ID
+					}
+				},
+				name: LIST_TOOL,
+				label: "List Workflows",
+				description: "List workflow definitions in this repository, not existing runs.",
+				promptGuidelines: ["Use list_workflows to discover definitions, not to find an existing run."],
+				parameters: zod.z.toJSONSchema(feature.listWorkflowsTool.getInputSchema()),
+				executionMode: "serial",
+				async execute(_toolCallId, parameters, signal, _onUpdate, context) {
+					signal?.throwIfAborted();
+					const input = parameters;
+					return callResult(await feature.listWorkflowsTool.execute({
+						...input,
+						directory: input?.directory === void 0 ? context.cwd : typeof input.directory === "string" ? (0, node_path.resolve)(context.cwd, input.directory) : input.directory
+					}));
+				}
+			},
+			{
+				when: {
+					state: { "minor-mode": WORKFLOW_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: WORKFLOW_MODE_ID
+					}
+				},
+				name: LAUNCH_TOOL,
+				label: "Launch Workflow",
+				description: "Start a workflow run. A successful launch is not a completed workflow.",
+				promptGuidelines: ["Launch returns when a run starts, not when it finishes. Use the exact run key and separate workspace from its launch result for workflow_run status, not Agiflow project or job identifiers.", "Do not relaunch a healthy running workflow merely because it has not completed."],
+				parameters: zod.z.toJSONSchema(feature.runTool.getInputSchema()),
+				executionMode: "serial",
+				async execute(_toolCallId, parameters, signal, _onUpdate, context) {
+					signal?.throwIfAborted();
+					const input = parameters;
+					return callResult(await launch({
+						...input,
+						...typeof input.workflowPath === "string" ? { workflowPath: (0, node_path.resolve)(context.cwd, input.workflowPath) } : {}
+					}, context));
+				}
+			},
+			{
+				when: {
+					state: { "minor-mode": WORKFLOW_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: WORKFLOW_MODE_ID
+					}
+				},
+				name: RUN_TOOL,
+				label: "Workflow Run",
+				description: "Inspect a session-owned workflow by exact run key and separate workspace, or request cooperative control.",
+				promptGuidelines: [
+					"Use workflow_run status for the recorded stage, outcome, position, jobs, and steps. A successful status lookup is not evidence that the workflow completed.",
+					"For a healthy running workflow, summarize the recorded progress. Do not automatically search CLI commands or filesystem logs, relaunch, or diagnose failure merely because it remains running.",
+					"Investigate further when the run reports failure or staleness, or when the user requests diagnostics. Only status, pause, resume, and stop are supported here; stop only on user request.",
+					"Use exact registry runKey and separate workspace from the launch or status result. Agiflow project and job identifiers are not workflow run keys."
+				],
+				parameters: {
+					type: "object",
+					properties: {
+						action: {
+							type: "string",
+							enum: [
+								"status",
+								"pause",
+								"resume",
+								"stop"
+							]
+						},
+						runKey: {
+							type: "string",
+							minLength: 1,
+							description: "Exact registry run key from the launch result, without the workspace prefix. Not an Agiflow job ID."
+						},
+						workspace: {
+							type: "string",
+							description: "Workspace from the launch result, passed separately from runKey."
+						},
+						reason: { type: "string" },
+						expectedRunId: { type: "string" }
+					},
+					required: ["action", "runKey"],
+					additionalProperties: false
+				},
+				executionMode: "serial",
+				async execute(_toolCallId, parameters, signal) {
+					signal?.throwIfAborted();
+					const input = parameters;
+					const runs = readWorkflowRuns({ environment: host.context.environment }).filter((run) => runBelongsToSession(run, host.context.sessionId) && run.view.runKey === input.runKey && (input.workspace === void 0 || run.view.workspace === input.workspace));
+					if (runs.length !== 1) return {
+						...callResult({ error: runs.length === 0 ? "No matching workflow run was found in this session. This is a lookup failure, not evidence that the workflow failed. Use the exact runKey and separate workspace from its launch result, not Agiflow job identifiers." : "Specify the workspace for this run key." }),
+						isError: true
+					};
+					const run = runs[0].view;
+					if (input.action === "status") return callResult(run);
+					if (!control) return callResult({ error: "Workflow activity is not active." });
+					if (typeof input.expectedRunId !== "string" || input.expectedRunId.length === 0) return callResult({ error: "expectedRunId is required for workflow control." });
+					return callResult(input.action === "pause" ? await control.pause(input.runKey, input.expectedRunId, input.workspace, input.reason) : input.action === "resume" ? await control.resume(input.runKey, input.expectedRunId, input.workspace) : await control.stop(input.runKey, input.expectedRunId, input.workspace, input.reason));
+				}
+			}
+		],
+		commands: [{
+			when: {
+				state: { "minor-mode": WORKFLOW_MODE_ID },
+				attribution: {
+					kind: "minor",
+					mode: WORKFLOW_MODE_ID
+				}
+			},
+			name: "workflow-launch",
+			description: "Launch a workflow from a slash command.",
+			async execute(args, execution) {
+				const parsed = require_workflowLaunchCommand.parseWorkflowLaunchCommand(args);
+				if ("error" in parsed) {
+					await execution.client.notify({
+						body: parsed.error,
+						level: "error"
+					});
+					return;
+				}
+				try {
+					const entry = require_workflowLaunchCommand.resolveWorkflowEntry(await catalogReader.read(execution.cwd), parsed.workflow);
+					if (!entry || entry.error) {
+						await execution.client.notify({
+							body: entry?.error ? needsFixingNotice(entry.name, entry.error) : `Workflow not found: ${parsed.workflow}`,
+							level: "error"
+						});
+						return;
+					}
+					const problems = require_workflowLaunchCommand.validateWorkflowLaunch(entry, parsed);
+					if (problems.length > 0) {
+						await execution.client.notify({
+							body: problems.join("\n"),
+							level: "error"
+						});
+						return;
+					}
+					const result = callResult(await launch({
+						workflowPath: entry.path,
+						...parsed.runner === void 0 ? {} : { runner: parsed.runner },
+						...parsed.command === void 0 ? {} : { command: parsed.command },
+						...parsed.choice === void 0 ? {} : { choice: parsed.choice },
+						...Object.keys(parsed.inputs).length === 0 ? {} : { inputs: parsed.inputs },
+						...parsed.prompt === void 0 ? {} : { prompt: parsed.prompt }
+					}, execution));
+					const rendered = result.content.find((item) => item.type === "text");
+					await execution.client.notify({
+						body: rendered?.type === "text" ? rendered.text : "Workflow launch requested.",
+						level: result.isError ? "error" : "info"
+					});
+				} catch (error) {
+					await execution.client.notify({
+						body: String(error),
+						level: "error"
+					});
+				}
+			}
+		}],
+		...dispatcher ? { toolRestrictions: [{ excludedTools: [RUN_TOOL] }] } : {},
+		async onDispose() {
+			disposeControl();
+			if (runsTimer !== void 0) clearTimeout(runsTimer);
+			await launcher.dispose();
+			runProvider?.dispose();
+			runProvider = void 0;
+			await telemetry.shutdown();
+		}
 	};
 }
-/** Streams media with byte-range support so browser audio, video, and PDF controls can seek. */
-function streamArtifact(resolved, requested, rangeHeader, download) {
-	const stats = statOf(resolved);
-	if (stats === void 0 || stats.isDirectory()) return void 0;
-	const mimeType = artifactMimeType(requested);
-	let start = 0;
-	let end = Math.max(0, stats.size - 1);
-	let partial = false;
-	const match = rangeHeader?.match(/^bytes=(\d*)-(\d*)$/);
-	if (match !== null && match !== void 0 && stats.size > 0) {
-		const requestedStart = match[1] === "" ? void 0 : Number(match[1]);
-		const requestedEnd = match[2] === "" ? void 0 : Number(match[2]);
-		if (requestedStart === void 0 && requestedEnd !== void 0) start = Math.max(0, stats.size - requestedEnd);
-		else if (requestedStart !== void 0) {
-			start = requestedStart;
-			end = requestedEnd === void 0 ? end : Math.min(requestedEnd, end);
-		}
-		if (start >= stats.size || start > end) return new Response(null, {
-			status: 416,
-			headers: { "content-range": `bytes */${String(stats.size)}` }
-		});
-		partial = true;
-	}
-	const filename = node_path.default.basename(requested).replace(/["\\\r\n]/g, "_");
-	const headers = new Headers({
-		"accept-ranges": "bytes",
-		"content-disposition": `${download || mimeType === "text/html" ? "attachment" : "inline"}; filename="${filename}"`,
-		"content-length": String(stats.size === 0 ? 0 : end - start + 1),
-		"content-type": mimeType,
-		"x-content-type-options": "nosniff"
-	});
-	if (partial) headers.set("content-range", `bytes ${String(start)}-${String(end)}/${String(stats.size)}`);
-	if (stats.size === 0) return new Response(null, {
-		status: 200,
-		headers
-	});
-	const body = node_stream.Readable.toWeb(node_fs.default.createReadStream(resolved, {
-		start,
-		end
-	}));
-	return new Response(body, {
-		status: partial ? 206 : 200,
-		headers
-	});
-}
-/** The named export a host imports from this package's built hub entry. */
-const api = {
-	basePath: WORKFLOW_API_BASE_PATH,
-	start(_context) {
-		const app = createWorkflowHubApi();
-		return {
-			fetch: (request) => app.fetch(request),
-			close: () => void 0
-		};
-	}
-};
 //#endregion
 //#region src/extensions/workspaces/sessions/(backend)/_lib/index.server.ts
-var index_server_default$1 = (({ agent, host }) => ({
-	api: [api],
-	...agent ? createWorkflowServerRuntime(agent, host) : {}
-}));
+var index_server_default$1 = (({ agent, host }) => agent ? createWorkflowServerRuntime(agent, host) : { api: [api] });
 //#endregion
 //#region src/extensions/workspaces/sessions/(backend)/root.server.ts
 var root_server_default = (0, _agimon_ai_doompi_core_extensionFile.defineRoot)((context) => {
@@ -1549,6 +2653,9 @@ var doompi_use_workflow_server_default = (0, _agimon_ai_doompi_core_extensionFil
 //#region src/extensions/workspaces/sessions/(backend)/resource/workflow-recovery.server.ts
 var workflow_recovery_server_default = (0, _agimon_ai_doompi_core_extensionFile.defineRoutedContribution)((context) => context.root.resources?.[2], { cardinality: "optional" });
 //#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool-restriction/dispatcher.server.ts
+var dispatcher_server_default = (0, _agimon_ai_doompi_core_extensionFile.defineRoutedContribution)((context) => context.root.toolRestrictions?.[0], { cardinality: "optional" });
+//#endregion
 //#region src/extensions/workspaces/sessions/(backend)/tool/launch-workflow.server.ts
 var launch_workflow_server_default = (0, _agimon_ai_doompi_core_extensionFile.defineRoutedContribution)((context) => context.root.tools?.[1], { cardinality: "optional" });
 //#endregion
@@ -1611,6 +2718,9 @@ const facet = (0, _agimon_ai_doompi_core_serverFacet.defineServerPlugin)({
 					at(workflow_recovery_server_default, contextSession)
 				]);
 			},
+			get toolRestrictions() {
+				return defined([at(dispatcher_server_default, contextSession)]);
+			},
 			get tools() {
 				return defined([
 					via({ name: "launch_workflow" }, at(launch_workflow_server_default, contextSession)),