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

package/dist/extensions/native.mjs

@@ -0,0 +1,1620 @@
+import { createApiClient, defineActivityGroup, defineChannelFile, defineFill, defineNativePlugin, defineSessionStore, nativeApiTransport, sessionApiAddress } from "@agimon-ai/po-core/native";
+import { Badge, Button, CodeBlock, Dot, Input, ListRow, Markdown, Sheet, SheetBody, SheetContent, SheetHeader, SheetTitle, Textarea, WorkflowIcon } from "@agimon-ai/po-native-components";
+import { createElement, useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { View } from "react-native-unistyles/components/native/View";
+import { Text } from "react-native-unistyles/components/native/Text";
+import { ScrollView } from "react-native-unistyles/components/native/ScrollView";
+import { StyleSheet } from "react-native-unistyles";
+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/runDuration.ts
+/**
+* Local copy of the host's formatRunDuration (src/web/lib/sessionSummary.ts):
+* this plugin keeps zero host-lib imports so its later move into the owning
+* package is a file relocation.
+*/
+const MINUTE_MS = 6e4;
+const HOUR_MS = 60 * MINUTE_MS;
+function formatRunDuration(elapsedMs) {
+	if (elapsedMs < MINUTE_MS) return "<1m";
+	if (elapsedMs < HOUR_MS) return `${Math.floor(elapsedMs / MINUTE_MS)}m`;
+	const hours = Math.floor(elapsedMs / HOUR_MS);
+	const minutes = Math.floor(elapsedMs % HOUR_MS / MINUTE_MS);
+	return `${hours}h ${String(minutes).padStart(2, "0")}m`;
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/workflowActivity.ts
+const PAUSED_STATES = /* @__PURE__ */ new Set(["paused", "pause_requested"]);
+function workflowRunIdentity(run) {
+	return `${run.workspace}/${run.runKey}`;
+}
+function toneOf(run) {
+	if (run.stage === "running") return run.executionState !== void 0 && PAUSED_STATES.has(run.executionState) ? "paused" : "running";
+	if (run.stage === "error") return "failed";
+	if (run.outcome !== void 0 && run.outcome !== "success") return run.outcome === "failed" ? "failed" : "skipped";
+	return "done";
+}
+function detailOf(run, tone) {
+	if (tone === "paused") return "paused; resume it from the owning session";
+	if (tone === "failed") return run.errorMessage ?? (run.failedJob === void 0 ? "failed" : `job '${run.failedJob}' failed`);
+	if (tone === "running") {
+		if (run.position === void 0) return "starting";
+		return run.position.step === void 0 ? run.position.job : `${run.position.job} · ${run.position.step}`;
+	}
+	return run.outcome ?? "done";
+}
+function elapsedOf(run, now) {
+	const start = Date.parse(run.startedAt);
+	if (!Number.isFinite(start)) return "";
+	const end = run.finishedAt === void 0 ? now : Date.parse(run.finishedAt);
+	return formatRunDuration(Math.max(0, (Number.isFinite(end) ? end : now) - start));
+}
+/** The hub's presented order is kept: it already puts live runs first. */
+function workflowActivityRows(runs, now, sessionId = null) {
+	return runs.map((run) => {
+		const tone = toneOf(run);
+		return {
+			identity: workflowRunIdentity(run),
+			runKey: run.runKey,
+			name: run.displayName,
+			tone,
+			elapsed: elapsedOf(run, now),
+			detail: detailOf(run, tone),
+			...run.ownerSessionId === void 0 || run.ownerSessionId === sessionId ? {} : { ownerSessionId: run.ownerSessionId }
+		};
+	});
+}
+const GROUP_OF = {
+	running: "running",
+	paused: "running",
+	failed: "failed",
+	done: "successful",
+	skipped: "successful"
+};
+const GROUP_ORDER = [
+	"running",
+	"failed",
+	"successful"
+];
+/** Rows split by outcome, in the order the dock shows them; empty groups are dropped. */
+function workflowActivityGroups(rows) {
+	return GROUP_ORDER.map((name) => ({
+		name,
+		rows: rows.filter((row) => GROUP_OF[row.tone] === name),
+		openByDefault: name !== "successful"
+	})).filter((group) => group.rows.length > 0);
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/workflowsStore.native.ts
+const workflows = defineSessionStore({
+	runs: [],
+	focusedRun: void 0,
+	pendingLaunch: void 0
+});
+function isRecord$2(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$2(input) || !Array.isArray(input.runs)) return null;
+		return { runs: input.runs.filter(isRecord$2) };
+	},
+	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)/activity-group/workflows.native.ts
+var workflows_native_default = defineActivityGroup({
+	keys: "w r",
+	icon: () => createElement(WorkflowIcon),
+	widgetKeys: ["workflow-mcp-progress", "workflow-mcp-follow"],
+	order: 30,
+	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");
+		}
+	}
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/catalogStore.native.ts
+const catalog = defineSessionStore({
+	cwd: "",
+	workflows: [],
+	warning: void 0,
+	open: false,
+	filter: "",
+	prompt: "",
+	selected: void 0,
+	inspected: void 0,
+	launch: void 0
+});
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function openCatalog(sessionId, prompt = "") {
+	catalog.update(sessionId, (current) => ({
+		...current,
+		open: true,
+		prompt
+	}));
+}
+function closeCatalog(sessionId) {
+	catalog.update(sessionId, (current) => ({
+		...current,
+		open: false,
+		prompt: "",
+		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$1(input) || typeof input.cwd !== "string" || !Array.isArray(input.workflows)) return null;
+		return {
+			cwd: input.cwd,
+			workflows: input.workflows.filter(isRecord$1),
+			...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)/channel/workflow-catalog.native.ts
+var workflow_catalog_native_default = defineChannelFile(workflowCatalogChannel);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/channel/workflow-runs.native.ts
+var workflow_runs_native_default = defineChannelFile(workflowRunsChannel);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/launchLine.ts
+/**
+* The `/workflow-launch` line the dialog sends.
+*
+* WHY THE BUILDER LIVES HERE AND THE PARSER DOES NOT:
+* Cockpit code is compiled into the host bundle and may import only this
+* package's own web and type modules, so it cannot share the session's parser.
+* The two are pinned together by a test that parses what this writes, which is
+* the only guarantee that matters: the line has to survive the trip.
+*/
+const WORKFLOW_LAUNCH_VERB = "/workflow-launch";
+/** Reserved keys; every other pair is one of the workflow's own inputs. */
+const RUNNER_KEY = "runner";
+const COMMAND_KEY = "command";
+const CHOICE_KEY = "choice";
+/** Quotes a value that carries whitespace, which is how a value survives tokenizing. */
+function quote(value) {
+	return /\s/.test(value) ? `"${value}"` : value;
+}
+function reservedPair(key, value) {
+	return value === void 0 || value === "" ? [] : [`${key}=${quote(value)}`];
+}
+function workflowLaunchLine(request) {
+	const pairs = [
+		...reservedPair(RUNNER_KEY, request.runner),
+		...reservedPair(COMMAND_KEY, request.command),
+		...reservedPair(CHOICE_KEY, request.choice),
+		...Object.entries(request.inputs).filter(([, value]) => value !== "").map(([key, value]) => `${key}=${quote(value)}`)
+	];
+	const prompt = request.prompt?.trim();
+	return [
+		WORKFLOW_LAUNCH_VERB,
+		quote(request.workflow),
+		...pairs,
+		...prompt ? [prompt] : []
+	].join(" ");
+}
+/** The trigger that makes a prompt mandatory. */
+const USER_PROMPT_TRIGGER = "user_prompt";
+/** What the dialog will not let a reader send, worded the way the session would answer. */
+function launchProblems(workflow, request) {
+	const problems = [];
+	if (workflow.triggers.includes(USER_PROMPT_TRIGGER) && (request.prompt ?? "").trim() === "") problems.push("This workflow is triggered by a prompt, so it needs one.");
+	const missing = workflow.inputs.filter((input) => input.required === true && (request.inputs[input.name] ?? "") === "").map((input) => input.name);
+	if (missing.length > 0) problems.push(`Missing required input${missing.length > 1 ? "s" : ""}: ${missing.join(", ")}.`);
+	return problems;
+}
+/** The default a field starts with: what the workflow declared, or empty. */
+function initialInputs(workflow) {
+	return Object.fromEntries(workflow.inputs.map((input) => [input.name, input.default ?? ""]));
+}
+/** The runner a launch starts on: the workflow's first declared one, when it declares any. */
+function initialRunner(workflow) {
+	return workflow.runners?.[0];
+}
+/** The command templated steps start on: the one their steps list first. */
+function initialCommand(workflow) {
+	return workflow.commands?.[0];
+}
+/** The choice a launch starts on: `default` when declared, else the first. */
+function initialChoice(workflow) {
+	const choices = workflow.choices ?? [];
+	return choices.includes("default") ? "default" : choices[0];
+}
+//#endregion
+//#region src/types/apiRoutes.ts
+/**
+* This package's routes, as data.
+*
+* No scope and no base path. The build reads both off
+* `src/extensions/(backend)/api/workflow/`, so the mount is stated once, by the
+* folder that creates it. The same API answers at all three scopes, because a
+* global contribution cascades into workspace and session; the folder under
+* `workspaces/sessions/` only re-mounts it for a session's own server.
+*
+* This is the one file the routes, the Hono app and the browser all read, so a
+* path cannot move on one side alone. The page used to build the hub's own
+* absolute URL and then rewrite its plugin prefix with String.replace to reach
+* a session, which is exactly the kind of copy that can move by one character
+* without anything noticing.
+*
+* `:workspace` and `:runKey` are Hono's own parameter syntax, because the app
+* registers `path` verbatim.
+*/
+/** One run, which every route below addresses. */
+const RUN = "/runs/:workspace/:runKey";
+/**
+* The artifact route's parameter, as Hono spells a multi-segment match.
+*
+* An artifact is named by its path inside the run directory, so `reports/a.md`
+* is one parameter across two segments. The client's `params` substitution
+* fills a single segment and percent-encodes the slash with it, so the page
+* substitutes this one itself; see the page's `_lib/terminalApi.ts`.
+*/
+const ARTIFACT_NAME_PARAM = ":name{.+}";
+/**
+* The step whose pane a terminal route reads: a step ref's id. Absent, the
+* route follows the run's current step, which is one of a parallel group's.
+*/
+const STEP_TARGET_PARAM = "step";
+const ARTIFACT_DOWNLOAD_PARAM = "download";
+const api = createApiClient({
+	/**
+	* 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.
+	*/
+	snapshot: {
+		method: "GET",
+		path: `${RUN}/screen`,
+		query: [STEP_TARGET_PARAM],
+		response: void 0
+	},
+	screen: {
+		method: "GET",
+		path: `${RUN}/screen/stream`,
+		query: [STEP_TARGET_PARAM],
+		stream: true
+	},
+	control: {
+		method: "POST",
+		path: `${RUN}/control`,
+		response: void 0
+	},
+	keys: {
+		method: "POST",
+		path: `${RUN}/keys`
+	},
+	resize: {
+		method: "POST",
+		path: `${RUN}/resize`,
+		response: void 0
+	},
+	remove: {
+		method: "DELETE",
+		path: RUN,
+		response: void 0
+	},
+	stop: {
+		method: "POST",
+		path: `${RUN}/stop`,
+		response: void 0
+	},
+	/** Guidance for the agent session the running step is in, like steering a Team sub-agent. */
+	steer: {
+		method: "POST",
+		path: `${RUN}/steer`,
+		response: void 0
+	},
+	/**
+	* Launch a workflow into the mounting session's own runtime, which then owns
+	* the run. A dispatcher session reaches its root's session mount through this.
+	*/
+	launch: {
+		method: "POST",
+		path: "/launch",
+		response: void 0
+	},
+	openRunDirectory: {
+		method: "POST",
+		path: `${RUN}/open-directory`,
+		response: void 0
+	},
+	artifacts: {
+		method: "GET",
+		path: `${RUN}/artifacts`,
+		query: ["directory"],
+		response: void 0
+	},
+	/** 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: void 0
+	}
+}, {
+	scopes: [
+		"global",
+		"workspace",
+		"session"
+	],
+	basePath: "workflow",
+	transport: nativeApiTransport,
+	sessionAddress: sessionApiAddress
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/terminalApi.native.ts
+/**
+* The page's half of this package's hub API: one run's terminal and the files
+* its run directory holds.
+*
+* These are adapters now, not a transport. The generated client owns the URL
+* and the sealed transport with it, so nothing here spells a mount. What stays
+* is this package's own vocabulary: which refusals the reader is shown, and the
+* shapes the terminal expects back.
+*
+* A run belongs to its multiplexer rather than to a session, so the same API
+* answers at the hub and inside a session's own server. Passing a session id
+* addresses that session's copy and passing none addresses the hub. The deleted
+* builder made that branch the other way round: it always built the hub's
+* absolute URL, then rewrote the plugin prefix into the session's with
+* String.replace, so a session's URL was a hub URL with its head swapped.
+*/
+const UNREACHABLE = "The cockpit hub is unreachable.";
+/** The hub, or one session's own copy of it; a null session id is the hub. */
+function scoped(sessionId) {
+	return sessionId == null ? api.global : api.session(sessionId);
+}
+/** The run every route addresses, as the route table's two path parameters. */
+function runParams(workspace, runKey) {
+	return {
+		workspace,
+		runKey
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* The message a reader is shown: the route's own words, or why there were none.
+*
+* `error` is optional because an answered call that simply carried the wrong
+* shape reaches here too, and that result has no error field at all.
+*/
+function messageOf(result, fallback) {
+	if (result.status === 0) return UNREACHABLE;
+	return result.error === void 0 || result.error === "" ? fallback : result.error;
+}
+/**
+* One artifact's URL, with its path filled in.
+*
+* An artifact is named by its path inside the run directory, which Hono matches
+* as the one multi-segment parameter `:name{.+}`. The client's own `params`
+* substitution fills a single segment and percent-encodes the separating slash
+* with it, which would move every nested artifact's URL, so that one segment is
+* substituted here instead: each segment encoded, the slashes between them
+* kept. Everything left of it still comes from the client.
+*/
+function artifactUrl(scope, workspace, runKey, artifactPath, query) {
+	return scope.artifact.url({
+		params: runParams(workspace, runKey),
+		...query === void 0 ? {} : { query }
+	}).replace(ARTIFACT_NAME_PARAM, artifactPath.split("/").map(encodeURIComponent).join("/"));
+}
+/** The pane a terminal call names, when it reads one step's rather than the run's current one. */
+function stepBody(step) {
+	return step === void 0 ? {} : { step };
+}
+/** One finite screen read over the session-bound sealed transport. */
+async function readScreen(workspace, runKey, sessionId, step, signal) {
+	const response = await nativeApiTransport(scoped(sessionId).snapshot.url({
+		params: runParams(workspace, runKey),
+		query: { [STEP_TARGET_PARAM]: step }
+	}), { signal });
+	const body = await response.json();
+	if (!response.ok) throw new Error(isRecord(body) && typeof body.error === "string" ? body.error : "The screen could not be read.");
+	if (!isRecord(body) || !Array.isArray(body.lines) || body.lines.length > 48 || !body.lines.every((line) => typeof line === "string" && line.length <= 4096) || !isRecord(body.capabilities) || typeof body.capabilities.readable !== "boolean" || typeof body.capabilities.writable !== "boolean" || typeof body.capabilities.resizable !== "boolean") throw new Error("The workflow hub returned an invalid screen.");
+	return body;
+}
+/** Takes the keyboard for one run, renewing when this page already holds it. */
+async function takeControl(workspace, runKey, token, sessionId, step) {
+	const result = await scoped(sessionId).control({
+		params: runParams(workspace, runKey),
+		body: {
+			token,
+			...stepBody(step)
+		}
+	});
+	if (result.status === 0) return {
+		held: false,
+		reason: UNREACHABLE
+	};
+	if (isRecord(result.data) && typeof result.data.held === "boolean") return result.data;
+	return {
+		held: false,
+		reason: messageOf(result, "The run refused the keyboard.")
+	};
+}
+async function releaseControl(workspace, runKey, token, sessionId, step) {
+	await scoped(sessionId).control({
+		params: runParams(workspace, runKey),
+		body: {
+			token,
+			release: true,
+			...stepBody(step)
+		}
+	});
+}
+/** Sends literal keystrokes; the reason comes back when the lease has moved on. */
+async function sendKeys(workspace, runKey, token, data, sessionId, step) {
+	const result = await scoped(sessionId).keys({
+		params: runParams(workspace, runKey),
+		body: {
+			token,
+			data,
+			...stepBody(step)
+		}
+	});
+	if (result.ok) return {};
+	return { error: messageOf(result, "The run would not take those keys.") };
+}
+/** Matches the run's terminal to the viewport of whoever holds the keyboard. */
+async function resizeRun(workspace, runKey, token, columns, rows, sessionId, step) {
+	await scoped(sessionId).resize({
+		params: runParams(workspace, runKey),
+		body: {
+			token,
+			columns,
+			rows,
+			...stepBody(step)
+		}
+	});
+}
+/** Permanently removes one settled run and its run directory. */
+async function deleteWorkflowRun(workspace, runKey, sessionId) {
+	const result = await scoped(sessionId).remove({ params: runParams(workspace, runKey) });
+	if (!result.ok) return { error: messageOf(result, "The workflow could not be deleted.") };
+	if (result.data.deleted === true) return { result: { deleted: true } };
+	return { error: "The workflow hub returned an invalid deletion response." };
+}
+/** Asks the engine running a workflow to stop it; the run settles on its own shortly after. */
+async function stopWorkflowRun(workspace, runKey, sessionId) {
+	const result = await scoped(sessionId).stop({ params: runParams(workspace, runKey) });
+	if (!result.ok) return { error: messageOf(result, "The workflow could not be stopped.") };
+	if (result.data.requested === true) return { result: { requested: true } };
+	return { error: "The workflow hub returned an invalid stop response." };
+}
+/**
+* Sends guidance to the agent session a running step is in: the run's current
+* step, or `step`, the session of one step of a parallel group.
+*/
+async function steerStep(workspace, runKey, message, sessionId, step) {
+	const result = await scoped(sessionId).steer({
+		params: runParams(workspace, runKey),
+		body: step === void 0 ? { message } : {
+			message,
+			step
+		}
+	});
+	if (!result.ok) return { error: messageOf(result, "The step would not take that guidance.") };
+	if (result.data.delivered === true) return { result: { delivered: true } };
+	return { error: "The workflow hub returned an invalid steer response." };
+}
+async function fetchArtifacts(workspace, runKey, sessionId, directory) {
+	const result = await scoped(sessionId).artifacts({
+		params: runParams(workspace, runKey),
+		query: { directory }
+	});
+	if (!result.ok) return { error: messageOf(result, "This run has no directory to read.") };
+	return { artifacts: result.data };
+}
+/** Trusted same-origin URL for browser-native media previews and downloads. */
+function artifactContentUrl(workspace, runKey, path, download = false, sessionId) {
+	return artifactUrl(scoped(sessionId), workspace, runKey, path, {
+		["raw"]: 1,
+		...download ? { [ARTIFACT_DOWNLOAD_PARAM]: 1 } : {}
+	});
+}
+/**
+* One artifact's metadata and text.
+*
+* The only route here that addresses itself rather than being called: its path
+* parameter spans segments, so the URL comes from `artifactUrl` and the request
+* goes over the same sealed transport the client is built on.
+*/
+async function fetchArtifact(workspace, runKey, path, sessionId) {
+	try {
+		const response = await nativeApiTransport(artifactUrl(scoped(sessionId), workspace, runKey, path));
+		const body = await response.json();
+		if (!response.ok) {
+			const error = isRecord(body) && typeof body.error === "string" && body.error !== "" ? body.error : "";
+			return { error: error === "" ? "That file has not been written." : error };
+		}
+		return { artifact: body };
+	} catch {
+		return { error: UNREACHABLE };
+	}
+}
+const MAX_MEDIA_BYTES = 5242880;
+const MAX_FRAME_BYTES = 65536;
+/** Drain each UTF-8 snapshot before asking the server for another screen. */
+function finiteScreenReader(load) {
+	let bytes = /* @__PURE__ */ new Uint8Array(0);
+	let cursor = 0;
+	let generation = 0;
+	let frame;
+	return async (from, previous, signal) => {
+		if (signal.aborted) throw new Error("Preview cancelled.");
+		let reset = previous !== String(generation) || from !== cursor;
+		if (!frame || cursor >= bytes.length || reset) {
+			const next = await load(signal);
+			if (signal.aborted) throw new Error("Preview cancelled.");
+			frame = next;
+			bytes = utf8(next.lines.join("\r\n"));
+			cursor = 0;
+			generation += 1;
+			reset = true;
+		}
+		const chunk = bytes.subarray(cursor, cursor + MAX_FRAME_BYTES);
+		cursor += chunk.length;
+		return {
+			chunk: base64(chunk),
+			offset: cursor,
+			reset,
+			generation: String(generation),
+			exists: frame.capabilities.readable,
+			hasMore: cursor < bytes.length,
+			ended: frame.ended === true
+		};
+	};
+}
+/** Raw media uses the same scoped sealed route as artifact metadata. */
+async function fetchArtifactMedia(workspace, runKey, path, sessionId, signal) {
+	if (signal.aborted) throw new Error("Preview cancelled.");
+	const response = await nativeApiTransport(artifactContentUrl(workspace, runKey, path, false, sessionId), { signal });
+	if (signal.aborted) throw new Error("Preview cancelled.");
+	if (!response.ok) throw new Error("That artifact could not be read.");
+	const mimeType = (response.headers.get("content-type") ?? "").split(";")[0].trim().toLowerCase();
+	if (!/^(application\/pdf|image\/(png|jpeg|gif|webp|bmp)|audio\/(mpeg|mp4|wav|x-wav|ogg|webm|aac|flac)|video\/(mp4|webm|quicktime|ogg))$/.test(mimeType)) throw new Error("This artifact type cannot be previewed.");
+	if (Number(response.headers.get("content-length")) > MAX_MEDIA_BYTES) throw new Error("This artifact exceeds the 5 MiB preview limit.");
+	const bytes = await response.arrayBuffer();
+	if (signal.aborted) throw new Error("Preview cancelled.");
+	if (bytes.byteLength > MAX_MEDIA_BYTES) throw new Error("This artifact exceeds the 5 MiB preview limit.");
+	return {
+		data: base64(new Uint8Array(bytes)),
+		mimeType
+	};
+}
+function base64(bytes) {
+	const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+	const parts = [];
+	let chunk = "";
+	for (let offset = 0; offset < bytes.length; offset += 3) {
+		const first = bytes[offset];
+		const second = bytes[offset + 1];
+		const third = bytes[offset + 2];
+		chunk += alphabet[first >> 2] + alphabet[(first & 3) << 4 | (second ?? 0) >> 4] + (second === void 0 ? "=" : alphabet[(second & 15) << 2 | (third ?? 0) >> 6]) + (third === void 0 ? "=" : alphabet[third & 63]);
+		if (chunk.length >= 8192) {
+			parts.push(chunk);
+			chunk = "";
+		}
+	}
+	parts.push(chunk);
+	return parts.join("");
+}
+function utf8(text) {
+	const bytes = [];
+	for (const character of text) {
+		let code = character.codePointAt(0);
+		if (code >= 55296 && code <= 57343) code = 65533;
+		if (code < 128) bytes.push(code);
+		else if (code < 2048) bytes.push(192 | code >> 6, 128 | code & 63);
+		else if (code < 65536) bytes.push(224 | code >> 12, 128 | code >> 6 & 63, 128 | code & 63);
+		else bytes.push(240 | code >> 18, 128 | code >> 12 & 63, 128 | code >> 6 & 63, 128 | code & 63);
+	}
+	return Uint8Array.from(bytes);
+}
+/** Binds a save to this package's guarded sealed route and one file version. */
+async function prepareArtifactSave(workspace, runKey, path, sessionId, signal) {
+	const load = async (headers, signal) => {
+		if (signal.aborted) throw new Error("Download cancelled.");
+		return nativeApiTransport(artifactContentUrl(workspace, runKey, path, true, sessionId), {
+			headers,
+			signal
+		});
+	};
+	const probe = await load({ Range: "bytes=0-0" }, signal);
+	if (signal.aborted) throw new Error("Download cancelled.");
+	const range = /^bytes 0-0\/(\d+)$/u.exec(probe.headers.get("content-range") ?? "");
+	const empty = probe.status === 416 && probe.headers.get("content-range") === "bytes */0" || probe.status === 200 && probe.headers.get("content-length") === "0";
+	if (!empty && (probe.status !== 206 || !range)) throw new Error("The file does not support bounded downloads.");
+	const size = empty ? 0 : Number(range[1]);
+	if (!Number.isSafeInteger(size) || size < 0) throw new Error("Invalid file size.");
+	if ((await probe.arrayBuffer()).byteLength !== (empty ? 0 : 1)) throw new Error("Invalid file response.");
+	const version = probe.headers.get("etag");
+	if (!version) throw new Error("The file has no version validator.");
+	return {
+		name: path.split(/[\\/]/u).at(-1) ?? "",
+		mimeType: probe.headers.get("content-type")?.split(";")[0]?.trim() || "application/octet-stream",
+		size,
+		signal,
+		read: async (offset, count, signal) => {
+			if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(count) || offset < 0 || count < 1 || count > 1048576 || offset + count > size) throw new Error("Invalid download range.");
+			const end = offset + count - 1;
+			const response = await load({
+				Range: `bytes=${offset}-${end}`,
+				"If-Match": version
+			}, signal);
+			if (signal.aborted) throw new Error("Download cancelled.");
+			if (response.status !== 206 || response.headers.get("etag") !== version || response.headers.get("content-range") !== `bytes ${offset}-${end}/${size}`) throw new Error("The file changed or its range response is invalid.");
+			const bytes = new Uint8Array(await response.arrayBuffer());
+			if (signal.aborted) throw new Error("Download cancelled.");
+			if (bytes.byteLength !== count) throw new Error("The file response is incomplete.");
+			return bytes;
+		}
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/WorkflowPanel.native.tsx
+function useWorkflows(sessionId) {
+	const subscribe = useCallback((listener) => {
+		const sub = workflows.store.subscribe(listener);
+		return () => sub.unsubscribe();
+	}, []);
+	return useSyncExternalStore(subscribe, () => workflows.select(workflows.store.state, sessionId));
+}
+function workflowTab(run) {
+	const identity = workflowRunIdentity(run);
+	return {
+		id: `workflows-run-${run.workspace}-${run.runKey}`.replace(/[^\w-]+/g, "-"),
+		label: run.displayName,
+		retainComposer: true,
+		panel: (props) => /* @__PURE__ */ jsx(WorkflowPanel, {
+			...props,
+			identity
+		})
+	};
+}
+function WorkflowLauncher(props) {
+	const subscribe = useCallback((listener) => {
+		const sub = catalog.store.subscribe(listener);
+		return () => sub.unsubscribe();
+	}, []);
+	const state = useSyncExternalStore(subscribe, () => catalog.select(catalog.store.state, props.sessionId));
+	const [filter, setFilter] = useState("");
+	const [selected, setSelected] = useState();
+	if (props.sessionId === null || !state.open) return null;
+	const workflow = state.workflows.find((item) => item.path === selected);
+	return /* @__PURE__ */ jsx(Sheet, {
+		open: true,
+		onOpenChange: (open) => {
+			if (!open) {
+				closeCatalog(props.sessionId);
+				setSelected(void 0);
+			}
+		},
+		children: /* @__PURE__ */ jsxs(SheetContent, { children: [/* @__PURE__ */ jsx(SheetHeader, { children: /* @__PURE__ */ jsx(SheetTitle, { children: workflow ? `Launch ${workflow.name}` : "Launch a workflow" }) }), /* @__PURE__ */ jsx(SheetBody, { children: workflow ? /* @__PURE__ */ jsx(WorkflowLaunch, {
+			...props,
+			sessionId: props.sessionId,
+			workflow,
+			initialPrompt: state.prompt,
+			onClose: () => {
+				closeCatalog(props.sessionId);
+				setSelected(void 0);
+			}
+		}, workflow.path) : /* @__PURE__ */ jsxs(View, {
+			style: styles.body,
+			children: [
+				/* @__PURE__ */ jsx(Input, {
+					accessibilityLabel: "Find a workflow",
+					value: filter,
+					onChangeText: setFilter,
+					placeholder: "Find a workflow"
+				}),
+				state.warning ? /* @__PURE__ */ jsx(Text, {
+					style: styles.error,
+					children: state.warning
+				}) : null,
+				filterCatalog(state.workflows, filter).map((item) => /* @__PURE__ */ jsx(ListRow, {
+					title: /* @__PURE__ */ jsx(Button, {
+						variant: "ghost",
+						onPress: () => setSelected(item.path),
+						children: item.name || item.relativePath
+					}),
+					description: `${item.description}\n${item.tags.join(", ")} · ${item.jobs.map((job) => job.name).join(", ")}`
+				}, item.path)),
+				state.workflows.length === 0 ? /* @__PURE__ */ jsx(Text, {
+					style: styles.meta,
+					children: "No workflows reported yet."
+				}) : null
+			]
+		}) })] })
+	});
+}
+function Choice({ label, options, value, onChange }) {
+	return /* @__PURE__ */ jsxs(View, { children: [/* @__PURE__ */ jsx(Text, {
+		style: styles.meta,
+		children: label
+	}), options.map((option) => /* @__PURE__ */ jsx(Button, {
+		variant: "outline",
+		accessibilityState: { selected: value === option },
+		onPress: () => onChange(option),
+		children: option
+	}, option))] });
+}
+function WorkflowLaunch({ sessionId, workflow, initialPrompt, sendSessionFrame, onClose }) {
+	const [prompt, setPrompt] = useState(initialPrompt);
+	const [inputs, setInputs] = useState(() => initialInputs(workflow));
+	const [runner, setRunner] = useState(() => initialRunner(workflow));
+	const [command, setCommand] = useState(() => initialCommand(workflow));
+	const [choice, setChoice] = useState(() => initialChoice(workflow));
+	const [error, setError] = useState();
+	const request = {
+		workflow: workflow.name || workflow.relativePath,
+		inputs,
+		runner,
+		command,
+		choice,
+		...prompt.trim() === "" ? {} : { prompt: prompt.trim() }
+	};
+	const problems = launchProblems(workflow, request);
+	const line = workflowLaunchLine(request);
+	return /* @__PURE__ */ jsxs(View, {
+		style: styles.body,
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				style: styles.meta,
+				children: workflow.description
+			}),
+			/* @__PURE__ */ jsx(Textarea, {
+				accessibilityLabel: "Workflow prompt",
+				placeholder: "What should this workflow do?",
+				value: prompt,
+				onChangeText: setPrompt
+			}),
+			workflow.inputs.map((input) => {
+				const options = input.options ?? (input.type === "boolean" ? ["true", "false"] : void 0);
+				return /* @__PURE__ */ jsxs(View, { children: [/* @__PURE__ */ jsxs(Text, {
+					style: styles.meta,
+					children: [
+						input.name,
+						input.required ? " (required)" : "",
+						" · ",
+						input.description
+					]
+				}), options ? /* @__PURE__ */ jsx(Choice, {
+					label: input.name,
+					options,
+					value: inputs[input.name],
+					onChange: (value) => setInputs((current) => ({
+						...current,
+						[input.name]: value
+					}))
+				}) : /* @__PURE__ */ jsx(Input, {
+					accessibilityLabel: input.name,
+					value: inputs[input.name] ?? "",
+					onChangeText: (value) => setInputs((current) => ({
+						...current,
+						[input.name]: value
+					}))
+				})] }, input.name);
+			}),
+			workflow.runners?.length ? /* @__PURE__ */ jsx(Choice, {
+				label: "Runner",
+				options: workflow.runners,
+				value: runner,
+				onChange: setRunner
+			}) : null,
+			workflow.commands?.length ? /* @__PURE__ */ jsx(Choice, {
+				label: "Command",
+				options: workflow.commands,
+				value: command,
+				onChange: setCommand
+			}) : null,
+			workflow.choices?.length ? /* @__PURE__ */ jsx(Choice, {
+				label: "Choice",
+				options: workflow.choices,
+				value: choice,
+				onChange: setChoice
+			}) : null,
+			/* @__PURE__ */ jsx(CodeBlock, { text: line }),
+			problems.map((problem) => /* @__PURE__ */ jsx(Text, {
+				style: styles.meta,
+				children: problem
+			}, problem)),
+			error ? /* @__PURE__ */ jsx(Text, {
+				style: styles.error,
+				children: error
+			}) : null,
+			/* @__PURE__ */ jsx(Button, {
+				testID: "launch-workflow-submit",
+				disabled: problems.length > 0,
+				onPress: () => {
+					try {
+						requestLaunch(sendSessionFrame, sessionId, line, workflow.path);
+						onClose();
+					} catch (cause) {
+						setError(cause instanceof Error ? cause.message : String(cause));
+					}
+				},
+				children: "Launch"
+			})
+		]
+	});
+}
+function WorkflowPanel(props) {
+	const state = useWorkflows(props.sessionId);
+	const run = state.runs.find((item) => workflowRunIdentity(item) === props.identity);
+	const [confirmDelete, setConfirmDelete] = useState(false);
+	const [busy, setBusy] = useState(false);
+	const [error, setError] = useState();
+	const act = async (action) => {
+		if (busy) return;
+		setBusy(true);
+		setError(void 0);
+		try {
+			await action();
+		} catch (cause) {
+			setError(cause instanceof Error ? cause.message : String(cause));
+		} finally {
+			setBusy(false);
+		}
+	};
+	if (!run) return /* @__PURE__ */ jsx(Text, {
+		style: styles.meta,
+		children: "This run is no longer listed."
+	});
+	return /* @__PURE__ */ jsxs(ScrollView, {
+		contentContainerStyle: styles.body,
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				style: styles.title,
+				children: run.displayName
+			}),
+			/* @__PURE__ */ jsx(Badge, { children: run.executionState ?? run.outcome ?? run.stage }),
+			/* @__PURE__ */ jsx(Text, {
+				style: styles.meta,
+				children: run.errorMessage ?? `${run.position?.job ?? ""} ${run.position?.step ?? ""}`
+			}),
+			state.runs.length > 1 ? state.runs.map((item) => /* @__PURE__ */ jsx(Button, {
+				variant: "ghost",
+				onPress: () => {
+					if (props.sessionId !== null) focusRun(props.sessionId, workflowRunIdentity(item));
+					props.openTransientTab(workflowTab(item));
+				},
+				children: item.displayName
+			}, workflowRunIdentity(item))) : null,
+			run.executionState === "paused" || run.executionState === "pause_requested" ? /* @__PURE__ */ jsx(Text, {
+				style: styles.meta,
+				children: "Waiting to be resumed. Ask the agent in this conversation to resume it."
+			}) : null,
+			run.jobs.map((job) => /* @__PURE__ */ jsxs(View, { children: [/* @__PURE__ */ jsxs(Button, {
+				variant: "ghost",
+				onPress: () => props.openTransientTab(stepTab(run, job.name)),
+				children: [
+					job.name,
+					" · ",
+					job.status
+				]
+			}), job.steps.map((step) => /* @__PURE__ */ jsx(ListRow, {
+				title: /* @__PURE__ */ jsx(Button, {
+					variant: "ghost",
+					onPress: () => props.openTransientTab(stepTab(run, job.name, step.name)),
+					children: step.name
+				}),
+				description: step.status
+			}, step.name))] }, job.name)),
+			/* @__PURE__ */ jsx(Text, {
+				style: styles.title,
+				children: "Artifacts"
+			}),
+			/* @__PURE__ */ jsx(WorkflowArtifacts, {
+				...props,
+				run
+			}),
+			error ? /* @__PURE__ */ jsx(Text, {
+				style: styles.error,
+				children: error
+			}) : null,
+			run.stage === "running" ? /* @__PURE__ */ jsx(Button, {
+				variant: "danger-outline",
+				disabled: busy || props.sessionId === null,
+				onPress: () => void act(async () => {
+					const result = await stopWorkflowRun(run.workspace, run.runKey, props.sessionId);
+					if ("error" in result) throw new Error(result.error);
+				}),
+				children: "Stop workflow"
+			}) : /* @__PURE__ */ jsx(Button, {
+				variant: "danger-outline",
+				disabled: props.sessionId === null,
+				onPress: () => setConfirmDelete(true),
+				children: "Delete run…"
+			}),
+			/* @__PURE__ */ jsx(Sheet, {
+				open: confirmDelete,
+				onOpenChange: setConfirmDelete,
+				children: /* @__PURE__ */ jsxs(SheetContent, { children: [/* @__PURE__ */ jsx(SheetHeader, { children: /* @__PURE__ */ jsx(SheetTitle, { children: "Delete this run?" }) }), /* @__PURE__ */ jsxs(SheetBody, { children: [/* @__PURE__ */ jsx(Text, {
+					style: styles.meta,
+					children: "This permanently removes the settled run and its directory."
+				}), /* @__PURE__ */ jsx(Button, {
+					variant: "danger-outline",
+					disabled: busy,
+					onPress: () => void act(async () => {
+						const result = await deleteWorkflowRun(run.workspace, run.runKey, props.sessionId);
+						if ("error" in result) throw new Error(result.error);
+						if (props.sessionId !== null) removeRun(props.sessionId, props.identity);
+						setConfirmDelete(false);
+						props.closeTransientTab(`workflows-run-${run.workspace}-${run.runKey}`.replace(/[^\w-]+/g, "-"));
+					}),
+					children: "Delete"
+				})] })] })
+			})
+		]
+	});
+}
+function stepTab(run, job, step) {
+	const workspace = run.workspace;
+	const runKey = run.runKey;
+	return {
+		id: `workflows-step-${workspace}-${runKey}-${job}${step === void 0 ? "" : `-${step}`}`.replace(/[^\w-]+/g, "-"),
+		label: `${run.displayName} › ${step ?? job}`,
+		panel: (props) => /* @__PURE__ */ jsx(WorkflowStep, {
+			...props,
+			workspace,
+			runKey,
+			job,
+			step
+		})
+	};
+}
+function WorkflowStep({ sessionId, workspace, runKey, job, step, renderSessionTranscript, renderRunnerTerminal }) {
+	const run = useWorkflows(sessionId).runs.find((item) => item.workspace === workspace && item.runKey === runKey);
+	const steps = run?.jobs.find((item) => item.name === job)?.steps;
+	const target = step === void 0 ? steps?.at(-1) : steps?.find((item) => item.name === step);
+	const [message, setMessage] = useState("");
+	const [error, setError] = useState();
+	const [busy, setBusy] = useState(false);
+	const ref = target?.ref;
+	const session = ref?.kind === "session" ? ref.id : void 0;
+	return /* @__PURE__ */ jsxs(View, {
+		style: styles.screen,
+		children: [
+			/* @__PURE__ */ jsxs(Text, {
+				style: styles.title,
+				children: [
+					job,
+					step === void 0 ? "" : ` › ${step}`,
+					" · ",
+					target?.status
+				]
+			}),
+			session ? renderSessionTranscript?.(session) : /* @__PURE__ */ jsx(WorkflowTerminal, {
+				sessionId,
+				workspace,
+				runKey,
+				pane: ref?.kind === "pane" ? ref.id : void 0,
+				renderRunnerTerminal
+			}, `${sessionId}:${workspace}:${runKey}:${ref?.id ?? ""}`),
+			session && run?.stage === "running" && target?.status === "running" ? /* @__PURE__ */ jsxs(View, {
+				style: styles.body,
+				children: [/* @__PURE__ */ jsx(Textarea, {
+					accessibilityLabel: "Step guidance",
+					value: message,
+					onChangeText: setMessage
+				}), /* @__PURE__ */ jsx(Button, {
+					disabled: busy || message.trim() === "",
+					onPress: () => {
+						setBusy(true);
+						steerStep(workspace, runKey, message.trim(), sessionId, session).then((result) => {
+							if ("error" in result) setError(result.error);
+							else {
+								setMessage("");
+								setError(void 0);
+							}
+						}).catch((cause) => setError(cause instanceof Error ? cause.message : String(cause))).finally(() => setBusy(false));
+					},
+					children: "Send guidance"
+				})]
+			}) : null,
+			error ? /* @__PURE__ */ jsx(Text, {
+				style: styles.error,
+				children: error
+			}) : null
+		]
+	});
+}
+function WorkflowTerminal({ sessionId, workspace, runKey, pane, renderRunnerTerminal }) {
+	const [capabilities, setCapabilities] = useState();
+	const [token, setToken] = useState();
+	const [notice, setNotice] = useState();
+	const [columns, setColumns] = useState("80");
+	const [rows, setRows] = useState("24");
+	const [busy, setBusy] = useState(false);
+	const [lifetime] = useState(() => new AbortController());
+	useEffect(() => () => lifetime.abort(), [lifetime]);
+	useEffect(() => {
+		if (token === void 0) return;
+		return () => {
+			releaseControl(workspace, runKey, token, sessionId, pane).catch(() => {});
+		};
+	}, [
+		workspace,
+		runKey,
+		token,
+		sessionId,
+		pane
+	]);
+	const request = useMemo(() => ({
+		key: `${sessionId}:${workspace}:${runKey}:${pane ?? ""}`,
+		read: finiteScreenReader(async (signal) => {
+			const frame = await readScreen(workspace, runKey, sessionId, pane, signal);
+			if (!signal.aborted && !lifetime.signal.aborted) setCapabilities(frame.capabilities);
+			return frame;
+		}),
+		write: async (text) => {
+			if (token === void 0) throw new Error("Take control before typing into this run.");
+			const result = await sendKeys(workspace, runKey, token, text, sessionId, pane);
+			if (result.error) {
+				if (!lifetime.signal.aborted) {
+					setNotice(result.error);
+					setToken(void 0);
+				}
+				throw new Error(result.error);
+			}
+		}
+	}), [
+		sessionId,
+		workspace,
+		runKey,
+		pane,
+		token,
+		lifetime
+	]);
+	const arm = async () => {
+		setBusy(true);
+		try {
+			const grant = await takeControl(workspace, runKey, void 0, sessionId, pane);
+			if (lifetime.signal.aborted) {
+				if (grant.held && grant.token) await releaseControl(workspace, runKey, grant.token, sessionId, pane);
+				return;
+			}
+			if (grant.held && grant.token) {
+				setToken(grant.token);
+				setNotice(void 0);
+			} else setNotice(grant.reason ?? "The keyboard is not available for this run.");
+		} catch (cause) {
+			if (!lifetime.signal.aborted) setNotice(cause instanceof Error ? cause.message : String(cause));
+		} finally {
+			if (!lifetime.signal.aborted) setBusy(false);
+		}
+	};
+	return /* @__PURE__ */ jsxs(View, {
+		style: styles.transcript,
+		children: [
+			/* @__PURE__ */ jsx(Badge, { children: token ? "keyboard yours" : "watching" }),
+			capabilities?.writable ? /* @__PURE__ */ jsx(Button, {
+				variant: "outline",
+				disabled: busy,
+				onPress: () => {
+					if (token) setToken(void 0);
+					else arm();
+				},
+				children: token ? "Release keyboard" : "Take control"
+			}) : null,
+			/* @__PURE__ */ jsx(View, {
+				style: styles.transcript,
+				children: renderRunnerTerminal?.(request)
+			}),
+			capabilities?.reason ? /* @__PURE__ */ jsx(Text, {
+				style: styles.meta,
+				children: capabilities.reason
+			}) : null,
+			token && capabilities?.resizable ? /* @__PURE__ */ jsxs(View, { children: [
+				/* @__PURE__ */ jsx(Input, {
+					accessibilityLabel: "Terminal columns",
+					keyboardType: "number-pad",
+					value: columns,
+					onChangeText: setColumns
+				}),
+				/* @__PURE__ */ jsx(Input, {
+					accessibilityLabel: "Terminal rows",
+					keyboardType: "number-pad",
+					value: rows,
+					onChangeText: setRows
+				}),
+				/* @__PURE__ */ jsx(Button, {
+					variant: "outline",
+					disabled: !Number.isInteger(Number(columns)) || !Number.isInteger(Number(rows)) || Number(columns) < 1 || Number(rows) < 1,
+					onPress: () => {
+						resizeRun(workspace, runKey, token, Number(columns), Number(rows), sessionId, pane).catch((cause) => {
+							if (!lifetime.signal.aborted) setNotice(cause instanceof Error ? cause.message : String(cause));
+						});
+					},
+					children: "Resize terminal"
+				})
+			] }) : null,
+			notice ? /* @__PURE__ */ jsx(Text, {
+				style: styles.meta,
+				children: notice
+			}) : null
+		]
+	});
+}
+function WorkflowArtifacts(props) {
+	const { run, sessionId, openTransientTab } = props;
+	const [directory, setDirectory] = useState();
+	const [listing, setListing] = useState();
+	const [error, setError] = useState();
+	useEffect(() => {
+		let active = true;
+		fetchArtifacts(run.workspace, run.runKey, sessionId, directory).then((result) => {
+			if (active) {
+				if ("error" in result) setError(result.error);
+				else {
+					setListing(result.artifacts);
+					setError(void 0);
+				}
+			}
+		}).catch((cause) => {
+			if (active) setError(cause instanceof Error ? cause.message : String(cause));
+		});
+		return () => {
+			active = false;
+		};
+	}, [
+		run.workspace,
+		run.runKey,
+		sessionId,
+		directory,
+		run.stage
+	]);
+	return /* @__PURE__ */ jsxs(View, { children: [
+		error ? /* @__PURE__ */ jsx(Text, {
+			style: styles.error,
+			children: error
+		}) : null,
+		directory ? /* @__PURE__ */ jsx(Button, {
+			variant: "ghost",
+			onPress: () => setDirectory(directory.includes("/") ? directory.slice(0, directory.lastIndexOf("/")) : void 0),
+			children: "Parent directory"
+		}) : null,
+		listing?.artifacts.map((item) => /* @__PURE__ */ jsx(ListRow, {
+			title: /* @__PURE__ */ jsx(Button, {
+				variant: "ghost",
+				disabled: item.kind !== "directory" && item.state !== "written" && item.state !== "empty",
+				onPress: () => {
+					if (item.kind === "directory") setDirectory(item.path);
+					else {
+						const workspace = run.workspace;
+						const runKey = run.runKey;
+						const path = item.path;
+						openTransientTab({
+							id: `workflows-artifact-${workspace}-${runKey}-${path}`.replace(/[^\w-]+/g, "-"),
+							label: path,
+							panel: (panelProps) => /* @__PURE__ */ jsx(ArtifactPreview, {
+								...panelProps,
+								workspace,
+								runKey,
+								path
+							})
+						});
+					}
+				},
+				children: item.path
+			}),
+			description: `${item.state} · ${item.description}`
+		}, item.path))
+	] });
+}
+function ArtifactPreview({ sessionId, workspace, runKey, path, renderFilePreview, renderMediaPreview, nativeSaveFile }) {
+	const [content, setContent] = useState();
+	const [error, setError] = useState();
+	const [raw, setRaw] = useState(false);
+	useEffect(() => {
+		let active = true;
+		fetchArtifact(workspace, runKey, path, sessionId).then((result) => {
+			if (active) {
+				if ("error" in result) setError(result.error);
+				else setContent(result.artifact);
+			}
+		}).catch((cause) => {
+			if (active) setError(cause instanceof Error ? cause.message : String(cause));
+		});
+		return () => {
+			active = false;
+		};
+	}, [
+		workspace,
+		runKey,
+		path,
+		sessionId
+	]);
+	const downloadController = useRef(void 0);
+	const [saving, setSaving] = useState(false);
+	const [saveNote, setSaveNote] = useState();
+	useEffect(() => () => downloadController.current?.abort(), [
+		workspace,
+		runKey,
+		path,
+		sessionId
+	]);
+	const download = async () => {
+		if (!nativeSaveFile || saving) return;
+		const controller = new AbortController();
+		downloadController.current = controller;
+		setSaving(true);
+		try {
+			await nativeSaveFile(await prepareArtifactSave(workspace, runKey, path, sessionId, controller.signal));
+			if (!controller.signal.aborted) setSaveNote("Saved.");
+		} catch (error) {
+			if (!controller.signal.aborted) setSaveNote(error instanceof Error ? error.message : String(error));
+		} finally {
+			setSaving(false);
+		}
+	};
+	return /* @__PURE__ */ jsxs(ScrollView, {
+		contentContainerStyle: styles.body,
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				style: styles.title,
+				children: path
+			}),
+			/* @__PURE__ */ jsx(Button, {
+				variant: "outline",
+				disabled: !nativeSaveFile || saving,
+				onPress: () => void download(),
+				children: "Download"
+			}),
+			saving ? /* @__PURE__ */ jsx(Button, {
+				variant: "ghost",
+				onPress: () => downloadController.current?.abort(),
+				children: "Cancel download"
+			}) : null,
+			saveNote ? /* @__PURE__ */ jsx(Text, {
+				style: styles.meta,
+				children: saveNote
+			}) : null,
+			error ? /* @__PURE__ */ jsx(Text, {
+				style: styles.error,
+				children: error
+			}) : null,
+			content?.text !== void 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
+				/* @__PURE__ */ jsx(Button, {
+					variant: "outline",
+					onPress: () => setRaw((value) => !value),
+					children: raw ? "Preview" : "Raw source"
+				}),
+				!raw && /\.(md|markdown)$/i.test(path) ? /* @__PURE__ */ jsx(Markdown, { text: content.text }) : !raw && /\.(html|htm)$/i.test(path) ? renderFilePreview?.({
+					key: `${sessionId}:${workspace}:${runKey}:${path}`,
+					html: content.text,
+					title: path
+				}) : !raw && /\.(csv|tsv)$/i.test(path) ? /* @__PURE__ */ jsx(DelimitedArtifact, {
+					text: content.text,
+					delimiter: /\.csv$/i.test(path) ? "," : "	"
+				}) : /* @__PURE__ */ jsx(CodeBlock, { text: !raw && /\.json$/i.test(path) ? prettyJson(content.text) : content.text }),
+				content.truncated ? /* @__PURE__ */ jsx(Text, {
+					style: styles.meta,
+					children: "This preview was truncated."
+				}) : null
+			] }) : content ? /* @__PURE__ */ jsx(BinaryArtifactPreview, {
+				sessionId,
+				workspace,
+				runKey,
+				path,
+				renderMediaPreview
+			}) : /* @__PURE__ */ jsx(Text, {
+				style: styles.meta,
+				children: "Loading preview…"
+			})
+		]
+	});
+}
+function BinaryArtifactPreview({ sessionId, workspace, runKey, path, renderMediaPreview }) {
+	const requestKey = JSON.stringify([
+		sessionId,
+		workspace,
+		runKey,
+		path
+	]);
+	const [loaded, setLoaded] = useState();
+	const media = loaded?.key === requestKey ? loaded.media : void 0;
+	const error = loaded?.key === requestKey ? loaded.error : void 0;
+	useEffect(() => {
+		const controller = new AbortController();
+		fetchArtifactMedia(workspace, runKey, path, sessionId, controller.signal).then((value) => {
+			if (!controller.signal.aborted) setLoaded({
+				key: requestKey,
+				media: value
+			});
+		}).catch((cause) => {
+			if (!controller.signal.aborted) setLoaded({
+				key: requestKey,
+				error: cause instanceof Error ? cause.message : String(cause)
+			});
+		});
+		return () => controller.abort();
+	}, [
+		workspace,
+		runKey,
+		path,
+		sessionId,
+		requestKey
+	]);
+	return media ? renderMediaPreview?.({
+		key: `${sessionId}:${workspace}:${runKey}:${path}`,
+		...media,
+		title: path,
+		path
+	}) : /* @__PURE__ */ jsx(Text, {
+		style: styles.meta,
+		children: error ?? "Loading preview…"
+	});
+}
+function prettyJson(text) {
+	try {
+		return JSON.stringify(JSON.parse(text), null, 2);
+	} catch {
+		return text;
+	}
+}
+function DelimitedArtifact({ 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 /* @__PURE__ */ jsx(ScrollView, {
+		horizontal: true,
+		children: /* @__PURE__ */ jsx(View, { children: rows.map((cells, index) => /* @__PURE__ */ jsx(View, {
+			style: styles.tableRow,
+			children: cells.map((value, column) => /* @__PURE__ */ jsx(Text, {
+				style: styles.tableCell,
+				children: value
+			}, column))
+		}, index)) })
+	});
+}
+const styles = StyleSheet.create((theme) => ({
+	screen: {
+		flex: 1,
+		backgroundColor: theme.colors.bg,
+		padding: theme.spacing(3),
+		uni__dependencies: [0]
+	},
+	transcript: { flex: 1 },
+	tableRow: { flexDirection: "row" },
+	tableCell: {
+		color: theme.colors.text,
+		fontSize: theme.fontSize.sm,
+		padding: theme.spacing(2),
+		width: theme.spacing(30),
+		borderWidth: 1,
+		borderColor: theme.colors.border,
+		uni__dependencies: [0]
+	},
+	body: {
+		padding: theme.spacing(3),
+		gap: theme.spacing(2),
+		uni__dependencies: [0]
+	},
+	title: {
+		color: theme.colors.hi,
+		fontSize: theme.fontSize.base,
+		fontWeight: "600",
+		uni__dependencies: [0]
+	},
+	meta: {
+		color: theme.colors.dim,
+		fontSize: theme.fontSize.sm,
+		uni__dependencies: [0]
+	},
+	error: {
+		color: theme.colors.red,
+		fontSize: theme.fontSize.sm,
+		uni__dependencies: [0]
+	}
+}));
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/WorkflowLauncher.overlay.native.tsx
+var WorkflowLauncher_overlay_native_default = defineFill({ component: WorkflowLauncher });
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/_components/WorkflowsActivitySection.native.tsx
+function WorkflowsActivitySection({ sessionId, openSession, openTransientTab }) {
+	const state = useWorkflows(sessionId);
+	const [now, setNow] = useState(() => Date.now());
+	const [folded, setFolded] = useState({});
+	useEffect(() => {
+		const timer = setInterval(() => setNow(Date.now()), 1e4);
+		return () => clearInterval(timer);
+	}, []);
+	const groups = workflowActivityGroups(workflowActivityRows(state.runs, now, sessionId));
+	return /* @__PURE__ */ jsxs(View, { children: [groups.map((group) => {
+		const open = folded[group.name] ?? group.openByDefault;
+		return /* @__PURE__ */ jsxs(View, { children: [/* @__PURE__ */ jsxs(Button, {
+			variant: "ghost",
+			accessibilityState: { expanded: open },
+			onPress: () => setFolded((current) => ({
+				...current,
+				[group.name]: !open
+			})),
+			children: [
+				group.name,
+				" · ",
+				group.rows.length
+			]
+		}), open ? group.rows.map((row) => /* @__PURE__ */ jsx(ListRow, {
+			leading: /* @__PURE__ */ jsx(Dot, { tone: row.tone === "failed" ? "red" : row.tone === "running" || row.tone === "paused" ? "yellow" : row.tone === "done" ? "green" : "muted" }),
+			title: /* @__PURE__ */ jsx(Button, {
+				variant: "ghost",
+				testID: `activity-workflow-${row.runKey}`,
+				onPress: () => {
+					if (row.ownerSessionId && openSession) {
+						openSession(row.ownerSessionId);
+						return;
+					}
+					const run = state.runs.find((item) => `${item.workspace}/${item.runKey}` === row.identity);
+					if (sessionId !== null) focusRun(sessionId, row.identity);
+					if (run) openTransientTab(workflowTab(run));
+				},
+				children: row.name
+			}),
+			description: `${row.detail} · ${row.elapsed}`
+		}, row.identity)) : null] }, group.name);
+	}), groups.length === 0 ? /* @__PURE__ */ jsx(Button, {
+		variant: "ghost",
+		testID: "activity-workflow-launch",
+		disabled: sessionId === null,
+		onPress: () => {
+			if (sessionId !== null) openCatalog(sessionId);
+		},
+		children: "Launch a workflow"
+	}) : null] });
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/Workflows.activity.workflows.native.tsx
+var Workflows_activity_workflows_native_default = defineFill({ component: WorkflowsActivitySection });
+//#endregion
+//#region generated/native.ts
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const nativePlugin = defineNativePlugin({
+	id: "workflows",
+	session: {
+		get activityGroups() {
+			return [via({ name: "workflows" }, workflows_native_default)];
+		},
+		get channels() {
+			return [via({ channel: "workflow_catalog" }, workflow_catalog_native_default), via({ channel: "workflow_runs" }, workflow_runs_native_default)];
+		},
+		get fills() {
+			return [via({
+				slot: "overlay",
+				id: "workflow-launcher"
+			}, WorkflowLauncher_overlay_native_default), via({
+				slot: "activity.workflows",
+				id: "workflows"
+			}, Workflows_activity_workflows_native_default)];
+		}
+	}
+});
+//#endregion
+export { nativePlugin };
+
+//# sourceMappingURL=native.mjs.map