@agimon-ai/doompi-workflow 0.0.1-alpha.76 → 0.0.1-alpha.78

package/dist/extensions/web.mjs

@@ -0,0 +1,3219 @@
+import { apiResponse, createApiClient, defineActivityGroup, defineApiRoutes, defineChannelFile, defineContextAction, defineFill, defineLeaderBinding, defineMinorModeFile, defineSessionStore, defineToolRenderer, defineWebPlugin, sessionApiAddress } from "@agimon-ai/doompi-core/web";
+import { AnsiLine, 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, Select, SelectContent, SelectItem, SelectTrigger, SelectValue, StatusBadge, StreamCursor, Textarea, cn, toolTone } from "@agimon-ai/doompi-web-components";
+import { useStore } from "@tanstack/react-store";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { sealedTransport } from "@agimon-ai/doompi-web-security/browser";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/types/webWorkflows.ts
+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, tab) {
+	if (context.sessionId === null) return;
+	openCatalog(context.sessionId, context.item.content);
+	context.openTransientTab(tab());
+}
+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/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{.+}";
+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`,
+		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()
+	},
+	artifacts: {
+		method: "GET",
+		path: `${RUN}/artifacts`,
+		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$1(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("/"));
+}
+/**
+* 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) {
+	const source = new EventSource(scoped(sessionId).screen.url({ params: runParams(workspace, runKey) }));
+	const handler = (message) => {
+		let parsed;
+		try {
+			parsed = JSON.parse(message.data);
+		} catch {
+			return;
+		}
+		if (!isRecord$1(parsed) || !Array.isArray(parsed.lines)) return;
+		onEvent(parsed);
+	};
+	source.addEventListener(WORKFLOW_SCREEN_EVENT, handler);
+	return () => {
+		source.removeEventListener(WORKFLOW_SCREEN_EVENT, handler);
+		source.close();
+	};
+}
+/** Takes the keyboard for one run, renewing when this page already holds it. */
+async function takeControl(workspace, runKey, token, sessionId) {
+	const result = await scoped(sessionId).control({
+		params: runParams(workspace, runKey),
+		body: { token }
+	});
+	if (result.status === 0) return {
+		held: false,
+		reason: UNREACHABLE
+	};
+	if (isRecord$1(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) {
+	await scoped(sessionId).control({
+		params: runParams(workspace, runKey),
+		body: {
+			token,
+			release: true
+		}
+	});
+}
+/** Sends literal keystrokes; the reason comes back when the lease has moved on. */
+async function sendKeys(workspace, runKey, token, data, sessionId) {
+	const result = await scoped(sessionId).keys({
+		params: runParams(workspace, runKey),
+		body: {
+			token,
+			data
+		}
+	});
+	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." };
+}
+async function fetchArtifacts(workspace, runKey, sessionId) {
+	const result = await scoped(sessionId).artifacts({ params: runParams(workspace, runKey) });
+	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$1(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)/_lib/workflowActivity.ts
+const PAUSED_STATES = /* @__PURE__ */ new Set(["paused", "pause_requested"]);
+function workflowRunIdentity(run) {
+	return `${run.workspace}/${run.runKey}`;
+}
+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) {
+	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)
+		};
+	});
+}
+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(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(input) || !Array.isArray(input.runs)) return null;
+		return { runs: input.runs.filter(isRecord) };
+	},
+	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)/_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-bold",
+					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-sm font-bold text-doom-hi",
+						children: path
+					}),
+					/* @__PURE__ */ jsx(Badge, {
+						size: "xs",
+						children: mimeType ?? "artifact"
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: "text-2xs text-doom-faint",
+						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-xs text-doom-yellow",
+					children: error
+				}) : content === void 0 ? /* @__PURE__ */ jsx("span", {
+					className: "text-xs text-doom-faint",
+					children: "loading preview"
+				}) : /* @__PURE__ */ jsx(ArtifactPreview, {
+					content,
+					rawUrl,
+					raw
+				})
+			}),
+			content?.truncated === true ? /* @__PURE__ */ jsxs("span", {
+				className: "pt-2 text-2xs text-doom-faint",
+				children: [
+					"this preview shows the first ",
+					formatSize(content.text?.length),
+					"; download the artifact for the complete file"
+				]
+			}) : null
+		]
+	});
+}
+/**
+* The run directory, as the run pane's second tab.
+*
+* The workflow's own declaration leads, in the order it was written and
+* including entries no job has produced yet, because the declaration is what
+* the run is for. What the folder holds besides that follows.
+*/
+function ArtifactsPane({ run, sessionId, onOpen }) {
+	const [listing, setListing] = useState();
+	const [error, setError] = useState();
+	useEffect(() => {
+		let live = true;
+		const read = () => {
+			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);
+			});
+		};
+		read();
+		if (run.stage !== "running") return;
+		const timer = setInterval(read, 5e3);
+		return () => {
+			live = false;
+			clearInterval(timer);
+		};
+	}, [
+		run.workspace,
+		run.runKey,
+		run.stage,
+		sessionId
+	]);
+	const declared = listing?.artifacts.filter((entry) => entry.declared) ?? [];
+	const found = listing?.artifacts.filter((entry) => !entry.declared) ?? [];
+	const Row = ({ entry }) => {
+		const glyph = STATE_GLYPH[entry.state];
+		const openable = entry.kind === "file" && entry.state !== "pending";
+		return /* @__PURE__ */ jsxs("button", {
+			type: "button",
+			"data-testid": `artifact-row-${entry.path}`,
+			"data-artifact-state": entry.state,
+			disabled: !openable,
+			onClick: () => 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: glyph.glyph
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: `truncate text-sm ${entry.state === "pending" ? "text-doom-dim" : "text-doom-hi"}`,
+						children: entry.path
+					}),
+					entry.producedBy.length === 0 ? null : /* @__PURE__ */ jsx(Badge, {
+						size: "xs",
+						tone: "violet",
+						className: "shrink-0",
+						children: entry.producedBy.join(", ")
+					}),
+					/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }),
+					/* @__PURE__ */ jsx("span", {
+						className: "shrink-0 text-2xs text-doom-faint",
+						children: entry.state === "pending" ? "not written yet" : `${formatSize(entry.size)} · ${formatWhen(entry.modifiedAt)}`
+					})
+				]
+			}), entry.description === "" ? null : /* @__PURE__ */ jsx("span", {
+				className: "truncate pl-5 text-2xs text-doom-faint",
+				children: entry.description
+			})]
+		});
+	};
+	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,
+			declared.length === 0 && found.length === 0 && error === void 0 ? /* @__PURE__ */ jsx(EmptyState, {
+				className: "py-4",
+				title: "nothing in the run directory yet"
+			}) : null,
+			declared.length === 0 ? null : /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsxs("span", {
+				className: "px-3 pb-1 pt-2 text-2xs font-bold tracking-wider text-doom-faint",
+				children: ["DECLARED · ", listing?.description || "run-directory"]
+			}), declared.map((entry) => /* @__PURE__ */ jsx(Row, { entry }, entry.path))] }),
+			found.length === 0 ? null : /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("span", {
+				className: "px-3 pb-1 pt-3 text-2xs font-bold tracking-wider text-doom-faint",
+				children: "ALSO IN THE FOLDER"
+			}), found.map((entry) => /* @__PURE__ */ jsx(Row, { entry }, entry.path))] }),
+			listing === void 0 ? null : /* @__PURE__ */ jsx("span", {
+				className: "truncate px-3 py-2 text-2xs text-doom-faint",
+				children: listing.runDir
+			})
+		]
+	});
+}
+//#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";
+/** The reserved key; every other pair is one of the workflow's own inputs. */
+const RUNNER_KEY = "runner";
+/** Quotes a value that carries whitespace, which is how a value survives tokenizing. */
+function quote(value) {
+	return /\s/.test(value) ? `"${value}"` : value;
+}
+function workflowLaunchLine(request) {
+	const pairs = [...request.runner === void 0 || request.runner === "" ? [] : [`${RUNNER_KEY}=${quote(request.runner)}`], ...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];
+}
+//#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-2xs font-bold tracking-widest text-doom-faint",
+		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-xs font-bold 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 text-xs 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-2xs text-doom-faint sm:w-40 sm:shrink-0",
+				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 request = {
+		workflow: workflow.name === "" ? workflow.relativePath : workflow.name,
+		...runner === void 0 ? {} : { runner },
+		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-2xs text-doom-faint",
+						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-2xs text-doom-faint",
+							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-2xs text-doom-faint",
+							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-xs 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 text-xs 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-2xs text-doom-faint",
+									children: workflow.runners === void 0 ? "no runner map declared" : "the runners every step agrees on"
+								})
+							]
+						}),
+						/* @__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-xs text-doom-dim",
+									children: workflow.jobs.map((job) => job.name).join(" → ") || "none declared"
+								}),
+								/* @__PURE__ */ jsx("span", {
+									className: "text-2xs text-doom-faint",
+									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 text-xs text-doom-dim",
+									children: cwd
+								}),
+								/* @__PURE__ */ jsx("span", {
+									className: "text-2xs text-doom-faint",
+									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 text-xs text-doom-green",
+						children: line
+					})]
+				}),
+				problems.length === 0 ? null : /* @__PURE__ */ jsx("p", {
+					"data-testid": "launch-problems",
+					className: "text-xs text-doom-yellow",
+					children: problems.join(" ")
+				}),
+				/* @__PURE__ */ jsxs(DialogFooter, {
+					className: "flex-wrap sm:flex-nowrap",
+					children: [
+						/* @__PURE__ */ jsx("span", {
+							className: "w-full text-2xs text-doom-faint 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/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
+		})
+	};
+}
+function ScreenLine$1({ line }) {
+	if (line.length === 0) return /* @__PURE__ */ jsx("span", { className: "block h-[15px]" });
+	return /* @__PURE__ */ jsx(AnsiLine, {
+		line,
+		className: "block whitespace-pre"
+	});
+}
+/**
+* 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 StepTerminalPanel({ sessionId, target }) {
+	const run = useStore(workflows.store, (state) => workflows.select(state, sessionId).runs).find((candidate) => candidate.workspace === target.workspace && candidate.runKey === target.runKey);
+	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);
+	useEffect(() => {
+		setEnded(false);
+		return followScreen(target.workspace, target.runKey, (event) => {
+			setLines(event.lines);
+			setCapabilities(event.capabilities);
+			if (event.ended === true) setEnded(true);
+		}, sessionId);
+	}, [
+		sessionId,
+		target.workspace,
+		target.runKey
+	]);
+	useEffect(() => {
+		if (token === void 0) return;
+		return () => {
+			releaseControl(target.workspace, target.runKey, token, sessionId);
+		};
+	}, [
+		sessionId,
+		token,
+		target.workspace,
+		target.runKey
+	]);
+	useEffect(() => {
+		screenRef.current?.scrollTo({ top: screenRef.current.scrollHeight });
+	}, [lines]);
+	const arm = useCallback(async () => {
+		const result = await takeControl(target.workspace, target.runKey, void 0, sessionId);
+		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
+	]);
+	const disarm = useCallback(async () => {
+		if (token !== void 0) await releaseControl(target.workspace, target.runKey, token, sessionId);
+		setToken(void 0);
+	}, [
+		sessionId,
+		token,
+		target.workspace,
+		target.runKey
+	]);
+	const type = async (data) => {
+		if (token === void 0) return;
+		const { error } = await sendKeys(target.workspace, target.runKey, token, data, sessionId);
+		if (error !== void 0) {
+			setNotice(error);
+			setToken(void 0);
+		}
+	};
+	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("div", {
+				"data-testid": "step-terminal-head",
+				className: "flex items-center gap-2.5 pb-3",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						className: "shrink-0 truncate text-sm font-bold 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-sm font-bold text-doom-blue",
+						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-sm 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" }),
+					/* @__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: () => void (held ? disarm() : 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-xs text-doom-faint",
+					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$1, { 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-2xs text-doom-faint",
+						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-2xs text-doom-faint",
+						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-2xs text-doom-yellow",
+						children: notice
+					})
+				]
+			})
+		]
+	});
+}
+//#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-2xs",
+		children: rows.map(([label, value]) => /* @__PURE__ */ jsxs("div", {
+			className: "flex gap-2",
+			children: [/* @__PURE__ */ jsx("dt", {
+				className: "w-16 shrink-0 text-doom-faint",
+				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-sm font-bold 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-2xs ${workflow.error === void 0 ? "text-doom-cyan" : "text-doom-red"}`,
+						children: workflow.error === void 0 ? `${jobs} job${jobs === 1 ? "" : "s"}` : "unreadable"
+					})
+				]
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "truncate text-xs text-doom-dim",
+				children: workflow.description || workflow.relativePath
+			}),
+			workflow.error === void 0 ? /* @__PURE__ */ jsxs("span", {
+				className: "truncate text-2xs text-doom-faint",
+				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-2xs 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))] 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-base font-bold 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-xs text-doom-faint",
+					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: "text-2xs text-doom-faint",
+					children: "↑↓ choose · enter launch · i inspect · esc close"
+				}), /* @__PURE__ */ jsx("span", {
+					className: "text-2xs text-doom-faint",
+					children: state.cwd
+				})]
+			})
+		]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/WorkflowsPanel.tsx
+/** One workflows tab per session; the surface is singular, so the id needs nothing else. */
+const WORKFLOWS_TAB_ID = "workflows-runs";
+const TICK_MS$1 = 1e4;
+const STATE_ICON = {
+	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.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;
+}
+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 }) {
+	const [open, setOpen] = useState(false);
+	const [query, setQuery] = useState("");
+	const matching = useMemo(() => [...runs].sort((left, right) => runPriority(left) - runPriority(right)), [runs]).filter((run) => runSearchText(run).includes(query.trim().toLowerCase()));
+	const sections = [
+		{
+			label: "needs you",
+			runs: matching.filter((run) => attentionFor(run) !== void 0)
+		},
+		{
+			label: "active",
+			runs: matching.filter((run) => attentionFor(run) === void 0 && run.stage === "running")
+		},
+		{
+			label: "recent",
+			runs: matching.filter((run) => run.stage !== "running" && attentionFor(run) === void 0)
+		}
+	].filter((section) => section.runs.length > 0);
+	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: "h-8 w-full max-w-[360px] justify-start border-doom-border bg-doom-deep px-2.5",
+				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 font-bold text-doom-hi",
+						children: selected.displayName
+					}),
+					/* @__PURE__ */ jsxs("span", {
+						className: "shrink-0 text-2xs font-normal text-doom-faint",
+						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-[600px]",
+			children: [
+				/* @__PURE__ */ jsx(PopoverHeader, { children: /* @__PURE__ */ jsxs("span", {
+					className: "relative flex w-full items-center",
+					children: [/* @__PURE__ */ jsx(SearchIcon, { className: "pointer-events-none absolute left-2.5 h-3 w-3 text-doom-blue" }), /* @__PURE__ */ jsx(Input, {
+						autoFocus: true,
+						size: "sm",
+						"data-testid": "workflow-picker-search",
+						value: query,
+						onChange: (event) => setQuery(event.target.value),
+						placeholder: `Search ${String(runs.length)} workflows by name, job, or status`,
+						className: "w-full pl-8"
+					})]
+				}) }),
+				/* @__PURE__ */ jsx("div", {
+					className: "grid max-h-[360px] grid-cols-1 gap-2 overflow-y-auto p-2 sm:grid-cols-2",
+					children: sections.length === 0 ? /* @__PURE__ */ jsx("span", {
+						className: "px-2 py-5 text-center text-xs text-doom-faint sm:col-span-2",
+						children: "no matching workflows"
+					}) : sections.map((section) => /* @__PURE__ */ jsxs("div", {
+						className: "flex min-w-0 flex-col gap-0.5",
+						children: [/* @__PURE__ */ jsxs("span", {
+							className: "px-2 py-1 text-2xs font-bold uppercase tracking-wider text-doom-faint",
+							children: [
+								section.label,
+								" · ",
+								section.runs.length
+							]
+						}), section.runs.map((run) => {
+							const active = workflowRunIdentity(run) === workflowRunIdentity(selected);
+							return /* @__PURE__ */ jsxs("button", {
+								type: "button",
+								"data-testid": `workflow-option-${run.runKey}`,
+								"data-run-stage": run.stage,
+								"data-active": active,
+								onClick: () => {
+									onSelect(run);
+									setOpen(false);
+								},
+								className: cn("flex min-w-0 flex-col gap-0.5 rounded px-2 py-1.5 text-left hover:bg-doom-deep", active && "bg-doom-tint-blue ring-1 ring-inset ring-doom-blue/50"),
+								children: [/* @__PURE__ */ jsxs("span", {
+									className: "flex min-w-0 items-center gap-2",
+									children: [
+										/* @__PURE__ */ jsx(Dot, {
+											tone: runDot(run),
+											pulse: run.stage === "running"
+										}),
+										/* @__PURE__ */ jsx("span", {
+											className: cn("min-w-0 flex-1 truncate text-xs", active && "font-bold text-doom-hi"),
+											children: run.displayName
+										}),
+										/* @__PURE__ */ jsx("span", {
+											className: "shrink-0 text-2xs text-doom-faint",
+											children: runState(run)
+										})
+									]
+								}), /* @__PURE__ */ jsx("span", {
+									className: "truncate pl-3.5 text-2xs text-doom-dim",
+									children: [run.position?.job, run.position?.step].filter(Boolean).join(" · ") || "settled"
+								})]
+							}, workflowRunIdentity(run));
+						})]
+					}, section.label))
+				}),
+				/* @__PURE__ */ jsxs(PopoverFooter, { children: [/* @__PURE__ */ jsx("span", { children: "needs you and active stay first" }), /* @__PURE__ */ jsx("span", { children: "esc closes" })] })
+			]
+		})]
+	});
+}
+function SelectedAttention({ run }) {
+	const attention = attentionFor(run);
+	if (attention === void 0) return null;
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "workflow-needs-you",
+		className: cn("flex items-center gap-2 rounded border px-3 py-2", attention.kind === "error" ? "border-doom-edge-red bg-doom-tint-red/40" : "border-doom-edge-yellow bg-doom-tint-yellow/40"),
+		children: [
+			/* @__PURE__ */ jsx(StatusBadge, {
+				size: "xs",
+				tone: attention.kind === "error" ? "error" : "running",
+				children: attention.kind === "error" ? "ERROR" : "PAUSED"
+			}),
+			/* @__PURE__ */ jsxs("span", {
+				"data-testid": `needs-card-${run.runKey}`,
+				className: "min-w-0 flex-1 truncate text-xs text-doom-text",
+				children: [
+					run.displayName,
+					": ",
+					attention.text
+				]
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "shrink-0 text-2xs text-doom-faint",
+				children: attention.kind === "error" ? "recover from the owning session" : "resume from the owning session"
+			})
+		]
+	});
+}
+function JobRow({ job, now, selected, onSelect }) {
+	const icon = STATE_ICON[job.status];
+	return /* @__PURE__ */ jsxs(OptionRow, {
+		density: "compact",
+		active: selected,
+		"data-testid": `job-row-${job.name}`,
+		"data-job-status": job.status,
+		onClick: onSelect,
+		className: cn("gap-2 rounded px-2 py-1.5", !selected && "hover:bg-doom-deep"),
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				className: `w-3 shrink-0 text-xs ${icon.className}`,
+				children: icon.glyph
+			}),
+			/* @__PURE__ */ jsx(OptionLabel, {
+				density: "compact",
+				className: cn("text-xs", selected ? "text-doom-hi" : "text-doom-text"),
+				children: job.name
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "shrink-0 text-2xs text-doom-faint",
+				children: spanDuration(job.startedAt, job.endedAt, now) ?? ""
+			})
+		]
+	});
+}
+function StepRow({ step, now, selected, onSelect }) {
+	const icon = STATE_ICON[step.status];
+	return /* @__PURE__ */ jsxs("button", {
+		type: "button",
+		"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 hover:bg-doom-deep", 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-2xs", step.status === "failed" ? "text-doom-red" : "text-doom-text"),
+					children: step.name
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: "shrink-0 text-2xs text-doom-faint",
+					children: spanDuration(step.startedAt, step.endedAt, now) ?? ""
+				})
+			]
+		}), step.reason === void 0 ? null : /* @__PURE__ */ jsx("span", {
+			className: cn("truncate pl-5 text-2xs", step.status === "failed" ? "text-doom-red" : "text-doom-faint"),
+			children: step.reason
+		})]
+	});
+}
+function ScreenLine({ line }) {
+	if (line.length === 0) return /* @__PURE__ */ jsx("span", { className: "block h-[15px]" });
+	return /* @__PURE__ */ jsx(AnsiLine, {
+		line,
+		className: "block whitespace-pre"
+	});
+}
+function InlineStepOutput({ run, job, step, sessionId, onOpenTerminal }) {
+	const [lines, setLines] = useState([]);
+	const [capabilities, setCapabilities] = useState();
+	const [ended, setEnded] = useState(false);
+	const screenRef = useRef(null);
+	useEffect(() => {
+		setLines([]);
+		setCapabilities(void 0);
+		setEnded(false);
+		return followScreen(run.workspace, run.runKey, (event) => {
+			setLines(event.lines);
+			setCapabilities(event.capabilities);
+			if (event.ended === true) setEnded(true);
+		}, sessionId);
+	}, [
+		run.workspace,
+		run.runKey,
+		sessionId
+	]);
+	useEffect(() => {
+		screenRef.current?.scrollTo({ top: screenRef.current.scrollHeight });
+	}, [lines]);
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "workflow-inline-output",
+		className: "flex min-h-0 flex-1 flex-col bg-doom-deep",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex h-9 shrink-0 items-center gap-2 border-b border-doom-border-soft px-3",
+				children: [
+					/* @__PURE__ */ jsx(Dot, {
+						tone: ended ? "neutral" : "blue",
+						pulse: !ended && run.stage === "running"
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: cn("text-2xs font-bold", ended ? "text-doom-faint" : "text-doom-blue"),
+						children: ended ? "FINAL OUTPUT" : "LIVE OUTPUT"
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: "min-w-0 truncate text-xs font-bold text-doom-hi",
+						children: step?.name ?? job.name
+					}),
+					/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }),
+					/* @__PURE__ */ jsx("span", {
+						className: "text-2xs text-doom-faint",
+						children: ended ? "settled" : "following · 500ms"
+					}),
+					/* @__PURE__ */ jsx(Button, {
+						variant: "outline",
+						size: "xs",
+						"data-testid": "workflow-open-terminal",
+						onClick: onOpenTerminal,
+						children: "open terminal"
+					})
+				]
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				ref: screenRef,
+				"data-testid": "workflow-inline-screen",
+				className: "min-h-0 flex-1 overflow-y-auto px-4 py-3 font-mono text-sm leading-tight text-doom-text",
+				children: [lines.length === 0 ? /* @__PURE__ */ jsx("span", {
+					className: "text-xs text-doom-faint",
+					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)), !ended && run.stage === "running" ? /* @__PURE__ */ jsx(StreamCursor, { className: "mt-0.5 h-[12px] w-1.5" }) : null]
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex h-7 shrink-0 items-center gap-2 border-t border-doom-border-soft px-3 text-2xs text-doom-faint",
+				children: [
+					/* @__PURE__ */ jsx("span", { children: "output follows automatically · select another step to inspect its current screen" }),
+					/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }),
+					/* @__PURE__ */ jsx("span", { children: "last 48 lines" })
+				]
+			})
+		]
+	});
+}
+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-xs 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"
+					})
+				] })
+			] })]
+		})
+	});
+}
+function DetailPane({ children }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: "flex min-h-0 min-w-0 flex-1 flex-col overflow-hidden rounded-md border border-doom-border",
+		children
+	});
+}
+/** The canonical workflow surface: a scalable picker, compact step navigation, and one dominant detail pane. */
+function WorkflowsPanel({ sessionId, openTransientTab, sendSessionFrame }) {
+	const runs = useStore(workflows.store, (state) => workflows.select(state, sessionId).runs);
+	const selectedRun = useStore(workflows.store, (state) => workflows.select(state, sessionId).focusedRun);
+	const catalogState = useStore(catalog.store, (state) => catalog.select(state, sessionId));
+	const [selectedJob, setSelectedJob] = useState(null);
+	const [selectedStep, setSelectedStep] = useState(null);
+	const [pane, setPane] = useState("output");
+	const [deletingRun, setDeletingRun] = useState();
+	const [now, setNow] = useState(() => Date.now());
+	useEffect(() => {
+		const timer = setInterval(() => setNow(Date.now()), TICK_MS$1);
+		return () => clearInterval(timer);
+	}, []);
+	const run = runs.find((candidate) => workflowRunIdentity(candidate) === selectedRun) ?? runs[0];
+	const jobs = run?.jobs ?? [];
+	const fallbackJob = run?.position?.job ?? jobs.find((candidate) => ACTIVE_STATES.has(candidate.status))?.name ?? jobs.at(-1)?.name;
+	const job = jobs.find((candidate) => candidate.name === selectedJob) ?? jobs.find((candidate) => candidate.name === fallbackJob);
+	const fallbackStep = run?.position?.job === job?.name ? run?.position?.step : job?.steps.find((candidate) => ACTIVE_STATES.has(candidate.status))?.name ?? job?.steps.at(-1)?.name;
+	const step = job?.steps.find((candidate) => candidate.name === selectedStep) ?? job?.steps.find((candidate) => candidate.name === fallbackStep);
+	const launching = catalogState.workflows.find((workflow) => workflow.path === catalogState.launch);
+	const selectRun = (candidate) => {
+		if (sessionId !== null) focusRun(sessionId, workflowRunIdentity(candidate));
+		setSelectedJob(null);
+		setSelectedStep(null);
+		setPane("output");
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "workflows-panel",
+		className: "flex min-h-0 flex-1",
+		children: [
+			/* @__PURE__ */ jsx("div", {
+				className: "flex min-w-0 flex-1 flex-col gap-3 overflow-hidden px-[18px] py-[14px]",
+				children: run === void 0 ? /* @__PURE__ */ jsx(EmptyState, {
+					"data-testid": "workflows-empty",
+					title: "no workflow runs yet",
+					description: "pick one from the catalog, or launch it from the session with SPC w l, and the run shows up here live.",
+					children: /* @__PURE__ */ jsxs(Button, {
+						variant: "outline",
+						size: "sm",
+						"data-testid": "workflows-open-catalog",
+						onClick: () => {
+							if (sessionId !== null) openCatalog(sessionId);
+						},
+						children: ["launch workflow ", /* @__PURE__ */ jsx(Kbd, { children: "SPC w l" })]
+					})
+				}) : /* @__PURE__ */ jsxs(Fragment, { children: [
+					/* @__PURE__ */ jsxs("div", {
+						className: "flex h-[46px] shrink-0 items-center gap-2 rounded-md border border-doom-border bg-doom-panel px-2.5",
+						children: [
+							/* @__PURE__ */ jsx(WorkflowPicker, {
+								runs,
+								selected: run,
+								onSelect: selectRun
+							}),
+							/* @__PURE__ */ jsx(StatusBadge, {
+								tone: run.stage === "error" ? "error" : run.stage === "running" ? "info" : "ok",
+								children: runState(run)
+							}),
+							/* @__PURE__ */ jsx("span", {
+								className: "truncate text-2xs text-doom-dim",
+								children: [run.position?.job, run.position?.step].filter(Boolean).join(" · ") || run.workflowName || run.displayName
+							}),
+							/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }),
+							/* @__PURE__ */ jsxs("span", {
+								"data-testid": "workflows-tally",
+								className: "text-2xs text-doom-faint",
+								children: [
+									runs.filter((candidate) => candidate.stage === "running").length,
+									" running · ",
+									runs.length,
+									" total"
+								]
+							}),
+							run.stage === "running" ? null : /* @__PURE__ */ jsx(Button, {
+								variant: "danger-outline",
+								size: "xs",
+								"data-testid": "delete-workflow",
+								onClick: () => setDeletingRun(run),
+								children: "delete"
+							}),
+							/* @__PURE__ */ jsx(Button, {
+								variant: "outline",
+								size: "xs",
+								"data-testid": "workflows-open-catalog",
+								onClick: () => {
+									if (sessionId !== null) openCatalog(sessionId);
+								},
+								children: "launch"
+							})
+						]
+					}),
+					/* @__PURE__ */ jsx(SelectedAttention, { run }),
+					/* @__PURE__ */ jsxs("div", {
+						className: "flex min-h-0 flex-1 flex-col gap-3 sm:flex-row",
+						children: [/* @__PURE__ */ jsxs("div", {
+							"data-testid": "jobs-pane",
+							className: "flex max-h-44 w-full shrink-0 flex-col overflow-y-auto rounded-md border border-doom-border bg-doom-panel p-1.5 sm:max-h-none sm:w-[214px]",
+							children: [
+								/* @__PURE__ */ jsxs("div", {
+									className: "flex items-center px-2 pb-1 pt-1",
+									children: [
+										/* @__PURE__ */ jsx("span", {
+											className: "text-2xs font-bold tracking-wider text-doom-faint",
+											children: "JOBS"
+										}),
+										/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }),
+										/* @__PURE__ */ jsxs("span", {
+											className: "text-2xs text-doom-faint",
+											children: [
+												jobs.filter((candidate) => candidate.status === "completed").length,
+												"/",
+												jobs.length
+											]
+										})
+									]
+								}),
+								jobs.length === 0 ? /* @__PURE__ */ jsx(EmptyState, {
+									className: "py-4",
+									title: "no progress recorded yet"
+								}) : jobs.map((candidate) => /* @__PURE__ */ jsx(JobRow, {
+									job: candidate,
+									now,
+									selected: job !== void 0 && candidate.name === job.name,
+									onSelect: () => {
+										setSelectedJob(candidate.name);
+										setSelectedStep(null);
+										setPane("output");
+									}
+								}, candidate.name)),
+								job === void 0 ? null : /* @__PURE__ */ jsxs(Fragment, { children: [
+									/* @__PURE__ */ jsx("div", { className: "mx-1 my-1.5 border-t border-doom-border-soft" }),
+									/* @__PURE__ */ jsxs("div", {
+										className: "flex items-center px-2 pb-1",
+										children: [/* @__PURE__ */ jsx("span", {
+											"data-testid": "job-pane-name",
+											className: "min-w-0 flex-1 truncate text-2xs font-bold text-doom-hi",
+											children: job.name
+										}), /* @__PURE__ */ jsx("span", {
+											className: "text-2xs text-doom-faint",
+											children: spanDuration(job.startedAt, job.endedAt, now) ?? ""
+										})]
+									}),
+									/* @__PURE__ */ jsx("div", {
+										className: "flex flex-col gap-0.5",
+										children: job.steps.map((candidate) => /* @__PURE__ */ jsx(StepRow, {
+											step: candidate,
+											now,
+											selected: step !== void 0 && candidate.name === step.name,
+											onSelect: () => {
+												setSelectedStep(candidate.name);
+												setPane("output");
+											}
+										}, candidate.name))
+									})
+								] })
+							]
+						}), /* @__PURE__ */ jsxs(DetailPane, { children: [/* @__PURE__ */ jsxs("div", {
+							className: "flex h-9 shrink-0 items-center gap-2 border-b border-doom-border-soft bg-doom-panel px-3",
+							children: [
+								/* @__PURE__ */ jsx("span", {
+									className: "min-w-0 truncate text-xs font-bold text-doom-hi",
+									children: job?.name ?? run.displayName
+								}),
+								job === void 0 ? null : /* @__PURE__ */ jsx(StatusBadge, {
+									className: cn("bg-doom-deep", STATE_ICON[job.status].className),
+									children: job.status.replace("_", " ")
+								}),
+								/* @__PURE__ */ jsx(Button, {
+									variant: pane === "output" ? "primary" : "outline",
+									size: "xs",
+									"data-testid": "pane-tab-output",
+									"data-active": pane === "output",
+									onClick: () => setPane("output"),
+									children: "output"
+								}),
+								/* @__PURE__ */ jsx(Button, {
+									variant: pane === "artifacts" ? "primary" : "outline",
+									size: "xs",
+									"data-testid": "pane-tab-artifacts",
+									"data-active": pane === "artifacts",
+									onClick: () => setPane("artifacts"),
+									children: "artifacts"
+								})
+							]
+						}), pane === "artifacts" ? /* @__PURE__ */ jsx(ArtifactsPane, {
+							run,
+							sessionId,
+							onOpen: (path) => openTransientTab(artifactTab(run, path))
+						}) : job === void 0 ? /* @__PURE__ */ jsx(EmptyState, {
+							className: "py-6",
+							title: "select a job to see its output"
+						}) : /* @__PURE__ */ jsx(InlineStepOutput, {
+							run,
+							job,
+							step,
+							sessionId,
+							onOpenTerminal: () => openTransientTab(stepTerminalTab(run, job.name, step?.name))
+						})] })]
+					})
+				] })
+			}),
+			sessionId !== null && catalogState.open ? /* @__PURE__ */ jsx(WorkflowCatalogDrawer, {
+				sessionId,
+				onClose: () => closeCatalog(sessionId),
+				onLaunch: (workflow) => openLaunch(sessionId, workflow.path)
+			}) : null,
+			sessionId !== null && launching !== void 0 ? /* @__PURE__ */ jsx(LaunchWorkflowDialog, {
+				sessionId,
+				workflow: launching,
+				cwd: catalogState.cwd,
+				initialPrompt: catalogState.prompt,
+				send: sendSessionFrame,
+				onClose: () => closeLaunch(sessionId),
+				onLaunched: () => {
+					closeLaunch(sessionId);
+					closeCatalog(sessionId);
+				}
+			}) : null,
+			sessionId !== null && deletingRun !== void 0 ? /* @__PURE__ */ jsx(DeleteWorkflowDialog, {
+				run: deletingRun,
+				sessionId,
+				onClose: () => setDeletingRun(void 0),
+				onDeleted: () => {
+					removeRun(sessionId, workflowRunIdentity(deletingRun));
+					setDeletingRun(void 0);
+				}
+			}) : null
+		]
+	});
+}
+/** The temporary tab the workflow surface opens in; opening it again only focuses it. */
+function workflowsTab() {
+	return {
+		id: WORKFLOWS_TAB_ID,
+		label: "workflows",
+		panel: WorkflowsPanel
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/_components/WorkflowsActivitySection.tsx
+const TICK_MS = 1e4;
+const TONE_DOT = {
+	running: "yellow",
+	paused: "yellow",
+	failed: "red",
+	done: "green",
+	skipped: "muted"
+};
+const TONE_DETAIL = {
+	running: "text-doom-faint",
+	paused: "text-doom-yellow",
+	failed: "text-doom-red",
+	done: "text-doom-faint",
+	skipped: "text-doom-faint"
+};
+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, openTransientTab }) {
+	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);
+		return () => clearInterval(timer);
+	}, []);
+	const groups = workflowActivityGroups(workflowActivityRows(runs, now));
+	if (groups.length === 0) return /* @__PURE__ */ jsxs("div", {
+		className: "flex items-center gap-2 px-1",
+		children: [/* @__PURE__ */ jsx("p", {
+			"data-testid": "activity-summary-workflows",
+			className: "text-xs text-doom-faint",
+			children: "idle"
+		}), /* @__PURE__ */ jsx(Button, {
+			variant: "link",
+			size: "xs",
+			"data-testid": "activity-workflow-launch",
+			className: "px-0",
+			onClick: () => {
+				if (sessionId === null) return;
+				openCatalog(sessionId);
+				openTransientTab(workflowsTab());
+			},
+			children: "launch a workflow"
+		})]
+	});
+	const RunRow = ({ row }) => /* @__PURE__ */ jsxs(Button, {
+		variant: "ghost",
+		size: "card",
+		"data-testid": `activity-workflow-${row.runKey}`,
+		"data-run-tone": row.tone,
+		title: "open this run in the workflows tab",
+		onClick: () => {
+			if (sessionId === null) return;
+			focusRun(sessionId, row.identity);
+			openTransientTab(workflowsTab());
+		},
+		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-xs font-bold ${row.tone === "running" || row.tone === "paused" ? "text-doom-hi" : "text-doom-dim"}`,
+					children: row.name
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: "shrink-0 text-2xs text-doom-faint",
+					children: row.elapsed
+				})
+			]
+		}), /* @__PURE__ */ jsx("span", {
+			className: `truncate pl-3 text-2xs ${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: `text-xs font-bold ${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-2xs text-doom-faint",
+					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"
+];
+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 recordScope(record) {
+	const runKey = readString(record, "runKey") ?? "unknown run";
+	const workspace = readString(record, "workspace");
+	return workspace ? `${workspace}/${runKey}` : runKey;
+}
+function currentActivity(record) {
+	const cursor = asRecord(record.executionCursor);
+	const job = readString(cursor, "job") ?? readString(record, "job");
+	const step = readString(cursor, "stepName");
+	const phase = readString(cursor, "phase");
+	if (!job && !step && !phase) return void 0;
+	return line(`[${job ?? phase ?? "workflow"}] ${step ?? phase ?? "running"}`, "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 displayName = readString(record, "displayName") ?? runKey;
+	const lines = [line(`${state.glyph} ${displayName} · ${recordScope(record)} · ${state.label}`, state.tone, { bold: true })];
+	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));
+	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(`✗ ${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-bold text-doom-hi",
+						children: summary.action
+					}),
+					summary.target ? /* @__PURE__ */ jsx("span", {
+						className: "min-w-0 truncate text-doom-faint",
+						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, workflowsTab)
+	}],
+	minorModes: [{
+		name: "workflow",
+		keys: "w e",
+		widgetKey: "workflow-mcp-progress",
+		order: 50
+	}],
+	activityGroups: [{
+		name: "workflows",
+		keys: "w r",
+		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");
+			}
+		},
+		transientTab: workflowsTab,
+		order: 30
+	}],
+	activitySections: [{
+		id: "workflows",
+		component: WorkflowsActivitySection
+	}],
+	toolRenderers: [{
+		tools: [
+			"list_workflows",
+			"launch_workflow",
+			"workflow_run"
+		],
+		message: WorkflowToolMessage
+	}],
+	leaderBindings: [
+		{
+			id: "doom-workflow.manage",
+			path: [WORKFLOWS_GROUP, {
+				key: "r",
+				label: "runs",
+				detail: "runs in this session"
+			}],
+			run: (context) => context.openTransientTab(workflowsTab())
+		},
+		{
+			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);
+				context.openTransientTab(workflowsTab());
+			}
+		},
+		{
+			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/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[1]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/leader/manage.web.ts
+var manage_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[2]);
+//#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) => ({
+	...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 fills() {
+			return [via({
+				slot: "activity.workflows",
+				id: "workflows"
+			}, Workflows_activity_workflows_web_default)];
+		},
+		get leaderBindings() {
+			return [
+				via({ id: "workflows.catalog" }, catalog_web_default),
+				via({ id: "workflows.manage" }, manage_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