@norman-else/dsh-claude 0.1.18 → 0.1.19

package/lib/index.mjs

@@ -1,10 +1,10 @@
-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 TASK_TOOL_NAMES, _ as CLAUDE_PROJECTION_PATH, a as latestClaudeTasks, b as CLAUDE_UPDATE_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_SETUP_PATH, y as CLAUDE_UPDATE_CHECK_PATH } from "./events-DPJaBReT.mjs";
+import { a as projectClaudeCommands, i as CLAUDE_COMMANDS_SERVICE, r as dynamicPresenterDefinition, t as CLAUDE_PRESENTER_NAMES } from "./presenters-DBRIOgJs.mjs";
+import { a as resolveClaudeExecutable, n as ensureManagedPreset, o as runClaudeDoctor, t as ManagedPresetConflictError } from "./preset-installer-DnoSEKGm.mjs";
 import z from "@deepseek-ai/schemastery";
 import { 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";
@@ -22,18 +22,18 @@ function emptyProjection() {
 		activities: []
 	};
 }
-function record$1(value) {
+function record$3(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$2(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$3(value);
+	if (input === void 0 || !string$2(input.claudeSessionId, 512) || !string$2(input.sdkVersion, 128) || !string$2(input.cwd, 4096) || input.cliVersion !== void 0 && !string$2(input.cliVersion, 128)) return void 0;
 	return {
 		claudeSessionId: input.claudeSessionId,
 		sdkVersion: input.sdkVersion,
@@ -61,22 +61,22 @@ const ACTIVITY_PHASES = /* @__PURE__ */ new Set([
 	"failed"
 ]);
 function activity(value) {
-	const input = record$1(value);
+	const input = record$3(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$3(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$3(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$3(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 +525,10 @@ function createUserQuestionBridge(userQuestions, activeContext) {
 }
 //#endregion
 //#region src/sdk-messages.ts
-function record(value) {
+function record$2(value) {
 	return value !== null && typeof value === "object" ? value : void 0;
 }
-function string(value) {
+function string$1(value) {
 	return typeof value === "string" ? value : void 0;
 }
 function taskUsageOf(usage) {
@@ -540,7 +540,7 @@ function taskUsageOf(usage) {
 	return Object.keys(normalized).length === 0 ? void 0 : normalized;
 }
 function resultUsage(message) {
-	const usage = record(message.usage);
+	const usage = record$2(message.usage);
 	const normalized = {};
 	if (usage !== void 0) {
 		if (typeof usage.input_tokens === "number") normalized.inputTokens = usage.input_tokens;
@@ -552,26 +552,26 @@ function resultUsage(message) {
 	return normalized;
 }
 function normalizeAssistant(message) {
-	const content = record(message.message)?.content;
+	const content = record$2(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$1(message.parent_tool_use_id);
 	const normalized = [];
 	for (const item of content) {
-		const block = record(item);
+		const block = record$2(item);
 		if (block === void 0) continue;
 		if (block.type === "text") {
-			const text = string(block.text);
+			const text = string$1(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$1(block.thinking);
 			if (text !== void 0 && text.length > 0) normalized.push({
 				kind: "thinking",
 				text,
@@ -579,8 +579,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$1(block.id);
+			const toolName = string$1(block.name);
 			if (toolUseId !== void 0 && toolName !== void 0) normalized.push({
 				kind: "tool-call",
 				toolUseId,
@@ -593,18 +593,18 @@ function normalizeAssistant(message) {
 	return normalized;
 }
 function normalizeUser(message) {
-	const content = record(message.message)?.content;
+	const content = record$2(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$1(message.parent_tool_use_id);
 	const normalized = [];
 	for (const item of content) {
-		const block = record(item);
+		const block = record$2(item);
 		if (block?.type !== "tool_result") continue;
-		const toolUseId = string(block.tool_use_id);
+		const toolUseId = string$1(block.tool_use_id);
 		if (toolUseId === void 0) continue;
 		normalized.push({
 			kind: "tool-result",
@@ -617,11 +617,11 @@ function normalizeUser(message) {
 	return normalized;
 }
 function normalizeSystem(message) {
-	const subtype = string(message.subtype);
+	const subtype = string$1(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$1(message.session_id);
+		const cliVersion = string$1(message.claude_code_version);
+		const cwd = string$1(message.cwd);
 		return sessionId !== void 0 && cliVersion !== void 0 && cwd !== void 0 ? [{
 			kind: "init",
 			sessionId,
@@ -650,20 +650,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$1(message.tool_use_id);
+		const toolName = string$1(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$1(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$1(message.task_id);
+		const description = string$1(message.description);
+		const subagentType = string$1(message.subagent_type);
+		const taskType = string$1(message.task_type);
 		return [{
 			kind: "subagent",
 			title: description ?? taskId ?? "Claude subagent started",
@@ -678,12 +678,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$1(message.task_id);
+		const description = string$1(message.description);
+		const summary = string$1(message.summary);
+		const subagentType = string$1(message.subagent_type);
+		const lastToolName = string$1(message.last_tool_name);
+		const usage = taskUsageOf(record$2(message.usage));
 		return [{
 			kind: "subagent",
 			title: summary ?? description ?? "Claude subagent update",
@@ -699,11 +699,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$2(message.patch);
+		const status = string$1(patch?.status);
+		const taskId = string$1(message.task_id);
+		const description = string$1(patch?.description);
+		const error = string$1(patch?.error);
 		const taskStatus = status === void 0 ? void 0 : status === "killed" ? "killed" : status === "completed" ? "completed" : status === "failed" ? "failed" : "running";
 		return [{
 			kind: "subagent",
@@ -719,10 +719,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$1(message.task_id);
+		const summary = string$1(message.summary);
 		const taskStatus = failed ? "failed" : stopped ? "stopped" : "completed";
-		const usage = taskUsageOf(record(message.usage));
+		const usage = taskUsageOf(record$2(message.usage));
 		return [{
 			kind: "subagent",
 			title: summary ?? taskId ?? "Claude subagent finished",
@@ -737,10 +737,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$2(item);
+			const taskId = string$1(entry?.task_id);
+			const description = string$1(entry?.description);
+			const taskType = string$1(entry?.task_type);
 			if (taskId === void 0 || description === void 0) return [];
 			return [{
 				taskId,
@@ -756,7 +756,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$1(message.content) ?? string$1(message.text) ?? "Claude Code notice",
 		detail: message
 	}];
 	if (subtype?.startsWith("hook_") === true || subtype === "plugin_install") return [{
@@ -780,12 +780,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$2(value.event);
+		const parentToolUseId = string$1(value.parent_tool_use_id);
 		if (event?.type === "content_block_delta") {
-			const delta = record(event.delta);
+			const delta = record$2(event.delta);
 			if (delta?.type === "text_delta") {
-				const text = string(delta.text);
+				const text = string$1(delta.text);
 				return text === void 0 ? [] : [{
 					kind: "text-delta",
 					text,
@@ -793,7 +793,7 @@ function normalizeSdkMessage(message) {
 				}];
 			}
 			if (delta?.type === "thinking_delta") {
-				const text = string(delta.thinking);
+				const text = string$1(delta.thinking);
 				return text === void 0 ? [] : [{
 					kind: "thinking",
 					text,
@@ -808,7 +808,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$1(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 +816,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$1(value.terminal_reason);
+		const userMessageUuid = string$1(value.user_message_uuid);
+		const permissionDenials = Array.isArray(value.permission_denials) ? value.permission_denials.map((item) => record$2(item)).filter((item) => item !== void 0).map((item) => {
+			const toolName = string$1(item.tool_name);
+			const toolUseId = string$1(item.tool_use_id);
 			return toolName === void 0 || toolUseId === void 0 ? void 0 : {
 				toolName,
 				toolUseId
@@ -844,7 +844,7 @@ function normalizeSdkMessage(message) {
 		detail: value.error ?? value.output
 	}];
 	if (value.type === "rate_limit_event") {
-		const status = string(record(value.rate_limit_info)?.status);
+		const status = string$1(record$2(value.rate_limit_info)?.status);
 		const blocking = status !== void 0 && status !== "allowed";
 		return [{
 			kind: blocking ? "warning" : "status",
@@ -2033,7 +2033,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 +2050,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);
@@ -2304,7 +2310,7 @@ function sessionIdFromUrl(rawUrl) {
 	}
 }
 /** 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) {
 	ctx.effect(() => ctx.webServer.register({
 		kind: "prefix",
 		path: CLAUDE_PROJECTION_PATH,
@@ -2315,14 +2321,17 @@ function registerClaudeProjectionRoute(ctx, sidecar, ownsSession, commandsForSes
 			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 }
 				});
 			} catch {
 				return json(res, 500, { error: "projection unavailable" });
@@ -2331,6 +2340,788 @@ function registerClaudeProjectionRoute(ctx, sidecar, ownsSession, commandsForSes
 	}), "dsh-claude: sidecar projection route");
 }
 //#endregion
+//#region src/repository-status.ts
+const MAX_OUTPUT_BYTES$1 = 65536;
+const MAX_DIFF_BYTES = 262144;
+const GIT_TIMEOUT_MS$1 = 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$1(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$1) {
+	const signal = AbortSignal.timeout(timeoutMs);
+	return collect$1(runtime.spawn({
+		argv: [executable, ...args],
+		cwd,
+		stdio: {
+			stdin: "ignore",
+			stdout: { maxBytes },
+			stderr: { maxBytes: MAX_OUTPUT_BYTES$1 }
+		},
+		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;
+	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.length > 0 && !line.startsWith("# ")) dirty = true;
+	}
+	return {
+		...branch === void 0 ? {} : { branch },
+		detached,
+		dirty
+	};
+}
+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$1(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$1(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$1(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$1(input.author)?.login === "string" ? { author: bounded(String(record$1(input.author)?.login)) } : {},
+		...typeof input.createdAt === "string" && Number.isFinite(Date.parse(input.createdAt)) ? { createdAt: new Date(input.createdAt).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;
+	}
+	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$1);
+			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=no"
+			], cwd, GIT_TIMEOUT_MS$1);
+			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$1);
+			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$1);
+			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$1);
+			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$1, MAX_DIFF_BYTES);
+			if (patch.exitCode !== 0) return {
+				...summary,
+				truncated: true
+			};
+			return {
+				...summary,
+				...patch.lossy ? {} : { patch: patch.stdout },
+				truncated: patch.lossy
+			};
+		} catch {
+			return;
+		}
+	}
+	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 = 131072;
+const GIT_TIMEOUT_MS = 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(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) {
+		return collect(this.#runtime.spawn({
+			argv: [executable, ...args],
+			cwd,
+			stdio: {
+				stdin: "ignore",
+				stdout: { maxBytes: MAX_OUTPUT_BYTES },
+				stderr: { maxBytes: MAX_OUTPUT_BYTES }
+			},
+			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-setup-routes.ts
+const MAX_BODY_BYTES = 16384;
+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 RepositorySetupError("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 RepositorySetupError("invalid-request", "The request body is invalid.");
+	return value;
+}
+function string(input, key) {
+	const value = input[key];
+	if (typeof value !== "string") throw new RepositorySetupError("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 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(input, "cwd"), string(input, "branch"), input.worktree, optionalString(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(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(req);
+					await service.bindLease(string(input, "leaseId"), string(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/update-routes.ts
 const PLUGIN_PACKAGE_NAME = "@norman-else/dsh-claude";
 const UPDATE_TIMEOUT_MS = 3e4;
@@ -2604,11 +3395,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 +3458,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 +3482,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 +3534,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 +3574,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 +3750,8 @@ 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 commandCatalogs = /* @__PURE__ */ new Map();
 	const supervisor = new ClaudeSupervisor({
 		runtime: ctx.subprocess,
@@ -2982,17 +3826,25 @@ async function apply(ctx, config) {
 	}
 	ctx.on("agent/disposed", async ({ agent }) => {
 		await supervisor.disposeSession(agent.id);
+		await repositorySetup.cleanupSession(agent.id);
 	});
 	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);
+		registerRepositorySetupRoute(webCtx, repositorySetup);
 		registerClaudeProjectionRoute(webCtx, sidecar, (sessionId) => {
 			const agent = webCtx.agents.get(sessionId);
 			return agent !== void 0 && webCtx.agentPresets.composedPreset(agent.ctx) === "claude";
-		}, (sessionId) => commandCatalogs.get(sessionId) ?? []);
+		}, (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);
+		});
 	});
 }
 //#endregion