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

package/dist/extensions/web.mjs

@@ -0,0 +1,861 @@
+import { apiResponse, createApiClient, defineActivityGroup, defineApiRoutes, defineFill, defineLeaderBinding, defineMinorModeFile, defineSettingsSection, defineToolRenderer, defineWebPlugin, sessionApiAddress } from "@agimon-ai/po-core/web";
+import { Button, CodeEditor, Kbd, Markdown, MessageItem, MessageItemBody, MessageItemHeader, MessageLines, OptionList, SectionLabel, handleOptionListKey, optionListHint, toolTone } from "@agimon-ai/po-web-components";
+import { useEffect, useRef, useState } from "react";
+import { sealedTransport } from "@agimon-ai/po-web-security/browser";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/types/planSettings.ts
+/**
+* The planning settings, described once for both surfaces.
+*
+* The terminal panel and the cockpit settings page render the same five fields,
+* and the one thing they must agree on is which config key each one writes. So
+* the ids, labels and key paths live here rather than in either renderer.
+*
+* It lives under src/types because that is the one server root a browser bundle
+* may read, which also means it may import nothing: pulling the config package
+* in for the thinking levels would drag a node module into the page. They are
+* spelled out instead, and a test asserts they still match the parser's.
+*/
+const PLAN_CONFIG_SECTION_ID = "planning";
+const PLANNING_PATH = ["modes", PLAN_CONFIG_SECTION_ID];
+const MAIN_KEY = "main";
+const SUBAGENTS_KEY = "subagents";
+/** Both agents fall back to the session's own settings when left unset. */
+const INHERIT_MODEL = "inherit the session model";
+const INHERIT_THINKING = "inherit";
+/** Mirrors DOOM_PLANNING_THINKING_LEVELS; pinned by planConfig's test. */
+const PLAN_THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+//#endregion
+//#region src/extensions/(frontend)/_lib/planSettings.ts
+/**
+* The planning settings, as the cockpit's settings page renders them.
+*
+* Built from the same descriptor table the terminal panel uses, so the two
+* surfaces cannot disagree about which config key a field writes. The host owns
+* the scope switch and the writes; this only says what the fields are.
+*/
+const planSettingsSection = {
+	id: PLAN_CONFIG_SECTION_ID,
+	label: "planning",
+	detail: "the models plan mode switches to, and where written plans land",
+	order: 30,
+	fields: [
+		{
+			id: "main.model",
+			label: "main model",
+			keyPath: [
+				...PLANNING_PATH,
+				MAIN_KEY,
+				"model"
+			],
+			placeholder: INHERIT_MODEL,
+			detail: "model the main agent switches to while plan mode is on.",
+			models: true
+		},
+		{
+			id: "main.thinking",
+			label: "main thinking",
+			keyPath: [
+				...PLANNING_PATH,
+				MAIN_KEY,
+				"thinking"
+			],
+			placeholder: INHERIT_THINKING,
+			detail: "thinking level appended to the main model while planning.",
+			options: PLAN_THINKING_LEVELS
+		},
+		{
+			id: "subagents.model",
+			label: "subagent model",
+			keyPath: [
+				...PLANNING_PATH,
+				SUBAGENTS_KEY,
+				"model"
+			],
+			placeholder: INHERIT_MODEL,
+			detail: "model forced onto delegated planning subagents.",
+			models: true
+		},
+		{
+			id: "subagents.thinking",
+			label: "subagent thinking",
+			keyPath: [
+				...PLANNING_PATH,
+				SUBAGENTS_KEY,
+				"thinking"
+			],
+			placeholder: INHERIT_THINKING,
+			detail: "thinking level appended to the subagent model.",
+			options: PLAN_THINKING_LEVELS
+		},
+		{
+			id: "plansdirectory",
+			label: "plans directory",
+			keyPath: [...PLANNING_PATH, "plansDirectory"],
+			placeholder: "~/.po/plans",
+			detail: "absolute, repo-relative, or under ~. written plans land here."
+		}
+	].map((shape) => ({
+		id: shape.id,
+		label: shape.label,
+		kind: shape.models === true || shape.options !== void 0 ? "select" : "text",
+		keyPath: shape.keyPath,
+		detail: shape.detail,
+		placeholder: shape.placeholder,
+		...shape.models === true ? { optionsFrom: "models" } : {},
+		...shape.options === void 0 ? {} : { options: shape.options.map((option) => ({
+			value: option,
+			label: option
+		})) }
+	}))
+};
+//#endregion
+//#region src/extensions/(frontend)/setting/plan.web.ts
+var plan_web_default$3 = defineSettingsSection(planSettingsSection);
+//#endregion
+//#region src/extensions/workspaces/(frontend)/setting/plan.web.ts
+var plan_web_default$2 = defineSettingsSection(planSettingsSection);
+//#endregion
+//#region src/types/planApi.ts
+/**
+* Footer status key the session publishes once a plan exists, which is what
+* makes the cockpit's activity group appear at all. It outlives plan mode: the
+* plan is most worth reading while the agent implements it.
+*/
+const PLAN_STATUS_KEY = "doom-plan-document";
+/** The same options as bare labels, which is all Pi's select and the composer prompt need. */
+const PLAN_REVIEW_OPTIONS = [{
+	label: "Exit plan mode and start implementation",
+	value: "exit"
+}, {
+	label: "Continue planning",
+	value: "continue"
+}].map((choice) => choice.label);
+/** Between the plan's title and the stamp that marks a rewrite. */
+const STATUS_SEPARATOR = " · ";
+/** Strips the colour a session may have themed a status with. */
+const ANSI = /\[[0-9;]*m/gu;
+/**
+* Reading the status line back. Statuses reach a plugin raw, so the colour a
+* session may have added comes off here. A title can itself contain the
+* separator, so the stamp is taken from the last one rather than the first.
+*/
+function parsePlanStatus(raw) {
+	if (raw === void 0) return void 0;
+	const text = raw.replace(ANSI, "").trim();
+	if (text === "") return void 0;
+	const cut = text.lastIndexOf(STATUS_SEPARATOR);
+	if (cut === -1) return {
+		title: text,
+		stamp: ""
+	};
+	return {
+		title: text.slice(0, cut).trim(),
+		stamp: text.slice(cut + 3).trim()
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/activity-group/plan.web.ts
+var plan_web_default$1 = defineActivityGroup({
+	name: "plan",
+	keys: "p e",
+	statusKey: PLAN_STATUS_KEY,
+	marksBackgroundWork: false,
+	order: 25
+});
+//#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/plans/`, so the mount is
+* stated once, by the folder that creates it. The paths used to be written
+* here as helpers, again in the contract, and again inside every URL the page
+* built, and the copies were free to disagree.
+*
+* This is the one file the routes, the Hono app and the browser all read, so a
+* path cannot move on one side alone.
+*
+* Neither route takes a query or a path parameter: a session has one current
+* plan, so `current` answers it and `save` takes the manual write back.
+*/
+var apiRoutes_default = defineApiRoutes({
+	current: {
+		method: "GET",
+		path: "/current",
+		response: apiResponse()
+	},
+	save: {
+		method: "PUT",
+		path: "/content",
+		response: apiResponse()
+	}
+});
+const api = createApiClient(apiRoutes_default, {
+	scopes: ["session"],
+	basePath: "plans",
+	transport: (input, init) => sealedTransport.fetch(input, init),
+	sessionAddress: sessionApiAddress
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/_lib/planApi.ts
+/**
+* The page's half of this package's session API: the current plan, and the
+* manual save.
+*
+* These are adapters now, not a transport. The generated client owns the URL
+* and the sealed transport with it, so nothing here spells a route or reaches
+* for `fetch`. What stays is this package's own vocabulary: which refusals the
+* reader is shown, and the stale-save contract the editor depends on.
+*/
+const UNREACHABLE = "The session is unreachable.";
+const NO_PLAN = "This session has not written a plan yet.";
+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. */
+function messageOf(result) {
+	if (result.status === 0) return UNREACHABLE;
+	return result.error === "" ? `The session answered ${String(result.status)}.` : result.error;
+}
+async function fetchPlan(sessionId) {
+	const result = await api.session(sessionId).current();
+	if (result.status === 404) return {
+		ok: false,
+		error: result.ok || result.error === "" ? NO_PLAN : result.error
+	};
+	if (!result.ok) return {
+		ok: false,
+		error: messageOf(result)
+	};
+	if (!isRecord(result.data)) return {
+		ok: false,
+		error: "The session answered with no plan."
+	};
+	return {
+		ok: true,
+		detail: result.data
+	};
+}
+async function savePlan(sessionId, expectedHash, content) {
+	const result = await api.session(sessionId).save({ body: {
+		expectedHash,
+		content
+	} });
+	if (result.status === 409) {
+		const data = result.ok ? void 0 : result.data;
+		const hash = isRecord(data) && typeof data.hash === "string" ? data.hash : void 0;
+		return {
+			ok: false,
+			stale: true,
+			error: result.ok ? "The plan changed since it was opened." : messageOf(result),
+			...hash === void 0 ? {} : { hash }
+		};
+	}
+	if (!result.ok) return {
+		ok: false,
+		stale: false,
+		error: messageOf(result)
+	};
+	return {
+		ok: true,
+		hash: isRecord(result.data) && typeof result.data.hash === "string" ? result.data.hash : ""
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/_components/PlanPanel.tsx
+/** One tab per session; the plan is singular, so the id needs nothing else. */
+const PLAN_TAB_ID = "plan-document";
+/** The one note that is not an error: anything else in that slot failed. */
+const SAVED_NOTE = "saved";
+function PlanPanel({ sessionId, statuses, closeTransientTab }) {
+	const [detail, setDetail] = useState(void 0);
+	const [error, setError] = useState(void 0);
+	const [loading, setLoading] = useState(false);
+	const [view, setView] = useState("preview");
+	const [draft, setDraft] = useState(void 0);
+	const [saving, setSaving] = useState(false);
+	const [saveNote, setSaveNote] = useState(void 0);
+	const revision = statuses["doom-plan-document"] ?? "";
+	useEffect(() => {
+		if (sessionId === null) return;
+		let cancelled = false;
+		setLoading(true);
+		fetchPlan(sessionId).then((result) => {
+			if (cancelled) return;
+			setLoading(false);
+			if (result.ok) {
+				setDetail(result.detail);
+				setError(void 0);
+				setDraft(void 0);
+				setSaveNote(void 0);
+				return;
+			}
+			setDetail(void 0);
+			setError(result.error);
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [sessionId, revision]);
+	const content = draft ?? detail?.content ?? "";
+	const save = async () => {
+		if (sessionId === null || detail === void 0 || draft === void 0) return;
+		setSaving(true);
+		const result = await savePlan(sessionId, detail.hash, draft);
+		setSaving(false);
+		if (result.ok) {
+			setSaveNote(SAVED_NOTE);
+			setDraft(void 0);
+			const refreshed = await fetchPlan(sessionId);
+			if (refreshed.ok) setDetail(refreshed.detail);
+			else setError(refreshed.error);
+			return;
+		}
+		setSaveNote(result.error);
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "plan-panel",
+		className: "flex min-h-0 flex-1 flex-col",
+		children: [
+			/* @__PURE__ */ jsxs("header", {
+				className: "flex shrink-0 items-center gap-2 border-b border-doom-border px-4 py-2",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						"data-testid": "plan-title",
+						className: "min-w-0 flex-1 truncate text-lg font-semibold text-doom-hi",
+						children: detail?.title ?? "plan"
+					}),
+					/* @__PURE__ */ jsx("nav", {
+						className: "flex shrink-0 items-center gap-1",
+						children: ["preview", "source"].map((entry) => /* @__PURE__ */ jsx(Button, {
+							variant: view === entry ? "outline" : "ghost",
+							size: "xs",
+							"data-testid": `plan-view-${entry}`,
+							onClick: () => setView(entry),
+							children: entry
+						}, entry))
+					}),
+					/* @__PURE__ */ jsx(Button, {
+						variant: "ghost",
+						size: "xs",
+						"data-testid": "plan-close",
+						onClick: () => closeTransientTab(PLAN_TAB_ID),
+						className: "shrink-0",
+						children: "close"
+					})
+				]
+			}),
+			loading && detail === void 0 ? /* @__PURE__ */ jsx("p", {
+				"data-testid": "plan-loading",
+				className: "px-4 py-3 text-sm text-doom-dim",
+				children: "reading this session's plan…"
+			}) : null,
+			error === void 0 ? null : /* @__PURE__ */ jsx("p", {
+				"data-testid": "plan-error",
+				className: "px-4 py-3 text-sm text-doom-red",
+				children: error
+			}),
+			/* @__PURE__ */ jsx("div", {
+				className: "flex min-h-0 flex-1 flex-col",
+				children: detail === void 0 ? null : detail.unavailable ? /* @__PURE__ */ jsx("p", {
+					"data-testid": "plan-unavailable",
+					className: "px-4 py-3 text-sm text-doom-dim",
+					children: detail.reason ?? "this plan cannot be shown"
+				}) : view === "preview" ? /* @__PURE__ */ jsx("div", {
+					"data-testid": "plan-preview",
+					className: "flex min-h-0 flex-1 flex-col gap-2 overflow-y-auto p-4 text-base text-doom-text",
+					children: /* @__PURE__ */ jsx(Markdown, { text: content })
+				}) : /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(CodeEditor, {
+					"data-testid": "plan-source",
+					value: content,
+					path: detail.path,
+					onChange: setDraft,
+					className: "min-h-0 flex-1"
+				}), /* @__PURE__ */ jsxs("div", {
+					className: "flex shrink-0 items-center gap-2 border-t border-doom-border px-3 py-2",
+					children: [
+						/* @__PURE__ */ jsx(Button, {
+							variant: "outline",
+							size: "xs",
+							"data-testid": "plan-save",
+							loading: saving,
+							disabled: draft === void 0 || saving,
+							onClick: () => void save(),
+							children: "save to disk"
+						}),
+						draft === void 0 ? null : /* @__PURE__ */ jsx(Button, {
+							variant: "ghost",
+							size: "xs",
+							"data-testid": "plan-revert",
+							onClick: () => setDraft(void 0),
+							children: "discard edits"
+						}),
+						saveNote === void 0 ? null : /* @__PURE__ */ jsx("span", {
+							"data-testid": "plan-save-note",
+							className: saveNote === SAVED_NOTE ? "text-sm text-doom-green" : "text-sm text-doom-red",
+							children: saveNote
+						})
+					]
+				})] })
+			}),
+			detail === void 0 ? null : /* @__PURE__ */ jsx("footer", {
+				"data-testid": "plan-source-path",
+				className: "shrink-0 truncate border-t border-doom-border px-4 py-1.5",
+				children: /* @__PURE__ */ jsx("span", {
+					className: "font-mono text-sm text-doom-dim",
+					children: detail.path
+				})
+			})
+		]
+	});
+}
+/** The transient tab the plan opens in; opening it again only focuses it. */
+function planTab() {
+	return {
+		id: PLAN_TAB_ID,
+		label: "plan",
+		panel: PlanPanel
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/_components/PlanActivitySection.tsx
+/**
+* The plan group's body in the activity dock: the plan this session wrote, and
+* the way in.
+*
+* A plan is one document, so the group is one row rather than a list. The row
+* is the whole point of the group: a written plan the reader cannot open is a
+* path in a tool card, which is what this replaces.
+*
+* The session's status line carries the title and the time it was last
+* written, so the row says what the plan is and whether the agent has revised
+* it since the reader last looked, without the dock holding any state.
+*/
+function PlanActivitySection({ sessionId, statuses, openTransientTab }) {
+	const view = parsePlanStatus(statuses[PLAN_STATUS_KEY]);
+	if (view === void 0) return /* @__PURE__ */ jsx("p", {
+		"data-testid": "activity-summary-plan",
+		className: "px-1 text-sm text-doom-dim",
+		children: "no plan written yet"
+	});
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "activity-plan",
+		className: "flex flex-col gap-0.5",
+		children: [/* @__PURE__ */ jsx(Button, {
+			variant: "ghost",
+			size: "card",
+			"data-testid": "activity-plan-open",
+			title: `open ${view.title}`,
+			disabled: sessionId === null,
+			onClick: () => {
+				if (sessionId === null) return;
+				openTransientTab(planTab());
+			},
+			className: "min-w-0 gap-0.5 rounded-md px-1 py-1 hover:bg-doom-panel",
+			children: /* @__PURE__ */ jsxs("span", {
+				className: "flex w-full min-w-0 items-center gap-1.5",
+				children: [/* @__PURE__ */ jsx("span", {
+					"data-testid": "activity-plan-title",
+					className: "min-w-0 flex-1 truncate text-left text-base font-semibold text-doom-hi",
+					children: view.title
+				}), view.stamp === "" ? null : /* @__PURE__ */ jsx("span", {
+					"data-testid": "activity-plan-stamp",
+					className: "shrink-0 text-sm tabular-nums text-doom-dim",
+					children: view.stamp
+				})]
+			})
+		}), /* @__PURE__ */ jsx("p", {
+			className: "px-1 text-sm leading-relaxed text-doom-dim",
+			children: "open to read or edit; the agent reads what you save."
+		})]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/Plan.activity.plan.web.tsx
+var Plan_activity_plan_web_default = defineFill({
+	slot: "activity.plan",
+	id: "plan",
+	component: PlanActivitySection
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/leader/toggle.web.ts
+var toggle_web_default = defineLeaderBinding({
+	id: "plan.toggle",
+	path: [{
+		key: "p",
+		label: "plan",
+		detail: "read-only planning modes"
+	}, {
+		key: "e",
+		label: "toggle",
+		detail: "enter or leave read-only planning"
+	}],
+	command: "minor plan"
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/mode/plan/mode.web.ts
+var mode_web_default = defineMinorModeFile({
+	name: "plan",
+	keys: "p e",
+	statusKey: "plan-mode",
+	order: 20
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/_components/PlanReviewPrompt.tsx
+/** Claims only the selector opened by complete_plan, leaving unrelated extension dialogs alone. */
+function claimsPlanReviewPrompt(dialog) {
+	return dialog.method === "select" && dialog.title === "Plan complete. What would you like to do?" && dialog.options.length === PLAN_REVIEW_OPTIONS.length && PLAN_REVIEW_OPTIONS.every((option, index) => dialog.options[index] === option);
+}
+/** Keeps plan approval in the composer so the conversation remains visible while the user decides. */
+function PlanReviewPrompt({ dialog, answer, cancel }) {
+	const [cursor, setCursor] = useState(0);
+	const frame = useRef(null);
+	useEffect(() => frame.current?.focus(), [dialog.id]);
+	return /* @__PURE__ */ jsxs("div", {
+		ref: frame,
+		role: "group",
+		tabIndex: -1,
+		"data-testid": "plan-review-prompt",
+		className: "flex min-w-0 flex-col overflow-hidden outline-none",
+		onKeyDown: (event) => {
+			if (event.key === "Escape") {
+				event.preventDefault();
+				event.stopPropagation();
+				cancel();
+				return;
+			}
+			handleOptionListKey(event, {
+				options: dialog.options,
+				cursor,
+				onCursorChange: setCursor,
+				onSelect: answer
+			});
+		},
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex flex-col gap-1 px-3.5 pt-3 pb-2",
+				children: [
+					/* @__PURE__ */ jsx(SectionLabel, { children: "plan review" }),
+					/* @__PURE__ */ jsx("p", {
+						className: "text-base font-semibold leading-relaxed text-doom-hi",
+						children: dialog.title
+					}),
+					/* @__PURE__ */ jsx("p", {
+						className: "text-sm leading-relaxed text-doom-dim",
+						children: "Review the plan in the conversation before choosing what happens next."
+					})
+				]
+			}),
+			/* @__PURE__ */ jsx(OptionList, {
+				options: dialog.options,
+				cursor,
+				onCursorChange: setCursor,
+				onSelect: answer,
+				testIdPrefix: "plan-review-option",
+				className: "max-h-48 px-3.5 pb-3"
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex min-h-[34px] items-center gap-2 border-t border-doom-border-soft px-3.5 py-2",
+				children: [/* @__PURE__ */ jsxs("span", {
+					className: "text-sm text-doom-dim",
+					children: [
+						optionListHint(dialog.options.length),
+						" · ",
+						/* @__PURE__ */ jsx(Kbd, { children: "esc" }),
+						" cancels"
+					]
+				}), /* @__PURE__ */ jsx(Button, {
+					variant: "outline",
+					size: "sm",
+					"data-testid": "plan-review-cancel",
+					className: "ml-auto",
+					onClick: cancel,
+					children: "cancel"
+				})]
+			})
+		]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/_lib/planToolRender.ts
+/**
+* Purpose-first summaries for the plan-mode tools. The TUI leaves these on
+* Pi's default shell, so the shapes here come straight from the tool
+* definitions in src/services/planServerSession/index.ts: write_plan and complete_plan
+* report through `details` (written, path, phase, exited), run_fable_plan
+* carries the broker result, and record_debug_evidence only confirms.
+*/
+const PLAN_TOOL_NAMES = [
+	"record_debug_evidence",
+	"run_fable_plan",
+	"write_plan",
+	"complete_plan"
+];
+const COLLAPSED_BODY_LINES = 12;
+const PREVIEW_LENGTH = 72;
+const EVIDENCE_LISTS = [
+	["logs", "log"],
+	["correlatedTraceEvidence", "trace"],
+	["processOutput", "process output"],
+	["browserConsoleEvidence", "console entry"],
+	["correlationIds", "correlation id"],
+	["timestamps", "timestamp"],
+	["verifiedFacts", "verified fact"],
+	["hypotheses", "hypothesis"],
+	["unavailableEvidence", "unavailable item"]
+];
+const PACKET_LISTS = [
+	["goal", "goal"],
+	["constraints", "constraint"],
+	["decisions", "decision"],
+	["verifiedFindings", "verified finding"],
+	["inferredFindings", "inferred finding"],
+	["unresolvedQuestions", "open question"]
+];
+function asRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function inlineText(value) {
+	let normalized = "";
+	for (const character of value) {
+		const code = character.codePointAt(0) ?? 0;
+		normalized += code <= 31 || code === 127 ? " " : character;
+	}
+	return normalized.replace(/\s+/gu, " ").trim();
+}
+function readString(record, key) {
+	const value = record?.[key];
+	return typeof value === "string" ? inlineText(value) || void 0 : void 0;
+}
+function readNumber(record, key) {
+	const value = record?.[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function listLength(record, key) {
+	const value = record[key];
+	return Array.isArray(value) ? value.length : 0;
+}
+function plural(count, singular) {
+	if (count === 1) return singular;
+	if (singular.endsWith("y")) return `${singular.slice(0, -1)}ies`;
+	return `${singular}s`;
+}
+function preview(value) {
+	if (!value) return void 0;
+	return value.length > PREVIEW_LENGTH ? `${value.slice(0, 69)}…` : value;
+}
+function countMetadata(args, lists) {
+	return lists.flatMap(([key, label]) => {
+		const count = listLength(args, key);
+		return count > 0 ? [`${count} ${plural(count, label)}`] : [];
+	});
+}
+function line(text, tone, extra = {}) {
+	return {
+		text,
+		tone,
+		...extra
+	};
+}
+function outputText(result) {
+	if (!result) return "";
+	return result.content.flatMap((item) => {
+		const record = asRecord(item);
+		return record?.type === "text" && typeof record.text === "string" ? [record.text] : [];
+	}).join("\n");
+}
+function bodyLines(text, expanded) {
+	const all = text.split("\n").map((entry) => entry.trimEnd()).filter((entry) => entry.length > 0);
+	const shown = expanded ? all : all.slice(0, COLLAPSED_BODY_LINES);
+	const lines = shown.map((entry) => line(entry, "text"));
+	if (all.length > shown.length) lines.push(line(`… ${all.length - shown.length} more lines`, "dim"));
+	return lines;
+}
+/** The header beside the tool name: what the call is for and how much it carries. */
+function planCallSummary(toolName, args) {
+	if (toolName === "record_debug_evidence") {
+		const issue = preview(readString(args, "issue"));
+		return {
+			action: "record evidence",
+			...issue ? { detail: issue } : {},
+			metadata: countMetadata(args, EVIDENCE_LISTS)
+		};
+	}
+	if (toolName === "run_fable_plan") {
+		const metadata = countMetadata(args, PACKET_LISTS);
+		if (readString(args, "currentPlan")) metadata.push("with current plan");
+		return {
+			action: "fable draft",
+			metadata
+		};
+	}
+	if (toolName === "write_plan") return {
+		action: "save plan",
+		metadata: []
+	};
+	const decision = readString(args, "decision");
+	return {
+		action: decision ? `decide ${decision}` : "request approval",
+		metadata: []
+	};
+}
+function evidenceLines(args, result, options) {
+	const lines = [asRecord(result?.details)?.recorded === true ? line("✓ evidence recorded as planning context", "success") : line(`○ ${inlineText(outputText(result)) || "not recorded"}`, "muted")];
+	if (!options.expanded) return lines;
+	for (const [key, label] of [
+		["issue", "issue"],
+		["expectedBehavior", "expected"],
+		["reproductionAttempt", "reproduction"],
+		["actualBehavior", "actual"]
+	]) {
+		const value = readString(args, key);
+		if (value) lines.push(line(`${label} ${value}`, "text"));
+	}
+	for (const [key, label] of EVIDENCE_LISTS) {
+		const raw = args[key];
+		const items = Array.isArray(raw) ? raw.filter((item) => typeof item === "string") : [];
+		if (items.length === 0) continue;
+		lines.push(line(plural(items.length, label), "hi", { bold: true }));
+		lines.push(...items.map((item) => line(inlineText(item), "text", { indent: true })));
+	}
+	return lines;
+}
+function fableLines(result, options) {
+	const details = asRecord(result?.details);
+	const text = outputText(result);
+	if (details?.started !== true) {
+		const code = readString(details, "errorCode");
+		return [line(`○ ${inlineText(text) || "fable planning did not start"}${code ? ` · ${code}` : ""}`, "muted")];
+	}
+	const status = readString(details, "status") ?? "unknown";
+	const draft = typeof details?.draft === "string" ? details.draft : void 0;
+	const code = readString(details, "errorCode");
+	if (!draft) return [line(`✗ fable planning ${status}${code ? ` · ${code}` : ""}`, "error")];
+	const finished = status === "completed";
+	return [line(`${finished ? "✓" : "!"} fable draft · ${status}${code ? ` · ${code}` : ""}`, finished ? "success" : "warning", { bold: true }), ...bodyLines(draft, options.expanded)];
+}
+function writeLines(result, options) {
+	const details = asRecord(result?.details);
+	const path = readString(details, "path");
+	if (options.isPartial) return [line(`◐ ${readString(details, "phase") ?? "checking"}${path ? ` ${path}` : ""}`, "warning")];
+	const duration = readNumber(details, "durationMs");
+	if (details?.written === true) return [line(`✓ wrote ${path ?? "the plan"}${duration === void 0 ? "" : ` · ${duration}ms`}`, "success")];
+	const lines = [line(`○ ${inlineText(outputText(result)) || "plan not written"}`, "muted")];
+	if (path) lines.push(line(`path ${path}`, "dim"));
+	return lines;
+}
+function completeLines(result) {
+	const text = inlineText(outputText(result));
+	if (asRecord(result?.details)?.exited === true) return [line(`✓ plan mode exited${text ? ` · ${text}` : ""}`, "success")];
+	return [line(`○ staying in plan mode${text ? ` · ${text}` : ""}`, "muted")];
+}
+/** The body of a plan tool card: the outcome line, plus the carried detail once expanded. */
+function planResultLines(toolName, args, result, options) {
+	if (options.isError) return [line(`✗ ${inlineText(outputText(result)) || `${toolName} failed`}`, "error")];
+	if (toolName === "record_debug_evidence") return evidenceLines(args, result, options);
+	if (toolName === "run_fable_plan") {
+		if (options.isPartial) return [line("◐ drafting with the local Fable broker", "warning")];
+		return fableLines(result, options);
+	}
+	if (toolName === "write_plan") return writeLines(result, options);
+	if (options.isPartial) return [line("◐ waiting for the review decision", "warning")];
+	return completeLines(result);
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/_components/PlanToolMessage.tsx
+/**
+* The plan tools' timeline item: the plan action, the issue or decision it
+* targets, and what the packet carries in the header; the outcome line, with
+* the recorded evidence or the Fable draft once expanded, in the body.
+*/
+function PlanToolMessage({ toolName, args, result, running, isError }) {
+	const summary = planCallSummary(toolName, args);
+	const collapsed = planResultLines(toolName, args, result, {
+		expanded: false,
+		isError,
+		isPartial: running
+	});
+	const full = planResultLines(toolName, args, result, {
+		expanded: true,
+		isError,
+		isPartial: running
+	});
+	return /* @__PURE__ */ jsx(MessageItem, {
+		tone: toolTone({
+			running,
+			isError
+		}),
+		expandable: full.length > collapsed.length,
+		children: ({ expanded }) => /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(MessageItemHeader, {
+			title: summary.action,
+			children: /* @__PURE__ */ jsx("span", {
+				"data-testid": `tool-call-${toolName}`,
+				title: [summary.detail, ...summary.metadata].filter(Boolean).join(" · ") || void 0,
+				className: "min-w-0 flex-1 truncate text-doom-dim",
+				children: [summary.detail, ...summary.metadata].filter(Boolean).join(" · ")
+			})
+		}), (expanded ? full : collapsed).length > 0 ? /* @__PURE__ */ jsx(MessageItemBody, {
+			"data-testid": `tool-result-${toolName}`,
+			children: /* @__PURE__ */ jsx(MessageLines, { lines: expanded ? full : collapsed })
+		}) : null] })
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/plan.web.tsx
+var plan_web_default = defineToolRenderer({
+	tools: [...PLAN_TOOL_NAMES],
+	message: PlanToolMessage,
+	prompt: {
+		claims: claimsPlanReviewPrompt,
+		component: PlanReviewPrompt
+	}
+});
+//#endregion
+//#region generated/web.ts
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const webPlugin = defineWebPlugin({
+	id: "plan",
+	global: { get settingsSections() {
+		return [via({ id: "plan" }, plan_web_default$3)];
+	} },
+	workspace: { get settingsSections() {
+		return [via({ id: "plan" }, plan_web_default$2)];
+	} },
+	session: {
+		get activityGroups() {
+			return [via({ name: "plan" }, plan_web_default$1)];
+		},
+		get fills() {
+			return [via({
+				slot: "activity.plan",
+				id: "plan"
+			}, Plan_activity_plan_web_default)];
+		},
+		get leaderBindings() {
+			return [via({ id: "plan.toggle" }, toggle_web_default)];
+		},
+		get minorModes() {
+			return [via({ name: "plan" }, mode_web_default)];
+		},
+		get toolRenderers() {
+			return [via({ tools: ["plan"] }, plan_web_default)];
+		}
+	}
+});
+//#endregion
+export { webPlugin };
+
+//# sourceMappingURL=web.mjs.map