@norman-else/dsh-claude 0.1.40 → 0.1.42

package/lib/index.mjs

@@ -1,12 +1,12 @@
-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 { A as CLAUDE_REPOSITORY_FEEDBACK_PATH, B as DEFAULT_CLAUDE_RENDER_MODE, C as CLAUDE_PROJECTION_PATH, D as CLAUDE_PROSE_MODES, E as CLAUDE_PROMPT_REFINE_PATH, F as CLAUDE_REWIND_PATH, G as isClaudeRenderMode, H as TASK_TOOL_NAMES, I as CLAUDE_UPDATE_CHECK_PATH, L as CLAUDE_UPDATE_PATH, M as CLAUDE_REPOSITORY_SETUP_PATH, N as CLAUDE_REPOSITORY_STATUS_PATH, O as CLAUDE_RENDER_MODES, P as CLAUDE_REVIEW_COMMENT_PATH, R as CLAUDE_USAGE_PATH, S as CLAUDE_PLAN_FEEDBACK_PATH, T as CLAUDE_PROMPT_NAME_PATH, U as isClaudeAlertMode, W as isClaudeProseMode, _ as CLAUDE_CODE_PROVIDER_IDS, a as latestClaudeTasks, b as CLAUDE_GLOBAL_SETTINGS_PATH, c as normalizeTasksEvent, d as CLAUDE_ACTIVITY_EVENT, f as CLAUDE_ALERT_MODES, g as CLAUDE_CODE_PROVIDER, h as CLAUDE_CODE_PRESET_ID, i as latestClaudeSessionBinding, j as CLAUDE_REPOSITORY_FILE_PATH, k as CLAUDE_REPOSITORY_ACTION_PATH, l as redactText, m as CLAUDE_CLIENT_DIAGNOSTICS_PATH, n as currentClaudeActivityCursor, o as normalizeActivity, p as CLAUDE_ASK_PATH, r as latestClaudeContextUsage, s as normalizeContextUsage, t as boundText, u as safeDetail, v as CLAUDE_DOCTOR_PATH, w as CLAUDE_PROMPTS_PATH, x as CLAUDE_JIRA_PATH, y as CLAUDE_EDITOR_OPEN_PATH, z as DEFAULT_CLAUDE_PROSE_MODE } from "./events-oovRTmX7.mjs";
+import { a as projectClaudeCommands, i as CLAUDE_COMMANDS_SERVICE, r as dynamicPresenterDefinition, t as CLAUDE_PRESENTER_NAMES } from "./presenters-BVWj7u0a.mjs";
+import { a as resolveClaudeExecutable, n as ensureManagedPreset, o as runClaudeDoctor, t as ManagedPresetConflictError } from "./preset-installer-JUktnfwS.mjs";
 import z from "@deepseek-ai/schemastery";
 import { createHash, randomUUID } from "node:crypto";
 import { chmod, mkdir, opendir, readFile, readdir, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, isAbsolute, join, resolve, sep } from "node:path";
 import { dshHomePath, resolveDshHome } from "@deepseek-ai/dsh-home-paths";
-import { homedir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { LlmAdapter, ReasoningEffortId, ToolCallId, createToolResultMessage } from "@deepseek-ai/dsh-llm";
 import { EventEmitter } from "node:events";
@@ -17,7 +17,8 @@ import { StringDecoder } from "node:string_decoder";
 //#region src/rewind.ts
 const EMPTY_REWIND_STATE = {
 	ranges: [],
-	anchors: []
+	anchors: [],
+	snapshots: []
 };
 /** Absorb one span into an ascending, non-overlapping range list. Adjacent
 *  spans merge so a rewind of a rewind reads as one hidden block. */
@@ -50,15 +51,32 @@ function recordRewindAnchor(state, anchor) {
 		anchors
 	};
 }
+/** Record the working tree one turn was admitted against, replacing a re-run
+*  turn's. */
+function recordRewindSnapshot(state, snapshot) {
+	const snapshots = [...state.snapshots.filter((item) => item.turn !== snapshot.turn), snapshot].sort((left, right) => left.turn - right.turn).slice(-100);
+	return {
+		...state,
+		snapshots
+	};
+}
 /** The turn a surface seq belongs to: the first turn opened at or after it.
 *  A message accepted but never run belongs to no logged turn, so nothing
 *  Claude holds is discarded and every anchor stays valid. */
 function turnAtOrAfter(events, seq) {
 	for (const event of events) if (event.seq >= seq && event.type === "turn/start") return event.data.turn;
 }
+/** The working tree a rewind at `seq` restores: the snapshot of the first turn
+*  it discards. Undefined when nothing is discarded, or when that turn ran
+*  before this session captured trees. */
+function rewindRestoreTree(state, events, seq) {
+	const turn = turnAtOrAfter(events, seq);
+	return turn === void 0 ? void 0 : state.snapshots.find((item) => item.turn === turn)?.tree;
+}
 /** Plan one rewind at `seq`, or undefined when the seq is not in the log.
-*  Anchors of the discarded turns go with them: after this rewind Claude no
-*  longer holds those entries, so a later rewind must never fork at one. */
+*  Anchors and snapshots of the discarded turns go with them: after this
+*  rewind Claude no longer holds those entries, so a later rewind must never
+*  fork at one — nor restore a tree for a turn that no longer exists. */
 function planRewind(state, events, seq) {
 	const last = events.at(-1)?.seq;
 	if (last === void 0 || seq > last) return void 0;
@@ -71,6 +89,7 @@ function planRewind(state, events, seq) {
 			end: last
 		}),
 		anchors,
+		snapshots: state.snapshots.filter((item) => item.turn < turn),
 		pending: kept === void 0 ? { fresh: true } : { resumeAt: kept.uuid }
 	};
 }
@@ -88,7 +107,7 @@ function emptyProjection() {
 		activities: []
 	};
 }
-function record$13(value) {
+function record$14(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 function finiteInteger(value) {
@@ -98,7 +117,7 @@ function string$4(value, max) {
 	return typeof value === "string" && value.length > 0 && value.length <= max;
 }
 function binding(value) {
-	const input = record$13(value);
+	const input = record$14(value);
 	if (input === void 0 || !string$4(input.claudeSessionId, 512) || !string$4(input.sdkVersion, 128) || !string$4(input.cwd, 4096) || input.cliVersion !== void 0 && !string$4(input.cliVersion, 128)) return void 0;
 	return {
 		claudeSessionId: input.claudeSessionId,
@@ -129,21 +148,21 @@ const ACTIVITY_PHASES = /* @__PURE__ */ new Set([
 	"failed"
 ]);
 function activity(value) {
-	const input = record$13(value);
+	const input = record$14(value);
 	if (input === void 0 || !finiteInteger(input.turn) || !finiteInteger(input.step) || !finiteInteger(input.ordinal) || typeof input.kind !== "string" || !ACTIVITY_KINDS.has(input.kind) || input.phase !== void 0 && (typeof input.phase !== "string" || !ACTIVITY_PHASES.has(input.phase))) return void 0;
 	return normalizeActivity(input);
 }
 function contextUsage(value) {
-	const input = record$13(value);
+	const input = record$14(value);
 	if (input === void 0 || !Array.isArray(input.categories)) return void 0;
 	return normalizeContextUsage(input);
 }
 function rewind(value) {
-	const input = record$13(value);
+	const input = record$14(value);
 	if (input === void 0 || !Array.isArray(input.ranges) || input.ranges.length > 200 || !Array.isArray(input.anchors) || input.anchors.length > 2e3) return void 0;
 	const ranges = [];
 	for (const item of input.ranges) {
-		const range = record$13(item);
+		const range = record$14(item);
 		if (range === void 0 || !finiteInteger(range.start) || !finiteInteger(range.end) || range.end < range.start) return void 0;
 		ranges.push({
 			start: range.start,
@@ -152,38 +171,53 @@ function rewind(value) {
 	}
 	const anchors = [];
 	for (const item of input.anchors) {
-		const anchor = record$13(item);
+		const anchor = record$14(item);
 		if (anchor === void 0 || !finiteInteger(anchor.turn) || !string$4(anchor.uuid, 128)) return void 0;
 		anchors.push({
 			turn: anchor.turn,
 			uuid: anchor.uuid
 		});
 	}
-	const pending = record$13(input.pending);
+	const snapshots = [];
+	if (input.snapshots !== void 0) {
+		if (!Array.isArray(input.snapshots) || input.snapshots.length > 100) return void 0;
+		for (const item of input.snapshots) {
+			const snapshot = record$14(item);
+			if (snapshot === void 0 || !finiteInteger(snapshot.turn) || !string$4(snapshot.tree, 64)) return void 0;
+			snapshots.push({
+				turn: snapshot.turn,
+				tree: snapshot.tree
+			});
+		}
+	}
+	const pending = record$14(input.pending);
 	if (input.pending !== void 0 && pending === void 0) return void 0;
 	if (pending === void 0) return {
 		ranges,
-		anchors
+		anchors,
+		snapshots
 	};
 	if (pending.fresh === true) return {
 		ranges,
 		anchors,
+		snapshots,
 		pending: { fresh: true }
 	};
 	if (!string$4(pending.resumeAt, 128)) return void 0;
 	return {
 		ranges,
 		anchors,
+		snapshots,
 		pending: { resumeAt: pending.resumeAt }
 	};
 }
 function tasks(value) {
-	const input = record$13(value);
+	const input = record$14(value);
 	if (input === void 0 || !Array.isArray(input.tasks)) return void 0;
 	return normalizeTasksEvent(input.tasks);
 }
 function parseClaudeSidecar(value) {
-	const input = record$13(value);
+	const input = record$14(value);
 	if (input === void 0 || input.schemaVersion !== SIDECAR_SCHEMA_VERSION || !finiteInteger(input.revision) || !Array.isArray(input.activities) || input.activities.length > MAX_ACTIVITIES) throw new Error("dsh-claude: invalid sidecar document");
 	const activities = input.activities.map(activity);
 	if (activities.some((item) => item === void 0)) throw new Error("dsh-claude: invalid sidecar activity");
@@ -411,11 +445,19 @@ var ClaudeSidecarRepository = class {
 		});
 	}
 	/** Land one planned rewind: hidden ranges, surviving anchors, and the fork
-	*  target the next Claude spawn consumes. */
-	writeRewind(sessionId, value) {
+	*  target the next Claude spawn consumes.
+	*
+	*  `droppedFromTurn` also drops the discarded turns' activity. The hidden
+	*  ranges are surface seqs and activity records carry none, so a reader that
+	*  works in turns — the plan panel, the task board — has nothing to filter
+	*  on and would go on showing a plan the session no longer contains. This
+	*  projection is rebuildable from the session log, so trimming it is not
+	*  losing anything the log still holds. */
+	writeRewind(sessionId, value, droppedFromTurn) {
 		return this.#update(sessionId, (current) => ({
 			...current,
-			rewind: value
+			rewind: value,
+			...droppedFromTurn === void 0 ? {} : { activities: current.activities.filter((activity) => activity.turn < droppedFromTurn) }
 		}), false, { kind: "sync" });
 	}
 	/** Remember where Claude's chain ended for one completed DSH turn. */
@@ -428,6 +470,16 @@ var ClaudeSidecarRepository = class {
 			})
 		}));
 	}
+	/** Remember the working tree one DSH turn was admitted against. */
+	recordRewindSnapshot(sessionId, turn, tree) {
+		return this.#update(sessionId, (current) => ({
+			...current,
+			rewind: recordRewindSnapshot(current.rewind ?? EMPTY_REWIND_STATE, {
+				turn,
+				tree
+			})
+		}));
+	}
 	/** Disarm the fork target once a Claude process has resumed at it, so a
 	*  later respawn continues the rewound session instead of re-truncating it. */
 	clearRewindPending(sessionId) {
@@ -435,7 +487,8 @@ var ClaudeSidecarRepository = class {
 			...current,
 			rewind: {
 				ranges: current.rewind.ranges,
-				anchors: current.rewind.anchors
+				anchors: current.rewind.anchors,
+				snapshots: current.rewind.snapshots
 			}
 		});
 	}
@@ -600,6 +653,93 @@ var AsyncQueue = class {
 	}
 };
 //#endregion
+//#region src/plan-feedback.ts
+const MAX_NOTES = 30;
+const MAX_NOTE_CHARS = 2e3;
+const MAX_QUOTE_CHARS = 1e3;
+var PlanFeedbackError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "PlanFeedbackError";
+		this.code = code;
+	}
+};
+/** Validate and bound one submission's notes. */
+function planNotesOf(value) {
+	if (!Array.isArray(value) || value.length === 0 || value.length > MAX_NOTES) throw new PlanFeedbackError("invalid-request", "The review notes are invalid.");
+	return value.map((item) => {
+		const note = item !== null && typeof item === "object" ? item : void 0;
+		const text = typeof note?.text === "string" ? note.text.trim() : "";
+		if (text.length === 0 || text.length > MAX_NOTE_CHARS) throw new PlanFeedbackError("invalid-request", "A review note is empty or too long.");
+		const quote = typeof note?.quote === "string" ? note.quote.trim().slice(0, MAX_QUOTE_CHARS) : "";
+		return quote.length === 0 ? { text } : {
+			quote,
+			text
+		};
+	});
+}
+/** What Claude is told when the reviewer asks for changes.
+*
+*  Addressed to Claude rather than logged at it: a rejection it cannot act on
+*  is the thing this whole path exists to replace. The quotes are fenced as
+*  block quotes so a passage containing its own Markdown cannot be mistaken
+*  for the reviewer's instruction. */
+function planFeedbackMessage(notes) {
+	return [
+		"The user reviewed the plan in DeepSeek Harness and asked for changes rather than approving or rejecting it.",
+		"",
+		notes.map((note) => note.quote === void 0 ? note.text : `On this part of the plan:\n${note.quote.split("\n").map((line) => `> ${line}`).join("\n")}\n\n${note.text}`).join("\n\n---\n\n"),
+		"",
+		"Revise the plan accordingly and propose it again."
+	].join("\n");
+}
+/** The seam between the panel's "send for changes" and the permission bridge
+*  waiting on that plan's approval.
+*
+*  The approval promise lives inside the bridge and cannot be resolved from
+*  outside, so the bridge races it against this gate instead: whichever
+*  answers first decides, and the loser is aborted. One waiter per tool use —
+*  a plan is approved once. */
+var PlanFeedbackGate = class {
+	#waiting = /* @__PURE__ */ new Map();
+	/** Notes for the plan under `toolUseId`, or undefined when the wait is
+	*  abandoned because the approval surface answered first. */
+	wait(toolUseId, signal) {
+		return new Promise((resolve) => {
+			const settle = (notes) => {
+				if (this.#waiting.get(toolUseId) === deliver) this.#waiting.delete(toolUseId);
+				signal.removeEventListener("abort", onAbort);
+				resolve(notes);
+			};
+			const deliver = (notes) => {
+				settle(notes);
+			};
+			const onAbort = () => {
+				settle(void 0);
+			};
+			if (signal.aborted) {
+				resolve(void 0);
+				return;
+			}
+			signal.addEventListener("abort", onAbort, { once: true });
+			this.#waiting.set(toolUseId, deliver);
+		});
+	}
+	/** Hand notes to a waiting plan approval. False when nothing is waiting —
+	*  the plan was already decided, or never existed. */
+	submit(toolUseId, notes) {
+		const deliver = this.#waiting.get(toolUseId);
+		if (deliver === void 0) return false;
+		deliver(notes);
+		return true;
+	}
+	/** Whether a plan is currently open for review. */
+	pending(toolUseId) {
+		return this.#waiting.has(toolUseId);
+	}
+};
+//#endregion
 //#region src/permission.ts
 function denialMessage(outcome) {
 	switch (outcome) {
@@ -609,10 +749,56 @@ function denialMessage(outcome) {
 		case "allowed-once": return "";
 	}
 }
+/** Claude leaving plan mode is not an ordinary tool call: its argument is the
+*  plan, written for the user, and the approval that follows is the user
+*  agreeing to it. Everything else reads better as a prompt plus its input. */
+const PLAN_TOOL = "ExitPlanMode";
+const MAX_REASON_CHARS = 1200;
+/** What the approval dialog says instead of the plan.
+*
+*  A plan is written to be read at length, and the approval dialog is a
+*  cramped modal that renders its reason as plain text: pasting the plan there
+*  turned a document into an unreadable wall. The decision stays with the Host
+*  — this is still an ordinary tool approval — and the plan itself is drawn by
+*  the plugin's own panel, where Markdown and the reader's chosen prose
+*  palette both apply. The dialog only has to say what is being decided and
+*  where to read it. */
+const PLAN_APPROVAL_PROMPT = "Claude proposed a plan. Read it in the Plan panel, then approve or reject here.";
+/** The plan an `ExitPlanMode` call carries, if it carries one.
+*
+*  Travels to the client on the permission activity's `text` field: `summary`
+*  is capped at 1k and `detail` at 4k, both of which truncate a real plan,
+*  while `text` holds 64k. Only `kind: 'text'` activities are drawn as prose
+*  by the transcript, so a plan riding a `kind: 'permission'` record reaches
+*  the panel without being painted twice. */
+function planText(toolName, input) {
+	if (toolName !== PLAN_TOOL) return void 0;
+	return typeof input.plan === "string" && input.plan.length > 0 ? input.plan : void 0;
+}
+/** The session's approval-policy override, or undefined when it never switched.
+*
+*  The same fold the approval service does — the last `approval/policy` event
+*  wins, because replaying the log IS the state. Read here rather than
+*  imported so this package keeps its runtime surface to the Host services it
+*  is actually handed. */
+function approvalPolicyOf(events) {
+	for (let index = events.length - 1; index >= 0; index -= 1) {
+		const event = events[index];
+		if (event?.type !== "approval/policy") continue;
+		const policy = event.data.policy;
+		return typeof policy === "string" ? policy : void 0;
+	}
+}
+/** The policy that answers every request with `rejected` before reaching an
+*  answerer, so no approval surface is ever shown. DSH writes it alongside
+*  `sandbox/mode: danger-full-access` — Full access means "stop asking". */
+const SILENT_POLICY = "never";
+const ASKING_POLICY = "ask";
 function permissionReason(toolName, input, options) {
+	if (planText(toolName, input) !== void 0) return PLAN_APPROVAL_PROMPT;
 	const prompt = options.title ?? options.description ?? options.decisionReason ?? `Claude Code wants to use ${toolName}.`;
 	const detail = safeDetail(input);
-	return boundText(detail === void 0 ? prompt : `${prompt}\nInput: ${detail}`, 1200);
+	return boundText(detail === void 0 ? prompt : `${prompt}\nInput: ${detail}`, MAX_REASON_CHARS);
 }
 function mapApprovalOutcome(outcome, input, toolUseID) {
 	if (outcome === "allowed-once") return {
@@ -628,7 +814,7 @@ function mapApprovalOutcome(outcome, input, toolUseID) {
 		decisionClassification: "user_reject"
 	};
 }
-function createPermissionBridge(approval, activeContext, userQuestion) {
+function createPermissionBridge(approval, activeContext, userQuestion, planFeedback) {
 	return async (toolName, input, options) => {
 		if (toolName === "AskUserQuestion") return userQuestion === void 0 ? {
 			behavior: "deny",
@@ -645,6 +831,9 @@ function createPermissionBridge(approval, activeContext, userQuestion) {
 		};
 		active.markActivity?.();
 		const reason = permissionReason(toolName, input, options);
+		const plan = planText(toolName, input);
+		const session = active.agent.session;
+		let silenced = false;
 		try {
 			await active.appendActivity({
 				kind: "permission",
@@ -653,16 +842,50 @@ function createPermissionBridge(approval, activeContext, userQuestion) {
 				toolName,
 				title: options.displayName ?? toolName,
 				summary: options.title ?? options.description ?? reason,
-				detail: input
+				detail: input,
+				...plan === void 0 ? {} : { text: plan }
 			});
-			const alreadyFullAccess = await active.hasFullAccess?.() === true;
-			const outcome = alreadyFullAccess ? "allowed-once" : await approval.request({
+			const userDecides = plan !== void 0;
+			silenced = userDecides && approvalPolicyOf(session.events) === SILENT_POLICY;
+			if (silenced) session.append("approval/policy", { policy: ASKING_POLICY });
+			const alreadyFullAccess = !userDecides && await active.hasFullAccess?.() === true;
+			const revision = new AbortController();
+			const notes = plan === void 0 || planFeedback === void 0 ? void 0 : planFeedback.wait(options.toolUseID, AbortSignal.any([options.signal, revision.signal]));
+			const decided = new AbortController();
+			const asked = alreadyFullAccess ? Promise.resolve("allowed-once") : approval.request({
 				agent: active.agent,
 				toolName,
 				reason,
-				signal: options.signal
+				signal: notes === void 0 ? options.signal : AbortSignal.any([options.signal, decided.signal])
+			});
+			const answer = notes === void 0 ? { outcome: await asked } : await Promise.race([asked.then((outcome) => {
+				revision.abort();
+				return { outcome };
+			}), notes.then((value) => value === void 0 ? void 0 : { revisions: value })]).then(async (first) => {
+				if (first !== void 0 && "revisions" in first) decided.abort();
+				return first ?? { outcome: await asked };
 			});
-			const fullAccess = alreadyFullAccess || await active.hasFullAccess?.() === true;
+			if ("revisions" in answer) {
+				const message = planFeedbackMessage(answer.revisions);
+				active.recordDenial?.(options.toolUseID);
+				await active.appendActivity({
+					kind: "permission",
+					phase: "denied",
+					toolUseId: options.toolUseID,
+					toolName,
+					title: options.displayName ?? toolName,
+					summary: "Sent back for changes in DeepSeek Harness",
+					text: message
+				});
+				return {
+					behavior: "deny",
+					message,
+					toolUseID: options.toolUseID,
+					decisionClassification: "user_reject"
+				};
+			}
+			const outcome = answer.outcome;
+			const fullAccess = alreadyFullAccess || !userDecides && await active.hasFullAccess?.() === true;
 			const effectiveOutcome = fullAccess ? "allowed-once" : outcome;
 			const result = mapApprovalOutcome(effectiveOutcome, input, options.toolUseID);
 			if (result.behavior === "deny") active.recordDenial?.(options.toolUseID);
@@ -695,6 +918,10 @@ function createPermissionBridge(approval, activeContext, userQuestion) {
 				toolUseID: options.toolUseID,
 				decisionClassification: "user_reject"
 			};
+		} finally {
+			try {
+				if (silenced) session.append("approval/policy", { policy: SILENT_POLICY });
+			} catch {}
 		}
 	};
 }
@@ -814,7 +1041,7 @@ function createUserQuestionBridge(userQuestions, activeContext) {
 }
 //#endregion
 //#region src/sdk-messages.ts
-function record$12(value) {
+function record$13(value) {
 	return value !== null && typeof value === "object" ? value : void 0;
 }
 function string$3(value) {
@@ -846,12 +1073,12 @@ function hasUsageCounts(usage) {
 	return usage.inputTokens !== void 0 || usage.outputTokens !== void 0 || usage.cacheReadTokens !== void 0 || usage.cacheCreationTokens !== void 0;
 }
 function resultUsage(message) {
-	const normalized = usageOf(record$12(message.usage));
+	const normalized = usageOf(record$13(message.usage));
 	if (typeof message.total_cost_usd === "number") normalized.cumulativeCostUsd = message.total_cost_usd;
 	return normalized;
 }
 function normalizeAssistant(message) {
-	const envelope = record$12(message.message);
+	const envelope = record$13(message.message);
 	const content = envelope?.content;
 	if (!Array.isArray(content)) return [{
 		kind: "protocol-error",
@@ -861,7 +1088,7 @@ function normalizeAssistant(message) {
 	const parentToolUseId = string$3(message.parent_tool_use_id);
 	const normalized = [];
 	for (const item of content) {
-		const block = record$12(item);
+		const block = record$13(item);
 		if (block === void 0) continue;
 		if (block.type === "text") {
 			const text = string$3(block.text);
@@ -890,7 +1117,7 @@ function normalizeAssistant(message) {
 			});
 		}
 	}
-	const usage = usageOf(record$12(envelope?.usage));
+	const usage = usageOf(record$13(envelope?.usage));
 	if (hasUsageCounts(usage)) normalized.push({
 		kind: "request-usage",
 		usage,
@@ -900,7 +1127,7 @@ function normalizeAssistant(message) {
 }
 function normalizeUser(message) {
 	if (message.isReplay === true) return [];
-	const content = record$12(message.message)?.content;
+	const content = record$13(message.message)?.content;
 	if (typeof content === "string") return [];
 	if (!Array.isArray(content)) return [{
 		kind: "protocol-error",
@@ -910,7 +1137,7 @@ function normalizeUser(message) {
 	const parentToolUseId = string$3(message.parent_tool_use_id);
 	const normalized = [];
 	for (const item of content) {
-		const block = record$12(item);
+		const block = record$13(item);
 		if (block?.type !== "tool_result") continue;
 		const toolUseId = string$3(block.tool_use_id);
 		if (toolUseId === void 0) continue;
@@ -991,7 +1218,7 @@ function normalizeSystem(message) {
 		const summary = string$3(message.summary);
 		const subagentType = string$3(message.subagent_type);
 		const lastToolName = string$3(message.last_tool_name);
-		const usage = taskUsageOf(record$12(message.usage));
+		const usage = taskUsageOf(record$13(message.usage));
 		return [{
 			kind: "subagent",
 			title: summary ?? description ?? "Claude subagent update",
@@ -1007,7 +1234,7 @@ function normalizeSystem(message) {
 		}];
 	}
 	if (subtype === "task_updated") {
-		const patch = record$12(message.patch);
+		const patch = record$13(message.patch);
 		const status = string$3(patch?.status);
 		const taskId = string$3(message.task_id);
 		const description = string$3(patch?.description);
@@ -1030,7 +1257,7 @@ function normalizeSystem(message) {
 		const taskId = string$3(message.task_id);
 		const summary = string$3(message.summary);
 		const taskStatus = failed ? "failed" : stopped ? "stopped" : "completed";
-		const usage = taskUsageOf(record$12(message.usage));
+		const usage = taskUsageOf(record$13(message.usage));
 		return [{
 			kind: "subagent",
 			title: summary ?? taskId ?? "Claude subagent finished",
@@ -1045,7 +1272,7 @@ function normalizeSystem(message) {
 	if (subtype === "background_tasks_changed") return [{
 		kind: "background-tasks",
 		tasks: (Array.isArray(message.tasks) ? message.tasks : []).flatMap((item) => {
-			const entry = record$12(item);
+			const entry = record$13(item);
 			const taskId = string$3(entry?.task_id);
 			const description = string$3(entry?.description);
 			const taskType = string$3(entry?.task_type);
@@ -1063,7 +1290,7 @@ function normalizeSystem(message) {
 		detail: message
 	}];
 	if (subtype === "compact_boundary") {
-		const metadata = record$12(message.compact_metadata);
+		const metadata = record$13(message.compact_metadata);
 		const trigger = metadata?.trigger === "auto" || metadata?.trigger === "manual" ? metadata.trigger : void 0;
 		const preTokens = finiteNumber(metadata?.pre_tokens);
 		const postTokens = finiteNumber(metadata?.post_tokens);
@@ -1102,10 +1329,10 @@ const RESULT_ERROR_SUBTYPES = /* @__PURE__ */ new Set([
 function normalizeSdkMessage(message) {
 	const value = message;
 	if (value.type === "stream_event") {
-		const event = record$12(value.event);
+		const event = record$13(value.event);
 		const parentToolUseId = string$3(value.parent_tool_use_id);
 		if (event?.type === "content_block_delta") {
-			const delta = record$12(event.delta);
+			const delta = record$13(event.delta);
 			if (delta?.type === "text_delta") {
 				const text = string$3(delta.text);
 				return text === void 0 ? [] : [{
@@ -1140,7 +1367,7 @@ function normalizeSdkMessage(message) {
 		const errors = Array.isArray(value.errors) ? value.errors.filter((item) => typeof item === "string") : void 0;
 		const terminalReason = string$3(value.terminal_reason);
 		const userMessageUuid = string$3(value.user_message_uuid);
-		const permissionDenials = Array.isArray(value.permission_denials) ? value.permission_denials.map((item) => record$12(item)).filter((item) => item !== void 0).map((item) => {
+		const permissionDenials = Array.isArray(value.permission_denials) ? value.permission_denials.map((item) => record$13(item)).filter((item) => item !== void 0).map((item) => {
 			const toolName = string$3(item.tool_name);
 			const toolUseId = string$3(item.tool_use_id);
 			return toolName === void 0 || toolUseId === void 0 ? void 0 : {
@@ -1166,7 +1393,7 @@ function normalizeSdkMessage(message) {
 		detail: value.error ?? value.output
 	}];
 	if (value.type === "rate_limit_event") {
-		const status = string$3(record$12(value.rate_limit_info)?.status);
+		const status = string$3(record$13(value.rate_limit_info)?.status);
 		return [{
 			kind: "status",
 			title: status !== void 0 && status !== "allowed" ? "Claude rate limit is blocking requests" : "Claude rate limit status changed",
@@ -1279,7 +1506,7 @@ const FIXED_WINDOWS = [
 	"seven_day_opus",
 	"seven_day_sonnet"
 ];
-function record$11(value) {
+function record$12(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 /** Utilization is documented as 0-100; clamp so a server glitch cannot render
@@ -1291,7 +1518,7 @@ function resetsAt(value) {
 	return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 function window(id, source, label) {
-	const entry = record$11(source);
+	const entry = record$12(source);
 	if (entry === void 0) return void 0;
 	const used = utilization(entry.utilization);
 	const reset = resetsAt(entry.resets_at);
@@ -1305,9 +1532,9 @@ function window(id, source, label) {
 }
 /** Project the SDK's `/usage` response onto the windows the settings card shows. */
 function normalizePlanUsage(value, fetchedAt) {
-	const response = record$11(value);
+	const response = record$12(value);
 	const subscription = typeof response?.subscription_type === "string" ? response.subscription_type : void 0;
-	const limits = record$11(response?.rate_limits);
+	const limits = record$12(response?.rate_limits);
 	if (response?.rate_limits_available !== true || limits === void 0) return {
 		available: false,
 		...subscription === void 0 ? {} : { subscription },
@@ -1315,7 +1542,7 @@ function normalizePlanUsage(value, fetchedAt) {
 		fetchedAt
 	};
 	const windows = [...FIXED_WINDOWS.map((id) => window(id, limits[id])), ...(Array.isArray(limits.model_scoped) ? limits.model_scoped : []).map((entry, index) => {
-		const name = record$11(entry)?.display_name;
+		const name = record$12(entry)?.display_name;
 		return window(`model:${typeof name === "string" ? name : index}`, entry, typeof name === "string" ? name : void 0);
 	})].filter((entry) => entry !== void 0);
 	return {
@@ -1442,6 +1669,115 @@ function createManagedClaudeSpawner(runtime, executablePath, observe) {
 	};
 }
 //#endregion
+//#region src/worktree-snapshot.ts
+/** Working-tree snapshots taken and restored with git's own plumbing.
+*
+*  A rewind that only truncates Claude's transcript leaves the files Claude
+*  wrote on disk, so the next turn resumes against a checkout the model no
+*  longer remembers writing. Git already stores trees: a throwaway index turns
+*  the working tree into one tree object without touching HEAD, the real
+*  index, or the checkout, and a restore reads that tree back.
+*
+*  Ignored files stay outside the snapshot in both directions. `git add -A`
+*  honours `.gitignore`, so build output and `node_modules` are neither
+*  captured nor removed.
+*/
+const MAX_OUTPUT_BYTES$5 = 65536;
+/** `add -A` walks the whole checkout; a large repository needs more than the
+*  status probes' five seconds, and this sits in front of every turn. */
+const GIT_TIMEOUT_MS$4 = 3e4;
+const OBJECT_NAME = /^[0-9a-f]{40}$|^[0-9a-f]{64}$/u;
+async function collect$4(handle) {
+	return {
+		exitCode: (await handle.done).exitCode,
+		stdout: handle.collected.stdout?.readFrom(0).text ?? ""
+	};
+}
+async function run$1(runtime, git, args, cwd, env = {}) {
+	return collect$4(runtime.spawn({
+		argv: [git, ...args],
+		cwd,
+		stdio: {
+			stdin: "ignore",
+			stdout: { maxBytes: MAX_OUTPUT_BYTES$5 },
+			stderr: { maxBytes: MAX_OUTPUT_BYTES$5 }
+		},
+		graceMs: 1e3,
+		signal: AbortSignal.timeout(GIT_TIMEOUT_MS$4),
+		env
+	}));
+}
+/** Capture the working tree as a git tree object.
+*
+*  Undefined whenever git cannot answer -- no git, not a repository, a locked
+*  or broken checkout. Snapshots are advisory: a turn without one simply
+*  cannot offer a file rewind, and must never fail for it.
+*
+*  ponytail: the tree is unreachable from any ref, so `git gc --prune` will
+*  eventually collect it. Two weeks is git's default grace period and a rewind
+*  happens minutes after the turn it undoes; anchor it to a real ref only if
+*  snapshots ever need to outlive a gc.
+*/
+async function captureWorktreeTree(runtime, cwd) {
+	let git;
+	try {
+		git = await runtime.resolveExecutable("git");
+	} catch {
+		return;
+	}
+	const indexFile = join(tmpdir(), `dsh-claude-index-${process.pid}-${randomUUID()}`);
+	const env = { GIT_INDEX_FILE: indexFile };
+	try {
+		await run$1(runtime, git, ["read-tree", "HEAD"], cwd, env);
+		if ((await run$1(runtime, git, ["add", "-A"], cwd, env)).exitCode !== 0) return void 0;
+		const written = await run$1(runtime, git, ["write-tree"], cwd, env);
+		const tree = written.stdout.trim();
+		return written.exitCode === 0 && OBJECT_NAME.test(tree) ? tree : void 0;
+	} catch {
+		return;
+	} finally {
+		await rm(indexFile, { force: true }).catch(() => void 0);
+	}
+}
+/** Put a captured tree back over the working tree, reporting whether it landed.
+*
+*  Files the tree holds are rewritten, and files created after the snapshot are
+*  removed. Nothing outside the snapshot's own scope is touched: ignored files
+*  survive, because `clean` runs without `-x`.
+*/
+async function restoreWorktreeTree(runtime, cwd, tree) {
+	if (!OBJECT_NAME.test(tree)) return false;
+	let git;
+	try {
+		git = await runtime.resolveExecutable("git");
+	} catch {
+		return false;
+	}
+	try {
+		const kind = await run$1(runtime, git, [
+			"cat-file",
+			"-t",
+			tree
+		], cwd);
+		if (kind.exitCode !== 0 || kind.stdout.trim() !== "tree") return false;
+		if ((await run$1(runtime, git, [
+			"read-tree",
+			"--reset",
+			"-u",
+			tree
+		], cwd)).exitCode !== 0) return false;
+		await run$1(runtime, git, ["clean", "-fd"], cwd);
+		await run$1(runtime, git, [
+			"reset",
+			"--mixed",
+			"HEAD"
+		], cwd);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
 //#region src/supervisor.ts
 const CLAUDE_INITIALIZATION_TIMEOUT_MS = 3e4;
 /** Control requests must settle; a wedged one must not clog the metadata chain. */
@@ -1504,6 +1840,21 @@ async function withTimeout(operation, timeoutMs, label) {
 		if (timer !== void 0) clearTimeout(timer);
 	}
 }
+async function withAbort(operation, signal) {
+	if (signal === void 0) return operation;
+	if (signal.aborted) throw abortFailure();
+	let abortListener;
+	try {
+		return await Promise.race([operation, new Promise((_resolve, reject) => {
+			abortListener = () => {
+				reject(abortFailure());
+			};
+			signal.addEventListener("abort", abortListener, { once: true });
+		})]);
+	} finally {
+		if (abortListener !== void 0) signal.removeEventListener("abort", abortListener);
+	}
+}
 /** The uuid of one main-chain transcript entry, or undefined for anything a
 *  rewind must not fork at: stream partials, results, and sidechain traffic. */
 function chainEntryUuid(message) {
@@ -1549,6 +1900,8 @@ var ClaudeSupervisor = class {
 	#runtime;
 	#approval;
 	#userQuestions;
+	/** Lets the plan panel answer a plan's approval with revisions. */
+	planFeedback = new PlanFeedbackGate();
 	#config;
 	#queryFactory;
 	#runDetached;
@@ -1557,6 +1910,15 @@ var ClaudeSupervisor = class {
 	#contextWindows = /* @__PURE__ */ new Map();
 	#disposed = false;
 	#admissionGate = Promise.resolve();
+	/** FIFO user turns live outside the gate while capacity-blocked, so
+	*  best-effort metadata can still enter the serialized path and fail. */
+	#turnAdmissions = [];
+	#metadataAdmissions = /* @__PURE__ */ new Set();
+	#admissionDrainScheduled = false;
+	/** Prevent a capacity change between a failed attempt and parking the head
+	*  from becoming a lost wake-up. */
+	#admissionRevision = 0;
+	#blockedAdmissionRevision;
 	constructor(dependencies) {
 		this.#runtime = dependencies.runtime;
 		this.#approval = dependencies.approval;
@@ -1630,28 +1992,140 @@ var ClaudeSupervisor = class {
 	runTurn(request) {
 		const interruption = this.#interruptions.get(request.agent.id);
 		if (interruption !== void 0) return interruption.then(() => this.runTurn(request));
-		const operation = this.#admissionGate.then(() => this.#runTurnAdmitted(request));
+		return new Promise((resolve, reject) => {
+			let complete;
+			const completion = new Promise((done) => {
+				complete = done;
+			});
+			const admission = {
+				request,
+				resolve,
+				reject,
+				delivered: false,
+				admitting: false,
+				waitedForCapacity: false,
+				cancellation: new AbortController(),
+				completion,
+				complete: () => {
+					complete?.();
+				}
+			};
+			if (request.signal !== void 0) {
+				const abortListener = () => {
+					if (!admission.admitting) this.#finishTurnAdmission(admission, { error: abortFailure() });
+					else if (admission.waitedForCapacity && !admission.delivered) {
+						admission.delivered = true;
+						admission.reject(abortFailure());
+					}
+					this.#admissionRevision += 1;
+					this.#blockedAdmissionRevision = void 0;
+					this.#scheduleTurnAdmissions();
+				};
+				admission.abortListener = abortListener;
+				request.signal.addEventListener("abort", abortListener, { once: true });
+			}
+			this.#turnAdmissions.push(admission);
+			this.#scheduleTurnAdmissions();
+		});
+	}
+	async #drainTurnAdmissions() {
+		while (this.#turnAdmissions.length > 0) {
+			const admission = this.#turnAdmissions[0];
+			if (signalAborted(admission.request.signal)) {
+				this.#finishTurnAdmission(admission, { error: abortFailure() });
+				continue;
+			}
+			const attemptedRevision = this.#admissionRevision;
+			admission.admitting = true;
+			try {
+				const output = await this.#runTurnAdmitted(admission.request, admission.waitedForCapacity, admission.cancellation.signal);
+				this.#finishTurnAdmission(admission, { output });
+			} catch (error) {
+				if (error instanceof ClaudeProcessLimitError && !signalAborted(admission.request.signal) && !admission.cancellation.signal.aborted && !this.#disposed) {
+					admission.admitting = false;
+					admission.waitedForCapacity = true;
+					if (attemptedRevision === this.#admissionRevision) {
+						this.#blockedAdmissionRevision = attemptedRevision;
+						return;
+					}
+					continue;
+				}
+				this.#finishTurnAdmission(admission, { error });
+			}
+		}
+	}
+	#finishTurnAdmission(admission, outcome) {
+		if (this.#turnAdmissions[0] === admission) this.#turnAdmissions.shift();
+		else {
+			const index = this.#turnAdmissions.indexOf(admission);
+			if (index >= 0) this.#turnAdmissions.splice(index, 1);
+		}
+		admission.admitting = false;
+		if (admission.request.signal !== void 0 && admission.abortListener !== void 0) admission.request.signal.removeEventListener("abort", admission.abortListener);
+		if (!admission.delivered) {
+			admission.delivered = true;
+			if ("error" in outcome) admission.reject(outcome.error);
+			else admission.resolve(outcome.output);
+		}
+		admission.complete();
+	}
+	#scheduleTurnAdmissions() {
+		if (this.#admissionDrainScheduled || this.#turnAdmissions.length === 0 || this.#blockedAdmissionRevision === this.#admissionRevision) return;
+		this.#admissionDrainScheduled = true;
+		const operation = this.#admissionGate.then(() => this.#drainTurnAdmissions());
 		this.#admissionGate = operation.then(() => void 0, () => void 0);
-		return operation;
+		const finished = () => {
+			this.#admissionDrainScheduled = false;
+			this.#scheduleTurnAdmissions();
+		};
+		operation.then(finished, finished);
 	}
-	async #runTurnAdmitted(request) {
+	async #runTurnAdmitted(request, abortDuringAdmission, cancellationSignal) {
 		if (this.#disposed) throw new Error("dsh-claude: supervisor is disposed");
+		if (cancellationSignal.aborted) throw abortFailure();
 		if (signalAborted(request.signal)) throw abortFailure();
 		const sessionId = request.agent.id;
 		let entry = this.#entries.get(sessionId);
+		let createdForRequest;
+		const throwIfUnavailable = async () => {
+			const failure = this.#disposed ? /* @__PURE__ */ new Error("dsh-claude: supervisor is disposed") : cancellationSignal.aborted || abortDuringAdmission && signalAborted(request.signal) ? abortFailure() : void 0;
+			if (failure === void 0) return;
+			if (createdForRequest !== void 0) {
+				if (this.#entries.get(sessionId) === createdForRequest) this.#entries.delete(sessionId);
+				await this.#disposeEntry(createdForRequest);
+				createdForRequest = void 0;
+			}
+			throw failure;
+		};
 		if (entry?.state === "disposed" || entry?.state === "disconnected" || entry?.state === "outcome-unknown") {
 			this.#entries.delete(sessionId);
 			await this.#disposeEntry(entry);
+			await throwIfUnavailable();
 			entry = void 0;
 		}
 		if (entry === void 0) {
 			await this.#makeRoom();
-			entry = await this.#createEntry(request.agent, request.model ?? this.#config.defaultModel, request.thinkingMode);
+			await throwIfUnavailable();
+			try {
+				entry = await this.#createEntry(request.agent, request.model ?? this.#config.defaultModel, request.thinkingMode, abortDuringAdmission ? request.signal : void 0, cancellationSignal);
+			} catch (error) {
+				await throwIfUnavailable();
+				throw error;
+			}
+			createdForRequest = entry;
+			await throwIfUnavailable();
 			this.#entries.set(sessionId, entry);
 		}
 		if (entry.ownerAgent !== request.agent) throw new Error(`dsh-claude: live agent identity changed for session ${sessionId}`);
 		if (entry.active !== void 0 || entry.state === "interrupting") throw new ClaudeTurnBusyError(sessionId);
-		await entry.sdkInitialization;
+		try {
+			const initialization = withAbort(entry.sdkInitialization, cancellationSignal);
+			await (abortDuringAdmission ? withAbort(initialization, request.signal) : initialization);
+		} catch (error) {
+			await throwIfUnavailable();
+			throw error;
+		}
+		await throwIfUnavailable();
 		if (entry.idleTimer !== void 0) {
 			clearTimeout(entry.idleTimer);
 			entry.idleTimer = void 0;
@@ -1660,16 +2134,35 @@ var ClaudeSupervisor = class {
 		if (request.thinkingMode !== entry.thinkingMode || model !== entry.model) {
 			this.#entries.delete(sessionId);
 			await this.#disposeEntry(entry);
-			entry = await this.#createEntry(request.agent, model, request.thinkingMode);
+			if (createdForRequest === entry) createdForRequest = void 0;
+			await throwIfUnavailable();
+			try {
+				entry = await this.#createEntry(request.agent, model, request.thinkingMode, abortDuringAdmission ? request.signal : void 0, cancellationSignal);
+			} catch (error) {
+				await throwIfUnavailable();
+				throw error;
+			}
+			createdForRequest = entry;
+			await throwIfUnavailable();
 			this.#entries.set(sessionId, entry);
-			await entry.sdkInitialization;
+			try {
+				const initialization = withAbort(entry.sdkInitialization, cancellationSignal);
+				await (abortDuringAdmission ? withAbort(initialization, request.signal) : initialization);
+			} catch (error) {
+				await throwIfUnavailable();
+				throw error;
+			}
 		} else await this.#syncPermissionMode(entry);
+		await throwIfUnavailable();
 		const promptUuid = randomUUID();
 		const cursor = currentClaudeActivityCursor(request.agent.session.events);
-		cursor.nextOrdinal = (await this.#sidecar.read(sessionId)).activities.reduce((next, activity) => activity.turn === cursor.turn && activity.step === cursor.step ? Math.max(next, activity.ordinal + 1) : next, 0);
+		const projection = await this.#sidecar.read(sessionId);
+		await throwIfUnavailable();
+		cursor.nextOrdinal = projection.activities.reduce((next, activity) => activity.turn === cursor.turn && activity.step === cursor.step ? Math.max(next, activity.ordinal + 1) : next, 0);
 		const active = {
 			agent: request.agent,
 			cursor,
+			native: (request.renderMode ?? this.#config.renderMode ?? "plugin") === "native",
 			output: new AsyncQueue(),
 			promptUuid,
 			phase: "primary",
@@ -1690,6 +2183,7 @@ var ClaudeSupervisor = class {
 		entry.active = active;
 		entry.state = "running";
 		entry.lastUsedAt = Date.now();
+		await this.#captureWorktree(entry, cursor.turn);
 		try {
 			await this.#appendActivity(active, {
 				kind: "status",
@@ -1712,9 +2206,12 @@ var ClaudeSupervisor = class {
 				title: "Claude Code turn cancelled before submission"
 			});
 			entry.active = void 0;
-			entry.state = "idle";
-			entry.lastUsedAt = Date.now();
-			this.#armIdleTimer(entry);
+			if (!abortDuringAdmission || createdForRequest === void 0) {
+				entry.state = "idle";
+				entry.lastUsedAt = Date.now();
+				this.#armIdleTimer(entry);
+			}
+			await throwIfUnavailable();
 			return active.output;
 		}
 		if (request.signal !== void 0) {
@@ -1728,31 +2225,57 @@ var ClaudeSupervisor = class {
 		return active.output;
 	}
 	#runMetadata(agent, model, operation) {
+		if (this.#turnAdmissions.some((admission) => admission.waitedForCapacity)) return Promise.reject(new ClaudeProcessLimitError(this.#config.maxProcesses));
+		let complete;
+		const admission = {
+			sessionId: agent.id,
+			cancellation: new AbortController(),
+			started: false,
+			completion: new Promise((done) => {
+				complete = done;
+			}),
+			complete: () => {
+				complete?.();
+			}
+		};
+		this.#metadataAdmissions.add(admission);
 		const admitted = this.#admissionGate.then(async () => {
+			admission.started = true;
 			if (this.#disposed) throw new Error("dsh-claude: supervisor is disposed");
-			const entry = await this.#metadataEntry(agent, model);
+			if (admission.cancellation.signal.aborted) throw abortFailure();
+			if (this.#turnAdmissions.some((admission) => admission.waitedForCapacity)) throw new ClaudeProcessLimitError(this.#config.maxProcesses);
+			const entry = await this.#metadataEntry(agent, model, admission.cancellation.signal);
 			try {
-				await entry.sdkInitialization;
-				return await this.#control(entry, operation(entry.query, entry), "Claude metadata request");
+				await withAbort(entry.sdkInitialization, admission.cancellation.signal);
+				return await withAbort(this.#control(entry, operation(entry.query, entry), "Claude metadata request"), admission.cancellation.signal);
 			} finally {
 				entry.lastUsedAt = Date.now();
 				if (entry.active === void 0 && entry.state === "idle") this.#armIdleTimer(entry);
 			}
+		}).finally(() => {
+			this.#finishMetadataAdmission(admission);
 		});
 		this.#admissionGate = admitted.then(() => void 0, () => void 0);
-		return admitted;
+		return withAbort(admitted, admission.cancellation.signal);
 	}
-	async #metadataEntry(agent, model) {
+	async #metadataEntry(agent, model, cancellationSignal) {
+		if (cancellationSignal.aborted) throw abortFailure();
 		const sessionId = agent.id;
 		let entry = this.#entries.get(sessionId);
 		if (entry?.state === "disposed" || entry?.state === "disconnected" || entry?.state === "outcome-unknown") {
 			this.#entries.delete(sessionId);
 			await this.#disposeEntry(entry);
+			if (cancellationSignal.aborted) throw abortFailure();
 			entry = void 0;
 		}
 		if (entry === void 0) {
 			await this.#makeRoom();
-			entry = await this.#createEntry(agent, model);
+			if (cancellationSignal.aborted) throw abortFailure();
+			entry = await this.#createEntry(agent, model, void 0, void 0, cancellationSignal);
+			if (cancellationSignal.aborted) {
+				await this.#disposeEntry(entry);
+				throw abortFailure();
+			}
 			this.#entries.set(sessionId, entry);
 		}
 		if (entry.ownerAgent !== agent) throw new Error(`dsh-claude: live agent identity changed for session ${sessionId}`);
@@ -1761,14 +2284,15 @@ var ClaudeSupervisor = class {
 			clearTimeout(entry.idleTimer);
 			entry.idleTimer = void 0;
 		}
-		await this.#syncPermissionMode(entry);
+		await withAbort(this.#syncPermissionMode(entry), cancellationSignal);
+		if (cancellationSignal.aborted) throw abortFailure();
 		return entry;
 	}
 	/** Run one SDK control request against a live entry, and discard the entry if
 	*  it does not answer.
 	*
-	*  Turn admission and every metadata read share one process-wide gate, so an
-	*  unbounded control request stalls every session until the Host restarts.
+	*  Turn admission attempts and metadata reads share one process-wide gate,
+	*  so an unbounded control request stalls every session until the Host restarts.
 	*  Bounding it is only half the cure: a timeout also proves this query has
 	*  stopped answering, and keeping the entry means the next caller reuses the
 	*  same dead process — timing out again, forever. Discarding it lets the next
@@ -1789,32 +2313,97 @@ var ClaudeSupervisor = class {
 		await this.#control(entry, entry.query.setPermissionMode(mode), "Claude Code permission mode switch");
 		entry.permissionMode = mode;
 	}
+	#finishMetadataAdmission(admission) {
+		this.#metadataAdmissions.delete(admission);
+		admission.complete();
+	}
+	#cancelMetadataAdmissions(predicate) {
+		const cancelled = [...this.#metadataAdmissions].filter(predicate);
+		for (const admission of cancelled) {
+			admission.cancellation.abort();
+			if (!admission.started) this.#finishMetadataAdmission(admission);
+		}
+		return cancelled.map((admission) => admission.completion);
+	}
+	#cancelTurnAdmissions(predicate, error) {
+		const cancelled = this.#turnAdmissions.filter(predicate);
+		for (const admission of cancelled) {
+			admission.cancellation.abort();
+			if (!admission.delivered) {
+				admission.delivered = true;
+				admission.reject(error);
+			}
+			if (!admission.admitting) this.#finishTurnAdmission(admission, { error });
+		}
+		if (cancelled.length > 0) {
+			this.#admissionRevision += 1;
+			this.#blockedAdmissionRevision = void 0;
+			this.#scheduleTurnAdmissions();
+		}
+		return cancelled.map((admission) => admission.completion);
+	}
+	limitsChanged() {
+		if (this.#disposed) return;
+		this.#notifyCapacityChange();
+		this.#scheduleLimitReconciliation();
+	}
 	async disposeSession(sessionId) {
+		const pendingAdmissions = this.#cancelTurnAdmissions((admission) => admission.request.agent.id === sessionId, abortFailure());
+		const pendingMetadata = this.#cancelMetadataAdmissions((admission) => admission.sessionId === sessionId);
 		const entry = this.#entries.get(sessionId);
-		if (entry === void 0) return;
-		this.#entries.delete(sessionId);
-		await this.#disposeEntry(entry);
+		if (entry !== void 0) this.#entries.delete(sessionId);
+		await Promise.allSettled([
+			...pendingAdmissions,
+			...pendingMetadata,
+			...entry === void 0 ? [] : [this.#disposeEntry(entry)]
+		]);
 	}
 	async dispose() {
 		if (this.#disposed) return;
 		this.#disposed = true;
+		const pendingAdmissions = this.#cancelTurnAdmissions(() => true, /* @__PURE__ */ new Error("dsh-claude: supervisor is disposed"));
+		const pendingMetadata = this.#cancelMetadataAdmissions(() => true);
 		const entries = [...this.#entries.values()];
 		this.#entries.clear();
-		await Promise.allSettled(entries.map((entry) => this.#disposeEntry(entry)));
+		this.#notifyCapacityChange();
+		await Promise.allSettled([
+			...pendingAdmissions,
+			...pendingMetadata,
+			...entries.map((entry) => this.#disposeEntry(entry))
+		]);
 	}
 	async #makeRoom() {
-		if (this.#entries.size < this.#config.maxProcesses) return;
-		const idle = [...this.#entries.values()].filter((entry) => entry.active === void 0 && entry.state === "idle").sort((left, right) => left.lastUsedAt - right.lastUsedAt)[0];
-		if (idle === void 0) throw new ClaudeProcessLimitError(this.#config.maxProcesses);
-		this.#entries.delete(idle.sessionId);
-		await this.#disposeEntry(idle);
+		while (this.#entries.size >= this.#config.maxProcesses) {
+			const idle = [...this.#entries.values()].filter((entry) => entry.active === void 0 && entry.state === "idle").sort((left, right) => left.lastUsedAt - right.lastUsedAt)[0];
+			if (idle === void 0) throw new ClaudeProcessLimitError(this.#config.maxProcesses);
+			this.#entries.delete(idle.sessionId);
+			await this.#disposeEntry(idle);
+		}
 	}
-	async #createEntry(agent, model, thinkingMode) {
+	async #trimExcessIdle() {
+		while (this.#entries.size > this.#config.maxProcesses) {
+			const idle = [...this.#entries.values()].filter((entry) => entry.active === void 0 && entry.state === "idle").sort((left, right) => left.lastUsedAt - right.lastUsedAt)[0];
+			if (idle === void 0) return;
+			this.#entries.delete(idle.sessionId);
+			await this.#disposeEntry(idle);
+		}
+	}
+	#notifyCapacityChange() {
+		this.#admissionRevision += 1;
+		this.#blockedAdmissionRevision = void 0;
+		this.#scheduleTurnAdmissions();
+	}
+	#scheduleLimitReconciliation() {
+		const operation = this.#admissionGate.then(() => this.#trimExcessIdle());
+		this.#admissionGate = operation.then(() => void 0, () => void 0);
+	}
+	async #createEntry(agent, model, thinkingMode, signal, cancellationSignal) {
 		const sessionId = agent.id;
 		const cwd = agent.session.header.cwd ?? process.cwd();
 		const input = new AsyncQueue();
 		const lifetime = new AbortController();
 		const projection = await this.#sidecar.importLegacy(sessionId, agent.session.events);
+		if (signalAborted(signal) || signalAborted(cancellationSignal)) throw abortFailure();
 		const binding = projection.binding;
 		const pendingRewind = projection.rewind?.pending;
 		const forkAt = pendingRewind !== void 0 && "resumeAt" in pendingRewind ? pendingRewind.resumeAt : void 0;
@@ -1860,7 +2449,7 @@ var ClaudeSupervisor = class {
 			};
 		};
 		const userQuestion = createUserQuestionBridge(this.#userQuestions, activeInteraction);
-		const canUseTool = createPermissionBridge(this.#approval, activeInteraction, userQuestion);
+		const canUseTool = createPermissionBridge(this.#approval, activeInteraction, userQuestion, this.planFeedback);
 		const options = {
 			pathToClaudeCodeExecutable: this.#config.executablePath,
 			cwd,
@@ -2000,7 +2589,7 @@ var ClaudeSupervisor = class {
 					title: "Claude thinking",
 					summary: message.text
 				});
-				if (this.#nativeRendering()) active.output.push({
+				if (active.native) active.output.push({
 					type: "thinking",
 					text: message.text
 				});
@@ -2019,7 +2608,7 @@ var ClaudeSupervisor = class {
 				});
 				if (message.parentToolUseId === void 0) {
 					active.openCalls.set(message.toolUseId, message.toolName);
-					if (this.#nativeRendering()) {
+					if (active.native) {
 						this.#ensureDynamicPresenter(active.agent, message.toolName);
 						await this.#appendNativeToolCall(active, message);
 					}
@@ -2036,7 +2625,7 @@ var ClaudeSupervisor = class {
 					detail: message.output,
 					isError: message.isError
 				});
-				if (message.parentToolUseId === void 0 && this.#nativeRendering()) await this.#appendNativeToolResult(active, message);
+				if (message.parentToolUseId === void 0 && active.native) await this.#appendNativeToolResult(active, message);
 				return;
 			case "subagent":
 				await this.#appendActivity(active, {
@@ -2086,7 +2675,7 @@ var ClaudeSupervisor = class {
 					title: message.toolName,
 					summary: message.summary
 				});
-				if (this.#nativeRendering()) await this.#appendNativeToolResult(active, {
+				if (active.native) await this.#appendNativeToolResult(active, {
 					kind: "tool-result",
 					toolUseId: message.toolUseId,
 					output: message.summary,
@@ -2106,9 +2695,6 @@ var ClaudeSupervisor = class {
 			...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
@@ -2340,6 +2926,8 @@ var ClaudeSupervisor = class {
 			await this.#recordChainAnchor(entry, active);
 			this.#checkpointProjection(entry);
 			this.#armIdleTimer(entry);
+			this.#notifyCapacityChange();
+			this.#scheduleLimitReconciliation();
 			return;
 		}
 		if (result.usage.inputTokens !== void 0 || result.usage.outputTokens !== void 0 || result.usage.cumulativeCostUsd !== void 0) {
@@ -2421,9 +3009,11 @@ var ClaudeSupervisor = class {
 		entry.state = "idle";
 		entry.lastUsedAt = Date.now();
 		await this.#recordChainAnchor(entry, active);
-		await this.#learnContextWindow(entry);
 		this.#checkpointProjection(entry);
 		this.#armIdleTimer(entry);
+		this.#notifyCapacityChange();
+		this.#scheduleLimitReconciliation();
+		await this.#learnContextWindow(entry);
 	}
 	/** Tell every reader where this session's delta stream ended.
 	*
@@ -2436,6 +3026,20 @@ var ClaudeSupervisor = class {
 			this.#sidecar.checkpoint(entry.sessionId);
 		} catch {}
 	}
+	/** Pin the working tree this turn is about to change, so a rewind of it can
+	*  put the checkout back where the turn found it.
+	*
+	*  Awaited, and deliberately: a snapshot taken after Claude's first edit
+	*  would restore to a state that never existed. It costs one `git add -A`
+	*  against a throwaway index per turn, and best effort throughout -- a
+	*  session with no repository simply never offers a file rewind. */
+	async #captureWorktree(entry, turn) {
+		try {
+			const tree = await captureWorktreeTree(this.#runtime, entry.cwd);
+			if (tree === void 0) return;
+			await this.#sidecar.recordRewindSnapshot(entry.sessionId, turn, tree);
+		} 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. */
@@ -2453,7 +3057,7 @@ var ClaudeSupervisor = class {
 		try {
 			this.#sidecar.appendTranscriptText(active.agent.id, {
 				text: active.transcriptText,
-				...this.#nativeRendering() ? { renderer: "native" } : {},
+				...active.native ? { renderer: "native" } : {},
 				turn: active.cursor.turn,
 				step: active.cursor.step,
 				ordinal
@@ -2472,7 +3076,7 @@ var ClaudeSupervisor = class {
 		const ordinal = active.cursor.nextOrdinal++;
 		await this.#sidecar.appendActivity(active.agent.id, {
 			...activity,
-			...this.#nativeRendering() ? { renderer: "native" } : {},
+			...active.native ? { renderer: "native" } : {},
 			turn: active.cursor.turn,
 			step: active.cursor.step,
 			ordinal
@@ -2511,7 +3115,7 @@ var ClaudeSupervisor = class {
 				summary,
 				isError: true
 			});
-			if (this.#nativeRendering()) await this.#appendNativeToolResult(active, {
+			if (active.native) await this.#appendNativeToolResult(active, {
 				kind: "tool-result",
 				toolUseId,
 				output: summary,
@@ -2591,6 +3195,7 @@ var ClaudeSupervisor = class {
 		if (entry.process !== void 0) try {
 			await entry.process.handle.waitForExit(AbortSignal.timeout(5e3));
 		} catch {}
+		this.#notifyCapacityChange();
 	}
 };
 //#endregion
@@ -2670,6 +3275,85 @@ function formatReviewComments(comments) {
 	].join("\n");
 }
 //#endregion
+//#region src/session-title.ts
+/** Answer DSH's auxiliary session-title request with a throwaway Haiku turn.
+*
+*  DSH titles a session by asking the model behind the session's own route for
+*  a summary of the first human message. That route is this plugin, and the
+*  session's Claude process must not answer it: the title call carries a
+*  plugin-authored system prompt and would land in the user's transcript. A
+*  separate one-shot turn keeps it out, for the same reasons as the branch-name
+*  summary and the plan-usage probe. Deployments that never installed a second
+*  model provider still get a readable title, since the only model this plugin
+*  needs is the one it already runs. */
+/** Cheapest model that can summarize a sentence in the language it was written in. */
+const SESSION_TITLE_MODEL = "haiku";
+/** Backstop only. The title service wraps its own deadline (60s by default)
+*  around the call and passes it as `signal`, so a shorter budget here just
+*  kills a turn the caller was still happy to wait for — a cold CLI start plus
+*  one Haiku reply routinely passes ten seconds. */
+const SESSION_TITLE_TIMEOUT_MS = 6e4;
+/** DSH frames the messages as JSON under its own byte cap; this only bounds a
+*  caller that does not. */
+const MAX_INPUT_CHARS = 8e3;
+/** Longer than any title DSH accepts (80 bytes), short enough to bound prose. */
+const MAX_TITLE_CHARS = 200;
+/** Carry DSH's instruction as the prompt's own preamble: a Claude Code turn has
+*  no separate system slot this plugin can borrow without replacing the CLI's. */
+function sessionTitlePrompt(request) {
+	const input = request.input.trim().slice(0, MAX_INPUT_CHARS);
+	return request.system === void 0 || request.system.length === 0 ? input : `${request.system}\n\n${input}`;
+}
+/** The one line of the reply that is the title. DSH strips control characters
+*  and truncates to its own byte cap, so nothing else is cleaned here. */
+function sessionTitleLine(reply) {
+	const line = reply.split("\n").map((candidate) => candidate.trim()).find((candidate) => candidate.length > 0);
+	return line === void 0 ? "" : line.slice(0, MAX_TITLE_CHARS);
+}
+/**
+* Summarize the framed messages into one title line.
+*
+* Rejects rather than returning a placeholder: the title service logs the
+* failure and keeps the deterministic first-words fallback, which is a better
+* label than anything this function could invent.
+*/
+async function summarizeSessionTitle(executablePath, request, factory = query) {
+	const prompt = sessionTitlePrompt(request);
+	if (prompt.length === 0) throw new Error("dsh-claude: the session-title request carried no text");
+	const lifetime = new AbortController();
+	const abort = () => {
+		lifetime.abort();
+	};
+	request.signal?.addEventListener("abort", abort, { once: true });
+	const timer = setTimeout(abort, SESSION_TITLE_TIMEOUT_MS);
+	timer.unref?.();
+	try {
+		const query = factory({
+			prompt,
+			options: {
+				cwd: process.cwd(),
+				abortController: lifetime,
+				model: SESSION_TITLE_MODEL,
+				allowedTools: [],
+				settingSources: [],
+				maxTurns: 1,
+				...executablePath.length === 0 ? {} : { pathToClaudeCodeExecutable: executablePath }
+			}
+		});
+		for await (const message of query) {
+			if (message.type !== "result" || message.subtype !== "success") continue;
+			const title = sessionTitleLine(message.result);
+			if (title.length > 0) return title;
+			break;
+		}
+		throw new Error("dsh-claude: the session-title turn produced no title");
+	} finally {
+		clearTimeout(timer);
+		request.signal?.removeEventListener("abort", abort);
+		lifetime.abort();
+	}
+}
+//#endregion
 //#region src/adapter.ts
 const THINKING_MODES = [
 	{
@@ -2822,6 +3506,12 @@ function tokenUsage(usage) {
 	if (usage.cacheCreationTokens !== void 0) normalized.cacheWriteTokens = usage.cacheCreationTokens;
 	return normalized;
 }
+/** Flatten a hand-built auxiliary request to text. Unlike a conversation turn
+*  it has no images and no human-sourced message to single out: every message
+*  in it was assembled by the plugin that asked the question. */
+function auxiliaryText(messages) {
+	return messages.flatMap((message) => message.content.filter((block) => block.type === "text").map((block) => block.text)).join("\n");
+}
 function resolveAgent(agents, options) {
 	const initiator = agents.currentInitiator();
 	if (initiator !== void 0) return initiator;
@@ -2837,8 +3527,12 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 	#attachments;
 	#presetIdFor;
 	#drainReviewComments;
+	/** The renderer setting, read from its file at the start of each turn. A
+	*  cached copy would go stale whenever the file is edited outside the
+	*  Settings dialog, and the read is dwarfed by the process the turn spawns. */
 	#renderMode;
-	constructor(supervisor, agents, attachments, presetIdFor, drainReviewComments = () => [], renderMode = () => DEFAULT_CLAUDE_RENDER_MODE) {
+	#summarizeTitle;
+	constructor(supervisor, agents, attachments, presetIdFor, drainReviewComments = () => [], renderMode = async () => DEFAULT_CLAUDE_RENDER_MODE, summarizeTitle = (request) => summarizeSessionTitle("", request)) {
 		super();
 		this.#supervisor = supervisor;
 		this.#agents = agents;
@@ -2846,6 +3540,7 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 		this.#presetIdFor = presetIdFor;
 		this.#drainReviewComments = drainReviewComments;
 		this.#renderMode = renderMode;
+		this.#summarizeTitle = summarizeTitle;
 	}
 	providerInfo(provider) {
 		return {
@@ -2888,7 +3583,47 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 			stream: (options) => this.stream(options)
 		};
 	}
+	/** Title the session from its own provider without touching its process.
+	*
+	*  DSH routes the title request at the session's model, which is this
+	*  adapter; a deployment with no second provider configured would otherwise
+	*  never get a title at all and keep the first five words of the first
+	*  message. A throwaway Haiku turn answers it, so the session's transcript,
+	*  context, and permission bridge stay out of it. */
+	async *#titleStream(options) {
+		const title = await this.#summarizeTitle({
+			...options.system === void 0 ? {} : { system: options.system },
+			input: auxiliaryText(options.messages),
+			...options.signal === void 0 ? {} : { signal: options.signal }
+		});
+		yield {
+			type: "block-start",
+			index: 0,
+			blockType: "text"
+		};
+		yield {
+			type: "text-delta",
+			index: 0,
+			text: title
+		};
+		yield {
+			type: "block-end",
+			index: 0,
+			block: {
+				type: "text",
+				text: title
+			}
+		};
+		yield {
+			type: "finish",
+			reason: { kind: "stop" }
+		};
+	}
 	async *stream(options) {
+		if (options.purpose === "session-title") {
+			yield* this.#titleStream(options);
+			return;
+		}
 		if (options.purpose !== void 0) throw new Error(`dsh-claude: auxiliary ${options.purpose} calls are not routed into the Claude session`);
 		const agent = resolveAgent(this.#agents, options);
 		if (this.#presetIdFor(agent) !== "claude") throw new Error(`dsh-claude: provider ${CLAUDE_CODE_PROVIDER} is available only to the ${CLAUDE_CODE_PRESET_ID} preset`);
@@ -2910,14 +3645,16 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 			};
 			return;
 		}
+		const renderMode = await this.#renderMode();
+		const native = renderMode === "native";
 		const events = await this.#supervisor.runTurn({
 			agent,
 			prompt: injectReviewComments(prompt, this.#drainReviewComments(agent.id)),
 			model: options.model,
+			renderMode,
 			...thinkingMode === void 0 ? {} : { thinkingMode },
 			...options.signal === void 0 ? {} : { signal: options.signal }
 		});
-		const native = this.#renderMode() === "native";
 		let pendingUsage;
 		let completed = false;
 		let blockIndex = 0;
@@ -3016,8 +3753,8 @@ 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 = () => [], renderMode = () => DEFAULT_CLAUDE_RENDER_MODE) {
-	return new ClaudeCodeAdapter(supervisor, agents, attachments, presetIdFor, drainReviewComments, renderMode);
+function createClaudeCodeAdapter(supervisor, agents, attachments, presetIdFor, drainReviewComments = () => [], renderMode = async () => DEFAULT_CLAUDE_RENDER_MODE, summarizeTitle = (request) => summarizeSessionTitle("", request)) {
+	return new ClaudeCodeAdapter(supervisor, agents, attachments, presetIdFor, drainReviewComments, renderMode, summarizeTitle);
 }
 //#endregion
 //#region src/plugin-budget.ts
@@ -3326,7 +4063,7 @@ function registerClaudeDoctorRoutes(ctx, runtime, supervisor, config, resolution
 }
 //#endregion
 //#region src/projection-routes.ts
-const MAX_SESSION_ID_CHARS$6 = 1024;
+const MAX_SESSION_ID_CHARS$7 = 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;
@@ -3334,7 +4071,7 @@ const META_REFRESH_MS = 5e3;
 *  so this cannot collide with one. */
 const MULTI_SEGMENT = "multi";
 function validSessionId(value) {
-	return value.length > 0 && value.length <= MAX_SESSION_ID_CHARS$6;
+	return value.length > 0 && value.length <= MAX_SESSION_ID_CHARS$7;
 }
 function targetFromUrl(url) {
 	const prefix = `${CLAUDE_PROJECTION_PATH}/`;
@@ -3512,7 +4249,11 @@ function registerClaudeProjectionRoute(ctx, sidecar, ownsSession, commandsForSes
 			}
 		}));
 		for (const sessionId of sessionIds) writeSnapshot(sessionId).catch(() => void 0);
+		let sweeping = false;
 		const timer = setInterval(() => {
+			writeLine({ type: "ping" });
+			if (sweeping) return;
+			sweeping = true;
 			(async () => {
 				for (const sessionId of sessionIds) {
 					if (closed) return;
@@ -3521,8 +4262,9 @@ function registerClaudeProjectionRoute(ctx, sidecar, ownsSession, commandsForSes
 					if (JSON.stringify(next) === JSON.stringify(metas.get(sessionId))) continue;
 					writeMeta(sessionId, next);
 				}
-				writeLine({ type: "ping" });
-			})().catch(() => void 0);
+			})().catch(() => void 0).finally(() => {
+				sweeping = false;
+			});
 		}, META_REFRESH_MS);
 		timer.unref?.();
 		await new Promise((resolve) => {
@@ -3676,14 +4418,14 @@ function parseGitHubRemote(value) {
 	if (match?.[1] === void 0 || match[2] === void 0) return void 0;
 	return `${match[1]}/${match[2]}`;
 }
-function record$10(value) {
+function record$11(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 function aggregateChecks(value) {
 	if (!Array.isArray(value) || value.length === 0) return "none";
 	let pending = false;
 	for (const item of value) {
-		const check = record$10(item);
+		const check = record$11(item);
 		if (check === void 0) continue;
 		const conclusion = typeof check.conclusion === "string" ? check.conclusion.toUpperCase() : void 0;
 		const status = typeof check.status === "string" ? check.status.toUpperCase() : void 0;
@@ -3707,7 +4449,7 @@ function reviewState(value) {
 	return "none";
 }
 function parsePullRequest(value) {
-	const input = record$10(value);
+	const input = record$11(value);
 	if (input === void 0 || !Number.isSafeInteger(input.number) || Number(input.number) <= 0 || typeof input.title !== "string" || typeof input.url !== "string") return void 0;
 	let url;
 	try {
@@ -3728,7 +4470,7 @@ function parsePullRequest(value) {
 		review: reviewState(input.reviewDecision),
 		checks: aggregateChecks(input.statusCheckRollup),
 		...typeof input.mergeStateStatus === "string" ? { mergeState: bounded(input.mergeStateStatus) } : {},
-		...typeof record$10(input.author)?.login === "string" ? { author: bounded(String(record$10(input.author)?.login)) } : {},
+		...typeof record$11(input.author)?.login === "string" ? { author: bounded(String(record$11(input.author)?.login)) } : {},
 		...typeof input.createdAt === "string" && Number.isFinite(Date.parse(input.createdAt)) ? { createdAt: new Date(input.createdAt).toISOString() } : {},
 		...typeof input.mergedAt === "string" && Number.isFinite(Date.parse(input.mergedAt)) ? { mergedAt: new Date(input.mergedAt).toISOString() } : {},
 		...typeof input.baseRefName === "string" && bounded(input.baseRefName).length > 0 ? { baseBranch: bounded(input.baseRefName) } : {}
@@ -5135,19 +5877,19 @@ var RepositoryActionService = class {
 };
 //#endregion
 //#region src/repository-setup-routes.ts
-const MAX_BODY_BYTES$6 = 16384;
-function record$9(value) {
+const MAX_BODY_BYTES$7 = 16384;
+function record$10(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
-async function readJson$5(io) {
+async function readJson$6(io) {
 	let parsed;
 	try {
-		parsed = await io.body(MAX_BODY_BYTES$6);
+		parsed = await io.body(MAX_BODY_BYTES$7);
 	} catch (error) {
 		if (error instanceof SyntaxError) throw error;
 		throw new RepositorySetupError("body-too-large", "The request body is too large.");
 	}
-	const value = record$9(parsed);
+	const value = record$10(parsed);
 	if (value === void 0) throw new RepositorySetupError("invalid-request", "The request body is invalid.");
 	return value;
 }
@@ -5216,7 +5958,7 @@ function registerRepositorySetupRoute(ctx, service, sweep) {
 			try {
 				if (pathname === `/plugins/dsh-claude/repository/setup/branches/refresh`) {
 					if (io.method !== "POST") return json(res, 405, { error: "method not allowed" });
-					const input = await readJson$5(io);
+					const input = await readJson$6(io);
 					return json(res, 200, await service.refreshBranches(string$2(input, "cwd")));
 				}
 				if (pathname === `/plugins/dsh-claude/repository/setup/branches`) {
@@ -5227,14 +5969,14 @@ function registerRepositorySetupRoute(ctx, service, sweep) {
 				}
 				if (pathname === "/plugins/dsh-claude/repository/setup") {
 					if (io.method !== "POST") return json(res, 405, { error: "method not allowed" });
-					const input = await readJson$5(io);
+					const input = await readJson$6(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 (io.method !== "POST") return json(res, 405, { error: "method not allowed" });
-					const input = await readJson$5(io);
+					const input = await readJson$6(io);
 					return json(res, 200, await service.cleanupMerged(string$2(input, "path"), string$2(input, "baseBranch")));
 				}
 				if (pathname === `/plugins/dsh-claude/repository/setup/sweep`) {
@@ -5244,7 +5986,7 @@ function registerRepositorySetupRoute(ctx, service, sweep) {
 				}
 				if (pathname === `/plugins/dsh-claude/repository/setup/bind`) {
 					if (io.method !== "POST") return json(res, 405, { error: "method not allowed" });
-					const input = await readJson$5(io);
+					const input = await readJson$6(io);
 					await service.bindLease(string$2(input, "leaseId"), string$2(input, "sessionId"));
 					return json(res, 200, { ok: true });
 				}
@@ -5262,8 +6004,8 @@ function registerRepositorySetupRoute(ctx, service, sweep) {
 }
 //#endregion
 //#region src/repository-action-routes.ts
-const MAX_BODY_BYTES$5 = 16384;
-const MAX_SESSION_ID_CHARS$5 = 1024;
+const MAX_BODY_BYTES$6 = 16384;
+const MAX_SESSION_ID_CHARS$6 = 1024;
 const ACTIONS = /* @__PURE__ */ new Set([
 	"commit",
 	"commit-push",
@@ -5272,24 +6014,24 @@ const ACTIONS = /* @__PURE__ */ new Set([
 	"merge-pr",
 	"update-branch"
 ]);
-function record$8(value) {
+function record$9(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
-async function readJson$4(io) {
+async function readJson$5(io) {
 	let parsed;
 	try {
-		parsed = await io.body(MAX_BODY_BYTES$5);
+		parsed = await io.body(MAX_BODY_BYTES$6);
 	} catch (error) {
 		if (error instanceof SyntaxError) throw error;
 		throw new RepositoryActionError("body-too-large", "The request body is too large.");
 	}
-	const value = record$8(parsed);
+	const value = record$9(parsed);
 	if (value === void 0) throw new RepositoryActionError("invalid-request", "The request body is invalid.");
 	return value;
 }
 function sessionId$1(url) {
 	const value = url.searchParams.get("sessionId");
-	if (value === null || value.length === 0 || value.length > MAX_SESSION_ID_CHARS$5) throw new RepositoryActionError("invalid-session", "The session is invalid.");
+	if (value === null || value.length === 0 || value.length > MAX_SESSION_ID_CHARS$6) throw new RepositoryActionError("invalid-session", "The session is invalid.");
 	return value;
 }
 function string$1(input, key) {
@@ -5353,7 +6095,7 @@ function registerRepositoryActionRoute(ctx, service, cwdForSession) {
 						status: 405,
 						value: { error: "method not allowed" }
 					};
-					const input = await readJson$4(io);
+					const input = await readJson$5(io);
 					return {
 						status: 200,
 						value: { message: await service.generateMessage(cwd, string$1(input, "fingerprint")) }
@@ -5366,7 +6108,7 @@ function registerRepositoryActionRoute(ctx, service, cwdForSession) {
 					};
 					return {
 						status: 200,
-						value: await service.execute(cwd, actionRequest(await readJson$4(io)))
+						value: await service.execute(cwd, actionRequest(await readJson$5(io)))
 					};
 				}
 				return {
@@ -5517,7 +6259,7 @@ var EditorOpenService = class {
 };
 //#endregion
 //#region src/editor-open-routes.ts
-const MAX_SESSION_ID_CHARS$4 = 1024;
+const MAX_SESSION_ID_CHARS$5 = 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) {
@@ -5531,7 +6273,7 @@ function registerEditorOpenRoute(ctx, service, cwdForSession) {
 			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 {
+			if (id === null || id.length === 0 || id.length > MAX_SESSION_ID_CHARS$5) return {
 				status: 400,
 				value: {
 					error: "invalid-session",
@@ -5579,6 +6321,358 @@ function registerEditorOpenRoute(ctx, service, cwdForSession) {
 	});
 }
 //#endregion
+//#region src/prompts.ts
+const MAX_PROMPT_FILES = 256;
+const MAX_PROMPT_BYTES = 16384;
+const MAX_DESCRIPTION_CHARS = 120;
+const MAX_REQUEST_BYTES$1 = 32768;
+/**
+* The same shape as the output-style name in `global-settings.ts`, plus
+* `\p{M}` so a macOS-decomposed name survives. Two properties matter and both
+* are load-bearing: no member of the class is a path separator, and the first
+* character can be neither a dot nor a separator — so `join(dir, name + '.md')`
+* cannot address anything outside `dir`. Nothing else validates the path.
+*/
+const PROMPT_NAME = /^[\p{L}\p{N}][\p{L}\p{M}\p{N} ._()\[\]-]{0,127}$/u;
+/** Prompt snippets live beside the rest of the user's Claude Code state. */
+function claudePromptsDir() {
+	return join(homedir(), ".claude", "prompts");
+}
+/** `~/.claude/prompts/x.md` rather than the absolute path it expands to. */
+function displayPath(file) {
+	const home = homedir();
+	return file.startsWith(`${home}/`) ? `~${file.slice(home.length)}` : file;
+}
+/** The menu's second row: the first non-empty line, collapsed and bounded. */
+function summarize(body) {
+	const line = body.split("\n").map((text) => text.trim()).find((text) => text.length > 0) ?? "";
+	return redactText(line.replace(/\s+/gu, " "), MAX_DESCRIPTION_CHARS);
+}
+/**
+* Every `.md` file in the prompts directory, sorted by name.
+*
+* A missing directory is the ordinary state before the user saves anything,
+* and one unreadable file must not empty the whole menu — both answer with
+* what is there rather than throwing.
+*/
+async function readClaudePrompts(directory) {
+	const prompts = [];
+	let entries;
+	try {
+		entries = await opendir(directory);
+	} catch (error) {
+		if (error.code === "ENOENT") return prompts;
+		throw error;
+	}
+	for await (const entry of entries) {
+		if (prompts.length >= MAX_PROMPT_FILES) break;
+		if (!entry.isFile() || extname(entry.name).toLowerCase() !== ".md") continue;
+		const name = entry.name.slice(0, -3);
+		if (!PROMPT_NAME.test(name)) continue;
+		try {
+			const file = join(directory, entry.name);
+			const body = await readFile(file, "utf8");
+			if (body.trim().length === 0 || Buffer.byteLength(body) > MAX_PROMPT_BYTES) continue;
+			prompts.push({
+				name,
+				description: summarize(body),
+				body,
+				location: displayPath(file)
+			});
+		} catch {}
+	}
+	return prompts.sort((left, right) => left.name.localeCompare(right.name));
+}
+var ClaudePromptWriteError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "ClaudePromptWriteError";
+		this.code = code;
+	}
+};
+/**
+* Save one prompt, refusing to clobber an existing file.
+*
+* `wx` is the whole collision policy: a name the user already uses is theirs
+* to resolve, and overwriting a prompt they keep is not something they can
+* undo from inside DSH.
+*/
+async function writeClaudePrompt(directory, name, body) {
+	if (typeof name !== "string" || !PROMPT_NAME.test(name)) throw new ClaudePromptWriteError("invalid-name", "The prompt name is invalid.");
+	if (typeof body !== "string" || body.trim().length === 0 || Buffer.byteLength(body) > MAX_PROMPT_BYTES) throw new ClaudePromptWriteError("invalid-body", "The prompt text is empty or too large.");
+	const text = body.endsWith("\n") ? body : `${body}\n`;
+	const file = join(directory, `${name}.md`);
+	await mkdir(directory, {
+		recursive: true,
+		mode: 448
+	});
+	try {
+		await writeFile(file, text, {
+			encoding: "utf8",
+			mode: 384,
+			flag: "wx"
+		});
+	} catch (error) {
+		if (error.code === "EEXIST") throw new ClaudePromptWriteError("name-taken", "A prompt with that name already exists.");
+		throw error;
+	}
+	return {
+		name,
+		description: summarize(text),
+		body: text,
+		location: displayPath(file)
+	};
+}
+const MAX_NAME_DRAFT_CHARS = 4e3;
+const MAX_NAME_OUTPUT_BYTES = 4096;
+const MAX_SUGGESTED_NAME_CHARS = 48;
+const MAX_REFINE_DRAFT_CHARS = 16e3;
+const MAX_REFINED_BYTES = 32768;
+const ASSIST_TIMEOUT_MS = 4e4;
+/**
+* Ask for a file name and nothing else, with the draft fenced as data.
+*
+* Two things here were measured rather than guessed. The instruction travels
+* in the user turn, not in `--system-prompt`: a saved prompt is itself an
+* instruction and a system prompt does not outrank it, so the model reads the
+* draft as its task and answers it instead of naming it. And the default
+* system prompt is left in place even though it is large, because the CLI
+* sends it as a cache read (~6.5k cached tokens); replacing it with a short
+* one costs a fresh 3.5k-token prefill and measured slower end to end.
+*
+* The naming spec is this specific because a vaguer one ("describe what the
+* template does, at most 40 characters") produced names that were both
+* inconsistent in style and stripped of the detail that tells two similar
+* templates apart.
+*/
+function promptNamePrompt(draft) {
+	return [
+		"Below is a reusable prompt template a user is saving to a file. Name it.",
+		"",
+		`"""\n${draft.trim().slice(0, MAX_NAME_DRAFT_CHARS).replaceAll("\"\"\"", "\" \" \"")}\n"""`,
+		"",
+		"Answer with the file name alone: no quotes, no explanation, no extension, no leading dot, no slashes.",
+		"Write it in English however the template is written, as lower-case words joined by hyphens.",
+		"Name the task the template performs, keeping whatever detail distinguishes it from a",
+		"similar template. At most 6 words."
+	].join("\n");
+}
+/**
+* Rewrite the draft into something an agent can act on, with the draft fenced
+* as data for the same reason the naming prompt fences it.
+*
+* The rule about people and places is not politeness. Asked to rewrite
+* "后端 assign 给我", the model reached into Claude Code's ambient system
+* prompt and substituted the operator's actual email address — inventing a
+* detail the original never carried, and putting a personal address into a
+* message the user had not written it into. Naming the failure explicitly is
+* what stopped it; stripping the ambient context with `--system-prompt` also
+* stopped it but cost a fresh prefill and produced looser rewrites.
+*/
+function promptRefinePrompt(draft) {
+	return [
+		"Below is a prompt a user is about to send to a coding agent. Rewrite it so the agent can act on it without coming back with questions.",
+		"",
+		`"""\n${draft.trim().slice(0, MAX_REFINE_DRAFT_CHARS).replaceAll("\"\"\"", "\" \" \"")}\n"""`,
+		"",
+		"Keep the intent and every concrete detail exactly as given — names, paths, branches, identifiers, numbers.",
+		"Leave every reference to a person or place as the original wrote it (\"me\", \"我\", \"the usual branch\");",
+		"you do not know who or what they resolve to, and guessing puts a wrong name in the user's message.",
+		"Do not invent requirements the original does not imply, do not answer the prompt, do not add a preamble or sign-off.",
+		"Write the rewrite in the same language the original is written in.",
+		"Reply with the rewritten prompt alone."
+	].join("\n");
+}
+/** One turn, no tools, no MCP: neither of these tasks needs them, and both
+*  cost seconds of cold start. Variadic `--tools` stays last. */
+function promptAssistArguments() {
+	return [
+		"-p",
+		"--output-format",
+		"text",
+		"--model",
+		"haiku",
+		"--strict-mcp-config",
+		"--mcp-config",
+		"{\"mcpServers\":{}}",
+		"--tools",
+		""
+	];
+}
+/** The rewrite in a model reply, or undefined when the reply is unusable.
+*
+*  A model told to answer with the text alone still sometimes wraps it in a
+*  markdown fence, so one is peeled off; anything else is the user's to read
+*  and edit, and is passed through untouched. */
+function refinedPrompt(output) {
+	const trimmed = output.trim();
+	const text = (/^```[^\n]*\n([\s\S]*?)\n?```$/u.exec(trimmed)?.[1] ?? trimmed).trim();
+	return text.length === 0 || Buffer.byteLength(text) > MAX_REFINED_BYTES ? void 0 : text;
+}
+/**
+* The usable name in a model reply, or undefined when there is none.
+*
+* A one-line answer is what the prompt asks for and usually what comes back,
+* but "usually" is not a contract: the reply is scrubbed to what a file name
+* may hold and then held to the same {@link PROMPT_NAME} guard the write path
+* uses, so a chatty or malformed answer is dropped rather than offered.
+*/
+function suggestedName(output) {
+	const scrubbed = wordBounded((output.split("\n").map((text) => text.trim()).find((text) => text.length > 0) ?? "").replace(/^["'`]+|["'`]+$/gu, "").replace(/\.md$/iu, "").replace(/[^\p{L}\p{M}\p{N} ._()\[\]-]/gu, " ").replace(/\s+/gu, " ").trim());
+	return PROMPT_NAME.test(scrubbed) ? scrubbed : void 0;
+}
+/** Cut a long name at its last word boundary. A name the user has to repair
+*  ("analyze-frontend-backend-create-jira-tic") is worse than a shorter one. */
+function wordBounded(name) {
+	if (name.length <= MAX_SUGGESTED_NAME_CHARS) return name;
+	const cut = name.slice(0, MAX_SUGGESTED_NAME_CHARS);
+	const boundary = cut.search(/[\s\-_][^\s\-_]*$/u);
+	return (boundary > 0 ? cut.slice(0, boundary) : cut).trim();
+}
+/** Runs Claude Code's cheapest model over the draft: names it, or rewrites it. */
+var PromptAssistService = class {
+	#runtime;
+	#executablePath;
+	constructor(runtime, executablePath) {
+		this.#runtime = runtime;
+		this.#executablePath = executablePath;
+	}
+	/** One bounded, tool-less turn; undefined whenever it cannot be had. */
+	async #ask(prompt, maxOutputBytes, signal) {
+		const executablePath = this.#executablePath();
+		if (executablePath.length === 0) return void 0;
+		const timeout = AbortSignal.timeout(ASSIST_TIMEOUT_MS);
+		try {
+			const handle = this.#runtime.spawn({
+				argv: [executablePath, ...promptAssistArguments()],
+				cwd: homedir(),
+				stdio: {
+					stdin: { data: prompt },
+					stdout: { maxBytes: maxOutputBytes },
+					stderr: { maxBytes: MAX_NAME_OUTPUT_BYTES }
+				},
+				graceMs: 1e3,
+				signal: signal === void 0 ? timeout : AbortSignal.any([signal, timeout]),
+				env: { MAX_THINKING_TOKENS: "0" }
+			});
+			if ((await handle.done).exitCode !== 0) return void 0;
+			return handle.collected.stdout?.readFrom(0).text ?? "";
+		} catch {
+			return;
+		}
+	}
+	/** The suggested file name, or undefined whenever one cannot be had. The
+	*  caller already has a name derived locally, so every failure here is a
+	*  non-event: nothing is reported, and nothing is retried. */
+	async suggest(draft, signal) {
+		if (draft.trim().length === 0) return void 0;
+		const output = await this.#ask(promptNamePrompt(draft), MAX_NAME_OUTPUT_BYTES, signal);
+		return output === void 0 ? void 0 : suggestedName(output);
+	}
+	/** The rewritten draft, or undefined when the rewrite could not be had.
+	*  Unlike naming, this failure is worth reporting: the user asked for it and
+	*  is waiting on it. */
+	async refine(draft, signal) {
+		if (draft.trim().length === 0) return void 0;
+		const output = await this.#ask(promptRefinePrompt(draft), MAX_REFINED_BYTES, signal);
+		return output === void 0 ? void 0 : refinedPrompt(output);
+	}
+};
+/** List the user's prompt snippets, and save the composer draft as a new one. */
+function registerClaudePromptsRoute(ctx, directory = claudePromptsDir()) {
+	registerPluginRoute(ctx, {
+		mode: "unary",
+		kind: "exact",
+		path: CLAUDE_PROMPTS_PATH,
+		methods: ["GET", "POST"],
+		budget: "fast",
+		handler: async (io) => {
+			if (io.method === "GET") return {
+				status: 200,
+				value: { prompts: await readClaudePrompts(directory) }
+			};
+			const payload = await io.body(MAX_REQUEST_BYTES$1);
+			try {
+				return {
+					status: 200,
+					value: {
+						saved: true,
+						prompt: await writeClaudePrompt(directory, payload.name, payload.body)
+					}
+				};
+			} catch (error) {
+				if (error instanceof ClaudePromptWriteError) return {
+					status: error.code === "name-taken" ? 409 : 400,
+					value: {
+						error: error.code,
+						message: error.message
+					}
+				};
+				return {
+					status: 500,
+					value: {
+						error: "prompt-write-failed",
+						message: "The prompt could not be saved."
+					}
+				};
+			}
+		}
+	});
+}
+/** Suggest a file name for a draft. Answers `{}` when no name could be had:
+*  the caller keeps the name it derived locally, so this is never an error. */
+function registerClaudePromptNameRoute(ctx, service) {
+	registerPluginRoute(ctx, {
+		mode: "unary",
+		kind: "exact",
+		path: CLAUDE_PROMPT_NAME_PATH,
+		methods: ["POST"],
+		budget: "git",
+		handler: async (io) => {
+			const payload = await io.body(MAX_REQUEST_BYTES$1);
+			const draft = typeof payload.draft === "string" ? payload.draft : "";
+			const name = await service.suggest(draft, io.signal);
+			return {
+				status: 200,
+				value: name === void 0 ? {} : { name }
+			};
+		}
+	});
+}
+/** Rewrite a draft into something an agent can act on. */
+function registerClaudePromptRefineRoute(ctx, service) {
+	registerPluginRoute(ctx, {
+		mode: "unary",
+		kind: "exact",
+		path: CLAUDE_PROMPT_REFINE_PATH,
+		methods: ["POST"],
+		budget: "git",
+		handler: async (io) => {
+			const payload = await io.body(MAX_REQUEST_BYTES$1);
+			const draft = typeof payload.draft === "string" ? payload.draft : "";
+			if (draft.trim().length === 0) return {
+				status: 400,
+				value: {
+					error: "empty-draft",
+					message: "There is nothing to rewrite."
+				}
+			};
+			const text = await service.refine(draft, io.signal);
+			return text === void 0 ? {
+				status: 503,
+				value: {
+					error: "refine-unavailable",
+					message: "Claude could not rewrite the prompt."
+				}
+			} : {
+				status: 200,
+				value: { text }
+			};
+		}
+	});
+}
+//#endregion
 //#region src/github-url.ts
 /** Only GitHub's own image hosts; the browser loads these directly, so a URL
 *  the API did not vouch for must never become an outbound request. */
@@ -5646,7 +6740,7 @@ async function collect(handle) {
 		lossy: stdout?.lossy === true
 	};
 }
-function record$7(value) {
+function record$8(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 /** Read `repository.pullRequest.reviewThreads.nodes` out of a GraphQL response.
@@ -5654,12 +6748,12 @@ function record$7(value) {
 *  throwing: the caller distinguishes "no threads" from "call failed" by the
 *  process exit code. */
 function parseReviewThreads(value) {
-	const nodes = record$7(record$7(record$7(record$7(record$7(value)?.data)?.repository)?.pullRequest)?.reviewThreads)?.nodes;
+	const nodes = record$8(record$8(record$8(record$8(record$8(value)?.data)?.repository)?.pullRequest)?.reviewThreads)?.nodes;
 	if (!Array.isArray(nodes)) return [];
 	const threads = [];
 	let total = 0;
 	for (const item of nodes) {
-		const input = record$7(item);
+		const input = record$8(item);
 		if (input === void 0 || typeof input.id !== "string" || input.id.length === 0) continue;
 		const path = typeof input.path === "string" ? input.path : "";
 		if (path.length === 0) continue;
@@ -5671,14 +6765,14 @@ function parseReviewThreads(value) {
 			side
 		};
 		const comments = [];
-		const commentNodes = record$7(input.comments)?.nodes;
+		const commentNodes = record$8(input.comments)?.nodes;
 		for (const node of Array.isArray(commentNodes) ? commentNodes : []) {
 			if (total >= MAX_COMMENTS) break;
-			const comment = record$7(node);
+			const comment = record$8(node);
 			if (comment === void 0 || !Number.isSafeInteger(comment.databaseId)) continue;
 			const body = typeof comment.body === "string" ? comment.body.trim() : "";
 			if (body.length === 0) continue;
-			const author = record$7(comment.author);
+			const author = record$8(comment.author);
 			const avatarUrl = githubAvatarUrl(author?.avatarUrl);
 			const login = typeof author?.login === "string" ? author.login : "unknown";
 			comments.push({
@@ -5707,11 +6801,11 @@ function parseReviewThreads(value) {
 }
 /** One posted reply, shaped like the thread comments it joins. */
 function parseReplyComment(value, anchor) {
-	const input = record$7(value);
+	const input = record$8(value);
 	if (input === void 0 || !Number.isSafeInteger(input.id)) return void 0;
 	const body = typeof input.body === "string" ? input.body.trim() : "";
 	if (body.length === 0) return void 0;
-	const user = record$7(input.user);
+	const user = record$8(input.user);
 	const avatarUrl = githubAvatarUrl(user?.avatar_url);
 	const login = typeof user?.login === "string" ? user.login : "unknown";
 	return {
@@ -5726,11 +6820,11 @@ function parseReplyComment(value, anchor) {
 	};
 }
 function parseMentionableUsers(value) {
-	const nodes = record$7(record$7(record$7(record$7(value)?.data)?.repository)?.mentionableUsers)?.nodes;
+	const nodes = record$8(record$8(record$8(record$8(value)?.data)?.repository)?.mentionableUsers)?.nodes;
 	if (!Array.isArray(nodes)) return [];
 	const users = [];
 	for (const item of nodes) {
-		const input = record$7(item);
+		const input = record$8(item);
 		if (input === void 0 || typeof input.login !== "string" || input.login.length === 0) continue;
 		const avatarUrl = githubAvatarUrl(input.avatarUrl);
 		users.push({
@@ -5750,7 +6844,7 @@ function parseFailingChecks(value) {
 	if (!Array.isArray(value)) return [];
 	const failing = [];
 	for (const item of value) {
-		const input = record$7(item);
+		const input = record$8(item);
 		if (input === void 0 || input.bucket !== "fail" || typeof input.name !== "string") continue;
 		failing.push({
 			name: input.name,
@@ -5813,12 +6907,12 @@ var PullRequestFeedbackService = class {
 		let posted;
 		try {
 			const parsed = JSON.parse(result.stdout);
-			const path = typeof record$7(parsed)?.path === "string" ? String(record$7(parsed)?.path) : "";
-			const line = Number.isSafeInteger(record$7(parsed)?.line) ? Number(record$7(parsed)?.line) : void 0;
+			const path = typeof record$8(parsed)?.path === "string" ? String(record$8(parsed)?.path) : "";
+			const line = Number.isSafeInteger(record$8(parsed)?.line) ? Number(record$8(parsed)?.line) : void 0;
 			posted = parseReplyComment(parsed, {
 				path,
 				...line === void 0 ? {} : { line },
-				side: record$7(parsed)?.side === "LEFT" ? "old" : "new"
+				side: record$8(parsed)?.side === "LEFT" ? "old" : "new"
 			});
 		} catch {
 			posted = void 0;
@@ -5839,7 +6933,7 @@ var PullRequestFeedbackService = class {
 		], cwd, GH_TIMEOUT_MS);
 		if (result.exitCode !== 0) throw new PullRequestFeedbackError("resolve-failed", "The thread could not be updated.");
 		try {
-			const thread = record$7(record$7(record$7(record$7(JSON.parse(result.stdout))?.data)?.[resolved ? "resolveReviewThread" : "unresolveReviewThread"])?.thread);
+			const thread = record$8(record$8(record$8(record$8(JSON.parse(result.stdout))?.data)?.[resolved ? "resolveReviewThread" : "unresolveReviewThread"])?.thread);
 			if (typeof thread?.isResolved !== "boolean") throw new Error("missing state");
 			return thread.isResolved;
 		} catch {
@@ -5962,23 +7056,23 @@ var PullRequestFeedbackService = class {
 };
 //#endregion
 //#region src/pr-feedback-routes.ts
-const MAX_SESSION_ID_CHARS$3 = 1024;
-const MAX_BODY_BYTES$4 = 16384;
+const MAX_SESSION_ID_CHARS$4 = 1024;
+const MAX_BODY_BYTES$5 = 16384;
 const MAX_REPLY_CHARS = 2e3;
 const MAX_THREAD_ID_CHARS = 512;
 const MAX_MENTION_QUERY_CHARS = 64;
-function record$6(value) {
+function record$7(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
-async function readJson$3(io) {
+async function readJson$4(io) {
 	let parsed;
 	try {
-		parsed = await io.body(MAX_BODY_BYTES$4);
+		parsed = await io.body(MAX_BODY_BYTES$5);
 	} catch (error) {
 		if (error instanceof SyntaxError) throw error;
 		throw new PullRequestFeedbackError("body-too-large", "The request body is too large.");
 	}
-	const value = record$6(parsed);
+	const value = record$7(parsed);
 	if (value === void 0) throw new PullRequestFeedbackError("invalid-request", "The request body is invalid.");
 	return value;
 }
@@ -5999,7 +7093,7 @@ function threadId(input) {
 }
 function sessionId(url) {
 	const value = url.searchParams.get("sessionId");
-	if (value === null || value.length === 0 || value.length > MAX_SESSION_ID_CHARS$3) throw new PullRequestFeedbackError("invalid-session", "The session is invalid.");
+	if (value === null || value.length === 0 || value.length > MAX_SESSION_ID_CHARS$4) throw new PullRequestFeedbackError("invalid-session", "The session is invalid.");
 	return value;
 }
 function pullNumber(url) {
@@ -6058,7 +7152,7 @@ function registerPullRequestFeedbackRoute(ctx, service, cwdForSession) {
 						status: 405,
 						value: { error: "method not allowed" }
 					};
-					const input = await readJson$3(io);
+					const input = await readJson$4(io);
 					return {
 						status: 200,
 						value: { comment: await service.reply(cwd, pullNumber(url), commentId(input), replyBody(input)) }
@@ -6069,7 +7163,7 @@ function registerPullRequestFeedbackRoute(ctx, service, cwdForSession) {
 						status: 405,
 						value: { error: "method not allowed" }
 					};
-					const input = await readJson$3(io);
+					const input = await readJson$4(io);
 					if (typeof input.resolved !== "boolean") throw new PullRequestFeedbackError("invalid-request", "The resolved field is required.");
 					return {
 						status: 200,
@@ -6215,7 +7309,7 @@ var JiraError = class extends Error {
 		this.code = code;
 	}
 };
-function record$5(value) {
+function record$6(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 /** Jira Cloud sites are origins; Data Center may carry a context path. */
@@ -6239,14 +7333,14 @@ function ticketKeyOf(query) {
 *  search and does match keys; its hits become the key filter the normal
 *  search then reads the display fields from. */
 function pickerKeys(value, number) {
-	const sections = record$5(value)?.sections;
+	const sections = record$6(value)?.sections;
 	if (!Array.isArray(sections)) return [];
 	const keys = [];
 	for (const section of sections) {
-		const issues = record$5(section)?.issues;
+		const issues = record$6(section)?.issues;
 		if (!Array.isArray(issues)) continue;
 		for (const issue of issues) {
-			const raw = record$5(issue)?.key;
+			const raw = record$6(issue)?.key;
 			const key = ticketKeyOf(typeof raw === "string" ? raw : "");
 			if (key !== void 0 && key.endsWith(`-${number}`) && !keys.includes(key)) keys.push(key);
 		}
@@ -6265,15 +7359,15 @@ function buildJql(query) {
 	return `text ~ "${trimmed.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}*" ORDER BY updated DESC`;
 }
 function parseTickets(value, siteUrl) {
-	const issues = record$5(value)?.issues;
+	const issues = record$6(value)?.issues;
 	if (!Array.isArray(issues)) return [];
 	const tickets = [];
 	for (const item of issues) {
-		const issue = record$5(item);
-		const fields = record$5(issue?.fields);
+		const issue = record$6(item);
+		const fields = record$6(issue?.fields);
 		if (issue === void 0 || typeof issue.key !== "string" || fields === void 0) continue;
-		const status = record$5(fields.status)?.name;
-		const type = record$5(fields.issuetype)?.name;
+		const status = record$6(fields.status)?.name;
+		const type = record$6(fields.issuetype)?.name;
 		tickets.push({
 			key: issue.key,
 			summary: typeof fields.summary === "string" ? fields.summary.slice(0, 256) : "",
@@ -6315,7 +7409,7 @@ var JiraService = class {
 			email,
 			apiToken
 		};
-		const myself = record$5(await this.#json(connection, "/rest/api/3/myself"));
+		const myself = record$6(await this.#json(connection, "/rest/api/3/myself"));
 		const displayName = typeof myself?.displayName === "string" ? myself.displayName : void 0;
 		const accountId = typeof myself?.accountId === "string" ? myself.accountId : void 0;
 		const store = {
@@ -6334,7 +7428,7 @@ var JiraService = class {
 		if (ticket === void 0) throw new JiraError("invalid-request", "The ticket key is invalid.");
 		let accountId = store.accountId;
 		if (accountId === void 0) {
-			const myself = record$5(await this.#json(store, "/rest/api/3/myself"));
+			const myself = record$6(await this.#json(store, "/rest/api/3/myself"));
 			if (typeof myself?.accountId !== "string") throw new JiraError("jira-failed", "The Jira account id is unavailable.");
 			accountId = myself.accountId;
 			await this.#write({
@@ -6410,7 +7504,7 @@ var JiraService = class {
 			throw error;
 		}
 		if (Buffer.byteLength(text) > MAX_STORE_BYTES) return void 0;
-		const input = record$5(JSON.parse(text));
+		const input = record$6(JSON.parse(text));
 		if (input === void 0 || typeof input.siteUrl !== "string" || typeof input.email !== "string" || typeof input.apiToken !== "string") return void 0;
 		return {
 			siteUrl: input.siteUrl,
@@ -6441,21 +7535,21 @@ var JiraService = class {
 };
 //#endregion
 //#region src/jira-routes.ts
-const MAX_BODY_BYTES$3 = 8192;
-function record$4(value) {
+const MAX_BODY_BYTES$4 = 8192;
+function record$5(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 /** 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) {
+async function readJson$3(io) {
 	let body;
 	try {
-		body = await io.body(MAX_BODY_BYTES$3);
+		body = await io.body(MAX_BODY_BYTES$4);
 	} catch (error) {
 		if (error instanceof SyntaxError) throw error;
 		throw new JiraError("body-too-large", "The request body is too large.");
 	}
-	const value = record$4(body);
+	const value = record$5(body);
 	if (value === void 0) throw new JiraError("invalid-request", "The request body is invalid.");
 	return value;
 }
@@ -6489,7 +7583,7 @@ function registerJiraRoute(ctx, service) {
 						status: 405,
 						value: { error: "method not allowed" }
 					};
-					const input = await readJson$2(io);
+					const input = await readJson$3(io);
 					return {
 						status: 200,
 						value: await service.connect({
@@ -6515,7 +7609,7 @@ function registerJiraRoute(ctx, service) {
 						status: 405,
 						value: { error: "method not allowed" }
 					};
-					const input = await readJson$2(io);
+					const input = await readJson$3(io);
 					await service.assignToMe(string(input, "key"));
 					return {
 						status: 200,
@@ -6634,12 +7728,12 @@ function askArguments(preferences) {
 		...READ_ONLY_TOOLS
 	];
 }
-function record$3(value) {
+function record$4(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 /** One-line description of a tool call, mirroring the main window's step titles. */
 function toolSummary(input) {
-	const fields = record$3(input);
+	const fields = record$4(input);
 	if (fields === void 0) return void 0;
 	const candidate = [
 		fields.command,
@@ -6653,7 +7747,7 @@ function toolSummary(input) {
 function eventsOfStreamLine(line) {
 	let parsed;
 	try {
-		parsed = record$3(JSON.parse(line));
+		parsed = record$4(JSON.parse(line));
 	} catch {
 		return [];
 	}
@@ -6663,9 +7757,9 @@ function eventsOfStreamLine(line) {
 		text: "ready"
 	}];
 	if (parsed.type === "stream_event") {
-		const event = record$3(parsed.event);
+		const event = record$4(parsed.event);
 		if (event?.type === "content_block_start") {
-			const block = record$3(event.content_block);
+			const block = record$4(event.content_block);
 			if (block?.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string") return [{
 				type: "tool",
 				id: block.id,
@@ -6674,7 +7768,7 @@ function eventsOfStreamLine(line) {
 			}];
 			return [];
 		}
-		const delta = record$3(event?.delta);
+		const delta = record$4(event?.delta);
 		if (event?.type !== "content_block_delta" || delta === void 0) return [];
 		if (delta.type === "text_delta" && typeof delta.text === "string") return [{
 			type: "text",
@@ -6687,11 +7781,11 @@ function eventsOfStreamLine(line) {
 		return [];
 	}
 	if (parsed.type === "assistant" || parsed.type === "user") {
-		const content = record$3(parsed.message)?.content;
+		const content = record$4(parsed.message)?.content;
 		if (!Array.isArray(content)) return [];
 		const events = [];
 		for (const item of content) {
-			const block = record$3(item);
+			const block = record$4(item);
 			if (block?.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string") {
 				const summary = toolSummary(block.input);
 				events.push({
@@ -6783,11 +7877,11 @@ var AskService = class {
 };
 //#endregion
 //#region src/ask-routes.ts
-const MAX_BODY_BYTES$2 = 131072;
-const MAX_SESSION_ID_CHARS$2 = 1024;
+const MAX_BODY_BYTES$3 = 131072;
+const MAX_SESSION_ID_CHARS$3 = 1024;
 /** Two sessions may await an answer at once; a third evicts the oldest. */
 const MAX_CONCURRENT_ASKS = 2;
-function record$2(value) {
+function record$3(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 function askRequest(input) {
@@ -6819,12 +7913,12 @@ function registerAskRoute(ctx, service, cwdForSession, preferencesFor) {
 			let sessionId;
 			try {
 				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.");
+				if (value === null || value.length === 0 || value.length > MAX_SESSION_ID_CHARS$3) 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;
-				const body = record$2(await io.body(MAX_BODY_BYTES$2));
+				const body = record$3(await io.body(MAX_BODY_BYTES$3));
 				if (body === void 0) throw new AskError("invalid-request", "The request body is invalid.");
 				request = askRequest(body);
 			} catch (error) {
@@ -6864,26 +7958,26 @@ function registerAskRoute(ctx, service, cwdForSession, preferencesFor) {
 }
 //#endregion
 //#region src/review-comment-routes.ts
-const MAX_BODY_BYTES$1 = 16384;
-const MAX_SESSION_ID_CHARS$1 = 1024;
-function record$1(value) {
+const MAX_BODY_BYTES$2 = 16384;
+const MAX_SESSION_ID_CHARS$2 = 1024;
+function record$2(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
-async function readJson$1(io) {
+async function readJson$2(io) {
 	let parsed;
 	try {
-		parsed = await io.body(MAX_BODY_BYTES$1);
+		parsed = await io.body(MAX_BODY_BYTES$2);
 	} catch (error) {
 		if (error instanceof SyntaxError) throw error;
 		throw new ReviewCommentError("body-too-large", "The request body is too large.");
 	}
-	const value = record$1(parsed);
+	const value = record$2(parsed);
 	if (value === void 0) throw new ReviewCommentError("invalid-request", "The request body is invalid.");
 	return value;
 }
 function sessionIdFromUrl(url) {
 	const value = url.searchParams.get("sessionId");
-	if (value === null || value.length === 0 || value.length > MAX_SESSION_ID_CHARS$1) throw new ReviewCommentError("invalid-session", "The session is invalid.");
+	if (value === null || value.length === 0 || value.length > MAX_SESSION_ID_CHARS$2) throw new ReviewCommentError("invalid-session", "The session is invalid.");
 	return value;
 }
 function registerReviewCommentRoute(ctx, store, ownsSession) {
@@ -6899,7 +7993,7 @@ function registerReviewCommentRoute(ctx, store, ownsSession) {
 				if (!ownsSession(sessionId)) throw new ReviewCommentError("session-unavailable", "The Claude session is unavailable.");
 				const pathname = io.url.pathname;
 				if (pathname === "/plugins/dsh-claude/review-comments") {
-					const input = await readJson$1(io);
+					const input = await readJson$2(io);
 					return {
 						status: 200,
 						value: { comment: store.add(sessionId, {
@@ -6916,7 +8010,7 @@ function registerReviewCommentRoute(ctx, store, ownsSession) {
 					value: { removed: store.drain(sessionId).length }
 				};
 				if (pathname === `/plugins/dsh-claude/review-comments/remove`) {
-					const input = await readJson$1(io);
+					const input = await readJson$2(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 {
 						status: 200,
@@ -6951,6 +8045,85 @@ function registerReviewCommentRoute(ctx, store, ownsSession) {
 	});
 }
 //#endregion
+//#region src/plan-feedback-routes.ts
+const MAX_BODY_BYTES$1 = 65536;
+const MAX_SESSION_ID_CHARS$1 = 1024;
+const MAX_TOOL_USE_ID_CHARS = 256;
+function record$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+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 PlanFeedbackError("body-too-large", "The request body is too large.");
+	}
+	const value = record$1(parsed);
+	if (value === void 0) throw new PlanFeedbackError("invalid-request", "The request body is invalid.");
+	return value;
+}
+/** Send one plan back for changes.
+*
+*  Unary rather than a stream: the panel hands over what the reviewer wrote
+*  and the turn carries on in the transcript it was already watching. Answers
+*  409 when nothing is waiting, which is what the panel shows if the approval
+*  dialog was answered while the reviewer was still typing. */
+function registerPlanFeedbackRoute(ctx, gate, ownsSession) {
+	registerPluginRoute(ctx, {
+		mode: "unary",
+		budget: "fast",
+		kind: "exact",
+		path: CLAUDE_PLAN_FEEDBACK_PATH,
+		methods: ["POST"],
+		handler: async (io) => {
+			try {
+				const sessionId = io.url.searchParams.get("sessionId");
+				if (sessionId === null || sessionId.length === 0 || sessionId.length > MAX_SESSION_ID_CHARS$1) return {
+					status: 400,
+					value: { error: "invalid-session" }
+				};
+				if (!ownsSession(sessionId)) return {
+					status: 409,
+					value: { error: "session-unavailable" }
+				};
+				const body = await readJson$1(io);
+				const toolUseId = body.toolUseId;
+				if (typeof toolUseId !== "string" || toolUseId.length === 0 || toolUseId.length > MAX_TOOL_USE_ID_CHARS) return {
+					status: 400,
+					value: { error: "invalid-request" }
+				};
+				const notes = planNotesOf(body.notes);
+				if (!gate.submit(toolUseId, notes)) return {
+					status: 409,
+					value: { error: "plan-settled" }
+				};
+				return {
+					status: 200,
+					value: { ok: true }
+				};
+			} catch (error) {
+				if (error instanceof PlanFeedbackError) return {
+					status: 400,
+					value: {
+						error: error.code,
+						message: error.message
+					}
+				};
+				if (error instanceof SyntaxError) return {
+					status: 400,
+					value: { error: "invalid-json" }
+				};
+				return {
+					status: 500,
+					value: { error: "plan-feedback-unavailable" }
+				};
+			}
+		}
+	});
+}
+//#endregion
 //#region src/client-diagnostics-routes.ts
 /** Enough for a message plus a trimmed stack; the client caps its own volume. */
 const MAX_DIAGNOSTIC_BYTES = 8192;
@@ -7015,8 +8188,15 @@ async function readJson(io) {
 		return;
 	}
 }
-/** `POST <path>` with `{ sessionId, seq }`: hide that surface event and every
-*  later one, and arm Claude to resume before the turn it opened. */
+/** `POST <path>` with `{ sessionId, seq, restoreFiles? }`: hide that surface
+*  event and every later one, and arm Claude to resume before the turn it
+*  opened. With `restoreFiles`, the checkout is also put back to the tree that
+*  turn was admitted against.
+*
+*  The conversation rewind is what the user confirmed, so it lands first and
+*  stands on its own; a checkout that cannot be restored — no snapshot, a
+*  collected tree, no git — reports `filesRestored: false` rather than
+*  failing the rewind. */
 function registerClaudeRewindRoute(ctx, sidecar, access) {
 	registerPluginRoute(ctx, {
 		mode: "unary",
@@ -7042,16 +8222,22 @@ function registerClaudeRewindRoute(ctx, sidecar, access) {
 					status: 409,
 					value: { error: "session-busy" }
 				};
-				const planned = planRewind((await sidecar.read(sessionId)).rewind ?? EMPTY_REWIND_STATE, events, seq);
+				const current = (await sidecar.read(sessionId)).rewind ?? EMPTY_REWIND_STATE;
+				const planned = planRewind(current, events, seq);
 				if (planned === void 0) return {
 					status: 409,
 					value: { error: "seq-unavailable" }
 				};
-				await sidecar.writeRewind(sessionId, planned);
+				const tree = input?.restoreFiles === true ? rewindRestoreTree(current, events, seq) : void 0;
+				await sidecar.writeRewind(sessionId, planned, turnAtOrAfter(events, seq));
 				await access.reset(sessionId);
+				const filesRestored = tree === void 0 || access.restoreFiles === void 0 ? false : await access.restoreFiles(sessionId, tree).catch(() => false);
 				return {
 					status: 200,
-					value: { ranges: planned.ranges }
+					value: {
+						ranges: planned.ranges,
+						filesRestored
+					}
 				};
 			} catch (error) {
 				if (error instanceof SyntaxError) return {
@@ -7555,15 +8741,40 @@ const PROSE = {
 		else document.prose = value;
 	}
 };
+/** Whether a session that needs the user interrupts them. Presentation only,
+*  and read by the Client at delivery time, so like {@link PROSE} the switch
+*  lands the moment it is saved. */
+const ALERTS = {
+	key: "alerts",
+	kind: "select",
+	document: "plugin",
+	effect: "immediate",
+	async options() {
+		return CLAUDE_ALERT_MODES.map((value) => ({
+			value,
+			label: value,
+			source: "built-in"
+		}));
+	},
+	read(document) {
+		const value = document.alerts;
+		return isClaudeAlertMode(value) ? value : "on";
+	},
+	apply(document, value) {
+		if (!isClaudeAlertMode(value)) throw new Error("Invalid value for global setting alerts");
+		if (value === "on") delete document.alerts;
+		else document.alerts = value;
+	}
+};
 function isBoundedInteger(value, min, max) {
 	return typeof value === "number" && Number.isInteger(value) && value >= min && value <= max;
 }
-function integerSetting(key, min, max, defaultFor) {
+function integerSetting(key, min, max, defaultFor, effect = "new-session") {
 	return {
 		key,
 		kind: "text",
 		document: "plugin",
-		effect: "new-session",
+		effect,
 		maxLength: String(max).length,
 		read(document, defaults = DEFAULT_LIMITS) {
 			const value = document[key];
@@ -7580,8 +8791,9 @@ const DESCRIPTORS = [
 	OUTPUT_STYLE,
 	RENDERER,
 	PROSE,
+	ALERTS,
 	WORKTREE_BRANCH_PREFIX,
-	integerSetting("maxProcesses", 1, MAX_PROCESSES_LIMIT, (limits) => limits.maxProcesses),
+	integerSetting("maxProcesses", 1, MAX_PROCESSES_LIMIT, (limits) => limits.maxProcesses, "immediate"),
 	integerSetting("idleTimeoutMinutes", 1, MAX_IDLE_TIMEOUT_MINUTES, (limits) => Math.max(1, Math.round(limits.idleTimeoutMs / 6e4)))
 ];
 const DESCRIPTOR_BY_KEY = new Map(DESCRIPTORS.map((descriptor) => [descriptor.key, descriptor]));
@@ -7863,14 +9075,12 @@ async function apply(ctx, config) {
 	const supervisorConfig = {
 		executablePath: "",
 		defaultModel: config.model ?? "default",
-		renderMode: DEFAULT_CLAUDE_RENDER_MODE,
 		...defaultLimits
 	};
 	const applySettingsOverrides = async () => {
 		const overrides = await readSupervisorLimitOverrides();
 		supervisorConfig.idleTimeoutMs = overrides.idleTimeoutMs ?? defaultLimits.idleTimeoutMs;
 		supervisorConfig.maxProcesses = overrides.maxProcesses ?? defaultLimits.maxProcesses;
-		supervisorConfig.renderMode = await readRenderMode();
 	};
 	await applySettingsOverrides();
 	const sidecar = new ClaudeSidecarRepository();
@@ -7892,7 +9102,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), () => supervisorConfig.renderMode));
+		ctx.llm.registerAdapter([...CLAUDE_CODE_PROVIDER_IDS], createClaudeCodeAdapter(supervisor, ctx.agents, ctx.attachments, (agent) => ctx.agentPresets.composedPreset(agent.ctx), (sessionId) => reviewComments.drain(sessionId), () => readRenderMode(), (request) => summarizeSessionTitle(supervisorConfig.executablePath, request)));
 		ctx.effect(() => {
 			const mounted = /* @__PURE__ */ new Map();
 			const pending = /* @__PURE__ */ new Set();
@@ -7996,7 +9206,10 @@ async function apply(ctx, config) {
 		registerClaudeUpdateRoutes(webCtx, webCtx.subprocess, { ...typeof desktopActions?.requestRestart === "function" ? { requestRestart: desktopActions.requestRestart.bind(desktopActions) } : {} });
 		registerClaudeGlobalSettingsRoute(webCtx, {
 			defaultLimits,
-			onUpdated: applySettingsOverrides
+			onUpdated: async () => {
+				await applySettingsOverrides();
+				supervisor.limitsChanged();
+			}
 		});
 		registerRepositorySetupRoute(webCtx, repositorySetup, () => sweepWorktrees?.());
 		registerRepositoryStatusRoute(webCtx, repositoryStatus);
@@ -8010,6 +9223,10 @@ async function apply(ctx, config) {
 		};
 		registerRepositoryActionRoute(webCtx, repositoryActions, cwdForClaudeSession);
 		registerEditorOpenRoute(webCtx, new EditorOpenService(webCtx.subprocess), cwdForClaudeSession);
+		registerClaudePromptsRoute(webCtx);
+		const promptAssist = new PromptAssistService(webCtx.subprocess, () => supervisorConfig.executablePath);
+		registerClaudePromptNameRoute(webCtx, promptAssist);
+		registerClaudePromptRefineRoute(webCtx, promptAssist);
 		registerPullRequestFeedbackRoute(webCtx, new PullRequestFeedbackService(webCtx.subprocess), cwdForClaudeSession);
 		registerAskRoute(webCtx, new AskService(webCtx.subprocess, supervisorConfig.executablePath), cwdForClaudeSession, (sessionId) => {
 			const snapshot = supervisor.snapshots().find((item) => item.sessionId === sessionId);
@@ -8023,13 +9240,18 @@ async function apply(ctx, config) {
 			return agent !== void 0 && webCtx.agentPresets.composedPreset(agent.ctx) === "claude";
 		};
 		registerReviewCommentRoute(webCtx, reviewComments, ownsClaudeSession);
+		registerPlanFeedbackRoute(webCtx, supervisor.planFeedback, ownsClaudeSession);
 		registerClaudeRewindRoute(webCtx, sidecar, {
 			eventsFor: (sessionId) => {
 				const agent = webCtx.agents.get(sessionId);
 				return agent === void 0 || webCtx.agentPresets.composedPreset(agent.ctx) !== "claude" ? void 0 : agent.session.events;
 			},
 			busy: (sessionId) => supervisor.snapshots().some((item) => item.sessionId === sessionId && (item.state === "running" || item.state === "interrupting")),
-			reset: (sessionId) => supervisor.disposeSession(sessionId)
+			reset: (sessionId) => supervisor.disposeSession(sessionId),
+			restoreFiles: async (sessionId, tree) => {
+				const cwd = webCtx.agents.get(sessionId)?.session.header.cwd;
+				return cwd === void 0 ? false : restoreWorktreeTree(ctx.subprocess, cwd, tree);
+			}
 		});
 		registerPlanUsageRoute(webCtx, (fetchedAt) => probePlanUsage(supervisorConfig.executablePath, fetchedAt));
 		registerClaudeProjectionRoute(webCtx, sidecar, ownsClaudeSession, (sessionId) => commandCatalogs.get(sessionId) ?? [], async (sessionId) => {