@agimon-ai/po-workflow 0.0.0-alpha.0

package/dist/extensions/web.mjs

@@ -0,0 +1,3788 @@
+import { apiResponse, createApiClient, defineActivityGroup, defineApiRoutes, defineChannelFile, defineContextAction, defineDockFace, defineFill, defineLeaderBinding, defineMinorModeFile, defineSessionStore, defineToolRenderer, defineWebPlugin, sessionApiAddress } from "@agimon-ai/po-core/web";
+import { AnsiLine, ArrowRightIcon, Badge, Button, ChevronDownIcon, ChevronRightIcon, CloseIcon, Dialog, DialogBody, DialogContent, DialogFooter, DialogHeader, DialogTitle, Dot, EmptyState, Input, Kbd, Markdown, MessageItem, MessageItemBody, MessageItemHeader, MessageLines, OptionLabel, OptionRow, Popover, PopoverContent, PopoverFooter, PopoverHeader, PopoverTrigger, SearchIcon, SectionLabel, Select, SelectContent, SelectItem, SelectTrigger, SelectValue, Sheet, SheetContent, SheetTitle, StatusBadge, StreamCursor, Textarea, WorkflowIcon, cn, toolTone } from "@agimon-ai/po-web-components";
+import { useStore } from "@tanstack/react-store";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { sealedTransport } from "@agimon-ai/po-web-security/browser";
+const WORKFLOW_RUNS_TYPE = "workflow_runs";
+const WORKFLOW_CATALOG_TYPE = "workflow_catalog";
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/catalogStore.ts
+const catalog = defineSessionStore({
+	cwd: "",
+	workflows: [],
+	warning: void 0,
+	open: false,
+	filter: "",
+	prompt: "",
+	selected: void 0,
+	inspected: void 0,
+	launch: void 0
+});
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function openCatalog(sessionId, prompt = "") {
+	catalog.update(sessionId, (current) => ({
+		...current,
+		open: true,
+		prompt
+	}));
+}
+/** Opens the Workflow picker with context supplied by another installed plugin. */
+function openWorkflowCatalogForContext(context) {
+	if (context.sessionId === null) return;
+	openCatalog(context.sessionId, context.item.content);
+}
+function closeCatalog(sessionId) {
+	catalog.update(sessionId, (current) => ({
+		...current,
+		open: false,
+		prompt: "",
+		launch: void 0
+	}));
+}
+function setCatalogFilter(sessionId, filter) {
+	catalog.update(sessionId, (current) => ({
+		...current,
+		filter
+	}));
+}
+function selectWorkflow(sessionId, path) {
+	catalog.update(sessionId, (current) => ({
+		...current,
+		selected: path
+	}));
+}
+function toggleInspect(sessionId, path) {
+	catalog.update(sessionId, (current) => ({
+		...current,
+		inspected: current.inspected === path ? void 0 : path
+	}));
+}
+function openLaunch(sessionId, path) {
+	catalog.update(sessionId, (current) => ({
+		...current,
+		selected: path,
+		launch: path
+	}));
+}
+function closeLaunch(sessionId) {
+	catalog.update(sessionId, (current) => ({
+		...current,
+		launch: void 0
+	}));
+}
+/** Rows whose name, path, tag or job matches the filter, case-insensitively. */
+function filterCatalog(workflows, filter) {
+	const needle = filter.trim().toLowerCase();
+	if (needle === "") return [...workflows];
+	return workflows.filter((workflow) => [
+		workflow.name,
+		workflow.relativePath,
+		workflow.description,
+		...workflow.tags,
+		...workflow.jobs.map((job) => job.name)
+	].join("\n").toLowerCase().includes(needle));
+}
+/** The plugin's catalog channel: 'workflow_catalog' payloads into the store. */
+const workflowCatalogChannel = catalog.channel({
+	channel: WORKFLOW_CATALOG_TYPE,
+	parse(input) {
+		if (!isRecord$2(input) || typeof input.cwd !== "string" || !Array.isArray(input.workflows)) return null;
+		return {
+			cwd: input.cwd,
+			workflows: input.workflows.filter(isRecord$2),
+			...typeof input.warning === "string" ? { warning: input.warning } : {}
+		};
+	},
+	reduce(current, payload) {
+		const paths = new Set(payload.workflows.map((workflow) => workflow.path));
+		return {
+			...current,
+			cwd: payload.cwd,
+			workflows: payload.workflows,
+			warning: payload.warning,
+			selected: current.selected !== void 0 && paths.has(current.selected) ? current.selected : void 0,
+			inspected: current.inspected !== void 0 && paths.has(current.inspected) ? current.inspected : void 0,
+			launch: current.launch !== void 0 && paths.has(current.launch) ? current.launch : void 0
+		};
+	}
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/runDuration.ts
+/**
+* Local copy of the host's formatRunDuration (src/web/lib/sessionSummary.ts):
+* this plugin keeps zero host-lib imports so its later move into the owning
+* package is a file relocation.
+*/
+const MINUTE_MS = 6e4;
+const HOUR_MS = 60 * MINUTE_MS;
+function formatRunDuration(elapsedMs) {
+	if (elapsedMs < MINUTE_MS) return "<1m";
+	if (elapsedMs < HOUR_MS) return `${Math.floor(elapsedMs / MINUTE_MS)}m`;
+	const hours = Math.floor(elapsedMs / HOUR_MS);
+	const minutes = Math.floor(elapsedMs % HOUR_MS / MINUTE_MS);
+	return `${hours}h ${String(minutes).padStart(2, "0")}m`;
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/workflowActivity.ts
+const PAUSED_STATES = /* @__PURE__ */ new Set(["paused", "pause_requested"]);
+function workflowRunIdentity(run) {
+	return `${run.workspace}/${run.runKey}`;
+}
+/** Whether the session runs this workflow itself; a record from an older hub names no owner and means the viewer. */
+function ownsRun(run, sessionId) {
+	return sessionId !== null && (run.ownerSessionId ?? sessionId) === sessionId;
+}
+function toneOf(run) {
+	if (run.stage === "running") return run.executionState !== void 0 && PAUSED_STATES.has(run.executionState) ? "paused" : "running";
+	if (run.stage === "error") return "failed";
+	if (run.outcome !== void 0 && run.outcome !== "success") return run.outcome === "failed" ? "failed" : "skipped";
+	return "done";
+}
+function detailOf(run, tone) {
+	if (tone === "paused") return "paused; resume it from the owning session";
+	if (tone === "failed") return run.errorMessage ?? (run.failedJob === void 0 ? "failed" : `job '${run.failedJob}' failed`);
+	if (tone === "running") {
+		if (run.position === void 0) return "starting";
+		return run.position.step === void 0 ? run.position.job : `${run.position.job} · ${run.position.step}`;
+	}
+	return run.outcome ?? "done";
+}
+function elapsedOf(run, now) {
+	const start = Date.parse(run.startedAt);
+	if (!Number.isFinite(start)) return "";
+	const end = run.finishedAt === void 0 ? now : Date.parse(run.finishedAt);
+	return formatRunDuration(Math.max(0, (Number.isFinite(end) ? end : now) - start));
+}
+/** The hub's presented order is kept: it already puts live runs first. */
+function workflowActivityRows(runs, now, sessionId = null) {
+	return runs.map((run) => {
+		const tone = toneOf(run);
+		return {
+			identity: workflowRunIdentity(run),
+			runKey: run.runKey,
+			name: run.displayName,
+			tone,
+			elapsed: elapsedOf(run, now),
+			detail: detailOf(run, tone),
+			...run.ownerSessionId === void 0 || run.ownerSessionId === sessionId ? {} : { ownerSessionId: run.ownerSessionId }
+		};
+	});
+}
+const GROUP_OF = {
+	running: "running",
+	paused: "running",
+	failed: "failed",
+	done: "successful",
+	skipped: "successful"
+};
+const GROUP_ORDER = [
+	"running",
+	"failed",
+	"successful"
+];
+/** Rows split by outcome, in the order the dock shows them; empty groups are dropped. */
+function workflowActivityGroups(rows) {
+	return GROUP_ORDER.map((name) => ({
+		name,
+		rows: rows.filter((row) => GROUP_OF[row.tone] === name),
+		openByDefault: name !== "successful"
+	})).filter((group) => group.rows.length > 0);
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/workflowsStore.ts
+const workflows = defineSessionStore({
+	runs: [],
+	focusedRun: void 0,
+	pendingLaunch: void 0
+});
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Points the workflows tab at one run; the activity dock uses this before opening the tab. */
+function focusRun(sessionId, identity) {
+	workflows.update(sessionId, (current) => ({
+		...current,
+		focusedRun: identity
+	}));
+}
+/** Removes a deleted run immediately while the registry channel catches up. */
+function removeRun(sessionId, identity) {
+	workflows.update(sessionId, (current) => {
+		const runs = current.runs.filter((run) => workflowRunIdentity(run) !== identity);
+		return {
+			...current,
+			runs,
+			focusedRun: current.focusedRun === identity ? runs[0] === void 0 ? void 0 : workflowRunIdentity(runs[0]) : current.focusedRun
+		};
+	});
+}
+/**
+* Sends a launch line to the session and remembers what was already running.
+*
+* The cockpit's only channel to a session is a prompt frame, so a launch is
+* the verb the extension registers for exactly this; see web/launchLine.ts.
+*/
+function requestLaunch(send, sessionId, line, workflowPath) {
+	send(sessionId, {
+		type: "prompt",
+		message: line
+	});
+	workflows.update(sessionId, (current) => ({
+		...current,
+		pendingLaunch: {
+			workflowPath,
+			knownRuns: current.runs.map(workflowRunIdentity)
+		}
+	}));
+}
+/** The plugin's session data channel: 'workflow_runs' payloads into the store. */
+const workflowRunsChannel = workflows.channel({
+	channel: WORKFLOW_RUNS_TYPE,
+	parse(input) {
+		if (!isRecord$1(input) || !Array.isArray(input.runs)) return null;
+		return { runs: input.runs.filter(isRecord$1) };
+	},
+	reduce: (current, { runs }) => {
+		const pending = current.pendingLaunch;
+		if (pending === void 0) return {
+			...current,
+			runs
+		};
+		const known = new Set(pending.knownRuns);
+		const arrived = runs.find((run) => !known.has(workflowRunIdentity(run)));
+		if (arrived === void 0) return {
+			...current,
+			runs
+		};
+		return {
+			...current,
+			runs,
+			focusedRun: workflowRunIdentity(arrived),
+			pendingLaunch: void 0
+		};
+	}
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/_components/WorkflowsActivitySection.tsx
+const TICK_MS$1 = 1e4;
+const TONE_DOT = {
+	running: "yellow",
+	paused: "yellow",
+	failed: "red",
+	done: "green",
+	skipped: "muted"
+};
+const TONE_DETAIL = {
+	running: "text-doom-dim",
+	paused: "text-doom-yellow",
+	failed: "text-doom-red",
+	done: "text-doom-dim",
+	skipped: "text-doom-dim"
+};
+const GROUP_LABEL = {
+	running: "text-doom-yellow",
+	failed: "text-doom-red",
+	successful: "text-doom-green"
+};
+/**
+* The workflows group's body in the activity dock: every run this session
+* started, split into running, failed and successful.
+*
+* A session keeps its whole history, so the groups fold: failures open because
+* they are the only ones that need an answer, and the rest stay out of the way
+* until somebody asks. Idle offers the catalog instead of saying nothing.
+*/
+function WorkflowsActivitySection({ sessionId, openSession }) {
+	const runs = useStore(workflows.store, (state) => workflows.select(state, sessionId).runs);
+	const [now, setNow] = useState(() => Date.now());
+	const [folded, setFolded] = useState({});
+	useEffect(() => {
+		const timer = setInterval(() => setNow(Date.now()), TICK_MS$1);
+		return () => clearInterval(timer);
+	}, []);
+	const groups = workflowActivityGroups(workflowActivityRows(runs, now, sessionId));
+	if (groups.length === 0) return /* @__PURE__ */ jsxs("div", {
+		className: "flex flex-wrap items-center gap-x-4 gap-y-1",
+		children: [/* @__PURE__ */ jsx("p", {
+			"data-testid": "activity-summary-workflows",
+			className: "text-sm text-doom-dim",
+			children: "Idle"
+		}), /* @__PURE__ */ jsxs(Button, {
+			variant: "link",
+			size: "sm",
+			"data-testid": "activity-workflow-launch",
+			className: "h-auto gap-1 px-0 text-doom-green",
+			onClick: () => {
+				if (sessionId === null) return;
+				openCatalog(sessionId);
+			},
+			children: ["Launch a workflow", /* @__PURE__ */ jsx(ArrowRightIcon, {
+				"aria-hidden": true,
+				className: "size-3.5"
+			})]
+		})]
+	});
+	const RunRow = ({ row }) => {
+		const delegated = row.ownerSessionId !== void 0 && openSession !== void 0;
+		return /* @__PURE__ */ jsxs(Button, {
+			variant: "ghost",
+			size: "card",
+			"data-testid": `activity-workflow-${row.runKey}`,
+			"data-run-tone": row.tone,
+			"data-delegated": delegated,
+			title: delegated ? "open its workflow session" : "show this run in the workflow dock",
+			onClick: () => {
+				if (row.ownerSessionId !== void 0 && openSession !== void 0) {
+					openSession(row.ownerSessionId);
+					return;
+				}
+				if (sessionId !== null) focusRun(sessionId, row.identity);
+			},
+			className: "min-w-0 gap-0.5 rounded-md px-1 py-1 hover:bg-doom-panel",
+			children: [/* @__PURE__ */ jsxs("span", {
+				className: "flex min-w-0 items-center gap-1.5",
+				children: [
+					/* @__PURE__ */ jsx(Dot, {
+						tone: TONE_DOT[row.tone],
+						pulse: row.tone === "running"
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: `min-w-0 flex-1 truncate text-base font-semibold ${row.tone === "running" || row.tone === "paused" ? "text-doom-hi" : "text-doom-dim"}`,
+						children: row.name
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: "shrink-0 text-sm text-doom-dim",
+						children: row.elapsed
+					})
+				]
+			}), /* @__PURE__ */ jsx("span", {
+				className: `truncate pl-3 text-sm ${TONE_DETAIL[row.tone]}`,
+				children: row.detail
+			})]
+		});
+	};
+	return /* @__PURE__ */ jsx("div", {
+		"data-testid": "activity-workflow-runs",
+		className: "flex flex-col gap-0.5",
+		children: groups.map((group) => {
+			const open = folded[group.name] ?? group.openByDefault;
+			return /* @__PURE__ */ jsxs("div", {
+				className: "flex flex-col gap-0.5",
+				children: [/* @__PURE__ */ jsxs(Button, {
+					variant: "ghost",
+					size: "xs",
+					"data-testid": `activity-workflow-group-${group.name}`,
+					"data-open": open,
+					"aria-expanded": open,
+					onClick: () => setFolded((current) => ({
+						...current,
+						[group.name]: !open
+					})),
+					className: "justify-start gap-1.5 rounded-md px-1 py-0.5 hover:bg-doom-panel",
+					children: [
+						open ? /* @__PURE__ */ jsx(ChevronDownIcon, { className: "h-2.5 w-2.5 text-doom-faint" }) : /* @__PURE__ */ jsx(ChevronRightIcon, { className: "h-2.5 w-2.5 text-doom-faint" }),
+						/* @__PURE__ */ jsx("span", {
+							className: `inline-block text-sm font-semibold first-letter:uppercase ${GROUP_LABEL[group.name]}`,
+							children: group.name
+						}),
+						/* @__PURE__ */ jsx("span", {
+							className: "text-2xs text-doom-faint",
+							children: group.rows.length
+						})
+					]
+				}), open ? /* @__PURE__ */ jsx("div", {
+					className: "flex flex-col gap-0.5 pl-2",
+					children: group.rows.map((row) => /* @__PURE__ */ jsx(RunRow, { row }, row.identity))
+				}) : /* @__PURE__ */ jsxs("span", {
+					className: "truncate pl-5 text-sm text-doom-dim",
+					children: [group.rows.slice(0, 2).map((row) => row.name).join(", "), group.rows.length > 2 ? `, and ${group.rows.length - 2} more` : ""]
+				})]
+			}, group.name);
+		})
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/_lib/workflowToolRender.ts
+const COLLAPSED_CATALOG_ROWS = 6;
+const COLLAPSED_DETAIL_LINES = 8;
+const WORKFLOW_TOOL_NAMES = [
+	"list_workflows",
+	"launch_workflow",
+	"workflow_run",
+	"workflow_tools"
+];
+function asRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	return value;
+}
+function inlineText(value) {
+	let normalized = "";
+	for (const character of value) {
+		const code = character.codePointAt(0) ?? 0;
+		normalized += code <= 31 || code === 127 ? " " : character;
+	}
+	return normalized.replace(/\s+/gu, " ").trim();
+}
+function readString(record, key) {
+	const value = record?.[key];
+	if (typeof value !== "string") return void 0;
+	return inlineText(value) || void 0;
+}
+function readNumber(record, key) {
+	const value = record?.[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readBoolean(record, key) {
+	const value = record?.[key];
+	return typeof value === "boolean" ? value : void 0;
+}
+function readStringArray(record, key) {
+	const value = record?.[key];
+	if (!Array.isArray(value)) return [];
+	return value.filter((item) => typeof item === "string");
+}
+function parseJsonRecord(text) {
+	if (!text) return void 0;
+	try {
+		return asRecord(JSON.parse(text));
+	} catch {
+		return;
+	}
+}
+function textBlocks(result) {
+	if (!result) return [];
+	return result.content.flatMap((item) => {
+		const record = asRecord(item);
+		return record?.type === "text" && typeof record.text === "string" ? [record.text] : [];
+	});
+}
+function detailLines(result) {
+	return textBlocks(result).flatMap((block) => block.split("\n")).map((entry) => entry.trimEnd()).filter((entry) => entry.length > 0);
+}
+function firstPayload(result) {
+	return parseJsonRecord(textBlocks(result)[0]);
+}
+function plural(count, singular, pluralForm = `${singular}s`) {
+	return count === 1 ? singular : pluralForm;
+}
+function line(text, tone, extra = {}) {
+	return {
+		text,
+		tone,
+		...extra
+	};
+}
+function labelValue(label, value) {
+	return line(`${label} ${value}`, "text");
+}
+function hiddenLine(hidden) {
+	return line(`… ${hidden} more`, "dim");
+}
+function targetScope(args) {
+	const runKey = readString(args, "runKey");
+	if (!runKey) return void 0;
+	const workspace = readString(args, "workspace");
+	return workspace ? `${workspace}/${runKey}` : runKey;
+}
+function toolAction(toolName, args) {
+	if (toolName === "list_workflows") return "list";
+	if (toolName === "launch_workflow") return "launch";
+	return readString(args, "action") ?? "run";
+}
+function toolTarget(toolName, args) {
+	if (toolName === "list_workflows") return readString(args, "directory");
+	if (toolName === "launch_workflow") return readString(args, "workflowPath");
+	return targetScope(args);
+}
+function statusTimestamp(value) {
+	return value.replace("T", " ").replace(/\.\d{3}Z$/, "Z");
+}
+function workflowNameFromPath(path) {
+	if (!path) return "workflow";
+	const filename = path.split("/").at(-1) ?? path;
+	return filename.replace(/\.workflow\.ya?ml$/u, "") || filename;
+}
+function callMetadata(toolName, args) {
+	const values = [];
+	if (toolName === "list_workflows") {
+		const page = readNumber(args, "page");
+		const pageSize = readNumber(args, "pageSize");
+		if (page !== void 0) values.push(`page ${page}`);
+		if (pageSize !== void 0) values.push(`${pageSize}/page`);
+		if (readString(args, "filter")) values.push("filtered");
+		const tags = readStringArray(args, "tags");
+		if (tags.length > 0) values.push(`${tags.length} ${plural(tags.length, "tag")}`);
+	} else if (toolName === "launch_workflow") {
+		const job = readString(args, "job");
+		const runner = readString(args, "runner");
+		const workspace = readString(args, "workspace");
+		const inputCount = Object.keys(asRecord(args.inputs) ?? {}).length;
+		const environmentCount = Object.keys(asRecord(args.env) ?? {}).length;
+		if (workspace) values.push(`workspace ${workspace}`);
+		if (job) values.push(`job ${job}`);
+		if (runner) values.push(`runner ${runner}`);
+		if (readBoolean(args, "dryRun")) values.push("dry run");
+		if (readString(args, "prompt")) values.push("with prompt");
+		if (inputCount > 0) values.push(`${inputCount} ${plural(inputCount, "input")}`);
+		if (environmentCount > 0) values.push(`${environmentCount} env`);
+	} else {
+		if (readString(args, "expectedRunId")) values.push("generation checked");
+		if (readString(args, "reason")) values.push("with reason");
+		if (readBoolean(args, "dryRun")) values.push("dry run");
+		if (readString(args, "job")) values.push("job override");
+		if (readString(args, "runner")) values.push("runner override");
+	}
+	return values;
+}
+/** The header beside the tool name: action, target, and the call's flags. */
+function workflowCallSummary(toolName, args) {
+	const target = toolTarget(toolName, args);
+	return {
+		action: toolAction(toolName, args),
+		...target === void 0 ? {} : { target },
+		metadata: callMetadata(toolName, args)
+	};
+}
+function parseCatalog(payload) {
+	if (!Array.isArray(payload?.workflows)) return void 0;
+	const workflows = payload.workflows.flatMap((value) => {
+		const record = asRecord(value);
+		const path = readString(record, "path");
+		if (!record || !path) return [];
+		return [{
+			description: readString(record, "description") ?? "",
+			name: readString(record, "name") ?? "",
+			path,
+			tags: readStringArray(record, "tags")
+		}];
+	});
+	const tags = Array.isArray(payload.tags) ? payload.tags.flatMap((value) => {
+		const record = asRecord(value);
+		const tag = readString(record, "tag");
+		const count = readNumber(record, "count");
+		return tag && count !== void 0 ? [{
+			count,
+			tag
+		}] : [];
+	}) : [];
+	const directory = readString(payload, "directory");
+	return {
+		...directory === void 0 ? {} : { directory },
+		page: readNumber(payload, "page") ?? 1,
+		pageSize: readNumber(payload, "pageSize") ?? workflows.length,
+		tags,
+		total: readNumber(payload, "total") ?? workflows.length,
+		totalPages: readNumber(payload, "totalPages") ?? (workflows.length > 0 ? 1 : 0),
+		workflows
+	};
+}
+function catalogItemLines(item, expanded) {
+	const lines = [line(`› ${item.name || workflowNameFromPath(item.path)} · ${item.path}`, "text")];
+	if (!expanded) return lines;
+	if (item.description) lines.push(line(item.description, "muted", { indent: true }));
+	if (item.tags.length > 0) lines.push(line(`tags ${item.tags.join(", ")}`, "dim", { indent: true }));
+	return lines;
+}
+function catalogLines(result, options) {
+	const catalog = parseCatalog(firstPayload(result));
+	if (!catalog) return void 0;
+	const pageLabel = `page ${catalog.page}/${catalog.totalPages}`;
+	const summary = line(`${catalog.total > 0 ? "✓" : "○"} ${catalog.total} ${plural(catalog.total, "workflow")} · ${pageLabel}`, "hi", { bold: true });
+	const shown = options.expanded ? catalog.workflows : catalog.workflows.slice(0, COLLAPSED_CATALOG_ROWS);
+	const lines = [summary, ...shown.flatMap((item) => catalogItemLines(item, options.expanded))];
+	const hidden = catalog.workflows.length - shown.length;
+	if (hidden > 0) lines.push(hiddenLine(hidden));
+	if (options.expanded) {
+		if (catalog.tags.length > 0) {
+			const tags = catalog.tags.map(({ count, tag }) => `${tag} (${count})`).join(", ");
+			lines.push(labelValue("available tags", tags));
+		}
+		if (catalog.directory) lines.push(labelValue("directory", catalog.directory));
+		lines.push(labelValue("page size", String(catalog.pageSize)));
+	}
+	return lines;
+}
+function readWorkflowState(record) {
+	const stage = readString(record, "effectiveStage") ?? readString(record, "stage") ?? "unknown";
+	const outcome = readString(record, "effectiveOutcome") ?? readString(record, "outcome");
+	const executionState = readString(record, "executionState");
+	if (outcome === "interrupted") return {
+		tone: "warning",
+		glyph: "!",
+		label: "interrupted"
+	};
+	if (stage === "error" || outcome === "failed") return {
+		tone: "error",
+		glyph: "✗",
+		label: "failed"
+	};
+	if (stage === "completed" && outcome === "skipped") return {
+		tone: "muted",
+		glyph: "○",
+		label: "skipped"
+	};
+	if (stage === "completed") return {
+		tone: "success",
+		glyph: "✓",
+		label: "completed"
+	};
+	if (executionState === "paused") return {
+		tone: "warning",
+		glyph: "Ⅱ",
+		label: "paused"
+	};
+	if (executionState === "pause_requested") return {
+		tone: "warning",
+		glyph: "◐",
+		label: "pause requested"
+	};
+	if (executionState === "resume_requested") return {
+		tone: "warning",
+		glyph: "◐",
+		label: "resume requested"
+	};
+	if (stage === "running") return {
+		tone: "accent",
+		glyph: "◐",
+		label: "running"
+	};
+	return {
+		tone: "muted",
+		glyph: "○",
+		label: stage
+	};
+}
+function currentActivity(record) {
+	const position = asRecord(record.position);
+	const cursor = asRecord(record.executionCursor);
+	const job = readString(position, "job") ?? readString(cursor, "job") ?? readString(record, "job");
+	const step = readString(position, "step") ?? readString(cursor, "stepName");
+	const phase = readString(cursor, "phase");
+	if (!job && !step && !phase) return void 0;
+	return line(`[${job ?? phase ?? "workflow"}] ${step ?? phase ?? "current job"}`, "text", { indent: true });
+}
+function launcherLabel(record) {
+	const launcher = asRecord(record.launcher);
+	const type = readString(launcher, "type");
+	if (!type) return void 0;
+	const identity = readString(launcher, "sessionName") ?? readString(launcher, "workspaceId");
+	return identity ? `${type} ${identity}` : type;
+}
+function workflowRecordLines(record, expanded) {
+	const runKey = readString(record, "runKey");
+	const stage = readString(record, "stage");
+	if (!runKey || !stage) return void 0;
+	const state = readWorkflowState(record);
+	const lines = [
+		line(`Status retrieved · ${readString(record, "displayName") ?? runKey} · workflow: ${state.label}`, state.tone, { bold: true }),
+		labelValue("workspace", readString(record, "workspace") ?? "unknown"),
+		labelValue("runKey", runKey)
+	];
+	const activity = currentActivity(record);
+	if (activity) lines.push(activity);
+	const failure = readString(record, "errorMessage") ?? readString(record, "failureReason");
+	if (failure) lines.push(line(`error ${failure}`, "error"));
+	const staleReason = readString(record, "staleReason");
+	if (staleReason) lines.push(line(`stale ${staleReason}`, "warning"));
+	const startedAt = readString(record, "startedAt");
+	const exitCode = readNumber(record, "exitCode");
+	const conciseMetadata = [
+		readString(record, "runner") ? `runner ${readString(record, "runner")}` : void 0,
+		readBoolean(record, "dryRun") ? "dry run" : void 0,
+		exitCode !== void 0 ? `exit ${exitCode}` : void 0,
+		startedAt ? `started ${statusTimestamp(startedAt)}` : void 0
+	].filter((value) => !!value);
+	if (conciseMetadata.length > 0) lines.push(line(conciseMetadata.join(" · "), "dim"));
+	if (!expanded) return lines;
+	const finishedAt = readString(record, "finishedAt");
+	const repairId = readString(record, "activeRepairId");
+	const detailedValues = [
+		["workflow", readString(record, "workflowPath")],
+		["workflow id", readString(record, "workflowId")],
+		["run id", readString(record, "runId")],
+		["launcher", launcherLabel(record)],
+		["job", readString(record, "job")],
+		["outcome", readString(record, "effectiveOutcome") ?? readString(record, "outcome")],
+		["finished", finishedAt ? statusTimestamp(finishedAt) : void 0],
+		["pid", readNumber(record, "pid")?.toString()],
+		["repair", repairId ? `#${repairId}` : void 0],
+		["worktree", readString(record, "worktreeBranch") ?? readString(record, "worktreePath")]
+	];
+	for (const [label, value] of detailedValues) if (value) lines.push(labelValue(label, value));
+	const jobs = record.jobs;
+	if (Array.isArray(jobs)) for (const value of jobs) {
+		const job = asRecord(value);
+		const name = readString(job, "name");
+		const status = readString(job, "status");
+		if (!name || !status) continue;
+		lines.push(labelValue("job", `${name} · ${status}`));
+		if (!Array.isArray(job?.steps)) continue;
+		for (const value of job.steps) {
+			const step = asRecord(value);
+			const stepName = readString(step, "name");
+			const stepStatus = readString(step, "status");
+			if (stepName && stepStatus) lines.push(line(`step ${stepName} · ${stepStatus}`, "text", { indent: true }));
+		}
+	}
+	return lines;
+}
+function statusLines(result, options) {
+	const payload = firstPayload(result);
+	if (!payload) return void 0;
+	return workflowRecordLines(payload, options.expanded);
+}
+function nestedRequestedAt(payload) {
+	return readString(asRecord(payload?.request), "requestedAt") ?? readString(payload, "requestedAt");
+}
+function controlLines(action, args, result, options) {
+	const payload = firstPayload(result);
+	const scope = targetScope(args) ?? readString(payload, "runKey") ?? "workflow";
+	const payloadWorkspace = readString(payload, "workspace");
+	const lines = [line(`◐ ${action} requested · ${payloadWorkspace && !scope.includes("/") ? `${payloadWorkspace}/${scope}` : scope}`, "warning", { bold: true })];
+	const requestedAt = nestedRequestedAt(payload);
+	if (requestedAt) lines.push(labelValue("requested", statusTimestamp(requestedAt)));
+	if (options.expanded) lines.push(line("verify the transition with workflow_run status", "dim"));
+	return lines;
+}
+function matchLine(text, pattern) {
+	return text.match(pattern)?.[1]?.trim();
+}
+function launchSummary(text, args) {
+	const startedName = matchLine(text, /^Started (.+) in workspace .+\.$/mu);
+	const workspace = matchLine(text, /^Started .+ in workspace (.+)\.$/mu) ?? readString(args, "workspace");
+	const runKey = matchLine(text, /^Run key:\s*(.+)$/mu);
+	const path = readString(args, "workflowPath");
+	const name = startedName ?? workflowNameFromPath(path);
+	const scope = runKey ? workspace ? `${workspace}/${runKey}` : runKey : workspace ?? path ?? "workflow";
+	if (/Workflow completed successfully/iu.test(text)) return {
+		name,
+		scope,
+		state: {
+			tone: "success",
+			glyph: "✓",
+			label: "completed"
+		}
+	};
+	if (/Workflow skipped/iu.test(text)) return {
+		name,
+		scope,
+		state: {
+			tone: "muted",
+			glyph: "○",
+			label: "skipped"
+		}
+	};
+	if (/no run was registered/iu.test(text)) return {
+		name,
+		scope,
+		state: {
+			tone: "warning",
+			glyph: "◐",
+			label: "starting · run key pending"
+		}
+	};
+	return {
+		name,
+		scope,
+		state: {
+			tone: "accent",
+			glyph: "◐",
+			label: runKey ? "started" : "launch accepted"
+		}
+	};
+}
+function launchLines(args, result, options) {
+	const summary = launchSummary(textBlocks(result).join("\n"), args);
+	const lines = [line(`${summary.state.glyph} ${summary.name} · ${summary.scope} · ${summary.state.label}`, summary.state.tone, { bold: true })];
+	const metadata = [
+		readString(args, "job") ? `job ${readString(args, "job")}` : void 0,
+		readString(args, "runner") ? `runner ${readString(args, "runner")}` : void 0,
+		readBoolean(args, "dryRun") ? "dry run" : void 0
+	].filter((value) => !!value);
+	if (metadata.length > 0) lines.push(line(metadata.join(" · "), "dim"));
+	if (options.expanded) {
+		const details = detailLines(result).filter((entry) => !entry.startsWith("Next steps for the agent:"));
+		lines.push(...details.map((entry) => line(entry, "text")));
+	}
+	return lines;
+}
+function splitEvidence(text) {
+	const sections = [];
+	let current;
+	for (const entry of text.split("\n")) {
+		const match = entry.match(/^--- (.+) ---$/u);
+		if (match?.[1]) {
+			current = {
+				body: [],
+				name: match[1]
+			};
+			sections.push(current);
+			continue;
+		}
+		current?.body.push(entry);
+	}
+	return sections;
+}
+function recoveryEvidenceLines(args, result, options) {
+	const sections = splitEvidence(textBlocks(result).join("\n"));
+	const record = parseJsonRecord(sections.find((section) => section.name === "run.json")?.body.join("\n"));
+	const recordLines = record ? workflowRecordLines(record, options.expanded) : void 0;
+	const evidenceSections = sections.filter((section) => section.name !== "run.json");
+	const scope = targetScope(args) ?? "workflow";
+	const lines = recordLines ?? [line(`✓ recovery evidence · ${scope}`, "success", { bold: true })];
+	const names = evidenceSections.map((section) => section.name);
+	lines.push(names.length > 0 ? labelValue("evidence", names.join(", ")) : line("no durable evidence files recorded", "muted"));
+	if (options.expanded) for (const section of evidenceSections) {
+		lines.push(line(section.name, "hi", { bold: true }));
+		lines.push(...section.body.filter((entry) => entry.length > 0).map((entry) => line(entry, "text")));
+	}
+	return lines;
+}
+function simpleActionLines(action, args, result, options) {
+	const scope = targetScope(args) ?? "workflow";
+	const actionLabel = {
+		follow: "following output",
+		open: "launcher opened",
+		recover: readBoolean(args, "dryRun") ? "recovery dry run finished" : "recovery accepted",
+		tail: "launcher output checked"
+	};
+	const state = action === "recover" ? {
+		tone: "accent",
+		glyph: "◐",
+		label: actionLabel[action] ?? action
+	} : {
+		tone: "success",
+		glyph: "✓",
+		label: actionLabel[action] ?? action
+	};
+	const lines = [line(`${state.glyph} ${state.label} · ${scope}`, state.tone, { bold: true })];
+	const details = detailLines(result);
+	if (action === "tail") {
+		const workflowLine = details.find((entry) => entry.startsWith("Workflow:"));
+		const stageLine = details.find((entry) => entry.startsWith("Stage:"));
+		if (workflowLine) lines.push(line(workflowLine, "text"));
+		if (stageLine) lines.push(line(stageLine, "text"));
+	}
+	if (options.expanded) lines.push(...details.map((entry) => line(entry, "text")));
+	return lines;
+}
+function failureLines(toolName, args, result, options) {
+	const action = toolAction(toolName, args);
+	const target = toolTarget(toolName, args);
+	const details = detailLines(result);
+	const shown = options.expanded ? details : details.slice(0, COLLAPSED_DETAIL_LINES);
+	const lines = [line(toolName === "workflow_run" && action === "status" ? `✗ Status lookup failed${target ? ` · ${target}` : ""}` : `✗ ${action} failed${target ? ` · ${target}` : ""}`, "error", { bold: true }), ...shown.length > 0 ? shown.map((entry) => line(entry, "text")) : [line("Unknown workflow error", "error")]];
+	const hidden = details.length - shown.length;
+	if (hidden > 0) lines.push(hiddenLine(hidden));
+	return lines;
+}
+function partialLines(toolName, args, result) {
+	const details = detailLines(result);
+	const shown = details.slice(-4);
+	const action = toolAction(toolName, args);
+	const target = toolTarget(toolName, args);
+	const hidden = details.length - shown.length;
+	const lines = [line(`◐ ${action}${target ? ` · ${target}` : ""}`, "accent", { bold: true })];
+	if (hidden > 0) lines.push(line(`… ${hidden} earlier`, "dim"));
+	lines.push(...shown.map((entry) => line(entry, "text")));
+	return lines;
+}
+function fallbackLines(result, options) {
+	const details = detailLines(result);
+	if (details.length === 0) return [line("No workflow output.", "muted")];
+	const shown = options.expanded ? details : details.slice(0, COLLAPSED_DETAIL_LINES);
+	const lines = shown.map((entry) => line(entry, "text"));
+	const hidden = details.length - shown.length;
+	if (hidden > 0) lines.push(hiddenLine(hidden));
+	return lines;
+}
+/** The body of a workflow tool card, chosen by tool, action, and result shape. */
+function workflowResultLines(toolName, args, result, options) {
+	if (options.isPartial) return partialLines(toolName, args, result);
+	if (options.isError) return failureLines(toolName, args, result, options);
+	if (toolName === "list_workflows") return catalogLines(result, options) ?? fallbackLines(result, options);
+	if (toolName === "launch_workflow") return launchLines(args, result, options);
+	const action = readString(args, "action");
+	if (action === "status") return statusLines(result, options) ?? fallbackLines(result, options);
+	if (action === "pause" || action === "resume" || action === "stop") return controlLines(action, args, result, options);
+	if (action === "recovery-evidence") return recoveryEvidenceLines(args, result, options);
+	if (action === "follow" || action === "open" || action === "recover" || action === "tail") return simpleActionLines(action, args, result, options);
+	return fallbackLines(result, options);
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/_components/WorkflowToolMessage.tsx
+function workflowToolName(name) {
+	return WORKFLOW_TOOL_NAMES.includes(name) ? name : "workflow_run";
+}
+/**
+* The workflow tools' timeline item, the web analog of renderWorkflowToolCall
+* and renderWorkflowToolResult: `action · target · flags` in the header and
+* the shape-specific summary lines in the body.
+*/
+function WorkflowToolMessage({ toolName, args, result, running, isError }) {
+	const name = workflowToolName(toolName);
+	const summary = workflowCallSummary(name, args);
+	const collapsed = workflowResultLines(name, args, result, {
+		expanded: false,
+		isError,
+		isPartial: running
+	});
+	const full = workflowResultLines(name, args, result, {
+		expanded: true,
+		isError,
+		isPartial: running
+	});
+	return /* @__PURE__ */ jsx(MessageItem, {
+		tone: toolTone({
+			running,
+			isError
+		}),
+		expandable: full.length > collapsed.length,
+		children: ({ expanded }) => /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(MessageItemHeader, {
+			title: toolName,
+			children: /* @__PURE__ */ jsxs("span", {
+				"data-testid": `tool-call-${toolName}`,
+				className: "flex min-w-0 flex-1 items-center gap-2",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						className: "font-semibold text-doom-hi",
+						children: summary.action
+					}),
+					summary.target ? /* @__PURE__ */ jsx("span", {
+						className: "min-w-0 truncate text-doom-dim",
+						children: summary.target
+					}) : null,
+					summary.metadata.map((value) => /* @__PURE__ */ jsxs("span", {
+						className: "shrink-0 text-doom-dim",
+						children: ["· ", value]
+					}, value))
+				]
+			})
+		}), (expanded ? full : collapsed).length > 0 ? /* @__PURE__ */ jsx(MessageItemBody, {
+			"data-testid": `tool-result-${toolName}`,
+			children: /* @__PURE__ */ jsx(MessageLines, { lines: expanded ? full : collapsed })
+		}) : null] })
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/index.ts
+const WORKFLOWS_GROUP = {
+	key: "w",
+	label: "workflows",
+	detail: "multi-step agent runs"
+};
+var _lib_default = {
+	channels: [workflowRunsChannel, workflowCatalogChannel],
+	contextActions: [{
+		id: "launch-workflow",
+		label: "Launch Workflow",
+		detail: "Choose a workflow, review its inputs, then launch it.",
+		kinds: ["work-item"],
+		order: 20,
+		run: (context) => openWorkflowCatalogForContext(context)
+	}],
+	minorModes: [{
+		name: "workflow",
+		keys: "w e",
+		widgetKey: "workflow-mcp-progress",
+		order: 50
+	}],
+	activityGroups: [{
+		name: "workflows",
+		keys: "w r",
+		icon: WorkflowIcon,
+		widgetKeys: ["workflow-mcp-progress", "workflow-mcp-follow"],
+		activeSource: {
+			subscribe(listener) {
+				const subscription = workflows.store.subscribe(listener);
+				return () => subscription.unsubscribe();
+			},
+			isActive(sessionId) {
+				return workflows.select(workflows.store.state, sessionId).runs.some((run) => run.stage === "running");
+			}
+		},
+		order: 30
+	}],
+	activitySections: [{
+		id: "workflows",
+		component: WorkflowsActivitySection
+	}],
+	toolRenderers: [{
+		tools: [
+			"list_workflows",
+			"launch_workflow",
+			"workflow_run",
+			"workflow_tools"
+		],
+		message: WorkflowToolMessage
+	}],
+	leaderBindings: [{
+		id: "doom-workflow.catalog",
+		path: [WORKFLOWS_GROUP, {
+			key: "l",
+			label: "launch",
+			detail: "pick a workflow and launch it"
+		}],
+		run: (context) => {
+			if (context.sessionId !== null) openCatalog(context.sessionId);
+		}
+	}, {
+		id: "doom-workflow.toggle",
+		path: [WORKFLOWS_GROUP, {
+			key: "e",
+			label: "toggle",
+			detail: "give the agent workflow tools or take them back"
+		}],
+		command: "minor workflow"
+	}]
+};
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/action/launch-workflow.web.ts
+var launch_workflow_web_default = defineContextAction(_lib_default.contextActions[0]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/activity-group/workflows.web.ts
+var workflows_web_default = defineActivityGroup(_lib_default.activityGroups[0]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/channel/workflow-catalog.web.ts
+var workflow_catalog_web_default = defineChannelFile(_lib_default.channels[1]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/channel/workflow-runs.web.ts
+var workflow_runs_web_default = defineChannelFile(_lib_default.channels[0]);
+//#endregion
+//#region src/types/apiRoutes.ts
+/**
+* This package's routes, as data.
+*
+* No scope and no base path. The build reads both off
+* `src/extensions/(backend)/api/workflow/`, so the mount is stated once, by the
+* folder that creates it. The same API answers at all three scopes, because a
+* global contribution cascades into workspace and session; the folder under
+* `workspaces/sessions/` only re-mounts it for a session's own server.
+*
+* This is the one file the routes, the Hono app and the browser all read, so a
+* path cannot move on one side alone. The page used to build the hub's own
+* absolute URL and then rewrite its plugin prefix with String.replace to reach
+* a session, which is exactly the kind of copy that can move by one character
+* without anything noticing.
+*
+* `:workspace` and `:runKey` are Hono's own parameter syntax, because the app
+* registers `path` verbatim.
+*/
+/** 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";
+const ARTIFACT_DOWNLOAD_PARAM = "download";
+var apiRoutes_default = defineApiRoutes({
+	/**
+	* The terminal, as server-sent events.
+	*
+	* `stream: true` gets a URL and no call method: the consumer is the browser's
+	* own `EventSource`, and a relayed call would buffer a stream that never ends.
+	*/
+	screen: {
+		method: "GET",
+		path: `${RUN}/screen/stream`,
+		query: [STEP_TARGET_PARAM],
+		stream: true
+	},
+	control: {
+		method: "POST",
+		path: `${RUN}/control`,
+		response: apiResponse()
+	},
+	keys: {
+		method: "POST",
+		path: `${RUN}/keys`
+	},
+	resize: {
+		method: "POST",
+		path: `${RUN}/resize`,
+		response: apiResponse()
+	},
+	remove: {
+		method: "DELETE",
+		path: RUN,
+		response: apiResponse()
+	},
+	stop: {
+		method: "POST",
+		path: `${RUN}/stop`,
+		response: apiResponse()
+	},
+	/** Guidance for the agent session the running step is in, like steering a Team sub-agent. */
+	steer: {
+		method: "POST",
+		path: `${RUN}/steer`,
+		response: 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: apiResponse()
+	},
+	openRunDirectory: {
+		method: "POST",
+		path: `${RUN}/open-directory`,
+		response: apiResponse()
+	},
+	artifacts: {
+		method: "GET",
+		path: `${RUN}/artifacts`,
+		query: ["directory"],
+		response: apiResponse()
+	},
+	/** One artifact: its metadata and text, or its raw bytes under `raw=1`. */
+	artifact: {
+		method: "GET",
+		path: `${RUN}/artifacts/${ARTIFACT_NAME_PARAM}`,
+		query: ["raw", ARTIFACT_DOWNLOAD_PARAM],
+		response: apiResponse()
+	}
+});
+const api = createApiClient(apiRoutes_default, {
+	scopes: [
+		"global",
+		"workspace",
+		"session"
+	],
+	basePath: "workflow",
+	transport: (input, init) => sealedTransport.fetch(input, init),
+	sessionAddress: sessionApiAddress
+});
+//#endregion
+//#region src/types/webWorkflowTerminal.ts
+/** The SSE event name the screen stream writes. */
+const WORKFLOW_SCREEN_EVENT = "screen";
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/terminalApi.ts
+/**
+* The page's half of this package's hub API: one run's terminal and the files
+* its run directory holds.
+*
+* These are adapters now, not a transport. The generated client owns the URL
+* and the sealed transport with it, so nothing here spells a mount. What stays
+* is this package's own vocabulary: which refusals the reader is shown, and the
+* shapes the terminal expects back.
+*
+* A run belongs to its multiplexer rather than to a session, so the same API
+* answers at the hub and inside a session's own server. Passing a session id
+* addresses that session's copy and passing none addresses the hub. The deleted
+* builder made that branch the other way round: it always built the hub's
+* absolute URL, then rewrote the plugin prefix into the session's with
+* String.replace, so a session's URL was a hub URL with its head swapped.
+*/
+const UNREACHABLE = "The cockpit hub is unreachable.";
+/** The hub, or one session's own copy of it; a null session id is the hub. */
+function scoped(sessionId) {
+	return sessionId == null ? api.global : api.session(sessionId);
+}
+/** The run every route addresses, as the route table's two path parameters. */
+function runParams(workspace, runKey) {
+	return {
+		workspace,
+		runKey
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* The message a reader is shown: the route's own words, or why there were none.
+*
+* `error` is optional because an answered call that simply carried the wrong
+* shape reaches here too, and that result has no error field at all.
+*/
+function messageOf(result, fallback) {
+	if (result.status === 0) return UNREACHABLE;
+	return result.error === void 0 || result.error === "" ? fallback : result.error;
+}
+/**
+* One artifact's URL, with its path filled in.
+*
+* An artifact is named by its path inside the run directory, which Hono matches
+* as the one multi-segment parameter `:name{.+}`. The client's own `params`
+* substitution fills a single segment and percent-encodes the separating slash
+* with it, which would move every nested artifact's URL, so that one segment is
+* substituted here instead: each segment encoded, the slashes between them
+* kept. Everything left of it still comes from the client.
+*/
+function artifactUrl(scope, workspace, runKey, artifactPath, query) {
+	return scope.artifact.url({
+		params: runParams(workspace, runKey),
+		...query === void 0 ? {} : { query }
+	}).replace(ARTIFACT_NAME_PARAM, artifactPath.split("/").map(encodeURIComponent).join("/"));
+}
+/** The pane a terminal call names, when it reads one step's rather than the run's current one. */
+function stepBody(step) {
+	return step === void 0 ? {} : { step };
+}
+/**
+* Follows one run's screen until the run settles or the caller stops.
+*
+* Returns the stop function. The stream is server-sent events, so a hub that
+* restarts reconnects on its own and the page keeps painting. The route is
+* declared `stream: true`, which is why the client hands out its address and no
+* call: an `EventSource` opens it directly, and a relayed call would buffer a
+* response that never ends.
+*/
+function followScreen(workspace, runKey, onEvent, sessionId, step) {
+	const source = new EventSource(scoped(sessionId).screen.url({
+		params: runParams(workspace, runKey),
+		...step === void 0 ? {} : { query: { [STEP_TARGET_PARAM]: step } }
+	}));
+	const stop = () => {
+		source.removeEventListener(WORKFLOW_SCREEN_EVENT, handler);
+		source.close();
+	};
+	const handler = (message) => {
+		let parsed;
+		try {
+			parsed = JSON.parse(message.data);
+		} catch {
+			return;
+		}
+		if (!isRecord(parsed) || !Array.isArray(parsed.lines)) return;
+		const event = parsed;
+		onEvent(event);
+		if (event.ended === true) stop();
+	};
+	source.addEventListener(WORKFLOW_SCREEN_EVENT, handler);
+	return stop;
+}
+/** Takes the keyboard for one run, renewing when this page already holds it. */
+async function takeControl(workspace, runKey, token, sessionId, step) {
+	const result = await scoped(sessionId).control({
+		params: runParams(workspace, runKey),
+		body: {
+			token,
+			...stepBody(step)
+		}
+	});
+	if (result.status === 0) return {
+		held: false,
+		reason: UNREACHABLE
+	};
+	if (isRecord(result.data) && typeof result.data.held === "boolean") return result.data;
+	return {
+		held: false,
+		reason: messageOf(result, "The run refused the keyboard.")
+	};
+}
+async function releaseControl(workspace, runKey, token, sessionId, step) {
+	await scoped(sessionId).control({
+		params: runParams(workspace, runKey),
+		body: {
+			token,
+			release: true,
+			...stepBody(step)
+		}
+	});
+}
+/** Sends literal keystrokes; the reason comes back when the lease has moved on. */
+async function sendKeys(workspace, runKey, token, data, sessionId, step) {
+	const result = await scoped(sessionId).keys({
+		params: runParams(workspace, runKey),
+		body: {
+			token,
+			data,
+			...stepBody(step)
+		}
+	});
+	if (result.ok) return {};
+	return { error: messageOf(result, "The run would not take those keys.") };
+}
+/** Permanently removes one settled run and its run directory. */
+async function deleteWorkflowRun(workspace, runKey, sessionId) {
+	const result = await scoped(sessionId).remove({ params: runParams(workspace, runKey) });
+	if (!result.ok) return { error: messageOf(result, "The workflow could not be deleted.") };
+	if (result.data.deleted === true) return { result: { deleted: true } };
+	return { error: "The workflow hub returned an invalid deletion response." };
+}
+/** Asks the engine running a workflow to stop it; the run settles on its own shortly after. */
+async function stopWorkflowRun(workspace, runKey, sessionId) {
+	const result = await scoped(sessionId).stop({ params: runParams(workspace, runKey) });
+	if (!result.ok) return { error: messageOf(result, "The workflow could not be stopped.") };
+	if (result.data.requested === true) return { result: { requested: true } };
+	return { error: "The workflow hub returned an invalid stop response." };
+}
+/**
+* Sends guidance to the agent session a running step is in: the run's current
+* step, or `step`, the session of one step of a parallel group.
+*/
+async function steerStep(workspace, runKey, message, sessionId, step) {
+	const result = await scoped(sessionId).steer({
+		params: runParams(workspace, runKey),
+		body: step === void 0 ? { message } : {
+			message,
+			step
+		}
+	});
+	if (!result.ok) return { error: messageOf(result, "The step would not take that guidance.") };
+	if (result.data.delivered === true) return { result: { delivered: true } };
+	return { error: "The workflow hub returned an invalid steer response." };
+}
+/** Opens the current registry folder, never a browser-supplied path. */
+async function openRunDirectory(workspace, runKey, sessionId) {
+	const result = await scoped(sessionId).openRunDirectory({ params: runParams(workspace, runKey) });
+	if (!result.ok) return { error: messageOf(result, "The run folder could not be opened in Finder.") };
+	return result.data.opened === true ? {} : { error: "The workflow hub returned an invalid folder response." };
+}
+async function fetchArtifacts(workspace, runKey, sessionId, directory) {
+	const result = await scoped(sessionId).artifacts({
+		params: runParams(workspace, runKey),
+		query: { directory }
+	});
+	if (!result.ok) return { error: messageOf(result, "This run has no directory to read.") };
+	return { artifacts: result.data };
+}
+/** Trusted same-origin URL for browser-native media previews and downloads. */
+function artifactContentUrl(workspace, runKey, path, download = false, sessionId) {
+	return artifactUrl(scoped(sessionId), workspace, runKey, path, {
+		["raw"]: 1,
+		...download ? { [ARTIFACT_DOWNLOAD_PARAM]: 1 } : {}
+	});
+}
+/**
+* One artifact's metadata and text.
+*
+* The only route here that addresses itself rather than being called: its path
+* parameter spans segments, so the URL comes from `artifactUrl` and the request
+* goes over the same sealed transport the client is built on.
+*/
+async function fetchArtifact(workspace, runKey, path, sessionId) {
+	try {
+		const response = await sealedTransport.fetch(artifactUrl(scoped(sessionId), workspace, runKey, path));
+		const body = await response.json();
+		if (!response.ok) {
+			const error = isRecord(body) && typeof body.error === "string" && body.error !== "" ? body.error : "";
+			return { error: error === "" ? "That file has not been written." : error };
+		}
+		return { artifact: body };
+	} catch {
+		return { error: UNREACHABLE };
+	}
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/ArtifactsPane.tsx
+const TAB_ID_PREFIX$1 = "workflows-artifact-";
+const BYTES_PER_UNIT = 1024;
+const UNITS = [
+	"B",
+	"KB",
+	"MB"
+];
+function formatSize(bytes) {
+	if (bytes === void 0) return "";
+	let value = bytes;
+	let unit = 0;
+	while (value >= BYTES_PER_UNIT && unit < UNITS.length - 1) {
+		value /= BYTES_PER_UNIT;
+		unit += 1;
+	}
+	return `${unit === 0 ? value : value.toFixed(1)} ${UNITS[unit]}`;
+}
+function formatWhen(iso) {
+	if (iso === void 0) return "";
+	const parsed = Date.parse(iso);
+	if (!Number.isFinite(parsed)) return "";
+	return new Date(parsed).toLocaleTimeString([], {
+		hour: "2-digit",
+		minute: "2-digit"
+	});
+}
+const STATE_GLYPH = {
+	written: {
+		glyph: "✓",
+		className: "text-doom-green"
+	},
+	empty: {
+		glyph: "○",
+		className: "text-doom-yellow"
+	},
+	pending: {
+		glyph: "○",
+		className: "text-doom-faint"
+	},
+	unreadable: {
+		glyph: "!",
+		className: "text-doom-red"
+	}
+};
+function parseDelimited(text, delimiter) {
+	const rows = [];
+	let row = [];
+	let cell = "";
+	let quoted = false;
+	for (let index = 0; index <= text.length && rows.length < 500; index += 1) {
+		const character = text[index] ?? "\n";
+		if (quoted) {
+			if (character === "\"" && text[index + 1] === "\"") {
+				cell += "\"";
+				index += 1;
+			} else if (character === "\"") quoted = false;
+			else cell += character;
+		} else if (character === "\"" && cell === "") quoted = true;
+		else if (character === delimiter) {
+			row.push(cell);
+			cell = "";
+		} else if (character === "\n") {
+			row.push(cell.replace(/\r$/, ""));
+			rows.push(row);
+			row = [];
+			cell = "";
+		} else cell += character;
+	}
+	return rows;
+}
+function DelimitedPreview({ text, delimiter }) {
+	const [head = [], ...body] = parseDelimited(text, delimiter);
+	return /* @__PURE__ */ jsx("div", {
+		className: "overflow-auto",
+		children: /* @__PURE__ */ jsxs("table", {
+			"data-testid": "artifact-table",
+			className: "min-w-full border-collapse font-mono text-sm",
+			children: [/* @__PURE__ */ jsx("thead", {
+				className: "sticky top-0 bg-doom-panel text-doom-hi",
+				children: /* @__PURE__ */ jsx("tr", { children: head.map((cell, index) => /* @__PURE__ */ jsx("th", {
+					className: "border border-doom-border px-2 py-1.5 text-left font-semibold",
+					children: cell
+				}, index)) })
+			}), /* @__PURE__ */ jsx("tbody", { children: body.map((cells, rowIndex) => /* @__PURE__ */ jsx("tr", { children: cells.map((cell, cellIndex) => /* @__PURE__ */ jsx("td", {
+				className: "border border-doom-border px-2 py-1 align-top text-doom-text",
+				children: cell
+			}, cellIndex)) }, rowIndex)) })]
+		})
+	});
+}
+/** Keeps a newly built viewer compatible while an older hub process is restarting. */
+function previewMimeType(content) {
+	if (content.mimeType !== void 0) return content.mimeType;
+	const extension = content.path.split(".").pop()?.toLowerCase();
+	if (extension === "md" || extension === "markdown") return "text/markdown";
+	if (extension === "json") return "application/json";
+	if (extension === "csv") return "text/csv";
+	if (extension === "tsv") return "text/tab-separated-values";
+	if (extension === "html" || extension === "htm") return "text/html";
+	if (extension === "pdf") return "application/pdf";
+	if ([
+		"bmp",
+		"gif",
+		"ico",
+		"jpeg",
+		"jpg",
+		"png",
+		"svg",
+		"webp"
+	].includes(extension ?? "")) return "image/unknown";
+	if ([
+		"aac",
+		"m4a",
+		"mp3",
+		"oga",
+		"ogg",
+		"wav"
+	].includes(extension ?? "")) return "audio/unknown";
+	if ([
+		"mov",
+		"mp4",
+		"ogv",
+		"webm"
+	].includes(extension ?? "")) return "video/unknown";
+	return content.text === void 0 ? "application/octet-stream" : "text/plain";
+}
+function ArtifactPreview({ content, rawUrl, raw }) {
+	const text = content.text ?? "";
+	const mimeType = previewMimeType(content);
+	if (content.size === 0) return /* @__PURE__ */ jsx(EmptyState, {
+		"data-testid": "artifact-empty",
+		title: "this artifact is empty",
+		description: "The workflow created the file but did not write any content."
+	});
+	if (mimeType === "text/markdown") return raw ? /* @__PURE__ */ jsx("pre", {
+		"data-testid": "artifact-raw",
+		className: "whitespace-pre-wrap break-words font-mono text-sm leading-snug text-doom-text",
+		children: text
+	}) : /* @__PURE__ */ jsx("div", {
+		"data-testid": "artifact-markdown",
+		className: "max-w-5xl text-base text-doom-text",
+		children: /* @__PURE__ */ jsx(Markdown, { text })
+	});
+	if (mimeType === "application/json") {
+		let formatted = text;
+		try {
+			formatted = JSON.stringify(JSON.parse(text), null, 2);
+		} catch {}
+		return /* @__PURE__ */ jsx("pre", {
+			className: "whitespace-pre-wrap break-words font-mono text-sm leading-snug text-doom-text",
+			children: formatted
+		});
+	}
+	if (mimeType === "text/csv" || mimeType === "text/tab-separated-values") return /* @__PURE__ */ jsx(DelimitedPreview, {
+		text,
+		delimiter: mimeType === "text/csv" ? "," : "	"
+	});
+	if (mimeType === "text/html") return /* @__PURE__ */ jsx("iframe", {
+		"data-testid": "artifact-html",
+		title: content.path,
+		sandbox: "",
+		referrerPolicy: "no-referrer",
+		srcDoc: text,
+		className: "min-h-[520px] w-full rounded bg-white"
+	});
+	if (mimeType.startsWith("image/")) return /* @__PURE__ */ jsx("img", {
+		"data-testid": "artifact-image",
+		src: rawUrl,
+		alt: content.path,
+		className: "max-h-full max-w-full object-contain"
+	});
+	if (mimeType === "application/pdf") return /* @__PURE__ */ jsx("object", {
+		"data-testid": "artifact-pdf",
+		data: rawUrl,
+		type: "application/pdf",
+		"aria-label": "PDF artifact",
+		className: "min-h-[600px] w-full"
+	});
+	if (mimeType.startsWith("audio/")) return /* @__PURE__ */ jsx("audio", {
+		"data-testid": "artifact-audio",
+		src: rawUrl,
+		controls: true,
+		preload: "metadata",
+		className: "w-full",
+		children: /* @__PURE__ */ jsx("track", { kind: "captions" })
+	});
+	if (mimeType.startsWith("video/")) return /* @__PURE__ */ jsx("video", {
+		"data-testid": "artifact-video",
+		src: rawUrl,
+		controls: true,
+		preload: "metadata",
+		className: "max-h-full max-w-full",
+		children: /* @__PURE__ */ jsx("track", { kind: "captions" })
+	});
+	if (content.text !== void 0) return /* @__PURE__ */ jsx("pre", {
+		className: "whitespace-pre-wrap break-words font-mono text-sm leading-snug text-doom-text",
+		children: text
+	});
+	return /* @__PURE__ */ jsx(EmptyState, {
+		title: "preview unavailable",
+		description: "Download this artifact to open it with a local application."
+	});
+}
+/** One artifact, read-only, in its own tab. */
+function artifactTab(run, path) {
+	return {
+		id: `${TAB_ID_PREFIX$1}${run.workspace}-${run.runKey}-${path}`.replace(/[^\w-]+/g, "-"),
+		label: path.split("/").pop() ?? path,
+		panel: (props) => /* @__PURE__ */ jsx(ArtifactViewerPanel, {
+			...props,
+			workspace: run.workspace,
+			runKey: run.runKey,
+			path
+		})
+	};
+}
+/**
+* One artifact's text.
+*
+* Read-only and reloadable: a run keeps writing while somebody is reading, and
+* the file on the next read is the one that matters.
+*/
+function ArtifactViewerPanel({ workspace, runKey, path, sessionId }) {
+	const [content, setContent] = useState();
+	const [error, setError] = useState();
+	const [reloads, setReloads] = useState(0);
+	const [raw, setRaw] = useState(false);
+	useEffect(() => {
+		let live = true;
+		fetchArtifact(workspace, runKey, path, sessionId).then((result) => {
+			if (!live) return;
+			if ("error" in result) {
+				setError(result.error);
+				setContent(void 0);
+				return;
+			}
+			setError(void 0);
+			setContent(result.artifact);
+		});
+		return () => {
+			live = false;
+		};
+	}, [
+		workspace,
+		runKey,
+		path,
+		reloads,
+		sessionId
+	]);
+	const rawUrl = artifactContentUrl(workspace, runKey, path, false, sessionId);
+	const downloadUrl = artifactContentUrl(workspace, runKey, path, true, sessionId);
+	const mimeType = content === void 0 ? void 0 : previewMimeType(content);
+	const isMarkdown = mimeType === "text/markdown";
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "artifact-viewer",
+		className: "flex min-h-0 flex-1 flex-col px-[26px] py-[18px]",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex items-center gap-2.5 pb-3",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						className: "truncate text-base font-semibold text-doom-hi",
+						children: path
+					}),
+					/* @__PURE__ */ jsx(Badge, {
+						size: "xs",
+						children: mimeType ?? "artifact"
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: "text-sm text-doom-dim",
+						children: content === void 0 ? "" : `${formatSize(content.size)} · written ${formatWhen(content.modifiedAt)}`
+					}),
+					/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }),
+					isMarkdown ? /* @__PURE__ */ jsxs("div", {
+						className: "flex items-center",
+						children: [/* @__PURE__ */ jsx(Button, {
+							variant: raw ? "outline" : "primary",
+							size: "xs",
+							"data-testid": "artifact-rendered-toggle",
+							onClick: () => setRaw(false),
+							children: "rendered"
+						}), /* @__PURE__ */ jsx(Button, {
+							variant: raw ? "primary" : "outline",
+							size: "xs",
+							"data-testid": "artifact-raw-toggle",
+							onClick: () => setRaw(true),
+							children: "raw"
+						})]
+					}) : null,
+					/* @__PURE__ */ jsx(Button, {
+						asChild: true,
+						variant: "ghost",
+						size: "xs",
+						children: /* @__PURE__ */ jsx("a", {
+							"data-testid": "artifact-download",
+							href: downloadUrl,
+							download: true,
+							children: "download"
+						})
+					}),
+					/* @__PURE__ */ jsx(Button, {
+						variant: "ghost",
+						size: "xs",
+						"data-testid": "artifact-reload",
+						onClick: () => setReloads((count) => count + 1),
+						children: "reload"
+					})
+				]
+			}),
+			/* @__PURE__ */ jsx("div", {
+				className: "min-h-0 flex-1 overflow-auto rounded-md border border-doom-border bg-doom-deep p-4",
+				children: error !== void 0 ? /* @__PURE__ */ jsx("span", {
+					"data-testid": "artifact-error",
+					className: "text-base text-doom-yellow",
+					children: error
+				}) : content === void 0 ? /* @__PURE__ */ jsx("span", {
+					className: "text-sm text-doom-dim",
+					children: "loading preview"
+				}) : /* @__PURE__ */ jsx(ArtifactPreview, {
+					content,
+					rawUrl,
+					raw
+				})
+			}),
+			content?.truncated === true ? /* @__PURE__ */ jsxs("span", {
+				className: "pt-2 text-sm text-doom-dim",
+				children: [
+					"this preview shows the first ",
+					formatSize(content.text?.length),
+					"; download the artifact for the complete file"
+				]
+			}) : null
+		]
+	});
+}
+/** The run's file tree, including declared outputs that have not been written yet. */
+function ArtifactsPane({ run, sessionId, onOpen }) {
+	const [listing, setListing] = useState();
+	const [error, setError] = useState();
+	useEffect(() => {
+		let live = true;
+		let reading = false;
+		const read = () => {
+			if (reading) return;
+			reading = true;
+			fetchArtifacts(run.workspace, run.runKey, sessionId).then((result) => {
+				if (!live) return;
+				if ("error" in result) {
+					setError(result.error);
+					return;
+				}
+				setError(void 0);
+				setListing(result.artifacts);
+			}).finally(() => {
+				reading = false;
+			});
+		};
+		read();
+		const timer = run.stage === "running" ? setInterval(read, 5e3) : void 0;
+		return () => {
+			live = false;
+			if (timer !== void 0) clearInterval(timer);
+		};
+	}, [
+		run.workspace,
+		run.runKey,
+		run.stage,
+		sessionId
+	]);
+	return /* @__PURE__ */ jsx(ArtifactList, {
+		listing,
+		error,
+		onLoadDirectory: (directory) => fetchArtifacts(run.workspace, run.runKey, sessionId, directory),
+		onOpen,
+		onOpenDirectory: () => openRunDirectory(run.workspace, run.runKey, sessionId)
+	});
+}
+/** Directory-first file tree with declared output metadata and lazy folder reads. */
+function ArtifactList({ listing, error, onOpen, onOpenDirectory, onLoadDirectory }) {
+	const [opening, setOpening] = useState(false);
+	const [openError, setOpenError] = useState();
+	const openDirectory = async () => {
+		if (onOpenDirectory === void 0 || opening) return;
+		setOpening(true);
+		setOpenError(void 0);
+		try {
+			const result = await onOpenDirectory();
+			setOpenError(result.error);
+		} catch {
+			setOpenError("The run folder could not be opened in Finder.");
+		} finally {
+			setOpening(false);
+		}
+	};
+	const [expanded, setExpanded] = useState(/* @__PURE__ */ new Set());
+	const [loaded, setLoaded] = useState({});
+	const [folderErrors, setFolderErrors] = useState({});
+	const [loading, setLoading] = useState(/* @__PURE__ */ new Set());
+	const entries = /* @__PURE__ */ new Map();
+	for (const entry of [...Object.values(loaded).flat(), ...listing?.artifacts ?? []]) entries.set(entry.path, entry);
+	for (const entry of entries.values()) {
+		const parts = entry.path.split("/");
+		parts.pop();
+		while (parts.length > 0) {
+			const parent = parts.join("/");
+			if (!entries.has(parent)) entries.set(parent, {
+				path: parent,
+				kind: "directory",
+				description: "",
+				producedBy: [],
+				declared: false,
+				state: entry.state === "pending" ? "pending" : "written"
+			});
+			parts.pop();
+		}
+	}
+	const toggle = async (entry) => {
+		const closing = expanded.has(entry.path);
+		setExpanded((current) => {
+			const next = new Set(current);
+			if (closing) next.delete(entry.path);
+			else next.add(entry.path);
+			return next;
+		});
+		if (closing || loading.has(entry.path) || onLoadDirectory === void 0 || entry.state === "pending") return;
+		setLoading((current) => new Set(current).add(entry.path));
+		try {
+			const result = await onLoadDirectory(entry.path);
+			if ("error" in result) setFolderErrors((current) => ({
+				...current,
+				[entry.path]: result.error
+			}));
+			else {
+				setLoaded((current) => ({
+					...current,
+					[entry.path]: result.artifacts.artifacts
+				}));
+				setFolderErrors((current) => ({
+					...current,
+					[entry.path]: ""
+				}));
+			}
+		} catch {
+			setFolderErrors((current) => ({
+				...current,
+				[entry.path]: "The folder cannot be read."
+			}));
+		} finally {
+			setLoading((current) => {
+				const next = new Set(current);
+				next.delete(entry.path);
+				return next;
+			});
+		}
+	};
+	const renderRow = (entry) => {
+		const glyph = STATE_GLYPH[entry.state];
+		const openable = entry.kind === "directory" || entry.state !== "pending";
+		return /* @__PURE__ */ jsxs("button", {
+			type: "button",
+			"data-testid": `artifact-row-${entry.path}`,
+			"data-artifact-state": entry.state,
+			disabled: !openable,
+			"aria-expanded": entry.kind === "directory" ? expanded.has(entry.path) : void 0,
+			onClick: () => entry.kind === "directory" ? void toggle(entry) : onOpen(entry.path),
+			className: `flex flex-col gap-0.5 px-3 py-1.5 text-left ${openable ? "cursor-pointer hover:bg-doom-panel" : "cursor-default"}`,
+			children: [/* @__PURE__ */ jsxs("span", {
+				className: "flex min-w-0 items-center gap-2",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						className: `w-3 shrink-0 text-xs ${glyph.className}`,
+						children: entry.kind === "directory" ? expanded.has(entry.path) ? "▾" : "▸" : glyph.glyph
+					}),
+					/* @__PURE__ */ jsxs("span", {
+						title: entry.path,
+						className: `min-w-0 flex-1 truncate text-base font-semibold ${entry.state === "pending" ? "text-doom-dim" : "text-doom-hi"}`,
+						children: [entry.path.split("/").pop(), entry.kind === "directory" ? "/" : ""]
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: "shrink-0 text-sm text-doom-dim",
+						children: entry.state === "pending" ? "pending" : entry.kind === "directory" ? "" : [formatSize(entry.size), formatWhen(entry.modifiedAt)].filter(Boolean).join(" · ")
+					})
+				]
+			}), entry.declared || entry.producedBy.length > 0 || entry.description !== "" ? /* @__PURE__ */ jsxs("span", {
+				className: "flex min-w-0 items-center gap-1 pl-5 text-sm text-doom-dim",
+				children: [
+					entry.declared ? /* @__PURE__ */ jsx(Badge, {
+						size: "xs",
+						tone: "violet",
+						className: "shrink-0",
+						children: "declared"
+					}) : null,
+					entry.producedBy.length === 0 ? null : /* @__PURE__ */ jsx("span", {
+						title: entry.producedBy.join(", "),
+						className: "truncate",
+						children: entry.producedBy.join(", ")
+					}),
+					entry.description === "" ? null : /* @__PURE__ */ jsx("span", {
+						title: entry.description,
+						className: "truncate",
+						children: entry.description
+					})
+				]
+			}) : null]
+		});
+	};
+	const renderChildren = (parent) => {
+		return [...entries.values()].filter((entry) => {
+			const cut = entry.path.lastIndexOf("/");
+			return (cut === -1 ? "" : entry.path.slice(0, cut)) === parent;
+		}).sort((left, right) => Number(right.kind === "directory") - Number(left.kind === "directory") || left.path.localeCompare(right.path)).map((entry) => /* @__PURE__ */ jsxs("div", {
+			className: "flex flex-col",
+			children: [renderRow(entry), entry.kind === "directory" && expanded.has(entry.path) ? /* @__PURE__ */ jsxs("div", {
+				className: "ml-3 border-l border-doom-border pl-1",
+				children: [
+					loading.has(entry.path) ? /* @__PURE__ */ jsx("span", {
+						className: "px-3 text-sm text-doom-dim",
+						children: "loading…"
+					}) : null,
+					folderErrors[entry.path] ? /* @__PURE__ */ jsx("span", {
+						role: "alert",
+						className: "px-3 text-base text-doom-yellow",
+						children: folderErrors[entry.path]
+					}) : null,
+					renderChildren(entry.path)
+				]
+			}) : null]
+		}, entry.path));
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "artifacts-pane",
+		className: "flex min-h-0 flex-1 flex-col",
+		children: [
+			error !== void 0 ? /* @__PURE__ */ jsx(EmptyState, {
+				className: "py-4",
+				title: "the run directory cannot be read",
+				description: error
+			}) : null,
+			entries.size === 0 && error === void 0 ? /* @__PURE__ */ jsx(EmptyState, {
+				className: "py-4",
+				title: "nothing in the run directory yet"
+			}) : null,
+			listing?.description ? /* @__PURE__ */ jsx("span", {
+				className: "px-3 py-2 text-sm text-doom-dim",
+				children: listing.description
+			}) : null,
+			renderChildren(""),
+			openError === void 0 ? null : /* @__PURE__ */ jsx("span", {
+				role: "alert",
+				className: "px-3 text-base text-doom-yellow",
+				children: openError
+			}),
+			listing === void 0 ? null : /* @__PURE__ */ jsx("button", {
+				type: "button",
+				"data-testid": "workflow-open-directory",
+				"aria-label": "Open workflow folder in Finder",
+				title: `${listing.runDir} (open in Finder)`,
+				disabled: opening || onOpenDirectory === void 0,
+				onClick: () => void openDirectory(),
+				className: "truncate px-3 py-2 text-left text-base text-doom-dim hover:text-doom-hi disabled:cursor-default",
+				children: listing.runDir
+			})
+		]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/keySender.ts
+/**
+* Sends keystrokes to a run one request at a time, in the order they were typed.
+*
+* One request per keystroke, all in flight together, can land out of order: a
+* quickly typed word reaches the pane as an anagram. Keys typed while a request
+* is in flight are batched into the next one. `send` answers false when the run
+* refused the keys; whatever is still queued is then dropped rather than sent
+* after a refusal.
+*/
+function createKeySender(send) {
+	let pending = "";
+	let sending = false;
+	const drain = async () => {
+		sending = true;
+		while (pending !== "") {
+			const batch = pending;
+			pending = "";
+			if (!await send(batch)) pending = "";
+		}
+		sending = false;
+	};
+	return (data) => {
+		pending += data;
+		if (!sending) drain();
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/StepSteerComposer.tsx
+/**
+* Guidance for the agent a running customRun step is in, the way a Team
+* sub-agent tab steers its run: the text lands in the turn the agent is
+* working on. The caller shows it only while the step runs, since guidance
+* after the step settles would no longer shape the workflow.
+*/
+function StepSteerComposer({ run, sessionId, step }) {
+	const [guidance, setGuidance] = useState("");
+	const [sending, setSending] = useState(false);
+	const [error, setError] = useState();
+	const submit = async (event) => {
+		event.preventDefault();
+		const message = guidance.trim();
+		if (message === "" || sending) return;
+		setSending(true);
+		setError(void 0);
+		try {
+			const result = await steerStep(run.workspace, run.runKey, message, sessionId, step);
+			if ("error" in result) {
+				setError(result.error);
+				return;
+			}
+			setGuidance("");
+		} catch (cause) {
+			setError(cause instanceof Error ? cause.message : String(cause));
+		} finally {
+			setSending(false);
+		}
+	};
+	return /* @__PURE__ */ jsx("form", {
+		"data-testid": "step-steer-composer",
+		className: "shrink-0 border-t border-doom-border-soft bg-doom-rail px-3 pt-3 pb-2.5",
+		onSubmit: (event) => void submit(event),
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "rounded-lg border border-doom-border bg-doom-deep transition-colors focus-within:border-doom-blue/60",
+			children: [
+				/* @__PURE__ */ jsxs("div", {
+					className: "flex min-w-0 items-start gap-2.5 px-3.5 pt-3",
+					children: [/* @__PURE__ */ jsx("span", {
+						className: "mt-[3px] shrink-0 select-none text-base leading-none text-doom-green",
+						children: ">"
+					}), /* @__PURE__ */ jsx(Textarea, {
+						variant: "bare",
+						"data-testid": "step-steer-input",
+						"aria-label": "Steering guidance",
+						rows: 2,
+						value: guidance,
+						readOnly: sending,
+						placeholder: "Guide this agent…",
+						className: "min-w-0 flex-1 text-base leading-relaxed",
+						onChange: (event) => setGuidance(event.target.value)
+					})]
+				}),
+				error === void 0 ? null : /* @__PURE__ */ jsx("p", {
+					role: "alert",
+					"data-testid": "step-steer-error",
+					className: "px-3.5 pt-2 text-base text-doom-red",
+					children: error
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: "flex items-center gap-2 px-3.5 pt-2 pb-2.5",
+					children: [
+						/* @__PURE__ */ jsx("span", {
+							role: "status",
+							"data-testid": "step-steer-hint",
+							className: "min-w-0 truncate text-sm text-doom-dim",
+							children: "guidance reaches this step while it is still working"
+						}),
+						/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }),
+						/* @__PURE__ */ jsx(Button, {
+							"data-testid": "step-steer-submit",
+							type: "submit",
+							variant: "primary",
+							size: "md",
+							className: "px-3.5",
+							disabled: sending || guidance.trim() === "",
+							children: sending ? "sending…" : "send"
+						})
+					]
+				})
+			]
+		})
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/StepTerminalPanel.tsx
+/** The tab id doubles as the URL segment, so it stays plain and unique across plugins. */
+const TAB_ID_PREFIX = "workflows-step-";
+/** Keys that mean something to a terminal but nothing to a text field. */
+const CONTROL_KEYS = {
+	Enter: "\r",
+	Backspace: "",
+	Tab: "	",
+	Escape: "\x1B",
+	ArrowUp: "\x1B[A",
+	ArrowDown: "\x1B[B",
+	ArrowRight: "\x1B[C",
+	ArrowLeft: "\x1B[D"
+};
+const CTRL_C = "";
+const CTRL_D = "";
+const CTRL_A_CODE = 64;
+/** The temporary tab for one step; the host keeps this panel while the tab is open. */
+function stepTerminalTab(run, job, step) {
+	const target = {
+		workspace: run.workspace,
+		runKey: run.runKey,
+		job,
+		...step === void 0 ? {} : { step }
+	};
+	const label = step ?? job;
+	return {
+		id: `${TAB_ID_PREFIX}${run.workspace}-${run.runKey}-${job}${step === void 0 ? "" : `-${step}`}`.replace(/[^\w-]+/g, "-"),
+		label: `${run.displayName} › ${label}`,
+		panel: (props) => /* @__PURE__ */ jsx(StepTerminalPanel, {
+			...props,
+			target
+		})
+	};
+}
+/**
+* The child session a customRun step ran as, when the tab shows one.
+*
+* A step tab follows that step. A job tab follows the job's latest step only,
+* so a job that moved on to a command step shows its terminal again.
+*/
+/** The step a tab points at: the named one, or the job's last step when it names none. */
+function targetStep(run, target) {
+	const steps = run?.jobs.find((job) => job.name === target.job)?.steps ?? [];
+	return target.step === void 0 ? steps.at(-1) : steps.find((candidate) => candidate.name === target.step);
+}
+/** The pane of the step a tab points at, so a parallel group's steps each read their own. */
+function stepPaneId(run, target) {
+	const ref = targetStep(run, target)?.ref;
+	return ref?.kind === "pane" ? ref.id : void 0;
+}
+function stepSessionRef(run, target) {
+	const step = targetStep(run, target);
+	return step?.ref?.kind === "session" ? step.ref : void 0;
+}
+function ScreenLine({ line }) {
+	if (line.length === 0) return /* @__PURE__ */ jsx("span", { className: "block h-[15px]" });
+	return /* @__PURE__ */ jsx(AnsiLine, {
+		line,
+		className: "block whitespace-pre"
+	});
+}
+/** The run, job and step the tab was opened from, with the run's stage and any controls. */
+function StepHeader({ run, target, children }) {
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "step-terminal-head",
+		className: "flex items-center gap-2.5 pb-3",
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				className: "shrink-0 truncate text-base font-semibold text-doom-hi",
+				children: run?.displayName ?? target.runKey
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "text-xs text-doom-faint",
+				children: "›"
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "shrink-0 truncate text-base font-semibold text-doom-hi",
+				children: target.job
+			}),
+			target.step === void 0 ? null : /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("span", {
+				className: "text-xs text-doom-faint",
+				children: "›"
+			}), /* @__PURE__ */ jsx("span", {
+				className: "min-w-0 truncate text-base text-doom-text",
+				children: target.step
+			})] }),
+			run === void 0 ? null : /* @__PURE__ */ jsx(StatusBadge, {
+				tone: run.stage === "running" ? "running" : run.stage === "error" ? "error" : "ok",
+				"data-testid": "step-terminal-stage",
+				children: run.stage
+			}),
+			/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }),
+			children
+		]
+	});
+}
+/**
+* One step of a run: the agent conversation for a customRun step, else the run's terminal.
+*
+* A customRun step runs as a child session, so its real messages replace the
+* screen a shell step would paint. The session outlives the step, so a
+* finished step still reads back.
+*/
+function StepTerminalPanel(props) {
+	const { sessionId, target, renderSessionTranscript } = props;
+	const run = useStore(workflows.store, (state) => workflows.select(state, sessionId).runs).find((candidate) => candidate.workspace === target.workspace && candidate.runKey === target.runKey);
+	const sessionRef = stepSessionRef(run, target);
+	if (sessionRef !== void 0 && renderSessionTranscript !== void 0) return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "step-conversation-panel",
+		className: "flex min-h-0 flex-1 flex-col px-[26px] py-[18px]",
+		children: [
+			/* @__PURE__ */ jsx(StepHeader, {
+				run,
+				target,
+				children: /* @__PURE__ */ jsx(Badge, {
+					size: "xs",
+					tone: "blue",
+					"data-testid": "step-conversation-session",
+					children: "agent session"
+				})
+			}),
+			/* @__PURE__ */ jsx("div", {
+				"data-testid": "step-conversation",
+				className: "flex min-h-0 flex-1 flex-col",
+				children: renderSessionTranscript(sessionRef.id)
+			}),
+			run?.stage === "running" && targetStep(run, target)?.status === "running" ? /* @__PURE__ */ jsx(StepSteerComposer, {
+				run,
+				sessionId,
+				step: sessionRef.id
+			}, sessionRef.id) : null
+		]
+	});
+	return /* @__PURE__ */ jsx(StepTerminal, {
+		sessionId,
+		target,
+		run
+	});
+}
+/**
+* One run's terminal, under a header naming the step the reader opened it from.
+*
+* A run has one terminal, shared by its steps in sequence, so this is the run's
+* screen and the header says which step is on it. Watching is free; typing
+* takes the keyboard first, because the pane belongs to whoever is answering
+* whatever the nested agent asked.
+*/
+function StepTerminal({ sessionId, target, run }) {
+	const [lines, setLines] = useState([]);
+	const [capabilities, setCapabilities] = useState();
+	const [ended, setEnded] = useState(false);
+	const [token, setToken] = useState();
+	const [notice, setNotice] = useState();
+	const screenRef = useRef(null);
+	const pane = stepPaneId(run, target);
+	const targetKey = `${sessionId ?? ""}\0${target.workspace}\0${target.runKey}\0${pane ?? ""}`;
+	const currentTarget = useRef(targetKey);
+	useEffect(() => {
+		currentTarget.current = targetKey;
+		return () => {
+			currentTarget.current = void 0;
+		};
+	}, [targetKey]);
+	useEffect(() => {
+		setEnded(false);
+		return followScreen(target.workspace, target.runKey, (event) => {
+			setLines(event.lines);
+			setCapabilities(event.capabilities);
+			if (event.ended === true) setEnded(true);
+		}, sessionId, pane);
+	}, [
+		sessionId,
+		target.workspace,
+		target.runKey,
+		pane
+	]);
+	useEffect(() => {
+		if (token === void 0) return;
+		return () => {
+			releaseControl(target.workspace, target.runKey, token, sessionId, pane);
+		};
+	}, [
+		sessionId,
+		token,
+		target.workspace,
+		target.runKey,
+		pane
+	]);
+	useEffect(() => {
+		screenRef.current?.scrollTo({ top: screenRef.current.scrollHeight });
+	}, [lines]);
+	const arm = useCallback(async () => {
+		const requested = targetKey;
+		const result = await takeControl(target.workspace, target.runKey, void 0, sessionId, pane);
+		if (currentTarget.current !== requested) {
+			if (result.held && result.token !== void 0) releaseControl(target.workspace, target.runKey, result.token, sessionId, pane);
+			return;
+		}
+		if (result.held && result.token !== void 0) {
+			setToken(result.token);
+			setNotice(void 0);
+			return;
+		}
+		setNotice(result.reason ?? "The keyboard is not available for this run.");
+	}, [
+		sessionId,
+		target.workspace,
+		target.runKey,
+		targetKey,
+		pane
+	]);
+	const disarm = useCallback(() => {
+		setToken(void 0);
+	}, []);
+	const typeKeys = useMemo(() => token === void 0 ? void 0 : createKeySender(async (data) => {
+		const { error } = await sendKeys(target.workspace, target.runKey, token, data, sessionId, pane);
+		if (error === void 0) return true;
+		setNotice(error);
+		setToken(void 0);
+		return false;
+	}), [
+		token,
+		target.workspace,
+		target.runKey,
+		sessionId,
+		pane
+	]);
+	const type = (data) => typeKeys?.(data);
+	const onKeyDown = (event) => {
+		if (token === void 0) return;
+		if (event.key === "Escape" && !event.ctrlKey) {
+			event.preventDefault();
+			disarm();
+			return;
+		}
+		const control = CONTROL_KEYS[event.key];
+		if (control !== void 0) {
+			event.preventDefault();
+			type(control);
+			return;
+		}
+		if (event.ctrlKey && event.key.length === 1) {
+			event.preventDefault();
+			const letter = event.key.toUpperCase().charCodeAt(0);
+			type(event.key === "c" ? CTRL_C : event.key === "d" ? CTRL_D : String.fromCharCode(letter - CTRL_A_CODE));
+			return;
+		}
+		if (event.key.length === 1 && !event.metaKey && !event.altKey) {
+			event.preventDefault();
+			type(event.key);
+		}
+	};
+	const held = token !== void 0;
+	const writable = capabilities?.writable === true;
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "step-terminal-panel",
+		className: "flex min-h-0 flex-1 flex-col px-[26px] py-[18px]",
+		children: [
+			/* @__PURE__ */ jsxs(StepHeader, {
+				run,
+				target,
+				children: [/* @__PURE__ */ jsx(Badge, {
+					size: "xs",
+					tone: held ? "blue" : "neutral",
+					"data-testid": "step-terminal-control",
+					className: held ? "border-doom-blue/60 bg-doom-tint-blue text-doom-hi" : "",
+					children: held ? "keyboard yours" : "watching"
+				}), writable ? /* @__PURE__ */ jsx(Button, {
+					variant: held ? "outline" : "primary",
+					size: "xs",
+					"data-testid": "step-terminal-arm",
+					onClick: () => held ? disarm() : void arm(),
+					children: held ? "release keyboard" : "take control"
+				}) : null]
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				ref: screenRef,
+				"data-testid": "step-terminal-screen",
+				tabIndex: 0,
+				onKeyDown,
+				className: `min-h-0 flex-1 overflow-y-auto rounded-md border bg-doom-deep px-4 py-3 font-mono text-sm leading-tight text-doom-text outline-none ${held ? "border-doom-blue/60" : "border-doom-border"}`,
+				children: [lines.length === 0 ? /* @__PURE__ */ jsx("span", {
+					className: "text-sm text-doom-dim",
+					children: capabilities?.readable === false ? capabilities.reason ?? "This run has no terminal to read." : "waiting for the run to paint…"
+				}) : lines.map((line, index) => /* @__PURE__ */ jsx(ScreenLine, { line }, index)), held && !ended ? /* @__PURE__ */ jsx(StreamCursor, { className: "mt-0.5 h-[12px] w-1.5" }) : null]
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex items-center gap-3 pt-2.5",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						"data-testid": "step-terminal-hint",
+						className: "text-sm text-doom-dim",
+						children: held ? "keys go to the run · ctrl-c and ctrl-d pass through · esc releases the keyboard" : capabilities?.writable === false ? capabilities.reason ?? "this run cannot be typed into" : "read-only until you take control · the run keeps going either way"
+					}),
+					/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }),
+					ended ? /* @__PURE__ */ jsx("span", {
+						"data-testid": "step-terminal-ended",
+						className: "text-sm text-doom-dim",
+						children: "the run has settled; this is its last screen"
+					}) : null,
+					notice === void 0 ? null : /* @__PURE__ */ jsx("span", {
+						"data-testid": "step-terminal-notice",
+						className: "text-sm text-doom-yellow",
+						children: notice
+					})
+				]
+			})
+		]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/WorkflowRunParts.tsx
+const STATE_ICON = {
+	pending: {
+		glyph: "○",
+		className: "text-doom-faint"
+	},
+	running: {
+		glyph: "●",
+		className: "text-doom-blue"
+	},
+	resumed: {
+		glyph: "●",
+		className: "text-doom-blue"
+	},
+	completed: {
+		glyph: "✓",
+		className: "text-doom-green"
+	},
+	failed: {
+		glyph: "✕",
+		className: "text-doom-red"
+	},
+	skipped: {
+		glyph: "↷",
+		className: "text-doom-faint"
+	},
+	pause_requested: {
+		glyph: "!",
+		className: "text-doom-yellow"
+	},
+	paused: {
+		glyph: "!",
+		className: "text-doom-yellow"
+	}
+};
+const ACTIVE_STATES = /* @__PURE__ */ new Set([
+	"running",
+	"resumed",
+	"pause_requested",
+	"paused"
+]);
+function spanDuration(startedAt, endedAt, now) {
+	if (startedAt === void 0) return void 0;
+	const start = Date.parse(startedAt);
+	if (!Number.isFinite(start)) return void 0;
+	const end = endedAt === void 0 ? now : Date.parse(endedAt);
+	if (!Number.isFinite(end)) return void 0;
+	return formatRunDuration(Math.max(0, end - start));
+}
+function attentionFor(run) {
+	if (run.stage === "error") {
+		const cause = run.errorMessage ?? "the run ended in the error stage";
+		return {
+			kind: "error",
+			text: run.failedJob === void 0 ? cause : `job '${run.failedJob}' failed: ${cause}`
+		};
+	}
+	if (run.stale === true) return {
+		kind: "stale",
+		text: run.staleReason ?? "the process that ran this workflow is gone"
+	};
+	if (run.executionState === "paused" || run.executionState === "pause_requested") return {
+		kind: "paused",
+		text: "the run is paused and will not move until it is resumed"
+	};
+}
+function runDot(run) {
+	if (run.stage === "error") return "red";
+	if (run.executionState === "paused" || run.executionState === "pause_requested") return "yellow";
+	if (run.stage === "running") return "blue";
+	if (run.outcome === "success") return "green";
+	return "neutral";
+}
+function runState(run) {
+	if (run.stage === "error") return "failed";
+	if (run.executionState === "paused" || run.executionState === "pause_requested") return "paused";
+	if (run.stage === "running") return "running";
+	return run.outcome ?? run.stage;
+}
+/** The statuses the picker filters by, in the order its status row lists them. */
+const RUN_FILTERS = [
+	"all",
+	"running",
+	"paused",
+	"failed",
+	"done"
+];
+function runFilterOf(run) {
+	if (run.stage === "error") return "failed";
+	if (run.executionState === "paused" || run.executionState === "pause_requested") return "paused";
+	if (run.stage === "running") return "running";
+	return "done";
+}
+function runPriority(run) {
+	if (attentionFor(run) !== void 0) return 0;
+	if (run.stage === "running") return 1;
+	return 2;
+}
+function runSearchText(run) {
+	return [
+		run.displayName,
+		run.workflowName,
+		run.stage,
+		run.outcome,
+		run.executionState,
+		run.position?.job,
+		run.position?.step
+	].filter((part) => typeof part === "string").join(" ").toLowerCase();
+}
+function WorkflowPicker({ runs, selected, onSelect, className }) {
+	const [open, setOpen] = useState(false);
+	const [query, setQuery] = useState("");
+	const [filter, setFilter] = useState("all");
+	const ordered = useMemo(() => [...runs].sort((left, right) => runPriority(left) - runPriority(right)), [runs]);
+	const needle = query.trim().toLowerCase();
+	const shown = ordered.filter((run) => (filter === "all" || runFilterOf(run) === filter) && runSearchText(run).includes(needle));
+	return /* @__PURE__ */ jsxs(Popover, {
+		open,
+		onOpenChange: (next) => {
+			setOpen(next);
+			if (!next) setQuery("");
+		},
+		children: [/* @__PURE__ */ jsx(PopoverTrigger, {
+			asChild: true,
+			children: /* @__PURE__ */ jsxs(Button, {
+				variant: "outline",
+				size: "sm",
+				"data-testid": "workflow-picker",
+				className: cn("h-8 w-full max-w-[360px] justify-start border-doom-border bg-doom-deep px-2.5", className),
+				children: [
+					/* @__PURE__ */ jsx(SearchIcon, { className: "h-3 w-3 shrink-0 text-doom-faint" }),
+					/* @__PURE__ */ jsx("span", {
+						className: "min-w-0 flex-1 truncate text-left text-base font-semibold text-doom-hi",
+						children: selected.displayName
+					}),
+					/* @__PURE__ */ jsxs("span", {
+						className: "shrink-0 text-sm font-normal text-doom-dim",
+						children: [runs.length, " workflows"]
+					}),
+					/* @__PURE__ */ jsx(ChevronDownIcon, { className: "h-3 w-3 shrink-0 text-doom-dim" })
+				]
+			})
+		}), /* @__PURE__ */ jsxs(PopoverContent, {
+			side: "bottom",
+			align: "start",
+			"data-testid": "workflow-picker-popover",
+			className: "w-[440px] border-doom-edge-blue",
+			children: [
+				/* @__PURE__ */ jsxs(PopoverHeader, { children: [/* @__PURE__ */ jsx(SectionLabel, {
+					className: "text-doom-blue",
+					children: "workflow"
+				}), /* @__PURE__ */ jsx("span", {
+					className: "truncate text-sm text-doom-dim",
+					children: selected.displayName
+				})] }),
+				/* @__PURE__ */ jsx("div", {
+					className: "border-b border-doom-border-soft p-1.5",
+					children: /* @__PURE__ */ jsx(Input, {
+						autoFocus: true,
+						"data-testid": "workflow-picker-search",
+						value: query,
+						onChange: (event) => setQuery(event.target.value),
+						placeholder: "filter workflows…",
+						className: "w-full px-2 py-1 text-sm"
+					})
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					role: "listbox",
+					"aria-label": "workflows",
+					className: "flex max-h-[300px] flex-col gap-0.5 overflow-y-auto p-1.5",
+					children: [shown.length === 0 ? /* @__PURE__ */ jsx(EmptyState, {
+						className: "py-4",
+						title: "no workflow matches"
+					}) : null, shown.map((run) => {
+						const active = workflowRunIdentity(run) === workflowRunIdentity(selected);
+						return /* @__PURE__ */ jsxs(OptionRow, {
+							density: "compact",
+							active,
+							"data-testid": `workflow-option-${run.runKey}`,
+							"data-run-stage": run.stage,
+							"data-active": active,
+							onClick: () => {
+								onSelect(run);
+								setOpen(false);
+							},
+							className: cn("w-full gap-2.5 py-1.5 transition-colors hover:bg-doom-deep focus-visible:bg-doom-deep", active && "bg-doom-tint-blue hover:brightness-125"),
+							children: [
+								/* @__PURE__ */ jsx("span", {
+									className: "w-14 shrink-0 truncate text-sm text-doom-dim",
+									children: runState(run)
+								}),
+								/* @__PURE__ */ jsx(OptionLabel, {
+									density: "compact",
+									className: active ? "text-doom-blue" : "text-doom-hi",
+									children: run.displayName
+								}),
+								/* @__PURE__ */ jsx("span", {
+									className: "max-w-[40%] truncate text-sm text-doom-dim",
+									children: [run.position?.job, run.position?.step].filter(Boolean).join(" · ")
+								}),
+								/* @__PURE__ */ jsx(Dot, {
+									tone: runDot(run),
+									pulse: run.stage === "running"
+								})
+							]
+						}, workflowRunIdentity(run));
+					})]
+				}),
+				/* @__PURE__ */ jsxs(PopoverFooter, {
+					className: "flex-wrap justify-start gap-1 py-1.5",
+					children: [/* @__PURE__ */ jsx(SectionLabel, {
+						className: "mr-1",
+						children: "status"
+					}), RUN_FILTERS.map((candidate) => {
+						const current = filter === candidate;
+						return /* @__PURE__ */ jsx(Button, {
+							variant: "ghost",
+							size: "xs",
+							"data-testid": `workflow-filter-${candidate}`,
+							"data-current": current,
+							onClick: () => setFilter(candidate),
+							className: cn(current && "bg-doom-blue/25 font-semibold text-doom-blue hover:bg-doom-blue/25"),
+							children: candidate
+						}, candidate);
+					})]
+				})
+			]
+		})]
+	});
+}
+function StepRow({ step, now, selected, onSelect }) {
+	const icon = STATE_ICON[step.status];
+	return /* @__PURE__ */ jsxs("button", {
+		type: "button",
+		disabled: step.status === "pending",
+		title: `${step.name}: ${step.status}`,
+		"data-testid": `step-row-${step.name}`,
+		"data-step-status": step.status,
+		"data-active": selected,
+		onClick: onSelect,
+		className: cn("flex w-full cursor-pointer flex-col gap-0.5 rounded px-2 py-1.5 text-left enabled:hover:bg-doom-deep disabled:cursor-default", selected && "bg-doom-tint-blue ring-1 ring-inset ring-doom-blue/40"),
+		children: [/* @__PURE__ */ jsxs("span", {
+			className: "flex items-center gap-2",
+			children: [
+				/* @__PURE__ */ jsx("span", {
+					className: `w-3 shrink-0 text-xs ${icon.className}`,
+					children: icon.glyph
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: cn("min-w-0 flex-1 truncate text-base font-medium", step.status === "failed" ? "text-doom-red" : "text-doom-text"),
+					children: step.name
+				}),
+				step.group === void 0 ? null : /* @__PURE__ */ jsxs("span", {
+					"data-testid": `step-group-${step.name}`,
+					className: "max-w-24 shrink-0 truncate text-sm text-doom-dim",
+					children: ["∥ ", step.group]
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: "shrink-0 text-sm text-doom-dim",
+					children: step.status === "pending" ? "pending" : spanDuration(step.startedAt, step.endedAt, now) ?? ""
+				})
+			]
+		}), step.reason === void 0 ? null : /* @__PURE__ */ jsx("span", {
+			"data-testid": `step-reason-${step.name}`,
+			title: step.reason,
+			className: cn("truncate pl-5 text-sm", step.status === "failed" ? "text-doom-red" : "text-doom-dim"),
+			children: step.reason
+		})]
+	});
+}
+function DeleteWorkflowDialog({ run, sessionId, onClose, onDeleted }) {
+	const [deleting, setDeleting] = useState(false);
+	const [error, setError] = useState();
+	const confirm = () => {
+		setDeleting(true);
+		setError(void 0);
+		deleteWorkflowRun(run.workspace, run.runKey, sessionId).then((result) => {
+			if ("error" in result) {
+				setDeleting(false);
+				setError(result.error);
+				return;
+			}
+			onDeleted();
+		});
+	};
+	return /* @__PURE__ */ jsx(Dialog, {
+		open: true,
+		onOpenChange: (open) => {
+			if (!open && !deleting) onClose();
+		},
+		children: /* @__PURE__ */ jsxs(DialogContent, {
+			width: "md",
+			"data-testid": "delete-workflow-dialog",
+			"aria-describedby": void 0,
+			children: [/* @__PURE__ */ jsx(DialogHeader, { children: /* @__PURE__ */ jsxs(DialogTitle, { children: [
+				"Delete ",
+				run.displayName,
+				"?"
+			] }) }), /* @__PURE__ */ jsxs(DialogBody, { children: [
+				/* @__PURE__ */ jsx("p", {
+					className: "text-sm leading-relaxed text-doom-dim",
+					children: "This permanently removes the workflow run, including its logs and artifacts. This action cannot be undone."
+				}),
+				error === void 0 ? null : /* @__PURE__ */ jsx("p", {
+					"data-testid": "delete-workflow-error",
+					className: "text-base text-doom-red",
+					children: error
+				}),
+				/* @__PURE__ */ jsxs(DialogFooter, { children: [
+					/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }),
+					/* @__PURE__ */ jsx(Button, {
+						variant: "outline",
+						size: "xs",
+						"data-testid": "delete-workflow-cancel",
+						disabled: deleting,
+						onClick: onClose,
+						children: "cancel"
+					}),
+					/* @__PURE__ */ jsx(Button, {
+						variant: "danger",
+						size: "xs",
+						"data-testid": "delete-workflow-confirm",
+						loading: deleting,
+						loadingLabel: "deleting workflow",
+						onClick: confirm,
+						children: "delete permanently"
+					})
+				] })
+			] })]
+		})
+	});
+}
+/** Ends a running workflow; the button holds its busy state until the run settles and it unmounts. */
+function StopWorkflowButton({ run, sessionId }) {
+	const [stopping, setStopping] = useState(false);
+	const [error, setError] = useState();
+	const stop = () => {
+		setStopping(true);
+		setError(void 0);
+		stopWorkflowRun(run.workspace, run.runKey, sessionId).then((result) => {
+			if (!("error" in result)) return;
+			setStopping(false);
+			setError(result.error);
+		});
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex shrink-0 flex-col gap-1 border-t border-doom-border-soft p-1.5",
+		children: [error === void 0 ? null : /* @__PURE__ */ jsx("span", {
+			"data-testid": "stop-workflow-error",
+			className: "px-1 text-base text-doom-red",
+			children: error
+		}), /* @__PURE__ */ jsx(Button, {
+			variant: "danger-outline",
+			size: "xs",
+			"data-testid": "stop-workflow",
+			loading: stopping,
+			loadingLabel: "stopping workflow",
+			onClick: stop,
+			className: "w-full",
+			children: "stop workflow"
+		})]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/dock/_components/WorkflowDockPanel.tsx
+const TICK_MS = 1e4;
+const STATE_TONE = {
+	running: "info",
+	paused: "running",
+	failed: "error",
+	success: "ok"
+};
+function stateTone(state) {
+	return state in STATE_TONE ? STATE_TONE[state] : "neutral";
+}
+/** The steps moving right now, across every job, so a parallel group reads as one list. */
+function activeSteps(run) {
+	return run.jobs.flatMap((job) => job.steps.filter((step) => ACTIVE_STATES.has(step.status)).map((step) => ({
+		job: job.name,
+		step
+	})));
+}
+function SectionHeading({ label, meta }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex items-center px-4 pb-1 pt-3",
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				className: "text-lg font-semibold text-doom-hi",
+				children: label
+			}),
+			/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }),
+			meta === void 0 ? null : /* @__PURE__ */ jsx("span", {
+				className: "text-sm text-doom-dim",
+				children: meta
+			})
+		]
+	});
+}
+function RunHeader({ run, runs, now, onSelectRun }) {
+	const state = runState(run);
+	const where = [run.position?.job, run.position?.step].filter(Boolean).join(" › ");
+	const elapsed = spanDuration(run.startedAt, run.finishedAt, now);
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "workflow-dock-run",
+		className: "flex shrink-0 flex-col gap-1.5 border-b border-doom-border px-4 py-3",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex min-w-0 items-center gap-2",
+				children: [
+					/* @__PURE__ */ jsx(Dot, {
+						tone: runDot(run),
+						pulse: run.stage === "running" && state === "running"
+					}),
+					/* @__PURE__ */ jsx("span", {
+						title: run.displayName,
+						className: "min-w-0 flex-1 truncate text-base font-semibold text-doom-hi",
+						children: run.displayName
+					}),
+					/* @__PURE__ */ jsx(StatusBadge, {
+						size: "xs",
+						tone: stateTone(state),
+						"data-testid": "workflow-dock-state",
+						"data-run-state": state,
+						children: state
+					})
+				]
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex min-w-0 items-center gap-1.5 text-sm text-doom-dim",
+				children: [/* @__PURE__ */ jsx("span", {
+					title: where,
+					className: "min-w-0 flex-1 truncate",
+					children: where || (run.stage === "running" ? "starting" : run.workflowPath)
+				}), elapsed === void 0 ? null : /* @__PURE__ */ jsx("span", {
+					className: "shrink-0",
+					children: elapsed
+				})]
+			}),
+			runs.length > 1 ? /* @__PURE__ */ jsx(WorkflowPicker, {
+				runs,
+				selected: run,
+				onSelect: onSelectRun,
+				className: "max-w-none"
+			}) : null
+		]
+	});
+}
+function AttentionBanner({ run }) {
+	const attention = attentionFor(run);
+	if (attention === void 0) return null;
+	const paused = attention.kind === "paused";
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "workflow-dock-attention",
+		"data-attention": attention.kind,
+		className: cn("mx-3 mt-3 flex flex-col gap-1 rounded-md border px-3 py-2", paused ? "border-doom-edge-yellow bg-doom-tint-yellow/40" : "border-doom-edge-red bg-doom-tint-red/40"),
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex items-center gap-2",
+				children: [/* @__PURE__ */ jsx(StatusBadge, {
+					size: "xs",
+					tone: paused ? "running" : "error",
+					children: attention.kind
+				}), /* @__PURE__ */ jsx("span", {
+					className: "min-w-0 flex-1 text-sm text-doom-dim",
+					children: paused ? "waiting to be resumed" : "needs a look"
+				})]
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "break-words text-base text-doom-text",
+				children: attention.text
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "text-sm text-doom-dim",
+				children: paused ? "ask the agent in this conversation to resume it" : "ask the agent in this conversation to diagnose or recover it"
+			})
+		]
+	});
+}
+function ActiveNow({ run, now, onOpenStep }) {
+	const active = activeSteps(run);
+	if (active.length === 0) return null;
+	return /* @__PURE__ */ jsxs("section", {
+		"data-testid": "workflow-dock-active",
+		"aria-label": "active steps",
+		children: [/* @__PURE__ */ jsx(SectionHeading, {
+			label: "Active now",
+			meta: String(active.length)
+		}), /* @__PURE__ */ jsx("div", {
+			className: "flex flex-col gap-0.5 px-2",
+			children: active.map(({ job, step }) => {
+				const paused = step.status === "paused" || step.status === "pause_requested";
+				return /* @__PURE__ */ jsxs("button", {
+					type: "button",
+					"data-testid": `workflow-dock-active-${step.name}`,
+					title: `open ${step.name}`,
+					onClick: () => onOpenStep(job, step.name),
+					className: "flex w-full cursor-pointer items-center gap-2 rounded px-2 py-1.5 text-left hover:bg-doom-panel",
+					children: [
+						/* @__PURE__ */ jsx(Dot, {
+							tone: paused ? "yellow" : "blue",
+							pulse: !paused
+						}),
+						/* @__PURE__ */ jsxs("span", {
+							className: "flex min-w-0 flex-1 flex-col",
+							children: [/* @__PURE__ */ jsx("span", {
+								className: "truncate text-base font-semibold text-doom-hi",
+								children: step.name
+							}), /* @__PURE__ */ jsxs("span", {
+								className: "truncate text-sm text-doom-dim",
+								children: [job, step.group === void 0 ? "" : ` · ∥ ${step.group}`]
+							})]
+						}),
+						/* @__PURE__ */ jsx("span", {
+							className: "shrink-0 text-sm text-doom-dim",
+							children: spanDuration(step.startedAt, step.endedAt, now) ?? ""
+						})
+					]
+				}, `${job}/${step.name}`);
+			})
+		})]
+	});
+}
+function JobTree({ run, now, onOpenStep }) {
+	const [toggled, setToggled] = useState({});
+	const done = run.jobs.filter((job) => job.status === "completed" || job.status === "skipped").length;
+	return /* @__PURE__ */ jsxs("section", {
+		"data-testid": "workflow-dock-jobs",
+		"aria-label": "jobs",
+		children: [/* @__PURE__ */ jsx(SectionHeading, {
+			label: "Jobs",
+			meta: `${done}/${run.jobs.length}`
+		}), run.jobs.length === 0 ? /* @__PURE__ */ jsx(EmptyState, {
+			className: "py-3",
+			title: "no progress recorded yet"
+		}) : /* @__PURE__ */ jsx("div", {
+			className: "flex flex-col gap-0.5 px-2",
+			children: run.jobs.map((job) => {
+				const open = toggled[job.name] ?? true;
+				const icon = STATE_ICON[job.status];
+				const finished = job.steps.filter((step) => step.status === "completed" || step.status === "skipped").length;
+				return /* @__PURE__ */ jsxs("div", {
+					className: "flex flex-col",
+					children: [/* @__PURE__ */ jsxs("button", {
+						type: "button",
+						"data-testid": `job-row-${job.name}`,
+						"data-job-status": job.status,
+						"aria-expanded": open,
+						title: `${job.name}: ${job.status}`,
+						onClick: () => setToggled((current) => ({
+							...current,
+							[job.name]: !open
+						})),
+						className: "flex w-full cursor-pointer items-center gap-2 rounded px-2 py-1.5 text-left hover:bg-doom-panel",
+						children: [
+							open ? /* @__PURE__ */ jsx(ChevronDownIcon, { className: "h-2.5 w-2.5 shrink-0 text-doom-faint" }) : /* @__PURE__ */ jsx(ChevronRightIcon, { className: "h-2.5 w-2.5 shrink-0 text-doom-faint" }),
+							/* @__PURE__ */ jsx("span", {
+								className: `w-3 shrink-0 text-xs ${icon.className}`,
+								children: icon.glyph
+							}),
+							/* @__PURE__ */ jsx("span", {
+								className: cn("min-w-0 flex-1 truncate text-base font-semibold", job.status === "failed" ? "text-doom-red" : "text-doom-hi"),
+								children: job.name
+							}),
+							/* @__PURE__ */ jsx("span", {
+								className: "shrink-0 text-sm text-doom-dim",
+								children: job.status === "pending" ? "pending" : open || job.steps.length === 0 ? spanDuration(job.startedAt, job.endedAt, now) ?? "" : `${finished}/${job.steps.length} steps`
+							})
+						]
+					}), open && job.steps.length > 0 ? /* @__PURE__ */ jsx("div", {
+						className: "ml-4 flex flex-col gap-0.5 border-l border-doom-border-soft pl-1",
+						children: job.steps.map((step) => /* @__PURE__ */ jsx(StepRow, {
+							step,
+							now,
+							selected: ACTIVE_STATES.has(step.status),
+							onSelect: () => onOpenStep(job.name, step.name)
+						}, step.name))
+					}) : null]
+				}, job.name);
+			})
+		})]
+	});
+}
+/** One workflow run as the dock shows it: where it is, what is moving, what it produced. */
+function WorkflowDockView({ runs, run, now, sessionId, onSelectRun, onOpenStep, onDeleted, artifacts }) {
+	const [deleting, setDeleting] = useState(false);
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "workflow-dock",
+		className: "flex h-full min-h-0 flex-1 flex-col",
+		children: [
+			/* @__PURE__ */ jsx(RunHeader, {
+				run,
+				runs,
+				now,
+				onSelectRun
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				"data-testid": "workflow-dock-scroll",
+				className: "min-h-0 flex-1 overflow-y-auto pb-3",
+				children: [
+					/* @__PURE__ */ jsx(AttentionBanner, { run }),
+					/* @__PURE__ */ jsx(ActiveNow, {
+						run,
+						now,
+						onOpenStep
+					}),
+					/* @__PURE__ */ jsx(JobTree, {
+						run,
+						now,
+						onOpenStep
+					}, workflowRunIdentity(run)),
+					/* @__PURE__ */ jsxs("section", {
+						"data-testid": "workflow-dock-artifacts",
+						"aria-label": "artifacts",
+						children: [/* @__PURE__ */ jsx(SectionHeading, { label: "Artifacts" }), /* @__PURE__ */ jsx("div", {
+							className: "px-1",
+							children: artifacts
+						})]
+					})
+				]
+			}),
+			run.stage === "running" ? /* @__PURE__ */ jsxs("div", {
+				className: "shrink-0",
+				children: [/* @__PURE__ */ jsx(StopWorkflowButton, {
+					run,
+					sessionId
+				}, workflowRunIdentity(run)), /* @__PURE__ */ jsx("p", {
+					className: "px-3 pb-2 text-sm text-doom-dim",
+					children: "this session runs the workflow; removing or restarting it stops the run"
+				})]
+			}) : /* @__PURE__ */ jsx("div", {
+				className: "flex shrink-0 border-t border-doom-border-soft p-1.5",
+				children: /* @__PURE__ */ jsx(Button, {
+					variant: "danger-outline",
+					size: "xs",
+					"data-testid": "delete-workflow",
+					disabled: sessionId === null,
+					onClick: () => setDeleting(true),
+					className: "w-full",
+					children: "delete run"
+				})
+			}),
+			sessionId !== null && deleting ? /* @__PURE__ */ jsx(DeleteWorkflowDialog, {
+				run,
+				sessionId,
+				onClose: () => setDeleting(false),
+				onDeleted: () => {
+					setDeleting(false);
+					onDeleted();
+				}
+			}) : null
+		]
+	});
+}
+/** The `workflow` dock face: the run this workflow session owns, live from the runs channel. */
+function WorkflowDockPanel({ sessionId, openTransientTab }) {
+	const reported = useStore(workflows.store, (state) => workflows.select(state, sessionId).runs);
+	const focused = useStore(workflows.store, (state) => workflows.select(state, sessionId).focusedRun);
+	const runs = useMemo(() => reported.filter((candidate) => ownsRun(candidate, sessionId)), [reported, sessionId]);
+	const [now, setNow] = useState(() => Date.now());
+	useEffect(() => {
+		const timer = setInterval(() => setNow(Date.now()), TICK_MS);
+		return () => clearInterval(timer);
+	}, []);
+	const run = runs.find((candidate) => workflowRunIdentity(candidate) === focused) ?? runs[0];
+	if (run === void 0) return /* @__PURE__ */ jsx(EmptyState, {
+		"data-testid": "workflow-dock-empty",
+		className: "px-4 py-5",
+		title: "this session has no workflow run",
+		description: "a run launched from here shows its jobs, steps and artifacts in this face.",
+		children: /* @__PURE__ */ jsx(Button, {
+			variant: "outline",
+			size: "sm",
+			"data-testid": "workflow-dock-launch",
+			onClick: () => {
+				if (sessionId !== null) openCatalog(sessionId);
+			},
+			children: "launch workflow"
+		})
+	});
+	return /* @__PURE__ */ jsx(WorkflowDockView, {
+		runs,
+		run,
+		now,
+		sessionId,
+		onSelectRun: (candidate) => {
+			if (sessionId !== null) focusRun(sessionId, workflowRunIdentity(candidate));
+		},
+		onOpenStep: (job, step) => openTransientTab(stepTerminalTab(run, job, step)),
+		onDeleted: () => {
+			if (sessionId !== null) removeRun(sessionId, workflowRunIdentity(run));
+		},
+		artifacts: /* @__PURE__ */ jsx(ArtifactsPane, {
+			run,
+			sessionId,
+			onOpen: (path) => openTransientTab(artifactTab(run, path))
+		}, `${workflowRunIdentity(run)}/${sessionId}`)
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/dock/workflow.web.tsx
+var workflow_web_default$1 = defineDockFace({
+	id: "workflow",
+	label: "workflow",
+	order: 20,
+	autoSelect: true,
+	panel: WorkflowDockPanel,
+	visibility: {
+		subscribe(listener) {
+			const subscription = workflows.store.subscribe(listener);
+			return () => subscription.unsubscribe();
+		},
+		isVisible(sessionId) {
+			return workflows.select(workflows.store.state, sessionId).runs.some((run) => ownsRun(run, sessionId));
+		}
+	}
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/launchLine.ts
+/**
+* The `/workflow-launch` line the dialog sends.
+*
+* WHY THE BUILDER LIVES HERE AND THE PARSER DOES NOT:
+* Cockpit code is compiled into the host bundle and may import only this
+* package's own web and type modules, so it cannot share the session's parser.
+* The two are pinned together by a test that parses what this writes, which is
+* the only guarantee that matters: the line has to survive the trip.
+*/
+const WORKFLOW_LAUNCH_VERB = "/workflow-launch";
+/** Reserved keys; every other pair is one of the workflow's own inputs. */
+const RUNNER_KEY = "runner";
+const COMMAND_KEY = "command";
+const CHOICE_KEY = "choice";
+/** Quotes a value that carries whitespace, which is how a value survives tokenizing. */
+function quote(value) {
+	return /\s/.test(value) ? `"${value}"` : value;
+}
+function reservedPair(key, value) {
+	return value === void 0 || value === "" ? [] : [`${key}=${quote(value)}`];
+}
+function workflowLaunchLine(request) {
+	const pairs = [
+		...reservedPair(RUNNER_KEY, request.runner),
+		...reservedPair(COMMAND_KEY, request.command),
+		...reservedPair(CHOICE_KEY, request.choice),
+		...Object.entries(request.inputs).filter(([, value]) => value !== "").map(([key, value]) => `${key}=${quote(value)}`)
+	];
+	const prompt = request.prompt?.trim();
+	return [
+		WORKFLOW_LAUNCH_VERB,
+		quote(request.workflow),
+		...pairs,
+		...prompt ? [prompt] : []
+	].join(" ");
+}
+/** The trigger that makes a prompt mandatory. */
+const USER_PROMPT_TRIGGER = "user_prompt";
+/** What the dialog will not let a reader send, worded the way the session would answer. */
+function launchProblems(workflow, request) {
+	const problems = [];
+	if (workflow.triggers.includes(USER_PROMPT_TRIGGER) && (request.prompt ?? "").trim() === "") problems.push("This workflow is triggered by a prompt, so it needs one.");
+	const missing = workflow.inputs.filter((input) => input.required === true && (request.inputs[input.name] ?? "") === "").map((input) => input.name);
+	if (missing.length > 0) problems.push(`Missing required input${missing.length > 1 ? "s" : ""}: ${missing.join(", ")}.`);
+	return problems;
+}
+/** The default a field starts with: what the workflow declared, or empty. */
+function initialInputs(workflow) {
+	return Object.fromEntries(workflow.inputs.map((input) => [input.name, input.default ?? ""]));
+}
+/** The runner a launch starts on: the workflow's first declared one, when it declares any. */
+function initialRunner(workflow) {
+	return workflow.runners?.[0];
+}
+/** The command templated steps start on: the one their steps list first. */
+function initialCommand(workflow) {
+	return workflow.commands?.[0];
+}
+/** The choice a launch starts on: `default` when declared, else the first. */
+function initialChoice(workflow) {
+	const choices = workflow.choices ?? [];
+	return choices.includes("default") ? "default" : choices[0];
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/LaunchWorkflowDialog.tsx
+const PROMPT_ROWS = 3;
+const BOOLEAN_TYPE = "boolean";
+const BOOLEAN_VALUES = ["true", "false"];
+function FieldLabel({ children }) {
+	return /* @__PURE__ */ jsx("span", {
+		className: "text-base font-medium text-doom-text",
+		children
+	});
+}
+/** One `workflow_dispatch` input: a picker when the workflow constrains it, a field otherwise. */
+function InputField({ input, value, onChange }) {
+	const options = input.options ?? (input.type === BOOLEAN_TYPE ? [...BOOLEAN_VALUES] : void 0);
+	const hint = [
+		input.required === true ? "required" : void 0,
+		input.default === void 0 ? void 0 : `default: ${input.default}`,
+		input.description
+	].filter((part) => part !== void 0 && part !== "").join(" · ");
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex flex-col gap-1.5 sm:flex-row sm:items-center sm:gap-2.5",
+		"data-testid": `launch-input-${input.name}`,
+		children: [
+			/* @__PURE__ */ jsxs("span", {
+				className: "min-w-0 truncate text-base font-medium text-doom-text sm:w-28 sm:shrink-0",
+				children: [input.name, input.required === true ? /* @__PURE__ */ jsx("span", {
+					className: "text-doom-yellow",
+					children: " *"
+				}) : null]
+			}),
+			options === void 0 ? /* @__PURE__ */ jsx(Input, {
+				className: "min-w-0 flex-1",
+				value,
+				placeholder: input.default ?? "",
+				onChange: (event) => onChange(event.target.value)
+			}) : /* @__PURE__ */ jsxs(Select, {
+				value: value === "" ? void 0 : value,
+				onValueChange: onChange,
+				children: [/* @__PURE__ */ jsx(SelectTrigger, {
+					className: "h-7 w-full min-w-0 sm:min-w-[160px]",
+					children: /* @__PURE__ */ jsx(SelectValue, { placeholder: "choose…" })
+				}), /* @__PURE__ */ jsx(SelectContent, { children: options.map((option) => /* @__PURE__ */ jsx(SelectItem, {
+					value: option,
+					children: option
+				}, option)) })]
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "min-w-0 truncate text-sm text-doom-dim sm:w-40 sm:shrink-0",
+				children: hint
+			})
+		]
+	});
+}
+/** A reserved launch value the workflow declares options for, such as its command or model choice. */
+function PickField({ label, testId, options, value, hint, onChange }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex flex-col gap-1.5",
+		children: [
+			/* @__PURE__ */ jsx(FieldLabel, { children: label }),
+			/* @__PURE__ */ jsxs(Select, {
+				value,
+				onValueChange: onChange,
+				children: [/* @__PURE__ */ jsx(SelectTrigger, {
+					"data-testid": testId,
+					className: "h-7 w-full min-w-0 sm:min-w-[160px]",
+					children: /* @__PURE__ */ jsx(SelectValue, {})
+				}), /* @__PURE__ */ jsx(SelectContent, { children: options.map((option) => /* @__PURE__ */ jsx(SelectItem, {
+					value: option,
+					children: option
+				}, option)) })]
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "text-sm text-doom-dim",
+				children: hint
+			})
+		]
+	});
+}
+/**
+* Launches one workflow from the catalog: the prompt, every input the file
+* declares, the runner when it declares a runner map, then the exact line the
+* session will parse. Enter launches, since the composer sends the same way.
+*/
+function LaunchWorkflowDialog({ sessionId, workflow, cwd, initialPrompt, send, onClose, onLaunched }) {
+	const [prompt, setPrompt] = useState(initialPrompt);
+	const [inputs, setInputs] = useState(() => initialInputs(workflow));
+	const [runner, setRunner] = useState(() => initialRunner(workflow));
+	const [command, setCommand] = useState(() => initialCommand(workflow));
+	const [choice, setChoice] = useState(() => initialChoice(workflow));
+	const request = {
+		workflow: workflow.name === "" ? workflow.relativePath : workflow.name,
+		...runner === void 0 ? {} : { runner },
+		...command === void 0 ? {} : { command },
+		...choice === void 0 ? {} : { choice },
+		inputs,
+		...prompt.trim() === "" ? {} : { prompt: prompt.trim() }
+	};
+	const problems = launchProblems(workflow, request);
+	const line = workflowLaunchLine(request);
+	const launch = () => {
+		if (problems.length > 0) return;
+		requestLaunch(send, sessionId, line, workflow.path);
+		onLaunched();
+	};
+	const onPromptKeyDown = (event) => {
+		if (event.key === "Enter" && !event.shiftKey) {
+			event.preventDefault();
+			launch();
+		}
+	};
+	return /* @__PURE__ */ jsx(Dialog, {
+		open: true,
+		onOpenChange: (open) => {
+			if (!open) onClose();
+		},
+		children: /* @__PURE__ */ jsxs(DialogContent, {
+			width: "lg",
+			"data-testid": "launch-workflow-dialog",
+			"aria-describedby": void 0,
+			children: [/* @__PURE__ */ jsx(DialogHeader, { children: /* @__PURE__ */ jsxs("div", {
+				className: "flex min-w-0 flex-col items-start gap-1 sm:flex-row sm:items-center sm:gap-2.5",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						className: "text-sm text-doom-dim",
+						children: "launch workflow"
+					}),
+					/* @__PURE__ */ jsx(DialogTitle, {
+						"data-testid": "launch-workflow-name",
+						className: "max-w-full break-words",
+						children: workflow.name
+					}),
+					/* @__PURE__ */ jsx(Badge, {
+						size: "xs",
+						className: "max-w-full truncate",
+						children: workflow.relativePath
+					})
+				]
+			}) }), /* @__PURE__ */ jsxs(DialogBody, { children: [
+				/* @__PURE__ */ jsx("p", {
+					className: "text-sm leading-relaxed text-doom-dim",
+					children: workflow.description || "This workflow declares no description."
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: "flex flex-col gap-1.5",
+					children: [
+						/* @__PURE__ */ jsx(FieldLabel, { children: "Prompt" }),
+						/* @__PURE__ */ jsx(Textarea, {
+							"data-testid": "launch-prompt",
+							autoFocus: true,
+							rows: PROMPT_ROWS,
+							value: prompt,
+							placeholder: "what should this run do? it becomes WORKFLOW_CONTEXT for every job",
+							onChange: (event) => setPrompt(event.target.value),
+							onKeyDown: onPromptKeyDown
+						}),
+						/* @__PURE__ */ jsx("span", {
+							className: "text-sm text-doom-dim",
+							children: "enter launches · shift+enter for a new line"
+						})
+					]
+				}),
+				workflow.inputs.length === 0 ? null : /* @__PURE__ */ jsxs("div", {
+					className: "flex flex-col gap-2",
+					children: [/* @__PURE__ */ jsxs("div", {
+						className: "flex items-center gap-2",
+						children: [/* @__PURE__ */ jsx(FieldLabel, { children: "Inputs" }), /* @__PURE__ */ jsxs("span", {
+							className: "text-sm text-doom-dim",
+							children: [
+								"workflow_dispatch · ",
+								workflow.inputs.length,
+								" declared"
+							]
+						})]
+					}), workflow.inputs.map((input) => /* @__PURE__ */ jsx(InputField, {
+						input,
+						value: inputs[input.name] ?? "",
+						onChange: (next) => setInputs((current) => ({
+							...current,
+							[input.name]: next
+						}))
+					}, input.name))]
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: "flex flex-wrap gap-5",
+					children: [
+						/* @__PURE__ */ jsxs("div", {
+							className: "flex flex-col gap-1.5",
+							children: [
+								/* @__PURE__ */ jsx(FieldLabel, { children: "Runner" }),
+								workflow.runners === void 0 || workflow.runners.length === 0 ? /* @__PURE__ */ jsx("span", {
+									className: "flex h-7 items-center text-base text-doom-dim",
+									children: "whatever the workflow resolves"
+								}) : /* @__PURE__ */ jsxs(Select, {
+									value: runner,
+									onValueChange: setRunner,
+									children: [/* @__PURE__ */ jsx(SelectTrigger, {
+										"data-testid": "launch-runner",
+										className: "h-7 w-full min-w-0 sm:min-w-[160px]",
+										children: /* @__PURE__ */ jsx(SelectValue, {})
+									}), /* @__PURE__ */ jsx(SelectContent, { children: workflow.runners.map((choice) => /* @__PURE__ */ jsx(SelectItem, {
+										value: choice,
+										children: choice
+									}, choice)) })]
+								}),
+								/* @__PURE__ */ jsx("span", {
+									className: "text-sm text-doom-dim",
+									children: workflow.runners === void 0 ? "no runner map declared" : "the runners every step agrees on"
+								})
+							]
+						}),
+						workflow.commands === void 0 || workflow.commands.length === 0 ? null : /* @__PURE__ */ jsx(PickField, {
+							label: "Command",
+							testId: "launch-command",
+							options: workflow.commands,
+							value: command,
+							hint: "what agent steps run through",
+							onChange: setCommand
+						}),
+						workflow.choices === void 0 || workflow.choices.length === 0 ? null : /* @__PURE__ */ jsx(PickField, {
+							label: "Choice",
+							testId: "launch-choice",
+							options: workflow.choices,
+							value: choice,
+							hint: "model and thinking, unless a step pins one",
+							onChange: setChoice
+						}),
+						/* @__PURE__ */ jsxs("div", {
+							className: "flex flex-col gap-1.5",
+							children: [
+								/* @__PURE__ */ jsx(FieldLabel, { children: "Jobs" }),
+								/* @__PURE__ */ jsx("span", {
+									className: "flex h-7 items-center text-base text-doom-dim",
+									children: workflow.jobs.map((job) => job.name).join(" → ") || "none declared"
+								}),
+								/* @__PURE__ */ jsx("span", {
+									className: "text-sm text-doom-dim",
+									children: "in the order the file declares them"
+								})
+							]
+						}),
+						/* @__PURE__ */ jsxs("div", {
+							className: "flex flex-col gap-1.5",
+							children: [
+								/* @__PURE__ */ jsx(FieldLabel, { children: "Cwd" }),
+								/* @__PURE__ */ jsx("span", {
+									className: "flex h-7 items-center font-mono text-sm text-doom-dim",
+									children: cwd
+								}),
+								/* @__PURE__ */ jsx("span", {
+									className: "text-sm text-doom-dim",
+									children: "the session's directory"
+								})
+							]
+						})
+					]
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: "flex flex-col gap-1 rounded-md border border-doom-border bg-doom-deep px-3 py-2",
+					children: [/* @__PURE__ */ jsx(FieldLabel, { children: "Sent to the session" }), /* @__PURE__ */ jsx("pre", {
+						"data-testid": "launch-line",
+						className: "whitespace-pre-wrap break-words font-mono text-sm text-doom-green",
+						children: line
+					})]
+				}),
+				problems.length === 0 ? null : /* @__PURE__ */ jsx("p", {
+					"data-testid": "launch-problems",
+					className: "text-base text-doom-yellow",
+					children: problems.join(" ")
+				}),
+				/* @__PURE__ */ jsxs(DialogFooter, {
+					className: "flex-wrap sm:flex-nowrap",
+					children: [
+						/* @__PURE__ */ jsx("span", {
+							className: "w-full text-sm text-doom-dim sm:w-auto",
+							children: "the run appears on the board as soon as it starts"
+						}),
+						/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }),
+						/* @__PURE__ */ jsx(Button, {
+							variant: "outline",
+							size: "xs",
+							"data-testid": "launch-cancel",
+							onClick: onClose,
+							children: "cancel"
+						}),
+						/* @__PURE__ */ jsx(Button, {
+							variant: "primary",
+							size: "xs",
+							"data-testid": "launch-submit",
+							disabled: problems.length > 0,
+							onClick: launch,
+							children: "launch"
+						})
+					]
+				})
+			] })]
+		})
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/WorkflowCatalogDrawer.tsx
+const INPUT_TAG = "INPUT";
+/** The unfolded row: what the file declares, read-only, as the TUI catalog's tabs show it. */
+function Detail({ workflow }) {
+	const rows = [
+		["triggers", workflow.triggers.length > 0 ? workflow.triggers.join(", ") : "none declared"],
+		["inputs", workflow.inputs.length > 0 ? workflow.inputs.map((input) => `${input.name}${input.required ? "*" : ""}${input.default ? ` = ${input.default}` : ""}`).join(", ") : "none declared"],
+		["jobs", workflow.jobs.length > 0 ? workflow.jobs.map((job) => job.name).join(" → ") : "none declared"],
+		["artifacts", workflow.artifacts.length > 0 ? workflow.artifacts.map((entry) => entry.path).join(", ") : "none declared"],
+		["runners", workflow.runners === void 0 ? "any runner" : workflow.runners.join(", ") || "none in common"],
+		["file", workflow.relativePath]
+	];
+	return /* @__PURE__ */ jsx("dl", {
+		"data-testid": `catalog-detail-${workflow.name}`,
+		className: "flex flex-col gap-1 pt-1 text-sm",
+		children: rows.map(([label, value]) => /* @__PURE__ */ jsxs("div", {
+			className: "flex gap-2",
+			children: [/* @__PURE__ */ jsx("dt", {
+				className: "w-16 shrink-0 text-doom-dim",
+				children: label
+			}), /* @__PURE__ */ jsx("dd", {
+				className: "min-w-0 break-words text-doom-dim",
+				children: value
+			})]
+		}, label))
+	});
+}
+function WorkflowRow({ workflow, selected, inspected, onSelect, onLaunch, onInspect }) {
+	const jobs = workflow.jobs.length;
+	return /* @__PURE__ */ jsxs("div", {
+		role: "option",
+		"aria-selected": selected,
+		tabIndex: -1,
+		"data-testid": `catalog-workflow-${workflow.name}`,
+		"data-selected": selected,
+		onClick: onSelect,
+		onDoubleClick: onLaunch,
+		className: `flex cursor-pointer flex-col gap-1 border-l-2 px-4 py-2 ${selected ? "border-doom-blue bg-doom-panel" : "border-transparent hover:bg-doom-panel/60"}`,
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex min-w-0 items-center gap-2",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						className: "truncate text-base font-semibold text-doom-hi",
+						children: workflow.name
+					}),
+					workflow.tags.map((tag) => /* @__PURE__ */ jsx(Badge, {
+						size: "xs",
+						className: "shrink-0",
+						children: tag
+					}, tag)),
+					/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }),
+					/* @__PURE__ */ jsx("span", {
+						className: `shrink-0 text-sm ${workflow.error === void 0 ? "text-doom-cyan" : "text-doom-red"}`,
+						children: workflow.error === void 0 ? `${jobs} job${jobs === 1 ? "" : "s"}` : "needs fixing"
+					})
+				]
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "truncate text-sm text-doom-dim",
+				children: workflow.description || workflow.relativePath
+			}),
+			workflow.error === void 0 ? /* @__PURE__ */ jsxs("span", {
+				className: "truncate text-sm text-doom-dim",
+				children: [
+					workflow.inputs.length,
+					" input",
+					workflow.inputs.length === 1 ? "" : "s",
+					" ·",
+					" ",
+					workflow.runners === void 0 ? "any runner" : workflow.runners.join(", ") || "no runner in common",
+					workflow.artifacts.length > 0 ? ` · ${workflow.artifacts.length} artifacts` : ""
+				]
+			}) : /* @__PURE__ */ jsx("span", {
+				className: "truncate text-base text-doom-red",
+				children: workflow.error
+			}),
+			selected ? /* @__PURE__ */ jsxs("div", {
+				className: "flex items-center gap-3 pt-0.5",
+				children: [/* @__PURE__ */ jsxs(Button, {
+					variant: "link",
+					size: "xs",
+					"data-testid": `catalog-launch-${workflow.name}`,
+					className: "px-0",
+					disabled: workflow.error !== void 0,
+					onClick: (event) => {
+						event.stopPropagation();
+						onLaunch();
+					},
+					children: ["launch ", /* @__PURE__ */ jsx(Kbd, { children: "↵" })]
+				}), /* @__PURE__ */ jsxs(Button, {
+					variant: "link",
+					size: "xs",
+					"data-testid": `catalog-inspect-${workflow.name}`,
+					className: "px-0 text-doom-dim",
+					onClick: (event) => {
+						event.stopPropagation();
+						onInspect();
+					},
+					children: ["inspect ", /* @__PURE__ */ jsx(Kbd, { children: "i" })]
+				})]
+			}) : null,
+			selected && inspected ? /* @__PURE__ */ jsx(Detail, { workflow }) : null
+		]
+	});
+}
+/**
+* The workflow catalog, in the workflows tab's drawer: every workflow the
+* session's directory declares, with a filter and the keys the TUI catalog
+* also answers to. Launching hands the chosen workflow to the dialog.
+*/
+function WorkflowCatalogDrawer({ sessionId, onClose, onLaunch }) {
+	const state = useStore(catalog.store, (current) => catalog.select(current, sessionId));
+	const shown = filterCatalog(state.workflows, state.filter);
+	const selected = shown.find((workflow) => workflow.path === state.selected) ?? shown[0];
+	const move = (delta) => {
+		if (shown.length === 0) return;
+		const index = selected === void 0 ? -1 : shown.findIndex((workflow) => workflow.path === selected.path);
+		const next = shown[(index + delta + shown.length) % shown.length];
+		if (next) selectWorkflow(sessionId, next.path);
+	};
+	const onKeyDown = (event) => {
+		const typing = event.target.tagName === INPUT_TAG;
+		if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+			event.preventDefault();
+			move(event.key === "ArrowDown" ? 1 : -1);
+			return;
+		}
+		if (event.key === "Escape") {
+			event.preventDefault();
+			onClose();
+			return;
+		}
+		if (selected === void 0) return;
+		if (event.key === "Enter") {
+			event.preventDefault();
+			if (selected.error === void 0) onLaunch(selected);
+			return;
+		}
+		if (typing) return;
+		if (event.key === "i") toggleInspect(sessionId, selected.path);
+	};
+	return /* @__PURE__ */ jsxs("aside", {
+		"data-testid": "workflow-catalog-drawer",
+		tabIndex: 0,
+		onKeyDown,
+		className: "flex w-[min(440px,calc(100vw-24px))] max-w-full shrink-0 flex-col overflow-hidden border-l border-doom-border bg-doom-rail outline-none",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex h-11 shrink-0 items-center gap-2.5 border-b border-doom-border px-4",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						className: "text-lg font-semibold text-doom-hi",
+						children: "workflow catalog"
+					}),
+					/* @__PURE__ */ jsxs(Badge, {
+						size: "xs",
+						"data-testid": "catalog-count",
+						children: [
+							state.workflows.length,
+							" workflow",
+							state.workflows.length === 1 ? "" : "s"
+						]
+					}),
+					/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }),
+					/* @__PURE__ */ jsx(Kbd, { children: "SPC w l" }),
+					/* @__PURE__ */ jsx(Button, {
+						variant: "ghost",
+						size: "icon",
+						"data-testid": "catalog-close",
+						title: "close the catalog",
+						onClick: onClose,
+						children: /* @__PURE__ */ jsx(CloseIcon, { className: "h-3 w-3" })
+					})
+				]
+			}),
+			/* @__PURE__ */ jsx("div", {
+				className: "px-4 pt-2.5 pb-1.5",
+				children: /* @__PURE__ */ jsx(Input, {
+					"data-testid": "catalog-filter",
+					value: state.filter,
+					placeholder: "filter by name, tag, or job…",
+					autoFocus: true,
+					onChange: (event) => setCatalogFilter(sessionId, event.target.value)
+				})
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				role: "listbox",
+				className: "flex min-h-0 flex-1 flex-col overflow-y-auto pb-2",
+				children: [shown.length === 0 ? /* @__PURE__ */ jsx("p", {
+					"data-testid": "catalog-empty",
+					className: "px-4 py-3 text-sm text-doom-dim",
+					children: state.warning ?? (state.workflows.length === 0 ? "no workflows found for this session; add one under automations/workflows" : "nothing matches the filter")
+				}) : null, shown.map((workflow) => /* @__PURE__ */ jsx(WorkflowRow, {
+					workflow,
+					selected: selected?.path === workflow.path,
+					inspected: state.inspected === workflow.path,
+					onSelect: () => selectWorkflow(sessionId, workflow.path),
+					onLaunch: () => onLaunch(workflow),
+					onInspect: () => toggleInspect(sessionId, workflow.path)
+				}, workflow.path))]
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex h-8 shrink-0 items-center justify-between border-t border-doom-border-soft bg-doom-deep px-4",
+				children: [/* @__PURE__ */ jsx("span", {
+					className: "shrink-0 text-sm text-doom-dim",
+					children: "↑↓ choose · enter launch · i inspect · esc close"
+				}), /* @__PURE__ */ jsx("span", {
+					className: "min-w-0 truncate font-mono text-sm text-doom-dim",
+					children: state.cwd
+				})]
+			})
+		]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/_components/WorkflowLauncherOverlay.tsx
+/**
+* The workflow catalog and its launch dialog, over whatever the session shows.
+*
+* Every way in (SPC w l, the Activity launcher, a work item's context action)
+* only flips the catalog store, so the surface lives in the host's overlay
+* slot rather than in a tab the reader would have to open first.
+*/
+function WorkflowLauncherOverlay({ sessionId, sendSessionFrame }) {
+	const state = useStore(catalog.store, (current) => catalog.select(current, sessionId));
+	if (sessionId === null) return null;
+	const launching = state.workflows.find((workflow) => workflow.path === state.launch);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Sheet, {
+		open: state.open,
+		onOpenChange: (open) => {
+			if (!open) closeCatalog(sessionId);
+		},
+		children: /* @__PURE__ */ jsxs(SheetContent, {
+			side: "right",
+			width: "md",
+			"aria-describedby": void 0,
+			className: "border-l-0",
+			children: [/* @__PURE__ */ jsx(SheetTitle, {
+				className: "sr-only",
+				children: "workflow catalog"
+			}), /* @__PURE__ */ jsx("div", {
+				"data-testid": "workflow-launcher-sheet",
+				className: "flex min-h-0 flex-1",
+				children: /* @__PURE__ */ jsx(WorkflowCatalogDrawer, {
+					sessionId,
+					onClose: () => closeCatalog(sessionId),
+					onLaunch: (workflow) => openLaunch(sessionId, workflow.path)
+				})
+			})]
+		})
+	}), launching === void 0 ? null : /* @__PURE__ */ jsx(LaunchWorkflowDialog, {
+		sessionId,
+		workflow: launching,
+		cwd: state.cwd,
+		initialPrompt: state.prompt,
+		send: sendSessionFrame,
+		onClose: () => closeLaunch(sessionId),
+		onLaunched: () => {
+			closeLaunch(sessionId);
+			closeCatalog(sessionId);
+		}
+	})] });
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/WorkflowLauncher.overlay.web.tsx
+var WorkflowLauncher_overlay_web_default = defineFill({ component: WorkflowLauncherOverlay });
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/Workflows.activity.workflows.web.tsx
+var Workflows_activity_workflows_web_default = defineFill({
+	slot: "activity.workflows",
+	..._lib_default.activitySections[0]
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/leader/catalog.web.ts
+var catalog_web_default = defineLeaderBinding(_lib_default.leaderBindings[0]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/leader/toggle.web.ts
+var toggle_web_default = defineLeaderBinding(_lib_default.leaderBindings[1]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/mode/workflow/mode.web.ts
+var mode_web_default = defineMinorModeFile(_lib_default.minorModes[0]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/workflow.web.tsx
+var workflow_web_default = defineToolRenderer(_lib_default.toolRenderers[0]);
+//#endregion
+//#region generated/web.ts
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const webPlugin = defineWebPlugin({
+	id: "workflows",
+	session: {
+		get activityGroups() {
+			return [via({ name: "workflows" }, workflows_web_default)];
+		},
+		get channels() {
+			return [via({ channel: "workflow_catalog" }, workflow_catalog_web_default), via({ channel: "workflow_runs" }, workflow_runs_web_default)];
+		},
+		get contextActions() {
+			return [via({ id: "launch-workflow" }, launch_workflow_web_default)];
+		},
+		get dockFaces() {
+			return [via({ id: "workflow" }, workflow_web_default$1)];
+		},
+		get fills() {
+			return [via({
+				slot: "overlay",
+				id: "workflow-launcher"
+			}, WorkflowLauncher_overlay_web_default), via({
+				slot: "activity.workflows",
+				id: "workflows"
+			}, Workflows_activity_workflows_web_default)];
+		},
+		get leaderBindings() {
+			return [via({ id: "workflows.catalog" }, catalog_web_default), via({ id: "workflows.toggle" }, toggle_web_default)];
+		},
+		get minorModes() {
+			return [via({ name: "workflow" }, mode_web_default)];
+		},
+		get toolRenderers() {
+			return [via({ tools: ["workflow"] }, workflow_web_default)];
+		}
+	}
+});
+//#endregion
+export { webPlugin };
+
+//# sourceMappingURL=web.mjs.map