@norman-else/dsh-claude 0.1.34 → 0.1.36

package/lib/index.mjs

@@ -1,6 +1,6 @@
-import { A as CLAUDE_UPDATE_PATH, C as CLAUDE_REPOSITORY_FEEDBACK_PATH, D as CLAUDE_REVIEW_COMMENT_PATH, E as CLAUDE_REPOSITORY_STATUS_PATH, N as TASK_TOOL_NAMES, O as CLAUDE_REWIND_PATH, S as CLAUDE_REPOSITORY_ACTION_PATH, T as CLAUDE_REPOSITORY_SETUP_PATH, _ as CLAUDE_DOCTOR_PATH, a as latestClaudeTasks, b as CLAUDE_JIRA_PATH, c as normalizeTasksEvent, d as CLAUDE_ACTIVITY_EVENT, f as CLAUDE_ASK_PATH, g as CLAUDE_CODE_PROVIDER_IDS, h as CLAUDE_CODE_PROVIDER, i as latestClaudeSessionBinding, j as CLAUDE_USAGE_PATH, k as CLAUDE_UPDATE_CHECK_PATH, l as redactText, m as CLAUDE_CODE_PRESET_ID, n as currentClaudeActivityCursor, o as normalizeActivity, p as CLAUDE_CLIENT_DIAGNOSTICS_PATH, r as latestClaudeContextUsage, s as normalizeContextUsage, t as boundText, u as safeDetail, v as CLAUDE_EDITOR_OPEN_PATH, w as CLAUDE_REPOSITORY_FILE_PATH, x as CLAUDE_PROJECTION_PATH, y as CLAUDE_GLOBAL_SETTINGS_PATH } from "./events-DeSV0S1-.mjs";
-import { n as projectClaudeCommands, t as CLAUDE_COMMANDS_SERVICE } from "./command-bridge-DXI6nWhB.mjs";
-import { a as resolveClaudeExecutable, n as ensureManagedPreset, o as runClaudeDoctor, t as ManagedPresetConflictError } from "./preset-installer-BY4846KK.mjs";
+import { A as CLAUDE_REWIND_PATH, C as CLAUDE_RENDER_MODES, D as CLAUDE_REPOSITORY_SETUP_PATH, E as CLAUDE_REPOSITORY_FILE_PATH, F as DEFAULT_CLAUDE_RENDER_MODE, L as TASK_TOOL_NAMES, M as CLAUDE_UPDATE_PATH, N as CLAUDE_USAGE_PATH, O as CLAUDE_REPOSITORY_STATUS_PATH, P as DEFAULT_CLAUDE_PROSE_MODE, R as isClaudeProseMode, S as CLAUDE_PROSE_MODES, T as CLAUDE_REPOSITORY_FEEDBACK_PATH, _ as CLAUDE_DOCTOR_PATH, a as latestClaudeTasks, b as CLAUDE_JIRA_PATH, c as normalizeTasksEvent, d as CLAUDE_ACTIVITY_EVENT, f as CLAUDE_ASK_PATH, g as CLAUDE_CODE_PROVIDER_IDS, h as CLAUDE_CODE_PROVIDER, i as latestClaudeSessionBinding, j as CLAUDE_UPDATE_CHECK_PATH, k as CLAUDE_REVIEW_COMMENT_PATH, l as redactText, m as CLAUDE_CODE_PRESET_ID, n as currentClaudeActivityCursor, o as normalizeActivity, p as CLAUDE_CLIENT_DIAGNOSTICS_PATH, r as latestClaudeContextUsage, s as normalizeContextUsage, t as boundText, u as safeDetail, v as CLAUDE_EDITOR_OPEN_PATH, w as CLAUDE_REPOSITORY_ACTION_PATH, x as CLAUDE_PROJECTION_PATH, y as CLAUDE_GLOBAL_SETTINGS_PATH, z as isClaudeRenderMode } from "./events-OhBoFNKO.mjs";
+import { a as projectClaudeCommands, i as CLAUDE_COMMANDS_SERVICE, r as dynamicPresenterDefinition, t as CLAUDE_PRESENTER_NAMES } from "./presenters-BBoM1Ju1.mjs";
+import { a as resolveClaudeExecutable, n as ensureManagedPreset, o as runClaudeDoctor, t as ManagedPresetConflictError } from "./preset-installer-loenwnLS.mjs";
 import z from "@deepseek-ai/schemastery";
 import { createHash, randomUUID } from "node:crypto";
 import { chmod, mkdir, opendir, readFile, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
@@ -8,10 +8,11 @@ import { basename, dirname, extname, isAbsolute, join, resolve, sep } from "node
 import { dshHomePath, resolveDshHome } from "@deepseek-ai/dsh-home-paths";
 import { homedir } from "node:os";
 import { query } from "@anthropic-ai/claude-agent-sdk";
+import { CallId, LlmAdapter, ReasoningEffortId, createToolResultMessage } from "@deepseek-ai/dsh-llm";
 import { EventEmitter } from "node:events";
 import { DSH_ENV_PREFIX, SENSITIVE_ENV_PATTERN } from "@deepseek-ai/dsh-subprocess";
-import { LlmAdapter, ReasoningEffortId } from "@deepseek-ai/dsh-llm";
 import { fileURLToPath } from "node:url";
+import { deadline } from "@deepseek-ai/dsh-timeout";
 import { StringDecoder } from "node:string_decoder";
 //#region src/rewind.ts
 const EMPTY_REWIND_STATE = {
@@ -227,6 +228,8 @@ var ClaudeSidecarRepository = class {
 	/** Latest durable projection per session; disk is read once and written through. */
 	#latest = /* @__PURE__ */ new Map();
 	#listeners = /* @__PURE__ */ new Map();
+	/** Notifications published per session, so a reader can spot a hole. */
+	#seq = /* @__PURE__ */ new Map();
 	/** Streaming transcript segments not yet persisted, keyed by activity key. */
 	#live = /* @__PURE__ */ new Map();
 	/** Monotonic revision boost so merged reads advance while text stays in memory. */
@@ -275,7 +278,8 @@ var ClaudeSidecarRepository = class {
 		const base = {
 			turn: normalized.turn,
 			step: normalized.step,
-			ordinal: normalized.ordinal
+			ordinal: normalized.ordinal,
+			...normalized.renderer === void 0 ? {} : { renderer: normalized.renderer }
 		};
 		this.#notify(sessionId, previous?.text !== void 0 && text.startsWith(previous.text) ? {
 			kind: "text",
@@ -297,11 +301,35 @@ var ClaudeSidecarRepository = class {
 		}
 		return this.#flushLive(sessionId);
 	}
+	/** How many notifications this session has published. */
+	sequence(sessionId) {
+		return this.#seq.get(sessionId) ?? 0;
+	}
+	/** Restate where the stream stands without changing anything.
+	*
+	*  A reader detects a lost delta from the hole the NEXT one leaves, which
+	*  never comes when the lost delta was the last of a turn -- exactly the
+	*  case that leaves a finished tool group pulsing forever. Called at turn
+	*  settlement, this gives that reader the one line it needs to disagree. */
+	checkpoint(sessionId) {
+		this.#deliver(sessionId, {
+			kind: "checkpoint",
+			seq: this.sequence(sessionId)
+		});
+	}
 	#notify(sessionId, delta) {
+		const seq = this.sequence(sessionId) + 1;
+		this.#seq.set(sessionId, seq);
+		this.#deliver(sessionId, {
+			...delta,
+			seq
+		});
+	}
+	#deliver(sessionId, notification) {
 		const set = this.#listeners.get(sessionId);
 		if (set === void 0) return;
 		for (const listener of [...set]) try {
-			listener(delta);
+			listener(notification);
 		} catch {}
 	}
 	#merged(sessionId, base) {
@@ -1451,6 +1479,7 @@ var ClaudeSupervisor = class {
 	#queryFactory;
 	#runDetached;
 	#sidecar;
+	#dynamicPresenterNames = /* @__PURE__ */ new WeakMap();
 	#contextWindows = /* @__PURE__ */ new Map();
 	#disposed = false;
 	#admissionGate = Promise.resolve();
@@ -1581,9 +1610,11 @@ var ClaudeSupervisor = class {
 			transcriptTextOrdinal: void 0,
 			thinking: "",
 			requestUsage: void 0,
+			startedAt: Date.now(),
+			firstOutputAt: void 0,
 			aborted: false,
 			deniedToolUseIds: /* @__PURE__ */ new Set(),
-			callNames: /* @__PURE__ */ new Map(),
+			openCalls: /* @__PURE__ */ new Map(),
 			...request.signal === void 0 ? {} : { signal: request.signal }
 		};
 		entry.active = active;
@@ -1869,6 +1900,7 @@ var ClaudeSupervisor = class {
 				active.text += message.text;
 				active.transcriptText += message.text;
 				await this.#upsertTranscriptText(active);
+				active.firstOutputAt ??= Date.now();
 				active.output.push({
 					type: "text-delta",
 					text: message.text
@@ -1881,6 +1913,7 @@ var ClaudeSupervisor = class {
 					active.text += message.text;
 					active.transcriptText += message.text;
 					await this.#upsertTranscriptText(active);
+					active.firstOutputAt ??= Date.now();
 					active.output.push({
 						type: "text-delta",
 						text: message.text
@@ -1900,6 +1933,10 @@ var ClaudeSupervisor = class {
 					title: "Claude thinking",
 					summary: message.text
 				});
+				if (this.#nativeRendering()) active.output.push({
+					type: "thinking",
+					text: message.text
+				});
 				return;
 			case "tool-call":
 				if (message.parentToolUseId === void 0) this.#closeTranscriptTextSegment(active);
@@ -1913,9 +1950,16 @@ var ClaudeSupervisor = class {
 					summary: message.parentToolUseId === void 0 ? rootCallSummary(message.toolName, message.input) : `Subagent called ${message.toolName}`,
 					detail: message.input
 				});
-				if (message.parentToolUseId === void 0) active.callNames.set(message.toolUseId, message.toolName);
+				if (message.parentToolUseId === void 0) {
+					active.openCalls.set(message.toolUseId, message.toolName);
+					if (this.#nativeRendering()) {
+						this.#ensureDynamicPresenter(active.agent, message.toolName);
+						await this.#appendNativeToolCall(active, message);
+					}
+				}
 				return;
 			case "tool-result":
+				active.openCalls.delete(message.toolUseId);
 				await this.#appendActivity(active, {
 					kind: message.parentToolUseId === void 0 ? "tool-result" : "subagent",
 					phase: message.isError ? "failed" : "completed",
@@ -1925,6 +1969,7 @@ var ClaudeSupervisor = class {
 					detail: message.output,
 					isError: message.isError
 				});
+				if (message.parentToolUseId === void 0 && this.#nativeRendering()) await this.#appendNativeToolResult(active, message);
 				return;
 			case "subagent":
 				await this.#appendActivity(active, {
@@ -1974,9 +2019,77 @@ var ClaudeSupervisor = class {
 					title: message.toolName,
 					summary: message.summary
 				});
+				if (this.#nativeRendering()) await this.#appendNativeToolResult(active, {
+					kind: "tool-result",
+					toolUseId: message.toolUseId,
+					output: message.summary,
+					isError: true
+				});
 				return;
 		}
 	}
+	/** The turn's accounting with its wall clock attached. The transcript draws
+	*  this line itself under the plugin renderer: activities carry no
+	*  timestamps, so a duration it did not measure is a duration nobody has. */
+	#timedUsage(active, usage) {
+		const now = Date.now();
+		return {
+			...usage,
+			durationMs: Math.max(0, now - active.startedAt),
+			...active.firstOutputAt === void 0 ? {} : { ttftMs: Math.max(0, active.firstOutputAt - active.startedAt) }
+		};
+	}
+	#nativeRendering() {
+		return (this.#config.renderMode ?? "plugin") === "native";
+	}
+	/** Register one presenter-only mirror for a tool name the static preset
+	*  registry does not cover (MCP tools, newly added built-ins). Runs in the
+	*  agent scope so the mirror is visible only to this preset's sessions and
+	*  unwinds with the agent; failure keeps the generic card, never the turn. */
+	#ensureDynamicPresenter(agent, name) {
+		if (CLAUDE_PRESENTER_NAMES.has(name)) return;
+		let known = this.#dynamicPresenterNames.get(agent);
+		if (known === void 0) {
+			known = /* @__PURE__ */ new Set();
+			this.#dynamicPresenterNames.set(agent, known);
+		}
+		if (known.has(name)) return;
+		try {
+			agent.ctx.tools.register(dynamicPresenterDefinition(name));
+			known.add(name);
+		} catch {}
+	}
+	/** Mirror one root Claude tool call into the durable native tool channel so
+	*  the host's tool presentation renders it exactly like a DSH-executed call.
+	*  Presentation duplication is best-effort and never unsettles the turn. */
+	async #appendNativeToolCall(active, message) {
+		try {
+			await active.agent.session.append("tool/call", {
+				turn: active.cursor.turn,
+				step: active.cursor.step,
+				callId: CallId(message.toolUseId),
+				name: message.toolName,
+				arguments: safeDetail(message.input) ?? "{}"
+			});
+		} catch {}
+	}
+	async #appendNativeToolResult(active, message) {
+		const text = typeof message.output === "string" ? redactText(message.output) : safeDetail(message.output) ?? "";
+		try {
+			await active.agent.session.append("tool/result", {
+				turn: active.cursor.turn,
+				step: active.cursor.step,
+				message: createToolResultMessage({
+					callId: CallId(message.toolUseId),
+					content: [{
+						type: "text",
+						text
+					}],
+					isError: message.isError
+				})
+			}, { surfaceOp: "append" });
+		} catch {}
+	}
 	/** Merge one task lifecycle message into the session's task board. */
 	async #trackTask(entry, message, taskId, originTurn) {
 		const previous = entry.tasks.get(taskId);
@@ -2117,7 +2230,7 @@ var ClaudeSupervisor = class {
 				phase: "completed",
 				title: "Claude usage",
 				summary: usageSummary(result.usage),
-				usage: result.usage
+				usage: this.#timedUsage(active, result.usage)
 			});
 			active.output.push({
 				type: "usage",
@@ -2148,6 +2261,7 @@ var ClaudeSupervisor = class {
 		if (active.aborted) {
 			await this.#upsertTranscriptText(active);
 			await this.#flushTranscript(active);
+			await this.#settleOpenCalls(active, "Cancelled with the turn");
 			await this.#appendSafely(active, {
 				kind: "status",
 				phase: "failed",
@@ -2157,6 +2271,7 @@ var ClaudeSupervisor = class {
 			entry.state = "idle";
 			entry.lastUsedAt = Date.now();
 			await this.#recordChainAnchor(entry, active);
+			this.#checkpointProjection(entry);
 			this.#armIdleTimer(entry);
 			return;
 		}
@@ -2166,7 +2281,7 @@ var ClaudeSupervisor = class {
 				phase: "completed",
 				title: "Claude usage",
 				summary: usageSummary(result.usage),
-				usage: result.usage
+				usage: this.#timedUsage(active, result.usage)
 			});
 			active.output.push({
 				type: "usage",
@@ -2240,8 +2355,20 @@ var ClaudeSupervisor = class {
 		entry.lastUsedAt = Date.now();
 		await this.#recordChainAnchor(entry, active);
 		await this.#learnContextWindow(entry);
+		this.#checkpointProjection(entry);
 		this.#armIdleTimer(entry);
 	}
+	/** Tell every reader where this session's delta stream ended.
+	*
+	*  A reader that lost the turn's last delta has nothing later to reveal the
+	*  hole, and a settled turn produces nothing further -- so a finished tool
+	*  group would keep pulsing until the session was reopened by hand. Last
+	*  line of the turn, best effort: presentation must never unsettle it. */
+	#checkpointProjection(entry) {
+		try {
+			this.#sidecar.checkpoint(entry.sessionId);
+		} catch {}
+	}
 	/** Pin where Claude's chain ended for the DSH turn that just settled, so a
 	*  later rewind of the following turn can fork exactly here. Best effort:
 	*  a missing anchor only makes a rewind fall back to an earlier turn. */
@@ -2259,6 +2386,7 @@ var ClaudeSupervisor = class {
 		try {
 			this.#sidecar.appendTranscriptText(active.agent.id, {
 				text: active.transcriptText,
+				...this.#nativeRendering() ? { renderer: "native" } : {},
 				turn: active.cursor.turn,
 				step: active.cursor.step,
 				ordinal
@@ -2277,6 +2405,7 @@ var ClaudeSupervisor = class {
 		const ordinal = active.cursor.nextOrdinal++;
 		await this.#sidecar.appendActivity(active.agent.id, {
 			...activity,
+			...this.#nativeRendering() ? { renderer: "native" } : {},
 			turn: active.cursor.turn,
 			step: active.cursor.step,
 			ordinal
@@ -2296,6 +2425,33 @@ var ClaudeSupervisor = class {
 		this.#interruptions.set(entry.sessionId, interruption);
 		return interruption;
 	}
+	/** Close out the root tool calls a turn is ending without answers for.
+	*
+	*  A tool result is the only thing that ever settles a call, and a turn that
+	*  is cancelled or disconnected produces none: the transcript would keep
+	*  drawing those calls as running for as long as the session lives, and no
+	*  later event would ever correct it. Written as the failures they are. */
+	async #settleOpenCalls(active, summary) {
+		const open = [...active.openCalls];
+		active.openCalls.clear();
+		for (const [toolUseId, toolName] of open) {
+			await this.#appendSafely(active, {
+				kind: "tool-result",
+				phase: "failed",
+				toolUseId,
+				toolName,
+				title: "Tool cancelled",
+				summary,
+				isError: true
+			});
+			if (this.#nativeRendering()) await this.#appendNativeToolResult(active, {
+				kind: "tool-result",
+				toolUseId,
+				output: summary,
+				isError: true
+			});
+		}
+	}
 	async #interrupt(entry) {
 		const active = entry.active;
 		if (active === void 0 || entry.state === "interrupting") return;
@@ -2309,6 +2465,7 @@ var ClaudeSupervisor = class {
 		} catch (error) {
 			interruptError = error;
 		}
+		await this.#settleOpenCalls(active, "Cancelled with the turn").catch(() => void 0);
 		try {
 			await this.#appendActivity(active, {
 				kind: "status",
@@ -2330,6 +2487,7 @@ var ClaudeSupervisor = class {
 			const unknown = active.sawActivity;
 			entry.state = unknown ? "outcome-unknown" : "disconnected";
 			const failure = unknown ? new ClaudeOutcomeUnknownError(stderr === void 0 || stderr.length === 0 ? void 0 : `Claude Code exited after activity; outcome unknown. ${stderr}`) : new Error(stderr === void 0 || stderr.length === 0 ? errorSummary(error) : stderr);
+			await this.#settleOpenCalls(active, "Claude Code stopped before the tool answered").catch(() => void 0);
 			await this.#appendSafely(active, {
 				kind: "error",
 				phase: "failed",
@@ -2640,13 +2798,15 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 	#attachments;
 	#presetIdFor;
 	#drainReviewComments;
-	constructor(supervisor, agents, attachments, presetIdFor, drainReviewComments = () => []) {
+	#renderMode;
+	constructor(supervisor, agents, attachments, presetIdFor, drainReviewComments = () => [], renderMode = () => DEFAULT_CLAUDE_RENDER_MODE) {
 		super();
 		this.#supervisor = supervisor;
 		this.#agents = agents;
 		this.#attachments = attachments;
 		this.#presetIdFor = presetIdFor;
 		this.#drainReviewComments = drainReviewComments;
+		this.#renderMode = renderMode;
 	}
 	providerInfo(provider) {
 		return {
@@ -2718,15 +2878,74 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 			...thinkingMode === void 0 ? {} : { thinkingMode },
 			...options.signal === void 0 ? {} : { signal: options.signal }
 		});
+		const native = this.#renderMode() === "native";
 		let pendingUsage;
 		let completed = false;
+		let blockIndex = 0;
+		let text = "";
+		/** Settle the buffered prose as one text block. Each Claude result is one
+		*  block so tool activity stays ahead of the prose it explains and a
+		*  background-task report can follow in a block of its own. */
+		function* flushText() {
+			if (text.length === 0) return;
+			const settled = text;
+			text = "";
+			yield {
+				type: "block-start",
+				index: blockIndex,
+				blockType: "text"
+			};
+			yield {
+				type: "text-delta",
+				index: blockIndex,
+				text: settled
+			};
+			yield {
+				type: "block-end",
+				index: blockIndex,
+				block: {
+					type: "text",
+					text: settled
+				}
+			};
+			blockIndex += 1;
+		}
 		try {
 			for await (const event of events) {
-				if (event.type === "text-delta" || event.type === "segment-complete") continue;
 				if (event.type === "usage") {
 					pendingUsage = tokenUsage(event.usage);
 					continue;
 				}
+				if (event.type === "text-delta") {
+					if (native) text += event.text;
+					continue;
+				}
+				if (event.type === "thinking") {
+					if (!native) continue;
+					yield* flushText();
+					yield {
+						type: "block-start",
+						index: blockIndex,
+						blockType: "reasoning"
+					};
+					yield {
+						type: "reasoning-delta",
+						index: blockIndex,
+						text: event.text
+					};
+					yield {
+						type: "block-end",
+						index: blockIndex,
+						block: {
+							type: "reasoning",
+							text: event.text
+						}
+					};
+					blockIndex += 1;
+					continue;
+				}
+				yield* flushText();
+				if (event.type === "segment-complete") continue;
 				completed = true;
 				if (pendingUsage !== void 0) yield {
 					type: "usage",
@@ -2740,6 +2959,7 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 		} catch (error) {
 			if (error.name === "AbortError") {
 				completed = true;
+				yield* flushText();
 				yield {
 					type: "finish",
 					reason: {
@@ -2757,10 +2977,41 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 		if (!completed) throw new Error("dsh-claude: Claude turn stream ended without a result");
 	}
 };
-function createClaudeCodeAdapter(supervisor, agents, attachments, presetIdFor, drainReviewComments = () => []) {
-	return new ClaudeCodeAdapter(supervisor, agents, attachments, presetIdFor, drainReviewComments);
+function createClaudeCodeAdapter(supervisor, agents, attachments, presetIdFor, drainReviewComments = () => [], renderMode = () => DEFAULT_CLAUDE_RENDER_MODE) {
+	return new ClaudeCodeAdapter(supervisor, agents, attachments, presetIdFor, drainReviewComments, renderMode);
 }
 //#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
+};
+//#endregion
 //#region src/http.ts
 /** Accept only loopback, same-origin browser requests to plugin-private routes. */
 function trustedRequest(req) {
@@ -2789,6 +3040,147 @@ function json(res, status, value) {
 	});
 	res.end(JSON.stringify(value));
 }
+const ROUTE_TIMEOUT_CODE = "DSH_CLAUDE_ROUTE";
+const DEFAULT_BODY_BYTES = 1048576;
+/** Bounds live streaming responses per path, so a teardown bug cannot become a
+*  permanent connection leak. Registration is per path, not global, because a
+*  wedged projection stream must not evict an in-flight repository setup. */
+var StreamRegistry = class {
+	#open = /* @__PURE__ */ new Map();
+	admit(path, key, max, close) {
+		let live = this.#open.get(path);
+		if (live === void 0) {
+			live = /* @__PURE__ */ new Map();
+			this.#open.set(path, live);
+		}
+		live.get(key)?.();
+		live.set(key, close);
+		while (live.size > max) {
+			const oldest = live.keys().next();
+			if (oldest.done === true) break;
+			const evict = live.get(oldest.value);
+			live.delete(oldest.value);
+			evict?.();
+		}
+		return () => {
+			const current = this.#open.get(path);
+			if (current?.get(key) === close) current.delete(key);
+		};
+	}
+};
+const streams = new StreamRegistry();
+function isPluginMethod(value) {
+	return value === "GET" || value === "POST" || value === "PATCH" || value === "DELETE";
+}
+/** Distinguishable so the wrapper can answer 413 rather than folding an
+*  oversized body into whatever generic failure the handler reports. */
+var PluginBodyTooLargeError = class extends Error {
+	constructor() {
+		super("Request body is too large");
+		this.name = "PluginBodyTooLargeError";
+	}
+};
+async function readBody(req, maxBytes) {
+	const declared = Number(req.headers["content-length"] ?? 0);
+	if (!Number.isFinite(declared) || declared < 0 || declared > maxBytes) throw new PluginBodyTooLargeError();
+	const chunks = [];
+	let bytes = 0;
+	for await (const chunk of req) {
+		const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		bytes += data.byteLength;
+		if (bytes > maxBytes) throw new PluginBodyTooLargeError();
+		chunks.push(data);
+	}
+	if (bytes === 0) return {};
+	return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+function rejectOn(signal) {
+	return new Promise((_resolve, reject) => {
+		if (signal.aborted) {
+			reject(signal.reason);
+			return;
+		}
+		signal.addEventListener("abort", () => reject(signal.reason), { once: true });
+	});
+}
+/**
+* Register one plugin route.
+*
+* This is the only place in the package that calls `ctx.webServer.register`,
+* and the ordering inside it is the fix rather than an implementation detail:
+* the disconnect listeners are attached before the first `await`, so a client
+* that goes away while the handler is still assembling its first response
+* still tears the route's work down. The previous per-route code attached
+* `res.on('close')` after awaiting an unbounded repository probe, which is how
+* the projection stream reached 53 opens against 33 closes.
+*/
+function registerPluginRoute(ctx, route) {
+	const label = `dsh-claude: ${route.path}`;
+	ctx.effect(() => ctx.webServer.register({
+		kind: route.kind,
+		path: route.path,
+		handler: async (req, res) => {
+			const method = req.method;
+			if (!isPluginMethod(method) || !route.methods.includes(method)) return json(res, 405, { error: "method not allowed" });
+			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
+			const aborted = new AbortController();
+			const abort = () => {
+				aborted.abort();
+			};
+			req.on("close", () => {
+				if (!req.complete) abort();
+			});
+			res.on("close", abort);
+			const url = new URL(req.url ?? "/", "http://localhost");
+			if (route.mode === "stream") {
+				const release = streams.admit(route.path, route.streamKey(url), route.maxConcurrent, abort);
+				const io = {
+					signal: aborted.signal,
+					method,
+					url,
+					body: async (maxBytes = DEFAULT_BODY_BYTES) => await readBody(req, maxBytes)
+				};
+				try {
+					await route.handler(res, io);
+				} catch (error) {
+					if (!res.headersSent) json(res, 500, { error: "stream-failed" });
+					ctx.logger.warn(`dsh-claude: ${route.path} stream failed: ${error instanceof Error ? error.message : String(error)}`);
+				} finally {
+					release();
+					res.end();
+				}
+				return;
+			}
+			const budgetMs = ROUTE_BUDGET_MS[route.budget];
+			const bounded = deadline(aborted.signal, budgetMs, ROUTE_TIMEOUT_CODE);
+			const io = {
+				signal: bounded.signal,
+				method,
+				url,
+				body: async (maxBytes = DEFAULT_BODY_BYTES) => await readBody(req, maxBytes)
+			};
+			try {
+				const result = await Promise.race([route.handler(io), rejectOn(bounded.signal)]);
+				if (!res.writableEnded) json(res, result.status, result.value);
+			} catch (error) {
+				if (res.writableEnded || res.headersSent) return;
+				if (bounded.signal.aborted && !aborted.signal.aborted) return json(res, 504, {
+					error: "deadline",
+					budget: route.budget,
+					ms: budgetMs
+				});
+				if (aborted.signal.aborted) return;
+				if (error instanceof PluginBodyTooLargeError) return json(res, 413, {
+					error: "body-too-large",
+					message: "The request body is too large."
+				});
+				json(res, 400, { error: error instanceof Error ? error.message : "request failed" });
+			} finally {
+				bounded[Symbol.dispose]();
+			}
+		}
+	}), label);
+}
 //#endregion
 //#region src/doctor-routes.ts
 const CLAUDE_DOCTOR_PROBE_TIMEOUT_MS = 15e3;
@@ -2828,60 +3220,70 @@ function commandDiagnostics(ctx) {
 	}
 }
 function registerClaudeDoctorRoutes(ctx, runtime, supervisor, config, resolutionError) {
-	ctx.effect(() => ctx.webServer.register({
+	registerPluginRoute(ctx, {
+		mode: "unary",
 		kind: "exact",
 		path: CLAUDE_DOCTOR_PATH,
-		handler: async (req, res) => {
-			if (req.method !== "GET") return json(res, 405, { error: "method not allowed" });
-			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
+		methods: ["GET"],
+		budget: "git",
+		handler: async (io) => {
 			try {
-				if (resolutionError !== void 0) return json(res, 200, {
-					executable: {
-						status: "missing",
-						searched: config.executablePath.length > 0 ? [config.executablePath] : [
-							"claude",
-							"~/.local/bin/claude",
-							"/opt/homebrew/bin/claude",
-							"/usr/local/bin/claude"
-						]
-					},
-					version: { status: "not-run" },
-					authentication: { status: "not-run" },
-					handshake: "not-run",
-					message: safeMessage$2(resolutionError),
-					limits: {
-						idleTimeoutMs: config.idleTimeoutMs,
-						maxProcesses: config.maxProcesses
-					},
-					processes: {
-						count: 0,
-						active: 0
+				if (resolutionError !== void 0) return {
+					status: 200,
+					value: {
+						executable: {
+							status: "missing",
+							searched: config.executablePath.length > 0 ? [config.executablePath] : [
+								"claude",
+								"~/.local/bin/claude",
+								"/opt/homebrew/bin/claude",
+								"/usr/local/bin/claude"
+							]
+						},
+						version: { status: "not-run" },
+						authentication: { status: "not-run" },
+						handshake: "not-run",
+						message: safeMessage$2(resolutionError),
+						limits: {
+							idleTimeoutMs: config.idleTimeoutMs,
+							maxProcesses: config.maxProcesses
+						},
+						processes: {
+							count: 0,
+							active: 0
+						}
 					}
-				});
+				};
 				const report = await runClaudeDoctor(runtime, {
 					configuredPath: config.executablePath,
 					cwd: process.cwd(),
-					signal: AbortSignal.timeout(CLAUDE_DOCTOR_PROBE_TIMEOUT_MS)
+					signal: AbortSignal.any([io.signal, AbortSignal.timeout(CLAUDE_DOCTOR_PROBE_TIMEOUT_MS)])
 				});
 				const processes = supervisor.snapshots();
 				if (processes.some((process) => process.claudeSessionId !== void 0)) report.handshake = "ok";
-				json(res, 200, {
-					...report,
-					limits: {
-						idleTimeoutMs: config.idleTimeoutMs,
-						maxProcesses: config.maxProcesses
-					},
-					processes: {
-						count: processes.length,
-						active: processes.filter((process) => process.state === "running" || process.state === "starting").length
-					},
-					commandBridge: commandDiagnostics(ctx)
-				});
+				return {
+					status: 200,
+					value: {
+						...report,
+						limits: {
+							idleTimeoutMs: config.idleTimeoutMs,
+							maxProcesses: config.maxProcesses
+						},
+						processes: {
+							count: processes.length,
+							active: processes.filter((process) => process.state === "running" || process.state === "starting").length
+						},
+						commandBridge: commandDiagnostics(ctx)
+					}
+				};
 			} catch (error) {
-				json(res, 500, { error: safeMessage$2(error) });
+				return {
+					status: 500,
+					value: { error: safeMessage$2(error) }
+				};
 			}
 		}
-	}), "dsh-claude: Doctor route");
+	});
 }
 //#endregion
 //#region src/projection-routes.ts
@@ -2889,21 +3291,34 @@ const MAX_SESSION_ID_CHARS$6 = 1024;
 /** Slow-moving metadata refresh and stream heartbeat cadence; deliberately off
 *  the transcript hot path so git/gh latency never delays visible text. */
 const META_REFRESH_MS = 5e3;
-function targetFromUrl(rawUrl) {
-	try {
-		const pathname = new URL(rawUrl ?? "/", "http://localhost").pathname;
-		const prefix = `${CLAUDE_PROJECTION_PATH}/`;
-		if (!pathname.startsWith(prefix)) return void 0;
-		let encoded = pathname.slice(prefix.length);
-		const stream = encoded.endsWith("/stream");
-		if (stream) encoded = encoded.slice(0, -7);
-		if (encoded.length === 0 || encoded.includes("/")) return void 0;
-		const sessionId = decodeURIComponent(encoded);
-		if (sessionId.length === 0 || sessionId.length > MAX_SESSION_ID_CHARS$6) return void 0;
+/** The multiplexed carrier's path segment. Session ids are `session-<uuid>`,
+*  so this cannot collide with one. */
+const MULTI_SEGMENT = "multi";
+function validSessionId(value) {
+	return value.length > 0 && value.length <= MAX_SESSION_ID_CHARS$6;
+}
+function targetFromUrl(url) {
+	const prefix = `${CLAUDE_PROJECTION_PATH}/`;
+	if (!url.pathname.startsWith(prefix)) return void 0;
+	const encoded = url.pathname.slice(prefix.length);
+	if (encoded.length === 0 || encoded.includes("/")) return void 0;
+	if (encoded === MULTI_SEGMENT) {
+		const raw = url.searchParams.get("sessions");
+		if (raw === null) return void 0;
+		const sessionIds = [...new Set(raw.split(",").filter((id) => id.length > 0))];
+		if (sessionIds.length === 0 || sessionIds.length > 16) return void 0;
+		if (!sessionIds.every(validSessionId)) return void 0;
 		return {
-			sessionId,
-			stream
+			kind: "multi",
+			sessionIds
 		};
+	}
+	try {
+		const sessionId = decodeURIComponent(encoded);
+		return validSessionId(sessionId) ? {
+			kind: "snapshot",
+			sessionId
+		} : void 0;
 	} catch {
 		return;
 	}
@@ -2923,9 +3338,16 @@ function envelope(projection, meta) {
 	};
 }
 /** Register the browser-readable, credential-free sidecar projection endpoint.
-*  `GET <path>/:sessionId` returns one snapshot; `GET <path>/:sessionId/stream`
-*  returns an NDJSON stream: a full snapshot line followed by incremental
-*  transcript/activity deltas and periodic metadata/heartbeat lines. */
+*
+*  `GET <path>/:sessionId` returns one snapshot. `GET <path>/multi?sessions=a,b`
+*  returns ONE NDJSON stream carrying every listed session, each line stamped
+*  with its `session`.
+*
+*  There is deliberately no per-session stream URL. The browser shares a small
+*  fixed connection budget between this plugin and the Host, and a stream per
+*  session spent it in proportion to how many Claude sessions existed — which
+*  is what left the settings panel unable to get a connection at all. One
+*  carrier is one connection, whatever the session count. */
 function registerClaudeProjectionRoute(ctx, sidecar, ownsSession, commandsForSession = () => [], repositoryForSession = async () => void 0, reviewCommentsForSession = () => []) {
 	const info = (message) => {
 		ctx.logger?.info?.(message);
@@ -2940,15 +3362,14 @@ function registerClaudeProjectionRoute(ctx, sidecar, ownsSession, commandsForSes
 			reviewComments: owned ? reviewCommentsForSession(sessionId) : []
 		};
 	};
-	const streamProjection = async (res, sessionId) => {
-		info(`dsh-claude: projection stream opened for ${sessionId.slice(0, 64)}`);
+	const streamMulti = async (res, io, sessionIds) => {
+		info(`dsh-claude: projection stream opened for ${sessionIds.length} session(s)`);
 		let textDeltas = 0;
 		let textBytes = 0;
 		let textSince = Date.now();
-		let meta = await assembleMeta(sessionId);
 		res.writeHead(200, {
 			"content-type": "application/x-ndjson; charset=utf-8",
-			"cache-control": "no-store",
+			"cache-control": "no-store, no-transform",
 			"x-content-type-options": "nosniff"
 		});
 		res.flushHeaders?.();
@@ -2961,102 +3382,146 @@ function registerClaudeProjectionRoute(ctx, sidecar, ownsSession, commandsForSes
 				closed = true;
 			}
 		};
-		const writeSnapshot = async () => {
-			const projection = await sidecar.read(sessionId);
+		const metas = /* @__PURE__ */ new Map();
+		const writeSnapshot = async (sessionId) => {
+			const [projection, meta] = await Promise.all([sidecar.read(sessionId), assembleMeta(sessionId)]);
+			metas.set(sessionId, meta);
 			writeLine({
 				type: "snapshot",
+				session: sessionId,
+				seq: sidecar.sequence(sessionId),
 				...envelope(projection, meta)
 			});
 		};
-		await writeSnapshot();
-		const unsubscribe = sidecar.subscribe(sessionId, (delta) => {
+		const unsubscribes = sessionIds.map((sessionId) => sidecar.subscribe(sessionId, (delta) => {
 			switch (delta.kind) {
 				case "text":
 					textDeltas += 1;
 					textBytes += (delta.append ?? delta.text ?? "").length;
 					if (textDeltas % 25 === 0) {
 						const elapsed = Date.now() - textSince;
-						info(`dsh-claude: stream ${sessionId.slice(0, 24)} 25 text deltas ${textBytes}B in ${elapsed}ms`);
+						info(`dsh-claude: stream 25 text deltas ${textBytes}B in ${elapsed}ms`);
 						textBytes = 0;
 						textSince = Date.now();
 					}
 					writeLine({
 						type: "text",
+						session: sessionId,
 						turn: delta.turn,
 						step: delta.step,
 						ordinal: delta.ordinal,
 						...delta.append === void 0 ? {} : { append: delta.append },
-						...delta.text === void 0 ? {} : { text: delta.text }
+						...delta.text === void 0 ? {} : { text: delta.text },
+						...delta.renderer === void 0 ? {} : { renderer: delta.renderer },
+						seq: delta.seq
 					});
 					return;
 				case "activity":
 					writeLine({
 						type: "activity",
-						activity: delta.activity
+						session: sessionId,
+						activity: delta.activity,
+						seq: delta.seq
 					});
 					return;
 				case "contextUsage":
 					writeLine({
 						type: "contextUsage",
-						value: delta.value
+						session: sessionId,
+						value: delta.value,
+						seq: delta.seq
 					});
 					return;
 				case "tasks":
 					writeLine({
 						type: "tasks",
-						value: delta.value
+						session: sessionId,
+						value: delta.value,
+						seq: delta.seq
 					});
 					return;
-				case "sync": writeSnapshot().catch(() => void 0);
+				case "checkpoint":
+					writeLine({
+						type: "checkpoint",
+						session: sessionId,
+						seq: delta.seq
+					});
+					return;
+				case "sync": writeSnapshot(sessionId).catch(() => void 0);
 			}
-		});
+		}));
+		for (const sessionId of sessionIds) writeSnapshot(sessionId).catch(() => void 0);
 		const timer = setInterval(() => {
 			(async () => {
-				const next = await assembleMeta(sessionId);
-				if (closed) return;
-				if (JSON.stringify(next) === JSON.stringify(meta)) {
-					writeLine({ type: "ping" });
-					return;
+				for (const sessionId of sessionIds) {
+					if (closed) return;
+					const next = await assembleMeta(sessionId);
+					if (closed) return;
+					if (JSON.stringify(next) === JSON.stringify(metas.get(sessionId))) continue;
+					metas.set(sessionId, next);
+					writeLine({
+						type: "meta",
+						session: sessionId,
+						owned: next.owned,
+						commands: next.commands,
+						...next.repository === void 0 ? {} : { repository: next.repository },
+						reviewComments: next.reviewComments
+					});
 				}
-				meta = next;
-				writeLine({
-					type: "meta",
-					owned: meta.owned,
-					commands: meta.commands,
-					...meta.repository === void 0 ? {} : { repository: meta.repository },
-					reviewComments: meta.reviewComments
-				});
+				writeLine({ type: "ping" });
 			})().catch(() => void 0);
 		}, META_REFRESH_MS);
 		timer.unref?.();
 		await new Promise((resolve) => {
-			res.on("close", () => {
+			const finish = () => {
+				if (closed) return;
 				closed = true;
 				clearInterval(timer);
-				unsubscribe();
-				info(`dsh-claude: projection stream closed for ${sessionId.slice(0, 64)} after ${textDeltas} text deltas`);
+				for (const unsubscribe of unsubscribes) unsubscribe();
+				info(`dsh-claude: projection stream closed after ${textDeltas} text deltas`);
 				resolve();
-			});
+			};
+			if (io.signal.aborted) finish();
+			else io.signal.addEventListener("abort", finish, { once: true });
 		});
 	};
-	ctx.effect(() => ctx.webServer.register({
+	registerPluginRoute(ctx, {
+		mode: "stream",
 		kind: "prefix",
 		path: CLAUDE_PROJECTION_PATH,
-		handler: async (req, res) => {
-			if (req.method !== "GET") return json(res, 405, { error: "method not allowed" });
-			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
-			const target = targetFromUrl(req.url);
-			if (target === void 0) return json(res, 400, { error: "invalid session id" });
+		methods: ["GET"],
+		maxConcurrent: 1,
+		streamKey: () => MULTI_SEGMENT,
+		handler: async (res, io) => {
+			const target = targetFromUrl(io.url);
+			if (target === void 0) {
+				res.writeHead(400, {
+					"content-type": "application/json; charset=utf-8",
+					"cache-control": "no-store"
+				});
+				res.write(JSON.stringify({ error: "invalid session id" }));
+				return;
+			}
+			if (target.kind === "multi") return await streamMulti(res, io, target.sessionIds);
+			info(`dsh-claude: projection poll for ${target.sessionId.slice(0, 64)}`);
 			try {
-				if (target.stream) return await streamProjection(res, target.sessionId);
-				info(`dsh-claude: projection poll for ${target.sessionId.slice(0, 64)}`);
-				return json(res, 200, envelope(await sidecar.read(target.sessionId), await assembleMeta(target.sessionId)));
+				const body = envelope(await sidecar.read(target.sessionId), await assembleMeta(target.sessionId));
+				res.writeHead(200, {
+					"content-type": "application/json; charset=utf-8",
+					"cache-control": "no-store",
+					"x-content-type-options": "nosniff"
+				});
+				res.write(JSON.stringify(body));
 			} catch {
-				if (!res.headersSent) return json(res, 500, { error: "projection unavailable" });
-				res.end();
+				if (res.headersSent) return;
+				res.writeHead(500, {
+					"content-type": "application/json; charset=utf-8",
+					"cache-control": "no-store"
+				});
+				res.write(JSON.stringify({ error: "projection unavailable" }));
 			}
 		}
-	}), "dsh-claude: sidecar projection route");
+	});
 }
 //#endregion
 //#region src/repository-status.ts
@@ -3235,10 +3700,13 @@ var RepositoryStatusService = class {
 		this.#runtime = runtime;
 		this.#cacheTtlMs = cacheTtlMs;
 	}
-	inspect(cwd) {
+	/** `signal` bounds the scan itself, not just the caller's patience: the
+	*  untracked-file diff below is a serial spawn loop that can outlive any
+	*  route budget, and work nobody is waiting for still occupies the process. */
+	inspect(cwd, signal) {
 		const current = this.#cache.get(cwd);
 		if (current !== void 0 && current.expiresAt > Date.now()) return current.value;
-		const value = this.#inspect(cwd).then((next) => this.#stabilize(cwd, next));
+		const value = this.#inspect(cwd, signal).then((next) => this.#stabilize(cwd, next));
 		this.#cache.set(cwd, {
 			expiresAt: Date.now() + this.#cacheTtlMs,
 			value
@@ -3296,7 +3764,7 @@ var RepositoryStatusService = class {
 		this.#ghExecutable ??= this.#runtime.resolveExecutable("gh").catch(() => void 0);
 		return this.#ghExecutable;
 	}
-	async #inspect(cwd) {
+	async #inspect(cwd, signal) {
 		const safeCwd = bounded(cwd);
 		let git;
 		try {
@@ -3346,7 +3814,7 @@ var RepositoryStatusService = class {
 			const remote = remoteResult.exitCode === 0 ? parseGitHubRemote(remoteResult.stdout) : void 0;
 			const pullRequest = status.branch === void 0 || remote === void 0 ? void 0 : await this.#pullRequest(cwd, remote, status.branch);
 			const diffBase = pullRequest?.baseBranch === void 0 ? "HEAD" : await this.#mergeBase(cwd, git, pullRequest.baseBranch) ?? "HEAD";
-			const diff = status.dirty || diffBase !== "HEAD" ? await this.#diff(cwd, git, diffBase) : {
+			const diff = status.dirty || diffBase !== "HEAD" ? await this.#diff(cwd, git, diffBase, signal) : {
 				additions: 0,
 				deletions: 0,
 				files: 0,
@@ -3400,7 +3868,7 @@ var RepositoryStatusService = class {
 			return;
 		}
 	}
-	async #diff(cwd, git, base) {
+	async #diff(cwd, git, base, signal) {
 		try {
 			const numstat = await run(this.#runtime, git, [
 				"diff",
@@ -3423,7 +3891,7 @@ var RepositoryStatusService = class {
 				...summary,
 				truncated: true
 			};
-			const untracked = await this.#untrackedDiff(cwd, git);
+			const untracked = await this.#untrackedDiff(cwd, git, signal);
 			const combinedPatch = `${patch.stdout}${untracked.patch}`;
 			return {
 				additions: summary.additions + untracked.additions,
@@ -3436,7 +3904,7 @@ var RepositoryStatusService = class {
 			return;
 		}
 	}
-	async #untrackedDiff(cwd, git) {
+	async #untrackedDiff(cwd, git, signal) {
 		const listed = await run(this.#runtime, git, [
 			"ls-files",
 			"--others",
@@ -3454,6 +3922,12 @@ var RepositoryStatusService = class {
 		let patch = "";
 		let truncated = paths.length > MAX_UNTRACKED_DIFFS;
 		for (const path of paths.slice(0, MAX_UNTRACKED_DIFFS)) {
+			if (signal?.aborted === true) return {
+				additions,
+				files: paths.length,
+				patch,
+				truncated: true
+			};
 			const result = await run(this.#runtime, git, [
 				"diff",
 				"--no-ext-diff",
@@ -4445,16 +4919,15 @@ const MAX_BODY_BYTES$6 = 16384;
 function record$9(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
-async function readJson$6(req) {
-	const chunks = [];
-	let size = 0;
-	for await (const chunk of req) {
-		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-		size += buffer.length;
-		if (size > MAX_BODY_BYTES$6) throw new RepositorySetupError("body-too-large", "The request body is too large.");
-		chunks.push(buffer);
+async function readJson$5(io) {
+	let parsed;
+	try {
+		parsed = await io.body(MAX_BODY_BYTES$6);
+	} catch (error) {
+		if (error instanceof SyntaxError) throw error;
+		throw new RepositorySetupError("body-too-large", "The request body is too large.");
 	}
-	const value = record$9(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+	const value = record$9(parsed);
 	if (value === void 0) throw new RepositorySetupError("invalid-request", "The request body is invalid.");
 	return value;
 }
@@ -4505,41 +4978,48 @@ async function streamSetup(res, service, input) {
 		res.end();
 	}
 }
-/** Register trusted browser routes for safe pre-session Git setup. */
+/** Register trusted browser routes for safe pre-session Git setup.
+*
+*  The prefix is registered as a stream because the setup POST holds its
+*  connection open for the whole worktree build; the short sibling paths ride
+*  the same registration and answer with `json` before releasing it. */
 function registerRepositorySetupRoute(ctx, service) {
-	ctx.effect(() => ctx.webServer.register({
+	registerPluginRoute(ctx, {
+		mode: "stream",
 		kind: "prefix",
 		path: CLAUDE_REPOSITORY_SETUP_PATH,
-		handler: async (req, res) => {
-			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
-			const pathname = new URL(req.url ?? "/", "http://localhost").pathname;
+		methods: ["GET", "POST"],
+		maxConcurrent: 2,
+		streamKey: (url) => `${url.pathname}?${url.searchParams.get("cwd") ?? url.searchParams.get("branch") ?? ""}`,
+		handler: async (res, io) => {
+			const pathname = io.url.pathname;
 			try {
 				if (pathname === `/plugins/dsh-claude/repository/setup/branches/refresh`) {
-					if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
-					const input = await readJson$6(req);
+					if (io.method !== "POST") return json(res, 405, { error: "method not allowed" });
+					const input = await readJson$5(io);
 					return json(res, 200, await service.refreshBranches(string$2(input, "cwd")));
 				}
 				if (pathname === `/plugins/dsh-claude/repository/setup/branches`) {
-					if (req.method !== "GET") return json(res, 405, { error: "method not allowed" });
-					const cwd = new URL(req.url ?? "/", "http://localhost").searchParams.get("cwd");
+					if (io.method !== "GET") return json(res, 405, { error: "method not allowed" });
+					const cwd = io.url.searchParams.get("cwd");
 					if (cwd === null) throw new RepositorySetupError("invalid-request", "The cwd query parameter is required.");
 					return json(res, 200, await service.listBranches(cwd));
 				}
 				if (pathname === "/plugins/dsh-claude/repository/setup") {
-					if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
-					const input = await readJson$6(req);
+					if (io.method !== "POST") return json(res, 405, { error: "method not allowed" });
+					const input = await readJson$5(io);
 					if (typeof input.worktree !== "boolean") throw new RepositorySetupError("invalid-request", "The worktree field is required.");
 					await streamSetup(res, service, input);
 					return;
 				}
 				if (pathname === `/plugins/dsh-claude/repository/setup/cleanup`) {
-					if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
-					const input = await readJson$6(req);
+					if (io.method !== "POST") return json(res, 405, { error: "method not allowed" });
+					const input = await readJson$5(io);
 					return json(res, 200, await service.cleanupMerged(string$2(input, "path"), string$2(input, "baseBranch")));
 				}
 				if (pathname === `/plugins/dsh-claude/repository/setup/bind`) {
-					if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
-					const input = await readJson$6(req);
+					if (io.method !== "POST") return json(res, 405, { error: "method not allowed" });
+					const input = await readJson$5(io);
 					await service.bindLease(string$2(input, "leaseId"), string$2(input, "sessionId"));
 					return json(res, 200, { ok: true });
 				}
@@ -4553,7 +5033,7 @@ function registerRepositorySetupRoute(ctx, service) {
 				return json(res, 500, { error: "repository setup unavailable" });
 			}
 		}
-	}), "dsh-claude: repository setup route");
+	});
 }
 //#endregion
 //#region src/repository-action-routes.ts
@@ -4570,16 +5050,15 @@ const ACTIONS = /* @__PURE__ */ new Set([
 function record$8(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
-async function readJson$5(req) {
-	const chunks = [];
-	let size = 0;
-	for await (const chunk of req) {
-		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-		size += buffer.length;
-		if (size > MAX_BODY_BYTES$5) throw new RepositoryActionError("body-too-large", "The request body is too large.");
-		chunks.push(buffer);
+async function readJson$4(io) {
+	let parsed;
+	try {
+		parsed = await io.body(MAX_BODY_BYTES$5);
+	} catch (error) {
+		if (error instanceof SyntaxError) throw error;
+		throw new RepositoryActionError("body-too-large", "The request body is too large.");
 	}
-	const value = record$8(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+	const value = record$8(parsed);
 	if (value === void 0) throw new RepositoryActionError("invalid-request", "The request body is invalid.");
 	return value;
 }
@@ -4618,44 +5097,80 @@ function actionRequest(input) {
 		})()
 	};
 }
+/** One prefix serves the local-Git preview and the POST arms that push, open
+*  and merge pull requests, so the registration takes the wider of the two
+*  budgets: a `remote` arm cut short at the `git` deadline would abandon work
+*  that had already reached GitHub. */
 function registerRepositoryActionRoute(ctx, service, cwdForSession) {
-	ctx.effect(() => ctx.webServer.register({
+	registerPluginRoute(ctx, {
+		mode: "unary",
 		kind: "prefix",
 		path: CLAUDE_REPOSITORY_ACTION_PATH,
-		handler: async (req, res) => {
-			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
-			const url = new URL(req.url ?? "/", "http://localhost");
+		methods: ["GET", "POST"],
+		budget: "remote",
+		handler: async (io) => {
+			const url = io.url;
 			try {
 				const cwd = cwdForSession(sessionId$1(url));
 				if (cwd === void 0) throw new RepositoryActionError("session-unavailable", "The Claude session is unavailable.");
 				if (url.pathname === `/plugins/dsh-claude/repository/action/preview`) {
-					if (req.method !== "GET") return json(res, 405, { error: "method not allowed" });
-					return json(res, 200, await service.preview(cwd));
+					if (io.method !== "GET") return {
+						status: 405,
+						value: { error: "method not allowed" }
+					};
+					return {
+						status: 200,
+						value: await service.preview(cwd)
+					};
 				}
 				if (url.pathname === `/plugins/dsh-claude/repository/action/message`) {
-					if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
-					const input = await readJson$5(req);
-					return json(res, 200, { message: await service.generateMessage(cwd, string$1(input, "fingerprint")) });
+					if (io.method !== "POST") return {
+						status: 405,
+						value: { error: "method not allowed" }
+					};
+					const input = await readJson$4(io);
+					return {
+						status: 200,
+						value: { message: await service.generateMessage(cwd, string$1(input, "fingerprint")) }
+					};
 				}
 				if (url.pathname === "/plugins/dsh-claude/repository/action") {
-					if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
-					return json(res, 200, await service.execute(cwd, actionRequest(await readJson$5(req))));
+					if (io.method !== "POST") return {
+						status: 405,
+						value: { error: "method not allowed" }
+					};
+					return {
+						status: 200,
+						value: await service.execute(cwd, actionRequest(await readJson$4(io)))
+					};
 				}
-				return json(res, 404, { error: "not found" });
+				return {
+					status: 404,
+					value: { error: "not found" }
+				};
 			} catch (error) {
-				if (error instanceof RepositoryActionError) return json(res, 409, {
-					error: error.code,
-					message: error.message,
-					...error.commit === void 0 ? {} : { commit: error.commit }
-				});
-				if (error instanceof SyntaxError) return json(res, 400, { error: "invalid-json" });
-				return json(res, 500, {
-					error: "repository-action-unavailable",
-					message: "Repository action is unavailable."
-				});
+				if (error instanceof RepositoryActionError) return {
+					status: 409,
+					value: {
+						error: error.code,
+						message: error.message,
+						...error.commit === void 0 ? {} : { commit: error.commit }
+					}
+				};
+				if (error instanceof SyntaxError) return {
+					status: 400,
+					value: { error: "invalid-json" }
+				};
+				return {
+					status: 500,
+					value: {
+						error: "repository-action-unavailable",
+						message: "Repository action is unavailable."
+					}
+				};
 			}
 		}
-	}), "dsh-claude: repository action route");
+	});
 }
 //#endregion
 //#region src/editor-open.ts
@@ -4781,43 +5296,62 @@ const MAX_SESSION_ID_CHARS$4 = 1024;
 /** Open the session's working directory in a desktop editor. Query-only: the
 *  request carries two enum-ish values, so there is no body to parse. */
 function registerEditorOpenRoute(ctx, service, cwdForSession) {
-	ctx.effect(() => ctx.webServer.register({
+	registerPluginRoute(ctx, {
+		mode: "unary",
 		kind: "exact",
 		path: CLAUDE_EDITOR_OPEN_PATH,
-		handler: async (req, res) => {
-			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
-			if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
-			const params = new URL(req.url ?? "/", "http://localhost").searchParams;
+		methods: ["POST"],
+		budget: "fast",
+		handler: async (io) => {
+			const params = io.url.searchParams;
 			const id = params.get("sessionId");
 			const editor = params.get("editor");
-			if (id === null || id.length === 0 || id.length > MAX_SESSION_ID_CHARS$4) return json(res, 400, {
-				error: "invalid-session",
-				message: "The session is invalid."
-			});
-			if (editor === null || !EDITOR_IDS.has(editor)) return json(res, 400, {
-				error: "invalid-editor",
-				message: "The editor is invalid."
-			});
+			if (id === null || id.length === 0 || id.length > MAX_SESSION_ID_CHARS$4) return {
+				status: 400,
+				value: {
+					error: "invalid-session",
+					message: "The session is invalid."
+				}
+			};
+			if (editor === null || !EDITOR_IDS.has(editor)) return {
+				status: 400,
+				value: {
+					error: "invalid-editor",
+					message: "The editor is invalid."
+				}
+			};
 			const cwd = cwdForSession(id);
-			if (cwd === void 0) return json(res, 409, {
-				error: "session-unavailable",
-				message: "The Claude session is unavailable."
-			});
+			if (cwd === void 0) return {
+				status: 409,
+				value: {
+					error: "session-unavailable",
+					message: "The Claude session is unavailable."
+				}
+			};
 			try {
 				await service.open(cwd, editor);
-				return json(res, 200, { opened: true });
+				return {
+					status: 200,
+					value: { opened: true }
+				};
 			} catch (error) {
-				if (error instanceof EditorOpenError) return json(res, 409, {
-					error: error.code,
-					message: error.message
-				});
-				return json(res, 500, {
-					error: "editor-open-unavailable",
-					message: "The editor could not be launched."
-				});
+				if (error instanceof EditorOpenError) return {
+					status: 409,
+					value: {
+						error: error.code,
+						message: error.message
+					}
+				};
+				return {
+					status: 500,
+					value: {
+						error: "editor-open-unavailable",
+						message: "The editor could not be launched."
+					}
+				};
 			}
 		}
-	}), "dsh-claude: editor open route");
+	});
 }
 //#endregion
 //#region src/github-url.ts
@@ -5110,7 +5644,10 @@ var PullRequestFeedbackService = class {
 			return [];
 		}
 	}
-	async failingChecks(cwd, pullNumber) {
+	/** `signal` bounds the log fetches below: each is capped on its own, but they
+	*  run one after another, so the honest worst case is their sum rather than
+	*  any single ceiling — more than a route is allowed to hold a connection. */
+	async failingChecks(cwd, pullNumber, signal) {
 		const gh = await this.#gh();
 		const result = await this.#run(gh, [
 			"pr",
@@ -5132,6 +5669,10 @@ var PullRequestFeedbackService = class {
 				detailed.push(check);
 				continue;
 			}
+			if (signal?.aborted === true) {
+				detailed.push(check);
+				continue;
+			}
 			const log = await this.#run(gh, [
 				"run",
 				"view",
@@ -5204,16 +5745,15 @@ const MAX_MENTION_QUERY_CHARS = 64;
 function record$6(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
-async function readJson$4(req) {
-	const chunks = [];
-	let size = 0;
-	for await (const chunk of req) {
-		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-		size += buffer.length;
-		if (size > MAX_BODY_BYTES$4) throw new PullRequestFeedbackError("body-too-large", "The request body is too large.");
-		chunks.push(buffer);
+async function readJson$3(io) {
+	let parsed;
+	try {
+		parsed = await io.body(MAX_BODY_BYTES$4);
+	} catch (error) {
+		if (error instanceof SyntaxError) throw error;
+		throw new PullRequestFeedbackError("body-too-large", "The request body is too large.");
 	}
-	const value = record$6(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+	const value = record$6(parsed);
 	if (value === void 0) throw new PullRequestFeedbackError("invalid-request", "The request body is invalid.");
 	return value;
 }
@@ -5242,123 +5782,199 @@ function pullNumber(url) {
 	if (!Number.isSafeInteger(value) || value <= 0 || value > 1e9) throw new PullRequestFeedbackError("invalid-request", "The pull request number is invalid.");
 	return value;
 }
+/** Every arm shells out to `gh`, so the whole prefix carries the network budget. */
 function registerPullRequestFeedbackRoute(ctx, service, cwdForSession) {
-	ctx.effect(() => ctx.webServer.register({
+	registerPluginRoute(ctx, {
+		mode: "unary",
 		kind: "prefix",
 		path: CLAUDE_REPOSITORY_FEEDBACK_PATH,
-		handler: async (req, res) => {
-			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
-			const url = new URL(req.url ?? "/", "http://localhost");
-			const reads = req.method === "GET";
-			const writes = req.method === "POST";
+		methods: ["GET", "POST"],
+		budget: "remote",
+		handler: async (io) => {
+			const url = io.url;
+			const reads = io.method === "GET";
+			const writes = io.method === "POST";
 			try {
 				const cwd = cwdForSession(sessionId(url));
 				if (cwd === void 0) throw new PullRequestFeedbackError("session-unavailable", "The Claude session is unavailable.");
 				if (url.pathname === `/plugins/dsh-claude/repository/feedback/comments`) {
-					if (!reads) return json(res, 405, { error: "method not allowed" });
-					return json(res, 200, { threads: await service.threads(cwd, pullNumber(url)) });
+					if (!reads) return {
+						status: 405,
+						value: { error: "method not allowed" }
+					};
+					return {
+						status: 200,
+						value: { threads: await service.threads(cwd, pullNumber(url)) }
+					};
 				}
 				if (url.pathname === `/plugins/dsh-claude/repository/feedback/checks`) {
-					if (!reads) return json(res, 405, { error: "method not allowed" });
-					return json(res, 200, { checks: await service.failingChecks(cwd, pullNumber(url)) });
+					if (!reads) return {
+						status: 405,
+						value: { error: "method not allowed" }
+					};
+					return {
+						status: 200,
+						value: { checks: await service.failingChecks(cwd, pullNumber(url), io.signal) }
+					};
 				}
 				if (url.pathname === `/plugins/dsh-claude/repository/feedback/mentionables`) {
-					if (!reads) return json(res, 405, { error: "method not allowed" });
+					if (!reads) return {
+						status: 405,
+						value: { error: "method not allowed" }
+					};
 					const query = (url.searchParams.get("q") ?? "").slice(0, MAX_MENTION_QUERY_CHARS);
-					return json(res, 200, { users: await service.mentionables(cwd, query) });
+					return {
+						status: 200,
+						value: { users: await service.mentionables(cwd, query) }
+					};
 				}
 				if (url.pathname === `/plugins/dsh-claude/repository/feedback/reply`) {
-					if (!writes) return json(res, 405, { error: "method not allowed" });
-					const input = await readJson$4(req);
-					return json(res, 200, { comment: await service.reply(cwd, pullNumber(url), commentId(input), replyBody(input)) });
+					if (!writes) return {
+						status: 405,
+						value: { error: "method not allowed" }
+					};
+					const input = await readJson$3(io);
+					return {
+						status: 200,
+						value: { comment: await service.reply(cwd, pullNumber(url), commentId(input), replyBody(input)) }
+					};
 				}
 				if (url.pathname === `/plugins/dsh-claude/repository/feedback/resolve`) {
-					if (!writes) return json(res, 405, { error: "method not allowed" });
-					const input = await readJson$4(req);
+					if (!writes) return {
+						status: 405,
+						value: { error: "method not allowed" }
+					};
+					const input = await readJson$3(io);
 					if (typeof input.resolved !== "boolean") throw new PullRequestFeedbackError("invalid-request", "The resolved field is required.");
-					return json(res, 200, { resolved: await service.setResolved(cwd, threadId(input), input.resolved) });
+					return {
+						status: 200,
+						value: { resolved: await service.setResolved(cwd, threadId(input), input.resolved) }
+					};
 				}
-				return json(res, 404, { error: "not found" });
+				return {
+					status: 404,
+					value: { error: "not found" }
+				};
 			} catch (error) {
-				if (error instanceof PullRequestFeedbackError) return json(res, 409, {
-					error: error.code,
-					message: error.message
-				});
-				if (error instanceof SyntaxError) return json(res, 400, { error: "invalid-json" });
-				return json(res, 500, {
-					error: "pr-feedback-unavailable",
-					message: "Pull request feedback is unavailable."
-				});
+				if (error instanceof PullRequestFeedbackError) return {
+					status: 409,
+					value: {
+						error: error.code,
+						message: error.message
+					}
+				};
+				if (error instanceof SyntaxError) return {
+					status: 400,
+					value: { error: "invalid-json" }
+				};
+				return {
+					status: 500,
+					value: {
+						error: "pr-feedback-unavailable",
+						message: "Pull request feedback is unavailable."
+					}
+				};
 			}
 		}
-	}), "dsh-claude: pull request feedback route");
+	});
 }
 //#endregion
 //#region src/repository-status-routes.ts
 const MAX_PATH_CHARS$1 = 4096;
 /** Read-only repository status for an arbitrary directory (the overview panel
-*  aggregates every Claude session's checkout through this). */
+*  aggregates every Claude session's checkout through this).
+*
+*  The route signal is threaded into the service because this is the one read
+*  the overview polls per distinct checkout every 30 seconds: freeing the
+*  socket at the budget while the Host kept scanning would just grow a queue
+*  of work nobody is waiting for any more. */
 function registerRepositoryStatusRoute(ctx, service) {
-	ctx.effect(() => ctx.webServer.register({
+	registerPluginRoute(ctx, {
+		mode: "unary",
 		kind: "exact",
 		path: CLAUDE_REPOSITORY_STATUS_PATH,
-		handler: async (req, res) => {
-			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
-			if (req.method !== "GET") return json(res, 405, { error: "method not allowed" });
-			const cwd = new URL(req.url ?? "/", "http://localhost").searchParams.get("cwd");
-			if (cwd === null || cwd.length === 0 || cwd.length > MAX_PATH_CHARS$1 || !isAbsolute(cwd) || cwd.includes("\0")) return json(res, 400, {
-				error: "invalid-request",
-				message: "The cwd query parameter is invalid."
-			});
+		methods: ["GET"],
+		budget: "git",
+		handler: async (io) => {
+			const cwd = io.url.searchParams.get("cwd");
+			if (cwd === null || cwd.length === 0 || cwd.length > MAX_PATH_CHARS$1 || !isAbsolute(cwd) || cwd.includes("\0")) return {
+				status: 400,
+				value: {
+					error: "invalid-request",
+					message: "The cwd query parameter is invalid."
+				}
+			};
 			try {
-				return json(res, 200, await service.inspect(cwd));
+				return {
+					status: 200,
+					value: await service.inspect(cwd, io.signal)
+				};
 			} catch {
-				return json(res, 500, {
-					error: "repository-status-unavailable",
-					message: "Repository status is unavailable."
-				});
+				return {
+					status: 500,
+					value: {
+						error: "repository-status-unavailable",
+						message: "Repository status is unavailable."
+					}
+				};
 			}
 		}
-	}), "dsh-claude: repository status route");
+	});
 }
 //#endregion
 //#region src/repository-file-routes.ts
 const MAX_PATH_CHARS = 4096;
 /** Read-only slice of a working-tree file so the diff panel can expand unmodified lines around hunks. */
 function registerRepositoryFileRoute(ctx, service) {
-	ctx.effect(() => ctx.webServer.register({
+	registerPluginRoute(ctx, {
+		mode: "unary",
 		kind: "exact",
 		path: CLAUDE_REPOSITORY_FILE_PATH,
-		handler: async (req, res) => {
-			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
-			if (req.method !== "GET") return json(res, 405, { error: "method not allowed" });
-			const params = new URL(req.url ?? "/", "http://localhost").searchParams;
+		methods: ["GET"],
+		budget: "git",
+		handler: async (io) => {
+			const params = io.url.searchParams;
 			const cwd = params.get("cwd");
 			const path = params.get("path");
 			const from = Number(params.get("from"));
 			const to = Number(params.get("to"));
-			if (cwd === null || cwd.length === 0 || cwd.length > MAX_PATH_CHARS || !isAbsolute(cwd) || cwd.includes("\0")) return json(res, 400, {
-				error: "invalid-request",
-				message: "The cwd query parameter is invalid."
-			});
-			if (path === null || path.length === 0 || path.length > MAX_PATH_CHARS) return json(res, 400, {
-				error: "invalid-request",
-				message: "The path query parameter is invalid."
-			});
+			if (cwd === null || cwd.length === 0 || cwd.length > MAX_PATH_CHARS || !isAbsolute(cwd) || cwd.includes("\0")) return {
+				status: 400,
+				value: {
+					error: "invalid-request",
+					message: "The cwd query parameter is invalid."
+				}
+			};
+			if (path === null || path.length === 0 || path.length > MAX_PATH_CHARS) return {
+				status: 400,
+				value: {
+					error: "invalid-request",
+					message: "The path query parameter is invalid."
+				}
+			};
 			try {
-				return json(res, 200, await service.fileLines(cwd, path, from, to));
+				return {
+					status: 200,
+					value: await service.fileLines(cwd, path, from, to)
+				};
 			} catch (error) {
-				if (error instanceof RepositoryFileError) return json(res, error.code === "invalid-request" ? 400 : 409, {
-					error: error.code,
-					message: error.message
-				});
-				return json(res, 500, {
-					error: "repository-file-unavailable",
-					message: "The file could not be read."
-				});
+				if (error instanceof RepositoryFileError) return {
+					status: error.code === "invalid-request" ? 400 : 409,
+					value: {
+						error: error.code,
+						message: error.message
+					}
+				};
+				return {
+					status: 500,
+					value: {
+						error: "repository-file-unavailable",
+						message: "The file could not be read."
+					}
+				};
 			}
 		}
-	}), "dsh-claude: repository file route");
+	});
 }
 //#endregion
 //#region src/jira.ts
@@ -5604,16 +6220,17 @@ const MAX_BODY_BYTES$3 = 8192;
 function record$4(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
-async function readJson$3(req) {
-	const chunks = [];
-	let size = 0;
-	for await (const chunk of req) {
-		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-		size += buffer.length;
-		if (size > MAX_BODY_BYTES$3) throw new JiraError("body-too-large", "The request body is too large.");
-		chunks.push(buffer);
+/** The wrapper enforces the byte cap; its plain rejection is translated back
+*  into the JiraError shape the panel already knows how to render. */
+async function readJson$2(io) {
+	let body;
+	try {
+		body = await io.body(MAX_BODY_BYTES$3);
+	} catch (error) {
+		if (error instanceof SyntaxError) throw error;
+		throw new JiraError("body-too-large", "The request body is too large.");
 	}
-	const value = record$4(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+	const value = record$4(body);
 	if (value === void 0) throw new JiraError("invalid-request", "The request body is invalid.");
 	return value;
 }
@@ -5623,55 +6240,99 @@ function string(input, key) {
 	return value;
 }
 function registerJiraRoute(ctx, service) {
-	ctx.effect(() => ctx.webServer.register({
+	registerPluginRoute(ctx, {
+		mode: "unary",
 		kind: "prefix",
 		path: CLAUDE_JIRA_PATH,
-		handler: async (req, res) => {
-			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
-			const url = new URL(req.url ?? "/", "http://localhost");
+		methods: ["GET", "POST"],
+		budget: "git",
+		handler: async (io) => {
+			const url = io.url;
 			try {
 				if (url.pathname === `/plugins/dsh-claude/jira/status`) {
-					if (req.method !== "GET") return json(res, 405, { error: "method not allowed" });
-					return json(res, 200, await service.status());
+					if (io.method !== "GET") return {
+						status: 405,
+						value: { error: "method not allowed" }
+					};
+					return {
+						status: 200,
+						value: await service.status()
+					};
 				}
 				if (url.pathname === `/plugins/dsh-claude/jira/connect`) {
-					if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
-					const input = await readJson$3(req);
-					return json(res, 200, await service.connect({
-						siteUrl: string(input, "siteUrl"),
-						email: string(input, "email"),
-						apiToken: string(input, "apiToken")
-					}));
+					if (io.method !== "POST") return {
+						status: 405,
+						value: { error: "method not allowed" }
+					};
+					const input = await readJson$2(io);
+					return {
+						status: 200,
+						value: await service.connect({
+							siteUrl: string(input, "siteUrl"),
+							email: string(input, "email"),
+							apiToken: string(input, "apiToken")
+						})
+					};
 				}
 				if (url.pathname === `/plugins/dsh-claude/jira/disconnect`) {
-					if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
+					if (io.method !== "POST") return {
+						status: 405,
+						value: { error: "method not allowed" }
+					};
 					await service.disconnect();
-					return json(res, 200, { connected: false });
+					return {
+						status: 200,
+						value: { connected: false }
+					};
 				}
 				if (url.pathname === `/plugins/dsh-claude/jira/assign`) {
-					if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
-					const input = await readJson$3(req);
+					if (io.method !== "POST") return {
+						status: 405,
+						value: { error: "method not allowed" }
+					};
+					const input = await readJson$2(io);
 					await service.assignToMe(string(input, "key"));
-					return json(res, 200, { assigned: true });
+					return {
+						status: 200,
+						value: { assigned: true }
+					};
 				}
 				if (url.pathname === `/plugins/dsh-claude/jira/search`) {
-					if (req.method !== "GET") return json(res, 405, { error: "method not allowed" });
-					return json(res, 200, { tickets: await service.search(url.searchParams.get("query") ?? "") });
+					if (io.method !== "GET") return {
+						status: 405,
+						value: { error: "method not allowed" }
+					};
+					return {
+						status: 200,
+						value: { tickets: await service.search(url.searchParams.get("query") ?? "") }
+					};
 				}
-				return json(res, 404, { error: "not found" });
+				return {
+					status: 404,
+					value: { error: "not found" }
+				};
 			} catch (error) {
-				if (error instanceof JiraError) return json(res, 409, {
-					error: error.code,
-					message: error.message
-				});
-				if (error instanceof SyntaxError) return json(res, 400, { error: "invalid-json" });
-				return json(res, 500, {
-					error: "jira-unavailable",
-					message: "Jira is unavailable."
-				});
+				if (error instanceof JiraError) return {
+					status: 409,
+					value: {
+						error: error.code,
+						message: error.message
+					}
+				};
+				if (error instanceof SyntaxError) return {
+					status: 400,
+					value: { error: "invalid-json" }
+				};
+				return {
+					status: 500,
+					value: {
+						error: "jira-unavailable",
+						message: "Jira is unavailable."
+					}
+				};
 			}
 		}
-	}), "dsh-claude: jira route");
+	});
 }
 //#endregion
 //#region src/ask.ts
@@ -5899,22 +6560,11 @@ var AskService = class {
 //#region src/ask-routes.ts
 const MAX_BODY_BYTES$2 = 131072;
 const MAX_SESSION_ID_CHARS$2 = 1024;
+/** Two sessions may await an answer at once; a third evicts the oldest. */
+const MAX_CONCURRENT_ASKS = 2;
 function record$2(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
-async function readJson$2(req) {
-	const chunks = [];
-	let size = 0;
-	for await (const chunk of req) {
-		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-		size += buffer.length;
-		if (size > MAX_BODY_BYTES$2) throw new AskError("body-too-large", "The request body is too large.");
-		chunks.push(buffer);
-	}
-	const value = record$2(JSON.parse(Buffer.concat(chunks).toString("utf8")));
-	if (value === void 0) throw new AskError("invalid-request", "The request body is invalid.");
-	return value;
-}
 function askRequest(input) {
 	if (typeof input.selection !== "string" || typeof input.question !== "string" || input.context !== void 0 && typeof input.context !== "string") throw new AskError("invalid-request", "The selection and question fields are required.");
 	return {
@@ -5926,25 +6576,32 @@ function askRequest(input) {
 function ndjson(res, value) {
 	res.write(`${JSON.stringify(value)}\n`);
 }
+/** A stream route rather than a unary one: the answer is written as it arrives,
+*  so the deadline stays where the work is — `ASK_TIMEOUT_MS` inside the
+*  service, fused there with the disconnect signal — instead of a route budget
+*  that would cut a legitimate long answer off mid-sentence. */
 function registerAskRoute(ctx, service, cwdForSession, preferencesFor) {
-	ctx.effect(() => ctx.webServer.register({
+	registerPluginRoute(ctx, {
+		mode: "stream",
 		kind: "exact",
 		path: CLAUDE_ASK_PATH,
-		handler: async (req, res) => {
-			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
-			if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
-			const url = new URL(req.url ?? "/", "http://localhost");
+		methods: ["POST"],
+		maxConcurrent: MAX_CONCURRENT_ASKS,
+		streamKey: (url) => url.searchParams.get("sessionId") ?? "",
+		handler: async (res, io) => {
 			let cwd;
 			let request;
 			let sessionId;
 			try {
-				const value = url.searchParams.get("sessionId");
+				const value = io.url.searchParams.get("sessionId");
 				if (value === null || value.length === 0 || value.length > MAX_SESSION_ID_CHARS$2) throw new AskError("invalid-session", "The session is invalid.");
 				sessionId = value;
 				const resolved = cwdForSession(sessionId);
 				if (resolved === void 0) throw new AskError("session-unavailable", "The Claude session is unavailable.");
 				cwd = resolved;
-				request = askRequest(await readJson$2(req));
+				const body = record$2(await io.body(MAX_BODY_BYTES$2));
+				if (body === void 0) throw new AskError("invalid-request", "The request body is invalid.");
+				request = askRequest(body);
 			} catch (error) {
 				if (error instanceof AskError) return json(res, 409, {
 					error: error.code,
@@ -5962,17 +6619,13 @@ function registerAskRoute(ctx, service, cwdForSession, preferencesFor) {
 				"x-content-type-options": "nosniff"
 			});
 			res.flushHeaders?.();
-			const controller = new AbortController();
-			req.on("close", () => {
-				controller.abort();
-			});
 			try {
 				await service.ask(cwd, request, preferencesFor(sessionId) ?? {}, (event) => {
 					ndjson(res, event.type === "text" ? {
 						type: "delta",
 						text: event.text
 					} : event);
-				}, controller.signal);
+				}, io.signal);
 				ndjson(res, { type: "done" });
 			} catch (error) {
 				ndjson(res, {
@@ -5980,11 +6633,9 @@ function registerAskRoute(ctx, service, cwdForSession, preferencesFor) {
 					code: error instanceof AskError ? error.code : "ask-unavailable",
 					message: error instanceof AskError ? error.message : "The question could not be answered."
 				});
-			} finally {
-				res.end();
 			}
 		}
-	}), "dsh-claude: ask route");
+	});
 }
 //#endregion
 //#region src/review-comment-routes.ts
@@ -5993,16 +6644,15 @@ const MAX_SESSION_ID_CHARS$1 = 1024;
 function record$1(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
-async function readJson$1(req) {
-	const chunks = [];
-	let size = 0;
-	for await (const chunk of req) {
-		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-		size += buffer.length;
-		if (size > MAX_BODY_BYTES$1) throw new ReviewCommentError("body-too-large", "The request body is too large.");
-		chunks.push(buffer);
+async function readJson$1(io) {
+	let parsed;
+	try {
+		parsed = await io.body(MAX_BODY_BYTES$1);
+	} catch (error) {
+		if (error instanceof SyntaxError) throw error;
+		throw new ReviewCommentError("body-too-large", "The request body is too large.");
 	}
-	const value = record$1(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+	const value = record$1(parsed);
 	if (value === void 0) throw new ReviewCommentError("invalid-request", "The request body is invalid.");
 	return value;
 }
@@ -6012,45 +6662,68 @@ function sessionIdFromUrl(url) {
 	return value;
 }
 function registerReviewCommentRoute(ctx, store, ownsSession) {
-	ctx.effect(() => ctx.webServer.register({
+	registerPluginRoute(ctx, {
+		mode: "unary",
 		kind: "prefix",
 		path: CLAUDE_REVIEW_COMMENT_PATH,
-		handler: async (req, res) => {
-			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
-			const url = new URL(req.url ?? "/", "http://localhost");
+		methods: ["POST"],
+		budget: "fast",
+		handler: async (io) => {
 			try {
-				const sessionId = sessionIdFromUrl(url);
+				const sessionId = sessionIdFromUrl(io.url);
 				if (!ownsSession(sessionId)) throw new ReviewCommentError("session-unavailable", "The Claude session is unavailable.");
-				if (url.pathname === "/plugins/dsh-claude/review-comments" && req.method === "POST") {
-					const input = await readJson$1(req);
-					return json(res, 200, { comment: store.add(sessionId, {
-						path: input.path,
-						line: input.line,
-						startLine: input.startLine,
-						side: input.side,
-						text: input.text
-					}) });
+				const pathname = io.url.pathname;
+				if (pathname === "/plugins/dsh-claude/review-comments") {
+					const input = await readJson$1(io);
+					return {
+						status: 200,
+						value: { comment: store.add(sessionId, {
+							path: input.path,
+							line: input.line,
+							startLine: input.startLine,
+							side: input.side,
+							text: input.text
+						}) }
+					};
 				}
-				if (url.pathname === `/plugins/dsh-claude/review-comments/clear` && req.method === "POST") return json(res, 200, { removed: store.drain(sessionId).length });
-				if (url.pathname === `/plugins/dsh-claude/review-comments/remove` && req.method === "POST") {
-					const input = await readJson$1(req);
+				if (pathname === `/plugins/dsh-claude/review-comments/clear`) return {
+					status: 200,
+					value: { removed: store.drain(sessionId).length }
+				};
+				if (pathname === `/plugins/dsh-claude/review-comments/remove`) {
+					const input = await readJson$1(io);
 					if (typeof input.id !== "string" || input.id.length === 0 || input.id.length > 128) throw new ReviewCommentError("invalid-request", "The comment id is invalid.");
-					return json(res, 200, { removed: store.remove(sessionId, input.id) });
+					return {
+						status: 200,
+						value: { removed: store.remove(sessionId, input.id) }
+					};
 				}
-				return json(res, 404, { error: "not found" });
+				return {
+					status: 404,
+					value: { error: "not found" }
+				};
 			} catch (error) {
-				if (error instanceof ReviewCommentError) return json(res, 409, {
-					error: error.code,
-					message: error.message
-				});
-				if (error instanceof SyntaxError) return json(res, 400, { error: "invalid-json" });
-				return json(res, 500, {
-					error: "review-comment-unavailable",
-					message: "Review comments are unavailable."
-				});
+				if (error instanceof ReviewCommentError) return {
+					status: 409,
+					value: {
+						error: error.code,
+						message: error.message
+					}
+				};
+				if (error instanceof SyntaxError) return {
+					status: 400,
+					value: { error: "invalid-json" }
+				};
+				return {
+					status: 500,
+					value: {
+						error: "review-comment-unavailable",
+						message: "Review comments are unavailable."
+					}
+				};
 			}
 		}
-	}), "dsh-claude: review comment route");
+	});
 }
 //#endregion
 //#region src/client-diagnostics-routes.ts
@@ -6058,17 +6731,6 @@ function registerReviewCommentRoute(ctx, store, ownsSession) {
 const MAX_DIAGNOSTIC_BYTES = 8192;
 const MAX_DETAIL_CHARS = 2e3;
 const MAX_KIND_CHARS = 60;
-async function readBody(req) {
-	const chunks = [];
-	let size = 0;
-	for await (const chunk of req) {
-		const buffer = chunk;
-		size += buffer.length;
-		if (size > MAX_DIAGNOSTIC_BYTES) throw new Error("diagnostic too large");
-		chunks.push(buffer);
-	}
-	return JSON.parse(Buffer.concat(chunks).toString("utf8"));
-}
 /** `POST <path>` with `{ kind, detail }`: write one renderer finding to the Host log.
 *
 *  The renderer has no other way to speak. A Slot entry that throws is caught
@@ -6078,25 +6740,38 @@ async function readBody(req) {
 *  Every finding here is data written by this package's own client half, but
 *  it is still bounded and redacted like any other untrusted input. */
 function registerClaudeClientDiagnosticsRoute(ctx) {
-	ctx.effect(() => ctx.webServer.register({
+	registerPluginRoute(ctx, {
+		mode: "unary",
 		kind: "exact",
 		path: CLAUDE_CLIENT_DIAGNOSTICS_PATH,
-		handler: async (req, res) => {
-			if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
-			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
+		methods: ["POST"],
+		budget: "fast",
+		handler: async (io) => {
 			try {
-				const body = await readBody(req);
+				const body = await io.body(MAX_DIAGNOSTIC_BYTES);
 				const kind = typeof body?.kind === "string" ? body.kind.slice(0, MAX_KIND_CHARS) : "unknown";
 				const detail = typeof body?.detail === "string" ? body.detail : "";
-				if (detail === "") return json(res, 400, { error: "invalid-request" });
+				if (detail === "") return {
+					status: 400,
+					value: { error: "invalid-request" }
+				};
 				ctx.logger.warn(`dsh-claude client [${kind}]: ${redactText(detail, MAX_DETAIL_CHARS)}`);
-				return json(res, 200, { ok: true });
+				return {
+					status: 200,
+					value: { ok: true }
+				};
 			} catch (error) {
-				if (error instanceof SyntaxError) return json(res, 400, { error: "invalid-json" });
-				return json(res, 400, { error: "invalid-request" });
+				if (error instanceof SyntaxError) return {
+					status: 400,
+					value: { error: "invalid-json" }
+				};
+				return {
+					status: 400,
+					value: { error: "invalid-request" }
+				};
 			}
 		}
-	}), "dsh-claude: client diagnostics route");
+	});
 }
 //#endregion
 //#region src/rewind-routes.ts
@@ -6105,55 +6780,78 @@ const MAX_SESSION_ID_CHARS = 1024;
 function record(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
-async function readJson(req) {
-	const chunks = [];
-	let size = 0;
-	for await (const chunk of req) {
-		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-		size += buffer.length;
-		if (size > MAX_BODY_BYTES) return void 0;
-		chunks.push(buffer);
+/** An oversized body fails the same field checks as a missing one; only
+*  malformed JSON is worth reporting separately. */
+async function readJson(io) {
+	try {
+		return record(await io.body(MAX_BODY_BYTES));
+	} catch (error) {
+		if (error instanceof SyntaxError) throw error;
+		return;
 	}
-	return record(JSON.parse(Buffer.concat(chunks).toString("utf8")));
 }
 /** `POST <path>` with `{ sessionId, seq }`: hide that surface event and every
 *  later one, and arm Claude to resume before the turn it opened. */
 function registerClaudeRewindRoute(ctx, sidecar, access) {
-	ctx.effect(() => ctx.webServer.register({
+	registerPluginRoute(ctx, {
+		mode: "unary",
 		kind: "exact",
 		path: CLAUDE_REWIND_PATH,
-		handler: async (req, res) => {
-			if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
-			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
+		methods: ["POST"],
+		budget: "git",
+		handler: async (io) => {
 			try {
-				const input = await readJson(req);
+				const input = await readJson(io);
 				const sessionId = input?.sessionId;
 				const seq = input?.seq;
-				if (typeof sessionId !== "string" || sessionId.length === 0 || sessionId.length > MAX_SESSION_ID_CHARS || typeof seq !== "number" || !Number.isSafeInteger(seq) || seq < 0) return json(res, 400, { error: "invalid-request" });
+				if (typeof sessionId !== "string" || sessionId.length === 0 || sessionId.length > MAX_SESSION_ID_CHARS || typeof seq !== "number" || !Number.isSafeInteger(seq) || seq < 0) return {
+					status: 400,
+					value: { error: "invalid-request" }
+				};
 				const events = access.eventsFor(sessionId);
-				if (events === void 0) return json(res, 409, { error: "session-unavailable" });
-				if (access.busy(sessionId)) return json(res, 409, { error: "session-busy" });
+				if (events === void 0) return {
+					status: 409,
+					value: { error: "session-unavailable" }
+				};
+				if (access.busy(sessionId)) return {
+					status: 409,
+					value: { error: "session-busy" }
+				};
 				const planned = planRewind((await sidecar.read(sessionId)).rewind ?? EMPTY_REWIND_STATE, events, seq);
-				if (planned === void 0) return json(res, 409, { error: "seq-unavailable" });
+				if (planned === void 0) return {
+					status: 409,
+					value: { error: "seq-unavailable" }
+				};
 				await sidecar.writeRewind(sessionId, planned);
 				await access.reset(sessionId);
-				return json(res, 200, { ranges: planned.ranges });
+				return {
+					status: 200,
+					value: { ranges: planned.ranges }
+				};
 			} catch (error) {
-				if (error instanceof SyntaxError) return json(res, 400, { error: "invalid-json" });
-				return json(res, 500, { error: "rewind-unavailable" });
+				if (error instanceof SyntaxError) return {
+					status: 400,
+					value: { error: "invalid-json" }
+				};
+				return {
+					status: 500,
+					value: { error: "rewind-unavailable" }
+				};
 			}
 		}
-	}), "dsh-claude: rewind route");
+	});
 }
 //#endregion
 //#region src/update-routes.ts
 const PLUGIN_PACKAGE_NAME = "@norman-else/dsh-claude";
-const UPDATE_TIMEOUT_MS = 3e4;
-const CHECK_TIMEOUT_MS = 1e4;
 const MAX_MANIFEST_BYTES = 262144;
 const MAX_UPDATE_OUTPUT_BYTES = 32768;
 const SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
 const PROFILE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+/** The route owns the deadline now. A direct caller with nothing to cancel
+*  against gets a signal that never fires, rather than a second timeout
+*  competing with the budget the route already declared. */
+const NEVER_ABORTS = new AbortController().signal;
 function safeMessage$1(error) {
 	return redactText(error instanceof Error ? error.message : String(error), 500);
 }
@@ -6272,7 +6970,7 @@ async function packageContext(deps) {
 		...installation === void 0 ? {} : { installation }
 	};
 }
-async function checkPluginUpdate(deps = {}) {
+async function checkPluginUpdate(deps = {}, signal = NEVER_ABORTS) {
 	try {
 		const { version, installation } = await packageContext(deps);
 		if (installation === void 0) return {
@@ -6299,7 +6997,7 @@ async function checkPluginUpdate(deps = {}) {
 			restartRequired: false,
 			message: "This installation source cannot be updated from the npm registry"
 		};
-		const latest = await (deps.fetchLatest ?? registryLatest)(AbortSignal.timeout(CHECK_TIMEOUT_MS));
+		const latest = await (deps.fetchLatest ?? registryLatest)(signal);
 		const comparison = compareVersions(version, latest);
 		return {
 			currentVersion: version,
@@ -6325,10 +7023,10 @@ async function verifyInstalledVersion(installation, expectedVersion) {
 	const installedManifest = await readManifest(join(installation.profileDir, "node_modules", ...PLUGIN_PACKAGE_NAME.split("/"), "package.json"));
 	if (installedManifest.name !== "@norman-else/dsh-claude" || installedManifest.version !== expectedVersion) throw new Error("DSH plugin update completed without installing the requested version");
 }
-async function updatePlugin(deps = {}) {
+async function updatePlugin(deps = {}, signal = NEVER_ABORTS) {
 	const { version, installation } = await packageContext(deps);
 	if (installation === void 0 || installation.source !== "registry") throw new Error("Plugin update is unavailable for this installation");
-	const latest = await (deps.fetchLatest ?? registryLatest)(AbortSignal.timeout(CHECK_TIMEOUT_MS));
+	const latest = await (deps.fetchLatest ?? registryLatest)(signal);
 	if (compareVersions(version, latest) >= 0) return {
 		currentVersion: version,
 		latestVersion: latest,
@@ -6340,7 +7038,6 @@ async function updatePlugin(deps = {}) {
 	const resolveExecutable = deps.resolveExecutable;
 	const spawn = deps.spawn;
 	if (resolveExecutable === void 0 || spawn === void 0) throw new Error("DSH update runtime is unavailable");
-	const signal = AbortSignal.timeout(UPDATE_TIMEOUT_MS);
 	const handle = spawn({
 		argv: [
 			await resolveExecutable("dsh", {}, signal),
@@ -6383,27 +7080,35 @@ function registerClaudeUpdateRoutes(ctx, runtime, deps = {}) {
 		resolveExecutable: runtime.resolveExecutable.bind(runtime),
 		spawn: runtime.spawn.bind(runtime)
 	};
-	for (const route of [{
+	const routes = [{
 		path: CLAUDE_UPDATE_CHECK_PATH,
 		method: "GET",
-		run: () => checkPluginUpdate(shared)
+		run: (signal) => checkPluginUpdate(shared, signal)
 	}, {
 		path: CLAUDE_UPDATE_PATH,
 		method: "POST",
-		run: () => updatePlugin(shared)
-	}]) ctx.effect(() => ctx.webServer.register({
+		run: (signal) => updatePlugin(shared, signal)
+	}];
+	for (const route of routes) registerPluginRoute(ctx, {
+		mode: "unary",
 		kind: "exact",
 		path: route.path,
-		handler: async (req, res) => {
-			if (req.method !== route.method) return json(res, 405, { error: "method not allowed" });
-			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
+		methods: [route.method],
+		budget: "remote",
+		handler: async (io) => {
 			try {
-				json(res, 200, await route.run());
+				return {
+					status: 200,
+					value: await route.run(io.signal)
+				};
 			} catch (error) {
-				json(res, 500, { error: safeMessage$1(error) });
+				return {
+					status: 500,
+					value: { error: safeMessage$1(error) }
+				};
 			}
 		}
-	}), `dsh-claude: ${route.method} ${route.path}`);
+	});
 }
 //#endregion
 //#region src/plan-usage-routes.ts
@@ -6420,22 +7125,32 @@ function safeMessage(error) {
 *  throwaway probe process so a refresh never depends on, or disturbs, a live
 *  Claude session. */
 function registerPlanUsageRoute(ctx, probe, now = Date.now) {
-	ctx.effect(() => ctx.webServer.register({
+	registerPluginRoute(ctx, {
+		mode: "unary",
 		kind: "exact",
 		path: CLAUDE_USAGE_PATH,
-		handler: async (req, res) => {
-			if (req.method !== "GET" && req.method !== "POST") return json(res, 405, { error: "method not allowed" });
-			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
-			if (req.method === "GET") return json(res, 200, latestPlanUsage() ?? EMPTY);
+		methods: ["GET", "POST"],
+		budget: "git",
+		handler: async (io) => {
+			if (io.method === "GET") return {
+				status: 200,
+				value: latestPlanUsage() ?? EMPTY
+			};
 			try {
 				const report = await probe(now());
 				recordPlanUsage(report);
-				json(res, 200, report);
+				return {
+					status: 200,
+					value: report
+				};
 			} catch (error) {
-				json(res, 500, { error: safeMessage(error) });
+				return {
+					status: 500,
+					value: { error: safeMessage(error) }
+				};
 			}
 		}
-	}), "dsh-claude: plan usage route");
+	});
 }
 //#endregion
 //#region src/global-settings.ts
@@ -6564,6 +7279,57 @@ const WORKTREE_BRANCH_PREFIX = {
 		else document.worktreeBranchPrefix = value;
 	}
 };
+/** Which renderer draws Claude's visible output. Plugin settings, not Claude's:
+*  the CLI has no opinion about how DSH paints a turn. The option labels stay
+*  machine-readable ids; the Client translates the two known values. */
+const RENDERER = {
+	key: "renderer",
+	kind: "select",
+	document: "plugin",
+	effect: "next-turn",
+	async options() {
+		return CLAUDE_RENDER_MODES.map((value) => ({
+			value,
+			label: value,
+			source: "built-in"
+		}));
+	},
+	read(document) {
+		const value = document.renderer;
+		return isClaudeRenderMode(value) ? value : DEFAULT_CLAUDE_RENDER_MODE;
+	},
+	apply(document, value) {
+		if (!isClaudeRenderMode(value)) throw new Error("Invalid value for global setting renderer");
+		if (value === "plugin") delete document.renderer;
+		else document.renderer = value;
+	}
+};
+/** Whether Claude's prose gets the highlight palette. Presentation only: no
+*  record carries it and nothing on the server reads it back, so unlike
+*  {@link RENDERER} the switch lands the moment the Client rewrites its own
+*  stylesheet — hence 'immediate' rather than 'next-turn'. */
+const PROSE = {
+	key: "prose",
+	kind: "select",
+	document: "plugin",
+	effect: "immediate",
+	async options() {
+		return CLAUDE_PROSE_MODES.map((value) => ({
+			value,
+			label: value,
+			source: "built-in"
+		}));
+	},
+	read(document) {
+		const value = document.prose;
+		return isClaudeProseMode(value) ? value : DEFAULT_CLAUDE_PROSE_MODE;
+	},
+	apply(document, value) {
+		if (!isClaudeProseMode(value)) throw new Error("Invalid value for global setting prose");
+		if (value === "plain") delete document.prose;
+		else document.prose = value;
+	}
+};
 function isBoundedInteger(value, min, max) {
 	return typeof value === "number" && Number.isInteger(value) && value >= min && value <= max;
 }
@@ -6587,6 +7353,8 @@ function integerSetting(key, min, max, defaultFor) {
 }
 const DESCRIPTORS = [
 	OUTPUT_STYLE,
+	RENDERER,
+	PROSE,
 	WORKTREE_BRANCH_PREFIX,
 	integerSetting("maxProcesses", 1, MAX_PROCESSES_LIMIT, (limits) => limits.maxProcesses),
 	integerSetting("idleTimeoutMinutes", 1, MAX_IDLE_TIMEOUT_MINUTES, (limits) => Math.max(1, Math.round(limits.idleTimeoutMs / 6e4)))
@@ -6648,6 +7416,17 @@ async function readSupervisorLimitOverrides(deps = {}) {
 		...isBoundedInteger(idleTimeoutMinutes, 1, MAX_IDLE_TIMEOUT_MINUTES) ? { idleTimeoutMs: idleTimeoutMinutes * 6e4 } : {}
 	};
 }
+/** The renderer the Host should produce output for. A missing, unreadable, or
+*  malformed plugin settings file keeps today's plugin-owned transcript. */
+async function readRenderMode(deps = {}) {
+	let document;
+	try {
+		document = await readDocument(pathsFor(deps).pluginSettingsFile);
+	} catch {
+		return DEFAULT_CLAUDE_RENDER_MODE;
+	}
+	return isClaudeRenderMode(document.renderer) ? document.renderer : DEFAULT_CLAUDE_RENDER_MODE;
+}
 async function readWorktreeBranchPrefix(deps = {}) {
 	const paths = pathsFor(deps);
 	return WORKTREE_BRANCH_PREFIX.read(await readDocument(paths.pluginSettingsFile));
@@ -6693,37 +7472,34 @@ function updateGlobalSettings(changes, deps = {}) {
 	pendingWrite = operation;
 	return operation;
 }
-async function requestJson(req) {
-	const declared = Number(req.headers["content-length"] ?? 0);
-	if (!Number.isFinite(declared) || declared < 0 || declared > MAX_REQUEST_BYTES) throw new Error("Request body is too large");
-	const chunks = [];
-	let bytes = 0;
-	for await (const chunk of req) {
-		const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-		bytes += data.byteLength;
-		if (bytes > MAX_REQUEST_BYTES) throw new Error("Request body is too large");
-		chunks.push(data);
-	}
-	const body = object(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+async function requestJson(io) {
+	const body = object(await io.body(MAX_REQUEST_BYTES));
 	if (body === void 0 || Object.keys(body).some((key) => key !== "changes")) throw new Error("Invalid global settings request");
 	return body.changes;
 }
 function registerClaudeGlobalSettingsRoute(ctx, deps = {}) {
-	ctx.effect(() => ctx.webServer.register({
+	registerPluginRoute(ctx, {
+		mode: "unary",
 		kind: "exact",
 		path: CLAUDE_GLOBAL_SETTINGS_PATH,
-		handler: async (req, res) => {
-			if (req.method !== "GET" && req.method !== "PATCH") return json(res, 405, { error: "method not allowed" });
-			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
+		methods: ["GET", "PATCH"],
+		budget: "fast",
+		handler: async (io) => {
 			try {
-				const result = req.method === "GET" ? await readGlobalSettings(deps) : await updateGlobalSettings(await requestJson(req), deps);
-				if (req.method === "PATCH") await deps.onUpdated?.();
-				json(res, 200, result);
+				const result = io.method === "GET" ? await readGlobalSettings(deps) : await updateGlobalSettings(await requestJson(io), deps);
+				if (io.method === "PATCH") await deps.onUpdated?.();
+				return {
+					status: 200,
+					value: result
+				};
 			} catch (error) {
-				json(res, 400, { error: error instanceof Error ? error.message : "Invalid global settings request" });
+				return {
+					status: 400,
+					value: { error: error instanceof Error ? error.message : "Invalid global settings request" }
+				};
 			}
 		}
-	}), "dsh-claude: global settings");
+	});
 }
 //#endregion
 //#region src/index.ts
@@ -6862,14 +7638,16 @@ async function apply(ctx, config) {
 	const supervisorConfig = {
 		executablePath: "",
 		defaultModel: config.model ?? "default",
+		renderMode: DEFAULT_CLAUDE_RENDER_MODE,
 		...defaultLimits
 	};
-	const applyLimitOverrides = async () => {
+	const applySettingsOverrides = async () => {
 		const overrides = await readSupervisorLimitOverrides();
 		supervisorConfig.idleTimeoutMs = overrides.idleTimeoutMs ?? defaultLimits.idleTimeoutMs;
 		supervisorConfig.maxProcesses = overrides.maxProcesses ?? defaultLimits.maxProcesses;
+		supervisorConfig.renderMode = await readRenderMode();
 	};
-	await applyLimitOverrides();
+	await applySettingsOverrides();
 	const sidecar = new ClaudeSidecarRepository();
 	const repositoryStatus = new RepositoryStatusService(ctx.subprocess);
 	const repositorySetup = new RepositorySetupService(ctx.subprocess, { branchPrefix: () => readWorktreeBranchPrefix() });
@@ -6886,7 +7664,7 @@ async function apply(ctx, config) {
 	let resolutionError;
 	try {
 		supervisorConfig.executablePath = (await resolveClaudeExecutable(ctx.subprocess, config.executablePath === void 0 || config.executablePath.length === 0 ? void 0 : config.executablePath)).path;
-		ctx.llm.registerAdapter([...CLAUDE_CODE_PROVIDER_IDS], createClaudeCodeAdapter(supervisor, ctx.agents, ctx.attachments, (agent) => ctx.agentPresets.composedPreset(agent.ctx), (sessionId) => reviewComments.drain(sessionId)));
+		ctx.llm.registerAdapter([...CLAUDE_CODE_PROVIDER_IDS], createClaudeCodeAdapter(supervisor, ctx.agents, ctx.attachments, (agent) => ctx.agentPresets.composedPreset(agent.ctx), (sessionId) => reviewComments.drain(sessionId), () => supervisorConfig.renderMode));
 		ctx.effect(() => {
 			const mounted = /* @__PURE__ */ new Map();
 			const pending = /* @__PURE__ */ new Set();
@@ -6975,7 +7753,7 @@ async function apply(ctx, config) {
 		registerClaudeUpdateRoutes(webCtx, webCtx.subprocess, { ...typeof desktopActions?.requestRestart === "function" ? { requestRestart: desktopActions.requestRestart.bind(desktopActions) } : {} });
 		registerClaudeGlobalSettingsRoute(webCtx, {
 			defaultLimits,
-			onUpdated: applyLimitOverrides
+			onUpdated: applySettingsOverrides
 		});
 		registerRepositorySetupRoute(webCtx, repositorySetup);
 		registerRepositoryStatusRoute(webCtx, repositoryStatus);