@norman-else/dsh-claude 0.1.34 → 0.1.36

package/lib/client.js

@@ -27,6 +27,13 @@ window.__ModuleLoader__.load({
 		const CLAUDE_ASK_PATH = "/plugins/dsh-claude/ask";
 		const CLAUDE_EDITOR_OPEN_PATH = "/plugins/dsh-claude/editor/open";
 		const CLAUDE_REWIND_PATH = "/plugins/dsh-claude/rewind";
+		function isClaudeRenderMode(value) {
+			return value === "plugin" || value === "native";
+		}
+		const DEFAULT_CLAUDE_PROSE_MODE = "plain";
+		function isClaudeProseMode(value) {
+			return value === "plain" || value === "enhanced";
+		}
 		//#endregion
 		//#region src/client/task-projection.ts
 		/** Tasks UI is reserved for detached work and genuine Claude subagents. */
@@ -239,7 +246,7 @@ window.__ModuleLoader__.load({
 				case "WebFetch": {
 					const url = inputString(input, "url") ?? "a web page";
 					completed = `Fetched ${url}`;
-					failedAction = `fetch ${url}`;
+					failedAction = `load ${url}`;
 					break;
 				}
 				case "WebSearch":
@@ -267,8 +274,76 @@ window.__ModuleLoader__.load({
 			}
 			return failed ? `Failed to ${failedAction}` : completed;
 		}
+		/** The call id a task's own lifecycle pings were dispatched from. */
+		function taskParentToolUseId(activities, taskId) {
+			for (const activity of activities) {
+				if (activity.taskId !== taskId) continue;
+				const id = inputRecord(activity.detail)?.tool_use_id;
+				if (typeof id === "string" && id.length > 0) return id;
+			}
+		}
+		/**
+		* The tools one task ran, in the shape the transcript's tool cards take.
+		*
+		* The task's own activities are lifecycle pings whose detail is the raw
+		* protocol message -- useful to nobody reading a panel. The work is in the
+		* activities addressed to the call that dispatched the task: a subagent's
+		* nested calls carry it as `parentToolUseId`, and a backgrounded command IS
+		* that call. Both are folded here the way {@link transcriptItemsForStep} folds
+		* a step, so one card renderer serves the transcript and the task panel.
+		*/
+		function taskTools(activities, taskId) {
+			const parent = taskParentToolUseId(activities, taskId);
+			if (parent === void 0) return [];
+			const tools = /* @__PURE__ */ new Map();
+			const ordered = [...activities].sort((left, right) => left.ordinal - right.ordinal);
+			for (const activity of ordered) {
+				const own = activity.parentToolUseId === parent;
+				const isRoot = activity.parentToolUseId === void 0 && activity.toolUseId === parent;
+				if (!own && !isRoot) continue;
+				const toolUseId = activity.toolUseId;
+				if (toolUseId === void 0) continue;
+				const previous = tools.get(toolUseId);
+				if (previous === void 0) {
+					if (activity.toolName === void 0) continue;
+					const input = inputRecord(activity.detail);
+					tools.set(toolUseId, {
+						toolUseId,
+						toolName: activity.toolName,
+						description: toolDescription(activity.toolName, input),
+						...activity.summary === void 0 ? {} : { summary: activity.summary },
+						...activity.detail === void 0 ? {} : { input: activity.detail },
+						...activity.phase === void 0 ? {} : { phase: activity.phase },
+						...activity.isError === void 0 ? {} : { isError: activity.isError },
+						subcalls: []
+					});
+					continue;
+				}
+				const failed = activity.isError === true || activity.phase === "failed";
+				tools.set(toolUseId, {
+					...previous,
+					description: toolDescription(previous.toolName, inputRecord(previous.input), failed),
+					...activity.detail === void 0 ? {} : { output: activity.detail },
+					...activity.phase === void 0 ? {} : { phase: activity.phase },
+					...activity.isError === void 0 ? {} : { isError: activity.isError }
+				});
+			}
+			return [...tools.values()];
+		}
+		/** Whether the Host drew this step with DSH's own renderer.
+		*
+		*  The stamp rides on the records themselves rather than on a Client-side copy
+		*  of the setting, because the two can disagree: the Host switches on the next
+		*  turn while a running Client keeps whatever it decided at boot, and the
+		*  failure mode of disagreeing is drawing every step twice. Reading it back per
+		*  step also keeps history honest in both directions -- a turn recorded under
+		*  one renderer keeps it after the setting changes. */
+		function nativelyRenderedStep(activities, turn, step) {
+			return activities.some((activity) => activity.turn === turn && activity.step === step && activity.renderer === "native");
+		}
 		/** Fold one step's shared ordinal stream into Claude Code-style prose and tool groups. */
 		function transcriptItemsForStep(activities, turn, step, tasks = []) {
+			if (nativelyRenderedStep(activities, turn, step)) return [];
 			const ordered = activities.filter((activity) => activity.turn === turn && activity.step === step && isProjectedTaskActivity(activity, tasks)).slice().sort((left, right) => left.ordinal - right.ordinal);
 			const rows = foldedRows(ordered, tasks);
 			const placed = /* @__PURE__ */ new Set();
@@ -327,6 +402,15 @@ window.__ModuleLoader__.load({
 					});
 					continue;
 				}
+				if (activity.kind === "usage" && activity.usage !== void 0) {
+					flushGroup();
+					items.push({
+						kind: "usage",
+						ordinal: activity.ordinal,
+						usage: activity.usage
+					});
+					continue;
+				}
 				if (activity.kind === "tool-call" && activity.toolUseId !== void 0 && activity.toolName !== void 0) {
 					group ??= {
 						ordinal: activity.ordinal,
@@ -674,30 +758,65 @@ window.__ModuleLoader__.load({
 			fontSize: 14,
 			lineHeight: "22px"
 		};
-		const settingSelectTrigger = {
-			width: "100%",
-			minHeight: 38,
-			display: "flex",
-			alignItems: "center",
-			justifyContent: "space-between",
-			gap: 12,
-			padding: "7px 11px 7px 13px",
-			border: "1px solid var(--dsw-alias-border-l2, color-mix(in srgb, currentColor 16%, transparent))",
-			borderRadius: 10,
-			background: "var(--dsw-alias-bg-layer-2)",
-			color: "var(--dsw-alias-label-primary)",
-			boxShadow: "0 1px 2px color-mix(in srgb, var(--dsw-alias-label-primary) 5%, transparent)",
-			font: "inherit",
-			fontSize: 14,
-			lineHeight: "22px",
-			textAlign: "left",
-			cursor: "pointer",
-			transition: "border-color 120ms ease, box-shadow 120ms ease, background 120ms ease"
-		};
-		const settingSelectTriggerOpen = {
-			borderColor: "var(--dsw-static-blue-450)",
-			boxShadow: "0 0 0 3px color-mix(in srgb, var(--dsw-static-blue-450) 15%, transparent)"
-		};
+		const settingSelectTriggerClass = "dshClaudeSettingSelectTrigger";
+		const settingSelectChevronClass = "dshClaudeSettingSelectChevron";
+		/**
+		* The listbox trigger and its chevron, in a stylesheet rather than inline
+		* because the states it has to draw cannot be expressed inline.
+		*
+		* Focus is the reason. An inline style carries no pseudo-class, so the blue
+		* ring used to ride on the open state alone: choosing an option closed the
+		* menu and took the ring with it while the button kept DOM focus, leaving the
+		* UA's own focus ring -- white on a dark theme, drawn outside the radius --
+		* as the only indicator. Focus and open are separate states; both draw the
+		* ring here, and `outline: none` retires the UA's.
+		*
+		* The open state reads `aria-expanded` instead of a second class because the
+		* attribute is already on the element and already correct. Its value is left
+		* unquoted: a valid identifier needs no quotes, and the sheet then survives
+		* React's server escaping, which would otherwise write `"` into markup a
+		* browser reads as raw text.
+		*/
+		const settingSelectCss = `
+		.${settingSelectTriggerClass} {
+		  width: 100%;
+		  min-height: 38px;
+		  display: flex;
+		  align-items: center;
+		  justify-content: space-between;
+		  gap: 12px;
+		  padding: 7px 11px 7px 13px;
+		  border: 1px solid var(--dsw-alias-border-l2, color-mix(in srgb, currentColor 16%, transparent));
+		  border-radius: 10px;
+		  background: var(--dsw-alias-bg-layer-2);
+		  color: var(--dsw-alias-label-primary);
+		  box-shadow: 0 1px 2px color-mix(in srgb, var(--dsw-alias-label-primary) 5%, transparent);
+		  font: inherit;
+		  font-size: 14px;
+		  line-height: 22px;
+		  text-align: left;
+		  cursor: pointer;
+		  transition: border-color 120ms ease, box-shadow 120ms ease, background 120ms ease;
+		}
+		.${settingSelectTriggerClass}:focus-visible,
+		.${settingSelectTriggerClass}[aria-expanded=true] {
+		  outline: none;
+		  border-color: var(--dsw-static-blue-450);
+		  box-shadow: 0 0 0 3px color-mix(in srgb, var(--dsw-static-blue-450) 15%, transparent);
+		}
+		.${settingSelectChevronClass} {
+		  flex: none;
+		  display: grid;
+		  place-items: center;
+		  width: 16px;
+		  height: 16px;
+		  color: var(--dsw-alias-label-tertiary);
+		  transition: transform 120ms ease;
+		}
+		.${settingSelectTriggerClass}[aria-expanded=true] .${settingSelectChevronClass} {
+		  transform: rotate(180deg);
+		}
+		`;
 		const settingSelectValue = {
 			minWidth: 0,
 			flex: 1,
@@ -705,15 +824,6 @@ window.__ModuleLoader__.load({
 			textOverflow: "ellipsis",
 			whiteSpace: "nowrap"
 		};
-		const settingSelectChevron = {
-			flex: "none",
-			color: "var(--dsw-alias-label-tertiary)",
-			fontSize: 16,
-			lineHeight: 1,
-			transform: "translateY(-1px)",
-			transition: "transform 120ms ease"
-		};
-		const settingSelectChevronOpen = { transform: "translateY(1px) rotate(180deg)" };
 		const settingSelectMenu = {
 			position: "absolute",
 			zIndex: 20,
@@ -1065,6 +1175,14 @@ window.__ModuleLoader__.load({
 			cursor: "pointer"
 		};
 		const taskActivitySection = { margin: "7px 0 0 27px" };
+		/** The task's tool cards. No inset panel of their own: each card already
+		*  carries its own surface, and nesting two would read as a box in a box. */
+		const taskToolList = {
+			display: "flex",
+			flexDirection: "column",
+			gap: 2,
+			marginTop: 7
+		};
 		const taskActivityList = {
 			display: "flex",
 			flexDirection: "column",
@@ -3311,460 +3429,576 @@ window.__ModuleLoader__.load({
 			lineHeight: "20px"
 		};
 		//#endregion
-		//#region src/client/token-format.ts
-		function formatTokenCount(tokens) {
-			if (tokens >= 1e6) return `${Number((tokens / 1e6).toFixed(tokens >= 1e7 ? 0 : 1))}M`;
-			if (tokens >= 1e3) return `${Number((tokens / 1e3).toFixed(tokens >= 1e5 ? 0 : 1))}K`;
-			return String(tokens);
+		//#region src/client/markdown-theme.ts
+		/** Claude Code's code presentation over the Host's Markdown renderer.
+		*
+		*  This package renders no Markdown of its own — prose, fenced blocks and the
+		*  copy affordance all come from the Host's `MarkdownText` primitive. What it
+		*  can own is what that primitive reads: the palette (custom properties) and
+		*  the block's chrome (CSS over the primitive's own markup).
+		*
+		*  PARITY IS PARTIAL BY CONSTRUCTION. Both renderers highlight with shiki, but
+		*  Claude Code's desktop build loads a full TextMate theme (Pierre Dark /
+		*  Pierre Light Soft: 248 tokenColor rules over 424 scopes) and bakes the
+		*  resolved colour into every span, while the Host loads shiki's legacy
+		*  `css-variables` theme, which collapses every scope into the eleven buckets
+		*  below. Those eleven carry the colours that dominate a code block —
+		*  keywords, strings, comments, functions, numbers — and nothing here can
+		*  recover the rest: `constant.numeric` and `constant` are two different
+		*  colours in Pierre and one bucket here, and Pierre's string-coloured string
+		*  delimiters share this sheet's single punctuation bucket. Matching the rest
+		*  means this package running its own shiki, which is a different decision
+		*  with a different cost.
+		*
+		*  Every rule fails open the way `host-chrome` does: the palette is
+		*  declarations on this package's own wrapper, and the chrome rules match the
+		*  primitive's CSS Module local names, so a Host that renames either simply
+		*  stops matching and its stock presentation comes back.
+		*/
+		/** Wrapper class carrying the palette and scoping the chrome rules.
+		*  `display:contents` so the extra element generates no box — custom
+		*  properties inherit through it regardless. */
+		const CLAUDE_MARKDOWN_SCOPE = "dsh-claude-markdown";
+		/** Pierre mapped onto the Host's eleven buckets. Each entry names the theme
+		*  scope the value was taken from, because the mapping — not the colour — is
+		*  the part a reader has to check. */
+		const PIERRE_DARK = [
+			[
+				"--shiki-background",
+				"#1a1a19",
+				"UI surface (--cds-surface-2)"
+			],
+			[
+				"--shiki-foreground",
+				"#fafafa",
+				"editor.foreground"
+			],
+			[
+				"--shiki-token-comment",
+				"#737373",
+				"comment"
+			],
+			[
+				"--shiki-token-keyword",
+				"#ff678d",
+				"keyword, storage.type"
+			],
+			[
+				"--shiki-token-string",
+				"#5ecc71",
+				"string"
+			],
+			[
+				"--shiki-token-string-expression",
+				"#ffa359",
+				"punctuation.section.embedded"
+			],
+			[
+				"--shiki-token-function",
+				"#9d6afb",
+				"entity.name.function"
+			],
+			[
+				"--shiki-token-constant",
+				"#68cdf2",
+				"constant.numeric, constant.language"
+			],
+			[
+				"--shiki-token-parameter",
+				"#a3a3a3",
+				"variable.parameter"
+			],
+			[
+				"--shiki-token-punctuation",
+				"#636363",
+				"punctuation"
+			],
+			[
+				"--shiki-token-link",
+				"#ff678d",
+				"markup.underline.link.markdown"
+			]
+		];
+		const PIERRE_LIGHT = [
+			[
+				"--shiki-background",
+				"#ffffff",
+				"UI surface (--cds-surface-2)"
+			],
+			[
+				"--shiki-foreground",
+				"#525252",
+				"editor.foreground"
+			],
+			[
+				"--shiki-token-comment",
+				"#8a8a8a",
+				"comment"
+			],
+			[
+				"--shiki-token-keyword",
+				"#ff678d",
+				"keyword, storage.type"
+			],
+			[
+				"--shiki-token-string",
+				"#0dbe4e",
+				"string"
+			],
+			[
+				"--shiki-token-string-expression",
+				"#fe8c2c",
+				"punctuation.section.embedded"
+			],
+			[
+				"--shiki-token-function",
+				"#9d6afb",
+				"entity.name.function"
+			],
+			[
+				"--shiki-token-constant",
+				"#08c0ef",
+				"constant.numeric, constant.language"
+			],
+			[
+				"--shiki-token-parameter",
+				"#737373",
+				"variable.parameter"
+			],
+			[
+				"--shiki-token-punctuation",
+				"#737373",
+				"punctuation"
+			],
+			[
+				"--shiki-token-link",
+				"#ff678d",
+				"markup.underline.link.markdown"
+			]
+		];
+		/** Claude's brand clay (`--cds-hsl-clay`), its inline-code TEXT colour; the
+		*  emphasized ramp is the light-theme variant. The chip's fill is deliberately
+		*  NOT tinted with it — see {@link INLINE_FILL_DARK}. */
+		const CLAY = "#d97757";
+		const CLAY_EMPHASIZED = "#c8603f";
+		/** Prose colours for the body of a Claude answer.
+		*
+		*  These are NOT Pierre: the palette above exists to match Claude's desktop
+		*  build inside code blocks, and Claude paints prose in plain body text. This
+		*  block is a deliberate departure — headings, emphasis and links get their
+		*  own hues so a long answer is scannable, the way a Markdown-highlighting
+		*  editor shows it. Values are theme-independent by design (the same six read
+		*  acceptably on both surfaces); split them if the light theme ever needs its
+		*  own ramp.
+		*
+		*  The inline-code entry REPLACES {@link CLAY} rather than sitting beside it:
+		*  two colours on the same chip is not a choice a stylesheet can make. */
+		const PROSE = {
+			heading: "#7C9EFF",
+			bold: "#FFB454",
+			italic: "#5BD6C0",
+			inlineCode: "#FF7A93",
+			listMarker: "#F2C94C",
+			quote: "#9AA3B2",
+			link: "#4DA3FF",
+			codeBackground: "#0F1218",
+			codeBorder: "#2E3546"
+		};
+		/** The inline-code chip fill: a neutral 4% wash (Claude's `--t1`), not a tint
+		*  of the text colour. A clay-tinted fill reads as a coloured box around every
+		*  identifier; the neutral one disappears into the surface and lets the text
+		*  carry the accent, which is what the chip is for. */
+		const INLINE_FILL_DARK = "hsl(0 0% 100% / .04)";
+		const INLINE_FILL_LIGHT = "hsl(0 0% 4.3% / .04)";
+		/** Block corner radius (Claude's `--r6`), against the Host's own 12px. */
+		const BLOCK_RADIUS = "8px";
+		/** @param banner - equal to `surface` on purpose: the bar is floated out of
+		*  the way below, so this colour is only reached if those chrome selectors
+		*  miss, and a bar that matches the block is the neutral fallback. */
+		function palette(entries, surface, banner, inlineFill) {
+			return [
+				...entries.map(([name, value]) => `${name}:${value};`),
+				`--dsw-alias-markdown-code-block:${surface};`,
+				`--dsw-alias-markdown-code-block-banner:${banner};`,
+				`--dsw-alias-markdown-inline-code:${inlineFill}`
+			].join("");
+		}
+		const CLAUDE_MARKDOWN_THEME_CSS = [
+			`.${CLAUDE_MARKDOWN_SCOPE}{display:contents;`,
+			palette(PIERRE_LIGHT, "#ffffff", "#ffffff", INLINE_FILL_LIGHT),
+			"}",
+			`body[data-ds-dark-theme] .${CLAUDE_MARKDOWN_SCOPE}{`,
+			palette(PIERRE_DARK, "#1a1a19", "#1a1a19", INLINE_FILL_DARK),
+			"}",
+			`.${CLAUDE_MARKDOWN_SCOPE} :not(pre)>code{color:${CLAY_EMPHASIZED};border-radius:4px;padding:1px 2px}`,
+			`body[data-ds-dark-theme] .${CLAUDE_MARKDOWN_SCOPE} :not(pre)>code{color:${CLAY}}`,
+			`.${CLAUDE_MARKDOWN_SCOPE} [class*="bannerWrap"]{position:absolute;top:0;right:0;z-index:7;background:transparent;border-radius:0}`,
+			`.${CLAUDE_MARKDOWN_SCOPE} [class*="banner"]:not([class*="bannerWrap"]){background:transparent;padding:6px 8px}`,
+			`.${CLAUDE_MARKDOWN_SCOPE} [class*="infostring"]{display:none}`,
+			`.${CLAUDE_MARKDOWN_SCOPE} pre{white-space:pre;word-break:normal;overflow-x:auto}`,
+			`.${CLAUDE_MARKDOWN_SCOPE} [class*="block"]{--dsl-code-block-border-radius:${BLOCK_RADIUS}}`
+		].join("");
+		/** The class the review-comment card puts on a rendered comment body. Declared
+		*  here rather than imported because it is a literal inside `styles.ts`'s CSS
+		*  string, not a constant; a rename there makes these rules miss and the
+		*  comment keeps its stock colours, which is the same fail-open the chrome
+		*  rules above rely on. */
+		const COMMENT_BODY_SCOPE = "dshClaudeDiffCommentBody";
+		/** Everything the `prose: 'enhanced'` setting adds, and nothing the base sheet
+		*  needs. Appended AFTER the base sheet so its rules win ties on source order —
+		*  see the note on the inline-code selector below. */
+		const CLAUDE_MARKDOWN_ENHANCED_CSS = [
+			`.${CLAUDE_MARKDOWN_SCOPE} :is(h1,h2,h3,h4,h5,h6){color:${PROSE.heading}}`,
+			`.${CLAUDE_MARKDOWN_SCOPE} strong{color:${PROSE.bold}}`,
+			`.${CLAUDE_MARKDOWN_SCOPE} em{color:${PROSE.italic}}`,
+			`.${CLAUDE_MARKDOWN_SCOPE} li::marker{color:${PROSE.listMarker}}`,
+			`.${CLAUDE_MARKDOWN_SCOPE} blockquote{border-left-color:${PROSE.quote};color:${PROSE.quote}}`,
+			`.${CLAUDE_MARKDOWN_SCOPE} a{color:${PROSE.link}}`,
+			`.${CLAUDE_MARKDOWN_SCOPE} :not(pre)>code,body[data-ds-dark-theme] .${CLAUDE_MARKDOWN_SCOPE} :not(pre)>code{color:${PROSE.inlineCode}}`,
+			`.${CLAUDE_MARKDOWN_SCOPE} [class*="block"]{background:${PROSE.codeBackground};box-shadow:0 0 0 1px ${PROSE.codeBorder}}`,
+			`.${CLAUDE_MARKDOWN_SCOPE} pre{background:${PROSE.codeBackground}}`,
+			`.${COMMENT_BODY_SCOPE} :is(h1,h2,h3,h4,h5,h6){color:${PROSE.heading}}`,
+			`.${COMMENT_BODY_SCOPE} strong{color:${PROSE.bold}}`,
+			`.${COMMENT_BODY_SCOPE} em{color:${PROSE.italic}}`,
+			`.${COMMENT_BODY_SCOPE} li::marker{color:${PROSE.listMarker}}`,
+			`.${COMMENT_BODY_SCOPE} blockquote{border-left-color:${PROSE.quote};color:${PROSE.quote}}`,
+			`.${COMMENT_BODY_SCOPE} a{color:${PROSE.link}}`,
+			`.${COMMENT_BODY_SCOPE} :not(pre)>code{color:${PROSE.inlineCode}}`
+		].join("");
+		/** Live reference to this package's sheet, and the mode it currently holds.
+		*  The mode is remembered so `ensureClaudeMarkdownTheme` — called on every
+		*  Markdown render — cannot undo a choice boot or the settings panel made. */
+		let styleTag = null;
+		let mode = DEFAULT_CLAUDE_PROSE_MODE;
+		function write() {
+			if (typeof document === "undefined") return;
+			if (styleTag === null || styleTag.parentNode === null) {
+				styleTag = document.createElement("style");
+				styleTag.dataset.dshClaudeMarkdownTheme = "";
+				document.head.appendChild(styleTag);
+			}
+			styleTag.textContent = mode === "enhanced" ? CLAUDE_MARKDOWN_THEME_CSS + CLAUDE_MARKDOWN_ENHANCED_CSS : CLAUDE_MARKDOWN_THEME_CSS;
+		}
+		/** Attach the sheet, keeping whatever mode is already set. Idempotent. */
+		function ensureClaudeMarkdownTheme() {
+			write();
+		}
+		/** Switch the prose palette. Rewriting one global sheet repaints every mounted
+		*  Markdown block at once, so no render state has to carry the setting. */
+		function applyClaudeMarkdownTheme(next) {
+			mode = next;
+			write();
 		}
 		//#endregion
-		//#region src/client/ClaudeTasksPanel.tsx
-		const STATUS_LABEL = {
-			running: "tasksRunning",
-			completed: "tasksCompleted",
-			failed: "tasksFailed",
-			stopped: "tasksStopped",
-			killed: "tasksKilled"
-		};
-		function visibleTaskGroups(tasks, dismissedSettledIds) {
-			const projected = tasks.filter(isProjectedTask);
-			return {
-				running: projected.filter((task) => task.status === "running"),
-				finished: projected.filter((task) => task.status !== "running" && !dismissedSettledIds.has(task.taskId))
+		//#region src/client/markdown-labels.tsx
+		/** Stable across renders: MarkdownText keys its streaming renderer on this
+		*  object's identity and reparses from scratch whenever it changes. */
+		function useClaudeMarkdownLabels(t) {
+			return useMemo(() => ({
+				code: {
+					copyLabel: t("markdownCopy"),
+					copiedLabel: t("markdownCopied")
+				},
+				footnotes: t("markdownFootnotes")
+			}), [t]);
+		}
+		/** MarkdownText with the labels the running Host demands.
+		*
+		*  The published primitives package still types the old `codeLabels` prop, so
+		*  the new shape cannot typecheck against it — the cast is confined here rather
+		*  than repeated at every call site. Drop it once the installed
+		*  @deepseek-ai/dsh-client-ui-primitives matches the Desktop build. */
+		function ClaudeMarkdown({ text, labels, streaming }) {
+			const props = {
+				text,
+				labels,
+				...streaming === void 0 ? {} : { streaming }
 			};
+			const Renderer = MarkdownText;
+			ensureClaudeMarkdownTheme();
+			return /* @__PURE__ */ jsx("div", {
+				className: CLAUDE_MARKDOWN_SCOPE,
+				children: /* @__PURE__ */ jsx(Renderer, { ...props })
+			});
 		}
-		function activitiesForTask(activities, taskId) {
-			return activities.filter((activity) => activity.taskId === taskId);
+		//#endregion
+		//#region src/plugin-budget.ts
+		/**
+		* The plugin's connection budget, in one table.
+		*
+		* A browser opens a small fixed number of connections to one origin — six for
+		* HTTP/1.1 in Chromium — and shares them with the Host's own traffic. Every
+		* response this plugin holds open costs one of them for its lifetime, and a
+		* request that cannot get one waits in the browser's queue where no server-side
+		* deadline can reach it. When the pool is exhausted the panels that would
+		* *diagnose* the problem are the first thing to stop answering, which is how
+		* this failure has always presented: four settings cards timing out at once
+		* against a Host that is demonstrably healthy.
+		*
+		* So the budget is a fixed constant rather than a function of how much work is
+		* in flight. Steady state is one connection (the multiplexed projection
+		* carrier); the peak is `PLUGIN_GLOBAL_PERMITS`, whatever the session count.
+		*
+		* Both halves read this file, which is the point: a route declares a budget
+		* class and the client derives its wait from the same entry, so a server
+		* deadline can never be quietly longer than the client's patience.
+		*/
+		/** Server-side budget classes. A route declares a class, never a number. */
+		const ROUTE_BUDGET_MS = {
+			/** Answers from memory or a single bounded probe. */
+			fast: 5e3,
+			/** Chains local Git work. */
+			git: 45e3,
+			/** Reaches the network: remote Git, `gh`, the npm registry. */
+			remote: 15e4
+		};
+		/** The client waits one round trip longer, so the route's own 504 wins the
+		*  race and the caller learns which budget elapsed instead of guessing. */
+		const CLIENT_GRACE_MS = 3e3;
+		function clientBudgetMs(budget) {
+			return ROUTE_BUDGET_MS[budget] + CLIENT_GRACE_MS;
+		}
+		/** A request that never got a permit fails fast and says so, rather than
+		*  spending its whole budget queued behind work it cannot see. */
+		const QUEUE_WAIT_BUDGET_MS = 4e3;
+		/** Per-lane ceilings inside the global budget.
+		*
+		*  The projection carrier holds a permanently reserved permit outside these,
+		*  so three remain. `write + stream <= 2` leaves one permit that only a read
+		*  can take: a diagnostic read always has somewhere to go, however many slow
+		*  actions are in flight. That invariant is what stops a 150s repository
+		*  action from reproducing the original symptom through a new mechanism. */
+		const PLUGIN_LANE_CAPS = {
+			read: 2,
+			write: 1,
+			stream: 1
+		};
+		//#endregion
+		//#region src/rewind.ts
+		function isRewound(ranges, seq) {
+			return ranges.some((range) => seq >= range.start && seq <= range.end);
 		}
-		function tasksForTurn(tasks, turn) {
-			return tasks.filter((task) => task.originTurn === turn && isProjectedTask(task));
+		//#endregion
+		//#region src/client/plugin-transport.ts
+		/**
+		* The plugin's only door to the network.
+		*
+		* Every request the Client makes goes through here, and the shape of the
+		* public functions is the point. There is no `signal` property, no `headers`,
+		* no `RequestInit` and no millisecond number in any parameter: a caller cannot
+		* hand this module an options object whose later spread silently overwrites
+		* the deadline sitting above it. That is not a hypothetical — it is exactly
+		* how four call sites lost their deadlines while looking completely ordinary,
+		* because `exactOptionalPropertyTypes` forbids writing `signal: undefined` and
+		* the spread idiom is what people reach for instead. `cancel` is positional
+		* here, so `undefined` is simply passable and the idiom has nothing to do.
+		*
+		* The second seal is arithmetic. The browser shares a small fixed connection
+		* budget between this plugin and the Host, and the plugin used to spend it
+		* proportionally to how many Claude sessions existed. Here every request takes
+		* a permit from a fixed pool first, so more call sites and more sessions
+		* cannot become more sockets — a saturated plugin queues, and says `starved`
+		* within `QUEUE_WAIT_BUDGET_MS` instead of dying silently at its full budget.
+		*
+		* Lane caps guarantee a read always has somewhere to go: the projection
+		* carrier holds a reserved permit, and `write + stream` can occupy at most two
+		* of the remaining three. The panel that diagnoses a saturated pool is
+		* therefore the one request that cannot be starved by it.
+		*/
+		var PluginRequestError = class extends Error {
+			reason;
+			status;
+			code;
+			constructor(reason, message, status, code) {
+				super(message);
+				this.name = "PluginRequestError";
+				this.reason = reason;
+				if (status !== void 0) this.status = status;
+				if (code !== void 0) this.code = code;
+			}
+		};
+		let send = (...args) => fetch(...args);
+		let held = 0;
+		const laneHeld = {
+			read: 0,
+			write: 0,
+			stream: 0
+		};
+		let projectionHeld = false;
+		let queue = [];
+		const inFlight = /* @__PURE__ */ new Map();
+		/** The projection carrier owns a permit of its own, outside the lane caps, so
+		*  the transcript stream and the panels never compete for the same slot. */
+		function laneHasRoom(lane) {
+			return held < 4 && laneHeld[lane] < PLUGIN_LANE_CAPS[lane];
+		}
+		function pump() {
+			for (let index = 0; index < queue.length; index += 1) {
+				const waiter = queue[index];
+				if (waiter === void 0 || !laneHasRoom(waiter.lane)) continue;
+				queue.splice(index, 1);
+				index -= 1;
+				clearTimeout(waiter.timer);
+				held += 1;
+				laneHeld[waiter.lane] += 1;
+				waiter.admit();
+			}
 		}
-		function summarizeTurnTasks(tasks) {
-			if (tasks.length === 0) return void 0;
-			const running = tasks.filter((task) => task.status === "running").length;
-			const failed = tasks.filter((task) => task.status === "failed" || task.status === "stopped" || task.status === "killed").length;
-			const completed = tasks.filter((task) => task.status === "completed").length;
-			return {
-				state: running > 0 ? "running" : failed > 0 ? "failed" : "completed",
-				count: tasks.length,
-				running,
-				failed,
-				completed
+		function release(lane) {
+			held -= 1;
+			laneHeld[lane] -= 1;
+			pump();
+		}
+		function acquire(lane) {
+			let released = false;
+			const releaseOnce = () => {
+				if (released) return;
+				released = true;
+				release(lane);
 			};
+			if (laneHasRoom(lane)) {
+				held += 1;
+				laneHeld[lane] += 1;
+				return Promise.resolve(releaseOnce);
+			}
+			return new Promise((resolve, reject) => {
+				const waiter = {
+					lane,
+					admit: () => resolve(releaseOnce),
+					reject,
+					timer: setTimeout(() => {
+						queue = queue.filter((item) => item !== waiter);
+						reject(new PluginRequestError("starved", "The plugin is holding every connection it is allowed to open."));
+					}, QUEUE_WAIT_BUDGET_MS)
+				};
+				queue.push(waiter);
+			});
 		}
-		function statusGlyph(status) {
-			if (status === "running") return "●";
-			if (status === "completed") return "✓";
-			if (status === "stopped") return "–";
-			return "×";
+		function withQuery(path, query) {
+			if (query === void 0) return path;
+			const encoded = new URLSearchParams(query).toString();
+			return encoded.length === 0 ? path : `${path}?${encoded}`;
 		}
-		function formatDuration(ms) {
-			if (ms < 1e3) return String(Math.max(1, Math.round(ms))) + "ms";
-			const seconds = Math.round(ms / 1e3);
-			if (seconds < 60) return String(seconds) + "s";
-			const minutes = Math.floor(seconds / 60);
-			return String(minutes) + "m " + String(seconds % 60) + "s";
+		function failureOf(error, cancel) {
+			if (error instanceof PluginRequestError) return error;
+			if (cancel?.aborted === true) return new PluginRequestError("cancelled", "The caller cancelled the request.");
+			const name = error instanceof Error ? error.name : "";
+			if (name === "TimeoutError" || name === "AbortError") return new PluginRequestError("timeout", "The plugin route did not answer inside its budget.");
+			return new PluginRequestError("http", error instanceof Error ? error.message : String(error));
 		}
-		function taskMeta(task, t) {
-			const parts = [];
-			if (task.subagentType !== void 0) parts.push(task.subagentType);
-			else if (task.taskType !== void 0) parts.push(task.taskType);
-			if (task.usage?.durationMs !== void 0) parts.push(formatDuration(task.usage.durationMs));
-			if (task.usage?.totalTokens !== void 0) parts.push(t("tokens", { count: formatTokenCount(task.usage.totalTokens) }));
-			if (task.usage?.toolUses !== void 0) parts.push(t("tasksToolUses", { count: task.usage.toolUses }));
-			if (task.lastToolName !== void 0) parts.push(t("tasksLastTool", { tool: task.lastToolName }));
-			return parts;
+		async function decode(response) {
+			let payload;
+			try {
+				payload = await response.json();
+			} catch {
+				if (response.ok) throw new PluginRequestError("shape", "The plugin route answered with a body this build cannot read.");
+				throw new PluginRequestError("http", `HTTP ${response.status}`, response.status);
+			}
+			if (response.ok) return payload;
+			if (response.status === 404) throw new PluginRequestError("route-missing", "The Host is running an older plugin build without this route.", 404);
+			const record = typeof payload === "object" && payload !== null ? payload : void 0;
+			const message = typeof record?.message === "string" ? record.message : typeof record?.error === "string" ? record.error : `HTTP ${response.status}`;
+			const code = typeof record?.error === "string" ? record.error : void 0;
+			throw new PluginRequestError("http", message, response.status, code);
+		}
+		async function dispatch(lane, method, path, budget, cancel, options) {
+			const url = withQuery(path, options?.query);
+			const key = options?.key ?? `${method} ${url}`;
+			const existing = inFlight.get(key);
+			if (existing !== void 0) return await existing;
+			const run = (async () => {
+				const free = await acquire(lane);
+				try {
+					const timeout = AbortSignal.timeout(clientBudgetMs(budget));
+					const signal = cancel === void 0 ? timeout : AbortSignal.any([cancel, timeout]);
+					return await decode(await send(url, {
+						method,
+						credentials: "same-origin",
+						signal,
+						headers: options?.json === void 0 ? { accept: "application/json" } : {
+							accept: "application/json",
+							"content-type": "application/json"
+						},
+						...options?.json === void 0 ? {} : { body: JSON.stringify(options.json) }
+					}));
+				} catch (error) {
+					throw failureOf(error, cancel);
+				} finally {
+					free();
+				}
+			})();
+			inFlight.set(key, run);
+			try {
+				return await run;
+			} finally {
+				if (inFlight.get(key) === run) inFlight.delete(key);
+			}
 		}
-		function TaskActivity({ activity, t }) {
-			return /* @__PURE__ */ jsxs("li", {
-				style: taskActivityItem,
-				children: [/* @__PURE__ */ jsx("span", {
-					style: taskActivityGlyph,
-					"aria-hidden": "true",
-					children: activity.isError === true ? "×" : "›"
-				}), /* @__PURE__ */ jsxs("div", {
-					style: taskActivityBody,
-					children: [
-						/* @__PURE__ */ jsx("p", {
-							style: taskActivityTitle,
-							children: activity.title ?? activity.kind
-						}),
-						activity.summary === void 0 ? null : /* @__PURE__ */ jsx("p", {
-							style: taskActivitySummary,
-							children: activity.summary
-						}),
-						activity.detail === void 0 ? null : /* @__PURE__ */ jsxs("details", {
-							style: taskActivityDetail,
-							children: [/* @__PURE__ */ jsx("summary", {
-								style: taskActivityDetailSummary,
-								children: t("detail")
-							}), /* @__PURE__ */ jsx("pre", {
-								style: detailCode,
-								children: activity.detail
-							})]
-						})
-					]
-				})]
+		/** A bounded read of a plugin route. */
+		function pluginRead(path, budget, cancel, options) {
+			return dispatch("read", "GET", path, budget, cancel, options);
+		}
+		/** A bounded write. Writes never coalesce by default: two of them are two
+		*  intents, even when their bodies match. */
+		function pluginWrite(path, budget, cancel, options) {
+			const method = options?.method ?? "POST";
+			return dispatch("write", method, path, budget, cancel, {
+				...options,
+				key: options?.key ?? `${method} ${withQuery(path, options?.query)} #${nextWriteId()}`
 			});
 		}
-		function TaskCard(props) {
-			const { task, activities, t } = props;
-			const [activityOpen, setActivityOpen] = useState(false);
-			const running = task.status === "running";
-			const failed = task.status === "failed" || task.status === "killed";
-			const meta = taskMeta(task, t);
-			return /* @__PURE__ */ jsxs("article", {
-				style: {
-					...taskCard,
-					...running ? taskCardRunning : {}
-				},
-				children: [
-					/* @__PURE__ */ jsxs("div", {
-						style: taskCardTop,
-						children: [/* @__PURE__ */ jsx("span", {
-							className: running ? "dsh-claude-act-running" : void 0,
-							style: {
-								...taskCardGlyph,
-								...running ? iconChipRunning : {},
-								...failed ? iconChipError : {}
-							},
-							"aria-hidden": "true",
-							children: statusGlyph(task.status)
-						}), /* @__PURE__ */ jsxs("div", {
-							style: taskCardBody,
-							children: [/* @__PURE__ */ jsx("p", {
-								style: {
-									...taskTitle,
-									...failed ? { color: "var(--dsw-alias-state-error-primary)" } : {}
-								},
-								children: task.description
-							}), /* @__PURE__ */ jsxs("p", {
-								style: taskStatusLine,
-								children: [/* @__PURE__ */ jsx("span", { children: t(STATUS_LABEL[task.status] ?? "tasksRunning") }), task.backgrounded === true ? /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("span", {
-									"aria-hidden": "true",
-									children: " · "
-								}), /* @__PURE__ */ jsx("span", { children: t("tasksBackground") })] }) : null]
-							})]
-						})]
-					}),
-					meta.length === 0 ? null : /* @__PURE__ */ jsx("p", {
-						style: taskMeta$1,
-						children: meta.join(" · ")
-					}),
-					task.summary === void 0 || running ? null : /* @__PURE__ */ jsx("p", {
-						style: taskSummary,
-						children: task.summary
-					}),
-					activities.length === 0 ? null : /* @__PURE__ */ jsxs("div", {
-						style: taskActivitySection,
-						children: [/* @__PURE__ */ jsx("button", {
-							type: "button",
-							style: taskTextButton,
-							"aria-expanded": activityOpen,
-							onClick: () => setActivityOpen((value) => !value),
-							children: activityOpen ? t("tasksHideActivity") : t("tasksViewActivity")
-						}), activityOpen ? /* @__PURE__ */ jsx("ul", {
-							style: taskActivityList,
-							children: activities.map((activity) => /* @__PURE__ */ jsx(TaskActivity, {
-								activity,
-								t
-							}, `${activity.turn}:${activity.step}:${activity.ordinal}`))
-						}) : null]
-					})
-				]
-			});
-		}
-		function GroupHeading(props) {
-			const { label, count, collapsed, onToggle, action } = props;
-			const content = /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("span", { children: label }), /* @__PURE__ */ jsx("span", {
-				style: tasksGroupCount,
-				children: count
-			})] });
-			return /* @__PURE__ */ jsxs("div", {
-				style: tasksGroupHeading,
-				children: [onToggle === void 0 ? /* @__PURE__ */ jsx("div", {
-					style: tasksGroupTitle,
-					children: content
-				}) : /* @__PURE__ */ jsxs("button", {
-					type: "button",
-					style: tasksGroupToggle,
-					"aria-expanded": !collapsed,
-					onClick: onToggle,
-					children: [/* @__PURE__ */ jsx("span", {
-						style: {
-							...chevron,
-							...collapsed === true ? {} : chevronOpen
-						},
-						children: "›"
-					}), content]
-				}), action === void 0 ? null : /* @__PURE__ */ jsx("button", {
-					type: "button",
-					style: taskTextButton,
-					onClick: action.onClick,
-					children: action.label
-				})]
-			});
-		}
-		function ClaudeTasksPanel({ useClaudeProjection, t, closeDetails, turn }) {
-			const projection = useClaudeProjection((value) => value);
-			const tasks = useMemo(() => tasksForTurn(projection.tasks?.tasks ?? [], turn), [projection.tasks, turn]);
-			useEffect(() => {
-				if (!projection.owned || tasks.length === 0) closeDetails();
-			}, [
-				closeDetails,
-				projection.owned,
-				tasks.length
-			]);
-			const [finishedCollapsed, setFinishedCollapsed] = useState(false);
-			const [dismissedSettledIds, setDismissedSettledIds] = useState(() => /* @__PURE__ */ new Set());
-			const groups = useMemo(() => visibleTaskGroups(tasks, dismissedSettledIds), [tasks, dismissedSettledIds]);
-			const taskActivities = useMemo(() => new Map(tasks.map((task) => [task.taskId, activitiesForTask(projection.activities, task.taskId)])), [projection.activities, tasks]);
-			const clearFinished = () => setDismissedSettledIds((previous) => /* @__PURE__ */ new Set([...previous, ...tasks.filter((task) => task.status !== "running").map((task) => task.taskId)]));
-			if (!projection.owned) return null;
-			return /* @__PURE__ */ jsxs("div", {
-				className: detailsCardClass,
-				style: tasksPanel,
-				children: [
-					/* @__PURE__ */ jsxs("style", {
-						"data-dsh-claude-panel-icon-styles": true,
-						children: [detailsCardCss, panelIconButtonCss]
-					}),
-					/* @__PURE__ */ jsxs("div", {
-						style: tasksHeader,
-						children: [/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("span", {
-							style: tasksHeading,
-							children: t("tasksPanelTurn")
-						}), /* @__PURE__ */ jsx("span", {
-							style: tasksTurnMeta,
-							children: t("tasksTurnNumber", { turn })
-						})] }), /* @__PURE__ */ jsx("button", {
-							type: "button",
-							className: panelIconButtonClass,
-							"aria-label": t("tasksClose"),
-							onClick: closeDetails,
-							children: /* @__PURE__ */ jsx(IconCloseOutline16, {})
-						})]
-					}),
-					/* @__PURE__ */ jsxs("div", {
-						style: tasksBody,
-						children: [/* @__PURE__ */ jsxs("section", {
-							"aria-label": t("tasksRunning"),
-							children: [/* @__PURE__ */ jsx(GroupHeading, {
-								label: t("tasksRunning"),
-								count: groups.running.length
-							}), groups.running.length === 0 ? /* @__PURE__ */ jsx("p", {
-								style: tasksGroupEmpty,
-								children: t("tasksNoneRunning")
-							}) : /* @__PURE__ */ jsx("div", {
-								style: taskCardList,
-								children: groups.running.map((task) => /* @__PURE__ */ jsx(TaskCard, {
-									task,
-									activities: taskActivities.get(task.taskId) ?? [],
-									t
-								}, task.taskId))
-							})]
-						}), /* @__PURE__ */ jsxs("section", {
-							"aria-label": t("tasksSettled"),
-							style: tasksFinishedSection,
-							children: [/* @__PURE__ */ jsx(GroupHeading, {
-								label: t("tasksSettled"),
-								count: groups.finished.length,
-								collapsed: finishedCollapsed,
-								onToggle: () => setFinishedCollapsed((value) => !value),
-								...groups.finished.length === 0 ? {} : { action: {
-									label: t("tasksClear"),
-									onClick: clearFinished
-								} }
-							}), finishedCollapsed || groups.finished.length === 0 ? null : /* @__PURE__ */ jsx("div", {
-								style: taskCardList,
-								children: groups.finished.map((task) => /* @__PURE__ */ jsx(TaskCard, {
-									task,
-									activities: taskActivities.get(task.taskId) ?? [],
-									t
-								}, task.taskId))
-							})]
-						})]
-					})
-				]
-			});
-		}
-		//#endregion
-		//#region src/client/ClaudeActivityTail.tsx
-		const MAX_HOVER_TASKS = 6;
-		function taskGlyph(status) {
-			if (status === "failed") return {
-				glyph: "×",
-				style: tasksHoverGlyphError
-			};
-			if (status === "completed") return {
-				glyph: "✓",
-				style: tasksHoverGlyphDone
-			};
-			return {
-				glyph: "●",
-				style: tasksHoverGlyphRunning
-			};
-		}
-		function ClaudeTaskLauncher({ turn, tasks, t, openTasks }) {
-			const [hovered, setHovered] = useState(false);
-			const closeTimer = useRef();
-			const turnTasks = useMemo(() => tasksForTurn(tasks, turn), [tasks, turn]);
-			const summary = useMemo(() => summarizeTurnTasks(turnTasks), [turnTasks]);
-			const open = () => {
-				if (closeTimer.current !== void 0) clearTimeout(closeTimer.current);
-				closeTimer.current = void 0;
-				setHovered(true);
-			};
-			const scheduleClose = () => {
-				if (closeTimer.current !== void 0) clearTimeout(closeTimer.current);
-				closeTimer.current = setTimeout(() => {
-					closeTimer.current = void 0;
-					setHovered(false);
-				}, 350);
-			};
-			useEffect(() => () => {
-				if (closeTimer.current !== void 0) clearTimeout(closeTimer.current);
-			}, []);
-			if (summary === void 0) return null;
-			const label = summary.state === "running" ? t("tasksTurnRunning", { count: summary.running }) : summary.state === "failed" ? t("tasksTurnFailed", {
-				failed: summary.failed,
-				completed: summary.completed
-			}) : t("tasksTurnCompleted", { count: summary.completed });
-			const stateStyle = summary.state === "completed" ? tasksBadgeDone : {};
-			const dotStyle = summary.state === "failed" ? tasksBadgeDotError : summary.state === "completed" ? tasksBadgeDotDone : {};
-			return /* @__PURE__ */ jsx("div", {
-				"data-claude-task-launcher": turn,
-				style: tasksBadgeWrap,
-				children: /* @__PURE__ */ jsxs("span", {
-					style: tasksBadgeSeat,
-					onMouseEnter: open,
-					onMouseLeave: scheduleClose,
-					onFocus: open,
-					onBlur: (event) => {
-						if (!event.currentTarget.contains(event.relatedTarget)) scheduleClose();
-					},
-					children: [hovered ? /* @__PURE__ */ jsxs("span", {
-						role: "tooltip",
-						style: tasksHoverCard,
-						onMouseEnter: open,
-						onMouseLeave: scheduleClose,
-						children: [
-							/* @__PURE__ */ jsx("span", {
-								style: tasksHoverHeader,
-								children: label
-							}),
-							turnTasks.slice(0, MAX_HOVER_TASKS).map((task) => {
-								const { glyph, style } = taskGlyph(task.status);
-								return /* @__PURE__ */ jsxs("span", {
-									style: tasksHoverRow,
-									children: [
-										/* @__PURE__ */ jsx("span", {
-											className: task.status === "running" ? "dsh-claude-act-running" : void 0,
-											style: {
-												...tasksHoverGlyph,
-												...style
-											},
-											"aria-hidden": "true",
-											children: glyph
-										}),
-										/* @__PURE__ */ jsx("span", {
-											style: tasksHoverDesc,
-											title: task.description,
-											children: task.description
-										}),
-										task.subagentType === void 0 ? null : /* @__PURE__ */ jsx("span", {
-											style: tasksHoverType,
-											children: task.subagentType
-										})
-									]
-								}, task.taskId);
-							}),
-							turnTasks.length > MAX_HOVER_TASKS ? /* @__PURE__ */ jsxs("span", {
-								style: tasksHoverMore,
-								children: ["+", turnTasks.length - MAX_HOVER_TASKS]
-							}) : null,
-							/* @__PURE__ */ jsx("span", {
-								style: tasksHoverHint,
-								children: t("tasksOpen")
-							})
-						]
-					}) : null, /* @__PURE__ */ jsxs("button", {
-						type: "button",
-						className: "dsh-claude-task-launcher",
-						style: {
-							...tasksTurnBadge,
-							...stateStyle,
-							...hovered ? tasksBadgeHovered : {}
-						},
-						"aria-label": `${label} — ${t("tasksOpen")}`,
-						onClick: () => openTasks(turn),
-						children: [/* @__PURE__ */ jsx("span", {
-							className: summary.state === "running" ? "dsh-claude-act-running" : void 0,
-							style: {
-								...tasksBadgeDot,
-								...dotStyle
-							},
-							"aria-hidden": "true"
-						}), /* @__PURE__ */ jsx("span", {
-							style: tasksBadgeLabel,
-							children: label
-						})]
-					})]
-				})
-			});
-		}
-		function ClaudeActivityTail({ matched, useClaudeProjection, t, openTasks }) {
-			const tasks = useClaudeProjection((value) => value.tasks?.tasks ?? []);
-			return /* @__PURE__ */ jsx(ClaudeTaskLauncher, {
-				turn: matched.turn,
-				tasks,
-				t,
-				openTasks
-			});
-		}
-		//#endregion
-		//#region src/client/ClaudeActiveTasksNode.tsx
-		const EMPTY_TASKS$1 = [];
-		/** Render the task launcher while the owning DSH turn is still open. */
-		function ClaudeActiveTasksNode({ node, useClaudeProjection, t, openTasks }) {
-			const tasks = useClaudeProjection((value) => value.tasks?.tasks ?? EMPTY_TASKS$1);
-			return /* @__PURE__ */ jsx(ClaudeTaskLauncher, {
-				turn: node.data.turn,
-				tasks,
-				t,
-				openTasks
-			});
-		}
-		//#endregion
-		//#region src/client/markdown-labels.tsx
-		/** Stable across renders: MarkdownText keys its streaming renderer on this
-		*  object's identity and reparses from scratch whenever it changes. */
-		function useClaudeMarkdownLabels(t) {
-			return useMemo(() => ({
-				code: {
-					copyLabel: t("markdownCopy"),
-					copiedLabel: t("markdownCopied")
-				},
-				footnotes: t("markdownFootnotes")
-			}), [t]);
+		let writeId = 0;
+		function nextWriteId() {
+			writeId += 1;
+			return writeId;
 		}
-		/** MarkdownText with the labels the running Host demands.
-		*
-		*  The published primitives package still types the old `codeLabels` prop, so
-		*  the new shape cannot typecheck against it — the cast is confined here rather
-		*  than repeated at every call site. Drop it once the installed
-		*  @deepseek-ai/dsh-client-ui-primitives matches the Desktop build. */
-		function ClaudeMarkdown({ text, labels, streaming }) {
-			return /* @__PURE__ */ jsx(MarkdownText, {
-				text,
-				labels,
-				...streaming === void 0 ? {} : { streaming }
-			});
+		async function openStream(lane, path, cancel, options, reserved) {
+			const url = withQuery(path, options?.query);
+			const free = reserved ? () => {
+				projectionHeld = false;
+			} : await acquire(lane);
+			try {
+				const response = await send(url, {
+					method: options?.method ?? "GET",
+					credentials: "same-origin",
+					signal: cancel,
+					headers: options?.json === void 0 ? { accept: "application/x-ndjson" } : {
+						accept: "application/x-ndjson",
+						"content-type": "application/json"
+					},
+					...options?.json === void 0 ? {} : { body: JSON.stringify(options.json) }
+				});
+				if (!response.ok || response.body === null) {
+					free();
+					if (response.status === 404) throw new PluginRequestError("route-missing", "The Host is running an older plugin build without this route.", 404);
+					throw new PluginRequestError("http", `HTTP ${response.status}`, response.status);
+				}
+				cancel.addEventListener("abort", free, { once: true });
+				return response.body.getReader();
+			} catch (error) {
+				free();
+				throw failureOf(error, cancel);
+			}
 		}
-		//#endregion
-		//#region src/rewind.ts
-		function isRewound(ranges, seq) {
-			return ranges.some((range) => seq >= range.start && seq <= range.end);
+		/** A long-lived NDJSON response. No deadline — it is meant to stay open — but
+		*  it takes a counted permit for its whole life, which is the bound that
+		*  matters. */
+		function pluginNdjson(path, cancel, options) {
+			return openStream("stream", path, cancel, options, false);
+		}
+		/** The reserved projection carrier: exactly one live connection, ever,
+		*  whatever the session count. */
+		function pluginProjectionStream(path, cancel, options) {
+			if (projectionHeld) return Promise.reject(new PluginRequestError("starved", "The projection carrier is already open."));
+			projectionHeld = true;
+			return openStream("stream", path, cancel, options, true);
+		}
+		/** Fire-and-forget diagnostics. Dropped rather than queued when saturated:
+		*  the channel that reports the plugin's own failures must never be the
+		*  traffic that causes them. */
+		function pluginBeacon(path, body) {
+			if (!laneHasRoom("write")) return;
+			pluginWrite(path, "fast", void 0, { json: body }).catch(() => void 0);
 		}
 		//#endregion
 		//#region src/client/projection.ts
@@ -3776,6 +4010,13 @@ window.__ModuleLoader__.load({
 			activities: []
 		};
 		const RETRY_DELAY_MS = 2e3;
+		/** Floor between carrier reopens forced by a desync. A carrier that is losing
+		*  lines must not be answered with a reconnect per lost line. */
+		const RESYNC_COOLDOWN_MS = 5e3;
+		/** Wait for the subscribed set to stop moving before reopening the carrier:
+		*  mounting a session list changes it once per row. */
+		const SUBSCRIPTION_SETTLE_MS = 250;
+		const NDJSON_SEPARATOR = String.fromCharCode(10);
 		/** Coalesce stream deltas into at most one React notification per frame. */
 		const FRAME_MS = 16;
 		/** Typewriter smoothing: drain newly arrived prose over roughly this window,
@@ -3899,11 +4140,19 @@ window.__ModuleLoader__.load({
 				setTimeout(resolve, ms).unref?.();
 			});
 		}
-		/** Create one lazy source: active subscribers open the Host NDJSON stream, and
-		*  a dropped stream reconnects with a fresh snapshot after a bounded delay. */
-		function createClaudeProjectionSource(sessionId, fetchProjection = fetch, retryDelayMs = RETRY_DELAY_MS) {
+		/** One session's reducer over the shared carrier's lines.
+		*
+		*  A source opens nothing. It used to hold a stream of its own, which made the
+		*  plugin's connection count a function of how many sessions existed;
+		*  {@link ClaudeProjectionStore} now owns the single carrier and feeds each
+		*  session's lines here. `onDemand` reports whether anyone is watching, which
+		*  is what the store uses to decide which sessions the carrier subscribes to. */
+		function createClaudeProjectionSource(sessionId, onDemand = () => {}, onDesync = () => {}) {
 			let snapshot = EMPTY_CLAUDE_PROJECTION;
 			let revision = 0;
+			/** Last carrier line this reducer applied, by the server's count. Undefined
+			*  until a snapshot states where the stream stands. */
+			let seq;
 			let owned = false;
 			let commands = [];
 			let contextUsage;
@@ -3916,8 +4165,6 @@ window.__ModuleLoader__.load({
 			/** Streaming prose still being revealed: full arrived text plus shown chars. */
 			const reveal = /* @__PURE__ */ new Map();
 			let disposed = false;
-			let running = false;
-			let controller;
 			let frame;
 			let usedAnimationFrame = false;
 			const listeners = /* @__PURE__ */ new Set();
@@ -4016,7 +4263,7 @@ window.__ModuleLoader__.load({
 				}
 			};
 			const applyText = (event) => {
-				const { turn, step, ordinal, append, text } = event;
+				const { turn, step, ordinal, append, text, renderer } = event;
 				if (!nonNegativeInteger(turn) || !nonNegativeInteger(step) || !nonNegativeInteger(ordinal)) return false;
 				if (append !== void 0 && (typeof append !== "string" || append.length > MAX_TRANSCRIPT_CHARS)) return false;
 				if (text !== void 0 && (typeof text !== "string" || text.length > MAX_TRANSCRIPT_CHARS)) return false;
@@ -4033,7 +4280,8 @@ window.__ModuleLoader__.load({
 						step,
 						ordinal,
 						kind: "text",
-						phase: "updated"
+						phase: "updated",
+						...isClaudeRenderMode(renderer) ? { renderer } : {}
 					},
 					text: fullText
 				};
@@ -4053,6 +4301,17 @@ window.__ModuleLoader__.load({
 				});
 				return true;
 			};
+			/** This reducer is behind the server and cannot catch up on its own: only a
+			*  fresh snapshot can. Reported as well as acted on, because a silent
+			*  self-heal hides how often the carrier is losing lines.
+			*
+			*  Numbering stops until that snapshot arrives and states it again; every
+			*  line in between would only be measured against a count already known to
+			*  be wrong. */
+			const desync = (kind, detail) => {
+				seq = void 0;
+				onDesync(kind, `${sessionId}: ${detail}`);
+			};
 			const applyLine = (line) => {
 				const trimmed = line.trim();
 				if (trimmed.length === 0) return;
@@ -4064,10 +4323,16 @@ window.__ModuleLoader__.load({
 				}
 				const event = record$7(value);
 				if (event === void 0 || typeof event.type !== "string") return;
+				if (event.type === "checkpoint") {
+					if (nonNegativeInteger(event.seq) && seq !== void 0 && event.seq !== seq) desync("projection-gap", `checkpoint at ${event.seq}, applied ${seq}`);
+					return;
+				}
+				if (event.type !== "snapshot" && nonNegativeInteger(event.seq) && seq !== void 0 && event.seq !== seq + 1) desync("projection-gap", `expected ${seq + 1}, received ${event.seq}`);
 				try {
 					switch (event.type) {
 						case "snapshot": {
 							const next = parseClaudeClientProjection(event);
+							seq = nonNegativeInteger(event.seq) ? event.seq : void 0;
 							revision = next.revision;
 							owned = next.owned;
 							commands = next.commands;
@@ -4080,7 +4345,10 @@ window.__ModuleLoader__.load({
 							break;
 						}
 						case "text":
-							if (!applyText(event)) return;
+							if (!applyText(event)) {
+								if (seq !== void 0) desync("projection-delta-rejected", "text not applied");
+								return;
+							}
 							revision += 1;
 							break;
 						case "activity":
@@ -4114,92 +4382,197 @@ window.__ModuleLoader__.load({
 						default: return;
 					}
 				} catch {
+					desync("projection-delta-rejected", `rejected ${event.type}`);
 					return;
 				}
+				if (nonNegativeInteger(event.seq)) seq = event.seq;
 				schedulePublish();
 			};
-			const run = async () => {
-				if (running) return;
-				running = true;
-				try {
-					while (!disposed && listeners.size > 0) {
-						controller = new AbortController();
-						try {
-							const response = await fetchProjection(`${CLAUDE_PROJECTION_PATH}/${encodeURIComponent(sessionId)}/stream`, {
-								headers: { accept: "application/x-ndjson" },
-								signal: controller.signal
-							});
-							if (!response.ok) throw new Error(`Claude projection stream failed (${response.status})`);
-							if (response.body === null) throw new Error("Claude projection stream is unavailable");
-							const reader = response.body.getReader();
-							const decoder = new TextDecoder();
-							let buffer = "";
-							while (true) {
-								if (disposed || listeners.size === 0) {
-									await reader.cancel().catch(() => void 0);
-									break;
-								}
-								const chunk = await reader.read();
-								buffer += decoder.decode(chunk.value, { stream: !chunk.done });
-								const lines = buffer.split("\n");
-								buffer = lines.pop() ?? "";
-								for (const line of lines) applyLine(line);
-								if (chunk.done) break;
-							}
-						} catch (error) {
-							if (isAbort(error)) return;
-						} finally {
-							controller = void 0;
-						}
-						if (disposed || listeners.size === 0) return;
-						await delay(retryDelayMs);
-					}
-				} finally {
-					running = false;
-				}
-			};
 			return {
 				getSnapshot: () => snapshot,
+				feed: applyLine,
 				subscribe(listener) {
 					if (disposed) return () => {};
 					const wasIdle = listeners.size === 0;
 					listeners.add(listener);
-					if (wasIdle) run();
+					if (wasIdle) onDemand(true);
 					return () => {
 						listeners.delete(listener);
 						if (listeners.size !== 0) return;
-						controller?.abort();
-						controller = void 0;
 						cancelFrame();
+						onDemand(false);
 					};
 				},
 				dispose() {
 					disposed = true;
 					listeners.clear();
-					controller?.abort();
-					controller = void 0;
 					cancelFrame();
+					onDemand(false);
 				}
 			};
 		}
+		/**
+		* Every session's projection over ONE connection.
+		*
+		* The plugin used to open an NDJSON stream per session, so its share of the
+		* browser's small per-origin connection budget grew with the number of Claude
+		* sessions — and the overview panel subscribes one per LISTED session, not per
+		* open one. Past a handful of sessions the plugin's own settings panel could no
+		* longer get a connection at all, which is the failure this class exists to
+		* make impossible: the carrier is one connection whatever the session count.
+		*
+		* `source(sessionId)` keeps its shape, so consumers are unaware of any of this.
+		*/
 		var ClaudeProjectionStore = class {
 			#sources = /* @__PURE__ */ new Map();
+			/** Sessions with at least one live subscriber, newest interest last. */
+			#wanted = /* @__PURE__ */ new Set();
+			#open;
+			#retryDelayMs;
+			#settleMs;
+			#report;
+			#resyncCooldownMs;
+			#resyncedAt = 0;
+			#controller;
+			#settle;
+			#running = false;
+			#disposed = false;
+			constructor(options = {}) {
+				this.#open = options.open ?? ((path, cancel) => pluginProjectionStream(path, cancel));
+				this.#retryDelayMs = options.retryDelayMs ?? RETRY_DELAY_MS;
+				this.#settleMs = options.settleMs ?? SUBSCRIPTION_SETTLE_MS;
+				this.#report = options.report ?? (() => {});
+				this.#resyncCooldownMs = options.resyncCooldownMs ?? RESYNC_COOLDOWN_MS;
+			}
 			source(sessionId) {
 				let source = this.#sources.get(sessionId);
 				if (source === void 0) {
-					source = createClaudeProjectionSource(sessionId);
+					source = createClaudeProjectionSource(sessionId, (active) => {
+						this.#demand(sessionId, active);
+					}, (kind, detail) => {
+						this.#resync(kind, detail);
+					});
 					this.#sources.set(sessionId, source);
 				}
 				return source;
 			}
+			/** Reopen the carrier so every lane is restated from a fresh snapshot.
+			*
+			*  One session noticed the hole, but the carrier is shared and a dropped
+			*  line is a property of the carrier, so the others are suspect too --
+			*  reopening restates all of them for the price of the one reconnect. */
+			#resync(kind, detail) {
+				if (this.#disposed) return;
+				this.#report(kind, detail);
+				const now = Date.now();
+				if (now - this.#resyncedAt < this.#resyncCooldownMs) return;
+				this.#resyncedAt = now;
+				this.#reopen();
+			}
 			dispose() {
+				this.#disposed = true;
+				if (this.#settle !== void 0) clearTimeout(this.#settle);
+				this.#settle = void 0;
+				this.#controller?.abort();
+				this.#controller = void 0;
 				for (const source of this.#sources.values()) source.dispose();
 				this.#sources.clear();
+				this.#wanted.clear();
+			}
+			/** Note interest and reopen the carrier once the set stops moving. Mounting
+			*  a session list would otherwise reopen it once per row. */
+			#demand(sessionId, active) {
+				if (this.#disposed) return;
+				if (active) {
+					this.#wanted.delete(sessionId);
+					this.#wanted.add(sessionId);
+				} else if (!this.#wanted.delete(sessionId)) return;
+				if (this.#settle !== void 0) clearTimeout(this.#settle);
+				const timer = setTimeout(() => {
+					this.#settle = void 0;
+					this.#reopen();
+				}, this.#settleMs);
+				timer.unref?.();
+				this.#settle = timer;
+			}
+			#lanes() {
+				const wanted = [...this.#wanted];
+				return wanted.slice(Math.max(0, wanted.length - 16));
+			}
+			#reopen() {
+				this.#controller?.abort();
+				this.#controller = void 0;
+				if (this.#disposed || this.#wanted.size === 0) return;
+				this.#run();
+			}
+			async #run() {
+				if (this.#running) return;
+				this.#running = true;
+				try {
+					while (!this.#disposed && this.#wanted.size > 0) {
+						const controller = new AbortController();
+						this.#controller = controller;
+						const lanes = this.#lanes();
+						let superseded = false;
+						try {
+							const reader = await this.#open(`${CLAUDE_PROJECTION_PATH}/multi?sessions=${lanes.map(encodeURIComponent).join(",")}`, controller.signal);
+							const stop = () => {
+								superseded = true;
+								reader.cancel().catch(() => void 0);
+							};
+							controller.signal.addEventListener("abort", stop, { once: true });
+							const decoder = new TextDecoder();
+							let buffer = "";
+							while (!controller.signal.aborted) {
+								const chunk = await reader.read();
+								buffer += decoder.decode(chunk.value, { stream: !chunk.done });
+								const lines = buffer.split(NDJSON_SEPARATOR);
+								buffer = lines.pop() ?? "";
+								for (const line of lines) this.#dispatch(line);
+								if (chunk.done) break;
+							}
+							controller.signal.removeEventListener("abort", stop);
+							await reader.cancel().catch(() => void 0);
+						} catch (error) {
+							if (isAbort(error)) {
+								if (this.#controller !== controller) continue;
+								return;
+							}
+						} finally {
+							if (this.#controller === controller) this.#controller = void 0;
+						}
+						if (this.#disposed || this.#wanted.size === 0) return;
+						if (superseded) continue;
+						await delay(this.#retryDelayMs);
+					}
+				} finally {
+					this.#running = false;
+				}
+			}
+			/** Route one carrier line to the session that owns it. A line for a session
+			*  nobody is watching any more is dropped rather than reviving its lane. */
+			#dispatch(line) {
+				if (line.length === 0) return;
+				let session;
+				try {
+					session = JSON.parse(line).session;
+				} catch {
+					return;
+				}
+				if (typeof session !== "string") return;
+				this.#sources.get(session)?.feed(line);
 			}
 		};
 		//#endregion
+		//#region src/client/token-format.ts
+		function formatTokenCount(tokens) {
+			if (tokens >= 1e6) return `${Number((tokens / 1e6).toFixed(tokens >= 1e7 ? 0 : 1))}M`;
+			if (tokens >= 1e3) return `${Number((tokens / 1e3).toFixed(tokens >= 1e5 ? 0 : 1))}K`;
+			return String(tokens);
+		}
+		//#endregion
 		//#region src/client/ClaudeActivityNode.tsx
-		const EMPTY_TASKS = [];
+		const EMPTY_TASKS$1 = [];
 		const ACTIVITY_CSS = [
 			".dsh-claude-flow{display:flex;flex-direction:column;gap:10px}",
 			".dsh-claude-transcript-text{color:var(--dsw-alias-label-primary);font-size:15px;line-height:24px;overflow-wrap:anywhere}",
@@ -4232,6 +4605,13 @@ window.__ModuleLoader__.load({
 			".dsh-claude-diff-delete{color:var(--dsw-alias-state-error-primary)}",
 			".dsh-claude-tool-name{font-size:14px;line-height:22px;color:var(--dsw-alias-label-primary)}",
 			".dsh-claude-tool-summary{margin-left:8px;color:var(--dsw-alias-label-tertiary)}",
+			".dsh-claude-turn-usage{display:flex;flex-wrap:wrap;align-items:center;gap:5px;margin-top:10px;",
+			"color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px}",
+			".dsh-claude-turn-usage-label{color:var(--dsw-alias-label-caption)}",
+			".dsh-claude-tool-terminal{display:flex;gap:8px;margin:6px 0 0;padding:8px 10px;max-height:220px;overflow:auto;",
+			"border-radius:8px;background:var(--dsw-alias-markdown-code-block);font:var(--dsw-font-markdown-code-block-small)}",
+			".dsh-claude-tool-prompt{flex:none;user-select:none;color:var(--dsw-alias-label-caption)}",
+			".dsh-claude-tool-command{min-width:0;margin:0;color:var(--dsw-alias-label-primary);white-space:pre-wrap;overflow-wrap:anywhere}",
 			".dsh-claude-tool-detail{margin:6px 0 0;padding:8px 10px;max-height:220px;overflow:auto;border-radius:8px;background:var(--dsw-alias-markdown-code-block);font:var(--dsw-font-markdown-code-block-small);white-space:pre-wrap;overflow-wrap:anywhere}",
 			".dsh-claude-flow-row{position:relative;overflow:hidden}",
 			".dsh-claude-flow-leading{flex-shrink:0}",
@@ -4407,6 +4787,21 @@ window.__ModuleLoader__.load({
 				}, index))
 			});
 		}
+		/** The command as a shell prompt rather than a labelled field: it was typed
+		*  at one, and the prompt is what tells a reader that at a glance. */
+		function Terminal({ command }) {
+			return /* @__PURE__ */ jsxs("div", {
+				className: "dsh-claude-tool-terminal",
+				children: [/* @__PURE__ */ jsx("span", {
+					className: "dsh-claude-tool-prompt",
+					"aria-hidden": "true",
+					children: "$"
+				}), /* @__PURE__ */ jsx("pre", {
+					className: "dsh-claude-tool-command",
+					children: command
+				})]
+			});
+		}
 		function TextDetail({ title, value }) {
 			if (value === void 0 || value.length === 0) return null;
 			return /* @__PURE__ */ jsx(Section, {
@@ -4479,176 +4874,633 @@ window.__ModuleLoader__.load({
 			if (tool.toolName === "Bash" || tool.toolName === "PowerShell") {
 				const command = text$1(input?.command);
 				const terminal = [text$1(output?.stdout), text$1(output?.stderr)].filter((value) => value !== void 0).join("\n");
+				const typed = command ?? (typeof inputValue === "string" ? inputValue : void 0);
 				return /* @__PURE__ */ jsxs(Fragment$1, { children: [
-					/* @__PURE__ */ jsx(TextDetail, {
-						title: "Command",
-						value: command ?? (typeof inputValue === "string" ? inputValue : void 0)
-					}),
+					typed === void 0 ? null : /* @__PURE__ */ jsx(Terminal, { command: typed }),
 					input === void 0 ? null : /* @__PURE__ */ jsx(Section, {
 						title: t("toolInput"),
 						children: /* @__PURE__ */ jsx(Fields, {
 							value: input,
-							omit: ["command"]
+							omit: ["command", "description"]
 						})
 					}),
 					/* @__PURE__ */ jsx(TextDetail, {
 						title: outputTitle,
 						value: terminal || (typeof outputValue === "string" ? outputValue : void 0)
 					})
-				] });
-			}
-			return /* @__PURE__ */ jsxs(Fragment$1, { children: [input === void 0 ? /* @__PURE__ */ jsx(TextDetail, {
-				title: t("toolInput"),
-				value: typeof inputValue === "string" ? inputValue : void 0
-			}) : /* @__PURE__ */ jsx(Section, {
-				title: t("toolInput"),
-				children: /* @__PURE__ */ jsx(Fields, { value: input })
-			}), output === void 0 ? /* @__PURE__ */ jsx(TextDetail, {
-				title: outputTitle,
-				value: typeof outputValue === "string" ? outputValue : void 0
-			}) : /* @__PURE__ */ jsx(Section, {
-				title: outputTitle,
-				children: /* @__PURE__ */ jsx(Fields, { value: output })
-			})] });
+				] });
+			}
+			return /* @__PURE__ */ jsxs(Fragment$1, { children: [input === void 0 ? /* @__PURE__ */ jsx(TextDetail, {
+				title: t("toolInput"),
+				value: typeof inputValue === "string" ? inputValue : void 0
+			}) : /* @__PURE__ */ jsx(Section, {
+				title: t("toolInput"),
+				children: /* @__PURE__ */ jsx(Fields, { value: input })
+			}), output === void 0 ? /* @__PURE__ */ jsx(TextDetail, {
+				title: outputTitle,
+				value: typeof outputValue === "string" ? outputValue : void 0
+			}) : /* @__PURE__ */ jsx(Section, {
+				title: outputTitle,
+				children: /* @__PURE__ */ jsx(Fields, { value: output })
+			})] });
+		}
+		function ClaudeTranscriptToolItem({ tool, t }) {
+			return /* @__PURE__ */ jsxs("details", {
+				className: "dsh-claude-tool-item",
+				children: [/* @__PURE__ */ jsxs("summary", {
+					className: "dsh-claude-tool-summary-row",
+					children: [
+						/* @__PURE__ */ jsx("span", {
+							className: "dsh-claude-tool-label",
+							children: tool.toolName
+						}),
+						/* @__PURE__ */ jsx("span", {
+							className: "dsh-claude-tool-description",
+							children: tool.description
+						}),
+						tool.additions === void 0 && tool.deletions === void 0 ? null : /* @__PURE__ */ jsxs("span", {
+							className: "dsh-claude-tool-stats",
+							children: [/* @__PURE__ */ jsxs("span", {
+								className: "dsh-claude-diff-add",
+								children: ["+", tool.additions ?? 0]
+							}), /* @__PURE__ */ jsxs("span", {
+								className: "dsh-claude-diff-delete",
+								children: ["−", tool.deletions ?? 0]
+							})]
+						})
+					]
+				}), /* @__PURE__ */ jsxs("div", {
+					className: "dsh-claude-tool-content",
+					children: [tool.subcalls.length === 0 ? null : /* @__PURE__ */ jsx("div", {
+						className: "dsh-claude-flow-subcalls",
+						children: tool.subcalls.map((subcall) => /* @__PURE__ */ jsxs("div", { children: [
+							subcallGlyph(subcall),
+							" ",
+							subcall.toolName ?? t("subagent"),
+							subcall.summary === void 0 ? "" : ` · ${subcall.summary}`
+						] }, subcall.toolUseId))
+					}), /* @__PURE__ */ jsx(ToolPresentation, {
+						tool,
+						t
+					})]
+				})]
+			});
+		}
+		function ClaudeTranscriptToolGroup({ tools, additions, deletions, files: _files, t }) {
+			const [open, setOpen] = useState(false);
+			const failed = tools.some((tool) => tool.isError === true || tool.phase === "failed");
+			const running = tools.some((tool) => tool.phase === "started" || tool.phase === "updated");
+			const summary = tools.length === 1 ? t("usedTool") : t("usedTools", { count: tools.length });
+			return /* @__PURE__ */ jsxs("div", {
+				className: "dsh-claude-tool-group-native",
+				children: [/* @__PURE__ */ jsx(DisclosureRow, {
+					rowClassName: "dsh-claude-flow-row",
+					leadingClassName: "dsh-claude-flow-leading",
+					titleClassName: "dsh-claude-flow-title",
+					chevronClassName: "dsh-claude-flow-chevron",
+					icon: failed ? /* @__PURE__ */ jsx(StateDot, { state: "error" }) : running ? /* @__PURE__ */ jsx(StateDot, { state: "ongoing" }) : /* @__PURE__ */ jsx(IconApiOutline14, { size: 14 }),
+					title: summary,
+					open,
+					expandable: true,
+					expandOnRowClick: true,
+					keepContentWhenOpen: true,
+					onToggle: () => setOpen((value) => !value),
+					collapsedContent: additions !== void 0 || deletions !== void 0 ? /* @__PURE__ */ jsxs("span", {
+						className: "dsh-claude-tool-stats",
+						children: [/* @__PURE__ */ jsxs("span", {
+							className: "dsh-claude-diff-add",
+							children: ["+", additions ?? 0]
+						}), /* @__PURE__ */ jsxs("span", {
+							className: "dsh-claude-diff-delete",
+							children: ["−", deletions ?? 0]
+						})]
+					}) : void 0
+				}), open ? /* @__PURE__ */ jsx("div", {
+					className: "dsh-claude-tool-list",
+					children: tools.map((tool) => /* @__PURE__ */ jsx(ClaudeTranscriptToolItem, {
+						tool,
+						t
+					}, tool.toolUseId))
+				}) : null]
+			});
+		}
+		/** Round a duration the way a reader reads one: no more precision than the
+		*  number deserves. */
+		function formatTurnDuration(ms) {
+			if (ms < 1e3) return `${Math.max(1, Math.round(ms))}ms`;
+			const seconds = ms / 1e3;
+			if (seconds < 60) return `${seconds < 10 ? seconds.toFixed(1) : String(Math.round(seconds))}s`;
+			const whole = Math.round(seconds);
+			return `${Math.floor(whole / 60)}m ${String(whole % 60).padStart(2, "0")}s`;
+		}
+		/** Share of the prompt that was served from cache.
+		*
+		*  Cache reads are counted against everything the prompt cost to assemble --
+		*  fresh input and cache writes included -- so a turn that read nothing scores
+		*  zero rather than dividing by nothing. */
+		function cacheHitRate(usage) {
+			const read = usage.cacheReadTokens ?? 0;
+			const total = read + (usage.cacheCreationTokens ?? 0) + (usage.inputTokens ?? 0);
+			return total === 0 ? void 0 : read / total;
+		}
+		/** The turn's accounting, in the order a reader wants it: size, then cost of
+		*  assembling it, then how long it took, then money. */
+		function turnUsageParts(usage, t) {
+			const tokens = (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0) + (usage.cacheReadTokens ?? 0) + (usage.cacheCreationTokens ?? 0);
+			const cached = cacheHitRate(usage);
+			const parts = [];
+			if (tokens > 0) parts.push(t("turnUsageTokens", { count: formatTokenCount(tokens) }));
+			if (cached !== void 0) parts.push(t("turnUsageCache", { percent: (cached * 100).toFixed(1) }));
+			if (usage.durationMs !== void 0) parts.push(formatTurnDuration(usage.durationMs));
+			if (usage.ttftMs !== void 0) parts.push(t("turnUsageTtft", { duration: formatTurnDuration(usage.ttftMs) }));
+			if (usage.cumulativeCostUsd !== void 0) parts.push(t("turnUsageCost", { cost: usage.cumulativeCostUsd.toFixed(2) }));
+			return parts;
+		}
+		/** The footer the Host draws under its own assistant message, drawn here for
+		*  the steps the Host never had a message for. */
+		function ClaudeTurnUsage({ usage, t }) {
+			const parts = turnUsageParts(usage, t);
+			if (parts.length === 0) return null;
+			return /* @__PURE__ */ jsxs("div", {
+				className: "dsh-claude-turn-usage",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						className: "dsh-claude-turn-usage-label",
+						children: t("turnUsage")
+					}),
+					/* @__PURE__ */ jsx("span", {
+						"aria-hidden": "true",
+						children: "·"
+					}),
+					/* @__PURE__ */ jsx("span", { children: parts.join(" · ") })
+				]
+			});
+		}
+		function ClaudeActivityNode({ node, useClaudeProjection, t }) {
+			ensureCss$3();
+			const marker = node.data;
+			const activities = useClaudeProjection((value) => selectStepActivities(value, marker.turn, marker.step));
+			const tasks = useClaudeProjection((value) => value.tasks?.tasks ?? EMPTY_TASKS$1);
+			const items = useMemo(() => transcriptItemsForStep(activities, marker.turn, marker.step, tasks), [
+				activities,
+				marker.step,
+				marker.turn,
+				tasks
+			]);
+			const markdownLabels = useClaudeMarkdownLabels(t);
+			if (items.length === 0) return null;
+			return /* @__PURE__ */ jsx("div", {
+				className: "dsh-claude-flow",
+				children: items.map((item) => item.kind === "text" ? /* @__PURE__ */ jsx("div", {
+					className: "dsh-claude-transcript-text",
+					children: /* @__PURE__ */ jsx(ClaudeMarkdown, {
+						text: item.text,
+						labels: markdownLabels
+					})
+				}, `text:${item.ordinal}`) : item.kind === "compaction" ? /* @__PURE__ */ jsx(ClaudeCompactionDivider, {
+					compaction: item.compaction,
+					t
+				}, `compaction:${item.ordinal}`) : item.kind === "usage" ? /* @__PURE__ */ jsx(ClaudeTurnUsage, {
+					usage: item.usage,
+					t
+				}, `usage:${item.ordinal}`) : item.kind === "tools" ? /* @__PURE__ */ jsx(ClaudeTranscriptToolGroup, {
+					tools: item.tools,
+					...item.additions === void 0 ? {} : { additions: item.additions },
+					...item.deletions === void 0 ? {} : { deletions: item.deletions },
+					...item.files === void 0 ? {} : { files: item.files },
+					t
+				}, `tools:${item.ordinal}`) : /* @__PURE__ */ jsx(ActivityRow, {
+					row: item.row,
+					t
+				}, `activity:${item.ordinal}`))
+			});
 		}
-		function ClaudeTranscriptToolItem({ tool, t }) {
-			return /* @__PURE__ */ jsxs("details", {
-				className: "dsh-claude-tool-item",
-				children: [/* @__PURE__ */ jsxs("summary", {
-					className: "dsh-claude-tool-summary-row",
+		//#endregion
+		//#region src/client/ClaudeTasksPanel.tsx
+		const STATUS_LABEL = {
+			running: "tasksRunning",
+			completed: "tasksCompleted",
+			failed: "tasksFailed",
+			stopped: "tasksStopped",
+			killed: "tasksKilled"
+		};
+		function visibleTaskGroups(tasks, dismissedSettledIds) {
+			const projected = tasks.filter(isProjectedTask);
+			return {
+				running: projected.filter((task) => task.status === "running"),
+				finished: projected.filter((task) => task.status !== "running" && !dismissedSettledIds.has(task.taskId))
+			};
+		}
+		function activitiesForTask(activities, taskId) {
+			return activities.filter((activity) => activity.taskId === taskId);
+		}
+		function tasksForTurn(tasks, turn) {
+			return tasks.filter((task) => task.originTurn === turn && isProjectedTask(task));
+		}
+		function summarizeTurnTasks(tasks) {
+			if (tasks.length === 0) return void 0;
+			const running = tasks.filter((task) => task.status === "running").length;
+			const failed = tasks.filter((task) => task.status === "failed" || task.status === "stopped" || task.status === "killed").length;
+			const completed = tasks.filter((task) => task.status === "completed").length;
+			return {
+				state: running > 0 ? "running" : failed > 0 ? "failed" : "completed",
+				count: tasks.length,
+				running,
+				failed,
+				completed
+			};
+		}
+		function statusGlyph(status) {
+			if (status === "running") return "●";
+			if (status === "completed") return "✓";
+			if (status === "stopped") return "–";
+			return "×";
+		}
+		function formatDuration(ms) {
+			if (ms < 1e3) return String(Math.max(1, Math.round(ms))) + "ms";
+			const seconds = Math.round(ms / 1e3);
+			if (seconds < 60) return String(seconds) + "s";
+			const minutes = Math.floor(seconds / 60);
+			return String(minutes) + "m " + String(seconds % 60) + "s";
+		}
+		function taskMeta(task, t) {
+			const parts = [];
+			if (task.subagentType !== void 0) parts.push(task.subagentType);
+			else if (task.taskType !== void 0) parts.push(task.taskType);
+			if (task.usage?.durationMs !== void 0) parts.push(formatDuration(task.usage.durationMs));
+			if (task.usage?.totalTokens !== void 0) parts.push(t("tokens", { count: formatTokenCount(task.usage.totalTokens) }));
+			if (task.usage?.toolUses !== void 0) parts.push(t("tasksToolUses", { count: task.usage.toolUses }));
+			if (task.lastToolName !== void 0) parts.push(t("tasksLastTool", { tool: task.lastToolName }));
+			return parts;
+		}
+		function TaskActivity({ activity, t }) {
+			return /* @__PURE__ */ jsxs("li", {
+				style: taskActivityItem,
+				children: [/* @__PURE__ */ jsx("span", {
+					style: taskActivityGlyph,
+					"aria-hidden": "true",
+					children: activity.isError === true ? "×" : "›"
+				}), /* @__PURE__ */ jsxs("div", {
+					style: taskActivityBody,
 					children: [
-						/* @__PURE__ */ jsx("span", {
-							className: "dsh-claude-tool-label",
-							children: tool.toolName
+						/* @__PURE__ */ jsx("p", {
+							style: taskActivityTitle,
+							children: activity.title ?? activity.kind
 						}),
-						/* @__PURE__ */ jsx("span", {
-							className: "dsh-claude-tool-description",
-							children: tool.description
+						activity.summary === void 0 ? null : /* @__PURE__ */ jsx("p", {
+							style: taskActivitySummary,
+							children: activity.summary
 						}),
-						tool.additions === void 0 && tool.deletions === void 0 ? null : /* @__PURE__ */ jsxs("span", {
-							className: "dsh-claude-tool-stats",
-							children: [/* @__PURE__ */ jsxs("span", {
-								className: "dsh-claude-diff-add",
-								children: ["+", tool.additions ?? 0]
-							}), /* @__PURE__ */ jsxs("span", {
-								className: "dsh-claude-diff-delete",
-								children: ["−", tool.deletions ?? 0]
+						activity.detail === void 0 ? null : /* @__PURE__ */ jsxs("details", {
+							style: taskActivityDetail,
+							children: [/* @__PURE__ */ jsx("summary", {
+								style: taskActivityDetailSummary,
+								children: t("detail")
+							}), /* @__PURE__ */ jsx("pre", {
+								style: detailCode,
+								children: activity.detail
 							})]
 						})
 					]
-				}), /* @__PURE__ */ jsxs("div", {
-					className: "dsh-claude-tool-content",
-					children: [tool.subcalls.length === 0 ? null : /* @__PURE__ */ jsx("div", {
-						className: "dsh-claude-flow-subcalls",
-						children: tool.subcalls.map((subcall) => /* @__PURE__ */ jsxs("div", { children: [
-							subcallGlyph(subcall),
-							" ",
-							subcall.toolName ?? t("subagent"),
-							subcall.summary === void 0 ? "" : ` · ${subcall.summary}`
-						] }, subcall.toolUseId))
-					}), /* @__PURE__ */ jsx(ToolPresentation, {
-						tool,
-						t
-					})]
 				})]
 			});
 		}
-		function ClaudeTranscriptToolGroup({ tools, additions, deletions, files: _files, t }) {
-			const [open, setOpen] = useState(false);
-			const failed = tools.some((tool) => tool.isError === true || tool.phase === "failed");
-			const running = tools.some((tool) => tool.phase === "started" || tool.phase === "updated");
-			const summary = tools.length === 1 ? t("usedTool") : t("usedTools", { count: tools.length });
+		function TaskCard(props) {
+			const { task, activities, allActivities, t } = props;
+			const tools = useMemo(() => taskTools(allActivities, task.taskId), [allActivities, task.taskId]);
+			const [activityOpen, setActivityOpen] = useState(false);
+			const running = task.status === "running";
+			const failed = task.status === "failed" || task.status === "killed";
+			const meta = taskMeta(task, t);
+			return /* @__PURE__ */ jsxs("article", {
+				style: {
+					...taskCard,
+					...running ? taskCardRunning : {}
+				},
+				children: [
+					/* @__PURE__ */ jsxs("div", {
+						style: taskCardTop,
+						children: [/* @__PURE__ */ jsx("span", {
+							className: running ? "dsh-claude-act-running" : void 0,
+							style: {
+								...taskCardGlyph,
+								...running ? iconChipRunning : {},
+								...failed ? iconChipError : {}
+							},
+							"aria-hidden": "true",
+							children: statusGlyph(task.status)
+						}), /* @__PURE__ */ jsxs("div", {
+							style: taskCardBody,
+							children: [/* @__PURE__ */ jsx("p", {
+								style: {
+									...taskTitle,
+									...failed ? { color: "var(--dsw-alias-state-error-primary)" } : {}
+								},
+								children: task.description
+							}), /* @__PURE__ */ jsxs("p", {
+								style: taskStatusLine,
+								children: [/* @__PURE__ */ jsx("span", { children: t(STATUS_LABEL[task.status] ?? "tasksRunning") }), task.backgrounded === true ? /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("span", {
+									"aria-hidden": "true",
+									children: " · "
+								}), /* @__PURE__ */ jsx("span", { children: t("tasksBackground") })] }) : null]
+							})]
+						})]
+					}),
+					meta.length === 0 ? null : /* @__PURE__ */ jsx("p", {
+						style: taskMeta$1,
+						children: meta.join(" · ")
+					}),
+					task.summary === void 0 || running ? null : /* @__PURE__ */ jsx("p", {
+						style: taskSummary,
+						children: task.summary
+					}),
+					activities.length === 0 && tools.length === 0 ? null : /* @__PURE__ */ jsxs("div", {
+						style: taskActivitySection,
+						children: [/* @__PURE__ */ jsx("button", {
+							type: "button",
+							style: taskTextButton,
+							"aria-expanded": activityOpen,
+							onClick: () => setActivityOpen((value) => !value),
+							children: activityOpen ? t("tasksHideActivity") : t("tasksViewActivity")
+						}), !activityOpen ? null : tools.length > 0 ? /* @__PURE__ */ jsx("div", {
+							style: taskToolList,
+							children: tools.map((tool) => /* @__PURE__ */ jsx(ClaudeTranscriptToolItem, {
+								tool,
+								t
+							}, tool.toolUseId))
+						}) : /* @__PURE__ */ jsx("ul", {
+							style: taskActivityList,
+							children: activities.map((activity) => /* @__PURE__ */ jsx(TaskActivity, {
+								activity,
+								t
+							}, `${activity.turn}:${activity.step}:${activity.ordinal}`))
+						})]
+					})
+				]
+			});
+		}
+		function GroupHeading(props) {
+			const { label, count, collapsed, onToggle, action } = props;
+			const content = /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("span", { children: label }), /* @__PURE__ */ jsx("span", {
+				style: tasksGroupCount,
+				children: count
+			})] });
+			return /* @__PURE__ */ jsxs("div", {
+				style: tasksGroupHeading,
+				children: [onToggle === void 0 ? /* @__PURE__ */ jsx("div", {
+					style: tasksGroupTitle,
+					children: content
+				}) : /* @__PURE__ */ jsxs("button", {
+					type: "button",
+					style: tasksGroupToggle,
+					"aria-expanded": !collapsed,
+					onClick: onToggle,
+					children: [/* @__PURE__ */ jsx("span", {
+						style: {
+							...chevron,
+							...collapsed === true ? {} : chevronOpen
+						},
+						children: "›"
+					}), content]
+				}), action === void 0 ? null : /* @__PURE__ */ jsx("button", {
+					type: "button",
+					style: taskTextButton,
+					onClick: action.onClick,
+					children: action.label
+				})]
+			});
+		}
+		function ClaudeTasksPanel({ useClaudeProjection, t, closeDetails, turn }) {
+			const projection = useClaudeProjection((value) => value);
+			const tasks = useMemo(() => tasksForTurn(projection.tasks?.tasks ?? [], turn), [projection.tasks, turn]);
+			useEffect(() => {
+				if (!projection.owned || tasks.length === 0) closeDetails();
+			}, [
+				closeDetails,
+				projection.owned,
+				tasks.length
+			]);
+			const [finishedCollapsed, setFinishedCollapsed] = useState(false);
+			const [dismissedSettledIds, setDismissedSettledIds] = useState(() => /* @__PURE__ */ new Set());
+			const groups = useMemo(() => visibleTaskGroups(tasks, dismissedSettledIds), [tasks, dismissedSettledIds]);
+			const taskActivities = useMemo(() => new Map(tasks.map((task) => [task.taskId, activitiesForTask(projection.activities, task.taskId)])), [projection.activities, tasks]);
+			const clearFinished = () => setDismissedSettledIds((previous) => /* @__PURE__ */ new Set([...previous, ...tasks.filter((task) => task.status !== "running").map((task) => task.taskId)]));
+			if (!projection.owned) return null;
 			return /* @__PURE__ */ jsxs("div", {
-				className: "dsh-claude-tool-group-native",
-				children: [/* @__PURE__ */ jsx(DisclosureRow, {
-					rowClassName: "dsh-claude-flow-row",
-					leadingClassName: "dsh-claude-flow-leading",
-					titleClassName: "dsh-claude-flow-title",
-					chevronClassName: "dsh-claude-flow-chevron",
-					icon: failed ? /* @__PURE__ */ jsx(StateDot, { state: "error" }) : running ? /* @__PURE__ */ jsx(StateDot, { state: "ongoing" }) : /* @__PURE__ */ jsx(IconApiOutline14, { size: 14 }),
-					title: summary,
-					open,
-					expandable: true,
-					expandOnRowClick: true,
-					keepContentWhenOpen: true,
-					onToggle: () => setOpen((value) => !value),
-					collapsedContent: additions !== void 0 || deletions !== void 0 ? /* @__PURE__ */ jsxs("span", {
-						className: "dsh-claude-tool-stats",
-						children: [/* @__PURE__ */ jsxs("span", {
-							className: "dsh-claude-diff-add",
-							children: ["+", additions ?? 0]
-						}), /* @__PURE__ */ jsxs("span", {
-							className: "dsh-claude-diff-delete",
-							children: ["−", deletions ?? 0]
+				className: detailsCardClass,
+				style: tasksPanel,
+				children: [
+					/* @__PURE__ */ jsxs("style", {
+						"data-dsh-claude-panel-icon-styles": true,
+						children: [detailsCardCss, panelIconButtonCss]
+					}),
+					/* @__PURE__ */ jsxs("div", {
+						style: tasksHeader,
+						children: [/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("span", {
+							style: tasksHeading,
+							children: t("tasksPanelTurn")
+						}), /* @__PURE__ */ jsx("span", {
+							style: tasksTurnMeta,
+							children: t("tasksTurnNumber", { turn })
+						})] }), /* @__PURE__ */ jsx("button", {
+							type: "button",
+							className: panelIconButtonClass,
+							"aria-label": t("tasksClose"),
+							onClick: closeDetails,
+							children: /* @__PURE__ */ jsx(IconCloseOutline16, {})
 						})]
-					}) : void 0
-				}), open ? /* @__PURE__ */ jsx("div", {
-					className: "dsh-claude-tool-list",
-					children: tools.map((tool) => /* @__PURE__ */ jsx(ClaudeTranscriptToolItem, {
-						tool,
-						t
-					}, tool.toolUseId))
-				}) : null]
+					}),
+					/* @__PURE__ */ jsxs("div", {
+						style: tasksBody,
+						children: [/* @__PURE__ */ jsxs("section", {
+							"aria-label": t("tasksRunning"),
+							children: [/* @__PURE__ */ jsx(GroupHeading, {
+								label: t("tasksRunning"),
+								count: groups.running.length
+							}), groups.running.length === 0 ? /* @__PURE__ */ jsx("p", {
+								style: tasksGroupEmpty,
+								children: t("tasksNoneRunning")
+							}) : /* @__PURE__ */ jsx("div", {
+								style: taskCardList,
+								children: groups.running.map((task) => /* @__PURE__ */ jsx(TaskCard, {
+									task,
+									activities: taskActivities.get(task.taskId) ?? [],
+									allActivities: projection.activities,
+									t
+								}, task.taskId))
+							})]
+						}), /* @__PURE__ */ jsxs("section", {
+							"aria-label": t("tasksSettled"),
+							style: tasksFinishedSection,
+							children: [/* @__PURE__ */ jsx(GroupHeading, {
+								label: t("tasksSettled"),
+								count: groups.finished.length,
+								collapsed: finishedCollapsed,
+								onToggle: () => setFinishedCollapsed((value) => !value),
+								...groups.finished.length === 0 ? {} : { action: {
+									label: t("tasksClear"),
+									onClick: clearFinished
+								} }
+							}), finishedCollapsed || groups.finished.length === 0 ? null : /* @__PURE__ */ jsx("div", {
+								style: taskCardList,
+								children: groups.finished.map((task) => /* @__PURE__ */ jsx(TaskCard, {
+									task,
+									activities: taskActivities.get(task.taskId) ?? [],
+									allActivities: projection.activities,
+									t
+								}, task.taskId))
+							})]
+						})]
+					})
+				]
 			});
 		}
-		function ClaudeActivityNode({ node, useClaudeProjection, t }) {
-			ensureCss$3();
-			const marker = node.data;
-			const activities = useClaudeProjection((value) => selectStepActivities(value, marker.turn, marker.step));
-			const tasks = useClaudeProjection((value) => value.tasks?.tasks ?? EMPTY_TASKS);
-			const items = useMemo(() => transcriptItemsForStep(activities, marker.turn, marker.step, tasks), [
-				activities,
-				marker.step,
-				marker.turn,
-				tasks
-			]);
-			const markdownLabels = useClaudeMarkdownLabels(t);
-			if (items.length === 0) return null;
+		//#endregion
+		//#region src/client/ClaudeActivityTail.tsx
+		const MAX_HOVER_TASKS = 6;
+		function taskGlyph(status) {
+			if (status === "failed") return {
+				glyph: "×",
+				style: tasksHoverGlyphError
+			};
+			if (status === "completed") return {
+				glyph: "✓",
+				style: tasksHoverGlyphDone
+			};
+			return {
+				glyph: "●",
+				style: tasksHoverGlyphRunning
+			};
+		}
+		function ClaudeTaskLauncher({ turn, tasks, t, openTasks }) {
+			const [hovered, setHovered] = useState(false);
+			const closeTimer = useRef();
+			const turnTasks = useMemo(() => tasksForTurn(tasks, turn), [tasks, turn]);
+			const summary = useMemo(() => summarizeTurnTasks(turnTasks), [turnTasks]);
+			const open = () => {
+				if (closeTimer.current !== void 0) clearTimeout(closeTimer.current);
+				closeTimer.current = void 0;
+				setHovered(true);
+			};
+			const scheduleClose = () => {
+				if (closeTimer.current !== void 0) clearTimeout(closeTimer.current);
+				closeTimer.current = setTimeout(() => {
+					closeTimer.current = void 0;
+					setHovered(false);
+				}, 350);
+			};
+			useEffect(() => () => {
+				if (closeTimer.current !== void 0) clearTimeout(closeTimer.current);
+			}, []);
+			if (summary === void 0) return null;
+			const label = summary.state === "running" ? t("tasksTurnRunning", { count: summary.running }) : summary.state === "failed" ? t("tasksTurnFailed", {
+				failed: summary.failed,
+				completed: summary.completed
+			}) : t("tasksTurnCompleted", { count: summary.completed });
+			const stateStyle = summary.state === "completed" ? tasksBadgeDone : {};
+			const dotStyle = summary.state === "failed" ? tasksBadgeDotError : summary.state === "completed" ? tasksBadgeDotDone : {};
 			return /* @__PURE__ */ jsx("div", {
-				className: "dsh-claude-flow",
-				children: items.map((item) => item.kind === "text" ? /* @__PURE__ */ jsx("div", {
-					className: "dsh-claude-transcript-text",
-					children: /* @__PURE__ */ jsx(ClaudeMarkdown, {
-						text: item.text,
-						labels: markdownLabels
-					})
-				}, `text:${item.ordinal}`) : item.kind === "compaction" ? /* @__PURE__ */ jsx(ClaudeCompactionDivider, {
-					compaction: item.compaction,
-					t
-				}, `compaction:${item.ordinal}`) : item.kind === "tools" ? /* @__PURE__ */ jsx(ClaudeTranscriptToolGroup, {
-					tools: item.tools,
-					...item.additions === void 0 ? {} : { additions: item.additions },
-					...item.deletions === void 0 ? {} : { deletions: item.deletions },
-					...item.files === void 0 ? {} : { files: item.files },
-					t
-				}, `tools:${item.ordinal}`) : /* @__PURE__ */ jsx(ActivityRow, {
-					row: item.row,
-					t
-				}, `activity:${item.ordinal}`))
+				"data-claude-task-launcher": turn,
+				style: tasksBadgeWrap,
+				children: /* @__PURE__ */ jsxs("span", {
+					style: tasksBadgeSeat,
+					onMouseEnter: open,
+					onMouseLeave: scheduleClose,
+					onFocus: open,
+					onBlur: (event) => {
+						if (!event.currentTarget.contains(event.relatedTarget)) scheduleClose();
+					},
+					children: [hovered ? /* @__PURE__ */ jsxs("span", {
+						role: "tooltip",
+						style: tasksHoverCard,
+						onMouseEnter: open,
+						onMouseLeave: scheduleClose,
+						children: [
+							/* @__PURE__ */ jsx("span", {
+								style: tasksHoverHeader,
+								children: label
+							}),
+							turnTasks.slice(0, MAX_HOVER_TASKS).map((task) => {
+								const { glyph, style } = taskGlyph(task.status);
+								return /* @__PURE__ */ jsxs("span", {
+									style: tasksHoverRow,
+									children: [
+										/* @__PURE__ */ jsx("span", {
+											className: task.status === "running" ? "dsh-claude-act-running" : void 0,
+											style: {
+												...tasksHoverGlyph,
+												...style
+											},
+											"aria-hidden": "true",
+											children: glyph
+										}),
+										/* @__PURE__ */ jsx("span", {
+											style: tasksHoverDesc,
+											title: task.description,
+											children: task.description
+										}),
+										task.subagentType === void 0 ? null : /* @__PURE__ */ jsx("span", {
+											style: tasksHoverType,
+											children: task.subagentType
+										})
+									]
+								}, task.taskId);
+							}),
+							turnTasks.length > MAX_HOVER_TASKS ? /* @__PURE__ */ jsxs("span", {
+								style: tasksHoverMore,
+								children: ["+", turnTasks.length - MAX_HOVER_TASKS]
+							}) : null,
+							/* @__PURE__ */ jsx("span", {
+								style: tasksHoverHint,
+								children: t("tasksOpen")
+							})
+						]
+					}) : null, /* @__PURE__ */ jsxs("button", {
+						type: "button",
+						className: "dsh-claude-task-launcher",
+						style: {
+							...tasksTurnBadge,
+							...stateStyle,
+							...hovered ? tasksBadgeHovered : {}
+						},
+						"aria-label": `${label} — ${t("tasksOpen")}`,
+						onClick: () => openTasks(turn),
+						children: [/* @__PURE__ */ jsx("span", {
+							className: summary.state === "running" ? "dsh-claude-act-running" : void 0,
+							style: {
+								...tasksBadgeDot,
+								...dotStyle
+							},
+							"aria-hidden": "true"
+						}), /* @__PURE__ */ jsx("span", {
+							style: tasksBadgeLabel,
+							children: label
+						})]
+					})]
+				})
+			});
+		}
+		function ClaudeActivityTail({ matched, useClaudeProjection, t, openTasks }) {
+			const tasks = useClaudeProjection((value) => value.tasks?.tasks ?? []);
+			return /* @__PURE__ */ jsx(ClaudeTaskLauncher, {
+				turn: matched.turn,
+				tasks,
+				t,
+				openTasks
 			});
 		}
 		//#endregion
-		//#region src/client/plugin-request.ts
-		/** Deadlines for the plugin's own HTTP routes.
-		*
-		*  A browser opens at most six connections to one origin, and a request that
-		*  never settles holds one of them for the life of the page. A handful of
-		*  those and every plugin route — the projection stream included — stops
-		*  answering, which reads as the whole plugin freezing until the Host is
-		*  restarted. So no plain request is allowed to wait forever: the deadline is
-		*  generous enough that a slow answer still arrives, and short enough that a
-		*  wedged one gives its connection back.
-		*
-		*  Streaming routes (projection, ask, repository setup) are legitimately
-		*  long-lived and carry their own cancellation instead. */
-		/** Reads: the route answers from cache or a short-timeout Git call. */
-		const PLUGIN_READ_TIMEOUT_MS = 3e4;
-		/** Writes: the route may chain several remote Git/gh calls of its own. */
-		const PLUGIN_ACTION_TIMEOUT_MS = 18e4;
-		/** Combine a caller's cancellation with this deadline. */
-		function pluginRequestSignal(timeoutMs, signal) {
-			const timeout = AbortSignal.timeout(timeoutMs);
-			return signal === void 0 ? timeout : AbortSignal.any([signal, timeout]);
+		//#region src/client/ClaudeActiveTasksNode.tsx
+		const EMPTY_TASKS = [];
+		/** Render the task launcher while the owning DSH turn is still open. */
+		function ClaudeActiveTasksNode({ node, useClaudeProjection, t, openTasks }) {
+			const tasks = useClaudeProjection((value) => value.tasks?.tasks ?? EMPTY_TASKS);
+			return /* @__PURE__ */ jsx(ClaudeTaskLauncher, {
+				turn: node.data.turn,
+				tasks,
+				t,
+				openTasks
+			});
 		}
 		//#endregion
 		//#region src/client/jira-api.ts
@@ -4663,68 +5515,75 @@ window.__ModuleLoader__.load({
 		function record$5(value) {
 			return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 		}
-		async function call(path, init) {
-			const response = await fetch(`${CLAUDE_JIRA_PATH}${path}`, {
-				credentials: "same-origin",
-				signal: pluginRequestSignal(PLUGIN_READ_TIMEOUT_MS),
-				...init
-			});
-			const body = record$5(await response.json());
-			if (!response.ok) throw new JiraClientError(typeof body?.message === "string" ? body.message : "Jira is unavailable.", typeof body?.error === "string" ? body.error : void 0);
+		/**
+		* Every Jira failure the panels catch is a `JiraClientError`, whatever the
+		* transport threw: `ClaudeHeroRepositoryControls` branches on `code` to tell
+		* 'not-connected' apart from a real outage, and the settings card renders the
+		* message verbatim.
+		*
+		* The routes answer `{ error, message }`, so `message` is already the sentence
+		* to show. A body carrying only a code — a 405, a bad JSON body — used to read
+		* 'Jira is unavailable.' rather than leaking the code as prose, and it still
+		* does. Transport failures (a starved pool, an elapsed budget, an older Host
+		* without the route) carry their own wording and keep it.
+		*/
+		function jiraFailure(cause) {
+			if (cause instanceof JiraClientError) return cause;
+			if (!(cause instanceof PluginRequestError)) return new JiraClientError(cause instanceof Error ? cause.message : String(cause));
+			return new JiraClientError(cause.message === cause.code ? "Jira is unavailable." : cause.message, cause.code);
+		}
+		function payload(value) {
+			const body = record$5(value);
 			if (body === void 0) throw new JiraClientError("Invalid Jira response.");
 			return body;
 		}
-		function status(body) {
+		function status(value) {
+			const body = payload(value);
 			if (typeof body.connected !== "boolean") throw new JiraClientError("Invalid Jira status response.");
 			return body;
 		}
 		async function loadJiraStatus(signal) {
-			return status(await call("/status", {
-				method: "GET",
-				headers: { accept: "application/json" },
-				...signal === void 0 ? {} : { signal }
-			}));
+			try {
+				return status(await pluginRead(`${CLAUDE_JIRA_PATH}/status`, "remote", signal));
+			} catch (cause) {
+				throw jiraFailure(cause);
+			}
 		}
 		async function connectJira(input) {
-			return status(await call("/connect", {
-				method: "POST",
-				headers: {
-					accept: "application/json",
-					"content-type": "application/json"
-				},
-				body: JSON.stringify(input)
-			}));
+			try {
+				return status(await pluginWrite(`${CLAUDE_JIRA_PATH}/connect`, "remote", void 0, { json: input }));
+			} catch (cause) {
+				throw jiraFailure(cause);
+			}
 		}
 		async function disconnectJira() {
-			await call("/disconnect", {
-				method: "POST",
-				headers: { accept: "application/json" }
-			});
+			try {
+				await pluginWrite(`${CLAUDE_JIRA_PATH}/disconnect`, "remote");
+			} catch (cause) {
+				throw jiraFailure(cause);
+			}
 		}
 		async function searchJiraTickets(query, signal) {
-			const body = await call(`/search?query=${encodeURIComponent(query)}`, {
-				method: "GET",
-				headers: { accept: "application/json" },
-				...signal === void 0 ? {} : { signal }
-			});
-			if (!Array.isArray(body.tickets)) throw new JiraClientError("Invalid Jira search response.");
-			const tickets = [];
-			for (const item of body.tickets) {
-				const ticket = record$5(item);
-				if (ticket === void 0 || typeof ticket.key !== "string" || typeof ticket.summary !== "string" || typeof ticket.url !== "string") continue;
-				tickets.push(ticket);
+			try {
+				const body = payload(await pluginRead(`${CLAUDE_JIRA_PATH}/search`, "remote", signal, { query: { query } }));
+				if (!Array.isArray(body.tickets)) throw new JiraClientError("Invalid Jira search response.");
+				const tickets = [];
+				for (const item of body.tickets) {
+					const ticket = record$5(item);
+					if (ticket === void 0 || typeof ticket.key !== "string" || typeof ticket.summary !== "string" || typeof ticket.url !== "string") continue;
+					tickets.push(ticket);
+				}
+				return tickets;
+			} catch (cause) {
+				throw jiraFailure(cause);
 			}
-			return tickets;
 		}
 		async function assignJiraTicket(key) {
-			await call("/assign", {
-				method: "POST",
-				headers: {
-					accept: "application/json",
-					"content-type": "application/json"
-				},
-				body: JSON.stringify({ key })
-			});
+			try {
+				await pluginWrite(`${CLAUDE_JIRA_PATH}/assign`, "remote", void 0, { json: { key } });
+			} catch (cause) {
+				throw jiraFailure(cause);
+			}
 		}
 		/** Draft seeded into the composer when a session starts from a ticket. */
 		function ticketPrompt(ticket) {
@@ -4760,7 +5619,9 @@ window.__ModuleLoader__.load({
 				if (typeof setting !== "object" || setting === null || Array.isArray(setting)) return false;
 				const item = setting;
 				if (typeof item.key !== "string" || typeof item.value !== "string" || ![
+					"immediate",
 					"new-session",
+					"next-turn",
 					"next-worktree",
 					"restart"
 				].includes(String(item.effect))) return false;
@@ -4775,6 +5636,27 @@ window.__ModuleLoader__.load({
 		function value(status, detail) {
 			return detail === void 0 ? status : `${status} · ${detail}`;
 		}
+		/** The trigger's disclosure chevron.
+		*
+		*  Geometry rather than a character: the ink spans y 6 to 10 in a 16-unit box,
+		*  so it is centred on the box's own centre and the open state's 180-degree
+		*  flip lands exactly where the closed state sat. A text arrowhead carries its
+		*  ink below the centre of the em box, which is why this needed a hand-tuned
+		*  nudge that could only be right in one of the two states. */
+		function SelectChevron() {
+			return /* @__PURE__ */ jsx("svg", {
+				width: "16",
+				height: "16",
+				viewBox: "0 0 16 16",
+				fill: "none",
+				stroke: "currentColor",
+				strokeWidth: "1.8",
+				strokeLinecap: "round",
+				strokeLinejoin: "round",
+				"aria-hidden": "true",
+				children: /* @__PURE__ */ jsx("path", { d: "M4 6l4 4 4-4" })
+			});
+		}
 		function GlobalSettingText({ setting, disabled, onChange }) {
 			const [draft, setDraft] = useState(setting.value);
 			useEffect(() => {
@@ -4805,7 +5687,7 @@ window.__ModuleLoader__.load({
 				}
 			});
 		}
-		function GlobalSettingSelect({ setting, disabled, onChange }) {
+		function GlobalSettingSelect({ setting, disabled, onChange, labelFor = (option) => option.label }) {
 			const [open, setOpen] = useState(false);
 			const [activeIndex, setActiveIndex] = useState(0);
 			const rootRef = useRef(null);
@@ -4843,80 +5725,81 @@ window.__ModuleLoader__.load({
 				onBlur: (event) => {
 					if (!event.currentTarget.contains(event.relatedTarget)) setOpen(false);
 				},
-				children: [/* @__PURE__ */ jsxs("button", {
-					ref: triggerRef,
-					type: "button",
-					"aria-haspopup": "listbox",
-					"aria-expanded": open,
-					"aria-controls": open ? listboxId : void 0,
-					"aria-activedescendant": open ? `${listboxId}-${activeIndex}` : void 0,
-					disabled: disabled || setting.options.length === 0,
-					style: {
-						...settingSelectTrigger,
-						...open ? settingSelectTriggerOpen : {}
-					},
-					onClick: () => {
-						if (open) setOpen(false);
-						else openMenu();
-					},
-					onKeyDown: (event) => {
-						if (event.key === "ArrowDown" || event.key === "ArrowUp") {
-							event.preventDefault();
-							if (!open) openMenu(event.key === "ArrowDown" ? selectedIndex : Math.max(0, setting.options.length - 1));
-							else move(event.key === "ArrowDown" ? 1 : -1);
-						} else if (event.key === "Home" && open) {
-							event.preventDefault();
-							setActiveIndex(0);
-						} else if (event.key === "End" && open) {
-							event.preventDefault();
-							setActiveIndex(Math.max(0, setting.options.length - 1));
-						} else if ((event.key === "Enter" || event.key === " ") && open) {
-							event.preventDefault();
-							choose(activeIndex);
-						} else if (event.key === "Escape" && open) {
-							event.preventDefault();
-							setOpen(false);
-						}
-					},
-					children: [/* @__PURE__ */ jsx("span", {
-						style: settingSelectValue,
-						children: selectedOption?.label ?? setting.value
-					}), /* @__PURE__ */ jsx("span", {
-						"aria-hidden": "true",
-						style: {
-							...settingSelectChevron,
-							...open ? settingSelectChevronOpen : {}
+				children: [
+					/* @__PURE__ */ jsx("style", {
+						"data-dsh-claude-setting-select-styles": true,
+						children: settingSelectCss
+					}),
+					/* @__PURE__ */ jsxs("button", {
+						ref: triggerRef,
+						type: "button",
+						"aria-haspopup": "listbox",
+						"aria-expanded": open,
+						"aria-controls": open ? listboxId : void 0,
+						"aria-activedescendant": open ? `${listboxId}-${activeIndex}` : void 0,
+						disabled: disabled || setting.options.length === 0,
+						className: settingSelectTriggerClass,
+						onClick: () => {
+							if (open) setOpen(false);
+							else openMenu();
 						},
-						children: "⌄"
-					})]
-				}), open ? /* @__PURE__ */ jsx("div", {
-					id: listboxId,
-					role: "listbox",
-					"aria-activedescendant": `${listboxId}-${activeIndex}`,
-					style: settingSelectMenu,
-					children: setting.options.map((option, index) => {
-						const selected = option.value === setting.value;
-						const active = index === activeIndex;
-						return /* @__PURE__ */ jsxs("button", {
-							id: `${listboxId}-${index}`,
-							type: "button",
-							role: "option",
-							"aria-selected": selected,
-							style: {
-								...settingSelectOption,
-								...active ? settingSelectOptionActive : {}
-							},
-							onMouseEnter: () => setActiveIndex(index),
-							onMouseDown: (event) => event.preventDefault(),
-							onClick: () => choose(index),
-							children: [/* @__PURE__ */ jsx("span", {
-								style: settingSelectCheck,
-								"aria-hidden": "true",
-								children: selected ? "✓" : ""
-							}), /* @__PURE__ */ jsx("span", { children: option.label })]
-						}, `${option.source}:${option.value}`);
-					})
-				}) : null]
+						onKeyDown: (event) => {
+							if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+								event.preventDefault();
+								if (!open) openMenu(event.key === "ArrowDown" ? selectedIndex : Math.max(0, setting.options.length - 1));
+								else move(event.key === "ArrowDown" ? 1 : -1);
+							} else if (event.key === "Home" && open) {
+								event.preventDefault();
+								setActiveIndex(0);
+							} else if (event.key === "End" && open) {
+								event.preventDefault();
+								setActiveIndex(Math.max(0, setting.options.length - 1));
+							} else if ((event.key === "Enter" || event.key === " ") && open) {
+								event.preventDefault();
+								choose(activeIndex);
+							} else if (event.key === "Escape" && open) {
+								event.preventDefault();
+								setOpen(false);
+							}
+						},
+						children: [/* @__PURE__ */ jsx("span", {
+							style: settingSelectValue,
+							children: selectedOption === void 0 ? setting.value : labelFor(selectedOption)
+						}), /* @__PURE__ */ jsx("span", {
+							"aria-hidden": "true",
+							className: settingSelectChevronClass,
+							children: /* @__PURE__ */ jsx(SelectChevron, {})
+						})]
+					}),
+					open ? /* @__PURE__ */ jsx("div", {
+						id: listboxId,
+						role: "listbox",
+						"aria-activedescendant": `${listboxId}-${activeIndex}`,
+						style: settingSelectMenu,
+						children: setting.options.map((option, index) => {
+							const selected = option.value === setting.value;
+							const active = index === activeIndex;
+							return /* @__PURE__ */ jsxs("button", {
+								id: `${listboxId}-${index}`,
+								type: "button",
+								role: "option",
+								"aria-selected": selected,
+								style: {
+									...settingSelectOption,
+									...active ? settingSelectOptionActive : {}
+								},
+								onMouseEnter: () => setActiveIndex(index),
+								onMouseDown: (event) => event.preventDefault(),
+								onClick: () => choose(index),
+								children: [/* @__PURE__ */ jsx("span", {
+									style: settingSelectCheck,
+									"aria-hidden": "true",
+									children: selected ? "✓" : ""
+								}), /* @__PURE__ */ jsx("span", { children: labelFor(option) })]
+							}, `${option.source}:${option.value}`);
+						})
+					}) : null
+				]
 			});
 		}
 		/** Fixed windows carry a translated label; server-named model buckets (e.g.
@@ -4927,6 +5810,23 @@ window.__ModuleLoader__.load({
 			"seven_day_opus",
 			"seven_day_sonnet"
 		]);
+		/** The prose mode a settings payload carries, or the default when it carries
+		*  none — an older Host, or a response this Client does not fully understand,
+		*  leaves the palette alone rather than guessing. */
+		function proseModeOf(settings) {
+			const value = settings.find((setting) => setting.key === "prose")?.value;
+			return isClaudeProseMode(value) ? value : DEFAULT_CLAUDE_PROSE_MODE;
+		}
+		/** Settings whose row only makes sense under a particular value of another.
+		*  Filtering here rather than server-side keeps the descriptor list flat: the
+		*  server has no view of what the Client can paint. Fails OPEN — a payload
+		*  missing the setting a row depends on shows the row rather than hiding it,
+		*  so an older Host cannot make a setting unreachable. */
+		function visibleGlobalSettings(settings) {
+			const renderer = settings.find((setting) => setting.key === "renderer");
+			if (renderer === void 0 || renderer.value !== "native") return settings;
+			return settings.filter((setting) => setting.key !== "prose");
+		}
 		/** Per-setting label and the effect note that used to sit as a standalone
 		*  paragraph under the card; it now hangs off the label as a hover hint. */
 		const SETTING_COPY = {
@@ -4934,6 +5834,14 @@ window.__ModuleLoader__.load({
 				label: "outputStyle",
 				hint: "globalSettingsNewSession"
 			},
+			renderer: {
+				label: "renderer",
+				hint: "rendererEffect"
+			},
+			prose: {
+				label: "prose",
+				hint: "proseEffect"
+			},
 			worktreeBranchPrefix: {
 				label: "worktreeBranchPrefix",
 				hint: "worktreeBranchPrefixEffect"
@@ -4947,6 +5855,19 @@ window.__ModuleLoader__.load({
 				hint: "idleTimeoutEffect"
 			}
 		};
+		/** Translated display text for the option vocabularies this plugin owns,
+		*  keyed `<setting>:<option>`. Options discovered on the machine (output style
+		*  names) carry no entry and keep the label the route reported. */
+		const SETTING_OPTION_COPY = {
+			"renderer:plugin": "rendererPlugin",
+			"renderer:native": "rendererNative",
+			"prose:plain": "prosePlain",
+			"prose:enhanced": "proseEnhanced"
+		};
+		function settingOptionLabel(settingKey, option, t) {
+			const key = SETTING_OPTION_COPY[`${settingKey}:${option.value}`];
+			return key === void 0 ? option.label : t(key);
+		}
 		/** '?' badge that reveals a setting's effect note on hover or keyboard focus. */
 		function SettingHint({ text, label }) {
 			return /* @__PURE__ */ jsx(Tooltip, {
@@ -4968,8 +5889,9 @@ window.__ModuleLoader__.load({
 			const report = value;
 			return typeof report.available === "boolean" && typeof report.fetchedAt === "number" && Array.isArray(report.windows) && report.windows.every((entry) => typeof entry === "object" && entry !== null && typeof entry.id === "string");
 		}
-		/** Coarse duration for a reset countdown or a fetch age: minutes below an
-		*  hour, then hours, then days. Never negative — a passed reset reads '0m'. */
+		/** Coarse duration for a reset countdown or the age of a reading: minutes
+		*  below an hour, then hours, then days. Never negative — a passed reset
+		*  reads '0m'. */
 		function durationLabel(milliseconds) {
 			const minutes = Math.max(0, Math.round(milliseconds / 6e4));
 			if (minutes < 60) return `${minutes}m`;
@@ -4999,23 +5921,31 @@ window.__ModuleLoader__.load({
 				})]
 			});
 		}
-		/** Every panel read is a local plugin route, so a request still outstanding
-		*  after this long is a wedged host, not a slow one — and a settings card that
-		*  says so beats one that says "Loading…" forever. */
-		const SETTINGS_REQUEST_TIMEOUT_MS = 2e4;
-		/** Fetch the plan usage report; POST forces the backend to re-read it. */
-		async function loadPlanUsage(refresh) {
-			const response = await fetch(CLAUDE_USAGE_PATH, {
-				method: refresh ? "POST" : "GET",
-				credentials: "same-origin",
-				signal: AbortSignal.timeout(SETTINGS_REQUEST_TIMEOUT_MS),
-				headers: { accept: "application/json" }
+		function cardFailure(cause) {
+			return {
+				detail: cause instanceof Error ? cause.message : String(cause),
+				starved: cause instanceof PluginRequestError && cause.reason === "starved"
+			};
+		}
+		function FailureNotice({ label, failure }) {
+			return /* @__PURE__ */ jsxs("p", {
+				role: "alert",
+				style: {
+					...notice,
+					color: failure.starved ? "var(--dsw-alias-state-warning-primary, #d69e2e)" : "var(--dsw-alias-state-error-primary)"
+				},
+				children: [
+					label,
+					": ",
+					failure.detail
+				]
 			});
-			const payload = await response.json();
-			if (!response.ok) {
-				const message = typeof payload === "object" && payload !== null && "error" in payload && typeof payload.error === "string" ? payload.error : `HTTP ${response.status}`;
-				throw new Error(message);
-			}
+		}
+		/** The plan usage report. A plain read serves the cached reading from memory;
+		*  the refresh spawns a probe process, which is why only it pays the remote
+		*  budget. */
+		async function loadPlanUsage(refresh) {
+			const payload = refresh ? await pluginWrite(CLAUDE_USAGE_PATH, "remote") : await pluginRead(CLAUDE_USAGE_PATH, "fast");
 			if (!isPlanUsageReport(payload)) throw new Error("Invalid plan usage response");
 			return payload;
 		}
@@ -5029,7 +5959,7 @@ window.__ModuleLoader__.load({
 				try {
 					setReport(await load(refresh));
 				} catch (cause) {
-					setError(cause instanceof Error ? cause.message : String(cause));
+					setError(cardFailure(cause));
 				} finally {
 					setBusy(false);
 				}
@@ -5086,17 +6016,9 @@ window.__ModuleLoader__.load({
 						style: notice,
 						children: t("planUsageUpdated", { age: durationLabel(now - report.fetchedAt) })
 					}) : null,
-					error === void 0 ? null : /* @__PURE__ */ jsxs("p", {
-						role: "alert",
-						style: {
-							...notice,
-							color: "var(--dsw-alias-state-error-primary)"
-						},
-						children: [
-							t("planUsageError"),
-							": ",
-							error
-						]
+					error === void 0 ? null : /* @__PURE__ */ jsx(FailureNotice, {
+						label: t("planUsageError"),
+						failure: error
 					})
 				]
 			});
@@ -5120,7 +6042,7 @@ window.__ModuleLoader__.load({
 			useEffect(() => {
 				const controller = new AbortController();
 				loadJiraStatus(controller.signal).then(setJiraStatus, (reason) => {
-					if (!controller.signal.aborted) setJiraError(reason instanceof Error ? reason.message : String(reason));
+					if (!controller.signal.aborted) setJiraError(cardFailure(reason));
 				});
 				return () => {
 					controller.abort();
@@ -5137,7 +6059,7 @@ window.__ModuleLoader__.load({
 					}));
 					setJiraToken("");
 				} catch (cause) {
-					setJiraError(cause instanceof Error ? cause.message : String(cause));
+					setJiraError(cardFailure(cause));
 				} finally {
 					setJiraBusy(false);
 				}
@@ -5149,7 +6071,7 @@ window.__ModuleLoader__.load({
 					await disconnectJira();
 					setJiraStatus({ connected: false });
 				} catch (cause) {
-					setJiraError(cause instanceof Error ? cause.message : String(cause));
+					setJiraError(cardFailure(cause));
 				} finally {
 					setJiraBusy(false);
 				}
@@ -5159,16 +6081,9 @@ window.__ModuleLoader__.load({
 				setError(void 0);
 				setReport(void 0);
 				try {
-					const response = await fetch(CLAUDE_DOCTOR_PATH, {
-						credentials: "same-origin",
-						signal: AbortSignal.timeout(SETTINGS_REQUEST_TIMEOUT_MS),
-						headers: { accept: "application/json" }
-					});
-					const payload = await response.json();
-					if (!response.ok) throw new Error("error" in payload ? payload.error : `HTTP ${response.status}`);
-					setReport(payload);
+					setReport(await pluginRead(CLAUDE_DOCTOR_PATH, "fast"));
 				} catch (cause) {
-					setError(cause instanceof Error ? cause.message : String(cause));
+					setError(cardFailure(cause));
 				} finally {
 					setBusy(false);
 				}
@@ -5180,25 +6095,15 @@ window.__ModuleLoader__.load({
 				setGlobalSettingsBusy(true);
 				setGlobalSettingsError(void 0);
 				try {
-					const response = await fetch(CLAUDE_GLOBAL_SETTINGS_PATH, {
-						method: changes === void 0 ? "GET" : "PATCH",
-						credentials: "same-origin",
-						signal: AbortSignal.timeout(SETTINGS_REQUEST_TIMEOUT_MS),
-						headers: {
-							accept: "application/json",
-							...changes === void 0 ? {} : { "content-type": "application/json" }
-						},
-						...changes === void 0 ? {} : { body: JSON.stringify({ changes }) }
+					const payload = changes === void 0 ? await pluginRead(CLAUDE_GLOBAL_SETTINGS_PATH, "fast") : await pluginWrite(CLAUDE_GLOBAL_SETTINGS_PATH, "fast", void 0, {
+						method: "PATCH",
+						json: { changes }
 					});
-					const payload = await response.json();
-					if (!response.ok) {
-						const message = typeof payload === "object" && payload !== null && "error" in payload && typeof payload.error === "string" ? payload.error : `HTTP ${response.status}`;
-						throw new Error(message);
-					}
 					if (!isGlobalSettingsView(payload)) throw new Error("Invalid global settings response");
 					setGlobalSettings(payload);
+					applyClaudeMarkdownTheme(proseModeOf(payload.settings));
 				} catch (cause) {
-					setGlobalSettingsError(cause instanceof Error ? cause.message : String(cause));
+					setGlobalSettingsError(cardFailure(cause));
 				} finally {
 					setGlobalSettingsBusy(false);
 				}
@@ -5210,20 +6115,11 @@ window.__ModuleLoader__.load({
 				setUpdateBusy(action);
 				setUpdateError(void 0);
 				try {
-					const response = await fetch(action === "check" ? CLAUDE_UPDATE_CHECK_PATH : CLAUDE_UPDATE_PATH, {
-						method: action === "check" ? "GET" : "POST",
-						credentials: "same-origin",
-						headers: { accept: "application/json" }
-					});
-					const payload = await response.json();
-					if (!response.ok) {
-						const message = typeof payload === "object" && payload !== null && "error" in payload && typeof payload.error === "string" ? payload.error : `HTTP ${response.status}`;
-						throw new Error(message);
-					}
+					const payload = action === "check" ? await pluginRead(CLAUDE_UPDATE_CHECK_PATH, "remote") : await pluginWrite(CLAUDE_UPDATE_PATH, "remote");
 					if (!isPluginUpdateStatus(payload)) throw new Error("Invalid update response");
 					setUpdateStatus(payload);
 				} catch (cause) {
-					setUpdateError(cause instanceof Error ? cause.message : String(cause));
+					setUpdateError(cardFailure(cause));
 				} finally {
 					setUpdateBusy(void 0);
 				}
@@ -5293,17 +6189,9 @@ window.__ModuleLoader__.load({
 									children: rowValue
 								}, `${label}-value`)])
 							}),
-							error === void 0 ? null : /* @__PURE__ */ jsxs("p", {
-								role: "alert",
-								style: {
-									...notice,
-									color: "var(--dsw-alias-state-error-primary)"
-								},
-								children: [
-									t("error"),
-									": ",
-									error
-								]
+							error === void 0 ? null : /* @__PURE__ */ jsx(FailureNotice, {
+								label: t("error"),
+								failure: error
 							})
 						]
 					}),
@@ -5324,7 +6212,7 @@ window.__ModuleLoader__.load({
 							globalSettings === void 0 ? /* @__PURE__ */ jsx("p", {
 								style: notice,
 								children: t("globalSettingsLoading")
-							}) : globalSettings.settings.map((setting) => {
+							}) : visibleGlobalSettings(globalSettings.settings).map((setting) => {
 								const copy = SETTING_COPY[setting.key];
 								return /* @__PURE__ */ jsxs("div", {
 									style: diagnosticGrid,
@@ -5337,6 +6225,7 @@ window.__ModuleLoader__.load({
 									}), setting.kind === "select" ? /* @__PURE__ */ jsx(GlobalSettingSelect, {
 										setting,
 										disabled: globalSettingsBusy,
+										labelFor: (option) => settingOptionLabel(setting.key, option, t),
 										onChange: (nextValue) => {
 											requestGlobalSettings({ [setting.key]: nextValue });
 										}
@@ -5349,17 +6238,9 @@ window.__ModuleLoader__.load({
 									})]
 								}, setting.key);
 							}),
-							globalSettingsError === void 0 ? null : /* @__PURE__ */ jsxs("p", {
-								role: "alert",
-								style: {
-									...notice,
-									color: "var(--dsw-alias-state-error-primary)"
-								},
-								children: [
-									t("globalSettingsError"),
-									": ",
-									globalSettingsError
-								]
+							globalSettingsError === void 0 ? null : /* @__PURE__ */ jsx(FailureNotice, {
+								label: t("globalSettingsError"),
+								failure: globalSettingsError
 							})
 						]
 					}),
@@ -5465,17 +6346,9 @@ window.__ModuleLoader__.load({
 									})]
 								})
 							] }),
-							jiraError === void 0 ? null : /* @__PURE__ */ jsxs("p", {
-								role: "alert",
-								style: {
-									...notice,
-									color: "var(--dsw-alias-state-error-primary)"
-								},
-								children: [
-									t("jiraError"),
-									": ",
-									jiraError
-								]
+							jiraError === void 0 ? null : /* @__PURE__ */ jsx(FailureNotice, {
+								label: t("jiraError"),
+								failure: jiraError
 							})
 						]
 					}),
@@ -5536,17 +6409,9 @@ window.__ModuleLoader__.load({
 								style: notice,
 								children: t("restartRequired")
 							}),
-							updateError === void 0 ? null : /* @__PURE__ */ jsxs("p", {
-								role: "alert",
-								style: {
-									...notice,
-									color: "var(--dsw-alias-state-error-primary)"
-								},
-								children: [
-									t("updateError"),
-									": ",
-									updateError
-								]
+							updateError === void 0 ? null : /* @__PURE__ */ jsx(FailureNotice, {
+								label: t("updateError"),
+								failure: updateError
 							}),
 							/* @__PURE__ */ jsxs("div", {
 								style: settingsActions,
@@ -5598,14 +6463,14 @@ window.__ModuleLoader__.load({
 		function record$4(value) {
 			return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 		}
-		async function response$1(pending) {
-			const result = await pending;
-			const body = await result.json();
-			if (!result.ok) {
-				const error = record$4(body);
-				throw new RepositoryActionClientError(typeof error?.message === "string" ? error.message : "Repository action failed.", typeof error?.error === "string" ? error.error : void 0, typeof error?.commit === "string" ? error.commit : void 0);
-			}
-			return body;
+		/** The dialog branches on `code`, so a route refusal keeps arriving as this
+		*  class rather than as the transport's own error.
+		*
+		*  `commit` cannot be carried across: the transport forwards a failed route's
+		*  message and error code, not the rest of its body, so a commit that survived
+		*  a failed push no longer reaches the dialog that offers its hash. */
+		function actionError(error) {
+			return error instanceof PluginRequestError ? new RepositoryActionClientError(error.message, error.code) : error;
 		}
 		function preview(value) {
 			const input = record$4(value);
@@ -5625,42 +6490,35 @@ window.__ModuleLoader__.load({
 			if (input === void 0 || typeof input.commit !== "string" || typeof input.pushed !== "boolean" || input.pullRequestUrl !== void 0 && typeof input.pullRequestUrl !== "string" || input.conflicts !== void 0 && (!Array.isArray(input.conflicts) || input.conflicts.some((item) => typeof item !== "string"))) throw new Error("Invalid repository action result.");
 			return input;
 		}
-		function endpoint(path, sessionId) {
-			return `${CLAUDE_REPOSITORY_ACTION_PATH}${path}?sessionId=${encodeURIComponent(sessionId)}`;
-		}
+		/** The preview only chains local Git; everything that writes may reach a remote. */
 		async function loadRepositoryActionPreview(sessionId, signal) {
-			return preview(await response$1(fetch(endpoint("/preview", sessionId), {
-				method: "GET",
-				credentials: "same-origin",
-				headers: { accept: "application/json" },
-				signal: pluginRequestSignal(PLUGIN_READ_TIMEOUT_MS, signal)
-			})));
+			try {
+				return preview(await pluginRead(`${CLAUDE_REPOSITORY_ACTION_PATH}/preview`, "git", signal, { query: { sessionId } }));
+			} catch (error) {
+				throw actionError(error);
+			}
 		}
 		async function generateCommitMessage(sessionId, fingerprint, signal) {
-			const value = record$4(await response$1(fetch(endpoint("/message", sessionId), {
-				method: "POST",
-				credentials: "same-origin",
-				headers: {
-					accept: "application/json",
-					"content-type": "application/json"
-				},
-				body: JSON.stringify({ fingerprint }),
-				signal: pluginRequestSignal(PLUGIN_ACTION_TIMEOUT_MS, signal)
-			})));
-			if (typeof value?.message !== "string") throw new Error("Invalid generated commit message.");
-			return value.message;
-		}
-		function executeRepositoryAction(sessionId, request) {
-			return response$1(fetch(endpoint("", sessionId), {
-				method: "POST",
-				credentials: "same-origin",
-				headers: {
-					accept: "application/json",
-					"content-type": "application/json"
-				},
-				body: JSON.stringify(request),
-				signal: pluginRequestSignal(PLUGIN_ACTION_TIMEOUT_MS)
-			})).then(result);
+			try {
+				const value = record$4(await pluginWrite(`${CLAUDE_REPOSITORY_ACTION_PATH}/message`, "remote", signal, {
+					query: { sessionId },
+					json: { fingerprint }
+				}));
+				if (typeof value?.message !== "string") throw new Error("Invalid generated commit message.");
+				return value.message;
+			} catch (error) {
+				throw actionError(error);
+			}
+		}
+		async function executeRepositoryAction(sessionId, request) {
+			try {
+				return result(await pluginWrite(CLAUDE_REPOSITORY_ACTION_PATH, "remote", void 0, {
+					query: { sessionId },
+					json: request
+				}));
+			} catch (error) {
+				throw actionError(error);
+			}
 		}
 		//#endregion
 		//#region src/client/action-toast.tsx
@@ -5722,130 +6580,79 @@ window.__ModuleLoader__.load({
 			if (event?.type === "error" && typeof event.message === "string") throw new Error(event.message);
 			throw new Error("Invalid repository setup progress response.");
 		}
-		async function response(pending) {
-			const result = await pending;
-			const body = await result.json();
-			if (!result.ok) {
-				const error = body;
-				throw new Error(error.message ?? error.error ?? "Repository setup failed.");
-			}
-			return body;
-		}
-		/** A wedged host must surface as an error; the hero has no other way out of its loading state. */
-		const BRANCH_LOAD_TIMEOUT_MS = 15e3;
 		function loadRepositoryBranches(cwd, signal) {
-			return response(fetch(`${CLAUDE_REPOSITORY_SETUP_PATH}/branches?cwd=${encodeURIComponent(cwd)}`, {
-				method: "GET",
-				credentials: "same-origin",
-				headers: { accept: "application/json" },
-				signal: pluginRequestSignal(BRANCH_LOAD_TIMEOUT_MS, signal)
-			}));
+			return pluginRead(`${CLAUDE_REPOSITORY_SETUP_PATH}/branches`, "git", signal, { query: { cwd } });
 		}
 		/** Pull remote refs down first, then list: a POST because `--prune` rewrites
-		*  this checkout's remote-tracking refs, and on the action deadline because the
+		*  this checkout's remote-tracking refs, and on the remote budget because the
 		*  host's own `git fetch` runs for up to a minute. */
 		async function refreshRepositoryBranches(cwd, signal) {
-			const result = await fetch(`${CLAUDE_REPOSITORY_SETUP_PATH}/branches/refresh`, {
-				method: "POST",
-				credentials: "same-origin",
-				headers: {
-					accept: "application/json",
-					"content-type": "application/json"
-				},
-				signal: pluginRequestSignal(PLUGIN_ACTION_TIMEOUT_MS, signal),
-				body: JSON.stringify({ cwd })
-			});
-			if (result.status === 404) throw new Error("route-missing");
-			return response(Promise.resolve(result));
+			try {
+				return await pluginWrite(`${CLAUDE_REPOSITORY_SETUP_PATH}/branches/refresh`, "remote", signal, { json: { cwd } });
+			} catch (error) {
+				if (error instanceof PluginRequestError && error.reason === "route-missing") throw new Error("route-missing");
+				throw error;
+			}
 		}
 		async function prepareRepository(cwd, branch, worktree, branchName, onProgress = () => {}) {
-			const result = await fetch(CLAUDE_REPOSITORY_SETUP_PATH, {
-				method: "POST",
-				credentials: "same-origin",
-				headers: {
-					accept: "application/x-ndjson",
-					"content-type": "application/json"
-				},
-				body: JSON.stringify({
-					cwd,
-					branch,
-					worktree,
-					...branchName === void 0 ? {} : { branchName }
-				})
-			});
-			if (!result.ok) {
-				const body = await result.json();
-				throw new Error(body.message ?? body.error ?? "Repository setup failed.");
-			}
-			if (result.body === null) throw new Error("Repository setup progress stream is unavailable.");
-			const reader = result.body.getReader();
-			const decoder = new TextDecoder();
-			let buffer = "";
-			let completed;
-			while (true) {
-				const chunk = await reader.read();
-				buffer += decoder.decode(chunk.value, { stream: !chunk.done });
-				const lines = buffer.split("\n");
-				buffer = lines.pop() ?? "";
-				for (const line of lines) {
-					if (line.trim().length === 0) continue;
-					const value = parseRepositorySetupEvent(line, onProgress);
+			const carrier = new AbortController();
+			try {
+				const reader = await pluginNdjson(CLAUDE_REPOSITORY_SETUP_PATH, carrier.signal, {
+					method: "POST",
+					json: {
+						cwd,
+						branch,
+						worktree,
+						...branchName === void 0 ? {} : { branchName }
+					}
+				});
+				const decoder = new TextDecoder();
+				let buffer = "";
+				let completed;
+				while (true) {
+					const chunk = await reader.read();
+					buffer += decoder.decode(chunk.value, { stream: !chunk.done });
+					const lines = buffer.split("\n");
+					buffer = lines.pop() ?? "";
+					for (const line of lines) {
+						if (line.trim().length === 0) continue;
+						const value = parseRepositorySetupEvent(line, onProgress);
+						if (value !== void 0) completed = value;
+					}
+					if (chunk.done) break;
+				}
+				if (buffer.trim().length > 0) {
+					const value = parseRepositorySetupEvent(buffer, onProgress);
 					if (value !== void 0) completed = value;
 				}
-				if (chunk.done) break;
+				if (completed === void 0) throw new Error("Repository setup progress ended before completion.");
+				return completed;
+			} finally {
+				carrier.abort();
 			}
-			if (buffer.trim().length > 0) {
-				const value = parseRepositorySetupEvent(buffer, onProgress);
-				if (value !== void 0) completed = value;
-			}
-			if (completed === void 0) throw new Error("Repository setup progress ended before completion.");
-			return completed;
 		}
-		/** Bookkeeping, not a gate: a wedged host must fail this instead of hanging on
-		*  a connection the rest of the flow is waiting behind. */
-		const LEASE_BIND_TIMEOUT_MS = 1e4;
 		async function bindRepositoryLease(leaseId, sessionId) {
-			await response(fetch(`${CLAUDE_REPOSITORY_SETUP_PATH}/bind`, {
-				method: "POST",
-				credentials: "same-origin",
-				signal: pluginRequestSignal(LEASE_BIND_TIMEOUT_MS),
-				headers: {
-					accept: "application/json",
-					"content-type": "application/json"
-				},
-				body: JSON.stringify({
-					leaseId,
-					sessionId
-				})
-			}));
+			await pluginWrite(`${CLAUDE_REPOSITORY_SETUP_PATH}/bind`, "remote", void 0, { json: {
+				leaseId,
+				sessionId
+			} });
 		}
 		async function cleanupMergedRepository(path, baseBranch) {
-			const body = await response(fetch(`${CLAUDE_REPOSITORY_SETUP_PATH}/cleanup`, {
-				signal: pluginRequestSignal(PLUGIN_ACTION_TIMEOUT_MS),
-				method: "POST",
-				credentials: "same-origin",
-				headers: {
-					accept: "application/json",
-					"content-type": "application/json"
-				},
-				body: JSON.stringify({
-					path,
-					baseBranch
-				})
-			}));
+			const body = await pluginWrite(`${CLAUDE_REPOSITORY_SETUP_PATH}/cleanup`, "remote", void 0, { json: {
+				path,
+				baseBranch
+			} });
 			if (body.mode !== "worktree" && body.mode !== "checkout" || typeof body.root !== "string" || typeof body.branch !== "string") throw new Error("Invalid repository cleanup response.");
 			return body;
 		}
 		/** Lines [from, to] of a working-tree file plus its total line count, for expanding unmodified diff context. */
 		async function loadRepositoryFileLines(cwd, path, from, to, signal) {
-			const query = `cwd=${encodeURIComponent(cwd)}&path=${encodeURIComponent(path)}&from=${from}&to=${to}`;
-			const body = await response(fetch(`${CLAUDE_REPOSITORY_FILE_PATH}?${query}`, {
-				signal: pluginRequestSignal(PLUGIN_READ_TIMEOUT_MS),
-				method: "GET",
-				credentials: "same-origin",
-				headers: { accept: "application/json" },
-				...signal === void 0 ? {} : { signal }
-			}));
+			const body = await pluginRead(CLAUDE_REPOSITORY_FILE_PATH, "git", signal, { query: {
+				cwd,
+				path,
+				from: String(from),
+				to: String(to)
+			} });
 			if (!Array.isArray(body.lines) || typeof body.total !== "number") throw new Error("Invalid repository file response.");
 			return {
 				lines: body.lines.map(String),
@@ -5853,13 +6660,7 @@ window.__ModuleLoader__.load({
 			};
 		}
 		async function loadRepositoryStatusFor(cwd, signal) {
-			const body = await response(fetch(`${CLAUDE_REPOSITORY_STATUS_PATH}?cwd=${encodeURIComponent(cwd)}`, {
-				signal: pluginRequestSignal(PLUGIN_READ_TIMEOUT_MS),
-				method: "GET",
-				credentials: "same-origin",
-				headers: { accept: "application/json" },
-				...signal === void 0 ? {} : { signal }
-			}));
+			const body = await pluginRead(CLAUDE_REPOSITORY_STATUS_PATH, "git", signal, { query: { cwd } });
 			if (typeof body.status !== "string" || typeof body.cwd !== "string") throw new Error("Invalid repository status response.");
 			return body;
 		}
@@ -5896,34 +6697,27 @@ window.__ModuleLoader__.load({
 		function record$2(value) {
 			return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 		}
-		function feedbackUrl(path, sessionId, pullNumber, extra = "") {
-			return `${CLAUDE_REPOSITORY_FEEDBACK_PATH}${path}?sessionId=${encodeURIComponent(sessionId)}&number=${pullNumber}${extra}`;
+		function feedbackQuery(sessionId, pullNumber, extra) {
+			return {
+				sessionId,
+				number: String(pullNumber),
+				...extra
+			};
 		}
-		async function answer(response) {
-			const body = record$2(await response.json());
-			if (!response.ok) throw new Error(typeof body?.message === "string" ? body.message : "Pull request feedback is unavailable.");
+		function answer(value) {
+			const body = record$2(value);
 			if (body === void 0) throw new Error("Invalid pull request feedback response.");
 			return body;
 		}
-		async function loadJson(path, sessionId, pullNumber, signal, extra = "") {
-			return answer(await fetch(feedbackUrl(path, sessionId, pullNumber, extra), {
-				method: "GET",
-				credentials: "same-origin",
-				headers: { accept: "application/json" },
-				signal: pluginRequestSignal(PLUGIN_READ_TIMEOUT_MS, signal)
-			}));
+		/** Every arm of this route shells out to `gh`, so reads and writes alike take
+		*  the remote budget. */
+		async function loadJson(path, sessionId, pullNumber, signal, extra) {
+			return answer(await pluginRead(`${CLAUDE_REPOSITORY_FEEDBACK_PATH}${path}`, "remote", signal, { query: feedbackQuery(sessionId, pullNumber, extra) }));
 		}
-		/** Writes reach GitHub through `gh`, so they get the action deadline. */
 		async function postJson(path, sessionId, pullNumber, input) {
-			return answer(await fetch(feedbackUrl(path, sessionId, pullNumber), {
-				method: "POST",
-				credentials: "same-origin",
-				headers: {
-					accept: "application/json",
-					"content-type": "application/json"
-				},
-				signal: pluginRequestSignal(PLUGIN_ACTION_TIMEOUT_MS),
-				body: JSON.stringify(input)
+			return answer(await pluginWrite(`${CLAUDE_REPOSITORY_FEEDBACK_PATH}${path}`, "remote", void 0, {
+				query: feedbackQuery(sessionId, pullNumber),
+				json: input
 			}));
 		}
 		function reviewComment(value) {
@@ -5972,7 +6766,7 @@ window.__ModuleLoader__.load({
 		}
 		/** Logins GitHub would notify, for the reply composer's `@` completion. */
 		async function loadMentionableUsers(sessionId, pullNumber, query, signal) {
-			const body = await loadJson("/mentionables", sessionId, pullNumber, signal, `&q=${encodeURIComponent(query)}`);
+			const body = await loadJson("/mentionables", sessionId, pullNumber, signal, { q: query });
 			if (!Array.isArray(body.users)) return [];
 			const users = [];
 			for (const item of body.users) {
@@ -7128,22 +7922,10 @@ window.__ModuleLoader__.load({
 			return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 		}
 		async function post(path, sessionId, body) {
-			const response = await fetch(`${CLAUDE_REVIEW_COMMENT_PATH}${path}?sessionId=${encodeURIComponent(sessionId)}`, {
-				method: "POST",
-				credentials: "same-origin",
-				headers: {
-					accept: "application/json",
-					"content-type": "application/json"
-				},
-				body: JSON.stringify(body),
-				signal: pluginRequestSignal(PLUGIN_READ_TIMEOUT_MS)
+			return await pluginWrite(`${CLAUDE_REVIEW_COMMENT_PATH}${path}`, "fast", void 0, {
+				query: { sessionId },
+				json: body
 			});
-			const value = await response.json();
-			if (!response.ok) {
-				const error = record$1(value);
-				throw new Error(typeof error?.message === "string" ? error.message : "Review comment request failed.");
-			}
-			return value;
 		}
 		async function addReviewComment(sessionId, comment) {
 			const created = record$1(record$1(await post("", sessionId, comment))?.comment);
@@ -13302,6 +14084,16 @@ window.__ModuleLoader__.load({
 			});
 		}
 		//#endregion
+		//#region src/client/session-preset.ts
+		/**
+		* Resolve one row's preset id, newest seat first.
+		* @param row - a session-list row, or undefined when the id is not listed.
+		* @returns the preset id, or undefined when neither source carries one.
+		*/
+		function sessionRowPreset(row) {
+			return row?.agentPreset ?? row?.projectionValues?.agentPreset;
+		}
+		//#endregion
 		//#region src/client/ClaudePullRequestsPanel.tsx
 		const NO_WORKSPACE_STATE = {};
 		const NO_WORKSPACES = {
@@ -13324,7 +14116,7 @@ window.__ModuleLoader__.load({
 		function claudeSessionRows(state, archivedSessionIds = []) {
 			const rows = state.ids === void 0 ? Object.values(state.byId) : state.ids.map((id) => state.byId[id]);
 			const archived = new Set(archivedSessionIds);
-			return rows.filter((row) => row !== void 0 && row.agentPreset === "claude" && row.blank !== true && row.origin !== "subagent" && !archived.has(row.id) && typeof row.cwd === "string").sort((left, right) => Number(right.running === true) - Number(left.running === true) || (left.displayTitle ?? left.id).localeCompare(right.displayTitle ?? right.id));
+			return rows.filter((row) => row !== void 0 && sessionRowPreset(row) === "claude" && row.blank !== true && row.origin !== "subagent" && !archived.has(row.id) && typeof row.cwd === "string").sort((left, right) => Number(right.running === true) - Number(left.running === true) || (left.displayTitle ?? left.id).localeCompare(right.displayTitle ?? right.id));
 		}
 		function Badge({ label, tone = "neutral" }) {
 			const toneStyle = tone === "success" ? repositoryItemSuccess : tone === "warning" ? repositoryItemWarning : tone === "error" ? repositoryItemError : tone === "merged" ? { color: "#a78bfa" } : {};
@@ -13519,56 +14311,64 @@ window.__ModuleLoader__.load({
 			};
 			throw new Error("Invalid ask stream event.");
 		}
+		async function openAnswer(sessionId, request, cancel) {
+			try {
+				return await pluginNdjson(CLAUDE_ASK_PATH, cancel, {
+					method: "POST",
+					query: { sessionId },
+					json: request
+				});
+			} catch (error) {
+				if (error instanceof PluginRequestError && error.reason === "http") throw new Error("The question could not be sent.");
+				throw error;
+			}
+		}
 		/** Stream an answer about selected reply text; resolves when the answer completes. */
 		async function askAboutSelection(sessionId, request, onProgress, signal) {
-			const response = await fetch(`${CLAUDE_ASK_PATH}?sessionId=${encodeURIComponent(sessionId)}`, {
-				method: "POST",
-				credentials: "same-origin",
-				headers: {
-					accept: "application/x-ndjson",
-					"content-type": "application/json"
-				},
-				body: JSON.stringify(request),
-				...signal === void 0 ? {} : { signal }
-			});
-			if (!response.ok) {
-				const body = record(await response.json().catch(() => void 0));
-				throw new Error(typeof body?.message === "string" ? body.message : "The question could not be sent.");
-			}
-			if (response.body === null) throw new Error("The answer stream is unavailable.");
-			const reader = response.body.getReader();
-			const decoder = new TextDecoder();
-			let buffer = "";
-			let finished = false;
-			const handle = (line) => {
-				if (line.trim().length === 0) return;
-				const event = parseAskEvent(line);
-				if (event.type === "delta") onProgress({
-					type: "text",
-					text: event.text
-				});
-				else if (event.type === "thinking") onProgress({
-					type: "thinking",
-					text: event.text
-				});
-				else if (event.type === "status") onProgress({
-					type: "status",
-					text: event.text
-				});
-				else if (event.type === "tool") onProgress(event);
-				else if (event.type === "done") finished = true;
-				else throw new Error(event.message);
+			const carrier = new AbortController();
+			const stop = () => {
+				carrier.abort();
 			};
-			while (true) {
-				const chunk = await reader.read();
-				buffer += decoder.decode(chunk.value, { stream: !chunk.done });
-				const lines = buffer.split("\n");
-				buffer = lines.pop() ?? "";
-				for (const line of lines) handle(line);
-				if (chunk.done) break;
+			signal?.addEventListener("abort", stop, { once: true });
+			if (signal?.aborted === true) carrier.abort();
+			try {
+				const reader = await openAnswer(sessionId, request, carrier.signal);
+				const decoder = new TextDecoder();
+				let buffer = "";
+				let finished = false;
+				const handle = (line) => {
+					if (line.trim().length === 0) return;
+					const event = parseAskEvent(line);
+					if (event.type === "delta") onProgress({
+						type: "text",
+						text: event.text
+					});
+					else if (event.type === "thinking") onProgress({
+						type: "thinking",
+						text: event.text
+					});
+					else if (event.type === "status") onProgress({
+						type: "status",
+						text: event.text
+					});
+					else if (event.type === "tool") onProgress(event);
+					else if (event.type === "done") finished = true;
+					else throw new Error(event.message);
+				};
+				while (true) {
+					const chunk = await reader.read();
+					buffer += decoder.decode(chunk.value, { stream: !chunk.done });
+					const lines = buffer.split("\n");
+					buffer = lines.pop() ?? "";
+					for (const line of lines) handle(line);
+					if (chunk.done) break;
+				}
+				handle(buffer);
+				if (!finished) throw new Error("The answer ended unexpectedly.");
+			} finally {
+				signal?.removeEventListener("abort", stop);
+				carrier.abort();
 			}
-			handle(buffer);
-			if (!finished) throw new Error("The answer ended unexpectedly.");
 		}
 		//#endregion
 		//#region src/client/ClaudeSelectionAsk.tsx
@@ -14124,13 +14924,12 @@ window.__ModuleLoader__.load({
 			});
 			return stop;
 		}
+		/** A beacon rather than a request: a finding is dropped when the connection
+		*  budget is spent, because the channel that reports the plugin's own failures
+		*  must never be the traffic that causes them — and must never queue behind
+		*  them either. */
 		function postToHost(report) {
-			fetch(CLAUDE_CLIENT_DIAGNOSTICS_PATH, {
-				method: "POST",
-				credentials: "same-origin",
-				headers: { "content-type": "application/json" },
-				body: JSON.stringify(report)
-			}).catch(() => {});
+			pluginBeacon(CLAUDE_CLIENT_DIAGNOSTICS_PATH, report);
 		}
 		/** Renderer-side findings reach the Host log through here.
 		*
@@ -14217,23 +15016,15 @@ window.__ModuleLoader__.load({
 		/** Drop one user message and everything after it: the rows are hidden from
 		*  this session's transcript and Claude resumes before that turn. */
 		async function rewindSession(sessionId, seq) {
-			const result = await fetch(CLAUDE_REWIND_PATH, {
-				method: "POST",
-				credentials: "same-origin",
-				signal: pluginRequestSignal(PLUGIN_READ_TIMEOUT_MS),
-				headers: {
-					"content-type": "application/json",
-					accept: "application/json"
-				},
-				body: JSON.stringify({
+			try {
+				await pluginWrite(CLAUDE_REWIND_PATH, "fast", void 0, { json: {
 					sessionId,
 					seq
-				})
-			});
-			if (result.ok) return;
-			if (result.status === 404) throw new Error("route-missing");
-			const body = await result.json().catch(() => void 0);
-			throw new Error(typeof body?.error === "string" ? body.error : `http-${result.status}`);
+				} });
+			} catch (error) {
+				if (!(error instanceof PluginRequestError)) throw error;
+				throw new Error(error.code ?? error.reason);
+			}
 		}
 		//#endregion
 		//#region src/client/ClaudeRewind.tsx
@@ -15449,15 +16240,10 @@ window.__ModuleLoader__.load({
 		//#region src/client/editor-open-api.ts
 		/** Launch the session's project in a desktop editor on the host machine. */
 		async function openProjectInEditor(sessionId, editor) {
-			const result = await fetch(`${CLAUDE_EDITOR_OPEN_PATH}?sessionId=${encodeURIComponent(sessionId)}&editor=${encodeURIComponent(editor)}`, {
-				method: "POST",
-				credentials: "same-origin",
-				signal: pluginRequestSignal(PLUGIN_READ_TIMEOUT_MS),
-				headers: { accept: "application/json" }
-			});
-			if (result.ok) return;
-			const body = await result.json().catch(() => void 0);
-			throw new Error(typeof body?.message === "string" ? body.message : "The editor could not be launched.");
+			await pluginWrite(CLAUDE_EDITOR_OPEN_PATH, "fast", void 0, { query: {
+				sessionId,
+				editor
+			} });
 		}
 		//#endregion
 		//#region src/client/ClaudeSessionMenu.tsx
@@ -15729,7 +16515,7 @@ window.__ModuleLoader__.load({
 			document.head.appendChild(element);
 		}
 		function ClaudeAgentPresetLabel({ t, hostT, roster, sessionId, useSessions }) {
-			const preset = useSessions((state) => state.byId[sessionId]?.agentPreset);
+			const preset = useSessions((state) => sessionRowPreset(state.byId[sessionId]));
 			const rows = useSyncExternalStore(roster.subscribe, roster.getSnapshot, roster.getSnapshot);
 			const { load } = roster;
 			useEffect(() => {
@@ -16162,6 +16948,14 @@ window.__ModuleLoader__.load({
 			globalSettingsNewSession: "修改仅对新建 Claude 会话生效。",
 			globalSettingsError: "全局设置保存失败",
 			outputStyle: "Output Style",
+			renderer: "AI 输出渲染器",
+			rendererPlugin: "插件渲染器",
+			rendererNative: "DSH 原生渲染器",
+			rendererEffect: "插件渲染器沿用本插件自带的转录视图：交错的正文、成组的工具卡片与活动行。DSH 原生渲染器改由 DSH 自身绘制：正文作为普通助手文本块，思考作为推理块，Claude 的顶层工具会镜像成原生工具卡片。修改从下一个回合起生效；已经产生的回合仍按记录时的渲染器显示，不会重绘。",
+			prose: "Markdown 彩色高亮",
+			prosePlain: "关闭",
+			proseEnhanced: "开启",
+			proseEffect: "开启后，正文的标题、加粗、斜体、行内代码、列表符号、引用与链接各自着色，代码块换成深色描边底。这会覆盖本插件默认对齐 Claude 桌面版的配色。仅在使用插件渲染器时有效，改动立即生效，无需等待下一回合。",
 			worktreeBranchPrefix: "Worktree 分支前缀",
 			worktreeBranchPrefixEffect: "分支前缀修改会应用于之后自动创建的 Worktree 分支；显式指定的完整分支名不会被修改。",
 			maxProcessesSetting: "Claude 进程上限",
@@ -16474,7 +17268,12 @@ window.__ModuleLoader__.load({
 			rewindSubmitting: "回退中…",
 			rewindFailed: "回退失败（{code}）。",
 			rewindBusy: "这个会话正在运行，请等本轮结束后再回退。",
-			rewindStale: "宿主进程里的插件还是旧版本（没有回退接口）。重启 DSH 后再试。"
+			rewindStale: "宿主进程里的插件还是旧版本（没有回退接口）。重启 DSH 后再试。",
+			turnUsage: "本回合用量",
+			turnUsageTokens: "{count} tok",
+			turnUsageCache: "缓存命中 {percent}%",
+			turnUsageTtft: "首字 {duration}",
+			turnUsageCost: "累计 ${cost}"
 		};
 		const en = {
 			nav: "Claude Code",
@@ -16522,6 +17321,14 @@ window.__ModuleLoader__.load({
 			globalSettingsNewSession: "Changes apply only to new Claude sessions.",
 			globalSettingsError: "Global settings save failed",
 			outputStyle: "Output Style",
+			renderer: "AI output renderer",
+			rendererPlugin: "Plugin renderer",
+			rendererNative: "DSH native renderer",
+			rendererEffect: "The plugin renderer keeps this package’s own transcript: interleaved prose, grouped tool cards, and activity rows. The DSH native renderer hands the same turn to DSH itself — prose as ordinary assistant text blocks, thinking as reasoning blocks, and root Claude tools mirrored into native tool cards. A change applies from the next turn; turns already recorded keep the renderer they were recorded with and are not redrawn.",
+			prose: "Markdown colour highlighting",
+			prosePlain: "Off",
+			proseEnhanced: "On",
+			proseEffect: "Gives headings, bold, italics, inline code, list markers, quotes and links their own colours, and paints the code block on a dark outlined surface. This overrides the Claude-desktop palette this package matches by default. Only applies under the plugin renderer, and takes effect immediately rather than on the next turn.",
 			worktreeBranchPrefix: "Worktree branch prefix",
 			worktreeBranchPrefixEffect: "Prefix changes apply to subsequently generated Worktree branches. Explicit full branch names remain unchanged.",
 			maxProcessesSetting: "Claude process limit",
@@ -16834,7 +17641,12 @@ window.__ModuleLoader__.load({
 			rewindSubmitting: "Rewinding…",
 			rewindFailed: "The rewind failed ({code}).",
 			rewindBusy: "This session is running; wait for the turn to finish before rewinding.",
-			rewindStale: "The Host process is still running the previous plugin build, which has no rewind route. Restart DSH and try again."
+			rewindStale: "The Host process is still running the previous plugin build, which has no rewind route. Restart DSH and try again.",
+			turnUsage: "Turn usage",
+			turnUsageTokens: "{count} tok",
+			turnUsageCache: "Cache hit {percent}%",
+			turnUsageTtft: "TTFT {duration}",
+			turnUsageCost: "${cost} total"
 		};
 		//#endregion
 		//#region src/client/index.tsx
@@ -16884,7 +17696,12 @@ window.__ModuleLoader__.load({
 			}), "dsh-claude: client copy");
 			const t = ctx.locale.bind(namespace);
 			ctx.effect(() => restyleHostChrome(), "dsh-claude: Host chrome restyling");
-			const projections = new ClaudeProjectionStore();
+			pluginRead(CLAUDE_GLOBAL_SETTINGS_PATH, "fast").then((payload) => {
+				if (isGlobalSettingsView(payload)) applyClaudeMarkdownTheme(proseModeOf(payload.settings));
+			}).catch(() => {});
+			const projections = new ClaudeProjectionStore({ report: (kind, detail) => {
+				diagnostics.report(kind, detail);
+			} });
 			ctx.effect(() => ctx.inputTriggers.registerSource(createClaudeCommandSource(ctx, projections)), "dsh-claude: Claude slash source");
 			const sessions = ctx.get("sessions");
 			const workspaces = ctx.get("workspaces");