@bud.sh/app 0.5.0 → 0.6.0

package/dist/hosted/assets/tasks-D66LlwxM.js

@@ -0,0 +1,1423 @@
+import { $ as Dialog, B as AgentBrowser, Ct as taskHref, Ht as CommentThreadDetail, In as taskRoutes, J as CommentThreadHeading, Mn as jsx, Nn as routes, On as Fragment, Q as FieldCardHeader, Qt as IconButton, S as ThreadTaskLinks, Si as parseWorkDetail, St as taskAgentHref, Ti as parseWorkMutationResult, Tt as taskRole, Ut as CommentThreadItem, V as TaskWorkspace, Wt as CommentComposer, Y as FieldCard, Z as FieldCardFooter, _i as parseSectionData, ar as predictWorkCreate, b as writeOptimistically, bt as agentViewOpen, cn as t, fn as ref, h as storedWorkspace, hn as on, ht as conversationLabel, in as writePreference, ir as predictWorkAction, ki as parseWorkSyncResult, l as projectStore, nn as toast, or as predictWorkUpdate, qt as Button, un as Text, w as ItemDiscussion, wt as taskLabel, x as writeRows, xt as selectedTask, y as plainRow, yt as readConversationLocation, z as TaskRunPanel } from "./comment-data-BXfMElfx.js";
+import { a as requestTasks, i as TaskRequestError, o as parseTaskContext, r as projectWork, s as parseRunRecord } from "../hosted.js";
+import { i as loadItemComments, n as createProjectComments, t as defineScreen } from "./screen-DpAcDUKR.js";
+import { n as ProjectThreadLinks, r as ProjectTaskPicker } from "./project-thread-links-KqQoKBLE.js";
+//#region app/client/factory-setup.tsx
+/**
+* Validates the factory's readiness from the server.
+* @param value - The response body.
+* @returns The readiness.
+*/
+function parseFactoryState(value) {
+	let input = value;
+	if (!input || typeof input.enabled !== "boolean" || typeof input.ready !== "boolean" || typeof input.canAdd !== "boolean" || !(input.message === null || typeof input.message === "string") || !Array.isArray(input.problems) || input.problems.length > 10 || input.problems.some((problem) => !problem || typeof problem.value !== "string" || problem.reason !== "missing" && problem.reason !== "category")) throw new TypeError("Invalid factory state.");
+	let statuses = input.statuses;
+	let roles = [
+		"open",
+		"inProgress",
+		"needsApproval",
+		"readyToMerge",
+		"merged"
+	];
+	return {
+		enabled: input.enabled,
+		ready: input.ready,
+		message: input.message,
+		problems: input.problems.map((problem) => ({
+			value: problem.value,
+			reason: problem.reason
+		})),
+		canAdd: input.canAdd,
+		statuses: statuses && roles.every((role) => typeof statuses[role] === "string") ? Object.fromEntries(roles.map((role) => [role, statuses[role]])) : null
+	};
+}
+async function request$1(url, token, signal, body) {
+	let response = await fetch(url, {
+		method: body === void 0 ? "GET" : "POST",
+		headers: {
+			"X-Bud-Token": token,
+			...body === void 0 ? {} : { "Content-Type": "application/json" }
+		},
+		...body === void 0 ? {} : { body: JSON.stringify(body) },
+		credentials: "same-origin",
+		redirect: "error",
+		cache: "no-store",
+		signal
+	});
+	let value = await response.json().catch(() => null);
+	if (!response.ok) throw new Error(value && typeof value === "object" && "error" in value && typeof value.error === "string" ? value.error : t("app.client.factorySetup.failed"));
+	return parseFactoryState(value);
+}
+var statuses = /* @__PURE__ */ new Map();
+var listeners = /* @__PURE__ */ new Map();
+/**
+* Follows the factory's readiness as this page changes it, such as when its statuses are added.
+* @param token - The capability.
+* @param listener - Gets the new readiness.
+* @param signal - Stops following.
+*/
+function onFactoryStatus(token, listener, signal) {
+	let set = listeners.get(token) ?? /* @__PURE__ */ new Set();
+	listeners.set(token, set);
+	set.add(listener);
+	signal.addEventListener("abort", () => set.delete(listener), { once: true });
+}
+/**
+* The factory's readiness, read once for the screens that show it.
+* @param token - The capability.
+* @param fresh - Read again, such as after adding the statuses.
+* @returns The readiness.
+*/
+function factoryStatus(token, fresh = false) {
+	let found = statuses.get(token);
+	if (!found || fresh) {
+		found = request$1(routes.factoryApi.status.href(), token, new AbortController().signal);
+		found.catch(() => statuses.delete(token));
+		statuses.set(token, found);
+	}
+	return found;
+}
+/**
+* Above the task board while the factory is on but the task store lacks its statuses: what's
+* missing, and Add factory statuses when the store can add them.
+* @param handle - The capability and what to do once the statuses exist.
+* @returns The notice, or nothing while the factory is off or ready.
+*/
+function FactorySetup(handle) {
+	let state = null;
+	let adding = false;
+	function update() {
+		if (!handle.signal.aborted) handle.update();
+	}
+	factoryStatus(handle.props.token).then((value) => {
+		state = value;
+		update();
+	}, () => {});
+	async function add() {
+		adding = true;
+		update();
+		try {
+			state = await request$1(routes.factoryApi.addStatuses.href(), handle.props.token, handle.signal, {});
+			statuses.set(handle.props.token, Promise.resolve(state));
+			for (let listener of listeners.get(handle.props.token) ?? []) listener(state);
+			toast.success(t("app.client.factorySetup.added"));
+			handle.props.onAdded();
+		} catch (cause) {
+			toast.error(t("app.client.factorySetup.failed"), { description: cause instanceof Error ? cause.message : void 0 });
+		} finally {
+			adding = false;
+			update();
+		}
+	}
+	return () => {
+		if (!state?.enabled || state.ready) return null;
+		let names = (reason) => state.problems.filter((problem) => problem.reason === reason).map((problem) => taskLabel(problem.value)).join(", ");
+		return /* @__PURE__ */ jsx("div", {
+			class: "flex min-w-0 flex-wrap items-center gap-x-3 gap-y-2 border-b border-line bg-panel px-4 py-2",
+			role: "status",
+			"data-testid": "factory-setup",
+			children: [/* @__PURE__ */ jsx(Text, {
+				variant: "ui-caption",
+				class: "min-w-0 flex-1",
+				children: state.message ?? [names("missing") && t("app.client.factorySetup.missing", { statuses: names("missing") }), names("category") && t("app.client.factorySetup.otherKind", { statuses: names("category") })].filter(Boolean).join(" ")
+			}), state.canAdd ? /* @__PURE__ */ jsx(Button, {
+				variant: "secondary",
+				size: "small",
+				disabled: adding,
+				"data-testid": "factory-add-statuses",
+				mix: on("click", () => void add()),
+				children: t("app.client.factorySetup.add")
+			}) : null]
+		});
+	};
+}
+//#endregion
+//#region app/client/factory-run.tsx
+async function request(url, token, signal, post = false, body = {}) {
+	let response = await fetch(url, {
+		method: post ? "POST" : "GET",
+		headers: {
+			"X-Bud-Token": token,
+			...post ? { "Content-Type": "application/json" } : {}
+		},
+		...post ? { body: JSON.stringify(body) } : {},
+		credentials: "same-origin",
+		redirect: "error",
+		cache: "no-store",
+		signal
+	});
+	let value = await response.json().catch(() => null);
+	if (!response.ok) throw new Error(value && typeof value === "object" && "error" in value && typeof value.error === "string" ? value.error : t("app.client.factoryRun.failed"));
+	return value;
+}
+function runOf(value) {
+	return value?.run == null ? null : parseRunRecord(value.run);
+}
+var TICK = 1e4;
+/**
+* A task's factory run above its discussion, while the factory is on: reads the run again as the
+* task changes, and carries out the panel's actions through the factory API.
+* @param handle - The capability, the project, the task, and its revision and run state, which
+*   change with each run step.
+* @returns The run panel, or nothing while the factory is off.
+*/
+function FactoryRun(handle) {
+	let state = null;
+	let run;
+	let seen;
+	let reading = 0;
+	let ticking;
+	handle.signal.addEventListener("abort", () => clearInterval(ticking));
+	function update() {
+		if (!handle.signal.aborted) handle.update();
+	}
+	onFactoryStatus(handle.props.token, (value) => {
+		state = value;
+		update();
+	}, handle.signal);
+	factoryStatus(handle.props.token).then((value) => {
+		state = value;
+		update();
+	}, () => {});
+	async function read() {
+		let mine = ++reading;
+		try {
+			let value = runOf(await request(routes.factoryApi.run.href({ id: handle.props.itemId }), handle.props.token, handle.signal));
+			if (mine === reading) run = value;
+		} catch {
+			if (mine === reading && run === void 0) run = null;
+		}
+		update();
+	}
+	async function act(route, body = {}) {
+		try {
+			let value = runOf(await request(routes.factoryApi[route].href({ id: handle.props.itemId }), handle.props.token, handle.signal, true, body));
+			reading++;
+			run = value;
+			update();
+		} catch (cause) {
+			toast.error(t("app.client.factoryRun.refused"), { description: cause instanceof Error ? cause.message : void 0 });
+			read();
+			throw cause;
+		}
+	}
+	async function preview() {
+		let tab = window.open("", "_blank");
+		try {
+			let url = ((await request(routes.factoryApi.preview.href({ id: handle.props.itemId }), handle.props.token, handle.signal))?.preview)?.url;
+			if (typeof url !== "string" || !/^https?:\/\//.test(url)) throw new Error(t("app.client.factoryRun.noPreview"));
+			if (tab) {
+				tab.opener = null;
+				tab.location.href = url;
+			} else window.open(url, "_blank", "noopener");
+		} catch (cause) {
+			tab?.close();
+			toast.error(t("app.client.factoryRun.previewFailed"), { description: cause instanceof Error ? cause.message : void 0 });
+		}
+	}
+	return () => {
+		let marker = `${handle.props.revision}:${handle.props.runState ?? ""}`;
+		if (marker !== seen) {
+			seen = marker;
+			handle.queueTask(() => void read());
+		}
+		if (!state?.enabled) return null;
+		let busy = run && [
+			"provisioning",
+			"working",
+			"changes",
+			"approved",
+			"pushing"
+		].includes(run.state);
+		if (busy && !ticking) ticking = setInterval(update, TICK);
+		else if (!busy && ticking) {
+			clearInterval(ticking);
+			ticking = void 0;
+		}
+		return /* @__PURE__ */ jsx(TaskRunPanel, {
+			run,
+			blocked: state.ready ? null : state.message ?? t("app.client.factoryRun.statusesMissing"),
+			preview: Boolean(run?.ports.dev),
+			onStart: () => act("start"),
+			onChanges: (message) => act("changes", { message }),
+			onAnswer: (message) => act("answer", { message }),
+			onApprove: () => act("approve"),
+			onDiscard: () => act("discard"),
+			onRetry: () => act("retry"),
+			onPreview: preview,
+			onCanvas: () => {
+				writePreference(`bud:canvas-branch:${handle.props.projectId}`, run.branch);
+				window.location.assign("/canvas");
+			}
+		});
+	};
+}
+/** Run states a hand move asks about: the run would go on although the task moved away. */
+var DISCARDABLE_RUN_STATES = [
+	"provisioning",
+	"working",
+	"changes",
+	"review",
+	"needs_context",
+	"failed"
+];
+/** Run states a hand move waits for: the branch is being pushed. */
+var PUSHING_RUN_STATES = ["approved", "pushing"];
+/**
+* Discards a task's run, for a person moving the task away from the run's status.
+* @param token - The capability.
+* @param itemId - The task.
+* @param signal - Stops the request.
+*/
+async function discardRun(token, itemId, signal) {
+	await request(routes.factoryApi.discard.href({ id: itemId }), token, signal, true);
+}
+/**
+* Asks whether to discard a task's run before moving the task by hand.
+* @param handle - The task, the status it moves to, and the answer.
+* @returns The dialog's render function.
+*/
+function RunMoveDialog(handle) {
+	let busy = false;
+	async function answer(discard) {
+		busy = true;
+		handle.update();
+		try {
+			await handle.props.onAnswer(discard);
+		} finally {
+			busy = false;
+			if (!handle.signal.aborted) handle.update();
+		}
+	}
+	return () => /* @__PURE__ */ jsx(Dialog, {
+		label: t("app.client.factoryRun.moveTitle"),
+		dismissible: !busy,
+		initialFocus: "[data-run-move-keep]",
+		onClose: () => void answer(false),
+		children: /* @__PURE__ */ jsx(FieldCard, { children: [/* @__PURE__ */ jsx(FieldCardHeader, {
+			title: t("app.client.factoryRun.moveTitle"),
+			subtitle: t("app.client.factoryRun.moveQuestion", {
+				id: handle.props.itemId,
+				status: handle.props.status
+			})
+		}), /* @__PURE__ */ jsx(FieldCardFooter, {
+			class: "justify-end",
+			children: [/* @__PURE__ */ jsx(Button, {
+				variant: "ghost",
+				size: "small",
+				disabled: busy,
+				"data-run-move-keep": true,
+				mix: on("click", () => void answer(false)),
+				children: t("app.client.factoryRun.keepRun")
+			}), /* @__PURE__ */ jsx(Button, {
+				variant: "primary",
+				size: "small",
+				disabled: busy,
+				"data-testid": "run-move-discard",
+				mix: on("click", () => void answer(true)),
+				children: t("app.client.factoryRun.discardAndMove")
+			})]
+		})] })
+	});
+}
+//#endregion
+//#region app/client/agent-panel.tsx
+var TOUCH = 12e4;
+var SANDBOXED = [
+	"working",
+	"changes",
+	"review",
+	"pushing",
+	"approved",
+	"failed"
+];
+async function call(url, token, signal, body) {
+	let response = await fetch(url, {
+		method: body === void 0 ? "GET" : "POST",
+		headers: {
+			"X-Bud-Token": token,
+			...body === void 0 ? {} : { "Content-Type": "application/json" }
+		},
+		...body === void 0 ? {} : { body: JSON.stringify(body) },
+		credentials: "same-origin",
+		redirect: "error",
+		cache: "no-store",
+		signal
+	});
+	let value = await response.json().catch(() => null);
+	if (!response.ok) throw new Error(value && typeof value === "object" && "error" in value && typeof value.error === "string" ? value.error : t("app.client.agentPanel.failed"));
+	return value;
+}
+/**
+* What a comment on the preview asks of the agent: the comment, and where on the page it is.
+* @param comment - The comment and its element.
+* @returns The message for Request changes.
+*/
+function previewChange(comment) {
+	let element = comment.element;
+	let where = [`On ${comment.path}`];
+	if (element) {
+		where.push(`at ${element.label || element.breadcrumb || element.selector} <${element.tagName}>`);
+		if (element.source?.file) where.push(`(${element.source.file}${element.source.line ? `:${element.source.line}` : ""}${element.source.component ? `, ${element.source.component}` : ""})`);
+	}
+	return `${comment.body.trim()}\n\n${where.join(" ")}.`;
+}
+/**
+* Agent view for a task with a run: its page beside the run's live preview and the terminal,
+* through the factory API. Opening it wakes a sleeping sandbox, and it keeps the sandbox up
+* while open. The terminal's sessions are brokered by Bud, so nothing about the sandbox reaches
+* this page.
+* @param handle - The capability, the task, its run's state and its page.
+* @returns The view's render function.
+*/
+function AgentPanel(handle) {
+	let run;
+	let preview = { state: "none" };
+	let seen;
+	let reading = 0;
+	let update = () => {
+		if (!handle.signal.aborted) handle.update();
+	};
+	let touching = setInterval(() => {
+		if (run && SANDBOXED.includes(run.state)) call(routes.factoryApi.touch.href({ id: handle.props.itemId }), handle.props.token, handle.signal, {}).catch(() => {});
+	}, TOUCH);
+	handle.signal.addEventListener("abort", () => clearInterval(touching));
+	async function showPreview() {
+		preview = { state: "waking" };
+		update();
+		try {
+			let url = ((await call(routes.factoryApi.preview.href({ id: handle.props.itemId }), handle.props.token, handle.signal))?.preview)?.url;
+			preview = typeof url === "string" && /^https?:\/\//.test(url) ? {
+				state: "ready",
+				url
+			} : { state: "none" };
+		} catch (cause) {
+			if (handle.signal.aborted) return;
+			preview = {
+				state: "failed",
+				message: cause instanceof Error ? cause.message : t("app.client.agentPanel.failed")
+			};
+		}
+		update();
+	}
+	async function read() {
+		let mine = ++reading;
+		try {
+			let value = await call(routes.factoryApi.run.href({ id: handle.props.itemId }), handle.props.token, handle.signal);
+			if (mine !== reading) return;
+			let previous = run;
+			run = value?.run == null ? null : parseRunRecord(value.run);
+			if (!Boolean(run?.sandbox && run.ports.dev && SANDBOXED.includes(run.state))) preview = { state: "none" };
+			else if (preview.state === "none" || previous?.sandbox !== run?.sandbox) showPreview();
+		} catch {
+			if (mine === reading && run === void 0) run = null;
+		}
+		update();
+	}
+	let connect = (tab, size, output, signal) => {
+		let offset = 0;
+		let cols = size.cols;
+		let rows = size.rows;
+		let applied = null;
+		let sending = Promise.resolve();
+		let post = (path, body) => {
+			sending = sending.then(() => call(path, handle.props.token, signal, body)).then(() => {}, () => {});
+		};
+		let encoder = new TextEncoder();
+		let resize = () => {
+			applied = {
+				cols,
+				rows
+			};
+			post(routes.factoryApi.terminalResize.href({
+				id: handle.props.itemId,
+				session: tab
+			}), {
+				cols,
+				rows
+			});
+		};
+		(async () => {
+			while (!signal.aborted) {
+				output.state("connecting");
+				try {
+					let url = new URL(routes.factoryApi.terminal.href({
+						id: handle.props.itemId,
+						session: tab
+					}), window.location.origin);
+					let asked = {
+						cols,
+						rows
+					};
+					url.searchParams.set("cols", String(cols));
+					url.searchParams.set("rows", String(rows));
+					url.searchParams.set("from", String(offset));
+					let response = await fetch(url, {
+						headers: { "X-Bud-Token": handle.props.token },
+						credentials: "same-origin",
+						cache: "no-store",
+						signal
+					});
+					if (!response.ok || !response.body) {
+						let value = await response.json().catch(() => null);
+						let message = typeof value?.error === "string" ? value.error : t("app.client.agentPanel.failed");
+						output.write(encoder.encode(`\r\n\x1b[2m${message}\x1b[0m\r\n`));
+						output.state("closed");
+						if (response.status === 404) return;
+					} else {
+						output.state("open");
+						applied = asked;
+						if (cols !== asked.cols || rows !== asked.rows) resize();
+						let reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+						let buffer = "";
+						let ended = false;
+						while (!ended) {
+							let { done, value } = await reader.read();
+							if (done) break;
+							buffer += value;
+							let blocks = buffer.split("\n\n");
+							buffer = blocks.pop() ?? "";
+							for (let block of blocks) {
+								let id = /^id: (\d+)$/m.exec(block)?.[1];
+								let data = /^data: (.*)$/m.exec(block)?.[1];
+								if (/^event: exit$/m.test(block)) ended = true;
+								else if (id && data) {
+									output.write(Uint8Array.from(atob(data), (character) => character.charCodeAt(0)));
+									offset = Number(id);
+								}
+							}
+						}
+						output.state("closed");
+						applied = null;
+						if (ended) {
+							output.write(encoder.encode(`\r\n\x1b[2m${t("app.client.agentPanel.ended")}\x1b[0m\r\n`));
+							offset = 0;
+						}
+					}
+				} catch {
+					if (signal.aborted) return;
+					output.state("closed");
+					applied = null;
+				}
+				await new Promise((resolve) => setTimeout(resolve, 2e3));
+			}
+		})();
+		return {
+			input: (data) => post(routes.factoryApi.terminalInput.href({
+				id: handle.props.itemId,
+				session: tab
+			}), { data }),
+			resize: (nextCols, nextRows) => {
+				cols = nextCols;
+				rows = nextRows;
+				if (applied) resize();
+			}
+		};
+	};
+	async function comment(change) {
+		try {
+			let value = await call(routes.factoryApi.changes.href({ id: handle.props.itemId }), handle.props.token, handle.signal, { message: previewChange(change) });
+			run = value?.run == null ? run : parseRunRecord(value.run);
+			toast.success(t("app.client.agentPanel.changesSent"));
+			update();
+		} catch (cause) {
+			toast.error(t("app.client.agentPanel.changesRefused"), { description: cause instanceof Error ? cause.message : void 0 });
+			throw cause;
+		}
+	}
+	return () => {
+		let marker = handle.props.runState ?? "";
+		if (marker !== seen) {
+			seen = marker;
+			handle.queueTask(() => void read());
+		}
+		let terminal = run?.sandbox && run.ports.terminal && SANDBOXED.includes(run.state) ? {
+			tabs: [
+				{
+					id: "agent",
+					label: t("app.client.agentPanel.agent")
+				},
+				{
+					id: "dev",
+					label: t("app.client.agentPanel.devServer")
+				},
+				{
+					id: "shell",
+					label: t("app.client.agentPanel.shell")
+				}
+			],
+			connect
+		} : null;
+		return /* @__PURE__ */ jsx(AgentBrowser, {
+			details: handle.props.details,
+			preview,
+			terminal,
+			onWake: () => void showPreview(),
+			onComment: run?.state === "review" ? comment : void 0
+		});
+	};
+}
+//#endregion
+//#region app/client/task-context-block.tsx
+async function get(url, token, signal) {
+	let response = await fetch(url, {
+		headers: { "X-Bud-Token": token },
+		credentials: "same-origin",
+		redirect: "error",
+		signal
+	});
+	if (!response.ok) throw new Error(String(response.status));
+	return response;
+}
+/**
+* Where a task made from a discussion came from: the screenshot around the comment, the page,
+* viewport and branch, and the element with its source, or a code comment's lines.
+* @param handle - The capability and the task.
+* @returns The block, or nothing for a task without context.
+*/
+function TaskContextBlock(handle) {
+	let context = null;
+	let image = null;
+	let update = () => {
+		if (!handle.signal.aborted) handle.update();
+	};
+	handle.signal.addEventListener("abort", () => {
+		if (image) URL.revokeObjectURL(image);
+	});
+	(async () => {
+		try {
+			let body = await (await get(routes.tasksApi.context.href({ id: handle.props.itemId }), handle.props.token, handle.signal)).json();
+			context = parseTaskContext(body.context);
+			update();
+			if (context?.image) {
+				let picture = await get(routes.tasksApi.attachment.href({ hash: context.image }), handle.props.token, handle.signal);
+				image = URL.createObjectURL(await picture.blob());
+				update();
+			}
+		} catch {}
+	})();
+	return () => {
+		if (!context) return null;
+		let { page, element, code, viewport, branch } = context;
+		let source = element?.source;
+		let rows = [];
+		if (page) rows.push([t("app.client.taskContextBlock.page"), page.title === page.path ? page.path : `${page.title} (${page.path})`]);
+		if (viewport) rows.push([t("app.client.taskContextBlock.viewport"), `${viewport} px`]);
+		if (branch) rows.push([t("app.client.taskContextBlock.branch"), branch]);
+		if (element) rows.push([t("app.client.taskContextBlock.element"), `${element.label || element.breadcrumb} <${element.tagName}>`]);
+		if (source?.file) rows.push([t("app.client.taskContextBlock.source"), `${source.file}${source.line ? `:${source.line}` : ""}${source.component ? ` (${source.component})` : ""}`]);
+		if (code) rows.push([t("app.client.taskContextBlock.code"), `${code.path}:${code.startLine}–${code.endLine}${code.commit ? ` @ ${code.commit.slice(0, 8)}` : ""}`]);
+		return /* @__PURE__ */ jsx("section", {
+			class: "flex min-w-0 flex-col gap-3",
+			"data-testid": "task-context",
+			children: [
+				/* @__PURE__ */ jsx(Text, {
+					as: "h3",
+					variant: "ui",
+					weight: "medium",
+					children: t("app.client.taskContextBlock.context")
+				}),
+				image ? /* @__PURE__ */ jsx("a", {
+					href: image,
+					target: "_blank",
+					rel: "noopener",
+					class: "block overflow-hidden rounded-lg ring-1 ring-[var(--bud-card-border)]",
+					mix: on("click", (event) => {
+						event.preventDefault();
+						window.open(image, "_blank", "noopener");
+					}),
+					children: /* @__PURE__ */ jsx("img", {
+						src: image,
+						alt: t("app.client.taskContextBlock.screenshot"),
+						class: "block h-auto max-h-80 w-full object-cover",
+						"data-testid": "task-context-image"
+					})
+				}) : null,
+				rows.length ? /* @__PURE__ */ jsx("dl", {
+					class: "grid min-w-0 grid-cols-[auto_minmax(0,1fr)] gap-x-4 gap-y-1",
+					children: rows.map(([label, value]) => /* @__PURE__ */ jsx(Fragment, { children: [/* @__PURE__ */ jsx("dt", { children: /* @__PURE__ */ jsx(Text, {
+						variant: "ui-caption",
+						tone: "muted",
+						children: label
+					}) }), /* @__PURE__ */ jsx("dd", {
+						class: "min-w-0",
+						children: /* @__PURE__ */ jsx(Text, {
+							variant: "ui-caption",
+							class: "[overflow-wrap:anywhere]",
+							children: value
+						})
+					})] }))
+				}) : null
+			]
+		});
+	};
+}
+//#endregion
+//#region app/client/task-discussion.tsx
+/**
+* Owns a task's filtered discussions and lazy detail requests within its mounted lifetime.
+* @param handle - The trusted project capability and currently displayed work-item ID.
+* @returns The discussion block supplied to the task design.
+*/
+function TaskDiscussion(handle) {
+	let requested = handle.props.conversationId;
+	let selected = requested;
+	let explicit = Boolean(requested);
+	let creating = false;
+	let picking = false;
+	let draftItemIds = [handle.props.itemId];
+	let comments = createProjectComments({
+		store: projectStore(handle.props.project),
+		token: handle.props.project.token,
+		signal: handle.signal,
+		filter: { itemId: handle.props.itemId },
+		initial: handle.props.initial,
+		onChange() {
+			if (!handle.signal.aborted) handle.update();
+		}
+	});
+	if (comments.loaded) selected ??= comments.snapshot.threads[0]?.id;
+	let mount = ref(() => {
+		if (comments.loaded) return;
+		comments.load().then(() => {
+			selected ??= comments.snapshot.threads[0]?.id;
+			if (!handle.signal.aborted) handle.update();
+		});
+	});
+	async function write(change) {
+		let result = await comments.write(change);
+		await handle.props.onChange?.();
+		return result;
+	}
+	function threadLinks(thread) {
+		return {
+			project: handle.props.project,
+			thread,
+			items: handle.props.items,
+			canLink: comments.snapshot.capabilities.link,
+			busy: comments.busy,
+			onChange: async () => {
+				await comments.load();
+				if (comments.snapshot.threads.some((item) => item.id === thread.id)) await comments.loadThread(thread.id, true);
+				await handle.props.onChange?.();
+			}
+		};
+	}
+	function links(thread) {
+		return /* @__PURE__ */ jsx("div", {
+			class: "flex items-start justify-between gap-2",
+			children: [handle.props.renderThreadLinks ? handle.props.renderThreadLinks(thread) : /* @__PURE__ */ jsx(ProjectThreadLinks, {
+				part: thread.anchor ? "links" : void 0,
+				...threadLinks(thread)
+			}), !thread.anchor && comments.snapshot.capabilities.reply && comments.snapshot.threads.length > 1 ? /* @__PURE__ */ jsx(Button, {
+				variant: "ghost",
+				size: "small",
+				disabled: comments.busy,
+				"aria-pressed": !creating && selected === thread.id,
+				mix: on("click", () => {
+					selected = thread.id;
+					explicit = true;
+					creating = false;
+					handle.update();
+				}),
+				children: t("app.client.taskDiscussion.reply")
+			}) : null]
+		});
+	}
+	function heading(thread) {
+		return /* @__PURE__ */ jsx(CommentThreadHeading, {
+			location: thread.anchor ? conversationLabel(thread) : t("app.client.taskDiscussion.discussion"),
+			actions: handle.props.renderThreadLinks ? void 0 : /* @__PURE__ */ jsx(ProjectThreadLinks, {
+				part: "action",
+				...threadLinks(thread)
+			}),
+			status: thread.status,
+			busy: comments.busy,
+			onStatusChange: comments.snapshot.capabilities.status ? (status) => {
+				write({
+					id: thread.id,
+					status
+				}).catch(() => {});
+			} : void 0
+		});
+	}
+	return () => {
+		if (requested !== handle.props.conversationId) {
+			requested = handle.props.conversationId;
+			explicit = Boolean(requested);
+			if (requested) {
+				selected = requested;
+				creating = false;
+			}
+		}
+		let { threads, capabilities } = comments.snapshot;
+		let reply = creating ? void 0 : threads.find((thread) => thread.id === selected && !thread.anchor) ?? (explicit ? void 0 : threads.find((thread) => !thread.anchor && thread.status !== "resolved") ?? (!capabilities.create ? threads.find((thread) => !thread.anchor) : void 0));
+		let replyPending = !creating && (explicit && (!reply || !capabilities.reply) || Boolean(reply && !reply.messagesLoaded));
+		if (comments.ready && !comments.busy && !comments.loading) handle.queueTask(() => {
+			if (explicit && selected) comments.loadThread(selected);
+			for (let thread of comments.snapshot.threads) if (!thread.messagesLoaded && (!thread.anchor || thread.id === selected)) comments.loadThread(thread.id);
+		});
+		let count = threads.reduce((sum, thread) => sum + thread.messageCount, 0);
+		return /* @__PURE__ */ jsx("section", {
+			class: "flex min-w-0 flex-col gap-3",
+			"aria-label": t("app.client.taskDiscussion.taskDiscussion"),
+			mix: mount,
+			children: [
+				/* @__PURE__ */ jsx("div", {
+					class: "flex items-center gap-2",
+					children: [
+						/* @__PURE__ */ jsx(Text, {
+							as: "h3",
+							variant: "ui",
+							weight: "medium",
+							children: t("app.client.taskDiscussion.discussion")
+						}),
+						count ? /* @__PURE__ */ jsx(Text, {
+							variant: "ui-caption",
+							tone: "muted",
+							children: count
+						}) : null,
+						comments.ready && capabilities.create && threads.length ? /* @__PURE__ */ jsx(Button, {
+							variant: "ghost",
+							size: "small",
+							class: "ms-auto",
+							disabled: comments.busy || creating,
+							mix: on("click", () => {
+								creating = true;
+								handle.update();
+							}),
+							children: t("app.client.taskDiscussion.newDiscussion")
+						}) : null
+					]
+				}),
+				comments.error ? /* @__PURE__ */ jsx("div", {
+					class: "flex flex-col items-start gap-2",
+					children: [/* @__PURE__ */ jsx(Text, {
+						variant: "ui-caption",
+						role: "alert",
+						children: comments.error
+					}), /* @__PURE__ */ jsx(Button, {
+						variant: "secondary",
+						size: "small",
+						mix: on("click", () => {
+							comments.load().then(() => selected ? comments.loadThread(selected, true) : void 0);
+						}),
+						children: t("app.client.taskDiscussion.reloadComments")
+					})]
+				}) : null,
+				!comments.loaded ? /* @__PURE__ */ jsx(Text, {
+					variant: "ui-caption",
+					tone: "muted",
+					role: "status",
+					children: t("app.client.taskDiscussion.loadingDiscussion")
+				}) : !comments.ready ? /* @__PURE__ */ jsx(Text, {
+					variant: "ui-caption",
+					tone: "muted",
+					children: t("app.client.taskDiscussion.commentsUnavailable")
+				}) : /* @__PURE__ */ jsx(Fragment, { children: [threads.length ? threads.map((thread) => !thread.anchor ? /* @__PURE__ */ jsx(ItemDiscussion, {
+					thread,
+					links: links(thread)
+				}, thread.id) : /* @__PURE__ */ jsx(CommentThreadItem, {
+					id: thread.id,
+					expanded: selected === thread.id,
+					heading: heading(thread),
+					messages: thread.messages,
+					messageCount: thread.messageCount,
+					now: comments.now,
+					onExpand: () => {
+						selected = thread.id;
+						explicit = false;
+						comments.loadThread(thread.id);
+						handle.update();
+					},
+					renderDetail: () => /* @__PURE__ */ jsx(CommentThreadDetail, {
+						heading: heading(thread),
+						messages: thread.messages,
+						messageCount: thread.messageCount,
+						messagesLoaded: thread.messagesLoaded,
+						messagesTruncated: thread.messagesTruncated,
+						now: comments.now,
+						busy: comments.busy,
+						links: links(thread),
+						onReply: capabilities.reply ? (body, parentId) => write({
+							id: thread.id,
+							body,
+							parentId
+						}) : void 0,
+						viewerId: comments.viewer?.id,
+						onDelete: capabilities.delete ? async (messageId) => {
+							let whole = thread.messages[0]?.id === messageId;
+							await comments.remove(thread.id, messageId);
+							if (whole && selected === thread.id) selected = void 0;
+							handle.update();
+						} : void 0
+					})
+				}, thread.id)) : /* @__PURE__ */ jsx(Text, {
+					variant: "ui-caption",
+					tone: "muted",
+					children: t("app.client.taskDiscussion.noDiscussionYet")
+				}), capabilities.create || capabilities.reply && (explicit || threads.some((thread) => !thread.anchor)) ? /* @__PURE__ */ jsx("div", {
+					class: "flex min-w-0 flex-col gap-2",
+					children: [capabilities.create && (creating || !explicit && !threads.length) ? /* @__PURE__ */ jsx("div", {
+						class: "flex items-start justify-between gap-2",
+						"aria-label": t("app.client.taskDiscussion.newDiscussionTasks"),
+						children: [/* @__PURE__ */ jsx(ThreadTaskLinks, {
+							itemIds: draftItemIds,
+							items: handle.props.items ?? [],
+							href: taskHref,
+							busy: comments.busy,
+							onEdit: capabilities.link ? () => {
+								picking = true;
+								handle.update();
+							} : void 0
+						}), creating ? /* @__PURE__ */ jsx(Button, {
+							variant: "ghost",
+							size: "small",
+							disabled: comments.busy,
+							mix: on("click", () => {
+								creating = false;
+								handle.update();
+							}),
+							children: t("app.client.taskDiscussion.cancel")
+						}) : null]
+					}) : threads.length > 1 ? /* @__PURE__ */ jsx(Text, {
+						variant: "ui-caption",
+						tone: "muted",
+						children: t("app.client.taskDiscussion.replyingTo", { name: reply?.messages[0]?.author.name ?? t("app.client.taskDiscussion.theDiscussion") })
+					}) : null, /* @__PURE__ */ jsx(CommentComposer, {
+						label: t("app.client.taskDiscussion.addTaskComment"),
+						placeholder: t("app.client.taskDiscussion.addContextPlaceholder"),
+						busy: comments.busy || replyPending,
+						class: "w-full",
+						onSubmit: async (body) => {
+							if (replyPending) throw new Error(t("app.client.taskDiscussion.loadBeforeReplying"));
+							if (reply && capabilities.reply) {
+								await write({
+									id: reply.id,
+									body
+								});
+								return;
+							}
+							selected = (await write({
+								anchor: null,
+								itemIds: draftItemIds,
+								body
+							})).thread.id;
+							explicit = Boolean(selected);
+							creating = false;
+							draftItemIds = [handle.props.itemId];
+							handle.update();
+						}
+					}, "task-composer")]
+				}) : null] }),
+				picking ? /* @__PURE__ */ jsx(ProjectTaskPicker, {
+					project: handle.props.project,
+					selected: draftItemIds,
+					required: [handle.props.itemId],
+					onSave: async (itemIds) => {
+						draftItemIds = itemIds;
+						handle.update();
+					},
+					onClose: () => {
+						picking = false;
+						handle.update();
+					}
+				}) : null
+			]
+		});
+	};
+}
+//#endregion
+//#region app/client/project-tasks.tsx
+function changedSince(row, item) {
+	if (row.revision !== null) return row.revision !== item.revision;
+	return Object.entries(row.values).some(([field, value]) => JSON.stringify(value) !== JSON.stringify(item.values[field]));
+}
+async function loadTask(token, id, schema, signal, conversationId) {
+	let [value, discussion, resolved] = await Promise.all([
+		requestTasks(routes.tasksApi.show.href({ id }), token, signal, (value) => value),
+		loadItemComments(token, id, signal, conversationId),
+		schema
+	]);
+	let detail = parseWorkDetail(value, resolved);
+	if (detail.item.id !== id) throw new Error(t("app.client.projectTasks.differentTaskRefresh"));
+	return {
+		detail,
+		discussion
+	};
+}
+/**
+* Opens the project's stored board, reading it from the companion only when this browser has
+* none yet, and reads the task the URL opens with its discussions in parallel. An adapter
+* failure is kept as data for the board.
+* @param project - The project whose store and companion to read.
+* @param signal - The screen's lifetime.
+* @param href - The screen's location; a task page also reads that task.
+* @param conversationId - A discussion the URL selects on that task page.
+* @returns The store, or the error the board shows until a refresh succeeds.
+*/
+async function loadTasks(project, signal, href, conversationId) {
+	let store = await projectStore(project);
+	let stored = storedWorkspace(store);
+	let workspace = stored ? Promise.resolve(stored) : projectWork(project).refresh(signal);
+	let id = href ? selectedTask(href) : null;
+	let open = (schema) => loadTask(project.token, id, schema, signal, conversationId);
+	let taskError = "";
+	let task = id ? open(workspace.then((value) => value.schema)).catch((cause) => {
+		if (!stored || cause instanceof TaskRequestError) throw cause;
+		return open(projectWork(project).refresh(signal).then((value) => value.schema));
+	}).catch((cause) => {
+		taskError = cause instanceof Error ? cause.message : t("app.client.projectTasks.couldNotLoadTask");
+		return null;
+	}) : null;
+	try {
+		await workspace;
+		let opened = await task;
+		return {
+			store,
+			stored: Boolean(stored),
+			error: "",
+			task: opened,
+			taskError
+		};
+	} catch (cause) {
+		signal.throwIfAborted();
+		return {
+			store,
+			stored: false,
+			error: cause instanceof Error ? cause.message : t("app.client.projectTasks.couldNotLoadTasks")
+		};
+	}
+}
+/**
+* The project's work board, its task details and task writes.
+* @param handle - The project and its first board.
+* @returns The board render function.
+*/
+function ProjectTasks(handle) {
+	let project = handle.props.project;
+	let store = handle.props.initial.store;
+	let work = projectWork(project);
+	let workspace = storedWorkspace(store);
+	let stored = () => {
+		let version = workspace?.snapshot.schemaVersion;
+		workspace = storedWorkspace(store);
+		let row = detail ? store.work.get(detail.item.id) : void 0;
+		if (row && !row.$hasPendingWrites && changedSince(plainRow(row), detail.item)) loadDetail();
+		else if (!detail && detailError && workspace?.snapshot.schemaVersion !== version) loadDetail();
+		changed();
+	};
+	let subscriptions = [store.boards.subscribeChanges(stored), store.work.subscribeChanges(stored)];
+	let selectedId = selectedTask(handle.props.href);
+	let agentOpen = agentViewOpen(handle.props.href);
+	let opened = handle.props.initial.task;
+	let detail = opened?.detail.item.id === selectedId ? opened.detail : null;
+	let discussion = detail ? opened.discussion : void 0;
+	let loading = false;
+	let detailError = handle.props.initial.task ? "" : handle.props.initial.taskError ?? "";
+	let detailLoading = selectedId !== null && !detail && !detailError;
+	let error = handle.props.initial.error;
+	let listRequest = null;
+	let detailRequest = null;
+	let writeRequests = /* @__PURE__ */ new Set();
+	let renderedHref = handle.props.href;
+	let pendingHref;
+	let deferredLocation = false;
+	let mounted = false;
+	function pending(open) {
+		let row = open ? store.work.get(open.item.id) : void 0;
+		if (!open || !row?.$hasPendingWrites) return open;
+		let values = {
+			...open.item.values,
+			...plainRow(row).values
+		};
+		return {
+			...open,
+			item: {
+				...open.item,
+				values
+			}
+		};
+	}
+	function currentSchema() {
+		if (!workspace) throw new Error(t("app.client.projectTasks.refreshBeforeChanges"));
+		return workspace.schema;
+	}
+	async function write(url, body, parse) {
+		let controller = new AbortController();
+		writeRequests.add(controller);
+		try {
+			return await requestTasks(url, project.token, AbortSignal.any([handle.signal, controller.signal]), parse, fetch, { body });
+		} finally {
+			writeRequests.delete(controller);
+		}
+	}
+	async function accepted(issue) {
+		await writeRows(store.work, { upsert: [issue] });
+		if (detail?.item.id === issue.id) detail = {
+			...detail,
+			item: issue
+		};
+		changed();
+	}
+	async function refreshAfterWrite() {
+		await load();
+		if (selectedId) await loadDetail();
+	}
+	let queues = /* @__PURE__ */ new Map();
+	async function save(url, body, predict, id) {
+		let previous = id ? queues.get(id) : void 0;
+		let settled = Promise.withResolvers();
+		if (id) queues.set(id, settled.promise);
+		try {
+			let item = await writeOptimistically(predict, async () => {
+				let prior = await previous;
+				let from = "expectedRevision" in body ? body.expectedRevision : void 0;
+				let result = await write(url, prior && from === prior.from && prior.to ? {
+					...body,
+					expectedRevision: prior.to
+				} : body, (value) => parseWorkMutationResult(value, currentSchema()));
+				if (id && result.item.id !== id) throw new Error(t("app.client.projectTasks.differentTaskRefreshRetry"));
+				await accepted(result.item);
+				settled.resolve(from ? {
+					from,
+					to: result.item.revision
+				} : null);
+				return result.item;
+			});
+			if (selectedId) await loadDetail();
+			return item;
+		} catch (cause) {
+			settled.resolve(null);
+			if (!handle.signal.aborted) toast.error(t("app.client.projectTasks.undidTaskChange"), { description: cause instanceof Error ? cause.message : t("app.client.projectTasks.writeNotConfirmed") });
+			refreshAfterWrite();
+			throw cause;
+		} finally {
+			if (id && queues.get(id) === settled.promise) queues.delete(id);
+		}
+	}
+	function predicted(id, next) {
+		return () => {
+			let row = store.work.get(id);
+			if (!row) return;
+			let { values } = next(plainRow(row));
+			store.work.update(id, (draft) => {
+				draft.values = values;
+			});
+		};
+	}
+	let moving = null;
+	async function leaveRun(id, body, next) {
+		let row = store.work.get(id);
+		let run = row?.run;
+		if (!row || !run) return body;
+		let schema = currentSchema();
+		let item = plainRow(row);
+		let to = taskRole(next(item), schema, "status");
+		if (taskRole(item, schema, "status") === to) return body;
+		if (PUSHING_RUN_STATES.includes(run.state)) throw new Error(t("app.client.projectTasks.runPushing"));
+		if (!DISCARDABLE_RUN_STATES.includes(run.state)) return body;
+		let flow = Promise.withResolvers();
+		let discard = await new Promise((resolve) => {
+			moving = {
+				itemId: id,
+				status: schema.statuses.find((status) => status.value === to)?.label ?? to,
+				answer: (value) => {
+					resolve(value);
+					return flow.promise;
+				}
+			};
+			changed();
+		});
+		try {
+			if (!discard) throw new Error(t("app.client.projectTasks.runKept"));
+			await discardRun(project.token, id, handle.signal);
+			let fresh = await operations.get(id);
+			return {
+				...body,
+				expectedRevision: fresh.revision ?? body.expectedRevision
+			};
+		} finally {
+			flow.resolve();
+			moving = null;
+			changed();
+		}
+	}
+	let factory = null;
+	let follow = (value) => {
+		factory = value;
+		changed();
+	};
+	onFactoryStatus(project.token, follow, handle.signal);
+	factoryStatus(project.token).then(follow, () => {});
+	function boardColumns(schema) {
+		let steps = factory?.enabled ? factory.statuses : null;
+		if (!steps || !schema) return void 0;
+		let shown = [
+			steps.open,
+			steps.inProgress,
+			steps.needsApproval,
+			steps.readyToMerge,
+			steps.merged
+		];
+		return {
+			shown,
+			collapsed: schema.statuses.filter((status) => !shown.includes(status.value) && (status.category === "done" || status.category === "cancelled")).map((status) => status.value)
+		};
+	}
+	let operations = {
+		create: (draft) => save(routes.tasksApi.create.href(), draft, () => {
+			store.work.insert(predictWorkCreate(currentSchema(), `pending-${crypto.randomUUID()}`, draft));
+		}),
+		update: async (id, action) => {
+			let body = await leaveRun(id, action, (item) => predictWorkUpdate(item, action));
+			return save(routes.tasksApi.update.href({ id }), body, predicted(id, (item) => predictWorkUpdate(item, body)), id);
+		},
+		act: async (id, action) => {
+			let body = await leaveRun(id, action, (item) => predictWorkAction(currentSchema(), item, action));
+			return save(routes.tasksApi.mutate.href({ id }), body, predicted(id, (item) => predictWorkAction(currentSchema(), item, body)), id);
+		},
+		get: async (id) => {
+			let next = await requestTasks(routes.tasksApi.show.href({ id }), project.token, handle.signal, (value) => parseWorkDetail(value, currentSchema()));
+			if (next.item.id !== id) throw new Error(t("app.client.projectTasks.differentTaskRefresh"));
+			return next.item;
+		},
+		section: (id, section, signal = handle.signal) => requestTasks(routes.tasksApi.section.href({
+			id,
+			section
+		}), project.token, AbortSignal.any([handle.signal, signal]), (value) => parseSectionData(value, currentSchema())),
+		sync: async (action) => {
+			try {
+				let result = await write(routes.tasksApi.sync.href(), action, parseWorkSyncResult);
+				await refreshAfterWrite();
+				return result;
+			} catch (cause) {
+				refreshAfterWrite();
+				throw cause;
+			}
+		}
+	};
+	function changed() {
+		if (!handle.signal.aborted) handle.update();
+	}
+	async function load() {
+		listRequest?.abort();
+		let controller = new AbortController();
+		listRequest = controller;
+		loading = true;
+		error = "";
+		changed();
+		try {
+			await work.refresh(AbortSignal.any([handle.signal, controller.signal]));
+		} catch (cause) {
+			if (!controller.signal.aborted && !handle.signal.aborted) error = cause instanceof Error ? cause.message : t("app.client.projectTasks.couldNotLoadTasks");
+		} finally {
+			if (listRequest === controller) {
+				loading = false;
+				changed();
+			}
+		}
+	}
+	async function loadDetail() {
+		detailRequest?.abort();
+		if (!selectedId) {
+			detail = null;
+			detailLoading = false;
+			detailError = "";
+			changed();
+			return;
+		}
+		let id = selectedId;
+		let controller = new AbortController();
+		detailRequest = controller;
+		let reopening = detail?.item.id !== id;
+		if (reopening) detail = null;
+		detailLoading = true;
+		detailError = "";
+		changed();
+		try {
+			let signal = AbortSignal.any([handle.signal, controller.signal]);
+			if (reopening) {
+				let next = await loadTask(project.token, id, currentSchema(), signal, handle.props.conversationId);
+				if (controller.signal.aborted || id !== selectedId) return;
+				detail = next.detail;
+				discussion = next.discussion;
+				return;
+			}
+			let next = await requestTasks(routes.tasksApi.show.href({ id }), project.token, signal, (value) => parseWorkDetail(value, currentSchema()));
+			if (controller.signal.aborted || id !== selectedId) return;
+			if (next.item.id !== id) throw new Error(t("app.client.projectTasks.differentTaskRefresh"));
+			detail = next;
+		} catch (cause) {
+			if (!controller.signal.aborted && !handle.signal.aborted && id === selectedId) detailError = cause instanceof Error ? cause.message : t("app.client.projectTasks.couldNotLoadTask");
+		} finally {
+			if (detailRequest === controller) {
+				detailLoading = false;
+				changed();
+			}
+		}
+	}
+	function select(id, history = true) {
+		if (id === selectedId) return;
+		selectedId = id;
+		agentOpen = false;
+		if (history) location(false);
+		loadDetail();
+		changed();
+	}
+	function location(replace) {
+		let root = taskHref(null);
+		if (!handle.props.active || !readConversationLocation(window.location.href) && window.location.pathname !== root && !window.location.pathname.startsWith(`${root}/`)) {
+			deferredLocation = true;
+			return;
+		}
+		deferredLocation = false;
+		let href = agentOpen && selectedId ? taskAgentHref(selectedId) : taskHref(selectedId);
+		if (window.location.pathname + window.location.search + window.location.hash === href) return;
+		pendingHref = new URL(href, window.location.origin).href;
+		window.history[replace ? "replaceState" : "pushState"]({
+			...window.history.state,
+			budTask: selectedId
+		}, "", href);
+	}
+	let mount = ref((_node, signal) => {
+		mounted = true;
+		let loaded = selectedId;
+		selectedId = selectedTask(handle.props.href);
+		if (detail?.item.id !== selectedId && !(detailError && loaded === selectedId)) loadDetail();
+		if (handle.props.initial.stored) load();
+		signal.addEventListener("abort", () => {
+			for (let subscription of subscriptions) subscription.unsubscribe();
+			listRequest?.abort();
+			detailRequest?.abort();
+			for (let controller of writeRequests) controller.abort();
+		}, { once: true });
+	});
+	return () => {
+		if (mounted && renderedHref !== handle.props.href) {
+			renderedHref = handle.props.href;
+			if (pendingHref !== renderedHref) {
+				deferredLocation = false;
+				let id = selectedTask(renderedHref);
+				let agent = agentViewOpen(renderedHref);
+				if (id !== selectedId) handle.queueTask(() => {
+					select(id, false);
+					agentOpen = agent;
+					changed();
+				});
+				else if (agent !== agentOpen) agentOpen = agent;
+			}
+			pendingHref = void 0;
+		}
+		if (deferredLocation && handle.props.active) handle.queueTask(() => location(true));
+		let current = workspace;
+		let runState = detail ? store.work.get(detail.item.id)?.run?.state ?? detail.item.run?.state ?? null : null;
+		let agentFor = detail && runState ? detail.item.id : null;
+		let linked = current?.snapshot.items.map((item) => ({
+			id: item.id,
+			title: taskRole(item, current.schema, "title") || void 0
+		}));
+		return /* @__PURE__ */ jsx("div", {
+			class: "flex h-full min-h-0 flex-col",
+			mix: mount,
+			children: [
+				/* @__PURE__ */ jsx(FactorySetup, {
+					token: project.token,
+					onAdded: () => void load()
+				}),
+				moving ? /* @__PURE__ */ jsx(RunMoveDialog, {
+					itemId: moving.itemId,
+					status: moving.status,
+					onAnswer: moving.answer
+				}, moving.itemId) : null,
+				/* @__PURE__ */ jsx("div", {
+					class: "min-h-0 flex-1",
+					children: /* @__PURE__ */ jsx(TaskWorkspace, {
+						projectName: project.name,
+						project: {
+							id: project.id,
+							name: project.name
+						},
+						design: handle.props.design,
+						storageKey: `bud:tasks:${project.id}:v1`,
+						snapshot: current?.snapshot ?? null,
+						schema: current?.schema ?? null,
+						loading,
+						error,
+						selectedId,
+						detail: pending(detail),
+						discussion: detail ? /* @__PURE__ */ jsx("div", {
+							class: "flex min-w-0 flex-col gap-8",
+							children: [
+								/* @__PURE__ */ jsx(TaskContextBlock, {
+									token: project.token,
+									itemId: detail.item.id
+								}, `context-${detail.item.id}`),
+								/* @__PURE__ */ jsx(FactoryRun, {
+									token: project.token,
+									projectId: project.id,
+									itemId: detail.item.id,
+									revision: detail.item.revision,
+									runState: store.work.get(detail.item.id)?.run?.state ?? detail.item.run?.state
+								}, `run-${detail.item.id}`),
+								/* @__PURE__ */ jsx(TaskDiscussion, {
+									project,
+									itemId: detail.item.id,
+									initial: discussion,
+									items: linked,
+									conversationId: handle.props.conversationId,
+									onChange: refreshAfterWrite
+								}, detail.item.id)
+							]
+						}) : void 0,
+						detailLoading,
+						detailError,
+						operations,
+						columns: boardColumns(current?.schema ?? null),
+						pageActions: agentFor ? /* @__PURE__ */ jsx(IconButton, {
+							tooltip: true,
+							icon: "terminal",
+							active: agentOpen,
+							label: agentOpen ? t("app.client.projectTasks.closeAgentView") : t("app.client.projectTasks.openAgentView"),
+							"data-testid": "agent-view-toggle",
+							mix: on("click", () => {
+								agentOpen = !agentOpen;
+								location(false);
+								changed();
+							})
+						}) : void 0,
+						pageFrame: agentOpen && agentFor ? (page) => /* @__PURE__ */ jsx(AgentPanel, {
+							token: project.token,
+							itemId: agentFor,
+							runState,
+							details: page
+						}, `agent-${agentFor}`) : void 0,
+						onSelect: select,
+						onReload: () => {
+							load();
+						},
+						onReloadDetail: () => {
+							loadDetail();
+						}
+					})
+				})
+			]
+		});
+	};
+}
+//#endregion
+//#region app/screens/tasks.tsx
+var tasks_default = defineScreen({
+	routes: taskRoutes,
+	load: ({ project, signal, url, conversation }) => loadTasks(project, signal, url.href, conversation?.id),
+	render: (tasks, { project, url, active, taskDesign, conversation }) => /* @__PURE__ */ jsx(ProjectTasks, {
+		project,
+		initial: tasks,
+		design: taskDesign,
+		href: url.href,
+		active,
+		conversationId: conversation?.id
+	})
+});
+//#endregion
+export { tasks_default as default };