@norman-else/dsh-claude 0.1.39 → 0.1.41

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_STATUS_PATH, B as isClaudeAlertMode, C as CLAUDE_PROJECTION_PATH, D as CLAUDE_REPOSITORY_FEEDBACK_PATH, E as CLAUDE_REPOSITORY_ACTION_PATH, F as CLAUDE_USAGE_PATH, H as isClaudeRenderMode, I as DEFAULT_CLAUDE_PROSE_MODE, L as DEFAULT_CLAUDE_RENDER_MODE, M as CLAUDE_REWIND_PATH, N as CLAUDE_UPDATE_CHECK_PATH, O as CLAUDE_REPOSITORY_FILE_PATH, P as CLAUDE_UPDATE_PATH, S as CLAUDE_PLAN_FEEDBACK_PATH, T as CLAUDE_RENDER_MODES, V 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_REVIEW_COMMENT_PATH, k as CLAUDE_REPOSITORY_SETUP_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_PROSE_MODES, x as CLAUDE_JIRA_PATH, y as CLAUDE_EDITOR_OPEN_PATH, z as TASK_TOOL_NAMES } from "./events-B-FPMzI7.mjs";
+import { a as projectClaudeCommands, i as CLAUDE_COMMANDS_SERVICE, r as dynamicPresenterDefinition, t as CLAUDE_PRESENTER_NAMES } from "./presenters-BV42EKkB.mjs";
+import { a as resolveClaudeExecutable, n as ensureManagedPreset, o as runClaudeDoctor, t as ManagedPresetConflictError } from "./preset-installer-yRGfkGjd.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. */
@@ -1549,6 +1885,8 @@ var ClaudeSupervisor = class {
 	#runtime;
 	#approval;
 	#userQuestions;
+	/** Lets the plan panel answer a plan's approval with revisions. */
+	planFeedback = new PlanFeedbackGate();
 	#config;
 	#queryFactory;
 	#runDetached;
@@ -1670,6 +2008,7 @@ var ClaudeSupervisor = class {
 		const active = {
 			agent: request.agent,
 			cursor,
+			native: (request.renderMode ?? this.#config.renderMode ?? "plugin") === "native",
 			output: new AsyncQueue(),
 			promptUuid,
 			phase: "primary",
@@ -1690,6 +2029,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",
@@ -1860,7 +2200,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 +2340,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 +2359,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 +2376,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 +2426,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 +2446,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
@@ -2436,6 +2773,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 +2804,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 +2823,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 +2862,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,
@@ -2670,6 +3021,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 +3252,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 +3273,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 +3286,7 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 		this.#presetIdFor = presetIdFor;
 		this.#drainReviewComments = drainReviewComments;
 		this.#renderMode = renderMode;
+		this.#summarizeTitle = summarizeTitle;
 	}
 	providerInfo(provider) {
 		return {
@@ -2888,7 +3329,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 +3391,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 +3499,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 +3809,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 +3817,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}/`;
@@ -3676,14 +4159,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 +4190,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 +4211,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) } : {}
@@ -4164,6 +4647,22 @@ function parseWorktreeBranches(value) {
 function slug(value, fallback) {
 	return value.toLocaleLowerCase("en-US").replace(/[^a-z0-9._-]+/gu, "-").replace(/^-+|-+$/gu, "").slice(0, 48) || fallback;
 }
+/** A branch name as one path segment: `/` and anything else unsafe folds to
+*  `-`, case is kept so a ticket key stays scannable (`PSOS-5683`, not
+*  `psos-5683`). Flattened rather than nested on purpose -- see
+*  {@link worktreeDirectoryName}. */
+function branchSegment(branch) {
+	return branch.replace(/[^A-Za-z0-9._-]+/gu, "-").replace(/^[-.]+/u, "").replace(/-+$/u, "").slice(0, 48).replace(/-+$/u, "") || "branch";
+}
+/** Name a worktree directory after the repository and the branch it holds, so
+*  the workspace list reads without opening a session.
+*
+*  One flat segment, never a `feature/x` subdirectory: the orphan sweep lists
+*  this root one level deep, and a prefix directory holds no lease of its own,
+*  so it would be removed along with every live worktree inside it. */
+function worktreeDirectoryName(root, branch) {
+	return `${slug(basename(root), "repository")}-${branchSegment(branch)}`;
+}
 /** Comparable form for path identity: resolved, forward slashes, case-folded
 *  so Windows drive-letter or case spelling differences cannot hide a match. */
 function comparablePath(value) {
@@ -4463,6 +4962,18 @@ var RepositorySetupService = class {
 		], root, GIT_FETCH_TIMEOUT_MS);
 		if (fetched.exitCode !== 0 || fetched.lossy) throw new RepositorySetupError("fetch-failed", "Git could not refresh remote references.");
 	}
+	/** The remote-tracking ref a local base branch follows, when that ref still
+	*  exists. Falls back to the local branch for a branch with no upstream. */
+	async #upstreamRef(git, info, branch) {
+		const upstream = await this.#run(git, [
+			"for-each-ref",
+			"--format=%(upstream:short)",
+			`refs/heads/${branch}`
+		], info.root);
+		if (upstream.exitCode !== 0 || upstream.lossy) return void 0;
+		const name = upstream.stdout.trim();
+		return name.length > 0 && info.remoteBranches.includes(name) ? `refs/remotes/${name}` : void 0;
+	}
 	async #checkout(info, branch) {
 		if (info.current !== branch) {
 			if (info.dirty) throw new RepositorySetupError("dirty-workspace", "Commit or stash workspace changes before switching branches.");
@@ -4493,10 +5004,11 @@ var RepositorySetupService = class {
 		const git = await this.#git();
 		progress("fetching");
 		await this.#fetchRemotes(git, root);
+		const startRef = reuseExistingBranch ? baseRef : await this.#upstreamRef(git, info, baseBranch) ?? baseRef;
 		const suffix = randomUUID().slice(0, 8);
 		const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/gu, "").replace(/\.\d{3}Z$/u, "Z");
 		const branch = explicitBranchName ?? await this.#generatedBranch(info, baseBranch, intent, stamp, suffix, progress);
-		const path = join(this.#worktreeRoot, `${slug(basename(root), "repository")}-${stamp}-${suffix}`);
+		const path = join(this.#worktreeRoot, await this.#freeDirectoryName(root, branch));
 		progress("creating-worktree");
 		await mkdir(this.#worktreeRoot, { recursive: true });
 		if (reuseExistingBranch) await this.#run(git, ["worktree", "prune"], root).catch(() => void 0);
@@ -4512,7 +5024,7 @@ var RepositorySetupService = class {
 			"-b",
 			branch,
 			path,
-			baseRef
+			startRef
 		], root);
 		if (created.exitCode !== 0) {
 			const detail = created.stderr.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0).at(-1);
@@ -4559,6 +5071,21 @@ var RepositorySetupService = class {
 	/** `<prefix>/<what the draft is about>`, falling back to
 	*  `<prefix>/<base branch>-<stamp>-<random>` whenever the summary is missing
 	*  or unusable. The prefix and the fallback shape are unchanged. */
+	/** The branch-named directory, or the first `-2`, `-3`, ... spelling free of
+	*  anything already on disk. Names no longer carry a timestamp, so a stale
+	*  directory a crash left behind -- or two branches that fold to the same
+	*  segment -- would otherwise fail `worktree add` outright. Compared
+	*  case-folded, since a case-insensitive filesystem would collide anyway. */
+	async #freeDirectoryName(root, branch) {
+		const base = worktreeDirectoryName(root, branch);
+		const taken = await readdir(this.#worktreeRoot).then((entries) => new Set(entries.map((entry) => entry.toLocaleLowerCase("en-US"))), () => /* @__PURE__ */ new Set());
+		if (!taken.has(base.toLocaleLowerCase("en-US"))) return base;
+		for (let index = 2; index < 100; index += 1) {
+			const candidate = `${base}-${index}`;
+			if (!taken.has(candidate.toLocaleLowerCase("en-US"))) return candidate;
+		}
+		return base;
+	}
 	async #generatedBranch(info, baseBranch, intent, stamp, suffix, progress) {
 		const prefix = safeBranch(await this.#branchPrefix());
 		if (intent !== void 0 && intent.trim().length > 0) {
@@ -5091,19 +5618,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;
 }
@@ -5172,7 +5699,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`) {
@@ -5183,14 +5710,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`) {
@@ -5200,7 +5727,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 });
 				}
@@ -5218,8 +5745,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",
@@ -5228,24 +5755,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) {
@@ -5309,7 +5836,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")) }
@@ -5322,7 +5849,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 {
@@ -5473,7 +6000,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) {
@@ -5487,7 +6014,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",
@@ -5602,7 +6129,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.
@@ -5610,12 +6137,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;
@@ -5627,14 +6154,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({
@@ -5663,11 +6190,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 {
@@ -5682,11 +6209,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({
@@ -5706,7 +6233,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,
@@ -5769,12 +6296,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;
@@ -5795,7 +6322,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 {
@@ -5918,23 +6445,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;
 }
@@ -5955,7 +6482,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) {
@@ -6014,7 +6541,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)) }
@@ -6025,7 +6552,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,
@@ -6171,7 +6698,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. */
@@ -6195,14 +6722,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);
 		}
@@ -6221,15 +6748,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) : "",
@@ -6271,7 +6798,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 = {
@@ -6290,7 +6817,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({
@@ -6366,7 +6893,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,
@@ -6397,21 +6924,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;
 }
@@ -6445,7 +6972,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({
@@ -6471,7 +6998,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,
@@ -6590,12 +7117,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,
@@ -6609,7 +7136,7 @@ function toolSummary(input) {
 function eventsOfStreamLine(line) {
 	let parsed;
 	try {
-		parsed = record$3(JSON.parse(line));
+		parsed = record$4(JSON.parse(line));
 	} catch {
 		return [];
 	}
@@ -6619,9 +7146,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,
@@ -6630,7 +7157,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",
@@ -6643,11 +7170,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({
@@ -6739,11 +7266,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) {
@@ -6775,12 +7302,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) {
@@ -6820,26 +7347,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) {
@@ -6855,7 +7382,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, {
@@ -6872,7 +7399,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,
@@ -6907,6 +7434,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;
@@ -6971,8 +7577,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",
@@ -6998,16 +7611,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 {
@@ -7511,6 +8130,31 @@ 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;
 }
@@ -7536,6 +8180,7 @@ const DESCRIPTORS = [
 	OUTPUT_STYLE,
 	RENDERER,
 	PROSE,
+	ALERTS,
 	WORKTREE_BRANCH_PREFIX,
 	integerSetting("maxProcesses", 1, MAX_PROCESSES_LIMIT, (limits) => limits.maxProcesses),
 	integerSetting("idleTimeoutMinutes", 1, MAX_IDLE_TIMEOUT_MINUTES, (limits) => Math.max(1, Math.round(limits.idleTimeoutMs / 6e4)))
@@ -7819,14 +8464,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();
@@ -7848,7 +8491,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();
@@ -7979,13 +8622,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) => {