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

package/dist/extensions/native.mjs

@@ -0,0 +1,752 @@
+import { createApiClient, defineActivityGroup, defineApiRoutes, defineChannelFile, defineFill, defineNativePlugin, defineSessionStore, nativeApiTransport, sessionApiAddress } from "@agimon-ai/po-core/native";
+import { Badge, Button, Dot, Input, ListRow, SegmentedControl, Sheet, SheetBody, SheetContent, SheetHeader, SheetTitle, Textarea, UsersIcon } from "@agimon-ai/po-native-components";
+import { createElement, useCallback, useEffect, useState, useSyncExternalStore } from "react";
+import { ScrollView } from "react-native-unistyles/components/native/ScrollView";
+import { View } from "react-native-unistyles/components/native/View";
+import { Text } from "react-native-unistyles/components/native/Text";
+import { StyleSheet } from "react-native-unistyles";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/catalog.native.ts
+const routes = defineApiRoutes({
+	catalog: {
+		method: "GET",
+		path: "/catalog"
+	},
+	run: {
+		method: "POST",
+		path: "/run"
+	},
+	steer: {
+		method: "POST",
+		path: "/steer"
+	},
+	stop: {
+		method: "POST",
+		path: "/stop"
+	}
+});
+const api = createApiClient(routes, {
+	scopes: ["session"],
+	basePath: "team",
+	transport: nativeApiTransport,
+	sessionAddress: sessionApiAddress
+});
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStrings(value) {
+	return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isAgent(value) {
+	return isRecord$2(value) && typeof value.name === "string" && typeof value.description === "string" && typeof value.filePath === "string" && [
+		"project",
+		"user",
+		"plugin"
+	].includes(String(value.source)) && (value.packageName === void 0 || typeof value.packageName === "string") && (value.model === void 0 || typeof value.model === "string") && isStrings(value.fallbackModels) && isStrings(value.tools) && isStrings(value.skills) && isStrings(value.extensions) && (value.defaultContext === "fresh" || value.defaultContext === "fork");
+}
+/** Read the selected session's catalog through the host's authenticated HTTP transport. */
+async function fetchCatalog(sessionId, signal) {
+	const response = await api.session(sessionId).catalog({ signal });
+	const body = response.data;
+	if (!response.ok) throw new Error(isRecord$2(body) && typeof body.error === "string" ? body.error : `Agent catalog could not be loaded (${response.status}).`);
+	if (!isRecord$2(body) || typeof body.cwd !== "string" || !Array.isArray(body.agents) || !body.agents.every(isAgent) || !isStrings(body.models)) throw new Error("The server returned an invalid agent catalog.");
+	return {
+		cwd: body.cwd,
+		agents: body.agents,
+		models: body.models
+	};
+}
+/** Launch on the selected session host, without submitting a parent prompt. */
+async function launchAgent(sessionId, request) {
+	const response = await api.session(sessionId).run({ body: request });
+	const body = response.data;
+	if (!response.ok) throw new Error(isRecord$2(body) && typeof body.error === "string" ? body.error : `Agent could not be launched (${response.status}).`);
+	if (!isRecord$2(body) || typeof body.runId !== "string" || body.runId === "") throw new Error("The server returned an invalid run ID.");
+	return body.runId;
+}
+function isSteerState(value) {
+	return value === "delivered" || value === "failed" || value === "pending";
+}
+/** Steer one run on the selected session host, without submitting a parent prompt. */
+async function steerRun(sessionId, runId, message) {
+	const response = await api.session(sessionId).steer({ body: {
+		runId,
+		message
+	} });
+	const body = response.data;
+	if (!response.ok) throw new Error(isRecord$2(body) && typeof body.error === "string" ? body.error : `Guidance could not be sent (${response.status}).`);
+	if (!isRecord$2(body) || !isSteerState(body.state) || typeof body.message !== "string") throw new Error("The server returned an invalid steer result.");
+	return {
+		state: body.state,
+		message: body.message
+	};
+}
+/** Ask the selected session host to stop one run; the run's own status reports when it has. */
+async function stopRun(sessionId, runId) {
+	const response = await api.session(sessionId).stop({ body: { runId } });
+	const body = response.data;
+	if (!response.ok) throw new Error(isRecord$2(body) && typeof body.error === "string" ? body.error : `The run could not be stopped (${response.status}).`);
+}
+//#endregion
+//#region src/types/webSubagents.ts
+const SUBAGENT_RUNS_TYPE = "subagent_runs";
+const SUBAGENT_CATALOG_TYPE = "subagent_catalog";
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/catalogStore.native.ts
+const catalog = defineSessionStore({
+	cwd: "",
+	agents: [],
+	models: [],
+	warning: void 0,
+	loading: false,
+	requestId: 0,
+	open: false,
+	filter: "",
+	task: "",
+	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, task = "") {
+	catalog.update(sessionId, (current) => ({
+		...current,
+		open: true,
+		task
+	}));
+}
+function closeCatalog(sessionId) {
+	catalog.update(sessionId, (current) => ({
+		...current,
+		open: false,
+		task: "",
+		launch: void 0
+	}));
+}
+/** Each drawer opening owns one request and cancels it when the drawer leaves. */
+function loadCatalog(sessionId) {
+	const controller = new AbortController();
+	const requestId = catalog.select(catalog.store.state, sessionId).requestId + 1;
+	catalog.update(sessionId, (current) => ({
+		...current,
+		requestId,
+		loading: true,
+		warning: void 0
+	}));
+	const isCurrent = () => !controller.signal.aborted && catalog.store.state[sessionId]?.requestId === requestId;
+	fetchCatalog(sessionId, controller.signal).then((payload) => {
+		if (isCurrent()) subagentCatalogChannel.apply(sessionId, payload);
+	}).catch((error) => {
+		if (isCurrent()) catalog.update(sessionId, (current) => ({
+			...current,
+			warning: error instanceof Error ? error.message : String(error)
+		}));
+	}).finally(() => {
+		if (isCurrent()) catalog.update(sessionId, (current) => ({
+			...current,
+			loading: false
+		}));
+	});
+	return () => {
+		if (isCurrent()) catalog.update(sessionId, (current) => ({
+			...current,
+			loading: false
+		}));
+		controller.abort();
+	};
+}
+/** The plugin's catalog channel: 'subagent_catalog' payloads into the store; the drawer's own state survives a refresh. */
+const subagentCatalogChannel = catalog.channel({
+	channel: SUBAGENT_CATALOG_TYPE,
+	parse(input) {
+		if (!isRecord$1(input) || typeof input.cwd !== "string" || !Array.isArray(input.agents)) return null;
+		const models = Array.isArray(input.models) ? input.models.filter((m) => typeof m === "string") : [];
+		return {
+			cwd: input.cwd,
+			agents: input.agents.filter(isRecord$1),
+			models,
+			...typeof input.warning === "string" ? { warning: input.warning } : {}
+		};
+	},
+	reduce(current, payload) {
+		const names = new Set(payload.agents.map((agent) => agent.name));
+		return {
+			...current,
+			cwd: payload.cwd,
+			agents: payload.agents,
+			models: payload.models,
+			warning: payload.warning,
+			selected: current.selected !== void 0 && names.has(current.selected) ? current.selected : void 0,
+			inspected: current.inspected !== void 0 && names.has(current.inspected) ? current.inspected : void 0,
+			launch: current.launch !== void 0 && names.has(current.launch.agent) ? current.launch : void 0
+		};
+	}
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/format.ts
+/**
+* Local copies of the host cockpit's pure formatters
+* (po-web src/web/lib/sessionSummary.ts): this plugin ships zero host
+* imports so the cockpit's bundler can compile it from any install.
+*/
+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`;
+}
+/**
+* What to call a run on screen.
+*
+* Prefers the generated identity, because a fan-out of one agent otherwise
+* renders as N rows reading the same word. Falls back to the agent name for a
+* run projected before identities existed. Duplicated rather than imported
+* from `services/agentIdentity`, which reaches for `node:fs` and so cannot be
+* pulled into the browser bundle; that module owns minting, this owns display.
+*/
+function agentRunLabel(run) {
+	const base = run.identity ?? run.agent;
+	return run.inline ? `${base} (inline)` : base;
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/launchCommand.ts
+const META_TOOL_LIMIT = 3;
+/** Rows whose name, source, package, description or a tool contains the filter, case-insensitively. */
+function filterCatalog(agents, filter) {
+	const needle = filter.trim().toLowerCase();
+	if (needle === "") return [...agents];
+	return agents.filter((agent) => [
+		agent.name,
+		agent.source,
+		agent.packageName ?? "",
+		agent.description,
+		...agent.tools
+	].some((field) => field.toLowerCase().includes(needle)));
+}
+/** What the picker offers: the agent's own model and fallbacks first, then the team's, without repeats. */
+function modelChoices(agent, models) {
+	const seen = /* @__PURE__ */ new Set();
+	const choices = [];
+	for (const model of [
+		agent.model ?? "",
+		...agent.fallbackModels,
+		...models
+	]) {
+		if (model === "" || seen.has(model)) continue;
+		seen.add(model);
+		choices.push(model);
+	}
+	return choices;
+}
+/** The row's one-liner: what tools it may use, how many skills, and how it starts. */
+function agentMeta(agent) {
+	return `${agent.tools.length === 0 ? "all tools" : `tools ${agent.tools.slice(0, META_TOOL_LIMIT).join(", ")}${agent.tools.length > META_TOOL_LIMIT ? ` +${agent.tools.length - META_TOOL_LIMIT}` : ""}`}${agent.skills.length > 0 ? ` · ${agent.skills.length} skill${agent.skills.length === 1 ? "" : "s"}` : ""} · ${agent.defaultContext === "fork" ? "forks the session" : "fresh context"}`;
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/subagentsStore.native.ts
+const TERMINAL_STATES = /* @__PURE__ */ new Set([
+	"done",
+	"failed",
+	"stopped"
+]);
+function isTerminalRun(run) {
+	return TERMINAL_STATES.has(run.state);
+}
+const subagents = defineSessionStore({
+	runs: [],
+	dismissed: [],
+	stopRequested: [],
+	openRunId: void 0,
+	pendingLaunch: void 0,
+	autoOpenRunId: void 0
+});
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function without(list, runId) {
+	return list.filter((id) => id !== runId);
+}
+/** The full Subagents tab's runs minus the ones the reader dismissed. */
+function visibleRuns(session) {
+	return session.dismissed.length === 0 ? session.runs : session.runs.filter((run) => !session.dismissed.includes(run.runId));
+}
+/** Only runs that can still be doing work belong in the activity group. */
+function activityRuns(session) {
+	return visibleRuns(session).filter((run) => run.state === "queued" || run.state === "running");
+}
+/**
+* Asks the session host to stop a run over the Team API, never as a parent
+* prompt: the web host does not know Team's slash commands and refuses
+* prompts mid-turn. Marked at once so the control reads "stopping"; rolled
+* back and rethrown if the host refuses. Once accepted, the request stands
+* until the run reports a final state.
+*/
+async function requestRunStop(sessionId, runId) {
+	subagents.update(sessionId, (current) => ({
+		...current,
+		stopRequested: [...without(current.stopRequested, runId), runId]
+	}));
+	try {
+		await stopRun(sessionId, runId);
+	} catch (error) {
+		subagents.update(sessionId, (current) => ({
+			...current,
+			stopRequested: without(current.stopRequested, runId)
+		}));
+		throw error;
+	}
+}
+/** Hides a finished run from this page; nothing is deleted. */
+function dismissRun(sessionId, runId) {
+	subagents.update(sessionId, (current) => ({
+		...current,
+		dismissed: [...without(current.dismissed, runId), runId],
+		openRunId: current.openRunId === runId ? void 0 : current.openRunId
+	}));
+}
+/** Remember the fleet before the server launch so its first update can open the new run. */
+function requestLaunch(sessionId, agent) {
+	subagents.update(sessionId, (current) => ({
+		...current,
+		pendingLaunch: {
+			agent,
+			knownRunIds: current.runs.map((run) => run.runId)
+		}
+	}));
+}
+function clearPendingLaunch(sessionId) {
+	subagents.update(sessionId, (current) => ({
+		...current,
+		pendingLaunch: void 0
+	}));
+}
+/** The plugin's session data channel: 'subagent_runs' payloads into the store. */
+const subagentRunsChannel = subagents.channel({
+	channel: SUBAGENT_RUNS_TYPE,
+	parse(input) {
+		if (!isRecord(input) || !Array.isArray(input.runs)) return null;
+		return { runs: input.runs.filter(isRecord) };
+	},
+	reduce(current, { runs }) {
+		const present = new Map(runs.map((run) => [run.runId, run]));
+		const stopRequested = current.stopRequested.filter((runId) => {
+			const run = present.get(runId);
+			return run !== void 0 && !isTerminalRun(run);
+		});
+		const dismissed = current.dismissed.filter((runId) => present.has(runId));
+		const arrived = current.pendingLaunch === void 0 ? void 0 : runs.find((run) => run.agent === current.pendingLaunch?.agent && !current.pendingLaunch.knownRunIds.includes(run.runId));
+		return {
+			...current,
+			runs,
+			stopRequested,
+			dismissed,
+			pendingLaunch: arrived === void 0 ? current.pendingLaunch : void 0,
+			autoOpenRunId: arrived === void 0 ? current.autoOpenRunId : arrived.runId
+		};
+	}
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/SubagentsPanel.native.tsx
+function useSubagents(sessionId) {
+	const subscribe = useCallback((listener) => {
+		const sub = subagents.store.subscribe(listener);
+		return () => sub.unsubscribe();
+	}, []);
+	return useSyncExternalStore(subscribe, () => subagents.select(subagents.store.state, sessionId));
+}
+function subagentsTab() {
+	return {
+		id: "subagents",
+		label: "agents",
+		panel: SubagentsPanel
+	};
+}
+function agentThreadTab(run) {
+	const runId = run.runId;
+	return {
+		id: `subagents-run-${runId}`,
+		label: agentRunLabel(run),
+		panel: (props) => /* @__PURE__ */ jsx(AgentThreadPanel, {
+			...props,
+			runId
+		})
+	};
+}
+function AgentRunRow({ run, onPress }) {
+	const detail = run.error ?? run.summary?.split("\n").find((line) => line.trim() !== "") ?? run.currentTool ?? run.tail.at(-1) ?? run.state;
+	return /* @__PURE__ */ jsx(ListRow, {
+		leading: /* @__PURE__ */ jsx(Dot, { tone: run.state === "failed" ? "red" : run.state === "running" ? "yellow" : run.state === "done" ? "green" : "muted" }),
+		title: /* @__PURE__ */ jsx(Button, {
+			variant: "ghost",
+			onPress,
+			testID: `activity-run-${run.runId}`,
+			children: agentRunLabel(run)
+		}),
+		description: detail,
+		trailing: /* @__PURE__ */ jsx(Badge, { children: run.state })
+	});
+}
+function SubagentsPanel(props) {
+	const state = useSubagents(props.sessionId);
+	return /* @__PURE__ */ jsxs(ScrollView, {
+		contentContainerStyle: styles.body,
+		children: [
+			/* @__PURE__ */ jsx(Button, {
+				testID: "activity-agents-launch",
+				onPress: () => {
+					if (props.sessionId !== null) openCatalog(props.sessionId);
+				},
+				children: "Launch an agent"
+			}),
+			visibleRuns(state).map((run) => /* @__PURE__ */ jsx(AgentRunRow, {
+				run,
+				onPress: () => props.openTransientTab(agentThreadTab(run))
+			}, run.runId)),
+			/* @__PURE__ */ jsx(AgentCatalog, { ...props })
+		]
+	});
+}
+function AgentCatalog({ sessionId }) {
+	const subscribe = useCallback((listener) => {
+		const sub = catalog.store.subscribe(listener);
+		return () => sub.unsubscribe();
+	}, []);
+	const state = useSyncExternalStore(subscribe, () => catalog.select(catalog.store.state, sessionId));
+	const [filter, setFilter] = useState("");
+	const [agent, setAgent] = useState();
+	useEffect(() => {
+		if (sessionId !== null && state.open) return loadCatalog(sessionId);
+	}, [sessionId, state.open]);
+	if (sessionId === null || !state.open) return null;
+	return /* @__PURE__ */ jsx(Sheet, {
+		open: true,
+		onOpenChange: (open) => {
+			if (!open) {
+				closeCatalog(sessionId);
+				setAgent(void 0);
+			}
+		},
+		children: /* @__PURE__ */ jsxs(SheetContent, { children: [/* @__PURE__ */ jsx(SheetHeader, { children: /* @__PURE__ */ jsx(SheetTitle, { children: agent ? `Launch ${agent.name}` : "Launch an agent" }) }), /* @__PURE__ */ jsx(SheetBody, { children: agent ? /* @__PURE__ */ jsx(AgentLaunch, {
+			sessionId,
+			agent,
+			models: state.models,
+			initialTask: state.task,
+			onClose: () => {
+				closeCatalog(sessionId);
+				setAgent(void 0);
+			}
+		}, agent.name) : /* @__PURE__ */ jsxs(View, {
+			style: styles.body,
+			children: [
+				/* @__PURE__ */ jsx(Input, {
+					accessibilityLabel: "Filter agents",
+					placeholder: "Find an agent",
+					value: filter,
+					onChangeText: setFilter
+				}),
+				state.loading ? /* @__PURE__ */ jsx(Text, {
+					style: styles.meta,
+					children: "Loading agents…"
+				}) : null,
+				state.warning ? /* @__PURE__ */ jsx(Text, {
+					style: styles.error,
+					children: state.warning
+				}) : null,
+				filterCatalog(state.agents, filter).map((item) => /* @__PURE__ */ jsx(ListRow, {
+					title: /* @__PURE__ */ jsx(Button, {
+						variant: "ghost",
+						onPress: () => setAgent(item),
+						children: item.name
+					}),
+					description: `${item.description}\n${agentMeta(item)}`
+				}, item.name))
+			]
+		}) })] })
+	});
+}
+function AgentLaunch({ sessionId, agent, models, initialTask, onClose }) {
+	const [task, setTask] = useState(initialTask);
+	const [fork, setFork] = useState(agent.defaultContext === "fork");
+	const [model, setModel] = useState("");
+	const [busy, setBusy] = useState(false);
+	const [error, setError] = useState();
+	const launch = async () => {
+		if (busy) return;
+		setBusy(true);
+		setError(void 0);
+		requestLaunch(sessionId, agent.name);
+		try {
+			await launchAgent(sessionId, {
+				agent: agent.name,
+				task,
+				fork,
+				...model === "" ? {} : { model }
+			});
+			onClose();
+		} catch (cause) {
+			clearPendingLaunch(sessionId);
+			setError(cause instanceof Error ? cause.message : String(cause));
+		} finally {
+			setBusy(false);
+		}
+	};
+	return /* @__PURE__ */ jsxs(View, {
+		style: styles.body,
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				style: styles.meta,
+				children: agent.description
+			}),
+			/* @__PURE__ */ jsx(Textarea, {
+				accessibilityLabel: "Task",
+				value: task,
+				onChangeText: setTask,
+				placeholder: "What should the agent do? Empty runs its own prompt"
+			}),
+			/* @__PURE__ */ jsx(SegmentedControl, {
+				value: fork ? "fork" : "fresh",
+				onValueChange: (value) => setFork(value === "fork"),
+				options: [{
+					value: "fresh",
+					label: "Fresh"
+				}, {
+					value: "fork",
+					label: "Fork this session"
+				}]
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				style: styles.meta,
+				children: "Model"
+			}),
+			/* @__PURE__ */ jsxs(Button, {
+				variant: model === "" ? "primary" : "outline",
+				onPress: () => setModel(""),
+				children: ["Agent default", agent.model ? ` · ${agent.model}` : ""]
+			}),
+			modelChoices(agent, models).map((choice) => /* @__PURE__ */ jsx(Button, {
+				variant: "outline",
+				onPress: () => setModel(choice),
+				accessibilityState: { selected: model === choice },
+				children: choice
+			}, choice)),
+			error ? /* @__PURE__ */ jsx(Text, {
+				style: styles.error,
+				children: error
+			}) : null,
+			/* @__PURE__ */ jsx(Button, {
+				testID: "launch-agent-submit",
+				disabled: busy,
+				onPress: () => void launch(),
+				children: busy ? "Launching…" : "Launch"
+			})
+		]
+	});
+}
+function AgentThreadPanel({ sessionId, runId, renderThread }) {
+	const state = useSubagents(sessionId);
+	const run = state.runs.find((item) => item.runId === runId);
+	const [guidance, setGuidance] = useState("");
+	const [busy, setBusy] = useState(false);
+	const [notice, setNotice] = useState();
+	const [confirmClear, setConfirmClear] = useState(false);
+	const act = async (action) => {
+		setBusy(true);
+		setNotice(void 0);
+		try {
+			await action();
+		} catch (cause) {
+			setNotice(cause instanceof Error ? cause.message : String(cause));
+		} finally {
+			setBusy(false);
+		}
+	};
+	return /* @__PURE__ */ jsxs(View, {
+		style: styles.screen,
+		children: [
+			run ? /* @__PURE__ */ jsxs(View, {
+				style: styles.body,
+				children: [
+					/* @__PURE__ */ jsxs(Text, {
+						style: styles.title,
+						children: [
+							agentRunLabel(run),
+							" · ",
+							run.state
+						]
+					}),
+					/* @__PURE__ */ jsxs(Text, {
+						style: styles.meta,
+						children: [
+							run.model,
+							"\\n",
+							run.task,
+							"\\n",
+							formatRunDuration(Math.max(0, (run.endedAt ?? run.lastUpdate) - run.startedAt))
+						]
+					}),
+					sessionId !== null ? isTerminalRun(run) ? /* @__PURE__ */ jsx(Button, {
+						variant: "outline",
+						onPress: () => setConfirmClear(true),
+						children: "Clear run"
+					}) : /* @__PURE__ */ jsx(Button, {
+						variant: "danger-outline",
+						disabled: busy || state.stopRequested.includes(runId),
+						onPress: () => void act(() => requestRunStop(sessionId, runId)),
+						children: state.stopRequested.includes(runId) ? "Stopping…" : "Stop"
+					}) : null
+				]
+			}) : /* @__PURE__ */ jsx(Text, {
+				style: styles.meta,
+				children: "This run is no longer listed; its transcript stays readable."
+			}),
+			/* @__PURE__ */ jsx(View, {
+				style: styles.transcript,
+				children: renderThread(runId)
+			}),
+			run && sessionId !== null && !isTerminalRun(run) ? /* @__PURE__ */ jsxs(View, {
+				style: styles.body,
+				children: [/* @__PURE__ */ jsx(Textarea, {
+					accessibilityLabel: "Steering guidance",
+					value: guidance,
+					onChangeText: setGuidance,
+					placeholder: "Guide this agent…"
+				}), /* @__PURE__ */ jsx(Button, {
+					disabled: busy || guidance.trim() === "",
+					onPress: () => void act(async () => {
+						const result = await steerRun(sessionId, runId, guidance.trim());
+						setNotice(result.message);
+						if (result.state !== "failed") setGuidance("");
+					}),
+					children: "Send guidance"
+				})]
+			}) : null,
+			notice ? /* @__PURE__ */ jsx(Text, {
+				style: styles.meta,
+				children: notice
+			}) : null,
+			/* @__PURE__ */ jsx(Sheet, {
+				open: confirmClear,
+				onOpenChange: setConfirmClear,
+				children: /* @__PURE__ */ jsxs(SheetContent, { children: [/* @__PURE__ */ jsx(SheetHeader, { children: /* @__PURE__ */ jsx(SheetTitle, { children: "Clear this run?" }) }), /* @__PURE__ */ jsxs(SheetBody, { children: [/* @__PURE__ */ jsx(Text, {
+					style: styles.meta,
+					children: "This hides the finished run. Its transcript stays on disk."
+				}), /* @__PURE__ */ jsx(Button, {
+					variant: "danger-outline",
+					onPress: () => {
+						if (sessionId !== null) dismissRun(sessionId, runId);
+						setConfirmClear(false);
+					},
+					children: "Clear"
+				})] })] })
+			})
+		]
+	});
+}
+const styles = StyleSheet.create((theme) => ({
+	screen: {
+		flex: 1,
+		backgroundColor: theme.colors.bg,
+		uni__dependencies: [0]
+	},
+	transcript: { flex: 1 },
+	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)/activity-group/agents.native.ts
+var agents_native_default = defineActivityGroup({
+	keys: "a r",
+	icon: () => createElement(UsersIcon),
+	statusKey: "doom-team-agents",
+	order: 10,
+	transientTab: subagentsTab,
+	activeSource: {
+		subscribe(listener) {
+			const subscription = subagents.store.subscribe(listener);
+			return () => subscription.unsubscribe();
+		},
+		isActive(sessionId) {
+			return activityRuns(subagents.select(subagents.store.state, sessionId)).length > 0;
+		}
+	}
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/channel/subagent-catalog.native.ts
+var subagent_catalog_native_default = defineChannelFile(subagentCatalogChannel);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/channel/subagent-runs.native.ts
+var subagent_runs_native_default = defineChannelFile(subagentRunsChannel);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/_components/AgentsActivitySection.native.tsx
+function AgentsActivitySection({ sessionId, openTransientTab }) {
+	const runs = activityRuns(useSubagents(sessionId));
+	return /* @__PURE__ */ jsxs(View, { children: [runs.map((run) => /* @__PURE__ */ jsx(AgentRunRow, {
+		run,
+		onPress: () => openTransientTab(agentThreadTab(run))
+	}, run.runId)), runs.length === 0 ? /* @__PURE__ */ jsx(Button, {
+		variant: "ghost",
+		testID: "activity-agents-launch",
+		disabled: sessionId === null,
+		onPress: () => {
+			if (sessionId !== null) {
+				openCatalog(sessionId);
+				openTransientTab(subagentsTab());
+			}
+		},
+		children: "Launch an agent"
+	}) : null] });
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/Agents.activity.agents.native.tsx
+var Agents_activity_agents_native_default = defineFill({ component: AgentsActivitySection });
+//#endregion
+//#region generated/native.ts
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const nativePlugin = defineNativePlugin({
+	id: "subagents",
+	session: {
+		get activityGroups() {
+			return [via({ name: "agents" }, agents_native_default)];
+		},
+		get channels() {
+			return [via({ channel: "subagent_catalog" }, subagent_catalog_native_default), via({ channel: "subagent_runs" }, subagent_runs_native_default)];
+		},
+		get fills() {
+			return [via({
+				slot: "activity.agents",
+				id: "agents"
+			}, Agents_activity_agents_native_default)];
+		}
+	}
+});
+//#endregion
+export { nativePlugin };
+
+//# sourceMappingURL=native.mjs.map