@norman-else/dsh-claude 0.1.34 → 0.1.35

package/lib/client.js

@@ -27,6 +27,9 @@ 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";
+		}
 		//#endregion
 		//#region src/client/task-projection.ts
 		/** Tasks UI is reserved for detached work and genuine Claude subagents. */
@@ -239,7 +242,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 +270,20 @@ window.__ModuleLoader__.load({
 			}
 			return failed ? `Failed to ${failedAction}` : completed;
 		}
+		/** 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();
@@ -674,30 +689,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 +755,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,
@@ -3736,6 +3777,203 @@ window.__ModuleLoader__.load({
 			});
 		}
 		//#endregion
+		//#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";
+		/** 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("");
+		let injected = false;
+		/** Attach the sheet once per page. */
+		function ensureClaudeMarkdownTheme() {
+			if (injected || typeof document === "undefined") return;
+			injected = true;
+			const element = document.createElement("style");
+			element.dataset.dshClaudeMarkdownTheme = "";
+			element.textContent = CLAUDE_MARKDOWN_THEME_CSS;
+			document.head.appendChild(element);
+		}
+		//#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. */
@@ -3755,18 +3993,298 @@ window.__ModuleLoader__.load({
 		*  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, {
+			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 })
 			});
 		}
 		//#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);
 		}
 		//#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 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 withQuery(path, query) {
+			if (query === void 0) return path;
+			const encoded = new URLSearchParams(query).toString();
+			return encoded.length === 0 ? path : `${path}?${encoded}`;
+		}
+		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));
+		}
+		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);
+			}
+		}
+		/** 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()}`
+			});
+		}
+		let writeId = 0;
+		function nextWriteId() {
+			writeId += 1;
+			return writeId;
+		}
+		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);
+			}
+		}
+		/** 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
 		const EMPTY_CLAUDE_PROJECTION = {
 			schemaVersion: 1,
@@ -3776,6 +4294,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 +4424,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 +4449,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 +4547,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 +4564,8 @@ window.__ModuleLoader__.load({
 						step,
 						ordinal,
 						kind: "text",
-						phase: "updated"
+						phase: "updated",
+						...isClaudeRenderMode(renderer) ? { renderer } : {}
 					},
 					text: fullText
 				};
@@ -4053,6 +4585,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 +4607,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 +4629,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,87 +4666,185 @@ 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
@@ -4628,29 +5278,6 @@ window.__ModuleLoader__.load({
 			});
 		}
 		//#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]);
-		}
-		//#endregion
 		//#region src/client/jira-api.ts
 		var JiraClientError = class extends Error {
 			code;
@@ -4663,68 +5290,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) {
@@ -4761,6 +5395,7 @@ window.__ModuleLoader__.load({
 				const item = setting;
 				if (typeof item.key !== "string" || typeof item.value !== "string" || ![
 					"new-session",
+					"next-turn",
 					"next-worktree",
 					"restart"
 				].includes(String(item.effect))) return false;
@@ -4775,6 +5410,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 +5461,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 +5499,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.
@@ -4934,6 +5591,10 @@ window.__ModuleLoader__.load({
 				label: "outputStyle",
 				hint: "globalSettingsNewSession"
 			},
+			renderer: {
+				label: "renderer",
+				hint: "rendererEffect"
+			},
 			worktreeBranchPrefix: {
 				label: "worktreeBranchPrefix",
 				hint: "worktreeBranchPrefixEffect"
@@ -4947,6 +5608,17 @@ 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"
+		};
+		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 +5640,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 +5672,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 +5710,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 +5767,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 +5793,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 +5810,7 @@ window.__ModuleLoader__.load({
 					}));
 					setJiraToken("");
 				} catch (cause) {
-					setJiraError(cause instanceof Error ? cause.message : String(cause));
+					setJiraError(cardFailure(cause));
 				} finally {
 					setJiraBusy(false);
 				}
@@ -5149,7 +5822,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 +5832,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 +5846,14 @@ 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);
 				} catch (cause) {
-					setGlobalSettingsError(cause instanceof Error ? cause.message : String(cause));
+					setGlobalSettingsError(cardFailure(cause));
 				} finally {
 					setGlobalSettingsBusy(false);
 				}
@@ -5210,20 +5865,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 +5939,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
 							})
 						]
 					}),
@@ -5337,6 +5975,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 +5988,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 +6096,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 +6159,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 +6213,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 +6240,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 +6330,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 (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;
+			} finally {
+				carrier.abort();
 			}
-			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 +6410,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 +6447,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 +6516,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 +7672,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 +13834,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 +13866,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 +14061,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 +14674,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 +14766,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 +15990,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 +16265,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 +16698,10 @@ window.__ModuleLoader__.load({
 			globalSettingsNewSession: "修改仅对新建 Claude 会话生效。",
 			globalSettingsError: "全局设置保存失败",
 			outputStyle: "Output Style",
+			renderer: "AI 输出渲染器",
+			rendererPlugin: "插件渲染器",
+			rendererNative: "DSH 原生渲染器",
+			rendererEffect: "插件渲染器沿用本插件自带的转录视图：交错的正文、成组的工具卡片与活动行。DSH 原生渲染器改由 DSH 自身绘制：正文作为普通助手文本块，思考作为推理块，Claude 的顶层工具会镜像成原生工具卡片。修改从下一个回合起生效；已经产生的回合仍按记录时的渲染器显示，不会重绘。",
 			worktreeBranchPrefix: "Worktree 分支前缀",
 			worktreeBranchPrefixEffect: "分支前缀修改会应用于之后自动创建的 Worktree 分支；显式指定的完整分支名不会被修改。",
 			maxProcessesSetting: "Claude 进程上限",
@@ -16522,6 +17062,10 @@ 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.",
 			worktreeBranchPrefix: "Worktree branch prefix",
 			worktreeBranchPrefixEffect: "Prefix changes apply to subsequently generated Worktree branches. Explicit full branch names remain unchanged.",
 			maxProcessesSetting: "Claude process limit",
@@ -16884,7 +17428,9 @@ 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();
+			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");