@norman-else/dsh-claude 0.1.18 → 0.1.20

package/lib/index.mjs

@@ -1,16 +1,16 @@
-import { _ as CLAUDE_PROJECTION_PATH, a as latestClaudeTasks, c as normalizeTasksEvent, d as CLAUDE_ACTIVITY_EVENT, f as CLAUDE_CODE_PRESET_ID, g as CLAUDE_GLOBAL_SETTINGS_PATH, h as CLAUDE_DOCTOR_PATH, i as latestClaudeSessionBinding, l as redactText, m as CLAUDE_CODE_PROVIDER_IDS, n as currentClaudeActivityCursor, o as normalizeActivity, p as CLAUDE_CODE_PROVIDER, r as latestClaudeContextUsage, s as normalizeContextUsage, t as boundText, u as safeDetail, v as CLAUDE_UPDATE_CHECK_PATH, x as TASK_TOOL_NAMES, y as CLAUDE_UPDATE_PATH } from "./events-6xTApIQw.mjs";
-import { a as projectClaudeCommands, i as CLAUDE_COMMANDS_SERVICE, r as dynamicPresenterDefinition, t as CLAUDE_PRESENTER_NAMES } from "./presenters-BWXp9d3p.mjs";
-import { a as resolveClaudeExecutable, n as ensureManagedPreset, o as runClaudeDoctor, t as ManagedPresetConflictError } from "./preset-installer-B0NrA4Hi.mjs";
+import { S as CLAUDE_UPDATE_PATH, _ as CLAUDE_PROJECTION_PATH, a as latestClaudeTasks, b as CLAUDE_REVIEW_COMMENT_PATH, c as normalizeTasksEvent, d as CLAUDE_ACTIVITY_EVENT, f as CLAUDE_CODE_PRESET_ID, g as CLAUDE_GLOBAL_SETTINGS_PATH, h as CLAUDE_DOCTOR_PATH, i as latestClaudeSessionBinding, l as redactText, m as CLAUDE_CODE_PROVIDER_IDS, n as currentClaudeActivityCursor, o as normalizeActivity, p as CLAUDE_CODE_PROVIDER, r as latestClaudeContextUsage, s as normalizeContextUsage, t as boundText, u as safeDetail, v as CLAUDE_REPOSITORY_ACTION_PATH, w as TASK_TOOL_NAMES, x as CLAUDE_UPDATE_CHECK_PATH, y as CLAUDE_REPOSITORY_SETUP_PATH } from "./events-BdDs9ebF.mjs";
+import { n as projectClaudeCommands, t as CLAUDE_COMMANDS_SERVICE } from "./command-bridge-C10-lz6A.mjs";
+import { a as resolveClaudeExecutable, n as ensureManagedPreset, o as runClaudeDoctor, t as ManagedPresetConflictError } from "./preset-installer-DMANIjwu.mjs";
 import z from "@deepseek-ai/schemastery";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { chmod, mkdir, opendir, readFile, realpath, rename, rm, writeFile } from "node:fs/promises";
-import { dirname, extname, join, resolve } from "node:path";
+import { basename, dirname, extname, isAbsolute, join, resolve } from "node:path";
 import { dshHomePath, resolveDshHome } from "@deepseek-ai/dsh-home-paths";
 import { homedir } from "node:os";
 import { query } from "@anthropic-ai/claude-agent-sdk";
-import { CallId, LlmAdapter, ReasoningEffortId, createToolResultMessage } from "@deepseek-ai/dsh-llm";
 import { EventEmitter } from "node:events";
 import { DSH_ENV_PREFIX, SENSITIVE_ENV_PATTERN } from "@deepseek-ai/dsh-subprocess";
+import { LlmAdapter, ReasoningEffortId } from "@deepseek-ai/dsh-llm";
 import { fileURLToPath } from "node:url";
 //#region src/sidecar.ts
 const SIDECAR_SCHEMA_VERSION = 1;
@@ -22,18 +22,18 @@ function emptyProjection() {
 		activities: []
 	};
 }
-function record$1(value) {
+function record$5(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 function finiteInteger(value) {
 	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
-function string$1(value, max) {
+function string$3(value, max) {
 	return typeof value === "string" && value.length > 0 && value.length <= max;
 }
 function binding(value) {
-	const input = record$1(value);
-	if (input === void 0 || !string$1(input.claudeSessionId, 512) || !string$1(input.sdkVersion, 128) || !string$1(input.cwd, 4096) || input.cliVersion !== void 0 && !string$1(input.cliVersion, 128)) return void 0;
+	const input = record$5(value);
+	if (input === void 0 || !string$3(input.claudeSessionId, 512) || !string$3(input.sdkVersion, 128) || !string$3(input.cwd, 4096) || input.cliVersion !== void 0 && !string$3(input.cliVersion, 128)) return void 0;
 	return {
 		claudeSessionId: input.claudeSessionId,
 		sdkVersion: input.sdkVersion,
@@ -42,6 +42,7 @@ function binding(value) {
 	};
 }
 const ACTIVITY_KINDS = /* @__PURE__ */ new Set([
+	"text",
 	"status",
 	"thinking",
 	"tool-call",
@@ -61,22 +62,22 @@ const ACTIVITY_PHASES = /* @__PURE__ */ new Set([
 	"failed"
 ]);
 function activity(value) {
-	const input = record$1(value);
+	const input = record$5(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$1(value);
+	const input = record$5(value);
 	if (input === void 0 || !Array.isArray(input.categories)) return void 0;
 	return normalizeContextUsage(input);
 }
 function tasks(value) {
-	const input = record$1(value);
+	const input = record$5(value);
 	if (input === void 0 || !Array.isArray(input.tasks)) return void 0;
 	return normalizeTasksEvent(input.tasks);
 }
 function parseClaudeSidecar(value) {
-	const input = record$1(value);
+	const input = record$5(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");
@@ -525,10 +526,10 @@ function createUserQuestionBridge(userQuestions, activeContext) {
 }
 //#endregion
 //#region src/sdk-messages.ts
-function record(value) {
+function record$4(value) {
 	return value !== null && typeof value === "object" ? value : void 0;
 }
-function string(value) {
+function string$2(value) {
 	return typeof value === "string" ? value : void 0;
 }
 function taskUsageOf(usage) {
@@ -540,7 +541,7 @@ function taskUsageOf(usage) {
 	return Object.keys(normalized).length === 0 ? void 0 : normalized;
 }
 function resultUsage(message) {
-	const usage = record(message.usage);
+	const usage = record$4(message.usage);
 	const normalized = {};
 	if (usage !== void 0) {
 		if (typeof usage.input_tokens === "number") normalized.inputTokens = usage.input_tokens;
@@ -552,26 +553,26 @@ function resultUsage(message) {
 	return normalized;
 }
 function normalizeAssistant(message) {
-	const content = record(message.message)?.content;
+	const content = record$4(message.message)?.content;
 	if (!Array.isArray(content)) return [{
 		kind: "protocol-error",
 		title: "Malformed Claude assistant message",
 		detail: message
 	}];
-	const parentToolUseId = string(message.parent_tool_use_id);
+	const parentToolUseId = string$2(message.parent_tool_use_id);
 	const normalized = [];
 	for (const item of content) {
-		const block = record(item);
+		const block = record$4(item);
 		if (block === void 0) continue;
 		if (block.type === "text") {
-			const text = string(block.text);
+			const text = string$2(block.text);
 			if (text !== void 0 && text.length > 0) normalized.push({
 				kind: "assistant-text",
 				text,
 				...parentToolUseId === void 0 ? {} : { parentToolUseId }
 			});
 		} else if (block.type === "thinking") {
-			const text = string(block.thinking);
+			const text = string$2(block.thinking);
 			if (text !== void 0 && text.length > 0) normalized.push({
 				kind: "thinking",
 				text,
@@ -579,8 +580,8 @@ function normalizeAssistant(message) {
 				...parentToolUseId === void 0 ? {} : { parentToolUseId }
 			});
 		} else if (block.type === "tool_use") {
-			const toolUseId = string(block.id);
-			const toolName = string(block.name);
+			const toolUseId = string$2(block.id);
+			const toolName = string$2(block.name);
 			if (toolUseId !== void 0 && toolName !== void 0) normalized.push({
 				kind: "tool-call",
 				toolUseId,
@@ -593,18 +594,18 @@ function normalizeAssistant(message) {
 	return normalized;
 }
 function normalizeUser(message) {
-	const content = record(message.message)?.content;
+	const content = record$4(message.message)?.content;
 	if (!Array.isArray(content)) return [{
 		kind: "protocol-error",
 		title: "Malformed Claude user message",
 		detail: message
 	}];
-	const parentToolUseId = string(message.parent_tool_use_id);
+	const parentToolUseId = string$2(message.parent_tool_use_id);
 	const normalized = [];
 	for (const item of content) {
-		const block = record(item);
+		const block = record$4(item);
 		if (block?.type !== "tool_result") continue;
-		const toolUseId = string(block.tool_use_id);
+		const toolUseId = string$2(block.tool_use_id);
 		if (toolUseId === void 0) continue;
 		normalized.push({
 			kind: "tool-result",
@@ -617,11 +618,11 @@ function normalizeUser(message) {
 	return normalized;
 }
 function normalizeSystem(message) {
-	const subtype = string(message.subtype);
+	const subtype = string$2(message.subtype);
 	if (subtype === "init") {
-		const sessionId = string(message.session_id);
-		const cliVersion = string(message.claude_code_version);
-		const cwd = string(message.cwd);
+		const sessionId = string$2(message.session_id);
+		const cliVersion = string$2(message.claude_code_version);
+		const cwd = string$2(message.cwd);
 		return sessionId !== void 0 && cliVersion !== void 0 && cwd !== void 0 ? [{
 			kind: "init",
 			sessionId,
@@ -650,20 +651,20 @@ function normalizeSystem(message) {
 		title: `Claude session ${String(message.state)}`
 	}];
 	if (subtype === "permission_denied") {
-		const toolUseId = string(message.tool_use_id);
-		const toolName = string(message.tool_name);
+		const toolUseId = string$2(message.tool_use_id);
+		const toolName = string$2(message.tool_name);
 		if (toolUseId !== void 0 && toolName !== void 0) return [{
 			kind: "permission-denied",
 			toolUseId,
 			toolName,
-			summary: string(message.message) ?? "Claude Code denied the action"
+			summary: string$2(message.message) ?? "Claude Code denied the action"
 		}];
 	}
 	if (subtype === "task_started") {
-		const taskId = string(message.task_id);
-		const description = string(message.description);
-		const subagentType = string(message.subagent_type);
-		const taskType = string(message.task_type);
+		const taskId = string$2(message.task_id);
+		const description = string$2(message.description);
+		const subagentType = string$2(message.subagent_type);
+		const taskType = string$2(message.task_type);
 		return [{
 			kind: "subagent",
 			title: description ?? taskId ?? "Claude subagent started",
@@ -678,12 +679,12 @@ function normalizeSystem(message) {
 		}];
 	}
 	if (subtype === "task_progress") {
-		const taskId = string(message.task_id);
-		const description = string(message.description);
-		const summary = string(message.summary);
-		const subagentType = string(message.subagent_type);
-		const lastToolName = string(message.last_tool_name);
-		const usage = taskUsageOf(record(message.usage));
+		const taskId = string$2(message.task_id);
+		const description = string$2(message.description);
+		const summary = string$2(message.summary);
+		const subagentType = string$2(message.subagent_type);
+		const lastToolName = string$2(message.last_tool_name);
+		const usage = taskUsageOf(record$4(message.usage));
 		return [{
 			kind: "subagent",
 			title: summary ?? description ?? "Claude subagent update",
@@ -699,11 +700,11 @@ function normalizeSystem(message) {
 		}];
 	}
 	if (subtype === "task_updated") {
-		const patch = record(message.patch);
-		const status = string(patch?.status);
-		const taskId = string(message.task_id);
-		const description = string(patch?.description);
-		const error = string(patch?.error);
+		const patch = record$4(message.patch);
+		const status = string$2(patch?.status);
+		const taskId = string$2(message.task_id);
+		const description = string$2(patch?.description);
+		const error = string$2(patch?.error);
 		const taskStatus = status === void 0 ? void 0 : status === "killed" ? "killed" : status === "completed" ? "completed" : status === "failed" ? "failed" : "running";
 		return [{
 			kind: "subagent",
@@ -719,10 +720,10 @@ function normalizeSystem(message) {
 	if (subtype === "task_notification") {
 		const failed = message.status === "failed";
 		const stopped = message.status === "stopped" || message.status === "cancelled";
-		const taskId = string(message.task_id);
-		const summary = string(message.summary);
+		const taskId = string$2(message.task_id);
+		const summary = string$2(message.summary);
 		const taskStatus = failed ? "failed" : stopped ? "stopped" : "completed";
-		const usage = taskUsageOf(record(message.usage));
+		const usage = taskUsageOf(record$4(message.usage));
 		return [{
 			kind: "subagent",
 			title: summary ?? taskId ?? "Claude subagent finished",
@@ -737,10 +738,10 @@ function normalizeSystem(message) {
 	if (subtype === "background_tasks_changed") return [{
 		kind: "background-tasks",
 		tasks: (Array.isArray(message.tasks) ? message.tasks : []).flatMap((item) => {
-			const entry = record(item);
-			const taskId = string(entry?.task_id);
-			const description = string(entry?.description);
-			const taskType = string(entry?.task_type);
+			const entry = record$4(item);
+			const taskId = string$2(entry?.task_id);
+			const description = string$2(entry?.description);
+			const taskType = string$2(entry?.task_type);
 			if (taskId === void 0 || description === void 0) return [];
 			return [{
 				taskId,
@@ -756,7 +757,7 @@ function normalizeSystem(message) {
 	}];
 	if (subtype === "informational" || subtype === "notification" || subtype === "local_command_output") return [{
 		kind: message.level === "warning" ? "warning" : "status",
-		title: string(message.content) ?? string(message.text) ?? "Claude Code notice",
+		title: string$2(message.content) ?? string$2(message.text) ?? "Claude Code notice",
 		detail: message
 	}];
 	if (subtype?.startsWith("hook_") === true || subtype === "plugin_install") return [{
@@ -780,12 +781,12 @@ const RESULT_ERROR_SUBTYPES = /* @__PURE__ */ new Set([
 function normalizeSdkMessage(message) {
 	const value = message;
 	if (value.type === "stream_event") {
-		const event = record(value.event);
-		const parentToolUseId = string(value.parent_tool_use_id);
+		const event = record$4(value.event);
+		const parentToolUseId = string$2(value.parent_tool_use_id);
 		if (event?.type === "content_block_delta") {
-			const delta = record(event.delta);
+			const delta = record$4(event.delta);
 			if (delta?.type === "text_delta") {
-				const text = string(delta.text);
+				const text = string$2(delta.text);
 				return text === void 0 ? [] : [{
 					kind: "text-delta",
 					text,
@@ -793,7 +794,7 @@ function normalizeSdkMessage(message) {
 				}];
 			}
 			if (delta?.type === "thinking_delta") {
-				const text = string(delta.thinking);
+				const text = string$2(delta.thinking);
 				return text === void 0 ? [] : [{
 					kind: "thinking",
 					text,
@@ -808,7 +809,7 @@ function normalizeSdkMessage(message) {
 	if (value.type === "user") return normalizeUser(value);
 	if (value.type === "system") return normalizeSystem(value);
 	if (value.type === "result") {
-		const sessionId = string(value.session_id);
+		const sessionId = string$2(value.session_id);
 		if (sessionId === void 0 || value.subtype !== "success" && !RESULT_ERROR_SUBTYPES.has(String(value.subtype))) return [{
 			kind: "protocol-error",
 			title: "Malformed Claude result message",
@@ -816,11 +817,11 @@ function normalizeSdkMessage(message) {
 		}];
 		const success = value.subtype === "success" && value.is_error !== true;
 		const errors = Array.isArray(value.errors) ? value.errors.filter((item) => typeof item === "string") : void 0;
-		const terminalReason = string(value.terminal_reason);
-		const userMessageUuid = string(value.user_message_uuid);
-		const permissionDenials = Array.isArray(value.permission_denials) ? value.permission_denials.map((item) => record(item)).filter((item) => item !== void 0).map((item) => {
-			const toolName = string(item.tool_name);
-			const toolUseId = string(item.tool_use_id);
+		const terminalReason = string$2(value.terminal_reason);
+		const userMessageUuid = string$2(value.user_message_uuid);
+		const permissionDenials = Array.isArray(value.permission_denials) ? value.permission_denials.map((item) => record$4(item)).filter((item) => item !== void 0).map((item) => {
+			const toolName = string$2(item.tool_name);
+			const toolUseId = string$2(item.tool_use_id);
 			return toolName === void 0 || toolUseId === void 0 ? void 0 : {
 				toolName,
 				toolUseId
@@ -844,11 +845,10 @@ function normalizeSdkMessage(message) {
 		detail: value.error ?? value.output
 	}];
 	if (value.type === "rate_limit_event") {
-		const status = string(record(value.rate_limit_info)?.status);
-		const blocking = status !== void 0 && status !== "allowed";
+		const status = string$2(record$4(value.rate_limit_info)?.status);
 		return [{
-			kind: blocking ? "warning" : "status",
-			title: blocking ? "Claude rate limit is blocking requests" : "Claude rate limit status changed",
+			kind: "status",
+			title: status !== void 0 && status !== "allowed" ? "Claude rate limit is blocking requests" : "Claude rate limit status changed",
 			detail: value.rate_limit_info
 		}];
 	}
@@ -1034,6 +1034,7 @@ function rootCallSummary(toolName, input) {
 }
 var ClaudeSupervisor = class {
 	#entries = /* @__PURE__ */ new Map();
+	#interruptions = /* @__PURE__ */ new Map();
 	#runtime;
 	#approval;
 	#userQuestions;
@@ -1041,7 +1042,6 @@ var ClaudeSupervisor = class {
 	#queryFactory;
 	#runDetached;
 	#sidecar;
-	#dynamicPresenterNames = /* @__PURE__ */ new WeakMap();
 	#contextWindows = /* @__PURE__ */ new Map();
 	#disposed = false;
 	#admissionGate = Promise.resolve();
@@ -1082,6 +1082,8 @@ var ClaudeSupervisor = class {
 		return this.#contextWindows.get(model);
 	}
 	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));
 		this.#admissionGate = operation.then(() => void 0, () => void 0);
 		return operation;
@@ -1134,6 +1136,8 @@ var ClaudeSupervisor = class {
 			sawActivity: false,
 			sawTextDelta: false,
 			text: "",
+			transcriptText: "",
+			transcriptTextOrdinal: void 0,
 			thinking: "",
 			aborted: false,
 			deniedToolUseIds: /* @__PURE__ */ new Set(),
@@ -1172,7 +1176,7 @@ var ClaudeSupervisor = class {
 		}
 		if (request.signal !== void 0) {
 			const abortListener = () => {
-				this.#interrupt(entry);
+				this.#startInterrupt(entry);
 			};
 			active.abortListener = abortListener;
 			request.signal.addEventListener("abort", abortListener, { once: true });
@@ -1387,7 +1391,14 @@ var ClaudeSupervisor = class {
 			if (message.userMessageUuid !== void 0 && message.userMessageUuid === entry.handshakeUuid) return;
 			if (entry.claudeSessionId === void 0) throw new ClaudeProtocolError("Claude Code sent a result before initialization");
 			if (message.sessionId !== entry.claudeSessionId) throw new ClaudeProtocolError(`Claude Code result session ${message.sessionId} does not match ${entry.claudeSessionId}`);
-			if (message.userMessageUuid !== void 0 && message.userMessageUuid !== active.promptUuid) throw new ClaudeProtocolError(`Claude Code result for user message ${message.userMessageUuid} does not match active request ${active.promptUuid}`);
+			if (active.phase === "waiting-tasks") {
+				await this.#completeProgressSegment(active, message);
+				return;
+			}
+			if (message.userMessageUuid !== void 0 && message.userMessageUuid !== active.promptUuid) {
+				if (active.phase === "follow-up") return;
+				throw new ClaudeProtocolError(`Claude Code result for user message ${message.userMessageUuid} does not match active request ${active.promptUuid}`);
+			}
 			await this.#completeTurn(entry, active, message);
 			return;
 		}
@@ -1398,6 +1409,8 @@ var ClaudeSupervisor = class {
 				if (message.parentToolUseId !== void 0) return;
 				active.sawTextDelta = true;
 				active.text += message.text;
+				active.transcriptText += message.text;
+				await this.#upsertTranscriptText(active);
 				active.output.push({
 					type: "text-delta",
 					text: message.text
@@ -1408,6 +1421,8 @@ var ClaudeSupervisor = class {
 				if (!active.sawTextDelta) {
 					active.sawTextDelta = true;
 					active.text += message.text;
+					active.transcriptText += message.text;
+					await this.#upsertTranscriptText(active);
 					active.output.push({
 						type: "text-delta",
 						text: message.text
@@ -1429,6 +1444,7 @@ var ClaudeSupervisor = class {
 				});
 				return;
 			case "tool-call":
+				if (message.parentToolUseId === void 0) this.#closeTranscriptTextSegment(active);
 				await this.#appendActivity(active, {
 					kind: message.parentToolUseId === void 0 ? "tool-call" : "subagent",
 					phase: "started",
@@ -1439,11 +1455,7 @@ var ClaudeSupervisor = class {
 					summary: message.parentToolUseId === void 0 ? rootCallSummary(message.toolName, message.input) : `Subagent called ${message.toolName}`,
 					detail: message.input
 				});
-				if (message.parentToolUseId === void 0) {
-					active.callNames.set(message.toolUseId, message.toolName);
-					this.#ensureDynamicPresenter(active.agent, message.toolName);
-					if (!TASK_TOOL_NAMES.has(message.toolName)) await this.#appendNativeToolCall(active, message);
-				}
+				if (message.parentToolUseId === void 0) active.callNames.set(message.toolUseId, message.toolName);
 				return;
 			case "tool-result":
 				await this.#appendActivity(active, {
@@ -1455,7 +1467,6 @@ var ClaudeSupervisor = class {
 					detail: message.output,
 					isError: message.isError
 				});
-				if (message.parentToolUseId === void 0 && !TASK_TOOL_NAMES.has(active.callNames.get(message.toolUseId) ?? "")) await this.#appendNativeToolResult(active, message);
 				return;
 			case "subagent":
 				await this.#appendActivity(active, {
@@ -1488,12 +1499,6 @@ var ClaudeSupervisor = class {
 					title: message.toolName,
 					summary: message.summary
 				});
-				if (!TASK_TOOL_NAMES.has(active.callNames.get(message.toolUseId) ?? message.toolName)) await this.#appendNativeToolResult(active, {
-					kind: "tool-result",
-					toolUseId: message.toolUseId,
-					output: message.summary,
-					isError: true
-				});
 				return;
 		}
 	}
@@ -1571,6 +1576,7 @@ var ClaudeSupervisor = class {
 		active.promptUuid = randomUUID();
 		active.sawTextDelta = false;
 		active.text = "";
+		this.#closeTranscriptTextSegment(active);
 		active.thinking = "";
 		await this.#appendSafely(active, {
 			kind: "status",
@@ -1604,9 +1610,43 @@ var ClaudeSupervisor = class {
 		entry.taskSnapshotAt = Date.now();
 		await this.#sidecar.writeTasks(entry.sessionId, [...entry.tasks.values()]).catch(() => void 0);
 	}
+	async #completeProgressSegment(active, result, recordUsage = true) {
+		if (recordUsage && (result.usage.inputTokens !== void 0 || result.usage.outputTokens !== void 0 || result.usage.cumulativeCostUsd !== void 0)) {
+			await this.#appendSafely(active, {
+				kind: "usage",
+				phase: "completed",
+				title: "Claude usage",
+				summary: usageSummary(result.usage),
+				usage: result.usage
+			});
+			active.output.push({
+				type: "usage",
+				usage: result.usage
+			});
+		}
+		if (!active.sawTextDelta && active.text.length === 0 && result.text !== void 0) {
+			active.text = result.text;
+			active.transcriptText = result.text;
+			await this.#upsertTranscriptText(active);
+			active.output.push({
+				type: "text-delta",
+				text: result.text
+			});
+		}
+		await this.#upsertTranscriptText(active);
+		active.output.push({
+			type: "segment-complete",
+			text: active.text
+		});
+		active.sawTextDelta = false;
+		active.text = "";
+		this.#closeTranscriptTextSegment(active);
+		active.thinking = "";
+	}
 	async #completeTurn(entry, active, result) {
 		if (entry.active !== active) return;
 		if (active.aborted) {
+			await this.#upsertTranscriptText(active);
 			await this.#appendSafely(active, {
 				kind: "status",
 				phase: "failed",
@@ -1639,6 +1679,16 @@ var ClaudeSupervisor = class {
 			summary: unmatchedDenials.map((denial) => denial.toolName).join(", ")
 		});
 		if (!result.success) {
+			if (!active.sawTextDelta && active.text.length === 0 && result.text !== void 0) {
+				active.text = result.text;
+				active.transcriptText = result.text;
+				await this.#upsertTranscriptText(active);
+				active.output.push({
+					type: "text-delta",
+					text: result.text
+				});
+			}
+			await this.#upsertTranscriptText(active);
 			const message = result.errors?.join("\n") ?? (result.terminalReason !== void 0 ? `Claude Code failed the turn (${result.terminalReason})` : "Claude Code failed the turn");
 			await this.#appendSafely(active, {
 				kind: "error",
@@ -1651,11 +1701,14 @@ var ClaudeSupervisor = class {
 		} else {
 			if (!active.sawTextDelta && active.text.length === 0 && result.text !== void 0) {
 				active.text = result.text;
+				active.transcriptText = result.text;
+				await this.#upsertTranscriptText(active);
 				active.output.push({
 					type: "text-delta",
 					text: result.text
 				});
 			}
+			await this.#upsertTranscriptText(active);
 			if (active.phase === "primary" && this.#hasRunningTasks(entry, active)) {
 				active.phase = "waiting-tasks";
 				await this.#appendSafely(active, {
@@ -1663,10 +1716,7 @@ var ClaudeSupervisor = class {
 					phase: "updated",
 					title: "Claude Code is waiting for background tasks"
 				});
-				active.output.push({
-					type: "segment-complete",
-					text: active.text
-				});
+				await this.#completeProgressSegment(active, result, false);
 				return;
 			}
 			await this.#appendSafely(active, {
@@ -1686,6 +1736,25 @@ var ClaudeSupervisor = class {
 		entry.lastUsedAt = Date.now();
 		this.#armIdleTimer(entry);
 	}
+	async #upsertTranscriptText(active) {
+		if (active.transcriptText.length === 0) return;
+		const ordinal = active.transcriptTextOrdinal ?? active.cursor.nextOrdinal++;
+		active.transcriptTextOrdinal = ordinal;
+		try {
+			await this.#sidecar.appendActivity(active.agent.id, {
+				kind: "text",
+				phase: "updated",
+				text: active.transcriptText,
+				turn: active.cursor.turn,
+				step: active.cursor.step,
+				ordinal
+			});
+		} catch {}
+	}
+	#closeTranscriptTextSegment(active) {
+		active.transcriptText = "";
+		active.transcriptTextOrdinal = void 0;
+	}
 	async #appendActivity(active, activity) {
 		const ordinal = active.cursor.nextOrdinal++;
 		await this.#sidecar.appendActivity(active.agent.id, {
@@ -1700,53 +1769,14 @@ var ClaudeSupervisor = class {
 	async #appendSafely(active, activity) {
 		await this.#appendActivity(active, activity).catch(() => void 0);
 	}
-	/** Register one presenter-only mirror for a tool name the static preset
-	*  registry does not cover (MCP tools, newly added built-ins). Runs in the
-	*  agent scope so the mirror is visible only to this preset's sessions and
-	*  unwinds with the agent; failure keeps the generic card, never the turn. */
-	#ensureDynamicPresenter(agent, name) {
-		if (CLAUDE_PRESENTER_NAMES.has(name)) return;
-		let known = this.#dynamicPresenterNames.get(agent);
-		if (known === void 0) {
-			known = /* @__PURE__ */ new Set();
-			this.#dynamicPresenterNames.set(agent, known);
-		}
-		if (known.has(name)) return;
-		try {
-			agent.ctx.tools.register(dynamicPresenterDefinition(name));
-			known.add(name);
-		} catch {}
-	}
-	/** Mirror one root Claude tool call into the durable native tool channel so
-	*  the host's tool presentation renders it exactly like a DSH-executed call.
-	*  Presentation duplication is best-effort and never unsettles the turn. */
-	async #appendNativeToolCall(active, message) {
-		try {
-			await active.agent.session.append("tool/call", {
-				turn: active.cursor.turn,
-				step: active.cursor.step,
-				callId: CallId(message.toolUseId),
-				name: message.toolName,
-				arguments: safeDetail(message.input) ?? "{}"
-			});
-		} catch {}
-	}
-	async #appendNativeToolResult(active, message) {
-		const text = typeof message.output === "string" ? redactText(message.output) : safeDetail(message.output) ?? "";
-		try {
-			await active.agent.session.append("tool/result", {
-				turn: active.cursor.turn,
-				step: active.cursor.step,
-				message: createToolResultMessage({
-					callId: CallId(message.toolUseId),
-					content: [{
-						type: "text",
-						text
-					}],
-					isError: message.isError
-				})
-			}, { surfaceOp: "append" });
-		} catch {}
+	#startInterrupt(entry) {
+		const existing = this.#interruptions.get(entry.sessionId);
+		if (existing !== void 0) return existing;
+		const interruption = this.#interrupt(entry).finally(() => {
+			this.#interruptions.delete(entry.sessionId);
+		});
+		this.#interruptions.set(entry.sessionId, interruption);
+		return interruption;
 	}
 	async #interrupt(entry) {
 		const active = entry.active;
@@ -1754,6 +1784,7 @@ var ClaudeSupervisor = class {
 		entry.state = "interrupting";
 		active.aborted = true;
 		active.output.fail(abortFailure());
+		await this.#upsertTranscriptText(active);
 		let interruptError;
 		try {
 			if (((await withTimeout(entry.query.interrupt(), 5e3, "Claude Code interrupt"))?.still_queued ?? []).includes(active.promptUuid)) throw new Error(`Claude Code interrupt left submitted prompt ${active.promptUuid} queued`);
@@ -1775,6 +1806,7 @@ var ClaudeSupervisor = class {
 		const active = entry.active;
 		const stderr = entry.process?.stderrTail();
 		if (active !== void 0) {
+			await this.#upsertTranscriptText(active);
 			if (active.signal !== void 0 && active.abortListener !== void 0) active.signal.removeEventListener("abort", active.abortListener);
 			const unknown = active.sawActivity;
 			entry.state = unknown ? "outcome-unknown" : "disconnected";
@@ -1830,6 +1862,79 @@ var ClaudeSupervisor = class {
 	}
 };
 //#endregion
+//#region src/review-comments.ts
+const MAX_COMMENTS_PER_SESSION = 50;
+const MAX_TEXT_CHARS$1 = 2e3;
+const MAX_PATH_CHARS$1 = 1024;
+const MAX_LINE = 1e7;
+var ReviewCommentError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "ReviewCommentError";
+		this.code = code;
+	}
+};
+function validSide(value) {
+	return value === "old" || value === "new";
+}
+/** Pending line comments queued per session until the next user turn drains them. */
+var ReviewCommentStore = class {
+	#comments = /* @__PURE__ */ new Map();
+	add(sessionId, input) {
+		const path = typeof input.path === "string" ? input.path.trim() : "";
+		const text = typeof input.text === "string" ? input.text.trim() : "";
+		if (path.length === 0 || path.length > MAX_PATH_CHARS$1 || /[\0\r\n]/u.test(path)) throw new ReviewCommentError("invalid-request", "The comment path is invalid.");
+		if (text.length === 0 || text.length > MAX_TEXT_CHARS$1 || text.includes("\0")) throw new ReviewCommentError("invalid-request", "The comment text is invalid.");
+		if (typeof input.line !== "number" || !Number.isSafeInteger(input.line) || input.line < 1 || input.line > MAX_LINE) throw new ReviewCommentError("invalid-request", "The comment line is invalid.");
+		if (!validSide(input.side)) throw new ReviewCommentError("invalid-request", "The comment side is invalid.");
+		const existing = this.#comments.get(sessionId) ?? [];
+		if (existing.length >= MAX_COMMENTS_PER_SESSION) throw new ReviewCommentError("too-many-comments", "Too many pending review comments. Remove one before adding another.");
+		const comment = {
+			id: randomUUID(),
+			path,
+			line: input.line,
+			side: input.side,
+			text
+		};
+		this.#comments.set(sessionId, [...existing, comment]);
+		return comment;
+	}
+	remove(sessionId, id) {
+		const existing = this.#comments.get(sessionId);
+		if (existing === void 0) return false;
+		const next = existing.filter((comment) => comment.id !== id);
+		if (next.length === existing.length) return false;
+		if (next.length === 0) this.#comments.delete(sessionId);
+		else this.#comments.set(sessionId, next);
+		return true;
+	}
+	list(sessionId) {
+		return this.#comments.get(sessionId) ?? [];
+	}
+	/** Remove and return every pending comment; called when a user turn consumes them. */
+	drain(sessionId) {
+		const existing = this.#comments.get(sessionId) ?? [];
+		this.#comments.delete(sessionId);
+		return existing;
+	}
+	disposeSession(sessionId) {
+		this.#comments.delete(sessionId);
+	}
+	dispose() {
+		this.#comments.clear();
+	}
+};
+/** Render drained comments as the prompt block preceding the user's message text. */
+function formatReviewComments(comments) {
+	return [
+		"<user-review-comments>",
+		"The user attached these code review comments to this message. Each references a file and line from the current working tree diff:",
+		...comments.map((comment, index) => `${index + 1}. ${comment.path}:${comment.line}${comment.side === "old" ? " (old side)" : ""} — ${comment.text}`),
+		"</user-review-comments>"
+	].join("\n");
+}
+//#endregion
 //#region src/adapter.ts
 const MODELS = [
 	{
@@ -1926,6 +2031,22 @@ function validateImageRef(ref, attachments, imageIndex) {
 	const maxDimension = "maxImageDimension" in limits && finiteNonNegative(limits.maxImageDimension) ? limits.maxImageDimension : void 0;
 	if (!finiteNonNegative(ref.width) || !finiteNonNegative(ref.height) || ref.width * ref.height > limits.maxImagePixels || maxDimension !== void 0 && (ref.width > maxDimension || ref.height > maxDimension)) throw new Error(`dsh-claude: image ${imageIndex} exceeds the configured dimension limit`);
 }
+/**
+* Prepend the session's pending diff-review comments to the outgoing user
+* prompt. The comments are drained once per turn: they are formatted into one
+* `<user-review-comments>` block placed ahead of the user's own text (or as a
+* leading text block for multi-part prompts) so Claude reads them in the same
+* turn that consumed them.
+*/
+function injectReviewComments(prompt, comments) {
+	if (comments.length === 0) return prompt;
+	const block = formatReviewComments(comments);
+	if (typeof prompt === "string") return `${block}\n\n${prompt}`;
+	return [{
+		type: "text",
+		text: block
+	}, ...prompt];
+}
 function imageBlock(data, mediaType) {
 	return {
 		type: "image",
@@ -2008,12 +2129,14 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 	#agents;
 	#attachments;
 	#presetIdFor;
-	constructor(supervisor, agents, attachments, presetIdFor) {
+	#drainReviewComments;
+	constructor(supervisor, agents, attachments, presetIdFor, drainReviewComments = () => []) {
 		super();
 		this.#supervisor = supervisor;
 		this.#agents = agents;
 		this.#attachments = attachments;
 		this.#presetIdFor = presetIdFor;
+		this.#drainReviewComments = drainReviewComments;
 	}
 	providerInfo(provider) {
 		return {
@@ -2033,7 +2156,7 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 			inputModalities: ["text", "image"]
 		}));
 	}
-	async resolveModel(provider, model) {
+	async resolveModel(provider, model, _signal) {
 		const known = MODELS.find((item) => item.id === model);
 		const contextWindow = this.#supervisor.contextWindow(model) ?? (known !== void 0 && "contextWindow" in known ? known.contextWindow : void 0);
 		return {
@@ -2050,6 +2173,12 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 			})) }
 		};
 	}
+	async prepareCall(provider, model, signal) {
+		return {
+			model: await this.resolveModel(provider, model, signal),
+			stream: (options) => this.stream(options)
+		};
+	}
 	async *stream(options) {
 		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);
@@ -2074,42 +2203,20 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 		}
 		const events = await this.#supervisor.runTurn({
 			agent,
-			prompt,
+			prompt: injectReviewComments(prompt, this.#drainReviewComments(agent.id)),
 			model: options.model,
 			...thinkingMode === void 0 ? {} : { thinkingMode },
 			...options.signal === void 0 ? {} : { signal: options.signal }
 		});
-		let text = "";
 		let pendingUsage;
 		let completed = false;
-		let blockIndex = 0;
 		try {
-			for await (const event of events) if (event.type === "text-delta") text += event.text;
-			else if (event.type === "usage") pendingUsage = tokenUsage(event.usage);
-			else {
-				if (text.length > 0) {
-					yield {
-						type: "block-start",
-						index: blockIndex,
-						blockType: "text"
-					};
-					yield {
-						type: "text-delta",
-						index: blockIndex,
-						text
-					};
-					yield {
-						type: "block-end",
-						index: blockIndex,
-						block: {
-							type: "text",
-							text
-						}
-					};
-					blockIndex += 1;
+			for await (const event of events) {
+				if (event.type === "text-delta" || event.type === "segment-complete") continue;
+				if (event.type === "usage") {
+					pendingUsage = tokenUsage(event.usage);
+					continue;
 				}
-				text = "";
-				if (event.type === "segment-complete") continue;
 				completed = true;
 				if (pendingUsage !== void 0) yield {
 					type: "usage",
@@ -2123,26 +2230,6 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 		} catch (error) {
 			if (error.name === "AbortError") {
 				completed = true;
-				if (text.length > 0) {
-					yield {
-						type: "block-start",
-						index: blockIndex,
-						blockType: "text"
-					};
-					yield {
-						type: "text-delta",
-						index: blockIndex,
-						text
-					};
-					yield {
-						type: "block-end",
-						index: blockIndex,
-						block: {
-							type: "text",
-							text
-						}
-					};
-				}
 				yield {
 					type: "finish",
 					reason: {
@@ -2160,8 +2247,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) {
-	return new ClaudeCodeAdapter(supervisor, agents, attachments, presetIdFor);
+function createClaudeCodeAdapter(supervisor, agents, attachments, presetIdFor, drainReviewComments = () => []) {
+	return new ClaudeCodeAdapter(supervisor, agents, attachments, presetIdFor, drainReviewComments);
 }
 //#endregion
 //#region src/http.ts
@@ -2288,8 +2375,8 @@ function registerClaudeDoctorRoutes(ctx, runtime, supervisor, config, resolution
 }
 //#endregion
 //#region src/projection-routes.ts
-const MAX_SESSION_ID_CHARS = 1024;
-function sessionIdFromUrl(rawUrl) {
+const MAX_SESSION_ID_CHARS$2 = 1024;
+function sessionIdFromUrl$1(rawUrl) {
 	try {
 		const pathname = new URL(rawUrl ?? "/", "http://localhost").pathname;
 		const prefix = `${CLAUDE_PROJECTION_PATH}/`;
@@ -2297,32 +2384,36 @@ function sessionIdFromUrl(rawUrl) {
 		const encoded = pathname.slice(prefix.length);
 		if (encoded.length === 0 || encoded.includes("/")) return void 0;
 		const sessionId = decodeURIComponent(encoded);
-		if (sessionId.length === 0 || sessionId.length > MAX_SESSION_ID_CHARS) return void 0;
+		if (sessionId.length === 0 || sessionId.length > MAX_SESSION_ID_CHARS$2) return void 0;
 		return sessionId;
 	} catch {
 		return;
 	}
 }
 /** Register the browser-readable, credential-free sidecar projection endpoint. */
-function registerClaudeProjectionRoute(ctx, sidecar, ownsSession, commandsForSession = () => []) {
+function registerClaudeProjectionRoute(ctx, sidecar, ownsSession, commandsForSession = () => [], repositoryForSession = async () => void 0, reviewCommentsForSession = () => []) {
 	ctx.effect(() => ctx.webServer.register({
 		kind: "prefix",
 		path: CLAUDE_PROJECTION_PATH,
 		handler: async (req, res) => {
 			if (req.method !== "GET") return json(res, 405, { error: "method not allowed" });
 			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
-			const sessionId = sessionIdFromUrl(req.url);
+			const sessionId = sessionIdFromUrl$1(req.url);
 			if (sessionId === void 0) return json(res, 400, { error: "invalid session id" });
 			try {
 				const projection = await sidecar.read(sessionId);
+				const owned = ownsSession(sessionId);
+				const repository = owned ? await repositoryForSession(sessionId) : void 0;
 				return json(res, 200, {
 					schemaVersion: projection.schemaVersion,
 					revision: projection.revision,
-					owned: ownsSession(sessionId),
+					owned,
 					commands: commandsForSession(sessionId),
 					activities: projection.activities,
 					...projection.contextUsage === void 0 ? {} : { contextUsage: projection.contextUsage },
-					...projection.tasks === void 0 ? {} : { tasks: projection.tasks }
+					...projection.tasks === void 0 ? {} : { tasks: projection.tasks },
+					...repository === void 0 ? {} : { repository },
+					reviewComments: owned ? reviewCommentsForSession(sessionId) : []
 				});
 			} catch {
 				return json(res, 500, { error: "projection unavailable" });
@@ -2331,6 +2422,1394 @@ function registerClaudeProjectionRoute(ctx, sidecar, ownsSession, commandsForSes
 	}), "dsh-claude: sidecar projection route");
 }
 //#endregion
+//#region src/repository-status.ts
+const MAX_OUTPUT_BYTES$2 = 65536;
+const MAX_DIFF_BYTES = 262144;
+const MAX_UNTRACKED_DIFFS = 50;
+const GIT_TIMEOUT_MS$2 = 5e3;
+const GH_TIMEOUT_MS = 8e3;
+const CACHE_TTL_MS = 5e3;
+const MAX_TEXT_CHARS = 1024;
+function bounded(value) {
+	return value.trim().slice(0, MAX_TEXT_CHARS);
+}
+async function collect$2(handle) {
+	const outcome = await handle.done;
+	const stdout = handle.collected.stdout?.readFrom(0);
+	return {
+		exitCode: outcome.exitCode,
+		stdout: stdout?.text ?? "",
+		lossy: stdout?.lossy === true
+	};
+}
+async function run(runtime, executable, args, cwd, timeoutMs, maxBytes = MAX_OUTPUT_BYTES$2) {
+	const signal = AbortSignal.timeout(timeoutMs);
+	return collect$2(runtime.spawn({
+		argv: [executable, ...args],
+		cwd,
+		stdio: {
+			stdin: "ignore",
+			stdout: { maxBytes },
+			stderr: { maxBytes: MAX_OUTPUT_BYTES$2 }
+		},
+		graceMs: 1e3,
+		signal,
+		env: {}
+	}));
+}
+function normalizedPath(value) {
+	return value.replaceAll("\\", "/").replace(/\/+$/u, "").toLocaleLowerCase("en-US");
+}
+function parseGitStatus(output) {
+	let branch;
+	let detached = false;
+	let dirty = false;
+	let upstream = false;
+	let ahead;
+	let behind;
+	for (const line of output.split(/\r?\n/u)) {
+		if (line.startsWith("# branch.head ")) {
+			const head = bounded(line.slice(14));
+			if (head === "(detached)") detached = true;
+			else if (head.length > 0 && head !== "(unknown)") branch = head;
+			continue;
+		}
+		if (line.startsWith("# branch.upstream ")) {
+			upstream = true;
+			continue;
+		}
+		if (line.startsWith("# branch.ab ")) {
+			const counts = /^# branch\.ab \+(\d+) -(\d+)$/u.exec(line);
+			if (counts !== null) {
+				ahead = Number(counts[1]);
+				behind = Number(counts[2]);
+			}
+			continue;
+		}
+		if (line.length > 0 && !line.startsWith("# ")) dirty = true;
+	}
+	return {
+		...branch === void 0 ? {} : { branch },
+		detached,
+		dirty,
+		upstream,
+		...ahead === void 0 ? {} : { ahead },
+		...behind === void 0 ? {} : { behind }
+	};
+}
+function parseDiffNumstat(value) {
+	let additions = 0;
+	let deletions = 0;
+	let files = 0;
+	for (const line of value.split(/\r?\n/u)) {
+		if (line.length === 0) continue;
+		const [added, deleted] = line.split("	");
+		files += 1;
+		if (added !== void 0 && /^\d+$/u.test(added)) additions += Number(added);
+		if (deleted !== void 0 && /^\d+$/u.test(deleted)) deletions += Number(deleted);
+	}
+	return {
+		additions,
+		deletions,
+		files
+	};
+}
+function parseGitHubRemote(value) {
+	const remote = bounded(value);
+	const match = /^(?:https:\/\/github\.com\/|git@github\.com:|ssh:\/\/git@github\.com\/)([^/\s]+)\/([^/\s]+?)(?:\.git)?$/iu.exec(remote);
+	if (match?.[1] === void 0 || match[2] === void 0) return void 0;
+	return `${match[1]}/${match[2]}`;
+}
+function record$3(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$3(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;
+		const state = typeof check.state === "string" ? check.state.toUpperCase() : void 0;
+		if ([
+			"FAILURE",
+			"ERROR",
+			"CANCELLED",
+			"TIMED_OUT",
+			"ACTION_REQUIRED"
+		].includes(conclusion ?? state ?? "")) return "failing";
+		if (status !== void 0 && status !== "COMPLETED") pending = true;
+		if (["PENDING", "EXPECTED"].includes(state ?? "")) pending = true;
+	}
+	return pending ? "pending" : "passing";
+}
+function reviewState(value) {
+	if (value === "APPROVED") return "approved";
+	if (value === "CHANGES_REQUESTED") return "changes-requested";
+	if (value === "REVIEW_REQUIRED") return "review-required";
+	return "none";
+}
+function parsePullRequest(value) {
+	const input = record$3(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 {
+		url = new URL(input.url);
+	} catch {
+		return;
+	}
+	if (url.protocol !== "https:" || url.hostname !== "github.com") return void 0;
+	const rawState = typeof input.state === "string" ? input.state.toUpperCase() : "";
+	const state = input.mergedAt !== void 0 && input.mergedAt !== null ? "merged" : rawState === "OPEN" ? "open" : rawState === "CLOSED" ? "closed" : void 0;
+	if (state === void 0) return void 0;
+	return {
+		number: Number(input.number),
+		title: bounded(input.title),
+		url: url.href,
+		state,
+		draft: input.isDraft === true,
+		review: reviewState(input.reviewDecision),
+		checks: aggregateChecks(input.statusCheckRollup),
+		...typeof input.mergeStateStatus === "string" ? { mergeState: bounded(input.mergeStateStatus) } : {},
+		...typeof record$3(input.author)?.login === "string" ? { author: bounded(String(record$3(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) } : {}
+	};
+}
+var RepositoryStatusService = class {
+	#runtime;
+	#cacheTtlMs;
+	#cache = /* @__PURE__ */ new Map();
+	#lastReady = /* @__PURE__ */ new Map();
+	#gitExecutable;
+	#ghExecutable;
+	constructor(runtime, cacheTtlMs = CACHE_TTL_MS) {
+		this.#runtime = runtime;
+		this.#cacheTtlMs = cacheTtlMs;
+	}
+	inspect(cwd) {
+		const current = this.#cache.get(cwd);
+		if (current !== void 0 && current.expiresAt > Date.now()) return current.value;
+		const value = this.#inspect(cwd).then((next) => this.#stabilize(cwd, next));
+		this.#cache.set(cwd, {
+			expiresAt: Date.now() + this.#cacheTtlMs,
+			value
+		});
+		value.catch(() => this.#cache.delete(cwd));
+		return value;
+	}
+	invalidate(cwd) {
+		this.#cache.delete(cwd);
+		this.#lastReady.delete(cwd);
+	}
+	dispose() {
+		this.#cache.clear();
+		this.#lastReady.clear();
+	}
+	#stabilize(cwd, next) {
+		const previous = this.#lastReady.get(cwd);
+		if (next.status !== "ready") return previous ?? next;
+		const stable = previous?.status === "ready" && previous.root === next.root && previous.branch === next.branch ? {
+			...next,
+			...next.pullRequest === void 0 && previous.pullRequest !== void 0 ? { pullRequest: previous.pullRequest } : {},
+			...next.pullRequest === void 0 && previous.pullRequest !== void 0 && previous.diff !== void 0 ? { diff: previous.diff } : next.diff === void 0 && previous.diff !== void 0 ? { diff: previous.diff } : {}
+		} : next;
+		this.#lastReady.set(cwd, stable);
+		return stable;
+	}
+	async #git() {
+		this.#gitExecutable ??= this.#runtime.resolveExecutable("git");
+		return this.#gitExecutable;
+	}
+	async #gh() {
+		this.#ghExecutable ??= this.#runtime.resolveExecutable("gh").catch(() => void 0);
+		return this.#ghExecutable;
+	}
+	async #inspect(cwd) {
+		const safeCwd = bounded(cwd);
+		let git;
+		try {
+			git = await this.#git();
+		} catch {
+			return {
+				status: "unavailable",
+				cwd: safeCwd
+			};
+		}
+		try {
+			const paths = await run(this.#runtime, git, [
+				"rev-parse",
+				"--path-format=absolute",
+				"--show-toplevel",
+				"--absolute-git-dir",
+				"--git-common-dir"
+			], cwd, GIT_TIMEOUT_MS$2);
+			if (paths.exitCode !== 0) return {
+				status: "not-repository",
+				cwd: safeCwd
+			};
+			const [rootValue, gitDirValue, commonDirValue] = paths.stdout.split(/\r?\n/u);
+			const root = bounded(rootValue ?? "");
+			const gitDir = bounded(gitDirValue ?? "");
+			const commonDir = bounded(commonDirValue ?? "");
+			if (root.length === 0 || gitDir.length === 0 || commonDir.length === 0) return {
+				status: "unavailable",
+				cwd: safeCwd
+			};
+			const statusResult = await run(this.#runtime, git, [
+				"status",
+				"--porcelain=v2",
+				"--branch",
+				"--untracked-files=normal"
+			], cwd, GIT_TIMEOUT_MS$2);
+			if (statusResult.exitCode !== 0) return {
+				status: "unavailable",
+				cwd: safeCwd
+			};
+			const status = parseGitStatus(statusResult.stdout);
+			const remoteResult = await run(this.#runtime, git, [
+				"remote",
+				"get-url",
+				"origin"
+			], cwd, GIT_TIMEOUT_MS$2);
+			const remote = remoteResult.exitCode === 0 ? parseGitHubRemote(remoteResult.stdout) : void 0;
+			const pullRequest = status.branch === void 0 || remote === void 0 ? void 0 : await this.#pullRequest(cwd, remote, status.branch);
+			const diffBase = pullRequest?.baseBranch === void 0 ? "HEAD" : await this.#mergeBase(cwd, git, pullRequest.baseBranch) ?? "HEAD";
+			const diff = status.dirty || diffBase !== "HEAD" ? await this.#diff(cwd, git, diffBase) : {
+				additions: 0,
+				deletions: 0,
+				files: 0,
+				truncated: false
+			};
+			return {
+				status: "ready",
+				cwd: safeCwd,
+				root,
+				...status,
+				worktree: normalizedPath(gitDir) !== normalizedPath(commonDir),
+				...remote === void 0 ? {} : { remote },
+				...pullRequest === void 0 ? {} : { pullRequest },
+				...diff === void 0 ? {} : { diff }
+			};
+		} catch {
+			return {
+				status: "unavailable",
+				cwd: safeCwd
+			};
+		}
+	}
+	async #mergeBase(cwd, git, baseBranch) {
+		try {
+			const result = await run(this.#runtime, git, [
+				"merge-base",
+				"HEAD",
+				`refs/remotes/origin/${baseBranch}`
+			], cwd, GIT_TIMEOUT_MS$2);
+			if (result.exitCode !== 0 || result.lossy) return void 0;
+			const oid = bounded(result.stdout);
+			return /^[0-9a-f]{40}$/iu.test(oid) ? oid : void 0;
+		} catch {
+			return;
+		}
+	}
+	async #diff(cwd, git, base) {
+		try {
+			const numstat = await run(this.#runtime, git, [
+				"diff",
+				"--no-ext-diff",
+				"--numstat",
+				base,
+				"--"
+			], cwd, GIT_TIMEOUT_MS$2);
+			if (numstat.exitCode !== 0 || numstat.lossy) return void 0;
+			const summary = parseDiffNumstat(numstat.stdout);
+			const patch = await run(this.#runtime, git, [
+				"diff",
+				"--no-ext-diff",
+				"--no-color",
+				"--unified=3",
+				base,
+				"--"
+			], cwd, GIT_TIMEOUT_MS$2, MAX_DIFF_BYTES);
+			if (patch.exitCode !== 0) return {
+				...summary,
+				truncated: true
+			};
+			const untracked = await this.#untrackedDiff(cwd, git);
+			const combinedPatch = `${patch.stdout}${untracked.patch}`;
+			return {
+				additions: summary.additions + untracked.additions,
+				deletions: summary.deletions,
+				files: summary.files + untracked.files,
+				...patch.lossy ? {} : { patch: combinedPatch.slice(0, MAX_DIFF_BYTES) },
+				truncated: patch.lossy || untracked.truncated || combinedPatch.length > MAX_DIFF_BYTES
+			};
+		} catch {
+			return;
+		}
+	}
+	async #untrackedDiff(cwd, git) {
+		const listed = await run(this.#runtime, git, [
+			"ls-files",
+			"--others",
+			"--exclude-standard",
+			"-z"
+		], cwd, GIT_TIMEOUT_MS$2);
+		if (listed.exitCode !== 0 || listed.lossy) return {
+			additions: 0,
+			files: 0,
+			patch: "",
+			truncated: listed.lossy
+		};
+		const paths = listed.stdout.split("\0").filter((path) => path.length > 0);
+		let additions = 0;
+		let patch = "";
+		let truncated = paths.length > MAX_UNTRACKED_DIFFS;
+		for (const path of paths.slice(0, MAX_UNTRACKED_DIFFS)) {
+			const result = await run(this.#runtime, git, [
+				"diff",
+				"--no-ext-diff",
+				"--no-color",
+				"--unified=3",
+				"--numstat",
+				"--patch",
+				"--no-index",
+				"--",
+				"/dev/null",
+				path
+			], cwd, GIT_TIMEOUT_MS$2, MAX_DIFF_BYTES);
+			if (result.exitCode !== 0 && result.exitCode !== 1) {
+				truncated = true;
+				continue;
+			}
+			const start = result.stdout.indexOf("diff --git ");
+			additions += parseDiffNumstat(start >= 0 ? result.stdout.slice(0, start) : result.stdout).additions;
+			if (result.lossy) truncated = true;
+			else if (start >= 0) patch += result.stdout.slice(start);
+		}
+		return {
+			additions,
+			files: paths.length,
+			patch,
+			truncated
+		};
+	}
+	async #pullRequest(cwd, repository, branch) {
+		const gh = await this.#gh();
+		if (gh === void 0) return void 0;
+		try {
+			const result = await run(this.#runtime, gh, [
+				"pr",
+				"view",
+				branch,
+				"--repo",
+				repository,
+				"--json",
+				"number,title,url,state,isDraft,reviewDecision,mergeStateStatus,mergedAt,statusCheckRollup,author,createdAt,baseRefName"
+			], cwd, GH_TIMEOUT_MS);
+			if (result.exitCode !== 0) return void 0;
+			return parsePullRequest(JSON.parse(result.stdout));
+		} catch {
+			return;
+		}
+	}
+};
+//#endregion
+//#region src/repository-setup.ts
+const MAX_OUTPUT_BYTES$1 = 131072;
+const GIT_TIMEOUT_MS$1 = 1e4;
+const GIT_FETCH_TIMEOUT_MS = 6e4;
+const MAX_PATH_CHARS = 4096;
+const MAX_BRANCH_CHARS = 512;
+const LEASE_SCHEMA_VERSION = 1;
+var RepositorySetupError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "RepositorySetupError";
+		this.code = code;
+	}
+};
+async function collect$1(handle) {
+	const outcome = await handle.done;
+	const stdout = handle.collected.stdout?.readFrom(0);
+	const stderr = handle.collected.stderr?.readFrom(0);
+	return {
+		exitCode: outcome.exitCode,
+		stdout: stdout?.text ?? "",
+		stderr: stderr?.text ?? "",
+		lossy: stdout?.lossy === true || stderr?.lossy === true
+	};
+}
+function safePath(value) {
+	if (value.length === 0 || value.length > MAX_PATH_CHARS || !isAbsolute(value) || value.includes("\0")) throw new RepositorySetupError("invalid-path", "The workspace path is invalid.");
+	return resolve(value);
+}
+function safeBranch(value) {
+	if (value.length === 0 || value.length > MAX_BRANCH_CHARS || value.trim() !== value || /[\0\r\n]/u.test(value)) throw new RepositorySetupError("invalid-branch", "The branch name is invalid.");
+	return value;
+}
+function parseCurrentBranch(value) {
+	const branch = value.trim();
+	return branch.length === 0 || branch === "HEAD" ? void 0 : branch;
+}
+function parseWorktreeBranches(value) {
+	const occupied = /* @__PURE__ */ new Map();
+	let path;
+	for (const line of `${value}\n`.split(/\r?\n/u)) if (line.startsWith("worktree ")) path = line.slice(9);
+	else if (line.startsWith("branch refs/heads/") && path !== void 0) occupied.set(line.slice(18), path);
+	else if (line.length === 0) path = void 0;
+	return occupied;
+}
+function slug(value, fallback) {
+	return value.toLocaleLowerCase("en-US").replace(/[^a-z0-9._-]+/gu, "-").replace(/^-+|-+$/gu, "").slice(0, 48) || fallback;
+}
+function lease(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const input = value;
+	if (typeof input.id !== "string" || typeof input.root !== "string" || typeof input.path !== "string" || typeof input.branch !== "string" || typeof input.createdAt !== "string" || input.pluginGeneratedBranch !== void 0 && typeof input.pluginGeneratedBranch !== "boolean" || input.sessionId !== void 0 && typeof input.sessionId !== "string") return void 0;
+	return {
+		id: input.id,
+		root: input.root,
+		path: input.path,
+		branch: input.branch,
+		createdAt: input.createdAt,
+		pluginGeneratedBranch: input.pluginGeneratedBranch === true,
+		...input.sessionId === void 0 ? {} : { sessionId: input.sessionId }
+	};
+}
+var RepositorySetupService = class {
+	#runtime;
+	#leasePath;
+	#worktreeRoot;
+	#branchPrefix;
+	#gitPath;
+	#pending = Promise.resolve();
+	constructor(runtime, options = {}) {
+		this.#runtime = runtime;
+		this.#leasePath = options.leasePath ?? dshHomePath("plugins", "dsh-claude", "worktrees.json");
+		this.#worktreeRoot = options.worktreeRoot ?? dshHomePath("plugins", "dsh-claude", "worktrees");
+		this.#branchPrefix = options.branchPrefix ?? (async () => "claude");
+	}
+	async listBranches(cwd) {
+		const git = await this.#git();
+		const root = await this.#repositoryRoot(git, safePath(cwd));
+		const [status, refs, remoteRefs] = await Promise.all([
+			this.#run(git, [
+				"status",
+				"--porcelain=v2",
+				"--branch",
+				"--untracked-files=normal"
+			], root),
+			this.#run(git, [
+				"for-each-ref",
+				"--format=%(refname:short)",
+				"refs/heads"
+			], root),
+			this.#run(git, [
+				"for-each-ref",
+				"--format=%(refname:short) %(symref)",
+				"refs/remotes"
+			], root)
+		]);
+		if (status.exitCode !== 0 || status.lossy || refs.exitCode !== 0 || refs.lossy || remoteRefs.exitCode !== 0 || remoteRefs.lossy) throw new RepositorySetupError("repository-unavailable", "The repository state is unavailable.");
+		const current = status.stdout.split(/\r?\n/u).find((line) => line.startsWith("# branch.head "))?.slice(14);
+		const branches = refs.stdout.split(/\r?\n/u).filter(Boolean).sort((left, right) => left.localeCompare(right));
+		const remoteBranches = remoteRefs.stdout.split(/\r?\n/u).map((line) => line.trim().split(/\s+/u)).filter((parts) => parts[0] !== void 0 && parts[0].length > 0 && parts.length === 1).map((parts) => parts[0]).sort((left, right) => left.localeCompare(right));
+		const currentBranch = current === void 0 ? void 0 : parseCurrentBranch(current);
+		return {
+			root,
+			...currentBranch === void 0 ? {} : { current: currentBranch },
+			dirty: status.stdout.split(/\r?\n/u).some((line) => line.length > 0 && !line.startsWith("# ")),
+			branches,
+			remoteBranches
+		};
+	}
+	async setup(cwd, branchValue, useWorktree, explicitBranchName, progress = () => {}) {
+		progress("inspecting");
+		const branch = safeBranch(branchValue);
+		const info = await this.listBranches(cwd);
+		const local = info.branches.includes(branch);
+		const remote = info.remoteBranches.includes(branch);
+		if (!local && !remote) throw new RepositorySetupError("branch-not-found", "The selected local or remote-tracking branch does not exist.");
+		const requestedBranch = explicitBranchName === void 0 ? void 0 : safeBranch(explicitBranchName);
+		if (useWorktree) return this.#createWorktree(info.root, branch, local ? `refs/heads/${branch}` : `refs/remotes/${branch}`, requestedBranch, progress);
+		progress("switching-branch");
+		return !local && remote ? this.#checkoutRemote(info, branch) : this.#checkout(info, branch);
+	}
+	bindLease(leaseId, sessionId) {
+		if (leaseId.length === 0 || leaseId.length > 128 || sessionId.length === 0 || sessionId.length > 1024) return Promise.reject(new RepositorySetupError("invalid-lease", "The worktree lease is invalid."));
+		return this.#serialize(async () => {
+			const leases = await this.#readLeases();
+			const index = leases.findIndex((item) => item.id === leaseId);
+			if (index < 0) throw new RepositorySetupError("lease-not-found", "The worktree lease no longer exists.");
+			const existing = leases[index];
+			if (existing === void 0) throw new RepositorySetupError("lease-not-found", "The worktree lease no longer exists.");
+			leases[index] = {
+				...existing,
+				sessionId
+			};
+			await this.#writeLeases(leases);
+		});
+	}
+	cleanupSession(sessionId) {
+		return this.#serialize(async () => {
+			const leases = await this.#readLeases();
+			const retained = [];
+			let changed = false;
+			const git = await this.#git();
+			for (const item of leases) {
+				if (item.sessionId !== sessionId) {
+					retained.push(item);
+					continue;
+				}
+				try {
+					const status = await this.#run(git, [
+						"status",
+						"--porcelain=v1",
+						"--untracked-files=normal"
+					], item.path);
+					if (status.exitCode !== 0 || status.lossy || status.stdout.trim().length > 0) {
+						retained.push(item);
+						continue;
+					}
+					if ((await this.#run(git, [
+						"worktree",
+						"remove",
+						"--",
+						item.path
+					], item.root)).exitCode !== 0) {
+						retained.push(item);
+						continue;
+					}
+					if (item.pluginGeneratedBranch) await this.#run(git, [
+						"branch",
+						"-D",
+						"--",
+						item.branch
+					], item.root).catch(() => void 0);
+					changed = true;
+				} catch {
+					retained.push(item);
+				}
+			}
+			if (changed) await this.#writeLeases(retained);
+		});
+	}
+	async #checkoutRemote(info, remoteBranch) {
+		const separator = remoteBranch.indexOf("/");
+		if (separator <= 0 || separator === remoteBranch.length - 1) throw new RepositorySetupError("invalid-branch", "The remote-tracking branch name is invalid.");
+		const localBranch = safeBranch(remoteBranch.slice(separator + 1));
+		if (info.branches.includes(localBranch)) {
+			const git = await this.#git();
+			const upstream = await this.#run(git, [
+				"for-each-ref",
+				"--format=%(upstream:short)",
+				`refs/heads/${localBranch}`
+			], info.root);
+			if (upstream.exitCode !== 0 || upstream.lossy) throw new RepositorySetupError("repository-unavailable", "The local branch tracking state is unavailable.");
+			if (upstream.stdout.trim() !== remoteBranch) throw new RepositorySetupError("branch-tracking-conflict", `The local branch ${localBranch} does not track ${remoteBranch}.`);
+			return this.#checkout(info, localBranch);
+		}
+		if (info.dirty) throw new RepositorySetupError("dirty-workspace", "Commit or stash workspace changes before switching branches.");
+		const git = await this.#git();
+		if ((await this.#run(git, [
+			"switch",
+			"--track",
+			"-c",
+			localBranch,
+			`refs/remotes/${remoteBranch}`
+		], info.root)).exitCode !== 0) throw new RepositorySetupError("checkout-failed", "Git could not create the local tracking branch.");
+		return {
+			mode: "checkout",
+			root: info.root,
+			path: info.root,
+			branch: localBranch
+		};
+	}
+	async #checkout(info, branch) {
+		if (info.dirty) throw new RepositorySetupError("dirty-workspace", "Commit or stash workspace changes before switching branches.");
+		if (info.current !== branch) {
+			const git = await this.#git();
+			const worktrees = await this.#run(git, [
+				"worktree",
+				"list",
+				"--porcelain"
+			], info.root);
+			if (worktrees.exitCode !== 0 || worktrees.lossy) throw new RepositorySetupError("repository-unavailable", "Worktree state is unavailable.");
+			const occupiedPath = parseWorktreeBranches(worktrees.stdout).get(branch);
+			if (occupiedPath !== void 0 && resolve(occupiedPath) !== info.root) throw new RepositorySetupError("branch-occupied", "The selected branch is already checked out in another worktree.");
+			if ((await this.#run(git, [
+				"switch",
+				"--",
+				branch
+			], info.root)).exitCode !== 0) throw new RepositorySetupError("checkout-failed", "Git could not switch to the selected branch.");
+		}
+		return {
+			mode: "checkout",
+			root: info.root,
+			path: info.root,
+			branch
+		};
+	}
+	async #createWorktree(root, baseBranch, baseRef, explicitBranchName, progress) {
+		const git = await this.#git();
+		progress("fetching");
+		const fetched = await this.#run(git, [
+			"-c",
+			"credential.interactive=never",
+			"fetch",
+			"--all",
+			"--prune"
+		], root, GIT_FETCH_TIMEOUT_MS);
+		if (fetched.exitCode !== 0 || fetched.lossy) throw new RepositorySetupError("fetch-failed", "Git could not refresh remote references before creating the worktree.");
+		const suffix = randomUUID().slice(0, 8);
+		const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/gu, "").replace(/\.\d{3}Z$/u, "Z");
+		const branch = explicitBranchName ?? `${safeBranch(await this.#branchPrefix())}/${slug(baseBranch, "branch")}-${stamp}-${suffix}`;
+		const path = join(this.#worktreeRoot, `${slug(basename(root), "repository")}-${stamp}-${suffix}`);
+		progress("creating-worktree");
+		await mkdir(this.#worktreeRoot, { recursive: true });
+		if ((await this.#run(git, [
+			"worktree",
+			"add",
+			"-b",
+			branch,
+			path,
+			baseRef
+		], root)).exitCode !== 0) throw new RepositorySetupError("worktree-failed", "Git could not create the worktree.");
+		const item = {
+			id: randomUUID(),
+			root,
+			path,
+			branch,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			pluginGeneratedBranch: explicitBranchName === void 0
+		};
+		progress("saving-worktree");
+		try {
+			await this.#serialize(async () => {
+				const leases = await this.#readLeases();
+				await this.#writeLeases([...leases, item]);
+			});
+		} catch (error) {
+			await this.#run(git, [
+				"worktree",
+				"remove",
+				"--force",
+				"--",
+				path
+			], root).catch(() => void 0);
+			throw error;
+		}
+		return {
+			mode: "worktree",
+			root,
+			path,
+			branch,
+			leaseId: item.id
+		};
+	}
+	async #repositoryRoot(git, cwd) {
+		const result = await this.#run(git, [
+			"rev-parse",
+			"--path-format=absolute",
+			"--show-toplevel"
+		], cwd);
+		const root = result.stdout.trim();
+		if (result.exitCode !== 0 || result.lossy || root.length === 0 || !isAbsolute(root)) throw new RepositorySetupError("not-repository", "The workspace is not a Git repository.");
+		return resolve(root);
+	}
+	#git() {
+		this.#gitPath ??= this.#runtime.resolveExecutable("git");
+		return this.#gitPath;
+	}
+	async #run(executable, args, cwd, timeoutMs = GIT_TIMEOUT_MS$1) {
+		return collect$1(this.#runtime.spawn({
+			argv: [executable, ...args],
+			cwd,
+			stdio: {
+				stdin: "ignore",
+				stdout: { maxBytes: MAX_OUTPUT_BYTES$1 },
+				stderr: { maxBytes: MAX_OUTPUT_BYTES$1 }
+			},
+			graceMs: 1e3,
+			signal: AbortSignal.timeout(timeoutMs),
+			env: {}
+		}));
+	}
+	async #readLeases() {
+		try {
+			const parsed = JSON.parse(await readFile(this.#leasePath, "utf8"));
+			if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return [];
+			const input = parsed;
+			if (input.schemaVersion !== LEASE_SCHEMA_VERSION || !Array.isArray(input.leases)) return [];
+			return input.leases.map(lease).filter((item) => item !== void 0);
+		} catch (error) {
+			if (error.code === "ENOENT") return [];
+			throw error;
+		}
+	}
+	async #writeLeases(leases) {
+		await mkdir(resolve(this.#leasePath, ".."), { recursive: true });
+		const temporary = `${this.#leasePath}.${process.pid}.${randomUUID()}.tmp`;
+		const document = {
+			schemaVersion: LEASE_SCHEMA_VERSION,
+			leases
+		};
+		try {
+			await writeFile(temporary, `${JSON.stringify(document, null, 2)}\n`, { mode: 384 });
+			await rename(temporary, this.#leasePath);
+		} finally {
+			await rm(temporary, { force: true }).catch(() => void 0);
+		}
+	}
+	#serialize(operation) {
+		const result = this.#pending.then(operation, operation);
+		this.#pending = result.then(() => void 0, () => void 0);
+		return result;
+	}
+};
+//#endregion
+//#region src/repository-actions.ts
+const MAX_OUTPUT_BYTES = 262144;
+const MAX_PATCH_CHARS = 65536;
+const MAX_MESSAGE_CHARS = 512;
+const MAX_PR_TEXT_CHARS = 8192;
+const MAX_UNPUSHED_COMMITS = 20;
+const GIT_TIMEOUT_MS = 15e3;
+const REMOTE_TIMEOUT_MS = 6e4;
+const GENERATE_TIMEOUT_MS = 6e4;
+var RepositoryActionError = class extends Error {
+	code;
+	commit;
+	constructor(code, message, commit) {
+		super(message);
+		this.name = "RepositoryActionError";
+		this.code = code;
+		if (commit !== void 0) this.commit = commit;
+	}
+};
+async function collect(handle) {
+	const outcome = await handle.done;
+	const stdout = handle.collected.stdout?.readFrom(0);
+	const stderr = handle.collected.stderr?.readFrom(0);
+	return {
+		exitCode: outcome.exitCode,
+		stdout: stdout?.text ?? "",
+		stderr: stderr?.text ?? "",
+		lossy: stdout?.lossy === true || stderr?.lossy === true
+	};
+}
+function safeText(value, maximum, label) {
+	const text = value.trim();
+	if (text.length === 0 || text.length > maximum || /[\0\r]/u.test(text)) throw new RepositoryActionError("invalid-request", `${label} is invalid.`);
+	return text;
+}
+function isProtectedWarpPath(path) {
+	return basename(path.replaceAll("\\", "/")).toLocaleLowerCase("en-US") === "warp.md";
+}
+function parseRepositoryActionStatus(output) {
+	const files = /* @__PURE__ */ new Map();
+	const records = output.includes("\0") ? output.split("\0") : output.split(/\r?\n/u);
+	for (let position = 0; position < records.length; position += 1) {
+		const line = records[position] ?? "";
+		if (line.length < 4) continue;
+		const index = line[0] ?? " ";
+		const worktree = line[1] ?? " ";
+		let path = line.slice(3);
+		const rename = path.lastIndexOf(" -> ");
+		if (rename >= 0) path = path.slice(rename + 4);
+		if (output.includes("\0") && (index === "R" || index === "C" || worktree === "R" || worktree === "C")) position += 1;
+		if (path.length === 0 || path.includes("\0") || isProtectedWarpPath(path)) continue;
+		files.set(path, {
+			path,
+			staged: index !== " " && index !== "?",
+			unstaged: worktree !== " " && worktree !== "?",
+			untracked: index === "?" && worktree === "?"
+		});
+	}
+	return [...files.values()].sort((left, right) => left.path.localeCompare(right.path));
+}
+function fallbackCommitMessage(files) {
+	if (files.length === 1) return `Update ${files[0]?.path ?? "repository files"}`;
+	return `Update ${files.length} repository files`;
+}
+function normalizedGeneratedMessage(value, fallback) {
+	const first = value.split(/\r?\n/u).map((line) => line.trim()).find(Boolean);
+	if (first === void 0) return fallback;
+	const message = first.replace(/^['"`]+|['"`]+$/gu, "").replace(/[\0\r\n]/gu, " ").trim();
+	return message.length === 0 || message.length > 72 ? fallback : message;
+}
+function validPrUrl(value) {
+	try {
+		const url = new URL(value.trim());
+		return url.protocol === "https:" && url.hostname === "github.com" ? url.href : void 0;
+	} catch {
+		return;
+	}
+}
+function validPullRequestBody(value) {
+	const body = value.trim();
+	const match = /^Summary:\s+([^\r\n]+)\r?\n\r?\nChanges:\s*\r?\n([\s\S]+)$/u.exec(body);
+	const summary = match?.[1]?.trim();
+	const changes = match?.[2]?.trim();
+	if (summary === void 0 || summary.length === 0 || changes === void 0 || changes.length === 0) return false;
+	return !/^#{1,6}\s|^[A-Za-z][A-Za-z ]+:\s*$/mu.test(changes);
+}
+var RepositoryActionService = class {
+	#runtime;
+	#claudeExecutable;
+	#invalidate;
+	#gitExecutable;
+	#ghExecutable;
+	#pending = Promise.resolve();
+	constructor(runtime, claudeExecutable, invalidate = () => {}) {
+		this.#runtime = runtime;
+		this.#claudeExecutable = claudeExecutable;
+		this.#invalidate = invalidate;
+	}
+	preview(cwd) {
+		return this.#preview(cwd);
+	}
+	async generateMessage(cwd, fingerprint) {
+		const preview = await this.#preview(cwd);
+		if (preview.fingerprint !== fingerprint) throw new RepositoryActionError("repository-changed", "Repository changes have changed. Refresh the commit panel.");
+		const fallback = fallbackCommitMessage(preview.files);
+		const prompt = [
+			"Write one concise English git commit subject (imperative mood, maximum 72 characters).",
+			"Return only the subject without quotes, markdown, body, or explanation.",
+			`Files: ${preview.files.map((file) => file.path).join(", ")}`,
+			`Diff:\n${preview.patch.slice(0, 24576)}`
+		].join("\n");
+		try {
+			const result = await this.#run(this.#claudeExecutable, [
+				"-p",
+				"--tools",
+				"",
+				"--output-format",
+				"text",
+				prompt
+			], preview.root, GENERATE_TIMEOUT_MS);
+			return result.exitCode === 0 && !result.lossy ? normalizedGeneratedMessage(result.stdout, fallback) : fallback;
+		} catch {
+			return fallback;
+		}
+	}
+	execute(cwd, request) {
+		const operation = this.#pending.then(() => this.#execute(cwd, request));
+		this.#pending = operation.then(() => void 0, () => void 0);
+		return operation;
+	}
+	async #execute(cwd, request) {
+		const before = await this.#preview(cwd);
+		if (before.fingerprint !== request.fingerprint) throw new RepositoryActionError("repository-changed", "Repository changes have changed. Refresh the commit panel.");
+		if (request.action === "push") {
+			const git = await this.#git();
+			try {
+				await this.#push(git, before.root, before.branch);
+			} catch (error) {
+				throw new RepositoryActionError("push-failed", error instanceof Error ? error.message : "Git push failed.");
+			}
+			this.#invalidate(before.root);
+			return {
+				commit: before.head,
+				pushed: true
+			};
+		}
+		const message = safeText(request.message, MAX_MESSAGE_CHARS, "Commit message");
+		if (before.files.length === 0 && request.action !== "create-pr") throw new RepositoryActionError("nothing-to-commit", "There are no changes to commit.");
+		const git = await this.#git();
+		let oid = before.head;
+		if (before.files.length > 0) {
+			await this.#rejectStagedWarp(git, before.root);
+			if (request.includeUnstaged) {
+				const paths = before.files.filter((file) => file.unstaged || file.untracked).map((file) => file.path);
+				if (paths.length > 0) await this.#mustRun(git, [
+					"add",
+					"--",
+					...paths
+				], before.root, GIT_TIMEOUT_MS, "stage-failed", "Changes could not be staged.");
+			}
+			await this.#rejectStagedWarp(git, before.root);
+			const staged = await this.#run(git, [
+				"diff",
+				"--cached",
+				"--quiet",
+				"--exit-code",
+				"--"
+			], before.root, GIT_TIMEOUT_MS);
+			if (staged.exitCode === 0) throw new RepositoryActionError("nothing-to-commit", "There are no staged changes to commit.");
+			if (staged.exitCode !== 1) throw new RepositoryActionError("repository-unavailable", "The staged changes could not be verified.");
+			await this.#mustRun(git, [
+				"commit",
+				"-m",
+				message,
+				"--"
+			], before.root, GIT_TIMEOUT_MS, "commit-failed", "Git commit failed.");
+			oid = (await this.#mustRun(git, ["rev-parse", "HEAD"], before.root, GIT_TIMEOUT_MS, "commit-failed", "The new commit could not be verified.")).stdout.trim();
+			this.#invalidate(before.root);
+			if (request.action === "commit") return {
+				commit: oid,
+				pushed: false
+			};
+		}
+		try {
+			await this.#push(git, before.root, before.branch);
+		} catch (error) {
+			throw new RepositoryActionError("push-failed", error instanceof Error ? error.message : "Git push failed.", oid);
+		}
+		this.#invalidate(before.root);
+		if (request.action === "commit-push") return {
+			commit: oid,
+			pushed: true
+		};
+		const title = safeText(request.prTitle ?? message, 256, "Pull request title");
+		const body = safeText(request.prBody ?? "", MAX_PR_TEXT_CHARS, "Pull request description");
+		if (!validPullRequestBody(body)) throw new RepositoryActionError("invalid-pr-description", "Pull request description must contain only Summary and Changes sections.", oid);
+		let gh;
+		try {
+			gh = await this.#gh();
+		} catch (error) {
+			throw new RepositoryActionError("gh-unavailable", error instanceof Error ? error.message : "GitHub CLI is unavailable.", oid);
+		}
+		const args = [
+			"pr",
+			"create",
+			"--title",
+			title,
+			"--body",
+			body
+		];
+		if (request.draft !== false) args.push("--draft");
+		if (request.baseBranch !== void 0) args.push("--base", safeText(request.baseBranch, 512, "Base branch"));
+		const created = await this.#run(gh, args, before.root, REMOTE_TIMEOUT_MS);
+		const url = created.exitCode === 0 && !created.lossy ? validPrUrl(created.stdout) : void 0;
+		if (url === void 0) throw new RepositoryActionError("pr-failed", "The pull request could not be created.", oid);
+		return {
+			commit: oid,
+			pushed: true,
+			pullRequestUrl: url
+		};
+	}
+	async #preview(cwd) {
+		const git = await this.#git();
+		const root = (await this.#mustRun(git, [
+			"rev-parse",
+			"--path-format=absolute",
+			"--show-toplevel"
+		], cwd, GIT_TIMEOUT_MS, "not-repository", "The session directory is not a Git repository.")).stdout.trim();
+		const [branchResult, headResult, statusResult, stagedPatch, unstagedPatch] = await Promise.all([
+			this.#run(git, [
+				"symbolic-ref",
+				"--quiet",
+				"--short",
+				"HEAD"
+			], root, GIT_TIMEOUT_MS),
+			this.#run(git, ["rev-parse", "HEAD"], root, GIT_TIMEOUT_MS),
+			this.#run(git, [
+				"status",
+				"--porcelain=v1",
+				"-z",
+				"--untracked-files=all"
+			], root, GIT_TIMEOUT_MS),
+			this.#run(git, [
+				"diff",
+				"--cached",
+				"--no-ext-diff",
+				"--no-color",
+				"--unified=3",
+				"--",
+				":(exclude)WARP.md",
+				":(exclude)**/WARP.md"
+			], root, GIT_TIMEOUT_MS, MAX_OUTPUT_BYTES),
+			this.#run(git, [
+				"diff",
+				"--no-ext-diff",
+				"--no-color",
+				"--unified=3",
+				"--",
+				":(exclude)WARP.md",
+				":(exclude)**/WARP.md"
+			], root, GIT_TIMEOUT_MS, MAX_OUTPUT_BYTES)
+		]);
+		if (branchResult.exitCode !== 0) throw new RepositoryActionError("detached-head", "A detached HEAD cannot be committed from this panel.");
+		if (headResult.exitCode !== 0 || statusResult.exitCode !== 0 || statusResult.lossy) throw new RepositoryActionError("repository-unavailable", "Repository state is unavailable.");
+		const files = parseRepositoryActionStatus(statusResult.stdout);
+		const patch = `${stagedPatch.stdout}${stagedPatch.stdout.length > 0 && unstagedPatch.stdout.length > 0 ? "\n" : ""}${unstagedPatch.stdout}`.slice(0, MAX_PATCH_CHARS);
+		const branch = branchResult.stdout.trim();
+		const head = headResult.stdout.trim();
+		const fingerprint = createHash("sha256").update([
+			head,
+			branch,
+			statusResult.stdout,
+			stagedPatch.stdout,
+			unstagedPatch.stdout
+		].join("\0")).digest("hex");
+		const upstreamResult = await this.#run(git, [
+			"rev-parse",
+			"--abbrev-ref",
+			"--symbolic-full-name",
+			"@{upstream}"
+		], root, GIT_TIMEOUT_MS);
+		const upstream = upstreamResult.exitCode === 0 && !upstreamResult.lossy ? upstreamResult.stdout.trim() : void 0;
+		const logResult = await this.#run(git, [
+			"log",
+			"--format=%H%x09%s",
+			`-n`,
+			String(21),
+			upstream === void 0 ? "HEAD" : "@{upstream}..HEAD",
+			"--"
+		], root, GIT_TIMEOUT_MS);
+		const commitLines = logResult.exitCode === 0 && !logResult.lossy ? logResult.stdout.split(/\r?\n/u).filter((line) => line.includes("	")) : [];
+		const unpushedCommits = commitLines.slice(0, MAX_UNPUSHED_COMMITS).flatMap((line) => {
+			const tab = line.indexOf("	");
+			const hash = line.slice(0, tab);
+			return /^[0-9a-f]{40}$/iu.test(hash) ? [{
+				hash,
+				subject: line.slice(tab + 1).slice(0, 140)
+			}] : [];
+		});
+		return {
+			root,
+			branch,
+			head,
+			fingerprint,
+			files,
+			patch,
+			truncated: stagedPatch.lossy || unstagedPatch.lossy || stagedPatch.stdout.length + unstagedPatch.stdout.length > MAX_PATCH_CHARS,
+			hasStaged: files.some((file) => file.staged),
+			hasUnstaged: files.some((file) => file.unstaged),
+			hasUntracked: files.some((file) => file.untracked),
+			...upstream === void 0 ? {} : { upstream },
+			unpushedCommits,
+			unpushedTruncated: commitLines.length > MAX_UNPUSHED_COMMITS
+		};
+	}
+	async #rejectStagedWarp(git, cwd) {
+		const staged = await this.#run(git, [
+			"diff",
+			"--cached",
+			"--name-only",
+			"--"
+		], cwd, GIT_TIMEOUT_MS);
+		if (staged.exitCode !== 0 || staged.lossy) throw new RepositoryActionError("repository-unavailable", "Staged files could not be verified.");
+		if (staged.stdout.split(/\r?\n/u).some((path) => path.length > 0 && isProtectedWarpPath(path))) throw new RepositoryActionError("protected-warp-file", "WARP.md files cannot be committed. Unstage them before continuing.");
+	}
+	async #push(git, cwd, branch) {
+		const args = (await this.#run(git, [
+			"rev-parse",
+			"--abbrev-ref",
+			"--symbolic-full-name",
+			"@{upstream}"
+		], cwd, GIT_TIMEOUT_MS)).exitCode === 0 ? ["push"] : [
+			"push",
+			"--set-upstream",
+			"origin",
+			branch
+		];
+		await this.#mustRun(git, args, cwd, REMOTE_TIMEOUT_MS, "push-failed", "Git push failed.");
+	}
+	#git() {
+		this.#gitExecutable ??= this.#runtime.resolveExecutable("git");
+		return this.#gitExecutable;
+	}
+	#gh() {
+		this.#ghExecutable ??= this.#runtime.resolveExecutable("gh").catch(() => {
+			throw new RepositoryActionError("gh-unavailable", "GitHub CLI is unavailable.");
+		});
+		return this.#ghExecutable;
+	}
+	async #mustRun(executable, args, cwd, timeoutMs, code, message) {
+		const result = await this.#run(executable, args, cwd, timeoutMs);
+		if (result.exitCode !== 0 || result.lossy) throw new RepositoryActionError(code, message);
+		return result;
+	}
+	#run(executable, args, cwd, timeoutMs, maxBytes = MAX_OUTPUT_BYTES) {
+		return collect(this.#runtime.spawn({
+			argv: [executable, ...args],
+			cwd,
+			stdio: {
+				stdin: "ignore",
+				stdout: { maxBytes },
+				stderr: { maxBytes: MAX_OUTPUT_BYTES }
+			},
+			graceMs: 1e3,
+			signal: AbortSignal.timeout(timeoutMs),
+			env: {}
+		}));
+	}
+};
+//#endregion
+//#region src/repository-setup-routes.ts
+const MAX_BODY_BYTES$2 = 16384;
+function record$2(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+async function readJson$2(req) {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of req) {
+		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		size += buffer.length;
+		if (size > MAX_BODY_BYTES$2) throw new RepositorySetupError("body-too-large", "The request body is too large.");
+		chunks.push(buffer);
+	}
+	const value = record$2(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+	if (value === void 0) throw new RepositorySetupError("invalid-request", "The request body is invalid.");
+	return value;
+}
+function string$1(input, key) {
+	const value = input[key];
+	if (typeof value !== "string") throw new RepositorySetupError("invalid-request", `The ${key} field is required.`);
+	return value;
+}
+function optionalString$1(input, key) {
+	const value = input[key];
+	if (value === void 0) return void 0;
+	if (typeof value !== "string") throw new RepositorySetupError("invalid-request", `The ${key} field must be a string.`);
+	return value;
+}
+function ndjsonHeaders(res) {
+	res.writeHead(200, {
+		"content-type": "application/x-ndjson; charset=utf-8",
+		"cache-control": "no-store",
+		"x-content-type-options": "nosniff"
+	});
+	res.flushHeaders?.();
+}
+function ndjson(res, value) {
+	res.write(`${JSON.stringify(value)}\n`);
+}
+async function streamSetup(res, service, input) {
+	ndjsonHeaders(res);
+	let ended = false;
+	try {
+		ndjson(res, {
+			type: "complete",
+			result: await service.setup(string$1(input, "cwd"), string$1(input, "branch"), input.worktree, optionalString$1(input, "branchName"), (stage) => {
+				if (!ended) ndjson(res, {
+					type: "progress",
+					stage
+				});
+			})
+		});
+	} catch (error) {
+		const setupError = error instanceof RepositorySetupError ? error : void 0;
+		ndjson(res, {
+			type: "error",
+			code: setupError?.code ?? "repository-setup-unavailable",
+			message: setupError?.message ?? "Repository setup is unavailable."
+		});
+	} finally {
+		ended = true;
+		res.end();
+	}
+}
+/** Register trusted browser routes for safe pre-session Git setup. */
+function registerRepositorySetupRoute(ctx, service) {
+	ctx.effect(() => ctx.webServer.register({
+		kind: "prefix",
+		path: CLAUDE_REPOSITORY_SETUP_PATH,
+		handler: async (req, res) => {
+			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
+			const pathname = new URL(req.url ?? "/", "http://localhost").pathname;
+			try {
+				if (pathname === `/plugins/dsh-claude/repository/setup/branches`) {
+					if (req.method !== "GET") return json(res, 405, { error: "method not allowed" });
+					const cwd = new URL(req.url ?? "/", "http://localhost").searchParams.get("cwd");
+					if (cwd === null) throw new RepositorySetupError("invalid-request", "The cwd query parameter is required.");
+					return json(res, 200, await service.listBranches(cwd));
+				}
+				if (pathname === "/plugins/dsh-claude/repository/setup") {
+					if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
+					const input = await readJson$2(req);
+					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/bind`) {
+					if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
+					const input = await readJson$2(req);
+					await service.bindLease(string$1(input, "leaseId"), string$1(input, "sessionId"));
+					return json(res, 200, { ok: true });
+				}
+				return json(res, 404, { error: "not found" });
+			} catch (error) {
+				if (error instanceof RepositorySetupError) return json(res, 409, {
+					error: error.code,
+					message: error.message
+				});
+				if (error instanceof SyntaxError) return json(res, 400, { error: "invalid json" });
+				return json(res, 500, { error: "repository setup unavailable" });
+			}
+		}
+	}), "dsh-claude: repository setup route");
+}
+//#endregion
+//#region src/repository-action-routes.ts
+const MAX_BODY_BYTES$1 = 16384;
+const MAX_SESSION_ID_CHARS$1 = 1024;
+const ACTIONS = /* @__PURE__ */ new Set([
+	"commit",
+	"commit-push",
+	"push",
+	"create-pr"
+]);
+function record$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+async function readJson$1(req) {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of req) {
+		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		size += buffer.length;
+		if (size > MAX_BODY_BYTES$1) throw new RepositoryActionError("body-too-large", "The request body is too large.");
+		chunks.push(buffer);
+	}
+	const value = record$1(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+	if (value === void 0) throw new RepositoryActionError("invalid-request", "The request body is invalid.");
+	return value;
+}
+function sessionId(url) {
+	const value = url.searchParams.get("sessionId");
+	if (value === null || value.length === 0 || value.length > MAX_SESSION_ID_CHARS$1) throw new RepositoryActionError("invalid-session", "The session is invalid.");
+	return value;
+}
+function string(input, key) {
+	const value = input[key];
+	if (typeof value !== "string") throw new RepositoryActionError("invalid-request", `The ${key} field is required.`);
+	return value;
+}
+function optionalString(input, key) {
+	const value = input[key];
+	if (value === void 0) return void 0;
+	if (typeof value !== "string") throw new RepositoryActionError("invalid-request", `The ${key} field must be a string.`);
+	return value;
+}
+function actionRequest(input) {
+	const action = input.action;
+	if (typeof action !== "string" || !ACTIONS.has(action) || typeof input.includeUnstaged !== "boolean") throw new RepositoryActionError("invalid-request", "The repository action is invalid.");
+	return {
+		action,
+		fingerprint: string(input, "fingerprint"),
+		message: action === "push" ? optionalString(input, "message") ?? "" : string(input, "message"),
+		includeUnstaged: input.includeUnstaged,
+		...optionalString(input, "prTitle") === void 0 ? {} : { prTitle: optionalString(input, "prTitle") },
+		...optionalString(input, "prBody") === void 0 ? {} : { prBody: optionalString(input, "prBody") },
+		...optionalString(input, "baseBranch") === void 0 ? {} : { baseBranch: optionalString(input, "baseBranch") },
+		...input.draft === void 0 ? {} : typeof input.draft === "boolean" ? { draft: input.draft } : (() => {
+			throw new RepositoryActionError("invalid-request", "The draft field must be a boolean.");
+		})()
+	};
+}
+function registerRepositoryActionRoute(ctx, service, cwdForSession) {
+	ctx.effect(() => ctx.webServer.register({
+		kind: "prefix",
+		path: CLAUDE_REPOSITORY_ACTION_PATH,
+		handler: async (req, res) => {
+			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
+			const url = new URL(req.url ?? "/", "http://localhost");
+			try {
+				const cwd = cwdForSession(sessionId(url));
+				if (cwd === void 0) throw new RepositoryActionError("session-unavailable", "The Claude session is unavailable.");
+				if (url.pathname === `/plugins/dsh-claude/repository/action/preview`) {
+					if (req.method !== "GET") return json(res, 405, { error: "method not allowed" });
+					return json(res, 200, await service.preview(cwd));
+				}
+				if (url.pathname === `/plugins/dsh-claude/repository/action/message`) {
+					if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
+					const input = await readJson$1(req);
+					return json(res, 200, { message: await service.generateMessage(cwd, string(input, "fingerprint")) });
+				}
+				if (url.pathname === "/plugins/dsh-claude/repository/action") {
+					if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
+					return json(res, 200, await service.execute(cwd, actionRequest(await readJson$1(req))));
+				}
+				return json(res, 404, { error: "not found" });
+			} catch (error) {
+				if (error instanceof RepositoryActionError) return json(res, 409, {
+					error: error.code,
+					message: error.message,
+					...error.commit === void 0 ? {} : { commit: error.commit }
+				});
+				if (error instanceof SyntaxError) return json(res, 400, { error: "invalid-json" });
+				return json(res, 500, {
+					error: "repository-action-unavailable",
+					message: "Repository action is unavailable."
+				});
+			}
+		}
+	}), "dsh-claude: repository action route");
+}
+//#endregion
+//#region src/review-comment-routes.ts
+const MAX_BODY_BYTES = 16384;
+const MAX_SESSION_ID_CHARS = 1024;
+function record(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+async function readJson(req) {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of req) {
+		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		size += buffer.length;
+		if (size > MAX_BODY_BYTES) throw new ReviewCommentError("body-too-large", "The request body is too large.");
+		chunks.push(buffer);
+	}
+	const value = record(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+	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) throw new ReviewCommentError("invalid-session", "The session is invalid.");
+	return value;
+}
+function registerReviewCommentRoute(ctx, store, ownsSession) {
+	ctx.effect(() => ctx.webServer.register({
+		kind: "prefix",
+		path: CLAUDE_REVIEW_COMMENT_PATH,
+		handler: async (req, res) => {
+			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
+			const url = new URL(req.url ?? "/", "http://localhost");
+			try {
+				const sessionId = sessionIdFromUrl(url);
+				if (!ownsSession(sessionId)) throw new ReviewCommentError("session-unavailable", "The Claude session is unavailable.");
+				if (url.pathname === "/plugins/dsh-claude/review-comments" && req.method === "POST") {
+					const input = await readJson(req);
+					return json(res, 200, { comment: store.add(sessionId, {
+						path: input.path,
+						line: input.line,
+						side: input.side,
+						text: input.text
+					}) });
+				}
+				if (url.pathname === `/plugins/dsh-claude/review-comments/clear` && req.method === "POST") return json(res, 200, { removed: store.drain(sessionId).length });
+				if (url.pathname === `/plugins/dsh-claude/review-comments/remove` && req.method === "POST") {
+					const input = await readJson(req);
+					if (typeof input.id !== "string" || input.id.length === 0 || input.id.length > 128) throw new ReviewCommentError("invalid-request", "The comment id is invalid.");
+					return json(res, 200, { removed: store.remove(sessionId, input.id) });
+				}
+				return json(res, 404, { error: "not found" });
+			} catch (error) {
+				if (error instanceof ReviewCommentError) return json(res, 409, {
+					error: error.code,
+					message: error.message
+				});
+				if (error instanceof SyntaxError) return json(res, 400, { error: "invalid-json" });
+				return json(res, 500, {
+					error: "review-comment-unavailable",
+					message: "Review comments are unavailable."
+				});
+			}
+		}
+	}), "dsh-claude: review comment route");
+}
+//#endregion
 //#region src/update-routes.ts
 const PLUGIN_PACKAGE_NAME = "@norman-else/dsh-claude";
 const UPDATE_TIMEOUT_MS = 3e4;
@@ -2604,11 +4083,14 @@ const BUILTIN_OUTPUT_STYLES = [
 	"Learning"
 ];
 const STYLE_NAME = /^[\p{L}\p{N}][\p{L}\p{N} ._()\[\]-]{0,127}$/u;
+const DEFAULT_WORKTREE_BRANCH_PREFIX = "claude";
+const MAX_BRANCH_PREFIX_CHARS = 128;
 function pathsFor(deps) {
 	const root = join(homedir(), ".claude");
 	return {
 		settingsFile: deps.paths?.settingsFile ?? join(root, "settings.json"),
-		outputStylesDir: deps.paths?.outputStylesDir ?? join(root, "output-styles")
+		outputStylesDir: deps.paths?.outputStylesDir ?? join(root, "output-styles"),
+		pluginSettingsFile: deps.paths?.pluginSettingsFile ?? dshHomePath("plugins", "dsh-claude", "settings.json")
 	};
 }
 function object(value) {
@@ -2664,9 +4146,10 @@ async function userOutputStyleOptions(directory) {
 	}
 	return options;
 }
-const DESCRIPTORS = [{
+const OUTPUT_STYLE = {
 	key: "outputStyle",
 	kind: "select",
+	document: "claude",
 	effect: "new-session",
 	async options(paths) {
 		const builtIn = BUILTIN_OUTPUT_STYLES.map((value) => ({
@@ -2687,11 +4170,42 @@ const DESCRIPTORS = [{
 		if (value === "Default") delete document.outputStyle;
 		else document.outputStyle = value;
 	}
-}];
+};
+function isValidWorktreeBranchPrefix(value) {
+	return value.length > 0 && value.length <= MAX_BRANCH_PREFIX_CHARS && value.trim() === value && !value.startsWith("/") && !value.endsWith("/") && !value.includes("//") && !value.includes("..") && !value.includes("@{") && !/[\0-\x20\x7f~^:?*[\\]/u.test(value) && value.split("/").every((segment) => segment.length > 0 && !segment.startsWith(".") && !segment.endsWith(".lock"));
+}
+const WORKTREE_BRANCH_PREFIX = {
+	key: "worktreeBranchPrefix",
+	kind: "text",
+	document: "plugin",
+	effect: "next-worktree",
+	maxLength: MAX_BRANCH_PREFIX_CHARS,
+	read(document) {
+		const value = document.worktreeBranchPrefix;
+		return typeof value === "string" && isValidWorktreeBranchPrefix(value) ? value : DEFAULT_WORKTREE_BRANCH_PREFIX;
+	},
+	apply(document, value) {
+		if (typeof value !== "string" || !isValidWorktreeBranchPrefix(value)) throw new Error("Invalid value for global setting worktreeBranchPrefix");
+		if (value === DEFAULT_WORKTREE_BRANCH_PREFIX) delete document.worktreeBranchPrefix;
+		else document.worktreeBranchPrefix = value;
+	}
+};
+const DESCRIPTORS = [OUTPUT_STYLE, WORKTREE_BRANCH_PREFIX];
 const DESCRIPTOR_BY_KEY = new Map(DESCRIPTORS.map((descriptor) => [descriptor.key, descriptor]));
 let pendingWrite = Promise.resolve();
-async function views(document, paths) {
+function documentFor(descriptor, documents) {
+	return documents[descriptor.document];
+}
+async function views(documents, paths) {
 	return { settings: await Promise.all(DESCRIPTORS.map(async (descriptor) => {
+		const document = documentFor(descriptor, documents);
+		if (descriptor.kind === "text") return {
+			key: descriptor.key,
+			kind: descriptor.kind,
+			value: descriptor.read(document),
+			maxLength: descriptor.maxLength,
+			effect: descriptor.effect
+		};
 		const discovered = await descriptor.options(paths);
 		const value = descriptor.read(document, discovered);
 		const options = discovered.some((option) => option.value === value) ? discovered : [...discovered, {
@@ -2708,9 +4222,20 @@ async function views(document, paths) {
 		};
 	})) };
 }
+async function readDocuments(paths) {
+	const [claude, plugin] = await Promise.all([readDocument(paths.settingsFile), readDocument(paths.pluginSettingsFile)]);
+	return {
+		claude,
+		plugin
+	};
+}
 async function readGlobalSettings(deps = {}) {
 	const paths = pathsFor(deps);
-	return views(await readDocument(paths.settingsFile), paths);
+	return views(await readDocuments(paths), paths);
+}
+async function readWorktreeBranchPrefix(deps = {}) {
+	const paths = pathsFor(deps);
+	return WORKTREE_BRANCH_PREFIX.read(await readDocument(paths.pluginSettingsFile));
 }
 async function atomicWrite(path, document) {
 	await mkdir(dirname(path), {
@@ -2737,13 +4262,18 @@ function updateGlobalSettings(changes, deps = {}) {
 	for (const key of Object.keys(changeObject)) if (!DESCRIPTOR_BY_KEY.has(key)) return Promise.reject(/* @__PURE__ */ new Error(`Unsupported global setting: ${key}`));
 	const paths = pathsFor(deps);
 	const operation = pendingWrite.catch(() => void 0).then(async () => {
-		const document = await readDocument(paths.settingsFile);
+		const documents = await readDocuments(paths);
+		const changedDocuments = /* @__PURE__ */ new Set();
 		for (const [key, value] of Object.entries(changeObject)) {
 			const descriptor = DESCRIPTOR_BY_KEY.get(key);
-			descriptor.apply(document, value, await descriptor.options(paths));
+			const document = documentFor(descriptor, documents);
+			if (descriptor.kind === "select") descriptor.apply(document, value, await descriptor.options(paths));
+			else descriptor.apply(document, value);
+			changedDocuments.add(descriptor.document);
 		}
-		await atomicWrite(paths.settingsFile, document);
-		return views(document, paths);
+		if (changedDocuments.has("claude")) await atomicWrite(paths.settingsFile, documents.claude);
+		if (changedDocuments.has("plugin")) await atomicWrite(paths.pluginSettingsFile, documents.plugin);
+		return views(documents, paths);
 	});
 	pendingWrite = operation;
 	return operation;
@@ -2908,6 +4438,9 @@ async function apply(ctx, config) {
 		maxProcesses: config.maxProcesses ?? 4
 	};
 	const sidecar = new ClaudeSidecarRepository();
+	const repositoryStatus = new RepositoryStatusService(ctx.subprocess);
+	const repositorySetup = new RepositorySetupService(ctx.subprocess, { branchPrefix: () => readWorktreeBranchPrefix() });
+	const reviewComments = new ReviewCommentStore();
 	const commandCatalogs = /* @__PURE__ */ new Map();
 	const supervisor = new ClaudeSupervisor({
 		runtime: ctx.subprocess,
@@ -2920,7 +4453,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)));
+		ctx.llm.registerAdapter([...CLAUDE_CODE_PROVIDER_IDS], createClaudeCodeAdapter(supervisor, ctx.agents, ctx.attachments, (agent) => ctx.agentPresets.composedPreset(agent.ctx), (sessionId) => reviewComments.drain(sessionId)));
 		ctx.effect(() => {
 			const mounted = /* @__PURE__ */ new Map();
 			const pending = /* @__PURE__ */ new Set();
@@ -2981,18 +4514,35 @@ async function apply(ctx, config) {
 		resolutionError = error;
 	}
 	ctx.on("agent/disposed", async ({ agent }) => {
+		reviewComments.disposeSession(agent.id);
 		await supervisor.disposeSession(agent.id);
+		await repositorySetup.cleanupSession(agent.id);
 	});
+	ctx.effect(() => () => reviewComments.dispose(), "dsh-claude: review comments store");
 	ctx.effect(() => () => supervisor.dispose(), "dsh-claude: process supervisor");
+	ctx.effect(() => () => repositoryStatus.dispose(), "dsh-claude: repository status cache");
 	ctx.inject(["webServer"], (webCtx) => {
 		registerClaudeDoctorRoutes(webCtx, webCtx.subprocess, supervisor, supervisorConfig, resolutionError);
 		const desktopActions = webCtx.get("desktopActions");
 		registerClaudeUpdateRoutes(webCtx, webCtx.subprocess, { ...typeof desktopActions?.requestRestart === "function" ? { requestRestart: desktopActions.requestRestart.bind(desktopActions) } : {} });
 		registerClaudeGlobalSettingsRoute(webCtx);
-		registerClaudeProjectionRoute(webCtx, sidecar, (sessionId) => {
+		registerRepositorySetupRoute(webCtx, repositorySetup);
+		registerRepositoryActionRoute(webCtx, new RepositoryActionService(webCtx.subprocess, supervisorConfig.executablePath, (cwd) => repositoryStatus.invalidate(cwd)), (sessionId) => {
+			const agent = webCtx.agents.get(sessionId);
+			if (agent === void 0 || webCtx.agentPresets.composedPreset(agent.ctx) !== "claude") return void 0;
+			return agent.session.header.cwd;
+		});
+		const ownsClaudeSession = (sessionId) => {
 			const agent = webCtx.agents.get(sessionId);
 			return agent !== void 0 && webCtx.agentPresets.composedPreset(agent.ctx) === "claude";
-		}, (sessionId) => commandCatalogs.get(sessionId) ?? []);
+		};
+		registerReviewCommentRoute(webCtx, reviewComments, ownsClaudeSession);
+		registerClaudeProjectionRoute(webCtx, sidecar, ownsClaudeSession, (sessionId) => commandCatalogs.get(sessionId) ?? [], async (sessionId) => {
+			const agent = webCtx.agents.get(sessionId);
+			if (agent === void 0 || webCtx.agentPresets.composedPreset(agent.ctx) !== "claude") return void 0;
+			const cwd = agent.session.header.cwd;
+			return cwd === void 0 ? void 0 : repositoryStatus.inspect(cwd);
+		}, (sessionId) => reviewComments.list(sessionId));
 	});
 }
 //#endregion