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

package/dist/extensions/web.mjs

@@ -0,0 +1,1785 @@
+import { apiResponse, createApiClient, defineActivityGroup, defineApiRoutes, defineChannelFile, defineFill, defineSessionStore, defineToolRenderer, defineWebPlugin, sessionApiAddress } from "@agimon-ai/po-core/web";
+import { AnsiLine, AnsiText, ArrowRightIcon, Button, Checkbox, Dialog, DialogBody, DialogContent, DialogFooter, DialogHeader, DialogTitle, Dot, DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger, EmptyState, FileIcon, Input, MessageItem, MessageItemBody, MessageItemHeader, MessageItemStatus, PlayCircleIcon, PlusIcon, SearchIcon, StatusBadge, SyntaxText, TerminalView, Textarea, ansiSpans, toolTone } from "@agimon-ai/po-web-components";
+import { useStore } from "@tanstack/react-store";
+import { Fragment, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { sealedTransport } from "@agimon-ai/po-web-security/browser";
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/format.ts
+/**
+* Local copy of the runtime's formatUptime (src/services/bashResult/index.ts):
+* the web plugin may reach only src/types, so the one helper it needs lives here.
+*/
+function formatRunnerUptime(startedAt, now) {
+	const started = Date.parse(startedAt);
+	if (Number.isNaN(started)) return "unknown";
+	const seconds = Math.max(0, Math.floor((now - started) / 1e3));
+	if (seconds < 60) return `${seconds}s`;
+	const minutes = Math.floor(seconds / 60);
+	if (minutes < 60) return `${minutes}m`;
+	const hours = Math.floor(minutes / 60);
+	return hours < 24 ? `${hours}h` : `${Math.floor(hours / 24)}d`;
+}
+/**
+* The lines a log view shows: the slice's text, then whatever the follow
+* stream appended, bounded to the newest `max`.
+*
+* A log file ends with a newline, and the reader hands its text back with that
+* newline intact, so a naive split reports one blank line more than the file
+* has. Dropping exactly one trailing empty entry keeps the count the reader
+* sees equal to the count the server reported.
+*/
+function logViewLines(text, appended, max, options = {}) {
+	const split = text.split("\n");
+	if (split.length > 0 && split[split.length - 1] === "") split.pop();
+	if (options.dropPartialTail === true && split.length > 0) split.pop();
+	const all = [...split, ...appended];
+	const lines = all.slice(-max);
+	return {
+		lines,
+		hidden: all.length - lines.length
+	};
+}
+/**
+* Absolute 1-based numbers for a tail, counted back from the last line.
+*
+* A tail is contiguous, so only its end has to be known. Grep results are not
+* contiguous and carry their own numbers from the reader instead.
+*/
+function tailLineNumbers(lastLineNumber, count) {
+	const first = Math.max(1, lastLineNumber - count + 1);
+	return Array.from({ length: count }, (_, index) => first + index);
+}
+/**
+* Whether the view is actually following a growing log.
+*
+* Three things must hold: the reader asked to follow, no query is set (a
+* filtered view is a snapshot of the whole file, which a stream cannot
+* assemble a chunk at a time), and the runner is still writing. Without the
+* last one a finished run would claim to be tailing a file nothing will ever
+* append to.
+*/
+function isFollowingLive(following, filtering, running) {
+	return following && !filtering && running;
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/launchLine.ts
+/**
+* The `/runners start` line the launch form 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
+* in src/services. 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 RUNNERS_START_LINE = "/runners start";
+/** The no-form launch used when a reader asks for a shell rather than a command. */
+const RUNNER_SHELL_REQUEST = {
+	command: "exec \"${SHELL:-/bin/bash}\" -l",
+	name: "shell",
+	interactive: true
+};
+/** Quotes a value that carries whitespace, which is how a value survives tokenizing. */
+function quote(value) {
+	return /\s/u.test(value) ? `"${value}"` : value;
+}
+function runnerLaunchLine(request) {
+	const cwd = request.cwd?.trim() ?? "";
+	const name = request.name?.trim() ?? "";
+	const pairs = [
+		...name === "" ? [] : [`name=${quote(name)}`],
+		...cwd === "" ? [] : [`cwd=${quote(cwd)}`],
+		...request.interactive === true ? ["interactive=true"] : []
+	];
+	return [
+		RUNNERS_START_LINE,
+		...pairs,
+		"--",
+		request.command.trim()
+	].join(" ");
+}
+/** What the form will not let a reader send, worded the way the session would answer. */
+function launchProblems(request) {
+	const problems = [];
+	if (request.command.trim() === "") problems.push("A runner needs a command to run.");
+	return problems;
+}
+//#endregion
+//#region src/constants/webRunners.ts
+const RUNNER_RUNS_TYPE = "runner_runs";
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/runnersStore.ts
+/** The runtime's slash verb that stops one runner headlessly. */
+const STOP_COMMAND = "/runners stop";
+const runners = defineSessionStore({
+	runs: [],
+	stopRequested: []
+});
+/** The runner channel keeps the dock's busy state aligned with its rendered run list. */
+const runnerActivitySource = {
+	subscribe(listener) {
+		const subscription = runners.store.subscribe(listener);
+		return () => subscription.unsubscribe();
+	},
+	isActive(sessionId) {
+		return runners.select(runners.store.state, sessionId).runs.some((run) => run.state === "running");
+	}
+};
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Asks the runtime to stop a runner through the same slash command the TUI's
+* Runner Space uses. The request is remembered until the runner's record
+* reports an exit; the runtime, not this click, decides when that is.
+*/
+function requestRunnerStop(send, sessionId, id) {
+	send(sessionId, {
+		type: "prompt",
+		message: `${STOP_COMMAND} ${id}`
+	});
+	runners.update(sessionId, (current) => ({
+		...current,
+		stopRequested: [...current.stopRequested.filter((known) => known !== id), id]
+	}));
+}
+/**
+* Asks the runtime to start a runner, through the same prompt frame the stop
+* request uses and the same way agents and workflows launch their own work.
+*
+* Nothing is recorded as pending here. The runtime names the run, and it
+* arrives in the feed on its own; guessing at an id before it exists would
+* only have to be reconciled later.
+*/
+function requestRunnerStart(send, sessionId, request) {
+	send(sessionId, {
+		type: "prompt",
+		message: runnerLaunchLine(request)
+	});
+}
+/** The plugin's session data channel: 'runner_runs' payloads into the store. */
+const runnerRunsChannel = runners.channel({
+	channel: RUNNER_RUNS_TYPE,
+	parse(input) {
+		if (!isRecord$3(input) || !Array.isArray(input.runs)) return null;
+		return { runs: input.runs.filter(isRecord$3) };
+	},
+	reduce(current, { runs }) {
+		const stillRunning = new Set(runs.filter((run) => run.state === "running").map((run) => run.id));
+		return {
+			runs,
+			stopRequested: current.stopRequested.filter((id) => stillRunning.has(id))
+		};
+	}
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/LaunchRunnerDialog.tsx
+const COMMAND_ROWS = 3;
+const INTERACTIVE_FIELD_ID = "runner-launch-interactive-field";
+function FieldLabel({ children }) {
+	return /* @__PURE__ */ jsx("span", {
+		className: "text-base font-medium text-doom-text",
+		children
+	});
+}
+/**
+* Starts one runner by hand: the command, where it runs, what to call it, and
+* whether it needs a terminal, then the exact `/runners start` line the
+* session will parse.
+*
+* The line is shown rather than hidden. This sends a shell command through the
+* session, and a reader is entitled to see exactly what they are about to run
+* before they run it.
+*/
+function LaunchRunnerDialog({ sessionId, sendSessionFrame, defaultCwd, onClose }) {
+	const [command, setCommand] = useState("");
+	const [cwd, setCwd] = useState(defaultCwd ?? "");
+	const [name, setName] = useState("");
+	const [interactive, setInteractive] = useState(false);
+	const request = {
+		command,
+		cwd,
+		name,
+		interactive
+	};
+	const problems = launchProblems(request);
+	const line = runnerLaunchLine(request);
+	const launch = () => {
+		if (problems.length > 0) return;
+		requestRunnerStart(sendSessionFrame, sessionId, request);
+		onClose();
+	};
+	return /* @__PURE__ */ jsx(Dialog, {
+		open: true,
+		onOpenChange: (open) => {
+			if (!open) onClose();
+		},
+		children: /* @__PURE__ */ jsxs(DialogContent, {
+			width: "lg",
+			"data-testid": "runner-launch-dialog",
+			"aria-describedby": void 0,
+			children: [/* @__PURE__ */ jsx(DialogHeader, { children: /* @__PURE__ */ jsx(DialogTitle, {
+				"data-testid": "runner-launch-title",
+				children: "launch a runner"
+			}) }), /* @__PURE__ */ jsxs(DialogBody, { children: [
+				/* @__PURE__ */ jsxs("div", {
+					className: "flex flex-col gap-1",
+					children: [/* @__PURE__ */ jsx(FieldLabel, { children: "Command" }), /* @__PURE__ */ jsx(Textarea, {
+						"data-testid": "runner-launch-command",
+						rows: COMMAND_ROWS,
+						value: command,
+						placeholder: "pnpm test",
+						onChange: (event) => setCommand(event.target.value)
+					})]
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: "flex flex-col gap-2.5 sm:flex-row",
+					children: [/* @__PURE__ */ jsxs("div", {
+						className: "flex min-w-0 flex-1 flex-col gap-1",
+						children: [/* @__PURE__ */ jsx(FieldLabel, { children: "Cwd" }), /* @__PURE__ */ jsx(Input, {
+							size: "sm",
+							"data-testid": "runner-launch-cwd",
+							value: cwd,
+							placeholder: "the session's own directory",
+							onChange: (event) => setCwd(event.target.value)
+						})]
+					}), /* @__PURE__ */ jsxs("div", {
+						className: "flex min-w-0 flex-1 flex-col gap-1",
+						children: [/* @__PURE__ */ jsx(FieldLabel, { children: "Name" }), /* @__PURE__ */ jsx(Input, {
+							size: "sm",
+							"data-testid": "runner-launch-name",
+							value: name,
+							placeholder: "chosen for you when empty",
+							onChange: (event) => setName(event.target.value)
+						})]
+					})]
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: "flex items-center gap-2",
+					children: [/* @__PURE__ */ jsx(Checkbox, {
+						id: INTERACTIVE_FIELD_ID,
+						"data-testid": "runner-launch-interactive",
+						checked: interactive,
+						onCheckedChange: (checked) => setInteractive(checked === true)
+					}), /* @__PURE__ */ jsx("label", {
+						htmlFor: INTERACTIVE_FIELD_ID,
+						className: "text-base text-doom-dim",
+						children: "needs a terminal, for a command that prompts (requires rmux or tmux)"
+					})]
+				}),
+				/* @__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": "runner-launch-line",
+						className: "whitespace-pre-wrap break-words font-mono text-sm text-doom-green",
+						children: line
+					})]
+				}),
+				problems.length > 0 ? /* @__PURE__ */ jsx("p", {
+					"data-testid": "runner-launch-problem",
+					className: "text-base text-doom-red",
+					children: problems.join(" ")
+				}) : null,
+				/* @__PURE__ */ jsxs(DialogFooter, {
+					className: "flex-wrap sm:flex-nowrap",
+					children: [
+						/* @__PURE__ */ jsx("span", {
+							className: "w-full text-sm text-doom-dim sm:w-auto",
+							children: "it appears above once the runtime starts it"
+						}),
+						/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }),
+						/* @__PURE__ */ jsx(Button, {
+							variant: "outline",
+							size: "xs",
+							"data-testid": "runner-launch-cancel",
+							onClick: onClose,
+							children: "cancel"
+						}),
+						/* @__PURE__ */ jsx(Button, {
+							variant: "primary",
+							size: "xs",
+							"data-testid": "runner-launch-submit",
+							disabled: problems.length > 0,
+							onClick: launch,
+							children: "launch"
+						})
+					]
+				})
+			] })]
+		})
+	});
+}
+//#endregion
+//#region src/constants/webRunnerLog.ts
+const RUN_ID_PARAM = "runId";
+const RUNNER_SCREEN_EVENT = "screen";
+const RUNNER_LOG_STREAM_EVENT = "append";
+//#endregion
+//#region src/types/webRunnerLog.ts
+/** The named SSE event carrying a RunnerLogStreamEvent payload. */
+/**
+* The named SSE event that carries nothing.
+*
+* A runner can be alive and silent for minutes, which on the wire is
+* indistinguishable from a connection that died. This is sent on a timer so
+* the socket keeps proving itself. Readers that only listen for `append`
+* ignore it, which is what makes it safe to add.
+*/
+/** Query parameter names, shared so the page and the route cannot drift apart. */
+const RUNNER_LOG_PARAMS = {
+	lines: "lines",
+	grep: "grep",
+	ignoreCase: "ignoreCase",
+	contextLines: "contextLines",
+	from: "from"
+};
+//#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/workspaces/sessions/(backend)/api/runner/`, so the mount is
+* stated once, by the folder that creates it. This package stated it four times
+* before, once per URL builder, each of them re-spelling `/plugins/` and the
+* session prefix by hand.
+*
+* The Hono app registers these paths verbatim and the browser addresses them,
+* so a path cannot move on one side alone. `:runId` is Hono's own parameter
+* syntax for that reason; a caller supplies the value as `params`, and the
+* client encodes the segment.
+*/
+var apiRoutes_default = defineApiRoutes({
+	log: {
+		method: "GET",
+		path: `/runners/:${RUN_ID_PARAM}/log`,
+		query: [
+			RUNNER_LOG_PARAMS.lines,
+			RUNNER_LOG_PARAMS.grep,
+			RUNNER_LOG_PARAMS.ignoreCase,
+			RUNNER_LOG_PARAMS.contextLines
+		],
+		response: apiResponse()
+	},
+	/**
+	* The live tail of that same log.
+	*
+	* `stream: true`, so the client exposes 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.
+	*/
+	logStream: {
+		method: "GET",
+		path: `/runners/:${RUN_ID_PARAM}/log/stream`,
+		query: [RUNNER_LOG_PARAMS.from],
+		stream: true
+	},
+	/** The unscrubbed pane bytes, for a terminal emulator rather than a reader. */
+	screenStream: {
+		method: "GET",
+		path: `/runners/:${RUN_ID_PARAM}/screen/stream`,
+		query: [RUNNER_LOG_PARAMS.from],
+		stream: true
+	},
+	input: {
+		method: "POST",
+		path: `/runners/:${RUN_ID_PARAM}/screen/input`
+	}
+});
+const api = createApiClient(apiRoutes_default, {
+	scopes: ["session"],
+	basePath: "runner",
+	transport: (input, init) => sealedTransport.fetch(input, init),
+	sessionAddress: sessionApiAddress
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/logApi.ts
+const UNREACHABLE = "The cockpit hub is unreachable.";
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Reads one runner's log: the last N lines, or the lines matching a substring with context. */
+async function fetchRunnerLog(sessionId, runId, params = {}, signal) {
+	const result = await api.session(sessionId).log({
+		params: { [RUN_ID_PARAM]: runId },
+		query: {
+			[RUNNER_LOG_PARAMS.lines]: params.lines,
+			[RUNNER_LOG_PARAMS.grep]: params.grep === "" ? void 0 : params.grep,
+			[RUNNER_LOG_PARAMS.ignoreCase]: params.ignoreCase === true ? true : void 0,
+			[RUNNER_LOG_PARAMS.contextLines]: params.contextLines
+		},
+		...signal === void 0 ? {} : { signal }
+	});
+	if (!result.ok) {
+		if (result.status === 0) return { error: signal?.aborted === true ? "" : UNREACHABLE };
+		return { error: result.error === "" ? `The hub answered ${String(result.status)}.` : result.error };
+	}
+	if (!isRecord$2(result.data) || typeof result.data.text !== "string") return { error: `The hub answered ${String(result.status)}.` };
+	return { slice: result.data };
+}
+/** Attempts before a dropped stream is reported as lost rather than retried. */
+const MAX_RETRIES$1 = 5;
+const RETRY_BASE_MS$1 = 500;
+/**
+* Follows a running log from the offset already read, so no line is missed
+* between the slice and the stream. The stream never filters; a page with a
+* query stops following and reads a filtered slice instead.
+*
+* A dropped connection is retried with backoff from the offset the last event
+* reported, not from the offset the page started at, so a reconnect resumes
+* instead of replaying. The browser's own EventSource retry cannot do this:
+* it reopens the URL it was given, whose offset is stale the moment a line
+* arrives, so each of its reconnects would duplicate everything since.
+*/
+function followRunnerLog(sessionId, runId, from, handlers) {
+	let offset = from;
+	let retries = 0;
+	let closed = false;
+	let source;
+	let timer;
+	const open = () => {
+		if (closed) return;
+		const current = new EventSource(api.session(sessionId).logStream.url({
+			params: { [RUN_ID_PARAM]: runId },
+			query: { [RUNNER_LOG_PARAMS.from]: offset }
+		}));
+		source = current;
+		current.addEventListener(RUNNER_LOG_STREAM_EVENT, (message) => {
+			let parsed;
+			try {
+				parsed = JSON.parse(message.data);
+			} catch {
+				return;
+			}
+			if (!isRecord$2(parsed) || !Array.isArray(parsed.lines)) return;
+			const event = parsed;
+			if (typeof event.offset === "number") offset = event.offset;
+			retries = 0;
+			if (event.ended === true) {
+				closed = true;
+				current.close();
+			}
+			handlers.onEvent(event);
+		});
+		current.addEventListener("error", () => {
+			current.close();
+			if (closed) return;
+			retries += 1;
+			if (retries > MAX_RETRIES$1) {
+				handlers.onLost();
+				return;
+			}
+			timer = setTimeout(open, RETRY_BASE_MS$1 * 2 ** (retries - 1));
+		});
+	};
+	open();
+	return { close: () => {
+		closed = true;
+		if (timer !== void 0) clearTimeout(timer);
+		source?.close();
+	} };
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/RunnerLogPanel.tsx
+const TICK_MS$2 = 1e4;
+/** The tab id doubles as the URL segment, so it stays plain and unique across plugins. */
+const TAB_ID_PREFIX$1 = "runner-log-";
+/** Lines held in the view; a follow that ran all day must not grow without bound. */
+const MAX_VIEW_LINES = 2e3;
+/** Context lines each side of a match, the same either-side window grep would use. */
+const CONTEXT_LINES = 2;
+/** A query is typed a character at a time; each one costs a whole-file read on the hub. */
+const SEARCH_DEBOUNCE_MS = 200;
+/** How close to the bottom still counts as "at the bottom" for following. */
+const NEAR_BOTTOM_PX = 24;
+const BYTES_PER_KB$1 = 1024;
+const BYTES_PER_MB$1 = BYTES_PER_KB$1 * BYTES_PER_KB$1;
+/** The temporary tab for one runner's log; the host keeps this panel while the tab is open. */
+function runnerLogTab(run) {
+	const runId = run.id;
+	return {
+		id: `${TAB_ID_PREFIX$1}${runId}`,
+		label: `log · ${run.name}`,
+		panel: (props) => /* @__PURE__ */ jsx(RunnerLogPanel, {
+			...props,
+			runId
+		})
+	};
+}
+function formatSize$1(bytes) {
+	if (bytes < BYTES_PER_KB$1) return `${bytes} B`;
+	if (bytes < BYTES_PER_MB$1) return `${(bytes / BYTES_PER_KB$1).toFixed(1)} KB`;
+	return `${(bytes / BYTES_PER_MB$1).toFixed(1)} MB`;
+}
+function badgeOf(run) {
+	if (run === void 0) return {
+		tone: "neutral",
+		label: "gone"
+	};
+	if (run.state === "running") return {
+		tone: "running",
+		label: "running"
+	};
+	if (run.exit === void 0 || run.exit.reason === "stopped") return {
+		tone: "neutral",
+		label: "stopped"
+	};
+	return run.exit.reason === "completed" && (run.exit.code === 0 || run.exit.code === null) ? {
+		tone: "ok",
+		label: "done"
+	} : {
+		tone: "error",
+		label: run.exit.reason.replace("_", " ")
+	};
+}
+/** Whether one line is a match rather than the context printed around one. */
+function isMatch(line, needle, ignoreCase) {
+	if (needle === "") return false;
+	return ignoreCase ? line.toLowerCase().includes(needle.toLowerCase()) : line.includes(needle);
+}
+/** One fact of the runner, on its own line so a long command is never elided. */
+function MetaRow({ label, value }) {
+	return /* @__PURE__ */ jsxs("span", {
+		className: "flex min-w-0 gap-2.5",
+		children: [/* @__PURE__ */ jsx("span", {
+			className: "w-14 shrink-0 text-base text-doom-dim",
+			children: label
+		}), /* @__PURE__ */ jsx("span", {
+			className: "min-w-0 flex-1 break-all font-mono text-sm text-doom-dim",
+			children: value
+		})]
+	});
+}
+/**
+* One rendered log line: its number, whether it matched, and the text.
+*
+* A row per line rather than one block of joined text. The block form re-parsed
+* every line's escapes whenever a single line arrived, because the parse was
+* keyed on the joined string; keyed by line number instead, an append only
+* costs the line that appended.
+*/
+function LogRow({ number, line, matched }) {
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "runner-log-row",
+		"data-matched": matched,
+		className: "flex min-w-0 gap-2",
+		children: [
+			number === void 0 ? null : /* @__PURE__ */ jsx("span", {
+				className: "w-12 shrink-0 select-none text-right text-xs leading-relaxed text-doom-faint",
+				children: number
+			}),
+			/* @__PURE__ */ jsx("span", {
+				"aria-hidden": true,
+				className: `w-4 shrink-0 select-none text-xs leading-relaxed ${matched ? "text-doom-yellow" : "text-doom-faint"}`,
+				children: matched ? ">>" : ""
+			}),
+			/* @__PURE__ */ jsx(AnsiLine, {
+				line,
+				className: `min-w-0 flex-1 whitespace-pre-wrap break-words font-mono text-xs leading-relaxed ${matched ? "text-doom-text" : "text-doom-dim"}`
+			})
+		]
+	});
+}
+/**
+* One runner's log: the bounded tail, following while the runner writes, and
+* a grep over the whole file when the reader types a query.
+*
+* Search is not find-next. The reader matches a literal substring and answers
+* with the matching lines and their context, so a query replaces the view
+* rather than moving a cursor through it, and following pauses while one is
+* set because a filtered view is a snapshot of a file that is still growing.
+*/
+function RunnerLogPanel({ sessionId, runId, sendSessionFrame }) {
+	const { runs, stopRequested } = useStore(runners.store, (state) => runners.select(state, sessionId));
+	const run = runs.find((candidate) => candidate.id === runId);
+	const [now, setNow] = useState(() => Date.now());
+	const [typed, setTyped] = useState("");
+	const [query, setQuery] = useState("");
+	const [ignoreCase, setIgnoreCase] = useState(false);
+	const [context, setContext] = useState(CONTEXT_LINES);
+	const [following, setFollowing] = useState(true);
+	const [slice, setSlice] = useState(void 0);
+	const [streamFrom, setStreamFrom] = useState(void 0);
+	const [appended, setAppended] = useState([]);
+	const [error, setError] = useState(void 0);
+	/** False once the reader scrolls up: following must not yank them back down. */
+	const [pinned, setPinned] = useState(true);
+	const bottom = useRef(null);
+	const body = useRef(null);
+	const filtering = query !== "";
+	const live = isFollowingLive(following, filtering, slice?.running === true);
+	useEffect(() => {
+		const timer = setInterval(() => setNow(Date.now()), TICK_MS$2);
+		return () => clearInterval(timer);
+	}, []);
+	useEffect(() => {
+		const timer = setTimeout(() => setQuery(typed), SEARCH_DEBOUNCE_MS);
+		return () => clearTimeout(timer);
+	}, [typed]);
+	const load = useCallback((signal) => {
+		if (sessionId === null) return;
+		fetchRunnerLog(sessionId, runId, filtering ? {
+			grep: query,
+			ignoreCase,
+			contextLines: context
+		} : {}, signal).then((result) => {
+			if (signal.aborted) return;
+			if ("error" in result) {
+				if (result.error !== "") setError(result.error);
+				return;
+			}
+			setError(void 0);
+			setAppended([]);
+			setSlice(result.slice);
+			setStreamFrom(result.slice.completeBytes);
+		});
+	}, [
+		sessionId,
+		runId,
+		filtering,
+		query,
+		ignoreCase,
+		context
+	]);
+	useEffect(() => {
+		const controller = new AbortController();
+		load(controller.signal);
+		return () => controller.abort();
+	}, [load]);
+	useEffect(() => {
+		if (!live || sessionId === null || streamFrom === void 0) return;
+		const follow = followRunnerLog(sessionId, runId, streamFrom, {
+			onEvent: (event) => {
+				if (event.lines.length > 0) setAppended((current) => [...current, ...event.lines].slice(-2e3));
+				if (event.ended === true) setFollowing(false);
+			},
+			onLost: () => setFollowing(false)
+		});
+		return () => follow.close();
+	}, [
+		live,
+		sessionId,
+		runId,
+		streamFrom
+	]);
+	const partialTail = slice !== void 0 && slice.exists && slice.completeBytes < slice.fileSize;
+	const view = logViewLines(slice?.text ?? "", appended, MAX_VIEW_LINES, { dropPartialTail: live && partialTail });
+	const numbers = useMemo(() => {
+		if (slice === void 0) return [];
+		if (filtering) return slice.lineNumbers ?? [];
+		return tailLineNumbers(slice.totalLines + appended.length - (live && partialTail ? 1 : 0), view.lines.length);
+	}, [
+		slice,
+		filtering,
+		appended.length,
+		live,
+		partialTail,
+		view.lines.length
+	]);
+	useEffect(() => {
+		if (live && pinned) bottom.current?.scrollIntoView({ block: "end" });
+	}, [
+		live,
+		pinned,
+		view.lines.length
+	]);
+	const onScroll = () => {
+		const element = body.current;
+		if (element === null) return;
+		setPinned(element.scrollHeight - element.scrollTop - element.clientHeight <= NEAR_BOTTOM_PX);
+	};
+	const badge = badgeOf(run);
+	const stopping = run !== void 0 && stopRequested.includes(run.id);
+	const elapsed = run === void 0 ? "" : formatRunnerUptime(run.startedAt, run.exit ? Date.parse(run.exit.finishedAt) : now);
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "runner-log-panel",
+		className: "flex min-h-0 flex-1 flex-col",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex min-h-11 shrink-0 flex-wrap items-center gap-2 border-b border-doom-border-soft px-3 py-2 sm:h-11 sm:flex-nowrap sm:gap-2.5 sm:px-[26px] sm:py-0",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						"data-testid": "runner-log-name",
+						className: "shrink-0 truncate text-base font-semibold text-doom-hi",
+						children: run?.name ?? runId
+					}),
+					/* @__PURE__ */ jsx(StatusBadge, {
+						tone: badge.tone,
+						"data-testid": "runner-log-state",
+						children: badge.label
+					}),
+					run ? /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("span", {
+						className: "shrink-0 text-sm text-doom-dim",
+						children: elapsed
+					}), /* @__PURE__ */ jsx("span", {
+						className: "shrink-0 text-sm text-doom-dim",
+						children: `pid ${String(run.pid)} · ${run.backend}${run.interactive ? " · tty" : ""}`
+					})] }) : /* @__PURE__ */ jsx("span", {
+						"data-testid": "runner-log-gone",
+						className: "text-sm text-doom-dim",
+						children: "no longer listed; its log stays readable"
+					}),
+					/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }),
+					run !== void 0 && run.state === "running" && sessionId !== null ? /* @__PURE__ */ jsx(Button, {
+						variant: stopping ? "outline" : "danger-outline",
+						size: "xs",
+						"data-testid": "runner-log-stop",
+						disabled: stopping,
+						title: stopping ? "stop requested; the runner reports its own exit" : "ask the runtime to stop this runner",
+						onClick: () => requestRunnerStop(sendSessionFrame, sessionId, run.id),
+						className: "px-2 ",
+						children: stopping ? "stopping…" : "stop"
+					}) : null
+				]
+			}),
+			run ? /* @__PURE__ */ jsxs("div", {
+				className: "flex shrink-0 flex-col gap-1.5 border-b border-doom-border-soft px-3 py-2.5 sm:px-[26px]",
+				children: [/* @__PURE__ */ jsx(MetaRow, {
+					label: "command",
+					value: run.command
+				}), /* @__PURE__ */ jsx(MetaRow, {
+					label: "cwd",
+					value: run.cwd
+				})]
+			}) : null,
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex min-h-10 shrink-0 flex-wrap items-center gap-2 border-b border-doom-border-soft px-3 py-2 sm:h-10 sm:flex-nowrap sm:gap-2.5 sm:px-[26px] sm:py-0",
+				children: [
+					/* @__PURE__ */ jsxs("span", {
+						className: "relative flex min-w-0 flex-1 items-center sm:w-[300px] sm:flex-none",
+						children: [/* @__PURE__ */ jsx(SearchIcon, { className: "pointer-events-none absolute left-2.5 h-3 w-3 text-doom-faint" }), /* @__PURE__ */ jsx(Input, {
+							size: "sm",
+							"data-testid": "runner-log-search",
+							value: typed,
+							placeholder: "search this log",
+							onChange: (event) => setTyped(event.target.value),
+							className: "pl-7 "
+						})]
+					}),
+					/* @__PURE__ */ jsx(Button, {
+						variant: ignoreCase ? "subtle" : "outline",
+						size: "xs",
+						"data-testid": "runner-log-ignore-case",
+						"aria-pressed": ignoreCase,
+						title: "match regardless of case",
+						onClick: () => setIgnoreCase((current) => !current),
+						className: "px-2 ",
+						children: "aA"
+					}),
+					/* @__PURE__ */ jsx(Button, {
+						variant: context > 0 && filtering ? "subtle" : "outline",
+						size: "xs",
+						"data-testid": "runner-log-context",
+						disabled: !filtering,
+						title: "lines of context kept either side of a match",
+						onClick: () => setContext((current) => current === 0 ? CONTEXT_LINES : 0),
+						className: "px-2 ",
+						children: `± ${String(context)} lines`
+					}),
+					/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }),
+					/* @__PURE__ */ jsxs("span", {
+						"data-testid": "runner-log-stats",
+						className: "min-w-0 basis-full truncate text-sm text-doom-dim sm:basis-auto",
+						children: [slice === void 0 ? "reading…" : filtering ? `${String(slice.lineCount)} matching of ${slice.totalLines.toLocaleString("en-US")} lines` : `${live ? "tailing" : "showing"} last ${String(view.lines.length)} of ${slice.totalLines.toLocaleString("en-US")} lines`, view.hidden > 0 ? ` · ${view.hidden.toLocaleString("en-US")} older hidden` : ""]
+					}),
+					/* @__PURE__ */ jsx(Button, {
+						variant: live ? "subtle" : "outline",
+						size: "xs",
+						"data-testid": "runner-log-follow",
+						"aria-pressed": live,
+						disabled: filtering || slice?.running !== true,
+						title: filtering ? "a filtered view is a snapshot; clear the query to follow" : "follow the log as it grows",
+						onClick: () => setFollowing((current) => !current),
+						className: "px-2 ",
+						children: filtering ? "follow · paused" : "follow"
+					})
+				]
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "relative min-h-0 flex-1",
+				children: [/* @__PURE__ */ jsxs("div", {
+					ref: body,
+					onScroll,
+					"data-testid": "runner-log-body",
+					className: "h-full overflow-auto bg-doom-deep px-3 py-3 sm:px-[26px]",
+					children: [error !== void 0 ? /* @__PURE__ */ jsx("p", {
+						"data-testid": "runner-log-error",
+						className: "text-base text-doom-red",
+						children: error
+					}) : slice === void 0 ? /* @__PURE__ */ jsx("p", {
+						"data-testid": "runner-log-reading",
+						className: "text-sm text-doom-dim",
+						children: "reading…"
+					}) : slice.exists === false ? /* @__PURE__ */ jsx("p", {
+						className: "text-sm text-doom-dim",
+						children: "this runner has not written a log yet"
+					}) : view.lines.length === 0 ? /* @__PURE__ */ jsx("p", {
+						className: "text-sm text-doom-dim",
+						children: filtering ? "nothing matched" : "the log is empty"
+					}) : view.lines.map((line, index) => {
+						const number = numbers[index];
+						const previous = numbers[index - 1];
+						const gap = previous !== void 0 && number !== void 0 && number - previous > 1;
+						return /* @__PURE__ */ jsxs(Fragment, { children: [gap ? /* @__PURE__ */ jsx("div", {
+							"data-testid": "runner-log-gap",
+							"aria-hidden": true,
+							className: "select-none py-0.5 pl-12 text-xs leading-relaxed text-doom-faint",
+							children: "⋯"
+						}) : null, /* @__PURE__ */ jsx(LogRow, {
+							number,
+							line,
+							matched: filtering && isMatch(line, query, ignoreCase)
+						})] }, number ?? `row-${String(index)}`);
+					}), /* @__PURE__ */ jsx("div", { ref: bottom })]
+				}), live && !pinned ? /* @__PURE__ */ jsx(Button, {
+					variant: "subtle",
+					size: "xs",
+					"data-testid": "runner-log-jump",
+					title: "scroll back to the newest lines and keep following",
+					onClick: () => {
+						setPinned(true);
+						bottom.current?.scrollIntoView({ block: "end" });
+					},
+					className: "absolute bottom-3 right-3 px-2 ",
+					children: "jump to latest"
+				}) : null]
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex h-8 shrink-0 items-center gap-2.5 border-t border-doom-border-soft px-3 sm:px-[26px]",
+				children: [/* @__PURE__ */ jsx("span", {
+					"data-testid": "runner-log-path",
+					className: "min-w-0 flex-1 truncate font-mono text-sm text-doom-dim",
+					children: run?.logPath ?? slice?.path ?? ""
+				}), slice !== void 0 ? /* @__PURE__ */ jsx("span", {
+					className: "shrink-0 text-sm text-doom-dim",
+					children: formatSize$1(slice.fileSize)
+				}) : null]
+			})
+		]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/screenApi.ts
+/**
+* The page's half of the attached pane.
+*
+* Two directions over two mechanisms, because the hub proxies requests and
+* server-sent events but cannot upgrade a socket: pane bytes arrive on an
+* EventSource, and keystrokes go back as ordinary POSTs. Both addresses come
+* from the generated client: the stream route offers a URL and no call method,
+* which is exactly what an EventSource wants and all it can be given.
+*/
+/** Turns one base64 chunk back into the bytes a terminal was sent. */
+function decodeChunk(chunk) {
+	const binary = atob(chunk);
+	const bytes = new Uint8Array(binary.length);
+	for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+	return bytes;
+}
+/** Attempts before a dropped screen stream is reported as lost rather than retried. */
+const MAX_RETRIES = 5;
+const RETRY_BASE_MS = 500;
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function watchRunnerScreen(sessionId, runId, from, handlers) {
+	let offset = from;
+	let retries = 0;
+	let closed = false;
+	let source;
+	let timer;
+	const open = () => {
+		if (closed) return;
+		const current = new EventSource(api.session(sessionId).screenStream.url({
+			params: { [RUN_ID_PARAM]: runId },
+			query: { [RUNNER_LOG_PARAMS.from]: offset }
+		}));
+		source = current;
+		current.addEventListener(RUNNER_SCREEN_EVENT, (message) => {
+			let parsed;
+			try {
+				parsed = JSON.parse(message.data);
+			} catch {
+				return;
+			}
+			if (!isRecord$1(parsed) || typeof parsed.chunk !== "string") return;
+			const event = parsed;
+			if (typeof event.offset === "number") offset = event.offset;
+			retries = 0;
+			if (event.ended === true) {
+				closed = true;
+				current.close();
+			}
+			handlers.onEvent(event);
+		});
+		current.addEventListener("error", () => {
+			current.close();
+			if (closed) return;
+			retries += 1;
+			if (retries > MAX_RETRIES) {
+				handlers.onLost();
+				return;
+			}
+			timer = setTimeout(open, RETRY_BASE_MS * 2 ** (retries - 1));
+		});
+	};
+	open();
+	return { close: () => {
+		closed = true;
+		if (timer !== void 0) clearTimeout(timer);
+		source?.close();
+	} };
+}
+/** Sends one batch of keystrokes. Resolves to whether the pane took them. */
+async function sendRunnerInput(sessionId, runId, text) {
+	const body = { text };
+	return (await api.session(sessionId).input({
+		params: { [RUN_ID_PARAM]: runId },
+		body
+	})).ok;
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/RunnerShellPanel.tsx
+const TAB_ID_PREFIX = "runner-shell-";
+/** Keystrokes are gathered for this long and sent as one request. */
+const FLUSH_MS = 30;
+/** The temporary tab holding one interactive runner's pane. */
+function runnerShellTab(run) {
+	const runId = run.id;
+	return {
+		id: `${TAB_ID_PREFIX}${runId}`,
+		label: `shell · ${run.name}`,
+		panel: (props) => /* @__PURE__ */ jsx(RunnerShellPanel, {
+			...props,
+			runId
+		})
+	};
+}
+/**
+* An interactive runner's pane, attached.
+*
+* A real terminal emulator, fed the pane's own bytes. The runner's sink keeps
+* an unscrubbed copy of its output beside the log for exactly this: the log is
+* stripped of cursor movement so it stays worth grepping, which is precisely
+* what a terminal needs. Because these are the original bytes, colour, cursor
+* placement and full-screen programs all render the way they would in a shell.
+*
+* xterm is loaded when the tab opens rather than with the plugin. Most sessions
+* never attach to anything, and an emulator is not a small thing to carry.
+*/
+function RunnerShellPanel({ sessionId, runId }) {
+	const { runs } = useStore(runners.store, (state) => runners.select(state, sessionId));
+	const run = runs.find((candidate) => candidate.id === runId);
+	const [ended, setEnded] = useState(false);
+	const [lost, setLost] = useState(false);
+	const [ready, setReady] = useState(false);
+	const terminal = useRef(null);
+	const pending = useRef([]);
+	const flush = useRef(void 0);
+	useEffect(() => {
+		if (sessionId === null || !ready) return;
+		const watch = watchRunnerScreen(sessionId, runId, 0, {
+			onEvent: (event) => {
+				if (event.chunk !== "") terminal.current?.write(decodeChunk(event.chunk));
+				if (event.ended === true) setEnded(true);
+			},
+			onLost: () => setLost(true)
+		});
+		return () => watch.close();
+	}, [
+		sessionId,
+		runId,
+		ready
+	]);
+	useEffect(() => () => {
+		if (flush.current !== void 0) clearTimeout(flush.current);
+	}, []);
+	const send = (text) => {
+		if (sessionId === null) return;
+		pending.current.push(text);
+		if (flush.current !== void 0) return;
+		flush.current = setTimeout(() => {
+			const batch = pending.current.join("");
+			pending.current = [];
+			flush.current = void 0;
+			if (batch !== "") sendRunnerInput(sessionId, runId, batch);
+		}, FLUSH_MS);
+	};
+	const live = run?.state === "running" && !ended;
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "runner-shell-panel",
+		className: "flex min-h-0 flex-1 flex-col",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex min-h-11 shrink-0 items-center gap-2.5 border-b border-doom-border-soft px-3 sm:h-11 sm:px-[26px]",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						"data-testid": "runner-shell-name",
+						className: "shrink-0 truncate text-base font-semibold text-doom-hi",
+						children: run?.name ?? runId
+					}),
+					/* @__PURE__ */ jsx(StatusBadge, {
+						tone: live ? "running" : "neutral",
+						"data-testid": "runner-shell-state",
+						children: live ? "attached" : "detached"
+					}),
+					/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }),
+					lost ? /* @__PURE__ */ jsx("span", {
+						"data-testid": "runner-shell-lost",
+						className: "shrink-0 text-base text-doom-red",
+						children: "the connection to this pane dropped"
+					}) : null,
+					live ? /* @__PURE__ */ jsx(Button, {
+						variant: "outline",
+						size: "xs",
+						"data-testid": "runner-shell-interrupt",
+						title: "send ctrl-c",
+						onClick: () => send(""),
+						className: "px-2 ",
+						children: "ctrl-c"
+					}) : null
+				]
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "relative min-h-0 flex-1 overflow-hidden bg-doom-deep px-3 py-2 sm:px-[26px]",
+				children: [/* @__PURE__ */ jsx(TerminalView, {
+					ref: terminal,
+					"data-testid": "runner-shell-terminal",
+					onData: (text) => send(text),
+					onReady: () => setReady(true)
+				}), ready ? null : /* @__PURE__ */ jsx("p", {
+					"data-testid": "runner-shell-reading",
+					className: "text-sm text-doom-dim",
+					children: "attaching…"
+				})]
+			}),
+			/* @__PURE__ */ jsx("div", {
+				className: "flex h-8 shrink-0 items-center border-t border-doom-border-soft px-3 sm:px-[26px]",
+				children: /* @__PURE__ */ jsx("span", {
+					className: "min-w-0 flex-1 truncate text-sm text-doom-dim",
+					children: live ? "typing goes straight to the runner" : "this runner is no longer accepting input"
+				})
+			})
+		]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/runnerTail.ts
+/**
+* The newest line a running runner has written, for a row that has one line to
+* spend.
+*
+* The dock answers "what is happening", and a command that has not changed
+* since it started answers "what was asked". The last line of the log is the
+* closest thing to progress the cockpit can show without opening the log, so a
+* row that is still running trades its command for it.
+*
+* The line comes from the same two calls the log panel makes: read the tail,
+* then follow the stream from exactly where that read ended. Nothing new goes
+* on the wire, and a runner nobody is looking at is not followed, because the
+* stream lives and dies with the row.
+*/
+/** Enough lines that a trailing blank, or a final progress redraw, is not the whole answer. */
+const TAIL_REQUEST_LINES = 5;
+/**
+* The last line worth showing, as plain text.
+*
+* Blank lines are skipped, because a log that ends with a newline would
+* otherwise report nothing at all. Colour is dropped rather than rendered: the
+* row is nine pixels of faint text beside a name and a stop control, and a
+* green tick from someone else's palette in the middle of it reads as damage.
+*/
+function plainTailLine(lines) {
+	for (let index = lines.length - 1; index >= 0; index -= 1) {
+		const text = ansiSpans(lines[index] ?? "").map((span) => span.text).join("").trim();
+		if (text.length > 0) return text;
+	}
+}
+/**
+* The newest log line of a running runner, or undefined for a runner that is
+* finished, unreachable, or has not written anything yet. The caller decides
+* what to show instead; this hook never invents a placeholder.
+*/
+function useRunnerTail(sessionId, runId, running) {
+	const [tail, setTail] = useState(void 0);
+	useEffect(() => {
+		if (!running || sessionId === null) return;
+		let live = true;
+		let follow;
+		const controller = new AbortController();
+		fetchRunnerLog(sessionId, runId, { lines: TAIL_REQUEST_LINES }, controller.signal).then((result) => {
+			if (!live || "error" in result) return;
+			const initial = plainTailLine(result.slice.text.split("\n"));
+			if (initial !== void 0) setTail({
+				runId,
+				text: initial
+			});
+			if (!result.slice.running) return;
+			follow = followRunnerLog(sessionId, runId, result.slice.completeBytes, {
+				onEvent: (event) => {
+					const next = plainTailLine(event.lines);
+					if (live && next !== void 0) setTail({
+						runId,
+						text: next
+					});
+				},
+				onLost: () => void 0
+			});
+		});
+		return () => {
+			live = false;
+			controller.abort();
+			follow?.close();
+		};
+	}, [
+		sessionId,
+		runId,
+		running
+	]);
+	return running && tail?.runId === runId ? tail.text : void 0;
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/RunnersPanel.tsx
+const TICK_MS$1 = 1e4;
+const SHELL_LAUNCH_TIMEOUT_MS = 3e4;
+const RUNNERS_TAB_ID = "runner-runs";
+/** The temporary tab the dock's runners group opens from its own name. */
+function runnersTab() {
+	return {
+		id: RUNNERS_TAB_ID,
+		label: "runners",
+		panel: RunnersPanel
+	};
+}
+/**
+* Everything this session has up, one card each.
+*
+* The dock's rail gives a runner one line, which is enough to notice it and
+* not enough to work with it. This is the same set with room: the command in
+* full, where it runs, and the last thing it said.
+*
+* Running runners only, the same rule the rail follows. A finished run leaves
+* the moment it exits, because this answers "what is happening"; its log stays
+* readable from its own tab, and `doom-runner list` is where history lives.
+*/
+function RunnersPanel({ sessionId, sendSessionFrame, openTransientTab }) {
+	const session = useStore(runners.store, (state) => runners.select(state, sessionId));
+	const running = session.runs.filter((run) => run.state === "running");
+	const [now, setNow] = useState(() => Date.now());
+	const [launching, setLaunching] = useState(false);
+	const shellBaseline = useRef(null);
+	const shellLaunchTimeout = useRef(void 0);
+	const defaultCwd = running[0]?.cwd;
+	const startShell = () => {
+		if (sessionId === null) return;
+		shellBaseline.current = new Set(session.runs.map((run) => run.id));
+		clearTimeout(shellLaunchTimeout.current);
+		shellLaunchTimeout.current = setTimeout(() => {
+			shellBaseline.current = null;
+		}, SHELL_LAUNCH_TIMEOUT_MS);
+		requestRunnerStart(sendSessionFrame, sessionId, RUNNER_SHELL_REQUEST);
+	};
+	useEffect(() => {
+		const timer = setInterval(() => setNow(Date.now()), TICK_MS$1);
+		return () => clearInterval(timer);
+	}, []);
+	useEffect(() => {
+		const baseline = shellBaseline.current;
+		if (baseline === null) return;
+		const shell = session.runs.find((run) => run.state === "running" && run.interactive && !baseline.has(run.id));
+		if (!shell) return;
+		shellBaseline.current = null;
+		clearTimeout(shellLaunchTimeout.current);
+		openTransientTab(runnerShellTab(shell));
+	}, [openTransientTab, session.runs]);
+	useEffect(() => () => clearTimeout(shellLaunchTimeout.current), []);
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "runners-panel",
+		className: "flex min-h-0 flex-1 flex-col overflow-auto",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex min-h-11 shrink-0 items-center gap-2.5 border-b border-doom-border-soft px-3 sm:h-11 sm:px-[26px]",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						className: "text-lg font-semibold text-doom-hi",
+						children: "runners"
+					}),
+					/* @__PURE__ */ jsx("span", {
+						"data-testid": "runners-panel-count",
+						className: "text-sm text-doom-dim",
+						children: running.length === 0 ? "nothing running" : `${String(running.length)} running`
+					}),
+					/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }),
+					sessionId === null ? null : /* @__PURE__ */ jsxs(DropdownMenu, { children: [/* @__PURE__ */ jsx(DropdownMenuTrigger, {
+						asChild: true,
+						children: /* @__PURE__ */ jsx(Button, {
+							variant: "ghost",
+							size: "icon",
+							"data-testid": "runners-panel-launch",
+							title: "launch a runner",
+							"aria-label": "launch a runner",
+							className: "text-doom-faint hover:text-doom-hi",
+							children: /* @__PURE__ */ jsx(PlusIcon, { className: "h-3 w-3" })
+						})
+					}), /* @__PURE__ */ jsxs(DropdownMenuContent, {
+						align: "end",
+						"data-testid": "runners-panel-launch-menu",
+						children: [/* @__PURE__ */ jsx(DropdownMenuItem, {
+							"data-testid": "runners-panel-start-shell",
+							onSelect: startShell,
+							children: "start shell"
+						}), /* @__PURE__ */ jsx(DropdownMenuItem, {
+							"data-testid": "runners-panel-run-command",
+							onSelect: () => setLaunching(true),
+							children: "run command"
+						})]
+					})] })
+				]
+			}),
+			running.length === 0 ? /* @__PURE__ */ jsx(EmptyState, {
+				"data-testid": "runners-panel-empty",
+				className: "px-4 py-8",
+				title: "nothing running",
+				description: "a command that outlives its turn moves to a runner and appears here while it works.",
+				children: sessionId === null ? null : /* @__PURE__ */ jsx(Button, {
+					variant: "outline",
+					size: "xs",
+					"data-testid": "runners-panel-launch-empty",
+					onClick: () => setLaunching(true),
+					className: "px-2 ",
+					children: "launch a runner"
+				})
+			}) : /* @__PURE__ */ jsx("div", {
+				"data-testid": "runners-panel-grid",
+				className: "grid grid-cols-1 gap-2.5 px-3 py-3 sm:grid-cols-2 sm:px-[26px] xl:grid-cols-3",
+				children: running.map((run) => /* @__PURE__ */ jsx(RunnerCard, {
+					run,
+					now,
+					stopRequested: session.stopRequested.includes(run.id),
+					sessionId,
+					sendSessionFrame,
+					openTransientTab
+				}, run.id))
+			}),
+			launching && sessionId !== null ? /* @__PURE__ */ jsx(LaunchRunnerDialog, {
+				sessionId,
+				sendSessionFrame,
+				...defaultCwd === void 0 ? {} : { defaultCwd },
+				onClose: () => setLaunching(false)
+			}) : null
+		]
+	});
+}
+/**
+* One running runner. Its own component because the tail line is a
+* subscription per card, and a card that leaves the grid closes it.
+*/
+function RunnerCard({ run, now, stopRequested, sessionId, sendSessionFrame, openTransientTab }) {
+	const tail = useRunnerTail(sessionId, run.id, run.state === "running");
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": `runners-card-${run.id}`,
+		className: "flex min-w-0 flex-col gap-1.5 rounded-md border border-doom-border-soft bg-doom-panel p-2.5",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex min-w-0 items-center gap-1.5",
+				children: [
+					/* @__PURE__ */ jsx(Dot, {
+						tone: "yellow",
+						pulse: true
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: "min-w-0 flex-1 truncate text-base font-semibold text-doom-hi",
+						children: run.name
+					}),
+					/* @__PURE__ */ jsxs("span", {
+						className: "shrink-0 text-sm text-doom-dim",
+						children: [formatRunnerUptime(run.startedAt, now), run.interactive ? " · tty" : ""]
+					})
+				]
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "min-w-0 break-all font-mono text-sm leading-normal text-doom-dim",
+				children: run.command
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "min-w-0 truncate font-mono text-sm text-doom-dim",
+				children: run.cwd
+			}),
+			/* @__PURE__ */ jsx("span", {
+				"data-testid": `runners-card-detail-${run.id}`,
+				"data-detail": tail === void 0 ? "command" : "tail",
+				className: "min-w-0 truncate text-sm text-doom-dim",
+				children: tail ?? "…"
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex items-center gap-1.5 pt-0.5",
+				children: [
+					/* @__PURE__ */ jsx(Button, {
+						variant: "outline",
+						size: "xs",
+						"data-testid": `runners-card-log-${run.id}`,
+						title: "open this runner's log",
+						onClick: () => openTransientTab(runnerLogTab(run)),
+						className: "px-2 ",
+						children: "log"
+					}),
+					run.interactive && sessionId !== null ? /* @__PURE__ */ jsx(Button, {
+						variant: "outline",
+						size: "xs",
+						"data-testid": `runners-card-shell-${run.id}`,
+						title: "attach to this runner's terminal",
+						onClick: () => openTransientTab(runnerShellTab(run)),
+						className: "px-2 ",
+						children: "shell"
+					}) : null,
+					/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }),
+					sessionId !== null ? /* @__PURE__ */ jsx(Button, {
+						variant: stopRequested ? "outline" : "danger-outline",
+						size: "xs",
+						"data-testid": `runners-card-stop-${run.id}`,
+						disabled: stopRequested,
+						title: stopRequested ? "stop requested; the runner reports its own exit" : "ask the runtime to stop this runner",
+						onClick: () => requestRunnerStop(sendSessionFrame, sessionId, run.id),
+						className: "px-2 ",
+						children: stopRequested ? "stopping…" : "stop"
+					}) : null
+				]
+			})
+		]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/activity-group/runners.web.ts
+var runners_web_default = defineActivityGroup({
+	keys: "r l",
+	icon: PlayCircleIcon,
+	statusKey: "doom-runner-runners",
+	activeSource: runnerActivitySource,
+	transientTab: runnersTab,
+	order: 20
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/channel/runner-runs.web.ts
+var runner_runs_web_default = defineChannelFile(runnerRunsChannel);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/_components/RunnersActivitySection.tsx
+const TICK_MS = 1e4;
+/**
+* The runners group's body in the activity dock: what this session has up
+* right now.
+*
+* Only running runners are listed. A finished one leaves the moment it exits,
+* because the dock answers "what is happening", and a rail that keeps ten
+* completed playwright calls around buries the one command still working. The
+* runtime keeps every record; `doom-runner list` and the run's own log tab are
+* where a finished run is read.
+*/
+function RunnersActivitySection({ sessionId, sendSessionFrame, openTransientTab }) {
+	const session = useStore(runners.store, (state) => runners.select(state, sessionId));
+	const running = session.runs.filter((run) => run.state === "running");
+	const [now, setNow] = useState(() => Date.now());
+	useEffect(() => {
+		const timer = setInterval(() => setNow(Date.now()), TICK_MS);
+		return () => clearInterval(timer);
+	}, []);
+	if (running.length === 0) return /* @__PURE__ */ jsxs("div", {
+		className: "flex flex-wrap items-center gap-x-4 gap-y-1",
+		children: [/* @__PURE__ */ jsx("p", {
+			"data-testid": "activity-summary-runners",
+			className: "text-sm text-doom-dim",
+			children: "Idle"
+		}), sessionId === null ? null : /* @__PURE__ */ jsxs(Button, {
+			variant: "link",
+			size: "sm",
+			"data-testid": "activity-runner-launch",
+			className: "h-auto gap-1 px-0 text-doom-green",
+			onClick: () => openTransientTab(runnersTab()),
+			children: ["Launch a runner", /* @__PURE__ */ jsx(ArrowRightIcon, {
+				"aria-hidden": true,
+				className: "size-3.5"
+			})]
+		})]
+	});
+	return /* @__PURE__ */ jsx("div", {
+		"data-testid": "activity-runner-runs",
+		className: "flex flex-col gap-0.5",
+		children: running.map((run) => /* @__PURE__ */ jsx(RunnerRow, {
+			run,
+			now,
+			stopRequested: session.stopRequested.includes(run.id),
+			sessionId,
+			sendSessionFrame,
+			openTransientTab
+		}, run.id))
+	});
+}
+/**
+* One running runner: its name, how long it has been up, a stop control, and
+* one line of what it is doing. Its own component because the tail line is a
+* subscription per row, and a row that scrolls out of the dock closes it.
+*/
+function RunnerRow({ run, now, stopRequested, sessionId, sendSessionFrame, openTransientTab }) {
+	const tail = useRunnerTail(sessionId, run.id, run.state === "running");
+	return /* @__PURE__ */ jsxs(Button, {
+		variant: "ghost",
+		size: "card",
+		"data-testid": `activity-runner-${run.id}`,
+		"data-runner-tone": "running",
+		title: "open this runner's log",
+		onClick: () => {
+			if (sessionId === null) return;
+			openTransientTab(runnerLogTab(run));
+		},
+		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: "yellow",
+					pulse: true
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: "min-w-0 flex-1 truncate text-left text-base font-semibold text-doom-hi",
+					children: run.name
+				}),
+				/* @__PURE__ */ jsxs("span", {
+					className: "shrink-0 text-sm text-doom-dim",
+					children: [formatRunnerUptime(run.startedAt, now), run.interactive ? " · tty" : ""]
+				}),
+				sessionId !== null ? /* @__PURE__ */ jsx(Button, {
+					asChild: true,
+					variant: stopRequested ? "outline" : "danger-outline",
+					size: "xs",
+					"data-testid": `activity-runner-stop-${run.id}`,
+					"data-stopping": stopRequested,
+					title: stopRequested ? "stop requested; the runner reports its own exit" : "ask the runtime to stop this runner",
+					className: "px-1.5",
+					children: /* @__PURE__ */ jsx("span", {
+						role: "button",
+						tabIndex: stopRequested ? -1 : 0,
+						"aria-disabled": stopRequested,
+						onClick: (event) => {
+							event.stopPropagation();
+							if (!stopRequested) requestRunnerStop(sendSessionFrame, sessionId, run.id);
+						},
+						onKeyDown: (event) => {
+							if (event.key !== "Enter" && event.key !== " ") return;
+							event.preventDefault();
+							event.stopPropagation();
+							if (!stopRequested) requestRunnerStop(sendSessionFrame, sessionId, run.id);
+						},
+						children: stopRequested ? "stopping…" : "stop"
+					})
+				}) : null
+			]
+		}), /* @__PURE__ */ jsx("span", {
+			"data-testid": `activity-runner-detail-${run.id}`,
+			"data-detail": tail === void 0 ? "command" : "tail",
+			className: "truncate pl-3 text-left text-sm text-doom-dim",
+			children: tail ?? run.command
+		})]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/Runners.activity.runners.web.tsx
+var Runners_activity_runners_web_default = defineFill({ component: RunnersActivitySection });
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/_lib/bashToolFormat.ts
+/**
+* Pure view logic for the browser bash tool card.
+* Every input is the wire JSON of a tool_execution frame.
+*/
+const ELLIPSIS = "…";
+/** Spaced so the join never glues two words into one unreadable token. */
+const GAP = " … ";
+/** Wide enough to keep a realistic command intact, short enough to stay on a few rows. */
+const MAX_COMMAND_LENGTH = 160;
+/** Live output is unbounded while a command runs, so the running state keeps only a window. */
+const STREAM_TAIL_LINES = 12;
+const BYTES_PER_KB = 1024;
+const BYTES_PER_MB = BYTES_PER_KB * BYTES_PER_KB;
+/** The user's home on the two platforms the runner ships for; the browser cannot ask the OS. */
+const HOME_PATH = /(?<![\w.-])(?:\/Users|\/home)\/[^/\s]+(?=\/|\s|$)/g;
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Narrows the result details to the fields the card reads; anything else is ignored. */
+function bashResultDetails(details) {
+	if (!isRecord(details)) return {};
+	const out = {};
+	if (typeof details.id === "string") out.id = details.id;
+	if (typeof details.runner === "string") out.runner = details.runner;
+	if (typeof details.exitCode === "number" || details.exitCode === null) out.exitCode = details.exitCode;
+	if (typeof details.logPath === "string") out.logPath = details.logPath;
+	if (typeof details.fileSize === "number") out.fileSize = details.fileSize;
+	if (typeof details.lines === "number") out.lines = details.lines;
+	if (details.timedOut === true) out.timedOut = true;
+	if (details.promoted === true) out.promoted = true;
+	if (typeof details.reason === "string") out.reason = details.reason;
+	if (typeof details.tail === "string") out.tail = details.tail;
+	if (typeof details.tailLines === "number") out.tailLines = details.tailLines;
+	return out;
+}
+/** `/Users/me/x` becomes `~/x`. Absolute home paths are what push these lines onto extra rows. */
+function abbreviateHome(text) {
+	return text.replace(HOME_PATH, "~");
+}
+/** Collapse a heredoc or multi-line script to one scannable line plus a count. */
+function collapseCommand(command) {
+	const lines = command.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+	const first = lines[0] ?? "";
+	return lines.length > 1 ? `${first} ${ELLIPSIS} +${lines.length - 1} lines` : first;
+}
+/** Drop the middle rather than the end, so a long pipeline keeps both its source and its sink. */
+function truncateMiddle(text, max = MAX_COMMAND_LENGTH) {
+	if (text.length <= max) return text;
+	const keep = max - 3;
+	const head = Math.ceil(keep / 2);
+	let start = text.slice(0, head);
+	let end = text.slice(text.length - (keep - head));
+	const lastSpace = start.lastIndexOf(" ");
+	if (lastSpace > start.length / 2) start = start.slice(0, lastSpace);
+	const firstSpace = end.indexOf(" ");
+	if (firstSpace >= 0 && firstSpace < end.length / 2) end = end.slice(firstSpace + 1);
+	return `${start}${GAP}${end}`;
+}
+function formatBashCommand(command) {
+	return truncateMiddle(abbreviateHome(collapseCommand(command)));
+}
+/** Modifiers worth seeing at a glance, in the widget's `·` idiom. */
+function formatBashFlags(args) {
+	const flags = [];
+	if (args.background === true) flags.push("bg");
+	if (args.interactive === true) flags.push("tty");
+	if (typeof args.timeout === "number") flags.push(`${args.timeout}s`);
+	if (typeof args.name === "string" && args.name.length > 0) flags.push(args.name);
+	return flags;
+}
+/** Human-readable byte count, matching how pi reports output sizes. */
+function formatSize(bytes) {
+	if (bytes < BYTES_PER_KB) return `${bytes} B`;
+	if (bytes < BYTES_PER_MB) return `${(bytes / BYTES_PER_KB).toFixed(1)} KB`;
+	return `${(bytes / BYTES_PER_MB).toFixed(1)} MB`;
+}
+/** The metadata footer, collapsed from five lines to one. */
+function formatResultSummary(details) {
+	const parts = [];
+	if (details.lines !== void 0) parts.push(`${details.lines.toLocaleString("en-US")} lines`);
+	if (details.fileSize !== void 0) parts.push(formatSize(details.fileSize));
+	if (details.runner !== void 0) parts.push(details.runner);
+	return parts.join(" · ");
+}
+/** Last `max` lines, so a chatty command cannot push the transcript off screen. */
+function lastLines(text, max) {
+	const all = text.split("\n");
+	while (all.length > 0 && all[all.length - 1]?.trim() === "") all.pop();
+	return all.length <= max ? all : all.slice(-max);
+}
+function bashResultView(input) {
+	const details = bashResultDetails(input.details);
+	if (input.isPartial) return {
+		lines: lastLines(input.output, STREAM_TAIL_LINES),
+		status: {
+			glyph: "◐",
+			tone: "running",
+			text: "running"
+		},
+		hidden: 0
+	};
+	if (input.isError) {
+		const all = lastLines(input.output, Number.MAX_SAFE_INTEGER);
+		const lines = input.expanded ? all : all.slice(-12);
+		const summary = formatResultSummary(details);
+		return {
+			lines,
+			status: {
+				glyph: "✗",
+				tone: "error",
+				text: summary.length > 0 ? summary : "failed"
+			},
+			hidden: all.length - lines.length
+		};
+	}
+	if (details.promoted === true) return {
+		lines: [],
+		status: {
+			glyph: "●",
+			tone: "background",
+			text: `${details.runner ?? details.id ?? "runner"}${details.id === void 0 ? "" : ` · ${details.id}`} · background`
+		},
+		hidden: 0
+	};
+	const all = lastLines(details.tail ?? "", Number.MAX_SAFE_INTEGER);
+	const lines = input.expanded ? all : all.slice(-12);
+	const exited = details.exitCode !== void 0 && details.exitCode !== null;
+	const failed = details.timedOut === true || exited && details.exitCode !== 0;
+	const meta = [];
+	if (details.timedOut === true) meta.push("timed out");
+	else if (failed) meta.push(`exit ${details.exitCode}`);
+	const summary = formatResultSummary(details);
+	if (summary.length > 0) meta.push(summary);
+	const text = meta.length > 0 ? meta.join(" · ") : failed ? "failed" : lines.length === 0 ? "done" : "";
+	return {
+		lines,
+		status: text.length > 0 ? {
+			glyph: failed ? "✗" : "✓",
+			tone: failed ? "error" : "ok",
+			text
+		} : null,
+		hidden: all.length - lines.length
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/_components/BashToolMessage.tsx
+const STATUS_TONE = {
+	running: "running",
+	ok: "ok",
+	error: "error",
+	background: "info"
+};
+/**
+* The bash tool's timeline item, the web half of renderBashCall and
+* renderBashResult. Collapsed it is a single header row: the tool name, the
+* command shortened to one line, its modifiers, and the outcome badge, so a
+* transcript of many calls stays scannable. Expanding it opens the body: the
+* command exactly as it was run, then the whole tail the frame carries, each
+* in its own scroll box so one chatty command cannot own the viewport. A
+* command promoted to a background runner offers the same stop the activity
+* dock does, for as long as the runners channel reports it running.
+*/
+function BashToolMessage({ sessionId, args, result, output, running, isError, sendSessionFrame, openTransientTab }) {
+	const details = bashResultDetails(result?.details);
+	const runnerId = details.promoted === true ? details.id : void 0;
+	const run = useStore(runners.store, (state) => details.id === void 0 ? void 0 : runners.select(state, sessionId).runs.find((entry) => entry.id === details.id));
+	const stopping = useStore(runners.store, (state) => runnerId !== void 0 && runners.select(state, sessionId).stopRequested.includes(runnerId));
+	const rawCommand = typeof args.command === "string" ? args.command : "";
+	const command = formatBashCommand(rawCommand);
+	const flags = formatBashFlags(args);
+	const stoppable = sessionId !== null && runnerId !== void 0 && run !== void 0 && run.exit === void 0;
+	return /* @__PURE__ */ jsx(MessageItem, {
+		tone: toolTone({
+			running,
+			isError
+		}),
+		expandable: true,
+		children: ({ expanded }) => {
+			const view = bashResultView({
+				details: result?.details,
+				output,
+				expanded: true,
+				isPartial: running,
+				isError
+			});
+			return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsxs(MessageItemHeader, {
+				title: "bash",
+				children: [
+					/* @__PURE__ */ jsxs("span", {
+						"data-testid": "tool-call-bash",
+						className: "flex min-w-0 flex-1 items-center gap-2",
+						children: [/* @__PURE__ */ jsx("span", {
+							className: "min-w-0 flex-1 truncate font-mono text-doom-text",
+							children: command
+						}), flags.length > 0 ? /* @__PURE__ */ jsxs("span", {
+							className: "hidden shrink-0 text-doom-dim sm:inline",
+							children: ["· ", flags.join(" · ")]
+						}) : null]
+					}),
+					run !== void 0 && sessionId !== null ? /* @__PURE__ */ jsxs(Button, {
+						variant: "outline",
+						size: "xs",
+						"data-testid": "tool-result-bash-open-log",
+						title: "open this runner's full log",
+						onClick: (event) => {
+							event.stopPropagation();
+							openTransientTab(runnerLogTab(run));
+						},
+						className: "shrink-0 gap-1 px-1.5 ",
+						children: [/* @__PURE__ */ jsx(FileIcon, { className: "h-2.5 w-2.5" }), "log"]
+					}) : null,
+					stoppable ? /* @__PURE__ */ jsx(Button, {
+						size: "xs",
+						variant: stopping ? "outline" : "danger-outline",
+						disabled: stopping,
+						"data-testid": "tool-result-bash-stop",
+						"data-stopping": stopping,
+						title: stopping ? "stop requested; the runner reports its own exit" : "ask the runtime to stop this runner",
+						onClick: (event) => {
+							event.stopPropagation();
+							if (sessionId !== null && runnerId !== void 0) requestRunnerStop(sendSessionFrame, sessionId, runnerId);
+						},
+						className: "shrink-0 px-1.5 ",
+						children: stopping ? "stopping…" : "stop"
+					}) : null
+				]
+			}), expanded ? /* @__PURE__ */ jsxs(MessageItemBody, {
+				"data-testid": "tool-result-bash",
+				className: "flex flex-col gap-2",
+				children: [
+					rawCommand.length > 0 ? /* @__PURE__ */ jsx(SyntaxText, {
+						"data-testid": "tool-result-bash-command",
+						grammar: "shell",
+						text: rawCommand,
+						className: "max-h-40 overflow-auto text-doom-text"
+					}) : null,
+					view.lines.length > 0 ? /* @__PURE__ */ jsx(AnsiText, {
+						"data-testid": "tool-result-bash-output",
+						text: view.lines.join("\n"),
+						className: "max-h-96 overflow-auto whitespace-pre-wrap break-words [overflow-wrap:anywhere] border-doom-border-soft border-t pt-2 font-mono text-doom-dim"
+					}) : null,
+					view.status ? /* @__PURE__ */ jsx(MessageItemStatus, {
+						"data-testid": "tool-result-bash-status",
+						tone: STATUS_TONE[view.status.tone],
+						glyph: view.status.glyph,
+						className: "min-w-0",
+						children: /* @__PURE__ */ jsx("span", {
+							className: "break-words",
+							children: view.status.text
+						})
+					}) : null,
+					details.logPath !== void 0 ? /* @__PURE__ */ jsxs("span", {
+						"data-testid": "tool-result-bash-log",
+						className: "min-w-0 break-all text-doom-dim",
+						children: ["full log · ", /* @__PURE__ */ jsx("span", {
+							className: "text-doom-dim",
+							children: details.logPath
+						})]
+					}) : null
+				]
+			}) : null] });
+		}
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/bash.web.tsx
+var bash_web_default = defineToolRenderer({ message: BashToolMessage });
+//#endregion
+//#region generated/web.ts
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const webPlugin = defineWebPlugin({
+	id: "runner",
+	session: {
+		get activityGroups() {
+			return [via({ name: "runners" }, runners_web_default)];
+		},
+		get channels() {
+			return [via({ channel: "runner_runs" }, runner_runs_web_default)];
+		},
+		get fills() {
+			return [via({
+				slot: "activity.runners",
+				id: "runners"
+			}, Runners_activity_runners_web_default)];
+		},
+		get toolRenderers() {
+			return [via({ tools: ["bash"] }, bash_web_default)];
+		}
+	}
+});
+//#endregion
+export { webPlugin };
+
+//# sourceMappingURL=web.mjs.map